@braine/quantum-query 1.2.6 → 1.2.7

package/dist/index.cjs

@@ -21,302 +21,34 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   HydrationBoundary: () => HydrationBoundary,
-  QueryCache: () => QueryCache,
+  QueryClient: () => QueryClient,
   QueryClientProvider: () => QueryClientProvider,
-  computed: () => computed,
+  SignalValue: () => SignalValue,
+  atom: () => atom,
   createHttpClient: () => createHttpClient,
-  createState: () => createState,
-  defineModel: () => defineModel,
   dehydrate: () => dehydrate,
   enableDevTools: () => enableDevTools,
-  fromSignal: () => fromSignal,
   getPromiseState: () => getPromiseState,
   handlePromise: () => handlePromise,
   hydrate: () => hydrate,
   isPromise: () => isPromise,
   scheduleUpdate: () => scheduleUpdate,
-  subscribe: () => subscribe,
-  toSignal: () => toSignal,
   unwrapPromise: () => unwrapPromise,
   useInfiniteQuery: () => useInfiniteQuery,
   useMutation: () => useMutation,
   usePaginatedQuery: () => usePaginatedQuery,
   useQuery: () => useQuery,
+  useQuery$: () => useQuery$,
   useQueryClient: () => useQueryClient,
-  useStore: () => useStore,
+  useQueryStore: () => useQueryStore,
   useSuspenseQuery: () => useSuspenseQuery
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/core/scheduler.ts
-var pending = /* @__PURE__ */ new Set();
-var timer = null;
-function flush() {
-  timer = null;
-  const tasks = [...pending];
-  pending.clear();
-  tasks.forEach((task) => task());
-}
-function scheduleUpdate(callback) {
-  pending.add(callback);
-  if (!timer) {
-    timer = Promise.resolve().then(flush);
-  }
-}
-
-// src/core/asyncUtils.ts
-var PROMISE_CACHE = /* @__PURE__ */ new WeakMap();
-var PROMISE_STATUS = /* @__PURE__ */ new WeakMap();
-var PROMISE_ERROR = /* @__PURE__ */ new WeakMap();
-function isPromise(value) {
-  return !!value && typeof value.then === "function";
-}
-function handlePromise(promise, triggerUpdate) {
-  if (PROMISE_STATUS.has(promise)) return;
-  PROMISE_STATUS.set(promise, "pending");
-  promise.then(
-    (value) => {
-      PROMISE_STATUS.set(promise, "fulfilled");
-      PROMISE_CACHE.set(promise, value);
-      triggerUpdate();
-    },
-    (error) => {
-      PROMISE_STATUS.set(promise, "rejected");
-      PROMISE_ERROR.set(promise, error);
-      triggerUpdate();
-    }
-  );
-}
-function unwrapPromise(promise) {
-  const status = PROMISE_STATUS.get(promise);
-  if (status === "fulfilled") {
-    return PROMISE_CACHE.get(promise);
-  } else if (status === "rejected") {
-    throw PROMISE_ERROR.get(promise);
-  } else {
-    throw promise;
-  }
-}
-function getPromiseState(promise) {
-  return {
-    status: PROMISE_STATUS.get(promise) || "pending",
-    value: PROMISE_CACHE.get(promise),
-    error: PROMISE_ERROR.get(promise)
-  };
-}
-
-// src/core/proxy.ts
-var LISTENERS = /* @__PURE__ */ new WeakMap();
-var PROXIES = /* @__PURE__ */ new WeakMap();
-var PROXY_TO_TARGET = /* @__PURE__ */ new WeakMap();
-var activeListener = null;
-function setActiveListener(listener) {
-  activeListener = listener;
-}
-function getActiveListener() {
-  return activeListener;
-}
-var GLOBAL_LISTENERS = /* @__PURE__ */ new WeakMap();
-function subscribe(store, callback) {
-  const target = PROXY_TO_TARGET.get(store) || store;
-  let listeners = GLOBAL_LISTENERS.get(target);
-  if (!listeners) {
-    listeners = /* @__PURE__ */ new Set();
-    GLOBAL_LISTENERS.set(target, listeners);
-  }
-  listeners.add(callback);
-  return () => listeners?.delete(callback);
-}
-var handler = {
-  get(target, prop, receiver) {
-    if (activeListener) {
-      let listeners = LISTENERS.get(target);
-      if (!listeners) {
-        listeners = /* @__PURE__ */ new Set();
-        LISTENERS.set(target, listeners);
-      }
-      listeners.add(activeListener);
-    }
-    const value = Reflect.get(target, prop, receiver);
-    if (isPromise(value)) {
-      return unwrapPromise(value);
-    }
-    if (typeof value === "object" && value !== null) {
-      return createState(value);
-    }
-    return value;
-  },
-  set(target, prop, value, receiver) {
-    const oldValue = Reflect.get(target, prop, receiver);
-    if (Object.is(oldValue, value)) return true;
-    if (isPromise(value)) {
-      const trigger = () => {
-        const listeners2 = LISTENERS.get(target);
-        if (listeners2) listeners2.forEach((l) => l());
-      };
-      handlePromise(value, trigger);
-    }
-    const result = Reflect.set(target, prop, value, receiver);
-    const listeners = LISTENERS.get(target);
-    if (listeners) {
-      listeners.forEach((l) => l());
-    }
-    const globals = GLOBAL_LISTENERS.get(target);
-    if (globals) {
-      globals.forEach((cb) => cb(target, prop, value));
-    }
-    return result;
-  },
-  deleteProperty(target, prop) {
-    const result = Reflect.deleteProperty(target, prop);
-    const listeners = LISTENERS.get(target);
-    if (listeners) {
-      listeners.forEach((l) => l());
-    }
-    return result;
-  }
-};
-function createState(initialState) {
-  if (PROXIES.has(initialState)) {
-    return PROXIES.get(initialState);
-  }
-  const proxy = new Proxy(initialState, handler);
-  PROXIES.set(initialState, proxy);
-  PROXY_TO_TARGET.set(proxy, initialState);
-  return proxy;
-}
-
-// src/core/model.ts
-function debounce(fn, ms) {
-  let timeout;
-  return (...args) => {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => fn(...args), ms);
-  };
-}
-function defineModel(def) {
-  const target = def.state;
-  if (def.actions) {
-    for (const [key, fn] of Object.entries(def.actions)) {
-      target[key] = fn;
-    }
-  }
-  if (def.computed) {
-    for (const [key, getter] of Object.entries(def.computed)) {
-      if (typeof getter === "function") {
-        Object.defineProperty(target, key, {
-          get: function() {
-            return getter.call(this);
-          },
-          enumerable: true,
-          configurable: true
-        });
-      }
-    }
-  }
-  const proxy = createState(target);
-  if (def.persist) {
-    const { key, storage = "local", paths, debug } = def.persist;
-    let engine = null;
-    if (typeof storage === "string") {
-      if (typeof window !== "undefined") {
-        engine = storage === "local" ? window.localStorage : window.sessionStorage;
-      }
-    } else {
-      engine = storage;
-    }
-    if (engine) {
-      const hydrate2 = () => {
-        const process = (stored) => {
-          try {
-            if (stored) {
-              const parsed = JSON.parse(stored);
-              Object.assign(proxy, parsed);
-              if (debug) console.log(`[Quantum] Hydrated '${key}'`, parsed);
-            }
-          } catch (err) {
-            if (debug) console.error(`[Quantum] Hydration Failed for '${key}'`, err);
-          }
-        };
-        try {
-          const result = engine.getItem(key);
-          if (result instanceof Promise) {
-            result.then(process);
-          } else {
-            process(result);
-          }
-        } catch (err) {
-          if (debug) console.error(`[Quantum] Storage Access Failed`, err);
-        }
-      };
-      hydrate2();
-      const save = debounce(async () => {
-        try {
-          let stateToSave;
-          if (paths) {
-            stateToSave = {};
-            for (const p of paths) {
-              stateToSave[p] = proxy[p];
-            }
-          } else {
-            stateToSave = {};
-            const keys = Object.keys(def.state);
-            for (const k of keys) {
-              stateToSave[k] = proxy[k];
-            }
-          }
-          const serialized = JSON.stringify(stateToSave);
-          await engine.setItem(key, serialized);
-          if (debug) console.log(`[Quantum] Saved '${key}'`);
-        } catch (err) {
-        }
-      }, 100);
-      subscribe(proxy, () => {
-        save();
-      });
-    }
-  }
-  return proxy;
-}
-
-// src/react/autoHook.ts
-var import_react = require("react");
-function useStore(store) {
-  const versionRef = (0, import_react.useRef)(0);
-  const notifyRef = (0, import_react.useRef)(void 0);
-  const listener = (0, import_react.useCallback)(() => {
-    versionRef.current++;
-    if (notifyRef.current) {
-      notifyRef.current();
-    }
-  }, []);
-  const subscribe2 = (0, import_react.useCallback)((onStoreChange) => {
-    notifyRef.current = onStoreChange;
-    return () => {
-      notifyRef.current = void 0;
-    };
-  }, []);
-  const getSnapshot = (0, import_react.useCallback)(() => versionRef.current, []);
-  (0, import_react.useSyncExternalStore)(subscribe2, getSnapshot, getSnapshot);
-  const proxy = new Proxy(store, {
-    get(target, prop, receiver) {
-      const prev = getActiveListener();
-      setActiveListener(listener);
-      try {
-        return Reflect.get(target, prop, receiver);
-      } finally {
-        setActiveListener(prev);
-      }
-    }
-  });
-  return proxy;
-}
-
-// src/addon/signals.ts
+// src/signals.ts
 var import_signals_core = require("@preact/signals-core");
 function createSignal(initialValue, options) {
   const s = (0, import_signals_core.signal)(initialValue);
-  let unsubscribeActive;
   let subscriberCount = 0;
   return {
     get: () => s.value,
@@ -338,9 +70,122 @@ function createSignal(initialValue, options) {
           options?.onInactive?.();
         }
       };
-    }
+    },
+    isWatched: () => subscriberCount > 0
   };
 }
+function computed(fn) {
+  const c = (0, import_signals_core.computed)(fn);
+  let subscriberCount = 0;
+  return {
+    get: () => c.value,
+    set: () => {
+      throw new Error("[Quantum] Cannot set a computed signal directly.");
+    },
+    subscribe: (fn2) => {
+      subscriberCount++;
+      const dispose = (0, import_signals_core.effect)(() => {
+        fn2(c.value);
+      });
+      return () => {
+        dispose();
+        subscriberCount--;
+      };
+    },
+    isWatched: () => subscriberCount > 0
+  };
+}
+function effect(fn) {
+  return (0, import_signals_core.effect)(fn);
+}
+function untracked(fn) {
+  return (0, import_signals_core.untracked)(fn);
+}
+
+// src/store/model.ts
+function atom(initialValue, options) {
+  const s = createSignal(initialValue);
+  if (options?.key) {
+    setupPersistence(s, options);
+  }
+  return s;
+}
+function setupPersistence(s, options) {
+  const { key, storage = "local", debug } = options;
+  if (!key) return;
+  let engine = null;
+  if (typeof storage === "string") {
+    if (typeof window !== "undefined") {
+      engine = storage === "local" ? window.localStorage : window.sessionStorage;
+    }
+  } else {
+    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);
+      }
+    };
+    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);
+  }
+  s.subscribe((value) => {
+    try {
+      const serialized = JSON.stringify(value);
+      engine.setItem(key, serialized);
+      if (debug) console.log(`[Quantum] Saved atom '${key}'`);
+    } catch (err) {
+      if (debug) console.error(`[Quantum] Save error`, err);
+    }
+  });
+}
+
+// src/react/SignalValue.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+function SignalValue({ signal: signal2, render, children }) {
+  const [value, setValue] = (0, import_react.useState)(() => signal2.get());
+  (0, import_react.useEffect)(() => {
+    const unsubscribe = signal2.subscribe((newValue) => {
+      setValue(newValue);
+    });
+    return () => unsubscribe();
+  }, [signal2]);
+  const renderer = render || children;
+  if (!renderer) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: renderer(value) });
+}
+
+// src/store/scheduler.ts
+var pending = /* @__PURE__ */ new Set();
+var timer = null;
+function flush() {
+  timer = null;
+  const tasks = [...pending];
+  pending.clear();
+  tasks.forEach((task) => task());
+}
+function scheduleUpdate(callback) {
+  pending.add(callback);
+  if (!timer) {
+    timer = Promise.resolve().then(flush);
+  }
+}
 
 // src/devtools/registry.ts
 var stores = createSignal([]);
@@ -354,30 +199,10 @@ function registerStore(store, name = "Store") {
 // src/middleware/devtools.ts
 function enableDevTools(store, name = "Store") {
   registerStore(store, name);
-  if (typeof window === "undefined" || !window.__REDUX_DEVTOOLS_EXTENSION__) return;
-  const devTools = window.__REDUX_DEVTOOLS_EXTENSION__.connect({ name });
-  devTools.init(store);
-  subscribe(store, (target, prop, value) => {
-    devTools.send({ type: `SET_${String(prop)}`, payload: value }, store);
-  });
-}
-
-// src/core/computed.ts
-function computed(fn) {
-  let value;
-  let dirty = true;
-  return {
-    get value() {
-      if (dirty) {
-        value = fn();
-        dirty = false;
-      }
-      return value;
-    }
-  };
+  console.warn("DevTools for Signals are WIP");
 }
 
-// src/addon/clientTypes.ts
+// src/clientTypes.ts
 var HttpError = class extends Error {
   constructor(status, message) {
     super(message);
@@ -386,7 +211,7 @@ var HttpError = class extends Error {
   }
 };
 
-// src/addon/middleware/types.ts
+// src/middleware/types.ts
 function compose(middleware) {
   return (ctx, next) => {
     let index = -1;
@@ -405,7 +230,7 @@ function compose(middleware) {
   };
 }
 
-// src/addon/middleware/dedupe.ts
+// src/middleware/dedupe.ts
 var DedupeMiddleware = async (ctx, next) => {
   if (ctx.req.method !== "GET") {
     return next(ctx);
@@ -431,10 +256,10 @@ var DedupeMiddleware = async (ctx, next) => {
   }
 };
 
-// src/addon/middleware/cache.ts
+// src/middleware/cache.ts
 var CacheMiddleware = async (ctx, next) => {
   const { method, url } = ctx.req;
-  const { cache: cacheConfig } = ctx.config;
+  const cacheConfig = typeof ctx.config.cache === "object" ? ctx.config.cache : void 0;
   if (method !== "GET" || !cacheConfig?.ttl || cacheConfig.force) {
     return next(ctx);
   }
@@ -467,7 +292,7 @@ var CacheMiddleware = async (ctx, next) => {
   return response;
 };
 
-// src/addon/middleware/auth.ts
+// src/middleware/auth.ts
 var AuthMiddleware = async (ctx, next) => {
   const { auth } = ctx.client.config;
   if (auth && auth.getToken && !ctx.req.headers.get("Authorization")) {
@@ -512,7 +337,7 @@ var AuthMiddleware = async (ctx, next) => {
   return response;
 };
 
-// src/addon/middleware/fetch.ts
+// src/middleware/fetch.ts
 var FetchMiddleware = async (ctx) => {
   return fetch(ctx.req);
 };
@@ -550,7 +375,7 @@ var RetryMiddleware = async (ctx, next) => {
   return attempt(0);
 };
 
-// src/addon/httpClient.ts
+// src/httpClient.ts
 function createHttpClient(config) {
   const cache = /* @__PURE__ */ new Map();
   const inflight = /* @__PURE__ */ new Map();
@@ -585,15 +410,17 @@ function createHttpClient(config) {
           controller.abort();
         });
       }
+      const { cache: _c, schema: _s, timeout: _t, retry: _r, ...fetchOptions } = options;
       let req = new Request(url, {
-        ...options,
+        ...fetchOptions,
         headers,
         signal: controller.signal
       });
       if (config.interceptors?.request) {
         const newConfig = await config.interceptors.request({ ...options, headers: Object.fromEntries(headers) });
+        const { cache: _nc, schema: _ns, timeout: _nt, retry: _nr, ...newFetchOptions } = newConfig;
         req = new Request(url, {
-          ...newConfig,
+          ...newFetchOptions,
           signal: controller.signal
         });
       }
@@ -634,8 +461,9 @@ function createHttpClient(config) {
             if (options.schema.parse) return options.schema.parse(data);
             if (options.schema.validateSync) return options.schema.validateSync(data);
           } catch (error) {
-            if (error.errors || error.name === "ZodError" || error.name === "ValidationError") {
-              throw new Error(`Validation Error: ${JSON.stringify(error.errors || error.message)}`);
+            const err = error;
+            if (err.errors || err.name === "ZodError" || err.name === "ValidationError") {
+              throw new Error(`Validation Error: ${JSON.stringify(err.errors || err.message)}`);
             }
             throw error;
           }
@@ -665,56 +493,168 @@ function createHttpClient(config) {
   return client;
 }
 
-// src/addon/query/utils.ts
-function stableHash(value) {
-  if (value === null || typeof value !== "object") {
-    return String(value);
+// src/store/asyncUtils.ts
+var PROMISE_CACHE = /* @__PURE__ */ new WeakMap();
+var PROMISE_STATUS = /* @__PURE__ */ new WeakMap();
+var PROMISE_ERROR = /* @__PURE__ */ new WeakMap();
+function isPromise(value) {
+  return !!value && typeof value.then === "function";
+}
+function handlePromise(promise, triggerUpdate) {
+  if (PROMISE_STATUS.has(promise)) return;
+  PROMISE_STATUS.set(promise, "pending");
+  promise.then(
+    (value) => {
+      PROMISE_STATUS.set(promise, "fulfilled");
+      PROMISE_CACHE.set(promise, value);
+      triggerUpdate();
+    },
+    (error) => {
+      PROMISE_STATUS.set(promise, "rejected");
+      PROMISE_ERROR.set(promise, error);
+      triggerUpdate();
+    }
+  );
+}
+function unwrapPromise(promise) {
+  const status = PROMISE_STATUS.get(promise);
+  if (status === "fulfilled") {
+    return PROMISE_CACHE.get(promise);
+  } else if (status === "rejected") {
+    throw PROMISE_ERROR.get(promise);
+  } else {
+    throw promise;
+  }
+}
+function getPromiseState(promise) {
+  return {
+    status: PROMISE_STATUS.get(promise) || "pending",
+    value: PROMISE_CACHE.get(promise),
+    error: PROMISE_ERROR.get(promise)
+  };
+}
+
+// src/query/utils.ts
+function stableHash(value, depth = 0) {
+  if (depth > 15) {
+    throw new Error("[Quantum] Query key is too deeply nested. Max depth is 15.");
+  }
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value !== "object") {
+    const strValue = String(value);
+    if (strValue.length > 1e3) {
+      return `${typeof value}:[large-string:${strValue.slice(0, 10)}...]`;
+    }
+    return `${typeof value}:${strValue}`;
   }
   if (Array.isArray(value)) {
-    return "[" + value.map(stableHash).join(",") + "]";
+    return `array:[${value.map((v) => stableHash(v, depth + 1)).join(",")}]`;
   }
   const keys = Object.keys(value).sort();
-  return "{" + keys.map((key) => `${key}:${stableHash(value[key])}`).join(",") + "}";
+  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)) {
+      const arrA = a;
+      const arrB = b;
+      length = arrA.length;
+      if (length !== arrB.length) return false;
+      for (i = length; i-- !== 0; ) {
+        if (!isDeepEqual(arrA[i], arrB[i])) return false;
+      }
+      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;
+    }
+    for (const key of keys) {
+      if (!isDeepEqual(objA[key], objB[key])) return false;
+    }
+    return true;
+  }
+  return a !== a && b !== b;
 }
 
-// src/addon/query/queryStorage.ts
+// src/query/queryStorage.ts
 var QueryStorage = class {
+  // Tracks access order (least to most recent)
   // Default configuration
-  constructor(defaultStaleTime = 0, defaultCacheTime = 5 * 60 * 1e3) {
+  constructor(defaultStaleTime = 0, defaultCacheTime = 5 * 60 * 1e3, maxSize = 100) {
     this.defaultStaleTime = defaultStaleTime;
     this.defaultCacheTime = defaultCacheTime;
+    this.maxSize = maxSize;
   }
   signals = /* @__PURE__ */ new Map();
   gcTimers = /* @__PURE__ */ new Map();
+  lruOrder = /* @__PURE__ */ new Set();
   generateKey(queryKey) {
     const key = Array.isArray(queryKey) ? stableHash(queryKey) : stableHash([queryKey.key, queryKey.params]);
     return key;
   }
   get(key, autoCreate = true) {
     let signal2 = this.signals.get(key);
+    if (signal2) {
+      this.touch(key);
+    }
     if (!signal2 && autoCreate) {
       const newSignal = createSignal(void 0, {
         onActive: () => {
           this.cancelGC(key);
         },
         onInactive: () => {
-          const entry = this.signals.get(key)?.get();
-          const cacheTime = entry?.cacheTime ?? this.defaultCacheTime;
+          const currentEntry = this.signals.get(key)?.get();
+          const cacheTime = currentEntry?.cacheTime ?? this.defaultCacheTime;
           this.scheduleGC(key, cacheTime);
         }
       });
       this.signals.set(key, newSignal);
+      this.touch(key);
+      if (!newSignal.isWatched()) {
+        this.scheduleGC(key, this.defaultCacheTime);
+      }
+      this.enforceMaxSize();
       signal2 = newSignal;
     }
-    if (!signal2) return void 0;
     return signal2;
   }
+  tagIndex = /* @__PURE__ */ new Map();
   set(key, entry) {
-    const signal2 = this.signals.get(key);
+    this.touch(key);
+    const oldEntry = this.signals.get(key)?.get();
+    if (oldEntry?.tags) {
+      for (const tag of oldEntry.tags) {
+        const set = this.tagIndex.get(tag);
+        if (set) {
+          set.delete(key);
+          if (set.size === 0) this.tagIndex.delete(tag);
+        }
+      }
+    }
+    if (entry.tags) {
+      for (const tag of entry.tags) {
+        if (!this.tagIndex.has(tag)) {
+          this.tagIndex.set(tag, /* @__PURE__ */ new Set());
+        }
+        this.tagIndex.get(tag).add(key);
+      }
+    }
+    let signal2 = this.signals.get(key);
     if (signal2) {
       signal2.set(entry);
     } else {
-      this.signals.set(key, createSignal(entry, {
+      const newSignal = createSignal(entry, {
         onActive: () => {
           this.cancelGC(key);
         },
@@ -723,15 +663,50 @@ var QueryStorage = class {
           const cacheTime = entry2?.cacheTime ?? this.defaultCacheTime;
           this.scheduleGC(key, cacheTime);
         }
-      }));
+      });
+      this.signals.set(key, newSignal);
+      if (!newSignal.isWatched()) {
+        this.scheduleGC(key, entry.cacheTime ?? this.defaultCacheTime);
+      }
+      this.enforceMaxSize();
     }
   }
   delete(key) {
+    const entry = this.signals.get(key)?.get();
+    if (entry?.tags) {
+      for (const tag of entry.tags) {
+        const set = this.tagIndex.get(tag);
+        if (set) {
+          set.delete(key);
+          if (set.size === 0) this.tagIndex.delete(tag);
+        }
+      }
+    }
     this.signals.delete(key);
+    this.lruOrder.delete(key);
     this.cancelGC(key);
   }
+  touch(key) {
+    this.lruOrder.delete(key);
+    this.lruOrder.add(key);
+  }
+  enforceMaxSize() {
+    if (this.signals.size <= this.maxSize) return;
+    for (const key of this.lruOrder) {
+      const signal2 = this.signals.get(key);
+      if (signal2 && !signal2.isWatched()) {
+        this.delete(key);
+        if (this.signals.size <= this.maxSize) break;
+      }
+    }
+  }
+  getKeysByTag(tag) {
+    return this.tagIndex.get(tag);
+  }
   clear() {
     this.signals.clear();
+    this.tagIndex.clear();
+    this.lruOrder.clear();
     this.gcTimers.forEach((timer2) => clearTimeout(timer2));
     this.gcTimers.clear();
   }
@@ -746,11 +721,19 @@ var QueryStorage = class {
   getStats() {
     return {
       size: this.signals.size,
-      keys: Array.from(this.signals.keys())
+      keys: Array.from(this.signals.keys()),
+      tags: this.tagIndex.size
     };
   }
   getSnapshot() {
-    return this.signals;
+    const snapshot = /* @__PURE__ */ new Map();
+    for (const [key, signal2] of this.signals.entries()) {
+      const value = signal2.get();
+      if (value) {
+        snapshot.set(key, value);
+      }
+    }
+    return snapshot;
   }
   // --- GC Logic ---
   scheduleGC(key, delay2) {
@@ -770,7 +753,7 @@ var QueryStorage = class {
   }
 };
 
-// src/addon/query/remotes.ts
+// src/query/remotes.ts
 var QueryRemotes = class {
   deduplicationCache = /* @__PURE__ */ new Map();
   async fetch(key, fn, options) {
@@ -833,7 +816,7 @@ var QueryRemotes = class {
   }
 };
 
-// src/addon/query/mutationCache.ts
+// src/query/mutationCache.ts
 var MutationCache = class {
   // Map<ID, Signal> - Stores state for every unique mutation execution
   mutations = /* @__PURE__ */ new Map();
@@ -912,9 +895,13 @@ var MutationCache = class {
   };
 };
 
-// src/addon/query/pluginManager.ts
+// src/query/pluginManager.ts
 var PluginManager = class {
   plugins = [];
+  client;
+  setClient(client) {
+    this.client = client;
+  }
   add(plugin) {
     this.plugins.push(plugin);
   }
@@ -935,8 +922,16 @@ var PluginManager = class {
   }
 };
 
-// src/addon/query/queryCache.ts
-var QueryCache = class {
+// src/query/plugins/validation.ts
+function validateWithSchema(data, schema) {
+  if (!schema) {
+    return data;
+  }
+  return schema.parse(data);
+}
+
+// src/query/queryClient.ts
+var QueryClient = class {
   // Components
   storage;
   remotes;
@@ -947,11 +942,18 @@ var QueryCache = class {
   // Config defaults
   defaultStaleTime;
   defaultCacheTime;
+  defaultSchema;
   constructor(config) {
     this.defaultStaleTime = config?.defaultStaleTime ?? 0;
     this.defaultCacheTime = config?.defaultCacheTime ?? 5 * 60 * 1e3;
-    this.storage = new QueryStorage(this.defaultStaleTime, this.defaultCacheTime);
+    this.defaultSchema = config?.defaultSchema;
+    this.storage = new QueryStorage(
+      this.defaultStaleTime,
+      this.defaultCacheTime,
+      config?.maxCacheSize
+    );
     this.remotes = new QueryRemotes();
+    this.pluginManager.setClient(this);
   }
   // --- FACADE API ---
   /**
@@ -962,7 +964,7 @@ var QueryCache = class {
     const signal2 = this.storage.get(key, false);
     if (!signal2) return void 0;
     const entry = signal2.get();
-    if (!entry) return void 0;
+    if (!this.isCacheEntry(entry)) return void 0;
     const now = Date.now();
     const age = now - entry.timestamp;
     if (age > entry.cacheTime) {
@@ -1017,18 +1019,18 @@ var QueryCache = class {
     const direction = options?.fetchDirection || "initial";
     const signal2 = this.storage.get(key, true);
     const currentEntry = signal2.get();
+    const mergedTags = options?.tags ?? currentEntry?.tags;
     this.storage.set(key, {
       data: currentEntry?.data,
       status: currentEntry?.status || "pending",
       error: null,
       isFetching: true,
-      // Mark fetching
       fetchDirection: direction,
       timestamp: currentEntry?.timestamp || Date.now(),
       staleTime: currentEntry?.staleTime ?? this.defaultStaleTime,
       cacheTime: currentEntry?.cacheTime ?? this.defaultCacheTime,
       key: queryKey,
-      tags: currentEntry?.tags
+      tags: mergedTags
     });
     this.pluginManager.onFetchStart(normalizedKey);
     try {
@@ -1037,21 +1039,40 @@ var QueryCache = class {
         retry: options?.retry,
         retryDelay: options?.retryDelay
       });
-      this.pluginManager.onFetchSuccess(normalizedKey, data);
-      return data;
+      this.storage.set(key, {
+        data,
+        status: "success",
+        error: null,
+        isFetching: false,
+        isInvalidated: void 0,
+        // Clear invalidation on success
+        fetchDirection: "idle",
+        timestamp: Date.now(),
+        staleTime: currentEntry?.staleTime ?? this.defaultStaleTime,
+        cacheTime: currentEntry?.cacheTime ?? this.defaultCacheTime,
+        key: queryKey,
+        tags: mergedTags
+      });
+      const schema = options?.schema || this.defaultSchema;
+      const validatedData = validateWithSchema(data, schema);
+      this.pluginManager.onFetchSuccess(normalizedKey, validatedData);
+      return validatedData;
     } catch (error) {
-      const current = signal2.get();
-      if (current) {
-        this.storage.set(key, {
-          ...current,
-          status: "error",
-          error,
-          isFetching: false,
-          fetchDirection: "idle"
-        });
-      }
-      this.pluginManager.onFetchError(normalizedKey, error);
-      throw error;
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.storage.set(key, {
+        data: currentEntry?.data,
+        status: "error",
+        error: err,
+        isFetching: false,
+        fetchDirection: "idle",
+        timestamp: currentEntry?.timestamp || Date.now(),
+        staleTime: currentEntry?.staleTime ?? this.defaultStaleTime,
+        cacheTime: currentEntry?.cacheTime ?? this.defaultCacheTime,
+        key: queryKey,
+        tags: mergedTags
+      });
+      this.pluginManager.onFetchError(normalizedKey, err);
+      throw err;
     }
   };
   /**
@@ -1076,12 +1097,17 @@ var QueryCache = class {
   };
   invalidateTags = (tags) => {
     const tagsToInvalidate = new Set(tags);
-    const snapshot = this.storage.getSnapshot();
-    for (const [key, signal2] of snapshot.entries()) {
-      const entry = signal2.get();
-      if (entry && entry.tags) {
-        if (entry.tags.some((tag) => tagsToInvalidate.has(tag))) {
-          signal2.set({ ...entry, isInvalidated: true });
+    for (const tag of tagsToInvalidate) {
+      const keys = this.storage.getKeysByTag(tag);
+      if (keys) {
+        for (const key of keys) {
+          const signal2 = this.storage.get(key, false);
+          if (signal2) {
+            const current = signal2.get();
+            if (current) {
+              signal2.set({ ...current, isInvalidated: true });
+            }
+          }
         }
       }
     }
@@ -1114,8 +1140,9 @@ var QueryCache = class {
   // For Hydration
   getSnapshot = () => this.storage.getSnapshot();
   invalidateAll = () => {
-    for (const key of this.storage.getSnapshot().keys()) {
-      const signal2 = this.storage.get(key);
+    const snapshot = this.storage.getSnapshot();
+    for (const key of snapshot.keys()) {
+      const signal2 = this.storage.get(key, false);
       const entry = signal2?.get();
       if (entry) {
         signal2?.set({ ...entry, isInvalidated: true });
@@ -1125,20 +1152,30 @@ var QueryCache = class {
   normalizeKey(queryKey) {
     return Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
   }
+  isCacheEntry(entry) {
+    return entry !== null && typeof entry === "object" && "status" in entry && "timestamp" in entry;
+  }
+  // --- DEBUGGER API (For DevTools) ---
+  debugSet = (key, data) => {
+    this.set(key, data);
+  };
+  debugInvalidate = (key) => {
+    this.invalidate(key);
+  };
 };
 
-// src/addon/query/pagination.ts
+// src/query/pagination.ts
 var import_react3 = require("react");
 
-// src/addon/query/context.tsx
+// src/query/context.tsx
 var import_react2 = require("react");
-var import_jsx_runtime = require("react/jsx-runtime");
+var import_jsx_runtime2 = require("react/jsx-runtime");
 var QueryClientContext = (0, import_react2.createContext)(void 0);
 var QueryClientProvider = ({
   client,
   children
 }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(QueryClientContext.Provider, { value: client, children });
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(QueryClientContext.Provider, { value: client, children: children || null });
 };
 var useQueryClient = () => {
   const client = (0, import_react2.useContext)(QueryClientContext);
@@ -1148,7 +1185,7 @@ var useQueryClient = () => {
   return client;
 };
 
-// src/addon/query/pagination.ts
+// src/query/pagination.ts
 function usePaginatedQuery({
   queryKey,
   queryFn,
@@ -1162,7 +1199,7 @@ function usePaginatedQuery({
   const [page, setPage] = (0, import_react3.useState)(0);
   const pageQueryKey = [...queryKey, "page", page];
   const pageQueryKeyHash = JSON.stringify(pageQueryKey);
-  const subscribe2 = (0, import_react3.useCallback)((onStoreChange) => {
+  const subscribe = (0, import_react3.useCallback)((onStoreChange) => {
     const signal2 = client.getSignal(pageQueryKey);
     return signal2.subscribe(() => onStoreChange());
   }, [client, pageQueryKeyHash]);
@@ -1170,7 +1207,7 @@ function usePaginatedQuery({
     const signal2 = client.getSignal(pageQueryKey);
     return signal2.get();
   }, [client, pageQueryKeyHash]);
-  const cacheEntry = (0, import_react3.useSyncExternalStore)(subscribe2, getSnapshot);
+  const cacheEntry = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot);
   const data = cacheEntry?.data;
   const status = cacheEntry?.status || "pending";
   const error = cacheEntry?.error || null;
@@ -1183,7 +1220,7 @@ function usePaginatedQuery({
     if (Array.isArray(data)) {
       hasNext = data.length === pageSize;
     } else if (typeof data === "object" && "hasMore" in data) {
-      hasNext = data.hasMore;
+      hasNext = !!data.hasMore;
     }
   }
   const hasPrevious = page > 0;
@@ -1248,289 +1285,263 @@ function usePaginatedQuery({
   };
 }
 
-// src/addon/query/useQuery.ts
+// src/query/useQuery.ts
 var import_react4 = require("react");
 
-// src/addon/query/plugins/validation.ts
-function validateWithSchema(data, schema) {
-  if (!schema) {
-    return data;
+// src/query/focusManager.ts
+var FocusManager = class {
+  listeners = /* @__PURE__ */ new Set();
+  focused = true;
+  unsubscribe = null;
+  constructor() {
+    if (typeof window !== "undefined" && window.addEventListener) {
+      const handleFocus = () => {
+        this.focused = true;
+        this.onFocus();
+      };
+      const handleBlur = () => {
+        this.focused = false;
+      };
+      window.addEventListener("focus", handleFocus, false);
+      window.addEventListener("visibilitychange", handleFocus, false);
+      window.addEventListener("blur", handleBlur, false);
+      this.unsubscribe = () => {
+        window.removeEventListener("focus", handleFocus);
+        window.removeEventListener("visibilitychange", handleFocus);
+        window.removeEventListener("blur", handleBlur);
+      };
+    }
   }
-  return schema.parse(data);
-}
+  onFocus() {
+    this.listeners.forEach((listener) => listener());
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  isFocused() {
+    return this.focused;
+  }
+  setFocused(focused) {
+    this.focused = focused;
+    if (focused) this.onFocus();
+  }
+};
+var focusManager = new FocusManager();
+
+// src/query/onlineManager.ts
+var OnlineManager = class {
+  listeners = /* @__PURE__ */ new Set();
+  online = true;
+  constructor() {
+    if (typeof window !== "undefined" && window.addEventListener) {
+      window.addEventListener("online", () => this.setOnline(true), false);
+      window.addEventListener("offline", () => this.setOnline(false), false);
+      this.online = navigator.onLine;
+    }
+  }
+  setOnline(online) {
+    this.online = online;
+    this.listeners.forEach((listener) => listener(online));
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  isOnline() {
+    return this.online;
+  }
+};
+var onlineManager = new OnlineManager();
 
-// src/addon/query/queryObserver.ts
+// src/query/queryObserver.ts
 var QueryObserver = class {
   client;
-  options;
-  queryKeyHash;
-  signal;
-  listeners = /* @__PURE__ */ new Set();
-  // Internal state management
+  // Reactive Inputs
+  options$;
+  // Reactive Outputs
+  result$;
+  // Internal
+  unsubscribe = null;
+  gcUnsubscribe = null;
   abortController = null;
   intervalParams = { id: null };
-  unsubscribeSignal = null;
-  // Derived state cache to ensure referential stability where possible
-  currentResult;
   constructor(client, options) {
     this.client = client;
-    this.options = options;
-    this.queryKeyHash = stableHash(options.queryKey);
-    this.signal = client.getSignal(options.queryKey);
-  }
-  setOptions(options) {
-    const prevOptions = this.options;
-    this.options = options;
-    const newHash = stableHash(options.queryKey);
-    if (newHash !== this.queryKeyHash) {
-      this.queryKeyHash = newHash;
-      this.updateSignal();
-      this.checkAndFetch();
-    } else {
-      if (options.enabled && !prevOptions.enabled) {
-        this.checkAndFetch();
+    this.options$ = createSignal(options);
+    let lastResult = null;
+    this.result$ = computed(() => {
+      const opts = this.options$.get();
+      const queryKey = opts.queryKey;
+      const cacheSignal = this.client.getSignal(queryKey);
+      const entry = cacheSignal.get();
+      const data = entry?.data;
+      const status = entry?.status || "pending";
+      const error = entry?.error || null;
+      const isFetching = entry?.isFetching || false;
+      const staleTime = opts.staleTime ?? 0;
+      const now = Date.now();
+      const dataTimestamp = entry?.timestamp;
+      const diff = dataTimestamp ? now - dataTimestamp : -1;
+      const isTimeStale = dataTimestamp ? diff > staleTime : true;
+      const isStale = entry?.isInvalidated || isTimeStale;
+      const isError = status === "error";
+      const isSuccess = status === "success";
+      const isPending = status === "pending";
+      const isLoading = data === void 0 && isFetching;
+      let finalData;
+      if (data !== void 0) {
+        try {
+          finalData = opts.select ? opts.select(data) : data;
+        } catch (e) {
+          return {
+            ...lastResult ?? {},
+            status: "error",
+            error: e,
+            isError: true
+          };
+        }
       }
-    }
-    if (options.refetchInterval !== prevOptions.refetchInterval) {
-      this.setupInterval();
-    }
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    if (this.listeners.size === 1) {
-      this.init();
-    }
-    return () => {
-      this.listeners.delete(listener);
-      if (this.listeners.size === 0) {
-        this.destroy();
+      const nextResult = {
+        data: finalData,
+        isLoading,
+        isError,
+        isSuccess,
+        isPending,
+        isFetching,
+        isStale,
+        error,
+        status,
+        refetch: this.refetch
+      };
+      const isDataEqual = lastResult?.data === nextResult.data || isDeepEqual(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;
       }
-    };
-  }
-  init() {
-    this.updateSignal();
-    this.setupGlobalListeners();
-    this.setupInterval();
-    this.checkAndFetch();
+      lastResult = nextResult;
+      return nextResult;
+    });
+    this.initSideEffects();
   }
-  destroy() {
-    this.cleanupGlobalListeners();
-    this.cleanupInterval();
-    if (this.unsubscribeSignal) {
-      this.unsubscribeSignal();
-      this.unsubscribeSignal = null;
-    }
-    if (this.abortController) {
-      this.abortController.abort();
+  setOptions(options) {
+    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 && current.cacheTime === options.cacheTime && current.refetchInterval === options.refetchInterval && current.retry === options.retry;
+    if (!isKeyEqual || !isConfigEqual || current.select !== options.select) {
+      this.options$.set(options);
     }
   }
-  updateSignal() {
-    if (this.unsubscribeSignal) this.unsubscribeSignal();
-    this.signal = this.client.getSignal(this.options.queryKey);
-    this.unsubscribeSignal = this.signal.subscribe(() => {
-      this.notify();
+  subscribe(listener) {
+    const unsub = this.result$.subscribe(() => {
+      listener();
     });
-  }
-  computeResult() {
-    const entry = this.signal.get();
-    const data = entry?.data;
-    const status = entry?.status || "pending";
-    const error = entry?.error || null;
-    const isFetching = entry?.isFetching || false;
-    const dataTimestamp = entry?.timestamp;
-    const staleTime = this.options.staleTime ?? 0;
-    const isStale = entry?.isInvalidated || (dataTimestamp ? Date.now() - dataTimestamp > staleTime : true);
-    const isError = status === "error";
-    const isLoading = data === void 0;
-    const nextResult = {
-      data,
-      isLoading,
-      isError,
-      isFetching,
-      isStale,
-      error,
-      status,
-      refetch: this.refetch
-    };
-    if (this.currentResult && this.shallowEqual(this.currentResult, nextResult)) {
-      return this.currentResult;
-    }
-    this.currentResult = nextResult;
-    return nextResult;
+    return unsub;
   }
   getSnapshot = () => {
-    if (!this.currentResult) {
-      return this.computeResult();
-    }
-    return this.currentResult;
+    return this.result$.get();
   };
-  shallowEqual(objA, objB) {
-    if (Object.is(objA, objB)) return true;
-    if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) return false;
-    const recordA = objA;
-    const recordB = objB;
-    const keysA = Object.keys(recordA);
-    const keysB = Object.keys(recordB);
-    if (keysA.length !== keysB.length) return false;
-    for (const key of keysA) {
-      if (!Object.prototype.hasOwnProperty.call(recordB, key) || !Object.is(recordA[key], recordB[key])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  notify() {
-    this.computeResult();
-    this.listeners.forEach((l) => l());
-    this.checkAndFetch();
-  }
-  // --- Fetch Logic ---
-  fetch = async (background = false) => {
-    if (this.options.enabled === false) return;
-    if (this.abortController) this.abortController.abort();
-    this.abortController = new AbortController();
-    const signal2 = this.abortController.signal;
-    try {
-      let result = await this.client.fetch(
-        this.options.queryKey,
-        (ctx) => this.options.queryFn(ctx),
-        { signal: signal2, retry: this.options.retry, retryDelay: this.options.retryDelay }
-      );
-      try {
-        result = validateWithSchema(result, this.options.schema);
-      } catch (validationErr) {
-        const current = this.signal.get();
-        this.signal.set({
-          ...current,
-          status: "error",
-          error: validationErr,
-          isFetching: false,
-          data: void 0
-        });
-        return;
+  initSideEffects() {
+    const disposeEffect = effect(() => {
+      const opts = this.options$.get();
+      const res = this.result$.get();
+      if (opts.enabled !== false) {
+        if (res.isLoading && !res.isFetching && !res.isError) {
+          untracked(() => this.fetch());
+        } else if (res.isStale && !res.isFetching && !res.isError) {
+          untracked(() => this.fetch());
+        }
       }
-      this.client.set(this.options.queryKey, result, {
-        staleTime: this.options.staleTime,
-        cacheTime: this.options.cacheTime,
-        tags: this.options.tags
+    });
+    const disposeGC = effect(() => {
+      const opts = this.options$.get();
+      const signal2 = this.client.getSignal(opts.queryKey);
+      const unsub = signal2.subscribe(() => {
       });
-    } catch (err) {
-      if (err instanceof Error && err.name === "AbortError") return;
-      if (err instanceof Error && err.name !== "AbortError") {
+      return () => unsub();
+    });
+    const disposeFocus = focusManager.subscribe(() => {
+      const opts = this.options$.get();
+      if (opts.enabled !== false && opts.refetchOnWindowFocus !== false) {
+        this.fetch();
       }
-    }
-  };
-  checkAndFetch() {
-    if (this.options.enabled === false) return;
-    const snapshot = this.getSnapshot();
-    if (snapshot.isLoading && !snapshot.isFetching && !snapshot.isError) {
-      this.fetch();
-    } else if (snapshot.isStale && !snapshot.isFetching && !snapshot.isError) {
-      this.fetch();
-    }
+    });
+    const disposeOnline = onlineManager.subscribe((isOnline) => {
+      const opts = this.options$.get();
+      if (isOnline && opts.enabled !== false && opts.refetchOnReconnect !== false) {
+        this.fetch();
+      }
+    });
+    this.unsubscribe = () => {
+      disposeEffect();
+      disposeGC();
+      disposeFocus();
+      disposeOnline();
+    };
   }
   refetch = async () => {
-    this.client.invalidate(this.options.queryKey);
+    const opts = this.options$.get();
+    this.client.invalidate(opts.queryKey);
     await this.fetch();
   };
-  // --- Background Refetching ---
-  setupInterval() {
-    this.cleanupInterval();
-    if (this.options.enabled !== false && this.options.refetchInterval) {
-      this.intervalParams.id = setInterval(() => {
-        this.fetch(true);
-      }, this.options.refetchInterval);
-    }
-  }
-  cleanupInterval() {
-    if (this.intervalParams.id) {
-      clearInterval(this.intervalParams.id);
-      this.intervalParams.id = null;
-    }
-  }
-  onFocus = () => {
-    if (this.options.refetchOnWindowFocus) {
-      const snapshot = this.getSnapshot();
-      if (snapshot.isStale && !snapshot.isFetching) {
-        this.fetch(true);
-      }
+  fetch = async (background = false) => {
+    const opts = this.options$.get();
+    if (opts.enabled === false) return;
+    if (this.abortController) {
+      this.abortController.abort();
     }
-  };
-  onOnline = () => {
-    if (this.options.refetchOnReconnect) {
-      const snapshot = this.getSnapshot();
-      if (snapshot.isStale && !snapshot.isFetching) {
-        this.fetch(true);
-      }
+    this.abortController = new AbortController();
+    const signal2 = this.abortController.signal;
+    try {
+      await this.client.fetch(
+        opts.queryKey,
+        async (ctx) => {
+          const data = await opts.queryFn(ctx);
+          if (opts.schema) {
+            return validateWithSchema(data, opts.schema);
+          }
+          return data;
+        },
+        { signal: signal2, retry: opts.retry, retryDelay: opts.retryDelay, tags: opts.tags }
+      );
+    } catch (e) {
     }
   };
-  setupGlobalListeners() {
-    if (typeof window !== "undefined") {
-      window.addEventListener("focus", this.onFocus);
-      window.addEventListener("online", this.onOnline);
-    }
-  }
-  cleanupGlobalListeners() {
-    if (typeof window !== "undefined") {
-      window.removeEventListener("focus", this.onFocus);
-      window.removeEventListener("online", this.onOnline);
-    }
+  destroy() {
+    if (this.unsubscribe) this.unsubscribe();
+    if (this.abortController) this.abortController.abort();
   }
 };
 
-// src/addon/query/useQuery.ts
+// src/query/useQuery.ts
 function useQuery(options) {
   const client = useQueryClient();
   const [observer] = (0, import_react4.useState)(() => new QueryObserver(client, options));
   (0, import_react4.useEffect)(() => {
     observer.setOptions(options);
   }, [observer, options]);
-  const subscribe2 = (0, import_react4.useCallback)((onStoreChange) => {
+  (0, import_react4.useEffect)(() => {
+    return () => {
+      observer.destroy();
+    };
+  }, [observer]);
+  const subscribe = (0, import_react4.useCallback)((onStoreChange) => {
     return observer.subscribe(onStoreChange);
   }, [observer]);
-  const select = options?.select;
-  const selectRef = (0, import_react4.useRef)(select);
-  selectRef.current = select;
-  const memoRef = (0, import_react4.useRef)({ entry: void 0, selected: void 0 });
-  const getSnapshotWithSelector = (0, import_react4.useCallback)(() => {
-    const entry = observer.getSnapshot();
-    if (entry === memoRef.current.entry) {
-      return memoRef.current.selected;
-    }
-    let processedResult;
-    if (!entry) {
-      processedResult = void 0;
-    } else {
-      if (selectRef.current && entry.data !== void 0) {
-        processedResult = { ...entry, data: selectRef.current(entry.data) };
-      } else {
-        processedResult = entry;
-      }
-    }
-    memoRef.current = { entry, selected: processedResult };
-    return processedResult;
+  const getSnapshot = (0, import_react4.useCallback)(() => {
+    return observer.getSnapshot();
   }, [observer]);
-  const result = (0, import_react4.useSyncExternalStore)(subscribe2, getSnapshotWithSelector);
-  const status = result?.status || "pending";
-  const computedResult = {
-    ...result,
-    isPending: status === "pending",
-    isSuccess: status === "success",
-    isError: status === "error"
-  };
-  const typedResult = computedResult;
-  const signal2 = client.getSignal(options.queryKey);
+  const result = (0, import_react4.useSyncExternalStore)(subscribe, getSnapshot);
   return {
-    ...typedResult,
-    signal: signal2
-    // Keep signal as T (source)
+    ...result,
+    signal: observer.result$
   };
 }
 
-// src/addon/query/useMutation.ts
+// src/query/useMutation.ts
 var import_react5 = require("react");
 
-// src/addon/query/mutationObserver.ts
+// src/query/mutationObserver.ts
 var generateId = () => {
   if (typeof crypto !== "undefined" && crypto.randomUUID) {
     return crypto.randomUUID();
@@ -1618,8 +1629,7 @@ var MutationObserver = class {
       return result;
     } catch (error) {
       if (optimistic && optimisticSnapshot !== void 0) {
-        const queryCache = this.client;
-        queryCache.set(optimistic.queryKey, optimisticSnapshot);
+        this.client.set(optimistic.queryKey, optimisticSnapshot);
       }
       notify({ status: "error", error });
       if (onError) onError(error, variables, context);
@@ -1633,13 +1643,14 @@ var MutationObserver = class {
       data: void 0,
       error: null,
       variables: void 0,
+      context: void 0,
       submittedAt: 0
     });
     this.currentMutationId = null;
   };
 };
 
-// src/addon/query/useMutation.ts
+// src/query/useMutation.ts
 function useMutation(options) {
   const client = useQueryClient();
   const [observer] = (0, import_react5.useState)(() => new MutationObserver(client, options));
@@ -1671,10 +1682,10 @@ function useMutation(options) {
   };
 }
 
-// src/addon/query/infiniteQuery.ts
+// src/query/infiniteQuery.ts
 var import_react6 = require("react");
 
-// src/addon/query/plugins/logger.ts
+// src/query/plugins/logger.ts
 var consoleLogger = {
   log: console.log,
   warn: console.warn,
@@ -1683,133 +1694,166 @@ var consoleLogger = {
 var currentLogger = consoleLogger;
 var getLogger = () => currentLogger;
 
-// src/addon/query/infiniteQuery.ts
-function useInfiniteQuery({
-  queryKey,
-  queryFn,
-  getNextPageParam,
-  getPreviousPageParam,
-  initialPageParam,
-  staleTime = 0,
-  cacheTime = 5 * 60 * 1e3,
-  enabled = true,
-  retry
-}) {
-  const client = useQueryClient();
-  const queryKeyHash = stableHash(queryKey);
-  const infiniteQueryKey = (0, import_react6.useMemo)(() => [...queryKey, "__infinite__"], [queryKeyHash]);
-  const subscribe2 = (0, import_react6.useCallback)((onStoreChange) => {
-    const signal2 = client.getSignal(infiniteQueryKey);
-    return signal2.subscribe(() => onStoreChange());
-  }, [client, infiniteQueryKey]);
-  const getSnapshot = (0, import_react6.useCallback)(() => {
-    const signal2 = client.getSignal(infiniteQueryKey);
-    return signal2.get();
-  }, [client, queryKeyHash]);
-  const cacheEntry = (0, import_react6.useSyncExternalStore)(subscribe2, getSnapshot);
-  const data = cacheEntry?.data;
-  const isFetching = cacheEntry?.isFetching || false;
-  const fetchDirection = cacheEntry?.fetchDirection || "idle";
-  const status = cacheEntry?.status || "pending";
-  const error = cacheEntry?.error || null;
-  const timestamp = cacheEntry?.timestamp || 0;
-  const isInvalidated = cacheEntry?.isInvalidated || false;
-  let hasNextPage = false;
-  let hasPreviousPage = false;
-  if (data && data.pages.length > 0) {
-    if (getNextPageParam) {
-      const lastPage = data.pages[data.pages.length - 1];
-      hasNextPage = getNextPageParam(lastPage, data.pages) !== void 0;
-    }
-    if (getPreviousPageParam) {
-      const firstPage = data.pages[0];
-      hasPreviousPage = getPreviousPageParam(firstPage, data.pages) !== void 0;
-    }
+// src/query/infiniteQueryObserver.ts
+var InfiniteQueryObserver = class {
+  client;
+  options$;
+  result$;
+  unsubscribe = null;
+  lastFetchTime = 0;
+  constructor(client, options) {
+    this.client = client;
+    this.options$ = createSignal(options);
+    const infiniteQueryKey = computed(() => {
+      const opts = this.options$.get();
+      return [...opts.queryKey, "__infinite__"];
+    });
+    let lastResult = null;
+    this.result$ = computed(() => {
+      const opts = this.options$.get();
+      const key = infiniteQueryKey.get();
+      const cacheSignal = this.client.getSignal(key);
+      const entry = cacheSignal.get();
+      const data = entry?.data;
+      const isFetching = entry?.isFetching || false;
+      const fetchDirection = entry?.fetchDirection || "idle";
+      const status = entry?.status || "pending";
+      const error = entry?.error || null;
+      let hasNextPage = false;
+      let hasPreviousPage = false;
+      if (data && data.pages.length > 0) {
+        if (opts.getNextPageParam) {
+          const lastPage = data.pages[data.pages.length - 1];
+          hasNextPage = opts.getNextPageParam(lastPage, data.pages) !== void 0;
+        }
+        if (opts.getPreviousPageParam) {
+          const firstPage = data.pages[0];
+          hasPreviousPage = opts.getPreviousPageParam(firstPage, data.pages) !== void 0;
+        }
+      }
+      const isFetchingNextPage = isFetching && fetchDirection === "next";
+      const isFetchingPreviousPage = isFetching && fetchDirection === "previous";
+      const isLoading = data === void 0 && isFetching;
+      const nextResult = {
+        data,
+        isFetching,
+        isFetchingNextPage,
+        isFetchingPreviousPage,
+        isLoading,
+        isError: status === "error",
+        hasNextPage,
+        hasPreviousPage,
+        error,
+        status,
+        fetchNextPage: this.fetchNextPage,
+        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) {
+        return lastResult;
+      }
+      lastResult = nextResult;
+      return nextResult;
+    });
+    this.initSideEffects();
   }
-  const isFetchingNextPage = isFetching && fetchDirection === "next";
-  const isFetchingPreviousPage = isFetching && fetchDirection === "previous";
-  const isLoading = data === void 0 && isFetching;
-  const isError = status === "error";
-  const queryFnRef = (0, import_react6.useRef)(queryFn);
-  const getNextPageParamRef = (0, import_react6.useRef)(getNextPageParam);
-  const getPreviousPageParamRef = (0, import_react6.useRef)(getPreviousPageParam);
-  const initialPageParamRef = (0, import_react6.useRef)(initialPageParam);
-  const staleTimeRef = (0, import_react6.useRef)(staleTime);
-  const cacheTimeRef = (0, import_react6.useRef)(cacheTime);
-  (0, import_react6.useEffect)(() => {
-    queryFnRef.current = queryFn;
-    getNextPageParamRef.current = getNextPageParam;
-    getPreviousPageParamRef.current = getPreviousPageParam;
-    initialPageParamRef.current = initialPageParam;
-    staleTimeRef.current = staleTime;
-    cacheTimeRef.current = cacheTime;
-  });
-  (0, import_react6.useEffect)(() => {
-    if (!enabled) return;
-    if (data && !isInvalidated && Date.now() - timestamp <= staleTime) return;
-    if (isFetching) return;
-    const doInitialFetch = async () => {
-      try {
-        if (data && data.pageParams.length > 0) {
-          const updatedPages = [];
-          const updatedParams = [];
-          let param = data.pageParams[0];
-          updatedParams.push(param);
-          const limit = data.pages.length;
-          const fetchedData = await client.fetch(infiniteQueryKey, async () => {
-            for (let i = 0; i < limit; i++) {
-              const page = await queryFnRef.current({ pageParam: param });
-              updatedPages.push(page);
-              if (i < limit - 1) {
-                const next = getNextPageParamRef.current?.(page, updatedPages);
-                if (next === void 0) break;
-                param = next;
-                updatedParams.push(param);
-              }
-            }
-            return {
-              pages: updatedPages,
-              pageParams: updatedParams
-            };
-          }, { fetchDirection: "initial", retry });
-          client.set(infiniteQueryKey, fetchedData, {
-            staleTime: staleTimeRef.current,
-            cacheTime: cacheTimeRef.current
-          });
-          return;
+  setOptions(options) {
+    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) {
+      this.options$.set(options);
+    }
+  }
+  initSideEffects() {
+    const dispose = effect(() => {
+      const opts = this.options$.get();
+      const res = this.result$.get();
+      if (opts.enabled !== false) {
+        const infiniteKey = [...opts.queryKey, "__infinite__"];
+        const entry = this.client.getSignal(infiniteKey).get();
+        const staleTime = opts.staleTime ?? 0;
+        const now = Date.now();
+        const timestamp = entry?.timestamp || 0;
+        const isStale = entry?.isInvalidated || entry?.data && now - timestamp > staleTime;
+        if ((!entry?.data || isStale) && !res.isFetching && !res.isError) {
+          untracked(() => this.fetchInitial());
         }
-        const initialParam = initialPageParamRef.current;
-        const firstParam = initialParam !== void 0 ? initialParam : 0;
-        const initialData = await client.fetch(infiniteQueryKey, async () => {
-          const firstPage = await queryFnRef.current({ pageParam: firstParam });
-          return {
-            pages: [firstPage],
-            pageParams: [firstParam]
-          };
-        }, { fetchDirection: "initial", retry });
-        client.set(infiniteQueryKey, initialData, {
-          staleTime: staleTimeRef.current,
-          cacheTime: cacheTimeRef.current
-        });
-      } catch (err) {
-        getLogger().error("Initial fetch failed", err);
       }
+    });
+    const disposeFocus = focusManager.subscribe(() => {
+      const opts = this.options$.get();
+      if (opts.enabled !== false && opts.refetchOnWindowFocus !== false) {
+        this.fetchInitial();
+      }
+    });
+    const disposeOnline = onlineManager.subscribe((isOnline) => {
+      const opts = this.options$.get();
+      if (isOnline && opts.enabled !== false && opts.refetchOnReconnect !== false) {
+        this.fetchInitial();
+      }
+    });
+    this.unsubscribe = () => {
+      dispose();
+      disposeFocus();
+      disposeOnline();
     };
-    doInitialFetch();
-  }, [enabled, data === void 0, isInvalidated, staleTime, timestamp]);
-  const fetchNextPage = (0, import_react6.useCallback)(async () => {
-    if (!hasNextPage || isFetching || !data) return;
-    const lastPage = data.pages[data.pages.length - 1];
-    const nextPageParam = getNextPageParamRef.current?.(lastPage, data.pages);
+  }
+  fetchInitial = async (options) => {
+    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 firstPage = await opts.queryFn({ pageParam: firstParam2 });
+        const latest = entrySignal.get()?.data;
+        if (!latest) return;
+        const updatedData = {
+          ...latest,
+          pages: [firstPage, ...latest.pages.slice(1)]
+        };
+        this.client.set(infiniteKey, updatedData, {
+          staleTime: opts.staleTime,
+          cacheTime: opts.cacheTime
+        });
+        return;
+      }
+      const initialParam = opts.initialPageParam;
+      const firstParam = initialParam !== void 0 ? initialParam : 0;
+      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("Initial fetch failed", err);
+    }
+  };
+  fetchNextPage = async () => {
+    const res = this.result$.get();
+    const opts = this.options$.get();
+    if (!res.hasNextPage || res.isFetching || !res.data) return;
+    const infiniteKey = [...opts.queryKey, "__infinite__"];
+    const lastPage = res.data.pages[res.data.pages.length - 1];
+    const nextPageParam = opts.getNextPageParam?.(lastPage, res.data.pages);
     if (nextPageParam === void 0) return;
     try {
-      const updatedData = await client.fetch(infiniteQueryKey, async ({ signal: signal2 }) => {
-        const newPage = await queryFnRef.current({ pageParam: nextPageParam });
-        const currentEntry = client.getSignal(infiniteQueryKey).get();
-        const currentData = currentEntry?.data;
-        if (!currentData) throw new Error("Infinite query data missing during fetchNextPage");
-        const nextCursor = getNextPageParamRef.current?.(newPage, [...currentData.pages, newPage]);
+      const updatedData = await this.client.fetch(infiniteKey, async () => {
+        const newPage = await opts.queryFn({ pageParam: nextPageParam });
+        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);
         }
@@ -1817,77 +1861,86 @@ function useInfiniteQuery({
           pages: [...currentData.pages, newPage],
           pageParams: updatedParams
         };
-      }, {
-        fetchDirection: "next",
-        retry
-      });
-      client.set(infiniteQueryKey, updatedData, {
-        staleTime: staleTimeRef.current,
-        cacheTime: cacheTimeRef.current
+      }, { fetchDirection: "next", retry: opts.retry });
+      this.client.set(infiniteKey, updatedData, {
+        staleTime: opts.staleTime,
+        cacheTime: opts.cacheTime
       });
     } catch (err) {
       getLogger().error("Fetch next page failed", err);
     }
-  }, [hasNextPage, isFetching, data, client, JSON.stringify(infiniteQueryKey)]);
-  const fetchPreviousPage = (0, import_react6.useCallback)(async () => {
-    if (!hasPreviousPage || isFetching || !data) return;
-    const firstPage = data.pages[0];
-    const previousPageParam = getPreviousPageParamRef.current?.(firstPage, data.pages);
+  };
+  fetchPreviousPage = async () => {
+    const res = this.result$.get();
+    const opts = this.options$.get();
+    if (!res.hasPreviousPage || res.isFetching || !res.data) return;
+    const infiniteKey = [...opts.queryKey, "__infinite__"];
+    const firstPage = res.data.pages[0];
+    const previousPageParam = opts.getPreviousPageParam?.(firstPage, res.data.pages);
     if (previousPageParam === void 0) return;
     try {
-      const updatedData = await client.fetch(infiniteQueryKey, async () => {
-        const newPage = await queryFnRef.current({ pageParam: previousPageParam });
-        const currentEntry = client.getSignal(infiniteQueryKey).get();
-        const currentData = currentEntry?.data;
-        if (!currentData) throw new Error("Infinite query data missing during fetchPreviousPage");
+      const updatedData = await this.client.fetch(infiniteKey, async () => {
+        const newPage = await opts.queryFn({ pageParam: previousPageParam });
+        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 });
-      client.set(infiniteQueryKey, updatedData, {
-        staleTime: staleTimeRef.current,
-        cacheTime: cacheTimeRef.current
+      }, { fetchDirection: "previous", retry: opts.retry });
+      this.client.set(infiniteKey, updatedData, {
+        staleTime: opts.staleTime,
+        cacheTime: opts.cacheTime
       });
     } catch (err) {
       getLogger().error("Fetch previous page failed", err);
     }
-  }, [hasPreviousPage, isFetching, data, client, JSON.stringify(infiniteQueryKey)]);
-  const refetch = (0, import_react6.useCallback)(async () => {
-    client.invalidate(infiniteQueryKey);
-  }, [client, JSON.stringify(infiniteQueryKey)]);
-  return {
-    data,
-    fetchNextPage,
-    fetchPreviousPage,
-    hasNextPage,
-    hasPreviousPage,
-    isFetching,
-    isFetchingNextPage,
-    isFetchingPreviousPage,
-    isLoading,
-    isError,
-    error,
-    refetch
   };
+  refetch = async () => {
+    const opts = this.options$.get();
+    const infiniteKey = [...opts.queryKey, "__infinite__"];
+    this.client.invalidate(infiniteKey);
+    await this.fetchInitial({ force: true });
+  };
+  destroy() {
+    if (this.unsubscribe) this.unsubscribe();
+  }
+};
+
+// src/query/infiniteQuery.ts
+function useInfiniteQuery(options) {
+  const client = useQueryClient();
+  const [observer] = (0, import_react6.useState)(() => new InfiniteQueryObserver(client, options));
+  (0, import_react6.useEffect)(() => {
+    observer.setOptions(options);
+  }, [observer, options]);
+  (0, import_react6.useEffect)(() => {
+    return () => {
+      observer.destroy();
+    };
+  }, [observer]);
+  const subscribe = (0, import_react6.useCallback)((onStoreChange) => {
+    return observer.result$.subscribe(() => onStoreChange());
+  }, [observer]);
+  const getSnapshot = (0, import_react6.useCallback)(() => {
+    return observer.result$.get();
+  }, [observer]);
+  return (0, import_react6.useSyncExternalStore)(subscribe, getSnapshot);
 }
 
-// src/addon/query/HydrationBoundary.tsx
+// src/query/HydrationBoundary.tsx
 var import_react7 = require("react");
 
-// src/addon/query/hydration.ts
+// src/query/hydration.ts
 function dehydrate(client) {
   const queries = [];
   const snapshot = client.getSnapshot();
-  snapshot.forEach((signal2, hash) => {
-    const state = signal2.get();
-    if (state) {
-      queries.push({
-        queryKey: state.key,
-        queryHash: hash,
-        state
-      });
-    }
+  snapshot.forEach((state, hash) => {
+    queries.push({
+      queryKey: state.key,
+      queryHash: hash,
+      state
+    });
   });
   return { queries };
 }
@@ -1899,8 +1952,8 @@ function hydrate(client, state) {
   });
 }
 
-// src/addon/query/HydrationBoundary.tsx
-var import_jsx_runtime2 = require("react/jsx-runtime");
+// src/query/HydrationBoundary.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
 function HydrationBoundary({ state, children }) {
   const client = useQueryClient();
   const hydratedRef = (0, import_react7.useRef)(false);
@@ -1908,10 +1961,10 @@ function HydrationBoundary({ state, children }) {
     hydrate(client, state);
     hydratedRef.current = true;
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_jsx_runtime3.Fragment, { children });
 }
 
-// src/addon/query/useSuspenseQuery.ts
+// src/query/useSuspenseQuery.ts
 function useSuspenseQuery(options) {
   const client = useQueryClient();
   const signal2 = client.getSignal(options.queryKey);
@@ -1920,8 +1973,7 @@ function useSuspenseQuery(options) {
   if (shouldSuspend) {
     const fetchPromise = client.fetch(
       options.queryKey,
-      // @ts-ignore
-      (ctx) => options.queryFn(ctx),
+      (ctx) => options.queryFn({ ...ctx, signal: void 0 }),
       { signal: void 0 }
     ).then((data) => {
       client.set(options.queryKey, data);
@@ -1939,73 +1991,60 @@ function useSuspenseQuery(options) {
   };
 }
 
-// src/core/bridge.ts
-function fromSignal(signal2) {
-  const initial = signal2.get();
-  const isObject = typeof initial === "object" && initial !== null;
-  const target = isObject ? initial : { value: initial };
-  const proxy = createState(target);
-  signal2.subscribe((newValue) => {
-    if (typeof newValue === "object" && newValue !== null) {
-      Object.assign(proxy, newValue);
-    } else {
-      proxy.value = newValue;
-    }
-  });
-  return proxy;
+// src/query/useQueryStore.ts
+var import_react8 = require("react");
+function useQueryStore() {
+  const client = useQueryClient();
+  const [cache, setCache] = (0, import_react8.useState)(client.getAll());
+  (0, import_react8.useEffect)(() => {
+    const interval = setInterval(() => {
+      setCache(new Map(client.getAll()));
+    }, 500);
+    return () => clearInterval(interval);
+  }, [client]);
+  return cache;
 }
-function toSignal(selector) {
-  const s = createSignal(void 0);
-  let isComputing = false;
-  const onDependencyChange = () => {
-    if (isComputing) return;
-    run();
-  };
-  const run = () => {
-    isComputing = true;
-    setActiveListener(onDependencyChange);
-    try {
-      const value = selector();
-      s.set(value);
-    } finally {
-      setActiveListener(null);
-      isComputing = false;
-    }
-  };
-  run();
-  return {
-    get: s.get,
-    set: () => {
-      throw new Error("Cannot set a read-only bridge signal");
-    },
-    subscribe: s.subscribe
-  };
+
+// src/query/useQuerySignal.ts
+var import_react9 = require("react");
+function useQuery$(options) {
+  const client = useQueryClient();
+  const [observer] = (0, import_react9.useState)(() => new QueryObserver(client, options));
+  (0, import_react9.useEffect)(() => {
+    observer.setOptions(options);
+  }, [observer, options.enabled, options.staleTime, options.cacheTime, options.queryKey, options.refetchInterval]);
+  (0, import_react9.useEffect)(() => {
+    const unsubscribe = observer.subscribe(() => {
+    });
+    return () => {
+      unsubscribe();
+      observer.destroy();
+    };
+  }, [observer]);
+  return observer.result$;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   HydrationBoundary,
-  QueryCache,
+  QueryClient,
   QueryClientProvider,
-  computed,
+  SignalValue,
+  atom,
   createHttpClient,
-  createState,
-  defineModel,
   dehydrate,
   enableDevTools,
-  fromSignal,
   getPromiseState,
   handlePromise,
   hydrate,
   isPromise,
   scheduleUpdate,
-  subscribe,
-  toSignal,
   unwrapPromise,
   useInfiniteQuery,
   useMutation,
   usePaginatedQuery,
   useQuery,
+  useQuery$,
   useQueryClient,
-  useStore,
+  useQueryStore,
   useSuspenseQuery
 });