@vrtmrz/livesync-commonlib 0.1.0-rc.0

package/dist/rpc/chunking.js

@@ -0,0 +1,58 @@
+const encoder = new TextEncoder();
+function estimateBytes(text) {
+  return encoder.encode(text).byteLength;
+}
+function splitIntoChunks(payload, maxBytes) {
+  if (maxBytes <= 0) return [payload];
+  if (estimateBytes(payload) <= maxBytes) return [payload];
+  const chunks = [];
+  let cursor = 0;
+  while (cursor < payload.length) {
+    let end = Math.min(payload.length, cursor + Math.max(16, Math.floor(maxBytes / 2)));
+    let part = payload.slice(cursor, end);
+    while (part.length > 1 && estimateBytes(part) > maxBytes) {
+      end = Math.max(cursor + 1, end - 1);
+      part = payload.slice(cursor, end);
+    }
+    chunks.push(part);
+    cursor = end;
+  }
+  return chunks;
+}
+class IncomingChunkBuffer {
+  total;
+  parts = /* @__PURE__ */ new Map();
+  constructor(total) {
+    this.total = total;
+  }
+  add(index, payload) {
+    if (index < 0 || index >= this.total) return;
+    this.parts.set(index, payload);
+  }
+  missingIndices() {
+    const missing = [];
+    for (let i = 0; i < this.total; i++) {
+      if (!this.parts.has(i)) missing.push(i);
+    }
+    return missing;
+  }
+  isComplete() {
+    return this.parts.size === this.total;
+  }
+  toPayload() {
+    let acc = "";
+    for (let i = 0; i < this.total; i++) {
+      const part = this.parts.get(i);
+      if (part === void 0) {
+        throw new Error(`Missing chunk ${i}`);
+      }
+      acc += part;
+    }
+    return acc;
+  }
+}
+export {
+  IncomingChunkBuffer,
+  estimateBytes,
+  splitIntoChunks
+};

package/dist/rpc/errors.d.ts

@@ -0,0 +1,8 @@
+import type { JsonLike, RpcErrorCode, RpcErrorShape } from "./types.js";
+export declare class RpcError extends Error {
+    code: RpcErrorCode;
+    details?: JsonLike;
+    constructor(code: RpcErrorCode, message: string, details?: JsonLike);
+    toShape(): RpcErrorShape;
+}
+export declare function asRpcErrorShape(ex: unknown): RpcErrorShape;

package/dist/rpc/errors.js

@@ -0,0 +1,26 @@
+class RpcError extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "RpcError";
+    this.code = code;
+    this.details = details;
+  }
+  toShape() {
+    return { code: this.code, message: this.message, details: this.details };
+  }
+}
+function asRpcErrorShape(ex) {
+  if (ex instanceof RpcError) {
+    return ex.toShape();
+  }
+  if (ex instanceof Error) {
+    return { code: "REMOTE_ERROR", message: ex.message };
+  }
+  return { code: "REMOTE_ERROR", message: "Unknown remote error" };
+}
+export {
+  RpcError,
+  asRpcErrorShape
+};

package/dist/rpc/index.d.ts

@@ -0,0 +1,6 @@
+export { RpcRoom } from "./RpcRoom.js";
+export { RpcSession } from "./RpcSession.js";
+export { RpcError } from "./errors.js";
+export { exposeDB } from "./pouchdb/RpcPouchDBServer.js";
+export { RpcPouchDBProxy } from "./pouchdb/RpcPouchDBProxy.js";
+export type { JsonLike, RpcEnvelope, RpcErrorCode, RpcErrorShape, RpcMethodHandler, RpcRegisterOptions, RpcRoomOptions, RpcWireMessage, TransportAdapter, } from "./types.js";

package/dist/rpc/index.js

@@ -0,0 +1,12 @@
+import { RpcRoom } from "./RpcRoom.js";
+import { RpcSession } from "./RpcSession.js";
+import { RpcError } from "./errors.js";
+import { exposeDB } from "./pouchdb/RpcPouchDBServer.js";
+import { RpcPouchDBProxy } from "./pouchdb/RpcPouchDBProxy.js";
+export {
+  RpcError,
+  RpcPouchDBProxy,
+  RpcRoom,
+  RpcSession,
+  exposeDB
+};

package/dist/rpc/pouchdb/RpcPouchDBProxy.d.ts

@@ -0,0 +1,75 @@
+import EventEmitter from "events";
+import type { RpcSession } from "../RpcSession.js";
+/**
+ * A PouchDB-compatible proxy that forwards all database operations to a remote
+ * peer via an {@link RpcSession}.
+ *
+ * The proxy exposes the same public interface as a PouchDB instance and can be
+ * passed directly to `PouchDB.replicate()` or `PouchDB.sync()` as either the
+ * source or the target database.  It can also be used with {@link replicateShim}
+ * from `ReplicatorShim.ts`.
+ *
+ * The remote side must have called {@link exposeDB} to register the matching
+ * RPC handlers.
+ *
+ * ### Changes feed
+ * `changes()` returns an object that satisfies both the EventEmitter interface
+ * required by `pouchdb-replication` and the Promise interface required by
+ * `replicateShim` (i.e. it can be `await`ed directly).
+ *
+ * ### Error propagation
+ * PouchDB-specific error properties (`status`, `name`, `reason`) are preserved
+ * across the RPC transport and reconstructed on the proxy side so that callers
+ * such as `pouchdb-checkpointer` can inspect `err.status === 404` correctly.
+ */
+export declare class RpcPouchDBProxy extends EventEmitter {
+    /** The logical name of the remote database. */
+    readonly name: string;
+    /**
+     * Stub ActiveTasks object required by `pouchdb-replication`.  All
+     * operations are no-ops; task state is not tracked across the RPC boundary.
+     */
+    readonly activeTasks: {
+        add: (_task: object) => unknown;
+        get: (_id: unknown) => unknown;
+        update: (_id: unknown, _update: object) => void;
+        remove: (_id: unknown, _err?: Error) => void;
+        list: () => unknown[];
+    };
+    private readonly session;
+    private readonly ns;
+    constructor(session: RpcSession, name: string, ns?: string);
+    /**
+     * Invoke an RPC method and reconstruct PouchDB error shapes on the response.
+     *
+     * When the remote handler wraps a PouchDB error via {@link exposeDB}'s
+     * `runDB` helper, the `RpcError.details` object carries `status`, `name`,
+     * and `reason`.  This method rebuilds a plain `Error` with those properties
+     * so that callers (e.g. pouchdb-checkpointer) can use `err.status` /
+     * `err.name` as expected.
+     */
+    private callDB;
+    info(): Promise<PouchDB.Core.DatabaseInfo>;
+    id(): Promise<string>;
+    /**
+     * Returns a `Changes`-compatible object that is simultaneously:
+     * - An **EventEmitter** with `change`, `complete`, and `error` events, plus
+     *   a `cancel()` method — satisfying the interface consumed by
+     *   `PouchDB.replicate()` / `PouchDB.sync()`.
+     * - A **thenable** (`then` / `catch`) — allowing `await db.changes(opts)`
+     *   as used by `replicateShim`.
+     *
+     * The remote changes feed is always fetched as a one-shot snapshot
+     * (`live: false`).
+     */
+    changes(opts: PouchDB.Core.ChangesOptions): PouchDB.Core.Changes<object>;
+    get<T extends object>(id: string, opts?: PouchDB.Core.GetOptions): Promise<T & PouchDB.Core.IdMeta & PouchDB.Core.GetMeta>;
+    put<T extends object>(doc: PouchDB.Core.PutDocument<T>, opts?: PouchDB.Core.PutOptions): Promise<PouchDB.Core.Response>;
+    bulkGet<T extends object>(opts: PouchDB.Core.BulkGetOptions): Promise<PouchDB.Core.BulkGetResponse<T>>;
+    bulkDocs<T extends object>(docs: PouchDB.Core.PostDocument<T>[] | {
+        docs: PouchDB.Core.PostDocument<T>[];
+        new_edits?: boolean;
+    }, opts?: PouchDB.Core.BulkDocsOptions): Promise<(PouchDB.Core.Response | PouchDB.Core.Error)[]>;
+    revsDiff(diff: PouchDB.Core.RevisionDiffOptions): Promise<PouchDB.Core.RevisionDiffResponse>;
+    allDocs<T extends object>(opts?: PouchDB.Core.AllDocsOptions): Promise<PouchDB.Core.AllDocsResponse<T>>;
+}

package/dist/rpc/pouchdb/RpcPouchDBProxy.js

@@ -0,0 +1,115 @@
+import EventEmitter from "events";
+import { RpcError } from "../errors.js";
+const noopActiveTasks = {
+  add: (_task) => null,
+  get: (_id) => null,
+  update: (_id, _update) => {
+  },
+  remove: (_id, _err) => {
+  },
+  list: () => []
+};
+class RpcPouchDBProxy extends EventEmitter {
+  /** The logical name of the remote database. */
+  name;
+  /**
+   * Stub ActiveTasks object required by `pouchdb-replication`.  All
+   * operations are no-ops; task state is not tracked across the RPC boundary.
+   */
+  activeTasks = noopActiveTasks;
+  session;
+  ns;
+  constructor(session, name, ns = "pdb") {
+    super();
+    this.session = session;
+    this.name = name;
+    this.ns = ns;
+  }
+  /**
+   * Invoke an RPC method and reconstruct PouchDB error shapes on the response.
+   *
+   * When the remote handler wraps a PouchDB error via {@link exposeDB}'s
+   * `runDB` helper, the `RpcError.details` object carries `status`, `name`,
+   * and `reason`.  This method rebuilds a plain `Error` with those properties
+   * so that callers (e.g. pouchdb-checkpointer) can use `err.status` /
+   * `err.name` as expected.
+   */
+  async callDB(method, args = []) {
+    try {
+      return await this.session.call(`${this.ns}.${method}`, args);
+    } catch (err) {
+      if (err instanceof RpcError && err.code === "REMOTE_ERROR") {
+        const d = err.details;
+        if (d?.name || d?.status) {
+          const pouchErr = new Error(err.message);
+          if (d.name) pouchErr.name = d.name;
+          if (d.status) pouchErr.status = d.status;
+          if (d.reason) pouchErr.reason = d.reason;
+          throw pouchErr;
+        }
+      }
+      throw err;
+    }
+  }
+  info() {
+    return this.callDB("info");
+  }
+  id() {
+    return this.callDB("id");
+  }
+  /**
+   * Returns a `Changes`-compatible object that is simultaneously:
+   * - An **EventEmitter** with `change`, `complete`, and `error` events, plus
+   *   a `cancel()` method — satisfying the interface consumed by
+   *   `PouchDB.replicate()` / `PouchDB.sync()`.
+   * - A **thenable** (`then` / `catch`) — allowing `await db.changes(opts)`
+   *   as used by `replicateShim`.
+   *
+   * The remote changes feed is always fetched as a one-shot snapshot
+   * (`live: false`).
+   */
+  changes(opts) {
+    const emitter = new EventEmitter();
+    let cancelled = false;
+    const promise = this.callDB("changes", [{ ...opts, live: false }]).then((info) => {
+      if (cancelled) return info;
+      for (const change of info.results ?? []) {
+        if (cancelled) break;
+        emitter.emit("change", change);
+      }
+      if (!cancelled) emitter.emit("complete", info);
+      return info;
+    });
+    promise.catch((err) => {
+      if (!cancelled) emitter.emit("error", err);
+    });
+    emitter.cancel = () => {
+      cancelled = true;
+      emitter.removeAllListeners();
+    };
+    emitter.then = (onfulfilled, onrejected) => promise.then(onfulfilled, onrejected);
+    emitter.catch = (onrejected) => promise.catch(onrejected);
+    return emitter;
+  }
+  get(id, opts) {
+    return this.callDB("get", [id, opts ?? {}]);
+  }
+  put(doc, opts) {
+    return this.callDB("put", [doc, opts ?? {}]);
+  }
+  bulkGet(opts) {
+    return this.callDB("bulkGet", [opts]);
+  }
+  bulkDocs(docs, opts) {
+    return this.callDB("bulkDocs", [docs, opts ?? {}]);
+  }
+  revsDiff(diff) {
+    return this.callDB("revsDiff", [diff]);
+  }
+  allDocs(opts) {
+    return this.callDB("allDocs", [opts ?? {}]);
+  }
+}
+export {
+  RpcPouchDBProxy
+};

package/dist/rpc/pouchdb/RpcPouchDBServer.d.ts

@@ -0,0 +1,16 @@
+import type { RpcRoom } from "../RpcRoom.js";
+/**
+ * Exposes a PouchDB database as a set of RPC methods registered on an
+ * {@link RpcRoom}.  The remote peer can access the database via
+ * {@link RpcPouchDBProxy}.
+ *
+ * All methods are registered under the given namespace prefix `ns` (default:
+ * `'pdb'`).  For example, with the default namespace the method names are
+ * `pdb.info`, `pdb.id`, `pdb.changes`, `pdb.get`, `pdb.put`, `pdb.bulkGet`,
+ * `pdb.bulkDocs`, `pdb.revsDiff`, and `pdb.allDocs`.
+ *
+ * @param room  The {@link RpcRoom} on which to register handlers.
+ * @param db    The PouchDB database instance to expose.
+ * @param ns    Method namespace prefix (default: `'pdb'`).
+ */
+export declare function exposeDB(room: RpcRoom, db: PouchDB.Database<object>, ns?: string): void;

package/dist/rpc/pouchdb/RpcPouchDBServer.js

@@ -0,0 +1,55 @@
+import { LiveSyncError } from "../../common/LSError.js";
+import { RpcError } from "../errors.js";
+async function runDB(fn) {
+  try {
+    return await fn();
+  } catch (e) {
+    const err = e;
+    if (err?.status || err?.name) {
+      const details = {};
+      if (err.status) details.status = err.status;
+      if (err.name) details.name = err.name;
+      if (err.reason) details.reason = err.reason;
+      throw new RpcError("REMOTE_ERROR", err.message ?? String(LiveSyncError.fromError(err)), details);
+    }
+    throw e;
+  }
+}
+function exposeDB(room, db, ns = "pdb") {
+  room.register(`${ns}.info`, () => runDB(() => db.info()));
+  room.register(`${ns}.id`, () => runDB(() => db.id()));
+  room.register(
+    `${ns}.changes`,
+    (_peerId, opts) => runDB(
+      () => new Promise((resolve, reject) => {
+        const feed = db.changes({ ...opts, live: false });
+        void feed.on("complete", resolve);
+        void feed.on("error", reject);
+      })
+    )
+  );
+  room.register(
+    `${ns}.get`,
+    (_peerId, id, opts) => runDB(() => db.get(id, opts ?? {}))
+  );
+  room.register(
+    `${ns}.put`,
+    (_peerId, doc, opts) => runDB(() => db.put(doc, opts ?? {}))
+  );
+  room.register(`${ns}.bulkGet`, (_peerId, opts) => runDB(() => db.bulkGet(opts)));
+  room.register(
+    `${ns}.bulkDocs`,
+    (_peerId, req, opts) => (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- wrongly typed in @types/pouchdb (incorrect overload signatures)
+      runDB(() => db.bulkDocs(req, opts ?? {}))
+    )
+  );
+  room.register(`${ns}.revsDiff`, (_peerId, diff) => runDB(() => db.revsDiff(diff)));
+  room.register(
+    `${ns}.allDocs`,
+    (_peerId, opts) => runDB(() => db.allDocs(opts ?? {}))
+  );
+}
+export {
+  exposeDB
+};

package/dist/rpc/transports/DiagRTCPeerConnections.d.ts

@@ -0,0 +1,24 @@
+import type { DiagRTCStats, DiagRTCFailureDiagnosis } from "./DiagRTCPeerConnections.types.js";
+/**
+ * Subscribes to connection status updates. The callback will be called with the latest connection statistics whenever there is a change in the connection status of any RTCPeerConnection instance.
+ * Returns an unsubscribe function to stop receiving updates.
+ *
+ * @param callback - The function to call with the latest connection statistics.
+ * @returns A function that can be called to unsubscribe from updates.
+ */
+export declare function subscribeConnectionStatus(callback: (status: DiagRTCStats) => void): () => void;
+/**
+ * Subscribes to failure diagnosis updates. The callback will be called with the diagnosis information whenever a connection failure is detected in any RTCPeerConnection instance.
+ * Returns an unsubscribe function to stop receiving updates.
+ * @param callback - The function to call with the diagnosis information.
+ * @returns A function that can be called to unsubscribe from updates.
+ */
+export declare function subscribeFailureDiagnosis(callback: (diagnosis: DiagRTCFailureDiagnosis) => void): () => void;
+export type DiagRTCPeerConnectionConstructor = typeof RTCPeerConnection;
+/**
+ * A wrapper around RTCPeerConnection to collect statistics for diagnostics.
+ * It extends the native (or globally-polyfilled) RTCPeerConnection and overrides its constructor to add event listeners for connection state changes,
+ * ice connection state changes, ice gathering state changes, and signaling state changes. It maintains a history of these states and logs the progress.
+ * It also tracks the number of new connections, failed connections, successful connections, and closed connections, and dispatches this information to subscribers.
+ */
+export declare function createDiagRTCPeerConnectionConstructor(): DiagRTCPeerConnectionConstructor;

package/dist/rpc/transports/DiagRTCPeerConnections.js

@@ -0,0 +1,208 @@
+import { compatGlobal } from "../../common/coreEnvFunctions.js";
+import { LOG_LEVEL_VERBOSE, Logger } from "../../common/logger.js";
+import { LOG_LEVEL_DEBUG, LOG_LEVEL_INFO } from "../../common/types.js";
+import {
+  auditRtcConnectionFailures,
+  describeRTCProgress,
+  getPeerConnectionStats
+} from "./DiagRTCPeerConnections.utils.js";
+let rtcInstanceCounter = 0;
+let totalNewConnections = 0;
+let totalFailedConnections = 0;
+let totalSuccessfulConnections = 0;
+let totalClosedConnections = 0;
+const RTCConnectionStatuses = /* @__PURE__ */ new Map();
+let connectionStatusSubscribers = [];
+let failureDiagnosisSubscribers = [];
+function logRtcProgress(instanceId, eventName, peer) {
+  Logger(
+    `[DiagRTC:${instanceId}] ${eventName}: connection=${peer.connectionState}, iceConnection=${peer.iceConnectionState}, iceGathering=${peer.iceGatheringState}, signaling=${peer.signalingState}`,
+    LOG_LEVEL_DEBUG
+  );
+}
+function dispatchStatus(status) {
+  const details = Object.fromEntries(RTCConnectionStatuses);
+  for (const subscriber of connectionStatusSubscribers) {
+    try {
+      subscriber({
+        totalNewConnections,
+        totalFailedConnections,
+        totalSuccessfulConnections,
+        totalClosedConnections,
+        details
+      });
+    } catch {
+    }
+  }
+}
+function dispatchFailureDiagnosis(diagnosis) {
+  for (const subscriber of failureDiagnosisSubscribers) {
+    try {
+      subscriber(diagnosis);
+    } catch {
+    }
+  }
+}
+function subscribeConnectionStatus(callback) {
+  connectionStatusSubscribers.push(callback);
+  return () => {
+    connectionStatusSubscribers = connectionStatusSubscribers.filter((cb) => cb !== callback);
+  };
+}
+function subscribeFailureDiagnosis(callback) {
+  failureDiagnosisSubscribers.push(callback);
+  return () => {
+    failureDiagnosisSubscribers = failureDiagnosisSubscribers.filter((cb) => cb !== callback);
+  };
+}
+function createDiagRTCPeerConnectionConstructor() {
+  if (typeof compatGlobal.RTCPeerConnection === "undefined") {
+    throw new Error("RTCPeerConnection is not available in the current environment.");
+  }
+  return class DiagRTCPeerConnection extends compatGlobal.RTCPeerConnection {
+    /**
+     * Internal unique identifier for this RTCPeerConnection instance, used for tracking and logging purposes.
+     */
+    __instanceId;
+    /**
+     * A flag to ensure that failure statistics are logged only once per failure event, to avoid duplicate logs in case of multiple related state changes.
+     */
+    __failureStatsLogged = false;
+    /**
+     * Histories of connection states
+     */
+    _connectionStateHistory = [];
+    /**
+     * Histories of ice connection states
+     */
+    _iceConnectionHistory = [];
+    /**
+     * Histories of ice gathering states
+     */
+    _iceGatheringHistory = [];
+    /**
+     * Histories of signaling states
+     */
+    _signalingHistory = [];
+    /**
+     * Last known connection state, used to detect changes and update statistics accordingly.
+     */
+    _previousConnectionState = void 0;
+    /**
+     * Returns the internal state history of this RTCPeerConnection instance, including connection state history, ice connection state history,
+     * ice gathering state history, and signaling state history.
+     * This is used for diagnostics and failure analysis.
+     */
+    get stateHistory() {
+      return {
+        connectionHistory: this._connectionStateHistory,
+        iceConnectionHistory: this._iceConnectionHistory,
+        iceGatheringHistory: this._iceGatheringHistory,
+        signalingHistory: this._signalingHistory
+      };
+    }
+    _logProgress(eventName) {
+      logRtcProgress(this.__instanceId, eventName, this);
+    }
+    /**
+     * Notifies subscribers about the current connection progress, including the latest connection state and ice connection state, as well as the overall progress of the connection based on the state history.
+     * @param status The current connection status, including connection state and ice connection state.
+     */
+    async notifyConnectionProgress(status) {
+      const metrics = await getPeerConnectionStats(this.__instanceId, this);
+      const progress = describeRTCProgress(this.stateHistory, metrics?.selectedPair);
+      Logger(`[DiagRTC:${this.__instanceId}]: ${progress}`, LOG_LEVEL_INFO);
+      Logger(
+        `[DiagRTC:${this.__instanceId}] status: connection=${status.connectionState}, iceConnection=${status.iceConnectionState}`,
+        LOG_LEVEL_VERBOSE
+      );
+    }
+    /**
+     * Tracks the connection progress of this RTCPeerConnection instance, updating statistics and notifying subscribers as needed.
+     * @param instanceId The unique identifier of this RTCPeerConnection instance.
+     * @param status The current connection status, including connection state and ice connection state.
+     */
+    trackConnectionProgress() {
+      const status = {
+        connectionState: this.connectionState,
+        iceConnectionState: this.iceConnectionState
+      };
+      const instanceId = this.__instanceId;
+      if (status.connectionState === "closed" || status.connectionState === "failed") {
+        RTCConnectionStatuses.delete(instanceId);
+      } else {
+        RTCConnectionStatuses.set(instanceId, status);
+      }
+      if (this._previousConnectionState != status.connectionState) {
+        if (status.connectionState === "connected") {
+          totalSuccessfulConnections += 1;
+        }
+        if (status.connectionState === "failed") {
+          totalFailedConnections += 1;
+        }
+        if (status.connectionState === "new") {
+          totalNewConnections += 1;
+        }
+        if (status.connectionState === "closed") {
+          totalClosedConnections += 1;
+        }
+        this._previousConnectionState = status.connectionState;
+        void this.notifyConnectionProgress(status);
+        dispatchStatus(status);
+      }
+    }
+    /**
+     * Analyses the failure of this RTCPeerConnection instance using the state history and selected pair information, and dispatches the diagnosis to subscribers.
+     */
+    async analyseFailureAndDispatch() {
+      const history = this.stateHistory;
+      const diagnosis = await auditRtcConnectionFailures(this.__instanceId, history, this);
+      if (diagnosis) {
+        dispatchFailureDiagnosis(diagnosis.diagnosis);
+      }
+    }
+    constructor(configuration) {
+      super(configuration);
+      rtcInstanceCounter += 1;
+      this.__instanceId = `rtc-${rtcInstanceCounter}`;
+      this._logProgress("created");
+      this.addEventListener("connectionstatechange", () => {
+        this._connectionStateHistory.push(this.connectionState);
+        this._logProgress("connectionstatechange");
+        this.trackConnectionProgress();
+        if (this.connectionState !== "failed") {
+          this.__failureStatsLogged = false;
+        }
+        if (this.connectionState === "failed" && !this.__failureStatsLogged) {
+          this.__failureStatsLogged = true;
+          void this.analyseFailureAndDispatch();
+        }
+      });
+      this.addEventListener("iceconnectionstatechange", () => {
+        this._iceConnectionHistory.push(this.iceConnectionState);
+        this._logProgress("iceconnectionstatechange");
+        this.trackConnectionProgress();
+        if (this.iceConnectionState !== "failed" && this.connectionState !== "failed") {
+          this.__failureStatsLogged = false;
+        }
+        if ((this.connectionState === "failed" || this.iceConnectionState === "failed") && !this.__failureStatsLogged) {
+          this.__failureStatsLogged = true;
+          void this.analyseFailureAndDispatch();
+        }
+      });
+      this.addEventListener("icegatheringstatechange", () => {
+        this._iceGatheringHistory.push(this.iceGatheringState);
+        this._logProgress("icegatheringstatechange");
+      });
+      this.addEventListener("signalingstatechange", () => {
+        this._signalingHistory.push(this.signalingState);
+        this._logProgress("signalingstatechange");
+      });
+    }
+  };
+}
+export {
+  createDiagRTCPeerConnectionConstructor,
+  subscribeConnectionStatus,
+  subscribeFailureDiagnosis
+};

package/dist/rpc/transports/DiagRTCPeerConnections.types.d.ts

@@ -0,0 +1,64 @@
+export type DiagRTCConnectionStatus = {
+    connectionState: RTCPeerConnection["connectionState"];
+    iceConnectionState: RTCPeerConnection["iceConnectionState"];
+};
+export type DiagRTCStats = {
+    totalNewConnections: number;
+    totalFailedConnections: number;
+    totalSuccessfulConnections: number;
+    totalClosedConnections: number;
+    details: Record<string, DiagRTCConnectionStatus>;
+};
+export type DiagRTCPeerConnectionInternalStateHistory = {
+    connectionHistory: RTCPeerConnection["connectionState"][];
+    iceConnectionHistory: RTCPeerConnection["iceConnectionState"][];
+    iceGatheringHistory: RTCPeerConnection["iceGatheringState"][];
+    signalingHistory: RTCPeerConnection["signalingState"][];
+};
+export declare const DiagRTCFailureReasonCodes: {
+    readonly ICE_GATHERING_NOT_COMPLETED: "ICE_GATHERING_NOT_COMPLETED";
+    readonly ICE_CONNECTIVITY_FAILED: "ICE_CONNECTIVITY_FAILED";
+    readonly STUN_REQUEST_TIMEOUT: "STUN_REQUEST_TIMEOUT";
+    readonly SIGNALING_NOT_STABLE: "SIGNALING_NOT_STABLE";
+    readonly CONNECTION_DROPPED_AFTER_ESTABLISHED: "CONNECTION_DROPPED_AFTER_ESTABLISHED";
+    readonly NETWORK_INTERRUPTED: "NETWORK_INTERRUPTED";
+    readonly UNKNOWN: "UNKNOWN";
+};
+export type DiagRTCFailureDiagnosis = {
+    reasonCode: keyof typeof DiagRTCFailureReasonCodes;
+    userMessage: string;
+};
+export type DiagRTCFailureStats = {
+    diagnosis: DiagRTCFailureDiagnosis;
+    stats: {
+        reportsCount: number;
+        selectedPair: {
+            id: string;
+            state: string;
+            localCandidateId: string;
+            remoteCandidateId: string;
+            currentRoundTripTime: number | "unknown";
+            totalRoundTripTime: number | "unknown";
+            requestsSent: number | "unknown";
+            responsesReceived: number | "unknown";
+            packetsDiscardedOnSend: number | "unknown";
+            bytesSent: number | "unknown";
+            bytesReceived: number | "unknown";
+        };
+    };
+};
+export type DiagRTCPeerConnectionMetrics = {
+    selectedPair: Record<string, unknown> | undefined;
+    selectedPairId: string;
+    state: string;
+    localCandidateId: string;
+    remoteCandidateId: string;
+    currentRoundTripTime: number | "unknown";
+    totalRoundTripTime: number | "unknown";
+    requestsSent: number | "unknown";
+    responsesReceived: number | "unknown";
+    packetsDiscardedOnSend: number | "unknown";
+    bytesSent: number | "unknown";
+    bytesReceived: number | "unknown";
+    reports: unknown[];
+};