A-Raphie · Oct 19, 2026 · Oct 19, 2026
diff --git a/packages/query-core/src/__tests__/query.test.tsx b/packages/query-core/src/__tests__/query.test.tsx
@@ -61,6 +61,28 @@ describe('query', () => {
     expect(query.gcTime).toBe(200)
   })
 
+  it('should not schedule a gc timer on the server even with a finite gcTime', async () => {
+    const restore = setIsServer(true)
+    try {
+      const key = queryKey()
+      await queryClient
+        .query({
+          queryKey: key,
+          queryFn: () => 'data',
+          gcTime: 1000,
+        })
+        .catch(noop)
+
+      // No observers left: on the client this is where the gc timer appears.
+      expect(vi.getTimerCount()).toBe(0)
+
+      await vi.advanceTimersByTimeAsync(1000)
+      expect(queryCache.find({ queryKey: key })).toBeDefined()
+    } finally {
+      restore()
+    }
+  })
+
   it('should continue retry after focus regain and resolve all promises', async () => {
     const key = queryKey()
 

diff --git a/packages/query-core/src/__tests__/queryObserver.test.tsx b/packages/query-core/src/__tests__/queryObserver.test.tsx
@@ -1589,6 +1589,35 @@ describe('queryObserver', () => {
     expect(result.data).toBe('data')
   })
 
+  it('should fetch a query that was rebuilt without a queryFn via fetchOptimistic options', async () => {
+    const key = queryKey()
+    const cache = queryClient.getQueryCache()
+
+    // The observer is first bound to a query with a queryFn...
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key,
+      queryFn: () => 'old',
+    })
+
+    // ...the query is removed (e.g. removeQueries on logout)...
+    const removed = cache.find({ queryKey: key })!
+    await cache.remove(removed)
+
+    // ...and broadcastQueryClient rebuilds it from { queryKey, queryHash }
+    // only, without a queryFn. The observer is still bound to the removed
+    // query, so the rebuilt query has no observers and no options when the
+    // suspending render calls fetchOptimistic.
+    cache.build(queryClient, { queryKey: key })
+
+    const result = await observer.fetchOptimistic({
+      queryKey: key,
+      queryFn: () => 'data',
+    })
+
+    expect(result.status).toBe('success')
+    expect(result.data).toBe('data')
+  })
+
   it('should resolve fetchOptimistic with cached data while the fetch continues', async () => {
     const key = queryKey()
 

diff --git a/packages/query-core/src/queryObserver.ts b/packages/query-core/src/queryObserver.ts
@@ -447,7 +447,12 @@ export class QueryObserver<
 
     return Promise.race([
       query
-        .fetch()
+        // Pass the options so a query that already existed without a queryFn
+        // (e.g. rebuilt from a broadcast message or hydrated) still fetches
+        // with this observer's queryFn - `build` does not apply options to an
+        // existing query, and `fetch()` would otherwise only fall back to
+        // already-attached observers, of which there are none yet here.
+        .fetch(defaultedOptions)
         .then(() => {
           const result = this.createResult(query, defaultedOptions)
           // Settle the subscriber promise so both branches always settle.

diff --git a/packages/query-core/src/removable.ts b/packages/query-core/src/removable.ts
@@ -22,11 +22,17 @@ export abstract class Removable {
 
   /**
    * Schedules the entry to be removed from its cache after `gcTime`, replacing any timeout scheduled
-   * before. Nothing is scheduled if `gcTime` is `Infinity`.
+   * before. Nothing is scheduled if `gcTime` is `Infinity`, or on the server: a request-scoped
+   * client is discarded with the response, so a pending timer would only keep the render's
+   * async context (and everything it retains) alive until it fires.
    */
   protected scheduleGc(): void {
     this.clearGcTimeout()
 
+    if (isServerEnvironment()) {
+      return
+    }
+
     if (isValidTimeout(this.gcTime)) {
       this.#gcTimeout = timeoutManager.setTimeout(() => {
         this.optionalRemove()