@braine/quantum-query 1.2.5 → 1.2.7

package/dist/index.js

@@ -1,293 +1,167 @@
-// 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();
+// src/signals.ts
+import {
+  signal,
+  computed as preactComputed,
+  effect as preactEffect,
+  batch as preactBatch,
+  untracked as preactUntracked
+} from "@preact/signals-core";
+function createSignal(initialValue, options) {
+  const s = signal(initialValue);
+  let subscriberCount = 0;
+  return {
+    get: () => s.value,
+    set: (newValue) => {
+      s.value = newValue;
     },
-    (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;
-  }
+    subscribe: (fn) => {
+      if (subscriberCount === 0) {
+        options?.onActive?.();
+      }
+      subscriberCount++;
+      const dispose = preactEffect(() => {
+        fn(s.value);
+      });
+      return () => {
+        dispose();
+        subscriberCount--;
+        if (subscriberCount === 0) {
+          options?.onInactive?.();
+        }
+      };
+    },
+    isWatched: () => subscriberCount > 0
+  };
 }
-function getPromiseState(promise) {
+function computed(fn) {
+  const c = preactComputed(fn);
+  let subscriberCount = 0;
   return {
-    status: PROMISE_STATUS.get(promise) || "pending",
-    value: PROMISE_CACHE.get(promise),
-    error: PROMISE_ERROR.get(promise)
+    get: () => c.value,
+    set: () => {
+      throw new Error("[Quantum] Cannot set a computed signal directly.");
+    },
+    subscribe: (fn2) => {
+      subscriberCount++;
+      const dispose = preactEffect(() => {
+        fn2(c.value);
+      });
+      return () => {
+        dispose();
+        subscriberCount--;
+      };
+    },
+    isWatched: () => subscriberCount > 0
   };
 }
-
-// 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);
+function effect(fn) {
+  return preactEffect(fn);
 }
-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;
+function untracked(fn) {
+  return preactUntracked(fn);
 }
 
-// src/core/model.ts
-function debounce(fn, ms) {
-  let timeout;
-  return (...args) => {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => fn(...args), ms);
-  };
+// src/store/model.ts
+function atom(initialValue, options) {
+  const s = createSignal(initialValue);
+  if (options?.key) {
+    setupPersistence(s, options);
+  }
+  return s;
 }
-function defineModel(def) {
-  const target = def.state;
-  if (def.actions) {
-    for (const [key, fn] of Object.entries(def.actions)) {
-      target[key] = fn;
+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 (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
-        });
+  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);
   }
-  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 hydrate = () => {
-        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);
-        }
-      };
-      hydrate();
-      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();
-      });
+  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
+import { useEffect, useState } from "react";
+import { Fragment, jsx } from "react/jsx-runtime";
+function SignalValue({ signal: signal2, render, children }) {
+  const [value, setValue] = useState(() => signal2.get());
+  useEffect(() => {
+    const unsubscribe = signal2.subscribe((newValue) => {
+      setValue(newValue);
+    });
+    return () => unsubscribe();
+  }, [signal2]);
+  const renderer = render || children;
+  if (!renderer) return null;
+  return /* @__PURE__ */ jsx(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);
   }
-  return proxy;
 }
 
-// src/react/autoHook.ts
-import { useSyncExternalStore, useRef, useCallback, useLayoutEffect, useEffect } from "react";
-function useStore(store) {
-  const versionRef = useRef(0);
-  const notifyRef = useRef(void 0);
-  const listener = useCallback(() => {
-    versionRef.current++;
-    if (notifyRef.current) {
-      notifyRef.current();
-    }
-  }, []);
-  const subscribe2 = useCallback((onStoreChange) => {
-    notifyRef.current = onStoreChange;
-    return () => {
-      notifyRef.current = void 0;
-    };
-  }, []);
-  const getSnapshot = useCallback(() => versionRef.current, []);
-  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/devtools/registry.ts
+var stores = createSignal([]);
+function registerStore(store, name = "Store") {
+  const current = stores.get();
+  if (!current.find((s) => s.store === store)) {
+    stores.set([...current, { name, store }]);
+  }
 }
 
 // src/middleware/devtools.ts
 function enableDevTools(store, name = "Store") {
-  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;
-    }
-  };
+  registerStore(store, name);
+  console.warn("DevTools for Signals are WIP");
 }
 
-// src/addon/clientTypes.ts
+// src/clientTypes.ts
 var HttpError = class extends Error {
   constructor(status, message) {
     super(message);
@@ -296,7 +170,7 @@ var HttpError = class extends Error {
   }
 };
 
-// src/addon/middleware/types.ts
+// src/middleware/types.ts
 function compose(middleware) {
   return (ctx, next) => {
     let index = -1;
@@ -315,7 +189,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);
@@ -341,10 +215,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);
   }
@@ -377,7 +251,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")) {
@@ -422,15 +296,21 @@ var AuthMiddleware = async (ctx, next) => {
   return response;
 };
 
-// src/addon/middleware/fetch.ts
+// src/middleware/fetch.ts
 var FetchMiddleware = async (ctx) => {
   return fetch(ctx.req);
 };
 var delay = (ms) => new Promise((res) => setTimeout(res, ms));
 var RetryMiddleware = async (ctx, next) => {
-  const retryConfig = ctx.config.retry;
-  if (!retryConfig) return next(ctx);
-  const { retries = 0, baseDelay = 1e3, maxDelay = 3e3 } = typeof retryConfig === "number" ? { retries: retryConfig } : retryConfig;
+  const retryConfigRaw = ctx.config.retry;
+  if (!retryConfigRaw) return next(ctx);
+  let config;
+  if (typeof retryConfigRaw === "number") {
+    config = { retries: retryConfigRaw };
+  } else {
+    config = retryConfigRaw;
+  }
+  const { retries = 0, baseDelay = 1e3, maxDelay = 3e3 } = config;
   const attempt = async (count) => {
     try {
       const response = await next(ctx);
@@ -443,7 +323,7 @@ var RetryMiddleware = async (ctx, next) => {
       return response;
     } catch (err) {
       if (count < retries) {
-        if (err.name === "AbortError") throw err;
+        if (err instanceof Error && err.name === "AbortError") throw err;
         const d = Math.min(baseDelay * 2 ** count, maxDelay);
         await delay(d);
         return attempt(count + 1);
@@ -454,7 +334,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();
@@ -489,15 +369,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
         });
       }
@@ -538,8 +420,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;
           }
@@ -569,345 +452,783 @@ 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(",")}}`;
 }
-
-// src/addon/signals.ts
-var pendingSignals = /* @__PURE__ */ new Set();
-var isFlushScheduled = false;
-function flushPendingSignals() {
-  const toFlush = Array.from(pendingSignals);
-  pendingSignals.clear();
-  isFlushScheduled = false;
-  toFlush.forEach((signal) => signal.flush());
-}
-var SignalImpl = class {
-  value;
-  subscribers = /* @__PURE__ */ new Set();
-  constructor(initialValue) {
-    this.value = initialValue;
-  }
-  get = () => this.value;
-  set = (newValue) => {
-    if (this.value === newValue) return;
-    this.value = newValue;
-    pendingSignals.add(this);
-    if (!isFlushScheduled) {
-      isFlushScheduled = true;
-      queueMicrotask(flushPendingSignals);
+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;
     }
-  };
-  flush() {
-    const currentValue = this.value;
-    this.subscribers.forEach((fn) => fn(currentValue));
+    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;
   }
-  subscribe = (fn) => {
-    this.subscribers.add(fn);
-    return () => {
-      this.subscribers.delete(fn);
-    };
-  };
-};
-function createSignal(initialValue) {
-  return new SignalImpl(initialValue);
+  return a !== a && b !== b;
 }
 
-// src/addon/query/queryCache.ts
-var QueryCache = class {
-  // Store signals instead of raw values
+// src/query/queryStorage.ts
+var QueryStorage = class {
+  // Tracks access order (least to most recent)
+  // Default configuration
+  constructor(defaultStaleTime = 0, defaultCacheTime = 5 * 60 * 1e3, maxSize = 100) {
+    this.defaultStaleTime = defaultStaleTime;
+    this.defaultCacheTime = defaultCacheTime;
+    this.maxSize = maxSize;
+  }
   signals = /* @__PURE__ */ new Map();
-  gcInterval = null;
-  defaultStaleTime = 0;
-  // Immediately stale
-  defaultCacheTime = 5 * 60 * 1e3;
-  // 5 minutes
-  constructor(config) {
-    if (config?.enableGC !== false) {
-      this.startGarbageCollection();
-    }
+  gcTimers = /* @__PURE__ */ new Map();
+  lruOrder = /* @__PURE__ */ new Set();
+  generateKey(queryKey) {
+    const key = Array.isArray(queryKey) ? stableHash(queryKey) : stableHash([queryKey.key, queryKey.params]);
+    return key;
   }
-  /**
-   * Generate cache key from query key array
-   */
-  generateKey = (queryKey) => {
-    if (Array.isArray(queryKey)) {
-      return stableHash(queryKey);
+  get(key, autoCreate = true) {
+    let signal2 = this.signals.get(key);
+    if (signal2) {
+      this.touch(key);
     }
-    return stableHash([queryKey.key, queryKey.params]);
-  };
-  /**
-   * Get data (wrapper around signal.get)
-   */
-  get = (queryKey) => {
-    const key = this.generateKey(queryKey);
-    const signal = this.signals.get(key);
-    if (!signal) return void 0;
-    const entry = signal.get();
-    if (!entry) return void 0;
-    const now = Date.now();
-    const age = now - entry.timestamp;
-    if (age > entry.cacheTime) {
-      this.signals.delete(key);
-      return void 0;
+    if (!signal2 && autoCreate) {
+      const newSignal = createSignal(void 0, {
+        onActive: () => {
+          this.cancelGC(key);
+        },
+        onInactive: () => {
+          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;
     }
-    return entry.data;
-  };
-  /**
-   * Get Signal for a key (Low level API for hooks)
-   * Automatically creates a signal if one doesn't exist
-   */
-  getSignal = (queryKey) => {
-    const key = this.generateKey(queryKey);
-    let signal = this.signals.get(key);
-    if (!signal) {
-      signal = createSignal(void 0);
-      this.signals.set(key, signal);
+    return signal2;
+  }
+  tagIndex = /* @__PURE__ */ new Map();
+  set(key, entry) {
+    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);
+        }
+      }
     }
-    return signal;
-  };
-  /**
-   * Check if data is stale
-   */
-  isStale = (queryKey) => {
-    const key = this.generateKey(queryKey);
-    const signal = this.signals.get(key);
-    if (!signal) return true;
-    const entry = signal.get();
-    if (!entry) return true;
-    const now = Date.now();
-    const age = now - entry.timestamp;
-    return age > entry.staleTime;
-  };
-  /**
-   * Set cached data (updates signal)
-   */
-  set = (queryKey, data, options) => {
-    const key = this.generateKey(queryKey);
-    const entry = {
-      data,
-      timestamp: Date.now(),
-      staleTime: options?.staleTime !== void 0 ? options.staleTime : this.defaultStaleTime,
-      cacheTime: options?.cacheTime !== void 0 ? options.cacheTime : this.defaultCacheTime,
-      key: Array.isArray(queryKey) ? queryKey : [queryKey]
-    };
-    const existingSignal = this.signals.get(key);
-    if (existingSignal) {
-      existingSignal.set(entry);
-    } else {
-      this.signals.set(key, createSignal(entry));
+    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);
+      }
     }
-    const normalizedKey = Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
-    this.plugins.forEach((p) => p.onQueryUpdated?.(normalizedKey, data));
-  };
-  // --- DEDUPLICATION ---
-  deduplicationCache = /* @__PURE__ */ new Map();
-  // --- MIDDLEWARE / PLUGINS ---
-  plugins = [];
-  /**
-   * Register a middleware plugin
-   */
-  use = (plugin) => {
-    this.plugins.push(plugin);
-    return this;
-  };
-  /**
-   * Fetch data with deduplication.
-   * If a request for the same key is already in flight, returns the existing promise.
-   */
-  fetch = async (queryKey, fn) => {
-    const key = this.generateKey(queryKey);
-    const normalizedKey = Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
-    if (this.deduplicationCache.has(key)) {
-      return this.deduplicationCache.get(key);
+    let signal2 = this.signals.get(key);
+    if (signal2) {
+      signal2.set(entry);
+    } else {
+      const newSignal = createSignal(entry, {
+        onActive: () => {
+          this.cancelGC(key);
+        },
+        onInactive: () => {
+          const entry2 = this.signals.get(key)?.get();
+          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();
     }
-    this.plugins.forEach((p) => p.onFetchStart?.(normalizedKey));
-    const promise = fn().then(
-      (data) => {
-        this.deduplicationCache.delete(key);
-        this.plugins.forEach((p) => p.onFetchSuccess?.(normalizedKey, data));
-        return data;
-      },
-      (error) => {
-        this.deduplicationCache.delete(key);
-        this.plugins.forEach((p) => p.onFetchError?.(normalizedKey, error));
-        throw error;
+  }
+  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.deduplicationCache.set(key, promise);
-    return promise;
+    }
+    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();
+  }
+  getAll() {
+    const map = /* @__PURE__ */ new Map();
+    for (const [key, signal2] of this.signals.entries()) {
+      const val = signal2.get();
+      if (val) map.set(key, val);
+    }
+    return map;
+  }
+  getStats() {
+    return {
+      size: this.signals.size,
+      keys: Array.from(this.signals.keys()),
+      tags: this.tagIndex.size
+    };
+  }
+  getSnapshot() {
+    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) {
+    if (this.gcTimers.has(key)) {
+      clearTimeout(this.gcTimers.get(key));
+    }
+    const timer2 = setTimeout(() => {
+      this.delete(key);
+    }, delay2);
+    this.gcTimers.set(key, timer2);
+  }
+  cancelGC(key) {
+    if (this.gcTimers.has(key)) {
+      clearTimeout(this.gcTimers.get(key));
+      this.gcTimers.delete(key);
+    }
+  }
+};
+
+// src/query/remotes.ts
+var QueryRemotes = class {
+  deduplicationCache = /* @__PURE__ */ new Map();
+  async fetch(key, fn, options) {
+    if (this.deduplicationCache.has(key)) {
+      return this.deduplicationCache.get(key);
+    }
+    const promise = this.executeWithRetry(fn, options);
+    this.deduplicationCache.set(key, promise);
+    try {
+      const result = await promise;
+      this.deduplicationCache.delete(key);
+      return result;
+    } catch (error) {
+      this.deduplicationCache.delete(key);
+      throw error;
+    }
+  }
+  async executeWithRetry(fn, options) {
+    const maxRetries = this.resolveRetry(options?.retry);
+    let attempt = 0;
+    while (true) {
+      attempt++;
+      try {
+        return await fn({ signal: options?.signal });
+      } catch (error) {
+        if (attempt > maxRetries || options?.signal && options.signal.aborted) {
+          throw error;
+        }
+        let delay2 = 1e3 * 2 ** (attempt - 1);
+        if (options?.retryDelay) {
+          delay2 = typeof options.retryDelay === "number" ? options.retryDelay : options.retryDelay(attempt - 1);
+        }
+        delay2 = Math.min(delay2, 3e4);
+        await this.wait(delay2, options?.signal);
+      }
+    }
+  }
+  resolveRetry(retry) {
+    if (typeof retry === "number") return retry;
+    if (retry === false) return 0;
+    return 3;
+  }
+  wait(ms, signal2) {
+    return new Promise((resolve, reject) => {
+      if (signal2?.aborted) return reject(new Error("Aborted"));
+      const timer2 = setTimeout(() => {
+        cleanup();
+        resolve();
+      }, ms);
+      const onAbort = () => {
+        cleanup();
+        reject(new Error("Aborted"));
+      };
+      const cleanup = () => {
+        clearTimeout(timer2);
+        signal2?.removeEventListener("abort", onAbort);
+      };
+      signal2?.addEventListener("abort", onAbort);
+    });
+  }
+};
+
+// src/query/mutationCache.ts
+var MutationCache = class {
+  // Map<ID, Signal> - Stores state for every unique mutation execution
+  mutations = /* @__PURE__ */ new Map();
+  // Map<KeyHash, Set<ID>> - Index to find mutations by key
+  mutationKeys = /* @__PURE__ */ new Map();
+  /**
+   * Get or Create a Signal for a specific mutation instance (ID)
+   */
+  getSignal = (id) => {
+    let signal2 = this.mutations.get(id);
+    if (!signal2) {
+      const initialState = {
+        data: void 0,
+        error: null,
+        variables: void 0,
+        context: void 0,
+        status: "idle",
+        submittedAt: 0
+      };
+      signal2 = createSignal(initialState);
+      this.mutations.set(id, signal2);
+    }
+    return signal2;
   };
   /**
-   * Invalidate all queries
+   * Register a mutation ID with a Key (for tracking shared keys)
    */
-  invalidateAll = () => {
-    for (const key of this.signals.keys()) {
-      this.signals.get(key)?.set(void 0);
+  register = (id, key) => {
+    if (!key) return;
+    const hash = stableHash(key);
+    if (!this.mutationKeys.has(hash)) {
+      this.mutationKeys.set(hash, /* @__PURE__ */ new Set());
     }
+    this.mutationKeys.get(hash).add(id);
   };
   /**
-   * Remove a specific query from cache
+   * Unregister cleanup
    */
-  remove = (queryKey) => {
-    const key = this.generateKey(queryKey);
-    this.signals.delete(key);
+  unregister = (id, key) => {
+    if (!key) return;
+    const hash = stableHash(key);
+    const set = this.mutationKeys.get(hash);
+    if (set) {
+      set.delete(id);
+      if (set.size === 0) {
+        this.mutationKeys.delete(hash);
+      }
+    }
+    this.mutations.delete(id);
+  };
+  notify = (id, state) => {
+    const signal2 = this.getSignal(id);
+    const current = signal2.get();
+    signal2.set({ ...current, ...state });
   };
   /**
-   * Invalidate queries matching the key prefix
-   * Marks them as undefined to trigger refetches without breaking subscriptions
+   * Get number of mutations currently pending
    */
-  invalidate = (queryKey) => {
-    const prefix = this.generateKey(queryKey);
-    const normalizedKey = Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
-    this.plugins.forEach((p) => p.onInvalidate?.(normalizedKey));
-    const invalidateKey = (key) => {
-      const signal = this.signals.get(key);
-      if (signal) {
-        signal.set(void 0);
+  isMutating = (filters) => {
+    let count = 0;
+    if (filters?.mutationKey) {
+      const hash = stableHash(filters.mutationKey);
+      const ids = this.mutationKeys.get(hash);
+      if (!ids) return 0;
+      for (const id of ids) {
+        if (this.mutations.get(id)?.get().status === "pending") {
+          count++;
+        }
       }
-    };
-    invalidateKey(prefix);
-    for (const key of this.signals.keys()) {
-      if (key.startsWith(prefix.slice(0, -1))) {
-        invalidateKey(key);
+    } else {
+      for (const signal2 of this.mutations.values()) {
+        if (signal2.get().status === "pending") count++;
       }
     }
+    return count;
   };
+};
+
+// src/query/pluginManager.ts
+var PluginManager = class {
+  plugins = [];
+  client;
+  setClient(client) {
+    this.client = client;
+  }
+  add(plugin) {
+    this.plugins.push(plugin);
+  }
+  onFetchStart(queryKey) {
+    this.plugins.forEach((p) => p.onFetchStart?.(queryKey));
+  }
+  onFetchSuccess(queryKey, data) {
+    this.plugins.forEach((p) => p.onFetchSuccess?.(queryKey, data));
+  }
+  onFetchError(queryKey, error) {
+    this.plugins.forEach((p) => p.onFetchError?.(queryKey, error));
+  }
+  onInvalidate(queryKey) {
+    this.plugins.forEach((p) => p.onInvalidate?.(queryKey));
+  }
+  onQueryUpdated(queryKey, data) {
+    this.plugins.forEach((p) => p.onQueryUpdated?.(queryKey, data));
+  }
+};
+
+// 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;
+  // Mutation Cache
+  mutationCache = new MutationCache();
+  // Plugins
+  pluginManager = new PluginManager();
+  // Config defaults
+  defaultStaleTime;
+  defaultCacheTime;
+  defaultSchema;
+  constructor(config) {
+    this.defaultStaleTime = config?.defaultStaleTime ?? 0;
+    this.defaultCacheTime = config?.defaultCacheTime ?? 5 * 60 * 1e3;
+    this.defaultSchema = config?.defaultSchema;
+    this.storage = new QueryStorage(
+      this.defaultStaleTime,
+      this.defaultCacheTime,
+      config?.maxCacheSize
+    );
+    this.remotes = new QueryRemotes();
+    this.pluginManager.setClient(this);
+  }
+  // --- FACADE API ---
   /**
-   * Remove all cache entries
+   * Get data from storage
    */
-  clear = () => {
-    this.signals.clear();
+  get = (queryKey) => {
+    const key = this.storage.generateKey(queryKey);
+    const signal2 = this.storage.get(key, false);
+    if (!signal2) return void 0;
+    const entry = signal2.get();
+    if (!this.isCacheEntry(entry)) return void 0;
+    const now = Date.now();
+    const age = now - entry.timestamp;
+    if (age > entry.cacheTime) {
+      this.storage.delete(key);
+      return void 0;
+    }
+    return entry.data;
   };
   /**
-   * Prefetch data (same as set but explicit intent)
+   * Get Signal for reactivity (used by hooks)
    */
-  prefetch = (queryKey, data, options) => {
-    this.set(queryKey, data, options);
+  getSignal = (queryKey) => {
+    const key = this.storage.generateKey(queryKey);
+    return this.storage.get(key, true);
   };
   /**
-   * Garbage collection - remove expired entries
+   * Set data manually (Optimistic updates / Prefetch)
    */
-  startGarbageCollection = () => {
-    this.gcInterval = setInterval(() => {
-      const now = Date.now();
-      for (const [key, signal] of this.signals.entries()) {
-        const entry = signal.get();
-        if (!entry) continue;
-        const age = now - entry.timestamp;
-        if (age > entry.cacheTime) {
-          this.signals.delete(key);
-        }
-      }
-    }, 60 * 1e3);
+  set = (queryKey, data, options) => {
+    const key = this.storage.generateKey(queryKey);
+    const entry = {
+      data,
+      status: "success",
+      error: null,
+      isFetching: false,
+      fetchDirection: "idle",
+      timestamp: Date.now(),
+      staleTime: options?.staleTime ?? this.defaultStaleTime,
+      cacheTime: options?.cacheTime ?? this.defaultCacheTime,
+      key: queryKey,
+      tags: options?.tags
+    };
+    this.storage.set(key, entry);
+    const normalizedKey = this.normalizeKey(queryKey);
+    this.pluginManager.onQueryUpdated(normalizedKey, data);
   };
   /**
-   * Stop garbage collection
+   * Restore cache entry (Hydration)
    */
-  destroy = () => {
-    if (this.gcInterval) {
-      clearInterval(this.gcInterval);
-      this.gcInterval = null;
-    }
-    this.clear();
+  restore = (queryKey, entry) => {
+    const key = this.storage.generateKey(queryKey);
+    this.storage.set(key, entry);
+    const normalizedKey = this.normalizeKey(queryKey);
+    this.pluginManager.onQueryUpdated(normalizedKey, entry.data);
   };
   /**
-   * Get cache stats (for debugging)
+   * Fetch data (Orchestration)
    */
-  getStats = () => {
-    return {
-      size: this.signals.size,
-      keys: Array.from(this.signals.keys())
-    };
+  fetch = async (queryKey, fn, options) => {
+    const key = this.storage.generateKey(queryKey);
+    const normalizedKey = this.normalizeKey(queryKey);
+    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,
+      fetchDirection: direction,
+      timestamp: currentEntry?.timestamp || Date.now(),
+      staleTime: currentEntry?.staleTime ?? this.defaultStaleTime,
+      cacheTime: currentEntry?.cacheTime ?? this.defaultCacheTime,
+      key: queryKey,
+      tags: mergedTags
+    });
+    this.pluginManager.onFetchStart(normalizedKey);
+    try {
+      const data = await this.remotes.fetch(key, fn, {
+        signal: options?.signal,
+        retry: options?.retry,
+        retryDelay: options?.retryDelay
+      });
+      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 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;
+    }
   };
   /**
-   * Get all entries (wrapper for DevTools)
+   * Invalidate queries
    */
-  getAll = () => {
-    const map = /* @__PURE__ */ new Map();
-    for (const [key, signal] of this.signals.entries()) {
-      const val = signal.get();
-      if (val) map.set(key, val);
+  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 });
+          }
+        }
+      }
+    }
+  };
+  invalidateTags = (tags) => {
+    const tagsToInvalidate = new Set(tags);
+    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 });
+            }
+          }
+        }
+      }
     }
-    return map;
+  };
+  // --- Helpers ---
+  use = (plugin) => {
+    this.pluginManager.add(plugin);
+    return this;
+  };
+  isStale = (queryKey) => {
+    const key = this.storage.generateKey(queryKey);
+    const signal2 = this.storage.get(key);
+    const entry = signal2?.get();
+    if (!entry) return true;
+    if (entry.isInvalidated) return true;
+    return Date.now() - entry.timestamp > entry.staleTime;
+  };
+  getAll = () => this.storage.getAll();
+  snapshot = () => this.storage.getSnapshot();
+  clear = () => this.storage.clear();
+  remove = (key) => this.storage.delete(this.storage.generateKey(key));
+  // Restored Methods
+  prefetch = (queryKey, data, options) => {
+    this.set(queryKey, data, options);
+  };
+  destroy = () => {
+    this.storage.clear();
+  };
+  getStats = () => this.storage.getStats();
+  // For Hydration
+  getSnapshot = () => this.storage.getSnapshot();
+  invalidateAll = () => {
+    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 });
+      }
+    }
+  };
+  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);
   };
 };
-var queryCache = new QueryCache();
 
-// src/addon/query/pagination.ts
-import { useState, useEffect as useEffect2, useCallback as useCallback2, useRef as useRef2 } from "react";
+// src/query/pagination.ts
+import { useState as useState2, useEffect as useEffect2, useCallback, useRef as useRef2, useSyncExternalStore } from "react";
+
+// src/query/context.tsx
+import { createContext, useContext } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var QueryClientContext = createContext(void 0);
+var QueryClientProvider = ({
+  client,
+  children
+}) => {
+  return /* @__PURE__ */ jsx2(QueryClientContext.Provider, { value: client, children: children || null });
+};
+var useQueryClient = () => {
+  const client = useContext(QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client;
+};
+
+// src/query/pagination.ts
 function usePaginatedQuery({
   queryKey,
   queryFn,
   pageSize = 20,
   staleTime,
   cacheTime,
-  enabled = true
+  enabled = true,
+  retry
 }) {
-  const [page, setPage] = useState(0);
-  const [data, setData] = useState();
-  const [isLoading, setIsLoading] = useState(true);
-  const [isError, setIsError] = useState(false);
-  const [error, setError] = useState(null);
-  const [hasNext, setHasNext] = useState(true);
+  const client = useQueryClient();
+  const [page, setPage] = useState2(0);
+  const pageQueryKey = [...queryKey, "page", page];
+  const pageQueryKeyHash = JSON.stringify(pageQueryKey);
+  const subscribe = useCallback((onStoreChange) => {
+    const signal2 = client.getSignal(pageQueryKey);
+    return signal2.subscribe(() => onStoreChange());
+  }, [client, pageQueryKeyHash]);
+  const getSnapshot = useCallback(() => {
+    const signal2 = client.getSignal(pageQueryKey);
+    return signal2.get();
+  }, [client, pageQueryKeyHash]);
+  const cacheEntry = useSyncExternalStore(subscribe, getSnapshot);
+  const data = cacheEntry?.data;
+  const status = cacheEntry?.status || "pending";
+  const error = cacheEntry?.error || null;
+  const isFetching = cacheEntry?.isFetching || false;
+  const dataTimestamp = cacheEntry?.timestamp;
+  const isError = status === "error";
+  const isLoading = data === void 0 && (isFetching || status === "pending");
+  let hasNext = true;
+  if (data) {
+    if (Array.isArray(data)) {
+      hasNext = data.length === pageSize;
+    } else if (typeof data === "object" && "hasMore" in data) {
+      hasNext = !!data.hasMore;
+    }
+  }
+  const hasPrevious = page > 0;
   const queryFnRef = useRef2(queryFn);
+  const staleTimeRef = useRef2(staleTime);
+  const cacheTimeRef = useRef2(cacheTime);
   useEffect2(() => {
     queryFnRef.current = queryFn;
+    staleTimeRef.current = staleTime;
+    cacheTimeRef.current = cacheTime;
   });
-  const queryKeyHash = JSON.stringify(queryKey);
-  const fetchPage = useCallback2(async (pageNum) => {
+  const fetchPage = useCallback(async (background = false) => {
     if (!enabled) return;
-    const pageQueryKey = [...queryKey, "page", pageNum];
-    const cached = queryCache.get(pageQueryKey);
-    if (cached && !queryCache.isStale(pageQueryKey)) {
-      setData(cached);
-      setIsLoading(false);
-      return;
+    if (!background) {
+      const currentEntry = getSnapshot();
+      if (currentEntry && Date.now() - currentEntry.timestamp <= (staleTimeRef.current || 0)) {
+        return;
+      }
     }
     try {
-      setIsLoading(true);
-      setIsError(false);
-      setError(null);
-      const result = await queryFnRef.current(pageNum);
-      queryCache.set(pageQueryKey, result, { staleTime, cacheTime });
-      setData(result);
-      if (Array.isArray(result)) {
-        setHasNext(result.length === pageSize);
-      } else if (result && typeof result === "object" && "hasMore" in result) {
-        setHasNext(result.hasMore);
-      }
-      setIsLoading(false);
+      const result = await client.fetch(pageQueryKey, async () => {
+        return await queryFnRef.current(page);
+      }, { retry });
+      client.set(pageQueryKey, result, {
+        staleTime: staleTimeRef.current,
+        cacheTime: cacheTimeRef.current
+      });
     } catch (err) {
-      setIsError(true);
-      setError(err);
-      setIsLoading(false);
     }
-  }, [queryKeyHash, enabled, pageSize, staleTime, cacheTime]);
+  }, [pageQueryKeyHash, enabled, client, getSnapshot, page]);
   useEffect2(() => {
-    fetchPage(page);
-  }, [page, fetchPage]);
-  const nextPage = useCallback2(() => {
+    if (enabled) {
+      fetchPage();
+    }
+  }, [fetchPage, enabled]);
+  const nextPage = useCallback(() => {
     if (hasNext) {
       setPage((p) => p + 1);
     }
   }, [hasNext]);
-  const previousPage = useCallback2(() => {
+  const previousPage = useCallback(() => {
     if (page > 0) {
       setPage((p) => p - 1);
     }
   }, [page]);
-  const refetch = useCallback2(async () => {
-    queryCache.invalidate([...queryKey, "page", String(page)]);
-    await fetchPage(page);
-  }, [queryKeyHash, page, fetchPage]);
+  const refetch = useCallback(async () => {
+    client.invalidate(pageQueryKey);
+    await fetchPage();
+  }, [pageQueryKeyHash, fetchPage, client]);
   return {
     data,
     isLoading,
@@ -918,502 +1239,723 @@ function usePaginatedQuery({
     nextPage,
     previousPage,
     hasNext,
-    hasPrevious: page > 0,
+    hasPrevious,
     refetch
   };
 }
 
-// src/addon/query/useQuery.ts
-import { useEffect as useEffect3, useCallback as useCallback3, useRef as useRef3, useSyncExternalStore as useSyncExternalStore2, useReducer } from "react";
+// src/query/useQuery.ts
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback2, useSyncExternalStore as useSyncExternalStore2 } from "react";
 
-// src/addon/query/context.tsx
-import { createContext, useContext } from "react";
-import { jsx } from "react/jsx-runtime";
-var QueryClientContext = createContext(void 0);
-var QueryClientProvider = ({
-  client,
-  children
-}) => {
-  return /* @__PURE__ */ jsx(QueryClientContext.Provider, { value: client, children });
+// 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);
+      };
+    }
+  }
+  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 useQueryClient = () => {
-  const client = useContext(QueryClientContext);
-  return client || queryCache;
+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/useQuery.ts
-function useQuery({
-  queryKey,
-  queryFn,
-  schema,
-  staleTime = 0,
-  cacheTime = 5 * 60 * 1e3,
-  enabled = true,
-  refetchOnWindowFocus = false,
-  refetchOnReconnect = false,
-  refetchInterval
-}) {
-  const client = useQueryClient();
-  const queryKeyHash = stableHash(queryKey);
-  const subscribe2 = useCallback3((onStoreChange) => {
-    const signal = client.getSignal(queryKey);
-    return signal.subscribe(() => {
-      onStoreChange();
-    });
-  }, [client, queryKeyHash]);
-  const getSnapshot = useCallback3(() => {
-    const signal = client.getSignal(queryKey);
-    return signal.get();
-  }, [client, queryKeyHash]);
-  const cacheEntry = useSyncExternalStore2(subscribe2, getSnapshot);
-  const data = cacheEntry?.data;
-  const dataTimestamp = cacheEntry?.timestamp;
-  const [statusState, dispatch] = useReducer(statusReducer, {
-    isFetching: false,
-    error: null
-  });
-  const abortControllerRef = useRef3(null);
-  const intervalRef = useRef3(null);
-  const isStale = dataTimestamp ? Date.now() - dataTimestamp > staleTime : true;
-  const isLoading = data === void 0 && statusState.isFetching;
-  const derivedIsLoading = data === void 0;
-  const queryFnRef = useRef3(queryFn);
-  const schemaRef = useRef3(schema);
-  const queryKeyRef = useRef3(queryKey);
-  useEffect3(() => {
-    queryFnRef.current = queryFn;
-    schemaRef.current = schema;
-    queryKeyRef.current = queryKey;
-  });
-  const fetchData = useCallback3(async (background = false) => {
-    if (!enabled) return;
-    if (abortControllerRef.current) abortControllerRef.current.abort();
-    abortControllerRef.current = new AbortController();
-    if (!background) {
-      const currentEntry = getSnapshot();
-      if (currentEntry && Date.now() - currentEntry.timestamp <= staleTime) {
-        return;
+// src/query/queryObserver.ts
+var QueryObserver = class {
+  client;
+  // Reactive Inputs
+  options$;
+  // Reactive Outputs
+  result$;
+  // Internal
+  unsubscribe = null;
+  gcUnsubscribe = null;
+  abortController = null;
+  intervalParams = { id: null };
+  constructor(client, options) {
+    this.client = client;
+    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
+          };
+        }
+      }
+      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;
       }
+      lastResult = nextResult;
+      return nextResult;
+    });
+    this.initSideEffects();
+  }
+  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);
     }
-    try {
-      dispatch({ type: "FETCH_START", background });
-      const fn = queryFnRef.current;
-      const sc = schemaRef.current;
-      const key = queryKeyRef.current;
-      let result = await client.fetch(key, async () => {
-        let res = await fn();
-        if (sc) {
-          res = sc.parse(res);
+  }
+  subscribe(listener) {
+    const unsub = this.result$.subscribe(() => {
+      listener();
+    });
+    return unsub;
+  }
+  getSnapshot = () => {
+    return this.result$.get();
+  };
+  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());
         }
-        return res;
+      }
+    });
+    const disposeGC = effect(() => {
+      const opts = this.options$.get();
+      const signal2 = this.client.getSignal(opts.queryKey);
+      const unsub = signal2.subscribe(() => {
       });
-      client.set(key, result, { staleTime, cacheTime });
-      dispatch({ type: "FETCH_SUCCESS" });
-    } catch (err) {
-      if (err.name === "AbortError") return;
-      dispatch({ type: "FETCH_ERROR", error: err });
+      return () => unsub();
+    });
+    const disposeFocus = focusManager.subscribe(() => {
+      const opts = this.options$.get();
+      if (opts.enabled !== false && opts.refetchOnWindowFocus !== false) {
+        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 () => {
+    const opts = this.options$.get();
+    this.client.invalidate(opts.queryKey);
+    await this.fetch();
+  };
+  fetch = async (background = false) => {
+    const opts = this.options$.get();
+    if (opts.enabled === false) return;
+    if (this.abortController) {
+      this.abortController.abort();
     }
-  }, [queryKeyHash, enabled, staleTime, cacheTime, client, getSnapshot]);
-  useEffect3(() => {
-    if (data === void 0 && !statusState.error) {
-      fetchData();
+    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) {
     }
-  }, [fetchData, data, statusState.error]);
-  useEffect3(() => {
-    if (!enabled || !refetchInterval) return;
-    intervalRef.current = setInterval(() => fetchData(true), refetchInterval);
-    return () => {
-      if (intervalRef.current) clearInterval(intervalRef.current);
-    };
-  }, [enabled, refetchInterval, fetchData]);
+  };
+  destroy() {
+    if (this.unsubscribe) this.unsubscribe();
+    if (this.abortController) this.abortController.abort();
+  }
+};
+
+// src/query/useQuery.ts
+function useQuery(options) {
+  const client = useQueryClient();
+  const [observer] = useState3(() => new QueryObserver(client, options));
   useEffect3(() => {
-    if (!enabled || !refetchOnWindowFocus) return;
-    const handleFocus = () => {
-      const entry = getSnapshot();
-      const isStaleNow = !entry || Date.now() - entry.timestamp > staleTime;
-      if (isStaleNow) fetchData(true);
-    };
-    window.addEventListener("focus", handleFocus);
-    return () => window.removeEventListener("focus", handleFocus);
-  }, [enabled, refetchOnWindowFocus, fetchData, getSnapshot, staleTime]);
+    observer.setOptions(options);
+  }, [observer, options]);
   useEffect3(() => {
-    if (!enabled || !refetchOnReconnect) return;
-    const handleOnline = () => {
-      const entry = getSnapshot();
-      const isStaleNow = !entry || Date.now() - entry.timestamp > staleTime;
-      if (isStaleNow) fetchData(true);
+    return () => {
+      observer.destroy();
     };
-    window.addEventListener("online", handleOnline);
-    return () => window.removeEventListener("online", handleOnline);
-  }, [enabled, refetchOnReconnect, fetchData, getSnapshot, staleTime]);
-  const refetch = useCallback3(async () => {
-    client.invalidate(queryKey);
-    await fetchData();
-  }, [queryKeyHash, fetchData, client]);
+  }, [observer]);
+  const subscribe = useCallback2((onStoreChange) => {
+    return observer.subscribe(onStoreChange);
+  }, [observer]);
+  const getSnapshot = useCallback2(() => {
+    return observer.getSnapshot();
+  }, [observer]);
+  const result = useSyncExternalStore2(subscribe, getSnapshot);
   return {
-    data,
-    isLoading: derivedIsLoading,
-    isError: !!statusState.error,
-    isFetching: statusState.isFetching,
-    isStale,
-    error: statusState.error,
-    refetch
+    ...result,
+    signal: observer.result$
   };
 }
-function statusReducer(state, action) {
-  switch (action.type) {
-    case "FETCH_START":
-      return {
-        ...state,
-        isFetching: true,
-        error: null
-      };
-    case "FETCH_SUCCESS":
-      return {
-        ...state,
-        isFetching: false,
-        error: null
-      };
-    case "FETCH_ERROR":
-      return {
-        ...state,
-        isFetching: false,
-        error: action.error
-      };
-    default:
-      return state;
-  }
-}
 
-// src/addon/query/useMutation.ts
-import { useState as useState3, useCallback as useCallback4 } from "react";
-function useMutation({
-  mutationFn,
-  onMutate,
-  onSuccess,
-  onError,
-  onSettled
-}) {
-  const [data, setData] = useState3();
-  const [error, setError] = useState3(null);
-  const [isLoading, setIsLoading] = useState3(false);
-  const [isError, setIsError] = useState3(false);
-  const [isSuccess, setIsSuccess] = useState3(false);
-  const mutateAsync = useCallback4(async (variables) => {
+// src/query/useMutation.ts
+import { useCallback as useCallback3, useEffect as useEffect4, useSyncExternalStore as useSyncExternalStore3, useState as useState4 } from "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;
+  }
+  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) => {
+      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 {
-      setIsLoading(true);
-      setIsError(false);
-      setError(null);
-      setIsSuccess(false);
+      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);
-      setData(result);
-      setIsSuccess(true);
-      setIsLoading(false);
-      if (onSuccess) {
-        onSuccess(result, variables, context);
+      notify({ status: "success", data: result });
+      if (onSuccess) await onSuccess(result, variables, context);
+      if (this.client.invalidateTags && invalidatesTags) {
+        this.client.invalidateTags(invalidatesTags);
       }
-      if (onSettled) {
-        onSettled(result, null, variables, context);
+      if (optimistic) {
+        this.client.invalidate(optimistic.queryKey);
       }
+      if (onSettled) onSettled(result, null, variables, context);
       return result;
-    } catch (err) {
-      setIsError(true);
-      setError(err);
-      setIsLoading(false);
-      if (onError) {
-        onError(err, variables, context);
-      }
-      if (onSettled) {
-        onSettled(void 0, err, variables, context);
+    } catch (error) {
+      if (optimistic && optimisticSnapshot !== void 0) {
+        this.client.set(optimistic.queryKey, optimisticSnapshot);
       }
-      throw err;
+      notify({ status: "error", error });
+      if (onError) onError(error, variables, context);
+      if (onSettled) onSettled(void 0, error, variables, context);
+      throw error;
     }
-  }, [mutationFn, onMutate, onSuccess, onError, onSettled]);
-  const mutate = useCallback4(async (variables) => {
-    try {
-      await mutateAsync(variables);
-    } catch {
-    }
-  }, [mutateAsync]);
-  const reset = useCallback4(() => {
-    setData(void 0);
-    setError(null);
-    setIsLoading(false);
-    setIsError(false);
-    setIsSuccess(false);
-  }, []);
+  };
+  reset = () => {
+    this.signal.set({
+      status: "idle",
+      data: void 0,
+      error: null,
+      variables: void 0,
+      context: void 0,
+      submittedAt: 0
+    });
+    this.currentMutationId = null;
+  };
+};
+
+// src/query/useMutation.ts
+function useMutation(options) {
+  const client = useQueryClient();
+  const [observer] = useState4(() => new MutationObserver(client, options));
+  useEffect4(() => {
+    observer.setOptions(options);
+  }, [observer, options]);
+  const state = useSyncExternalStore3(
+    useCallback3((cb) => observer.signal.subscribe(cb), [observer]),
+    () => observer.signal.get()
+  );
+  const mutateAsync = useCallback3((variables) => {
+    return observer.mutate(variables);
+  }, [observer]);
+  const mutate = useCallback3((variables) => {
+    observer.mutate(variables).catch(() => {
+    });
+  }, [observer]);
   return {
     mutate,
     mutateAsync,
-    data,
-    error,
-    isLoading,
-    isError,
-    isSuccess,
-    reset
+    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
   };
 }
-var optimisticHelpers = {
-  /**
-   * Cancel ongoing queries for a key
-   */
-  async cancelQueries(queryKey) {
-  },
-  /**
-   * Get current query data
-   */
-  getQueryData(queryKey) {
-    return queryCache.get(queryKey);
-  },
-  /**
-   * Set query data (for optimistic updates)
-   */
-  setQueryData(queryKey, updater) {
-    const current = queryCache.get(queryKey);
-    const newData = typeof updater === "function" ? updater(current) : updater;
-    queryCache.set(queryKey, newData);
-    return current;
-  },
-  /**
-   * Invalidate queries (trigger refetch)
-   */
-  invalidateQueries(queryKey) {
-    queryCache.invalidate(queryKey);
-  }
+
+// src/query/infiniteQuery.ts
+import { useState as useState5, useEffect as useEffect5, useCallback as useCallback4, useSyncExternalStore as useSyncExternalStore4 } from "react";
+
+// src/query/plugins/logger.ts
+var consoleLogger = {
+  log: console.log,
+  warn: console.warn,
+  error: console.error
 };
+var currentLogger = consoleLogger;
+var getLogger = () => currentLogger;
 
-// src/addon/query/infiniteQuery.ts
-import { useEffect as useEffect4, useCallback as useCallback5, useRef as useRef4, useReducer as useReducer2, useSyncExternalStore as useSyncExternalStore3 } from "react";
-function statusReducer2(state, action) {
-  switch (action.type) {
-    case "FETCH_START":
-      return {
-        ...state,
-        isFetching: true,
-        isFetchingNextPage: action.direction === "next",
-        isFetchingPreviousPage: action.direction === "previous",
-        error: null
-      };
-    case "FETCH_SUCCESS":
-      return {
-        ...state,
-        isFetching: false,
-        isFetchingNextPage: false,
-        isFetchingPreviousPage: false,
-        hasNextPage: action.hasNextPage !== void 0 ? action.hasNextPage : state.hasNextPage,
-        hasPreviousPage: action.hasPreviousPage !== void 0 ? action.hasPreviousPage : state.hasPreviousPage
-      };
-    case "FETCH_ERROR":
-      return {
-        ...state,
-        isFetching: false,
-        isFetchingNextPage: false,
-        isFetchingPreviousPage: false,
-        error: action.error
-      };
-    case "SET_PAGINATION":
-      return {
-        ...state,
-        hasNextPage: action.hasNextPage !== void 0 ? action.hasNextPage : state.hasNextPage,
-        hasPreviousPage: action.hasPreviousPage !== void 0 ? action.hasPreviousPage : state.hasPreviousPage
+// 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
       };
-    default:
-      return state;
+      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();
   }
-}
-function useInfiniteQuery({
-  queryKey,
-  queryFn,
-  getNextPageParam,
-  getPreviousPageParam,
-  initialPageParam,
-  staleTime = 0,
-  cacheTime = 5 * 60 * 1e3,
-  enabled = true
-}) {
-  const client = useQueryClient();
-  const queryKeyHash = stableHash(queryKey);
-  const infiniteQueryKey = [...queryKey, "__infinite__"];
-  const subscribe2 = useCallback5((onStoreChange) => {
-    const signal = client.getSignal(infiniteQueryKey);
-    return signal.subscribe(() => onStoreChange());
-  }, [client, queryKeyHash]);
-  const getSnapshot = useCallback5(() => {
-    const signal = client.getSignal(infiniteQueryKey);
-    return signal.get();
-  }, [client, queryKeyHash]);
-  const cacheEntry = useSyncExternalStore3(subscribe2, getSnapshot);
-  const data = cacheEntry?.data;
-  const [statusState, dispatch] = useReducer2(statusReducer2, {
-    isFetching: false,
-    isFetchingNextPage: false,
-    isFetchingPreviousPage: false,
-    error: null,
-    hasNextPage: false,
-    // Will be set after first fetch
-    hasPreviousPage: false
-  });
-  const queryFnRef = useRef4(queryFn);
-  const getNextPageParamRef = useRef4(getNextPageParam);
-  const getPreviousPageParamRef = useRef4(getPreviousPageParam);
-  const initialFetchDoneRef = useRef4(false);
-  const clientRef = useRef4(client);
-  const infiniteQueryKeyRef = useRef4(infiniteQueryKey);
-  const initialPageParamRef = useRef4(initialPageParam);
-  const staleTimeRef = useRef4(staleTime);
-  const cacheTimeRef = useRef4(cacheTime);
-  useEffect4(() => {
-    queryFnRef.current = queryFn;
-    getNextPageParamRef.current = getNextPageParam;
-    getPreviousPageParamRef.current = getPreviousPageParam;
-    clientRef.current = client;
-    infiniteQueryKeyRef.current = infiniteQueryKey;
-    initialPageParamRef.current = initialPageParam;
-    staleTimeRef.current = staleTime;
-    cacheTimeRef.current = cacheTime;
-  });
-  const prevDataRef = useRef4(data);
-  useEffect4(() => {
-    if (prevDataRef.current && !data) {
-      initialFetchDoneRef.current = false;
+  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);
     }
-    prevDataRef.current = data;
-  }, [data]);
-  useEffect4(() => {
-    if (!enabled) return;
-    if (data) return;
-    const doFetch = async () => {
-      const initialParam = initialPageParamRef.current;
-      const firstParam = initialParam !== void 0 ? initialParam : 0;
-      if (!initialFetchDoneRef.current) {
-        initialFetchDoneRef.current = true;
+  }
+  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());
+        }
       }
-      dispatch({ type: "FETCH_START", direction: "initial" });
-      const pageKey = [...infiniteQueryKey, "initial", String(firstParam)];
-      let firstPage;
-      try {
-        firstPage = await clientRef.current.fetch(
-          pageKey,
-          () => queryFnRef.current({ pageParam: firstParam })
-        );
-      } catch (error) {
-        dispatch({ type: "FETCH_ERROR", error });
+    });
+    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();
+    };
+  }
+  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;
       }
-      if (firstPage) {
-        const initialData = {
+      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]
         };
-        let hasNext = false;
-        if (getNextPageParamRef.current) {
-          const nextParam = getNextPageParamRef.current(firstPage, [firstPage]);
-          hasNext = nextParam !== void 0;
-        }
-        clientRef.current.set(infiniteQueryKeyRef.current, initialData, {
-          staleTime: staleTimeRef.current,
-          cacheTime: cacheTimeRef.current
-        });
-        dispatch({ type: "FETCH_SUCCESS", hasNextPage: hasNext });
-      }
-    };
-    doFetch();
-  }, [enabled, data]);
-  const fetchPageHelper = useCallback5(async (pageParam) => {
-    try {
-      const pageKey = [...infiniteQueryKey, String(pageParam)];
-      return await clientRef.current.fetch(
-        pageKey,
-        () => queryFnRef.current({ pageParam })
-      );
-    } catch (error) {
-      dispatch({ type: "FETCH_ERROR", error });
-      return void 0;
+      }, { fetchDirection: "initial", retry: opts.retry });
+      this.client.set(infiniteKey, initialData, {
+        staleTime: opts.staleTime,
+        cacheTime: opts.cacheTime
+      });
+    } catch (err) {
+      getLogger().error("Initial fetch failed", err);
     }
-  }, [client, infiniteQueryKey]);
-  const fetchNextPage = useCallback5(async () => {
-    if (!statusState.hasNextPage || statusState.isFetchingNextPage || !data) return;
-    const lastPage = data.pages[data.pages.length - 1];
-    if (!lastPage || !getNextPageParamRef.current) return;
-    const nextPageParam = getNextPageParamRef.current(lastPage, data.pages);
+  };
+  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;
-    dispatch({ type: "FETCH_START", direction: "next" });
-    const newPage = await fetchPageHelper(nextPageParam);
-    if (newPage) {
-      const updatedData = {
-        pages: [...data.pages, newPage],
-        pageParams: [...data.pageParams, nextPageParam]
-      };
-      let hasNext = false;
-      if (getNextPageParamRef.current) {
-        const nextParam = getNextPageParamRef.current(newPage, updatedData.pages);
-        hasNext = nextParam !== void 0;
-      }
-      clientRef.current.set(infiniteQueryKeyRef.current, updatedData, {
-        staleTime: staleTimeRef.current,
-        cacheTime: cacheTimeRef.current
+    try {
+      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);
+        }
+        return {
+          pages: [...currentData.pages, newPage],
+          pageParams: updatedParams
+        };
+      }, { fetchDirection: "next", retry: opts.retry });
+      this.client.set(infiniteKey, updatedData, {
+        staleTime: opts.staleTime,
+        cacheTime: opts.cacheTime
       });
-      dispatch({ type: "FETCH_SUCCESS", hasNextPage: hasNext });
+    } catch (err) {
+      getLogger().error("Fetch next page failed", err);
     }
-  }, [statusState.hasNextPage, statusState.isFetchingNextPage, data, fetchPageHelper]);
-  const fetchPreviousPage = useCallback5(async () => {
-    if (!statusState.hasPreviousPage || statusState.isFetchingPreviousPage || !data) return;
-    const firstPage = data.pages[0];
-    if (!firstPage || !getPreviousPageParamRef.current) return;
-    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;
-    dispatch({ type: "FETCH_START", direction: "previous" });
-    const newPage = await fetchPageHelper(previousPageParam);
-    if (newPage) {
-      const updatedData = {
-        pages: [newPage, ...data.pages],
-        pageParams: [previousPageParam, ...data.pageParams]
-      };
-      let hasPrev = false;
-      if (getPreviousPageParamRef.current) {
-        const prevParam = getPreviousPageParamRef.current(newPage, updatedData.pages);
-        hasPrev = prevParam !== void 0;
-      }
-      clientRef.current.set(infiniteQueryKeyRef.current, updatedData, {
-        staleTime: staleTimeRef.current,
-        cacheTime: cacheTimeRef.current
+    try {
+      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: opts.retry });
+      this.client.set(infiniteKey, updatedData, {
+        staleTime: opts.staleTime,
+        cacheTime: opts.cacheTime
       });
-      dispatch({ type: "FETCH_SUCCESS", hasPreviousPage: hasPrev });
+    } catch (err) {
+      getLogger().error("Fetch previous page failed", err);
     }
-  }, [statusState.hasPreviousPage, statusState.isFetchingPreviousPage, data, fetchPageHelper]);
-  const refetch = useCallback5(async () => {
-    initialFetchDoneRef.current = false;
-    clientRef.current.invalidate(infiniteQueryKeyRef.current);
-  }, []);
-  return {
-    data,
-    fetchNextPage,
-    fetchPreviousPage,
-    hasNextPage: statusState.hasNextPage,
-    hasPreviousPage: statusState.hasPreviousPage,
-    isFetching: statusState.isFetching,
-    isFetchingNextPage: statusState.isFetchingNextPage,
-    isFetchingPreviousPage: statusState.isFetchingPreviousPage,
-    isLoading: data === void 0 && statusState.isFetching,
-    isError: !!statusState.error,
-    error: statusState.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] = useState5(() => new InfiniteQueryObserver(client, options));
+  useEffect5(() => {
+    observer.setOptions(options);
+  }, [observer, options]);
+  useEffect5(() => {
+    return () => {
+      observer.destroy();
+    };
+  }, [observer]);
+  const subscribe = useCallback4((onStoreChange) => {
+    return observer.result$.subscribe(() => onStoreChange());
+  }, [observer]);
+  const getSnapshot = useCallback4(() => {
+    return observer.result$.get();
+  }, [observer]);
+  return useSyncExternalStore4(subscribe, getSnapshot);
 }
 
-// src/addon/query/devtools.tsx
-import { useState as useState5, useMemo, useRef as useRef5, useEffect as useEffect6 } from "react";
+// src/query/HydrationBoundary.tsx
+import { useRef as useRef3 } from "react";
 
-// src/addon/query/useQueryCache.ts
-import { useState as useState4, useEffect as useEffect5 } from "react";
-function useQueryCache() {
+// src/query/hydration.ts
+function dehydrate(client) {
+  const queries = [];
+  const snapshot = client.getSnapshot();
+  snapshot.forEach((state, hash) => {
+    queries.push({
+      queryKey: state.key,
+      queryHash: hash,
+      state
+    });
+  });
+  return { queries };
+}
+function hydrate(client, state) {
+  if (!state || !state.queries) return;
+  state.queries.forEach(({ queryKey, state: queryState }) => {
+    const key = queryKey;
+    client.restore(queryKey, queryState);
+  });
+}
+
+// src/query/HydrationBoundary.tsx
+import { Fragment as Fragment2, jsx as jsx3 } from "react/jsx-runtime";
+function HydrationBoundary({ state, children }) {
   const client = useQueryClient();
-  const [cache, setCache] = useState4(client.getAll());
-  useEffect5(() => {
+  const hydratedRef = useRef3(false);
+  if (state && !hydratedRef.current) {
+    hydrate(client, state);
+    hydratedRef.current = true;
+  }
+  return /* @__PURE__ */ jsx3(Fragment2, { children });
+}
+
+// src/query/useSuspenseQuery.ts
+function useSuspenseQuery(options) {
+  const client = useQueryClient();
+  const signal2 = client.getSignal(options.queryKey);
+  const entry = signal2.get();
+  const shouldSuspend = !entry || entry.status === "pending" && entry.data === void 0;
+  if (shouldSuspend) {
+    const fetchPromise = client.fetch(
+      options.queryKey,
+      (ctx) => options.queryFn({ ...ctx, signal: void 0 }),
+      { signal: void 0 }
+    ).then((data) => {
+      client.set(options.queryKey, data);
+      return data;
+    });
+    throw fetchPromise;
+  }
+  if (entry?.status === "error") {
+    throw entry.error;
+  }
+  const query = useQuery(options);
+  return {
+    ...query,
+    data: query.data
+  };
+}
+
+// src/query/useQueryStore.ts
+import { useState as useState6, useEffect as useEffect6 } from "react";
+function useQueryStore() {
+  const client = useQueryClient();
+  const [cache, setCache] = useState6(client.getAll());
+  useEffect6(() => {
     const interval = setInterval(() => {
       setCache(new Map(client.getAll()));
     }, 500);
@@ -1422,430 +1964,45 @@ function useQueryCache() {
   return cache;
 }
 
-// src/addon/query/devtools.tsx
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
-function QuantumDevTools() {
-  const [isOpen, setIsOpen] = useState5(false);
-  const [isMinimized, setIsMinimized] = useState5(false);
-  const [height, setHeight] = useState5(450);
-  const [filter, setFilter] = useState5("");
-  const cache = useQueryCache();
+// src/query/useQuerySignal.ts
+import { useEffect as useEffect7, useState as useState7 } from "react";
+function useQuery$(options) {
   const client = useQueryClient();
-  const isResizingRef = useRef5(false);
-  const containerRef = useRef5(null);
-  useEffect6(() => {
-    const handleMouseMove = (e) => {
-      if (!isResizingRef.current) return;
-      const newHeight = window.innerHeight - e.clientY;
-      if (newHeight > 200 && newHeight < window.innerHeight - 50) {
-        setHeight(newHeight);
-      }
-    };
-    const handleMouseUp = () => {
-      isResizingRef.current = false;
-      document.body.style.cursor = "default";
-    };
-    window.addEventListener("mousemove", handleMouseMove);
-    window.addEventListener("mouseup", handleMouseUp);
+  const [observer] = useState7(() => new QueryObserver(client, options));
+  useEffect7(() => {
+    observer.setOptions(options);
+  }, [observer, options.enabled, options.staleTime, options.cacheTime, options.queryKey, options.refetchInterval]);
+  useEffect7(() => {
+    const unsubscribe = observer.subscribe(() => {
+    });
     return () => {
-      window.removeEventListener("mousemove", handleMouseMove);
-      window.removeEventListener("mouseup", handleMouseUp);
+      unsubscribe();
+      observer.destroy();
     };
-  }, []);
-  const entries = useMemo(() => Array.from(cache.entries()), [cache]);
-  const filteredEntries = useMemo(() => {
-    if (!filter) return entries;
-    const search = filter.toLowerCase();
-    return entries.filter(
-      ([_, entry]) => entry.key.some((k) => String(k).toLowerCase().includes(search))
-    );
-  }, [entries, filter]);
-  if (!isOpen) {
-    return /* @__PURE__ */ jsx2(
-      "button",
-      {
-        onClick: () => setIsOpen(true),
-        style: {
-          position: "fixed",
-          bottom: "20px",
-          right: "20px",
-          background: "#111",
-          color: "#b0fb5d",
-          // Quantum Green
-          border: "1px solid #333",
-          borderRadius: "50%",
-          width: "48px",
-          height: "48px",
-          cursor: "pointer",
-          zIndex: 9999,
-          boxShadow: "0 8px 32px rgba(0, 0, 0, 0.4)",
-          fontSize: "20px",
-          display: "flex",
-          alignItems: "center",
-          justifyContent: "center",
-          transition: "transform 0.2s",
-          fontFamily: "monospace"
-        },
-        onMouseEnter: (e) => e.currentTarget.style.transform = "scale(1.1)",
-        onMouseLeave: (e) => e.currentTarget.style.transform = "scale(1)",
-        title: "Open Quantum DevTools",
-        children: "\u26A1\uFE0F"
-      }
-    );
-  }
-  if (isMinimized) {
-    return /* @__PURE__ */ jsxs("div", { style: {
-      position: "fixed",
-      bottom: "20px",
-      right: "20px",
-      background: "#111",
-      border: "1px solid #333",
-      borderRadius: "8px",
-      padding: "8px 12px",
-      zIndex: 9999,
-      display: "flex",
-      alignItems: "center",
-      gap: "10px",
-      boxShadow: "0 8px 32px rgba(0, 0, 0, 0.4)",
-      fontFamily: "monospace",
-      color: "#e0e0e0",
-      cursor: "pointer"
-    }, onClick: () => setIsMinimized(false), children: [
-      /* @__PURE__ */ jsx2("span", { style: { color: "#b0fb5d" }, children: "\u26A1\uFE0F" }),
-      /* @__PURE__ */ jsx2("span", { style: { fontSize: "12px" }, children: "DevTools" }),
-      /* @__PURE__ */ jsxs("span", { style: {
-        background: "#333",
-        padding: "2px 6px",
-        borderRadius: "4px",
-        fontSize: "10px"
-      }, children: [
-        entries.length,
-        " queries"
-      ] })
-    ] });
-  }
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      ref: containerRef,
-      style: {
-        position: "fixed",
-        bottom: 0,
-        right: 0,
-        width: "100%",
-        height: `${height}px`,
-        background: "#0a0a0a",
-        color: "#e0e0e0",
-        borderTopLeftRadius: "12px",
-        borderTopRightRadius: "12px",
-        boxShadow: "0 -10px 40px rgba(0,0,0,0.5)",
-        zIndex: 9999,
-        display: "flex",
-        flexDirection: "column",
-        fontFamily: "'JetBrains Mono', 'Fira Code', monospace",
-        fontSize: "13px",
-        borderTop: "1px solid #333"
-      },
-      children: [
-        /* @__PURE__ */ jsx2(
-          "div",
-          {
-            onMouseDown: () => {
-              isResizingRef.current = true;
-              document.body.style.cursor = "ns-resize";
-            },
-            style: {
-              height: "6px",
-              width: "100%",
-              cursor: "ns-resize",
-              position: "absolute",
-              top: "-3px",
-              left: 0,
-              zIndex: 10
-              // debugging color: background: 'red', opacity: 0.2
-            }
-          }
-        ),
-        /* @__PURE__ */ jsxs("div", { style: {
-          padding: "12px 16px",
-          borderBottom: "1px solid #222",
-          display: "flex",
-          justifyContent: "space-between",
-          alignItems: "center",
-          background: "#111",
-          borderTopLeftRadius: "12px",
-          borderTopRightRadius: "12px",
-          userSelect: "none"
-        }, children: [
-          /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: "8px" }, children: [
-            /* @__PURE__ */ jsx2("span", { style: { color: "#b0fb5d", fontSize: "16px" }, children: "\u26A1\uFE0F" }),
-            /* @__PURE__ */ jsx2("span", { style: { fontWeight: 600, letterSpacing: "-0.5px" }, children: "Quantum DevTools" }),
-            /* @__PURE__ */ jsx2("span", { style: {
-              background: "#222",
-              padding: "2px 6px",
-              borderRadius: "4px",
-              fontSize: "10px",
-              color: "#666"
-            }, children: "v1.2.3" })
-          ] }),
-          /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "8px" }, children: [
-            /* @__PURE__ */ jsx2(
-              "button",
-              {
-                onClick: () => setIsMinimized(true),
-                title: "Minimize",
-                style: {
-                  background: "transparent",
-                  border: "none",
-                  color: "#666",
-                  cursor: "pointer",
-                  fontSize: "16px",
-                  padding: "4px",
-                  lineHeight: 1
-                },
-                children: "_"
-              }
-            ),
-            /* @__PURE__ */ jsx2(
-              "button",
-              {
-                onClick: () => setIsOpen(false),
-                title: "Close",
-                style: {
-                  background: "transparent",
-                  border: "none",
-                  color: "#666",
-                  cursor: "pointer",
-                  fontSize: "18px",
-                  padding: "4px",
-                  lineHeight: 1
-                },
-                children: "\xD7"
-              }
-            )
-          ] })
-        ] }),
-        /* @__PURE__ */ jsxs("div", { style: {
-          padding: "8px 16px",
-          borderBottom: "1px solid #222",
-          background: "#0f0f0f",
-          display: "flex",
-          gap: "12px"
-        }, children: [
-          /* @__PURE__ */ jsx2(
-            "input",
-            {
-              type: "text",
-              placeholder: "Filter queries...",
-              value: filter,
-              onChange: (e) => setFilter(e.target.value),
-              style: {
-                background: "#1a1a1a",
-                border: "1px solid #333",
-                color: "#fff",
-                padding: "6px 10px",
-                borderRadius: "4px",
-                flex: 1,
-                fontSize: "12px",
-                outline: "none"
-              }
-            }
-          ),
-          /* @__PURE__ */ jsx2(
-            "button",
-            {
-              onClick: () => client.invalidateAll(),
-              title: "Invalidate All Queries",
-              style: {
-                background: "#222",
-                border: "1px solid #333",
-                color: "#d69e2e",
-                borderRadius: "4px",
-                padding: "0 12px",
-                cursor: "pointer",
-                fontSize: "12px",
-                fontWeight: 500
-              },
-              children: "\u21BB Invalidate All"
-            }
-          )
-        ] }),
-        /* @__PURE__ */ jsx2("div", { style: {
-          flex: 1,
-          overflowY: "auto",
-          padding: "8px",
-          display: "flex",
-          flexDirection: "column",
-          gap: "8px",
-          background: "#050505"
-        }, children: entries.length === 0 ? /* @__PURE__ */ jsxs("div", { style: {
-          padding: "40px",
-          textAlign: "center",
-          color: "#444",
-          fontStyle: "italic"
-        }, children: [
-          "No active queries in cache.",
-          /* @__PURE__ */ jsx2("br", {}),
-          /* @__PURE__ */ jsx2("span", { style: { fontSize: "11px", opacity: 0.7 }, children: "(Note: Only `useQuery` calls appear here. Raw `api.get` calls are not cached globally.)" })
-        ] }) : filteredEntries.map(([keyHash, entry]) => /* @__PURE__ */ jsx2(
-          QueryItem,
-          {
-            entry,
-            client,
-            isStale: client.isStale(entry.key)
-          },
-          keyHash
-        )) })
-      ]
-    }
-  );
-}
-function QueryItem({ entry, client, isStale }) {
-  const [expanded, setExpanded] = useState5(false);
-  return /* @__PURE__ */ jsxs("div", { style: {
-    background: "#111",
-    borderRadius: "6px",
-    border: "1px solid #222",
-    overflow: "hidden"
-  }, children: [
-    /* @__PURE__ */ jsxs(
-      "div",
-      {
-        onClick: () => setExpanded(!expanded),
-        style: {
-          padding: "8px 12px",
-          display: "flex",
-          alignItems: "center",
-          justifyContent: "space-between",
-          cursor: "pointer",
-          background: expanded ? "#161616" : "transparent"
-        },
-        children: [
-          /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "10px", alignItems: "center", overflow: "hidden" }, children: [
-            /* @__PURE__ */ jsx2("span", { style: {
-              color: isStale ? "#d69e2e" : "#b0fb5d",
-              fontSize: "14px",
-              fontWeight: "bold",
-              minWidth: "10px"
-            }, children: isStale ? "\u2022" : "\u2022" }),
-            /* @__PURE__ */ jsxs("span", { style: {
-              color: "#e0e0e0",
-              fontWeight: 500,
-              whiteSpace: "nowrap",
-              overflow: "hidden",
-              textOverflow: "ellipsis"
-            }, children: [
-              "['",
-              entry.key.join("', '"),
-              "']"
-            ] })
-          ] }),
-          /* @__PURE__ */ jsxs("div", { style: { display: "flex", gap: "8px", alignItems: "center" }, children: [
-            /* @__PURE__ */ jsx2("span", { style: {
-              fontSize: "10px",
-              padding: "2px 6px",
-              borderRadius: "3px",
-              background: isStale ? "rgba(214, 158, 46, 0.15)" : "rgba(176, 251, 93, 0.15)",
-              color: isStale ? "#d69e2e" : "#b0fb5d",
-              border: `1px solid ${isStale ? "rgba(214, 158, 46, 0.3)" : "rgba(176, 251, 93, 0.3)"}`
-            }, children: isStale ? "STALE" : "FRESH" }),
-            /* @__PURE__ */ jsx2("span", { style: { color: "#666", fontSize: "10px" }, children: expanded ? "\u25BC" : "\u25B6" })
-          ] })
-        ]
-      }
-    ),
-    expanded && /* @__PURE__ */ jsxs("div", { style: {
-      padding: "10px",
-      borderTop: "1px solid #222",
-      background: "#0a0a0a"
-    }, children: [
-      /* @__PURE__ */ jsxs("div", { style: {
-        display: "flex",
-        gap: "8px",
-        marginBottom: "10px",
-        borderBottom: "1px solid #222",
-        paddingBottom: "8px"
-      }, children: [
-        /* @__PURE__ */ jsx2(
-          "button",
-          {
-            onClick: (e) => {
-              e.stopPropagation();
-              client.invalidate(entry.key);
-            },
-            style: {
-              background: "#222",
-              border: "1px solid #333",
-              color: "#d69e2e",
-              padding: "4px 10px",
-              borderRadius: "4px",
-              cursor: "pointer",
-              fontSize: "11px"
-            },
-            children: "Invalidate"
-          }
-        ),
-        /* @__PURE__ */ jsx2(
-          "button",
-          {
-            onClick: (e) => {
-              e.stopPropagation();
-              client.remove(entry.key);
-            },
-            style: {
-              background: "#222",
-              border: "1px solid #333",
-              color: "#ff4d4f",
-              padding: "4px 10px",
-              borderRadius: "4px",
-              cursor: "pointer",
-              fontSize: "11px"
-            },
-            children: "Remove"
-          }
-        )
-      ] }),
-      /* @__PURE__ */ jsx2("div", { style: { position: "relative" }, children: /* @__PURE__ */ jsx2("pre", { style: {
-        margin: 0,
-        fontSize: "11px",
-        color: "#a0a0a0",
-        overflowX: "auto",
-        fontFamily: "monospace"
-      }, children: JSON.stringify(entry.data, null, 2) }) }),
-      /* @__PURE__ */ jsxs("div", { style: {
-        marginTop: "8px",
-        fontSize: "10px",
-        color: "#444",
-        textAlign: "right"
-      }, children: [
-        "Updated: ",
-        new Date(entry.updatedAt).toLocaleTimeString()
-      ] })
-    ] })
-  ] });
+  }, [observer]);
+  return observer.result$;
 }
 export {
-  QuantumDevTools,
-  QueryCache,
+  HydrationBoundary,
+  QueryClient,
   QueryClientProvider,
-  computed,
+  SignalValue,
+  atom,
   createHttpClient,
-  createState,
-  defineModel,
+  dehydrate,
   enableDevTools,
   getPromiseState,
   handlePromise,
+  hydrate,
   isPromise,
-  optimisticHelpers,
-  queryCache,
   scheduleUpdate,
-  subscribe,
   unwrapPromise,
   useInfiniteQuery,
   useMutation,
   usePaginatedQuery,
   useQuery,
-  useQueryCache,
+  useQuery$,
   useQueryClient,
-  useStore
+  useQueryStore,
+  useSuspenseQuery
 };