@rpcbase/client 0.464.0 → 0.466.0

package/dist/useQuery-DZqYIJog.js

@@ -1,3474 +0,0 @@
-import { createContext, useContext, useMemo, useState, useRef, useEffect } from "react";
-import { jsx } from "react/jsx-runtime";
-import { c } from "react/compiler-runtime";
-const STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY = "__staticRpcbaseRtsHydrationData";
-const RtsSsrRuntimeContext = createContext(null);
-const hydrationDataStore = /* @__PURE__ */ new Map();
-const hydrationPageInfoStore = /* @__PURE__ */ new Map();
-const hydrationTotalCountStore = /* @__PURE__ */ new Map();
-const hydrationCountStore = /* @__PURE__ */ new Map();
-const makeStoreKey = (modelName, queryKey) => `${modelName}.${queryKey}`;
-const normalizeStringOrNull = (value) => {
-  if (typeof value !== "string") return null;
-  const normalized = value.trim();
-  return normalized ? normalized : null;
-};
-const normalizePageInfo$2 = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const raw = value;
-  if (typeof raw.hasNextPage !== "boolean" || typeof raw.hasPrevPage !== "boolean") return void 0;
-  const nextCursor = typeof raw.nextCursor === "string" && raw.nextCursor ? raw.nextCursor : void 0;
-  const prevCursor = typeof raw.prevCursor === "string" && raw.prevCursor ? raw.prevCursor : void 0;
-  return {
-    hasNextPage: raw.hasNextPage,
-    hasPrevPage: raw.hasPrevPage,
-    ...nextCursor ? {
-      nextCursor
-    } : {},
-    ...prevCursor ? {
-      prevCursor
-    } : {}
-  };
-};
-const normalizeTotalCount$2 = (value) => {
-  if (typeof value !== "number") return void 0;
-  if (!Number.isFinite(value) || value < 0) return void 0;
-  return Math.floor(value);
-};
-const parseHydrationData = (value) => {
-  if (!value || typeof value !== "object") return null;
-  const raw = value;
-  if (raw.v !== 1) return null;
-  if (!Array.isArray(raw.queries)) return null;
-  const rawCounts = Array.isArray(raw.counts) ? raw.counts : [];
-  const queries = [];
-  for (const entry of raw.queries) {
-    if (!entry || typeof entry !== "object") continue;
-    const query = entry;
-    const modelName = normalizeStringOrNull(query.modelName);
-    const queryKey = normalizeStringOrNull(query.queryKey);
-    if (!modelName || !queryKey) continue;
-    if (!Array.isArray(query.data)) continue;
-    const pageInfo = normalizePageInfo$2(query.pageInfo);
-    const totalCount = normalizeTotalCount$2(query.totalCount);
-    queries.push({
-      modelName,
-      queryKey,
-      data: query.data,
-      ...pageInfo ? {
-        pageInfo
-      } : {},
-      ...totalCount !== void 0 ? {
-        totalCount
-      } : {}
-    });
-  }
-  const counts = [];
-  for (const entry of rawCounts) {
-    if (!entry || typeof entry !== "object") continue;
-    const countEntry = entry;
-    const modelName = normalizeStringOrNull(countEntry.modelName);
-    const queryKey = normalizeStringOrNull(countEntry.queryKey);
-    const count = normalizeTotalCount$2(countEntry.count);
-    if (!modelName || !queryKey || count === void 0) continue;
-    counts.push({
-      modelName,
-      queryKey,
-      count
-    });
-  }
-  return {
-    v: 1,
-    tenantId: normalizeStringOrNull(raw.tenantId),
-    uid: normalizeStringOrNull(raw.uid),
-    queries,
-    counts
-  };
-};
-const hydrateRtsFromWindow = () => {
-  if (typeof window === "undefined") return;
-  const browserWindow = window;
-  const raw = browserWindow[STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY];
-  delete browserWindow[STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY];
-  const parsed = parseHydrationData(raw);
-  if (!parsed) return;
-  hydrationDataStore.clear();
-  hydrationPageInfoStore.clear();
-  hydrationTotalCountStore.clear();
-  hydrationCountStore.clear();
-  for (const query of parsed.queries) {
-    hydrationDataStore.set(makeStoreKey(query.modelName, query.queryKey), query.data);
-    hydrationPageInfoStore.set(makeStoreKey(query.modelName, query.queryKey), query.pageInfo);
-    hydrationTotalCountStore.set(makeStoreKey(query.modelName, query.queryKey), query.totalCount);
-  }
-  for (const count of parsed.counts) {
-    hydrationCountStore.set(makeStoreKey(count.modelName, count.queryKey), count.count);
-  }
-};
-const peekHydratedRtsQueryData = (modelName, queryKey) => {
-  return hydrationDataStore.get(makeStoreKey(modelName, queryKey));
-};
-const peekHydratedRtsQueryPageInfo = (modelName, queryKey) => {
-  return hydrationPageInfoStore.get(makeStoreKey(modelName, queryKey));
-};
-const peekHydratedRtsQueryTotalCount = (modelName, queryKey) => {
-  return hydrationTotalCountStore.get(makeStoreKey(modelName, queryKey));
-};
-const peekHydratedRtsCount = (modelName, queryKey) => {
-  return hydrationCountStore.get(makeStoreKey(modelName, queryKey));
-};
-const consumeHydratedRtsQueryData = (modelName, queryKey) => {
-  const key = makeStoreKey(modelName, queryKey);
-  hydrationDataStore.delete(key);
-  hydrationPageInfoStore.delete(key);
-  hydrationTotalCountStore.delete(key);
-};
-const consumeHydratedRtsCount = (modelName, queryKey) => {
-  hydrationCountStore.delete(makeStoreKey(modelName, queryKey));
-};
-const clearHydratedRtsQueryData = () => {
-  hydrationDataStore.clear();
-  hydrationPageInfoStore.clear();
-  hydrationTotalCountStore.clear();
-  hydrationCountStore.clear();
-};
-const RtsSsrRuntimeProvider = (t0) => {
-  const $ = c(3);
-  const {
-    value,
-    children
-  } = t0;
-  let t1;
-  if ($[0] !== children || $[1] !== value) {
-    t1 = /* @__PURE__ */ jsx(RtsSsrRuntimeContext.Provider, { value, children });
-    $[0] = children;
-    $[1] = value;
-    $[2] = t1;
-  } else {
-    t1 = $[2];
-  }
-  return t1;
-};
-const useRtsSsrRuntime = () => {
-  return useContext(RtsSsrRuntimeContext);
-};
-const RTS_QUERY_WINDOW_MAX_COUNT = 4096;
-const memoryStore = /* @__PURE__ */ new Map();
-let reactNativeStorage = null;
-const MMKV_STORAGE_ID = "rpcbase-rts";
-const memoryStorage = {
-  getItem: (key) => memoryStore.get(key) ?? null,
-  setItem: (key, value) => {
-    memoryStore.set(key, String(value));
-  },
-  removeItem: (key) => {
-    memoryStore.delete(key);
-  }
-};
-const asRuntimeStorage = (value) => {
-  if (!value || typeof value !== "object") return null;
-  const candidate = value;
-  if (typeof candidate.getItem !== "function" || typeof candidate.setItem !== "function" || typeof candidate.removeItem !== "function") {
-    return null;
-  }
-  return {
-    getItem: candidate.getItem.bind(value),
-    setItem: candidate.setItem.bind(value),
-    removeItem: candidate.removeItem.bind(value)
-  };
-};
-const isReactNativeRuntime = () => {
-  if (typeof navigator === "undefined") return false;
-  return navigator.product === "ReactNative";
-};
-const getRuntimeRequire = () => {
-  const globalRequire = globalThis.require;
-  if (typeof globalRequire === "function") {
-    return globalRequire;
-  }
-  try {
-    return (0, eval)("require");
-  } catch {
-    return null;
-  }
-};
-const getReactNativeStorage = () => {
-  if (reactNativeStorage) return reactNativeStorage;
-  const runtimeRequire = getRuntimeRequire();
-  if (!runtimeRequire) {
-    throw new Error("RTS storage: react-native-mmkv is required in React Native runtime");
-  }
-  let mmkvModule;
-  try {
-    mmkvModule = runtimeRequire("react-native-mmkv");
-  } catch (error) {
-    const runtimeError = error instanceof Error ? ` ${error.message}` : "";
-    throw new Error(`RTS storage: react-native-mmkv is required in React Native runtime.${runtimeError}`);
-  }
-  const MMKV = mmkvModule.MMKV;
-  if (typeof MMKV !== "function") {
-    throw new Error("RTS storage: invalid react-native-mmkv module shape");
-  }
-  const mmkv = new MMKV({
-    id: MMKV_STORAGE_ID
-  });
-  reactNativeStorage = {
-    getItem: (key) => {
-      const value = mmkv.getString(key);
-      return typeof value === "string" ? value : null;
-    },
-    setItem: (key, value) => {
-      mmkv.set(key, String(value));
-    },
-    removeItem: (key) => {
-      mmkv.delete(key);
-    }
-  };
-  return reactNativeStorage;
-};
-const getRuntimeStorage = () => {
-  if (isReactNativeRuntime()) {
-    return getReactNativeStorage();
-  }
-  const direct = asRuntimeStorage(globalThis.localStorage);
-  if (direct) return direct;
-  const windowStorage = asRuntimeStorage(globalThis.window?.localStorage);
-  if (windowStorage) return windowStorage;
-  return memoryStorage;
-};
-const UNDERSCORE_PREFIX = "$_";
-const DEFAULT_FIND_LIMIT = 4096;
-const INDEXED_DB_ADAPTER = "indexeddb";
-const REACT_NATIVE_SQLITE_ADAPTER = "react-native-sqlite";
-const QUERY_WINDOW_COLLECTION = "$query-windows-v1";
-const QUERY_WINDOW_DOC_TYPE = "rts-query-window";
-const QUERY_WINDOW_SCHEMA_VERSION = 1;
-const QUERY_WINDOW_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-const QUERY_WINDOW_WRITE_ATTEMPTS = 4;
-let storeConfig = null;
-let pouchDbPromise = null;
-let lastAppliedPrefix = null;
-let activePouchAdapter = INDEXED_DB_ADAPTER;
-const collections = /* @__PURE__ */ new Map();
-const dbNamesByPrefix = /* @__PURE__ */ new Map();
-const unwrapDefault = (mod) => {
-  if (!mod || typeof mod !== "object") return mod;
-  const maybe = mod;
-  return maybe.default ?? mod;
-};
-const computeBasePrefix = ({
-  tenantId,
-  appName
-}) => {
-  let prefix = "rb/";
-  if (appName) prefix += `${appName}/`;
-  prefix += `${tenantId}/`;
-  return prefix;
-};
-const getDbNamesKey = (prefix) => `rb:rts:pouchDbs:${prefix}`;
-const getPrefixOverrideKey = ({
-  tenantId,
-  appName
-}) => `rb:rts:pouchPrefix:${appName ?? ""}:${tenantId}`;
-const readPrefixOverride = ({
-  tenantId,
-  appName
-}) => {
-  const storage = getRuntimeStorage();
-  try {
-    const value = storage.getItem(getPrefixOverrideKey({
-      tenantId,
-      appName
-    }));
-    if (!value) return null;
-    if (!value.endsWith("/")) return `${value}/`;
-    return value;
-  } catch {
-    return null;
-  }
-};
-const getPrefix = () => {
-  if (!storeConfig) {
-    throw new Error("RTS PouchDB store is not configured");
-  }
-  if (storeConfig.prefix) return storeConfig.prefix;
-  const basePrefix = computeBasePrefix({
-    tenantId: storeConfig.tenantId,
-    appName: storeConfig.appName
-  });
-  const override = readPrefixOverride({
-    tenantId: storeConfig.tenantId,
-    appName: storeConfig.appName
-  });
-  return override ?? basePrefix;
-};
-const loadDbNames = (prefix) => {
-  const existing = dbNamesByPrefix.get(prefix);
-  if (existing) return existing;
-  const names = /* @__PURE__ */ new Set();
-  const storage = getRuntimeStorage();
-  try {
-    const raw = storage.getItem(getDbNamesKey(prefix));
-    if (raw) {
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed)) {
-        for (const value of parsed) {
-          if (typeof value === "string" && value) names.add(value);
-        }
-      }
-    }
-  } catch {
-    return names;
-  }
-  dbNamesByPrefix.set(prefix, names);
-  return names;
-};
-const persistDbNames = (prefix, names) => {
-  const storage = getRuntimeStorage();
-  try {
-    if (!names.size) {
-      storage.removeItem(getDbNamesKey(prefix));
-      dbNamesByPrefix.delete(prefix);
-      return;
-    }
-    storage.setItem(getDbNamesKey(prefix), JSON.stringify(Array.from(names)));
-    dbNamesByPrefix.set(prefix, names);
-  } catch {
-    return;
-  }
-};
-const registerDbName = (prefix, dbName) => {
-  if (!prefix || !dbName) return;
-  const names = loadDbNames(prefix);
-  if (names.has(dbName)) return;
-  names.add(dbName);
-  persistDbNames(prefix, names);
-};
-const unregisterDbName = (prefix, dbName) => {
-  if (!prefix || !dbName) return;
-  const names = loadDbNames(prefix);
-  if (!names.delete(dbName)) return;
-  persistDbNames(prefix, names);
-};
-const getPouchDb = async () => {
-  if (!pouchDbPromise) {
-    pouchDbPromise = (async () => {
-      const [core, findPlugin] = await Promise.all([import("pouchdb-core"), import("pouchdb-find")]);
-      const PouchDB = unwrapDefault(core);
-      if (isReactNativeRuntime()) {
-        const moduleName = "pouchdb-adapter-react-native-sqlite";
-        let sqliteAdapterModule;
-        try {
-          sqliteAdapterModule = await import(
-            /* @vite-ignore */
-            moduleName
-          );
-        } catch (error) {
-          const runtimeError = error instanceof Error ? ` ${error.message}` : "";
-          throw new Error(`RTS PouchDB: missing react-native sqlite adapter. Install \`pouchdb-adapter-react-native-sqlite\` in the app.${runtimeError}`);
-        }
-        PouchDB.plugin(unwrapDefault(sqliteAdapterModule));
-        activePouchAdapter = REACT_NATIVE_SQLITE_ADAPTER;
-      } else {
-        const indexedDbAdapter = await import("pouchdb-adapter-indexeddb");
-        PouchDB.plugin(unwrapDefault(indexedDbAdapter));
-        activePouchAdapter = INDEXED_DB_ADAPTER;
-      }
-      PouchDB.plugin(unwrapDefault(findPlugin));
-      return PouchDB;
-    })();
-  }
-  return pouchDbPromise;
-};
-const applyPrefix = (PouchDB, prefix = getPrefix()) => {
-  if (prefix === lastAppliedPrefix) return;
-  PouchDB.prefix = prefix;
-  lastAppliedPrefix = prefix;
-};
-const configureRtsPouchStore = (config) => {
-  storeConfig = config;
-  lastAppliedPrefix = null;
-  collections.clear();
-};
-const getCollection = async (modelName, options) => {
-  const prefix = getPrefix();
-  const PouchDB = await getPouchDb();
-  applyPrefix(PouchDB, prefix);
-  const dbName = `${options.uid}/${modelName}`;
-  const dbKey = `${prefix}${dbName}`;
-  const existing = collections.get(dbKey);
-  if (existing) return existing;
-  registerDbName(prefix, dbName);
-  const db = new PouchDB(dbName, {
-    adapter: activePouchAdapter,
-    revs_limit: 1
-  });
-  collections.set(dbKey, db);
-  return db;
-};
-const getQueryWindowScope = (uid) => {
-  if (!storeConfig) {
-    throw new Error("RTS PouchDB store is not configured");
-  }
-  return {
-    appName: storeConfig.appName ?? "",
-    tenantId: storeConfig.tenantId,
-    uid
-  };
-};
-const getQueryWindowFingerprint = (scope, modelName, queryKey) => JSON.stringify([QUERY_WINDOW_SCHEMA_VERSION, scope.appName, scope.tenantId, scope.uid, modelName, queryKey]);
-const getQueryWindowDocumentId = (fingerprint) => `${QUERY_WINDOW_DOC_TYPE}:${encodeURIComponent(fingerprint)}`;
-const getPouchErrorStatus = (error) => {
-  if (!error || typeof error !== "object") return void 0;
-  const status = error.status;
-  return typeof status === "number" && Number.isFinite(status) ? status : void 0;
-};
-const getPouchDocument = async (collection, id) => {
-  try {
-    return await collection.get(id);
-  } catch (error) {
-    if (getPouchErrorStatus(error) === 404) return null;
-    throw error;
-  }
-};
-const normalizeQueryWindowPageInfo = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-  const raw = value;
-  if (typeof raw.hasNextPage !== "boolean" || typeof raw.hasPrevPage !== "boolean") return null;
-  if (raw.nextCursor !== void 0 && typeof raw.nextCursor !== "string") return null;
-  if (raw.prevCursor !== void 0 && typeof raw.prevCursor !== "string") return null;
-  const nextCursor = typeof raw.nextCursor === "string" && raw.nextCursor ? raw.nextCursor : void 0;
-  const prevCursor = typeof raw.prevCursor === "string" && raw.prevCursor ? raw.prevCursor : void 0;
-  return {
-    hasNextPage: raw.hasNextPage,
-    hasPrevPage: raw.hasPrevPage,
-    ...nextCursor ? {
-      nextCursor
-    } : {},
-    ...prevCursor ? {
-      prevCursor
-    } : {}
-  };
-};
-const isValidQueryWindowServerVersion = (value) => {
-  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-};
-const isQueryWindowData = (value) => Array.isArray(value) && value.every((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
-const parseQueryWindowSnapshot = (doc, expected) => {
-  if (doc.type !== QUERY_WINDOW_DOC_TYPE || doc.schemaVersion !== QUERY_WINDOW_SCHEMA_VERSION) return null;
-  if (doc.fingerprint !== expected.fingerprint) return null;
-  if (doc.modelName !== expected.modelName || doc.queryKey !== expected.queryKey) return null;
-  const scope = doc.scope;
-  if (!scope || typeof scope !== "object" || Array.isArray(scope)) return null;
-  const rawScope = scope;
-  if (rawScope.appName !== expected.scope.appName || rawScope.tenantId !== expected.scope.tenantId || rawScope.uid !== expected.scope.uid) {
-    return null;
-  }
-  if (!isQueryWindowData(doc.data)) return null;
-  const pageInfo = normalizeQueryWindowPageInfo(doc.pageInfo);
-  if (!pageInfo) return null;
-  const requestedCount = doc.requestedCount;
-  if (!Number.isSafeInteger(requestedCount) || requestedCount <= 0 || requestedCount > RTS_QUERY_WINDOW_MAX_COUNT || doc.data.length > requestedCount) {
-    return null;
-  }
-  const storedAt = doc.storedAt;
-  if (typeof storedAt !== "number" || !Number.isFinite(storedAt) || storedAt < 0) return null;
-  const totalCount = doc.totalCount;
-  if (totalCount !== void 0 && (!Number.isSafeInteger(totalCount) || totalCount < 0)) {
-    return null;
-  }
-  const serverVersion = doc.serverVersion;
-  if (serverVersion !== void 0 && !isValidQueryWindowServerVersion(serverVersion)) return null;
-  const serverEpoch = doc.serverEpoch;
-  if (serverEpoch !== void 0 && (typeof serverEpoch !== "string" || !serverEpoch)) return null;
-  if (serverEpoch === void 0 !== (serverVersion === void 0)) return null;
-  return {
-    data: doc.data,
-    pageInfo,
-    ...typeof totalCount === "number" ? {
-      totalCount
-    } : {},
-    requestedCount,
-    ...serverEpoch !== void 0 ? {
-      serverEpoch
-    } : {},
-    ...serverVersion !== void 0 ? {
-      serverVersion
-    } : {},
-    storedAt
-  };
-};
-const deleteQueryWindowDocument = async (collection, doc) => {
-  const id = typeof doc._id === "string" ? doc._id : "";
-  const rev = typeof doc._rev === "string" ? doc._rev : "";
-  if (!id || !rev) return;
-  await collection.put({
-    _id: id,
-    _rev: rev,
-    _deleted: true
-  }).catch(() => void 0);
-};
-const readQueryWindowSnapshot = async ({
-  modelName,
-  queryKey,
-  uid,
-  now = Date.now()
-}) => {
-  const scope = getQueryWindowScope(uid);
-  const fingerprint = getQueryWindowFingerprint(scope, modelName, queryKey);
-  const id = getQueryWindowDocumentId(fingerprint);
-  const collection = await getCollection(QUERY_WINDOW_COLLECTION, {
-    uid
-  });
-  const doc = await getPouchDocument(collection, id);
-  if (!doc) return {
-    hit: false
-  };
-  const snapshot = parseQueryWindowSnapshot(doc, {
-    fingerprint,
-    scope,
-    modelName,
-    queryKey
-  });
-  if (!snapshot || now - snapshot.storedAt >= QUERY_WINDOW_TTL_MS) {
-    await deleteQueryWindowDocument(collection, doc);
-    return {
-      hit: false
-    };
-  }
-  return {
-    hit: true,
-    snapshot
-  };
-};
-const writeQueryWindowSnapshot = async ({
-  modelName,
-  queryKey,
-  uid,
-  data,
-  pageInfo: rawPageInfo,
-  totalCount,
-  requestedCount,
-  serverEpoch,
-  serverVersion,
-  storedAt: rawStoredAt
-}) => {
-  if (!modelName.trim()) throw new Error("writeQueryWindowSnapshot: modelName must be a non-empty string");
-  if (!queryKey) throw new Error("writeQueryWindowSnapshot: queryKey must be a non-empty string");
-  if (!uid.trim()) throw new Error("writeQueryWindowSnapshot: uid must be a non-empty string");
-  if (!isQueryWindowData(data)) throw new Error("writeQueryWindowSnapshot: data must contain objects");
-  const pageInfo = normalizeQueryWindowPageInfo(rawPageInfo);
-  if (!pageInfo) throw new Error("writeQueryWindowSnapshot: invalid pageInfo");
-  if (!Number.isSafeInteger(requestedCount) || requestedCount <= 0 || requestedCount > RTS_QUERY_WINDOW_MAX_COUNT || data.length > requestedCount) {
-    throw new Error("writeQueryWindowSnapshot: requestedCount must cover data and be between 1 and 4096");
-  }
-  if (totalCount !== void 0 && (!Number.isSafeInteger(totalCount) || totalCount < 0)) {
-    throw new Error("writeQueryWindowSnapshot: totalCount must be a non-negative integer");
-  }
-  if (serverVersion !== void 0 && !isValidQueryWindowServerVersion(serverVersion)) {
-    throw new Error("writeQueryWindowSnapshot: invalid serverVersion");
-  }
-  if (serverEpoch !== void 0 && (typeof serverEpoch !== "string" || !serverEpoch)) {
-    throw new Error("writeQueryWindowSnapshot: invalid serverEpoch");
-  }
-  if (serverEpoch === void 0 !== (serverVersion === void 0)) {
-    throw new Error("writeQueryWindowSnapshot: serverEpoch and serverVersion must be provided together");
-  }
-  const storedAt = rawStoredAt ?? Date.now();
-  if (!Number.isFinite(storedAt) || storedAt < 0) {
-    throw new Error("writeQueryWindowSnapshot: storedAt must be a non-negative finite number");
-  }
-  const scope = getQueryWindowScope(uid);
-  const fingerprint = getQueryWindowFingerprint(scope, modelName, queryKey);
-  const id = getQueryWindowDocumentId(fingerprint);
-  const collection = await getCollection(QUERY_WINDOW_COLLECTION, {
-    uid
-  });
-  const snapshot = {
-    data,
-    pageInfo,
-    ...totalCount !== void 0 ? {
-      totalCount
-    } : {},
-    requestedCount,
-    ...serverEpoch !== void 0 ? {
-      serverEpoch
-    } : {},
-    ...serverVersion !== void 0 ? {
-      serverVersion
-    } : {},
-    storedAt
-  };
-  let lastConflict;
-  for (let attempt = 0; attempt < QUERY_WINDOW_WRITE_ATTEMPTS; attempt += 1) {
-    const current = await getPouchDocument(collection, id);
-    const currentSnapshot = current ? parseQueryWindowSnapshot(current, {
-      fingerprint,
-      scope,
-      modelName,
-      queryKey
-    }) : null;
-    if (currentSnapshot && (currentSnapshot.serverEpoch === serverEpoch && currentSnapshot.serverVersion !== void 0 && serverVersion !== void 0 && currentSnapshot.serverVersion >= serverVersion || (!serverEpoch || currentSnapshot.serverEpoch !== serverEpoch) && currentSnapshot.storedAt > storedAt)) {
-      return currentSnapshot;
-    }
-    const rev = typeof current?._rev === "string" ? current._rev : void 0;
-    const doc = {
-      _id: id,
-      ...rev ? {
-        _rev: rev
-      } : {},
-      type: QUERY_WINDOW_DOC_TYPE,
-      schemaVersion: QUERY_WINDOW_SCHEMA_VERSION,
-      fingerprint,
-      scope,
-      modelName,
-      queryKey,
-      data,
-      pageInfo,
-      ...totalCount !== void 0 ? {
-        totalCount
-      } : {},
-      requestedCount,
-      ...serverEpoch !== void 0 ? {
-        serverEpoch
-      } : {},
-      ...serverVersion !== void 0 ? {
-        serverVersion
-      } : {},
-      storedAt
-    };
-    try {
-      await collection.put(doc);
-      return snapshot;
-    } catch (error) {
-      if (getPouchErrorStatus(error) !== 409) throw error;
-      lastConflict = error;
-    }
-  }
-  throw lastConflict ?? new Error("writeQueryWindowSnapshot: failed to persist snapshot");
-};
-const invalidateQueryWindowSnapshots = async ({
-  uid,
-  modelName
-}) => {
-  const collection = await getCollection(QUERY_WINDOW_COLLECTION, {
-    uid
-  });
-  const selector = {
-    type: QUERY_WINDOW_DOC_TYPE,
-    ...modelName ? {
-      modelName
-    } : {}
-  };
-  for (let batch = 0; batch < 32; batch += 1) {
-    const {
-      docs
-    } = await collection.find({
-      selector,
-      fields: ["_id", "_rev"],
-      limit: DEFAULT_FIND_LIMIT
-    });
-    const deletions = docs.map((doc) => ({
-      _id: typeof doc._id === "string" ? doc._id : "",
-      _rev: typeof doc._rev === "string" ? doc._rev : "",
-      _deleted: true
-    })).filter((doc) => doc._id && doc._rev);
-    if (!deletions.length) return;
-    const results = await collection.bulkDocs(deletions);
-    const hasConflict = Array.isArray(results) && results.some((result) => {
-      if (!result || typeof result !== "object") return false;
-      const record = result;
-      return record.error === true || record.status === 409;
-    });
-    if (hasConflict) continue;
-    if (docs.length < DEFAULT_FIND_LIMIT) return;
-  }
-};
-const replaceQueryKeys = (value, replaceKey) => {
-  if (typeof value !== "object" || value === null) {
-    return value;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => replaceQueryKeys(item, replaceKey));
-  }
-  const obj = value;
-  const next = Object.create(Object.getPrototypeOf(obj));
-  for (const key of Object.keys(obj)) {
-    if (/^\$/.test(key) || /\.\d+$/.test(key)) {
-      throw new Error(`replaceQueryKeys: Unexpected key format: ${key}`);
-    }
-    const newKey = replaceKey(key);
-    next[newKey] = replaceQueryKeys(obj[key], replaceKey);
-  }
-  return next;
-};
-const isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
-const splitPath = (path) => path.split(".").map((part) => part.trim()).filter(Boolean);
-const getKeys = (obj, parentKey = "") => {
-  const keys = [];
-  for (const key of Object.keys(obj)) {
-    const nextKey = parentKey ? `${parentKey}.${key}` : key;
-    const value = obj[key];
-    if (Array.isArray(value)) {
-      const arrayKeys = /* @__PURE__ */ new Set();
-      for (const item of value) {
-        if (isRecord(item)) {
-          for (const nestedKey of getKeys(item, nextKey)) {
-            arrayKeys.add(nestedKey);
-          }
-        }
-      }
-      if (arrayKeys.size > 0) {
-        keys.push(...arrayKeys);
-      } else {
-        keys.push(nextKey);
-      }
-    } else if (isRecord(value)) {
-      keys.push(...getKeys(value, nextKey));
-    } else {
-      keys.push(nextKey);
-    }
-  }
-  return keys;
-};
-const satisfiesProjection = (doc, projection) => {
-  const docKeys = new Set(getKeys(doc));
-  const projectionKeys = new Set(Object.keys(projection).filter((key) => projection[key] === 1));
-  if (!projectionKeys.has("_id")) {
-    docKeys.delete("_id");
-  }
-  if (projectionKeys.size > docKeys.size) return false;
-  for (const key of projectionKeys) {
-    if (!docKeys.has(key)) return false;
-  }
-  return true;
-};
-const collectValuesAtPath = (value, parts, index) => {
-  if (index >= parts.length) return [value];
-  if (Array.isArray(value)) {
-    return value.flatMap((item) => collectValuesAtPath(item, parts, index));
-  }
-  if (!isRecord(value)) return [void 0];
-  return collectValuesAtPath(value[parts[index]], parts, index + 1);
-};
-const getValueAtPath = (doc, path) => {
-  const parts = splitPath(path);
-  if (!parts.length) return void 0;
-  const values = collectValuesAtPath(doc, parts, 0);
-  if (values.length === 0) return void 0;
-  if (values.length === 1) return values[0];
-  return values;
-};
-const pathCrossesArrayBeforeLeaf = (value, parts, index = 0) => {
-  if (index >= parts.length - 1) return false;
-  if (!isRecord(value)) return false;
-  const next = value[parts[index]];
-  if (Array.isArray(next)) return true;
-  return pathCrossesArrayBeforeLeaf(next, parts, index + 1);
-};
-const assignValueAtPath = (current, parts, index, value, valuesQueue) => {
-  const key = parts[index];
-  if (index === parts.length - 1) {
-    current[key] = valuesQueue ? valuesQueue.shift() : value;
-    return;
-  }
-  const next = current[key];
-  if (Array.isArray(next)) {
-    for (const item of next) {
-      if (isRecord(item)) {
-        assignValueAtPath(item, parts, index + 1, value, valuesQueue);
-      }
-    }
-    return;
-  }
-  if (!isRecord(next)) {
-    current[key] = {};
-  }
-  assignValueAtPath(current[key], parts, index + 1, value, valuesQueue);
-};
-const setValueAtPath = (doc, path, value) => {
-  const parts = splitPath(path);
-  if (!parts.length) return;
-  const valuesQueue = pathCrossesArrayBeforeLeaf(doc, parts) && Array.isArray(value) ? [...value] : void 0;
-  assignValueAtPath(doc, parts, 0, value, valuesQueue);
-};
-const unsetValueAtPathParts = (current, parts, index) => {
-  if (Array.isArray(current)) {
-    for (const item of current) {
-      unsetValueAtPathParts(item, parts, index);
-    }
-    return;
-  }
-  if (!isRecord(current)) return;
-  const key = parts[index];
-  if (index === parts.length - 1) {
-    delete current[key];
-    return;
-  }
-  unsetValueAtPathParts(current[key], parts, index + 1);
-};
-const unsetValueAtPath = (doc, path) => {
-  const parts = splitPath(path);
-  if (!parts.length) return;
-  unsetValueAtPathParts(doc, parts, 0);
-};
-const cloneDoc = (doc) => {
-  try {
-    return structuredClone(doc);
-  } catch {
-    return JSON.parse(JSON.stringify(doc));
-  }
-};
-const toProjectionSpec = (projection) => {
-  const spec = {};
-  for (const [key, value] of Object.entries(projection)) {
-    const path = key.trim();
-    if (!path) continue;
-    if (value === 1 || value === 0) {
-      spec[path] = value;
-    }
-  }
-  return spec;
-};
-const copyValueAtPath = (source, target, parts, index = 0) => {
-  if (!isRecord(source)) return false;
-  const key = parts[index];
-  const sourceValue = source[key];
-  if (sourceValue === void 0) return false;
-  if (index === parts.length - 1) {
-    target[key] = cloneDoc(sourceValue);
-    return true;
-  }
-  if (Array.isArray(sourceValue)) {
-    const existing = Array.isArray(target[key]) ? target[key] : [];
-    let copiedAny = false;
-    const nextArray = sourceValue.map((item, itemIndex) => {
-      const currentTarget = isRecord(existing[itemIndex]) ? existing[itemIndex] : {};
-      if (copyValueAtPath(item, currentTarget, parts, index + 1)) {
-        copiedAny = true;
-      }
-      return currentTarget;
-    });
-    if (copiedAny || sourceValue.length === 0) {
-      target[key] = nextArray;
-      return true;
-    }
-    return false;
-  }
-  const nextTarget = isRecord(target[key]) ? target[key] : {};
-  if (!copyValueAtPath(sourceValue, nextTarget, parts, index + 1)) return false;
-  target[key] = nextTarget;
-  return true;
-};
-const applyProjection = (doc, projection) => {
-  const spec = toProjectionSpec(projection);
-  const includeKeys = Object.keys(spec).filter((key) => spec[key] === 1);
-  const excludeKeys = Object.keys(spec).filter((key) => spec[key] === 0);
-  if (includeKeys.length > 0) {
-    const projected2 = {};
-    for (const key of includeKeys) {
-      const parts = splitPath(key);
-      if (parts.length > 0) copyValueAtPath(doc, projected2, parts);
-    }
-    if (spec._id !== 0 && Object.hasOwn(doc, "_id")) {
-      projected2._id = doc._id;
-    }
-    return projected2;
-  }
-  const projected = cloneDoc(doc);
-  for (const key of excludeKeys) {
-    unsetValueAtPath(projected, key);
-  }
-  return projected;
-};
-const compareSort = (a, b, sort) => {
-  for (const key of Object.keys(sort)) {
-    const dir = sort[key];
-    const aVal = getValueAtPath(a, key);
-    const bVal = getValueAtPath(b, key);
-    if (typeof aVal === "number" && typeof bVal === "number") {
-      if (aVal < bVal) return -1 * dir;
-      if (aVal > bVal) return 1 * dir;
-      continue;
-    }
-    if (typeof aVal === "string" && typeof bVal === "string") {
-      if (aVal < bVal) return -1 * dir;
-      if (aVal > bVal) return 1 * dir;
-      continue;
-    }
-  }
-  return 0;
-};
-const extractDocId = (value) => {
-  if (typeof value === "string") return value;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return "";
-  const id = value._id;
-  return typeof id === "string" ? id : "";
-};
-const matchValue = (docValue, matchValueRaw) => {
-  if (Array.isArray(matchValueRaw)) {
-    if (!Array.isArray(docValue)) return false;
-    if (docValue.length !== matchValueRaw.length) return false;
-    for (let i = 0; i < matchValueRaw.length; i += 1) {
-      const matched = matchValue(docValue[i], matchValueRaw[i]);
-      if (matched === null) return null;
-      if (!matched) return false;
-    }
-    return true;
-  }
-  if (matchValueRaw && typeof matchValueRaw === "object") {
-    const matchObj = matchValueRaw;
-    if (Object.keys(matchObj).some((key) => key.startsWith("$"))) return null;
-    if (!docValue || typeof docValue !== "object" || Array.isArray(docValue)) return false;
-    const docObj = docValue;
-    for (const key of Object.keys(matchObj)) {
-      const matched = matchValue(docObj[key], matchObj[key]);
-      if (matched === null) return null;
-      if (!matched) return false;
-    }
-    return true;
-  }
-  return Object.is(docValue, matchValueRaw);
-};
-const matchesSimpleQuery = (doc, query) => {
-  for (const [key, expected] of Object.entries(query)) {
-    if (key.startsWith("$")) return null;
-    const actual = getValueAtPath(doc, key);
-    const matched = matchValue(actual, expected);
-    if (matched === null) return null;
-    if (!matched) return false;
-  }
-  return true;
-};
-const remapDocFromStorage = (doc) => {
-  const next = {};
-  for (const [key, value] of Object.entries(doc)) {
-    const newKey = key.startsWith(UNDERSCORE_PREFIX) ? key.replace(/^\$_/, "") : key;
-    next[newKey] = value;
-  }
-  return next;
-};
-const runQueryInternal = async ({
-  modelName,
-  query = {},
-  options,
-  strictProjection = false
-}) => {
-  const collection = await getCollection(modelName, {
-    uid: options.uid
-  });
-  const replacedQuery = replaceQueryKeys(query, (key) => key.startsWith("_") && key !== "_id" ? `${UNDERSCORE_PREFIX}${key}` : key);
-  const limit = typeof options.limit === "number" ? Math.abs(options.limit) : DEFAULT_FIND_LIMIT;
-  const {
-    docs
-  } = await collection.find({
-    selector: replacedQuery,
-    limit
-  });
-  const mappedDocs = docs.map(({
-    _rev: _revIgnored,
-    ...rest
-  }) => remapDocFromStorage(rest));
-  let filteredDocs = mappedDocs;
-  if (options.projection) {
-    if (strictProjection && mappedDocs.some((entry) => !satisfiesProjection(entry, options.projection))) {
-      return {
-        data: [],
-        context: {
-          source: "cache"
-        },
-        projectionMismatch: true
-      };
-    }
-    filteredDocs = filteredDocs.filter((entry) => satisfiesProjection(entry, options.projection));
-  }
-  let result = filteredDocs;
-  if (options.sort) {
-    result = result.sort((a, b) => compareSort(a, b, options.sort));
-  }
-  return {
-    data: result,
-    context: {
-      source: "cache"
-    },
-    projectionMismatch: false
-  };
-};
-const runQuery = async ({
-  modelName,
-  query = {},
-  options
-}) => {
-  const result = await runQueryInternal({
-    modelName,
-    query,
-    options
-  });
-  return {
-    data: result.data,
-    context: result.context
-  };
-};
-const addWriteDoc = (writes, modelName, doc) => {
-  const docsById = writes.get(modelName) ?? /* @__PURE__ */ new Map();
-  docsById.set(doc._id, doc);
-  writes.set(modelName, docsById);
-};
-const sanitizePopulatedDoc = (doc, populate, writes) => {
-  const next = cloneDoc(doc);
-  for (const entry of populate) {
-    const pathParts = splitPath(entry.path);
-    const crossesArray = pathCrossesArrayBeforeLeaf(next, pathParts);
-    const value = getValueAtPath(next, entry.path);
-    if (value === void 0) continue;
-    if (Array.isArray(value)) {
-      const ids = [];
-      const nextValues = [];
-      for (const candidate of value) {
-        const id2 = extractDocId(candidate);
-        if (id2) ids.push(id2);
-        if (crossesArray) nextValues.push(id2 || null);
-        if (!entry.model) continue;
-        if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
-        const candidateDoc = candidate;
-        const nested2 = entry.populate?.length ? sanitizePopulatedDoc(candidateDoc, entry.populate, writes) : cloneDoc(candidateDoc);
-        addWriteDoc(writes, entry.model, nested2);
-      }
-      setValueAtPath(next, entry.path, crossesArray ? nextValues : ids);
-      continue;
-    }
-    const id = extractDocId(value);
-    setValueAtPath(next, entry.path, id || null);
-    if (!id) continue;
-    if (!entry.model) continue;
-    if (!value || typeof value !== "object" || Array.isArray(value)) continue;
-    const valueDoc = value;
-    const nested = entry.populate?.length ? sanitizePopulatedDoc(valueDoc, entry.populate, writes) : cloneDoc(valueDoc);
-    addWriteDoc(writes, entry.model, nested);
-  }
-  return next;
-};
-const updatePopulatedDocs = async ({
-  modelName,
-  data,
-  uid,
-  populate
-}) => {
-  if (!data.length) return;
-  const writes = /* @__PURE__ */ new Map();
-  const roots = data.map((doc) => sanitizePopulatedDoc(doc, populate, writes));
-  await updateDocs(modelName, roots, uid);
-  for (const [targetModelName, docsById] of writes.entries()) {
-    if (!docsById.size) continue;
-    await updateDocs(targetModelName, Array.from(docsById.values()), uid);
-  }
-};
-const loadProjectedDocsByIds = async ({
-  modelName,
-  ids,
-  uid,
-  projection
-}) => {
-  const uniqueIds = Array.from(new Set(ids.filter(Boolean)));
-  if (!uniqueIds.length) {
-    return {
-      rawDocsById: /* @__PURE__ */ new Map(),
-      projectedDocsById: /* @__PURE__ */ new Map(),
-      projectionMismatch: false
-    };
-  }
-  const collection = await getCollection(modelName, {
-    uid
-  });
-  const {
-    docs
-  } = await collection.find({
-    selector: {
-      _id: {
-        $in: uniqueIds
-      }
-    },
-    limit: uniqueIds.length
-  });
-  const rawDocsById = /* @__PURE__ */ new Map();
-  const projectedDocsById = /* @__PURE__ */ new Map();
-  let projectionMismatch = false;
-  for (const rawDoc of docs) {
-    const id = typeof rawDoc._id === "string" ? rawDoc._id : "";
-    if (!id) continue;
-    const {
-      _rev: _revIgnored,
-      ...rest
-    } = rawDoc;
-    const remapped = remapDocFromStorage(rest);
-    if (!satisfiesProjection(remapped, projection)) {
-      projectionMismatch = true;
-      continue;
-    }
-    rawDocsById.set(id, remapped);
-    projectedDocsById.set(id, applyProjection(remapped, projection));
-  }
-  if (projectedDocsById.size < uniqueIds.length) {
-    projectionMismatch = true;
-  }
-  return {
-    rawDocsById,
-    projectedDocsById,
-    projectionMismatch
-  };
-};
-const hydratePopulateEntries = async ({
-  docs,
-  populate,
-  uid
-}) => {
-  const currentDocs = docs;
-  for (const entry of populate) {
-    if (!entry.model) {
-      return {
-        hit: false,
-        data: []
-      };
-    }
-    const descriptors = currentDocs.map((doc) => {
-      const pathParts = splitPath(entry.path);
-      const crossesArray = pathCrossesArrayBeforeLeaf(doc, pathParts);
-      const rawValue = getValueAtPath(doc, entry.path);
-      const isArray = Array.isArray(rawValue);
-      const values = isArray ? rawValue : [rawValue];
-      const ids = values.map((candidate) => extractDocId(candidate)).filter(Boolean);
-      return {
-        doc,
-        hasValue: rawValue !== void 0,
-        isArray,
-        crossesArray,
-        values,
-        ids
-      };
-    });
-    const allIds = descriptors.flatMap((descriptor) => descriptor.ids);
-    const loaded = await loadProjectedDocsByIds({
-      modelName: entry.model,
-      ids: allIds,
-      uid,
-      projection: entry.select
-    });
-    if (loaded.projectionMismatch) {
-      return {
-        hit: false,
-        data: []
-      };
-    }
-    let populatedDocsById = loaded.projectedDocsById;
-    if (entry.match) {
-      const filtered = /* @__PURE__ */ new Map();
-      for (const [id, candidate] of loaded.rawDocsById.entries()) {
-        const matched = matchesSimpleQuery(candidate, entry.match);
-        if (matched === null) return {
-          hit: false,
-          data: []
-        };
-        if (!matched) continue;
-        const projected = populatedDocsById.get(id);
-        if (projected) filtered.set(id, projected);
-      }
-      populatedDocsById = filtered;
-    }
-    if (entry.populate?.length) {
-      const nestedResult = await hydratePopulateEntries({
-        docs: Array.from(populatedDocsById.values()).map((candidate) => cloneDoc(candidate)),
-        populate: entry.populate,
-        uid
-      });
-      if (!nestedResult.hit) {
-        return {
-          hit: false,
-          data: []
-        };
-      }
-      populatedDocsById = nestedResult.data.reduce((acc, candidate) => {
-        const id = extractDocId(candidate);
-        if (id) acc.set(id, candidate);
-        return acc;
-      }, /* @__PURE__ */ new Map());
-    }
-    for (const descriptor of descriptors) {
-      if (!descriptor.hasValue) continue;
-      if (descriptor.isArray && descriptor.crossesArray) {
-        const values = descriptor.values.map((candidate) => {
-          const id = extractDocId(candidate);
-          return id ? populatedDocsById.get(id) ?? null : null;
-        });
-        setValueAtPath(descriptor.doc, entry.path, values);
-        continue;
-      }
-      if (!descriptor.ids.length) {
-        setValueAtPath(descriptor.doc, entry.path, descriptor.isArray ? [] : null);
-        continue;
-      }
-      if (descriptor.isArray) {
-        let values = descriptor.ids.map((id) => populatedDocsById.get(id)).filter((candidate) => Boolean(candidate));
-        if (entry.options?.sort) {
-          values = values.sort((a, b) => compareSort(a, b, entry.options.sort));
-        }
-        if (typeof entry.options?.limit === "number" && Number.isFinite(entry.options.limit)) {
-          values = values.slice(0, Math.max(0, Math.floor(Math.abs(entry.options.limit))));
-        }
-        setValueAtPath(descriptor.doc, entry.path, values);
-        continue;
-      }
-      const value = populatedDocsById.get(descriptor.ids[0]);
-      setValueAtPath(descriptor.doc, entry.path, value ?? null);
-    }
-  }
-  return {
-    hit: true,
-    data: currentDocs
-  };
-};
-const runPopulatedQuery = async ({
-  modelName,
-  query = {},
-  options
-}) => {
-  const rootResult = await runQueryInternal({
-    modelName,
-    query,
-    options: {
-      uid: options.uid,
-      projection: options.projection,
-      sort: options.sort,
-      limit: options.limit
-    },
-    strictProjection: true
-  });
-  if (rootResult.projectionMismatch) {
-    return {
-      hit: false,
-      data: [],
-      context: rootResult.context
-    };
-  }
-  const projectedRoots = rootResult.data.map((doc) => applyProjection(doc, options.projection));
-  const hydrated = await hydratePopulateEntries({
-    docs: projectedRoots.map((doc) => cloneDoc(doc)),
-    populate: options.populate,
-    uid: options.uid
-  });
-  if (!hydrated.hit) {
-    return {
-      hit: false,
-      data: [],
-      context: rootResult.context
-    };
-  }
-  return {
-    hit: true,
-    data: hydrated.data,
-    context: rootResult.context
-  };
-};
-const updateDocs = async (modelName, data, uid) => {
-  const collection = await getCollection(modelName, {
-    uid
-  });
-  const allIds = data.map((doc) => doc._id).filter(Boolean);
-  if (!allIds.length) return;
-  const {
-    docs: currentDocs
-  } = await collection.find({
-    selector: {
-      _id: {
-        $in: allIds
-      }
-    },
-    fields: ["_id", "_rev"],
-    limit: allIds.length
-  });
-  const currentDocsById = currentDocs.reduce((acc, doc) => {
-    const id = String(doc._id ?? "");
-    if (id) acc[id] = doc;
-    return acc;
-  }, {});
-  const newDocs = data.map((mongoDoc) => {
-    const currentDoc = currentDocsById[mongoDoc._id] ?? {
-      _id: mongoDoc._id
-    };
-    const nextDoc = Object.entries(mongoDoc).reduce((acc, [key, value]) => {
-      const newKey = key !== "_id" && key.startsWith("_") ? `${UNDERSCORE_PREFIX}${key}` : key;
-      acc[newKey] = value;
-      return acc;
-    }, {
-      ...currentDoc
-    });
-    const rev = currentDoc._rev;
-    if (typeof rev === "string" && rev) {
-      nextDoc._rev = rev;
-    } else {
-      delete nextDoc._rev;
-    }
-    return nextDoc;
-  });
-  await collection.bulkDocs(newDocs);
-};
-const deleteDocs = async (modelName, ids, uid) => {
-  const collection = await getCollection(modelName, {
-    uid
-  });
-  const allIds = ids.map((id) => String(id ?? "")).filter(Boolean);
-  if (!allIds.length) return;
-  const {
-    docs: currentDocs
-  } = await collection.find({
-    selector: {
-      _id: {
-        $in: allIds
-      }
-    },
-    fields: ["_id", "_rev"],
-    limit: allIds.length
-  });
-  const deletions = currentDocs.map((doc) => ({
-    _id: String(doc?._id ?? ""),
-    _rev: doc?._rev,
-    _deleted: true
-  })).filter((doc) => doc._id && typeof doc._rev === "string" && doc._rev);
-  if (!deletions.length) return;
-  await collection.bulkDocs(deletions);
-};
-const destroyCollection = async (modelName, uid) => {
-  const collection = await getCollection(modelName, {
-    uid
-  });
-  const prefix = getPrefix();
-  const dbName = `${uid}/${modelName}`;
-  collections.delete(`${prefix}${dbName}`);
-  unregisterDbName(prefix, dbName);
-  await collection.destroy();
-};
-const resetRtsPouchStore = ({
-  tenantId,
-  appName
-}) => {
-  const basePrefix = computeBasePrefix({
-    tenantId,
-    appName
-  });
-  const oldPrefix = readPrefixOverride({
-    tenantId,
-    appName
-  }) ?? basePrefix;
-  const dbNames = Array.from(loadDbNames(oldPrefix));
-  const openDbs = Array.from(collections.entries()).filter(([key]) => key.startsWith(oldPrefix)).map(([, db]) => db);
-  void (async () => {
-    const remaining = new Set(dbNames);
-    await Promise.all(openDbs.map((db) => db.destroy().catch(() => {
-    })));
-    if (remaining.size) {
-      const PouchDB = await getPouchDb();
-      const PouchDBForPrefix = PouchDB.defaults?.({}) ?? PouchDB;
-      PouchDBForPrefix.prefix = oldPrefix;
-      await Promise.all(Array.from(remaining).map(async (name) => {
-        const db = new PouchDBForPrefix(name, {
-          adapter: activePouchAdapter,
-          revs_limit: 1
-        });
-        await db.destroy().then(() => {
-          remaining.delete(name);
-        }).catch(() => {
-        });
-      }));
-    }
-    if (remaining.size) {
-      persistDbNames(oldPrefix, remaining);
-    } else {
-      persistDbNames(oldPrefix, /* @__PURE__ */ new Set());
-    }
-  })();
-  const newPrefix = `${basePrefix}reset-${Date.now().toString(16)}/`;
-  const storage = getRuntimeStorage();
-  try {
-    storage.setItem(getPrefixOverrideKey({
-      tenantId,
-      appName
-    }), newPrefix);
-  } catch {
-    return newPrefix;
-  }
-  lastAppliedPrefix = null;
-  collections.clear();
-  return newPrefix;
-};
-const destroyAllCollections = async () => {
-  const dbs = Array.from(collections.values());
-  await Promise.all(dbs.map((db) => db.destroy()));
-  collections.clear();
-};
-const EXCLUDE_PROJECTION_ERROR = "must be include-only (value 1); exclusion projection is not supported";
-const sortProjectionSpec = (projection) => {
-  const sorted = {};
-  for (const key of Object.keys(projection).sort()) {
-    sorted[key] = projection[key];
-  }
-  return sorted;
-};
-const normalizeProjectionSpec = (value, source, label) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const raw = value;
-  const normalized = {};
-  let hasExclude = false;
-  for (const [key, rawValue] of Object.entries(raw)) {
-    const path = key.trim();
-    if (!path) continue;
-    if (rawValue === 1 || rawValue === true) {
-      normalized[path] = 1;
-      continue;
-    }
-    if (rawValue === 0 || rawValue === false) {
-      hasExclude = true;
-      continue;
-    }
-    if (typeof rawValue === "number" && Number.isFinite(rawValue)) {
-      if (rawValue === 1) normalized[path] = 1;
-      if (rawValue === 0) hasExclude = true;
-    }
-  }
-  if (hasExclude) {
-    throw new Error(`${source}: ${label} ${EXCLUDE_PROJECTION_ERROR}`);
-  }
-  return Object.keys(normalized).length > 0 ? sortProjectionSpec(normalized) : void 0;
-};
-const normalizeSelectString = (value, source) => {
-  const tokens = value.split(/\s+/).map((token) => token.trim()).filter(Boolean);
-  if (!tokens.length) return void 0;
-  const normalized = {};
-  for (const token of tokens) {
-    let path = token;
-    if (token.startsWith("-")) {
-      throw new Error(`${source}: populate select ${EXCLUDE_PROJECTION_ERROR}`);
-    } else if (token.startsWith("+")) {
-      path = token.slice(1);
-    }
-    path = path.trim();
-    if (!path) continue;
-    normalized[path] = 1;
-  }
-  return Object.keys(normalized).length > 0 ? sortProjectionSpec(normalized) : void 0;
-};
-const normalizePopulateSelect = (value, source) => {
-  if (typeof value === "string") {
-    return normalizeSelectString(value, source);
-  }
-  return normalizeProjectionSpec(value, source, "populate select");
-};
-const normalizePopulateOptions = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const raw = value;
-  const normalized = {};
-  if (raw.sort && typeof raw.sort === "object" && !Array.isArray(raw.sort)) {
-    const sortRaw = raw.sort;
-    const sort = {};
-    for (const [key, rawDirection] of Object.entries(sortRaw)) {
-      const path = key.trim();
-      if (!path) continue;
-      if (rawDirection === 1 || rawDirection === "asc") {
-        sort[path] = 1;
-        continue;
-      }
-      if (rawDirection === -1 || rawDirection === "desc") {
-        sort[path] = -1;
-      }
-    }
-    if (Object.keys(sort).length > 0) {
-      normalized.sort = sort;
-    }
-  }
-  if (typeof raw.limit === "number" && Number.isFinite(raw.limit)) {
-    normalized.limit = Math.max(0, Math.floor(Math.abs(raw.limit)));
-  }
-  return Object.keys(normalized).length > 0 ? normalized : void 0;
-};
-const normalizeString = (value) => {
-  if (typeof value !== "string") return void 0;
-  const normalized = value.trim();
-  return normalized || void 0;
-};
-const normalizeObject = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  return value;
-};
-const normalizePopulateObject = (value, source) => {
-  const path = normalizeString(value.path);
-  if (!path) {
-    throw new Error(`${source}: populate entries must define a non-empty path`);
-  }
-  const select = normalizePopulateSelect(value.select, source);
-  if (!select) {
-    throw new Error(`${source}: populate entries must define a select projection`);
-  }
-  const nested = value.populate !== void 0 ? normalizePopulateOption(value.populate, source) : void 0;
-  return {
-    path,
-    select,
-    ...normalizeString(value.model) ? {
-      model: normalizeString(value.model)
-    } : {},
-    ...normalizeObject(value.match) ? {
-      match: normalizeObject(value.match)
-    } : {},
-    ...normalizePopulateOptions(value.options) ? {
-      options: normalizePopulateOptions(value.options)
-    } : {},
-    ...nested && nested.length > 0 ? {
-      populate: nested
-    } : {}
-  };
-};
-const normalizePopulateOption = (value, source) => {
-  if (typeof value === "string") {
-    throw new Error(`${source}: populate string syntax is not supported; use object entries with select`);
-  }
-  if (Array.isArray(value)) {
-    if (value.length === 0) {
-      throw new Error(`${source}: populate must contain at least one entry`);
-    }
-    return value.map((entry) => {
-      if (typeof entry === "string") {
-        throw new Error(`${source}: populate string syntax is not supported; use object entries with select`);
-      }
-      return normalizePopulateObject(entry, source);
-    });
-  }
-  return [normalizePopulateObject(value, source)];
-};
-const preparePopulateCacheOptions = (options, source) => {
-  if (!options.populate) return void 0;
-  const rootProjection = normalizeProjectionSpec(options.projection, source, "projection");
-  if (!rootProjection) {
-    throw new Error(`${source}: projection is required when populate is used`);
-  }
-  const populate = normalizePopulateOption(options.populate, source);
-  if (!populate.length) {
-    throw new Error(`${source}: populate must contain at least one entry`);
-  }
-  return {
-    rootProjection,
-    populate
-  };
-};
-const isPlainObject = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-};
-const serializeRtsQueryValue = (value) => {
-  return JSON.stringify(value, (_key, currentValue) => {
-    if (!isPlainObject(currentValue)) return currentValue;
-    return Object.keys(currentValue).sort().reduce((acc, key) => {
-      acc[key] = currentValue[key];
-      return acc;
-    }, {});
-  }) ?? "";
-};
-const computeRtsQueryKey = (query, options) => {
-  return serializeRtsQueryValue({
-    version: 2,
-    key: options.key ?? null,
-    query,
-    projection: options.projection ?? null,
-    sort: options.sort ?? null,
-    limit: typeof options.limit === "number" ? options.limit : null,
-    populate: options.populate ?? null,
-    pagination: options.pagination ?? null
-  });
-};
-const hasSnapshotError = (snapshot) => {
-  return snapshot?.error !== null && snapshot?.error !== void 0;
-};
-const RTS_CHANGES_PATH = "/api/rb/rts/changes";
-const MAX_TXN_BUF = 2048;
-const SERVER_RECONNECT_DELAY_MIN_MS = 1e4;
-const SERVER_RECONNECT_DELAY_MAX_MS = 15e3;
-const RUN_NETWORK_QUERY_TIMEOUT_ERROR = "runNetworkQuery: request timed out";
-const RUN_NETWORK_COUNT_TIMEOUT_ERROR = "runNetworkCount: request timed out";
-let socket = null;
-let socketReadyForMessages = false;
-let connectPromise = null;
-let pendingConnectionAttempt = null;
-let explicitDisconnect = false;
-let currentTenantId = null;
-let currentUid = null;
-let connectOptions = {};
-let connectionGeneration = 0;
-let connectionEpoch = null;
-const localTxnBuf = [];
-const queryCallbacks = /* @__PURE__ */ new Map();
-const countCallbacks = /* @__PURE__ */ new Map();
-const subscriptions = /* @__PURE__ */ new Map();
-const countSubscriptions = /* @__PURE__ */ new Map();
-const messageCallbacks = /* @__PURE__ */ new Map();
-const rtsMessageCallbacks = /* @__PURE__ */ new Map();
-const pendingWindowRequests = /* @__PURE__ */ new Map();
-let reconnectTimer = null;
-let reconnectAttempts = 0;
-let hasEstablishedConnection = false;
-let forceInitialQueryOnNextConnection = false;
-let pendingServerReconnectJitter = false;
-let syncPromise = null;
-let syncKey = null;
-let connectionStatus = "idle";
-let connectionError = null;
-const connectionStatusCallbacks = /* @__PURE__ */ new Set();
-const ensureRealtimeRuntime = () => {
-  if (typeof WebSocket !== "function") {
-    throw new Error("RTS websocket client requires WebSocket support");
-  }
-  if (typeof globalThis.setTimeout !== "function" || typeof globalThis.clearTimeout !== "function") {
-    throw new Error("RTS websocket client requires timer support");
-  }
-};
-const ensureSyncRuntime = () => {
-  if (typeof fetch !== "function") {
-    throw new Error("syncRtsChanges requires fetch support");
-  }
-};
-const getRuntimeLocationHref = () => {
-  if (typeof window !== "undefined" && typeof window.location?.href === "string" && window.location.href) {
-    return window.location.href;
-  }
-  const location = globalThis.location;
-  if (typeof location?.href === "string" && location.href) {
-    return location.href;
-  }
-  return null;
-};
-const setRuntimeTimeout = (handler, delayMs) => {
-  return globalThis.setTimeout(handler, delayMs);
-};
-const clearRuntimeTimeout = (timer) => {
-  globalThis.clearTimeout(timer);
-};
-const setConnectionStatus = (status, error = null) => {
-  connectionStatus = status;
-  connectionError = error;
-  for (const callback of connectionStatusCallbacks) {
-    callback(status, error);
-  }
-};
-const resolveWebSocketUrlFromCandidate = (candidateUrl, options) => {
-  const url = new URL(candidateUrl);
-  if (url.protocol === "http:") {
-    url.protocol = "ws:";
-  } else if (url.protocol === "https:") {
-    url.protocol = "wss:";
-  }
-  if (!url.pathname || url.pathname === "/") {
-    url.pathname = options.path ?? "/rts";
-  }
-  return url;
-};
-const resolveApiOriginUrl = ({
-  url
-}) => {
-  if (url) {
-    const base2 = new URL(url);
-    if (base2.protocol === "ws:") {
-      base2.protocol = "http:";
-    } else if (base2.protocol === "wss:") {
-      base2.protocol = "https:";
-    }
-    base2.pathname = "/";
-    base2.search = "";
-    base2.hash = "";
-    return base2;
-  }
-  const locationHref = getRuntimeLocationHref();
-  if (!locationHref) {
-    throw new Error("syncRtsChanges: options.url is required when location.href is unavailable");
-  }
-  const base = new URL(locationHref);
-  base.pathname = "/";
-  base.search = "";
-  base.hash = "";
-  return base;
-};
-const buildSyncChangesUrl = (_tenantId, options) => {
-  const base = resolveApiOriginUrl(options);
-  const url = new URL(RTS_CHANGES_PATH, base);
-  return url.toString();
-};
-const buildSocketUrl = (_tenantId, _uid, options) => {
-  if (options.url) {
-    const url = resolveWebSocketUrlFromCandidate(options.url, options);
-    return url.toString();
-  }
-  const locationHref = getRuntimeLocationHref();
-  if (!locationHref) {
-    throw new Error("connect: options.url is required when location.href is unavailable");
-  }
-  const base = new URL(locationHref);
-  base.protocol = base.protocol === "https:" ? "wss:" : "ws:";
-  base.pathname = options.path ?? "/rts";
-  base.search = "";
-  base.hash = "";
-  return base.toString();
-};
-const sendToServer = (message) => {
-  if (!socket || !socketReadyForMessages) return;
-  if (socket.readyState !== WebSocket.OPEN) return;
-  socket.send(JSON.stringify(message));
-};
-const isSocketReady = () => Boolean(socket && socketReadyForMessages && socket.readyState === WebSocket.OPEN);
-const normalizeRequestedCount = (value) => {
-  if (!Number.isSafeInteger(value)) return void 0;
-  if (value < 1 || value > RTS_QUERY_WINDOW_MAX_COUNT) return void 0;
-  return value;
-};
-const getSubscriptionServerOptions = (subscription) => {
-  if (!subscription.options.pagination || !subscription.requestedCount) {
-    return subscription.options;
-  }
-  const {
-    cursor: _cursor,
-    direction: _direction,
-    ...pagination
-  } = subscription.options.pagination;
-  return {
-    ...subscription.options,
-    pagination: {
-      ...pagination,
-      limit: subscription.requestedCount
-    }
-  };
-};
-const resubscribeAll = ({
-  forceInitialQuery
-}) => {
-  for (const sub of subscriptions.values()) {
-    const runInitialQuery = forceInitialQuery || sub.runInitialNetworkQuery;
-    sendToServer({
-      type: "register-query",
-      modelName: sub.modelName,
-      queryKey: sub.queryKey,
-      query: sub.query,
-      options: getSubscriptionServerOptions(sub),
-      runInitialQuery
-    });
-  }
-  for (const sub of countSubscriptions.values()) {
-    const runInitialQuery = forceInitialQuery || sub.runInitialNetworkQuery;
-    sendToServer({
-      type: "register-count",
-      modelName: sub.modelName,
-      queryKey: sub.queryKey,
-      query: sub.query,
-      options: sub.options,
-      runInitialQuery
-    });
-  }
-};
-const clearReconnectTimer = () => {
-  if (reconnectTimer === null) return;
-  clearRuntimeTimeout(reconnectTimer);
-  reconnectTimer = null;
-};
-const rejectPendingConnectionAttempt = () => {
-  const attempt = pendingConnectionAttempt;
-  if (!attempt) return;
-  pendingConnectionAttempt = null;
-  attempt.reject(new Error("RTS WebSocket connection attempt superseded"));
-};
-const scheduleReconnect = () => {
-  clearReconnectTimer();
-  if (explicitDisconnect) {
-    pendingServerReconnectJitter = false;
-    return;
-  }
-  if (!currentTenantId || !currentUid) return;
-  const cfg = connectOptions.reconnect ?? {};
-  const maxAttempts = cfg.attempts ?? 128;
-  const delayMs = cfg.delayMs ?? 400;
-  const delayMaxMs = cfg.delayMaxMs ?? 1e4;
-  if (reconnectAttempts >= maxAttempts) return;
-  let delay = Math.min(delayMaxMs, delayMs * Math.pow(2, reconnectAttempts));
-  if (pendingServerReconnectJitter) {
-    const span = SERVER_RECONNECT_DELAY_MAX_MS - SERVER_RECONNECT_DELAY_MIN_MS;
-    delay = SERVER_RECONNECT_DELAY_MIN_MS + Math.floor(Math.random() * (span + 1));
-    pendingServerReconnectJitter = false;
-  }
-  reconnectAttempts += 1;
-  reconnectTimer = setRuntimeTimeout(() => {
-    void connectInternal(currentTenantId, currentUid, connectOptions, {
-      resetReconnectAttempts: false
-    });
-  }, delay);
-};
-const isDocWithId = (doc) => {
-  if (!doc || typeof doc !== "object") return false;
-  return typeof doc._id === "string";
-};
-const normalizePageInfo$1 = (value) => {
-  if (!value || typeof value !== "object") return void 0;
-  if (Array.isArray(value)) return void 0;
-  const raw = value;
-  if (typeof raw.hasNextPage !== "boolean" || typeof raw.hasPrevPage !== "boolean") return void 0;
-  const nextCursor = typeof raw.nextCursor === "string" && raw.nextCursor ? raw.nextCursor : void 0;
-  const prevCursor = typeof raw.prevCursor === "string" && raw.prevCursor ? raw.prevCursor : void 0;
-  return {
-    hasNextPage: raw.hasNextPage,
-    hasPrevPage: raw.hasPrevPage,
-    ...nextCursor ? {
-      nextCursor
-    } : {},
-    ...prevCursor ? {
-      prevCursor
-    } : {}
-  };
-};
-const normalizeTotalCount$1 = (value) => {
-  if (typeof value !== "number") return void 0;
-  if (!Number.isFinite(value) || value < 0) return void 0;
-  return Math.floor(value);
-};
-const normalizeQueryWindow = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const raw = value;
-  const requestedCount = normalizeRequestedCount(raw.requestedCount);
-  if (!requestedCount) return void 0;
-  const version = Number.isSafeInteger(raw.version) && raw.version >= 0 ? raw.version : void 0;
-  return {
-    requestedCount,
-    ...version !== void 0 ? {
-      version
-    } : {}
-  };
-};
-const settlePendingWindowRequests = (cbKey, requestedCount, success) => {
-  const pending = pendingWindowRequests.get(cbKey);
-  if (!pending?.size) return;
-  for (const request of Array.from(pending)) {
-    if (request.requestedCount !== requestedCount) continue;
-    clearRuntimeTimeout(request.timeoutId);
-    pending.delete(request);
-    if (!success) {
-      const subscription = subscriptions.get(cbKey);
-      if (subscription?.requestedCount === request.requestedCount) {
-        const snapshotRequestedCount = subscription.lastSnapshot && !hasSnapshotError(subscription.lastSnapshot) ? subscription.lastSnapshot.context.window?.requestedCount : void 0;
-        const rollbackRequestedCount = snapshotRequestedCount ?? request.previousRequestedCount;
-        subscription.windowIntentVersion += 1;
-        subscription.requestedCount = rollbackRequestedCount;
-        sendToServer({
-          type: "set-query-window",
-          modelName: subscription.modelName,
-          queryKey: subscription.queryKey,
-          requestedCount: rollbackRequestedCount
-        });
-      }
-    }
-    request.resolve(success);
-  }
-  if (!pending.size) pendingWindowRequests.delete(cbKey);
-};
-const failPendingWindowRequests = (cbKey) => {
-  const pending = pendingWindowRequests.get(cbKey);
-  if (!pending?.size) return;
-  for (const request of Array.from(pending)) {
-    settlePendingWindowRequests(cbKey, request.requestedCount, false);
-  }
-};
-const cancelPendingWindowRequests = (cbKey) => {
-  const entries = cbKey ? [[cbKey, pendingWindowRequests.get(cbKey)]] : Array.from(pendingWindowRequests.entries());
-  for (const [key, pending] of entries) {
-    if (!pending) continue;
-    for (const request of pending) {
-      clearRuntimeTimeout(request.timeoutId);
-      request.resolve(false);
-    }
-    pendingWindowRequests.delete(key);
-  }
-};
-const updateQuerySubscriptionSnapshot = (subscription, snapshot) => {
-  if (snapshot.context.source === "cache" && subscription.lastSnapshot?.context.source === "network") {
-    const cachedCount = snapshot.context.window?.requestedCount;
-    const networkCount = subscription.lastSnapshot.context.window?.requestedCount;
-    if (!cachedCount || !networkCount || cachedCount <= networkCount) return false;
-  }
-  subscription.lastSnapshot = snapshot;
-  return true;
-};
-const updateCountSubscriptionSnapshot = (subscription, snapshot) => {
-  if (snapshot.context.source === "cache" && subscription.lastSnapshot?.context.source === "network") {
-    return false;
-  }
-  subscription.lastSnapshot = snapshot;
-  return true;
-};
-const dispatchQuerySnapshotToSubscription = (subscription, snapshot) => {
-  for (const callback of subscription.callbacks) {
-    callback(snapshot.error, snapshot.data, snapshot.context);
-  }
-};
-const dispatchQuerySnapshotToOneshotCallbacks = (cbKey, snapshot) => {
-  const callbacks = queryCallbacks.get(cbKey);
-  if (!callbacks || !callbacks.size) return;
-  for (const callback of callbacks) {
-    callback(snapshot.error, snapshot.data, snapshot.context);
-  }
-};
-const dispatchCountSnapshotToSubscription = (subscription, snapshot) => {
-  for (const callback of subscription.callbacks) {
-    callback(snapshot.error, snapshot.count, snapshot.context);
-  }
-};
-const dispatchCountSnapshotToOneshotCallbacks = (cbKey, snapshot) => {
-  const callbacks = countCallbacks.get(cbKey);
-  if (!callbacks || !callbacks.size) return;
-  for (const callback of callbacks) {
-    callback(snapshot.error, snapshot.count, snapshot.context);
-  }
-};
-const requestRegisteredQueryRefresh = (subscription) => {
-  if (subscription.options.pagination && subscription.requestedCount) {
-    sendToServer({
-      type: "set-query-window",
-      modelName: subscription.modelName,
-      queryKey: subscription.queryKey,
-      requestedCount: subscription.requestedCount
-    });
-    return;
-  }
-  sendToServer({
-    type: "run-query",
-    modelName: subscription.modelName,
-    queryKey: subscription.queryKey,
-    query: subscription.query,
-    options: getSubscriptionServerOptions(subscription)
-  });
-};
-const requestRegisteredCountRefresh = (subscription) => {
-  sendToServer({
-    type: "run-count",
-    modelName: subscription.modelName,
-    queryKey: subscription.queryKey,
-    query: subscription.query,
-    options: subscription.options
-  });
-};
-const requestSubscriptionLocalQuery = (cbKey, subscription) => {
-  if (!currentUid) return false;
-  const uid = currentUid;
-  const generation = connectionGeneration;
-  if (subscription.options.pagination) {
-    const requestedCountAtStart = subscription.requestedCount;
-    const windowIntentVersionAtStart = subscription.windowIntentVersion;
-    const localQueryPromise = readQueryWindowSnapshot({
-      uid,
-      modelName: subscription.modelName,
-      queryKey: subscription.queryKey
-    }).then((result) => {
-      if (!result.hit || generation !== connectionGeneration) return;
-      const currentSubscription = subscriptions.get(cbKey);
-      if (!currentSubscription) return;
-      const requestedCount = normalizeRequestedCount(result.snapshot.requestedCount);
-      if (!requestedCount) return;
-      if (currentSubscription.windowIntentVersion !== windowIntentVersionAtStart) return;
-      if (currentSubscription.requestedCount !== requestedCountAtStart) return;
-      const snapshot = {
-        error: null,
-        data: result.snapshot.data,
-        context: {
-          source: "cache",
-          pageInfo: result.snapshot.pageInfo,
-          ...result.snapshot.totalCount !== void 0 ? {
-            totalCount: result.snapshot.totalCount
-          } : {},
-          window: {
-            requestedCount
-          }
-        }
-      };
-      if (!updateQuerySubscriptionSnapshot(currentSubscription, snapshot)) return;
-      currentSubscription.requestedCount = requestedCount;
-      currentSubscription.windowIntentVersion += 1;
-      if (requestedCount !== requestedCountAtStart) {
-        sendToServer({
-          type: "set-query-window",
-          modelName: currentSubscription.modelName,
-          queryKey: currentSubscription.queryKey,
-          requestedCount
-        });
-      }
-      dispatchQuerySnapshotToSubscription(currentSubscription, snapshot);
-    }).catch(() => {
-    });
-    subscription.localQueryPromise = localQueryPromise;
-    void localQueryPromise.finally(() => {
-      const currentSubscription = subscriptions.get(cbKey);
-      if (currentSubscription?.localQueryPromise === localQueryPromise) {
-        delete currentSubscription.localQueryPromise;
-      }
-    });
-    return true;
-  }
-  const populateCache = subscription.populateCache;
-  const hasPopulate = Boolean(populateCache);
-  if (hasPopulate && populateCache) {
-    void runPopulatedQuery({
-      modelName: subscription.modelName,
-      query: subscription.query,
-      options: {
-        uid,
-        projection: populateCache.rootProjection,
-        sort: subscription.options.sort,
-        limit: subscription.options.limit,
-        populate: populateCache.populate
-      }
-    }).then(({
-      hit,
-      data,
-      context
-    }) => {
-      if (!hit) return;
-      if (generation !== connectionGeneration) return;
-      const currentSubscription = subscriptions.get(cbKey);
-      if (!currentSubscription) return;
-      const snapshot = {
-        error: null,
-        data,
-        context
-      };
-      if (!updateQuerySubscriptionSnapshot(currentSubscription, snapshot)) return;
-      dispatchQuerySnapshotToSubscription(currentSubscription, snapshot);
-    }).catch(() => {
-    });
-    return true;
-  }
-  void runQuery({
-    modelName: subscription.modelName,
-    query: subscription.query,
-    options: {
-      uid,
-      projection: subscription.options.projection,
-      sort: subscription.options.sort,
-      limit: subscription.options.limit
-    }
-  }).then(({
-    data,
-    context
-  }) => {
-    if (generation !== connectionGeneration) return;
-    const currentSubscription = subscriptions.get(cbKey);
-    if (!currentSubscription) return;
-    const snapshot = {
-      error: null,
-      data,
-      context
-    };
-    if (!updateQuerySubscriptionSnapshot(currentSubscription, snapshot)) return;
-    dispatchQuerySnapshotToSubscription(currentSubscription, snapshot);
-  }).catch(() => {
-  });
-  return true;
-};
-const handleQueryPayload = (payload) => {
-  const {
-    modelName,
-    queryKey,
-    data,
-    error,
-    txnId
-  } = payload;
-  const cbKey = `${modelName}.${queryKey}`;
-  const subscription = subscriptions.get(cbKey);
-  const hasSubscriptionCallbacks = Boolean(subscription?.callbacks.size);
-  const hasOneshotCallbacks = Boolean(queryCallbacks.get(cbKey)?.size);
-  if (!hasSubscriptionCallbacks && !hasOneshotCallbacks) return;
-  const pageInfo = normalizePageInfo$1(payload.pageInfo);
-  const totalCount = normalizeTotalCount$1(payload.totalCount);
-  const queryWindow = normalizeQueryWindow(payload.window);
-  const populateCache = subscription?.populateCache;
-  const hasPopulate = Boolean(populateCache);
-  const hasPagination = Boolean(subscription?.options?.pagination || pageInfo || totalCount !== void 0);
-  if (subscription?.options.pagination && queryWindow) {
-    if (queryWindow.requestedCount !== subscription.requestedCount) return;
-    if (queryWindow.version !== void 0 && queryWindow.version <= subscription.lastNetworkVersion) return;
-    if (queryWindow.version !== void 0) {
-      subscription.lastNetworkVersion = queryWindow.version;
-    }
-  }
-  const isLocal = !!(txnId && localTxnBuf.includes(txnId));
-  const context = {
-    source: "network",
-    isLocal,
-    txnId,
-    ...pageInfo ? {
-      pageInfo
-    } : {},
-    ...totalCount !== void 0 ? {
-      totalCount
-    } : {},
-    ...queryWindow ? {
-      window: queryWindow
-    } : {}
-  };
-  const snapshot = {
-    error: error ?? null,
-    data,
-    context
-  };
-  if (error) {
-    if (subscription && updateQuerySubscriptionSnapshot(subscription, snapshot)) {
-      dispatchQuerySnapshotToSubscription(subscription, snapshot);
-    }
-    dispatchQuerySnapshotToOneshotCallbacks(cbKey, snapshot);
-    if (queryWindow) {
-      settlePendingWindowRequests(cbKey, queryWindow.requestedCount, false);
-    } else if (subscription?.options.pagination) {
-      failPendingWindowRequests(cbKey);
-    }
-    return;
-  }
-  if (subscription && updateQuerySubscriptionSnapshot(subscription, snapshot)) {
-    dispatchQuerySnapshotToSubscription(subscription, snapshot);
-  }
-  dispatchQuerySnapshotToOneshotCallbacks(cbKey, snapshot);
-  if (queryWindow) {
-    settlePendingWindowRequests(cbKey, queryWindow.requestedCount, true);
-  }
-  if (!currentUid) return;
-  if (subscription?.options.pagination && queryWindow && pageInfo && Array.isArray(data) && connectionEpoch) {
-    const uid = currentUid;
-    const generation = connectionGeneration;
-    const serverEpoch = connectionEpoch;
-    const localQueryPromise = subscription.localQueryPromise;
-    void Promise.resolve().then(async () => {
-      await localQueryPromise;
-      if (generation !== connectionGeneration || serverEpoch !== connectionEpoch) return;
-      const currentSubscription = subscriptions.get(cbKey);
-      if (!currentSubscription || currentSubscription.requestedCount !== queryWindow.requestedCount) return;
-      await writeQueryWindowSnapshot({
-        uid,
-        modelName,
-        queryKey,
-        data,
-        pageInfo,
-        ...totalCount !== void 0 ? {
-          totalCount
-        } : {},
-        requestedCount: queryWindow.requestedCount,
-        ...queryWindow.version !== void 0 ? {
-          serverEpoch,
-          serverVersion: queryWindow.version
-        } : {}
-      });
-    }).catch(() => {
-    });
-    return;
-  }
-  const docs = Array.isArray(data) ? data.filter(isDocWithId) : [];
-  if (hasPagination) return;
-  if (!docs.length) return;
-  if (hasPopulate && populateCache) {
-    void updatePopulatedDocs({
-      modelName,
-      data: docs,
-      uid: currentUid,
-      populate: populateCache.populate
-    }).catch(() => {
-    });
-    return;
-  }
-  void updateDocs(modelName, docs, currentUid).catch(() => {
-  });
-};
-const handleCountPayload = (payload) => {
-  const {
-    modelName,
-    queryKey,
-    count,
-    error,
-    txnId
-  } = payload;
-  const cbKey = `${modelName}.${queryKey}`;
-  const subscription = countSubscriptions.get(cbKey);
-  const hasSubscriptionCallbacks = Boolean(subscription?.callbacks.size);
-  const hasOneshotCallbacks = Boolean(countCallbacks.get(cbKey)?.size);
-  if (!hasSubscriptionCallbacks && !hasOneshotCallbacks) return;
-  const isLocal = !!(txnId && localTxnBuf.includes(txnId));
-  const context = {
-    source: "network",
-    isLocal,
-    txnId
-  };
-  const normalizedCount = normalizeTotalCount$1(count);
-  const snapshot = {
-    error: error ?? null,
-    count: normalizedCount,
-    context
-  };
-  if (error) {
-    if (subscription && updateCountSubscriptionSnapshot(subscription, snapshot)) {
-      dispatchCountSnapshotToSubscription(subscription, snapshot);
-    }
-    dispatchCountSnapshotToOneshotCallbacks(cbKey, snapshot);
-    return;
-  }
-  if (subscription && updateCountSubscriptionSnapshot(subscription, snapshot)) {
-    dispatchCountSnapshotToSubscription(subscription, snapshot);
-  }
-  dispatchCountSnapshotToOneshotCallbacks(cbKey, snapshot);
-};
-const handleEvent = (payload) => {
-  const callbacks = messageCallbacks.get(payload.event);
-  if (!callbacks || !callbacks.size) return;
-  for (const cb of callbacks) cb(payload.payload);
-};
-const handleRtsMessage = (payload) => {
-  const callbacks = rtsMessageCallbacks.get(payload.channel);
-  if (!callbacks || !callbacks.size) return;
-  for (const cb of callbacks) cb(payload.payload);
-};
-const handleMessage = (event) => {
-  let parsed;
-  try {
-    parsed = JSON.parse(typeof event.data === "string" ? event.data : String(event.data));
-  } catch {
-    return;
-  }
-  if (!parsed || typeof parsed !== "object") return;
-  const message = parsed;
-  if (message.type === "query-payload") {
-    handleQueryPayload(message);
-    return;
-  }
-  if (message.type === "count-payload") {
-    handleCountPayload(message);
-    return;
-  }
-  if (message.type === "event") {
-    handleEvent(message);
-    return;
-  }
-  if (message.type === "rts-message") {
-    handleRtsMessage(message);
-  }
-};
-const addLocalTxn = (txnId) => {
-  if (!txnId) return;
-  localTxnBuf.push(txnId);
-  if (localTxnBuf.length > MAX_TXN_BUF) {
-    localTxnBuf.shift();
-  }
-};
-const getSyncStorageKey = ({
-  tenantId,
-  uid,
-  appName
-}) => `rb:rts:changesSeq:${appName ?? ""}:${tenantId}:${uid}`;
-const readStoredSeq = (key) => {
-  const storage = getRuntimeStorage();
-  try {
-    const raw = storage.getItem(key);
-    const num = raw ? Number(raw) : 0;
-    return Number.isFinite(num) && num >= 0 ? Math.floor(num) : 0;
-  } catch {
-    return 0;
-  }
-};
-const writeStoredSeq = (key, value) => {
-  const storage = getRuntimeStorage();
-  try {
-    storage.setItem(key, String(Math.max(0, Math.floor(value))));
-  } catch {
-    return;
-  }
-};
-const applyChangeBatch = async (changes, uid, isCurrent) => {
-  const resetModels = /* @__PURE__ */ new Set();
-  const deletesByModel = /* @__PURE__ */ new Map();
-  for (const change of changes) {
-    const modelName = typeof change.modelName === "string" ? change.modelName : "";
-    if (!modelName) continue;
-    if (change.op === "reset_model") {
-      resetModels.add(modelName);
-      continue;
-    }
-    if (change.op === "delete") {
-      const docId = typeof change.docId === "string" ? change.docId : "";
-      if (!docId) continue;
-      const existing = deletesByModel.get(modelName) ?? [];
-      existing.push(docId);
-      deletesByModel.set(modelName, existing);
-    }
-  }
-  for (const modelName of resetModels) {
-    if (!isCurrent()) return false;
-    await destroyCollection(modelName, uid).catch(() => {
-    });
-  }
-  for (const [modelName, ids] of deletesByModel.entries()) {
-    if (resetModels.has(modelName)) continue;
-    if (!isCurrent()) return false;
-    await deleteDocs(modelName, ids, uid).catch(() => {
-    });
-  }
-  if (resetModels.size || deletesByModel.size) {
-    if (!isCurrent()) return false;
-    await invalidateQueryWindowSnapshots({
-      uid
-    }).catch(() => {
-    });
-  }
-  return true;
-};
-const syncRtsChangesWithResult = async (tenantId, uid, options = {}, isCurrent = () => true) => {
-  ensureSyncRuntime();
-  if (!tenantId || !uid) return false;
-  const storageKey = getSyncStorageKey({
-    tenantId,
-    uid,
-    appName: options.appName
-  });
-  let sinceSeq = readStoredSeq(storageKey);
-  let cacheInvalidated = false;
-  const syncUrl = buildSyncChangesUrl(tenantId, {
-    url: options.url
-  });
-  for (let i = 0; i < 32; i += 1) {
-    const response = await fetch(syncUrl, {
-      method: "POST",
-      credentials: "include",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        sinceSeq,
-        limit: 2e3
-      })
-    });
-    if (!isCurrent()) return false;
-    if (!response.ok) return cacheInvalidated;
-    const payload = await response.json().catch(() => null);
-    if (!payload || typeof payload !== "object") return cacheInvalidated;
-    const payloadObj = payload;
-    const ok = payloadObj.ok;
-    if (ok !== true) return cacheInvalidated;
-    const latestSeq = Number(payloadObj.latestSeq ?? 0);
-    const needsFullResync = Boolean(payloadObj.needsFullResync);
-    if (needsFullResync) {
-      if (!isCurrent()) return false;
-      resetRtsPouchStore({
-        tenantId,
-        appName: options.appName
-      });
-      writeStoredSeq(storageKey, latestSeq);
-      return true;
-    }
-    const changesRaw = payloadObj.changes;
-    const changes = Array.isArray(changesRaw) ? changesRaw : [];
-    const normalized = changes.map((c2) => {
-      if (!c2 || typeof c2 !== "object") return null;
-      const obj = c2;
-      const seq = Number(obj.seq ?? 0);
-      const modelName = typeof obj.modelName === "string" ? obj.modelName : String(obj.modelName ?? "");
-      const op = obj.op === "reset_model" ? "reset_model" : "delete";
-      const docId = typeof obj.docId === "string" && obj.docId ? obj.docId : obj.docId ? String(obj.docId) : void 0;
-      return {
-        seq,
-        modelName,
-        op,
-        ...docId ? {
-          docId
-        } : {}
-      };
-    }).filter((c2) => c2 !== null).filter((c2) => Number.isFinite(c2.seq) && c2.seq > 0 && c2.modelName && (c2.op === "reset_model" || !!c2.docId));
-    if (!normalized.length) {
-      writeStoredSeq(storageKey, latestSeq);
-      return cacheInvalidated;
-    }
-    const applied = await applyChangeBatch(normalized, uid, isCurrent);
-    if (!applied) return false;
-    cacheInvalidated = true;
-    const lastSeq = normalized.reduce((max, c2) => c2.seq > max ? c2.seq : max, sinceSeq);
-    sinceSeq = lastSeq;
-    writeStoredSeq(storageKey, sinceSeq);
-    if (latestSeq > 0 && sinceSeq >= latestSeq) {
-      return cacheInvalidated;
-    }
-  }
-  return cacheInvalidated;
-};
-const syncRtsChanges = async (tenantId, uid, options = {}) => {
-  await syncRtsChangesWithResult(tenantId, uid, options);
-};
-const ensureSynced = (tenantId, uid, options) => {
-  if (options.syncChanges === false) return Promise.resolve(false);
-  const key = `${options.appName ?? ""}:${tenantId}:${uid}`;
-  if (syncPromise && syncKey === key) return syncPromise;
-  syncKey = key;
-  syncPromise = syncRtsChangesWithResult(tenantId, uid, {
-    appName: options.appName,
-    url: options.url
-  }, () => currentTenantId === tenantId && currentUid === uid && (connectOptions.appName ?? "") === (options.appName ?? "")).catch(() => false).finally(() => {
-    if (syncKey === key) {
-      syncPromise = null;
-    }
-  });
-  return syncPromise;
-};
-const connectInternal = (tenantId, uid, options, {
-  resetReconnectAttempts
-}) => {
-  ensureRealtimeRuntime();
-  if (!tenantId) return Promise.resolve();
-  if (!uid) throw new Error("Missing uid");
-  currentTenantId = tenantId;
-  currentUid = uid;
-  connectOptions = options;
-  if (options.configureStore !== false) {
-    configureRtsPouchStore({
-      tenantId,
-      appName: options.appName
-    });
-  }
-  if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) {
-    return connectPromise ?? Promise.resolve();
-  }
-  const synchronization = ensureSynced(tenantId, uid, options);
-  explicitDisconnect = false;
-  clearReconnectTimer();
-  socketReadyForMessages = false;
-  const url = buildSocketUrl(tenantId, uid, options);
-  connectPromise = new Promise((resolve, reject) => {
-    if (resetReconnectAttempts) reconnectAttempts = 0;
-    let opened = false;
-    let settled = false;
-    let subscriptionsStarted = false;
-    let cacheInvalidatedBeforeSubscriptions = false;
-    const generation = ++connectionGeneration;
-    const epoch = `${Date.now().toString(36)}.${generation.toString(36)}.${Math.random().toString(36).slice(2, 10)}`;
-    connectionEpoch = epoch;
-    pendingConnectionAttempt = {
-      generation,
-      reject: (error) => {
-        if (settled) return;
-        settled = true;
-        reject(error);
-      }
-    };
-    setConnectionStatus("connecting");
-    const nextSocket = new WebSocket(url);
-    socket = nextSocket;
-    if (options.syncChanges !== false) {
-      void synchronization.then((cacheInvalidated) => {
-        if (!cacheInvalidated || generation !== connectionGeneration) return;
-        if (!subscriptionsStarted) {
-          cacheInvalidatedBeforeSubscriptions = true;
-          return;
-        }
-        if (nextSocket.readyState !== WebSocket.OPEN) return;
-        for (const subscription of subscriptions.values()) {
-          if (!subscription.options.pagination) continue;
-          requestRegisteredQueryRefresh(subscription);
-        }
-      });
-    }
-    nextSocket.addEventListener("open", () => {
-      if (generation !== connectionGeneration) return;
-      opened = true;
-      settled = true;
-      if (pendingConnectionAttempt?.generation === generation) pendingConnectionAttempt = null;
-      reconnectAttempts = 0;
-      pendingServerReconnectJitter = false;
-      socketReadyForMessages = true;
-      setConnectionStatus("connected");
-      for (const subscription of subscriptions.values()) {
-        subscription.lastNetworkVersion = 0;
-        if (subscription.runInitialLocalQuery && !subscription.hasRequestedInitialLocalQuery) {
-          const cbKey = `${subscription.modelName}.${subscription.queryKey}`;
-          subscription.hasRequestedInitialLocalQuery = requestSubscriptionLocalQuery(cbKey, subscription);
-        }
-      }
-      const forceInitialQuery = hasEstablishedConnection || forceInitialQueryOnNextConnection || cacheInvalidatedBeforeSubscriptions;
-      resubscribeAll({
-        forceInitialQuery
-      });
-      forceInitialQueryOnNextConnection = false;
-      subscriptionsStarted = true;
-      hasEstablishedConnection = true;
-      resolve();
-    });
-    nextSocket.addEventListener("message", (event) => {
-      if (generation !== connectionGeneration) return;
-      handleMessage(event);
-    });
-    nextSocket.addEventListener("close", (event) => {
-      if (generation !== connectionGeneration) return;
-      socketReadyForMessages = false;
-      if (!settled) {
-        settled = true;
-        if (pendingConnectionAttempt?.generation === generation) pendingConnectionAttempt = null;
-        const error = new Error(`RTS WebSocket closed before becoming ready (code=${event.code})`);
-        setConnectionStatus("error", error);
-        reject(error);
-      }
-      if (!explicitDisconnect) {
-        pendingServerReconnectJitter = opened;
-        setConnectionStatus("connecting", connectionError);
-      } else {
-        setConnectionStatus("idle");
-      }
-      socket = null;
-      connectPromise = null;
-      scheduleReconnect();
-    });
-    nextSocket.addEventListener("error", (err) => {
-      if (generation !== connectionGeneration) return;
-      if (settled) return;
-      settled = true;
-      if (pendingConnectionAttempt?.generation === generation) pendingConnectionAttempt = null;
-      socketReadyForMessages = false;
-      const error = err instanceof Error ? err : new Error("RTS WebSocket error");
-      setConnectionStatus("error", error);
-      reject(error);
-    });
-  });
-  return connectPromise;
-};
-const connect = (tenantId, uid, options = {}) => {
-  const identityChanged = currentTenantId !== null && (currentTenantId !== tenantId || currentUid !== uid || (connectOptions.appName ?? "") !== (options.appName ?? ""));
-  if (identityChanged) return reconnect(tenantId, uid, options);
-  return connectInternal(tenantId, uid, options, {
-    resetReconnectAttempts: true
-  });
-};
-const disconnect = () => {
-  explicitDisconnect = true;
-  connectionGeneration += 1;
-  rejectPendingConnectionAttempt();
-  clearReconnectTimer();
-  hasEstablishedConnection = false;
-  forceInitialQueryOnNextConnection = false;
-  pendingServerReconnectJitter = false;
-  if (socket) {
-    try {
-      socket.close();
-    } catch {
-    }
-  }
-  socket = null;
-  socketReadyForMessages = false;
-  connectPromise = null;
-  connectionEpoch = null;
-  cancelPendingWindowRequests();
-  setConnectionStatus("idle");
-};
-const reconnect = (tenantId, uid, options = {}) => {
-  const hasPreviousIdentity = currentTenantId !== null && currentUid !== null;
-  const identityChanged = hasPreviousIdentity && (currentTenantId !== tenantId || currentUid !== uid || (connectOptions.appName ?? "") !== (options.appName ?? ""));
-  if (identityChanged) {
-    cancelPendingWindowRequests();
-    for (const subscription of subscriptions.values()) {
-      subscription.hasRequestedInitialLocalQuery = false;
-      subscription.lastSnapshot = void 0;
-      subscription.lastNetworkVersion = 0;
-      subscription.windowIntentVersion += 1;
-      subscription.requestedCount = subscription.initialWindowSize;
-      delete subscription.localQueryPromise;
-      dispatchQuerySnapshotToSubscription(subscription, {
-        error: null,
-        data: void 0,
-        context: {
-          source: "cache",
-          reset: true,
-          ...subscription.initialWindowSize ? {
-            window: {
-              requestedCount: subscription.initialWindowSize
-            }
-          } : {}
-        }
-      });
-    }
-    for (const subscription of countSubscriptions.values()) {
-      subscription.lastSnapshot = void 0;
-      dispatchCountSnapshotToSubscription(subscription, {
-        error: null,
-        count: void 0,
-        context: {
-          source: "cache",
-          reset: true
-        }
-      });
-    }
-  }
-  forceInitialQueryOnNextConnection = hasEstablishedConnection || identityChanged;
-  explicitDisconnect = true;
-  connectionGeneration += 1;
-  rejectPendingConnectionAttempt();
-  clearReconnectTimer();
-  pendingServerReconnectJitter = false;
-  if (socket) {
-    try {
-      socket.close();
-    } catch {
-    }
-  }
-  socket = null;
-  socketReadyForMessages = false;
-  connectPromise = null;
-  connectionEpoch = null;
-  return connectInternal(tenantId, uid, options, {
-    resetReconnectAttempts: true
-  });
-};
-const getConnectionStatus = () => {
-  return connectionStatus;
-};
-const getConnectionError = () => {
-  return connectionError;
-};
-const onConnectionStatusChange = (callback) => {
-  connectionStatusCallbacks.add(callback);
-  return () => {
-    connectionStatusCallbacks.delete(callback);
-  };
-};
-const registerQuery = (modelName, query, optionsOrCallback, callbackMaybe, behavior) => {
-  let options;
-  let callback;
-  if (typeof optionsOrCallback === "function") {
-    options = {};
-    callback = optionsOrCallback;
-  } else {
-    options = optionsOrCallback ?? {};
-    callback = callbackMaybe;
-  }
-  if (!callback) return void 0;
-  if (typeof modelName !== "string" || modelName.trim().length === 0) {
-    throw new Error("registerQuery: modelName must be a non-empty string");
-  }
-  const queryKey = computeRtsQueryKey(query, options);
-  const cbKey = `${modelName}.${queryKey}`;
-  const runInitialNetworkQuery = behavior?.runInitialNetworkQuery !== false;
-  const runInitialLocalQuery = behavior?.runInitialLocalQuery !== false;
-  const forceRefreshOnMount = behavior?.forceRefreshOnMount === true;
-  const populateCache = preparePopulateCacheOptions({
-    projection: options.projection,
-    populate: options.populate
-  }, "registerQuery");
-  const initialWindowSize = options.pagination ? normalizeRequestedCount(options.pagination.limit) : void 0;
-  const existingSubscription = subscriptions.get(cbKey);
-  const subscription = existingSubscription ?? {
-    modelName,
-    query,
-    options,
-    queryKey,
-    callbacks: /* @__PURE__ */ new Set(),
-    runInitialNetworkQuery,
-    runInitialLocalQuery,
-    hasRequestedInitialLocalQuery: false,
-    lastNetworkVersion: 0,
-    windowIntentVersion: 0,
-    ...initialWindowSize ? {
-      initialWindowSize,
-      requestedCount: initialWindowSize
-    } : {},
-    ...populateCache ? {
-      populateCache
-    } : {}
-  };
-  const hadCallbacks = subscription.callbacks.size > 0;
-  const hadInitialNetworkQuery = subscription.runInitialNetworkQuery;
-  subscription.callbacks.add(callback);
-  if (runInitialNetworkQuery) {
-    subscription.runInitialNetworkQuery = true;
-  }
-  if (runInitialLocalQuery) {
-    subscription.runInitialLocalQuery = true;
-  }
-  subscriptions.set(cbKey, subscription);
-  let seeded = false;
-  if (behavior?.seedSnapshot && updateQuerySubscriptionSnapshot(subscription, behavior.seedSnapshot)) {
-    dispatchQuerySnapshotToSubscription(subscription, behavior.seedSnapshot);
-    seeded = true;
-  }
-  if (!seeded && hadCallbacks && subscription.lastSnapshot && !hasSnapshotError(subscription.lastSnapshot)) {
-    callback(subscription.lastSnapshot.error, subscription.lastSnapshot.data, subscription.lastSnapshot.context);
-  }
-  if (!hadCallbacks) {
-    if (runInitialLocalQuery) {
-      subscription.hasRequestedInitialLocalQuery = requestSubscriptionLocalQuery(cbKey, subscription);
-    }
-    sendToServer({
-      type: "register-query",
-      modelName,
-      queryKey,
-      query,
-      options: getSubscriptionServerOptions(subscription),
-      runInitialQuery: runInitialNetworkQuery
-    });
-  } else {
-    if (runInitialLocalQuery && !subscription.hasRequestedInitialLocalQuery) {
-      subscription.hasRequestedInitialLocalQuery = requestSubscriptionLocalQuery(cbKey, subscription);
-    }
-    if (forceRefreshOnMount || runInitialNetworkQuery && (!hadInitialNetworkQuery || hasSnapshotError(subscription.lastSnapshot))) {
-      requestRegisteredQueryRefresh(subscription);
-    }
-  }
-  return () => {
-    const currentSubscription = subscriptions.get(cbKey);
-    currentSubscription?.callbacks.delete(callback);
-    if (currentSubscription && currentSubscription.callbacks.size === 0) {
-      subscriptions.delete(cbKey);
-      cancelPendingWindowRequests(cbKey);
-      sendToServer({
-        type: "remove-query",
-        modelName,
-        queryKey
-      });
-    }
-  };
-};
-const setQueryWindowSize = async ({
-  modelName,
-  query,
-  options,
-  requestedCount,
-  timeoutMs = 1e4
-}) => {
-  const normalizedRequestedCount = normalizeRequestedCount(requestedCount);
-  if (!normalizedRequestedCount || !options.pagination) return false;
-  const queryKey = computeRtsQueryKey(query, options);
-  const cbKey = `${modelName}.${queryKey}`;
-  const subscription = subscriptions.get(cbKey);
-  if (!subscription?.options.pagination) return false;
-  const currentNetworkWindow = subscription.lastSnapshot?.context.source === "network" ? subscription.lastSnapshot.context.window : void 0;
-  if (subscription.requestedCount === normalizedRequestedCount && currentNetworkWindow?.requestedCount === normalizedRequestedCount) {
-    return true;
-  }
-  const previousRequestedCount = subscription.requestedCount ?? subscription.initialWindowSize ?? normalizedRequestedCount;
-  subscription.windowIntentVersion += 1;
-  subscription.requestedCount = normalizedRequestedCount;
-  let request;
-  const response = new Promise((resolve) => {
-    const timeoutId = setRuntimeTimeout(() => {
-      settlePendingWindowRequests(cbKey, request.requestedCount, false);
-    }, timeoutMs);
-    request = {
-      requestedCount: normalizedRequestedCount,
-      previousRequestedCount,
-      resolve,
-      timeoutId
-    };
-    const pending = pendingWindowRequests.get(cbKey) ?? /* @__PURE__ */ new Set();
-    pending.add(request);
-    pendingWindowRequests.set(cbKey, pending);
-  });
-  try {
-    if (!isSocketReady()) {
-      if (!currentTenantId || !currentUid) {
-        settlePendingWindowRequests(cbKey, normalizedRequestedCount, false);
-        return false;
-      }
-      await connectInternal(currentTenantId, currentUid, connectOptions, {
-        resetReconnectAttempts: false
-      });
-    }
-    sendToServer({
-      type: "set-query-window",
-      modelName,
-      queryKey,
-      requestedCount: normalizedRequestedCount
-    });
-  } catch {
-    settlePendingWindowRequests(cbKey, normalizedRequestedCount, false);
-    return false;
-  }
-  return await response;
-};
-const registerCount = (modelName, query, optionsOrCallback, callbackMaybe, behavior) => {
-  let options;
-  let callback;
-  if (typeof optionsOrCallback === "function") {
-    options = {};
-    callback = optionsOrCallback;
-  } else {
-    options = optionsOrCallback ?? {};
-    callback = callbackMaybe;
-  }
-  if (!callback) return void 0;
-  if (typeof modelName !== "string" || modelName.trim().length === 0) {
-    throw new Error("registerCount: modelName must be a non-empty string");
-  }
-  const queryKey = computeRtsQueryKey(query, options);
-  const cbKey = `${modelName}.${queryKey}`;
-  const runInitialNetworkQuery = behavior?.runInitialNetworkQuery !== false;
-  const forceRefreshOnMount = behavior?.forceRefreshOnMount === true;
-  const existingSubscription = countSubscriptions.get(cbKey);
-  const subscription = existingSubscription ?? {
-    modelName,
-    query,
-    options,
-    queryKey,
-    callbacks: /* @__PURE__ */ new Set(),
-    runInitialNetworkQuery
-  };
-  const hadCallbacks = subscription.callbacks.size > 0;
-  const hadInitialNetworkQuery = subscription.runInitialNetworkQuery;
-  subscription.callbacks.add(callback);
-  if (runInitialNetworkQuery) {
-    subscription.runInitialNetworkQuery = true;
-  }
-  countSubscriptions.set(cbKey, subscription);
-  let seeded = false;
-  if (behavior?.seedSnapshot && updateCountSubscriptionSnapshot(subscription, behavior.seedSnapshot)) {
-    dispatchCountSnapshotToSubscription(subscription, behavior.seedSnapshot);
-    seeded = true;
-  }
-  if (!seeded && hadCallbacks && subscription.lastSnapshot && !hasSnapshotError(subscription.lastSnapshot)) {
-    callback(subscription.lastSnapshot.error, subscription.lastSnapshot.count, subscription.lastSnapshot.context);
-  }
-  if (!hadCallbacks) {
-    sendToServer({
-      type: "register-count",
-      modelName,
-      queryKey,
-      query,
-      options,
-      runInitialQuery: runInitialNetworkQuery
-    });
-  } else if (forceRefreshOnMount || runInitialNetworkQuery && (!hadInitialNetworkQuery || hasSnapshotError(subscription.lastSnapshot))) {
-    requestRegisteredCountRefresh(subscription);
-  }
-  return () => {
-    const currentSubscription = countSubscriptions.get(cbKey);
-    currentSubscription?.callbacks.delete(callback);
-    if (currentSubscription && currentSubscription.callbacks.size === 0) {
-      countSubscriptions.delete(cbKey);
-      sendToServer({
-        type: "remove-count",
-        modelName,
-        queryKey
-      });
-    }
-  };
-};
-const makeRunQueryKey = () => `run-query.${Date.now().toString(36)}.${Math.random().toString(36).slice(2, 10)}`;
-const runNetworkQuery = async ({
-  modelName,
-  query,
-  options = {},
-  timeoutMs = 1e4
-}) => {
-  if (typeof modelName !== "string" || modelName.trim().length === 0) {
-    throw new Error("runNetworkQuery: modelName must be a non-empty string");
-  }
-  preparePopulateCacheOptions({
-    projection: options.projection,
-    populate: options.populate
-  }, "runNetworkQuery");
-  const hasTimeout = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0;
-  const timeoutStartedAt = hasTimeout ? Date.now() : 0;
-  if (!isSocketReady()) {
-    if (currentTenantId && currentUid) {
-      try {
-        const connectAttempt = connectInternal(currentTenantId, currentUid, connectOptions, {
-          resetReconnectAttempts: false
-        });
-        if (hasTimeout) {
-          await new Promise((resolve, reject) => {
-            const timeoutId = setRuntimeTimeout(() => {
-              reject(new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR));
-            }, timeoutMs);
-            connectAttempt.then(() => {
-              clearRuntimeTimeout(timeoutId);
-              resolve();
-            }, (error) => {
-              clearRuntimeTimeout(timeoutId);
-              reject(error);
-            });
-          });
-        } else {
-          await connectAttempt;
-        }
-      } catch {
-      }
-    }
-  }
-  if (!isSocketReady()) {
-    if (hasTimeout && Date.now() - timeoutStartedAt >= timeoutMs) {
-      throw new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR);
-    }
-    throw new Error("runNetworkQuery: RTS socket is not connected");
-  }
-  const remainingTimeoutMs = hasTimeout ? Math.max(0, timeoutMs - (Date.now() - timeoutStartedAt)) : null;
-  if (remainingTimeoutMs !== null && remainingTimeoutMs <= 0) {
-    throw new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR);
-  }
-  const resolvedOptions = {
-    ...options,
-    key: makeRunQueryKey()
-  };
-  const queryKey = computeRtsQueryKey(query, resolvedOptions);
-  const cbKey = `${modelName}.${queryKey}`;
-  return await new Promise((resolve, reject) => {
-    let settled = false;
-    let timeoutId = null;
-    const cleanup = () => {
-      const callbacks2 = queryCallbacks.get(cbKey);
-      callbacks2?.delete(callback);
-      if (callbacks2 && callbacks2.size === 0) queryCallbacks.delete(cbKey);
-      if (timeoutId !== null) {
-        clearRuntimeTimeout(timeoutId);
-      }
-    };
-    const settle = (next) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      next();
-    };
-    const callback = (error, data, context) => {
-      if (error) {
-        settle(() => reject(error));
-        return;
-      }
-      settle(() => resolve({
-        data,
-        context
-      }));
-    };
-    const callbacks = queryCallbacks.get(cbKey) ?? /* @__PURE__ */ new Set();
-    callbacks.add(callback);
-    queryCallbacks.set(cbKey, callbacks);
-    if (remainingTimeoutMs !== null) {
-      timeoutId = setRuntimeTimeout(() => {
-        settle(() => reject(new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR)));
-      }, remainingTimeoutMs);
-    }
-    sendToServer({
-      type: "run-query",
-      modelName,
-      queryKey,
-      query,
-      options: resolvedOptions
-    });
-  });
-};
-const runNetworkCount = async ({
-  modelName,
-  query,
-  options = {},
-  timeoutMs = 1e4
-}) => {
-  if (typeof modelName !== "string" || modelName.trim().length === 0) {
-    throw new Error("runNetworkCount: modelName must be a non-empty string");
-  }
-  const hasTimeout = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0;
-  const timeoutStartedAt = hasTimeout ? Date.now() : 0;
-  if (!isSocketReady()) {
-    if (currentTenantId && currentUid) {
-      try {
-        const connectAttempt = connectInternal(currentTenantId, currentUid, connectOptions, {
-          resetReconnectAttempts: false
-        });
-        if (hasTimeout) {
-          await new Promise((resolve, reject) => {
-            const timeoutId = setRuntimeTimeout(() => {
-              reject(new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR));
-            }, timeoutMs);
-            connectAttempt.then(() => {
-              clearRuntimeTimeout(timeoutId);
-              resolve();
-            }, (error) => {
-              clearRuntimeTimeout(timeoutId);
-              reject(error);
-            });
-          });
-        } else {
-          await connectAttempt;
-        }
-      } catch {
-      }
-    }
-  }
-  if (!isSocketReady()) {
-    if (hasTimeout && Date.now() - timeoutStartedAt >= timeoutMs) {
-      throw new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR);
-    }
-    throw new Error("runNetworkCount: RTS socket is not connected");
-  }
-  const remainingTimeoutMs = hasTimeout ? Math.max(0, timeoutMs - (Date.now() - timeoutStartedAt)) : null;
-  if (remainingTimeoutMs !== null && remainingTimeoutMs <= 0) {
-    throw new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR);
-  }
-  const resolvedOptions = {
-    ...options,
-    key: makeRunQueryKey()
-  };
-  const queryKey = computeRtsQueryKey(query, resolvedOptions);
-  const cbKey = `${modelName}.${queryKey}`;
-  return await new Promise((resolve, reject) => {
-    let settled = false;
-    let timeoutId = null;
-    const cleanup = () => {
-      const callbacks = countCallbacks.get(cbKey);
-      callbacks?.delete(callback);
-      if (callbacks && callbacks.size === 0) countCallbacks.delete(cbKey);
-      if (timeoutId !== null) {
-        clearRuntimeTimeout(timeoutId);
-      }
-    };
-    const settle = (next) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      next();
-    };
-    const callback = (error, count, context) => {
-      if (error) {
-        settle(() => reject(typeof error === "string" ? new Error(error) : error));
-        return;
-      }
-      if (count === void 0) {
-        settle(() => reject(new Error("runNetworkCount: invalid count payload")));
-        return;
-      }
-      settle(() => resolve({
-        count,
-        context
-      }));
-    };
-    const set = countCallbacks.get(cbKey) ?? /* @__PURE__ */ new Set();
-    set.add(callback);
-    countCallbacks.set(cbKey, set);
-    if (remainingTimeoutMs !== null) {
-      timeoutId = setRuntimeTimeout(() => {
-        settle(() => reject(new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR)));
-      }, remainingTimeoutMs);
-    }
-    sendToServer({
-      type: "run-count",
-      modelName,
-      queryKey,
-      query,
-      options: resolvedOptions
-    });
-  });
-};
-const sendMessage = (event, payload) => {
-  sendToServer({
-    type: "event",
-    event,
-    payload
-  });
-};
-const sendRtsMessage = (channel, payload) => {
-  sendToServer({
-    type: "rts-message",
-    channel,
-    payload
-  });
-};
-const onMessage = (event, callback) => {
-  const set = messageCallbacks.get(event) ?? /* @__PURE__ */ new Set();
-  set.add(callback);
-  messageCallbacks.set(event, set);
-  return () => {
-    const callbacks = messageCallbacks.get(event);
-    callbacks?.delete(callback);
-    if (callbacks && callbacks.size === 0) messageCallbacks.delete(event);
-  };
-};
-const onRtsMessage = (channel, callback) => {
-  const set = rtsMessageCallbacks.get(channel) ?? /* @__PURE__ */ new Set();
-  set.add(callback);
-  rtsMessageCallbacks.set(channel, set);
-  return () => {
-    const callbacks = rtsMessageCallbacks.get(channel);
-    callbacks?.delete(callback);
-    if (callbacks && callbacks.size === 0) rtsMessageCallbacks.delete(channel);
-  };
-};
-const normalizePageInfo = (value) => {
-  if (!value || typeof value !== "object") return void 0;
-  if (Array.isArray(value)) return void 0;
-  const raw = value;
-  if (typeof raw.hasNextPage !== "boolean" || typeof raw.hasPrevPage !== "boolean") return void 0;
-  const nextCursor = typeof raw.nextCursor === "string" && raw.nextCursor ? raw.nextCursor : void 0;
-  const prevCursor = typeof raw.prevCursor === "string" && raw.prevCursor ? raw.prevCursor : void 0;
-  return {
-    hasNextPage: raw.hasNextPage,
-    hasPrevPage: raw.hasPrevPage,
-    ...nextCursor ? {
-      nextCursor
-    } : {},
-    ...prevCursor ? {
-      prevCursor
-    } : {}
-  };
-};
-const normalizeTotalCount = (value) => {
-  if (typeof value !== "number") return void 0;
-  if (!Number.isFinite(value) || value < 0) return void 0;
-  return Math.floor(value);
-};
-const normalizeWindowSize = (value) => {
-  if (typeof value !== "number" || !Number.isFinite(value)) return 1;
-  return Math.max(1, Math.min(RTS_QUERY_WINDOW_MAX_COUNT, Math.floor(value)));
-};
-const assertIncludeOnlyProjection = (projection) => {
-  if (!projection) return;
-  for (const [path, value] of Object.entries(projection)) {
-    if (!path.trim()) continue;
-    if (value !== 1) {
-      throw new Error("useQuery: projection must be include-only (value 1); exclusion projection is not supported");
-    }
-  }
-};
-const useQuery = (modelName, query = {}, options = {}) => {
-  if (typeof modelName !== "string" || modelName.trim().length === 0) {
-    throw new Error("useQuery: modelName must be a non-empty string");
-  }
-  assertIncludeOnlyProjection(options.projection);
-  const enabled = options.enabled ?? true;
-  const ssrEnabled = options.ssr !== false;
-  const refreshOnMount = options.refreshOnMount === true;
-  const key = options.key;
-  const queryJson = serializeRtsQueryValue(query);
-  const projectionJson = options.projection ? serializeRtsQueryValue(options.projection) : "";
-  const sortJson = options.sort ? serializeRtsQueryValue(options.sort) : "";
-  const limitStr = typeof options.limit === "number" ? String(options.limit) : "";
-  const populateJson = options.populate ? serializeRtsQueryValue(options.populate) : "";
-  const paginationJson = options.pagination ? serializeRtsQueryValue(options.pagination) : "";
-  preparePopulateCacheOptions({
-    projection: options.projection,
-    populate: options.populate
-  }, "useQuery");
-  const isPaginated = Boolean(options.pagination);
-  if (options.pagination && (!Number.isInteger(options.pagination.limit) || options.pagination.limit < 1 || options.pagination.limit > RTS_QUERY_WINDOW_MAX_COUNT)) {
-    throw new Error("useQuery: pagination limit must be an integer between 1 and 4096");
-  }
-  if (options.pagination?.cursor || options.pagination?.direction) {
-    throw new Error("useQuery: cursor and direction are not supported by virtual query windows");
-  }
-  const initialWindowSize = isPaginated ? normalizeWindowSize(options.pagination?.limit) : void 0;
-  const queryKey = computeRtsQueryKey(query, {
-    key,
-    projection: options.projection,
-    sort: options.sort,
-    limit: options.limit,
-    populate: options.populate,
-    pagination: options.pagination
-  });
-  const ssrRuntime = useRtsSsrRuntime();
-  if (enabled && ssrEnabled && ssrRuntime) {
-    ssrRuntime.registerQuery({
-      modelName,
-      query,
-      options: {
-        key,
-        projection: options.projection,
-        sort: options.sort,
-        limit: options.limit,
-        populate: options.populate,
-        pagination: options.pagination
-      },
-      queryKey
-    });
-  }
-  const seedDataRaw = useMemo(() => enabled && ssrEnabled ? ssrRuntime ? ssrRuntime.getQueryData(modelName, queryKey) : peekHydratedRtsQueryData(modelName, queryKey) : void 0, [enabled, ssrEnabled, ssrRuntime, modelName, queryKey]);
-  const seedPageInfoRaw = useMemo(() => enabled && ssrEnabled ? ssrRuntime ? ssrRuntime.getQueryPageInfo(modelName, queryKey) : peekHydratedRtsQueryPageInfo(modelName, queryKey) : void 0, [enabled, ssrEnabled, ssrRuntime, modelName, queryKey]);
-  const seedTotalCountRaw = useMemo(() => enabled && ssrEnabled ? ssrRuntime ? ssrRuntime.getQueryTotalCount(modelName, queryKey) : peekHydratedRtsQueryTotalCount(modelName, queryKey) : void 0, [enabled, ssrEnabled, ssrRuntime, modelName, queryKey]);
-  const hasSeedData = Array.isArray(seedDataRaw);
-  const seedData = hasSeedData ? seedDataRaw : void 0;
-  const seedPageInfo = useMemo(() => normalizePageInfo(seedPageInfoRaw), [seedPageInfoRaw]);
-  const seedTotalCount = normalizeTotalCount(seedTotalCountRaw);
-  const seedJson = (() => {
-    if (!hasSeedData) return "";
-    try {
-      return JSON.stringify(seedDataRaw);
-    } catch {
-      return "";
-    }
-  })();
-  const seedPageInfoJson = (() => {
-    if (!seedPageInfo) return "";
-    try {
-      return JSON.stringify(seedPageInfo);
-    } catch {
-      return "";
-    }
-  })();
-  const seedTotalCountStr = seedTotalCount !== void 0 ? String(seedTotalCount) : "";
-  const [data, setData] = useState(() => isPaginated ? void 0 : seedData);
-  const [paginatedData, setPaginatedData] = useState(() => isPaginated ? seedData : void 0);
-  const [pageInfo, setPageInfo] = useState(() => isPaginated ? seedPageInfo : void 0);
-  const [totalCount, setTotalCount] = useState(() => isPaginated ? seedTotalCount : void 0);
-  const [source, setSource] = useState(() => hasSeedData ? "cache" : void 0);
-  const [error, setError] = useState(void 0);
-  const [loading, setLoading] = useState(enabled && !hasSeedData);
-  const hasFirstReply = useRef(false);
-  const hasNetworkReply = useRef(false);
-  const lastDataJsonRef = useRef("");
-  const pageInfoRef = useRef(seedPageInfo);
-  const requestedCountRef = useRef(initialWindowSize ?? 1);
-  const pagingRef = useRef(false);
-  useEffect(() => {
-    pageInfoRef.current = pageInfo;
-  }, [pageInfo]);
-  useEffect(() => {
-    if (!ssrRuntime && enabled && ssrEnabled && hasSeedData) {
-      consumeHydratedRtsQueryData(modelName, queryKey);
-    }
-    hasFirstReply.current = hasSeedData;
-    hasNetworkReply.current = false;
-    lastDataJsonRef.current = seedJson;
-    requestedCountRef.current = initialWindowSize ?? 1;
-    pagingRef.current = false;
-    setError(void 0);
-    if (!enabled) {
-      setLoading(false);
-      setData(void 0);
-      setPaginatedData(void 0);
-      setPageInfo(void 0);
-      setTotalCount(void 0);
-      setSource(void 0);
-      return;
-    }
-    if (hasSeedData) {
-      const nextSeedData = seedData;
-      setLoading(false);
-      setSource("cache");
-      if (isPaginated) {
-        setPaginatedData(nextSeedData);
-        setPageInfo(seedPageInfo);
-        setTotalCount(seedTotalCount);
-        setData(void 0);
-      } else {
-        setData(nextSeedData);
-        setTotalCount(void 0);
-        setPaginatedData(void 0);
-        setPageInfo(void 0);
-      }
-      return;
-    }
-    setData(void 0);
-    setPaginatedData(void 0);
-    setPageInfo(void 0);
-    setTotalCount(void 0);
-    setLoading(true);
-  }, [enabled, ssrEnabled, ssrRuntime, modelName, queryKey, hasSeedData, seedData, seedJson, seedPageInfo, seedPageInfoJson, seedTotalCount, seedTotalCountStr, isPaginated, initialWindowSize]);
-  useEffect(() => {
-    if (!enabled) return;
-    const runInitialNetworkQuery = isPaginated || refreshOnMount || !hasSeedData;
-    const runInitialLocalQuery = !hasSeedData;
-    const unsubscribe = registerQuery(modelName, query, {
-      key,
-      projection: options.projection,
-      sort: options.sort,
-      limit: options.limit,
-      populate: options.populate,
-      pagination: options.pagination
-    }, (err, result, context) => {
-      if (context.source === "cache" && context.reset) {
-        hasFirstReply.current = false;
-        hasNetworkReply.current = false;
-        lastDataJsonRef.current = "";
-        pageInfoRef.current = void 0;
-        requestedCountRef.current = initialWindowSize ?? 1;
-        pagingRef.current = false;
-        setData(void 0);
-        setPaginatedData(void 0);
-        setPageInfo(void 0);
-        setTotalCount(void 0);
-        setSource(void 0);
-        setError(void 0);
-        setLoading(true);
-        return;
-      }
-      if (context.source === "cache" && hasNetworkReply.current && (!isPaginated || !context.window || context.window.requestedCount <= requestedCountRef.current)) return;
-      if (context.source === "network") {
-        hasNetworkReply.current = true;
-      }
-      setLoading(false);
-      if (err) {
-        setError(err);
-        return;
-      }
-      if (!Array.isArray(result)) return;
-      if (context.source === "network" && context.isLocal && options.skipLocal && hasFirstReply.current) {
-        return;
-      }
-      hasFirstReply.current = true;
-      const nextPageInfo = context.pageInfo;
-      const nextTotalCount = context.totalCount;
-      const nextRequestedCount = context.window?.requestedCount;
-      if (isPaginated && nextRequestedCount !== void 0) {
-        requestedCountRef.current = nextRequestedCount;
-      }
-      const payloadForHash = isPaginated ? {
-        result,
-        pageInfo: nextPageInfo,
-        totalCount: nextTotalCount,
-        requestedCount: nextRequestedCount
-      } : result;
-      let nextJson = "";
-      try {
-        nextJson = JSON.stringify(payloadForHash);
-      } catch {
-        nextJson = "";
-      }
-      if (nextJson && nextJson === lastDataJsonRef.current) {
-        setSource(context.source);
-        return;
-      }
-      lastDataJsonRef.current = nextJson;
-      setSource(context.source);
-      setError(void 0);
-      if (isPaginated) {
-        setPaginatedData(result);
-        setPageInfo(nextPageInfo);
-        setTotalCount(nextTotalCount);
-        return;
-      }
-      setData(result);
-      setTotalCount(void 0);
-    }, {
-      runInitialNetworkQuery,
-      runInitialLocalQuery,
-      forceRefreshOnMount: refreshOnMount,
-      ...hasSeedData ? {
-        seedSnapshot: {
-          error: null,
-          data: seedData,
-          context: {
-            source: "cache",
-            ...seedPageInfo ? {
-              pageInfo: seedPageInfo
-            } : {},
-            ...seedTotalCount !== void 0 ? {
-              totalCount: seedTotalCount
-            } : {},
-            ...initialWindowSize ? {
-              window: {
-                requestedCount: initialWindowSize
-              }
-            } : {}
-          }
-        }
-      } : {}
-    });
-    return () => {
-      unsubscribe?.();
-    };
-  }, [enabled, modelName, queryKey, queryJson, projectionJson, sortJson, limitStr, populateJson, paginationJson, hasSeedData, refreshOnMount, isPaginated, initialWindowSize]);
-  const fetchNext = async () => {
-    if (!enabled || !isPaginated || !options.pagination) return false;
-    if (pagingRef.current || !pageInfoRef.current?.hasNextPage) return false;
-    const pageSize = initialWindowSize ?? normalizeWindowSize(options.pagination.limit);
-    const nextRequestedCount_0 = Math.min(RTS_QUERY_WINDOW_MAX_COUNT, requestedCountRef.current + pageSize);
-    if (nextRequestedCount_0 === requestedCountRef.current) return false;
-    pagingRef.current = true;
-    setLoading(true);
-    setError(void 0);
-    try {
-      return await setQueryWindowSize({
-        modelName,
-        query,
-        options: {
-          key,
-          projection: options.projection,
-          sort: options.sort,
-          limit: options.limit,
-          populate: options.populate,
-          pagination: options.pagination
-        },
-        requestedCount: nextRequestedCount_0
-      });
-    } catch (err_0) {
-      setError(err_0);
-      return false;
-    } finally {
-      pagingRef.current = false;
-      setLoading(false);
-    }
-  };
-  const fetchPrevious = async () => {
-    return false;
-  };
-  const resetPagination = () => {
-    if (!enabled || !isPaginated || !options.pagination || !initialWindowSize) return;
-    if (pagingRef.current || requestedCountRef.current === initialWindowSize) return;
-    pagingRef.current = true;
-    setLoading(true);
-    setError(void 0);
-    void setQueryWindowSize({
-      modelName,
-      query,
-      options: {
-        key,
-        projection: options.projection,
-        sort: options.sort,
-        limit: options.limit,
-        populate: options.populate,
-        pagination: options.pagination
-      },
-      requestedCount: initialWindowSize
-    }).finally(() => {
-      pagingRef.current = false;
-      setLoading(false);
-    });
-  };
-  return {
-    data: isPaginated ? paginatedData : data,
-    pageInfo: isPaginated ? pageInfo : void 0,
-    totalCount: isPaginated ? totalCount : void 0,
-    source,
-    error,
-    loading,
-    fetchNext,
-    fetchPrevious,
-    resetPagination
-  };
-};
-export {
-  registerQuery as A,
-  resetRtsPouchStore as B,
-  runNetworkCount as C,
-  runNetworkQuery as D,
-  runQuery as E,
-  sendMessage as F,
-  sendRtsMessage as G,
-  syncRtsChanges as H,
-  updateDocs as I,
-  RtsSsrRuntimeProvider as R,
-  STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY as S,
-  consumeHydratedRtsCount as a,
-  peekHydratedRtsQueryData as b,
-  clearHydratedRtsQueryData as c,
-  peekHydratedRtsQueryPageInfo as d,
-  peekHydratedRtsQueryTotalCount as e,
-  computeRtsQueryKey as f,
-  useRtsSsrRuntime as g,
-  hydrateRtsFromWindow as h,
-  reconnect as i,
-  disconnect as j,
-  addLocalTxn as k,
-  configureRtsPouchStore as l,
-  connect as m,
-  deleteDocs as n,
-  destroyAllCollections as o,
-  peekHydratedRtsCount as p,
-  destroyCollection as q,
-  registerCount as r,
-  serializeRtsQueryValue as s,
-  getCollection as t,
-  useQuery as u,
-  getConnectionError as v,
-  getConnectionStatus as w,
-  onConnectionStatusChange as x,
-  onMessage as y,
-  onRtsMessage as z
-};
-//# sourceMappingURL=useQuery-DZqYIJog.js.map