From e461e4ce2ca93cce9511eadd6f977e625a0b2c64 Mon Sep 17 00:00:00 2001
From: Vordgi <sasha2822222@gmail.com>
Date: Tue, 10 Feb 2026 22:20:30 +0000
Subject: [PATCH 01/11] fix: correct search data transferring server to client

---
 app/composables/npm/useSearch.ts | 65 +++++++++++++++++++++++++-------
 1 file changed, 51 insertions(+), 14 deletions(-)

diff --git a/app/composables/npm/useSearch.ts b/app/composables/npm/useSearch.ts
index 39f33e65c..5b525ce8e 100644
--- a/app/composables/npm/useSearch.ts
+++ b/app/composables/npm/useSearch.ts
@@ -4,6 +4,14 @@ import type { AlgoliaMultiSearchChecks } from './useAlgoliaSearch'
 import { type SearchSuggestion, emptySearchResponse, parseSuggestionIntent } from './search-utils'
 import { isValidNewPackageName, checkPackageExists } from '~/utils/package-name'
 
+function emptySearchPayload() {
+  return {
+    searchResponse: emptySearchResponse(),
+    suggestions: [] as SearchSuggestion[],
+    packageAvailability: null as { name: string; available: boolean } | null,
+  }
+}
+
 export interface SearchOptions {
   size?: number
 }
@@ -142,7 +150,7 @@ export function useSearch(
 
       if (!q.trim()) {
         isRateLimited.value = false
-        return emptySearchResponse()
+        return emptySearchPayload()
       }
 
       const opts = toValue(options)
@@ -156,29 +164,37 @@ export function useSearch(
           const result = await algoliaMultiSearch(q, { size: opts.size ?? 25 }, checks)
 
           if (q !== toValue(query)) {
-            return emptySearchResponse()
+            return emptySearchPayload()
           }
 
           isRateLimited.value = false
           processAlgoliaChecks(q, checks, result)
-          return result.search
+          return {
+            searchResponse: result.search,
+            suggestions: suggestions.value,
+            packageAvailability: packageAvailability.value,
+          }
         }
 
         const response = await searchAlgolia(q, { size: opts.size ?? 25 })
 
         if (q !== toValue(query)) {
-          return emptySearchResponse()
+          return emptySearchPayload()
         }
 
         isRateLimited.value = false
-        return response
+        return {
+          searchResponse: response,
+          suggestions: [],
+          packageAvailability: null,
+        }
       }
 
       try {
         const response = await searchNpm(q, { size: opts.size ?? 25 }, signal)
 
         if (q !== toValue(query)) {
-          return emptySearchResponse()
+          return emptySearchPayload()
         }
 
         cache.value = {
@@ -189,7 +205,11 @@ export function useSearch(
         }
 
         isRateLimited.value = false
-        return response
+        return {
+          searchResponse: response,
+          suggestions: [],
+          packageAvailability: null,
+        }
       } catch (error: unknown) {
         const errorMessage = (error as { message?: string })?.message || String(error)
         const isRateLimitError =
@@ -197,12 +217,29 @@ export function useSearch(
 
         if (isRateLimitError) {
           isRateLimited.value = true
-          return emptySearchResponse()
+          return emptySearchPayload()
         }
         throw error
       }
     },
-    { default: emptySearchResponse },
+    { default: emptySearchPayload },
+  )
+
+  watch(
+    [() => asyncData.data.value.suggestions, () => suggestions.value],
+    ([payloadSuggestions, localSuggestions]) => {
+      if (!payloadSuggestions.length && !localSuggestions.length) return
+      suggestions.value = payloadSuggestions.length ? payloadSuggestions : localSuggestions
+    },
+    { immediate: true },
+  )
+
+  watch(
+    [() => asyncData.data.value?.packageAvailability, () => packageAvailability.value],
+    ([payloadPackageAvailability, localPackageAvailability]) => {
+      packageAvailability.value = payloadPackageAvailability || localPackageAvailability
+    },
+    { immediate: true },
   )
 
   async function fetchMore(targetSize: number): Promise<void> {
@@ -222,12 +259,12 @@ export function useSearch(
 
     // Seed cache from asyncData for Algolia (which skips cache on initial fetch)
     if (!cache.value && asyncData.data.value) {
-      const d = asyncData.data.value
+      const { searchResponse } = asyncData.data.value
       cache.value = {
         query: q,
         provider,
-        objects: [...d.objects],
-        total: d.total,
+        objects: [...searchResponse.objects],
+        total: searchResponse.total,
       }
     }
 
@@ -306,10 +343,10 @@ export function useSearch(
         time: new Date().toISOString(),
       }
     }
-    return asyncData.data.value
+    return asyncData.data.value?.searchResponse ?? null
   })
 
-  if (import.meta.client && asyncData.data.value?.isStale) {
+  if (import.meta.client && asyncData.data.value?.searchResponse.isStale) {
     onMounted(() => {
       asyncData.refresh()
     })

From 552240ba32d3aa8e2a21d2292efa7453162eee1e Mon Sep 17 00:00:00 2001
From: Vordgi <sasha2822222@gmail.com>
Date: Tue, 10 Feb 2026 22:31:39 +0000
Subject: [PATCH 02/11] fix: correct search data transferring client to server

---
 app/composables/useSettings.ts | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/app/composables/useSettings.ts b/app/composables/useSettings.ts
index 31476415e..b822b455b 100644
--- a/app/composables/useSettings.ts
+++ b/app/composables/useSettings.ts
@@ -115,11 +115,18 @@ export function useAccentColor() {
  * Composable for managing the search provider setting.
  */
 export function useSearchProvider() {
+  const cookie = useCookie('search-provider', {
+    secure: true,
+    sameSite: 'strict',
+    maxAge: 60 * 60 * 24 * 30,
+    path: '/',
+  })
   const { settings } = useSettings()
 
   const searchProvider = computed({
-    get: () => settings.value.searchProvider,
+    get: () => (cookie.value === 'npm' ? 'npm' : settings.value.searchProvider),
     set: (value: SearchProvider) => {
+      cookie.value = value
       settings.value.searchProvider = value
     },
   })

From 73c4d8429c08d4aca76a678c303e9d339c0bbea0 Mon Sep 17 00:00:00 2001
From: Vordgi <sasha2822222@gmail.com>
Date: Tue, 10 Feb 2026 23:15:19 +0000
Subject: [PATCH 03/11] fix: correct npm search data transferring server to
 client

---
 app/composables/npm/useSearch.ts | 225 ++++++++++++++++---------------
 1 file changed, 115 insertions(+), 110 deletions(-)

diff --git a/app/composables/npm/useSearch.ts b/app/composables/npm/useSearch.ts
index 5b525ce8e..77820a472 100644
--- a/app/composables/npm/useSearch.ts
+++ b/app/composables/npm/useSearch.ts
@@ -52,7 +52,7 @@ export function useSearch(
   const suggestionsLoading = shallowRef(false)
   const packageAvailability = shallowRef<{ name: string; available: boolean } | null>(null)
   const existenceCache = shallowRef<Record<string, boolean>>({})
-  let suggestionRequestId = 0
+  const suggestionRequestId = shallowRef(0)
 
   /**
    * Determine which extra checks to include in the Algolia multi-search.
@@ -225,23 +225,6 @@ export function useSearch(
     { default: emptySearchPayload },
   )
 
-  watch(
-    [() => asyncData.data.value.suggestions, () => suggestions.value],
-    ([payloadSuggestions, localSuggestions]) => {
-      if (!payloadSuggestions.length && !localSuggestions.length) return
-      suggestions.value = payloadSuggestions.length ? payloadSuggestions : localSuggestions
-    },
-    { immediate: true },
-  )
-
-  watch(
-    [() => asyncData.data.value?.packageAvailability, () => packageAvailability.value],
-    ([payloadPackageAvailability, localPackageAvailability]) => {
-      packageAvailability.value = payloadPackageAvailability || localPackageAvailability
-    },
-    { immediate: true },
-  )
-
   async function fetchMore(targetSize: number): Promise<void> {
     const q = toValue(query).trim()
     const provider = searchProvider.value
@@ -346,118 +329,140 @@ export function useSearch(
     return asyncData.data.value?.searchResponse ?? null
   })
 
-  if (import.meta.client && asyncData.data.value?.searchResponse.isStale) {
-    onMounted(() => {
-      asyncData.refresh()
-    })
-  }
-
   const hasMore = computed(() => {
     if (!cache.value) return true
     return cache.value.objects.length < cache.value.total
   })
 
-  // npm suggestion checking (Algolia handles suggestions inside the search handler above)
-  if (config.suggestions) {
-    async function validateSuggestionsNpm(q: string) {
-      const requestId = ++suggestionRequestId
-      const { intent, name } = parseSuggestionIntent(q)
-
-      const trimmed = q.trim()
-      if (isValidNewPackageName(trimmed)) {
-        checkPackageExists(trimmed)
-          .then(exists => {
-            if (trimmed === toValue(query).trim()) {
-              packageAvailability.value = { name: trimmed, available: !exists }
-            }
-          })
-          .catch(() => {
-            packageAvailability.value = null
-          })
-      } else {
-        packageAvailability.value = null
-      }
+  async function validateSuggestionsNpm(q: string) {
+    const requestId = ++suggestionRequestId.value
+    const { intent, name } = parseSuggestionIntent(q)
+    let availability: { name: string; available: boolean } | null = null
 
-      if (!intent || !name) {
-        suggestions.value = []
-        suggestionsLoading.value = false
-        return
-      }
+    const trimmed = q.trim()
+    if (isValidNewPackageName(trimmed)) {
+      checkPackageExists(trimmed)
+        .then(exists => {
+          if (trimmed === toValue(query).trim()) {
+            availability = { name: trimmed, available: !exists }
+            packageAvailability.value = availability
+          }
+        })
+        .catch(() => {
+          availability = null
+        })
+    } else {
+      availability = null
+    }
 
-      suggestionsLoading.value = true
-      const result: SearchSuggestion[] = []
-      const lowerName = name.toLowerCase()
+    if (!intent || !name) {
+      suggestionsLoading.value = false
+      return { suggestions: [], packageAvailability: availability }
+    }
 
-      try {
-        const wantOrg = intent === 'org' || intent === 'both'
-        const wantUser = intent === 'user' || intent === 'both'
-
-        const promises: Promise<void>[] = []
-
-        if (wantOrg && existenceCache.value[`org:${lowerName}`] === undefined) {
-          promises.push(
-            checkOrgNpm(name)
-              .then(exists => {
-                existenceCache.value = { ...existenceCache.value, [`org:${lowerName}`]: exists }
-              })
-              .catch(() => {
-                existenceCache.value = { ...existenceCache.value, [`org:${lowerName}`]: false }
-              }),
-          )
-        }
+    suggestionsLoading.value = true
+    const result: SearchSuggestion[] = []
+    const lowerName = name.toLowerCase()
 
-        if (wantUser && existenceCache.value[`user:${lowerName}`] === undefined) {
-          promises.push(
-            checkUserNpm(name)
-              .then(exists => {
-                existenceCache.value = { ...existenceCache.value, [`user:${lowerName}`]: exists }
-              })
-              .catch(() => {
-                existenceCache.value = { ...existenceCache.value, [`user:${lowerName}`]: false }
-              }),
-          )
-        }
+    try {
+      const wantOrg = intent === 'org' || intent === 'both'
+      const wantUser = intent === 'user' || intent === 'both'
 
-        if (promises.length > 0) {
-          await Promise.all(promises)
-        }
+      const promises: Promise<void>[] = []
 
-        if (requestId !== suggestionRequestId) return
+      if (wantOrg && existenceCache.value[`org:${lowerName}`] === undefined) {
+        promises.push(
+          checkOrgNpm(name)
+            .then(exists => {
+              existenceCache.value = { ...existenceCache.value, [`org:${lowerName}`]: exists }
+            })
+            .catch(() => {
+              existenceCache.value = { ...existenceCache.value, [`org:${lowerName}`]: false }
+            }),
+        )
+      }
 
-        const isOrg = wantOrg && existenceCache.value[`org:${lowerName}`]
-        const isUser = wantUser && existenceCache.value[`user:${lowerName}`]
+      if (wantUser && existenceCache.value[`user:${lowerName}`] === undefined) {
+        promises.push(
+          checkUserNpm(name)
+            .then(exists => {
+              existenceCache.value = { ...existenceCache.value, [`user:${lowerName}`]: exists }
+            })
+            .catch(() => {
+              existenceCache.value = { ...existenceCache.value, [`user:${lowerName}`]: false }
+            }),
+        )
+      }
 
-        if (isOrg) {
-          result.push({ type: 'org', name, exists: true })
-        }
-        if (isUser && !isOrg) {
-          result.push({ type: 'user', name, exists: true })
-        }
-      } finally {
-        if (requestId === suggestionRequestId) {
-          suggestionsLoading.value = false
-        }
+      if (promises.length > 0) {
+        await Promise.all(promises)
       }
 
-      if (requestId === suggestionRequestId) {
-        suggestions.value = result
+      if (requestId !== suggestionRequestId.value)
+        return { suggestions: [], packageAvailability: availability }
+
+      const isOrg = wantOrg && existenceCache.value[`org:${lowerName}`]
+      const isUser = wantUser && existenceCache.value[`user:${lowerName}`]
+
+      if (isOrg) {
+        result.push({ type: 'org', name, exists: true })
+      }
+      if (isUser && !isOrg) {
+        result.push({ type: 'user', name, exists: true })
+      }
+    } finally {
+      if (requestId === suggestionRequestId.value) {
+        suggestionsLoading.value = false
       }
     }
 
-    watch(
-      () => toValue(query),
-      q => {
-        if (searchProvider.value !== 'algolia') {
-          validateSuggestionsNpm(q)
-        }
-      },
-      { immediate: true },
-    )
+    if (requestId === suggestionRequestId.value) {
+      suggestions.value = result
+      return { suggestions: result, packageAvailability: availability }
+    }
+
+    return { suggestions: [], packageAvailability: availability }
+  }
+
+  const npmSuggestions = useLazyAsyncData(
+    () => `npm-suggestions:${searchProvider.value}:${toValue(query)}`,
+    async () => {
+      const q = toValue(query).trim()
+      if (searchProvider.value === 'algolia' || !q)
+        return { suggestions: [], packageAvailability: null }
+      const { intent, name } = parseSuggestionIntent(q)
+      if (!intent || !name) return { suggestions: [], packageAvailability: null }
+      return validateSuggestionsNpm(q)
+    },
+    { default: () => ({ suggestions: [], packageAvailability: null }) },
+  )
 
-    watch(searchProvider, () => {
-      if (searchProvider.value !== 'algolia') {
-        validateSuggestionsNpm(toValue(query))
+  watch(
+    [() => asyncData.data.value.suggestions, () => npmSuggestions.data.value.suggestions],
+    ([algoliaSuggestions, npmSuggestions]) => {
+      if (algoliaSuggestions.length || npmSuggestions.length) {
+        suggestions.value = algoliaSuggestions.length ? algoliaSuggestions : npmSuggestions
       }
+    },
+    { immediate: true },
+  )
+
+  watch(
+    [
+      () => asyncData.data.value?.packageAvailability,
+      () => npmSuggestions.data.value.packageAvailability,
+    ],
+    ([algoliaPackageAvailability, npmPackageAvailability]) => {
+      if (algoliaPackageAvailability || npmPackageAvailability) {
+        packageAvailability.value = algoliaPackageAvailability || npmPackageAvailability
+      }
+    },
+    { immediate: true },
+  )
+
+  if (import.meta.client && asyncData.data.value?.searchResponse.isStale) {
+    onMounted(() => {
+      asyncData.refresh()
     })
   }
 

From 1f6de931b1f5454cc7da4ca3b3dd4851096def8d Mon Sep 17 00:00:00 2001
From: Vordgi <sasha2822222@gmail.com>
Date: Wed, 11 Feb 2026 00:34:07 +0000
Subject: [PATCH 04/11] fix: apply suggestion about check-package-exist

---
 app/composables/npm/useSearch.ts | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/app/composables/npm/useSearch.ts b/app/composables/npm/useSearch.ts
index 77820a472..7c623dbbc 100644
--- a/app/composables/npm/useSearch.ts
+++ b/app/composables/npm/useSearch.ts
@@ -339,18 +339,22 @@ export function useSearch(
     const { intent, name } = parseSuggestionIntent(q)
     let availability: { name: string; available: boolean } | null = null
 
+    const promises: Promise<void>[] = []
+
     const trimmed = q.trim()
     if (isValidNewPackageName(trimmed)) {
-      checkPackageExists(trimmed)
-        .then(exists => {
-          if (trimmed === toValue(query).trim()) {
-            availability = { name: trimmed, available: !exists }
-            packageAvailability.value = availability
-          }
-        })
-        .catch(() => {
-          availability = null
-        })
+      promises.push(
+        checkPackageExists(trimmed)
+          .then(exists => {
+            if (trimmed === toValue(query).trim()) {
+              availability = { name: trimmed, available: !exists }
+              packageAvailability.value = availability
+            }
+          })
+          .catch(() => {
+            availability = null
+          }),
+      )
     } else {
       availability = null
     }
@@ -368,8 +372,6 @@ export function useSearch(
       const wantOrg = intent === 'org' || intent === 'both'
       const wantUser = intent === 'user' || intent === 'both'
 
-      const promises: Promise<void>[] = []
-
       if (wantOrg && existenceCache.value[`org:${lowerName}`] === undefined) {
         promises.push(
           checkOrgNpm(name)

From d62de7c16e14e0269f29a7db47d22c3ee9699527 Mon Sep 17 00:00:00 2001
From: Vordgi <sasha2822222@gmail.com>
Date: Wed, 11 Feb 2026 01:00:47 +0000
Subject: [PATCH 05/11] fix: rename arg in use-search

---
 app/composables/npm/useSearch.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/app/composables/npm/useSearch.ts b/app/composables/npm/useSearch.ts
index 7c623dbbc..bc3099e99 100644
--- a/app/composables/npm/useSearch.ts
+++ b/app/composables/npm/useSearch.ts
@@ -441,9 +441,9 @@ export function useSearch(
 
   watch(
     [() => asyncData.data.value.suggestions, () => npmSuggestions.data.value.suggestions],
-    ([algoliaSuggestions, npmSuggestions]) => {
-      if (algoliaSuggestions.length || npmSuggestions.length) {
-        suggestions.value = algoliaSuggestions.length ? algoliaSuggestions : npmSuggestions
+    ([algoliaSuggestions, npmSuggestionsValue]) => {
+      if (algoliaSuggestions.length || npmSuggestionsValue.length) {
+        suggestions.value = algoliaSuggestions.length ? algoliaSuggestions : npmSuggestionsValue
       }
     },
     { immediate: true },

From e181dd2b0ee511abf660b0754de72742f0b173d4 Mon Sep 17 00:00:00 2001
From: Vordgi <sasha2822222@gmail.com>
Date: Wed, 11 Feb 2026 01:58:47 +0000
Subject: [PATCH 06/11] fix: use query param for search provider instead of
 cookie

---
 app/components/Compare/PackageSelector.vue    |  3 +-
 app/components/Header/SearchBox.vue           | 18 +++++++---
 .../SearchProviderToggle.client.vue           | 34 ++++++++++++++-----
 app/composables/npm/useOrgPackages.ts         | 10 ++++--
 app/composables/npm/useSearch.ts              | 33 ++++++++++--------
 app/composables/npm/useUserPackages.ts        | 29 ++++++++++------
 app/composables/useSettings.ts                |  9 +----
 app/pages/index.vue                           |  6 ++--
 app/pages/search.vue                          | 19 +++++++----
 9 files changed, 104 insertions(+), 57 deletions(-)

diff --git a/app/components/Compare/PackageSelector.vue b/app/components/Compare/PackageSelector.vue
index efcce9877..6475c9c3e 100644
--- a/app/components/Compare/PackageSelector.vue
+++ b/app/components/Compare/PackageSelector.vue
@@ -15,7 +15,8 @@ const inputValue = shallowRef('')
 const isInputFocused = shallowRef(false)
 
 // Use the shared search composable (supports both npm and Algolia providers)
-const { data: searchData, status } = useSearch(inputValue, { size: 15 })
+const { searchProvider } = useSearchProvider()
+const { data: searchData, status } = useSearch(inputValue, searchProvider, { size: 15 })
 
 const isSearching = computed(() => status.value === 'pending')
 
diff --git a/app/components/Header/SearchBox.vue b/app/components/Header/SearchBox.vue
index 51e2c3567..993c2c105 100644
--- a/app/components/Header/SearchBox.vue
+++ b/app/components/Header/SearchBox.vue
@@ -15,7 +15,13 @@ const emit = defineEmits(['blur', 'focus'])
 
 const router = useRouter()
 const route = useRoute()
-const { isAlgolia } = useSearchProvider()
+// The actual search provider (from URL, used for API calls)
+const searchProviderParam = computed(() => {
+  const p = normalizeSearchParam(route.query.p)
+  return p === 'npm' ? 'npm' : 'algolia'
+})
+const { searchProvider } = useSearchProvider()
+const searchProviderValue = computed(() => searchProviderParam.value || searchProvider.value)
 
 const isSearchFocused = shallowRef(false)
 
@@ -35,7 +41,7 @@ function updateUrlQueryImpl(value: string) {
     return
   }
   if (route.name === 'search') {
-    router.replace({ query: { q: value || undefined } })
+    router.replace({ query: { q: value || undefined, p: searchProviderValue.value } })
     return
   }
   if (!value) {
@@ -46,6 +52,7 @@ function updateUrlQueryImpl(value: string) {
     name: 'search',
     query: {
       q: value,
+      p: searchProviderValue.value,
     },
   })
 }
@@ -54,9 +61,11 @@ const updateUrlQueryNpm = debounce(updateUrlQueryImpl, 250)
 const updateUrlQueryAlgolia = debounce(updateUrlQueryImpl, 80)
 
 const updateUrlQuery = Object.assign(
-  (value: string) => (isAlgolia.value ? updateUrlQueryAlgolia : updateUrlQueryNpm)(value),
+  (value: string) =>
+    (searchProviderValue.value === 'algolia' ? updateUrlQueryAlgolia : updateUrlQueryNpm)(value),
   {
-    flush: () => (isAlgolia.value ? updateUrlQueryAlgolia : updateUrlQueryNpm).flush(),
+    flush: () =>
+      (searchProviderValue.value === 'algolia' ? updateUrlQueryAlgolia : updateUrlQueryNpm).flush(),
   },
 )
 
@@ -85,6 +94,7 @@ function handleSubmit() {
       name: 'search',
       query: {
         q: searchQuery.value,
+        p: searchProviderValue.value,
       },
     })
   } else {
diff --git a/app/components/SearchProviderToggle.client.vue b/app/components/SearchProviderToggle.client.vue
index bb1dff5d1..461d132ae 100644
--- a/app/components/SearchProviderToggle.client.vue
+++ b/app/components/SearchProviderToggle.client.vue
@@ -1,5 +1,12 @@
 <script setup lang="ts">
-const { searchProvider, isAlgolia } = useSearchProvider()
+const route = useRoute()
+const router = useRouter()
+const searchProviderParam = computed(() => {
+  const p = normalizeSearchParam(route.query.p)
+  return p === 'npm' ? 'npm' : 'algolia'
+})
+const { searchProvider } = useSearchProvider()
+const searchProviderValue = computed(() => searchProviderParam.value || searchProvider.value)
 
 const isOpen = shallowRef(false)
 const toggleRef = useTemplateRef('toggleRef')
@@ -47,21 +54,25 @@ useEventListener('keydown', event => {
             type="button"
             role="menuitem"
             class="w-full flex items-start gap-3 px-3 py-2.5 rounded-md text-start transition-colors hover:bg-bg-muted"
-            :class="[!isAlgolia ? 'bg-bg-muted' : '']"
+            :class="[searchProviderValue !== 'algolia' ? 'bg-bg-muted' : '']"
             @click="
               () => {
                 searchProvider = 'npm'
+                router.push({ query: { ...route.query, p: 'npm' } })
                 isOpen = false
               }
             "
           >
             <span
               class="i-carbon:catalog w-4 h-4 mt-0.5 shrink-0"
-              :class="!isAlgolia ? 'text-accent' : 'text-fg-muted'"
+              :class="searchProviderValue !== 'algolia' ? 'text-accent' : 'text-fg-muted'"
               aria-hidden="true"
             />
             <div class="min-w-0 flex-1">
-              <div class="text-sm font-medium" :class="!isAlgolia ? 'text-fg' : 'text-fg-muted'">
+              <div
+                class="text-sm font-medium"
+                :class="searchProviderValue !== 'algolia' ? 'text-fg' : 'text-fg-muted'"
+              >
                 {{ $t('settings.data_source.npm') }}
               </div>
               <p class="text-xs text-fg-subtle mt-0.5">
@@ -75,21 +86,25 @@ useEventListener('keydown', event => {
             type="button"
             role="menuitem"
             class="w-full flex items-start gap-3 px-3 py-2.5 rounded-md text-start transition-colors hover:bg-bg-muted mt-1"
-            :class="[isAlgolia ? 'bg-bg-muted' : '']"
+            :class="[searchProviderValue === 'algolia' ? 'bg-bg-muted' : '']"
             @click="
               () => {
                 searchProvider = 'algolia'
+                router.push({ query: { ...route.query, p: 'algolia' } })
                 isOpen = false
               }
             "
           >
             <span
               class="i-carbon:search w-4 h-4 mt-0.5 shrink-0"
-              :class="isAlgolia ? 'text-accent' : 'text-fg-muted'"
+              :class="searchProviderValue === 'algolia' ? 'text-accent' : 'text-fg-muted'"
               aria-hidden="true"
             />
             <div class="min-w-0 flex-1">
-              <div class="text-sm font-medium" :class="isAlgolia ? 'text-fg' : 'text-fg-muted'">
+              <div
+                class="text-sm font-medium"
+                :class="searchProviderValue === 'algolia' ? 'text-fg' : 'text-fg-muted'"
+              >
                 {{ $t('settings.data_source.algolia') }}
               </div>
               <p class="text-xs text-fg-subtle mt-0.5">
@@ -99,7 +114,10 @@ useEventListener('keydown', event => {
           </button>
 
           <!-- Algolia attribution -->
-          <div v-if="isAlgolia" class="border-t border-border mx-1 mt-1 pt-2 pb-1">
+          <div
+            v-if="searchProviderValue === 'algolia'"
+            class="border-t border-border mx-1 mt-1 pt-2 pb-1"
+          >
             <a
               href="https://www.algolia.com/developers"
               target="_blank"
diff --git a/app/composables/npm/useOrgPackages.ts b/app/composables/npm/useOrgPackages.ts
index 038d0712a..e235f0357 100644
--- a/app/composables/npm/useOrgPackages.ts
+++ b/app/composables/npm/useOrgPackages.ts
@@ -10,11 +10,17 @@ import { mapWithConcurrency } from '#shared/utils/async'
  * 3. Falls back to lightweight server-side package-meta lookups
  */
 export function useOrgPackages(orgName: MaybeRefOrGetter<string>) {
+  const route = useRoute()
+  const searchProviderParam = computed(() => {
+    const p = normalizeSearchParam(route.query.p)
+    return p === 'npm' ? 'npm' : 'algolia'
+  })
   const { searchProvider } = useSearchProvider()
+  const searchProviderValue = computed(() => searchProviderParam.value || searchProvider.value)
   const { getPackagesByName } = useAlgoliaSearch()
 
   const asyncData = useLazyAsyncData(
-    () => `org-packages:${searchProvider.value}:${toValue(orgName)}`,
+    () => `org-packages:${searchProviderValue.value}:${toValue(orgName)}`,
     async ({ ssrContext }, { signal }) => {
       const org = toValue(orgName)
       if (!org) {
@@ -51,7 +57,7 @@ export function useOrgPackages(orgName: MaybeRefOrGetter<string>) {
       }
 
       // Fetch metadata + downloads from Algolia (single request via getObjects)
-      if (searchProvider.value === 'algolia') {
+      if (searchProviderValue.value === 'algolia') {
         try {
           const response = await getPackagesByName(packageNames)
           if (response.objects.length > 0) {
diff --git a/app/composables/npm/useSearch.ts b/app/composables/npm/useSearch.ts
index bc3099e99..302d05299 100644
--- a/app/composables/npm/useSearch.ts
+++ b/app/composables/npm/useSearch.ts
@@ -27,10 +27,10 @@ export interface UseSearchConfig {
 
 export function useSearch(
   query: MaybeRefOrGetter<string>,
+  searchProvider: MaybeRefOrGetter<SearchProvider>,
   options: MaybeRefOrGetter<SearchOptions> = {},
   config: UseSearchConfig = {},
 ) {
-  const { searchProvider } = useSearchProvider()
   const { search: searchAlgolia, searchWithSuggestions: algoliaMultiSearch } = useAlgoliaSearch()
   const {
     search: searchNpm,
@@ -143,10 +143,10 @@ export function useSearch(
   }
 
   const asyncData = useLazyAsyncData(
-    () => `search:${searchProvider.value}:${toValue(query)}`,
+    () => `search:${toValue(searchProvider)}:${toValue(query)}`,
     async (_nuxtApp, { signal }) => {
       const q = toValue(query)
-      const provider = searchProvider.value
+      const provider = toValue(searchProvider)
 
       if (!q.trim()) {
         isRateLimited.value = false
@@ -227,7 +227,7 @@ export function useSearch(
 
   async function fetchMore(targetSize: number): Promise<void> {
     const q = toValue(query).trim()
-    const provider = searchProvider.value
+    const provider = toValue(searchProvider)
 
     if (!q) {
       cache.value = null
@@ -307,15 +307,18 @@ export function useSearch(
     },
   )
 
-  watch(searchProvider, async () => {
-    cache.value = null
-    existenceCache.value = {}
-    await asyncData.refresh()
-    const targetSize = toValue(options).size
-    if (targetSize) {
-      await fetchMore(targetSize)
-    }
-  })
+  watch(
+    () => toValue(searchProvider),
+    async () => {
+      cache.value = null
+      existenceCache.value = {}
+      await asyncData.refresh()
+      const targetSize = toValue(options).size
+      if (targetSize) {
+        await fetchMore(targetSize)
+      }
+    },
+  )
 
   const data = computed<NpmSearchResponse | null>(() => {
     if (cache.value) {
@@ -427,10 +430,10 @@ export function useSearch(
   }
 
   const npmSuggestions = useLazyAsyncData(
-    () => `npm-suggestions:${searchProvider.value}:${toValue(query)}`,
+    () => `npm-suggestions:${toValue(searchProvider)}:${toValue(query)}`,
     async () => {
       const q = toValue(query).trim()
-      if (searchProvider.value === 'algolia' || !q)
+      if (toValue(searchProvider) === 'algolia' || !q)
         return { suggestions: [], packageAvailability: null }
       const { intent, name } = parseSuggestionIntent(q)
       if (!intent || !name) return { suggestions: [], packageAvailability: null }
diff --git a/app/composables/npm/useUserPackages.ts b/app/composables/npm/useUserPackages.ts
index c42f53064..c9cb82e13 100644
--- a/app/composables/npm/useUserPackages.ts
+++ b/app/composables/npm/useUserPackages.ts
@@ -22,7 +22,13 @@ const MAX_RESULTS = 250
  * ```
  */
 export function useUserPackages(username: MaybeRefOrGetter<string>) {
+  const route = useRoute()
+  const searchProviderParam = computed(() => {
+    const p = normalizeSearchParam(route.query.p)
+    return p === 'npm' ? 'npm' : 'algolia'
+  })
   const { searchProvider } = useSearchProvider()
+  const searchProviderValue = computed(() => searchProviderParam.value || searchProvider.value)
   // this is only used in npm path, but we need to extract it when the composable runs
   const { $npmRegistry } = useNuxtApp()
   const { searchByOwner } = useAlgoliaSearch()
@@ -32,7 +38,7 @@ export function useUserPackages(username: MaybeRefOrGetter<string>) {
 
   /** Tracks which provider actually served the current data (may differ from
    *  searchProvider when Algolia returns empty and we fall through to npm) */
-  const activeProvider = shallowRef<'npm' | 'algolia'>(searchProvider.value)
+  const activeProvider = shallowRef<'npm' | 'algolia'>(searchProviderValue.value)
 
   const cache = shallowRef<{
     username: string
@@ -43,14 +49,14 @@ export function useUserPackages(username: MaybeRefOrGetter<string>) {
   const isLoadingMore = shallowRef(false)
 
   const asyncData = useLazyAsyncData(
-    () => `user-packages:${searchProvider.value}:${toValue(username)}`,
+    () => `user-packages:${searchProviderValue.value}:${toValue(username)}`,
     async ({ $npmRegistry }, { signal }) => {
       const user = toValue(username)
       if (!user) {
         return emptySearchResponse()
       }
 
-      const provider = searchProvider.value
+      const provider = searchProviderValue.value
 
       // --- Algolia: fetch all at once ---
       if (provider === 'algolia') {
@@ -58,7 +64,7 @@ export function useUserPackages(username: MaybeRefOrGetter<string>) {
           const response = await searchByOwner(user)
 
           // Guard against stale response (user/provider changed during await)
-          if (user !== toValue(username) || provider !== searchProvider.value) {
+          if (user !== toValue(username) || provider !== searchProviderValue.value) {
             return emptySearchResponse()
           }
 
@@ -95,7 +101,7 @@ export function useUserPackages(username: MaybeRefOrGetter<string>) {
       )
 
       // Guard against stale response (user/provider changed during await)
-      if (user !== toValue(username) || provider !== searchProvider.value) {
+      if (user !== toValue(username) || provider !== searchProviderValue.value) {
         return emptySearchResponse()
       }
 
@@ -193,11 +199,14 @@ export function useUserPackages(username: MaybeRefOrGetter<string>) {
 
   // asyncdata will automatically rerun due to key, but we need to reset cache/page
   // when provider changes
-  watch(searchProvider, newProvider => {
-    cache.value = null
-    currentPage.value = 1
-    activeProvider.value = newProvider
-  })
+  watch(
+    () => searchProviderValue.value,
+    newProvider => {
+      cache.value = null
+      currentPage.value = 1
+      activeProvider.value = newProvider
+    },
+  )
 
   // Computed data that uses cache (only if it belongs to the current username)
   const data = computed<NpmSearchResponse | null>(() => {
diff --git a/app/composables/useSettings.ts b/app/composables/useSettings.ts
index b822b455b..31476415e 100644
--- a/app/composables/useSettings.ts
+++ b/app/composables/useSettings.ts
@@ -115,18 +115,11 @@ export function useAccentColor() {
  * Composable for managing the search provider setting.
  */
 export function useSearchProvider() {
-  const cookie = useCookie('search-provider', {
-    secure: true,
-    sameSite: 'strict',
-    maxAge: 60 * 60 * 24 * 30,
-    path: '/',
-  })
   const { settings } = useSettings()
 
   const searchProvider = computed({
-    get: () => (cookie.value === 'npm' ? 'npm' : settings.value.searchProvider),
+    get: () => settings.value.searchProvider,
     set: (value: SearchProvider) => {
-      cookie.value = value
       settings.value.searchProvider = value
     },
   })
diff --git a/app/pages/index.vue b/app/pages/index.vue
index 9053fd1d3..4d8da912d 100644
--- a/app/pages/index.vue
+++ b/app/pages/index.vue
@@ -2,7 +2,7 @@
 import { debounce } from 'perfect-debounce'
 import { SHOWCASED_FRAMEWORKS } from '~/utils/frameworks'
 
-const { isAlgolia } = useSearchProvider()
+const { searchProvider } = useSearchProvider()
 
 const searchQuery = shallowRef('')
 const isSearchFocused = shallowRef(false)
@@ -12,7 +12,7 @@ async function search() {
   if (!query) return
   await navigateTo({
     path: '/search',
-    query: query ? { q: query } : undefined,
+    query: query ? { q: query, p: searchProvider.value } : undefined,
   })
   const newQuery = searchQuery.value.trim()
   if (newQuery !== query) {
@@ -26,7 +26,7 @@ const handleInputAlgolia = debounce(search, 80, { leading: true, trailing: true
 function handleInput() {
   if (isTouchDevice()) {
     search()
-  } else if (isAlgolia.value) {
+  } else if (searchProvider.value === 'algolia') {
     handleInputAlgolia()
   } else {
     handleInputNpm()
diff --git a/app/pages/search.vue b/app/pages/search.vue
index 49d44c7b3..249735602 100644
--- a/app/pages/search.vue
+++ b/app/pages/search.vue
@@ -10,8 +10,13 @@ import { normalizeSearchParam } from '#shared/utils/url'
 const route = useRoute()
 const router = useRouter()
 
-// Search provider
-const { isAlgolia } = useSearchProvider()
+// The actual search provider (from URL, used for API calls)
+const searchProviderParam = computed(() => {
+  const p = normalizeSearchParam(route.query.p)
+  return p === 'npm' ? 'npm' : 'algolia'
+})
+const { searchProvider } = useSearchProvider()
+const searchProviderValue = computed(() => searchProviderParam.value || searchProvider.value)
 
 // Preferences (persisted to localStorage)
 const {
@@ -29,6 +34,7 @@ const updateUrlPage = debounce((page: number) => {
     query: {
       ...route.query,
       page: page > 1 ? page : undefined,
+      p: searchProviderValue.value,
     },
   })
 }, 500)
@@ -126,7 +132,7 @@ const ALL_SORT_KEYS: SortKey[] = [
 
 // Disable sort keys the current provider can't meaningfully sort by
 const disabledSortKeys = computed<SortKey[]>(() => {
-  const supported = PROVIDER_SORT_KEYS[isAlgolia.value ? 'algolia' : 'npm']
+  const supported = PROVIDER_SORT_KEYS[searchProviderValue.value]
   return ALL_SORT_KEYS.filter(k => !supported.has(k))
 })
 
@@ -168,16 +174,16 @@ const requestedSize = computed(() => {
   // 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) {
-    const cap = isAlgolia.value ? EAGER_LOAD_SIZE.algolia : EAGER_LOAD_SIZE.npm
+    const cap = EAGER_LOAD_SIZE[searchProviderValue.value]
     return Math.max(base, cap)
   }
   return base
 })
 
 // Reset to relevance sort when switching to a provider that doesn't support the current sort key
-watch(isAlgolia, algolia => {
+watch(searchProviderValue, provider => {
   const { key } = parseSortOption(sortOption.value)
-  const supported = PROVIDER_SORT_KEYS[algolia ? 'algolia' : 'npm']
+  const supported = PROVIDER_SORT_KEYS[provider]
   if (!supported.has(key)) {
     sortOption.value = 'relevance-desc'
   }
@@ -195,6 +201,7 @@ const {
   packageAvailability,
 } = useSearch(
   query,
+  searchProviderValue,
   () => ({
     size: requestedSize.value,
   }),

From bd9b041b7a6ff1fd927a1613bdbb6af4c35ad4ca Mon Sep 17 00:00:00 2001
From: Vordgi <sasha2822222@gmail.com>
Date: Wed, 11 Feb 2026 02:05:17 +0000
Subject: [PATCH 07/11] fix: add provider param only for npm

---
 app/components/Header/SearchBox.vue            | 6 ++++--
 app/components/SearchProviderToggle.client.vue | 2 +-
 app/pages/index.vue                            | 2 +-
 app/pages/search.vue                           | 2 +-
 4 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/app/components/Header/SearchBox.vue b/app/components/Header/SearchBox.vue
index 993c2c105..4f1811615 100644
--- a/app/components/Header/SearchBox.vue
+++ b/app/components/Header/SearchBox.vue
@@ -41,7 +41,9 @@ function updateUrlQueryImpl(value: string) {
     return
   }
   if (route.name === 'search') {
-    router.replace({ query: { q: value || undefined, p: searchProviderValue.value } })
+    router.replace({
+      query: { q: value || undefined, p: searchProviderValue.value === 'npm' ? 'npm' : undefined },
+    })
     return
   }
   if (!value) {
@@ -52,7 +54,7 @@ function updateUrlQueryImpl(value: string) {
     name: 'search',
     query: {
       q: value,
-      p: searchProviderValue.value,
+      p: searchProviderValue.value === 'npm' ? 'npm' : undefined,
     },
   })
 }
diff --git a/app/components/SearchProviderToggle.client.vue b/app/components/SearchProviderToggle.client.vue
index 461d132ae..b9e507b8f 100644
--- a/app/components/SearchProviderToggle.client.vue
+++ b/app/components/SearchProviderToggle.client.vue
@@ -90,7 +90,7 @@ useEventListener('keydown', event => {
             @click="
               () => {
                 searchProvider = 'algolia'
-                router.push({ query: { ...route.query, p: 'algolia' } })
+                router.push({ query: { ...route.query, p: undefined } })
                 isOpen = false
               }
             "
diff --git a/app/pages/index.vue b/app/pages/index.vue
index 4d8da912d..897888a27 100644
--- a/app/pages/index.vue
+++ b/app/pages/index.vue
@@ -12,7 +12,7 @@ async function search() {
   if (!query) return
   await navigateTo({
     path: '/search',
-    query: query ? { q: query, p: searchProvider.value } : undefined,
+    query: query ? { q: query, p: searchProvider.value === 'npm' ? 'npm' : undefined } : undefined,
   })
   const newQuery = searchQuery.value.trim()
   if (newQuery !== query) {
diff --git a/app/pages/search.vue b/app/pages/search.vue
index 249735602..3a792cd38 100644
--- a/app/pages/search.vue
+++ b/app/pages/search.vue
@@ -34,7 +34,7 @@ const updateUrlPage = debounce((page: number) => {
     query: {
       ...route.query,
       page: page > 1 ? page : undefined,
-      p: searchProviderValue.value,
+      p: searchProviderValue.value === 'npm' ? 'npm' : undefined,
     },
   })
 }, 500)

From e024a63992792dd94bc991708aca08690cd7aa71 Mon Sep 17 00:00:00 2001
From: Vordgi <sasha2822222@gmail.com>
Date: Wed, 11 Feb 2026 02:24:19 +0000
Subject: [PATCH 08/11] fix: fix navigation to search for provider

---
 app/components/Header/SearchBox.vue | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/app/components/Header/SearchBox.vue b/app/components/Header/SearchBox.vue
index 4f1811615..e13d5c6e1 100644
--- a/app/components/Header/SearchBox.vue
+++ b/app/components/Header/SearchBox.vue
@@ -15,12 +15,13 @@ const emit = defineEmits(['blur', 'focus'])
 
 const router = useRouter()
 const route = useRoute()
+const { searchProvider } = useSearchProvider()
 // The actual search provider (from URL, used for API calls)
 const searchProviderParam = computed(() => {
   const p = normalizeSearchParam(route.query.p)
+  if (!p && searchProvider.value === 'npm') return 'npm'
   return p === 'npm' ? 'npm' : 'algolia'
 })
-const { searchProvider } = useSearchProvider()
 const searchProviderValue = computed(() => searchProviderParam.value || searchProvider.value)
 
 const isSearchFocused = shallowRef(false)
@@ -35,15 +36,13 @@ const searchQuery = shallowRef(normalizeSearchParam(route.query.q))
 // Pages that have their own local filter using ?q
 const pagesWithLocalFilter = new Set(['~username', 'org'])
 
-function updateUrlQueryImpl(value: string) {
+function updateUrlQueryImpl(value: string, provider: 'npm' | 'algolia') {
   // Don't navigate away from pages that use ?q for local filtering
   if (pagesWithLocalFilter.has(route.name as string)) {
     return
   }
   if (route.name === 'search') {
-    router.replace({
-      query: { q: value || undefined, p: searchProviderValue.value === 'npm' ? 'npm' : undefined },
-    })
+    router.replace({ query: { q: value || undefined, p: provider === 'npm' ? 'npm' : undefined } })
     return
   }
   if (!value) {
@@ -54,7 +53,7 @@ function updateUrlQueryImpl(value: string) {
     name: 'search',
     query: {
       q: value,
-      p: searchProviderValue.value === 'npm' ? 'npm' : undefined,
+      p: provider === 'npm' ? 'npm' : undefined,
     },
   })
 }
@@ -64,7 +63,10 @@ const updateUrlQueryAlgolia = debounce(updateUrlQueryImpl, 80)
 
 const updateUrlQuery = Object.assign(
   (value: string) =>
-    (searchProviderValue.value === 'algolia' ? updateUrlQueryAlgolia : updateUrlQueryNpm)(value),
+    (searchProviderValue.value === 'algolia' ? updateUrlQueryAlgolia : updateUrlQueryNpm)(
+      value,
+      searchProviderValue.value,
+    ),
   {
     flush: () =>
       (searchProviderValue.value === 'algolia' ? updateUrlQueryAlgolia : updateUrlQueryNpm).flush(),
@@ -96,7 +98,7 @@ function handleSubmit() {
       name: 'search',
       query: {
         q: searchQuery.value,
-        p: searchProviderValue.value,
+        p: searchProviderValue.value === 'npm' ? 'npm' : undefined,
       },
     })
   } else {

From e3e470c19f4aeeabd750666670e89694eb581c81 Mon Sep 17 00:00:00 2001
From: Vordgi <sasha2822222@gmail.com>
Date: Wed, 11 Feb 2026 09:42:04 +0000
Subject: [PATCH 09/11] test: update search navigation test for suggestions

---
 test/e2e/interactions.spec.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/e2e/interactions.spec.ts b/test/e2e/interactions.spec.ts
index f40403267..b900bbafa 100644
--- a/test/e2e/interactions.spec.ts
+++ b/test/e2e/interactions.spec.ts
@@ -68,9 +68,9 @@ test.describe('Search Pages', () => {
     await page.keyboard.press('ArrowUp')
 
     // Enter navigates to the selected result
-    // URL is /package/vue not /vue
+    // URL is /package/vue or /org/vue or /user/vue. Not /vue
     await page.keyboard.press('Enter')
-    await expect(page).toHaveURL(/\/package\/vue/)
+    await expect(page).toHaveURL(/\/(package|org|user)\/vue/)
   })
 
   test('/search?q=vue → "/" focuses the search input from results', async ({ page, goto }) => {

From 2277c0280939ff871d55300e586ba06214b2c364 Mon Sep 17 00:00:00 2001
From: Vordgi <sasha2822222@gmail.com>
Date: Wed, 11 Feb 2026 09:43:15 +0000
Subject: [PATCH 10/11] fix: always wait promises in validate suggestions

---
 app/composables/npm/useSearch.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/app/composables/npm/useSearch.ts b/app/composables/npm/useSearch.ts
index 302d05299..302cb159e 100644
--- a/app/composables/npm/useSearch.ts
+++ b/app/composables/npm/useSearch.ts
@@ -364,6 +364,7 @@ export function useSearch(
 
     if (!intent || !name) {
       suggestionsLoading.value = false
+      await Promise.all(promises)
       return { suggestions: [], packageAvailability: availability }
     }
 

From 9d6fa0a7291ccf1108a95b529ad6dcd7d2cefc32 Mon Sep 17 00:00:00 2001
From: Vordgi <sasha2822222@gmail.com>
Date: Wed, 11 Feb 2026 09:57:42 +0000
Subject: [PATCH 11/11] fix: update provider detection logic

---
 app/components/Header/SearchBox.vue            | 8 +++-----
 app/components/SearchProviderToggle.client.vue | 8 ++++----
 app/composables/npm/useOrgPackages.ts          | 8 ++++----
 app/composables/npm/useUserPackages.ts         | 8 ++++----
 app/pages/search.vue                           | 9 ++++-----
 5 files changed, 19 insertions(+), 22 deletions(-)

diff --git a/app/components/Header/SearchBox.vue b/app/components/Header/SearchBox.vue
index e13d5c6e1..d9b5adf4d 100644
--- a/app/components/Header/SearchBox.vue
+++ b/app/components/Header/SearchBox.vue
@@ -16,13 +16,11 @@ const emit = defineEmits(['blur', 'focus'])
 const router = useRouter()
 const route = useRoute()
 const { searchProvider } = useSearchProvider()
-// The actual search provider (from URL, used for API calls)
-const searchProviderParam = computed(() => {
+const searchProviderValue = computed(() => {
   const p = normalizeSearchParam(route.query.p)
-  if (!p && searchProvider.value === 'npm') return 'npm'
-  return p === 'npm' ? 'npm' : 'algolia'
+  if (p === 'npm' || searchProvider.value === 'npm') return 'npm'
+  return 'algolia'
 })
-const searchProviderValue = computed(() => searchProviderParam.value || searchProvider.value)
 
 const isSearchFocused = shallowRef(false)
 
diff --git a/app/components/SearchProviderToggle.client.vue b/app/components/SearchProviderToggle.client.vue
index b9e507b8f..deeb89f01 100644
--- a/app/components/SearchProviderToggle.client.vue
+++ b/app/components/SearchProviderToggle.client.vue
@@ -1,12 +1,12 @@
 <script setup lang="ts">
 const route = useRoute()
 const router = useRouter()
-const searchProviderParam = computed(() => {
+const { searchProvider } = useSearchProvider()
+const searchProviderValue = computed(() => {
   const p = normalizeSearchParam(route.query.p)
-  return p === 'npm' ? 'npm' : 'algolia'
+  if (p === 'npm' || searchProvider.value === 'npm') return 'npm'
+  return 'algolia'
 })
-const { searchProvider } = useSearchProvider()
-const searchProviderValue = computed(() => searchProviderParam.value || searchProvider.value)
 
 const isOpen = shallowRef(false)
 const toggleRef = useTemplateRef('toggleRef')
diff --git a/app/composables/npm/useOrgPackages.ts b/app/composables/npm/useOrgPackages.ts
index e235f0357..3e1321d60 100644
--- a/app/composables/npm/useOrgPackages.ts
+++ b/app/composables/npm/useOrgPackages.ts
@@ -11,12 +11,12 @@ import { mapWithConcurrency } from '#shared/utils/async'
  */
 export function useOrgPackages(orgName: MaybeRefOrGetter<string>) {
   const route = useRoute()
-  const searchProviderParam = computed(() => {
+  const { searchProvider } = useSearchProvider()
+  const searchProviderValue = computed(() => {
     const p = normalizeSearchParam(route.query.p)
-    return p === 'npm' ? 'npm' : 'algolia'
+    if (p === 'npm' || searchProvider.value === 'npm') return 'npm'
+    return 'algolia'
   })
-  const { searchProvider } = useSearchProvider()
-  const searchProviderValue = computed(() => searchProviderParam.value || searchProvider.value)
   const { getPackagesByName } = useAlgoliaSearch()
 
   const asyncData = useLazyAsyncData(
diff --git a/app/composables/npm/useUserPackages.ts b/app/composables/npm/useUserPackages.ts
index c9cb82e13..dc9ab0ffa 100644
--- a/app/composables/npm/useUserPackages.ts
+++ b/app/composables/npm/useUserPackages.ts
@@ -23,12 +23,12 @@ const MAX_RESULTS = 250
  */
 export function useUserPackages(username: MaybeRefOrGetter<string>) {
   const route = useRoute()
-  const searchProviderParam = computed(() => {
+  const { searchProvider } = useSearchProvider()
+  const searchProviderValue = computed(() => {
     const p = normalizeSearchParam(route.query.p)
-    return p === 'npm' ? 'npm' : 'algolia'
+    if (p === 'npm' || searchProvider.value === 'npm') return 'npm'
+    return 'algolia'
   })
-  const { searchProvider } = useSearchProvider()
-  const searchProviderValue = computed(() => searchProviderParam.value || searchProvider.value)
   // this is only used in npm path, but we need to extract it when the composable runs
   const { $npmRegistry } = useNuxtApp()
   const { searchByOwner } = useAlgoliaSearch()
diff --git a/app/pages/search.vue b/app/pages/search.vue
index 3a792cd38..ca4c63f92 100644
--- a/app/pages/search.vue
+++ b/app/pages/search.vue
@@ -10,13 +10,12 @@ import { normalizeSearchParam } from '#shared/utils/url'
 const route = useRoute()
 const router = useRouter()
 
-// The actual search provider (from URL, used for API calls)
-const searchProviderParam = computed(() => {
+const { searchProvider } = useSearchProvider()
+const searchProviderValue = computed(() => {
   const p = normalizeSearchParam(route.query.p)
-  return p === 'npm' ? 'npm' : 'algolia'
+  if (p === 'npm' || searchProvider.value === 'npm') return 'npm'
+  return 'algolia'
 })
-const { searchProvider } = useSearchProvider()
-const searchProviderValue = computed(() => searchProviderParam.value || searchProvider.value)
 
 // Preferences (persisted to localStorage)
 const {