@rpcbase/client 0.415.0 → 0.417.0

package/dist/useQuery-NQNva6kg.js

@@ -0,0 +1,2573 @@
+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 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 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";
+const RUN_NETWORK_COUNT_TIMEOUT_ERROR = "runNetworkCount: 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 countCallbacks = /* @__PURE__ */ new Map();
+const subscriptions = /* @__PURE__ */ new Map();
+const countSubscriptions = /* @__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;
+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);
+  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
+    });
+  }
+  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 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 handleCountPayload = (payload) => {
+  const {
+    modelName,
+    queryKey,
+    count,
+    error,
+    txnId
+  } = payload;
+  const cbKey = `${modelName}.${queryKey}`;
+  const callbacks = countCallbacks.get(cbKey);
+  if (!callbacks || !callbacks.size) return;
+  const isLocal = !!(txnId && localTxnBuf.includes(txnId));
+  const context = {
+    source: "network",
+    isLocal,
+    txnId
+  };
+  if (error) {
+    for (const cb of callbacks) cb(error, void 0, context);
+    return;
+  }
+  const normalizedCount = normalizeTotalCount$1(count);
+  for (const cb of callbacks) cb(null, normalizedCount, context);
+};
+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 === "count-payload") {
+    handleCountPayload(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;
+    setConnectionStatus("connecting");
+    socket = new WebSocket(url);
+    socket.addEventListener("open", () => {
+      opened = true;
+      settled = true;
+      reconnectAttempts = 0;
+      pendingServerReconnectJitter = false;
+      setConnectionStatus("connected");
+      const forceInitialQuery = hasEstablishedConnection;
+      resubscribeAll({
+        forceInitialQuery
+      });
+      hasEstablishedConnection = true;
+      resolve();
+    });
+    socket.addEventListener("message", handleMessage);
+    socket.addEventListener("close", (event) => {
+      if (!opened && !settled) {
+        settled = true;
+        const error = new Error(`RTS WebSocket closed before opening (code=${event.code})`);
+        setConnectionStatus("error", error);
+        reject(error);
+      }
+      if (!explicitDisconnect) {
+        pendingServerReconnectJitter = opened;
+        setConnectionStatus("connecting", connectionError);
+      } else {
+        setConnectionStatus("idle");
+      }
+      socket = null;
+      connectPromise = null;
+      scheduleReconnect();
+    });
+    socket.addEventListener("error", (err) => {
+      if (settled) return;
+      settled = true;
+      const error = err instanceof Error ? err : new Error("RTS WebSocket error");
+      setConnectionStatus("error", error);
+      reject(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;
+  setConnectionStatus("idle");
+};
+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 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 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 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 set = countCallbacks.get(cbKey) ?? /* @__PURE__ */ new Set();
+  set.add(callback);
+  countCallbacks.set(cbKey, set);
+  countSubscriptions.set(cbKey, {
+    modelName,
+    query,
+    options,
+    queryKey,
+    runInitialNetworkQuery
+  });
+  sendToServer({
+    type: "register-count",
+    modelName,
+    queryKey,
+    query,
+    options,
+    runInitialQuery: runInitialNetworkQuery
+  });
+  return () => {
+    const callbacks = countCallbacks.get(cbKey);
+    callbacks?.delete(callback);
+    if (callbacks && callbacks.size === 0) {
+      countCallbacks.delete(cbKey);
+      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 (!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_COUNT_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 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 (!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_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 ? 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 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 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 {
+  runNetworkCount as A,
+  runNetworkQuery as B,
+  runQuery as C,
+  sendMessage as D,
+  syncRtsChanges as E,
+  updateDocs as F,
+  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,
+  addLocalTxn as i,
+  configureRtsPouchStore as j,
+  connect as k,
+  deleteDocs as l,
+  destroyAllCollections as m,
+  destroyCollection as n,
+  disconnect as o,
+  peekHydratedRtsCount as p,
+  getCollection as q,
+  registerCount as r,
+  getConnectionError as s,
+  getConnectionStatus as t,
+  useQuery as u,
+  onConnectionStatusChange as v,
+  onMessage as w,
+  reconnect as x,
+  registerQuery as y,
+  resetRtsPouchStore as z
+};
+//# sourceMappingURL=useQuery-NQNva6kg.js.map