@rpcbase/client 0.405.0 → 0.406.0

package/dist/useQuery-XvXbEwG_.js

@@ -1,2312 +0,0 @@
-import { createContext, useContext, useId, 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 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 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
-      } : {}
-    });
-  }
-  return {
-    v: 1,
-    tenantId: normalizeStringOrNull(raw.tenantId),
-    uid: normalizeStringOrNull(raw.uid),
-    queries
-  };
-};
-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();
-  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);
-  }
-};
-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 consumeHydratedRtsQueryData = (modelName, queryKey) => {
-  const key = makeStoreKey(modelName, queryKey);
-  hydrationDataStore.delete(key);
-  hydrationPageInfoStore.delete(key);
-  hydrationTotalCountStore.delete(key);
-};
-const clearHydratedRtsQueryData = () => {
-  hydrationDataStore.clear();
-  hydrationPageInfoStore.clear();
-  hydrationTotalCountStore.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 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";
-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) => {
-  const 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 PouchDB = await getPouchDb();
-  applyPrefix(PouchDB);
-  const prefix = getPrefix();
-  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 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 getKeys = (obj, parentKey = "") => {
-  const keys = [];
-  for (const key of Object.keys(obj)) {
-    const nextKey = parentKey ? `${parentKey}.${key}` : key;
-    const value = obj[key];
-    if (typeof value === "object" && value !== null && !Array.isArray(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 getValueAtPath = (doc, path) => {
-  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
-  if (!parts.length) return void 0;
-  let current = doc;
-  for (const part of parts) {
-    if (!current || typeof current !== "object" || Array.isArray(current)) return void 0;
-    current = current[part];
-  }
-  return current;
-};
-const setValueAtPath = (doc, path, value) => {
-  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
-  if (!parts.length) return;
-  let current = doc;
-  for (let i = 0; i < parts.length - 1; i += 1) {
-    const key = parts[i];
-    const existing = current[key];
-    if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
-      current[key] = {};
-    }
-    current = current[key];
-  }
-  current[parts[parts.length - 1]] = value;
-};
-const unsetValueAtPath = (doc, path) => {
-  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
-  if (!parts.length) return;
-  let current = doc;
-  for (let i = 0; i < parts.length - 1; i += 1) {
-    const key = parts[i];
-    const next = current[key];
-    if (!next || typeof next !== "object" || Array.isArray(next)) return;
-    current = next;
-  }
-  delete current[parts[parts.length - 1]];
-};
-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 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 value = getValueAtPath(doc, key);
-      if (value !== void 0) setValueAtPath(projected2, key, value);
-    }
-    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 value = getValueAtPath(next, entry.path);
-    if (value === void 0) continue;
-    if (Array.isArray(value)) {
-      const ids = [];
-      for (const candidate of value) {
-        const id2 = extractDocId(candidate);
-        if (!id2) continue;
-        ids.push(id2);
-        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, 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 rawValue = getValueAtPath(doc, entry.path);
-      const isArray = Array.isArray(rawValue);
-      const ids = (isArray ? rawValue : [rawValue]).map((candidate) => extractDocId(candidate)).filter(Boolean);
-      return {
-        doc,
-        hasValue: rawValue !== void 0,
-        isArray,
-        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.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 computeRtsQueryKey = (query, options) => {
-  const key = options.key ?? "";
-  const projection = options.projection ? JSON.stringify(options.projection) : "";
-  const sort = options.sort ? JSON.stringify(options.sort) : "";
-  const limit = typeof options.limit === "number" ? String(options.limit) : "";
-  const populate = options.populate ? JSON.stringify(options.populate) : "";
-  const pagination = options.pagination ? JSON.stringify(options.pagination) : "";
-  return `${key}${JSON.stringify(query)}${projection}${sort}${limit}${populate}${pagination}`;
-};
-const TENANT_ID_QUERY_PARAM = "rb-tenant-id";
-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";
-let socket = null;
-let connectPromise = null;
-let explicitDisconnect = false;
-let currentTenantId = null;
-let currentUid = null;
-let connectOptions = {};
-const localTxnBuf = [];
-const queryCallbacks = /* @__PURE__ */ new Map();
-const subscriptions = /* @__PURE__ */ new Map();
-const messageCallbacks = /* @__PURE__ */ new Map();
-let reconnectTimer = null;
-let reconnectAttempts = 0;
-let hasEstablishedConnection = false;
-let pendingServerReconnectJitter = false;
-let syncPromise = null;
-let syncKey = null;
-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 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);
-  url.searchParams.set(TENANT_ID_QUERY_PARAM, tenantId);
-  return url.toString();
-};
-const buildSocketUrl = (tenantId, _uid, options) => {
-  if (options.url) {
-    const url = resolveWebSocketUrlFromCandidate(options.url, options);
-    url.searchParams.set(TENANT_ID_QUERY_PARAM, tenantId);
-    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 = "";
-  base.searchParams.set(TENANT_ID_QUERY_PARAM, tenantId);
-  return base.toString();
-};
-const sendToServer = (message) => {
-  if (!socket) return;
-  if (socket.readyState !== WebSocket.OPEN) return;
-  socket.send(JSON.stringify(message));
-};
-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: sub.options,
-      runInitialQuery
-    });
-  }
-};
-const clearReconnectTimer = () => {
-  if (reconnectTimer === null) return;
-  clearRuntimeTimeout(reconnectTimer);
-  reconnectTimer = null;
-};
-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 handleQueryPayload = (payload) => {
-  const {
-    modelName,
-    queryKey,
-    data,
-    error,
-    txnId
-  } = payload;
-  const cbKey = `${modelName}.${queryKey}`;
-  const callbacks = queryCallbacks.get(cbKey);
-  if (!callbacks || !callbacks.size) return;
-  const subscription = subscriptions.get(cbKey);
-  const pageInfo = normalizePageInfo$1(payload.pageInfo);
-  const totalCount = normalizeTotalCount$1(payload.totalCount);
-  const populateCache = subscription?.populateCache;
-  const hasPopulate = Boolean(populateCache);
-  const hasPagination = Boolean(subscription?.options?.pagination || pageInfo || totalCount !== void 0);
-  const isLocal = !!(txnId && localTxnBuf.includes(txnId));
-  const context = {
-    source: "network",
-    isLocal,
-    txnId,
-    ...pageInfo ? {
-      pageInfo
-    } : {},
-    ...totalCount !== void 0 ? {
-      totalCount
-    } : {}
-  };
-  if (error) {
-    for (const cb of callbacks) cb(error, void 0, context);
-    return;
-  }
-  for (const cb of callbacks) cb(null, data, context);
-  if (!currentUid) 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 handleEvent = (payload) => {
-  const callbacks = messageCallbacks.get(payload.event);
-  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 === "event") {
-    handleEvent(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) => {
-  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) {
-    await destroyCollection(modelName, uid).catch(() => {
-    });
-  }
-  for (const [modelName, ids] of deletesByModel.entries()) {
-    if (resetModels.has(modelName)) continue;
-    await deleteDocs(modelName, ids, uid).catch(() => {
-    });
-  }
-};
-const syncRtsChanges = async (tenantId, uid, options = {}) => {
-  ensureSyncRuntime();
-  if (!tenantId || !uid) return;
-  const storageKey = getSyncStorageKey({
-    tenantId,
-    uid,
-    appName: options.appName
-  });
-  let sinceSeq = readStoredSeq(storageKey);
-  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 (!response.ok) return;
-    const payload = await response.json().catch(() => null);
-    if (!payload || typeof payload !== "object") return;
-    const payloadObj = payload;
-    const ok = payloadObj.ok;
-    if (ok !== true) return;
-    const latestSeq = Number(payloadObj.latestSeq ?? 0);
-    const needsFullResync = Boolean(payloadObj.needsFullResync);
-    if (needsFullResync) {
-      resetRtsPouchStore({
-        tenantId,
-        appName: options.appName
-      });
-      writeStoredSeq(storageKey, latestSeq);
-      return;
-    }
-    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;
-    }
-    await applyChangeBatch(normalized, uid);
-    const lastSeq = normalized.reduce((max, c2) => c2.seq > max ? c2.seq : max, sinceSeq);
-    sinceSeq = lastSeq;
-    writeStoredSeq(storageKey, sinceSeq);
-    if (latestSeq > 0 && sinceSeq >= latestSeq) {
-      return;
-    }
-  }
-};
-const ensureSynced = (tenantId, uid, options) => {
-  if (options.syncChanges === false) return;
-  const key = `${options.appName ?? ""}:${tenantId}:${uid}`;
-  if (syncPromise && syncKey === key) return;
-  syncKey = key;
-  syncPromise = syncRtsChanges(tenantId, uid, {
-    appName: options.appName,
-    url: options.url
-  }).catch(() => {
-  }).finally(() => {
-    if (syncKey === key) {
-      syncPromise = null;
-    }
-  });
-};
-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
-    });
-  }
-  ensureSynced(tenantId, uid, options);
-  if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) {
-    return connectPromise ?? Promise.resolve();
-  }
-  explicitDisconnect = false;
-  clearReconnectTimer();
-  const url = buildSocketUrl(tenantId, uid, options);
-  connectPromise = new Promise((resolve, reject) => {
-    if (resetReconnectAttempts) reconnectAttempts = 0;
-    let opened = false;
-    let settled = false;
-    socket = new WebSocket(url);
-    socket.addEventListener("open", () => {
-      opened = true;
-      settled = true;
-      reconnectAttempts = 0;
-      pendingServerReconnectJitter = false;
-      const forceInitialQuery = hasEstablishedConnection;
-      resubscribeAll({
-        forceInitialQuery
-      });
-      hasEstablishedConnection = true;
-      resolve();
-    });
-    socket.addEventListener("message", handleMessage);
-    socket.addEventListener("close", (event) => {
-      if (!opened && !settled) {
-        settled = true;
-        reject(new Error(`RTS WebSocket closed before opening (code=${event.code})`));
-      }
-      if (!explicitDisconnect) {
-        pendingServerReconnectJitter = opened;
-      }
-      socket = null;
-      connectPromise = null;
-      scheduleReconnect();
-    });
-    socket.addEventListener("error", (err) => {
-      if (settled) return;
-      settled = true;
-      reject(err instanceof Error ? err : new Error("RTS WebSocket error"));
-    });
-  });
-  return connectPromise;
-};
-const connect = (tenantId, uid, options = {}) => {
-  return connectInternal(tenantId, uid, options, {
-    resetReconnectAttempts: true
-  });
-};
-const disconnect = () => {
-  explicitDisconnect = true;
-  clearReconnectTimer();
-  hasEstablishedConnection = false;
-  pendingServerReconnectJitter = false;
-  if (socket) {
-    try {
-      socket.close();
-    } catch {
-    }
-  }
-  socket = null;
-  connectPromise = null;
-};
-const reconnect = (tenantId, uid, options = {}) => {
-  explicitDisconnect = true;
-  clearReconnectTimer();
-  pendingServerReconnectJitter = false;
-  if (socket) {
-    try {
-      socket.close();
-    } catch {
-    }
-  }
-  socket = null;
-  connectPromise = null;
-  return connect(tenantId, uid, options);
-};
-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 populateCache = preparePopulateCacheOptions({
-    projection: options.projection,
-    populate: options.populate
-  }, "registerQuery");
-  const hasPopulate = Boolean(populateCache);
-  const hasPagination = Boolean(options.pagination);
-  const set = queryCallbacks.get(cbKey) ?? /* @__PURE__ */ new Set();
-  set.add(callback);
-  queryCallbacks.set(cbKey, set);
-  subscriptions.set(cbKey, {
-    modelName,
-    query,
-    options,
-    queryKey,
-    runInitialNetworkQuery,
-    ...populateCache ? {
-      populateCache
-    } : {}
-  });
-  if (currentUid && runInitialLocalQuery && !hasPagination) {
-    if (hasPopulate && populateCache) {
-      void runPopulatedQuery({
-        modelName,
-        query,
-        options: {
-          uid: currentUid,
-          projection: populateCache.rootProjection,
-          sort: options.sort,
-          limit: options.limit,
-          populate: populateCache.populate
-        }
-      }).then(({
-        hit,
-        data,
-        context
-      }) => {
-        if (!hit) return;
-        callback?.(null, data, context);
-      }).catch(() => {
-      });
-    } else {
-      void runQuery({
-        modelName,
-        query,
-        options: {
-          uid: currentUid,
-          projection: options.projection,
-          sort: options.sort,
-          limit: options.limit
-        }
-      }).then(({
-        data,
-        context
-      }) => {
-        callback?.(null, data, context);
-      }).catch(() => {
-      });
-    }
-  }
-  sendToServer({
-    type: "register-query",
-    modelName,
-    queryKey,
-    query,
-    options,
-    runInitialQuery: runInitialNetworkQuery
-  });
-  return () => {
-    sendToServer({
-      type: "remove-query",
-      modelName,
-      queryKey
-    });
-    const callbacks = queryCallbacks.get(cbKey);
-    callbacks?.delete(callback);
-    if (callbacks && callbacks.size === 0) {
-      queryCallbacks.delete(cbKey);
-      subscriptions.delete(cbKey);
-    }
-  };
-};
-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 (!socket || socket.readyState !== WebSocket.OPEN) {
-    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 (!socket || socket.readyState !== WebSocket.OPEN) {
-    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 ? options : {
-    ...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 sendMessage = (event, payload) => {
-  sendToServer({
-    type: "event",
-    event,
-    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 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 getDocId = (doc) => {
-  if (!doc || typeof doc !== "object") return "";
-  const id = doc._id;
-  return typeof id === "string" ? id.trim() : "";
-};
-const dedupeById = (docs) => {
-  const seen = /* @__PURE__ */ new Set();
-  const merged = [];
-  for (const doc of docs) {
-    const id = getDocId(doc);
-    if (id && seen.has(id)) continue;
-    if (id) seen.add(id);
-    merged.push(doc);
-  }
-  return merged;
-};
-const flattenLoadedPages = (previousPages, headPage, nextPages) => {
-  const merged = [];
-  for (const page of previousPages) merged.push(...page.nodes);
-  if (headPage) merged.push(...headPage.nodes);
-  for (const page of nextPages) merged.push(...page.nodes);
-  return dedupeById(merged);
-};
-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 id = useId();
-  const enabled = options.enabled ?? true;
-  const ssrEnabled = options.ssr !== false;
-  const refreshOnMount = options.refreshOnMount === true;
-  const key = options.key ?? id;
-  const queryJson = JSON.stringify(query);
-  const projectionJson = options.projection ? JSON.stringify(options.projection) : "";
-  const sortJson = options.sort ? JSON.stringify(options.sort) : "";
-  const limitStr = typeof options.limit === "number" ? String(options.limit) : "";
-  const populateJson = options.populate ? JSON.stringify(options.populate) : "";
-  const paginationJson = options.pagination ? JSON.stringify(options.pagination) : "";
-  preparePopulateCacheOptions({
-    projection: options.projection,
-    populate: options.populate
-  }, "useQuery");
-  const isPaginated = Boolean(options.pagination);
-  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 = normalizePageInfo(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 [headPage, setHeadPage] = useState(() => isPaginated && seedData ? {
-    nodes: seedData,
-    ...seedPageInfo ? {
-      pageInfo: seedPageInfo
-    } : {}
-  } : null);
-  const [totalCount, setTotalCount] = useState(() => isPaginated ? seedTotalCount : void 0);
-  const [previousPages, setPreviousPages] = useState([]);
-  const [nextPages, setNextPages] = useState([]);
-  const [source, setSource] = useState(() => hasSeedData ? "cache" : void 0);
-  const [error, setError] = useState(void 0);
-  const [loading, setLoading] = useState(enabled && !hasSeedData);
-  const [pagingDirection, setPagingDirection] = useState(null);
-  const hasFirstReply = useRef(false);
-  const hasNetworkReply = useRef(false);
-  const lastDataJsonRef = useRef("");
-  const previousPagesRef = useRef([]);
-  const nextPagesRef = useRef([]);
-  const headPageRef = useRef(null);
-  const pagingDirectionRef = useRef(null);
-  useEffect(() => {
-    previousPagesRef.current = previousPages;
-  }, [previousPages]);
-  useEffect(() => {
-    nextPagesRef.current = nextPages;
-  }, [nextPages]);
-  useEffect(() => {
-    headPageRef.current = headPage;
-  }, [headPage]);
-  useEffect(() => {
-    pagingDirectionRef.current = pagingDirection;
-  }, [pagingDirection]);
-  useEffect(() => {
-    if (!ssrRuntime && enabled && ssrEnabled && hasSeedData) {
-      consumeHydratedRtsQueryData(modelName, queryKey);
-    }
-    hasFirstReply.current = hasSeedData;
-    hasNetworkReply.current = false;
-    lastDataJsonRef.current = seedJson;
-    setError(void 0);
-    setPreviousPages([]);
-    setNextPages([]);
-    if (!enabled) {
-      setLoading(false);
-      setData(void 0);
-      setHeadPage(null);
-      setTotalCount(void 0);
-      setSource(void 0);
-      return;
-    }
-    if (hasSeedData) {
-      const nextSeedData = seedData;
-      setLoading(false);
-      setSource("cache");
-      if (isPaginated) {
-        setHeadPage({
-          nodes: nextSeedData,
-          ...seedPageInfo ? {
-            pageInfo: seedPageInfo
-          } : {}
-        });
-        setTotalCount(seedTotalCount);
-        setData(void 0);
-      } else {
-        setData(nextSeedData);
-        setTotalCount(void 0);
-        setHeadPage(null);
-      }
-      return;
-    }
-    setData(void 0);
-    setHeadPage(null);
-    setTotalCount(void 0);
-    setLoading(true);
-  }, [enabled, ssrEnabled, ssrRuntime, modelName, queryKey, hasSeedData, seedJson, seedPageInfoJson, seedTotalCountStr, isPaginated]);
-  useEffect(() => {
-    if (!enabled) return;
-    const runInitialNetworkQuery = refreshOnMount || !hasSeedData;
-    const runInitialLocalQuery = !hasSeedData && !isPaginated;
-    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" && hasNetworkReply.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 networkPageInfo = context.source === "network" ? context.pageInfo : void 0;
-      const networkTotalCount = context.source === "network" ? context.totalCount : void 0;
-      const payloadForHash = isPaginated ? {
-        result,
-        pageInfo: networkPageInfo,
-        totalCount: networkTotalCount
-      } : 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) {
-        setHeadPage({
-          nodes: result,
-          ...networkPageInfo ? {
-            pageInfo: networkPageInfo
-          } : {}
-        });
-        setTotalCount((current) => networkTotalCount === void 0 ? current : networkTotalCount);
-        return;
-      }
-      setData(result);
-      setTotalCount(void 0);
-    }, {
-      runInitialNetworkQuery,
-      runInitialLocalQuery
-    });
-    return () => {
-      unsubscribe?.();
-    };
-  }, [enabled, modelName, queryKey, queryJson, projectionJson, sortJson, limitStr, populateJson, paginationJson, hasSeedData, refreshOnMount, isPaginated]);
-  const effectivePageInfo = useMemo(() => {
-    if (!isPaginated) return void 0;
-    const firstPageInfo = previousPages.length > 0 ? previousPages[0]?.pageInfo : headPage?.pageInfo;
-    const lastPageInfo = nextPages.length > 0 ? nextPages[nextPages.length - 1]?.pageInfo : headPage?.pageInfo;
-    if (!firstPageInfo && !lastPageInfo) return void 0;
-    const hasPrevPage = Boolean(firstPageInfo?.hasPrevPage);
-    const hasNextPage = Boolean(lastPageInfo?.hasNextPage);
-    const prevCursor = firstPageInfo?.prevCursor;
-    const nextCursor = lastPageInfo?.nextCursor;
-    return {
-      hasPrevPage,
-      hasNextPage,
-      ...prevCursor ? {
-        prevCursor
-      } : {},
-      ...nextCursor ? {
-        nextCursor
-      } : {}
-    };
-  }, [headPage, isPaginated, nextPages, previousPages]);
-  const mergedPaginatedData = useMemo(() => {
-    if (!isPaginated) return void 0;
-    if (!headPage && previousPages.length === 0 && nextPages.length === 0) return void 0;
-    return flattenLoadedPages(previousPages, headPage, nextPages);
-  }, [headPage, isPaginated, nextPages, previousPages]);
-  const fetchNext = async () => {
-    if (!enabled || !isPaginated || !options.pagination) return false;
-    if (pagingDirectionRef.current) return false;
-    const currentHead = headPageRef.current;
-    const currentNextPages = nextPagesRef.current;
-    const cursor = currentNextPages.length > 0 ? currentNextPages[currentNextPages.length - 1]?.pageInfo?.nextCursor : currentHead?.pageInfo?.nextCursor;
-    const hasNextPage_0 = currentNextPages.length > 0 ? Boolean(currentNextPages[currentNextPages.length - 1]?.pageInfo?.hasNextPage) : Boolean(currentHead?.pageInfo?.hasNextPage);
-    if (!cursor || !hasNextPage_0) return false;
-    setPagingDirection("next");
-    setLoading(true);
-    setError(void 0);
-    try {
-      const response = await runNetworkQuery({
-        modelName,
-        query,
-        options: {
-          key,
-          projection: options.projection,
-          sort: options.sort,
-          limit: options.limit,
-          populate: options.populate,
-          pagination: {
-            ...options.pagination,
-            direction: "next",
-            cursor
-          }
-        }
-      });
-      if (!Array.isArray(response.data)) return false;
-      const page = {
-        nodes: response.data,
-        ...response.context.source === "network" && response.context.pageInfo ? {
-          pageInfo: response.context.pageInfo
-        } : {}
-      };
-      setSource("network");
-      if (response.context.source === "network" && response.context.totalCount !== void 0) {
-        setTotalCount(response.context.totalCount);
-      }
-      setNextPages((current_0) => [...current_0, page]);
-      return true;
-    } catch (err_0) {
-      setError(err_0);
-      return false;
-    } finally {
-      setPagingDirection(null);
-      setLoading(false);
-    }
-  };
-  const fetchPrevious = async () => {
-    if (!enabled || !isPaginated || !options.pagination) return false;
-    if (pagingDirectionRef.current) return false;
-    const currentHead_0 = headPageRef.current;
-    const currentPreviousPages = previousPagesRef.current;
-    const cursor_0 = currentPreviousPages.length > 0 ? currentPreviousPages[0]?.pageInfo?.prevCursor : currentHead_0?.pageInfo?.prevCursor;
-    const hasPrevPage_0 = currentPreviousPages.length > 0 ? Boolean(currentPreviousPages[0]?.pageInfo?.hasPrevPage) : Boolean(currentHead_0?.pageInfo?.hasPrevPage);
-    if (!cursor_0 || !hasPrevPage_0) return false;
-    setPagingDirection("prev");
-    setLoading(true);
-    setError(void 0);
-    try {
-      const response_0 = await runNetworkQuery({
-        modelName,
-        query,
-        options: {
-          key,
-          projection: options.projection,
-          sort: options.sort,
-          limit: options.limit,
-          populate: options.populate,
-          pagination: {
-            ...options.pagination,
-            direction: "prev",
-            cursor: cursor_0
-          }
-        }
-      });
-      if (!Array.isArray(response_0.data)) return false;
-      const page_0 = {
-        nodes: response_0.data,
-        ...response_0.context.source === "network" && response_0.context.pageInfo ? {
-          pageInfo: response_0.context.pageInfo
-        } : {}
-      };
-      setSource("network");
-      if (response_0.context.source === "network" && response_0.context.totalCount !== void 0) {
-        setTotalCount(response_0.context.totalCount);
-      }
-      setPreviousPages((current_1) => [page_0, ...current_1]);
-      return true;
-    } catch (err_1) {
-      setError(err_1);
-      return false;
-    } finally {
-      setPagingDirection(null);
-      setLoading(false);
-    }
-  };
-  const resetPagination = () => {
-    if (!isPaginated) return;
-    setPreviousPages([]);
-    setNextPages([]);
-  };
-  return useMemo(() => ({
-    data: isPaginated ? mergedPaginatedData : data,
-    pageInfo: effectivePageInfo,
-    totalCount: isPaginated ? totalCount : void 0,
-    source,
-    error,
-    loading,
-    fetchNext,
-    fetchPrevious,
-    resetPagination
-  }), [data, effectivePageInfo, error, fetchNext, fetchPrevious, isPaginated, loading, mergedPaginatedData, source, totalCount]);
-};
-export {
-  RtsSsrRuntimeProvider as R,
-  STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY as S,
-  destroyCollection as a,
-  deleteDocs as b,
-  configureRtsPouchStore as c,
-  destroyAllCollections as d,
-  runQuery as e,
-  addLocalTxn as f,
-  getCollection as g,
-  connect as h,
-  disconnect as i,
-  reconnect as j,
-  registerQuery as k,
-  runNetworkQuery as l,
-  syncRtsChanges as m,
-  hydrateRtsFromWindow as n,
-  onMessage as o,
-  clearHydratedRtsQueryData as p,
-  peekHydratedRtsQueryData as q,
-  resetRtsPouchStore as r,
-  sendMessage as s,
-  peekHydratedRtsQueryPageInfo as t,
-  updateDocs as u,
-  peekHydratedRtsQueryTotalCount as v,
-  useQuery as w
-};
-//# sourceMappingURL=useQuery-XvXbEwG_.js.map