react-smart-query 1.0.0

package/dist/index.js

@@ -0,0 +1,1533 @@
+'use strict';
+
+var reactNative = require('react-native');
+var react = require('react');
+var reactQuery = require('@tanstack/react-query');
+var equal = require('fast-deep-equal');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var equal__default = /*#__PURE__*/_interopDefault(equal);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/services/storage.adapter.ts
+var storage_adapter_exports = {};
+__export(storage_adapter_exports, {
+  _setStorageOverride: () => _setStorageOverride,
+  getStorage: () => getStorage,
+  storage: () => storage
+});
+function createMemoryStorage() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => Promise.resolve(store.get(key)),
+    set: (key, value) => {
+      store.set(key, value);
+      return Promise.resolve();
+    },
+    delete: (key) => {
+      store.delete(key);
+      return Promise.resolve();
+    },
+    clearAll: () => {
+      store.clear();
+      return Promise.resolve();
+    },
+    keys: () => Promise.resolve(Array.from(store.keys()))
+  };
+}
+function createNativeStorage() {
+  const MMKV = __require("react-native-mmkv").MMKV;
+  const mmkv = new MMKV({ id: "react-smart-query-v2" });
+  return {
+    get: (key) => Promise.resolve(mmkv.getString(key) ?? void 0),
+    set: (key, value) => Promise.resolve(void mmkv.set(key, value)),
+    delete: (key) => Promise.resolve(void mmkv.delete(key)),
+    clearAll: () => Promise.resolve(void mmkv.clearAll()),
+    keys: () => Promise.resolve(mmkv.getAllKeys())
+  };
+}
+function isIDBAvailable() {
+  return typeof globalThis !== "undefined" && typeof globalThis.indexedDB !== "undefined";
+}
+function openIDB() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(IDB_NAME, IDB_VERSION);
+    req.onupgradeneeded = (e) => {
+      const db = e.target.result;
+      if (!db.objectStoreNames.contains(IDB_STORE)) {
+        db.createObjectStore(IDB_STORE);
+      }
+    };
+    req.onsuccess = (e) => resolve(e.target.result);
+    req.onerror = () => reject(req.error);
+    req.onblocked = () => reject(new Error("IDB blocked by another tab"));
+  });
+}
+function idbWrap(req) {
+  return new Promise((res, rej) => {
+    req.onsuccess = () => res(req.result);
+    req.onerror = () => rej(req.error);
+  });
+}
+function createWebStorage() {
+  if (!isIDBAvailable()) return createMemoryStorage();
+  return {
+    async get(key) {
+      const db = await getIDB();
+      return idbWrap(
+        db.transaction(IDB_STORE, "readonly").objectStore(IDB_STORE).get(key)
+      );
+    },
+    async set(key, value) {
+      const db = await getIDB();
+      await idbWrap(
+        db.transaction(IDB_STORE, "readwrite").objectStore(IDB_STORE).put(value, key)
+      );
+    },
+    async delete(key) {
+      const db = await getIDB();
+      await idbWrap(
+        db.transaction(IDB_STORE, "readwrite").objectStore(IDB_STORE).delete(key)
+      );
+    },
+    async clearAll() {
+      const db = await getIDB();
+      await idbWrap(
+        db.transaction(IDB_STORE, "readwrite").objectStore(IDB_STORE).clear()
+      );
+    },
+    async keys() {
+      const db = await getIDB();
+      const result = await idbWrap(
+        db.transaction(IDB_STORE, "readonly").objectStore(IDB_STORE).getAllKeys()
+      );
+      return result.map(String);
+    }
+  };
+}
+function getStorage() {
+  return _overrideStorage ?? storage;
+}
+function _setStorageOverride(s) {
+  _overrideStorage = s;
+}
+var IDB_NAME, IDB_STORE, IDB_VERSION, _idb, getIDB, storage, _overrideStorage;
+var init_storage_adapter = __esm({
+  "src/services/storage.adapter.ts"() {
+    IDB_NAME = "SmartQueryV2";
+    IDB_STORE = "entries";
+    IDB_VERSION = 1;
+    _idb = null;
+    getIDB = () => {
+      _idb ??= openIDB();
+      return _idb;
+    };
+    storage = reactNative.Platform.OS === "web" ? createWebStorage() : createNativeStorage();
+    _overrideStorage = null;
+  }
+});
+
+// src/services/observer.service.ts
+function addObserver(fn) {
+  observers.add(fn);
+  return () => observers.delete(fn);
+}
+function removeObserver(fn) {
+  observers.delete(fn);
+}
+function clearObservers() {
+  observers.clear();
+}
+function emit(event) {
+  if (observers.size === 0) return;
+  for (const fn of observers) {
+    try {
+      fn(event);
+    } catch {
+    }
+  }
+}
+var observers;
+var init_observer_service = __esm({
+  "src/services/observer.service.ts"() {
+    observers = /* @__PURE__ */ new Set();
+  }
+});
+
+// src/services/cache.service.ts
+var cache_service_exports = {};
+__export(cache_service_exports, {
+  CURRENT_CACHE_VERSION: () => exports.CURRENT_CACHE_VERSION,
+  cacheKeyFor: () => cacheKeyFor,
+  deleteCache: () => deleteCache,
+  getPartialCache: () => getPartialCache,
+  isCacheStale: () => isCacheStale,
+  readCache: () => readCache,
+  setMaxCacheEntries: () => setMaxCacheEntries,
+  writeCache: () => writeCache
+});
+function setMaxCacheEntries(n) {
+  _maxEntries = n;
+}
+function cacheKeyFor(queryKey) {
+  return `sq2:${JSON.stringify(queryKey)}`;
+}
+async function readCache(key, queryKey) {
+  try {
+    const storage2 = getStorage();
+    const raw = await storage2.get(key);
+    if (!raw) {
+      if (queryKey) emit({ type: "cache_miss", queryKey });
+      return null;
+    }
+    const entry = JSON.parse(raw);
+    if (entry.version !== exports.CURRENT_CACHE_VERSION) {
+      void storage2.delete(key);
+      if (queryKey) emit({ type: "cache_miss", queryKey });
+      return null;
+    }
+    void storage2.set(
+      key,
+      JSON.stringify({ ...entry, lastAccessedAt: Date.now() })
+    );
+    if (queryKey) emit({ type: "cache_hit", queryKey, cachedAt: entry.cachedAt });
+    return entry;
+  } catch {
+    return null;
+  }
+}
+async function writeCache(key, data, queryKey) {
+  try {
+    const storage2 = getStorage();
+    const now = Date.now();
+    const entry = {
+      version: exports.CURRENT_CACHE_VERSION,
+      data,
+      cachedAt: now,
+      lastAccessedAt: now
+    };
+    const serialized = JSON.stringify(entry);
+    try {
+      await storage2.set(key, serialized);
+      if (queryKey) {
+        emit({ type: "cache_write", queryKey, dataSize: serialized.length });
+      }
+    } catch (quotaErr) {
+      emit({ type: "storage_quota_exceeded", key });
+      await evictLRUEntries();
+      await storage2.set(key, serialized);
+    }
+    void checkAndEvict();
+  } catch {
+  }
+}
+async function deleteCache(key) {
+  try {
+    await getStorage().delete(key);
+  } catch {
+  }
+}
+async function checkAndEvict() {
+  const storage2 = getStorage();
+  const allKeys = await storage2.keys();
+  const sqKeys = allKeys.filter((k) => k.startsWith("sq2:"));
+  if (sqKeys.length <= _maxEntries) return;
+  await evictLRUEntries(sqKeys);
+}
+async function evictLRUEntries(sqKeys) {
+  const storage2 = getStorage();
+  const keys = sqKeys ?? (await storage2.keys()).filter((k) => k.startsWith("sq2:"));
+  const metas = [];
+  await Promise.all(
+    keys.map(async (key) => {
+      try {
+        const raw = await storage2.get(key);
+        if (!raw) return;
+        const parsed = JSON.parse(raw);
+        metas.push({ key, lastAccessedAt: parsed.lastAccessedAt ?? 0 });
+      } catch {
+      }
+    })
+  );
+  metas.sort((a, b) => a.lastAccessedAt - b.lastAccessedAt);
+  const evictCount = Math.max(1, Math.floor(metas.length * 0.2));
+  const toEvict = metas.slice(0, evictCount);
+  await Promise.all(toEvict.map(({ key }) => storage2.delete(key)));
+}
+async function getPartialCache(key, ids) {
+  const entry = await readCache(key);
+  if (!entry) return null;
+  const { byId } = entry.data;
+  const result = [];
+  for (const id of ids) {
+    if (id in byId) result.push(byId[id]);
+  }
+  return result;
+}
+function isCacheStale(entry, ttlMs) {
+  return Date.now() - entry.cachedAt > ttlMs;
+}
+exports.CURRENT_CACHE_VERSION = void 0; var DEFAULT_MAX_ENTRIES, _maxEntries;
+var init_cache_service = __esm({
+  "src/services/cache.service.ts"() {
+    init_storage_adapter();
+    init_observer_service();
+    exports.CURRENT_CACHE_VERSION = 2;
+    DEFAULT_MAX_ENTRIES = 200;
+    _maxEntries = DEFAULT_MAX_ENTRIES;
+  }
+});
+
+// src/services/requestLock.service.ts
+var requestLock_service_exports = {};
+__export(requestLock_service_exports, {
+  fetchWithLock: () => fetchWithLock,
+  inFlightCount: () => exports.inFlightCount,
+  inFlightKeys: () => exports.inFlightKeys
+});
+function fetchWithLock(key, fn) {
+  const existing = inFlight.get(key);
+  if (existing) return existing;
+  const promise = fn().finally(() => inFlight.delete(key));
+  inFlight.set(key, promise);
+  return promise;
+}
+var inFlight; exports.inFlightCount = void 0; exports.inFlightKeys = void 0;
+var init_requestLock_service = __esm({
+  "src/services/requestLock.service.ts"() {
+    inFlight = /* @__PURE__ */ new Map();
+    exports.inFlightCount = () => inFlight.size;
+    exports.inFlightKeys = () => Array.from(inFlight.keys());
+  }
+});
+
+// src/hooks/useSmartQuery.ts
+init_cache_service();
+init_requestLock_service();
+init_storage_adapter();
+init_observer_service();
+function smartCompare(oldData, newData, options = {}) {
+  const idField = options.idField ?? "id";
+  const versionField = options.versionField === void 0 ? "updatedAt" : options.versionField;
+  if (oldData === newData) return { isEqual: true, tier: 1 };
+  const oldIsArr = Array.isArray(oldData);
+  const newIsArr = Array.isArray(newData);
+  if (oldIsArr !== newIsArr) return { isEqual: false, tier: 2 };
+  if (!oldIsArr) return { isEqual: equal__default.default(oldData, newData), tier: 5 };
+  const o = oldData;
+  const n = newData;
+  if (o.length !== n.length) return { isEqual: false, tier: 2 };
+  if (o.length === 0) return { isEqual: true, tier: 2 };
+  let oldIds = "";
+  let newIds = "";
+  for (let i = 0; i < o.length; i++) {
+    oldIds += String(o[i][idField] ?? i) + "|";
+    newIds += String(n[i][idField] ?? i) + "|";
+  }
+  if (oldIds !== newIds) return { isEqual: false, tier: 3 };
+  if (versionField !== null) {
+    let xorOld = 0;
+    let xorNew = 0;
+    for (let i = 0; i < o.length; i++) {
+      xorOld ^= Number(o[i][versionField] ?? 0) ^ i;
+      xorNew ^= Number(n[i][versionField] ?? 0) ^ i;
+    }
+    if (xorOld !== xorNew) return { isEqual: false, tier: 4 };
+  }
+  return { isEqual: equal__default.default(oldData, newData), tier: 5 };
+}
+function isDataEqual(oldData, newData, options) {
+  return smartCompare(oldData, newData, options).isEqual;
+}
+
+// src/utils/normalize.ts
+function emptyList() {
+  return { byId: /* @__PURE__ */ Object.create(null), allIds: [] };
+}
+function fromArray(items, getItemId, comparator) {
+  const byId = /* @__PURE__ */ Object.create(null);
+  const allIds = new Array(items.length);
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    const id = getItemId(item);
+    byId[id] = item;
+    allIds[i] = id;
+  }
+  if (comparator) allIds.sort((a, b) => comparator(byId[a], byId[b]));
+  return { byId, allIds };
+}
+function toArray(list) {
+  const out = new Array(list.allIds.length);
+  for (let i = 0; i < list.allIds.length; i++) out[i] = list.byId[list.allIds[i]];
+  return out;
+}
+function binaryIdx(allIds, byId, item, getItemId, cmp) {
+  const itemId = getItemId(item);
+  let lo = 0, hi = allIds.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const midItem = byId[allIds[mid]];
+    let res = cmp(midItem, item);
+    if (res === 0) {
+      res = allIds[mid].localeCompare(itemId);
+    }
+    res <= 0 ? lo = mid + 1 : hi = mid;
+  }
+  return lo;
+}
+function normalizedAdd(list, item, getItemId, comparator, getItemVersion) {
+  const id = getItemId(item);
+  const existing = list.byId[id];
+  if (existing && getItemVersion) {
+    const vExisting = getItemVersion(existing);
+    const vNew = getItemVersion(item);
+    if (vNew < vExisting) return list;
+  }
+  const newById = { ...list.byId, [id]: item };
+  const existingIdx = list.allIds.indexOf(id);
+  const workingIds = list.allIds.slice();
+  if (existingIdx !== -1) workingIds.splice(existingIdx, 1);
+  const insertIdx = binaryIdx(workingIds, newById, item, getItemId, comparator);
+  workingIds.splice(insertIdx, 0, id);
+  return { byId: newById, allIds: workingIds };
+}
+function normalizedUpdate(list, item, getItemId, comparator, getItemVersion) {
+  const id = getItemId(item);
+  const oldItem = list.byId[id];
+  if (!oldItem) return list;
+  if (getItemVersion) {
+    const vExisting = getItemVersion(oldItem);
+    const vNew = getItemVersion(item);
+    if (vNew < vExisting) return list;
+  }
+  if (comparator(oldItem, item) === 0) {
+    return {
+      allIds: list.allIds,
+      // Keep same reference if possible, but immutable is safer
+      byId: { ...list.byId, [id]: item }
+    };
+  }
+  return normalizedAdd(list, item, getItemId, comparator, getItemVersion);
+}
+function normalizedRemove(list, id) {
+  if (!(id in list.byId)) return list;
+  const newById = { ...list.byId };
+  delete newById[id];
+  const idx = list.allIds.indexOf(id);
+  const newAllIds = list.allIds.slice();
+  if (idx !== -1) newAllIds.splice(idx, 1);
+  return { byId: newById, allIds: newAllIds };
+}
+function mergeNormalizedData(existing, incomingIds, incomingById, getItemId, comparator) {
+  const newById = { ...existing.byId, ...incomingById };
+  const allIds = [...existing.allIds];
+  const seen = new Set(existing.allIds);
+  for (const id of incomingIds) {
+    if (seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    if (comparator) {
+      const item = incomingById[id];
+      const insertIdx = binaryIdx(allIds, newById, item, getItemId, comparator);
+      allIds.splice(insertIdx, 0, id);
+    } else {
+      allIds.push(id);
+    }
+  }
+  if (comparator && incomingIds.some((id) => existing.byId[id])) {
+    allIds.sort((a, b) => comparator(newById[a], newById[b]));
+  }
+  return { byId: newById, allIds };
+}
+function getPage(allIds, byId, pageIndex, pageSize) {
+  const start = pageIndex * pageSize;
+  const ids = allIds.slice(start, start + pageSize);
+  return ids.map((id) => byId[id]);
+}
+function derivePages(allIds, byId, pageSize) {
+  const totalItems = allIds.length;
+  const totalPages = Math.ceil(totalItems / pageSize);
+  const pages = [];
+  for (let i = 0; i < totalPages; i++) {
+    pages.push(getPage(allIds, byId, i, pageSize));
+  }
+  return pages;
+}
+function isNormalizedEmpty(list) {
+  return list.allIds.length === 0;
+}
+function trimNormalizedList(list, maxItems) {
+  if (list.allIds.length <= maxItems) return list;
+  const removeCount = Math.max(
+    Math.ceil(list.allIds.length * 0.2),
+    list.allIds.length - maxItems
+  );
+  const newSize = list.allIds.length - removeCount;
+  const newAllIds = list.allIds.slice(0, newSize);
+  const newById = {};
+  for (const id of newAllIds) {
+    newById[id] = list.byId[id];
+  }
+  return { byId: newById, allIds: newAllIds };
+}
+
+// src/registry/smartQueryRegistry.ts
+init_cache_service();
+var liveRegistry = /* @__PURE__ */ new Map();
+var sortConfigRegistry = /* @__PURE__ */ new Map();
+function _registerUpdater(storageKey, updater, config) {
+  liveRegistry.set(storageKey, updater);
+  if (config) sortConfigRegistry.set(storageKey, config);
+}
+function _unregisterUpdater(storageKey) {
+  liveRegistry.delete(storageKey);
+}
+async function mutateStorageOnly(storageKey, queryKey, fn) {
+  const config = sortConfigRegistry.get(storageKey);
+  if (!config) return;
+  const entry = await readCache(storageKey, queryKey);
+  if (!entry) return;
+  const rawData = entry.data;
+  const isUnified = "data" in rawData && "meta" in rawData;
+  const currentList = isUnified ? rawData.data : rawData;
+  const nextList = fn(currentList, config);
+  const nextData = isUnified ? { ...rawData, data: nextList } : nextList;
+  await writeCache(storageKey, nextData, queryKey);
+}
+function getSmartQueryActions(queryKey) {
+  const storageKey = cacheKeyFor(queryKey);
+  return {
+    isActive: () => liveRegistry.has(storageKey),
+    addItem: async (item) => {
+      const live = liveRegistry.get(storageKey);
+      if (live) {
+        live.add(item);
+        return;
+      }
+      await mutateStorageOnly(
+        storageKey,
+        queryKey,
+        (list, { comparator, getItemId }) => normalizedAdd(list, item, getItemId, comparator)
+      );
+    },
+    updateItem: async (item) => {
+      const live = liveRegistry.get(storageKey);
+      if (live) {
+        live.update(item);
+        return;
+      }
+      await mutateStorageOnly(
+        storageKey,
+        queryKey,
+        (list, { comparator, getItemId }) => normalizedUpdate(list, item, getItemId, comparator)
+      );
+    },
+    removeItem: async (id) => {
+      const live = liveRegistry.get(storageKey);
+      if (live) {
+        live.remove(id);
+        return;
+      }
+      await mutateStorageOnly(
+        storageKey,
+        queryKey,
+        (list) => normalizedRemove(list, id)
+      );
+    }
+  };
+}
+var smartQueryDebug = {
+  /** Get the current normalized state for a query key. */
+  getNormalizedState: async (queryKey) => {
+    if (typeof __DEV__ !== "undefined" && !__DEV__) return null;
+    const storageKey = cacheKeyFor(queryKey);
+    const entry = await readCache(storageKey, queryKey);
+    return entry ? entry.data : null;
+  },
+  /** Log a detailed summary of the cache entry to the console. */
+  inspectCache: async (queryKey) => {
+    if (typeof __DEV__ !== "undefined" && !__DEV__) return;
+    const storageKey = cacheKeyFor(queryKey);
+    const entry = await readCache(storageKey, queryKey);
+    if (!entry) {
+      console.log(`[SmartQuery Debug] Cache MISS for:`, queryKey);
+      return;
+    }
+    console.log(`[SmartQuery Debug] Cache HIT for:`, queryKey, {
+      cachedAt: new Date(entry.cachedAt).toISOString(),
+      size: JSON.stringify(entry.data).length,
+      data: entry.data
+    });
+  },
+  /** Clear the cache entry for a query key. */
+  clearCache: async (queryKey) => {
+    if (typeof __DEV__ !== "undefined" && !__DEV__) return;
+    const storageKey = cacheKeyFor(queryKey);
+    const { deleteCache: deleteCache2 } = await Promise.resolve().then(() => (init_cache_service(), cache_service_exports));
+    await deleteCache2(storageKey);
+  },
+  /** Get the current state of the offline mutation queue. */
+  getQueue: async () => {
+    if (typeof __DEV__ !== "undefined" && !__DEV__) return [];
+    try {
+      const { getStorage: getStorage2 } = await Promise.resolve().then(() => (init_storage_adapter(), storage_adapter_exports));
+      const raw = await getStorage2().get("sq_mutation_queue");
+      return raw ? JSON.parse(raw) : [];
+    } catch {
+      return [];
+    }
+  },
+  /** Get list of all storage keys currently being fetched. */
+  inFlightRequests: () => {
+    if (typeof __DEV__ !== "undefined" && !__DEV__) return [];
+    try {
+      const { inFlightKeys: inFlightKeys2 } = (init_requestLock_service(), __toCommonJS(requestLock_service_exports));
+      return inFlightKeys2();
+    } catch {
+      return [];
+    }
+  }
+};
+async function batchUpdate(queryKey, fn) {
+  const storageKey = cacheKeyFor(queryKey);
+  const actions = getSmartQueryActions(queryKey);
+  const live = liveRegistry.has(storageKey);
+  if (live) {
+    await fn(actions);
+    return;
+  }
+  const config = sortConfigRegistry.get(storageKey);
+  if (!config) return;
+  const entry = await readCache(storageKey, queryKey);
+  if (!entry) return;
+  let currentData = entry.data;
+  const isUnified = "data" in currentData && "meta" in currentData;
+  let currentList = isUnified ? currentData.data : currentData;
+  const batchActions = {
+    isActive: () => false,
+    addItem: async (item) => {
+      currentList = normalizedAdd(currentList, item, config.getItemId, config.comparator);
+    },
+    updateItem: async (item) => {
+      currentList = normalizedUpdate(currentList, item, config.getItemId, config.comparator);
+    },
+    removeItem: async (id) => {
+      currentList = normalizedRemove(currentList, id);
+    }
+  };
+  await fn(batchActions);
+  const nextData = isUnified ? { ...currentData, data: currentList } : currentList;
+  await writeCache(storageKey, nextData, queryKey);
+}
+
+// src/hooks/useSmartQuery.ts
+function normalizeError(cause) {
+  if (cause instanceof Error) {
+    const err = cause;
+    const status = err.status;
+    return {
+      cause,
+      message: cause.message,
+      retryable: !status || status >= 500 || status === 429,
+      statusCode: status
+    };
+  }
+  return { cause, message: String(cause), retryable: true };
+}
+var DEFAULT_TTL = 5 * 6e4;
+function useSmartQuery(options) {
+  const {
+    queryKey,
+    queryFn,
+    select,
+    getItemId,
+    sortComparator,
+    cacheTtl = DEFAULT_TTL,
+    maxItems = 1e3,
+    getItemVersion,
+    strictFreshness = false,
+    fallbackData,
+    compareOptions,
+    onSuccess,
+    onError,
+    queryOptions = {}
+  } = options;
+  const queryClient = reactQuery.useQueryClient();
+  const storageKey = react.useMemo(
+    () => cacheKeyFor(queryKey),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(queryKey)]
+  );
+  const listMode = typeof sortComparator === "function" && typeof getItemId === "function";
+  const [viewData, setViewData] = react.useState(void 0);
+  const [isCacheLoading, setIsCacheLoading] = react.useState(true);
+  const [isFromCache, setIsFromCache] = react.useState(false);
+  const [shouldFetch, setShouldFetch] = react.useState(false);
+  const [smartError, setSmartError] = react.useState(null);
+  const prevRawRef = react.useRef(void 0);
+  const normalizedRef = react.useRef(emptyList());
+  react.useEffect(() => {
+    let cancelled = false;
+    setIsCacheLoading(true);
+    readCache(storageKey, queryKey).then((entry) => {
+      if (cancelled) return;
+      if (entry !== null) {
+        const isStale = isCacheStale(entry, cacheTtl);
+        const usable = !strictFreshness || !isStale;
+        if (usable) {
+          if (listMode) {
+            let normalized;
+            if (Array.isArray(entry.data)) {
+              normalized = fromArray(
+                entry.data,
+                getItemId,
+                sortComparator
+              );
+            } else {
+              normalized = entry.data;
+            }
+            normalizedRef.current = normalized;
+            const view = toArray(normalized);
+            prevRawRef.current = normalized;
+            queryClient.setQueryData(queryKey, view);
+            setViewData(view);
+          } else {
+            prevRawRef.current = entry.data;
+            queryClient.setQueryData(queryKey, entry.data);
+            setViewData(entry.data);
+          }
+          setIsFromCache(true);
+          setShouldFetch(isStale);
+        } else {
+          setShouldFetch(true);
+        }
+      } else {
+        setShouldFetch(true);
+      }
+      setIsCacheLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [storageKey]);
+  const wrappedQueryFn = react.useCallback(
+    async (ctx) => {
+      emit({ type: "fetch_start", queryKey });
+      const start = Date.now();
+      try {
+        const raw = await fetchWithLock(storageKey, () => queryFn(ctx));
+        const transformed = select ? select(raw) : raw;
+        emit({
+          type: "fetch_success",
+          queryKey,
+          durationMs: Date.now() - start
+        });
+        return transformed;
+      } catch (err) {
+        emit({ type: "fetch_error", queryKey, error: err });
+        throw err;
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [storageKey, queryFn, select]
+  );
+  const {
+    data: freshData,
+    isFetching,
+    error: tqError,
+    refetch: tqRefetch
+  } = reactQuery.useQuery({
+    queryKey,
+    queryFn: wrappedQueryFn,
+    enabled: !isCacheLoading && shouldFetch,
+    staleTime: cacheTtl,
+    gcTime: cacheTtl * 2,
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: true,
+    networkMode: "offlineFirst",
+    ...queryOptions
+  });
+  react.useEffect(() => {
+    if (!tqError) {
+      setSmartError(null);
+      return;
+    }
+    const structured = normalizeError(tqError);
+    const suppressed = onError?.(structured);
+    if (!suppressed) setSmartError(structured);
+  }, [tqError, onError]);
+  react.useEffect(() => {
+    if (freshData === void 0 || isFetching) return;
+    if (listMode) {
+      const freshNormalized = fromArray(
+        freshData,
+        getItemId,
+        sortComparator
+      );
+      if (!isDataEqual(prevRawRef.current, freshNormalized, compareOptions)) {
+        prevRawRef.current = freshNormalized;
+        normalizedRef.current = freshNormalized;
+        const view = toArray(freshNormalized);
+        queryClient.setQueryData(queryKey, view);
+        setViewData(() => view);
+        setIsFromCache(false);
+        const trimmed = trimNormalizedList(freshNormalized, maxItems);
+        void writeCache(storageKey, trimmed, queryKey);
+        onSuccess?.(view);
+      }
+    } else {
+      if (!isDataEqual(prevRawRef.current, freshData, compareOptions)) {
+        prevRawRef.current = freshData;
+        queryClient.setQueryData(queryKey, freshData);
+        setViewData(() => freshData);
+        setIsFromCache(false);
+        void writeCache(storageKey, freshData, queryKey);
+        onSuccess?.(freshData);
+      }
+    }
+  }, [freshData, isFetching]);
+  const applyMutation = react.useCallback(
+    (fn) => {
+      const next = trimNormalizedList(fn(normalizedRef.current), maxItems);
+      normalizedRef.current = next;
+      prevRawRef.current = next;
+      const view = toArray(next);
+      queryClient.setQueryData(queryKey, view);
+      setViewData(view);
+      void writeCache(storageKey, next, queryKey);
+    },
+    [queryClient, queryKey, storageKey, maxItems]
+  );
+  const addItem = react.useCallback(
+    (item) => {
+      if (!listMode) return;
+      applyMutation(
+        (cur) => normalizedAdd(
+          cur,
+          item,
+          getItemId,
+          sortComparator,
+          getItemVersion
+        )
+      );
+    },
+    [listMode, getItemId, sortComparator, getItemVersion, applyMutation]
+  );
+  const updateItem = react.useCallback(
+    (item) => {
+      if (!listMode) return;
+      applyMutation(
+        (cur) => normalizedUpdate(
+          cur,
+          item,
+          getItemId,
+          sortComparator,
+          getItemVersion
+        )
+      );
+    },
+    [listMode, getItemId, sortComparator, getItemVersion, applyMutation]
+  );
+  const removeItem = react.useCallback(
+    (id) => {
+      if (!listMode) return;
+      applyMutation((cur) => normalizedRemove(cur, id));
+    },
+    [listMode, applyMutation]
+  );
+  const addRef = react.useRef(addItem);
+  const updateRef = react.useRef(updateItem);
+  const removeRef = react.useRef(removeItem);
+  react.useEffect(() => {
+    addRef.current = addItem;
+  }, [addItem]);
+  react.useEffect(() => {
+    updateRef.current = updateItem;
+  }, [updateItem]);
+  react.useEffect(() => {
+    removeRef.current = removeItem;
+  }, [removeItem]);
+  react.useEffect(() => {
+    _registerUpdater(
+      storageKey,
+      {
+        add: (item) => addRef.current(item),
+        update: (item) => updateRef.current(item),
+        remove: (id) => removeRef.current(id)
+      },
+      listMode && !!sortComparator && !!getItemId ? {
+        comparator: sortComparator,
+        getItemId
+      } : null
+    );
+    return () => _unregisterUpdater(storageKey);
+  }, [storageKey]);
+  const data = viewData ?? (tqError ? fallbackData : void 0);
+  const isLoading = isCacheLoading || data === void 0 && isFetching;
+  const refetch = react.useCallback(() => {
+    setShouldFetch(true);
+    tqRefetch();
+  }, [tqRefetch]);
+  return {
+    data,
+    isLoading,
+    isFetching,
+    isFromCache,
+    isCacheLoading,
+    error: smartError,
+    refetch,
+    addItem,
+    updateItem,
+    removeItem
+  };
+}
+var invalidateSmartCache = (queryKey) => deleteCache(cacheKeyFor(queryKey));
+var clearAllSmartCache = () => storage.clearAll();
+
+// src/services/queue.service.ts
+init_storage_adapter();
+init_observer_service();
+var QUEUE_KEY = "sq2:mutation_queue";
+var DEFAULT_MAX_RETRIES = 5;
+var BACKOFF_BASE_MS = 1e3;
+var BACKOFF_MAX_MS = 12e4;
+var executors = /* @__PURE__ */ new Map();
+function registerExecutor(type, fn) {
+  executors.set(type, fn);
+}
+function coalesceQueue(queue) {
+  const byEntityKey = /* @__PURE__ */ new Map();
+  const standalone = [];
+  for (const m of queue) {
+    if (!m.entityKey) {
+      standalone.push(m);
+      continue;
+    }
+    const group = byEntityKey.get(m.entityKey) ?? [];
+    group.push(m);
+    byEntityKey.set(m.entityKey, group);
+  }
+  const coalesced = [];
+  for (const group of byEntityKey.values()) {
+    group.sort((a, b) => a.enqueuedAt - b.enqueuedAt);
+    const hasRemove = group.some((m) => m.type === "REMOVE_ITEM");
+    if (hasRemove) {
+      const removeOp = [...group].reverse().find((m) => m.type === "REMOVE_ITEM");
+      coalesced.push(removeOp);
+      continue;
+    }
+    const addOp = group.find((m) => m.type === "ADD_ITEM");
+    const updateOps = group.filter((m) => m.type === "UPDATE_ITEM");
+    if (addOp && updateOps.length > 0) {
+      const latestUpdate = updateOps[updateOps.length - 1];
+      coalesced.push({ ...addOp, payload: latestUpdate.payload });
+    } else if (addOp) {
+      coalesced.push(addOp);
+    } else if (updateOps.length > 0) {
+      coalesced.push(updateOps[updateOps.length - 1]);
+    } else {
+      coalesced.push(...group);
+    }
+  }
+  return [...standalone, ...coalesced].sort((a, b) => a.enqueuedAt - b.enqueuedAt);
+}
+async function loadQueue() {
+  try {
+    const raw = await getStorage().get(QUEUE_KEY);
+    if (!raw) return [];
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+async function saveQueue(queue) {
+  try {
+    await getStorage().set(QUEUE_KEY, JSON.stringify(queue));
+  } catch {
+  }
+}
+function backoffMs(retryCount) {
+  const exp = Math.min(BACKOFF_BASE_MS * 2 ** retryCount, BACKOFF_MAX_MS);
+  return Math.random() * exp;
+}
+var isProcessing = false;
+async function processQueue() {
+  if (isProcessing) return;
+  isProcessing = true;
+  try {
+    const raw = await loadQueue();
+    if (raw.length === 0) return;
+    const queue = coalesceQueue(raw);
+    const now = Date.now();
+    const remaining = [];
+    for (const mutation of queue) {
+      if (mutation.nextRetryAt > now) {
+        remaining.push(mutation);
+        continue;
+      }
+      const executor = executors.get(mutation.type);
+      if (!executor) {
+        if (__DEV__) {
+          console.warn(`[SmartQuery] No executor for "${mutation.type}"`);
+        }
+        remaining.push(mutation);
+        continue;
+      }
+      try {
+        await executor(mutation);
+        emit({ type: "queue_success", mutationId: mutation.id });
+      } catch (err) {
+        const nextRetry = mutation.retryCount + 1;
+        emit({ type: "queue_failure", mutationId: mutation.id, retryCount: nextRetry });
+        if (nextRetry >= mutation.maxRetries) {
+          if (__DEV__) {
+            console.error(
+              `[SmartQuery] Mutation ${mutation.id} dropped after ${mutation.maxRetries} retries`,
+              err
+            );
+          }
+        } else {
+          remaining.push({
+            ...mutation,
+            retryCount: nextRetry,
+            nextRetryAt: now + backoffMs(nextRetry)
+          });
+        }
+      }
+    }
+    await saveQueue(remaining);
+    if (remaining.length === 0) emit({ type: "queue_drained" });
+  } finally {
+    isProcessing = false;
+  }
+}
+async function enqueueMutation(options) {
+  const queue = await loadQueue();
+  const mutation = {
+    id: `mut_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    type: options.type,
+    entityKey: options.entityKey,
+    queryKey: options.queryKey,
+    payload: options.payload,
+    enqueuedAt: Date.now(),
+    retryCount: 0,
+    maxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES,
+    nextRetryAt: 0
+  };
+  queue.push(mutation);
+  await saveQueue(queue);
+  emit({ type: "queue_enqueue", mutationId: mutation.id, mutationType: mutation.type });
+}
+async function initQueue() {
+  await processQueue();
+}
+async function clearQueue() {
+  await saveQueue([]);
+}
+var getQueue = loadQueue;
+var getQueueLength = async () => (await loadQueue()).length;
+
+// src/hooks/useSmartMutation.ts
+init_observer_service();
+function defaultIsOnline() {
+  if (typeof navigator !== "undefined" && "onLine" in navigator) {
+    return navigator.onLine;
+  }
+  return true;
+}
+function normalizeError2(cause) {
+  if (cause instanceof Error) {
+    const err = cause;
+    const status = err.status;
+    return {
+      cause,
+      message: cause.message,
+      retryable: !status || status >= 500 || status === 429,
+      statusCode: status
+    };
+  }
+  return { cause, message: String(cause), retryable: true };
+}
+function useSmartMutation(options) {
+  const {
+    queryKey,
+    mutationType,
+    mutationFn,
+    getItemId,
+    toItem,
+    enableOfflineQueue = true,
+    getEntityKey,
+    onSuccess,
+    onError,
+    isOnline = defaultIsOnline
+  } = options;
+  const [isPending, setIsPending] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const isMounted = react.useRef(true);
+  const getActions = react.useCallback(
+    () => getSmartQueryActions(queryKey),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(queryKey)]
+  );
+  const mutateAsync = react.useCallback(
+    async (item) => {
+      const actions = getActions();
+      const itemId = getItemId(item);
+      if (isMounted.current) {
+        setIsPending(true);
+        setError(null);
+      }
+      if (mutationType === "ADD_ITEM" || mutationType === "CUSTOM") {
+        await actions.addItem(item);
+      } else if (mutationType === "UPDATE_ITEM") {
+        await actions.updateItem(item);
+      } else if (mutationType === "REMOVE_ITEM") {
+        await actions.removeItem(itemId);
+      }
+      if (!isOnline()) {
+        if (enableOfflineQueue) {
+          await enqueueMutation({
+            type: mutationType,
+            queryKey,
+            payload: item,
+            entityKey: getEntityKey?.(item)
+          });
+        }
+        if (isMounted.current) setIsPending(false);
+        return;
+      }
+      try {
+        const response = await mutationFn(item);
+        const confirmedItem = toItem ? toItem(response) : response;
+        if (mutationType !== "REMOVE_ITEM") {
+          await actions.updateItem(confirmedItem);
+        }
+        emit({
+          type: "queue_success",
+          mutationId: `${mutationType}:${itemId}`
+        });
+        onSuccess?.(response, item);
+        void processQueue();
+      } catch (err) {
+        if (mutationType === "ADD_ITEM" || mutationType === "CUSTOM") {
+          await actions.removeItem(itemId);
+        } else if (mutationType === "UPDATE_ITEM") ; else if (mutationType === "REMOVE_ITEM") {
+          await actions.addItem(item);
+        }
+        const structured = normalizeError2(err);
+        if (isMounted.current) setError(structured);
+        onError?.(structured, item);
+      } finally {
+        if (isMounted.current) setIsPending(false);
+      }
+    },
+    [
+      getActions,
+      getItemId,
+      mutationType,
+      mutationFn,
+      toItem,
+      enableOfflineQueue,
+      getEntityKey,
+      isOnline,
+      onSuccess,
+      onError,
+      queryKey
+    ]
+  );
+  const mutate = react.useCallback(
+    (item) => {
+      void mutateAsync(item);
+    },
+    [mutateAsync]
+  );
+  const reset = react.useCallback(() => {
+    setError(null);
+    setIsPending(false);
+  }, []);
+  return { mutate, mutateAsync, isPending, error, reset };
+}
+
+// src/hooks/useInfiniteSmartQuery.ts
+init_cache_service();
+init_requestLock_service();
+init_observer_service();
+function normalizeError3(cause) {
+  if (cause instanceof Error) {
+    const err = cause;
+    const status = err.status;
+    return {
+      cause,
+      message: cause.message,
+      retryable: !status || status >= 500 || status === 429,
+      statusCode: status
+    };
+  }
+  return { cause, message: String(cause), retryable: true };
+}
+var DEFAULT_TTL2 = 5 * 6e4;
+function useInfiniteSmartQuery(options) {
+  const {
+    queryKey,
+    queryFn,
+    getNextCursor,
+    select,
+    getItemId,
+    getItemVersion,
+    sortComparator,
+    initialPageParam = void 0,
+    paginationMode = "normalized",
+    pageSize: pageSizeProp,
+    maxItems = 1e3,
+    cacheTtl = DEFAULT_TTL2,
+    strictFreshness = false,
+    onError
+  } = options;
+  const storageKey = react.useMemo(
+    () => cacheKeyFor(queryKey),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [JSON.stringify(queryKey)]
+  );
+  const [infiniteData, setInfiniteData] = react.useState({
+    data: emptyList(),
+    meta: {
+      nextCursor: initialPageParam ?? null,
+      pageParams: []
+    }
+  });
+  const [pageSize, setPageSize] = react.useState(pageSizeProp);
+  const [isCacheLoading, setIsCacheLoading] = react.useState(true);
+  const [isFetchingNextPage, setIsFetchingNextPage] = react.useState(false);
+  const [isFetching, setIsFetching] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const infiniteRef = react.useRef(infiniteData);
+  function setAndNotify(next) {
+    infiniteRef.current = next;
+    setInfiniteData(next);
+  }
+  react.useEffect(() => {
+    let cancelled = false;
+    setIsCacheLoading(true);
+    readCache(storageKey, queryKey).then((entry) => {
+      if (cancelled) return;
+      if (entry !== null) {
+        const isStale = isCacheStale(entry, cacheTtl);
+        if (!strictFreshness || !isStale) {
+          setAndNotify(entry.data);
+        }
+      }
+      setIsCacheLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [storageKey]);
+  const fetchPage = react.useCallback(
+    async (cursor) => {
+      const lockKey = `${storageKey}:${JSON.stringify(cursor)}`;
+      emit({ type: "fetch_start", queryKey });
+      try {
+        const raw = await fetchWithLock(lockKey, () => queryFn({ pageParam: cursor }));
+        const items = select(raw);
+        const nextCursor = getNextCursor(raw);
+        const pageIds = items.map(getItemId);
+        const pageById = fromArray(items, getItemId).byId;
+        const now = Date.now();
+        emit({ type: "fetch_success", queryKey, durationMs: 0 });
+        const current = infiniteRef.current;
+        const alreadyFetched = current.meta.pageParams.includes(cursor);
+        if (!pageSize && items.length > 0) {
+          setPageSize(items.length);
+        }
+        let mergedList = mergeNormalizedData(
+          current.data,
+          pageIds,
+          pageById,
+          getItemId,
+          sortComparator
+        );
+        mergedList = trimNormalizedList(mergedList, maxItems);
+        const next = {
+          data: mergedList,
+          meta: {
+            pageParams: alreadyFetched ? current.meta.pageParams : [...current.meta.pageParams, cursor],
+            nextCursor,
+            lastFetchedAt: now
+          }
+        };
+        setAndNotify(next);
+        void writeCache(storageKey, next, queryKey);
+        setError(null);
+      } catch (err) {
+        emit({ type: "fetch_error", queryKey, error: err });
+        const structured = normalizeError3(err);
+        setError(structured);
+        onError?.(structured);
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [storageKey, queryFn, select, getNextCursor, getItemId, sortComparator, maxItems]
+  );
+  react.useEffect(() => {
+    if (isCacheLoading) return;
+    void (async () => {
+      setIsFetching(true);
+      await fetchPage(initialPageParam);
+      setIsFetching(false);
+    })();
+  }, [isCacheLoading]);
+  const inFlightRef = react.useRef(/* @__PURE__ */ new Set());
+  const fetchNextPage = react.useCallback(() => {
+    const { nextCursor, lastFetchedAt } = infiniteRef.current.meta;
+    if (nextCursor === null || isFetchingNextPage) return;
+    const cursorKey = JSON.stringify(nextCursor);
+    if (inFlightRef.current.has(cursorKey)) return;
+    if (lastFetchedAt && Date.now() - lastFetchedAt < 500) return;
+    void (async () => {
+      inFlightRef.current.add(cursorKey);
+      setIsFetchingNextPage(true);
+      await fetchPage(nextCursor);
+      setIsFetchingNextPage(false);
+      inFlightRef.current.delete(cursorKey);
+    })();
+  }, [fetchPage, isFetchingNextPage]);
+  const refetch = react.useCallback(() => {
+    void (async () => {
+      setIsFetching(true);
+      await fetchPage(initialPageParam);
+      setIsFetching(false);
+    })();
+  }, [fetchPage, initialPageParam]);
+  const applyItemMutation = react.useCallback(
+    (fn) => {
+      const current = infiniteRef.current;
+      const next = {
+        ...current,
+        data: fn(current.data)
+      };
+      setAndNotify(next);
+      void writeCache(storageKey, next, queryKey);
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [storageKey]
+  );
+  const updateItem = react.useCallback(
+    (item) => {
+      applyItemMutation(
+        (data) => normalizedUpdate(
+          data,
+          item,
+          getItemId,
+          sortComparator ?? ((a, b) => 0),
+          getItemVersion
+        )
+      );
+    },
+    [getItemId, sortComparator, getItemVersion, applyItemMutation]
+  );
+  const addItem = react.useCallback(
+    (item) => {
+      const id = getItemId(item);
+      const current = infiniteRef.current;
+      if (id in current.data.byId) {
+        updateItem(item);
+        return;
+      }
+      applyItemMutation((data) => {
+        const next = normalizedAdd(
+          data,
+          item,
+          getItemId,
+          sortComparator ?? ((a, b) => 0),
+          getItemVersion
+        );
+        return trimNormalizedList(next, maxItems);
+      });
+    },
+    [getItemId, sortComparator, getItemVersion, applyItemMutation, updateItem, maxItems]
+  );
+  const removeItem = react.useCallback(
+    (id) => {
+      applyItemMutation((data) => normalizedRemove(data, id));
+    },
+    [applyItemMutation]
+  );
+  const flatData = react.useMemo(() => toArray(infiniteData.data), [infiniteData.data]);
+  const isLoading = isCacheLoading || flatData.length === 0 && isFetching;
+  const isRefreshing = !!(flatData.length > 0 && isFetching && !isFetchingNextPage);
+  const hasNextPage = infiniteRef.current.meta.nextCursor !== null;
+  const totalCount = infiniteData.data.allIds.length;
+  const derivedData = react.useMemo(() => {
+    if (paginationMode === "pages") {
+      return {
+        pages: derivePages(
+          infiniteData.data.allIds,
+          infiniteData.data.byId,
+          pageSize ?? flatData.length
+        )
+      };
+    }
+    return flatData;
+  }, [paginationMode, infiniteData.data.allIds, infiniteData.data.byId, pageSize, flatData]);
+  return {
+    data: derivedData,
+    isLoading,
+    isFetchingNextPage,
+    isFetching,
+    isRefreshing,
+    hasNextPage,
+    error,
+    totalCount,
+    fetchNextPage,
+    refetch,
+    addItem,
+    updateItem,
+    removeItem
+  };
+}
+function useSmartQuerySelector(queryKey, selector, equalityFn = equal__default.default) {
+  const queryClient = reactQuery.useQueryClient();
+  const selectedRef = react.useRef(selector(queryClient.getQueryData(queryKey)));
+  const subscribe = react.useCallback(
+    (onStoreChange) => {
+      return queryClient.getQueryCache().subscribe((event) => {
+        if (event.type !== "updated" && event.type !== "added" && event.type !== "removed") return;
+        const cacheKey = JSON.stringify(queryKey);
+        const eventKey = JSON.stringify(event.query.queryKey);
+        if (cacheKey !== eventKey) return;
+        const newSelected = selector(queryClient.getQueryData(queryKey));
+        if (!equalityFn(selectedRef.current, newSelected)) {
+          selectedRef.current = newSelected;
+          onStoreChange();
+        }
+      });
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [queryClient, JSON.stringify(queryKey), selector, equalityFn]
+  );
+  const getSnapshot = react.useCallback(
+    () => selectedRef.current,
+    []
+  );
+  const getServerSnapshot = react.useCallback(
+    () => selector(void 0),
+    [selector]
+  );
+  return react.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+}
+
+// src/factory/createTypedQuery.ts
+function createTypedQuery(config) {
+  return {
+    useQuery(...args) {
+      const qk = config.queryKey(...args);
+      return useSmartQuery({
+        queryKey: qk,
+        queryFn: () => config.queryFn(...args),
+        select: config.select,
+        getItemId: config.getItemId,
+        sortComparator: config.sortComparator,
+        cacheTtl: config.cacheTtl,
+        strictFreshness: config.strictFreshness,
+        ...config.defaultOptions
+      });
+    },
+    useMutation(...argsAndOptions) {
+      const mutationOptions = argsAndOptions[argsAndOptions.length - 1];
+      const args = argsAndOptions.slice(0, -1);
+      const qk = config.queryKey(...args);
+      if (!config.getItemId) {
+        throw new Error(
+          "[SmartQuery] useMutation requires getItemId to be defined in createTypedQuery"
+        );
+      }
+      return useSmartMutation({
+        queryKey: qk,
+        getItemId: config.getItemId,
+        ...mutationOptions
+      });
+    },
+    getActions(...args) {
+      const qk = config.queryKey(...args);
+      return getSmartQueryActions(qk);
+    },
+    invalidate(...args) {
+      const qk = config.queryKey(...args);
+      return invalidateSmartCache(qk);
+    }
+  };
+}
+
+// src/index.ts
+init_observer_service();
+init_cache_service();
+init_requestLock_service();
+
+exports.addObserver = addObserver;
+exports.batchUpdate = batchUpdate;
+exports.cacheKeyFor = cacheKeyFor;
+exports.clearAllSmartCache = clearAllSmartCache;
+exports.clearObservers = clearObservers;
+exports.clearQueue = clearQueue;
+exports.createTypedQuery = createTypedQuery;
+exports.deleteCache = deleteCache;
+exports.emptyList = emptyList;
+exports.enqueueMutation = enqueueMutation;
+exports.fetchWithLock = fetchWithLock;
+exports.fromArray = fromArray;
+exports.getPartialCache = getPartialCache;
+exports.getQueue = getQueue;
+exports.getQueueLength = getQueueLength;
+exports.getSmartQueryActions = getSmartQueryActions;
+exports.initQueue = initQueue;
+exports.invalidateSmartCache = invalidateSmartCache;
+exports.isCacheStale = isCacheStale;
+exports.isDataEqual = isDataEqual;
+exports.isNormalizedEmpty = isNormalizedEmpty;
+exports.normalizedAdd = normalizedAdd;
+exports.normalizedRemove = normalizedRemove;
+exports.normalizedUpdate = normalizedUpdate;
+exports.processQueue = processQueue;
+exports.readCache = readCache;
+exports.registerExecutor = registerExecutor;
+exports.removeObserver = removeObserver;
+exports.setMaxCacheEntries = setMaxCacheEntries;
+exports.smartCompare = smartCompare;
+exports.smartQueryDebug = smartQueryDebug;
+exports.toArray = toArray;
+exports.trimNormalizedList = trimNormalizedList;
+exports.useInfiniteSmartQuery = useInfiniteSmartQuery;
+exports.useSmartMutation = useSmartMutation;
+exports.useSmartQuery = useSmartQuery;
+exports.useSmartQuerySelector = useSmartQuerySelector;
+exports.writeCache = writeCache;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map