fix(query-core): decouple timers, retry and gc defaults from isServer guard

packages/query-core/src/__tests__/queryObserver.test.tsx

@@ -1536,6 +1536,71 @@ describe('queryObserver', () => {
     expect(observer.getCurrentResult().data).toBe('updated')
   })
 
+  test('should refetchInterval when window is undefined (non-windowed environments)', async () => {
+  const originalWindow = (globalThis as any).window
+  ;(globalThis as any).window = undefined
+
+  try {
+    const key = queryKey()
+    let count = 0
+
+    const fetchData = () => {
+      count++
+      return Promise.resolve('data')
+    }
+
+    const observer = new QueryObserver(queryClient, {
+      queryKey: key,
+      queryFn: fetchData,
+      refetchInterval: 10,
+    })
+
+    const unsubscribe = observer.subscribe(() => undefined)
+
+    // initial fetch
+    expect(count).toBe(1)
+
+    // should refetch even though isServer would be true
+    await vi.advanceTimersByTimeAsync(10)
+    expect(count).toBe(2)
+
+    unsubscribe()
+  } finally {
+    ;(globalThis as any).window = originalWindow
+  }
+  })
+
+  test('should schedule staleTimeout when window is undefined (non-windowed environments)', async () => {
+    const originalWindow = (globalThis as any).window
+    // simulate windowless client runtime (vscode/chrome extension contexts)
+    ;(globalThis as any).window = undefined
+
+    try {
+      const key = queryKey()
+      const observer = new QueryObserver(queryClient, {
+        queryKey: key,
+        queryFn: () => 'data',
+        staleTime: 10,
+      })
+
+      const results: Array<QueryObserverResult> = []
+      const unsubscribe = observer.subscribe((r) => results.push(r))
+
+      await vi.advanceTimersByTimeAsync(0)
+      expect(results.at(-1)?.status).toBe('success')
+      expect(results.at(-1)?.isStale).toBe(false)
+
+      // after staleTime (+1ms padding) the staleTimeout should fire
+      // and updateResult should flip isStale
+      await vi.advanceTimersByTimeAsync(11)
+      expect(observer.getCurrentResult().isStale).toBe(true)
+
+      unsubscribe()
+    } finally {
+      ;(globalThis as any).window = originalWindow
+    }
+  })
+
   describe('StrictMode behavior', () => {
     it('should deduplicate calls to queryFn', async () => {
       const key = queryKey()

packages/query-core/src/__tests__/removable.test.tsx

@@ -0,0 +1,32 @@
+import { describe, expect, test } from 'vitest'
+import { Removable } from '../removable'
+
+class TestRemovable extends Removable {
+  removed = 0
+
+  optionalRemove() {
+    this.removed++
+  }
+
+  // expose protected method for testing
+  public _updateGcTime(v: number | undefined) {
+    this.updateGcTime(v)
+  }
+}
+
+describe('removable (windowless env)', () => {
+  test('defaults gcTime to 5 minutes when window is undefined', () => {
+    const originalWindow = (globalThis as any).window
+    // simulate windowless client runtime (vscode/chrome extension contexts)
+    ;(globalThis as any).window = undefined
+
+    try {
+      const r = new TestRemovable()
+      r._updateGcTime(undefined)
+
+      expect(r.gcTime).toBe(5 * 60 * 1000)
+    } finally {
+      ;(globalThis as any).window = originalWindow
+    }
+  })
+})

packages/query-core/src/__tests__/retryer.test.tsx

@@ -0,0 +1,51 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
+import { createRetryer } from '../retryer'
+import { onlineManager } from '../onlineManager'
+
+describe('retryer (windowless env)', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+    vi.spyOn(onlineManager, 'isOnline').mockReturnValue(true)
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+    vi.restoreAllMocks()
+  })
+
+  test('defaults retry to 3 when window is undefined', async () => {
+    const originalWindow = (globalThis as any).window
+    // simulate windowless client runtime (vscode/chrome extension contexts)
+    ;(globalThis as any).window = undefined
+
+    try {
+      let attempts = 0
+
+      const retryer = createRetryer({
+        fn: () => {
+          attempts++
+          if (attempts <= 3) throw new Error('nope')
+          return 'ok'
+        },
+        networkMode: 'online',
+        canRun: () => true,
+      })
+
+      retryer.start()
+
+      // defaultRetryDelay: min(1000 * 2^failureCount, 30000)
+      // retry 1: delay = 1000 * 2^1 = 2000
+      await vi.advanceTimersByTimeAsync(2000)
+      // retry 2: delay = 1000 * 2^2 = 4000
+      await vi.advanceTimersByTimeAsync(4000)
+      // retry 3: delay = 1000 * 2^3 = 8000
+      await vi.advanceTimersByTimeAsync(8000)
+
+      await vi.advanceTimersByTimeAsync(0) // flush microtasks
+
+      expect(attempts).toBe(4) // 1 initial + 3 retries
+    } finally {
+      ;(globalThis as any).window = originalWindow
+    }
+  })
+})

packages/query-core/src/queryObserver.ts

@@ -4,7 +4,6 @@ import { fetchState } from './query'
 import { Subscribable } from './subscribable'
 import { pendingThenable } from './thenable'
 import {
-  isServer,
   isValidTimeout,
   noop,
   replaceData,
@@ -358,7 +357,7 @@ export class QueryObserver<
       this.#currentQuery,
     )
 
-    if (isServer || this.#currentResult.isStale || !isValidTimeout(staleTime)) {
+    if (this.#currentResult.isStale || !isValidTimeout(staleTime)) {
       return
     }
 
@@ -389,7 +388,6 @@ export class QueryObserver<
     this.#currentRefetchInterval = nextInterval
 
     if (
-      isServer ||
       resolveEnabled(this.options.enabled, this.#currentQuery) === false ||
       !isValidTimeout(this.#currentRefetchInterval) ||
       this.#currentRefetchInterval === 0

packages/query-core/src/removable.ts

@@ -1,5 +1,5 @@
 import { timeoutManager } from './timeoutManager'
-import { isServer, isValidTimeout } from './utils'
+import { isValidTimeout } from './utils'
 import type { ManagedTimerId } from './timeoutManager'
 
 export abstract class Removable {
@@ -21,11 +21,8 @@ export abstract class Removable {
   }
 
   protected updateGcTime(newGcTime: number | undefined): void {
-    // Default to 5 minutes (Infinity for server-side) if no gcTime is set
-    this.gcTime = Math.max(
-      this.gcTime || 0,
-      newGcTime ?? (isServer ? Infinity : 5 * 60 * 1000),
-    )
+    // Default to 5 minutes if no gcTime is set
+    this.gcTime = Math.max(this.gcTime || 0, newGcTime ?? 5 * 60 * 1000)
   }
 
   protected clearGcTimeout() {

packages/query-core/src/retryer.ts

@@ -1,7 +1,7 @@
 import { focusManager } from './focusManager'
 import { onlineManager } from './onlineManager'
 import { pendingThenable } from './thenable'
-import { isServer, sleep } from './utils'
+import { sleep } from './utils'
 import type { Thenable } from './thenable'
 import type { CancelOptions, DefaultError, NetworkMode } from './types'
 
@@ -166,7 +166,7 @@ export function createRetryer<TData = unknown, TError = DefaultError>(
         }
 
         // Do we need to retry the request?
-        const retry = config.retry ?? (isServer ? 0 : 3)
+        const retry = config.retry ?? 3
         const retryDelay = config.retryDelay ?? defaultRetryDelay
         const delay =
           typeof retryDelay === 'function'