@tanstack/solid-query 6.0.0-alpha.2 → 6.0.0-beta.4

package/build/dev.cjs

@@ -93,10 +93,10 @@ var hydratableObserverResult = (query, result) => {
   return obj;
 };
 function useBaseQuery(options, Observer, queryClient) {
-  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const [client] = solidJs.createSignal(() => exports.useQueryClient(queryClient?.()));
   const isRestoring = exports.useIsRestoring();
   let unsubscribeQueued = false;
-  const defaultedOptions = solidJs.createMemo(() => {
+  const [defaultedOptions] = solidJs.createSignal(() => {
     const defaultOptions = client().defaultQueryOptions(options());
     defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
     defaultOptions.structuralSharing = false;
@@ -108,11 +108,11 @@ function useBaseQuery(options, Observer, queryClient) {
     return defaultOptions;
   });
   const observer = solidJs.untrack(() => new Observer(client(), defaultedOptions()));
-  const trackedDefaultedOptions = solidJs.createMemo(() => defaultedOptions());
+  const [trackedDefaultedOptions] = solidJs.createSignal(() => defaultedOptions());
   solidJs.createRenderEffect(
     () => trackedDefaultedOptions(),
     (opts) => {
-      observer.setOptions(opts);
+      solidJs.runWithOwner(null, () => observer.setOptions(opts));
     }
   );
   let observerResult = solidJs.untrack(
@@ -146,8 +146,8 @@ function useBaseQuery(options, Observer, queryClient) {
     return observer.subscribe((result) => {
       const previousResult = observerResult;
       observerResult = result;
-      setStateWithReconciliation(result);
-      queueMicrotask(() => {
+      solidJs.runWithOwner(null, () => {
+        setStateWithReconciliation(result);
         if (unsubscribe && !disposed && (previousResult.isLoading !== result.isLoading || previousResult.isError !== result.isError)) {
           try {
             solidJs.refresh(queryResource);
@@ -173,41 +173,58 @@ function useBaseQuery(options, Observer, queryClient) {
   let unsubscribe = null;
   let disposed = false;
   let resolver = null;
-  const queryResource = solidJs.createMemo(
-    () => {
-      const opts = trackedDefaultedOptions();
-      const restoring = isRestoring();
-      return new Promise((resolve, reject) => {
-        resolver = resolve;
-        if (isServer) {
-          unsubscribe = createServerSubscriber((data) => {
-            resolve(data);
-          }, reject);
-        } else if (!unsubscribe && !restoring) {
-          unsubscribe = createClientSubscriber();
-        }
-        const currentResult = observer.getOptimisticResult(opts);
-        observerResult = currentResult;
+  const [queryResource] = solidJs.createSignal(() => {
+    const opts = trackedDefaultedOptions();
+    const restoring = isRestoring();
+    if (isServer) {
+      const cached = observer.getOptimisticResult(opts);
+      if (!cached.isLoading) {
+        observerResult = cached;
+        solidJs.runWithOwner(null, () => {
+          setStateWithReconciliation(cached);
+        });
+        return hydratableObserverResult(
+          observer.getCurrentQuery(),
+          cached
+        );
+      }
+    }
+    return new Promise((resolve, reject) => {
+      resolver = resolve;
+      if (isServer) {
+        unsubscribe = createServerSubscriber((data) => {
+          resolve(data);
+        }, reject);
+      } else if (!unsubscribe && !restoring) {
+        unsubscribe = createClientSubscriber();
+      }
+      const currentResult = observer.getOptimisticResult(opts);
+      observerResult = currentResult;
+      solidJs.runWithOwner(null, () => {
         if (currentResult.isError && !currentResult.isFetching && !restoring && queryCore.shouldThrowError(opts.throwOnError, [
           currentResult.error,
           observer.getCurrentQuery()
         ])) {
           setStateWithReconciliation(currentResult);
-          return reject(currentResult.error);
+          reject(currentResult.error);
+          return;
         }
-        if (!currentResult.isLoading) {
-          resolver = null;
-          setStateWithReconciliation(currentResult);
-          return resolve(
-            hydratableObserverResult(observer.getCurrentQuery(), currentResult)
-          );
-        }
-        queueMicrotask(() => setStateWithReconciliation(currentResult));
+        setStateWithReconciliation(currentResult);
       });
-    },
-    observerResult,
-    { ssrSource: "client" }
-  );
+      if (currentResult.isError && !currentResult.isFetching && !restoring && queryCore.shouldThrowError(opts.throwOnError, [
+        currentResult.error,
+        observer.getCurrentQuery()
+      ])) {
+        return;
+      }
+      if (!currentResult.isLoading) {
+        resolver = null;
+        return resolve(
+          hydratableObserverResult(observer.getCurrentQuery(), currentResult)
+        );
+      }
+    });
+  });
   solidJs.onCleanup(() => {
     disposed = true;
     if (isServer && solidJs.isPending(queryResource)) {
@@ -236,6 +253,9 @@ function useBaseQuery(options, Observer, queryClient) {
       if (typeof prop === "symbol") {
         return Reflect.get(target, prop, receiver);
       }
+      if (isServer) {
+        queryResource();
+      }
       if (errorPassthroughProps.has(prop)) {
         return Reflect.get(target, prop, receiver);
       }
@@ -345,14 +365,16 @@ function useQueries(queriesOptions, queryClient) {
     () => {
       if (!isRestoring()) {
         unsubscribe = observer.subscribe((result) => {
-          setState(
-            solidJs.reconcile(
-              [...result],
-              // Use a key function that returns undefined so reconcile
-              // uses positional matching and recursively updates nested properties
-              () => void 0
-            )
-          );
+          solidJs.runWithOwner(null, () => {
+            setState(
+              solidJs.reconcile(
+                [...result],
+                // Use a key function that returns undefined so reconcile
+                // uses positional matching and recursively updates nested properties
+                () => void 0
+              )
+            );
+          });
         });
       }
     },
@@ -364,12 +386,14 @@ function useQueries(queriesOptions, queryClient) {
   });
   solidJs.createMemo(() => {
     const queries = defaultedQueries();
-    observer.setQueries(
-      queries,
-      queriesOptions().combine ? {
-        combine: queriesOptions().combine
-      } : void 0
-    );
+    solidJs.runWithOwner(null, () => {
+      observer.setQueries(
+        queries,
+        queriesOptions().combine ? {
+          combine: queriesOptions().combine
+        } : void 0
+      );
+    });
     return queries;
   });
   return state;
@@ -389,7 +413,7 @@ function useIsFetching(filters, queryClient) {
   const queryCache = solidJs.createMemo(() => client().getQueryCache());
   const [fetches, setFetches] = solidJs.createSignal(
     solidJs.untrack(() => client().isFetching(filters?.())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = solidJs.untrack(
     () => queryCache().subscribe(() => {
@@ -414,7 +438,7 @@ function useIsMutating(filters, queryClient) {
   const mutationCache = solidJs.createMemo(() => client().getMutationCache());
   const [mutations, setMutations] = solidJs.createSignal(
     solidJs.untrack(() => client().isMutating(filters?.())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = solidJs.untrack(
     () => mutationCache().subscribe((_result) => {
@@ -434,7 +458,7 @@ function useMutationState(options = () => ({}), queryClient) {
   const mutationCache = solidJs.createMemo(() => client().getMutationCache());
   const [result, setResult] = solidJs.createSignal(
     solidJs.untrack(() => getResult(mutationCache(), options())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = solidJs.untrack(
     () => mutationCache().subscribe(() => {

package/build/dev.js

@@ -1,6 +1,6 @@
 import { MutationObserver, shouldThrowError, QueriesObserver, QueryClient as QueryClient$1, replaceEqualDeep, noop, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
-import { createContext, useContext, onCleanup, createMemo, untrack, createRenderEffect, createStore, merge, createEffect, reconcile, createSignal, isPending, refresh, snapshot } from 'solid-js';
+import { createContext, useContext, onCleanup, createMemo, untrack, createRenderEffect, createStore, merge, createEffect, runWithOwner, reconcile, createSignal, isPending, refresh, snapshot } from 'solid-js';
 import { createComponent } from '@solidjs/web';
 
 // src/useQuery.ts
@@ -92,10 +92,10 @@ var hydratableObserverResult = (query, result) => {
   return obj;
 };
 function useBaseQuery(options, Observer, queryClient) {
-  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const [client] = createSignal(() => useQueryClient(queryClient?.()));
   const isRestoring = useIsRestoring();
   let unsubscribeQueued = false;
-  const defaultedOptions = createMemo(() => {
+  const [defaultedOptions] = createSignal(() => {
     const defaultOptions = client().defaultQueryOptions(options());
     defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
     defaultOptions.structuralSharing = false;
@@ -107,11 +107,11 @@ function useBaseQuery(options, Observer, queryClient) {
     return defaultOptions;
   });
   const observer = untrack(() => new Observer(client(), defaultedOptions()));
-  const trackedDefaultedOptions = createMemo(() => defaultedOptions());
+  const [trackedDefaultedOptions] = createSignal(() => defaultedOptions());
   createRenderEffect(
     () => trackedDefaultedOptions(),
     (opts) => {
-      observer.setOptions(opts);
+      runWithOwner(null, () => observer.setOptions(opts));
     }
   );
   let observerResult = untrack(
@@ -145,8 +145,8 @@ function useBaseQuery(options, Observer, queryClient) {
     return observer.subscribe((result) => {
       const previousResult = observerResult;
       observerResult = result;
-      setStateWithReconciliation(result);
-      queueMicrotask(() => {
+      runWithOwner(null, () => {
+        setStateWithReconciliation(result);
         if (unsubscribe && !disposed && (previousResult.isLoading !== result.isLoading || previousResult.isError !== result.isError)) {
           try {
             refresh(queryResource);
@@ -172,41 +172,58 @@ function useBaseQuery(options, Observer, queryClient) {
   let unsubscribe = null;
   let disposed = false;
   let resolver = null;
-  const queryResource = createMemo(
-    () => {
-      const opts = trackedDefaultedOptions();
-      const restoring = isRestoring();
-      return new Promise((resolve, reject) => {
-        resolver = resolve;
-        if (isServer) {
-          unsubscribe = createServerSubscriber((data) => {
-            resolve(data);
-          }, reject);
-        } else if (!unsubscribe && !restoring) {
-          unsubscribe = createClientSubscriber();
-        }
-        const currentResult = observer.getOptimisticResult(opts);
-        observerResult = currentResult;
+  const [queryResource] = createSignal(() => {
+    const opts = trackedDefaultedOptions();
+    const restoring = isRestoring();
+    if (isServer) {
+      const cached = observer.getOptimisticResult(opts);
+      if (!cached.isLoading) {
+        observerResult = cached;
+        runWithOwner(null, () => {
+          setStateWithReconciliation(cached);
+        });
+        return hydratableObserverResult(
+          observer.getCurrentQuery(),
+          cached
+        );
+      }
+    }
+    return new Promise((resolve, reject) => {
+      resolver = resolve;
+      if (isServer) {
+        unsubscribe = createServerSubscriber((data) => {
+          resolve(data);
+        }, reject);
+      } else if (!unsubscribe && !restoring) {
+        unsubscribe = createClientSubscriber();
+      }
+      const currentResult = observer.getOptimisticResult(opts);
+      observerResult = currentResult;
+      runWithOwner(null, () => {
         if (currentResult.isError && !currentResult.isFetching && !restoring && shouldThrowError(opts.throwOnError, [
           currentResult.error,
           observer.getCurrentQuery()
         ])) {
           setStateWithReconciliation(currentResult);
-          return reject(currentResult.error);
+          reject(currentResult.error);
+          return;
         }
-        if (!currentResult.isLoading) {
-          resolver = null;
-          setStateWithReconciliation(currentResult);
-          return resolve(
-            hydratableObserverResult(observer.getCurrentQuery(), currentResult)
-          );
-        }
-        queueMicrotask(() => setStateWithReconciliation(currentResult));
+        setStateWithReconciliation(currentResult);
       });
-    },
-    observerResult,
-    { ssrSource: "client" }
-  );
+      if (currentResult.isError && !currentResult.isFetching && !restoring && shouldThrowError(opts.throwOnError, [
+        currentResult.error,
+        observer.getCurrentQuery()
+      ])) {
+        return;
+      }
+      if (!currentResult.isLoading) {
+        resolver = null;
+        return resolve(
+          hydratableObserverResult(observer.getCurrentQuery(), currentResult)
+        );
+      }
+    });
+  });
   onCleanup(() => {
     disposed = true;
     if (isServer && isPending(queryResource)) {
@@ -235,6 +252,9 @@ function useBaseQuery(options, Observer, queryClient) {
       if (typeof prop === "symbol") {
         return Reflect.get(target, prop, receiver);
       }
+      if (isServer) {
+        queryResource();
+      }
       if (errorPassthroughProps.has(prop)) {
         return Reflect.get(target, prop, receiver);
       }
@@ -344,14 +364,16 @@ function useQueries(queriesOptions, queryClient) {
     () => {
       if (!isRestoring()) {
         unsubscribe = observer.subscribe((result) => {
-          setState(
-            reconcile(
-              [...result],
-              // Use a key function that returns undefined so reconcile
-              // uses positional matching and recursively updates nested properties
-              () => void 0
-            )
-          );
+          runWithOwner(null, () => {
+            setState(
+              reconcile(
+                [...result],
+                // Use a key function that returns undefined so reconcile
+                // uses positional matching and recursively updates nested properties
+                () => void 0
+              )
+            );
+          });
         });
       }
     },
@@ -363,12 +385,14 @@ function useQueries(queriesOptions, queryClient) {
   });
   createMemo(() => {
     const queries = defaultedQueries();
-    observer.setQueries(
-      queries,
-      queriesOptions().combine ? {
-        combine: queriesOptions().combine
-      } : void 0
-    );
+    runWithOwner(null, () => {
+      observer.setQueries(
+        queries,
+        queriesOptions().combine ? {
+          combine: queriesOptions().combine
+        } : void 0
+      );
+    });
     return queries;
   });
   return state;
@@ -388,7 +412,7 @@ function useIsFetching(filters, queryClient) {
   const queryCache = createMemo(() => client().getQueryCache());
   const [fetches, setFetches] = createSignal(
     untrack(() => client().isFetching(filters?.())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = untrack(
     () => queryCache().subscribe(() => {
@@ -413,7 +437,7 @@ function useIsMutating(filters, queryClient) {
   const mutationCache = createMemo(() => client().getMutationCache());
   const [mutations, setMutations] = createSignal(
     untrack(() => client().isMutating(filters?.())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = untrack(
     () => mutationCache().subscribe((_result) => {
@@ -433,7 +457,7 @@ function useMutationState(options = () => ({}), queryClient) {
   const mutationCache = createMemo(() => client().getMutationCache());
   const [result, setResult] = createSignal(
     untrack(() => getResult(mutationCache(), options())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = untrack(
     () => mutationCache().subscribe(() => {

package/build/index.cjs

@@ -84,10 +84,10 @@ var hydratableObserverResult = (query, result) => {
   return obj;
 };
 function useBaseQuery(options, Observer, queryClient) {
-  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const [client] = solidJs.createSignal(() => exports.useQueryClient(queryClient?.()));
   const isRestoring = exports.useIsRestoring();
   let unsubscribeQueued = false;
-  const defaultedOptions = solidJs.createMemo(() => {
+  const [defaultedOptions] = solidJs.createSignal(() => {
     const defaultOptions = client().defaultQueryOptions(options());
     defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
     defaultOptions.structuralSharing = false;
@@ -99,11 +99,11 @@ function useBaseQuery(options, Observer, queryClient) {
     return defaultOptions;
   });
   const observer = solidJs.untrack(() => new Observer(client(), defaultedOptions()));
-  const trackedDefaultedOptions = solidJs.createMemo(() => defaultedOptions());
+  const [trackedDefaultedOptions] = solidJs.createSignal(() => defaultedOptions());
   solidJs.createRenderEffect(
     () => trackedDefaultedOptions(),
     (opts) => {
-      observer.setOptions(opts);
+      solidJs.runWithOwner(null, () => observer.setOptions(opts));
     }
   );
   let observerResult = solidJs.untrack(
@@ -137,8 +137,8 @@ function useBaseQuery(options, Observer, queryClient) {
     return observer.subscribe((result) => {
       const previousResult = observerResult;
       observerResult = result;
-      setStateWithReconciliation(result);
-      queueMicrotask(() => {
+      solidJs.runWithOwner(null, () => {
+        setStateWithReconciliation(result);
         if (unsubscribe && !disposed && (previousResult.isLoading !== result.isLoading || previousResult.isError !== result.isError)) {
           try {
             solidJs.refresh(queryResource);
@@ -164,41 +164,58 @@ function useBaseQuery(options, Observer, queryClient) {
   let unsubscribe = null;
   let disposed = false;
   let resolver = null;
-  const queryResource = solidJs.createMemo(
-    () => {
-      const opts = trackedDefaultedOptions();
-      const restoring = isRestoring();
-      return new Promise((resolve, reject) => {
-        resolver = resolve;
-        if (isServer) {
-          unsubscribe = createServerSubscriber((data) => {
-            resolve(data);
-          }, reject);
-        } else if (!unsubscribe && !restoring) {
-          unsubscribe = createClientSubscriber();
-        }
-        const currentResult = observer.getOptimisticResult(opts);
-        observerResult = currentResult;
+  const [queryResource] = solidJs.createSignal(() => {
+    const opts = trackedDefaultedOptions();
+    const restoring = isRestoring();
+    if (isServer) {
+      const cached = observer.getOptimisticResult(opts);
+      if (!cached.isLoading) {
+        observerResult = cached;
+        solidJs.runWithOwner(null, () => {
+          setStateWithReconciliation(cached);
+        });
+        return hydratableObserverResult(
+          observer.getCurrentQuery(),
+          cached
+        );
+      }
+    }
+    return new Promise((resolve, reject) => {
+      resolver = resolve;
+      if (isServer) {
+        unsubscribe = createServerSubscriber((data) => {
+          resolve(data);
+        }, reject);
+      } else if (!unsubscribe && !restoring) {
+        unsubscribe = createClientSubscriber();
+      }
+      const currentResult = observer.getOptimisticResult(opts);
+      observerResult = currentResult;
+      solidJs.runWithOwner(null, () => {
         if (currentResult.isError && !currentResult.isFetching && !restoring && queryCore.shouldThrowError(opts.throwOnError, [
           currentResult.error,
           observer.getCurrentQuery()
         ])) {
           setStateWithReconciliation(currentResult);
-          return reject(currentResult.error);
+          reject(currentResult.error);
+          return;
         }
-        if (!currentResult.isLoading) {
-          resolver = null;
-          setStateWithReconciliation(currentResult);
-          return resolve(
-            hydratableObserverResult(observer.getCurrentQuery(), currentResult)
-          );
-        }
-        queueMicrotask(() => setStateWithReconciliation(currentResult));
+        setStateWithReconciliation(currentResult);
       });
-    },
-    observerResult,
-    { ssrSource: "client" }
-  );
+      if (currentResult.isError && !currentResult.isFetching && !restoring && queryCore.shouldThrowError(opts.throwOnError, [
+        currentResult.error,
+        observer.getCurrentQuery()
+      ])) {
+        return;
+      }
+      if (!currentResult.isLoading) {
+        resolver = null;
+        return resolve(
+          hydratableObserverResult(observer.getCurrentQuery(), currentResult)
+        );
+      }
+    });
+  });
   solidJs.onCleanup(() => {
     disposed = true;
     if (isServer && solidJs.isPending(queryResource)) {
@@ -227,6 +244,9 @@ function useBaseQuery(options, Observer, queryClient) {
       if (typeof prop === "symbol") {
         return Reflect.get(target, prop, receiver);
       }
+      if (isServer) {
+        queryResource();
+      }
       if (errorPassthroughProps.has(prop)) {
         return Reflect.get(target, prop, receiver);
       }
@@ -336,14 +356,16 @@ function useQueries(queriesOptions, queryClient) {
     () => {
       if (!isRestoring()) {
         unsubscribe = observer.subscribe((result) => {
-          setState(
-            solidJs.reconcile(
-              [...result],
-              // Use a key function that returns undefined so reconcile
-              // uses positional matching and recursively updates nested properties
-              () => void 0
-            )
-          );
+          solidJs.runWithOwner(null, () => {
+            setState(
+              solidJs.reconcile(
+                [...result],
+                // Use a key function that returns undefined so reconcile
+                // uses positional matching and recursively updates nested properties
+                () => void 0
+              )
+            );
+          });
         });
       }
     },
@@ -355,12 +377,14 @@ function useQueries(queriesOptions, queryClient) {
   });
   solidJs.createMemo(() => {
     const queries = defaultedQueries();
-    observer.setQueries(
-      queries,
-      queriesOptions().combine ? {
-        combine: queriesOptions().combine
-      } : void 0
-    );
+    solidJs.runWithOwner(null, () => {
+      observer.setQueries(
+        queries,
+        queriesOptions().combine ? {
+          combine: queriesOptions().combine
+        } : void 0
+      );
+    });
     return queries;
   });
   return state;
@@ -380,7 +404,7 @@ function useIsFetching(filters, queryClient) {
   const queryCache = solidJs.createMemo(() => client().getQueryCache());
   const [fetches, setFetches] = solidJs.createSignal(
     solidJs.untrack(() => client().isFetching(filters?.())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = solidJs.untrack(
     () => queryCache().subscribe(() => {
@@ -405,7 +429,7 @@ function useIsMutating(filters, queryClient) {
   const mutationCache = solidJs.createMemo(() => client().getMutationCache());
   const [mutations, setMutations] = solidJs.createSignal(
     solidJs.untrack(() => client().isMutating(filters?.())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = solidJs.untrack(
     () => mutationCache().subscribe((_result) => {
@@ -425,7 +449,7 @@ function useMutationState(options = () => ({}), queryClient) {
   const mutationCache = solidJs.createMemo(() => client().getMutationCache());
   const [result, setResult] = solidJs.createSignal(
     solidJs.untrack(() => getResult(mutationCache(), options())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = solidJs.untrack(
     () => mutationCache().subscribe(() => {

package/build/index.js

@@ -1,6 +1,6 @@
 import { MutationObserver, shouldThrowError, QueriesObserver, QueryClient as QueryClient$1, replaceEqualDeep, noop, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
-import { createContext, useContext, onCleanup, createMemo, untrack, createRenderEffect, createStore, merge, createEffect, reconcile, createSignal, isPending, refresh, snapshot } from 'solid-js';
+import { createContext, useContext, onCleanup, createMemo, untrack, createRenderEffect, createStore, merge, createEffect, runWithOwner, reconcile, createSignal, isPending, refresh, snapshot } from 'solid-js';
 import { createComponent } from '@solidjs/web';
 
 // src/useQuery.ts
@@ -83,10 +83,10 @@ var hydratableObserverResult = (query, result) => {
   return obj;
 };
 function useBaseQuery(options, Observer, queryClient) {
-  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const [client] = createSignal(() => useQueryClient(queryClient?.()));
   const isRestoring = useIsRestoring();
   let unsubscribeQueued = false;
-  const defaultedOptions = createMemo(() => {
+  const [defaultedOptions] = createSignal(() => {
     const defaultOptions = client().defaultQueryOptions(options());
     defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
     defaultOptions.structuralSharing = false;
@@ -98,11 +98,11 @@ function useBaseQuery(options, Observer, queryClient) {
     return defaultOptions;
   });
   const observer = untrack(() => new Observer(client(), defaultedOptions()));
-  const trackedDefaultedOptions = createMemo(() => defaultedOptions());
+  const [trackedDefaultedOptions] = createSignal(() => defaultedOptions());
   createRenderEffect(
     () => trackedDefaultedOptions(),
     (opts) => {
-      observer.setOptions(opts);
+      runWithOwner(null, () => observer.setOptions(opts));
     }
   );
   let observerResult = untrack(
@@ -136,8 +136,8 @@ function useBaseQuery(options, Observer, queryClient) {
     return observer.subscribe((result) => {
       const previousResult = observerResult;
       observerResult = result;
-      setStateWithReconciliation(result);
-      queueMicrotask(() => {
+      runWithOwner(null, () => {
+        setStateWithReconciliation(result);
         if (unsubscribe && !disposed && (previousResult.isLoading !== result.isLoading || previousResult.isError !== result.isError)) {
           try {
             refresh(queryResource);
@@ -163,41 +163,58 @@ function useBaseQuery(options, Observer, queryClient) {
   let unsubscribe = null;
   let disposed = false;
   let resolver = null;
-  const queryResource = createMemo(
-    () => {
-      const opts = trackedDefaultedOptions();
-      const restoring = isRestoring();
-      return new Promise((resolve, reject) => {
-        resolver = resolve;
-        if (isServer) {
-          unsubscribe = createServerSubscriber((data) => {
-            resolve(data);
-          }, reject);
-        } else if (!unsubscribe && !restoring) {
-          unsubscribe = createClientSubscriber();
-        }
-        const currentResult = observer.getOptimisticResult(opts);
-        observerResult = currentResult;
+  const [queryResource] = createSignal(() => {
+    const opts = trackedDefaultedOptions();
+    const restoring = isRestoring();
+    if (isServer) {
+      const cached = observer.getOptimisticResult(opts);
+      if (!cached.isLoading) {
+        observerResult = cached;
+        runWithOwner(null, () => {
+          setStateWithReconciliation(cached);
+        });
+        return hydratableObserverResult(
+          observer.getCurrentQuery(),
+          cached
+        );
+      }
+    }
+    return new Promise((resolve, reject) => {
+      resolver = resolve;
+      if (isServer) {
+        unsubscribe = createServerSubscriber((data) => {
+          resolve(data);
+        }, reject);
+      } else if (!unsubscribe && !restoring) {
+        unsubscribe = createClientSubscriber();
+      }
+      const currentResult = observer.getOptimisticResult(opts);
+      observerResult = currentResult;
+      runWithOwner(null, () => {
         if (currentResult.isError && !currentResult.isFetching && !restoring && shouldThrowError(opts.throwOnError, [
           currentResult.error,
           observer.getCurrentQuery()
         ])) {
           setStateWithReconciliation(currentResult);
-          return reject(currentResult.error);
+          reject(currentResult.error);
+          return;
         }
-        if (!currentResult.isLoading) {
-          resolver = null;
-          setStateWithReconciliation(currentResult);
-          return resolve(
-            hydratableObserverResult(observer.getCurrentQuery(), currentResult)
-          );
-        }
-        queueMicrotask(() => setStateWithReconciliation(currentResult));
+        setStateWithReconciliation(currentResult);
       });
-    },
-    observerResult,
-    { ssrSource: "client" }
-  );
+      if (currentResult.isError && !currentResult.isFetching && !restoring && shouldThrowError(opts.throwOnError, [
+        currentResult.error,
+        observer.getCurrentQuery()
+      ])) {
+        return;
+      }
+      if (!currentResult.isLoading) {
+        resolver = null;
+        return resolve(
+          hydratableObserverResult(observer.getCurrentQuery(), currentResult)
+        );
+      }
+    });
+  });
   onCleanup(() => {
     disposed = true;
     if (isServer && isPending(queryResource)) {
@@ -226,6 +243,9 @@ function useBaseQuery(options, Observer, queryClient) {
       if (typeof prop === "symbol") {
         return Reflect.get(target, prop, receiver);
       }
+      if (isServer) {
+        queryResource();
+      }
       if (errorPassthroughProps.has(prop)) {
         return Reflect.get(target, prop, receiver);
       }
@@ -335,14 +355,16 @@ function useQueries(queriesOptions, queryClient) {
     () => {
       if (!isRestoring()) {
         unsubscribe = observer.subscribe((result) => {
-          setState(
-            reconcile(
-              [...result],
-              // Use a key function that returns undefined so reconcile
-              // uses positional matching and recursively updates nested properties
-              () => void 0
-            )
-          );
+          runWithOwner(null, () => {
+            setState(
+              reconcile(
+                [...result],
+                // Use a key function that returns undefined so reconcile
+                // uses positional matching and recursively updates nested properties
+                () => void 0
+              )
+            );
+          });
         });
       }
     },
@@ -354,12 +376,14 @@ function useQueries(queriesOptions, queryClient) {
   });
   createMemo(() => {
     const queries = defaultedQueries();
-    observer.setQueries(
-      queries,
-      queriesOptions().combine ? {
-        combine: queriesOptions().combine
-      } : void 0
-    );
+    runWithOwner(null, () => {
+      observer.setQueries(
+        queries,
+        queriesOptions().combine ? {
+          combine: queriesOptions().combine
+        } : void 0
+      );
+    });
     return queries;
   });
   return state;
@@ -379,7 +403,7 @@ function useIsFetching(filters, queryClient) {
   const queryCache = createMemo(() => client().getQueryCache());
   const [fetches, setFetches] = createSignal(
     untrack(() => client().isFetching(filters?.())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = untrack(
     () => queryCache().subscribe(() => {
@@ -404,7 +428,7 @@ function useIsMutating(filters, queryClient) {
   const mutationCache = createMemo(() => client().getMutationCache());
   const [mutations, setMutations] = createSignal(
     untrack(() => client().isMutating(filters?.())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = untrack(
     () => mutationCache().subscribe((_result) => {
@@ -424,7 +448,7 @@ function useMutationState(options = () => ({}), queryClient) {
   const mutationCache = createMemo(() => client().getMutationCache());
   const [result, setResult] = createSignal(
     untrack(() => getResult(mutationCache(), options())),
-    { pureWrite: true }
+    { ownedWrite: true }
   );
   const unsubscribe = untrack(
     () => mutationCache().subscribe(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-query",
-  "version": "6.0.0-alpha.2",
+  "version": "6.0.0-beta.4",
   "description": "Primitives for managing, caching and syncing asynchronous and remote data in Solid",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -52,12 +52,12 @@
     "@babel/core": "^7.28.0",
     "@babel/preset-typescript": "^7.18.6",
     "@solidjs/testing-library": "^0.8.10",
-    "@solidjs/web": "2.0.0-beta.4",
-    "babel-preset-solid": "2.0.0-beta.4",
+    "@solidjs/web": "2.0.0-beta.7",
+    "babel-preset-solid": "2.0.0-beta.7",
     "npm-run-all2": "^5.0.0",
-    "solid-js": "2.0.0-beta.4",
+    "solid-js": "2.0.0-beta.7",
     "tsup-preset-solid": "^2.2.0",
-    "vite-plugin-solid": "3.0.0-next.2",
+    "vite-plugin-solid": "3.0.0-next.5",
     "@tanstack/query-test-utils": "0.0.0"
   },
   "peerDependencies": {

package/src/useBaseQuery.ts

@@ -3,13 +3,14 @@
 // why that happens.
 import { notifyManager, shouldThrowError } from '@tanstack/query-core'
 import {
-  createMemo,
   createRenderEffect,
+  createSignal,
   createStore,
   isPending,
   onCleanup,
   reconcile,
   refresh,
+  runWithOwner,
   snapshot,
   untrack,
 } from 'solid-js'
@@ -151,7 +152,12 @@ export function useBaseQuery<
 ) {
   type ResourceData = QueryObserverResult<TData, TError>
 
-  const client = createMemo(() => useQueryClient(queryClient?.()))
+  // Use createSignal(fn) instead of createMemo so these derived memos have
+  // _preventAutoDisposal set. Without it, a createMemo that no one reads
+  // reactively gets auto-disposed in Solid v2, which cascades and disposes
+  // the component's onCleanup, unsubscribing the observer before the fetch
+  // completes.
+  const [client] = createSignal(() => useQueryClient(queryClient?.()))
   const isRestoring = useIsRestoring()
   // There are times when we run a query on the server but the resource is never read
   // This could lead to times when the queryObserver is unsubscribed before the resource has loaded
@@ -159,7 +165,7 @@ export function useBaseQuery<
   // before the resource has loaded
   let unsubscribeQueued = false
 
-  const defaultedOptions = createMemo(() => {
+  const [defaultedOptions] = createSignal(() => {
     const defaultOptions = client().defaultQueryOptions(options())
     defaultOptions._optimisticResults = isRestoring()
       ? 'isRestoring'
@@ -178,7 +184,7 @@ export function useBaseQuery<
   const observer = untrack(() => new Observer(client(), defaultedOptions()))
 
   // Track options reactively so the queryResource memo re-runs on change.
-  const trackedDefaultedOptions = createMemo(() => defaultedOptions())
+  const [trackedDefaultedOptions] = createSignal(() => defaultedOptions())
 
   // Apply options in an effect to avoid store writes inside the memo.
   // setOptions triggers updateResult → notify → subscription → setState,
@@ -186,7 +192,11 @@ export function useBaseQuery<
   createRenderEffect(
     () => trackedDefaultedOptions(),
     (opts) => {
-      observer.setOptions(opts)
+      // observer.setOptions synchronously invokes subscribers which write to
+      // the store. In Solid v2, signal/store writes inside an owned scope
+      // (like this render effect) throw. Escape the owner so subscriber
+      // writes don't trip the guard.
+      runWithOwner(null, () => observer.setOptions(opts))
     },
   )
 
@@ -231,8 +241,8 @@ export function useBaseQuery<
     return observer.subscribe((result) => {
       const previousResult = observerResult
       observerResult = result
-      setStateWithReconciliation(result)
-      queueMicrotask(() => {
+      runWithOwner(null, () => {
+        setStateWithReconciliation(result)
         if (
           unsubscribe &&
           !disposed &&
@@ -243,8 +253,7 @@ export function useBaseQuery<
             refresh(queryResource)
           } catch {
             // NotReadyError is expected when refreshing a memo that returns
-            // a Promise. The Loading boundary handles this during rendering,
-            // but when refresh is called from a microtask there is no boundary.
+            // a Promise. The Loading boundary handles this during rendering.
           }
         }
       })
@@ -280,27 +289,59 @@ export function useBaseQuery<
     but the resource is still in a loading state
   */
   let resolver: ((value: ResourceData) => void) | null = null
-  const queryResource = createMemo<ResourceData>(
-    () => {
-      // Read trackedDefaultedOptions to ensure this memo re-runs when options change
-      const opts = trackedDefaultedOptions()
-      // Read isRestoring unconditionally so the memo re-runs when it changes
-      const restoring = isRestoring()
-
-      return new Promise((resolve, reject) => {
-        resolver = resolve
-        if (isServer) {
-          unsubscribe = createServerSubscriber((data) => {
-            resolve(data as ResourceData)
-          }, reject)
-        } else if (!unsubscribe && !restoring) {
-          unsubscribe = createClientSubscriber()
-        }
-        // Use getOptimisticResult instead of updateResult to keep the memo
-        // free of store writes (updateResult triggers notify → setState).
-        const currentResult = observer.getOptimisticResult(opts)
-        observerResult = currentResult
+  // Use createSignal(fn) instead of createMemo so the derived memo has
+  // _preventAutoDisposal set. Without it, a createMemo that no one reads
+  // reactively gets auto-disposed in Solid v2, which would cascade-dispose
+  // the component's onCleanup and unsubscribe the observer before fetch
+  // completion.
+  const [queryResource] = createSignal<ResourceData>(() => {
+    // Read trackedDefaultedOptions to ensure this memo re-runs when options change
+    const opts = trackedDefaultedOptions()
+    // Read isRestoring unconditionally so the memo re-runs when it changes
+    const restoring = isRestoring()
+
+    if (isServer) {
+      // On retry passes (after the streaming Loading boundary awaits a
+      // pending Promise), the QueryClient cache already has the data, so
+      // `getOptimisticResult` returns a non-loading result synchronously.
+      // Returning the value directly (instead of a fresh Promise that
+      // resolves synchronously) lets Solid's `processResult` set
+      // `comp.value` directly without queueing another async settle. If we
+      // returned a new Promise on every retry, Solid's streaming Loading
+      // boundary `while (ret.p.length)` loop in `createLoadingBoundary`
+      // would never terminate, because each retry adds a new pending
+      // Promise to the boundary's tracked set even when it resolves
+      // synchronously.
+      const cached = observer.getOptimisticResult(opts)
+      if (!cached.isLoading) {
+        observerResult = cached
+        runWithOwner(null, () => {
+          setStateWithReconciliation(cached)
+        })
+        return hydratableObserverResult(
+          observer.getCurrentQuery(),
+          cached,
+        ) as ResourceData
+      }
+    }
 
+    return new Promise<ResourceData>((resolve, reject) => {
+      resolver = resolve
+      if (isServer) {
+        unsubscribe = createServerSubscriber((data) => {
+          resolve(data as ResourceData)
+        }, reject)
+      } else if (!unsubscribe && !restoring) {
+        unsubscribe = createClientSubscriber()
+      }
+      // Use getOptimisticResult instead of updateResult to keep the memo
+      // free of store writes (updateResult triggers notify → setState).
+      const currentResult = observer.getOptimisticResult(opts)
+      observerResult = currentResult
+
+      // Store writes inside a memo's owned scope throw in Solid v2.
+      // Escape the owner so setState calls are allowed.
+      runWithOwner(null, () => {
         if (
           currentResult.isError &&
           !currentResult.isFetching &&
@@ -311,23 +352,31 @@ export function useBaseQuery<
           ])
         ) {
           setStateWithReconciliation(currentResult)
-          return reject(currentResult.error)
-        }
-        if (!currentResult.isLoading) {
-          resolver = null
-          setStateWithReconciliation(currentResult)
-          return resolve(
-            hydratableObserverResult(observer.getCurrentQuery(), currentResult),
-          )
+          reject(currentResult.error)
+          return
         }
-
-        // Defer the loading-state store write so it runs outside the memo.
-        queueMicrotask(() => setStateWithReconciliation(currentResult))
+        setStateWithReconciliation(currentResult)
       })
-    },
-    observerResult,
-    { ssrSource: 'client' },
-  )
+
+      if (
+        currentResult.isError &&
+        !currentResult.isFetching &&
+        !restoring &&
+        shouldThrowError(opts.throwOnError, [
+          currentResult.error,
+          observer.getCurrentQuery(),
+        ])
+      ) {
+        return
+      }
+      if (!currentResult.isLoading) {
+        resolver = null
+        return resolve(
+          hydratableObserverResult(observer.getCurrentQuery(), currentResult),
+        )
+      }
+    })
+  })
 
   onCleanup(() => {
     disposed = true
@@ -364,6 +413,15 @@ export function useBaseQuery<
         return Reflect.get(target, prop, receiver)
       }
 
+      // On the server, force a Suspense dependency on the query resource so
+      // the per-route Loading boundary catches NotReadyError, awaits the
+      // pending Promise, and re-renders with the resolved state. Without
+      // this, JSX reads through the Proxy never subscribe to queryResource
+      // and SSR HTML reflects the initial loading state.
+      if (isServer) {
+        queryResource()
+      }
+
       // Always pass through error-related props without throwing
       if (errorPassthroughProps.has(prop)) {
         return Reflect.get(target, prop, receiver)

package/src/useIsFetching.ts

@@ -13,7 +13,7 @@ export function useIsFetching(
 
   const [fetches, setFetches] = createSignal(
     untrack(() => client().isFetching(filters?.())),
-    { pureWrite: true },
+    { ownedWrite: true },
   )
 
   const unsubscribe = untrack(() =>

package/src/useIsMutating.ts

@@ -13,7 +13,7 @@ export function useIsMutating(
 
   const [mutations, setMutations] = createSignal(
     untrack(() => client().isMutating(filters?.())),
-    { pureWrite: true },
+    { ownedWrite: true },
   )
 
   const unsubscribe = untrack(() =>

package/src/useMutationState.ts

@@ -36,7 +36,7 @@ export function useMutationState<TResult = MutationState>(
 
   const [result, setResult] = createSignal(
     untrack(() => getResult(mutationCache(), options())),
-    { pureWrite: true },
+    { ownedWrite: true },
   )
 
   const unsubscribe = untrack(() =>

package/src/useQueries.ts

@@ -6,6 +6,7 @@ import {
   merge,
   onCleanup,
   reconcile,
+  runWithOwner,
   untrack,
 } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
@@ -244,14 +245,16 @@ export function useQueries<
     () => {
       if (!isRestoring()) {
         unsubscribe = observer.subscribe((result) => {
-          setState(
-            reconcile(
-              [...result] as Array<QueryObserverResult>,
-              // Use a key function that returns undefined so reconcile
-              // uses positional matching and recursively updates nested properties
-              () => undefined,
-            ),
-          )
+          runWithOwner(null, () => {
+            setState(
+              reconcile(
+                [...result] as Array<QueryObserverResult>,
+                // Use a key function that returns undefined so reconcile
+                // uses positional matching and recursively updates nested properties
+                () => undefined,
+              ),
+            )
+          })
         })
       }
     },
@@ -265,14 +268,16 @@ export function useQueries<
   // Update observer queries when options change reactively
   const trackedDefaultedQueries = createMemo(() => {
     const queries = defaultedQueries()
-    observer.setQueries(
-      queries,
-      queriesOptions().combine
-        ? ({
-            combine: queriesOptions().combine,
-          } as QueriesObserverOptions<TCombinedResult>)
-        : undefined,
-    )
+    runWithOwner(null, () => {
+      observer.setQueries(
+        queries,
+        queriesOptions().combine
+          ? ({
+              combine: queriesOptions().combine,
+            } as QueriesObserverOptions<TCombinedResult>)
+          : undefined,
+      )
+    })
     return queries
   })