S-jooyoung · Oct 19, 2026
diff --git a/.changeset/solid-query-key-switch-relay.md b/.changeset/solid-query-key-switch-relay.md
@@ -0,0 +1,13 @@
+---
+'@tanstack/solid-query': patch
+---
+
+fix: compute the data once when a query switches to a key that is already
+cached. The read layer bumped its per-hook version signal on every cache
+event for its hash, including the observer events that `setOptions` emits
+from the options render effect, so the data projection (and `select`) ran
+a second time in a later flush and Solid's dev diagnostics reported
+`EFFECT_RELAY_TEAR`. The version now moves only on state events (`added`,
+`removed`, `updated`). `observerResultsUpdated`, which is how a query going
+stale by time reaches the adapter, bumps a separate signal that only
+`isStale` reads.
diff --git a/packages/solid-query/src/__tests__/useQuery-semantics.test.tsx b/packages/solid-query/src/__tests__/useQuery-semantics.test.tsx
@@ -6,7 +6,7 @@
 // re-pointed separately.
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { fireEvent } from '@solidjs/testing-library'
-import { Errored, Loading, createSignal } from 'solid-js'
+import { Errored, Loading, createSignal, flush } from 'solid-js'
 import { queryKey, sleep } from '@tanstack/query-test-utils'
 import { QueryCache, QueryClient, useQuery } from '..'
 import { renderWithClient } from './utils'
@@ -590,4 +590,66 @@ describe('useQuery 2.0 read semantics', () => {
       expect(rendered.getByText('v2')).toBeInTheDocument()
     })
   })
+
+  describe('key switch', () => {
+    // `select` runs once in the observer's `setOptions` and once in the data
+    // projection. Observer bookkeeping events from `setOptions` used to bump
+    // the version and recompute the projection a second time (#11903).
+    function setup() {
+      const key = queryKey()
+      queryClient.setQueryData([...key, 'base'], 1)
+      queryClient.setQueryData([...key, 'site'], 2)
+      const [tariff, setTariff] = createSignal('base')
+      const selected: Array<number> = []
+      const select = (data: number) => {
+        selected.push(data)
+        return data
+      }
+
+      function Price() {
+        const query = useQuery(() => ({
+          queryKey: [...key, tariff()],
+          queryFn: () => 0,
+          staleTime: Infinity,
+          select,
+        }))
+        return <span>{query.data}</span>
+      }
+
+      const rendered = renderWithClient(queryClient, () => (
+        <Loading fallback={<span>loading</span>}>
+          <Price />
+        </Loading>
+      ))
+      flush()
+      return { rendered, selected, setTariff }
+    }
+
+    it('computes the data once when switching to a cached key (#11903)', async () => {
+      const { rendered, selected, setTariff } = setup()
+      selected.length = 0
+
+      setTariff('site')
+      flush()
+      await vi.advanceTimersByTimeAsync(30)
+
+      expect(rendered.getByText('2')).toBeInTheDocument()
+      expect(selected).toEqual([2, 2])
+    })
+
+    it('computes the data once when switching back to a previously loaded key', async () => {
+      const { rendered, selected, setTariff } = setup()
+      setTariff('site')
+      flush()
+      await vi.advanceTimersByTimeAsync(30)
+      selected.length = 0
+
+      setTariff('base')
+      flush()
+      await vi.advanceTimersByTimeAsync(30)
+
+      expect(rendered.getByText('1')).toBeInTheDocument()
+      expect(selected).toEqual([1, 1])
+    })
+  })
 })
diff --git a/packages/solid-query/src/useBaseQuery.ts b/packages/solid-query/src/useBaseQuery.ts
@@ -20,6 +20,7 @@ import type { QueryClient } from './QueryClient'
 import type {
   DefaultedQueryObserverOptions,
   Query,
+  QueryCacheNotifyEvent,
   QueryKey,
   QueryObserver,
   QueryObserverResult,
@@ -197,14 +198,33 @@ export function useBaseQueryLayer<
   const [primed, setPrimed] = createSignal(!hydratedMount, {
     ownedWrite: true,
   })
-  const onCacheEvent = (event: { query: { queryHash: string } }) => {
+  /**
+   * Bumped by `observerResultsUpdated`, which is how the observer reports a
+   * query going stale by time. Only `isStale` reads it: the same event also
+   * follows every `setOptions`, and bumping `version` on it re-ran the data
+   * projection a second time after a key switch (#11903).
+   */
+  const [staleVersion, setStaleVersion] = createSignal(0, {
+    ownedWrite: true,
+  })
+  const onCacheEvent = (event: QueryCacheNotifyEvent) => {
     // Match the committed options hash OR the latest computed one (they
     // diverge during a hold — see `latestHash`).
     if (
-      event.query.queryHash === untrack(defaultedOptions).queryHash ||
-      event.query.queryHash === latestHash
+      event.query.queryHash !== untrack(defaultedOptions).queryHash &&
+      event.query.queryHash !== latestHash
+    ) {
+      return
+    }
+    // Other observer events don't change anything the reads derive.
+    if (
+      event.type === 'added' ||
+      event.type === 'removed' ||
+      event.type === 'updated'
     ) {
       setVersion((v) => v + 1)
+    } else if (event.type === 'observerResultsUpdated') {
+      setStaleVersion((v) => v + 1)
     }
   }
 
@@ -434,11 +454,11 @@ export function useBaseQueryLayer<
    * for hydration adoption on the client.
    */
   // Stable promise identity across recomputes: mid-flight version bumps
-  // (fetch dispatch, observer updates) re-run the data compute while the
-  // same underlying fetch is pending. Chaining a fresh `.then` each time
-  // would hand the engine a new pending promise per recompute — the node
-  // keeps restarting its pending tracking and the settle can be missed
-  // (observed as `isPending` probes stuck true after the fetch lands).
+  // (fetch dispatch, retries, other state updates) re-run the data compute
+  // while the same underlying fetch is pending. Chaining a fresh `.then`
+  // each time would hand the engine a new pending promise per recompute —
+  // the node keeps restarting its pending tracking and the settle can be
+  // missed (observed as `isPending` probes stuck true after the fetch lands).
   let chained: {
     base: Promise<unknown>
     select: unknown
@@ -703,6 +723,7 @@ export function useBaseQueryLayer<
         ? (opts.staleTime as (q: any) => number | 'static')(q)
         : opts.staleTime
     version()
+    staleVersion()
     return q.isStaleByTime(staleTime)
   }