@rpcbase/client 0.465.0 → 0.466.0

package/dist/rts-C9lvbdZX.js

@@ -0,0 +1,3161 @@
+import { c } from "react/compiler-runtime";
+import { createContext, useContext, useEffect, 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 hydrationCountStore = /* @__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 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
+	};
+};
+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();
+	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);
+};
+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 peekHydratedRtsCount = (modelName, queryKey) => {
+	return hydrationCountStore.get(makeStoreKey(modelName, queryKey));
+};
+var consumeHydratedRtsQueryData = (modelName, queryKey) => {
+	const key = makeStoreKey(modelName, queryKey);
+	hydrationDataStore.delete(key);
+	hydrationPageInfoStore.delete(key);
+	hydrationTotalCountStore.delete(key);
+};
+var consumeHydratedRtsCount = (modelName, queryKey) => {
+	hydrationCountStore.delete(makeStoreKey(modelName, queryKey));
+};
+var clearHydratedRtsQueryData = () => {
+	hydrationDataStore.clear();
+	hydrationPageInfoStore.clear();
+	hydrationTotalCountStore.clear();
+	hydrationCountStore.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/queryWindow.ts
+var RTS_QUERY_WINDOW_MAX_COUNT = 4096;
+//#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 QUERY_WINDOW_COLLECTION = "$query-windows-v1";
+var QUERY_WINDOW_DOC_TYPE = "rts-query-window";
+var QUERY_WINDOW_SCHEMA_VERSION = 1;
+var QUERY_WINDOW_TTL_MS = 10080 * 60 * 1e3;
+var QUERY_WINDOW_WRITE_ATTEMPTS = 4;
+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, 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 prefix = getPrefix();
+	const PouchDB = await getPouchDb();
+	applyPrefix(PouchDB, prefix);
+	const dbName = `${options.uid}/${modelName}`;
+	const dbKey = `${prefix}${dbName}`;
+	const existing = collections.get(dbKey);
+	if (existing) return existing;
+	registerDbName(prefix, dbName);
+	const db = new PouchDB(dbName, {
+		adapter: activePouchAdapter,
+		revs_limit: 1
+	});
+	collections.set(dbKey, db);
+	return db;
+};
+var getQueryWindowScope = (uid) => {
+	if (!storeConfig) throw new Error("RTS PouchDB store is not configured");
+	return {
+		appName: storeConfig.appName ?? "",
+		tenantId: storeConfig.tenantId,
+		uid
+	};
+};
+var getQueryWindowFingerprint = (scope, modelName, queryKey) => JSON.stringify([
+	QUERY_WINDOW_SCHEMA_VERSION,
+	scope.appName,
+	scope.tenantId,
+	scope.uid,
+	modelName,
+	queryKey
+]);
+var getQueryWindowDocumentId = (fingerprint) => `${QUERY_WINDOW_DOC_TYPE}:${encodeURIComponent(fingerprint)}`;
+var getPouchErrorStatus = (error) => {
+	if (!error || typeof error !== "object") return void 0;
+	const status = error.status;
+	return typeof status === "number" && Number.isFinite(status) ? status : void 0;
+};
+var getPouchDocument = async (collection, id) => {
+	try {
+		return await collection.get(id);
+	} catch (error) {
+		if (getPouchErrorStatus(error) === 404) return null;
+		throw error;
+	}
+};
+var normalizeQueryWindowPageInfo = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const raw = value;
+	if (typeof raw.hasNextPage !== "boolean" || typeof raw.hasPrevPage !== "boolean") return null;
+	if (raw.nextCursor !== void 0 && typeof raw.nextCursor !== "string") return null;
+	if (raw.prevCursor !== void 0 && typeof raw.prevCursor !== "string") return null;
+	const nextCursor = typeof raw.nextCursor === "string" && raw.nextCursor ? raw.nextCursor : void 0;
+	const prevCursor = typeof raw.prevCursor === "string" && raw.prevCursor ? raw.prevCursor : void 0;
+	return {
+		hasNextPage: raw.hasNextPage,
+		hasPrevPage: raw.hasPrevPage,
+		...nextCursor ? { nextCursor } : {},
+		...prevCursor ? { prevCursor } : {}
+	};
+};
+var isValidQueryWindowServerVersion = (value) => {
+	return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+};
+var isQueryWindowData = (value) => Array.isArray(value) && value.every((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+var parseQueryWindowSnapshot = (doc, expected) => {
+	if (doc.type !== QUERY_WINDOW_DOC_TYPE || doc.schemaVersion !== QUERY_WINDOW_SCHEMA_VERSION) return null;
+	if (doc.fingerprint !== expected.fingerprint) return null;
+	if (doc.modelName !== expected.modelName || doc.queryKey !== expected.queryKey) return null;
+	const scope = doc.scope;
+	if (!scope || typeof scope !== "object" || Array.isArray(scope)) return null;
+	const rawScope = scope;
+	if (rawScope.appName !== expected.scope.appName || rawScope.tenantId !== expected.scope.tenantId || rawScope.uid !== expected.scope.uid) return null;
+	if (!isQueryWindowData(doc.data)) return null;
+	const pageInfo = normalizeQueryWindowPageInfo(doc.pageInfo);
+	if (!pageInfo) return null;
+	const requestedCount = doc.requestedCount;
+	if (!Number.isSafeInteger(requestedCount) || requestedCount <= 0 || requestedCount > 4096 || doc.data.length > requestedCount) return null;
+	const storedAt = doc.storedAt;
+	if (typeof storedAt !== "number" || !Number.isFinite(storedAt) || storedAt < 0) return null;
+	const totalCount = doc.totalCount;
+	if (totalCount !== void 0 && (!Number.isSafeInteger(totalCount) || totalCount < 0)) return null;
+	const serverVersion = doc.serverVersion;
+	if (serverVersion !== void 0 && !isValidQueryWindowServerVersion(serverVersion)) return null;
+	const serverEpoch = doc.serverEpoch;
+	if (serverEpoch !== void 0 && (typeof serverEpoch !== "string" || !serverEpoch)) return null;
+	if (serverEpoch === void 0 !== (serverVersion === void 0)) return null;
+	return {
+		data: doc.data,
+		pageInfo,
+		...typeof totalCount === "number" ? { totalCount } : {},
+		requestedCount,
+		...serverEpoch !== void 0 ? { serverEpoch } : {},
+		...serverVersion !== void 0 ? { serverVersion } : {},
+		storedAt
+	};
+};
+var deleteQueryWindowDocument = async (collection, doc) => {
+	const id = typeof doc._id === "string" ? doc._id : "";
+	const rev = typeof doc._rev === "string" ? doc._rev : "";
+	if (!id || !rev) return;
+	await collection.put({
+		_id: id,
+		_rev: rev,
+		_deleted: true
+	}).catch(() => void 0);
+};
+var readQueryWindowSnapshot = async ({ modelName, queryKey, uid, now = Date.now() }) => {
+	const scope = getQueryWindowScope(uid);
+	const fingerprint = getQueryWindowFingerprint(scope, modelName, queryKey);
+	const id = getQueryWindowDocumentId(fingerprint);
+	const collection = await getCollection(QUERY_WINDOW_COLLECTION, { uid });
+	const doc = await getPouchDocument(collection, id);
+	if (!doc) return { hit: false };
+	const snapshot = parseQueryWindowSnapshot(doc, {
+		fingerprint,
+		scope,
+		modelName,
+		queryKey
+	});
+	if (!snapshot || now - snapshot.storedAt >= QUERY_WINDOW_TTL_MS) {
+		await deleteQueryWindowDocument(collection, doc);
+		return { hit: false };
+	}
+	return {
+		hit: true,
+		snapshot
+	};
+};
+var writeQueryWindowSnapshot = async ({ modelName, queryKey, uid, data, pageInfo: rawPageInfo, totalCount, requestedCount, serverEpoch, serverVersion, storedAt: rawStoredAt }) => {
+	if (!modelName.trim()) throw new Error("writeQueryWindowSnapshot: modelName must be a non-empty string");
+	if (!queryKey) throw new Error("writeQueryWindowSnapshot: queryKey must be a non-empty string");
+	if (!uid.trim()) throw new Error("writeQueryWindowSnapshot: uid must be a non-empty string");
+	if (!isQueryWindowData(data)) throw new Error("writeQueryWindowSnapshot: data must contain objects");
+	const pageInfo = normalizeQueryWindowPageInfo(rawPageInfo);
+	if (!pageInfo) throw new Error("writeQueryWindowSnapshot: invalid pageInfo");
+	if (!Number.isSafeInteger(requestedCount) || requestedCount <= 0 || requestedCount > 4096 || data.length > requestedCount) throw new Error("writeQueryWindowSnapshot: requestedCount must cover data and be between 1 and 4096");
+	if (totalCount !== void 0 && (!Number.isSafeInteger(totalCount) || totalCount < 0)) throw new Error("writeQueryWindowSnapshot: totalCount must be a non-negative integer");
+	if (serverVersion !== void 0 && !isValidQueryWindowServerVersion(serverVersion)) throw new Error("writeQueryWindowSnapshot: invalid serverVersion");
+	if (serverEpoch !== void 0 && (typeof serverEpoch !== "string" || !serverEpoch)) throw new Error("writeQueryWindowSnapshot: invalid serverEpoch");
+	if (serverEpoch === void 0 !== (serverVersion === void 0)) throw new Error("writeQueryWindowSnapshot: serverEpoch and serverVersion must be provided together");
+	const storedAt = rawStoredAt ?? Date.now();
+	if (!Number.isFinite(storedAt) || storedAt < 0) throw new Error("writeQueryWindowSnapshot: storedAt must be a non-negative finite number");
+	const scope = getQueryWindowScope(uid);
+	const fingerprint = getQueryWindowFingerprint(scope, modelName, queryKey);
+	const id = getQueryWindowDocumentId(fingerprint);
+	const collection = await getCollection(QUERY_WINDOW_COLLECTION, { uid });
+	const snapshot = {
+		data,
+		pageInfo,
+		...totalCount !== void 0 ? { totalCount } : {},
+		requestedCount,
+		...serverEpoch !== void 0 ? { serverEpoch } : {},
+		...serverVersion !== void 0 ? { serverVersion } : {},
+		storedAt
+	};
+	let lastConflict;
+	for (let attempt = 0; attempt < QUERY_WINDOW_WRITE_ATTEMPTS; attempt += 1) {
+		const current = await getPouchDocument(collection, id);
+		const currentSnapshot = current ? parseQueryWindowSnapshot(current, {
+			fingerprint,
+			scope,
+			modelName,
+			queryKey
+		}) : null;
+		if (currentSnapshot && (currentSnapshot.serverEpoch === serverEpoch && currentSnapshot.serverVersion !== void 0 && serverVersion !== void 0 && currentSnapshot.serverVersion >= serverVersion || (!serverEpoch || currentSnapshot.serverEpoch !== serverEpoch) && currentSnapshot.storedAt > storedAt)) return currentSnapshot;
+		const rev = typeof current?._rev === "string" ? current._rev : void 0;
+		const doc = {
+			_id: id,
+			...rev ? { _rev: rev } : {},
+			type: QUERY_WINDOW_DOC_TYPE,
+			schemaVersion: QUERY_WINDOW_SCHEMA_VERSION,
+			fingerprint,
+			scope,
+			modelName,
+			queryKey,
+			data,
+			pageInfo,
+			...totalCount !== void 0 ? { totalCount } : {},
+			requestedCount,
+			...serverEpoch !== void 0 ? { serverEpoch } : {},
+			...serverVersion !== void 0 ? { serverVersion } : {},
+			storedAt
+		};
+		try {
+			await collection.put(doc);
+			return snapshot;
+		} catch (error) {
+			if (getPouchErrorStatus(error) !== 409) throw error;
+			lastConflict = error;
+		}
+	}
+	throw lastConflict ?? /* @__PURE__ */ new Error("writeQueryWindowSnapshot: failed to persist snapshot");
+};
+var invalidateQueryWindowSnapshots = async ({ uid, modelName }) => {
+	const collection = await getCollection(QUERY_WINDOW_COLLECTION, { uid });
+	const selector = {
+		type: QUERY_WINDOW_DOC_TYPE,
+		...modelName ? { modelName } : {}
+	};
+	for (let batch = 0; batch < 32; batch += 1) {
+		const { docs } = await collection.find({
+			selector,
+			fields: ["_id", "_rev"],
+			limit: DEFAULT_FIND_LIMIT
+		});
+		const deletions = docs.map((doc) => ({
+			_id: typeof doc._id === "string" ? doc._id : "",
+			_rev: typeof doc._rev === "string" ? doc._rev : "",
+			_deleted: true
+		})).filter((doc) => doc._id && doc._rev);
+		if (!deletions.length) return;
+		const results = await collection.bulkDocs(deletions);
+		if (Array.isArray(results) && results.some((result) => {
+			if (!result || typeof result !== "object") return false;
+			const record = result;
+			return record.error === true || record.status === 409;
+		})) continue;
+		if (docs.length < DEFAULT_FIND_LIMIT) return;
+	}
+};
+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 isRecord = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+var splitPath = (path) => path.split(".").map((part) => part.trim()).filter(Boolean);
+var getKeys = (obj, parentKey = "") => {
+	const keys = [];
+	for (const key of Object.keys(obj)) {
+		const nextKey = parentKey ? `${parentKey}.${key}` : key;
+		const value = obj[key];
+		if (Array.isArray(value)) {
+			const arrayKeys = /* @__PURE__ */ new Set();
+			for (const item of value) if (isRecord(item)) for (const nestedKey of getKeys(item, nextKey)) arrayKeys.add(nestedKey);
+			if (arrayKeys.size > 0) keys.push(...arrayKeys);
+			else keys.push(nextKey);
+		} else if (isRecord(value)) keys.push(...getKeys(value, nextKey));
+		else keys.push(nextKey);
+	}
+	return keys;
+};
+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 collectValuesAtPath = (value, parts, index) => {
+	if (index >= parts.length) return [value];
+	if (Array.isArray(value)) return value.flatMap((item) => collectValuesAtPath(item, parts, index));
+	if (!isRecord(value)) return [void 0];
+	return collectValuesAtPath(value[parts[index]], parts, index + 1);
+};
+var getValueAtPath = (doc, path) => {
+	const parts = splitPath(path);
+	if (!parts.length) return void 0;
+	const values = collectValuesAtPath(doc, parts, 0);
+	if (values.length === 0) return void 0;
+	if (values.length === 1) return values[0];
+	return values;
+};
+var pathCrossesArrayBeforeLeaf = (value, parts, index = 0) => {
+	if (index >= parts.length - 1) return false;
+	if (!isRecord(value)) return false;
+	const next = value[parts[index]];
+	if (Array.isArray(next)) return true;
+	return pathCrossesArrayBeforeLeaf(next, parts, index + 1);
+};
+var assignValueAtPath = (current, parts, index, value, valuesQueue) => {
+	const key = parts[index];
+	if (index === parts.length - 1) {
+		current[key] = valuesQueue ? valuesQueue.shift() : value;
+		return;
+	}
+	const next = current[key];
+	if (Array.isArray(next)) {
+		for (const item of next) if (isRecord(item)) assignValueAtPath(item, parts, index + 1, value, valuesQueue);
+		return;
+	}
+	if (!isRecord(next)) current[key] = {};
+	assignValueAtPath(current[key], parts, index + 1, value, valuesQueue);
+};
+var setValueAtPath = (doc, path, value) => {
+	const parts = splitPath(path);
+	if (!parts.length) return;
+	assignValueAtPath(doc, parts, 0, value, pathCrossesArrayBeforeLeaf(doc, parts) && Array.isArray(value) ? [...value] : void 0);
+};
+var unsetValueAtPathParts = (current, parts, index) => {
+	if (Array.isArray(current)) {
+		for (const item of current) unsetValueAtPathParts(item, parts, index);
+		return;
+	}
+	if (!isRecord(current)) return;
+	const key = parts[index];
+	if (index === parts.length - 1) {
+		delete current[key];
+		return;
+	}
+	unsetValueAtPathParts(current[key], parts, index + 1);
+};
+var unsetValueAtPath = (doc, path) => {
+	const parts = splitPath(path);
+	if (!parts.length) return;
+	unsetValueAtPathParts(doc, parts, 0);
+};
+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 copyValueAtPath = (source, target, parts, index = 0) => {
+	if (!isRecord(source)) return false;
+	const key = parts[index];
+	const sourceValue = source[key];
+	if (sourceValue === void 0) return false;
+	if (index === parts.length - 1) {
+		target[key] = cloneDoc(sourceValue);
+		return true;
+	}
+	if (Array.isArray(sourceValue)) {
+		const existing = Array.isArray(target[key]) ? target[key] : [];
+		let copiedAny = false;
+		const nextArray = sourceValue.map((item, itemIndex) => {
+			const currentTarget = isRecord(existing[itemIndex]) ? existing[itemIndex] : {};
+			if (copyValueAtPath(item, currentTarget, parts, index + 1)) copiedAny = true;
+			return currentTarget;
+		});
+		if (copiedAny || sourceValue.length === 0) {
+			target[key] = nextArray;
+			return true;
+		}
+		return false;
+	}
+	const nextTarget = isRecord(target[key]) ? target[key] : {};
+	if (!copyValueAtPath(sourceValue, nextTarget, parts, index + 1)) return false;
+	target[key] = nextTarget;
+	return true;
+};
+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 parts = splitPath(key);
+			if (parts.length > 0) copyValueAtPath(doc, projected, parts);
+		}
+		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 crossesArray = pathCrossesArrayBeforeLeaf(next, splitPath(entry.path));
+		const value = getValueAtPath(next, entry.path);
+		if (value === void 0) continue;
+		if (Array.isArray(value)) {
+			const ids = [];
+			const nextValues = [];
+			for (const candidate of value) {
+				const id = extractDocId(candidate);
+				if (id) ids.push(id);
+				if (crossesArray) nextValues.push(id || null);
+				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, crossesArray ? nextValues : ids);
+			continue;
+		}
+		const id = extractDocId(value);
+		setValueAtPath(next, entry.path, id || null);
+		if (!id) continue;
+		if (!entry.model) continue;
+		if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+		const valueDoc = value;
+		const nested = entry.populate?.length ? sanitizePopulatedDoc(valueDoc, entry.populate, writes) : cloneDoc(valueDoc);
+		addWriteDoc(writes, entry.model, nested);
+	}
+	return next;
+};
+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 crossesArray = pathCrossesArrayBeforeLeaf(doc, splitPath(entry.path));
+			const rawValue = getValueAtPath(doc, entry.path);
+			const isArray = Array.isArray(rawValue);
+			const values = isArray ? rawValue : [rawValue];
+			const ids = values.map((candidate) => extractDocId(candidate)).filter(Boolean);
+			return {
+				doc,
+				hasValue: rawValue !== void 0,
+				isArray,
+				crossesArray,
+				values,
+				ids
+			};
+		});
+		const allIds = descriptors.flatMap((descriptor) => descriptor.ids);
+		const loaded = await loadProjectedDocsByIds({
+			modelName: entry.model,
+			ids: allIds,
+			uid,
+			projection: entry.select
+		});
+		if (loaded.projectionMismatch) return {
+			hit: false,
+			data: []
+		};
+		let populatedDocsById = loaded.projectedDocsById;
+		if (entry.match) {
+			const filtered = /* @__PURE__ */ new Map();
+			for (const [id, candidate] of loaded.rawDocsById.entries()) {
+				const matched = matchesSimpleQuery(candidate, entry.match);
+				if (matched === null) return {
+					hit: false,
+					data: []
+				};
+				if (!matched) continue;
+				const projected = populatedDocsById.get(id);
+				if (projected) filtered.set(id, projected);
+			}
+			populatedDocsById = filtered;
+		}
+		if (entry.populate?.length) {
+			const nestedResult = await hydratePopulateEntries({
+				docs: Array.from(populatedDocsById.values()).map((candidate) => cloneDoc(candidate)),
+				populate: entry.populate,
+				uid
+			});
+			if (!nestedResult.hit) return {
+				hit: false,
+				data: []
+			};
+			populatedDocsById = nestedResult.data.reduce((acc, candidate) => {
+				const id = extractDocId(candidate);
+				if (id) acc.set(id, candidate);
+				return acc;
+			}, /* @__PURE__ */ new Map());
+		}
+		for (const descriptor of descriptors) {
+			if (!descriptor.hasValue) continue;
+			if (descriptor.isArray && descriptor.crossesArray) {
+				const values = descriptor.values.map((candidate) => {
+					const id = extractDocId(candidate);
+					return id ? populatedDocsById.get(id) ?? null : null;
+				});
+				setValueAtPath(descriptor.doc, entry.path, values);
+				continue;
+			}
+			if (!descriptor.ids.length) {
+				setValueAtPath(descriptor.doc, entry.path, descriptor.isArray ? [] : null);
+				continue;
+			}
+			if (descriptor.isArray) {
+				let values = descriptor.ids.map((id) => populatedDocsById.get(id)).filter((candidate) => Boolean(candidate));
+				if (entry.options?.sort) values = values.sort((a, b) => compareSort(a, b, entry.options.sort));
+				if (typeof entry.options?.limit === "number" && Number.isFinite(entry.options.limit)) values = values.slice(0, Math.max(0, Math.floor(Math.abs(entry.options.limit))));
+				setValueAtPath(descriptor.doc, entry.path, values);
+				continue;
+			}
+			const value = populatedDocsById.get(descriptor.ids[0]);
+			setValueAtPath(descriptor.doc, entry.path, value ?? null);
+		}
+	}
+	return {
+		hit: true,
+		data: currentDocs
+	};
+};
+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 isPlainObject = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+var serializeRtsQueryValue = (value) => {
+	return JSON.stringify(value, (_key, currentValue) => {
+		if (!isPlainObject(currentValue)) return currentValue;
+		return Object.keys(currentValue).sort().reduce((acc, key) => {
+			acc[key] = currentValue[key];
+			return acc;
+		}, {});
+	}) ?? "";
+};
+var computeRtsQueryKey = (query, options) => {
+	return serializeRtsQueryValue({
+		version: 2,
+		key: options.key ?? null,
+		query,
+		projection: options.projection ?? null,
+		sort: options.sort ?? null,
+		limit: typeof options.limit === "number" ? options.limit : null,
+		populate: options.populate ?? null,
+		pagination: options.pagination ?? null
+	});
+};
+//#endregion
+//#region src/rts/wsClient.ts
+var hasSnapshotError = (snapshot) => {
+	return snapshot?.error !== null && snapshot?.error !== void 0;
+};
+var RTS_CHANGES_PATH = "/api/rb/rts/changes";
+var MAX_TXN_BUF = 2048;
+var SERVER_RECONNECT_DELAY_MIN_MS = 1e4;
+var RUN_NETWORK_QUERY_TIMEOUT_ERROR = "runNetworkQuery: request timed out";
+var RUN_NETWORK_COUNT_TIMEOUT_ERROR = "runNetworkCount: request timed out";
+var socket = null;
+var socketReadyForMessages = false;
+var connectPromise = null;
+var pendingConnectionAttempt = null;
+var explicitDisconnect = false;
+var currentTenantId = null;
+var currentUid = null;
+var connectOptions = {};
+var connectionGeneration = 0;
+var connectionEpoch = null;
+var localTxnBuf = [];
+var queryCallbacks = /* @__PURE__ */ new Map();
+var countCallbacks = /* @__PURE__ */ new Map();
+var subscriptions = /* @__PURE__ */ new Map();
+var countSubscriptions = /* @__PURE__ */ new Map();
+var messageCallbacks = /* @__PURE__ */ new Map();
+var rtsMessageCallbacks = /* @__PURE__ */ new Map();
+var pendingWindowRequests = /* @__PURE__ */ new Map();
+var reconnectTimer = null;
+var reconnectAttempts = 0;
+var hasEstablishedConnection = false;
+var forceInitialQueryOnNextConnection = false;
+var pendingServerReconnectJitter = false;
+var syncPromise = null;
+var syncKey = null;
+var connectionStatus = "idle";
+var connectionError = null;
+var connectionStatusCallbacks = /* @__PURE__ */ new Set();
+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 setConnectionStatus = (status, error = null) => {
+	connectionStatus = status;
+	connectionError = error;
+	for (const callback of connectionStatusCallbacks) callback(status, error);
+};
+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);
+	return new URL(RTS_CHANGES_PATH, base).toString();
+};
+var buildSocketUrl = (_tenantId, _uid, options) => {
+	if (options.url) return resolveWebSocketUrlFromCandidate(options.url, options).toString();
+	const locationHref = getRuntimeLocationHref();
+	if (!locationHref) throw new Error("connect: options.url is required when location.href is unavailable");
+	const base = new URL(locationHref);
+	base.protocol = base.protocol === "https:" ? "wss:" : "ws:";
+	base.pathname = options.path ?? "/rts";
+	base.search = "";
+	base.hash = "";
+	return base.toString();
+};
+var sendToServer = (message) => {
+	if (!socket || !socketReadyForMessages) return;
+	if (socket.readyState !== WebSocket.OPEN) return;
+	socket.send(JSON.stringify(message));
+};
+var isSocketReady = () => Boolean(socket && socketReadyForMessages && socket.readyState === WebSocket.OPEN);
+var normalizeRequestedCount = (value) => {
+	if (!Number.isSafeInteger(value)) return void 0;
+	if (value < 1 || value > 4096) return void 0;
+	return value;
+};
+var getSubscriptionServerOptions = (subscription) => {
+	if (!subscription.options.pagination || !subscription.requestedCount) return subscription.options;
+	const { cursor: _cursor, direction: _direction, ...pagination } = subscription.options.pagination;
+	return {
+		...subscription.options,
+		pagination: {
+			...pagination,
+			limit: subscription.requestedCount
+		}
+	};
+};
+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: getSubscriptionServerOptions(sub),
+			runInitialQuery
+		});
+	}
+	for (const sub of countSubscriptions.values()) {
+		const runInitialQuery = forceInitialQuery || sub.runInitialNetworkQuery;
+		sendToServer({
+			type: "register-count",
+			modelName: sub.modelName,
+			queryKey: sub.queryKey,
+			query: sub.query,
+			options: sub.options,
+			runInitialQuery
+		});
+	}
+};
+var clearReconnectTimer = () => {
+	if (reconnectTimer === null) return;
+	clearRuntimeTimeout(reconnectTimer);
+	reconnectTimer = null;
+};
+var rejectPendingConnectionAttempt = () => {
+	const attempt = pendingConnectionAttempt;
+	if (!attempt) return;
+	pendingConnectionAttempt = null;
+	attempt.reject(/* @__PURE__ */ new Error("RTS WebSocket connection attempt superseded"));
+};
+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) {
+		delay = SERVER_RECONNECT_DELAY_MIN_MS + Math.floor(Math.random() * 5001);
+		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 normalizeQueryWindow = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const raw = value;
+	const requestedCount = normalizeRequestedCount(raw.requestedCount);
+	if (!requestedCount) return void 0;
+	const version = Number.isSafeInteger(raw.version) && raw.version >= 0 ? raw.version : void 0;
+	return {
+		requestedCount,
+		...version !== void 0 ? { version } : {}
+	};
+};
+var settlePendingWindowRequests = (cbKey, requestedCount, success) => {
+	const pending = pendingWindowRequests.get(cbKey);
+	if (!pending?.size) return;
+	for (const request of Array.from(pending)) {
+		if (request.requestedCount !== requestedCount) continue;
+		clearRuntimeTimeout(request.timeoutId);
+		pending.delete(request);
+		if (!success) {
+			const subscription = subscriptions.get(cbKey);
+			if (subscription?.requestedCount === request.requestedCount) {
+				const rollbackRequestedCount = (subscription.lastSnapshot && !hasSnapshotError(subscription.lastSnapshot) ? subscription.lastSnapshot.context.window?.requestedCount : void 0) ?? request.previousRequestedCount;
+				subscription.windowIntentVersion += 1;
+				subscription.requestedCount = rollbackRequestedCount;
+				sendToServer({
+					type: "set-query-window",
+					modelName: subscription.modelName,
+					queryKey: subscription.queryKey,
+					requestedCount: rollbackRequestedCount
+				});
+			}
+		}
+		request.resolve(success);
+	}
+	if (!pending.size) pendingWindowRequests.delete(cbKey);
+};
+var failPendingWindowRequests = (cbKey) => {
+	const pending = pendingWindowRequests.get(cbKey);
+	if (!pending?.size) return;
+	for (const request of Array.from(pending)) settlePendingWindowRequests(cbKey, request.requestedCount, false);
+};
+var cancelPendingWindowRequests = (cbKey) => {
+	const entries = cbKey ? [[cbKey, pendingWindowRequests.get(cbKey)]] : Array.from(pendingWindowRequests.entries());
+	for (const [key, pending] of entries) {
+		if (!pending) continue;
+		for (const request of pending) {
+			clearRuntimeTimeout(request.timeoutId);
+			request.resolve(false);
+		}
+		pendingWindowRequests.delete(key);
+	}
+};
+var updateQuerySubscriptionSnapshot = (subscription, snapshot) => {
+	if (snapshot.context.source === "cache" && subscription.lastSnapshot?.context.source === "network") {
+		const cachedCount = snapshot.context.window?.requestedCount;
+		const networkCount = subscription.lastSnapshot.context.window?.requestedCount;
+		if (!cachedCount || !networkCount || cachedCount <= networkCount) return false;
+	}
+	subscription.lastSnapshot = snapshot;
+	return true;
+};
+var updateCountSubscriptionSnapshot = (subscription, snapshot) => {
+	if (snapshot.context.source === "cache" && subscription.lastSnapshot?.context.source === "network") return false;
+	subscription.lastSnapshot = snapshot;
+	return true;
+};
+var dispatchQuerySnapshotToSubscription = (subscription, snapshot) => {
+	for (const callback of subscription.callbacks) callback(snapshot.error, snapshot.data, snapshot.context);
+};
+var dispatchQuerySnapshotToOneshotCallbacks = (cbKey, snapshot) => {
+	const callbacks = queryCallbacks.get(cbKey);
+	if (!callbacks || !callbacks.size) return;
+	for (const callback of callbacks) callback(snapshot.error, snapshot.data, snapshot.context);
+};
+var dispatchCountSnapshotToSubscription = (subscription, snapshot) => {
+	for (const callback of subscription.callbacks) callback(snapshot.error, snapshot.count, snapshot.context);
+};
+var dispatchCountSnapshotToOneshotCallbacks = (cbKey, snapshot) => {
+	const callbacks = countCallbacks.get(cbKey);
+	if (!callbacks || !callbacks.size) return;
+	for (const callback of callbacks) callback(snapshot.error, snapshot.count, snapshot.context);
+};
+var requestRegisteredQueryRefresh = (subscription) => {
+	if (subscription.options.pagination && subscription.requestedCount) {
+		sendToServer({
+			type: "set-query-window",
+			modelName: subscription.modelName,
+			queryKey: subscription.queryKey,
+			requestedCount: subscription.requestedCount
+		});
+		return;
+	}
+	sendToServer({
+		type: "run-query",
+		modelName: subscription.modelName,
+		queryKey: subscription.queryKey,
+		query: subscription.query,
+		options: getSubscriptionServerOptions(subscription)
+	});
+};
+var requestRegisteredCountRefresh = (subscription) => {
+	sendToServer({
+		type: "run-count",
+		modelName: subscription.modelName,
+		queryKey: subscription.queryKey,
+		query: subscription.query,
+		options: subscription.options
+	});
+};
+var requestSubscriptionLocalQuery = (cbKey, subscription) => {
+	if (!currentUid) return false;
+	const uid = currentUid;
+	const generation = connectionGeneration;
+	if (subscription.options.pagination) {
+		const requestedCountAtStart = subscription.requestedCount;
+		const windowIntentVersionAtStart = subscription.windowIntentVersion;
+		const localQueryPromise = readQueryWindowSnapshot({
+			uid,
+			modelName: subscription.modelName,
+			queryKey: subscription.queryKey
+		}).then((result) => {
+			if (!result.hit || generation !== connectionGeneration) return;
+			const currentSubscription = subscriptions.get(cbKey);
+			if (!currentSubscription) return;
+			const requestedCount = normalizeRequestedCount(result.snapshot.requestedCount);
+			if (!requestedCount) return;
+			if (currentSubscription.windowIntentVersion !== windowIntentVersionAtStart) return;
+			if (currentSubscription.requestedCount !== requestedCountAtStart) return;
+			const snapshot = {
+				error: null,
+				data: result.snapshot.data,
+				context: {
+					source: "cache",
+					pageInfo: result.snapshot.pageInfo,
+					...result.snapshot.totalCount !== void 0 ? { totalCount: result.snapshot.totalCount } : {},
+					window: { requestedCount }
+				}
+			};
+			if (!updateQuerySubscriptionSnapshot(currentSubscription, snapshot)) return;
+			currentSubscription.requestedCount = requestedCount;
+			currentSubscription.windowIntentVersion += 1;
+			if (requestedCount !== requestedCountAtStart) sendToServer({
+				type: "set-query-window",
+				modelName: currentSubscription.modelName,
+				queryKey: currentSubscription.queryKey,
+				requestedCount
+			});
+			dispatchQuerySnapshotToSubscription(currentSubscription, snapshot);
+		}).catch(() => {});
+		subscription.localQueryPromise = localQueryPromise;
+		localQueryPromise.finally(() => {
+			const currentSubscription = subscriptions.get(cbKey);
+			if (currentSubscription?.localQueryPromise === localQueryPromise) delete currentSubscription.localQueryPromise;
+		});
+		return true;
+	}
+	const populateCache = subscription.populateCache;
+	if (Boolean(populateCache) && populateCache) {
+		runPopulatedQuery({
+			modelName: subscription.modelName,
+			query: subscription.query,
+			options: {
+				uid,
+				projection: populateCache.rootProjection,
+				sort: subscription.options.sort,
+				limit: subscription.options.limit,
+				populate: populateCache.populate
+			}
+		}).then(({ hit, data, context }) => {
+			if (!hit) return;
+			if (generation !== connectionGeneration) return;
+			const currentSubscription = subscriptions.get(cbKey);
+			if (!currentSubscription) return;
+			const snapshot = {
+				error: null,
+				data,
+				context
+			};
+			if (!updateQuerySubscriptionSnapshot(currentSubscription, snapshot)) return;
+			dispatchQuerySnapshotToSubscription(currentSubscription, snapshot);
+		}).catch(() => {});
+		return true;
+	}
+	runQuery({
+		modelName: subscription.modelName,
+		query: subscription.query,
+		options: {
+			uid,
+			projection: subscription.options.projection,
+			sort: subscription.options.sort,
+			limit: subscription.options.limit
+		}
+	}).then(({ data, context }) => {
+		if (generation !== connectionGeneration) return;
+		const currentSubscription = subscriptions.get(cbKey);
+		if (!currentSubscription) return;
+		const snapshot = {
+			error: null,
+			data,
+			context
+		};
+		if (!updateQuerySubscriptionSnapshot(currentSubscription, snapshot)) return;
+		dispatchQuerySnapshotToSubscription(currentSubscription, snapshot);
+	}).catch(() => {});
+	return true;
+};
+var handleQueryPayload = (payload) => {
+	const { modelName, queryKey, data, error, txnId } = payload;
+	const cbKey = `${modelName}.${queryKey}`;
+	const subscription = subscriptions.get(cbKey);
+	const hasSubscriptionCallbacks = Boolean(subscription?.callbacks.size);
+	const hasOneshotCallbacks = Boolean(queryCallbacks.get(cbKey)?.size);
+	if (!hasSubscriptionCallbacks && !hasOneshotCallbacks) return;
+	const pageInfo = normalizePageInfo$1(payload.pageInfo);
+	const totalCount = normalizeTotalCount$1(payload.totalCount);
+	const queryWindow = normalizeQueryWindow(payload.window);
+	const populateCache = subscription?.populateCache;
+	const hasPopulate = Boolean(populateCache);
+	const hasPagination = Boolean(subscription?.options?.pagination || pageInfo || totalCount !== void 0);
+	if (subscription?.options.pagination && queryWindow) {
+		if (queryWindow.requestedCount !== subscription.requestedCount) return;
+		if (queryWindow.version !== void 0 && queryWindow.version <= subscription.lastNetworkVersion) return;
+		if (queryWindow.version !== void 0) subscription.lastNetworkVersion = queryWindow.version;
+	}
+	const context = {
+		source: "network",
+		isLocal: !!(txnId && localTxnBuf.includes(txnId)),
+		txnId,
+		...pageInfo ? { pageInfo } : {},
+		...totalCount !== void 0 ? { totalCount } : {},
+		...queryWindow ? { window: queryWindow } : {}
+	};
+	const snapshot = {
+		error: error ?? null,
+		data,
+		context
+	};
+	if (error) {
+		if (subscription && updateQuerySubscriptionSnapshot(subscription, snapshot)) dispatchQuerySnapshotToSubscription(subscription, snapshot);
+		dispatchQuerySnapshotToOneshotCallbacks(cbKey, snapshot);
+		if (queryWindow) settlePendingWindowRequests(cbKey, queryWindow.requestedCount, false);
+		else if (subscription?.options.pagination) failPendingWindowRequests(cbKey);
+		return;
+	}
+	if (subscription && updateQuerySubscriptionSnapshot(subscription, snapshot)) dispatchQuerySnapshotToSubscription(subscription, snapshot);
+	dispatchQuerySnapshotToOneshotCallbacks(cbKey, snapshot);
+	if (queryWindow) settlePendingWindowRequests(cbKey, queryWindow.requestedCount, true);
+	if (!currentUid) return;
+	if (subscription?.options.pagination && queryWindow && pageInfo && Array.isArray(data) && connectionEpoch) {
+		const uid = currentUid;
+		const generation = connectionGeneration;
+		const serverEpoch = connectionEpoch;
+		const localQueryPromise = subscription.localQueryPromise;
+		Promise.resolve().then(async () => {
+			await localQueryPromise;
+			if (generation !== connectionGeneration || serverEpoch !== connectionEpoch) return;
+			const currentSubscription = subscriptions.get(cbKey);
+			if (!currentSubscription || currentSubscription.requestedCount !== queryWindow.requestedCount) return;
+			await writeQueryWindowSnapshot({
+				uid,
+				modelName,
+				queryKey,
+				data,
+				pageInfo,
+				...totalCount !== void 0 ? { totalCount } : {},
+				requestedCount: queryWindow.requestedCount,
+				...queryWindow.version !== void 0 ? {
+					serverEpoch,
+					serverVersion: queryWindow.version
+				} : {}
+			});
+		}).catch(() => {});
+		return;
+	}
+	const docs = Array.isArray(data) ? data.filter(isDocWithId) : [];
+	if (hasPagination) return;
+	if (!docs.length) return;
+	if (hasPopulate && populateCache) {
+		updatePopulatedDocs({
+			modelName,
+			data: docs,
+			uid: currentUid,
+			populate: populateCache.populate
+		}).catch(() => {});
+		return;
+	}
+	updateDocs(modelName, docs, currentUid).catch(() => {});
+};
+var handleCountPayload = (payload) => {
+	const { modelName, queryKey, count, error, txnId } = payload;
+	const cbKey = `${modelName}.${queryKey}`;
+	const subscription = countSubscriptions.get(cbKey);
+	const hasSubscriptionCallbacks = Boolean(subscription?.callbacks.size);
+	const hasOneshotCallbacks = Boolean(countCallbacks.get(cbKey)?.size);
+	if (!hasSubscriptionCallbacks && !hasOneshotCallbacks) return;
+	const context = {
+		source: "network",
+		isLocal: !!(txnId && localTxnBuf.includes(txnId)),
+		txnId
+	};
+	const normalizedCount = normalizeTotalCount$1(count);
+	const snapshot = {
+		error: error ?? null,
+		count: normalizedCount,
+		context
+	};
+	if (error) {
+		if (subscription && updateCountSubscriptionSnapshot(subscription, snapshot)) dispatchCountSnapshotToSubscription(subscription, snapshot);
+		dispatchCountSnapshotToOneshotCallbacks(cbKey, snapshot);
+		return;
+	}
+	if (subscription && updateCountSubscriptionSnapshot(subscription, snapshot)) dispatchCountSnapshotToSubscription(subscription, snapshot);
+	dispatchCountSnapshotToOneshotCallbacks(cbKey, snapshot);
+};
+var handleEvent = (payload) => {
+	const callbacks = messageCallbacks.get(payload.event);
+	if (!callbacks || !callbacks.size) return;
+	for (const cb of callbacks) cb(payload.payload);
+};
+var handleRtsMessage = (payload) => {
+	const callbacks = rtsMessageCallbacks.get(payload.channel);
+	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 === "count-payload") {
+		handleCountPayload(message);
+		return;
+	}
+	if (message.type === "event") {
+		handleEvent(message);
+		return;
+	}
+	if (message.type === "rts-message") handleRtsMessage(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, isCurrent) => {
+	const resetModels = /* @__PURE__ */ new Set();
+	const deletesByModel = /* @__PURE__ */ new Map();
+	for (const change of changes) {
+		const modelName = typeof change.modelName === "string" ? change.modelName : "";
+		if (!modelName) continue;
+		if (change.op === "reset_model") {
+			resetModels.add(modelName);
+			continue;
+		}
+		if (change.op === "delete") {
+			const docId = typeof change.docId === "string" ? change.docId : "";
+			if (!docId) continue;
+			const existing = deletesByModel.get(modelName) ?? [];
+			existing.push(docId);
+			deletesByModel.set(modelName, existing);
+		}
+	}
+	for (const modelName of resetModels) {
+		if (!isCurrent()) return false;
+		await destroyCollection(modelName, uid).catch(() => {});
+	}
+	for (const [modelName, ids] of deletesByModel.entries()) {
+		if (resetModels.has(modelName)) continue;
+		if (!isCurrent()) return false;
+		await deleteDocs(modelName, ids, uid).catch(() => {});
+	}
+	if (resetModels.size || deletesByModel.size) {
+		if (!isCurrent()) return false;
+		await invalidateQueryWindowSnapshots({ uid }).catch(() => {});
+	}
+	return true;
+};
+var syncRtsChangesWithResult = async (tenantId, uid, options = {}, isCurrent = () => true) => {
+	ensureSyncRuntime();
+	if (!tenantId || !uid) return false;
+	const storageKey = getSyncStorageKey({
+		tenantId,
+		uid,
+		appName: options.appName
+	});
+	let sinceSeq = readStoredSeq(storageKey);
+	let cacheInvalidated = false;
+	const syncUrl = buildSyncChangesUrl(tenantId, { url: options.url });
+	for (let i = 0; i < 32; i += 1) {
+		const response = await fetch(syncUrl, {
+			method: "POST",
+			credentials: "include",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				sinceSeq,
+				limit: 2e3
+			})
+		});
+		if (!isCurrent()) return false;
+		if (!response.ok) return cacheInvalidated;
+		const payload = await response.json().catch(() => null);
+		if (!payload || typeof payload !== "object") return cacheInvalidated;
+		const payloadObj = payload;
+		if (payloadObj.ok !== true) return cacheInvalidated;
+		const latestSeq = Number(payloadObj.latestSeq ?? 0);
+		if (Boolean(payloadObj.needsFullResync)) {
+			if (!isCurrent()) return false;
+			resetRtsPouchStore({
+				tenantId,
+				appName: options.appName
+			});
+			writeStoredSeq(storageKey, latestSeq);
+			return true;
+		}
+		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 cacheInvalidated;
+		}
+		if (!await applyChangeBatch(normalized, uid, isCurrent)) return false;
+		cacheInvalidated = true;
+		sinceSeq = normalized.reduce((max, c) => c.seq > max ? c.seq : max, sinceSeq);
+		writeStoredSeq(storageKey, sinceSeq);
+		if (latestSeq > 0 && sinceSeq >= latestSeq) return cacheInvalidated;
+	}
+	return cacheInvalidated;
+};
+var syncRtsChanges = async (tenantId, uid, options = {}) => {
+	await syncRtsChangesWithResult(tenantId, uid, options);
+};
+var ensureSynced = (tenantId, uid, options) => {
+	if (options.syncChanges === false) return Promise.resolve(false);
+	const key = `${options.appName ?? ""}:${tenantId}:${uid}`;
+	if (syncPromise && syncKey === key) return syncPromise;
+	syncKey = key;
+	syncPromise = syncRtsChangesWithResult(tenantId, uid, {
+		appName: options.appName,
+		url: options.url
+	}, () => currentTenantId === tenantId && currentUid === uid && (connectOptions.appName ?? "") === (options.appName ?? "")).catch(() => false).finally(() => {
+		if (syncKey === key) syncPromise = null;
+	});
+	return syncPromise;
+};
+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
+	});
+	if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) return connectPromise ?? Promise.resolve();
+	const synchronization = ensureSynced(tenantId, uid, options);
+	explicitDisconnect = false;
+	clearReconnectTimer();
+	socketReadyForMessages = false;
+	const url = buildSocketUrl(tenantId, uid, options);
+	connectPromise = new Promise((resolve, reject) => {
+		if (resetReconnectAttempts) reconnectAttempts = 0;
+		let opened = false;
+		let settled = false;
+		let subscriptionsStarted = false;
+		let cacheInvalidatedBeforeSubscriptions = false;
+		const generation = ++connectionGeneration;
+		connectionEpoch = `${Date.now().toString(36)}.${generation.toString(36)}.${Math.random().toString(36).slice(2, 10)}`;
+		pendingConnectionAttempt = {
+			generation,
+			reject: (error) => {
+				if (settled) return;
+				settled = true;
+				reject(error);
+			}
+		};
+		setConnectionStatus("connecting");
+		const nextSocket = new WebSocket(url);
+		socket = nextSocket;
+		if (options.syncChanges !== false) synchronization.then((cacheInvalidated) => {
+			if (!cacheInvalidated || generation !== connectionGeneration) return;
+			if (!subscriptionsStarted) {
+				cacheInvalidatedBeforeSubscriptions = true;
+				return;
+			}
+			if (nextSocket.readyState !== WebSocket.OPEN) return;
+			for (const subscription of subscriptions.values()) {
+				if (!subscription.options.pagination) continue;
+				requestRegisteredQueryRefresh(subscription);
+			}
+		});
+		nextSocket.addEventListener("open", () => {
+			if (generation !== connectionGeneration) return;
+			opened = true;
+			settled = true;
+			if (pendingConnectionAttempt?.generation === generation) pendingConnectionAttempt = null;
+			reconnectAttempts = 0;
+			pendingServerReconnectJitter = false;
+			socketReadyForMessages = true;
+			setConnectionStatus("connected");
+			for (const subscription of subscriptions.values()) {
+				subscription.lastNetworkVersion = 0;
+				if (subscription.runInitialLocalQuery && !subscription.hasRequestedInitialLocalQuery) subscription.hasRequestedInitialLocalQuery = requestSubscriptionLocalQuery(`${subscription.modelName}.${subscription.queryKey}`, subscription);
+			}
+			resubscribeAll({ forceInitialQuery: hasEstablishedConnection || forceInitialQueryOnNextConnection || cacheInvalidatedBeforeSubscriptions });
+			forceInitialQueryOnNextConnection = false;
+			subscriptionsStarted = true;
+			hasEstablishedConnection = true;
+			resolve();
+		});
+		nextSocket.addEventListener("message", (event) => {
+			if (generation !== connectionGeneration) return;
+			handleMessage(event);
+		});
+		nextSocket.addEventListener("close", (event) => {
+			if (generation !== connectionGeneration) return;
+			socketReadyForMessages = false;
+			if (!settled) {
+				settled = true;
+				if (pendingConnectionAttempt?.generation === generation) pendingConnectionAttempt = null;
+				const error = /* @__PURE__ */ new Error(`RTS WebSocket closed before becoming ready (code=${event.code})`);
+				setConnectionStatus("error", error);
+				reject(error);
+			}
+			if (!explicitDisconnect) {
+				pendingServerReconnectJitter = opened;
+				setConnectionStatus("connecting", connectionError);
+			} else setConnectionStatus("idle");
+			socket = null;
+			connectPromise = null;
+			scheduleReconnect();
+		});
+		nextSocket.addEventListener("error", (err) => {
+			if (generation !== connectionGeneration) return;
+			if (settled) return;
+			settled = true;
+			if (pendingConnectionAttempt?.generation === generation) pendingConnectionAttempt = null;
+			socketReadyForMessages = false;
+			const error = err instanceof Error ? err : /* @__PURE__ */ new Error("RTS WebSocket error");
+			setConnectionStatus("error", error);
+			reject(error);
+		});
+	});
+	return connectPromise;
+};
+var connect = (tenantId, uid, options = {}) => {
+	if (currentTenantId !== null && (currentTenantId !== tenantId || currentUid !== uid || (connectOptions.appName ?? "") !== (options.appName ?? ""))) return reconnect(tenantId, uid, options);
+	return connectInternal(tenantId, uid, options, { resetReconnectAttempts: true });
+};
+var disconnect = () => {
+	explicitDisconnect = true;
+	connectionGeneration += 1;
+	rejectPendingConnectionAttempt();
+	clearReconnectTimer();
+	hasEstablishedConnection = false;
+	forceInitialQueryOnNextConnection = false;
+	pendingServerReconnectJitter = false;
+	if (socket) try {
+		socket.close();
+	} catch {}
+	socket = null;
+	socketReadyForMessages = false;
+	connectPromise = null;
+	connectionEpoch = null;
+	cancelPendingWindowRequests();
+	setConnectionStatus("idle");
+};
+var reconnect = (tenantId, uid, options = {}) => {
+	const identityChanged = currentTenantId !== null && currentUid !== null && (currentTenantId !== tenantId || currentUid !== uid || (connectOptions.appName ?? "") !== (options.appName ?? ""));
+	if (identityChanged) {
+		cancelPendingWindowRequests();
+		for (const subscription of subscriptions.values()) {
+			subscription.hasRequestedInitialLocalQuery = false;
+			subscription.lastSnapshot = void 0;
+			subscription.lastNetworkVersion = 0;
+			subscription.windowIntentVersion += 1;
+			subscription.requestedCount = subscription.initialWindowSize;
+			delete subscription.localQueryPromise;
+			dispatchQuerySnapshotToSubscription(subscription, {
+				error: null,
+				data: void 0,
+				context: {
+					source: "cache",
+					reset: true,
+					...subscription.initialWindowSize ? { window: { requestedCount: subscription.initialWindowSize } } : {}
+				}
+			});
+		}
+		for (const subscription of countSubscriptions.values()) {
+			subscription.lastSnapshot = void 0;
+			dispatchCountSnapshotToSubscription(subscription, {
+				error: null,
+				count: void 0,
+				context: {
+					source: "cache",
+					reset: true
+				}
+			});
+		}
+	}
+	forceInitialQueryOnNextConnection = hasEstablishedConnection || identityChanged;
+	explicitDisconnect = true;
+	connectionGeneration += 1;
+	rejectPendingConnectionAttempt();
+	clearReconnectTimer();
+	pendingServerReconnectJitter = false;
+	if (socket) try {
+		socket.close();
+	} catch {}
+	socket = null;
+	socketReadyForMessages = false;
+	connectPromise = null;
+	connectionEpoch = null;
+	return connectInternal(tenantId, uid, options, { resetReconnectAttempts: true });
+};
+var getConnectionStatus = () => {
+	return connectionStatus;
+};
+var getConnectionError = () => {
+	return connectionError;
+};
+var onConnectionStatusChange = (callback) => {
+	connectionStatusCallbacks.add(callback);
+	return () => {
+		connectionStatusCallbacks.delete(callback);
+	};
+};
+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 forceRefreshOnMount = behavior?.forceRefreshOnMount === true;
+	const populateCache = preparePopulateCacheOptions({
+		projection: options.projection,
+		populate: options.populate
+	}, "registerQuery");
+	const initialWindowSize = options.pagination ? normalizeRequestedCount(options.pagination.limit) : void 0;
+	const subscription = subscriptions.get(cbKey) ?? {
+		modelName,
+		query,
+		options,
+		queryKey,
+		callbacks: /* @__PURE__ */ new Set(),
+		runInitialNetworkQuery,
+		runInitialLocalQuery,
+		hasRequestedInitialLocalQuery: false,
+		lastNetworkVersion: 0,
+		windowIntentVersion: 0,
+		...initialWindowSize ? {
+			initialWindowSize,
+			requestedCount: initialWindowSize
+		} : {},
+		...populateCache ? { populateCache } : {}
+	};
+	const hadCallbacks = subscription.callbacks.size > 0;
+	const hadInitialNetworkQuery = subscription.runInitialNetworkQuery;
+	subscription.callbacks.add(callback);
+	if (runInitialNetworkQuery) subscription.runInitialNetworkQuery = true;
+	if (runInitialLocalQuery) subscription.runInitialLocalQuery = true;
+	subscriptions.set(cbKey, subscription);
+	let seeded = false;
+	if (behavior?.seedSnapshot && updateQuerySubscriptionSnapshot(subscription, behavior.seedSnapshot)) {
+		dispatchQuerySnapshotToSubscription(subscription, behavior.seedSnapshot);
+		seeded = true;
+	}
+	if (!seeded && hadCallbacks && subscription.lastSnapshot && !hasSnapshotError(subscription.lastSnapshot)) callback(subscription.lastSnapshot.error, subscription.lastSnapshot.data, subscription.lastSnapshot.context);
+	if (!hadCallbacks) {
+		if (runInitialLocalQuery) subscription.hasRequestedInitialLocalQuery = requestSubscriptionLocalQuery(cbKey, subscription);
+		sendToServer({
+			type: "register-query",
+			modelName,
+			queryKey,
+			query,
+			options: getSubscriptionServerOptions(subscription),
+			runInitialQuery: runInitialNetworkQuery
+		});
+	} else {
+		if (runInitialLocalQuery && !subscription.hasRequestedInitialLocalQuery) subscription.hasRequestedInitialLocalQuery = requestSubscriptionLocalQuery(cbKey, subscription);
+		if (forceRefreshOnMount || runInitialNetworkQuery && (!hadInitialNetworkQuery || hasSnapshotError(subscription.lastSnapshot))) requestRegisteredQueryRefresh(subscription);
+	}
+	return () => {
+		const currentSubscription = subscriptions.get(cbKey);
+		currentSubscription?.callbacks.delete(callback);
+		if (currentSubscription && currentSubscription.callbacks.size === 0) {
+			subscriptions.delete(cbKey);
+			cancelPendingWindowRequests(cbKey);
+			sendToServer({
+				type: "remove-query",
+				modelName,
+				queryKey
+			});
+		}
+	};
+};
+var setQueryWindowSize = async ({ modelName, query, options, requestedCount, timeoutMs = 1e4 }) => {
+	const normalizedRequestedCount = normalizeRequestedCount(requestedCount);
+	if (!normalizedRequestedCount || !options.pagination) return false;
+	const queryKey = computeRtsQueryKey(query, options);
+	const cbKey = `${modelName}.${queryKey}`;
+	const subscription = subscriptions.get(cbKey);
+	if (!subscription?.options.pagination) return false;
+	const currentNetworkWindow = subscription.lastSnapshot?.context.source === "network" ? subscription.lastSnapshot.context.window : void 0;
+	if (subscription.requestedCount === normalizedRequestedCount && currentNetworkWindow?.requestedCount === normalizedRequestedCount) return true;
+	const previousRequestedCount = subscription.requestedCount ?? subscription.initialWindowSize ?? normalizedRequestedCount;
+	subscription.windowIntentVersion += 1;
+	subscription.requestedCount = normalizedRequestedCount;
+	let request;
+	const response = new Promise((resolve) => {
+		const timeoutId = setRuntimeTimeout(() => {
+			settlePendingWindowRequests(cbKey, request.requestedCount, false);
+		}, timeoutMs);
+		request = {
+			requestedCount: normalizedRequestedCount,
+			previousRequestedCount,
+			resolve,
+			timeoutId
+		};
+		const pending = pendingWindowRequests.get(cbKey) ?? /* @__PURE__ */ new Set();
+		pending.add(request);
+		pendingWindowRequests.set(cbKey, pending);
+	});
+	try {
+		if (!isSocketReady()) {
+			if (!currentTenantId || !currentUid) {
+				settlePendingWindowRequests(cbKey, normalizedRequestedCount, false);
+				return false;
+			}
+			await connectInternal(currentTenantId, currentUid, connectOptions, { resetReconnectAttempts: false });
+		}
+		sendToServer({
+			type: "set-query-window",
+			modelName,
+			queryKey,
+			requestedCount: normalizedRequestedCount
+		});
+	} catch {
+		settlePendingWindowRequests(cbKey, normalizedRequestedCount, false);
+		return false;
+	}
+	return await response;
+};
+var registerCount = (modelName, query, optionsOrCallback, callbackMaybe, behavior) => {
+	let options;
+	let callback;
+	if (typeof optionsOrCallback === "function") {
+		options = {};
+		callback = optionsOrCallback;
+	} else {
+		options = optionsOrCallback ?? {};
+		callback = callbackMaybe;
+	}
+	if (!callback) return void 0;
+	if (typeof modelName !== "string" || modelName.trim().length === 0) throw new Error("registerCount: modelName must be a non-empty string");
+	const queryKey = computeRtsQueryKey(query, options);
+	const cbKey = `${modelName}.${queryKey}`;
+	const runInitialNetworkQuery = behavior?.runInitialNetworkQuery !== false;
+	const forceRefreshOnMount = behavior?.forceRefreshOnMount === true;
+	const subscription = countSubscriptions.get(cbKey) ?? {
+		modelName,
+		query,
+		options,
+		queryKey,
+		callbacks: /* @__PURE__ */ new Set(),
+		runInitialNetworkQuery
+	};
+	const hadCallbacks = subscription.callbacks.size > 0;
+	const hadInitialNetworkQuery = subscription.runInitialNetworkQuery;
+	subscription.callbacks.add(callback);
+	if (runInitialNetworkQuery) subscription.runInitialNetworkQuery = true;
+	countSubscriptions.set(cbKey, subscription);
+	let seeded = false;
+	if (behavior?.seedSnapshot && updateCountSubscriptionSnapshot(subscription, behavior.seedSnapshot)) {
+		dispatchCountSnapshotToSubscription(subscription, behavior.seedSnapshot);
+		seeded = true;
+	}
+	if (!seeded && hadCallbacks && subscription.lastSnapshot && !hasSnapshotError(subscription.lastSnapshot)) callback(subscription.lastSnapshot.error, subscription.lastSnapshot.count, subscription.lastSnapshot.context);
+	if (!hadCallbacks) sendToServer({
+		type: "register-count",
+		modelName,
+		queryKey,
+		query,
+		options,
+		runInitialQuery: runInitialNetworkQuery
+	});
+	else if (forceRefreshOnMount || runInitialNetworkQuery && (!hadInitialNetworkQuery || hasSnapshotError(subscription.lastSnapshot))) requestRegisteredCountRefresh(subscription);
+	return () => {
+		const currentSubscription = countSubscriptions.get(cbKey);
+		currentSubscription?.callbacks.delete(callback);
+		if (currentSubscription && currentSubscription.callbacks.size === 0) {
+			countSubscriptions.delete(cbKey);
+			sendToServer({
+				type: "remove-count",
+				modelName,
+				queryKey
+			});
+		}
+	};
+};
+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 (!isSocketReady()) {
+		if (currentTenantId && currentUid) try {
+			const connectAttempt = connectInternal(currentTenantId, currentUid, connectOptions, { resetReconnectAttempts: false });
+			if (hasTimeout) await new Promise((resolve, reject) => {
+				const timeoutId = setRuntimeTimeout(() => {
+					reject(/* @__PURE__ */ new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR));
+				}, timeoutMs);
+				connectAttempt.then(() => {
+					clearRuntimeTimeout(timeoutId);
+					resolve();
+				}, (error) => {
+					clearRuntimeTimeout(timeoutId);
+					reject(error);
+				});
+			});
+			else await connectAttempt;
+		} catch {}
+	}
+	if (!isSocketReady()) {
+		if (hasTimeout && Date.now() - timeoutStartedAt >= timeoutMs) throw new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR);
+		throw new Error("runNetworkQuery: RTS socket is not connected");
+	}
+	const remainingTimeoutMs = hasTimeout ? Math.max(0, timeoutMs - (Date.now() - timeoutStartedAt)) : null;
+	if (remainingTimeoutMs !== null && remainingTimeoutMs <= 0) throw new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR);
+	const resolvedOptions = {
+		...options,
+		key: makeRunQueryKey()
+	};
+	const queryKey = computeRtsQueryKey(query, resolvedOptions);
+	const cbKey = `${modelName}.${queryKey}`;
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		let timeoutId = null;
+		const cleanup = () => {
+			const 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(/* @__PURE__ */ new Error(RUN_NETWORK_QUERY_TIMEOUT_ERROR)));
+		}, remainingTimeoutMs);
+		sendToServer({
+			type: "run-query",
+			modelName,
+			queryKey,
+			query,
+			options: resolvedOptions
+		});
+	});
+};
+var runNetworkCount = async ({ modelName, query, options = {}, timeoutMs = 1e4 }) => {
+	if (typeof modelName !== "string" || modelName.trim().length === 0) throw new Error("runNetworkCount: modelName must be a non-empty string");
+	const hasTimeout = typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0;
+	const timeoutStartedAt = hasTimeout ? Date.now() : 0;
+	if (!isSocketReady()) {
+		if (currentTenantId && currentUid) try {
+			const connectAttempt = connectInternal(currentTenantId, currentUid, connectOptions, { resetReconnectAttempts: false });
+			if (hasTimeout) await new Promise((resolve, reject) => {
+				const timeoutId = setRuntimeTimeout(() => {
+					reject(/* @__PURE__ */ new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR));
+				}, timeoutMs);
+				connectAttempt.then(() => {
+					clearRuntimeTimeout(timeoutId);
+					resolve();
+				}, (error) => {
+					clearRuntimeTimeout(timeoutId);
+					reject(error);
+				});
+			});
+			else await connectAttempt;
+		} catch {}
+	}
+	if (!isSocketReady()) {
+		if (hasTimeout && Date.now() - timeoutStartedAt >= timeoutMs) throw new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR);
+		throw new Error("runNetworkCount: RTS socket is not connected");
+	}
+	const remainingTimeoutMs = hasTimeout ? Math.max(0, timeoutMs - (Date.now() - timeoutStartedAt)) : null;
+	if (remainingTimeoutMs !== null && remainingTimeoutMs <= 0) throw new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR);
+	const resolvedOptions = {
+		...options,
+		key: makeRunQueryKey()
+	};
+	const queryKey = computeRtsQueryKey(query, resolvedOptions);
+	const cbKey = `${modelName}.${queryKey}`;
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		let timeoutId = null;
+		const cleanup = () => {
+			const callbacks = countCallbacks.get(cbKey);
+			callbacks?.delete(callback);
+			if (callbacks && callbacks.size === 0) countCallbacks.delete(cbKey);
+			if (timeoutId !== null) clearRuntimeTimeout(timeoutId);
+		};
+		const settle = (next) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			next();
+		};
+		const callback = (error, count, context) => {
+			if (error) {
+				settle(() => reject(typeof error === "string" ? new Error(error) : error));
+				return;
+			}
+			if (count === void 0) {
+				settle(() => reject(/* @__PURE__ */ 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(/* @__PURE__ */ new Error(RUN_NETWORK_COUNT_TIMEOUT_ERROR)));
+		}, remainingTimeoutMs);
+		sendToServer({
+			type: "run-count",
+			modelName,
+			queryKey,
+			query,
+			options: resolvedOptions
+		});
+	});
+};
+var sendMessage = (event, payload) => {
+	sendToServer({
+		type: "event",
+		event,
+		payload
+	});
+};
+var sendRtsMessage = (channel, payload) => {
+	sendToServer({
+		type: "rts-message",
+		channel,
+		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);
+	};
+};
+var onRtsMessage = (channel, callback) => {
+	const set = rtsMessageCallbacks.get(channel) ?? /* @__PURE__ */ new Set();
+	set.add(callback);
+	rtsMessageCallbacks.set(channel, set);
+	return () => {
+		const callbacks = rtsMessageCallbacks.get(channel);
+		callbacks?.delete(callback);
+		if (callbacks && callbacks.size === 0) rtsMessageCallbacks.delete(channel);
+	};
+};
+//#endregion
+//#region src/rts/useCountQuery.ts
+var normalizeCount = (value) => {
+	if (typeof value !== "number") return void 0;
+	if (!Number.isFinite(value) || value < 0) return void 0;
+	return Math.floor(value);
+};
+var useCountQuery = (modelName, t0, t1) => {
+	const $ = c(54);
+	const query = t0 === void 0 ? {} : t0;
+	let t2;
+	if ($[0] !== t1) {
+		t2 = t1 === void 0 ? {} : t1;
+		$[0] = t1;
+		$[1] = t2;
+	} else t2 = $[1];
+	const options = t2;
+	if (typeof modelName !== "string" || modelName.trim().length === 0) throw new Error("useCountQuery: modelName must be a non-empty string");
+	const enabled = options.enabled ?? true;
+	const ssrEnabled = options.ssr !== false;
+	const refreshOnMount = options.refreshOnMount === true;
+	const key = options.key;
+	const queryJson = serializeRtsQueryValue(query);
+	let t3;
+	if ($[2] !== key) {
+		t3 = key ? { key } : {};
+		$[2] = key;
+		$[3] = t3;
+	} else t3 = $[3];
+	const runtimeOptions = t3;
+	const queryKey = computeRtsQueryKey(query, runtimeOptions);
+	const ssrRuntime = useRtsSsrRuntime();
+	if (enabled && ssrEnabled && ssrRuntime) ssrRuntime.registerCount({
+		modelName,
+		query,
+		options: runtimeOptions,
+		queryKey
+	});
+	let t4;
+	if ($[4] !== enabled || $[5] !== modelName || $[6] !== queryKey || $[7] !== ssrEnabled || $[8] !== ssrRuntime) {
+		t4 = enabled && ssrEnabled ? ssrRuntime ? ssrRuntime.getCount(modelName, queryKey) : peekHydratedRtsCount(modelName, queryKey) : void 0;
+		$[4] = enabled;
+		$[5] = modelName;
+		$[6] = queryKey;
+		$[7] = ssrEnabled;
+		$[8] = ssrRuntime;
+		$[9] = t4;
+	} else t4 = $[9];
+	const seedCountRaw = t4;
+	let t5;
+	if ($[10] !== seedCountRaw) {
+		t5 = normalizeCount(seedCountRaw);
+		$[10] = seedCountRaw;
+		$[11] = t5;
+	} else t5 = $[11];
+	const seedCount = t5;
+	const seedCountStr = seedCount !== void 0 ? String(seedCount) : "";
+	const hasSeedCount = seedCount !== void 0;
+	let t6;
+	if ($[12] !== seedCount) {
+		t6 = () => seedCount;
+		$[12] = seedCount;
+		$[13] = t6;
+	} else t6 = $[13];
+	const [count, setCount] = useState(t6);
+	let t7;
+	if ($[14] !== hasSeedCount) {
+		t7 = () => hasSeedCount ? "cache" : void 0;
+		$[14] = hasSeedCount;
+		$[15] = t7;
+	} else t7 = $[15];
+	const [source, setSource] = useState(t7);
+	const [error, setError] = useState(void 0);
+	const [loading, setLoading] = useState(enabled && !hasSeedCount);
+	const lastCountRef = useRef(seedCount);
+	let t8;
+	if ($[16] !== enabled || $[17] !== hasSeedCount || $[18] !== modelName || $[19] !== queryKey || $[20] !== seedCount || $[21] !== ssrEnabled || $[22] !== ssrRuntime) {
+		t8 = () => {
+			if (!ssrRuntime && enabled && ssrEnabled && hasSeedCount) consumeHydratedRtsCount(modelName, queryKey);
+			lastCountRef.current = seedCount;
+			setError(void 0);
+			if (!enabled) {
+				setCount(void 0);
+				setSource(void 0);
+				setLoading(false);
+				return;
+			}
+			if (hasSeedCount) {
+				setCount(seedCount);
+				setSource("cache");
+				setLoading(false);
+				return;
+			}
+			setCount(void 0);
+			setSource(void 0);
+			setLoading(true);
+		};
+		$[16] = enabled;
+		$[17] = hasSeedCount;
+		$[18] = modelName;
+		$[19] = queryKey;
+		$[20] = seedCount;
+		$[21] = ssrEnabled;
+		$[22] = ssrRuntime;
+		$[23] = t8;
+	} else t8 = $[23];
+	let t9;
+	if ($[24] !== enabled || $[25] !== hasSeedCount || $[26] !== modelName || $[27] !== queryKey || $[28] !== seedCount || $[29] !== seedCountStr || $[30] !== ssrEnabled || $[31] !== ssrRuntime) {
+		t9 = [
+			enabled,
+			ssrEnabled,
+			ssrRuntime,
+			modelName,
+			queryKey,
+			hasSeedCount,
+			seedCount,
+			seedCountStr
+		];
+		$[24] = enabled;
+		$[25] = hasSeedCount;
+		$[26] = modelName;
+		$[27] = queryKey;
+		$[28] = seedCount;
+		$[29] = seedCountStr;
+		$[30] = ssrEnabled;
+		$[31] = ssrRuntime;
+		$[32] = t9;
+	} else t9 = $[32];
+	useEffect(t8, t9);
+	let t10;
+	if ($[33] !== enabled || $[34] !== hasSeedCount || $[35] !== modelName || $[36] !== query || $[37] !== refreshOnMount || $[38] !== runtimeOptions || $[39] !== seedCount) {
+		t10 = () => {
+			if (!enabled) return;
+			const unsubscribe = registerCount(modelName, query, runtimeOptions, (err, nextCount, context) => {
+				if (context.source === "cache" && context.reset) {
+					lastCountRef.current = void 0;
+					setCount(void 0);
+					setSource(void 0);
+					setError(void 0);
+					setLoading(true);
+					return;
+				}
+				setLoading(false);
+				if (err) {
+					setError(err);
+					return;
+				}
+				if (nextCount === void 0) return;
+				setError(void 0);
+				if (lastCountRef.current === nextCount) {
+					setSource(context.source);
+					return;
+				}
+				lastCountRef.current = nextCount;
+				setCount(nextCount);
+				setSource(context.source);
+			}, {
+				runInitialNetworkQuery: refreshOnMount || !hasSeedCount,
+				forceRefreshOnMount: refreshOnMount,
+				...hasSeedCount ? { seedSnapshot: {
+					error: null,
+					count: seedCount,
+					context: { source: "cache" }
+				} } : {}
+			});
+			return () => {
+				unsubscribe?.();
+			};
+		};
+		$[33] = enabled;
+		$[34] = hasSeedCount;
+		$[35] = modelName;
+		$[36] = query;
+		$[37] = refreshOnMount;
+		$[38] = runtimeOptions;
+		$[39] = seedCount;
+		$[40] = t10;
+	} else t10 = $[40];
+	let t11;
+	if ($[41] !== enabled || $[42] !== hasSeedCount || $[43] !== modelName || $[44] !== queryJson || $[45] !== queryKey || $[46] !== refreshOnMount || $[47] !== runtimeOptions) {
+		t11 = [
+			enabled,
+			modelName,
+			queryJson,
+			queryKey,
+			runtimeOptions,
+			hasSeedCount,
+			refreshOnMount
+		];
+		$[41] = enabled;
+		$[42] = hasSeedCount;
+		$[43] = modelName;
+		$[44] = queryJson;
+		$[45] = queryKey;
+		$[46] = refreshOnMount;
+		$[47] = runtimeOptions;
+		$[48] = t11;
+	} else t11 = $[48];
+	useEffect(t10, t11);
+	let t12;
+	if ($[49] !== count || $[50] !== error || $[51] !== loading || $[52] !== source) {
+		t12 = {
+			count,
+			source,
+			error,
+			loading
+		};
+		$[49] = count;
+		$[50] = error;
+		$[51] = loading;
+		$[52] = source;
+		$[53] = t12;
+	} else t12 = $[53];
+	return t12;
+};
+//#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 normalizeWindowSize = (value) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) return 1;
+	return Math.max(1, Math.min(RTS_QUERY_WINDOW_MAX_COUNT, Math.floor(value)));
+};
+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 enabled = options.enabled ?? true;
+	const ssrEnabled = options.ssr !== false;
+	const refreshOnMount = options.refreshOnMount === true;
+	const key = options.key;
+	const queryJson = serializeRtsQueryValue(query);
+	const projectionJson = options.projection ? serializeRtsQueryValue(options.projection) : "";
+	const sortJson = options.sort ? serializeRtsQueryValue(options.sort) : "";
+	const limitStr = typeof options.limit === "number" ? String(options.limit) : "";
+	const populateJson = options.populate ? serializeRtsQueryValue(options.populate) : "";
+	const paginationJson = options.pagination ? serializeRtsQueryValue(options.pagination) : "";
+	preparePopulateCacheOptions({
+		projection: options.projection,
+		populate: options.populate
+	}, "useQuery");
+	const isPaginated = Boolean(options.pagination);
+	if (options.pagination && (!Number.isInteger(options.pagination.limit) || options.pagination.limit < 1 || options.pagination.limit > 4096)) throw new Error("useQuery: pagination limit must be an integer between 1 and 4096");
+	if (options.pagination?.cursor || options.pagination?.direction) throw new Error("useQuery: cursor and direction are not supported by virtual query windows");
+	const initialWindowSize = isPaginated ? normalizeWindowSize(options.pagination?.limit) : void 0;
+	const queryKey = computeRtsQueryKey(query, {
+		key,
+		projection: options.projection,
+		sort: options.sort,
+		limit: options.limit,
+		populate: options.populate,
+		pagination: options.pagination
+	});
+	const ssrRuntime = useRtsSsrRuntime();
+	if (enabled && ssrEnabled && ssrRuntime) ssrRuntime.registerQuery({
+		modelName,
+		query,
+		options: {
+			key,
+			projection: options.projection,
+			sort: options.sort,
+			limit: options.limit,
+			populate: options.populate,
+			pagination: options.pagination
+		},
+		queryKey
+	});
+	const seedDataRaw = useMemo(() => enabled && ssrEnabled ? ssrRuntime ? ssrRuntime.getQueryData(modelName, queryKey) : peekHydratedRtsQueryData(modelName, queryKey) : void 0, [
+		enabled,
+		ssrEnabled,
+		ssrRuntime,
+		modelName,
+		queryKey
+	]);
+	const seedPageInfoRaw = useMemo(() => enabled && ssrEnabled ? ssrRuntime ? ssrRuntime.getQueryPageInfo(modelName, queryKey) : peekHydratedRtsQueryPageInfo(modelName, queryKey) : void 0, [
+		enabled,
+		ssrEnabled,
+		ssrRuntime,
+		modelName,
+		queryKey
+	]);
+	const seedTotalCountRaw = useMemo(() => enabled && ssrEnabled ? ssrRuntime ? ssrRuntime.getQueryTotalCount(modelName, queryKey) : peekHydratedRtsQueryTotalCount(modelName, queryKey) : void 0, [
+		enabled,
+		ssrEnabled,
+		ssrRuntime,
+		modelName,
+		queryKey
+	]);
+	const hasSeedData = Array.isArray(seedDataRaw);
+	const seedData = hasSeedData ? seedDataRaw : void 0;
+	const seedPageInfo = useMemo(() => normalizePageInfo(seedPageInfoRaw), [seedPageInfoRaw]);
+	const seedTotalCount = normalizeTotalCount(seedTotalCountRaw);
+	const seedJson = (() => {
+		if (!hasSeedData) return "";
+		try {
+			return JSON.stringify(seedDataRaw);
+		} catch {
+			return "";
+		}
+	})();
+	const seedPageInfoJson = (() => {
+		if (!seedPageInfo) return "";
+		try {
+			return JSON.stringify(seedPageInfo);
+		} catch {
+			return "";
+		}
+	})();
+	const seedTotalCountStr = seedTotalCount !== void 0 ? String(seedTotalCount) : "";
+	const [data, setData] = useState(() => isPaginated ? void 0 : seedData);
+	const [paginatedData, setPaginatedData] = useState(() => isPaginated ? seedData : void 0);
+	const [pageInfo, setPageInfo] = useState(() => isPaginated ? seedPageInfo : void 0);
+	const [totalCount, setTotalCount] = useState(() => isPaginated ? seedTotalCount : void 0);
+	const [source, setSource] = useState(() => hasSeedData ? "cache" : void 0);
+	const [error, setError] = useState(void 0);
+	const [loading, setLoading] = useState(enabled && !hasSeedData);
+	const hasFirstReply = useRef(false);
+	const hasNetworkReply = useRef(false);
+	const lastDataJsonRef = useRef("");
+	const pageInfoRef = useRef(seedPageInfo);
+	const requestedCountRef = useRef(initialWindowSize ?? 1);
+	const pagingRef = useRef(false);
+	useEffect(() => {
+		pageInfoRef.current = pageInfo;
+	}, [pageInfo]);
+	useEffect(() => {
+		if (!ssrRuntime && enabled && ssrEnabled && hasSeedData) consumeHydratedRtsQueryData(modelName, queryKey);
+		hasFirstReply.current = hasSeedData;
+		hasNetworkReply.current = false;
+		lastDataJsonRef.current = seedJson;
+		requestedCountRef.current = initialWindowSize ?? 1;
+		pagingRef.current = false;
+		setError(void 0);
+		if (!enabled) {
+			setLoading(false);
+			setData(void 0);
+			setPaginatedData(void 0);
+			setPageInfo(void 0);
+			setTotalCount(void 0);
+			setSource(void 0);
+			return;
+		}
+		if (hasSeedData) {
+			const nextSeedData = seedData;
+			setLoading(false);
+			setSource("cache");
+			if (isPaginated) {
+				setPaginatedData(nextSeedData);
+				setPageInfo(seedPageInfo);
+				setTotalCount(seedTotalCount);
+				setData(void 0);
+			} else {
+				setData(nextSeedData);
+				setTotalCount(void 0);
+				setPaginatedData(void 0);
+				setPageInfo(void 0);
+			}
+			return;
+		}
+		setData(void 0);
+		setPaginatedData(void 0);
+		setPageInfo(void 0);
+		setTotalCount(void 0);
+		setLoading(true);
+	}, [
+		enabled,
+		ssrEnabled,
+		ssrRuntime,
+		modelName,
+		queryKey,
+		hasSeedData,
+		seedData,
+		seedJson,
+		seedPageInfo,
+		seedPageInfoJson,
+		seedTotalCount,
+		seedTotalCountStr,
+		isPaginated,
+		initialWindowSize
+	]);
+	useEffect(() => {
+		if (!enabled) return;
+		const runInitialNetworkQuery = isPaginated || refreshOnMount || !hasSeedData;
+		const runInitialLocalQuery = !hasSeedData;
+		const unsubscribe = registerQuery(modelName, query, {
+			key,
+			projection: options.projection,
+			sort: options.sort,
+			limit: options.limit,
+			populate: options.populate,
+			pagination: options.pagination
+		}, (err, result, context) => {
+			if (context.source === "cache" && context.reset) {
+				hasFirstReply.current = false;
+				hasNetworkReply.current = false;
+				lastDataJsonRef.current = "";
+				pageInfoRef.current = void 0;
+				requestedCountRef.current = initialWindowSize ?? 1;
+				pagingRef.current = false;
+				setData(void 0);
+				setPaginatedData(void 0);
+				setPageInfo(void 0);
+				setTotalCount(void 0);
+				setSource(void 0);
+				setError(void 0);
+				setLoading(true);
+				return;
+			}
+			if (context.source === "cache" && hasNetworkReply.current && (!isPaginated || !context.window || context.window.requestedCount <= requestedCountRef.current)) return;
+			if (context.source === "network") hasNetworkReply.current = true;
+			setLoading(false);
+			if (err) {
+				setError(err);
+				return;
+			}
+			if (!Array.isArray(result)) return;
+			if (context.source === "network" && context.isLocal && options.skipLocal && hasFirstReply.current) return;
+			hasFirstReply.current = true;
+			const nextPageInfo = context.pageInfo;
+			const nextTotalCount = context.totalCount;
+			const nextRequestedCount = context.window?.requestedCount;
+			if (isPaginated && nextRequestedCount !== void 0) requestedCountRef.current = nextRequestedCount;
+			const payloadForHash = isPaginated ? {
+				result,
+				pageInfo: nextPageInfo,
+				totalCount: nextTotalCount,
+				requestedCount: nextRequestedCount
+			} : result;
+			let nextJson = "";
+			try {
+				nextJson = JSON.stringify(payloadForHash);
+			} catch {
+				nextJson = "";
+			}
+			if (nextJson && nextJson === lastDataJsonRef.current) {
+				setSource(context.source);
+				return;
+			}
+			lastDataJsonRef.current = nextJson;
+			setSource(context.source);
+			setError(void 0);
+			if (isPaginated) {
+				setPaginatedData(result);
+				setPageInfo(nextPageInfo);
+				setTotalCount(nextTotalCount);
+				return;
+			}
+			setData(result);
+			setTotalCount(void 0);
+		}, {
+			runInitialNetworkQuery,
+			runInitialLocalQuery,
+			forceRefreshOnMount: refreshOnMount,
+			...hasSeedData ? { seedSnapshot: {
+				error: null,
+				data: seedData,
+				context: {
+					source: "cache",
+					...seedPageInfo ? { pageInfo: seedPageInfo } : {},
+					...seedTotalCount !== void 0 ? { totalCount: seedTotalCount } : {},
+					...initialWindowSize ? { window: { requestedCount: initialWindowSize } } : {}
+				}
+			} } : {}
+		});
+		return () => {
+			unsubscribe?.();
+		};
+	}, [
+		enabled,
+		modelName,
+		queryKey,
+		queryJson,
+		projectionJson,
+		sortJson,
+		limitStr,
+		populateJson,
+		paginationJson,
+		hasSeedData,
+		refreshOnMount,
+		isPaginated,
+		initialWindowSize
+	]);
+	const fetchNext = async () => {
+		if (!enabled || !isPaginated || !options.pagination) return false;
+		if (pagingRef.current || !pageInfoRef.current?.hasNextPage) return false;
+		const pageSize = initialWindowSize ?? normalizeWindowSize(options.pagination.limit);
+		const nextRequestedCount_0 = Math.min(RTS_QUERY_WINDOW_MAX_COUNT, requestedCountRef.current + pageSize);
+		if (nextRequestedCount_0 === requestedCountRef.current) return false;
+		pagingRef.current = true;
+		setLoading(true);
+		setError(void 0);
+		try {
+			return await setQueryWindowSize({
+				modelName,
+				query,
+				options: {
+					key,
+					projection: options.projection,
+					sort: options.sort,
+					limit: options.limit,
+					populate: options.populate,
+					pagination: options.pagination
+				},
+				requestedCount: nextRequestedCount_0
+			});
+		} catch (err_0) {
+			setError(err_0);
+			return false;
+		} finally {
+			pagingRef.current = false;
+			setLoading(false);
+		}
+	};
+	const fetchPrevious = async () => {
+		return false;
+	};
+	const resetPagination = () => {
+		if (!enabled || !isPaginated || !options.pagination || !initialWindowSize) return;
+		if (pagingRef.current || requestedCountRef.current === initialWindowSize) return;
+		pagingRef.current = true;
+		setLoading(true);
+		setError(void 0);
+		setQueryWindowSize({
+			modelName,
+			query,
+			options: {
+				key,
+				projection: options.projection,
+				sort: options.sort,
+				limit: options.limit,
+				populate: options.populate,
+				pagination: options.pagination
+			},
+			requestedCount: initialWindowSize
+		}).finally(() => {
+			pagingRef.current = false;
+			setLoading(false);
+		});
+	};
+	return {
+		data: isPaginated ? paginatedData : data,
+		pageInfo: isPaginated ? pageInfo : void 0,
+		totalCount: isPaginated ? totalCount : void 0,
+		source,
+		error,
+		loading,
+		fetchNext,
+		fetchPrevious,
+		resetPagination
+	};
+};
+//#endregion
+//#region src/rts/useRtsConnection.ts
+var activeConsumers = 0;
+var connectedKey = null;
+var pendingDisconnectTimer = null;
+var cancelPendingDisconnect = () => {
+	if (pendingDisconnectTimer !== null) {
+		clearTimeout(pendingDisconnectTimer);
+		pendingDisconnectTimer = null;
+	}
+};
+var useRtsConnection = (tenantId, uid, options = {}) => {
+	const tenantIdValue = typeof tenantId === "string" ? tenantId.trim() : "";
+	const uidValue = typeof uid === "string" ? uid.trim() : "";
+	const optionsJson = serializeRtsQueryValue(options);
+	const optionsRef = useRef(options);
+	optionsRef.current = options;
+	useEffect(() => {
+		if (typeof window === "undefined") return;
+		if (!tenantIdValue || !uidValue) return;
+		activeConsumers += 1;
+		cancelPendingDisconnect();
+		const key = `${tenantIdValue}::${uidValue}::${optionsJson}`;
+		if (connectedKey !== key) {
+			connectedKey = key;
+			reconnect(tenantIdValue, uidValue, optionsRef.current).catch((error) => {
+				connectedKey = null;
+				console.error("RTS connection failed", error);
+			});
+		}
+		return () => {
+			activeConsumers -= 1;
+			if (activeConsumers > 0) return;
+			pendingDisconnectTimer = setTimeout(() => {
+				pendingDisconnectTimer = null;
+				if (activeConsumers > 0) return;
+				connectedKey = null;
+				disconnect();
+			}, 0);
+		};
+	}, [
+		tenantIdValue,
+		uidValue,
+		optionsJson
+	]);
+};
+//#endregion
+export { clearHydratedRtsQueryData as A, destroyCollection as C, updateDocs as D, runQuery as E, peekHydratedRtsQueryPageInfo as F, peekHydratedRtsQueryTotalCount as I, hydrateRtsFromWindow as M, peekHydratedRtsCount as N, RtsSsrRuntimeProvider as O, peekHydratedRtsQueryData as P, destroyAllCollections as S, resetRtsPouchStore as T, sendMessage as _, connect as a, configureRtsPouchStore as b, getConnectionStatus as c, onRtsMessage as d, reconnect as f, runNetworkQuery as g, runNetworkCount as h, addLocalTxn as i, consumeHydratedRtsCount as j, STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY as k, onConnectionStatusChange as l, registerQuery as m, useQuery as n, disconnect as o, registerCount as p, useCountQuery as r, getConnectionError as s, useRtsConnection as t, onMessage as u, sendRtsMessage as v, getCollection as w, deleteDocs as x, syncRtsChanges as y };
+
+//# sourceMappingURL=rts-C9lvbdZX.js.map