@braine/quantum-query 1.2.5 → 1.2.6

package/dist/index.js

@@ -176,7 +176,7 @@ function defineModel(def) {
       engine = storage;
     }
     if (engine) {
-      const hydrate = () => {
+      const hydrate2 = () => {
         const process = (stored) => {
           try {
             if (stored) {
@@ -199,7 +199,7 @@ function defineModel(def) {
           if (debug) console.error(`[Quantum] Storage Access Failed`, err);
         }
       };
-      hydrate();
+      hydrate2();
       const save = debounce(async () => {
         try {
           let stateToSave;
@@ -262,8 +262,48 @@ function useStore(store) {
   return proxy;
 }
 
+// src/addon/signals.ts
+import { signal, computed as preactComputed, effect, batch } from "@preact/signals-core";
+function createSignal(initialValue, options) {
+  const s = signal(initialValue);
+  let unsubscribeActive;
+  let subscriberCount = 0;
+  return {
+    get: () => s.value,
+    set: (newValue) => {
+      s.value = newValue;
+    },
+    subscribe: (fn) => {
+      if (subscriberCount === 0) {
+        options?.onActive?.();
+      }
+      subscriberCount++;
+      const dispose = effect(() => {
+        fn(s.value);
+      });
+      return () => {
+        dispose();
+        subscriberCount--;
+        if (subscriberCount === 0) {
+          options?.onInactive?.();
+        }
+      };
+    }
+  };
+}
+
+// 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") {
+  registerStore(store, name);
   if (typeof window === "undefined" || !window.__REDUX_DEVTOOLS_EXTENSION__) return;
   const devTools = window.__REDUX_DEVTOOLS_EXTENSION__.connect({ name });
   devTools.init(store);
@@ -428,9 +468,15 @@ var FetchMiddleware = async (ctx) => {
 };
 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 +489,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);
@@ -581,319 +627,548 @@ function stableHash(value) {
   return "{" + keys.map((key) => `${key}:${stableHash(value[key])}`).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);
+// src/addon/query/queryStorage.ts
+var QueryStorage = class {
+  // Default configuration
+  constructor(defaultStaleTime = 0, defaultCacheTime = 5 * 60 * 1e3) {
+    this.defaultStaleTime = defaultStaleTime;
+    this.defaultCacheTime = defaultCacheTime;
+  }
+  signals = /* @__PURE__ */ new Map();
+  gcTimers = /* @__PURE__ */ new Map();
+  generateKey(queryKey) {
+    const key = Array.isArray(queryKey) ? stableHash(queryKey) : stableHash([queryKey.key, queryKey.params]);
+    return key;
+  }
+  get(key, autoCreate = true) {
+    let signal2 = this.signals.get(key);
+    if (!signal2 && autoCreate) {
+      const newSignal = createSignal(void 0, {
+        onActive: () => {
+          this.cancelGC(key);
+        },
+        onInactive: () => {
+          const entry = this.signals.get(key)?.get();
+          const cacheTime = entry?.cacheTime ?? this.defaultCacheTime;
+          this.scheduleGC(key, cacheTime);
+        }
+      });
+      this.signals.set(key, newSignal);
+      signal2 = newSignal;
     }
-  };
-  flush() {
-    const currentValue = this.value;
-    this.subscribers.forEach((fn) => fn(currentValue));
+    if (!signal2) return void 0;
+    return signal2;
   }
-  subscribe = (fn) => {
-    this.subscribers.add(fn);
-    return () => {
-      this.subscribers.delete(fn);
+  set(key, entry) {
+    const signal2 = this.signals.get(key);
+    if (signal2) {
+      signal2.set(entry);
+    } else {
+      this.signals.set(key, createSignal(entry, {
+        onActive: () => {
+          this.cancelGC(key);
+        },
+        onInactive: () => {
+          const entry2 = this.signals.get(key)?.get();
+          const cacheTime = entry2?.cacheTime ?? this.defaultCacheTime;
+          this.scheduleGC(key, cacheTime);
+        }
+      }));
+    }
+  }
+  delete(key) {
+    this.signals.delete(key);
+    this.cancelGC(key);
+  }
+  clear() {
+    this.signals.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())
     };
-  };
+  }
+  getSnapshot() {
+    return this.signals;
+  }
+  // --- 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);
+    }
+  }
 };
-function createSignal(initialValue) {
-  return new SignalImpl(initialValue);
-}
 
-// src/addon/query/queryCache.ts
-var QueryCache = class {
-  // Store signals instead of raw values
-  signals = /* @__PURE__ */ new Map();
-  gcInterval = null;
-  defaultStaleTime = 0;
-  // Immediately stale
-  defaultCacheTime = 5 * 60 * 1e3;
-  // 5 minutes
-  constructor(config) {
-    if (config?.enableGC !== false) {
-      this.startGarbageCollection();
+// src/addon/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/addon/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;
+  };
+  /**
+   * Register a mutation ID with a Key (for tracking shared keys)
+   */
+  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);
+  };
+  /**
+   * Unregister cleanup
+   */
+  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 });
+  };
   /**
-   * Generate cache key from query key array
+   * Get number of mutations currently pending
    */
-  generateKey = (queryKey) => {
-    if (Array.isArray(queryKey)) {
-      return stableHash(queryKey);
+  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++;
+        }
+      }
+    } else {
+      for (const signal2 of this.mutations.values()) {
+        if (signal2.get().status === "pending") count++;
+      }
     }
-    return stableHash([queryKey.key, queryKey.params]);
+    return count;
   };
+};
+
+// src/addon/query/pluginManager.ts
+var PluginManager = class {
+  plugins = [];
+  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/addon/query/queryCache.ts
+var QueryCache = class {
+  // Components
+  storage;
+  remotes;
+  // Mutation Cache
+  mutationCache = new MutationCache();
+  // Plugins
+  pluginManager = new PluginManager();
+  // Config defaults
+  defaultStaleTime;
+  defaultCacheTime;
+  constructor(config) {
+    this.defaultStaleTime = config?.defaultStaleTime ?? 0;
+    this.defaultCacheTime = config?.defaultCacheTime ?? 5 * 60 * 1e3;
+    this.storage = new QueryStorage(this.defaultStaleTime, this.defaultCacheTime);
+    this.remotes = new QueryRemotes();
+  }
+  // --- FACADE API ---
   /**
-   * Get data (wrapper around signal.get)
+   * Get data from storage
    */
   get = (queryKey) => {
-    const key = this.generateKey(queryKey);
-    const signal = this.signals.get(key);
-    if (!signal) return void 0;
-    const entry = signal.get();
+    const key = this.storage.generateKey(queryKey);
+    const signal2 = this.storage.get(key, false);
+    if (!signal2) return void 0;
+    const entry = signal2.get();
     if (!entry) return void 0;
     const now = Date.now();
     const age = now - entry.timestamp;
     if (age > entry.cacheTime) {
-      this.signals.delete(key);
+      this.storage.delete(key);
       return void 0;
     }
     return entry.data;
   };
   /**
-   * Get Signal for a key (Low level API for hooks)
-   * Automatically creates a signal if one doesn't exist
+   * Get Signal for reactivity (used by hooks)
    */
   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 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;
+    const key = this.storage.generateKey(queryKey);
+    return this.storage.get(key, true);
   };
   /**
-   * Set cached data (updates signal)
+   * Set data manually (Optimistic updates / Prefetch)
    */
   set = (queryKey, data, options) => {
-    const key = this.generateKey(queryKey);
+    const key = this.storage.generateKey(queryKey);
     const entry = {
       data,
+      status: "success",
+      error: null,
+      isFetching: false,
+      fetchDirection: "idle",
       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]
+      staleTime: options?.staleTime ?? this.defaultStaleTime,
+      cacheTime: options?.cacheTime ?? this.defaultCacheTime,
+      key: queryKey,
+      tags: options?.tags
     };
-    const existingSignal = this.signals.get(key);
-    if (existingSignal) {
-      existingSignal.set(entry);
-    } else {
-      this.signals.set(key, createSignal(entry));
-    }
-    const normalizedKey = Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
-    this.plugins.forEach((p) => p.onQueryUpdated?.(normalizedKey, data));
+    this.storage.set(key, entry);
+    const normalizedKey = this.normalizeKey(queryKey);
+    this.pluginManager.onQueryUpdated(normalizedKey, data);
   };
-  // --- DEDUPLICATION ---
-  deduplicationCache = /* @__PURE__ */ new Map();
-  // --- MIDDLEWARE / PLUGINS ---
-  plugins = [];
   /**
-   * Register a middleware plugin
+   * Restore cache entry (Hydration)
    */
-  use = (plugin) => {
-    this.plugins.push(plugin);
-    return this;
+  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);
   };
   /**
-   * Fetch data with deduplication.
-   * If a request for the same key is already in flight, returns the existing promise.
+   * Fetch data (Orchestration)
    */
-  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);
-    }
-    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;
+  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();
+    this.storage.set(key, {
+      data: currentEntry?.data,
+      status: currentEntry?.status || "pending",
+      error: null,
+      isFetching: true,
+      // Mark fetching
+      fetchDirection: direction,
+      timestamp: currentEntry?.timestamp || Date.now(),
+      staleTime: currentEntry?.staleTime ?? this.defaultStaleTime,
+      cacheTime: currentEntry?.cacheTime ?? this.defaultCacheTime,
+      key: queryKey,
+      tags: currentEntry?.tags
+    });
+    this.pluginManager.onFetchStart(normalizedKey);
+    try {
+      const data = await this.remotes.fetch(key, fn, {
+        signal: options?.signal,
+        retry: options?.retry,
+        retryDelay: options?.retryDelay
+      });
+      this.pluginManager.onFetchSuccess(normalizedKey, data);
+      return data;
+    } catch (error) {
+      const current = signal2.get();
+      if (current) {
+        this.storage.set(key, {
+          ...current,
+          status: "error",
+          error,
+          isFetching: false,
+          fetchDirection: "idle"
+        });
       }
-    );
-    this.deduplicationCache.set(key, promise);
-    return promise;
-  };
-  /**
-   * Invalidate all queries
-   */
-  invalidateAll = () => {
-    for (const key of this.signals.keys()) {
-      this.signals.get(key)?.set(void 0);
+      this.pluginManager.onFetchError(normalizedKey, error);
+      throw error;
     }
   };
   /**
-   * Remove a specific query from cache
-   */
-  remove = (queryKey) => {
-    const key = this.generateKey(queryKey);
-    this.signals.delete(key);
-  };
-  /**
-   * Invalidate queries matching the key prefix
-   * Marks them as undefined to trigger refetches without breaking subscriptions
+   * Invalidate queries
    */
   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);
+    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 });
+          }
+        }
       }
-    };
-    invalidateKey(prefix);
-    for (const key of this.signals.keys()) {
-      if (key.startsWith(prefix.slice(0, -1))) {
-        invalidateKey(key);
+    }
+  };
+  invalidateTags = (tags) => {
+    const tagsToInvalidate = new Set(tags);
+    const snapshot = this.storage.getSnapshot();
+    for (const [key, signal2] of snapshot.entries()) {
+      const entry = signal2.get();
+      if (entry && entry.tags) {
+        if (entry.tags.some((tag) => tagsToInvalidate.has(tag))) {
+          signal2.set({ ...entry, isInvalidated: true });
+        }
       }
     }
   };
-  /**
-   * Remove all cache entries
-   */
-  clear = () => {
-    this.signals.clear();
+  // --- Helpers ---
+  use = (plugin) => {
+    this.pluginManager.add(plugin);
+    return this;
   };
-  /**
-   * Prefetch data (same as set but explicit intent)
-   */
+  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);
   };
-  /**
-   * Garbage collection - remove expired entries
-   */
-  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);
-  };
-  /**
-   * Stop garbage collection
-   */
   destroy = () => {
-    if (this.gcInterval) {
-      clearInterval(this.gcInterval);
-      this.gcInterval = null;
-    }
-    this.clear();
+    this.storage.clear();
   };
-  /**
-   * Get cache stats (for debugging)
-   */
-  getStats = () => {
-    return {
-      size: this.signals.size,
-      keys: Array.from(this.signals.keys())
-    };
-  };
-  /**
-   * Get all entries (wrapper for DevTools)
-   */
-  getAll = () => {
-    const map = /* @__PURE__ */ new Map();
-    for (const [key, signal] of this.signals.entries()) {
-      const val = signal.get();
-      if (val) map.set(key, val);
+  getStats = () => this.storage.getStats();
+  // For Hydration
+  getSnapshot = () => this.storage.getSnapshot();
+  invalidateAll = () => {
+    for (const key of this.storage.getSnapshot().keys()) {
+      const signal2 = this.storage.get(key);
+      const entry = signal2?.get();
+      if (entry) {
+        signal2?.set({ ...entry, isInvalidated: true });
+      }
     }
-    return map;
   };
+  normalizeKey(queryKey) {
+    return Array.isArray(queryKey) ? queryKey : [queryKey.key, queryKey.params];
+  }
+};
+
+// src/addon/query/pagination.ts
+import { useState, useEffect as useEffect2, useCallback as useCallback2, useRef as useRef2, 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 });
+};
+var useQueryClient = () => {
+  const client = useContext(QueryClientContext);
+  if (!client) {
+    throw new Error("No QueryClient set, use QueryClientProvider to set one");
+  }
+  return client;
 };
-var queryCache = new QueryCache();
 
 // src/addon/query/pagination.ts
-import { useState, useEffect as useEffect2, useCallback as useCallback2, useRef as useRef2 } from "react";
 function usePaginatedQuery({
   queryKey,
   queryFn,
   pageSize = 20,
   staleTime,
   cacheTime,
-  enabled = true
+  enabled = true,
+  retry
 }) {
+  const client = useQueryClient();
   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 pageQueryKey = [...queryKey, "page", page];
+  const pageQueryKeyHash = JSON.stringify(pageQueryKey);
+  const subscribe2 = useCallback2((onStoreChange) => {
+    const signal2 = client.getSignal(pageQueryKey);
+    return signal2.subscribe(() => onStoreChange());
+  }, [client, pageQueryKeyHash]);
+  const getSnapshot = useCallback2(() => {
+    const signal2 = client.getSignal(pageQueryKey);
+    return signal2.get();
+  }, [client, pageQueryKeyHash]);
+  const cacheEntry = useSyncExternalStore2(subscribe2, 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 = useCallback2(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]);
+    if (enabled) {
+      fetchPage();
+    }
+  }, [fetchPage, enabled]);
   const nextPage = useCallback2(() => {
     if (hasNext) {
       setPage((p) => p + 1);
@@ -905,9 +1180,9 @@ function usePaginatedQuery({
     }
   }, [page]);
   const refetch = useCallback2(async () => {
-    queryCache.invalidate([...queryKey, "page", String(page)]);
-    await fetchPage(page);
-  }, [queryKeyHash, page, fetchPage]);
+    client.invalidate(pageQueryKey);
+    await fetchPage();
+  }, [pageQueryKeyHash, fetchPage, client]);
   return {
     data,
     isLoading,
@@ -918,313 +1193,447 @@ 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";
+import { useState as useState2, useEffect as useEffect3, useCallback as useCallback3, useSyncExternalStore as useSyncExternalStore3, useRef as useRef3 } 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 });
-};
-var useQueryClient = () => {
-  const client = useContext(QueryClientContext);
-  return client || queryCache;
-};
+// src/addon/query/plugins/validation.ts
+function validateWithSchema(data, schema) {
+  if (!schema) {
+    return data;
+  }
+  return schema.parse(data);
+}
 
-// 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();
+// src/addon/query/queryObserver.ts
+var QueryObserver = class {
+  client;
+  options;
+  queryKeyHash;
+  signal;
+  listeners = /* @__PURE__ */ new Set();
+  // Internal state management
+  abortController = null;
+  intervalParams = { id: null };
+  unsubscribeSignal = null;
+  // Derived state cache to ensure referential stability where possible
+  currentResult;
+  constructor(client, options) {
+    this.client = client;
+    this.options = options;
+    this.queryKeyHash = stableHash(options.queryKey);
+    this.signal = client.getSignal(options.queryKey);
+  }
+  setOptions(options) {
+    const prevOptions = this.options;
+    this.options = options;
+    const newHash = stableHash(options.queryKey);
+    if (newHash !== this.queryKeyHash) {
+      this.queryKeyHash = newHash;
+      this.updateSignal();
+      this.checkAndFetch();
+    } else {
+      if (options.enabled && !prevOptions.enabled) {
+        this.checkAndFetch();
+      }
+    }
+    if (options.refetchInterval !== prevOptions.refetchInterval) {
+      this.setupInterval();
+    }
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    if (this.listeners.size === 1) {
+      this.init();
+    }
+    return () => {
+      this.listeners.delete(listener);
+      if (this.listeners.size === 0) {
+        this.destroy();
+      }
+    };
+  }
+  init() {
+    this.updateSignal();
+    this.setupGlobalListeners();
+    this.setupInterval();
+    this.checkAndFetch();
+  }
+  destroy() {
+    this.cleanupGlobalListeners();
+    this.cleanupInterval();
+    if (this.unsubscribeSignal) {
+      this.unsubscribeSignal();
+      this.unsubscribeSignal = null;
+    }
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+  updateSignal() {
+    if (this.unsubscribeSignal) this.unsubscribeSignal();
+    this.signal = this.client.getSignal(this.options.queryKey);
+    this.unsubscribeSignal = this.signal.subscribe(() => {
+      this.notify();
     });
-  }, [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;
+  }
+  computeResult() {
+    const entry = this.signal.get();
+    const data = entry?.data;
+    const status = entry?.status || "pending";
+    const error = entry?.error || null;
+    const isFetching = entry?.isFetching || false;
+    const dataTimestamp = entry?.timestamp;
+    const staleTime = this.options.staleTime ?? 0;
+    const isStale = entry?.isInvalidated || (dataTimestamp ? Date.now() - dataTimestamp > staleTime : true);
+    const isError = status === "error";
+    const isLoading = data === void 0;
+    const nextResult = {
+      data,
+      isLoading,
+      isError,
+      isFetching,
+      isStale,
+      error,
+      status,
+      refetch: this.refetch
+    };
+    if (this.currentResult && this.shallowEqual(this.currentResult, nextResult)) {
+      return this.currentResult;
+    }
+    this.currentResult = nextResult;
+    return nextResult;
+  }
+  getSnapshot = () => {
+    if (!this.currentResult) {
+      return this.computeResult();
+    }
+    return this.currentResult;
+  };
+  shallowEqual(objA, objB) {
+    if (Object.is(objA, objB)) return true;
+    if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) return false;
+    const recordA = objA;
+    const recordB = objB;
+    const keysA = Object.keys(recordA);
+    const keysB = Object.keys(recordB);
+    if (keysA.length !== keysB.length) return false;
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(recordB, key) || !Object.is(recordA[key], recordB[key])) {
+        return false;
       }
     }
+    return true;
+  }
+  notify() {
+    this.computeResult();
+    this.listeners.forEach((l) => l());
+    this.checkAndFetch();
+  }
+  // --- Fetch Logic ---
+  fetch = async (background = false) => {
+    if (this.options.enabled === false) return;
+    if (this.abortController) this.abortController.abort();
+    this.abortController = new AbortController();
+    const signal2 = this.abortController.signal;
     try {
-      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);
-        }
-        return res;
+      let result = await this.client.fetch(
+        this.options.queryKey,
+        (ctx) => this.options.queryFn(ctx),
+        { signal: signal2, retry: this.options.retry, retryDelay: this.options.retryDelay }
+      );
+      try {
+        result = validateWithSchema(result, this.options.schema);
+      } catch (validationErr) {
+        const current = this.signal.get();
+        this.signal.set({
+          ...current,
+          status: "error",
+          error: validationErr,
+          isFetching: false,
+          data: void 0
+        });
+        return;
+      }
+      this.client.set(this.options.queryKey, result, {
+        staleTime: this.options.staleTime,
+        cacheTime: this.options.cacheTime,
+        tags: this.options.tags
       });
-      client.set(key, result, { staleTime, cacheTime });
-      dispatch({ type: "FETCH_SUCCESS" });
     } catch (err) {
-      if (err.name === "AbortError") return;
-      dispatch({ type: "FETCH_ERROR", error: err });
+      if (err instanceof Error && err.name === "AbortError") return;
+      if (err instanceof Error && err.name !== "AbortError") {
+      }
     }
-  }, [queryKeyHash, enabled, staleTime, cacheTime, client, getSnapshot]);
-  useEffect3(() => {
-    if (data === void 0 && !statusState.error) {
-      fetchData();
+  };
+  checkAndFetch() {
+    if (this.options.enabled === false) return;
+    const snapshot = this.getSnapshot();
+    if (snapshot.isLoading && !snapshot.isFetching && !snapshot.isError) {
+      this.fetch();
+    } else if (snapshot.isStale && !snapshot.isFetching && !snapshot.isError) {
+      this.fetch();
     }
-  }, [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]);
-  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]);
+  }
+  refetch = async () => {
+    this.client.invalidate(this.options.queryKey);
+    await this.fetch();
+  };
+  // --- Background Refetching ---
+  setupInterval() {
+    this.cleanupInterval();
+    if (this.options.enabled !== false && this.options.refetchInterval) {
+      this.intervalParams.id = setInterval(() => {
+        this.fetch(true);
+      }, this.options.refetchInterval);
+    }
+  }
+  cleanupInterval() {
+    if (this.intervalParams.id) {
+      clearInterval(this.intervalParams.id);
+      this.intervalParams.id = null;
+    }
+  }
+  onFocus = () => {
+    if (this.options.refetchOnWindowFocus) {
+      const snapshot = this.getSnapshot();
+      if (snapshot.isStale && !snapshot.isFetching) {
+        this.fetch(true);
+      }
+    }
+  };
+  onOnline = () => {
+    if (this.options.refetchOnReconnect) {
+      const snapshot = this.getSnapshot();
+      if (snapshot.isStale && !snapshot.isFetching) {
+        this.fetch(true);
+      }
+    }
+  };
+  setupGlobalListeners() {
+    if (typeof window !== "undefined") {
+      window.addEventListener("focus", this.onFocus);
+      window.addEventListener("online", this.onOnline);
+    }
+  }
+  cleanupGlobalListeners() {
+    if (typeof window !== "undefined") {
+      window.removeEventListener("focus", this.onFocus);
+      window.removeEventListener("online", this.onOnline);
+    }
+  }
+};
+
+// src/addon/query/useQuery.ts
+function useQuery(options) {
+  const client = useQueryClient();
+  const [observer] = useState2(() => new QueryObserver(client, options));
   useEffect3(() => {
-    if (!enabled || !refetchOnReconnect) return;
-    const handleOnline = () => {
-      const entry = getSnapshot();
-      const isStaleNow = !entry || Date.now() - entry.timestamp > staleTime;
-      if (isStaleNow) fetchData(true);
-    };
-    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.setOptions(options);
+  }, [observer, options]);
+  const subscribe2 = useCallback3((onStoreChange) => {
+    return observer.subscribe(onStoreChange);
+  }, [observer]);
+  const select = options?.select;
+  const selectRef = useRef3(select);
+  selectRef.current = select;
+  const memoRef = useRef3({ entry: void 0, selected: void 0 });
+  const getSnapshotWithSelector = useCallback3(() => {
+    const entry = observer.getSnapshot();
+    if (entry === memoRef.current.entry) {
+      return memoRef.current.selected;
+    }
+    let processedResult;
+    if (!entry) {
+      processedResult = void 0;
+    } else {
+      if (selectRef.current && entry.data !== void 0) {
+        processedResult = { ...entry, data: selectRef.current(entry.data) };
+      } else {
+        processedResult = entry;
+      }
+    }
+    memoRef.current = { entry, selected: processedResult };
+    return processedResult;
+  }, [observer]);
+  const result = useSyncExternalStore3(subscribe2, getSnapshotWithSelector);
+  const status = result?.status || "pending";
+  const computedResult = {
+    ...result,
+    isPending: status === "pending",
+    isSuccess: status === "success",
+    isError: status === "error"
+  };
+  const typedResult = computedResult;
+  const signal2 = client.getSignal(options.queryKey);
   return {
-    data,
-    isLoading: derivedIsLoading,
-    isError: !!statusState.error,
-    isFetching: statusState.isFetching,
-    isStale,
-    error: statusState.error,
-    refetch
+    ...typedResult,
+    signal: signal2
+    // Keep signal as T (source)
   };
 }
-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) => {
+import { useCallback as useCallback4, useEffect as useEffect4, useSyncExternalStore as useSyncExternalStore4, useState as useState3 } from "react";
+
+// src/addon/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) {
+        const queryCache = this.client;
+        queryCache.set(optimistic.queryKey, optimisticSnapshot);
       }
-      throw err;
-    }
-  }, [mutationFn, onMutate, onSuccess, onError, onSettled]);
-  const mutate = useCallback4(async (variables) => {
-    try {
-      await mutateAsync(variables);
-    } catch {
+      notify({ status: "error", error });
+      if (onError) onError(error, variables, context);
+      if (onSettled) onSettled(void 0, error, variables, context);
+      throw error;
     }
-  }, [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,
+      submittedAt: 0
+    });
+    this.currentMutationId = null;
+  };
+};
+
+// src/addon/query/useMutation.ts
+function useMutation(options) {
+  const client = useQueryClient();
+  const [observer] = useState3(() => new MutationObserver(client, options));
+  useEffect4(() => {
+    observer.setOptions(options);
+  }, [observer, options]);
+  const state = useSyncExternalStore4(
+    useCallback4((cb) => observer.signal.subscribe(cb), [observer]),
+    () => observer.signal.get()
+  );
+  const mutateAsync = useCallback4((variables) => {
+    return observer.mutate(variables);
+  }, [observer]);
+  const mutate = useCallback4((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/addon/query/infiniteQuery.ts
+import { useEffect as useEffect5, useCallback as useCallback5, useRef as useRef4, useSyncExternalStore as useSyncExternalStore5, useMemo } from "react";
+
+// src/addon/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
-      };
-    default:
-      return state;
-  }
-}
 function useInfiniteQuery({
   queryKey,
   queryFn,
@@ -1233,619 +1642,319 @@ function useInfiniteQuery({
   initialPageParam,
   staleTime = 0,
   cacheTime = 5 * 60 * 1e3,
-  enabled = true
+  enabled = true,
+  retry
 }) {
   const client = useQueryClient();
   const queryKeyHash = stableHash(queryKey);
-  const infiniteQueryKey = [...queryKey, "__infinite__"];
+  const infiniteQueryKey = useMemo(() => [...queryKey, "__infinite__"], [queryKeyHash]);
   const subscribe2 = useCallback5((onStoreChange) => {
-    const signal = client.getSignal(infiniteQueryKey);
-    return signal.subscribe(() => onStoreChange());
-  }, [client, queryKeyHash]);
+    const signal2 = client.getSignal(infiniteQueryKey);
+    return signal2.subscribe(() => onStoreChange());
+  }, [client, infiniteQueryKey]);
   const getSnapshot = useCallback5(() => {
-    const signal = client.getSignal(infiniteQueryKey);
-    return signal.get();
+    const signal2 = client.getSignal(infiniteQueryKey);
+    return signal2.get();
   }, [client, queryKeyHash]);
-  const cacheEntry = useSyncExternalStore3(subscribe2, getSnapshot);
+  const cacheEntry = useSyncExternalStore5(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 isFetching = cacheEntry?.isFetching || false;
+  const fetchDirection = cacheEntry?.fetchDirection || "idle";
+  const status = cacheEntry?.status || "pending";
+  const error = cacheEntry?.error || null;
+  const timestamp = cacheEntry?.timestamp || 0;
+  const isInvalidated = cacheEntry?.isInvalidated || false;
+  let hasNextPage = false;
+  let hasPreviousPage = false;
+  if (data && data.pages.length > 0) {
+    if (getNextPageParam) {
+      const lastPage = data.pages[data.pages.length - 1];
+      hasNextPage = getNextPageParam(lastPage, data.pages) !== void 0;
+    }
+    if (getPreviousPageParam) {
+      const firstPage = data.pages[0];
+      hasPreviousPage = getPreviousPageParam(firstPage, data.pages) !== void 0;
+    }
+  }
+  const isFetchingNextPage = isFetching && fetchDirection === "next";
+  const isFetchingPreviousPage = isFetching && fetchDirection === "previous";
+  const isLoading = data === void 0 && isFetching;
+  const isError = status === "error";
   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(() => {
+  useEffect5(() => {
     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;
-    }
-    prevDataRef.current = data;
-  }, [data]);
-  useEffect4(() => {
+  useEffect5(() => {
     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;
-      }
-      dispatch({ type: "FETCH_START", direction: "initial" });
-      const pageKey = [...infiniteQueryKey, "initial", String(firstParam)];
-      let firstPage;
+    if (data && !isInvalidated && Date.now() - timestamp <= staleTime) return;
+    if (isFetching) return;
+    const doInitialFetch = async () => {
       try {
-        firstPage = await clientRef.current.fetch(
-          pageKey,
-          () => queryFnRef.current({ pageParam: firstParam })
-        );
-      } catch (error) {
-        dispatch({ type: "FETCH_ERROR", error });
-        return;
-      }
-      if (firstPage) {
-        const initialData = {
-          pages: [firstPage],
-          pageParams: [firstParam]
-        };
-        let hasNext = false;
-        if (getNextPageParamRef.current) {
-          const nextParam = getNextPageParamRef.current(firstPage, [firstPage]);
-          hasNext = nextParam !== void 0;
+        if (data && data.pageParams.length > 0) {
+          const updatedPages = [];
+          const updatedParams = [];
+          let param = data.pageParams[0];
+          updatedParams.push(param);
+          const limit = data.pages.length;
+          const fetchedData = await client.fetch(infiniteQueryKey, async () => {
+            for (let i = 0; i < limit; i++) {
+              const page = await queryFnRef.current({ pageParam: param });
+              updatedPages.push(page);
+              if (i < limit - 1) {
+                const next = getNextPageParamRef.current?.(page, updatedPages);
+                if (next === void 0) break;
+                param = next;
+                updatedParams.push(param);
+              }
+            }
+            return {
+              pages: updatedPages,
+              pageParams: updatedParams
+            };
+          }, { fetchDirection: "initial", retry });
+          client.set(infiniteQueryKey, fetchedData, {
+            staleTime: staleTimeRef.current,
+            cacheTime: cacheTimeRef.current
+          });
+          return;
         }
-        clientRef.current.set(infiniteQueryKeyRef.current, initialData, {
+        const initialParam = initialPageParamRef.current;
+        const firstParam = initialParam !== void 0 ? initialParam : 0;
+        const initialData = await client.fetch(infiniteQueryKey, async () => {
+          const firstPage = await queryFnRef.current({ pageParam: firstParam });
+          return {
+            pages: [firstPage],
+            pageParams: [firstParam]
+          };
+        }, { fetchDirection: "initial", retry });
+        client.set(infiniteQueryKey, initialData, {
           staleTime: staleTimeRef.current,
           cacheTime: cacheTimeRef.current
         });
-        dispatch({ type: "FETCH_SUCCESS", hasNextPage: hasNext });
+      } catch (err) {
+        getLogger().error("Initial fetch failed", err);
       }
     };
-    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;
-    }
-  }, [client, infiniteQueryKey]);
+    doInitialFetch();
+  }, [enabled, data === void 0, isInvalidated, staleTime, timestamp]);
   const fetchNextPage = useCallback5(async () => {
-    if (!statusState.hasNextPage || statusState.isFetchingNextPage || !data) return;
+    if (!hasNextPage || isFetching || !data) return;
     const lastPage = data.pages[data.pages.length - 1];
-    if (!lastPage || !getNextPageParamRef.current) return;
-    const nextPageParam = getNextPageParamRef.current(lastPage, data.pages);
+    const nextPageParam = getNextPageParamRef.current?.(lastPage, 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, {
+    try {
+      const updatedData = await client.fetch(infiniteQueryKey, async ({ signal: signal2 }) => {
+        const newPage = await queryFnRef.current({ pageParam: nextPageParam });
+        const currentEntry = client.getSignal(infiniteQueryKey).get();
+        const currentData = currentEntry?.data;
+        if (!currentData) throw new Error("Infinite query data missing during fetchNextPage");
+        const nextCursor = getNextPageParamRef.current?.(newPage, [...currentData.pages, newPage]);
+        const updatedParams = [...currentData.pageParams, nextPageParam];
+        if (nextCursor !== void 0) {
+          updatedParams.push(nextCursor);
+        }
+        return {
+          pages: [...currentData.pages, newPage],
+          pageParams: updatedParams
+        };
+      }, {
+        fetchDirection: "next",
+        retry
+      });
+      client.set(infiniteQueryKey, updatedData, {
         staleTime: staleTimeRef.current,
         cacheTime: cacheTimeRef.current
       });
-      dispatch({ type: "FETCH_SUCCESS", hasNextPage: hasNext });
+    } catch (err) {
+      getLogger().error("Fetch next page failed", err);
     }
-  }, [statusState.hasNextPage, statusState.isFetchingNextPage, data, fetchPageHelper]);
+  }, [hasNextPage, isFetching, data, client, JSON.stringify(infiniteQueryKey)]);
   const fetchPreviousPage = useCallback5(async () => {
-    if (!statusState.hasPreviousPage || statusState.isFetchingPreviousPage || !data) return;
+    if (!hasPreviousPage || isFetching || !data) return;
     const firstPage = data.pages[0];
-    if (!firstPage || !getPreviousPageParamRef.current) return;
-    const previousPageParam = getPreviousPageParamRef.current(firstPage, data.pages);
+    const previousPageParam = getPreviousPageParamRef.current?.(firstPage, 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, {
+    try {
+      const updatedData = await client.fetch(infiniteQueryKey, async () => {
+        const newPage = await queryFnRef.current({ pageParam: previousPageParam });
+        const currentEntry = client.getSignal(infiniteQueryKey).get();
+        const currentData = currentEntry?.data;
+        if (!currentData) throw new Error("Infinite query data missing during fetchPreviousPage");
+        return {
+          pages: [newPage, ...currentData.pages],
+          pageParams: [previousPageParam, ...currentData.pageParams]
+        };
+      }, { fetchDirection: "previous", retry });
+      client.set(infiniteQueryKey, updatedData, {
         staleTime: staleTimeRef.current,
         cacheTime: cacheTimeRef.current
       });
-      dispatch({ type: "FETCH_SUCCESS", hasPreviousPage: hasPrev });
+    } catch (err) {
+      getLogger().error("Fetch previous page failed", err);
     }
-  }, [statusState.hasPreviousPage, statusState.isFetchingPreviousPage, data, fetchPageHelper]);
+  }, [hasPreviousPage, isFetching, data, client, JSON.stringify(infiniteQueryKey)]);
   const refetch = useCallback5(async () => {
-    initialFetchDoneRef.current = false;
-    clientRef.current.invalidate(infiniteQueryKeyRef.current);
-  }, []);
+    client.invalidate(infiniteQueryKey);
+  }, [client, JSON.stringify(infiniteQueryKey)]);
   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,
+    hasNextPage,
+    hasPreviousPage,
+    isFetching,
+    isFetchingNextPage,
+    isFetchingPreviousPage,
+    isLoading,
+    isError,
+    error,
     refetch
   };
 }
 
-// src/addon/query/devtools.tsx
-import { useState as useState5, useMemo, useRef as useRef5, useEffect as useEffect6 } from "react";
+// src/addon/query/HydrationBoundary.tsx
+import { useRef as useRef5 } from "react";
+
+// src/addon/query/hydration.ts
+function dehydrate(client) {
+  const queries = [];
+  const snapshot = client.getSnapshot();
+  snapshot.forEach((signal2, hash) => {
+    const state = signal2.get();
+    if (state) {
+      queries.push({
+        queryKey: state.key,
+        queryHash: hash,
+        state
+      });
+    }
+  });
+  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/addon/query/useQueryCache.ts
-import { useState as useState4, useEffect as useEffect5 } from "react";
-function useQueryCache() {
+// src/addon/query/HydrationBoundary.tsx
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+function HydrationBoundary({ state, children }) {
   const client = useQueryClient();
-  const [cache, setCache] = useState4(client.getAll());
-  useEffect5(() => {
-    const interval = setInterval(() => {
-      setCache(new Map(client.getAll()));
-    }, 500);
-    return () => clearInterval(interval);
-  }, [client]);
-  return cache;
+  const hydratedRef = useRef5(false);
+  if (state && !hydratedRef.current) {
+    hydrate(client, state);
+    hydratedRef.current = true;
+  }
+  return /* @__PURE__ */ jsx2(Fragment, { children });
 }
 
-// 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/addon/query/useSuspenseQuery.ts
+function useSuspenseQuery(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);
-    return () => {
-      window.removeEventListener("mousemove", handleMouseMove);
-      window.removeEventListener("mouseup", handleMouseUp);
-    };
-  }, []);
-  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
-        )) })
-      ]
+  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,
+      // @ts-ignore
+      (ctx) => options.queryFn(ctx),
+      { 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/core/bridge.ts
+function fromSignal(signal2) {
+  const initial = signal2.get();
+  const isObject = typeof initial === "object" && initial !== null;
+  const target = isObject ? initial : { value: initial };
+  const proxy = createState(target);
+  signal2.subscribe((newValue) => {
+    if (typeof newValue === "object" && newValue !== null) {
+      Object.assign(proxy, newValue);
+    } else {
+      proxy.value = newValue;
     }
-  );
+  });
+  return proxy;
 }
-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()
-      ] })
-    ] })
-  ] });
+function toSignal(selector) {
+  const s = createSignal(void 0);
+  let isComputing = false;
+  const onDependencyChange = () => {
+    if (isComputing) return;
+    run();
+  };
+  const run = () => {
+    isComputing = true;
+    setActiveListener(onDependencyChange);
+    try {
+      const value = selector();
+      s.set(value);
+    } finally {
+      setActiveListener(null);
+      isComputing = false;
+    }
+  };
+  run();
+  return {
+    get: s.get,
+    set: () => {
+      throw new Error("Cannot set a read-only bridge signal");
+    },
+    subscribe: s.subscribe
+  };
 }
 export {
-  QuantumDevTools,
+  HydrationBoundary,
   QueryCache,
   QueryClientProvider,
   computed,
   createHttpClient,
   createState,
   defineModel,
+  dehydrate,
   enableDevTools,
+  fromSignal,
   getPromiseState,
   handlePromise,
+  hydrate,
   isPromise,
-  optimisticHelpers,
-  queryCache,
   scheduleUpdate,
   subscribe,
+  toSignal,
   unwrapPromise,
   useInfiniteQuery,
   useMutation,
   usePaginatedQuery,
   useQuery,
-  useQueryCache,
   useQueryClient,
-  useStore
+  useStore,
+  useSuspenseQuery
 };