From 357c3e44e195fa5f11909a510ca797059baa1021 Mon Sep 17 00:00:00 2001
From: Daniel Roe <daniel@roe.dev>
Date: Sun, 8 Feb 2026 12:57:40 +0000
Subject: [PATCH 1/5] fix: support sorting algolia search results

---
 app/components/Package/ListToolbar.vue |  23 ++--
 app/pages/search.vue                   | 165 ++++++++++++++++++-------
 i18n/locales/en.json                   |   1 +
 lunaria/files/en-GB.json               |   1 +
 lunaria/files/en-US.json               |   1 +
 5 files changed, 138 insertions(+), 53 deletions(-)

diff --git a/app/components/Package/ListToolbar.vue b/app/components/Package/ListToolbar.vue
index ce0b2fa269..84be1a6ee2 100644
--- a/app/components/Package/ListToolbar.vue
+++ b/app/components/Package/ListToolbar.vue
@@ -30,6 +30,8 @@ const props = defineProps<{
   activeFilters: FilterChip[]
   /** When true, shows search-specific UI (relevance sort, no filters) */
   searchContext?: boolean
+  /** Sort keys to force-disable (e.g. when the current provider doesn't support them) */
+  disabledSortKeys?: SortKey[]
 }>()
 
 const { t } = useI18n()
@@ -58,17 +60,20 @@ const showingFiltered = computed(() => props.filteredCount !== props.totalCount)
 const currentSort = computed(() => parseSortOption(sortOption.value))
 
 // Get available sort keys based on context
+const disabledSet = computed(() => new Set(props.disabledSortKeys ?? []))
+
 const availableSortKeys = computed(() => {
+  const applyDisabled = (k: (typeof SORT_KEYS)[number]) => ({
+    ...k,
+    disabled: k.disabled || disabledSet.value.has(k.key),
+  })
+
   if (props.searchContext) {
-    // In search context: show relevance (enabled) and others (disabled)
-    return SORT_KEYS.filter(k => !k.searchOnly || k.key === 'relevance').map(k =>
-      Object.assign({}, k, {
-        disabled: k.key !== 'relevance',
-      }),
-    )
+    // In search context: show relevance + non-disabled sorts (downloads, updated, name)
+    return SORT_KEYS.filter(k => !k.searchOnly || k.key === 'relevance').map(applyDisabled)
   }
   // In org/user context: hide search-only sorts
-  return SORT_KEYS.filter(k => !k.searchOnly)
+  return SORT_KEYS.filter(k => !k.searchOnly).map(applyDisabled)
 })
 
 // Handle sort key change from dropdown
@@ -182,9 +187,9 @@ function getSortKeyLabelKey(key: SortKey): string {
             </div>
           </div>
 
-          <!-- Sort direction toggle (hidden in search context) -->
+          <!-- Sort direction toggle -->
           <button
-            v-if="!searchContext"
+            v-if="!searchContext || currentSort.key !== 'relevance'"
             type="button"
             class="p-1.5 rounded border border-border bg-bg-subtle text-fg-muted hover:text-fg hover:border-border-hover transition-colors duration-200 focus-visible:ring-2 focus-visible:ring-fg focus-visible:ring-offset-2 focus-visible:ring-offset-bg"
             :aria-label="$t('filters.sort.toggle_direction')"
diff --git a/app/pages/search.vue b/app/pages/search.vue
index a11090c297..df28331757 100644
--- a/app/pages/search.vue
+++ b/app/pages/search.vue
@@ -1,5 +1,6 @@
 <script setup lang="ts">
-import type { FilterChip } from '#shared/types/preferences'
+import type { FilterChip, SortKey } from '#shared/types/preferences'
+import { parseSortOption } from '#shared/types/preferences'
 import { onKeyDown } from '@vueuse/core'
 import { debounce } from 'perfect-debounce'
 import { isValidNewPackageName, checkPackageExists } from '~/utils/package-name'
@@ -9,6 +10,10 @@ import { normalizeSearchParam } from '#shared/utils/url'
 const route = useRoute()
 const router = useRouter()
 
+// Search provider
+const { search: algoliaSearch } = useAlgoliaSearch()
+const { isAlgolia } = useSearchProvider()
+
 // Preferences (persisted to localStorage)
 const {
   viewMode,
@@ -45,13 +50,6 @@ onMounted(() => {
 const pageSize = 25
 const currentPage = shallowRef(1)
 
-// Calculate how many results we need based on current page and preferred page size
-const requestedSize = computed(() => {
-  const numericPrefSize = preferredPageSize.value === 'all' ? 250 : preferredPageSize.value
-  // Always fetch at least enough for the current page
-  return Math.max(pageSize, currentPage.value * numericPrefSize)
-})
-
 // Get initial page from URL (for scroll restoration on reload)
 const initialPage = computed(() => {
   const p = Number.parseInt(normalizeSearchParam(route.query.page), 10)
@@ -65,18 +63,6 @@ onMounted(() => {
   }
 })
 
-// Use incremental search with client-side caching
-const {
-  data: results,
-  status,
-  isLoadingMore,
-  hasMore,
-  fetchMore,
-  isRateLimited,
-} = useNpmSearch(query, () => ({
-  size: requestedSize.value,
-}))
-
 // Results to display (directly from incremental search)
 const rawVisibleResults = computed(() => results.value)
 
@@ -125,11 +111,27 @@ const visibleResults = computed(() => {
 // Use structured filters for client-side refinement of search results
 const resultsArray = computed(() => visibleResults.value?.objects ?? [])
 
+// Sort keys that the npm registry path doesn't support (only relevance works server-side)
+const NON_RELEVANCE_SORT_KEYS: SortKey[] = [
+  'downloads-week',
+  'downloads-day',
+  'downloads-month',
+  'downloads-year',
+  'updated',
+  'name',
+  'quality',
+  'popularity',
+  'maintenance',
+  'score',
+]
+
+// Disable non-relevance sorts when using npm provider (results are relevance-only from server)
+const disabledSortKeys = computed<SortKey[]>(() => (isAlgolia.value ? [] : NON_RELEVANCE_SORT_KEYS))
+
 // Minimal structured filters usage for search context (no client-side filtering)
 const {
   filters,
   sortOption,
-  sortedPackages,
   availableKeywords,
   activeFilters,
   setTextFilter,
@@ -148,19 +150,90 @@ const {
   initialSort: 'relevance-desc', // Default to search relevance
 })
 
-// Client-side filtered/sorted results for display
-// In search context, we always use server order (relevance) - no client-side filtering
+const isRelevanceSort = computed(
+  () => sortOption.value === 'relevance-desc' || sortOption.value === 'relevance-asc',
+)
+
+// Calculate how many results we need based on current page and preferred page size
+const requestedSize = computed(() => {
+  const numericPrefSize = preferredPageSize.value === 'all' ? 250 : preferredPageSize.value
+  const base = Math.max(pageSize, currentPage.value * numericPrefSize)
+  // When sorting by something other than relevance, fetch a large batch from Algolia
+  // so client-side sorting operates on a meaningful pool of matching results
+  if (!isRelevanceSort.value) {
+    return Math.max(base, 250)
+  }
+  return base
+})
+
+// Reset to relevance sort when switching to npm (which only supports relevance)
+watch(isAlgolia, algolia => {
+  if (!algolia && !isRelevanceSort.value) {
+    sortOption.value = 'relevance-desc'
+  }
+})
+
+// Use incremental search with client-side caching
+const {
+  data: results,
+  status,
+  isLoadingMore,
+  hasMore,
+  fetchMore,
+  isRateLimited,
+} = useNpmSearch(query, () => ({
+  size: requestedSize.value,
+}))
+
+// Client-side sorted results for display
+// The search API already handles text filtering, so we only need to sort.
 const displayResults = computed(() => {
-  // When using relevance sort, return original server-sorted results
-  if (sortOption.value === 'relevance-desc' || sortOption.value === 'relevance-asc') {
+  if (isRelevanceSort.value) {
     return resultsArray.value
   }
 
-  return sortedPackages.value
+  // Sort the fetched results client-side (Algolia doesn't support arbitrary
+  // sort orders without replica indices, so we fetch a large batch and sort here)
+  const { key, direction } = parseSortOption(sortOption.value)
+  const multiplier = direction === 'asc' ? 1 : -1
+
+  return [...resultsArray.value].sort((a, b) => {
+    let diff: number
+    switch (key) {
+      case 'downloads-week':
+      case 'downloads-day':
+      case 'downloads-month':
+      case 'downloads-year':
+        diff = (a.downloads?.weekly ?? 0) - (b.downloads?.weekly ?? 0)
+        break
+      case 'updated':
+        diff = new Date(a.package.date).getTime() - new Date(b.package.date).getTime()
+        break
+      case 'name':
+        diff = a.package.name.localeCompare(b.package.name)
+        break
+      default:
+        diff = 0
+    }
+    return diff * multiplier
+  })
 })
 
 const resultCount = computed(() => displayResults.value.length)
 
+/**
+ * The effective total for display and pagination purposes.
+ * When sorting by non-relevance, we're working with a fetched subset (e.g. 250),
+ * not the full Algolia total (e.g. 92,324). Show the actual working set size.
+ */
+const effectiveTotal = computed(() => {
+  if (isRelevanceSort.value) {
+    return visibleResults.value?.total ?? 0
+  }
+  // When sorting, the total is the number of results we actually fetched and sorted
+  return displayResults.value.length
+})
+
 // Handle filter chip removal
 function handleClearFilter(chip: FilterChip) {
   clearFilter(chip)
@@ -316,9 +389,6 @@ interface ValidatedSuggestion {
 /** Cache for existence checks to avoid repeated API calls */
 const existenceCache = ref<Record<string, boolean | 'pending'>>({})
 
-const { search: algoliaSearch } = useAlgoliaSearch()
-const { isAlgolia } = useSearchProvider()
-
 /**
  * Check if an org exists by searching for scoped packages (@orgname/...).
  * When Algolia is active, searches for `@name/` scoped packages via text query.
@@ -773,10 +843,11 @@ defineOgImageComponent('Default', {
               :columns="columns"
               v-model:pagination-mode="paginationMode"
               v-model:page-size="preferredPageSize"
-              :total-count="visibleResults.total"
+              :total-count="effectiveTotal"
               :filtered-count="displayResults.length"
               :available-keywords="availableKeywords"
               :active-filters="activeFilters"
+              :disabled-sort-keys="disabledSortKeys"
               search-context
               @toggle-column="toggleColumn"
               @reset-columns="resetColumns"
@@ -789,24 +860,31 @@ defineOgImageComponent('Default', {
               @update:updated-within="setUpdatedWithin"
               @toggle-keyword="toggleKeyword"
             />
-            <!-- Show "Found X packages" (infinite scroll mode only) -->
+            <!-- Show count status (infinite scroll mode only) -->
             <p
               v-if="viewMode === 'cards' && paginationMode === 'infinite'"
               role="status"
               class="text-fg-muted text-sm mt-4 font-mono"
             >
-              {{
-                $t(
-                  'search.found_packages',
-                  { count: $n(visibleResults.total) },
-                  visibleResults.total,
-                )
-              }}
+              <template v-if="isRelevanceSort">
+                {{
+                  $t(
+                    'search.found_packages',
+                    { count: $n(visibleResults.total) },
+                    visibleResults.total,
+                  )
+                }}
+              </template>
+              <template v-else>
+                {{
+                  $t('search.found_packages_sorted', { count: $n(effectiveTotal) }, effectiveTotal)
+                }}
+              </template>
               <span v-if="status === 'pending'" class="text-fg-subtle">{{
                 $t('search.updating')
               }}</span>
             </p>
-            <!-- Show "x of y packages" (paginated/table mode only) -->
+            <!-- Show "x of y" (paginated/table mode only) -->
             <p
               v-if="viewMode === 'table' || paginationMode === 'paginated'"
               role="status"
@@ -816,11 +894,10 @@ defineOgImageComponent('Default', {
                 $t(
                   'filters.count.showing_paginated',
                   {
-                    pageSize:
-                      preferredPageSize === 'all' ? $n(visibleResults.total) : preferredPageSize,
-                    count: $n(visibleResults.total),
+                    pageSize: preferredPageSize === 'all' ? $n(effectiveTotal) : preferredPageSize,
+                    count: $n(effectiveTotal),
                   },
-                  visibleResults.total,
+                  effectiveTotal,
                 )
               }}
             </p>
@@ -890,7 +967,7 @@ defineOgImageComponent('Default', {
             v-model:mode="paginationMode"
             v-model:page-size="preferredPageSize"
             v-model:current-page="currentPage"
-            :total-items="visibleResults?.total ?? displayResults.length"
+            :total-items="effectiveTotal"
             :view-mode="viewMode"
           />
         </div>
diff --git a/i18n/locales/en.json b/i18n/locales/en.json
index 6fd6a79475..d04d73c15d 100644
--- a/i18n/locales/en.json
+++ b/i18n/locales/en.json
@@ -23,6 +23,7 @@
     "button": "search",
     "searching": "Searching...",
     "found_packages": "No packages found | Found 1 package | Found {count} packages",
+    "found_packages_sorted": "Sorting top {count} result | Sorting top {count} results",
     "updating": "(updating...)",
     "no_results": "No packages found for \"{query}\"",
     "rate_limited": "Hit npm rate limit, try again in a moment",
diff --git a/lunaria/files/en-GB.json b/lunaria/files/en-GB.json
index 22d33f0a5b..fc1e8ab4e7 100644
--- a/lunaria/files/en-GB.json
+++ b/lunaria/files/en-GB.json
@@ -23,6 +23,7 @@
     "button": "search",
     "searching": "Searching...",
     "found_packages": "No packages found | Found 1 package | Found {count} packages",
+    "found_packages_sorted": "Sorting top {count} result | Sorting top {count} results",
     "updating": "(updating...)",
     "no_results": "No packages found for \"{query}\"",
     "rate_limited": "Hit npm rate limit, try again in a moment",
diff --git a/lunaria/files/en-US.json b/lunaria/files/en-US.json
index 6fd6a79475..d04d73c15d 100644
--- a/lunaria/files/en-US.json
+++ b/lunaria/files/en-US.json
@@ -23,6 +23,7 @@
     "button": "search",
     "searching": "Searching...",
     "found_packages": "No packages found | Found 1 package | Found {count} packages",
+    "found_packages_sorted": "Sorting top {count} result | Sorting top {count} results",
     "updating": "(updating...)",
     "no_results": "No packages found for \"{query}\"",
     "rate_limited": "Hit npm rate limit, try again in a moment",

From 01fd072a6bf91384c94fea0bb6d81adec8ab8d78 Mon Sep 17 00:00:00 2001
From: Daniel Roe <daniel@roe.dev>
Date: Sun, 8 Feb 2026 16:11:14 +0000
Subject: [PATCH 2/5] feat: add sorting for npm as well

---
 app/pages/search.vue        | 45 ++++++++++++++++++++++++++++---------
 shared/types/preferences.ts | 30 +++++++++++++++++++++----
 2 files changed, 60 insertions(+), 15 deletions(-)

diff --git a/app/pages/search.vue b/app/pages/search.vue
index df28331757..b77cef25c1 100644
--- a/app/pages/search.vue
+++ b/app/pages/search.vue
@@ -1,6 +1,6 @@
 <script setup lang="ts">
 import type { FilterChip, SortKey } from '#shared/types/preferences'
-import { parseSortOption } from '#shared/types/preferences'
+import { parseSortOption, PROVIDER_SORT_KEYS } from '#shared/types/preferences'
 import { onKeyDown } from '@vueuse/core'
 import { debounce } from 'perfect-debounce'
 import { isValidNewPackageName, checkPackageExists } from '~/utils/package-name'
@@ -111,8 +111,8 @@ const visibleResults = computed(() => {
 // Use structured filters for client-side refinement of search results
 const resultsArray = computed(() => visibleResults.value?.objects ?? [])
 
-// Sort keys that the npm registry path doesn't support (only relevance works server-side)
-const NON_RELEVANCE_SORT_KEYS: SortKey[] = [
+// All possible non-relevance sort keys
+const ALL_SORT_KEYS: SortKey[] = [
   'downloads-week',
   'downloads-day',
   'downloads-month',
@@ -125,8 +125,11 @@ const NON_RELEVANCE_SORT_KEYS: SortKey[] = [
   'score',
 ]
 
-// Disable non-relevance sorts when using npm provider (results are relevance-only from server)
-const disabledSortKeys = computed<SortKey[]>(() => (isAlgolia.value ? [] : NON_RELEVANCE_SORT_KEYS))
+// Disable sort keys the current provider can't meaningfully sort by
+const disabledSortKeys = computed<SortKey[]>(() => {
+  const supported = PROVIDER_SORT_KEYS[isAlgolia.value ? 'algolia' : 'npm']
+  return ALL_SORT_KEYS.filter(k => !supported.has(k))
+})
 
 // Minimal structured filters usage for search context (no client-side filtering)
 const {
@@ -154,21 +157,29 @@ const isRelevanceSort = computed(
   () => sortOption.value === 'relevance-desc' || sortOption.value === 'relevance-asc',
 )
 
+// Maximum eager-load sizes per provider for client-side sorting.
+// Algolia supports up to 1000 with offset/length pagination.
+// npm supports pagination via `from` parameter (no hard cap, but diminishing relevance).
+const EAGER_LOAD_SIZE = { algolia: 500, npm: 500 } as const
+
 // Calculate how many results we need based on current page and preferred page size
 const requestedSize = computed(() => {
   const numericPrefSize = preferredPageSize.value === 'all' ? 250 : preferredPageSize.value
   const base = Math.max(pageSize, currentPage.value * numericPrefSize)
-  // When sorting by something other than relevance, fetch a large batch from Algolia
+  // When sorting by something other than relevance, fetch a large batch
   // so client-side sorting operates on a meaningful pool of matching results
   if (!isRelevanceSort.value) {
-    return Math.max(base, 250)
+    const cap = isAlgolia.value ? EAGER_LOAD_SIZE.algolia : EAGER_LOAD_SIZE.npm
+    return Math.max(base, cap)
   }
   return base
 })
 
-// Reset to relevance sort when switching to npm (which only supports relevance)
+// Reset to relevance sort when switching to a provider that doesn't support the current sort key
 watch(isAlgolia, algolia => {
-  if (!algolia && !isRelevanceSort.value) {
+  const { key } = parseSortOption(sortOption.value)
+  const supported = PROVIDER_SORT_KEYS[algolia ? 'algolia' : 'npm']
+  if (!supported.has(key)) {
     sortOption.value = 'relevance-desc'
   }
 })
@@ -192,8 +203,8 @@ const displayResults = computed(() => {
     return resultsArray.value
   }
 
-  // Sort the fetched results client-side (Algolia doesn't support arbitrary
-  // sort orders without replica indices, so we fetch a large batch and sort here)
+  // Sort the fetched results client-side — neither Algolia nor npm support
+  // arbitrary sort orders server-side, so we fetch a large batch and sort here
   const { key, direction } = parseSortOption(sortOption.value)
   const multiplier = direction === 'asc' ? 1 : -1
 
@@ -212,6 +223,18 @@ const displayResults = computed(() => {
       case 'name':
         diff = a.package.name.localeCompare(b.package.name)
         break
+      case 'quality':
+        diff = (a.score?.detail?.quality ?? 0) - (b.score?.detail?.quality ?? 0)
+        break
+      case 'popularity':
+        diff = (a.score?.detail?.popularity ?? 0) - (b.score?.detail?.popularity ?? 0)
+        break
+      case 'maintenance':
+        diff = (a.score?.detail?.maintenance ?? 0) - (b.score?.detail?.maintenance ?? 0)
+        break
+      case 'score':
+        diff = (a.score?.final ?? 0) - (b.score?.final ?? 0)
+        break
       default:
         diff = 0
     }
diff --git a/shared/types/preferences.ts b/shared/types/preferences.ts
index b14275171e..63351bca4b 100644
--- a/shared/types/preferences.ts
+++ b/shared/types/preferences.ts
@@ -140,12 +140,34 @@ export const SORT_KEYS: SortKeyConfig[] = [
   { key: 'downloads-year', defaultDirection: 'desc', disabled: true },
   { key: 'updated', defaultDirection: 'desc' },
   { key: 'name', defaultDirection: 'asc' },
-  { key: 'quality', defaultDirection: 'desc', disabled: true },
-  { key: 'popularity', defaultDirection: 'desc', disabled: true },
-  { key: 'maintenance', defaultDirection: 'desc', disabled: true },
-  { key: 'score', defaultDirection: 'desc', disabled: true },
+  { key: 'quality', defaultDirection: 'desc' },
+  { key: 'popularity', defaultDirection: 'desc' },
+  { key: 'maintenance', defaultDirection: 'desc' },
+  { key: 'score', defaultDirection: 'desc' },
 ]
 
+/**
+ * Sort keys each search provider can meaningfully sort by.
+ *
+ * Algolia: has download counts and dates but synthetic/zeroed score values
+ *   - quality is 0 or 1 (boolean `popular` flag), maintenance is always 0, score is always 0
+ *   - popularity is `downloadsRatio` (a meaningful float)
+ *
+ * npm: has real score values and dates but no download counts in search results
+ */
+export const PROVIDER_SORT_KEYS: Record<'algolia' | 'npm', Set<SortKey>> = {
+  algolia: new Set<SortKey>(['relevance', 'downloads-week', 'updated', 'name', 'popularity']),
+  npm: new Set<SortKey>([
+    'relevance',
+    'updated',
+    'name',
+    'quality',
+    'popularity',
+    'maintenance',
+    'score',
+  ]),
+}
+
 /** All valid sort keys for validation */
 const VALID_SORT_KEYS = new Set<SortKey>([
   'relevance',

From 510dc34aefa14bf13194dd5f7def2ff0369c6dad Mon Sep 17 00:00:00 2001
From: Daniel Roe <daniel@roe.dev>
Date: Sun, 8 Feb 2026 16:32:33 +0000
Subject: [PATCH 3/5] fix: update sort results

---
 app/pages/search.vue        | 12 ------------
 shared/types/preferences.ts | 36 ++++++++++++++++++------------------
 2 files changed, 18 insertions(+), 30 deletions(-)

diff --git a/app/pages/search.vue b/app/pages/search.vue
index b77cef25c1..6bba77f6d8 100644
--- a/app/pages/search.vue
+++ b/app/pages/search.vue
@@ -223,18 +223,6 @@ const displayResults = computed(() => {
       case 'name':
         diff = a.package.name.localeCompare(b.package.name)
         break
-      case 'quality':
-        diff = (a.score?.detail?.quality ?? 0) - (b.score?.detail?.quality ?? 0)
-        break
-      case 'popularity':
-        diff = (a.score?.detail?.popularity ?? 0) - (b.score?.detail?.popularity ?? 0)
-        break
-      case 'maintenance':
-        diff = (a.score?.detail?.maintenance ?? 0) - (b.score?.detail?.maintenance ?? 0)
-        break
-      case 'score':
-        diff = (a.score?.final ?? 0) - (b.score?.final ?? 0)
-        break
       default:
         diff = 0
     }
diff --git a/shared/types/preferences.ts b/shared/types/preferences.ts
index 63351bca4b..d95b18af0f 100644
--- a/shared/types/preferences.ts
+++ b/shared/types/preferences.ts
@@ -140,32 +140,32 @@ export const SORT_KEYS: SortKeyConfig[] = [
   { key: 'downloads-year', defaultDirection: 'desc', disabled: true },
   { key: 'updated', defaultDirection: 'desc' },
   { key: 'name', defaultDirection: 'asc' },
-  { key: 'quality', defaultDirection: 'desc' },
-  { key: 'popularity', defaultDirection: 'desc' },
-  { key: 'maintenance', defaultDirection: 'desc' },
-  { key: 'score', defaultDirection: 'desc' },
+  // quality/popularity/maintenance: npm returns 1 for all, Algolia returns synthetic values.
+  // Neither provider produces meaningful values for these.
+  { key: 'quality', defaultDirection: 'desc', disabled: true },
+  { key: 'popularity', defaultDirection: 'desc', disabled: true },
+  { key: 'maintenance', defaultDirection: 'desc', disabled: true },
+  // score.final === searchScore (identical to relevance), redundant sort key
+  { key: 'score', defaultDirection: 'desc', disabled: true },
 ]
 
 /**
  * Sort keys each search provider can meaningfully sort by.
  *
- * Algolia: has download counts and dates but synthetic/zeroed score values
- *   - quality is 0 or 1 (boolean `popular` flag), maintenance is always 0, score is always 0
- *   - popularity is `downloadsRatio` (a meaningful float)
+ * Both providers support: relevance (server-side order), updated, name.
  *
- * npm: has real score values and dates but no download counts in search results
+ * Algolia: has `downloadsLast30Days` for download sorting.
+ *
+ * npm: the search API now includes `downloads.weekly` and `downloads.monthly`
+ * directly in results, so download sorting works here too.
+ *
+ * Neither provider returns useful quality/popularity/maintenance/score values:
+ * - npm returns 1 for all detail scores, and score.final === searchScore (= relevance)
+ * - Algolia returns synthetic values (quality: 0|1, maintenance: 0, score: 0)
  */
 export const PROVIDER_SORT_KEYS: Record<'algolia' | 'npm', Set<SortKey>> = {
-  algolia: new Set<SortKey>(['relevance', 'downloads-week', 'updated', 'name', 'popularity']),
-  npm: new Set<SortKey>([
-    'relevance',
-    'updated',
-    'name',
-    'quality',
-    'popularity',
-    'maintenance',
-    'score',
-  ]),
+  algolia: new Set<SortKey>(['relevance', 'downloads-week', 'updated', 'name']),
+  npm: new Set<SortKey>(['relevance', 'downloads-week', 'updated', 'name']),
 }
 
 /** All valid sort keys for validation */

From 3fe1ded153e8ba21a67da1df0c8a88b0ef56f84b Mon Sep 17 00:00:00 2001
From: Daniel Roe <daniel@roe.dev>
Date: Sun, 8 Feb 2026 16:40:10 +0000
Subject: [PATCH 4/5] fix: ensure we refetch when increasing results size

---
 app/composables/npm/useNpmSearch.ts | 8 ++++++--
 app/pages/search.vue                | 2 +-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/app/composables/npm/useNpmSearch.ts b/app/composables/npm/useNpmSearch.ts
index 2a00761830..ca3504770b 100644
--- a/app/composables/npm/useNpmSearch.ts
+++ b/app/composables/npm/useNpmSearch.ts
@@ -307,9 +307,13 @@ export function useNpmSearch(
   )
 
   // Re-search when provider changes
-  watch(searchProvider, () => {
+  watch(searchProvider, async () => {
     cache.value = null
-    asyncData.refresh()
+    await asyncData.refresh()
+    const targetSize = toValue(options).size
+    if (targetSize) {
+      await fetchMore(targetSize)
+    }
   })
 
   // Computed data that uses cache
diff --git a/app/pages/search.vue b/app/pages/search.vue
index 6bba77f6d8..a44d8af134 100644
--- a/app/pages/search.vue
+++ b/app/pages/search.vue
@@ -915,7 +915,7 @@ defineOgImageComponent('Default', {
           </div>
 
           <!-- No results found -->
-          <div v-else-if="status !== 'pending'" role="status" class="py-12">
+          <div v-else-if="status === 'success' || status === 'error'" role="status" class="py-12">
             <p class="text-fg-muted font-mono mb-6 text-center">
               {{ $t('search.no_results', { query }) }}
             </p>

From 135dac3541172ed1f2f2e81d8007d5eb06454f8c Mon Sep 17 00:00:00 2001
From: Daniel Roe <daniel@roe.dev>
Date: Sun, 8 Feb 2026 17:05:46 +0000
Subject: [PATCH 5/5] fix: get org packages from algolia directly

---
 app/composables/npm/useAlgoliaSearch.ts |  40 +++++++
 app/composables/npm/useOrgPackages.ts   | 153 +++++-------------------
 2 files changed, 69 insertions(+), 124 deletions(-)

diff --git a/app/composables/npm/useAlgoliaSearch.ts b/app/composables/npm/useAlgoliaSearch.ts
index 989fde22f6..75928b582c 100644
--- a/app/composables/npm/useAlgoliaSearch.ts
+++ b/app/composables/npm/useAlgoliaSearch.ts
@@ -229,10 +229,50 @@ export function useAlgoliaSearch() {
     }
   }
 
+  /**
+   * Fetch metadata for specific packages by exact name.
+   * Uses Algolia's getObjects REST API to look up packages by objectID
+   * (which equals the package name in the npm-search index).
+   */
+  async function getPackagesByName(packageNames: string[]): Promise<NpmSearchResponse> {
+    if (packageNames.length === 0) {
+      return { isStale: false, objects: [], total: 0, time: new Date().toISOString() }
+    }
+
+    // Algolia getObjects REST API: fetch up to 1000 objects by ID in a single request
+    const response = await $fetch<{ results: (AlgoliaHit | null)[] }>(
+      `https://${algolia.appId}-dsn.algolia.net/1/indexes/*/objects`,
+      {
+        method: 'POST',
+        headers: {
+          'x-algolia-api-key': algolia.apiKey,
+          'x-algolia-application-id': algolia.appId,
+        },
+        body: {
+          requests: packageNames.map(name => ({
+            indexName,
+            objectID: name,
+            attributesToRetrieve: ATTRIBUTES_TO_RETRIEVE,
+          })),
+        },
+      },
+    )
+
+    const hits = response.results.filter((r): r is AlgoliaHit => r !== null && 'name' in r)
+    return {
+      isStale: false,
+      objects: hits.map(hitToSearchResult),
+      total: hits.length,
+      time: new Date().toISOString(),
+    }
+  }
+
   return {
     /** Search packages by text query */
     search,
     /** Fetch all packages for an owner (org or user) */
     searchByOwner,
+    /** Fetch metadata for specific packages by exact name */
+    getPackagesByName,
   }
 }
diff --git a/app/composables/npm/useOrgPackages.ts b/app/composables/npm/useOrgPackages.ts
index 3351419523..7a392f87ba 100644
--- a/app/composables/npm/useOrgPackages.ts
+++ b/app/composables/npm/useOrgPackages.ts
@@ -1,103 +1,27 @@
-import type { NuxtApp } from '#app'
 import type { NpmSearchResponse, NpmSearchResult, MinimalPackument } from '#shared/types'
 import { emptySearchResponse, packumentToSearchResult } from './useNpmSearch'
 import { mapWithConcurrency } from '#shared/utils/async'
 
-/**
- * Fetch downloads for multiple packages.
- * Returns a map of package name -> weekly downloads.
- * Uses bulk API for unscoped packages, parallel individual requests for scoped.
- * Note: npm bulk downloads API does not support scoped packages.
- */
-async function fetchBulkDownloads(
-  $npmApi: NuxtApp['$npmApi'],
-  packageNames: string[],
-  options: Parameters<typeof $fetch>[1] = {},
-): Promise<Map<string, number>> {
-  const downloads = new Map<string, number>()
-  if (packageNames.length === 0) return downloads
-
-  // Separate scoped and unscoped packages
-  const scopedPackages = packageNames.filter(n => n.startsWith('@'))
-  const unscopedPackages = packageNames.filter(n => !n.startsWith('@'))
-
-  // Fetch unscoped packages via bulk API (max 128 per request)
-  const bulkPromises: Promise<void>[] = []
-  const chunkSize = 100
-  for (let i = 0; i < unscopedPackages.length; i += chunkSize) {
-    const chunk = unscopedPackages.slice(i, i + chunkSize)
-    bulkPromises.push(
-      (async () => {
-        try {
-          const response = await $npmApi<Record<string, { downloads: number } | null>>(
-            `/downloads/point/last-week/${chunk.join(',')}`,
-            options,
-          )
-          for (const [name, data] of Object.entries(response.data)) {
-            if (data?.downloads !== undefined) {
-              downloads.set(name, data.downloads)
-            }
-          }
-        } catch {
-          // Ignore errors - downloads are optional
-        }
-      })(),
-    )
-  }
-
-  // Fetch scoped packages in parallel batches (concurrency limit to avoid overwhelming the API)
-  // Use Promise.allSettled to not fail on individual errors
-  const scopedBatchSize = 20 // Concurrent requests per batch
-  for (let i = 0; i < scopedPackages.length; i += scopedBatchSize) {
-    const batch = scopedPackages.slice(i, i + scopedBatchSize)
-    bulkPromises.push(
-      (async () => {
-        const results = await Promise.allSettled(
-          batch.map(async name => {
-            const encoded = encodePackageName(name)
-            const { data } = await $npmApi<{ downloads: number }>(
-              `/downloads/point/last-week/${encoded}`,
-            )
-            return { name, downloads: data.downloads }
-          }),
-        )
-        for (const result of results) {
-          if (result.status === 'fulfilled' && result.value.downloads !== undefined) {
-            downloads.set(result.value.name, result.value.downloads)
-          }
-        }
-      })(),
-    )
-  }
-
-  // Wait for all fetches to complete
-  await Promise.all(bulkPromises)
-
-  return downloads
-}
-
 /**
  * Fetch all packages for an npm organization.
  *
- * Always uses the npm registry's org endpoint as the source of truth for which
- * packages belong to the org. When Algolia is enabled, uses it to quickly fetch
- * metadata for those packages (instead of N+1 packument fetches).
+ * 1. Gets the authoritative package list from the npm registry (single request)
+ * 2. Fetches metadata from Algolia by exact name (single request)
+ * 3. Falls back to individual packument fetches when Algolia is unavailable
  */
 export function useOrgPackages(orgName: MaybeRefOrGetter<string>) {
   const { searchProvider } = useSearchProvider()
-  const { searchByOwner } = useAlgoliaSearch()
+  const { getPackagesByName } = useAlgoliaSearch()
 
   const asyncData = useLazyAsyncData(
     () => `org-packages:${searchProvider.value}:${toValue(orgName)}`,
-    async ({ $npmRegistry, $npmApi, ssrContext }, { signal }) => {
+    async ({ $npmRegistry, ssrContext }, { signal }) => {
       const org = toValue(orgName)
       if (!org) {
         return emptySearchResponse
       }
 
-      // Always get the authoritative package list from the npm registry.
-      // Algolia's owner.name filter doesn't precisely match npm org membership
-      // (e.g. it includes @nuxtjs/* packages for the @nuxt org).
+      // Get the authoritative package list from the npm registry (single request)
       let packageNames: string[]
       try {
         const { packages } = await $fetch<{ packages: string[]; count: number }>(
@@ -126,60 +50,41 @@ export function useOrgPackages(orgName: MaybeRefOrGetter<string>) {
         return emptySearchResponse
       }
 
-      // --- Algolia fast path: use Algolia to get metadata for known packages ---
+      // Fetch metadata + downloads from Algolia (single request via getObjects)
       if (searchProvider.value === 'algolia') {
         try {
-          const response = await searchByOwner(org)
+          const response = await getPackagesByName(packageNames)
           if (response.objects.length > 0) {
-            // Filter Algolia results to only include packages that are
-            // actually in the org (per the npm registry's authoritative list)
-            const orgPackageSet = new Set(packageNames.map(n => n.toLowerCase()))
-            const filtered = response.objects.filter(obj =>
-              orgPackageSet.has(obj.package.name.toLowerCase()),
-            )
-
-            if (filtered.length > 0) {
-              return {
-                ...response,
-                objects: filtered,
-                total: filtered.length,
-              }
-            }
+            return response
           }
         } catch {
           // Fall through to npm registry path
         }
       }
 
-      // --- npm registry path: fetch packuments individually ---
-      const [packuments, downloads] = await Promise.all([
-        (async () => {
-          const results = await mapWithConcurrency(
-            packageNames,
-            async name => {
-              try {
-                const encoded = encodePackageName(name)
-                const { data: pkg } = await $npmRegistry<MinimalPackument>(`/${encoded}`, {
-                  signal,
-                })
-                return pkg
-              } catch {
-                return null
-              }
-            },
-            10,
-          )
-          return results.filter(
-            (pkg): pkg is MinimalPackument => pkg !== null && !!pkg['dist-tags'],
-          )
-        })(),
-        fetchBulkDownloads($npmApi, packageNames, { signal }),
-      ])
+      // npm fallback: fetch packuments individually
+      const packuments = await mapWithConcurrency(
+        packageNames,
+        async name => {
+          try {
+            const encoded = encodePackageName(name)
+            const { data: pkg } = await $npmRegistry<MinimalPackument>(`/${encoded}`, {
+              signal,
+            })
+            return pkg
+          } catch {
+            return null
+          }
+        },
+        10,
+      )
 
-      const results: NpmSearchResult[] = packuments.map(pkg =>
-        packumentToSearchResult(pkg, downloads.get(pkg.name)),
+      const validPackuments = packuments.filter(
+        (pkg): pkg is MinimalPackument => pkg !== null && !!pkg['dist-tags'],
       )
 
+      const results: NpmSearchResult[] = validPackuments.map(pkg => packumentToSearchResult(pkg))
+
       return {
         isStale: false,
         objects: results,