@braine/quantum-query 1.3.2 → 1.3.4

package/dist/index.js

@@ -76,7 +76,7 @@ function atom(initialValue, options) {
   return s;
 }
 function setupPersistence(s, options) {
-  const { key, storage = "local", debug } = options;
+  const { key, storage = "local", debug, hydrateSync } = options;
   if (!key) return;
   let engine = null;
   if (typeof storage === "string") {
@@ -87,27 +87,34 @@ function setupPersistence(s, options) {
     engine = storage;
   }
   if (!engine) return;
-  try {
-    const stored = engine.getItem(key);
-    const applyValue = (val) => {
-      try {
-        const parsed = JSON.parse(val);
-        const validated = options.validate ? options.validate(parsed) : parsed;
-        s.set(validated);
-        if (debug) console.log(`[Quantum] Hydrated atom '${key}'`);
-      } catch (e) {
-        if (debug) console.error(`[Quantum] Hydration validation failed for '${key}'`, e);
+  const hydrate2 = () => {
+    try {
+      const stored = engine?.getItem(key);
+      const applyValue = (val) => {
+        try {
+          const parsed = JSON.parse(val);
+          const validated = options.validate ? options.validate(parsed) : parsed;
+          s.set(validated);
+          if (debug) console.log(`[Quantum] Hydrated atom '${key}'`);
+        } catch (e) {
+          if (debug) console.error(`[Quantum] Hydration validation failed for '${key}'`, e);
+        }
+      };
+      if (stored instanceof Promise) {
+        stored.then((val) => {
+          if (val) applyValue(val);
+        });
+      } else if (stored) {
+        applyValue(stored);
       }
-    };
-    if (stored instanceof Promise) {
-      stored.then((val) => {
-        if (val) applyValue(val);
-      });
-    } else if (stored) {
-      applyValue(stored);
+    } catch (err) {
+      if (debug) console.error(`[Quantum] Hydration error`, err);
     }
-  } catch (err) {
-    if (debug) console.error(`[Quantum] Hydration error`, err);
+  };
+  if (hydrateSync) {
+    hydrate2();
+  } else {
+    Promise.resolve().then(hydrate2);
   }
   s.subscribe((value) => {
     try {
@@ -138,6 +145,19 @@ function SignalValue({ signal: signal2, render, children }) {
   return /* @__PURE__ */ jsx(Fragment, { children: renderer(value) });
 }
 
+// src/react/QueryMatch.tsx
+import "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function QueryMatch({ signal: signal2, selector, children }) {
+  return /* @__PURE__ */ jsx2(SignalValue, { signal: signal2, children: (value) => {
+    const selected = selector(value);
+    return children(selected);
+  } });
+}
+function Match({ signal: signal2, when, children }) {
+  return /* @__PURE__ */ jsx2(SignalValue, { signal: signal2, children: (value) => when(value) ? children : null });
+}
+
 // src/store/scheduler.ts
 var pending = /* @__PURE__ */ new Set();
 var timer = null;
@@ -201,41 +221,90 @@ function stableHash(value, depth = 0) {
   const keys = Object.keys(value).sort();
   return `object:{${keys.map((key) => `${key}:${stableHash(value[key], depth + 1)}`).join(",")}}`;
 }
-function isDeepEqual(a, b) {
-  if (a === b) return true;
-  if (a && b && typeof a === "object" && typeof b === "object") {
-    const objA = a;
-    const objB = b;
-    if (objA.constructor !== objB.constructor) return false;
-    let length, i, keys;
-    if (Array.isArray(a)) {
-      if (!Array.isArray(b)) return false;
-      length = a.length;
-      if (length !== b.length) return false;
-      for (i = length; i-- !== 0; ) {
-        if (!isDeepEqual(a[i], b[i])) return false;
+
+// src/query/trie.ts
+var TrieNode = class {
+  children = /* @__PURE__ */ new Map();
+  keys = /* @__PURE__ */ new Set();
+  // Stores the full hashed keys valid at this path
+};
+var QueryKeyTrie = class {
+  root = new TrieNode();
+  insert(queryKey, hashedKey) {
+    const parts = this.normalizeParts(queryKey);
+    let node = this.root;
+    for (const part of parts) {
+      const hash = stableHash(part);
+      let child = node.children.get(hash);
+      if (!child) {
+        child = new TrieNode();
+        node.children.set(hash, child);
       }
-      return true;
+      node = child;
+    }
+    node.keys.add(hashedKey);
+  }
+  remove(queryKey, hashedKey) {
+    const parts = this.normalizeParts(queryKey);
+    this.removeRecursive(this.root, parts, 0, hashedKey);
+  }
+  removeRecursive(node, parts, index, hashedKey) {
+    if (index === parts.length) {
+      node.keys.delete(hashedKey);
+      return node.children.size === 0 && node.keys.size === 0;
+    }
+    const part = parts[index];
+    const hash = stableHash(part);
+    const child = node.children.get(hash);
+    if (child) {
+      const shouldDeleteChild = this.removeRecursive(child, parts, index + 1, hashedKey);
+      if (shouldDeleteChild) {
+        node.children.delete(hash);
+      }
+    }
+    return node.children.size === 0 && node.keys.size === 0;
+  }
+  /**
+   * Get all hashed keys that match the given partial query key (prefix)
+   */
+  getMatchingKeys(partialKey) {
+    const parts = this.normalizeParts(partialKey);
+    let node = this.root;
+    for (const part of parts) {
+      const hash = stableHash(part);
+      const child = node.children.get(hash);
+      if (!child) {
+        return /* @__PURE__ */ new Set();
+      }
+      node = child;
     }
-    if (objA.valueOf !== Object.prototype.valueOf) return objA.valueOf() === objB.valueOf();
-    if (objA.toString !== Object.prototype.toString) return objA.toString() === objB.toString();
-    keys = Object.keys(objA);
-    length = keys.length;
-    if (length !== Object.keys(objB).length) return false;
-    for (const key of keys) {
-      if (!Object.prototype.hasOwnProperty.call(objB, key)) return false;
+    const results = /* @__PURE__ */ new Set();
+    this.collectKeys(node, results);
+    return results;
+  }
+  collectKeys(node, results) {
+    for (const key of node.keys) {
+      results.add(key);
     }
-    for (const key of keys) {
-      if (!isDeepEqual(objA[key], objB[key])) return false;
+    for (const child of node.children.values()) {
+      this.collectKeys(child, results);
     }
-    return true;
   }
-  return a !== a && b !== b;
-}
+  normalizeParts(queryKey) {
+    if (Array.isArray(queryKey)) {
+      return queryKey;
+    }
+    if (queryKey && typeof queryKey === "object" && "key" in queryKey) {
+      const qk = queryKey;
+      return [qk.key, qk.params];
+    }
+    return [queryKey];
+  }
+};
 
 // src/query/queryStorage.ts
 var QueryStorage = class {
-  // Tracks access order (least to most recent)
+  // 10/10: O(K) Lookup
   // Default configuration
   constructor(defaultStaleTime = 5 * 60 * 1e3, defaultCacheTime = 5 * 60 * 1e3, maxSize = 100) {
     this.defaultStaleTime = defaultStaleTime;
@@ -245,6 +314,8 @@ var QueryStorage = class {
   signals = /* @__PURE__ */ new Map();
   gcTimers = /* @__PURE__ */ new Map();
   lruOrder = /* @__PURE__ */ new Set();
+  // Tracks access order (least to most recent)
+  trie = new QueryKeyTrie();
   generateKey(queryKey) {
     const key = Array.isArray(queryKey) ? stableHash(queryKey) : stableHash([queryKey.key, queryKey.params]);
     return key;
@@ -319,6 +390,7 @@ var QueryStorage = class {
       }
       this.enforceMaxSize();
     }
+    this.trie.insert(entry.key, key);
   }
   delete(key) {
     const entry = this.signals.get(key)?.get();
@@ -331,6 +403,9 @@ var QueryStorage = class {
         }
       }
     }
+    if (entry?.key) {
+      this.trie.remove(entry.key, key);
+    }
     this.signals.delete(key);
     this.lruOrder.delete(key);
     this.cancelGC(key);
@@ -355,6 +430,7 @@ var QueryStorage = class {
   clear() {
     this.signals.clear();
     this.tagIndex.clear();
+    this.trie = new QueryKeyTrie();
     this.lruOrder.clear();
     this.gcTimers.forEach((timer2) => clearTimeout(timer2));
     this.gcTimers.clear();
@@ -907,11 +983,26 @@ var QueryClient = class {
     });
     this.pluginManager.onFetchStart(normalizedKey);
     try {
-      const data = await this.remotes.fetch(key, fn, {
+      const fetchPromise = this.remotes.fetch(key, fn, {
         signal: options?.signal,
         retry: options?.retry,
         retryDelay: options?.retryDelay
       });
+      this.storage.set(key, {
+        data: currentEntry?.data,
+        status: currentEntry?.status || "pending",
+        error: null,
+        isFetching: true,
+        fetchDirection: direction,
+        timestamp: currentEntry?.timestamp || Date.now(),
+        staleTime: currentEntry?.staleTime ?? this.defaultStaleTime,
+        cacheTime: currentEntry?.cacheTime ?? this.defaultCacheTime,
+        key: queryKey,
+        tags: mergedTags,
+        promise: fetchPromise
+        // Store for Suspense
+      });
+      const data = await fetchPromise;
       this.storage.set(key, {
         data,
         status: "success",
@@ -924,7 +1015,9 @@ var QueryClient = class {
         staleTime: currentEntry?.staleTime ?? this.defaultStaleTime,
         cacheTime: currentEntry?.cacheTime ?? this.defaultCacheTime,
         key: queryKey,
-        tags: mergedTags
+        tags: mergedTags,
+        promise: void 0
+        // Clear promise
       });
       const schema = options?.schema || this.defaultSchema;
       const validatedData = validateWithSchema(data, schema);
@@ -942,7 +1035,9 @@ var QueryClient = class {
         staleTime: currentEntry?.staleTime ?? this.defaultStaleTime,
         cacheTime: currentEntry?.cacheTime ?? this.defaultCacheTime,
         key: queryKey,
-        tags: mergedTags
+        tags: mergedTags,
+        promise: void 0
+        // Clear promise
       });
       this.pluginManager.onFetchError(normalizedKey, err);
       throw err;
@@ -952,18 +1047,15 @@ var QueryClient = class {
    * Invalidate queries
    */
   invalidate = (queryKey) => {
-    const prefix = this.storage.generateKey(queryKey);
     const normalizedKey = this.normalizeKey(queryKey);
     this.pluginManager.onInvalidate(normalizedKey);
-    const allKeys = this.storage.getSnapshot().keys();
-    for (const key of allKeys) {
-      if (key === prefix || key.startsWith(prefix.slice(0, -1))) {
-        const signal2 = this.storage.get(key, false);
-        if (signal2) {
-          const current = signal2.get();
-          if (current) {
-            signal2.set({ ...current, isInvalidated: true });
-          }
+    const matchingKeys = this.storage.trie.getMatchingKeys(queryKey);
+    for (const key of matchingKeys) {
+      const signal2 = this.storage.get(key, false);
+      if (signal2) {
+        const current = signal2.get();
+        if (current) {
+          signal2.set({ ...current, isInvalidated: true });
         }
       }
     }
@@ -1056,13 +1148,13 @@ var QueryClient = class {
 };
 
 // src/query/context.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
+import { jsx as jsx3 } from "react/jsx-runtime";
 var QueryClientContext = createContext(void 0);
 var QueryClientProvider = ({
   client,
   children
 }) => {
-  return /* @__PURE__ */ jsx2(QueryClientContext.Provider, { value: client, children: children || null });
+  return /* @__PURE__ */ jsx3(QueryClientContext.Provider, { value: client, children: children || null });
 };
 var useQueryClient = () => {
   const client = useContext(QueryClientContext);
@@ -1086,7 +1178,7 @@ function useQueryStore() {
 }
 
 // src/devtools/QueryPanel.tsx
-import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
 function QueryPanel() {
   const cache = useQueryStore();
   const client = useQueryClient();
@@ -1111,7 +1203,7 @@ function QueryPanel() {
       display: "flex",
       gap: "8px"
     }, children: [
-      /* @__PURE__ */ jsx3(
+      /* @__PURE__ */ jsx4(
         "input",
         {
           type: "text",
@@ -1130,7 +1222,7 @@ function QueryPanel() {
           }
         }
       ),
-      /* @__PURE__ */ jsx3(
+      /* @__PURE__ */ jsx4(
         "button",
         {
           onClick: () => client.invalidateAll(),
@@ -1147,7 +1239,7 @@ function QueryPanel() {
         }
       )
     ] }),
-    /* @__PURE__ */ jsx3("div", { style: {
+    /* @__PURE__ */ jsx4("div", { style: {
       flex: 1,
       overflowY: "auto",
       padding: "8px",
@@ -1155,7 +1247,7 @@ function QueryPanel() {
       flexDirection: "column",
       gap: "8px",
       background: "#050505"
-    }, children: entries.length === 0 ? /* @__PURE__ */ jsx3("div", { style: { padding: "20px", textAlign: "center", color: "#444", fontSize: "12px" }, children: "No active queries." }) : filteredEntries.map(([keyHash, entry]) => /* @__PURE__ */ jsx3(
+    }, children: entries.length === 0 ? /* @__PURE__ */ jsx4("div", { style: { padding: "20px", textAlign: "center", color: "#444", fontSize: "12px" }, children: "No active queries." }) : filteredEntries.map(([keyHash, entry]) => /* @__PURE__ */ jsx4(
       QueryItem,
       {
         entry,
@@ -1188,12 +1280,12 @@ function QueryItem({ entry, client, isStale }) {
         },
         children: [
           /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "8px", alignItems: "center", overflow: "hidden" }, children: [
-            /* @__PURE__ */ jsx3("span", { style: {
+            /* @__PURE__ */ jsx4("span", { style: {
               color: isStale ? "#d69e2e" : "#b0fb5d",
               fontSize: "12px",
               fontWeight: "bold"
             }, children: "\u2022" }),
-            /* @__PURE__ */ jsx3("span", { style: {
+            /* @__PURE__ */ jsx4("span", { style: {
               color: "#e0e0e0",
               fontSize: "12px",
               whiteSpace: "nowrap",
@@ -1201,7 +1293,7 @@ function QueryItem({ entry, client, isStale }) {
               textOverflow: "ellipsis"
             }, children: JSON.stringify(entry.key) })
           ] }),
-          /* @__PURE__ */ jsx3("span", { style: {
+          /* @__PURE__ */ jsx4("span", { style: {
             fontSize: "9px",
             color: isStale ? "#d69e2e" : "#b0fb5d",
             padding: "1px 4px",
@@ -1218,7 +1310,7 @@ function QueryItem({ entry, client, isStale }) {
       background: "#0a0a0a"
     }, children: [
       /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "8px", marginBottom: "8px" }, children: [
-        /* @__PURE__ */ jsx3(
+        /* @__PURE__ */ jsx4(
           "button",
           {
             onClick: (e) => {
@@ -1229,7 +1321,7 @@ function QueryItem({ entry, client, isStale }) {
             children: "Invalidate"
           }
         ),
-        /* @__PURE__ */ jsx3(
+        /* @__PURE__ */ jsx4(
           "button",
           {
             onClick: (e) => {
@@ -1241,13 +1333,13 @@ function QueryItem({ entry, client, isStale }) {
           }
         )
       ] }),
-      /* @__PURE__ */ jsx3("pre", { style: { margin: 0, fontSize: "10px", color: "#a0a0a0", overflowX: "auto", fontFamily: "monospace" }, children: JSON.stringify(entry.data, null, 2) })
+      /* @__PURE__ */ jsx4("pre", { style: { margin: 0, fontSize: "10px", color: "#a0a0a0", overflowX: "auto", fontFamily: "monospace" }, children: JSON.stringify(entry.data, null, 2) })
     ] })
   ] });
 }
 
 // src/devtools/index.tsx
-import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
 function QuantumDevTools() {
   const [isOpen, setIsOpen] = useState4(false);
   const [activeTab, setActiveTab] = useState4("queries");
@@ -1271,7 +1363,7 @@ function QuantumDevTools() {
     };
   }, []);
   if (!isOpen) {
-    return /* @__PURE__ */ jsx4(
+    return /* @__PURE__ */ jsx5(
       "button",
       {
         onClick: () => setIsOpen(true),
@@ -1309,7 +1401,7 @@ function QuantumDevTools() {
     flexDirection: "column",
     fontFamily: "monospace"
   }, children: [
-    /* @__PURE__ */ jsx4(
+    /* @__PURE__ */ jsx5(
       "div",
       {
         onMouseDown: () => {
@@ -1328,19 +1420,19 @@ function QuantumDevTools() {
       borderBottom: "1px solid #222"
     }, children: [
       /* @__PURE__ */ jsxs2("div", { style: { display: "flex", gap: "16px", alignItems: "center" }, children: [
-        /* @__PURE__ */ jsx4("span", { style: { color: "#b0fb5d", fontWeight: "bold" }, children: "Quantum DevTools" }),
+        /* @__PURE__ */ jsx5("span", { style: { color: "#b0fb5d", fontWeight: "bold" }, children: "Quantum DevTools" }),
         /* @__PURE__ */ jsxs2("div", { style: { display: "flex", gap: "4px", background: "#000", padding: "2px", borderRadius: "4px" }, children: [
-          /* @__PURE__ */ jsx4(TabButton, { active: activeTab === "queries", onClick: () => setActiveTab("queries"), children: "Queries" }),
-          /* @__PURE__ */ jsx4(TabButton, { active: activeTab === "state", onClick: () => setActiveTab("state"), children: "State" })
+          /* @__PURE__ */ jsx5(TabButton, { active: activeTab === "queries", onClick: () => setActiveTab("queries"), children: "Queries" }),
+          /* @__PURE__ */ jsx5(TabButton, { active: activeTab === "state", onClick: () => setActiveTab("state"), children: "State" })
         ] })
       ] }),
-      /* @__PURE__ */ jsx4("button", { onClick: () => setIsOpen(false), style: { background: "none", border: "none", color: "#666", cursor: "pointer" }, children: "\xD7" })
+      /* @__PURE__ */ jsx5("button", { onClick: () => setIsOpen(false), style: { background: "none", border: "none", color: "#666", cursor: "pointer" }, children: "\xD7" })
     ] }),
-    /* @__PURE__ */ jsx4("div", { style: { flex: 1, overflow: "hidden" }, children: activeTab === "queries" ? /* @__PURE__ */ jsx4(QueryPanel, {}) : /* @__PURE__ */ jsx4("div", { children: "State Panel (Under Construction)" }) })
+    /* @__PURE__ */ jsx5("div", { style: { flex: 1, overflow: "hidden" }, children: activeTab === "queries" ? /* @__PURE__ */ jsx5(QueryPanel, {}) : /* @__PURE__ */ jsx5("div", { children: "State Panel (Under Construction)" }) })
   ] });
 }
 function TabButton({ active, children, onClick }) {
-  return /* @__PURE__ */ jsx4(
+  return /* @__PURE__ */ jsx5(
     "button",
     {
       onClick,
@@ -1506,6 +1598,8 @@ var RetryMiddleware = async (ctx, next) => {
   let config;
   if (typeof retryConfigRaw === "number") {
     config = { retries: retryConfigRaw };
+  } else if (typeof retryConfigRaw === "boolean") {
+    config = retryConfigRaw ? { retries: 3 } : { retries: 0 };
   } else if (typeof retryConfigRaw === "object" && retryConfigRaw !== null) {
     config = retryConfigRaw;
   } else {
@@ -1932,7 +2026,7 @@ var QueryObserver = class {
         status: selectorError ? "error" : status,
         refetch: this.refetch
       };
-      const isDataEqual = lastResult?.data === nextResult.data || isDeepEqual(lastResult?.data, nextResult.data);
+      const isDataEqual = lastResult?.data === nextResult.data;
       if (lastResult && isDataEqual && lastResult.status === nextResult.status && lastResult.isFetching === nextResult.isFetching && lastResult.isStale === nextResult.isStale && lastResult.error === nextResult.error) {
         return lastResult;
       }
@@ -2076,6 +2170,33 @@ function useQuery(options) {
   };
 }
 
+// src/query/useSuspenseQuery.ts
+function useSuspenseQuery(options) {
+  const client = useQueryClient();
+  const signal2 = client.getSignal(options.queryKey);
+  const entry = signal2.get();
+  if (entry?.status === "error") {
+    throw entry.error;
+  }
+  if (!entry || entry.status === "pending" && entry.data === void 0) {
+    if (entry?.promise) {
+      throw entry.promise;
+    }
+    const fetchPromise = client.fetch(options.queryKey, options.queryFn, {
+      retry: options.retry,
+      retryDelay: options.retryDelay,
+      tags: options.tags,
+      schema: options.schema
+    });
+    throw fetchPromise;
+  }
+  const query = useQuery(options);
+  return {
+    ...query,
+    data: query.data
+  };
+}
+
 // src/query/useMutation.ts
 import { useCallback as useCallback3, useEffect as useEffect6, useSyncExternalStore as useSyncExternalStore3, useState as useState7 } from "react";
 
@@ -2241,7 +2362,7 @@ var InfiniteQueryObserver = class {
   options$;
   result$;
   unsubscribe = null;
-  lastFetchTime = 0;
+  abortController = null;
   constructor(client, options) {
     this.client = client;
     this.options$ = createSignal(options);
@@ -2294,8 +2415,7 @@ var InfiniteQueryObserver = class {
         fetchPreviousPage: this.fetchPreviousPage,
         refetch: this.refetch
       };
-      const isDataEqual = lastResult?.data === nextResult.data || isDeepEqual(lastResult?.data, nextResult.data);
-      if (lastResult && isDataEqual && lastResult.isFetching === nextResult.isFetching && lastResult.status === nextResult.status && lastResult.hasNextPage === nextResult.hasNextPage && lastResult.hasPreviousPage === nextResult.hasPreviousPage) {
+      if (lastResult && lastResult.data === nextResult.data && lastResult.isFetching === nextResult.isFetching && lastResult.status === nextResult.status && lastResult.hasNextPage === nextResult.hasNextPage && lastResult.hasPreviousPage === nextResult.hasPreviousPage && lastResult.error === nextResult.error) {
         return lastResult;
       }
       lastResult = nextResult;
@@ -2307,8 +2427,8 @@ var InfiniteQueryObserver = class {
     const current = this.options$.get();
     if (current === options) return;
     const isKeyEqual = stableHash(current.queryKey) === stableHash(options.queryKey);
-    const isConfigEqual = current.enabled === options.enabled && current.staleTime === options.staleTime;
-    if (!isKeyEqual || !isConfigEqual || current.getNextPageParam !== options.getNextPageParam || current.getPreviousPageParam !== options.getPreviousPageParam) {
+    const isConfigEqual = current.enabled === options.enabled && current.staleTime === options.staleTime && current.retry === options.retry;
+    if (!isKeyEqual || !isConfigEqual) {
       this.options$.set(options);
     }
   }
@@ -2341,25 +2461,37 @@ var InfiniteQueryObserver = class {
       }
     });
     this.unsubscribe = () => {
+      this.cancel();
       dispose();
       disposeFocus();
       disposeOnline();
     };
   }
+  cancel() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
   fetchInitial = async (options) => {
+    this.cancel();
+    this.abortController = new AbortController();
+    const signal2 = this.abortController.signal;
     const opts = this.options$.get();
     const infiniteKey = [...opts.queryKey, "__infinite__"];
     try {
       const entrySignal = this.client.getSignal(infiniteKey);
-      const data = entrySignal.get()?.data;
-      if (data && data.pageParams.length > 0 && !options?.force) {
-        const firstParam2 = data.pageParams[0];
+      const currentState = entrySignal.get()?.data;
+      if (currentState && currentState.pageParams.length > 0 && !options?.force) {
+        const firstParam2 = currentState.pageParams[0];
         const firstPage = await opts.queryFn({ pageParam: firstParam2 });
+        if (signal2.aborted) return;
         const latest = entrySignal.get()?.data;
         if (!latest) return;
         const updatedData = {
           ...latest,
           pages: [firstPage, ...latest.pages.slice(1)]
+          // pageParams remain the same
         };
         this.client.set(infiniteKey, updatedData, {
           staleTime: opts.staleTime,
@@ -2369,107 +2501,116 @@ var InfiniteQueryObserver = class {
       }
       const initialParam = opts.initialPageParam;
       const firstParam = initialParam !== void 0 ? initialParam : 0;
-      const initialData = await this.client.fetch(infiniteKey, async () => {
+      const initialData = await this.client.fetch(infiniteKey, async (ctx) => {
         const firstPage = await opts.queryFn({ pageParam: firstParam });
         return {
           pages: [firstPage],
           pageParams: [firstParam]
         };
-      }, { fetchDirection: "initial", retry: opts.retry });
-      this.client.set(infiniteKey, initialData, {
-        staleTime: opts.staleTime,
-        cacheTime: opts.cacheTime
+      }, {
+        fetchDirection: "initial",
+        retry: opts.retry,
+        signal: signal2
       });
+      if (!signal2.aborted) {
+        this.client.set(infiniteKey, initialData, {
+          staleTime: opts.staleTime,
+          cacheTime: opts.cacheTime
+        });
+      }
     } catch (err) {
-      getLogger().error("Initial fetch failed", err);
+      if (!signal2.aborted) {
+        getLogger().error("Initial fetch failed", err);
+      }
     }
   };
   fetchNextPage = async () => {
     const res = this.result$.get();
-    const opts = this.options$.get();
     if (!res.hasNextPage || res.isFetching || !res.data) return;
+    this.cancel();
+    this.abortController = new AbortController();
+    const signal2 = this.abortController.signal;
+    const opts = this.options$.get();
     const infiniteKey = [...opts.queryKey, "__infinite__"];
     const lastPage = res.data.pages[res.data.pages.length - 1];
-    if (!lastPage) {
-      return;
-    }
+    if (!lastPage) return;
     const nextPageParam = opts.getNextPageParam?.(lastPage, res.data.pages);
     if (nextPageParam === void 0) return;
     try {
-      const updatedData = await this.client.fetch(infiniteKey, async () => {
+      const updatedData = await this.client.fetch(infiniteKey, async (ctx) => {
         const newPage = await opts.queryFn({ pageParam: nextPageParam });
+        if (ctx.signal?.aborted) throw new Error("Aborted");
         const currentData = this.client.getSignal(infiniteKey).get()?.data;
         if (!currentData) throw new Error("Infinite query data missing");
-        const updatedParams = [...currentData.pageParams, nextPageParam];
-        const nextCursor = opts.getNextPageParam?.(newPage, [...currentData.pages, newPage]);
-        if (nextCursor !== void 0) {
-          updatedParams.push(nextCursor);
-        }
         return {
           pages: [...currentData.pages, newPage],
-          pageParams: updatedParams
+          pageParams: [...currentData.pageParams, nextPageParam]
         };
-      }, { fetchDirection: "next", retry: opts.retry });
-      this.client.set(infiniteKey, updatedData, {
-        staleTime: opts.staleTime,
-        cacheTime: opts.cacheTime
+      }, {
+        fetchDirection: "next",
+        retry: opts.retry,
+        signal: signal2
       });
+      if (!signal2.aborted) {
+        this.client.set(infiniteKey, updatedData, {
+          staleTime: opts.staleTime,
+          cacheTime: opts.cacheTime
+        });
+      }
     } catch (err) {
-      getLogger().error("Fetch next page failed", err);
+      if (!signal2.aborted) {
+        getLogger().error("Fetch next page failed", err);
+      }
     }
   };
   fetchPreviousPage = async () => {
     const res = this.result$.get();
-    const opts = this.options$.get();
     if (!res.hasPreviousPage || res.isFetching || !res.data) return;
+    this.cancel();
+    this.abortController = new AbortController();
+    const signal2 = this.abortController.signal;
+    const opts = this.options$.get();
     const infiniteKey = [...opts.queryKey, "__infinite__"];
     const firstPage = res.data.pages[0];
-    if (!firstPage) {
-      return;
-    }
+    if (!firstPage) return;
     const previousPageParam = opts.getPreviousPageParam?.(firstPage, res.data.pages);
     if (previousPageParam === void 0) return;
     try {
-      const updatedData = await this.client.fetch(infiniteKey, async () => {
+      const updatedData = await this.client.fetch(infiniteKey, async (ctx) => {
         const newPage = await opts.queryFn({ pageParam: previousPageParam });
+        if (ctx.signal?.aborted) throw new Error("Aborted");
         const currentData = this.client.getSignal(infiniteKey).get()?.data;
         if (!currentData) throw new Error("Infinite query data missing");
         return {
           pages: [newPage, ...currentData.pages],
           pageParams: [previousPageParam, ...currentData.pageParams]
         };
-      }, { fetchDirection: "previous", retry: opts.retry });
-      this.client.set(infiniteKey, updatedData, {
-        staleTime: opts.staleTime,
-        cacheTime: opts.cacheTime
+      }, {
+        fetchDirection: "previous",
+        retry: opts.retry,
+        signal: signal2
       });
+      if (!signal2.aborted) {
+        this.client.set(infiniteKey, updatedData, {
+          staleTime: opts.staleTime,
+          cacheTime: opts.cacheTime
+        });
+      }
     } catch (err) {
-      getLogger().error("Fetch previous page failed", err);
+      if (!signal2.aborted) {
+        getLogger().error("Fetch previous page failed", err);
+      }
     }
   };
   refetch = async () => {
+    this.cancel();
     const opts = this.options$.get();
     const infiniteKey = [...opts.queryKey, "__infinite__"];
     this.client.invalidate(infiniteKey);
-    const initialParam = opts.initialPageParam;
-    const firstParam = initialParam !== void 0 ? initialParam : 0;
-    try {
-      const initialData = await this.client.fetch(infiniteKey, async () => {
-        const firstPage = await opts.queryFn({ pageParam: firstParam });
-        return {
-          pages: [firstPage],
-          pageParams: [firstParam]
-        };
-      }, { fetchDirection: "initial", retry: opts.retry });
-      this.client.set(infiniteKey, initialData, {
-        staleTime: opts.staleTime,
-        cacheTime: opts.cacheTime
-      });
-    } catch (err) {
-      getLogger().error("Refetch failed", err);
-    }
+    await this.fetchInitial({ force: true });
   };
   destroy() {
+    this.cancel();
     if (this.unsubscribe) this.unsubscribe();
   }
 };
@@ -2521,7 +2662,7 @@ function hydrate(client, state) {
 }
 
 // src/query/HydrationBoundary.tsx
-import { Fragment as Fragment2, jsx as jsx5 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx6 } from "react/jsx-runtime";
 function HydrationBoundary({ state, children }) {
   const client = useQueryClient();
   const hydratedRef = useRef4(false);
@@ -2529,34 +2670,7 @@ function HydrationBoundary({ state, children }) {
     hydrate(client, state);
     hydratedRef.current = true;
   }
-  return /* @__PURE__ */ jsx5(Fragment2, { children });
-}
-
-// src/query/useSuspenseQuery.ts
-function useSuspenseQuery(options) {
-  const client = useQueryClient();
-  const signal2 = client.getSignal(options.queryKey);
-  const entry = signal2.get();
-  const shouldSuspend = !entry || entry.status === "pending" && entry.data === void 0;
-  if (shouldSuspend) {
-    const fetchPromise = client.fetch(
-      options.queryKey,
-      (ctx) => options.queryFn({ ...ctx, signal: void 0 }),
-      { signal: void 0 }
-    ).then((data) => {
-      client.set(options.queryKey, data);
-      return data;
-    });
-    throw fetchPromise;
-  }
-  if (entry?.status === "error") {
-    throw entry.error;
-  }
-  const query = useQuery(options);
-  return {
-    ...query,
-    data: query.data
-  };
+  return /* @__PURE__ */ jsx6(Fragment2, { children });
 }
 
 // src/query/useQuerySignal.ts
@@ -2638,9 +2752,12 @@ function useCombinedQueries(queries, client) {
 }
 export {
   HydrationBoundary,
+  Match,
+  MutationCache,
   QuantumDevTools,
   QueryClient,
   QueryClientProvider,
+  QueryMatch,
   SignalValue,
   atom,
   createHttpClient,