@rpcbase/client 0.405.0 → 0.407.0

package/dist/rts-C9dMrcRZ.js

@@ -0,0 +1,1991 @@
+import { c } from "react/compiler-runtime";
+import { createContext, useContext, useEffect, useId, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/rts/ssrHydration.tsx
+var STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY = "__staticRpcbaseRtsHydrationData";
+var RtsSsrRuntimeContext = createContext(null);
+var hydrationDataStore = /* @__PURE__ */ new Map();
+var hydrationPageInfoStore = /* @__PURE__ */ new Map();
+var hydrationTotalCountStore = /* @__PURE__ */ new Map();
+var makeStoreKey = (modelName, queryKey) => `${modelName}.${queryKey}`;
+var normalizeStringOrNull = (value) => {
+	if (typeof value !== "string") return null;
+	const normalized = value.trim();
+	return normalized ? normalized : null;
+};
+var 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 } : {}
+	};
+};
+var normalizeTotalCount$2 = (value) => {
+	if (typeof value !== "number") return void 0;
+	if (!Number.isFinite(value) || value < 0) return void 0;
+	return Math.floor(value);
+};
+var 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
+	};
+};
+var 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);
+	}
+};
+var peekHydratedRtsQueryData = (modelName, queryKey) => {
+	return hydrationDataStore.get(makeStoreKey(modelName, queryKey));
+};
+var peekHydratedRtsQueryPageInfo = (modelName, queryKey) => {
+	return hydrationPageInfoStore.get(makeStoreKey(modelName, queryKey));
+};
+var peekHydratedRtsQueryTotalCount = (modelName, queryKey) => {
+	return hydrationTotalCountStore.get(makeStoreKey(modelName, queryKey));
+};
+var consumeHydratedRtsQueryData = (modelName, queryKey) => {
+	const key = makeStoreKey(modelName, queryKey);
+	hydrationDataStore.delete(key);
+	hydrationPageInfoStore.delete(key);
+	hydrationTotalCountStore.delete(key);
+};
+var clearHydratedRtsQueryData = () => {
+	hydrationDataStore.clear();
+	hydrationPageInfoStore.clear();
+	hydrationTotalCountStore.clear();
+};
+var 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;
+};
+var useRtsSsrRuntime = () => {
+	return useContext(RtsSsrRuntimeContext);
+};
+//#endregion
+//#region src/rts/runtimeStorage.ts
+var memoryStore = /* @__PURE__ */ new Map();
+var reactNativeStorage = null;
+var MMKV_STORAGE_ID = "rpcbase-rts";
+var memoryStorage = {
+	getItem: (key) => memoryStore.get(key) ?? null,
+	setItem: (key, value) => {
+		memoryStore.set(key, String(value));
+	},
+	removeItem: (key) => {
+		memoryStore.delete(key);
+	}
+};
+var 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)
+	};
+};
+var isReactNativeRuntime = () => {
+	if (typeof navigator === "undefined") return false;
+	return navigator.product === "ReactNative";
+};
+var getRuntimeRequire = () => {
+	const globalRequire = globalThis.require;
+	if (typeof globalRequire === "function") return globalRequire;
+	try {
+		return (0, eval)("require");
+	} catch {
+		return null;
+	}
+};
+var 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;
+};
+var 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;
+};
+//#endregion
+//#region src/rts/pouchStore.ts
+var UNDERSCORE_PREFIX = "$_";
+var DEFAULT_FIND_LIMIT = 4096;
+var INDEXED_DB_ADAPTER = "indexeddb";
+var REACT_NATIVE_SQLITE_ADAPTER = "react-native-sqlite";
+var storeConfig = null;
+var pouchDbPromise = null;
+var lastAppliedPrefix = null;
+var activePouchAdapter = INDEXED_DB_ADAPTER;
+var collections = /* @__PURE__ */ new Map();
+var dbNamesByPrefix = /* @__PURE__ */ new Map();
+var unwrapDefault = (mod) => {
+	if (!mod || typeof mod !== "object") return mod;
+	return mod.default ?? mod;
+};
+var computeBasePrefix = ({ tenantId, appName }) => {
+	let prefix = "rb/";
+	if (appName) prefix += `${appName}/`;
+	prefix += `${tenantId}/`;
+	return prefix;
+};
+var getDbNamesKey = (prefix) => `rb:rts:pouchDbs:${prefix}`;
+var getPrefixOverrideKey = ({ tenantId, appName }) => `rb:rts:pouchPrefix:${appName ?? ""}:${tenantId}`;
+var 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;
+	}
+};
+var 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
+	});
+	return readPrefixOverride({
+		tenantId: storeConfig.tenantId,
+		appName: storeConfig.appName
+	}) ?? basePrefix;
+};
+var 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;
+};
+var 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;
+	}
+};
+var registerDbName = (prefix, dbName) => {
+	if (!prefix || !dbName) return;
+	const names = loadDbNames(prefix);
+	if (names.has(dbName)) return;
+	names.add(dbName);
+	persistDbNames(prefix, names);
+};
+var unregisterDbName = (prefix, dbName) => {
+	if (!prefix || !dbName) return;
+	const names = loadDbNames(prefix);
+	if (!names.delete(dbName)) return;
+	persistDbNames(prefix, names);
+};
+var 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;
+};
+var applyPrefix = (PouchDB) => {
+	const prefix = getPrefix();
+	if (prefix === lastAppliedPrefix) return;
+	PouchDB.prefix = prefix;
+	lastAppliedPrefix = prefix;
+};
+var configureRtsPouchStore = (config) => {
+	storeConfig = config;
+	lastAppliedPrefix = null;
+	collections.clear();
+};
+var 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;
+};
+var 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;
+};
+var 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;
+};
+var 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;
+};
+var 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;
+};
+var 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;
+};
+var 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]];
+};
+var cloneDoc = (doc) => {
+	try {
+		return structuredClone(doc);
+	} catch {
+		return JSON.parse(JSON.stringify(doc));
+	}
+};
+var 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;
+};
+var 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 projected = {};
+		for (const key of includeKeys) {
+			const value = getValueAtPath(doc, key);
+			if (value !== void 0) setValueAtPath(projected, key, value);
+		}
+		if (spec._id !== 0 && Object.hasOwn(doc, "_id")) projected._id = doc._id;
+		return projected;
+	}
+	const projected = cloneDoc(doc);
+	for (const key of excludeKeys) unsetValueAtPath(projected, key);
+	return projected;
+};
+var 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;
+};
+var 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 : "";
+};
+var 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);
+};
+var matchesSimpleQuery = (doc, query) => {
+	for (const [key, expected] of Object.entries(query)) {
+		if (key.startsWith("$")) return null;
+		const matched = matchValue(getValueAtPath(doc, key), expected);
+		if (matched === null) return null;
+		if (!matched) return false;
+	}
+	return true;
+};
+var 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;
+};
+var 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
+	};
+};
+var runQuery = async ({ modelName, query = {}, options }) => {
+	const result = await runQueryInternal({
+		modelName,
+		query,
+		options
+	});
+	return {
+		data: result.data,
+		context: result.context
+	};
+};
+var addWriteDoc = (writes, modelName, doc) => {
+	const docsById = writes.get(modelName) ?? /* @__PURE__ */ new Map();
+	docsById.set(doc._id, doc);
+	writes.set(modelName, docsById);
+};
+var 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 id = extractDocId(candidate);
+				if (!id) continue;
+				ids.push(id);
+				if (!entry.model) continue;
+				if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
+				const candidateDoc = candidate;
+				const nested = entry.populate?.length ? sanitizePopulatedDoc(candidateDoc, entry.populate, writes) : cloneDoc(candidateDoc);
+				addWriteDoc(writes, entry.model, nested);
+			}
+			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;
+};
+var updatePopulatedDocs = async ({ modelName, data, uid, populate }) => {
+	if (!data.length) return;
+	const writes = /* @__PURE__ */ new Map();
+	await updateDocs(modelName, data.map((doc) => sanitizePopulatedDoc(doc, populate, writes)), uid);
+	for (const [targetModelName, docsById] of writes.entries()) {
+		if (!docsById.size) continue;
+		await updateDocs(targetModelName, Array.from(docsById.values()), uid);
+	}
+};
+var 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 { docs } = await (await getCollection(modelName, { uid })).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
+	};
+};
+var 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
+	};
+};
+var 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 hydrated = await hydratePopulateEntries({
+		docs: rootResult.data.map((doc) => applyProjection(doc, options.projection)).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
+	};
+};
+var 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);
+};
+var 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);
+};
+var 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();
+};
+var 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);
+	(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) => {
+				await new PouchDBForPrefix(name, {
+					adapter: activePouchAdapter,
+					revs_limit: 1
+				}).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;
+};
+var destroyAllCollections = async () => {
+	const dbs = Array.from(collections.values());
+	await Promise.all(dbs.map((db) => db.destroy()));
+	collections.clear();
+};
+//#endregion
+//#region src/rts/populateCache.ts
+var EXCLUDE_PROJECTION_ERROR = "must be include-only (value 1); exclusion projection is not supported";
+var sortProjectionSpec = (projection) => {
+	const sorted = {};
+	for (const key of Object.keys(projection).sort()) sorted[key] = projection[key];
+	return sorted;
+};
+var 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;
+};
+var 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;
+};
+var normalizePopulateSelect = (value, source) => {
+	if (typeof value === "string") return normalizeSelectString(value, source);
+	return normalizeProjectionSpec(value, source, "populate select");
+};
+var 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;
+};
+var normalizeString = (value) => {
+	if (typeof value !== "string") return void 0;
+	return value.trim() || void 0;
+};
+var normalizeObject = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	return value;
+};
+var 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 } : {}
+	};
+};
+var 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)];
+};
+var 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
+	};
+};
+//#endregion
+//#region src/rts/queryKey.ts
+var 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}`;
+};
+//#endregion
+//#region src/rts/wsClient.ts
+var TENANT_ID_QUERY_PARAM = "rb-tenant-id";
+var RTS_CHANGES_PATH = "/api/rb/rts/changes";
+var MAX_TXN_BUF = 2048;
+var SERVER_RECONNECT_DELAY_MIN_MS = 1e4;
+var SERVER_RECONNECT_DELAY_MAX_MS = 15e3;
+var RUN_NETWORK_QUERY_TIMEOUT_ERROR = "runNetworkQuery: request timed out";
+var socket = null;
+var connectPromise = null;
+var explicitDisconnect = false;
+var currentTenantId = null;
+var currentUid = null;
+var connectOptions = {};
+var localTxnBuf = [];
+var queryCallbacks = /* @__PURE__ */ new Map();
+var subscriptions = /* @__PURE__ */ new Map();
+var messageCallbacks = /* @__PURE__ */ new Map();
+var reconnectTimer = null;
+var reconnectAttempts = 0;
+var hasEstablishedConnection = false;
+var pendingServerReconnectJitter = false;
+var syncPromise = null;
+var syncKey = null;
+var 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");
+};
+var ensureSyncRuntime = () => {
+	if (typeof fetch !== "function") throw new Error("syncRtsChanges requires fetch support");
+};
+var 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;
+};
+var setRuntimeTimeout = (handler, delayMs) => {
+	return globalThis.setTimeout(handler, delayMs);
+};
+var clearRuntimeTimeout = (timer) => {
+	globalThis.clearTimeout(timer);
+};
+var 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;
+};
+var resolveApiOriginUrl = ({ url }) => {
+	if (url) {
+		const base = new URL(url);
+		if (base.protocol === "ws:") base.protocol = "http:";
+		else if (base.protocol === "wss:") base.protocol = "https:";
+		base.pathname = "/";
+		base.search = "";
+		base.hash = "";
+		return base;
+	}
+	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;
+};
+var 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();
+};
+var 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();
+};
+var sendToServer = (message) => {
+	if (!socket) return;
+	if (socket.readyState !== WebSocket.OPEN) return;
+	socket.send(JSON.stringify(message));
+};
+var 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
+		});
+	}
+};
+var clearReconnectTimer = () => {
+	if (reconnectTimer === null) return;
+	clearRuntimeTimeout(reconnectTimer);
+	reconnectTimer = null;
+};
+var 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(() => {
+		connectInternal(currentTenantId, currentUid, connectOptions, { resetReconnectAttempts: false });
+	}, delay);
+};
+var isDocWithId = (doc) => {
+	if (!doc || typeof doc !== "object") return false;
+	return typeof doc._id === "string";
+};
+var 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 } : {}
+	};
+};
+var normalizeTotalCount$1 = (value) => {
+	if (typeof value !== "number") return void 0;
+	if (!Number.isFinite(value) || value < 0) return void 0;
+	return Math.floor(value);
+};
+var 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 context = {
+		source: "network",
+		isLocal: !!(txnId && localTxnBuf.includes(txnId)),
+		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) {
+		updatePopulatedDocs({
+			modelName,
+			data: docs,
+			uid: currentUid,
+			populate: populateCache.populate
+		}).catch(() => {});
+		return;
+	}
+	updateDocs(modelName, docs, currentUid).catch(() => {});
+};
+var handleEvent = (payload) => {
+	const callbacks = messageCallbacks.get(payload.event);
+	if (!callbacks || !callbacks.size) return;
+	for (const cb of callbacks) cb(payload.payload);
+};
+var 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);
+};
+var addLocalTxn = (txnId) => {
+	if (!txnId) return;
+	localTxnBuf.push(txnId);
+	if (localTxnBuf.length > MAX_TXN_BUF) localTxnBuf.shift();
+};
+var getSyncStorageKey = ({ tenantId, uid, appName }) => `rb:rts:changesSeq:${appName ?? ""}:${tenantId}:${uid}`;
+var 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;
+	}
+};
+var writeStoredSeq = (key, value) => {
+	const storage = getRuntimeStorage();
+	try {
+		storage.setItem(key, String(Math.max(0, Math.floor(value))));
+	} catch {
+		return;
+	}
+};
+var 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(() => {});
+	}
+};
+var 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;
+		if (payloadObj.ok !== true) return;
+		const latestSeq = Number(payloadObj.latestSeq ?? 0);
+		if (Boolean(payloadObj.needsFullResync)) {
+			resetRtsPouchStore({
+				tenantId,
+				appName: options.appName
+			});
+			writeStoredSeq(storageKey, latestSeq);
+			return;
+		}
+		const changesRaw = payloadObj.changes;
+		const normalized = (Array.isArray(changesRaw) ? changesRaw : []).map((c) => {
+			if (!c || typeof c !== "object") return null;
+			const obj = c;
+			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((c) => c !== null).filter((c) => Number.isFinite(c.seq) && c.seq > 0 && c.modelName && (c.op === "reset_model" || !!c.docId));
+		if (!normalized.length) {
+			writeStoredSeq(storageKey, latestSeq);
+			return;
+		}
+		await applyChangeBatch(normalized, uid);
+		sinceSeq = normalized.reduce((max, c) => c.seq > max ? c.seq : max, sinceSeq);
+		writeStoredSeq(storageKey, sinceSeq);
+		if (latestSeq > 0 && sinceSeq >= latestSeq) return;
+	}
+};
+var 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;
+	});
+};
+var 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;
+			resubscribeAll({ forceInitialQuery: hasEstablishedConnection });
+			hasEstablishedConnection = true;
+			resolve();
+		});
+		socket.addEventListener("message", handleMessage);
+		socket.addEventListener("close", (event) => {
+			if (!opened && !settled) {
+				settled = true;
+				reject(/* @__PURE__ */ 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 : /* @__PURE__ */ new Error("RTS WebSocket error"));
+		});
+	});
+	return connectPromise;
+};
+var connect = (tenantId, uid, options = {}) => {
+	return connectInternal(tenantId, uid, options, { resetReconnectAttempts: true });
+};
+var disconnect = () => {
+	explicitDisconnect = true;
+	clearReconnectTimer();
+	hasEstablishedConnection = false;
+	pendingServerReconnectJitter = false;
+	if (socket) try {
+		socket.close();
+	} catch {}
+	socket = null;
+	connectPromise = null;
+};
+var reconnect = (tenantId, uid, options = {}) => {
+	explicitDisconnect = true;
+	clearReconnectTimer();
+	pendingServerReconnectJitter = false;
+	if (socket) try {
+		socket.close();
+	} catch {}
+	socket = null;
+	connectPromise = null;
+	return connect(tenantId, uid, options);
+};
+var 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) 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 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);
+		}
+	};
+};
+var makeRunQueryKey = () => `run-query.${Date.now().toString(36)}.${Math.random().toString(36).slice(2, 10)}`;
+var 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 callbacks = queryCallbacks.get(cbKey);
+			callbacks?.delete(callback);
+			if (callbacks && callbacks.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
+		});
+	});
+};
+var sendMessage = (event, payload) => {
+	sendToServer({
+		type: "event",
+		event,
+		payload
+	});
+};
+var 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);
+	};
+};
+//#endregion
+//#region src/rts/useQuery.ts
+var 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 } : {}
+	};
+};
+var normalizeTotalCount = (value) => {
+	if (typeof value !== "number") return void 0;
+	if (!Number.isFinite(value) || value < 0) return void 0;
+	return Math.floor(value);
+};
+var getDocId = (doc) => {
+	if (!doc || typeof doc !== "object") return "";
+	const id = doc._id;
+	return typeof id === "string" ? id.trim() : "";
+};
+var 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;
+};
+var 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);
+};
+var 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");
+	}
+};
+var 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
+	]);
+};
+//#endregion
+export { peekHydratedRtsQueryData as C, hydrateRtsFromWindow as S, peekHydratedRtsQueryTotalCount as T, runQuery as _, onMessage as a, STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY as b, runNetworkQuery as c, configureRtsPouchStore as d, deleteDocs as f, resetRtsPouchStore as g, getCollection as h, disconnect as i, sendMessage as l, destroyCollection as m, addLocalTxn as n, reconnect as o, destroyAllCollections as p, connect as r, registerQuery as s, useQuery as t, syncRtsChanges as u, updateDocs as v, peekHydratedRtsQueryPageInfo as w, clearHydratedRtsQueryData as x, RtsSsrRuntimeProvider as y };
+
+//# sourceMappingURL=rts-C9dMrcRZ.js.map