@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/replication/trystero/types.d.ts

@@ -0,0 +1,95 @@
+import type { JsonLike } from "../../rpc/index.js";
+import type { P2PSyncSetting, EntryDoc } from "../../common/types.js";
+import type { SimpleStore } from "../../common/utils.js";
+import type { Confirm } from "../../interfaces/Confirm.js";
+import type { AsyncActivityRunner } from "../../interfaces/AsyncActivityRunner.js";
+import type { LiveSyncEventHub } from "../../hub/hub.js";
+import type { MessageTranslator } from "../../services/base/MessageTranslator.js";
+export declare const DIRECTION_REQUEST = "request";
+export type DIRECTION_REQUEST = typeof DIRECTION_REQUEST;
+export declare const DIRECTION_RESPONSE = "response";
+export type DIRECTION_RESPONSE = typeof DIRECTION_RESPONSE;
+export declare const DEFAULT_RPC_TIMEOUT = 30000;
+export declare const BULK_GET_RPC_TIMEOUT = 40000;
+export type BindableFunction = (...args: any[]) => any;
+export type NonPrivateMethodKeys<T> = {
+    [K in keyof T]: K extends `_${string}` ? never : K extends `constructor` ? never : T[K] extends BindableFunction ? K : never;
+}[keyof T];
+export type BindableObject<T = any> = {
+    [k in NonPrivateMethodKeys<T>]: T[k] extends BindableFunction ? T[k] : never;
+};
+export type ConnectionInfo = {
+    relayURIs: string[];
+    roomId: string;
+    password: string;
+    appId: string;
+};
+export declare class ResponsePreventedError extends Error {
+    constructor(message: string);
+}
+export type Request<T = JsonLike[]> = {
+    type: string;
+    direction: DIRECTION_REQUEST;
+    seq: number;
+    args: T;
+};
+export type Response<T = JsonLike> = {
+    type: string;
+    direction: DIRECTION_RESPONSE;
+    seq: number;
+    data?: T;
+    error?: JsonLike;
+};
+export type DeviceInfo = {
+    currentPeerId: string;
+    name?: string;
+    version?: string;
+    platform?: string;
+    decision?: DeviceDecisions;
+};
+export type DeviceInfoForRequest = {
+    currentPeerId: string;
+    name: string;
+};
+export type FullFilledDeviceInfo = {
+    currentPeerId: string;
+    name: string;
+    version: string;
+    platform: string;
+    decision?: DeviceDecisions;
+};
+export declare enum DeviceDecisions {
+    ACCEPT = "accepted",
+    REJECT = "rejected",
+    IGNORE = "ignore"
+}
+export declare const ID_P2PKnownDevices = "_local/P2PKnownDevices";
+export type KnownDevices = {
+    _id: typeof ID_P2PKnownDevices;
+    devices: {
+        [deviceName: string]: DeviceDecisions;
+    };
+};
+export type Payload = Request | Response;
+export interface ReplicatorHost {
+    deviceName: string;
+    platform: string;
+    confirm: Confirm;
+}
+export interface ReplicatorHostEnv extends ReplicatorHost {
+    /** Event channel owned by the containing Commonlib service composition. */
+    events: LiveSyncEventHub;
+    /** Message translation owned by the containing Commonlib service composition. */
+    translate: MessageTranslator;
+    settings: P2PSyncSetting;
+    db: PouchDB.Database<EntryDoc>;
+    simpleStore: SimpleStore<unknown>;
+    runFiniteReplicationActivity?: AsyncActivityRunner["run"];
+    processReplicatedDocs(docs: Array<PouchDB.Core.ExistingDocument<EntryDoc>>): void | Promise<void>;
+}
+export type Advertisement = {
+    peerId: string;
+    name: string;
+    platform: string;
+};
+export declare const KEY_DEVICE_DECISIONS = "p2p-device-decisions";

package/dist/replication/trystero/types.js

@@ -0,0 +1,27 @@
+const DIRECTION_REQUEST = "request";
+const DIRECTION_RESPONSE = "response";
+const DEFAULT_RPC_TIMEOUT = 3e4;
+const BULK_GET_RPC_TIMEOUT = 4e4;
+class ResponsePreventedError extends Error {
+  constructor(message) {
+    super(`Response prevented: ${message}`);
+  }
+}
+var DeviceDecisions = /* @__PURE__ */ ((DeviceDecisions2) => {
+  DeviceDecisions2["ACCEPT"] = "accepted";
+  DeviceDecisions2["REJECT"] = "rejected";
+  DeviceDecisions2["IGNORE"] = "ignore";
+  return DeviceDecisions2;
+})(DeviceDecisions || {});
+const ID_P2PKnownDevices = "_local/P2PKnownDevices";
+const KEY_DEVICE_DECISIONS = "p2p-device-decisions";
+export {
+  BULK_GET_RPC_TIMEOUT,
+  DEFAULT_RPC_TIMEOUT,
+  DIRECTION_REQUEST,
+  DIRECTION_RESPONSE,
+  DeviceDecisions,
+  ID_P2PKnownDevices,
+  KEY_DEVICE_DECISIONS,
+  ResponsePreventedError
+};

package/dist/replication/trystero/useP2PReplicatorCommands.d.ts

@@ -0,0 +1,7 @@
+import type { NecessaryServices } from "../../interfaces/ServiceModule.js";
+import type { UseP2PReplicatorResult } from "./UseP2PReplicatorResult.js";
+/**
+ * ServiceFeature: Registers event handlers for P2P replication and manages the lifecycle of a LiveSyncTrysteroReplicator instance.
+ * @param host
+ */
+export declare function useP2PReplicatorCommands(host: NecessaryServices<"API" | "setting", never>, { replicator }: UseP2PReplicatorResult): void;

package/dist/replication/trystero/useP2PReplicatorCommands.js

@@ -0,0 +1,25 @@
+import { Logger, LOG_LEVEL_NOTICE } from "octagonal-wheels/common/logger";
+function useP2PReplicatorCommands(host, { replicator }) {
+  host.services.API.addCommand({
+    id: "p2p-establish-connection",
+    name: "P2P Sync : Connect to the Signalling Server",
+    checkCallback: (isChecking) => {
+      if (!replicator) return false;
+      if (isChecking) return !(replicator.server?.isServing ?? false);
+      void replicator.open();
+    }
+  });
+  host.services.API.addCommand({
+    id: "p2p-close-connection",
+    name: "P2P Sync : Disconnect from the Signalling Server",
+    checkCallback: (isChecking) => {
+      if (!replicator) return false;
+      if (isChecking) return replicator.server?.isServing ?? false;
+      Logger("Closing P2P Connection", LOG_LEVEL_NOTICE);
+      void replicator.close();
+    }
+  });
+}
+export {
+  useP2PReplicatorCommands
+};

package/dist/replication/trystero/useP2PReplicatorFeature.d.ts

@@ -0,0 +1,17 @@
+import type { NecessaryServices } from "../../interfaces/ServiceModule.js";
+import { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
+import { type UseP2PReplicatorResult } from "./UseP2PReplicatorResult.js";
+/**
+ * Factory type: given a replicator instance, returns the openReplicationUI callback for that instance.
+ * Injected by the host platform (e.g. Obsidian). CLI/headless environments omit this.
+ */
+export type OpenReplicationUIFactory = (replicator: LiveSyncTrysteroReplicator) => (showResult: boolean) => Promise<boolean | void>;
+/** Same shape as OpenReplicationUIFactory, used for the rebuild/replicateAllFromServer flow. */
+export type OpenRebuildUIFactory = OpenReplicationUIFactory;
+/**
+ * ServiceFeature: P2P Replicator integration and lifecycle management.
+ * Registers a LiveSyncTrysteroReplicator instance as the active replicator when P2P is enabled in settings,
+ * and binds it to lifecycle events for proper initialization and cleanup.
+ * @param host
+ */
+export declare function useP2PReplicatorFeature(host: NecessaryServices<"API" | "appLifecycle" | "setting" | "vault" | "database" | "databaseEvents" | "keyValueDB" | "replication" | "config" | "UI" | "replicator" | "remote", never>, openReplicationUIFactory?: OpenReplicationUIFactory, openRebuildUIFactory?: OpenRebuildUIFactory): UseP2PReplicatorResult;

package/dist/replication/trystero/useP2PReplicatorFeature.js

@@ -0,0 +1,82 @@
+import { Logger, LOG_LEVEL_VERBOSE } from "octagonal-wheels/common/logger";
+import { AutoAccepting, REMOTE_P2P } from "../../common/types.js";
+import { LiveSyncTrysteroReplicator } from "./LiveSyncTrysteroReplicator.js";
+import {} from "./UseP2PReplicatorResult.js";
+import { addP2PEventHandlers } from "./addP2PEventHandlers.js";
+import { compatGlobal } from "../../common/coreEnvFunctions.js";
+function useP2PReplicatorFeature(host, openReplicationUIFactory, openRebuildUIFactory) {
+  let replicator = new LiveSyncTrysteroReplicator({
+    services: host.services
+  });
+  if (openReplicationUIFactory) {
+    replicator.env.openReplicationUI = openReplicationUIFactory(replicator);
+  }
+  if (openRebuildUIFactory) {
+    replicator.env.openRebuildUI = openRebuildUIFactory(replicator);
+  }
+  const activeReplicator = {
+    get replicator() {
+      return replicator;
+    }
+  };
+  addP2PEventHandlers(activeReplicator.replicator, host.services.context.events);
+  host.services.replicator.getNewReplicator.addHandler(
+    async (settingOverride = {}) => {
+      const settings = { ...host.services.setting.currentSettings(), ...settingOverride };
+      if (settings.remoteType == REMOTE_P2P) {
+        const existingReplicator = replicator;
+        try {
+          await existingReplicator?.close();
+        } catch (e) {
+          Logger(`Error closing existing p2p replicator`);
+          Logger(e, LOG_LEVEL_VERBOSE);
+        }
+        const newReplicator = new LiveSyncTrysteroReplicator({ services: host.services });
+        if (openReplicationUIFactory) {
+          newReplicator.env.openReplicationUI = openReplicationUIFactory(newReplicator);
+        }
+        if (openRebuildUIFactory) {
+          newReplicator.env.openRebuildUI = openRebuildUIFactory(newReplicator);
+        }
+        replicator = newReplicator;
+        return replicator;
+      }
+      return void 0;
+    }
+  );
+  host.services.appLifecycle.onUnload.addHandler(async () => {
+    await replicator?.close();
+    return true;
+  });
+  host.services.appLifecycle.onSuspending.addHandler(async () => {
+    await replicator?.close();
+    return true;
+  });
+  host.services.databaseEvents.onDatabaseInitialisation.addHandler(async () => {
+    await replicator?.close();
+    return true;
+  });
+  host.services.appLifecycle.onResumed.addHandler(() => {
+    const settings = host.services.setting.currentSettings();
+    if (settings.P2P_Enabled && settings.P2P_AutoStart) {
+      compatGlobal.setTimeout(() => void replicator?.open(), 100);
+    }
+    return Promise.resolve(true);
+  });
+  host.services.setting.suspendExtraSync.addHandler(() => {
+    const s = host.services.setting.currentSettings();
+    if (s.remoteType !== REMOTE_P2P) {
+      s.P2P_Enabled = false;
+    }
+    s.P2P_AutoAccepting = AutoAccepting.NONE;
+    s.P2P_AutoBroadcast = false;
+    s.P2P_AutoStart = false;
+    s.P2P_AutoSyncPeers = "";
+    s.P2P_AutoWatchPeers = "";
+    return Promise.resolve(true);
+  });
+  return activeReplicator;
+}
+export {
+  useP2PReplicatorFeature
+};

package/dist/rpc/RpcRoom.d.ts

@@ -0,0 +1,24 @@
+import { RpcSession } from "./RpcSession.js";
+import { type JsonLike, type RpcMethodHandler, type RpcRegisterOptions, type RpcRoomOptions } from "./types.js";
+export declare class RpcRoom {
+    private options;
+    private pending;
+    private inboundCalls;
+    private methods;
+    private sessions;
+    private outgoingChunkMap;
+    private incomingChunkMap;
+    private incomingChunkTimers;
+    private peerVersion;
+    private disposer;
+    constructor(options: RpcRoomOptions);
+    close(): void;
+    session(peerId: string): RpcSession;
+    register<T extends JsonLike[], U>(method: string, handler: RpcMethodHandler<T, U>, options?: RpcRegisterOptions): void;
+    invoke(peerId: string, method: string, args: JsonLike[], timeoutMs?: number): Promise<JsonLike>;
+    cancel(peerId: string, requestId: string): Promise<void>;
+    private sendEnvelope;
+    private scheduleMissingAck;
+    private onWireMessage;
+    private onEnvelopePayload;
+}

package/dist/rpc/RpcRoom.js

@@ -0,0 +1,300 @@
+import { compatGlobal } from "../common/coreEnvFunctions.js";
+import { IncomingChunkBuffer, estimateBytes, splitIntoChunks } from "./chunking.js";
+import { asRpcErrorShape, RpcError } from "./errors.js";
+import { RpcSession } from "./RpcSession.js";
+import {
+  RPC_VERSION_MAJOR,
+  RPC_VERSION_MINOR
+} from "./types.js";
+function newId(prefix) {
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function validNamespacedMethod(method) {
+  return method.includes(".") || method.includes("/");
+}
+class RpcRoom {
+  options;
+  pending = /* @__PURE__ */ new Map();
+  inboundCalls = /* @__PURE__ */ new Map();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- This is a generic type for method handlers, so we can't be more specific about the types here.
+  methods = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  outgoingChunkMap = /* @__PURE__ */ new Map();
+  incomingChunkMap = /* @__PURE__ */ new Map();
+  incomingChunkTimers = /* @__PURE__ */ new Map();
+  peerVersion = /* @__PURE__ */ new Map();
+  disposer;
+  constructor(options) {
+    this.options = {
+      maxWirePayloadBytes: options.maxWirePayloadBytes ?? 32 * 1024,
+      chunkMissingRetryMs: options.chunkMissingRetryMs ?? 350,
+      ...options
+    };
+    this.disposer = this.options.transport.onMessage((msg, peerId) => {
+      void this.onWireMessage(msg, peerId);
+    });
+    if (this.options.transport.onPeerJoin) {
+      this.options.transport.onPeerJoin((peerId) => {
+        void this.sendEnvelope(peerId, {
+          kind: "handshake",
+          versionMajor: RPC_VERSION_MAJOR,
+          versionMinor: RPC_VERSION_MINOR
+        });
+      });
+    }
+    if (this.options.transport.onPeerLeave) {
+      this.options.transport.onPeerLeave((peerId) => {
+        this.sessions.delete(peerId);
+        this.peerVersion.delete(peerId);
+      });
+    }
+  }
+  close() {
+    this.disposer?.();
+    this.pending.forEach((pending) => pending.reject(new RpcError("NOT_CONNECTED", "Room closed")));
+    this.pending.clear();
+    this.inboundCalls.clear();
+    this.methods.clear();
+    this.sessions.clear();
+    this.outgoingChunkMap.clear();
+    this.incomingChunkMap.clear();
+    this.incomingChunkTimers.forEach((h) => compatGlobal.clearTimeout(h));
+    this.incomingChunkTimers.clear();
+  }
+  session(peerId) {
+    const existing = this.sessions.get(peerId);
+    if (existing) return existing;
+    const s = new RpcSession(this, peerId);
+    this.sessions.set(peerId, s);
+    return s;
+  }
+  register(method, handler, options = {}) {
+    if (!validNamespacedMethod(method)) {
+      throw new RpcError("PROTOCOL_ERROR", `Method must be namespaced: ${method}`);
+    }
+    this.methods.set(method, {
+      handler,
+      serial: options.serial ?? false,
+      queue: Promise.resolve()
+    });
+  }
+  async invoke(peerId, method, args, timeoutMs = 3e4) {
+    if (!validNamespacedMethod(method)) {
+      throw new RpcError("PROTOCOL_ERROR", `Method must be namespaced: ${method}`);
+    }
+    const requestId = newId("req");
+    const p = new Promise((resolve, reject) => {
+      const pending = { resolve, reject };
+      if (timeoutMs > 0) {
+        pending.timeoutHandle = compatGlobal.setTimeout(() => {
+          this.pending.delete(requestId);
+          reject(new RpcError("TIMEOUT", `RPC timed out: ${method}`));
+        }, timeoutMs);
+      }
+      this.pending.set(requestId, pending);
+    });
+    await this.sendEnvelope(peerId, {
+      kind: "request",
+      requestId,
+      method,
+      args
+    });
+    return await p;
+  }
+  async cancel(peerId, requestId) {
+    await this.sendEnvelope(peerId, {
+      kind: "cancel",
+      requestId
+    });
+  }
+  async sendEnvelope(peerId, envelope) {
+    const serialized = JSON.stringify(envelope);
+    if (estimateBytes(serialized) <= this.options.maxWirePayloadBytes) {
+      await this.options.transport.send({ wire: "raw", payload: serialized }, peerId);
+      return;
+    }
+    const streamId = newId("stream");
+    const chunks = splitIntoChunks(serialized, this.options.maxWirePayloadBytes);
+    this.outgoingChunkMap.set(streamId, { peerId, chunks });
+    for (let i = 0; i < chunks.length; i++) {
+      await this.options.transport.send(
+        {
+          wire: "chunk",
+          streamId,
+          index: i,
+          total: chunks.length,
+          payload: chunks[i]
+        },
+        peerId
+      );
+    }
+  }
+  scheduleMissingAck(streamId, peerId) {
+    const existing = this.incomingChunkTimers.get(streamId);
+    if (existing) compatGlobal.clearTimeout(existing);
+    const handle = compatGlobal.setTimeout(() => {
+      const state = this.incomingChunkMap.get(streamId);
+      if (!state || state.isComplete()) return;
+      const missing = state.missingIndices();
+      void this.options.transport.send({ wire: "chunk-ack", streamId, missing }, peerId);
+    }, this.options.chunkMissingRetryMs);
+    this.incomingChunkTimers.set(streamId, handle);
+  }
+  async onWireMessage(message, peerId) {
+    if (message.wire === "raw") {
+      await this.onEnvelopePayload(message.payload, peerId);
+      return;
+    }
+    if (message.wire === "chunk") {
+      let state2 = this.incomingChunkMap.get(message.streamId);
+      if (!state2) {
+        state2 = new IncomingChunkBuffer(message.total);
+        this.incomingChunkMap.set(message.streamId, state2);
+      }
+      state2.add(message.index, message.payload);
+      this.scheduleMissingAck(message.streamId, peerId);
+      if (state2.isComplete()) {
+        const timer = this.incomingChunkTimers.get(message.streamId);
+        if (timer) compatGlobal.clearTimeout(timer);
+        this.incomingChunkTimers.delete(message.streamId);
+        this.incomingChunkMap.delete(message.streamId);
+        await this.options.transport.send(
+          { wire: "chunk-ack", streamId: message.streamId, missing: [] },
+          peerId
+        );
+        await this.onEnvelopePayload(state2.toPayload(), peerId);
+      }
+      return;
+    }
+    const state = this.outgoingChunkMap.get(message.streamId);
+    if (!state) return;
+    if (message.missing.length === 0) {
+      this.outgoingChunkMap.delete(message.streamId);
+      return;
+    }
+    for (const index of message.missing) {
+      const payload = state.chunks[index];
+      if (payload === void 0) continue;
+      await this.options.transport.send(
+        {
+          wire: "chunk",
+          streamId: message.streamId,
+          index,
+          total: state.chunks.length,
+          payload
+        },
+        state.peerId
+      );
+    }
+  }
+  async onEnvelopePayload(payload, peerId) {
+    let envelope;
+    try {
+      envelope = JSON.parse(payload);
+    } catch (ex) {
+      this.options.onProtocolWarning?.("Invalid payload", peerId);
+      this.options.onProtocolWarning?.(String(ex), peerId);
+      return;
+    }
+    if (envelope.kind === "handshake") {
+      this.peerVersion.set(peerId, { major: envelope.versionMajor, minor: envelope.versionMinor });
+      if (envelope.versionMajor !== RPC_VERSION_MAJOR) {
+        this.options.onProtocolWarning?.(
+          `RPC major mismatch: local=${RPC_VERSION_MAJOR}, remote=${envelope.versionMajor}`,
+          peerId
+        );
+      }
+      return;
+    }
+    if (envelope.kind === "cancel") {
+      const ctx2 = this.inboundCalls.get(envelope.requestId);
+      if (ctx2) ctx2.cancelled = true;
+      return;
+    }
+    if (envelope.kind === "response") {
+      const pending = this.pending.get(envelope.requestId);
+      if (!pending) return;
+      this.pending.delete(envelope.requestId);
+      if (pending.timeoutHandle) compatGlobal.clearTimeout(pending.timeoutHandle);
+      if (envelope.ok === true) {
+        pending.resolve(envelope.data);
+      } else {
+        pending.reject(new RpcError(envelope.error.code, envelope.error.message, envelope.error.details));
+      }
+      return;
+    }
+    const accepted = await this.options.canAcceptRequest?.(peerId, envelope.method);
+    if (accepted === false) {
+      return;
+    }
+    const version = this.peerVersion.get(peerId);
+    if (version && version.major !== RPC_VERSION_MAJOR) {
+      await this.sendEnvelope(peerId, {
+        kind: "response",
+        requestId: envelope.requestId,
+        ok: false,
+        error: {
+          code: "REMOTE_ERROR",
+          message: `RPC major mismatch: local=${RPC_VERSION_MAJOR}, remote=${version.major}`
+        }
+      });
+      return;
+    }
+    if (version && version.minor !== RPC_VERSION_MINOR) {
+      this.options.onProtocolWarning?.(
+        `RPC minor mismatch: local=${RPC_VERSION_MINOR}, remote=${version.minor}`,
+        peerId
+      );
+    }
+    const method = this.methods.get(envelope.method);
+    if (!method) {
+      await this.sendEnvelope(peerId, {
+        kind: "response",
+        requestId: envelope.requestId,
+        ok: false,
+        error: {
+          code: "REMOTE_ERROR",
+          message: `Method not found: ${envelope.method}`
+        }
+      });
+      return;
+    }
+    const ctx = { cancelled: false };
+    this.inboundCalls.set(envelope.requestId, ctx);
+    const runner = async () => {
+      try {
+        if (ctx.cancelled) {
+          throw new RpcError("CANCELLED", "Invocation cancelled");
+        }
+        const data = await method.handler(peerId, ...envelope.args);
+        if (ctx.cancelled) {
+          throw new RpcError("CANCELLED", "Invocation cancelled");
+        }
+        await this.sendEnvelope(peerId, {
+          kind: "response",
+          requestId: envelope.requestId,
+          ok: true,
+          data
+        });
+      } catch (ex) {
+        await this.sendEnvelope(peerId, {
+          kind: "response",
+          requestId: envelope.requestId,
+          ok: false,
+          error: asRpcErrorShape(ex)
+        });
+      } finally {
+        this.inboundCalls.delete(envelope.requestId);
+      }
+    };
+    if (method.serial) {
+      method.queue = method.queue.then(runner, runner);
+      await method.queue;
+    } else {
+      await runner();
+    }
+  }
+}
+export {
+  RpcRoom
+};

package/dist/rpc/RpcSession.d.ts

@@ -0,0 +1,9 @@
+import type { JsonLike } from "./types.js";
+import type { RpcRoom } from "./RpcRoom.js";
+export declare class RpcSession {
+    readonly peerId: string;
+    private room;
+    constructor(room: RpcRoom, peerId: string);
+    call<T = JsonLike>(method: string, args?: JsonLike[], timeoutMs?: number): Promise<T>;
+    createProxy<T extends object>(namespace: string): T;
+}

package/dist/rpc/RpcSession.js

@@ -0,0 +1,32 @@
+import { RpcError } from "./errors.js";
+class RpcSession {
+  peerId;
+  room;
+  constructor(room, peerId) {
+    this.room = room;
+    this.peerId = peerId;
+  }
+  async call(method, args = [], timeoutMs) {
+    if (!this.peerId) {
+      throw new RpcError("NOT_CONNECTED", "Peer is not connected");
+    }
+    return await this.room.invoke(this.peerId, method, args, timeoutMs);
+  }
+  createProxy(namespace) {
+    const session = this;
+    return new Proxy(
+      {},
+      {
+        get(_target, propKey) {
+          if (typeof propKey !== "string") return void 0;
+          return async (...args) => {
+            return await session.call(`${namespace}.${propKey}`, args);
+          };
+        }
+      }
+    );
+  }
+}
+export {
+  RpcSession
+};

package/dist/rpc/chunking.d.ts

@@ -0,0 +1,11 @@
+export declare function estimateBytes(text: string): number;
+export declare function splitIntoChunks(payload: string, maxBytes: number): string[];
+export declare class IncomingChunkBuffer {
+    total: number;
+    parts: Map<number, string>;
+    constructor(total: number);
+    add(index: number, payload: string): void;
+    missingIndices(): number[];
+    isComplete(): boolean;
+    toPayload(): string;
+}