@tanstack/solid-query 6.0.0-rc.0 → 6.0.0-rc.2

package/build/index.js

@@ -1,161 +1,18 @@
-import { MutationObserver, shouldThrowError, QueriesObserver, QueryClient as QueryClient$1, replaceEqualDeep, noop, hydrate, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
+import { noop, QueryClient as QueryClient$1, hydrate, dehydrate, shouldThrowError, InfiniteQueryObserver, QueryObserver, replaceEqualDeep } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
-import { createContext, useContext, onCleanup, createSignal, createRenderEffect, createMemo, untrack, createStore, runWithOwner, merge, createEffect, reconcile, isPending, refresh, snapshot } from 'solid-js';
+import { createContext, useContext, onCleanup, createMemo, createOptimistic, createSignal, action, createRenderEffect, untrack, repeat, $TRACK, sharedConfig, createEffect, createProjection, runWithOwner, isPending, resolve } from 'solid-js';
 import { createComponent } from '@solidjs/web';
+import { subscribeFlightData } from '@solidjs/web/server-functions';
 
-// src/useQuery.ts
-function createServerDehydrationChannel(client) {
-  const cache = client.getQueryCache();
-  const entryCache = /* @__PURE__ */ new Map();
-  const snapshot2 = () => {
-    const entries = [];
-    for (const query of cache.getAll()) {
-      if (query.state.status !== "success") continue;
-      let cached = entryCache.get(query.queryHash);
-      if (!cached || cached.state !== query.state) {
-        cached = {
-          state: query.state,
-          entry: {
-            dehydratedAt: Date.now(),
-            state: query.state,
-            queryKey: query.queryKey,
-            queryHash: query.queryHash,
-            ...query.meta && { meta: query.meta },
-            ...query.queryType && { queryType: query.queryType }
-          }
-        };
-        entryCache.set(query.queryHash, cached);
-      }
-      entries.push(cached.entry);
-    }
-    return entries;
-  };
-  let closed = false;
-  let pull = null;
-  const buffered = [];
-  const emit = (value) => {
-    if (closed) return;
-    if (value.done) closed = true;
-    if (pull) {
-      const resolve = pull;
-      pull = null;
-      resolve({ done: false, value });
-    } else {
-      buffered.push(value);
-    }
-  };
-  let closeTimer = null;
-  const scheduleCloseCheck = () => {
-    if (closed || closeTimer !== null) return;
-    closeTimer = setTimeout(() => {
-      closeTimer = null;
-      if (closed) return;
-      if (client.isFetching() === 0) {
-        unsubscribe();
-        emit({ entries: snapshot2(), done: true });
-      }
-    }, 0);
-  };
-  const unsubscribe = cache.subscribe((event) => {
-    if (closed) return;
-    if (event.type === "updated" && event.action.type === "success") {
-      emit({ entries: snapshot2(), done: false });
-    }
-    scheduleCloseCheck();
-  });
-  scheduleCloseCheck();
-  return {
-    [Symbol.asyncIterator]() {
-      return {
-        next() {
-          if (buffered.length > 0) {
-            return Promise.resolve({ done: false, value: buffered.shift() });
-          }
-          if (closed) {
-            return Promise.resolve({
-              done: true,
-              value: void 0
-            });
-          }
-          return new Promise(
-            (resolve) => {
-              pull = resolve;
-            }
-          );
-        },
-        return(value) {
-          if (!closed) {
-            closed = true;
-            unsubscribe();
-            if (closeTimer !== null) {
-              clearTimeout(closeTimer);
-              closeTimer = null;
-            }
-            const resolve = pull;
-            pull = null;
-            resolve?.({ done: true, value: void 0 });
-          }
-          return Promise.resolve({
-            done: true,
-            value
-          });
-        }
-      };
-    }
-  };
-}
-function createHydrationCoordinator(client) {
-  const applied = /* @__PURE__ */ new Map();
-  const waiters = /* @__PURE__ */ new Map();
-  let channelDone = false;
-  const fireWaiters = (queryHash) => {
-    const callbacks = waiters.get(queryHash);
-    if (!callbacks) return;
-    waiters.delete(queryHash);
-    for (const callback of callbacks) queueMicrotask(callback);
-  };
-  return {
-    applyYield(value) {
-      const fresh = value.entries.filter(
-        (entry) => applied.get(entry.queryHash) !== entry.state.dataUpdatedAt
-      );
-      if (fresh.length > 0) {
-        runWithOwner(
-          null,
-          () => hydrate(client(), { queries: fresh, mutations: [] })
-        );
-        for (const entry of fresh) {
-          applied.set(entry.queryHash, entry.state.dataUpdatedAt);
-          fireWaiters(entry.queryHash);
-        }
-      }
-      if (value.done && !channelDone) {
-        channelDone = true;
-        const remaining = [...waiters.values()];
-        waiters.clear();
-        for (const callbacks of remaining) {
-          for (const callback of callbacks) queueMicrotask(callback);
-        }
-      }
-    },
-    whenQueryPrimed(queryHash, callback) {
-      if (channelDone || applied.has(queryHash)) {
-        queueMicrotask(callback);
-        return;
-      }
-      let list = waiters.get(queryHash);
-      if (!list) {
-        list = [];
-        waiters.set(queryHash, list);
-      }
-      list.push(callback);
-    }
-  };
-}
-var HydrationCoordinatorContext = createContext(null);
-
-// src/QueryClientProvider.tsx
+// src/index.ts
+var QueryClient = class extends QueryClient$1 {
+  constructor(config = {}) {
+    super(config);
+  }
+};
 var isServer = typeof window === "undefined";
+var HYDRATION_KEY_PREFIX = "sq:";
+var FLIGHT_DATA_SOURCE = "sq";
 var QueryClientContext = createContext(null);
 var useQueryClient = (queryClient) => {
   if (queryClient) {
@@ -167,25 +24,53 @@ var useQueryClient = (queryClient) => {
   }
   return client();
 };
+function serializeCacheOnServer(client) {
+  const ctx = sharedConfig.context;
+  if (!ctx || !ctx.async || ctx.noHydrate) return;
+  const cache = client.getQueryCache();
+  const shouldDehydrateQuery = client.getDefaultOptions().dehydrate?.shouldDehydrateQuery;
+  const seen = /* @__PURE__ */ new Set();
+  const serializeQuery = (query) => {
+    if (seen.has(query.queryHash)) return;
+    if (shouldDehydrateQuery && !shouldDehydrateQuery(query)) return;
+    const state = query.state;
+    if (state.status === "success") {
+      seen.add(query.queryHash);
+      ctx.serialize(HYDRATION_KEY_PREFIX + query.queryHash, {
+        data: state.data,
+        t: state.dataUpdatedAt
+      });
+    } else if (state.fetchStatus !== "idle") {
+      const promise = query.promise;
+      if (!promise) return;
+      seen.add(query.queryHash);
+      ctx.serialize(HYDRATION_KEY_PREFIX + query.queryHash, promise.then(() => ({
+        data: query.state.data,
+        t: query.state.dataUpdatedAt
+      })));
+    }
+  };
+  for (const query of cache.getAll()) serializeQuery(query);
+  onCleanup(cache.subscribe((event) => serializeQuery(event.query)));
+}
 var QueryClientProvider = (props) => {
   props.client.mount();
   onCleanup(() => props.client.unmount());
-  const [channelValue] = createSignal(() => isServer ? createServerDehydrationChannel(props.client) : void 0);
-  const coordinator = isServer ? null : createHydrationCoordinator(() => props.client);
-  createRenderEffect(() => isServer ? void 0 : channelValue(), (value) => {
-    if (value && coordinator) {
-      coordinator.applyYield(value);
-    }
-  });
+  if (isServer) {
+    serializeCacheOnServer(props.client);
+    onCleanup(() => {
+      props.client.cancelQueries().catch(() => void 0);
+      props.client.clear();
+    });
+  } else {
+    onCleanup(subscribeFlightData(FLIGHT_DATA_SOURCE, (data) => {
+      hydrate(props.client, data);
+    }));
+  }
   return createComponent(QueryClientContext, {
     value: () => props.client,
     get children() {
-      return createComponent(HydrationCoordinatorContext, {
-        value: coordinator,
-        get children() {
-          return props.children;
-        }
-      });
+      return props.children;
     }
   });
 };
@@ -194,251 +79,357 @@ var useIsRestoring = () => useContext(IsRestoringContext);
 
 // src/useBaseQuery.ts
 var isServer2 = typeof window === "undefined";
-function _stripFnsForSSR(obj) {
-  if (!isServer2) return obj;
-  const out = {};
-  for (const k of Object.keys(obj)) {
-    if (k === "refetch" || k === "fetchNextPage" || k === "fetchPreviousPage") {
-      out[k] = void 0;
-    } else {
-      out[k] = obj[k];
-    }
-  }
-  return out;
-}
-function reconcileFn(store, result, reconcileOption, queryHash) {
-  if (typeof reconcileOption === "function") {
-    const newData = reconcileOption(store.data, result.data);
-    return { ...result, data: newData };
-  }
-  if (reconcileOption === false) return result;
-  const key = reconcileOption;
-  let data = result.data;
-  if (store.data === void 0) {
-    try {
-      data = structuredClone(data);
-    } catch (error) {
-    }
-  }
-  if (store.data !== void 0 && data !== void 0) {
-    reconcile(data, key)(store.data);
-    return { ...result, data: store.data };
-  }
-  return { ...result, data };
-}
-var hydratableObserverResult = (_query, result) => {
-  if (!isServer2) return result;
-  const obj = {
-    ...snapshot(result),
-    // During SSR, functions cannot be serialized, so we need to remove them
-    // This is safe because we will add these functions back when the query is hydrated
-    refetch: void 0
+var NEVER = new Promise(noop);
+function metaFrom(state) {
+  return {
+    dataUpdateCount: state.dataUpdateCount,
+    dataUpdatedAt: state.dataUpdatedAt,
+    error: state.error,
+    errorUpdateCount: state.errorUpdateCount,
+    errorUpdatedAt: state.errorUpdatedAt,
+    fetchFailureCount: state.fetchFailureCount,
+    fetchFailureReason: state.fetchFailureReason,
+    fetchStatus: state.fetchStatus,
+    isInvalidated: state.isInvalidated,
+    status: state.status
   };
-  if ("fetchNextPage" in result) {
-    obj.fetchNextPage = void 0;
-    obj.fetchPreviousPage = void 0;
-  }
-  return obj;
-};
+}
 function useBaseQuery(options, Observer, queryClient) {
-  const [client] = createSignal(() => useQueryClient(queryClient?.()));
+  return useBaseQueryLayer(options, Observer, queryClient).result;
+}
+function useBaseQueryLayer(options, Observer, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
   const isRestoring = useIsRestoring();
-  let unsubscribeQueued = false;
-  const [defaultedOptions] = createSignal(() => {
-    const defaultOptions = client().defaultQueryOptions(options());
-    defaultOptions._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
-    defaultOptions.structuralSharing = false;
+  let latestHash;
+  let latestOptions;
+  const defaultedOptions = createMemo(() => {
+    const defaulted = client().defaultQueryOptions(options());
+    defaulted._optimisticResults = isRestoring() ? "isRestoring" : "optimistic";
     if (isServer2) {
-      defaultOptions.retry = false;
-      defaultOptions.throwOnError = true;
-      defaultOptions.experimental_prefetchInRender = true;
+      defaulted.retry = false;
+      defaulted.throwOnError = true;
     }
-    return defaultOptions;
+    latestHash = defaulted.queryHash;
+    latestOptions = defaulted;
+    return defaulted;
   });
-  const observer = untrack(() => new Observer(client(), defaultedOptions()));
-  const [trackedDefaultedOptions] = createSignal(() => defaultedOptions());
+  let observer = untrack(() => new Observer(client(), defaultedOptions()));
   createRenderEffect(
-    () => trackedDefaultedOptions(),
-    (opts) => {
-      runWithOwner(null, () => observer.setOptions(opts));
-    }
+    () => defaultedOptions(),
+    (opts) => observer.setOptions(opts)
   );
-  let observerResult = untrack(
-    () => observer.getOptimisticResult(defaultedOptions())
-  );
-  const [state, setState] = createStore(
-    _stripFnsForSSR(observerResult)
-  );
-  const createServerSubscriber = (resolve, reject) => {
-    return observer.subscribe((result) => {
-      notifyManager.batchCalls(() => {
-        const query = observer.getCurrentQuery();
-        const unwrappedResult = hydratableObserverResult(query, result);
-        if (result.data !== void 0 && unwrappedResult.isError) {
-          reject(unwrappedResult.error);
-          unsubscribeIfQueued();
-        } else {
-          resolve(unwrappedResult);
-          unsubscribeIfQueued();
-        }
-      })();
-    });
-  };
-  const unsubscribeIfQueued = () => {
-    if (unsubscribeQueued) {
-      unsubscribe?.();
-      unsubscribeQueued = false;
+  const hydratedMount = !isServer2 && sharedConfig.hydrating === true;
+  const [version, setVersion] = createSignal(0, { ownedWrite: true });
+  const [primed, setPrimed] = createSignal(!hydratedMount, {
+    ownedWrite: true
+  });
+  const onCacheEvent = (event) => {
+    if (event.query.queryHash === untrack(defaultedOptions).queryHash || event.query.queryHash === latestHash) {
+      setVersion((v) => v + 1);
     }
   };
-  const createClientSubscriber = () => {
-    return observer.subscribe((result) => {
-      const previousResult = observerResult;
-      observerResult = result;
-      runWithOwner(null, () => {
-        setStateWithReconciliation(result);
-        if (unsubscribe && !disposed && (previousResult.isLoading !== result.isLoading || previousResult.isError !== result.isError)) {
-          try {
-            refresh(queryResource);
-          } catch {
-          }
-        }
-      });
-    });
-  };
-  function setStateWithReconciliation(res) {
-    const opts = observer.options;
-    const reconcileOptions = opts.reconcile;
-    const sanitized = _stripFnsForSSR(res);
-    setState((store) => {
-      return reconcileFn(
-        store,
-        sanitized,
-        reconcileOptions === void 0 ? false : reconcileOptions,
-        opts.queryHash
-      );
-    });
-  }
-  let unsubscribe = null;
+  let observerSub = null;
+  let cacheSub = null;
   let disposed = false;
-  const coordinator = useContext(HydrationCoordinatorContext);
-  const attachHydratedSubscriber = () => {
-    if (!unsubscribe && !disposed && !isRestoring()) {
-      unsubscribe = createClientSubscriber();
+  let shouldAttach = false;
+  let activeClient = untrack(client);
+  const attach = () => {
+    if (!disposed && !observerSub && !untrack(isRestoring)) {
+      shouldAttach = true;
+      observerSub = observer.subscribe(noop);
     }
   };
-  const scheduleHydratedAttach = () => {
-    const queryHash = untrack(() => observer.getCurrentQuery().queryHash);
-    if (coordinator) {
-      coordinator.whenQueryPrimed(queryHash, attachHydratedSubscriber);
-    } else {
-      queueMicrotask(attachHydratedSubscriber);
+  const syncClient = (c) => {
+    if (isServer2 || c === activeClient) return;
+    activeClient = c;
+    cacheSub?.();
+    cacheSub = c.getQueryCache().subscribe(onCacheEvent);
+    observerSub?.();
+    observerSub = null;
+    observer = new Observer(c, untrack(defaultedOptions));
+    if (shouldAttach && !disposed && !untrack(isRestoring)) {
+      observerSub = observer.subscribe(noop);
     }
   };
-  let resolver = null;
-  const [queryResource] = createSignal(() => {
-    const opts = trackedDefaultedOptions();
-    const restoring = isRestoring();
-    if (isServer2) {
-      const cached = observer.getOptimisticResult(opts);
-      if (!cached.isLoading) {
-        observerResult = cached;
-        runWithOwner(null, () => {
-          setStateWithReconciliation(cached);
-        });
-        return hydratableObserverResult(
-          observer.getCurrentQuery(),
-          cached
-        );
-      }
+  const prime = (entry) => {
+    if (entry != null && typeof entry === "object" && (entry.t ?? 0) > 0) {
+      const c = untrack(client);
+      const opts = untrack(defaultedOptions);
+      runWithOwner(
+        null,
+        () => hydrate(c, {
+          mutations: [],
+          queries: [
+            {
+              queryKey: opts.queryKey,
+              queryHash: opts.queryHash,
+              dehydratedAt: entry.t,
+              ...opts.meta && { meta: opts.meta },
+              ...opts._type && {
+                queryType: opts._type
+              },
+              state: {
+                data: entry.data,
+                dataUpdatedAt: entry.t,
+                dataUpdateCount: 1,
+                error: null,
+                errorUpdateCount: 0,
+                errorUpdatedAt: 0,
+                fetchFailureCount: 0,
+                fetchFailureReason: null,
+                fetchMeta: null,
+                isInvalidated: false,
+                status: "success",
+                fetchStatus: "idle"
+              }
+            }
+          ]
+        })
+      );
     }
-    const replayProbe = { executorRan: false };
-    const resource = new Promise((resolve, reject) => {
-      replayProbe.executorRan = true;
-      resolver = resolve;
-      if (isServer2) {
-        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);
-          reject(currentResult.error);
-          return;
-        }
-        setStateWithReconciliation(currentResult);
-      });
-      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)
-        );
+  };
+  if (!isServer2) {
+    cacheSub = activeClient.getQueryCache().subscribe(onCacheEvent);
+    const sc = sharedConfig;
+    const registryKey = HYDRATION_KEY_PREFIX + untrack(defaultedOptions).queryHash;
+    const primeAndAttach = (entry) => {
+      prime(entry);
+      setPrimed(true);
+      attach();
+    };
+    const settle = hydratedMount ? primeAndAttach : prime;
+    if (sc.has?.(registryKey)) {
+      const entry = sc.load(registryKey);
+      delete globalThis._$HY.r[registryKey];
+      if (entry != null && typeof entry === "object") {
+        if (entry.s === 1) settle(entry.v);
+        else if (entry.s === 2) settle();
+        else if (typeof entry.then === "function")
+          entry.then(settle, () => settle());
+        else settle(entry);
+      } else {
+        settle(entry);
       }
-    });
-    if (!isServer2 && !replayProbe.executorRan) {
-      scheduleHydratedAttach();
+    } else if (hydratedMount) {
+      primeAndAttach();
     }
-    return resource;
-  });
-  onCleanup(() => {
-    disposed = true;
-    if (isServer2 && isPending(queryResource)) {
-      unsubscribeQueued = true;
-      return;
+    if (!hydratedMount) {
+      createRenderEffect(
+        () => isRestoring(),
+        (restoring) => {
+          if (!restoring) attach();
+        }
+      );
     }
-    if (unsubscribe) {
-      unsubscribe();
-      unsubscribe = null;
+    onCleanup(() => {
+      disposed = true;
+      observerSub?.();
+      observerSub = null;
+      cacheSub?.();
+      cacheSub = null;
+    });
+  }
+  const query = () => {
+    version();
+    const c = client();
+    syncClient(c);
+    return c.getQueryCache().build(c, defaultedOptions());
+  };
+  const isEnabled = () => {
+    const opts = defaultedOptions();
+    const enabled = typeof opts.enabled === "function" ? opts.enabled(untrack(query)) : opts.enabled;
+    return enabled !== false;
+  };
+  const resolvePlaceholder = (opts) => {
+    const placeholder = opts.placeholderData;
+    if (placeholder === void 0) return void 0;
+    return typeof placeholder === "function" ? placeholder() : placeholder;
+  };
+  let chained = null;
+  const chainOnce = (base, select, wrap) => {
+    if (chained?.base !== base || chained.select !== select) {
+      chained = { base, select, value: base.then(wrap) };
     }
-    if (resolver && !isServer2) {
-      resolver(observerResult);
-      resolver = null;
+    return chained.value;
+  };
+  const computeData = (prev) => {
+    const opts = defaultedOptions();
+    const q = query();
+    const state = q.state;
+    const select = opts.select;
+    const wrap = (d) => ({
+      value: select ? select(d) : d
+    });
+    if (state.data === void 0 && state.status === "pending") {
+      const placeholder = resolvePlaceholder(opts);
+      if (placeholder !== void 0) return wrap(placeholder);
     }
-  });
-  const errorPassthroughProps = /* @__PURE__ */ new Set([
-    "error",
-    "isError",
-    "failureCount",
-    "failureReason",
-    "errorUpdateCount",
-    "errorUpdatedAt"
-  ]);
-  return new Proxy(state, {
-    get(target, prop, receiver) {
-      if (typeof prop === "symbol") {
-        return Reflect.get(target, prop, receiver);
-      }
-      if (isServer2) {
-        const resolved = queryResource();
-        if (prop in resolved) {
-          return Reflect.get(resolved, prop);
-        }
+    if (state.fetchStatus !== "idle") {
+      if (state.data === void 0 || prev !== void 0) {
+        const promise = q.promise;
+        if (promise) return chainOnce(promise, select, wrap);
       }
-      if (errorPassthroughProps.has(prop)) {
-        return Reflect.get(target, prop, receiver);
-      }
-      if (state.isError && !state.isFetching && shouldThrowError(observer.options.throwOnError, [
+    }
+    if (state.status === "error") {
+      if (state.data === void 0 || shouldThrowError(opts.throwOnError, [
         state.error,
-        observer.getCurrentQuery()
+        q
       ])) {
         throw state.error;
       }
-      return Reflect.get(target, prop, receiver);
     }
+    if (state.data !== void 0) return wrap(state.data);
+    if (isEnabled()) {
+      if (!isServer2 && sharedConfig.hydrating) {
+        return NEVER;
+      }
+      if (!primed()) {
+        return NEVER;
+      }
+      if (isRestoring()) {
+        return NEVER;
+      }
+      if (!isServer2) observer.setOptions(opts);
+      return chainOnce(q.fetch(opts), select, wrap);
+    }
+    return NEVER;
+  };
+  const dataStore = createProjection(
+    (draft) => computeData(draft.value),
+    {},
+    {
+      key: untrack(() => options().reconcile),
+      deferStream: untrack(() => options().deferStream)
+    }
+  );
+  const data = () => dataStore.value;
+  const serverMeta = () => {
+    if (query().state.status === "pending" && isEnabled()) data();
+    return metaFrom(query().state);
+  };
+  const metaProjection = createProjection(
+    (draft) => {
+      Object.assign(draft, metaFrom(query().state));
+    },
+    untrack(() => metaFrom(query().state))
+  );
+  const meta = isServer2 ? new Proxy({}, {
+    get: (_, key) => serverMeta()[key]
+  }) : metaProjection;
+  const mountedAt = isServer2 ? {
+    get dataUpdateCount() {
+      return untrack(query).state.dataUpdateCount;
+    },
+    get errorUpdateCount() {
+      return untrack(query).state.errorUpdateCount;
+    }
+  } : untrack(() => {
+    const state = query().state;
+    return {
+      dataUpdateCount: state.dataUpdateCount,
+      errorUpdateCount: state.errorUpdateCount
+    };
   });
+  const hasPlaceholder = () => meta.status === "pending" && untrack(() => resolvePlaceholder(defaultedOptions())) !== void 0;
+  const status = () => hasPlaceholder() ? "success" : meta.status;
+  const isPending$1 = () => status() === "pending";
+  const isFetching = () => meta.fetchStatus === "fetching" || isPending(() => data());
+  const isError = () => status() === "error";
+  const isStale = () => {
+    const opts = defaultedOptions();
+    const q = untrack(query);
+    const staleTime = typeof opts.staleTime === "function" ? opts.staleTime(q) : opts.staleTime;
+    version();
+    return q.isStaleByTime(staleTime);
+  };
+  const result = {
+    get data() {
+      return data();
+    },
+    get error() {
+      return meta.error;
+    },
+    get status() {
+      return status();
+    },
+    get fetchStatus() {
+      return meta.fetchStatus;
+    },
+    get isPending() {
+      return isPending$1();
+    },
+    get isSuccess() {
+      return status() === "success";
+    },
+    get isError() {
+      return isError();
+    },
+    get isLoading() {
+      return isPending$1() && isFetching();
+    },
+    get isFetching() {
+      return isFetching();
+    },
+    get isRefetching() {
+      return isFetching() && !isPending$1();
+    },
+    get isPaused() {
+      return meta.fetchStatus === "paused";
+    },
+    get isEnabled() {
+      return isEnabled();
+    },
+    get isLoadingError() {
+      return isError() && meta.dataUpdatedAt === 0;
+    },
+    get isRefetchError() {
+      return isError() && meta.dataUpdatedAt !== 0;
+    },
+    get isPlaceholderData() {
+      return hasPlaceholder();
+    },
+    get isStale() {
+      return isStale();
+    },
+    get isFetched() {
+      return meta.dataUpdateCount > 0 || meta.errorUpdateCount > 0;
+    },
+    get isFetchedAfterMount() {
+      return meta.dataUpdateCount > mountedAt.dataUpdateCount || meta.errorUpdateCount > mountedAt.errorUpdateCount;
+    },
+    get dataUpdatedAt() {
+      return meta.dataUpdatedAt;
+    },
+    get errorUpdatedAt() {
+      return meta.errorUpdatedAt;
+    },
+    get failureCount() {
+      return meta.fetchFailureCount;
+    },
+    get failureReason() {
+      return meta.fetchFailureReason;
+    },
+    get errorUpdateCount() {
+      return meta.errorUpdateCount;
+    },
+    get promise() {
+      return resolve(() => data());
+    },
+    refetch: ((refetchOptions) => {
+      if (!isServer2 && latestOptions) {
+        observer.setOptions(latestOptions);
+      }
+      return observer.refetch(refetchOptions);
+    })
+  };
+  return {
+    result,
+    observer,
+    query,
+    defaultedOptions,
+    isFetching,
+    status
+  };
 }
 
 // src/useQuery.ts
@@ -449,157 +440,356 @@ function useQuery(options, queryClient) {
     queryClient
   );
 }
-function useInfiniteQuery(options, queryClient) {
-  return useBaseQuery(
-    createMemo(() => options()),
-    InfiniteQueryObserver,
-    queryClient
-  );
+
+// src/queryOptions.ts
+function queryOptions(options) {
+  return options;
 }
-function useMutation(options, queryClient) {
-  const client = createMemo(() => useQueryClient(queryClient?.()));
-  const observer = untrack(
-    () => new MutationObserver(
-      client(),
-      options()
-    )
-  );
-  createRenderEffect(
-    () => options(),
-    (opts) => {
-      observer.setOptions(opts);
-    }
+async function dehydrateSettled(client, options) {
+  const cache = client.getQueryCache();
+  for (; ; ) {
+    const pending = cache.getAll().filter((query) => query.state.fetchStatus !== "idle").map((query) => query.promise);
+    if (pending.length === 0) break;
+    await Promise.allSettled(pending);
+  }
+  return dehydrate(client, options);
+}
+var isServer3 = typeof window === "undefined";
+function createCacheAggregate(subscribe, read, empty) {
+  const hydratedMount = !isServer3 && sharedConfig.hydrating === true;
+  const [durable, setDurable] = createSignal(
+    hydratedMount || isServer3 ? empty : untrack(() => read(empty)),
+    { ownedWrite: true }
   );
-  const mutate = (variables, mutateOptions) => {
-    observer.mutate(variables, mutateOptions).catch(noop);
-  };
-  const initialResult = untrack(() => observer.getCurrentResult());
-  const [state, setState] = createStore({
-    ...initialResult,
-    mutate,
-    mutateAsync: initialResult.mutate
+  const [value, setValue] = createOptimistic(() => durable(), {
+    ownedWrite: true
   });
-  const unsubscribe = observer.subscribe((result) => {
-    runWithOwner(null, () => {
-      setState(() => ({
-        ...result,
-        mutate,
-        mutateAsync: result.mutate
-      }));
-    });
-  });
-  onCleanup(unsubscribe);
-  createRenderEffect(
+  const sync = () => {
+    const next = untrack(() => read(untrack(durable)));
+    setDurable(() => next);
+    setValue(() => next);
+  };
+  let unsubscribe = null;
+  const attach = () => {
+    unsubscribe ??= untrack(() => subscribe(sync));
+  };
+  onCleanup(() => unsubscribe?.());
+  createEffect(
+    () => void 0,
     () => {
-      const isError = state.isError;
-      const error = state.error;
-      if (isError && shouldThrowError(observer.options.throwOnError, [error])) {
-        throw error;
+      if (hydratedMount) {
+        attach();
+        sync();
       }
-    },
-    () => {
     }
   );
-  return state;
+  if (isServer3) return () => empty;
+  if (!hydratedMount) attach();
+  return value;
 }
-function useQueries(queriesOptions, queryClient) {
+
+// src/useIsFetching.ts
+function useIsFetching(filters, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
-  const isRestoring = useIsRestoring();
-  const defaultedQueries = createMemo(
-    () => queriesOptions().queries.map(
-      (options) => merge(client().defaultQueryOptions(options), {
-        get _optimisticResults() {
-          return isRestoring() ? "isRestoring" : "optimistic";
-        }
-      })
-    )
+  return createCacheAggregate(
+    (onEvent) => client().getQueryCache().subscribe(onEvent),
+    () => client().isFetching(filters?.()),
+    0
   );
-  const observer = untrack(
-    () => new QueriesObserver(
-      client(),
-      defaultedQueries(),
-      queriesOptions().combine ? {
-        combine: queriesOptions().combine
-      } : void 0
-    )
-  );
-  const [, getCombinedResult] = untrack(
-    () => observer.getOptimisticResult(
-      defaultedQueries(),
-      queriesOptions().combine
-    )
-  );
-  const initialResult = getCombinedResult();
-  const [state, setState] = createStore(
-    Array.isArray(initialResult) ? initialResult : [initialResult]
+}
+function hasNextPage(options, data) {
+  if (!data || data.pages.length === 0) return false;
+  const lastIndex = data.pages.length - 1;
+  return options.getNextPageParam(
+    data.pages[lastIndex],
+    data.pages,
+    data.pageParams[lastIndex],
+    data.pageParams
+  ) != null;
+}
+function hasPreviousPage(options, data) {
+  if (!data || data.pages.length === 0 || !options.getPreviousPageParam)
+    return false;
+  return options.getPreviousPageParam(
+    data.pages[0],
+    data.pages,
+    data.pageParams[0],
+    data.pageParams
+  ) != null;
+}
+function useInfiniteQuery(options, queryClient) {
+  const layer = useBaseQueryLayer(
+    // `_type` is how query-core stamps a cache entry as infinite
+    // (`Query.setOptions` → `#queryType`), which makes every fetch attach
+    // `infiniteQueryBehavior`. Core only sets it inside
+    // `InfiniteQueryObserver.setOptions`, but the adapter's pull path can
+    // build and fetch the entry first (reactive key change recomputes the
+    // data memo before the deferred observer effect runs) — without the
+    // stamp that fetch would run as a plain query and corrupt the entry.
+    createMemo(() => ({ ...options(), _type: "infinite" })),
+    InfiniteQueryObserver,
+    queryClient
   );
-  let unsubscribe = noop;
-  createEffect(
-    () => {
-      if (!isRestoring()) {
-        unsubscribe = observer.subscribe((result) => {
-          runWithOwner(null, () => {
-            setState(
-              reconcile(
-                [...result],
-                // Use a key function that returns undefined so reconcile
-                // uses positional matching and recursively updates nested properties
-                () => void 0
-              )
-            );
-          });
-        });
+  const observer = layer.observer;
+  const direction = () => layer.query().state.fetchMeta?.fetchMore?.direction;
+  const pageOptions = () => layer.defaultedOptions();
+  const infiniteData = () => layer.query().state.data;
+  const isFetchingNextPage = () => layer.isFetching() && direction() === "forward";
+  const isFetchingPreviousPage = () => layer.isFetching() && direction() === "backward";
+  const isError = () => layer.status() === "error";
+  const result = Object.defineProperties(
+    {},
+    {
+      ...Object.getOwnPropertyDescriptors(layer.result),
+      fetchNextPage: {
+        value: (fetchOptions) => observer.fetchNextPage(fetchOptions),
+        enumerable: true
+      },
+      fetchPreviousPage: {
+        value: (fetchOptions) => observer.fetchPreviousPage(fetchOptions),
+        enumerable: true
+      },
+      hasNextPage: {
+        get: () => hasNextPage(pageOptions(), infiniteData()),
+        enumerable: true
+      },
+      hasPreviousPage: {
+        get: () => hasPreviousPage(pageOptions(), infiniteData()),
+        enumerable: true
+      },
+      isFetchingNextPage: {
+        get: isFetchingNextPage,
+        enumerable: true
+      },
+      isFetchingPreviousPage: {
+        get: isFetchingPreviousPage,
+        enumerable: true
+      },
+      isFetchNextPageError: {
+        get: () => isError() && direction() === "forward",
+        enumerable: true
+      },
+      isFetchPreviousPageError: {
+        get: () => isError() && direction() === "backward",
+        enumerable: true
+      },
+      isRefetching: {
+        get: () => layer.isFetching() && layer.status() !== "pending" && !isFetchingNextPage() && !isFetchingPreviousPage(),
+        enumerable: true
+      },
+      isRefetchError: {
+        get: () => {
+          const errored = isError() && layer.query().state.dataUpdatedAt !== 0;
+          return errored && direction() === void 0;
+        },
+        enumerable: true
       }
-    },
-    () => {
     }
   );
-  onCleanup(() => {
-    unsubscribe();
-  });
-  createMemo(() => {
-    const queries = defaultedQueries();
-    runWithOwner(null, () => {
-      observer.setQueries(
-        queries,
-        queriesOptions().combine ? {
-          combine: queriesOptions().combine
-        } : void 0
-      );
-    });
-    return queries;
-  });
-  return state;
+  return result;
 }
-var QueryClient = class extends QueryClient$1 {
-  constructor(config = {}) {
-    super(config);
-  }
-};
 
-// src/queryOptions.ts
-function queryOptions(options) {
+// src/infiniteQueryOptions.ts
+function infiniteQueryOptions(options) {
   return options;
 }
-function useIsFetching(filters, queryClient) {
+var isServer4 = typeof window === "undefined";
+var IDLE = {
+  status: "idle",
+  data: void 0,
+  error: null,
+  variables: void 0,
+  submittedAt: 0
+};
+async function drain(iterator) {
+  let input;
+  for (; ; ) {
+    const result = await iterator.next(input);
+    if (result.done) return result.value;
+    input = result.value != null ? await result.value : void 0;
+  }
+}
+function useMutation(options, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
-  const queryCache = createMemo(() => client().getQueryCache());
-  const [fetches, setFetches] = createSignal(
-    untrack(() => client().isFetching(filters?.())),
-    { ownedWrite: true }
-  );
-  const unsubscribe = untrack(
-    () => queryCache().subscribe(() => {
-      setFetches(client().isFetching(filters?.()));
-    })
+  const [flight, setFlight] = createOptimistic(null);
+  const [settled, setSettled] = createSignal(IDLE);
+  let activeMutation = null;
+  let unsubscribeFlight = null;
+  const [flightVersion, setFlightVersion] = createSignal(0);
+  if (!isServer4)
+    onCleanup(() => {
+      unsubscribeFlight?.();
+      unsubscribeFlight = null;
+    });
+  async function* run(variables) {
+    const opts = untrack(options);
+    const callbackContext = {
+      client: untrack(client),
+      meta: opts.meta,
+      mutationKey: opts.mutationKey
+    };
+    if (!isServer4) setFlight({ variables });
+    opts.onMutate?.(variables, callbackContext);
+    const c = untrack(client);
+    const mutation = c.getMutationCache().build(c, {
+      ...opts,
+      // Options-level callbacks re-run below, inside the transaction —
+      // executing them here (inside the await gap) would let their
+      // cache writes and invalidations escape the atomic settle.
+      onMutate: void 0,
+      onSuccess: void 0,
+      onError: void 0,
+      onSettled: void 0
+    });
+    activeMutation = mutation;
+    if (!isServer4) {
+      unsubscribeFlight?.();
+      unsubscribeFlight = c.getMutationCache().subscribe((event) => {
+        if ("mutation" in event && event.mutation === activeMutation) {
+          setFlightVersion((v) => v + 1);
+        }
+      });
+    }
+    const settleFlight = () => {
+      if (activeMutation !== mutation) return;
+      activeMutation = null;
+      unsubscribeFlight?.();
+      unsubscribeFlight = null;
+    };
+    async function* settleFailure(error) {
+      try {
+        if (opts.onError)
+          yield opts.onError(error, variables, void 0, callbackContext);
+      } catch (callbackError) {
+        void Promise.reject(callbackError);
+      }
+      try {
+        if (opts.onSettled)
+          yield opts.onSettled(
+            void 0,
+            error,
+            variables,
+            void 0,
+            callbackContext
+          );
+      } catch (callbackError) {
+        void Promise.reject(callbackError);
+      }
+      if (!isServer4)
+        setSettled({
+          status: "error",
+          data: void 0,
+          error,
+          variables,
+          submittedAt: mutation.state.submittedAt
+        });
+      settleFlight();
+      throw error;
+    }
+    let result2;
+    try {
+      result2 = await mutation.execute(variables);
+    } catch (error) {
+      yield;
+      yield* settleFailure(error);
+      throw error;
+    }
+    yield;
+    try {
+      if (opts.onSuccess)
+        yield opts.onSuccess(
+          result2,
+          variables,
+          void 0,
+          callbackContext
+        );
+      if (opts.onSettled)
+        yield opts.onSettled(
+          result2,
+          null,
+          variables,
+          void 0,
+          callbackContext
+        );
+    } catch (callbackError) {
+      yield* settleFailure(callbackError);
+      throw callbackError;
+    }
+    if (!isServer4)
+      setSettled({
+        status: "success",
+        data: result2,
+        error: null,
+        variables,
+        submittedAt: mutation.state.submittedAt
+      });
+    settleFlight();
+    return result2;
+  }
+  const invoke = isServer4 ? (variables) => drain(run(variables)) : action(run);
+  const mutate = (variables) => {
+    const promise = invoke(variables);
+    promise.catch(noop);
+    return promise;
+  };
+  const status = () => flight() !== null ? "pending" : settled().status;
+  const isPending = () => flight() !== null;
+  createRenderEffect(
+    () => {
+      const state = settled();
+      if (state.status === "error" && shouldThrowError(untrack(options).throwOnError, [state.error])) {
+        throw state.error;
+      }
+    },
+    () => {
+    }
   );
-  onCleanup(unsubscribe);
-  return fetches;
-}
-
-// src/infiniteQueryOptions.ts
-function infiniteQueryOptions(options) {
-  return options;
+  const result = {
+    mutate,
+    get data() {
+      return settled().data;
+    },
+    get error() {
+      return flight() !== null ? null : settled().error;
+    },
+    get variables() {
+      return flight()?.variables ?? settled().variables;
+    },
+    get status() {
+      return status();
+    },
+    get isPending() {
+      return isPending();
+    },
+    get isIdle() {
+      return status() === "idle";
+    },
+    get isSuccess() {
+      return status() === "success";
+    },
+    get isError() {
+      return status() === "error";
+    },
+    get submittedAt() {
+      return flight() !== null ? (flightVersion(), activeMutation?.state.submittedAt ?? 0) : settled().submittedAt;
+    },
+    get failureCount() {
+      flightVersion();
+      return activeMutation?.state.failureCount ?? 0;
+    },
+    get failureReason() {
+      flightVersion();
+      return activeMutation?.state.failureReason ?? null;
+    },
+    get isPaused() {
+      flightVersion();
+      return activeMutation?.state.isPaused ?? false;
+    },
+    reset: () => {
+      setSettled(IDLE);
+    }
+  };
+  return result;
 }
 
 // src/mutationOptions.ts
@@ -608,18 +798,11 @@ function mutationOptions(options) {
 }
 function useIsMutating(filters, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
-  const mutationCache = createMemo(() => client().getMutationCache());
-  const [mutations, setMutations] = createSignal(
-    untrack(() => client().isMutating(filters?.())),
-    { ownedWrite: true }
-  );
-  const unsubscribe = untrack(
-    () => mutationCache().subscribe((_result) => {
-      setMutations(client().isMutating(filters?.()));
-    })
+  return createCacheAggregate(
+    (onEvent) => client().getMutationCache().subscribe(onEvent),
+    () => client().isMutating(filters?.()),
+    0
   );
-  onCleanup(unsubscribe);
-  return mutations;
 }
 function getResult(mutationCache, options) {
   return mutationCache.findAll(options.filters).map(
@@ -628,30 +811,54 @@ function getResult(mutationCache, options) {
 }
 function useMutationState(options = () => ({}), queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
-  const mutationCache = createMemo(() => client().getMutationCache());
-  const [result, setResult] = createSignal(
-    untrack(() => getResult(mutationCache(), options())),
-    { ownedWrite: true }
-  );
-  const unsubscribe = untrack(
-    () => mutationCache().subscribe(() => {
-      setResult((prev) => {
-        const nextResult = replaceEqualDeep(
-          prev,
-          getResult(mutationCache(), options())
-        );
-        return prev === nextResult ? prev : nextResult;
-      });
-    })
+  return createCacheAggregate(
+    (onEvent) => client().getMutationCache().subscribe(onEvent),
+    // Structural sharing against the previous committed value keeps
+    // unchanged mutation states referentially stable across syncs.
+    (prev) => replaceEqualDeep(prev, getResult(client().getMutationCache(), options())),
+    []
   );
-  onCleanup(unsubscribe);
-  return result;
+}
+function useQueries(queriesOptions, queryClient) {
+  const length = createMemo(() => queriesOptions().queries.length);
+  const results = repeat(length, (index) => {
+    let lastOptions;
+    return useBaseQuery(
+      () => {
+        const next = queriesOptions().queries[index];
+        if (next !== void 0) lastOptions = next;
+        return lastOptions;
+      },
+      QueryObserver,
+      queryClient
+    );
+  });
+  const combined = createMemo(() => {
+    const combine = queriesOptions().combine;
+    const list = results();
+    return combine ? combine(list) : list;
+  });
+  return new Proxy([], {
+    get(_, prop) {
+      if (prop === $TRACK) return combined();
+      return Reflect.get(combined(), prop);
+    },
+    has(_, prop) {
+      if (prop === $TRACK) return true;
+      return Reflect.has(combined(), prop);
+    },
+    ownKeys() {
+      return Reflect.ownKeys(combined());
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(
+        combined(),
+        prop
+      );
+      if (descriptor) descriptor.configurable = true;
+      return descriptor;
+    }
+  });
 }
 
-// src/index.ts
-var createQuery = useQuery;
-var createInfiniteQuery = useInfiniteQuery;
-var createMutation = useMutation;
-var createQueries = useQueries;
-
-export { IsRestoringContext, QueryClient, QueryClientContext, QueryClientProvider, createInfiniteQuery, useIsFetching as createIsFetching, useIsMutating as createIsMutating, createMutation, useMutationState as createMutationState, createQueries, createQuery, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };
+export { FLIGHT_DATA_SOURCE, IsRestoringContext, QueryClient, QueryClientContext, QueryClientProvider, dehydrateSettled, infiniteQueryOptions, mutationOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };