@braine/quantum-query 1.3.2 → 1.3.3

package/dist/index.cjs

@@ -21,9 +21,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   HydrationBoundary: () => HydrationBoundary,
+  Match: () => Match,
+  MutationCache: () => MutationCache,
   QuantumDevTools: () => QuantumDevTools,
   QueryClient: () => QueryClient,
   QueryClientProvider: () => QueryClientProvider,
+  QueryMatch: () => QueryMatch,
   SignalValue: () => SignalValue,
   atom: () => atom,
   createHttpClient: () => createHttpClient,
@@ -37,7 +40,6 @@ __export(index_exports, {
   unwrapPromise: () => unwrapPromise,
   useCombinedQueries: () => useCombinedQueries,
   useInfiniteQuery: () => useInfiniteQuery,
-  useMutation: () => useMutation,
   usePaginatedQuery: () => usePaginatedQuery,
   useQueries: () => useQueries,
   useQuery: () => useQuery,
@@ -120,7 +122,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") {
@@ -131,27 +133,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 {
@@ -182,6 +191,19 @@ function SignalValue({ signal: signal2, render, children }) {
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: renderer(value) });
 }
 
+// src/react/QueryMatch.tsx
+var import_react2 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function QueryMatch({ signal: signal2, selector, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SignalValue, { signal: signal2, children: (value) => {
+    const selected = selector(value);
+    return children(selected);
+  } });
+}
+function Match({ signal: signal2, when, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SignalValue, { signal: signal2, children: (value) => when(value) ? children : null });
+}
+
 // src/store/scheduler.ts
 var pending = /* @__PURE__ */ new Set();
 var timer = null;
@@ -214,16 +236,16 @@ function enableDevTools(store, name = "Store") {
 }
 
 // src/devtools/index.tsx
-var import_react5 = require("react");
+var import_react6 = require("react");
 
 // src/devtools/QueryPanel.tsx
-var import_react4 = require("react");
+var import_react5 = require("react");
 
 // src/query/useQueryStore.ts
-var import_react3 = require("react");
+var import_react4 = require("react");
 
 // src/query/context.tsx
-var import_react2 = require("react");
+var import_react3 = require("react");
 
 // src/query/utils.ts
 function stableHash(value, depth = 0) {
@@ -245,41 +267,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);
+      }
+      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 true;
     }
-    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;
+    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;
     }
-    for (const key of keys) {
-      if (!isDeepEqual(objA[key], 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 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;
@@ -289,6 +360,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;
@@ -363,6 +436,7 @@ var QueryStorage = class {
       }
       this.enforceMaxSize();
     }
+    this.trie.insert(entry.key, key);
   }
   delete(key) {
     const entry = this.signals.get(key)?.get();
@@ -375,6 +449,9 @@ var QueryStorage = class {
         }
       }
     }
+    if (entry?.key) {
+      this.trie.remove(entry.key, key);
+    }
     this.signals.delete(key);
     this.lruOrder.delete(key);
     this.cancelGC(key);
@@ -399,6 +476,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();
@@ -951,11 +1029,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",
@@ -968,7 +1061,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);
@@ -986,7 +1081,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;
@@ -996,18 +1093,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 });
         }
       }
     }
@@ -1100,16 +1194,16 @@ var QueryClient = class {
 };
 
 // src/query/context.tsx
-var import_jsx_runtime2 = require("react/jsx-runtime");
-var QueryClientContext = (0, import_react2.createContext)(void 0);
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var QueryClientContext = (0, import_react3.createContext)(void 0);
 var QueryClientProvider = ({
   client,
   children
 }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(QueryClientContext.Provider, { value: client, children: children || null });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(QueryClientContext.Provider, { value: client, children: children || null });
 };
 var useQueryClient = () => {
-  const client = (0, import_react2.useContext)(QueryClientContext);
+  const client = (0, import_react3.useContext)(QueryClientContext);
   if (!client) {
     throw new Error("No QueryClient set, use QueryClientProvider to set one");
   }
@@ -1119,8 +1213,8 @@ var useQueryClient = () => {
 // src/query/useQueryStore.ts
 function useQueryStore() {
   const client = useQueryClient();
-  const [cache, setCache] = (0, import_react3.useState)(client.getAll());
-  (0, import_react3.useEffect)(() => {
+  const [cache, setCache] = (0, import_react4.useState)(client.getAll());
+  (0, import_react4.useEffect)(() => {
     const interval = setInterval(() => {
       setCache(new Map(client.getAll()));
     }, 500);
@@ -1130,13 +1224,13 @@ function useQueryStore() {
 }
 
 // src/devtools/QueryPanel.tsx
-var import_jsx_runtime3 = require("react/jsx-runtime");
+var import_jsx_runtime4 = require("react/jsx-runtime");
 function QueryPanel() {
   const cache = useQueryStore();
   const client = useQueryClient();
-  const [filter, setFilter] = (0, import_react4.useState)("");
-  const entries = (0, import_react4.useMemo)(() => Array.from(cache.entries()), [cache]);
-  const filteredEntries = (0, import_react4.useMemo)(() => {
+  const [filter, setFilter] = (0, import_react5.useState)("");
+  const entries = (0, import_react5.useMemo)(() => Array.from(cache.entries()), [cache]);
+  const filteredEntries = (0, import_react5.useMemo)(() => {
     if (!filter) return entries;
     const search = filter.toLowerCase();
     return entries.filter(([_, entry]) => {
@@ -1147,15 +1241,15 @@ function QueryPanel() {
       return JSON.stringify(key).toLowerCase().includes(search);
     });
   }, [entries, filter]);
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: { display: "flex", flexDirection: "column", height: "100%" }, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: {
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { style: { display: "flex", flexDirection: "column", height: "100%" }, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { style: {
       padding: "8px",
       borderBottom: "1px solid #222",
       background: "#0f0f0f",
       display: "flex",
       gap: "8px"
     }, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
         "input",
         {
           type: "text",
@@ -1174,7 +1268,7 @@ function QueryPanel() {
           }
         }
       ),
-      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
         "button",
         {
           onClick: () => client.invalidateAll(),
@@ -1191,7 +1285,7 @@ function QueryPanel() {
         }
       )
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: {
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { style: {
       flex: 1,
       overflowY: "auto",
       padding: "8px",
@@ -1199,7 +1293,7 @@ function QueryPanel() {
       flexDirection: "column",
       gap: "8px",
       background: "#050505"
-    }, children: entries.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: { padding: "20px", textAlign: "center", color: "#444", fontSize: "12px" }, children: "No active queries." }) : filteredEntries.map(([keyHash, entry]) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    }, children: entries.length === 0 ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { style: { padding: "20px", textAlign: "center", color: "#444", fontSize: "12px" }, children: "No active queries." }) : filteredEntries.map(([keyHash, entry]) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
       QueryItem,
       {
         entry,
@@ -1211,14 +1305,14 @@ function QueryPanel() {
   ] });
 }
 function QueryItem({ entry, client, isStale }) {
-  const [expanded, setExpanded] = (0, import_react4.useState)(false);
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: {
+  const [expanded, setExpanded] = (0, import_react5.useState)(false);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { style: {
     background: "#111",
     borderRadius: "4px",
     border: "1px solid #222",
     overflow: "hidden"
   }, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
       "div",
       {
         onClick: () => setExpanded(!expanded),
@@ -1231,13 +1325,13 @@ function QueryItem({ entry, client, isStale }) {
           background: expanded ? "#161616" : "transparent"
         },
         children: [
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: { display: "flex", gap: "8px", alignItems: "center", overflow: "hidden" }, children: [
-            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: {
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { style: { display: "flex", gap: "8px", alignItems: "center", overflow: "hidden" }, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { style: {
               color: isStale ? "#d69e2e" : "#b0fb5d",
               fontSize: "12px",
               fontWeight: "bold"
             }, children: "\u2022" }),
-            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: {
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { style: {
               color: "#e0e0e0",
               fontSize: "12px",
               whiteSpace: "nowrap",
@@ -1245,7 +1339,7 @@ function QueryItem({ entry, client, isStale }) {
               textOverflow: "ellipsis"
             }, children: JSON.stringify(entry.key) })
           ] }),
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: {
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { style: {
             fontSize: "9px",
             color: isStale ? "#d69e2e" : "#b0fb5d",
             padding: "1px 4px",
@@ -1256,13 +1350,13 @@ function QueryItem({ entry, client, isStale }) {
         ]
       }
     ),
-    expanded && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: {
+    expanded && /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { style: {
       padding: "8px",
       borderTop: "1px solid #222",
       background: "#0a0a0a"
     }, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { style: { display: "flex", gap: "8px", marginBottom: "8px" }, children: [
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { style: { display: "flex", gap: "8px", marginBottom: "8px" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
           "button",
           {
             onClick: (e) => {
@@ -1273,7 +1367,7 @@ function QueryItem({ entry, client, isStale }) {
             children: "Invalidate"
           }
         ),
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
           "button",
           {
             onClick: (e) => {
@@ -1285,19 +1379,19 @@ function QueryItem({ entry, client, isStale }) {
           }
         )
       ] }),
-      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("pre", { style: { margin: 0, fontSize: "10px", color: "#a0a0a0", overflowX: "auto", fontFamily: "monospace" }, children: JSON.stringify(entry.data, null, 2) })
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("pre", { style: { margin: 0, fontSize: "10px", color: "#a0a0a0", overflowX: "auto", fontFamily: "monospace" }, children: JSON.stringify(entry.data, null, 2) })
     ] })
   ] });
 }
 
 // src/devtools/index.tsx
-var import_jsx_runtime4 = require("react/jsx-runtime");
+var import_jsx_runtime5 = require("react/jsx-runtime");
 function QuantumDevTools() {
-  const [isOpen, setIsOpen] = (0, import_react5.useState)(false);
-  const [activeTab, setActiveTab] = (0, import_react5.useState)("queries");
-  const [height, setHeight] = (0, import_react5.useState)(400);
-  const isResizingRef = (0, import_react5.useRef)(false);
-  (0, import_react5.useEffect)(() => {
+  const [isOpen, setIsOpen] = (0, import_react6.useState)(false);
+  const [activeTab, setActiveTab] = (0, import_react6.useState)("queries");
+  const [height, setHeight] = (0, import_react6.useState)(400);
+  const isResizingRef = (0, import_react6.useRef)(false);
+  (0, import_react6.useEffect)(() => {
     const handleMouseMove = (e) => {
       if (!isResizingRef.current) return;
       const newHeight = window.innerHeight - e.clientY;
@@ -1315,7 +1409,7 @@ function QuantumDevTools() {
     };
   }, []);
   if (!isOpen) {
-    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
       "button",
       {
         onClick: () => setIsOpen(true),
@@ -1340,7 +1434,7 @@ function QuantumDevTools() {
       }
     );
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { style: {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: {
     position: "fixed",
     bottom: 0,
     right: 0,
@@ -1353,7 +1447,7 @@ function QuantumDevTools() {
     flexDirection: "column",
     fontFamily: "monospace"
   }, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
       "div",
       {
         onMouseDown: () => {
@@ -1363,7 +1457,7 @@ function QuantumDevTools() {
         style: { height: "6px", top: "-3px", position: "absolute", width: "100%", cursor: "ns-resize", zIndex: 100 }
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { style: {
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: {
       display: "flex",
       justifyContent: "space-between",
       alignItems: "center",
@@ -1371,20 +1465,20 @@ function QuantumDevTools() {
       background: "#111",
       borderBottom: "1px solid #222"
     }, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { style: { display: "flex", gap: "16px", alignItems: "center" }, children: [
-        /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { style: { color: "#b0fb5d", fontWeight: "bold" }, children: "Quantum DevTools" }),
-        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { style: { display: "flex", gap: "4px", background: "#000", padding: "2px", borderRadius: "4px" }, children: [
-          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(TabButton, { active: activeTab === "queries", onClick: () => setActiveTab("queries"), children: "Queries" }),
-          /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(TabButton, { active: activeTab === "state", onClick: () => setActiveTab("state"), children: "State" })
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: { display: "flex", gap: "16px", alignItems: "center" }, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("span", { style: { color: "#b0fb5d", fontWeight: "bold" }, children: "Quantum DevTools" }),
+        /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { style: { display: "flex", gap: "4px", background: "#000", padding: "2px", borderRadius: "4px" }, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(TabButton, { active: activeTab === "queries", onClick: () => setActiveTab("queries"), children: "Queries" }),
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(TabButton, { active: activeTab === "state", onClick: () => setActiveTab("state"), children: "State" })
         ] })
       ] }),
-      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("button", { onClick: () => setIsOpen(false), style: { background: "none", border: "none", color: "#666", cursor: "pointer" }, children: "\xD7" })
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("button", { onClick: () => setIsOpen(false), style: { background: "none", border: "none", color: "#666", cursor: "pointer" }, children: "\xD7" })
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { style: { flex: 1, overflow: "hidden" }, children: activeTab === "queries" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(QueryPanel, {}) : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { children: "State Panel (Under Construction)" }) })
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { style: { flex: 1, overflow: "hidden" }, children: activeTab === "queries" ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(QueryPanel, {}) : /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { children: "State Panel (Under Construction)" }) })
   ] });
 }
 function TabButton({ active, children, onClick }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
     "button",
     {
       onClick,
@@ -1550,6 +1644,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 {
@@ -1739,7 +1835,7 @@ function getPromiseState(promise) {
 }
 
 // src/query/pagination.ts
-var import_react6 = require("react");
+var import_react7 = require("react");
 function usePaginatedQuery({
   queryKey,
   queryFn,
@@ -1750,18 +1846,18 @@ function usePaginatedQuery({
   retry
 }) {
   const client = useQueryClient();
-  const [page, setPage] = (0, import_react6.useState)(0);
+  const [page, setPage] = (0, import_react7.useState)(0);
   const pageQueryKey = [...queryKey, "page", page];
   const pageQueryKeyHash = JSON.stringify(pageQueryKey);
-  const subscribe = (0, import_react6.useCallback)((onStoreChange) => {
+  const subscribe = (0, import_react7.useCallback)((onStoreChange) => {
     const signal2 = client.getSignal(pageQueryKey);
     return signal2.subscribe(() => onStoreChange());
   }, [client, pageQueryKeyHash]);
-  const getSnapshot = (0, import_react6.useCallback)(() => {
+  const getSnapshot = (0, import_react7.useCallback)(() => {
     const signal2 = client.getSignal(pageQueryKey);
     return signal2.get();
   }, [client, pageQueryKeyHash]);
-  const cacheEntry = (0, import_react6.useSyncExternalStore)(subscribe, getSnapshot);
+  const cacheEntry = (0, import_react7.useSyncExternalStore)(subscribe, getSnapshot);
   const data = cacheEntry?.data;
   const status = cacheEntry?.status || "pending";
   const error = cacheEntry?.error || null;
@@ -1778,15 +1874,15 @@ function usePaginatedQuery({
     }
   }
   const hasPrevious = page > 0;
-  const queryFnRef = (0, import_react6.useRef)(queryFn);
-  const staleTimeRef = (0, import_react6.useRef)(staleTime);
-  const cacheTimeRef = (0, import_react6.useRef)(cacheTime);
-  (0, import_react6.useEffect)(() => {
+  const queryFnRef = (0, import_react7.useRef)(queryFn);
+  const staleTimeRef = (0, import_react7.useRef)(staleTime);
+  const cacheTimeRef = (0, import_react7.useRef)(cacheTime);
+  (0, import_react7.useEffect)(() => {
     queryFnRef.current = queryFn;
     staleTimeRef.current = staleTime;
     cacheTimeRef.current = cacheTime;
   });
-  const fetchPage = (0, import_react6.useCallback)(async (background = false) => {
+  const fetchPage = (0, import_react7.useCallback)(async (background = false) => {
     if (!enabled) return;
     if (!background) {
       const currentEntry = getSnapshot();
@@ -1805,22 +1901,22 @@ function usePaginatedQuery({
     } catch (err) {
     }
   }, [pageQueryKeyHash, enabled, client, getSnapshot, page]);
-  (0, import_react6.useEffect)(() => {
+  (0, import_react7.useEffect)(() => {
     if (enabled) {
       fetchPage();
     }
   }, [fetchPage, enabled]);
-  const nextPage = (0, import_react6.useCallback)(() => {
+  const nextPage = (0, import_react7.useCallback)(() => {
     if (hasNext) {
       setPage((p) => p + 1);
     }
   }, [hasNext]);
-  const previousPage = (0, import_react6.useCallback)(() => {
+  const previousPage = (0, import_react7.useCallback)(() => {
     if (page > 0) {
       setPage((p) => p - 1);
     }
   }, [page]);
-  const refetch = (0, import_react6.useCallback)(async () => {
+  const refetch = (0, import_react7.useCallback)(async () => {
     client.invalidate(pageQueryKey);
     await fetchPage();
   }, [pageQueryKeyHash, fetchPage, client]);
@@ -1840,7 +1936,7 @@ function usePaginatedQuery({
 }
 
 // src/query/useQuery.ts
-var import_react7 = require("react");
+var import_react8 = require("react");
 
 // src/query/focusManager.ts
 var FocusManager = class {
@@ -1976,7 +2072,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;
       }
@@ -2098,172 +2194,52 @@ var QueryObserver = class {
 // src/query/useQuery.ts
 function useQuery(options) {
   const client = useQueryClient();
-  const [observer] = (0, import_react7.useState)(() => new QueryObserver(client, options));
-  (0, import_react7.useEffect)(() => {
+  const [observer] = (0, import_react8.useState)(() => new QueryObserver(client, options));
+  (0, import_react8.useEffect)(() => {
     observer.setOptions(options);
   }, [observer, options]);
-  (0, import_react7.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     return () => {
       observer.destroy();
     };
   }, [observer]);
-  const subscribe = (0, import_react7.useCallback)((onStoreChange) => {
+  const subscribe = (0, import_react8.useCallback)((onStoreChange) => {
     return observer.subscribe(onStoreChange);
   }, [observer]);
-  const getSnapshot = (0, import_react7.useCallback)(() => {
+  const getSnapshot = (0, import_react8.useCallback)(() => {
     return observer.getSnapshot();
   }, [observer]);
-  const result = (0, import_react7.useSyncExternalStore)(subscribe, getSnapshot);
+  const result = (0, import_react8.useSyncExternalStore)(subscribe, getSnapshot);
   return {
     ...result,
     signal: observer.result$
   };
 }
 
-// src/query/useMutation.ts
-var import_react8 = require("react");
-
-// src/query/mutationObserver.ts
-var generateId = () => {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return "mutation-" + Date.now() + "-" + Math.random().toString(36).slice(2);
-};
-var MutationObserver = class {
-  client;
-  options;
-  currentMutationId = null;
-  // We maintain our own signal for this observer's view of the mutation
-  // This ensures we don't miss updates if we switch IDs.
-  signal;
-  constructor(client, options) {
-    this.client = client;
-    this.options = options;
-    this.signal = createSignal({
-      status: "idle",
-      data: void 0,
-      error: null,
-      variables: void 0,
-      context: void 0,
-      submittedAt: 0
-    });
-  }
-  setOptions(options) {
-    this.options = 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;
   }
-  mutate = (variables) => {
-    const id = generateId();
-    this.currentMutationId = id;
-    this.client.mutationCache.register(id, this.options.mutationKey);
-    const pendingState = {
-      status: "pending",
-      variables,
-      submittedAt: Date.now(),
-      data: void 0,
-      error: null,
-      context: void 0
-    };
-    this.signal.set({
-      ...this.signal.get(),
-      ...pendingState
-    });
-    this.client.mutationCache.notify(id, pendingState);
-    const unsubscribe = this.client.mutationCache.getSignal(id).subscribe((state) => {
-      untracked(() => {
-        const current = this.signal.get();
-        if (current.status !== state.status || current.data !== state.data || current.error !== state.error) {
-          this.signal.set(state);
-        }
-      });
-    });
-    return this.executeMutation(id, variables).finally(() => {
-    });
-  };
-  executeMutation = async (id, variables) => {
-    const { mutationFn, onMutate, onSuccess, onError, onSettled, invalidatesTags, optimistic, mutationKey } = this.options;
-    let context;
-    let optimisticSnapshot;
-    const notify = (update) => {
-      this.client.mutationCache.notify(id, update);
-    };
-    try {
-      if (optimistic) {
-        const { queryKey, update } = optimistic;
-        const signal2 = this.client.getSignal(queryKey);
-        const currentData = signal2.get()?.data;
-        optimisticSnapshot = currentData;
-        const optimisticData = update(variables, currentData);
-        this.client.set(queryKey, optimisticData);
-      }
-      if (onMutate) {
-        context = await onMutate(variables);
-        notify({ context });
-      }
-      const result = await mutationFn(variables);
-      notify({ status: "success", data: result });
-      if (onSuccess) await onSuccess(result, variables, context);
-      if (this.client.invalidateTags && invalidatesTags) {
-        this.client.invalidateTags(invalidatesTags);
-      }
-      if (optimistic) {
-        this.client.invalidate(optimistic.queryKey);
-      }
-      if (onSettled) onSettled(result, null, variables, context);
-      return result;
-    } catch (error) {
-      if (optimistic && optimisticSnapshot !== void 0) {
-        this.client.set(optimistic.queryKey, optimisticSnapshot);
-      }
-      const errorObj = error instanceof Error ? error : new Error(String(error));
-      notify({ status: "error", error: errorObj });
-      if (onError) onError(errorObj, variables, context);
-      if (onSettled) onSettled(void 0, errorObj, variables, context);
-      throw error;
+  if (!entry || entry.status === "pending" && entry.data === void 0) {
+    if (entry?.promise) {
+      throw entry.promise;
     }
-  };
-  reset = () => {
-    this.signal.set({
-      status: "idle",
-      data: void 0,
-      error: null,
-      variables: void 0,
-      context: void 0,
-      submittedAt: 0
+    const fetchPromise = client.fetch(options.queryKey, options.queryFn, {
+      retry: options.retry,
+      retryDelay: options.retryDelay,
+      tags: options.tags,
+      schema: options.schema
     });
-    this.currentMutationId = null;
-  };
-};
-
-// src/query/useMutation.ts
-function useMutation(options) {
-  const client = useQueryClient();
-  const [observer] = (0, import_react8.useState)(() => new MutationObserver(client, options));
-  (0, import_react8.useEffect)(() => {
-    observer.setOptions(options);
-  }, [observer, options]);
-  const state = (0, import_react8.useSyncExternalStore)(
-    (0, import_react8.useCallback)((cb) => observer.signal.subscribe(cb), [observer]),
-    () => observer.signal.get()
-  );
-  const mutateAsync = (0, import_react8.useCallback)((variables) => {
-    return observer.mutate(variables);
-  }, [observer]);
-  const mutate = (0, import_react8.useCallback)((variables) => {
-    observer.mutate(variables).catch(() => {
-    });
-  }, [observer]);
+    throw fetchPromise;
+  }
+  const query = useQuery(options);
   return {
-    mutate,
-    mutateAsync,
-    data: state.data,
-    error: state.error,
-    status: state.status,
-    isLoading: state.status === "pending",
-    isError: state.status === "error",
-    isSuccess: state.status === "success",
-    isIdle: state.status === "idle",
-    reset: observer.reset
+    ...query,
+    data: query.data
   };
 }
 
@@ -2285,7 +2261,7 @@ var InfiniteQueryObserver = class {
   options$;
   result$;
   unsubscribe = null;
-  lastFetchTime = 0;
+  abortController = null;
   constructor(client, options) {
     this.client = client;
     this.options$ = createSignal(options);
@@ -2338,8 +2314,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;
@@ -2351,8 +2326,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);
     }
   }
@@ -2385,25 +2360,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,
@@ -2413,107 +2400,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();
   }
 };
@@ -2565,7 +2561,7 @@ function hydrate(client, state) {
 }
 
 // src/query/HydrationBoundary.tsx
-var import_jsx_runtime5 = require("react/jsx-runtime");
+var import_jsx_runtime6 = require("react/jsx-runtime");
 function HydrationBoundary({ state, children }) {
   const client = useQueryClient();
   const hydratedRef = (0, import_react10.useRef)(false);
@@ -2573,34 +2569,7 @@ function HydrationBoundary({ state, children }) {
     hydrate(client, state);
     hydratedRef.current = true;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_jsx_runtime5.Fragment, { 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__ */ (0, import_jsx_runtime6.jsx)(import_jsx_runtime6.Fragment, { children });
 }
 
 // src/query/useQuerySignal.ts
@@ -2683,9 +2652,12 @@ function useCombinedQueries(queries, client) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HydrationBoundary,
+  Match,
+  MutationCache,
   QuantumDevTools,
   QueryClient,
   QueryClientProvider,
+  QueryMatch,
   SignalValue,
   atom,
   createHttpClient,
@@ -2699,7 +2671,6 @@ function useCombinedQueries(queries, client) {
   unwrapPromise,
   useCombinedQueries,
   useInfiniteQuery,
-  useMutation,
   usePaginatedQuery,
   useQueries,
   useQuery,