@rpcbase/client 0.326.0 → 0.328.0

package/dist/rts/pouchStore.d.ts

@@ -0,0 +1,39 @@
+type PouchDbDatabase = {
+    find: (options: Record<string, unknown>) => Promise<{
+        docs: Record<string, unknown>[];
+    }>;
+    bulkDocs: (docs: Record<string, unknown>[]) => Promise<unknown>;
+    destroy: () => Promise<unknown>;
+};
+export type RtsPouchStoreConfig = {
+    tenantId: string;
+    appName?: string;
+    prefix?: string;
+};
+export type RtsPouchQueryOptions = {
+    uid: string;
+    projection?: Record<string, 0 | 1>;
+    sort?: Record<string, 1 | -1>;
+    limit?: number;
+};
+export type RtsPouchQueryContext = {
+    source: "cache";
+};
+export declare const configureRtsPouchStore: (config: RtsPouchStoreConfig | null) => void;
+export declare const getCollection: (modelName: string, options: {
+    uid: string;
+}) => Promise<PouchDbDatabase>;
+export declare const runQuery: <T extends Record<string, unknown>>({ modelName, query, options, }: {
+    modelName: string;
+    query?: Record<string, unknown>;
+    options: RtsPouchQueryOptions;
+}) => Promise<{
+    data: T[];
+    context: RtsPouchQueryContext;
+}>;
+export declare const updateDocs: (modelName: string, data: Array<Record<string, unknown> & {
+    _id: string;
+}>, uid: string) => Promise<void>;
+export declare const destroyAllCollections: () => Promise<void>;
+export {};
+//# sourceMappingURL=pouchStore.d.ts.map

package/dist/rts/pouchStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pouchStore.d.ts","sourceRoot":"","sources":["../../src/rts/pouchStore.ts"],"names":[],"mappings":"AAMA,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;KAAE,CAAC,CAAA;IACxF,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAC/D,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,GAAG,EAAE,MAAM,CAAA;IACX,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AA8DD,eAAO,MAAM,sBAAsB,GAAI,QAAQ,mBAAmB,GAAG,IAAI,SAGxE,CAAA;AAED,eAAO,MAAM,aAAa,GAAU,WAAW,MAAM,EAAE,SAAS;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,KAAG,OAAO,CAAC,eAAe,CAaxG,CAAA;AAqED,eAAO,MAAM,QAAQ,GAAU,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,gCAI/D;IACD,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,OAAO,EAAE,oBAAoB,CAAA;CAC9B,KAAG,OAAO,CAAC;IAAE,IAAI,EAAE,CAAC,EAAE,CAAC;IAAC,OAAO,EAAE,oBAAoB,CAAA;CAAE,CAqCvD,CAAA;AAED,eAAO,MAAM,UAAU,GACrB,WAAW,MAAM,EACjB,MAAM,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,EACtD,KAAK,MAAM,KACV,OAAO,CAAC,IAAI,CAqCd,CAAA;AAED,eAAO,MAAM,qBAAqB,QAAa,OAAO,CAAC,IAAI,CAI1D,CAAA"}

package/dist/rts/useQuery.d.ts

@@ -0,0 +1,14 @@
+import { RtsQueryContext, RtsQueryOptions } from './wsClient';
+type JsonObject = Record<string, unknown>;
+export type UseRtsQueryOptions = RtsQueryOptions & {
+    skipLocal?: boolean;
+};
+export type UseRtsQueryResult<T> = {
+    data: T[] | undefined;
+    source: RtsQueryContext["source"] | undefined;
+    error: unknown | undefined;
+    loading: boolean;
+};
+export declare const useQuery: <T extends Record<string, unknown> = Record<string, unknown>>(modelName: string, query?: JsonObject, options?: UseRtsQueryOptions) => UseRtsQueryResult<T>;
+export {};
+//# sourceMappingURL=useQuery.d.ts.map

package/dist/rts/useQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQuery.d.ts","sourceRoot":"","sources":["../../src/rts/useQuery.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAIlE,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,eAAe,GAAG;IACjD,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI;IACjC,IAAI,EAAE,CAAC,EAAE,GAAG,SAAS,CAAA;IACrB,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAA;IAC7C,KAAK,EAAE,OAAO,GAAG,SAAS,CAAA;IAC1B,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAED,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClF,WAAW,MAAM,EACjB,QAAO,UAAe,EACtB,UAAS,kBAAuB,KAC/B,iBAAiB,CAAC,CAAC,CA2FrB,CAAA"}

package/dist/rts/wsClient.d.ts

@@ -0,0 +1,37 @@
+type JsonObject = Record<string, unknown>;
+export type RtsNetworkQueryContext = {
+    source: "network";
+    isLocal: boolean;
+    txnId?: string;
+};
+export type RtsCacheQueryContext = {
+    source: "cache";
+};
+export type RtsQueryContext = RtsNetworkQueryContext | RtsCacheQueryContext;
+export type RtsQueryOptions = {
+    key?: string;
+    projection?: Record<string, 0 | 1>;
+    sort?: Record<string, 1 | -1>;
+    limit?: number;
+};
+export type RtsConnectOptions = {
+    url?: string;
+    path?: string;
+    appName?: string;
+    configureStore?: boolean;
+    reconnect?: {
+        attempts?: number;
+        delayMs?: number;
+        delayMaxMs?: number;
+    };
+};
+type QueryCallback = (error: unknown | null, data: unknown, context: RtsQueryContext) => void;
+export declare const addLocalTxn: (txnId: string) => void;
+export declare const connect: (tenantId: string, uid: string, options?: RtsConnectOptions) => Promise<void>;
+export declare const disconnect: () => void;
+export declare const reconnect: (tenantId: string, uid: string, options?: RtsConnectOptions) => Promise<void>;
+export declare const registerQuery: (modelName: string, query: JsonObject, optionsOrCallback?: RtsQueryOptions | QueryCallback, callbackMaybe?: QueryCallback) => (() => void) | undefined;
+export declare const sendMessage: (event: string, payload?: unknown) => void;
+export declare const onMessage: (event: string, callback: (payload: unknown) => void) => (() => void);
+export {};
+//# sourceMappingURL=wsClient.d.ts.map

package/dist/rts/wsClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wsClient.d.ts","sourceRoot":"","sources":["../../src/rts/wsClient.ts"],"names":[],"mappings":"AAGA,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,SAAS,CAAA;IACjB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,sBAAsB,GAAG,oBAAoB,CAAA;AAE3E,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,SAAS,CAAC,EAAE;QACV,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,UAAU,CAAC,EAAE,MAAM,CAAA;KACpB,CAAA;CACF,CAAA;AAED,KAAK,aAAa,GAAG,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,eAAe,KAAK,IAAI,CAAA;AA2K7F,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,KAAG,IAM3C,CAAA;AAoED,eAAO,MAAM,OAAO,GAAI,UAAU,MAAM,EAAE,KAAK,MAAM,EAAE,UAAS,iBAAsB,KAAG,OAAO,CAAC,IAAI,CAEpG,CAAA;AAED,eAAO,MAAM,UAAU,QAAO,IAY7B,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,UAAU,MAAM,EAAE,KAAK,MAAM,EAAE,UAAS,iBAAsB,KAAG,OAAO,CAAC,IAAI,CAGtG,CAAA;AAED,eAAO,MAAM,aAAa,GACxB,WAAW,MAAM,EACjB,OAAO,UAAU,EACjB,oBAAoB,eAAe,GAAG,aAAa,EACnD,gBAAgB,aAAa,KAC5B,CAAC,MAAM,IAAI,CAAC,GAAG,SAsDjB,CAAA;AAED,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,UAAU,OAAO,KAAG,IAE9D,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,EAAE,UAAU,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,KAAG,CAAC,MAAM,IAAI,CAU1F,CAAA"}

package/dist/rts.d.ts

@@ -0,0 +1,25 @@
+export { configureRtsPouchStore, destroyAllCollections, getCollection, runQuery, updateDocs, type RtsPouchQueryContext, type RtsPouchQueryOptions, type RtsPouchStoreConfig, } from './rts/pouchStore';
+export { addLocalTxn, connect, disconnect, onMessage, reconnect, registerQuery, sendMessage, type RtsConnectOptions, type RtsQueryContext, type RtsQueryOptions, } from './rts/wsClient';
+export { useQuery, type UseRtsQueryOptions, type UseRtsQueryResult, } from './rts/useQuery';
+export declare const get_collection: (modelName: string, options: {
+    uid: string;
+}) => Promise<{
+    find: (options: Record<string, unknown>) => Promise<{
+        docs: Record<string, unknown>[];
+    }>;
+    bulkDocs: (docs: Record<string, unknown>[]) => Promise<unknown>;
+    destroy: () => Promise<unknown>;
+}>;
+export declare const run_query: <T extends Record<string, unknown>>({ modelName, query, options, }: {
+    modelName: string;
+    query?: Record<string, unknown>;
+    options: import('./rts/pouchStore').RtsPouchQueryOptions;
+}) => Promise<{
+    data: T[];
+    context: import('./rts/pouchStore').RtsPouchQueryContext;
+}>;
+export declare const update_docs: (modelName: string, data: Array<Record<string, unknown> & {
+    _id: string;
+}>, uid: string) => Promise<void>;
+export declare const destroy_all: () => Promise<void>;
+//# sourceMappingURL=rts.d.ts.map

package/dist/rts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rts.d.ts","sourceRoot":"","sources":["../src/rts.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,qBAAqB,EACrB,aAAa,EACb,QAAQ,EACR,UAAU,EACV,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,WAAW,EACX,OAAO,EACP,UAAU,EACV,SAAS,EACT,SAAS,EACT,aAAa,EACb,WAAW,EACX,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EACL,QAAQ,EACR,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,GACvB,MAAM,gBAAgB,CAAA;AAKvB,eAAO,MAAM,cAAc;;;;;;;;EAAgB,CAAA;AAC3C,eAAO,MAAM,SAAS;;SAGigI,CAAC;;;;;EAHv/H,CAAA;AACjC,eAAO,MAAM,WAAW;;iCAAa,CAAA;AACrC,eAAO,MAAM,WAAW,qBAAwB,CAAA"}

package/dist/rts.js

@@ -0,0 +1,534 @@
+import { useId, useState, useRef, useEffect, useMemo } from "react";
+const UNDERSCORE_PREFIX = "$_";
+const DEFAULT_FIND_LIMIT = 4096;
+let storeConfig = null;
+let pouchDbPromise = null;
+let lastAppliedPrefix = null;
+const collections = /* @__PURE__ */ new Map();
+const unwrapDefault = (mod) => mod?.default ?? mod;
+const ensureBrowser$1 = () => {
+  if (typeof window === "undefined") {
+    throw new Error("RTS PouchDB store can only be used in the browser");
+  }
+};
+const getPrefix = () => {
+  if (!storeConfig) {
+    throw new Error("RTS PouchDB store is not configured");
+  }
+  if (storeConfig.prefix) return storeConfig.prefix;
+  let prefix = "rb/";
+  if (storeConfig.appName) prefix += `${storeConfig.appName}/`;
+  prefix += `${storeConfig.tenantId}/`;
+  return prefix;
+};
+const getPouchDb = async () => {
+  ensureBrowser$1();
+  if (!pouchDbPromise) {
+    pouchDbPromise = (async () => {
+      const [core, indexedDbAdapter, findPlugin] = await Promise.all([
+        import("pouchdb-core"),
+        import("pouchdb-adapter-indexeddb"),
+        import("pouchdb-find")
+      ]);
+      const PouchDB = unwrapDefault(core);
+      PouchDB.plugin(unwrapDefault(indexedDbAdapter));
+      PouchDB.plugin(unwrapDefault(findPlugin));
+      return PouchDB;
+    })();
+  }
+  return pouchDbPromise;
+};
+const applyPrefix = (PouchDB) => {
+  const prefix = getPrefix();
+  if (prefix === lastAppliedPrefix) return;
+  PouchDB.prefix = prefix;
+  lastAppliedPrefix = prefix;
+};
+const configureRtsPouchStore = (config) => {
+  storeConfig = config;
+  lastAppliedPrefix = null;
+};
+const getCollection = async (modelName, options) => {
+  const PouchDB = await getPouchDb();
+  applyPrefix(PouchDB);
+  const prefix = getPrefix();
+  const dbKey = `${prefix}${options.uid}/${modelName}`;
+  const existing = collections.get(dbKey);
+  if (existing) return existing;
+  const db = new PouchDB(`${options.uid}/${modelName}`, { adapter: "indexeddb", revs_limit: 1 });
+  collections.set(dbKey, db);
+  return db;
+};
+const replaceQueryKeys = (value, replaceKey) => {
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => replaceQueryKeys(item, replaceKey));
+  }
+  const obj = value;
+  const next = Object.create(Object.getPrototypeOf(obj));
+  for (const key of Object.keys(obj)) {
+    if (/^\$/.test(key) || /\.\d+$/.test(key)) {
+      throw new Error(`replaceQueryKeys: Unexpected key format: ${key}`);
+    }
+    const newKey = replaceKey(key);
+    next[newKey] = replaceQueryKeys(obj[key], replaceKey);
+  }
+  return next;
+};
+const getKeys = (obj, parentKey = "") => {
+  const keys = [];
+  for (const key of Object.keys(obj)) {
+    const nextKey = parentKey ? `${parentKey}.${key}` : key;
+    const value = obj[key];
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+      keys.push(...getKeys(value, nextKey));
+    } else {
+      keys.push(nextKey);
+    }
+  }
+  return keys;
+};
+const satisfiesProjection = (doc, projection) => {
+  const docKeys = new Set(getKeys(doc));
+  const projectionKeys = new Set(Object.keys(projection).filter((key) => projection[key] === 1));
+  if (!projectionKeys.has("_id")) {
+    docKeys.delete("_id");
+  }
+  if (projectionKeys.size > docKeys.size) return false;
+  for (const key of projectionKeys) {
+    if (!docKeys.has(key)) return false;
+  }
+  return true;
+};
+const remapDocFromStorage = (doc) => {
+  const next = {};
+  for (const [key, value] of Object.entries(doc)) {
+    const newKey = key.startsWith(UNDERSCORE_PREFIX) ? key.replace(/^\$_/, "") : key;
+    next[newKey] = value;
+  }
+  return next;
+};
+const runQuery = async ({
+  modelName,
+  query = {},
+  options
+}) => {
+  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
+  });
+  let mappedDocs = docs.map(({ _rev: _revIgnored, ...rest }) => remapDocFromStorage(rest));
+  if (options.projection) {
+    mappedDocs = mappedDocs.filter((doc) => satisfiesProjection(doc, options.projection));
+  }
+  if (options.sort) {
+    mappedDocs = mappedDocs.sort((a, b) => {
+      for (const key of Object.keys(options.sort)) {
+        if (!Object.hasOwn(a, key) || !Object.hasOwn(b, key)) continue;
+        const dir = options.sort[key];
+        const aVal = a[key];
+        const bVal = b[key];
+        if (aVal < bVal) return -1 * dir;
+        if (aVal > bVal) return 1 * dir;
+      }
+      return 0;
+    });
+  }
+  return { data: mappedDocs, context: { source: "cache" } };
+};
+const updateDocs = async (modelName, data, uid) => {
+  const collection = await getCollection(modelName, { uid });
+  const allIds = data.map((doc) => doc._id).filter(Boolean);
+  if (!allIds.length) return;
+  const { docs: currentDocs } = await collection.find({
+    selector: { _id: { $in: allIds } },
+    fields: ["_id", "_rev"],
+    limit: allIds.length
+  });
+  const currentDocsById = currentDocs.reduce((acc, doc) => {
+    const id = String(doc._id ?? "");
+    if (id) acc[id] = doc;
+    return acc;
+  }, {});
+  const newDocs = data.map((mongoDoc) => {
+    const currentDoc = currentDocsById[mongoDoc._id] ?? { _id: mongoDoc._id };
+    const nextDoc = Object.entries(mongoDoc).reduce((acc, [key, value]) => {
+      const newKey = key !== "_id" && key.startsWith("_") ? `${UNDERSCORE_PREFIX}${key}` : key;
+      acc[newKey] = value;
+      return acc;
+    }, { ...currentDoc });
+    const rev = currentDoc._rev;
+    if (typeof rev === "string" && rev) {
+      nextDoc._rev = rev;
+    } else {
+      delete nextDoc._rev;
+    }
+    return nextDoc;
+  });
+  await collection.bulkDocs(newDocs);
+};
+const destroyAllCollections = async () => {
+  const dbs = Array.from(collections.values());
+  await Promise.all(dbs.map((db) => db.destroy()));
+  collections.clear();
+};
+const TENANT_ID_QUERY_PARAM = "rb-tenant-id";
+const MAX_TXN_BUF = 2048;
+let socket = null;
+let connectPromise = null;
+let explicitDisconnect = false;
+let currentTenantId = null;
+let currentUid = null;
+let connectOptions = {};
+const localTxnBuf = [];
+const queryCallbacks = /* @__PURE__ */ new Map();
+const subscriptions = /* @__PURE__ */ new Map();
+const messageCallbacks = /* @__PURE__ */ new Map();
+let reconnectTimer = null;
+let reconnectAttempts = 0;
+const ensureBrowser = () => {
+  if (typeof window === "undefined") {
+    throw new Error("RTS websocket client can only be used in the browser");
+  }
+};
+const buildSocketUrl = (tenantId, _uid, options) => {
+  if (options.url) {
+    const url = new URL(options.url);
+    url.searchParams.set(TENANT_ID_QUERY_PARAM, tenantId);
+    return url.toString();
+  }
+  const base = new URL(window.location.href);
+  base.protocol = base.protocol === "https:" ? "wss:" : "ws:";
+  base.pathname = options.path ?? "/rts";
+  base.search = "";
+  base.hash = "";
+  base.searchParams.set(TENANT_ID_QUERY_PARAM, tenantId);
+  return base.toString();
+};
+const computeQueryKey = (query, options) => {
+  const key = options.key ?? "";
+  const projection = options.projection ? JSON.stringify(options.projection) : "";
+  const sort = options.sort ? JSON.stringify(options.sort) : "";
+  const limit = typeof options.limit === "number" ? String(options.limit) : "";
+  return `${key}${JSON.stringify(query)}${projection}${sort}${limit}`;
+};
+const sendToServer = (message) => {
+  if (!socket) return;
+  if (socket.readyState !== WebSocket.OPEN) return;
+  socket.send(JSON.stringify(message));
+};
+const resubscribeAll = () => {
+  for (const sub of subscriptions.values()) {
+    sendToServer({
+      type: "registerQuery",
+      modelName: sub.modelName,
+      queryKey: sub.queryKey,
+      query: sub.query,
+      options: sub.options
+    });
+    sendToServer({
+      type: "run_query",
+      modelName: sub.modelName,
+      queryKey: sub.queryKey,
+      query: sub.query,
+      options: sub.options
+    });
+  }
+};
+const clearReconnectTimer = () => {
+  if (reconnectTimer === null) return;
+  if (typeof window !== "undefined") {
+    window.clearTimeout(reconnectTimer);
+  }
+  reconnectTimer = null;
+};
+const scheduleReconnect = () => {
+  clearReconnectTimer();
+  if (explicitDisconnect) 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;
+  const delay = Math.min(delayMaxMs, delayMs * Math.pow(2, reconnectAttempts));
+  reconnectAttempts += 1;
+  reconnectTimer = window.setTimeout(() => {
+    void connectInternal(currentTenantId, currentUid, connectOptions, { resetReconnectAttempts: false });
+  }, delay);
+};
+const handleQueryPayload = (payload) => {
+  const { modelName, queryKey, data, error, txnId } = payload;
+  const cbKey = `${modelName}.${queryKey}`;
+  const callbacks = queryCallbacks.get(cbKey);
+  if (!callbacks || !callbacks.size) return;
+  const isLocal = !!(txnId && localTxnBuf.includes(txnId));
+  const context = { source: "network", isLocal, txnId };
+  if (error) {
+    for (const cb of callbacks) cb(error, void 0, context);
+    return;
+  }
+  for (const cb of callbacks) cb(null, data, context);
+  if (!currentUid) return;
+  if (!Array.isArray(data)) return;
+  void updateDocs(modelName, data, currentUid).catch(() => {
+  });
+};
+const handleEvent = (payload) => {
+  const callbacks = messageCallbacks.get(payload.event);
+  if (!callbacks || !callbacks.size) return;
+  for (const cb of callbacks) cb(payload.payload);
+};
+const handleMessage = (event) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(typeof event.data === "string" ? event.data : String(event.data));
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object") return;
+  const message = parsed;
+  if (message.type === "query_payload") {
+    handleQueryPayload(message);
+    return;
+  }
+  if (message.type === "event") {
+    handleEvent(message);
+  }
+};
+const addLocalTxn = (txnId) => {
+  if (!txnId) return;
+  localTxnBuf.push(txnId);
+  if (localTxnBuf.length > MAX_TXN_BUF) {
+    localTxnBuf.shift();
+  }
+};
+const connectInternal = (tenantId, uid, options, { resetReconnectAttempts }) => {
+  ensureBrowser();
+  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();
+  }
+  explicitDisconnect = false;
+  clearReconnectTimer();
+  const url = buildSocketUrl(tenantId, uid, options);
+  connectPromise = new Promise((resolve, reject) => {
+    if (resetReconnectAttempts) reconnectAttempts = 0;
+    let opened = false;
+    let settled = false;
+    socket = new WebSocket(url);
+    socket.addEventListener("open", () => {
+      opened = true;
+      settled = true;
+      reconnectAttempts = 0;
+      resubscribeAll();
+      resolve();
+    });
+    socket.addEventListener("message", handleMessage);
+    socket.addEventListener("close", (event) => {
+      if (!opened && !settled) {
+        settled = true;
+        reject(new Error(`RTS WebSocket closed before opening (code=${event.code})`));
+      }
+      socket = null;
+      connectPromise = null;
+      scheduleReconnect();
+    });
+    socket.addEventListener("error", (err) => {
+      if (settled) return;
+      settled = true;
+      reject(err instanceof Error ? err : new Error("RTS WebSocket error"));
+    });
+  });
+  return connectPromise;
+};
+const connect = (tenantId, uid, options = {}) => {
+  return connectInternal(tenantId, uid, options, { resetReconnectAttempts: true });
+};
+const disconnect = () => {
+  explicitDisconnect = true;
+  clearReconnectTimer();
+  if (socket) {
+    try {
+      socket.close();
+    } catch {
+    }
+  }
+  socket = null;
+  connectPromise = null;
+};
+const reconnect = (tenantId, uid, options = {}) => {
+  disconnect();
+  return connect(tenantId, uid, options);
+};
+const registerQuery = (modelName, query, optionsOrCallback, callbackMaybe) => {
+  let options;
+  let callback;
+  if (typeof optionsOrCallback === "function") {
+    options = {};
+    callback = optionsOrCallback;
+  } else {
+    options = optionsOrCallback ?? {};
+    callback = callbackMaybe;
+  }
+  if (!callback) return void 0;
+  if (!modelName) return void 0;
+  const queryKey = computeQueryKey(query, options);
+  const cbKey = `${modelName}.${queryKey}`;
+  const set = queryCallbacks.get(cbKey) ?? /* @__PURE__ */ new Set();
+  set.add(callback);
+  queryCallbacks.set(cbKey, set);
+  subscriptions.set(cbKey, { modelName, query, options, queryKey });
+  if (currentUid) {
+    void runQuery({
+      modelName,
+      query,
+      options: {
+        uid: currentUid,
+        projection: options.projection,
+        sort: options.sort,
+        limit: options.limit
+      }
+    }).then(({ data, context }) => {
+      callback?.(null, data, context);
+    }).catch(() => {
+    });
+  }
+  sendToServer({ type: "run_query", modelName, queryKey, query, options });
+  sendToServer({ type: "registerQuery", modelName, queryKey, query, options });
+  return () => {
+    sendToServer({ type: "remove_query", modelName, queryKey });
+    const callbacks = queryCallbacks.get(cbKey);
+    callbacks?.delete(callback);
+    if (callbacks && callbacks.size === 0) {
+      queryCallbacks.delete(cbKey);
+      subscriptions.delete(cbKey);
+    }
+  };
+};
+const sendMessage = (event, payload) => {
+  sendToServer({ type: "event", event, payload });
+};
+const onMessage = (event, callback) => {
+  const set = messageCallbacks.get(event) ?? /* @__PURE__ */ new Set();
+  set.add(callback);
+  messageCallbacks.set(event, set);
+  return () => {
+    const callbacks = messageCallbacks.get(event);
+    callbacks?.delete(callback);
+    if (callbacks && callbacks.size === 0) messageCallbacks.delete(event);
+  };
+};
+const useQuery = (modelName, query = {}, options = {}) => {
+  const id = useId();
+  const key = options.key ?? id;
+  const projectionJson = options.projection ? JSON.stringify(options.projection) : "";
+  const sortJson = options.sort ? JSON.stringify(options.sort) : "";
+  const limitStr = typeof options.limit === "number" ? String(options.limit) : "";
+  const [data, setData] = useState(void 0);
+  const [source, setSource] = useState(void 0);
+  const [error, setError] = useState(void 0);
+  const [loading, setLoading] = useState(true);
+  const hasFirstReply = useRef(false);
+  const hasNetworkReply = useRef(false);
+  const lastDataJsonRef = useRef("");
+  useEffect(() => {
+    hasFirstReply.current = false;
+    hasNetworkReply.current = false;
+    lastDataJsonRef.current = "";
+    setLoading(true);
+    setError(void 0);
+  }, [modelName, key, JSON.stringify(query), projectionJson, sortJson, limitStr]);
+  useEffect(() => {
+    if (!modelName) return;
+    const unsubscribe = registerQuery(
+      modelName,
+      query,
+      {
+        key,
+        projection: options.projection,
+        sort: options.sort,
+        limit: options.limit
+      },
+      (err, result, context) => {
+        if (context.source === "cache" && hasNetworkReply.current) return;
+        if (context.source === "network") {
+          hasNetworkReply.current = true;
+        }
+        setLoading(false);
+        if (err) {
+          setError(err);
+          return;
+        }
+        if (!Array.isArray(result)) return;
+        if (context.source === "network" && context.isLocal && options.skipLocal && hasFirstReply.current) {
+          return;
+        }
+        hasFirstReply.current = true;
+        let nextJson = "";
+        try {
+          nextJson = JSON.stringify(result);
+        } catch {
+          nextJson = "";
+        }
+        if (nextJson && nextJson === lastDataJsonRef.current) {
+          setSource(context.source);
+          return;
+        }
+        lastDataJsonRef.current = nextJson;
+        setSource(context.source);
+        setData(result);
+      }
+    );
+    return () => {
+      unsubscribe?.();
+    };
+  }, [modelName, key, JSON.stringify(query), projectionJson, sortJson, limitStr]);
+  return useMemo(
+    () => ({
+      data,
+      source,
+      error,
+      loading
+    }),
+    [data, source, error, loading]
+  );
+};
+const get_collection = getCollection;
+const run_query = runQuery;
+const update_docs = updateDocs;
+const destroy_all = destroyAllCollections;
+export {
+  addLocalTxn,
+  configureRtsPouchStore,
+  connect,
+  destroyAllCollections,
+  destroy_all,
+  disconnect,
+  getCollection,
+  get_collection,
+  onMessage,
+  reconnect,
+  registerQuery,
+  runQuery,
+  run_query,
+  sendMessage,
+  updateDocs,
+  update_docs,
+  useQuery
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rpcbase/client",
-  "version": "0.326.0",
+  "version": "0.328.0",
   "type": "module",
   "files": [
     "dist"
@@ -13,6 +13,11 @@
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     },
+    "./rts": {
+      "types": "./dist/rts.d.ts",
+      "import": "./dist/rts.js",
+      "default": "./dist/rts.js"
+    },
     "./instrument": {
       "types": "./dist/instrument.d.ts",
       "import": "./dist/instrument.js",
@@ -60,6 +65,12 @@
       }
     }
   },
+  "dependencies": {
+    "events": "3.3.0",
+    "pouchdb-adapter-indexeddb": "9.0.0",
+    "pouchdb-core": "9.0.0",
+    "pouchdb-find": "9.0.0"
+  },
   "peerDependencies": {
     "axios": "^1.13"
   },