@braine/quantum-query 1.1.1 → 1.2.1

package/dist/index.js

@@ -58,6 +58,7 @@ function getPromiseState(promise) {
 // src/core/proxy.ts
 var LISTENERS = /* @__PURE__ */ new WeakMap();
 var PROXIES = /* @__PURE__ */ new WeakMap();
+var PROXY_TO_TARGET = /* @__PURE__ */ new WeakMap();
 var activeListener = null;
 function setActiveListener(listener) {
   activeListener = listener;
@@ -67,10 +68,11 @@ function getActiveListener() {
 }
 var GLOBAL_LISTENERS = /* @__PURE__ */ new WeakMap();
 function subscribe(store, callback) {
-  let listeners = GLOBAL_LISTENERS.get(store);
+  const target = PROXY_TO_TARGET.get(store) || store;
+  let listeners = GLOBAL_LISTENERS.get(target);
   if (!listeners) {
     listeners = /* @__PURE__ */ new Set();
-    GLOBAL_LISTENERS.set(store, listeners);
+    GLOBAL_LISTENERS.set(target, listeners);
   }
   listeners.add(callback);
   return () => listeners?.delete(callback);
@@ -87,8 +89,6 @@ var handler = {
     }
     const value = Reflect.get(target, prop, receiver);
     if (isPromise(value)) {
-      if (prop === "$state") {
-      }
       return unwrapPromise(value);
     }
     if (typeof value === "object" && value !== null) {
@@ -132,10 +132,18 @@ function createState(initialState) {
   }
   const proxy = new Proxy(initialState, handler);
   PROXIES.set(initialState, proxy);
+  PROXY_TO_TARGET.set(proxy, initialState);
   return proxy;
 }
 
 // src/core/model.ts
+function debounce(fn, ms) {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => fn(...args), ms);
+  };
+}
 function defineModel(def) {
   const target = def.state;
   if (def.actions) {
@@ -156,7 +164,69 @@ function defineModel(def) {
       }
     }
   }
-  return createState(target);
+  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();
+      });
+    }
+  }
+  return proxy;
 }
 
 // src/react/autoHook.ts
@@ -217,8 +287,7 @@ function computed(fn) {
   };
 }
 
-// src/addon/httpClient.ts
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// src/addon/clientTypes.ts
 var HttpError = class extends Error {
   constructor(status, message) {
     super(message);
@@ -226,156 +295,259 @@ var HttpError = class extends Error {
     this.name = "HttpError";
   }
 };
-function createHttpClient(config) {
-  let isRefreshing = false;
-  let refreshPromise = null;
-  const inflightRequests = /* @__PURE__ */ new Map();
-  const getRetryConfig = (reqConfig) => {
-    const raw = reqConfig?.retry ?? config.retry;
-    if (raw === void 0 || raw === 0) return null;
-    if (typeof raw === "number") {
-      return { retries: raw, baseDelay: 1e3, maxDelay: 5e3 };
-    }
-    return raw;
+
+// src/addon/middleware/types.ts
+function compose(middleware) {
+  return (ctx, next) => {
+    let index = -1;
+    async function dispatch(i) {
+      index = i;
+      let fn = middleware[i];
+      if (i === middleware.length) fn = next;
+      if (!fn) return Promise.resolve(new Response(null, { status: 404 }));
+      try {
+        return fn(ctx, dispatch.bind(null, i + 1));
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    }
+    return dispatch(0);
+  };
+}
+
+// src/addon/middleware/dedupe.ts
+var DedupeMiddleware = async (ctx, next) => {
+  if (ctx.req.method !== "GET") {
+    return next(ctx);
+  }
+  const key = `${ctx.req.method}:${ctx.req.url}`;
+  if (ctx.inflight.has(key)) {
+    const promise = ctx.inflight.get(key);
+    const response = await promise;
+    return response.clone();
+  }
+  const sharedPromise = next(ctx).then((res) => {
+    return res;
+  }).catch((err) => {
+    ctx.inflight.delete(key);
+    throw err;
+  });
+  ctx.inflight.set(key, sharedPromise);
+  try {
+    const response = await sharedPromise;
+    return response.clone();
+  } finally {
+    ctx.inflight.delete(key);
+  }
+};
+
+// src/addon/middleware/cache.ts
+var CacheMiddleware = async (ctx, next) => {
+  const { method, url } = ctx.req;
+  const { cache: cacheConfig } = ctx.config;
+  if (method !== "GET" || !cacheConfig?.ttl || cacheConfig.force) {
+    return next(ctx);
+  }
+  const key = `${method}:${url}`;
+  const cache = ctx.cache;
+  if (cache.has(key)) {
+    const entry = cache.get(key);
+    if (entry.expiresAt > Date.now()) {
+      const blob = JSON.stringify(entry.data);
+      return new Response(blob, { status: 200, statusText: "OK (Cached)" });
+    } else {
+      cache.delete(key);
+    }
+  }
+  const response = await next(ctx);
+  if (response.ok) {
+    const clone = response.clone();
+    const text = await clone.text();
+    try {
+      const data = JSON.parse(text);
+      cache.set(key, {
+        data,
+        // Storing raw data object
+        timestamp: Date.now(),
+        expiresAt: Date.now() + cacheConfig.ttl
+      });
+    } catch {
+    }
+  }
+  return response;
+};
+
+// src/addon/middleware/auth.ts
+var AuthMiddleware = async (ctx, next) => {
+  const { auth } = ctx.client.config;
+  if (auth && auth.getToken && !ctx.req.headers.get("Authorization")) {
+    const token = await auth.getToken();
+    if (token) {
+      const newHeaders = new Headers(ctx.req.headers);
+      newHeaders.set("Authorization", `Bearer ${token}`);
+      const newReq = new Request(ctx.req, {
+        headers: newHeaders
+      });
+      ctx.req = newReq;
+    }
+  }
+  const response = await next(ctx);
+  if (response.status === 401 && auth && auth.onTokenExpired) {
+    try {
+      const newToken = await auth.onTokenExpired(ctx.client);
+      if (newToken) {
+        const newHeaders = new Headers(ctx.req.headers);
+        newHeaders.set("Authorization", `Bearer ${newToken}`);
+        const newReq = new Request(ctx.req.url, {
+          method: ctx.req.method,
+          headers: newHeaders,
+          body: ctx.req.body,
+          mode: ctx.req.mode,
+          credentials: ctx.req.credentials,
+          cache: ctx.req.cache,
+          redirect: ctx.req.redirect,
+          referrer: ctx.req.referrer,
+          integrity: ctx.req.integrity
+        });
+        ctx.req = newReq;
+        return next(ctx);
+      } else {
+        auth.onAuthFailed?.();
+        throw new HttpError(401, "Authentication Failed");
+      }
+    } catch (err) {
+      throw err;
+    }
+  }
+  return response;
+};
+
+// src/addon/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 attempt = async (count) => {
+    try {
+      const response = await next(ctx);
+      if (!response.ok && response.status !== 401) {
+        if (response.status < 500 && response.status !== 429) {
+          return response;
+        }
+        throw new HttpError(response.status, response.statusText);
+      }
+      return response;
+    } catch (err) {
+      if (count < retries) {
+        if (err.name === "AbortError") throw err;
+        const d = Math.min(baseDelay * 2 ** count, maxDelay);
+        await delay(d);
+        return attempt(count + 1);
+      }
+      throw err;
+    }
   };
+  return attempt(0);
+};
+
+// src/addon/httpClient.ts
+function createHttpClient(config) {
+  const cache = /* @__PURE__ */ new Map();
+  const inflight = /* @__PURE__ */ new Map();
+  const pipeline = compose([
+    DedupeMiddleware,
+    CacheMiddleware,
+    AuthMiddleware,
+    RetryMiddleware,
+    FetchMiddleware
+  ]);
   const client = {
+    config,
+    // Expose for middleware access
     async request(endpoint, options = {}) {
       let url = config.baseURL ? `${config.baseURL}${endpoint}` : endpoint;
-      const method = options.method || "GET";
-      const isGet = method.toUpperCase() === "GET";
-      const dedupeKey = isGet ? `${method}:${url}` : null;
-      if (dedupeKey && inflightRequests.has(dedupeKey)) {
-        return inflightRequests.get(dedupeKey);
-      }
-      const retryConfig = getRetryConfig(options);
+      let headers = new Headers({
+        "Content-Type": "application/json",
+        ...config.headers,
+        ...options.headers
+      });
       const timeoutMs = options.timeout ?? config.timeout ?? 1e4;
       const controller = new AbortController();
       const id = setTimeout(() => controller.abort(), timeoutMs);
       const userSignal = options.signal;
-      let finalSignal = controller.signal;
       if (userSignal) {
         if (userSignal.aborted) {
           clearTimeout(id);
           throw new Error("Aborted");
         }
+        userSignal.addEventListener("abort", () => {
+          clearTimeout(id);
+          controller.abort();
+        });
       }
-      const executeBaseRequest = async (overrideToken) => {
-        let headers = {
-          "Content-Type": "application/json",
-          ...config.headers,
-          ...options.headers
-        };
-        if (overrideToken) {
-          headers["Authorization"] = `Bearer ${overrideToken}`;
-        } else if (config.auth) {
-          const token = await config.auth.getToken();
-          if (token) {
-            headers["Authorization"] = `Bearer ${token}`;
-          }
-        }
-        let requestConfig = {
+      let req = new Request(url, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+      if (config.interceptors?.request) {
+        const newConfig = await config.interceptors.request({ ...options, headers: Object.fromEntries(headers) });
+        req = new Request(url, {
+          ...newConfig,
+          signal: controller.signal
+        });
+      }
+      const ctx = {
+        req,
+        config: {
           ...options,
-          headers,
-          signal: finalSignal
-        };
-        if (config.interceptors?.request) {
-          requestConfig = await config.interceptors.request(requestConfig);
+          retry: options.retry !== void 0 ? options.retry : config.retry
+        },
+        // Merge retry
+        cache,
+        inflight,
+        client: this
+        // Pass client for Auth access hooks
+      };
+      try {
+        let response = await pipeline(ctx, async () => new Response("Internal Error", { status: 500 }));
+        clearTimeout(id);
+        if (config.interceptors?.response) {
+          response = await config.interceptors.response(response);
         }
-        try {
-          if (userSignal?.aborted) throw new DOMException("Aborted", "AbortError");
-          let response = await fetch(url, requestConfig);
-          if (config.interceptors?.response) {
-            response = await config.interceptors.response(response);
-          }
-          return response;
-        } catch (error) {
-          throw error;
+        if (!response.ok) {
+          throw new HttpError(response.status, `HTTP Error ${response.status}`);
         }
-      };
-      const attemptRequest = async (attempt) => {
-        try {
-          const response = await executeBaseRequest();
-          if (response.status === 401 && config.auth) {
-            if (!isRefreshing) {
-              isRefreshing = true;
-              refreshPromise = config.auth.onTokenExpired(client).finally(() => {
-                isRefreshing = false;
-                refreshPromise = null;
-              });
-            }
-            const newToken = await refreshPromise;
-            if (newToken) {
-              return executeBaseRequest(newToken);
-            } else {
-              config.auth.onAuthFailed?.();
-              throw new HttpError(401, "Authentication Failed");
-            }
-          }
-          if (!response.ok) {
-            throw new HttpError(response.status, `HTTP Error ${response.status}`);
+        let data;
+        if (response.status === 204) {
+          data = {};
+        } else {
+          const text = await response.text();
+          try {
+            data = JSON.parse(text);
+          } catch {
+            data = text;
           }
-          return response;
-        } catch (error) {
-          if (retryConfig && attempt < retryConfig.retries) {
-            const isAbort = error.name === "AbortError";
-            if (isAbort) throw error;
-            if (error instanceof HttpError) {
-              if (error.status < 500 && error.status !== 429) {
-                throw error;
-              }
-            }
-            const d = Math.min(
-              retryConfig.baseDelay * 2 ** attempt,
-              retryConfig.maxDelay
-            );
-            await delay(d);
-            return attemptRequest(attempt + 1);
-          }
-          throw error;
         }
-      };
-      const execute = async () => {
-        try {
-          const response = await attemptRequest(0);
-          clearTimeout(id);
-          let data;
-          if (response.status === 204) {
-            data = {};
-          } else {
-            const text = await response.text();
-            try {
-              data = JSON.parse(text);
-            } catch {
-              data = text;
+        if (options.schema) {
+          try {
+            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)}`);
             }
+            throw error;
           }
-          if (options.schema) {
-            try {
-              if (options.schema.parse) {
-                return options.schema.parse(data);
-              } else if (options.schema.validateSync) {
-                return options.schema.validateSync(data);
-              }
-            } catch (error) {
-              throw new Error(`Validation Error: ${error}`);
-            }
-          }
-          return data;
-        } catch (err) {
-          clearTimeout(id);
-          throw err;
-        }
-      };
-      const promise = execute();
-      if (dedupeKey) {
-        inflightRequests.set(dedupeKey, promise);
-      }
-      try {
-        return await promise;
-      } finally {
-        if (dedupeKey) {
-          inflightRequests.delete(dedupeKey);
         }
+        return data;
+      } catch (err) {
+        clearTimeout(id);
+        throw err;
       }
     },
     get(url, config2) {
@@ -396,8 +568,993 @@ function createHttpClient(config) {
   };
   return client;
 }
+
+// src/addon/query/utils.ts
+function stableHash(value) {
+  if (value === null || typeof value !== "object") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return "[" + value.map(stableHash).join(",") + "]";
+  }
+  const keys = Object.keys(value).sort();
+  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);
+    }
+  };
+  flush() {
+    const currentValue = this.value;
+    this.subscribers.forEach((fn) => fn(currentValue));
+  }
+  subscribe = (fn) => {
+    this.subscribers.add(fn);
+    return () => {
+      this.subscribers.delete(fn);
+    };
+  };
+};
+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();
+    }
+  }
+  /**
+   * Generate cache key from query key array
+   */
+  generateKey = (queryKey) => {
+    if (Array.isArray(queryKey)) {
+      return stableHash(queryKey);
+    }
+    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;
+    }
+    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 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));
+    }
+    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);
+    }
+    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;
+      }
+    );
+    this.deduplicationCache.set(key, promise);
+    return promise;
+  };
+  /**
+   * Invalidate queries matching the key prefix
+   * Marks them as undefined to trigger refetches without breaking subscriptions
+   */
+  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);
+      }
+    };
+    invalidateKey(prefix);
+    for (const key of this.signals.keys()) {
+      if (key.startsWith(prefix.slice(0, -1))) {
+        invalidateKey(key);
+      }
+    }
+  };
+  /**
+   * Remove all cache entries
+   */
+  clear = () => {
+    this.signals.clear();
+  };
+  /**
+   * Prefetch data (same as set but explicit intent)
+   */
+  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();
+  };
+  /**
+   * 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);
+    }
+    return map;
+  };
+};
+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
+}) {
+  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 queryFnRef = useRef2(queryFn);
+  useEffect2(() => {
+    queryFnRef.current = queryFn;
+  });
+  const queryKeyHash = JSON.stringify(queryKey);
+  const fetchPage = useCallback2(async (pageNum) => {
+    if (!enabled) return;
+    const pageQueryKey = [...queryKey, "page", pageNum];
+    const cached = queryCache.get(pageQueryKey);
+    if (cached && !queryCache.isStale(pageQueryKey)) {
+      setData(cached);
+      setIsLoading(false);
+      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);
+    } catch (err) {
+      setIsError(true);
+      setError(err);
+      setIsLoading(false);
+    }
+  }, [queryKeyHash, enabled, pageSize, staleTime, cacheTime]);
+  useEffect2(() => {
+    fetchPage(page);
+  }, [page, fetchPage]);
+  const nextPage = useCallback2(() => {
+    if (hasNext) {
+      setPage((p) => p + 1);
+    }
+  }, [hasNext]);
+  const previousPage = useCallback2(() => {
+    if (page > 0) {
+      setPage((p) => p - 1);
+    }
+  }, [page]);
+  const refetch = useCallback2(async () => {
+    queryCache.invalidate([...queryKey, "page", String(page)]);
+    await fetchPage(page);
+  }, [queryKeyHash, page, fetchPage]);
+  return {
+    data,
+    isLoading,
+    isError,
+    error,
+    page,
+    setPage,
+    nextPage,
+    previousPage,
+    hasNext,
+    hasPrevious: page > 0,
+    refetch
+  };
+}
+
+// src/addon/query/useQuery.ts
+import { useEffect as useEffect3, useCallback as useCallback3, useRef as useRef3, useSyncExternalStore as useSyncExternalStore2, useReducer } 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/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;
+      }
+    }
+    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;
+      });
+      client.set(key, result, { staleTime, cacheTime });
+      dispatch({ type: "FETCH_SUCCESS" });
+    } catch (err) {
+      if (err.name === "AbortError") return;
+      dispatch({ type: "FETCH_ERROR", error: err });
+    }
+  }, [queryKeyHash, enabled, staleTime, cacheTime, client, getSnapshot]);
+  useEffect3(() => {
+    if (data === void 0 && !statusState.error) {
+      fetchData();
+    }
+  }, [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]);
+  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]);
+  return {
+    data,
+    isLoading: derivedIsLoading,
+    isError: !!statusState.error,
+    isFetching: statusState.isFetching,
+    isStale,
+    error: statusState.error,
+    refetch
+  };
+}
+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) => {
+    let context;
+    try {
+      setIsLoading(true);
+      setIsError(false);
+      setError(null);
+      setIsSuccess(false);
+      if (onMutate) {
+        context = await onMutate(variables);
+      }
+      const result = await mutationFn(variables);
+      setData(result);
+      setIsSuccess(true);
+      setIsLoading(false);
+      if (onSuccess) {
+        onSuccess(result, variables, context);
+      }
+      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);
+      }
+      throw err;
+    }
+  }, [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);
+  }, []);
+  return {
+    mutate,
+    mutateAsync,
+    data,
+    error,
+    isLoading,
+    isError,
+    isSuccess,
+    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 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,
+  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;
+    }
+    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;
+      }
+      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 });
+        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;
+        }
+        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;
+    }
+  }, [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);
+    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
+      });
+      dispatch({ type: "FETCH_SUCCESS", hasNextPage: hasNext });
+    }
+  }, [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);
+    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
+      });
+      dispatch({ type: "FETCH_SUCCESS", hasPreviousPage: hasPrev });
+    }
+  }, [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
+  };
+}
+
+// src/addon/query/devtools.tsx
+import { useState as useState5 } from "react";
+
+// src/addon/query/useQueryCache.ts
+import { useState as useState4, useEffect as useEffect5 } from "react";
+function useQueryCache() {
+  const client = useQueryClient();
+  const [cache, setCache] = useState4(client.getAll());
+  useEffect5(() => {
+    const interval = setInterval(() => {
+      setCache({ ...client.getAll() });
+    }, 500);
+    return () => clearInterval(interval);
+  }, [client]);
+  return cache;
+}
+
+// src/addon/query/devtools.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function QuantumDevTools() {
+  const [isOpen, setIsOpen] = useState5(false);
+  const cache = useQueryCache();
+  const client = useQueryClient();
+  if (!isOpen) {
+    return /* @__PURE__ */ jsx2(
+      "button",
+      {
+        onClick: () => setIsOpen(true),
+        style: {
+          position: "fixed",
+          bottom: "10px",
+          right: "10px",
+          background: "#000",
+          color: "#fff",
+          border: "none",
+          borderRadius: "50%",
+          width: "40px",
+          height: "40px",
+          cursor: "pointer",
+          zIndex: 9999,
+          boxShadow: "0 4px 6px rgba(0,0,0,0.1)",
+          fontSize: "20px",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center"
+        },
+        children: "\u26A1\uFE0F"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs("div", { style: {
+    position: "fixed",
+    bottom: 0,
+    right: 0,
+    width: "100%",
+    maxWidth: "600px",
+    height: "400px",
+    background: "#1a1a1a",
+    color: "#fff",
+    borderTopLeftRadius: "10px",
+    boxShadow: "0 -4px 20px rgba(0,0,0,0.3)",
+    zIndex: 9999,
+    display: "flex",
+    flexDirection: "column",
+    fontFamily: "monospace"
+  }, children: [
+    /* @__PURE__ */ jsxs("div", { style: {
+      padding: "10px",
+      borderBottom: "1px solid #333",
+      display: "flex",
+      justifyContent: "space-between",
+      alignItems: "center",
+      background: "#222",
+      borderTopLeftRadius: "10px"
+    }, children: [
+      /* @__PURE__ */ jsx2("span", { style: { fontWeight: "bold" }, children: "\u26A1\uFE0F Quantum DevTools" }),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          onClick: () => setIsOpen(false),
+          style: {
+            background: "transparent",
+            border: "none",
+            color: "#999",
+            cursor: "pointer",
+            fontSize: "16px"
+          },
+          children: "\u2715"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx2("div", { style: {
+      flex: 1,
+      overflowY: "auto",
+      padding: "10px",
+      display: "flex",
+      flexDirection: "column",
+      gap: "8px"
+    }, children: Array.from(cache.entries()).length === 0 ? /* @__PURE__ */ jsx2("div", { style: { padding: "20px", textAlign: "center", color: "#666" }, children: "No active queries" }) : Array.from(cache.entries()).map(([keyHash, entry]) => /* @__PURE__ */ jsxs("div", { style: {
+      background: "#2a2a2a",
+      borderRadius: "4px",
+      padding: "8px",
+      border: "1px solid #333"
+    }, children: [
+      /* @__PURE__ */ jsxs("div", { style: { display: "flex", justifyContent: "space-between", marginBottom: "8px" }, children: [
+        /* @__PURE__ */ jsx2("span", { style: { color: "#aaa", fontSize: "12px" }, children: entry.key.map((k) => String(k)).join(" / ") }),
+        /* @__PURE__ */ jsx2("div", { style: { display: "flex", gap: "5px" }, children: /* @__PURE__ */ jsx2("span", { style: {
+          fontSize: "10px",
+          padding: "2px 4px",
+          borderRadius: "2px",
+          background: client.isStale(entry.key) ? "#dda0dd" : "#90ee90",
+          color: "#000"
+        }, children: client.isStale(entry.key) ? "STALE" : "FRESH" }) })
+      ] }),
+      /* @__PURE__ */ jsx2("div", { style: {
+        fontSize: "11px",
+        color: "#ddd",
+        whiteSpace: "pre-wrap",
+        maxHeight: "100px",
+        overflow: "hidden",
+        opacity: 0.8
+      }, children: JSON.stringify(entry.data, null, 2) }),
+      /* @__PURE__ */ jsxs("div", { style: { marginTop: "8px", display: "flex", gap: "8px" }, children: [
+        /* @__PURE__ */ jsx2(
+          "button",
+          {
+            onClick: () => client.invalidate(entry.key),
+            style: {
+              background: "#444",
+              border: "none",
+              color: "#fff",
+              padding: "4px 8px",
+              borderRadius: "3px",
+              cursor: "pointer",
+              fontSize: "10px"
+            },
+            children: "Invalidate"
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "button",
+          {
+            onClick: () => {
+              client.invalidate(entry.key);
+            },
+            style: {
+              background: "#444",
+              border: "none",
+              color: "#fff",
+              padding: "4px 8px",
+              borderRadius: "3px",
+              cursor: "pointer",
+              fontSize: "10px"
+            },
+            children: "Refetch"
+          }
+        )
+      ] })
+    ] }, keyHash)) })
+  ] });
+}
 export {
-  HttpError,
+  QuantumDevTools,
+  QueryCache,
+  QueryClientProvider,
   computed,
   createHttpClient,
   createState,
@@ -406,8 +1563,16 @@ export {
   getPromiseState,
   handlePromise,
   isPromise,
+  optimisticHelpers,
+  queryCache,
   scheduleUpdate,
   subscribe,
   unwrapPromise,
+  useInfiniteQuery,
+  useMutation,
+  usePaginatedQuery,
+  useQuery,
+  useQueryCache,
+  useQueryClient,
   useStore
 };