@vrtmrz/livesync-commonlib 0.3.1 → 0.4.0

package/dist/replication/journal/LiveSyncJournalReplicator.js

@@ -12,7 +12,7 @@ import { MinioStorageAdapter } from "./objectstore/MinioStorageAdapter.js";
 import { LiveSyncAbstractReplicator } from "../LiveSyncAbstractReplicator.js";
 import { ensureRemoteIsCompatible } from "../../pouchdb/LiveSyncDBFunctions.js";
 import { getEffectiveTweakValues } from "../../pouchdb/LiveSyncDBFunctions.js";
-import { assertSupportedPathNormalizationVersion, getPathNormalizationVersion } from "../../common/pathNormalization.js";
+import { assertSupportedPathNormalizationVersion } from "../../common/pathNormalization.js";
 import { JournalStorageReadStatuses } from "./objectstore/JournalStorageAdapter.js";
 import { computeKeyedId, configuredIdKey } from "../../common/idDerivation.js";
 import { decryptString, encryptString } from "../../encryption/stringEncryption.js";
@@ -31,6 +31,12 @@ import {
   forgetJoinedDevice as forgetJoinedDeviceFromStore,
   projectJoinedDevices
 } from "../joinedDevices.js";
+import {
+  journalVersionRange,
+  hasJournalNodeDeclarations,
+  matchesJournalPathIdentity,
+  inspectJournalPathIdentity
+} from "./journalCompatibility.js";
 const MILSTONE_DOCID = "_00000000-milestone.json";
 async function readRemoteMilestone(client) {
   const result = await client.downloadJsonWithResult(MILSTONE_DOCID);
@@ -38,23 +44,6 @@ async function readRemoteMilestone(client) {
   if (result.status === JournalStorageReadStatuses.NOT_FOUND) return void 0;
   throw result.error;
 }
-const currentVersionRange = {
-  min: 0,
-  max: 2,
-  current: 2
-};
-function journalVersionRange(setting) {
-  if (getPathNormalizationVersion(setting) === 1) return { min: 4, max: 4, current: 4 };
-  return configuredIdKey(setting) && setting.encrypt && setting.usePathObfuscation ? { min: 3, max: 3, current: 3 } : currentVersionRange;
-}
-function pathIdentityFromJournalRange(range) {
-  if (range?.min === 4 && range?.max === 4) return 1;
-  if (!range) return 0;
-  if (Number.isSafeInteger(range.min) && Number.isSafeInteger(range.max) && range.min >= 0 && range.max <= 3 && range.min <= range.max) {
-    return 0;
-  }
-  throw new Error("The Journal declares an unsupported path identity range.");
-}
 class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   get client() {
     return this.setupJournalSyncClient();
@@ -89,17 +78,8 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
     return this._client;
   }
   async isBucketPathIdentityCompatible(setting, milestone, client) {
-    const pathVersion = getPathNormalizationVersion(setting);
-    const ranges = milestone?.node_chunk_info ?? {};
-    const nodes = /* @__PURE__ */ new Set([...milestone?.accepted_nodes ?? [], ...Object.keys(ranges)]);
-    for (const node of nodes) {
-      const range = ranges[node];
-      const usesNFC = range?.min === 4 && range?.max === 4;
-      if (usesNFC !== (pathVersion === 1)) return false;
-    }
-    const preferred = milestone?.tweak_values?.[DEVICE_ID_PREFERRED];
-    if (preferred && getPathNormalizationVersion(preferred) !== pathVersion) return false;
-    if (nodes.size === 0 && await client.hasRemoteJournals()) {
+    if (!matchesJournalPathIdentity(setting, milestone)) return false;
+    if (!hasJournalNodeDeclarations(milestone) && await client.hasRemoteJournals()) {
       throw new Error(
         "The Journal compatibility milestone is missing. Rebuild from the authoritative Vault before synchronising."
       );
@@ -144,22 +124,13 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
   async inspectRemotePathIdentity(setting) {
     const client = this.setupJournalSyncClient(setting);
     const milestone = await readRemoteMilestone(client);
-    const versions = /* @__PURE__ */ new Set();
-    const ranges = milestone?.node_chunk_info ?? {};
-    const nodes = /* @__PURE__ */ new Set([...milestone?.accepted_nodes ?? [], ...Object.keys(ranges)]);
-    for (const node of nodes) {
-      versions.add(pathIdentityFromJournalRange(ranges[node]));
-    }
-    const preferred = milestone?.tweak_values?.[DEVICE_ID_PREFERRED];
-    if (preferred) versions.add(getPathNormalizationVersion(preferred));
-    if (versions.size > 1) throw new Error("The Journal has conflicting path identity declarations.");
-    if (nodes.size === 0 && await client.hasRemoteJournals()) {
+    const identity = inspectJournalPathIdentity(milestone);
+    if (!hasJournalNodeDeclarations(milestone) && await client.hasRemoteJournals()) {
       throw new Error(
         "The Journal path identity declaration is missing. Use matching settings or Rebuild from the authoritative Vault."
       );
     }
-    const version = [...versions][0];
-    return version === void 0 ? { status: "empty" } : { status: "configured", pathNormalizationVersion: version };
+    return identity;
   }
   /** Lock existing journals for replacement without declaring the replacement's identity. */
   async markRemoteLockedForRebuild(setting) {
@@ -178,7 +149,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       throw new Error("Could not upload remote milestone");
     }
   }
-  async ensureBucketIsCompatible(deviceNodeID, currentVersionRange2, setting = this.currentSettings, client = this.setupJournalSyncClient(setting), recordTweakAssessment) {
+  async ensureBucketIsCompatible(deviceNodeID, currentVersionRange, setting = this.currentSettings, client = this.setupJournalSyncClient(setting), recordTweakAssessment) {
     const downloadedMilestone = await readRemoteMilestone(client) ?? false;
     if (!await this.isBucketPathIdentityCompatible(setting, downloadedMilestone || void 0, client)) {
       return "INCOMPATIBLE";
@@ -193,7 +164,7 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       downloadedMilestone,
       setting,
       deviceNodeID,
-      currentVersionRange2,
+      currentVersionRange,
       {
         app_version: this.env.services.API.getAppVersion(),
         plugin_version: this.env.services.API.getPluginVersion(),
@@ -356,6 +327,18 @@ class LiveSyncJournalReplicator extends LiveSyncAbstractReplicator {
       (client) => client.sendLocalJournal(showingNotice)
     );
   }
+  /** Return the stopped Journal from the current transfer client without creating another client. */
+  getStoppedJournal() {
+    return this._client?.getStoppedJournal();
+  }
+  /** Recheck connectivity and compatibility, skip the confirmed Journal, and resume receipt. */
+  async skipStoppedJournalAndResume(setting, stopped, showingNotice = true) {
+    return await this.runDirectionalReplication(
+      setting,
+      showingNotice,
+      (client) => client.skipStoppedJournalAndResume(stopped, showingNotice)
+    );
+  }
   async replicateAllFromServer(setting, showingNotice) {
     return await this.runDirectionalReplication(
       setting,
@@ -721,6 +704,10 @@ ${ex.message}`, LOG_LEVEL_NOTICE);
     return Promise.resolve(false);
   }
 }
+function isLiveSyncJournalReplicator(value) {
+  return value instanceof LiveSyncJournalReplicator;
+}
 export {
-  LiveSyncJournalReplicator
+  LiveSyncJournalReplicator,
+  isLiveSyncJournalReplicator
 };

package/dist/replication/journal/journalCompatibility.d.ts

@@ -0,0 +1,9 @@
+import { type ChunkVersionRange, type EntryMilestoneInfo, type RemoteDBSettings } from "../../common/types.js";
+import type { PathIdentityInspection } from "../../pouchdb/pathIdentityCompatibility.js";
+export declare function journalVersionRange(setting: RemoteDBSettings): ChunkVersionRange;
+export declare function pathIdentityFromJournalRange(range: ChunkVersionRange | undefined): 0 | 1;
+/** Without a node declaration, the caller must inspect storage before treating the bucket as empty. */
+export declare function hasJournalNodeDeclarations(milestone: EntryMilestoneInfo | undefined): boolean;
+export declare function matchesJournalPathIdentity(setting: RemoteDBSettings, milestone: EntryMilestoneInfo | undefined): boolean;
+/** Project declarations only; an empty result does not establish that remote storage is empty. */
+export declare function inspectJournalPathIdentity(milestone: EntryMilestoneInfo | undefined): PathIdentityInspection;

package/dist/replication/journal/journalCompatibility.js

@@ -0,0 +1,58 @@
+import {
+  DEVICE_ID_PREFERRED
+} from "../../common/types.js";
+import { configuredIdKey } from "../../common/idDerivation.js";
+import { getPathNormalizationVersion } from "../../common/pathNormalization.js";
+const currentVersionRange = {
+  min: 0,
+  max: 2,
+  current: 2
+};
+function journalVersionRange(setting) {
+  if (getPathNormalizationVersion(setting) === 1) return { min: 4, max: 4, current: 4 };
+  return configuredIdKey(setting) && setting.encrypt && setting.usePathObfuscation ? { min: 3, max: 3, current: 3 } : currentVersionRange;
+}
+function pathIdentityFromJournalRange(range) {
+  if (range?.min === 4 && range?.max === 4) return 1;
+  if (!range) return 0;
+  if (Number.isSafeInteger(range.min) && Number.isSafeInteger(range.max) && range.min >= 0 && range.max <= 3 && range.min <= range.max) {
+    return 0;
+  }
+  throw new Error("The Journal declares an unsupported path identity range.");
+}
+function journalPathIdentityNodes(milestone) {
+  return /* @__PURE__ */ new Set([...milestone?.accepted_nodes ?? [], ...Object.keys(milestone?.node_chunk_info ?? {})]);
+}
+function hasJournalNodeDeclarations(milestone) {
+  return journalPathIdentityNodes(milestone).size > 0;
+}
+function matchesJournalPathIdentity(setting, milestone) {
+  const pathVersion = getPathNormalizationVersion(setting);
+  const ranges = milestone?.node_chunk_info ?? {};
+  for (const node of journalPathIdentityNodes(milestone)) {
+    const range = ranges[node];
+    const usesNFC = range?.min === 4 && range?.max === 4;
+    if (usesNFC !== (pathVersion === 1)) return false;
+  }
+  const preferred = milestone?.tweak_values?.[DEVICE_ID_PREFERRED];
+  return !preferred || getPathNormalizationVersion(preferred) === pathVersion;
+}
+function inspectJournalPathIdentity(milestone) {
+  const versions = /* @__PURE__ */ new Set();
+  const ranges = milestone?.node_chunk_info ?? {};
+  for (const node of journalPathIdentityNodes(milestone)) {
+    versions.add(pathIdentityFromJournalRange(ranges[node]));
+  }
+  const preferred = milestone?.tweak_values?.[DEVICE_ID_PREFERRED];
+  if (preferred) versions.add(getPathNormalizationVersion(preferred));
+  if (versions.size > 1) throw new Error("The Journal has conflicting path identity declarations.");
+  const version = [...versions][0];
+  return version === void 0 ? { status: "empty" } : { status: "configured", pathNormalizationVersion: version };
+}
+export {
+  hasJournalNodeDeclarations,
+  inspectJournalPathIdentity,
+  journalVersionRange,
+  matchesJournalPathIdentity,
+  pathIdentityFromJournalRange
+};

package/dist/replication/journal/journalReceive.d.ts

@@ -0,0 +1,23 @@
+import type { EntryDoc } from "../../common/types.js";
+import type { ProcessingEntry } from "./journalRecords.js";
+type ChunkReadRow = {
+    id?: string;
+    error?: string;
+};
+type WriteResult = PouchDB.Core.Error | PouchDB.Core.Response;
+export declare function partitionJournalDocuments(entries: readonly ProcessingEntry[]): {
+    chunks: ProcessingEntry[];
+    docs: ProcessingEntry[];
+};
+/** Chunks have stable content, so only absent identifiers need a new local revision. */
+export declare function selectChunksToSave(chunks: readonly ProcessingEntry[], rows: readonly ChunkReadRow[]): PouchDB.Core.PutDocument<EntryDoc>[];
+export declare function hasJournalWriteErrors(results: readonly WriteResult[]): boolean;
+/** Report persisted Chunks even when another row failed, but require every requested Chunk for completion. */
+export declare function assessChunkWrites<T extends PouchDB.Core.PutDocument<EntryDoc>>(chunks: readonly T[], results: readonly WriteResult[]): {
+    persisted: T[];
+    failed: boolean;
+};
+export declare function journalMetadataRevisions(docs: readonly ProcessingEntry[]): PouchDB.Core.RevisionDiffOptions;
+/** Retain complete transferred Metadata, including revision ancestry, for each missing revision. */
+export declare function selectMetadataToSave(docs: readonly ProcessingEntry[], diff: PouchDB.Core.RevisionDiffResponse): ProcessingEntry[];
+export {};

package/dist/replication/journal/journalReceive.js

@@ -0,0 +1,44 @@
+function partitionJournalDocuments(entries) {
+  const chunks = [];
+  const docs = [];
+  for (const entry of entries) {
+    (entry._id.startsWith("h:") ? chunks : docs).push(entry);
+  }
+  return { chunks, docs };
+}
+function selectChunksToSave(chunks, rows) {
+  if (rows.some((row) => "error" in row && row.error !== "not_found")) {
+    throw new Error("Could not inspect existing Chunks");
+  }
+  const existingIDs = new Set(rows.map((row) => row.id).filter((id) => id !== void 0));
+  return chunks.filter((entry) => !existingIDs.has(entry._id)).map((entry) => ({ ...entry, _rev: void 0 }));
+}
+function hasJournalWriteErrors(results) {
+  return results.some((row) => "error" in row);
+}
+function assessChunkWrites(chunks, results) {
+  const persistedIDs = new Set(results.filter((row) => !("error" in row)).map((row) => row.id));
+  return {
+    persisted: chunks.filter((entry) => persistedIDs.has(entry._id)),
+    failed: hasJournalWriteErrors(results) || chunks.some((entry) => !persistedIDs.has(entry._id))
+  };
+}
+function journalMetadataRevisions(docs) {
+  return docs.reduce(
+    (revisions, entry) => ({ ...revisions, [entry._id]: [...revisions[entry._id] ?? [], entry._rev] }),
+    {}
+  );
+}
+function selectMetadataToSave(docs, diff) {
+  return docs.filter(
+    (entry) => entry._id in diff && "missing" in diff[entry._id] && (diff[entry._id].missing?.indexOf(entry._rev) ?? 0) !== -1
+  );
+}
+export {
+  assessChunkWrites,
+  hasJournalWriteErrors,
+  journalMetadataRevisions,
+  partitionJournalDocuments,
+  selectChunksToSave,
+  selectMetadataToSave
+};

package/dist/replication/journal/journalRecords.d.ts

@@ -0,0 +1,10 @@
+import { type EntryDoc } from "../../common/types.js";
+export type ProcessingEntry = PouchDB.Core.PutDocument<EntryDoc> & PouchDB.Core.GetMeta;
+export declare function serializeDoc(doc: EntryDoc): Uint8Array;
+export declare function decodeJournalRecords(data: Uint8Array): {
+    ok: true;
+    docs: ProcessingEntry[];
+} | {
+    ok: false;
+    stage: "decode" | "parse";
+};

package/dist/replication/journal/journalRecords.js

@@ -0,0 +1,96 @@
+import {} from "../../common/types.js";
+import { escapeNewLineFromString, unescapeNewLineFromString } from "../../common/utils.js";
+const RECORD_SPLIT = `
+`;
+const UNIT_SPLIT = ``;
+const te = new TextEncoder();
+function parseJournalRecord(value) {
+  const parsed = JSON.parse(value);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new TypeError("Invalid Journal record");
+  }
+  const record = parsed;
+  if (typeof record._id !== "string" || record._id.length === 0) {
+    throw new TypeError("Invalid Journal document identifier");
+  }
+  if (record._id.startsWith("h:")) {
+    if (record._id.length <= 2 || typeof record._rev !== "string" || typeof record.data !== "string") {
+      throw new TypeError("Invalid Journal Chunk record");
+    }
+  } else if (typeof record._rev !== "string" || record._rev.length === 0) {
+    throw new TypeError("Invalid Journal Metadata revision");
+  }
+  return parsed;
+}
+function decodeCompactJournalRecord(value) {
+  const separatorIndex = value.indexOf(UNIT_SPLIT);
+  if (separatorIndex === -1) {
+    return { ok: false, stage: "parse" };
+  }
+  const idPart = value.substring(1, separatorIndex);
+  if (!idPart.startsWith("h:") || idPart.length <= 2) {
+    return { ok: false, stage: "parse" };
+  }
+  const dataPart = value.substring(separatorIndex + 1);
+  return {
+    ok: true,
+    doc: {
+      _id: idPart,
+      data: unescapeNewLineFromString(dataPart),
+      type: "leaf",
+      _rev: ""
+    }
+  };
+}
+function decodeJournalRecordFrame(frame, decoder) {
+  let value;
+  try {
+    value = decoder.decode(frame);
+  } catch {
+    return { ok: false, stage: "decode" };
+  }
+  if (value.startsWith("~")) {
+    return decodeCompactJournalRecord(value);
+  }
+  try {
+    return { ok: true, doc: parseJournalRecord(value) };
+  } catch {
+    return { ok: false, stage: "parse" };
+  }
+}
+function serializeDoc(doc) {
+  if (doc._id.startsWith("h:")) {
+    const data = doc.data;
+    const writeData = escapeNewLineFromString(data);
+    return te.encode(`~${doc._id}${UNIT_SPLIT}${writeData}${RECORD_SPLIT}`);
+  }
+  return te.encode(JSON.stringify(doc) + RECORD_SPLIT);
+}
+function decodeJournalRecords(data) {
+  if (data.length === 0) {
+    return { ok: true, docs: [] };
+  }
+  if (data[data.length - 1] !== 10) {
+    return { ok: false, stage: "parse" };
+  }
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let idxFrom = 0;
+  const result = [];
+  while (idxFrom < data.length) {
+    const idxTo = data.indexOf(10, idxFrom);
+    if (idxTo === -1 || idxTo === idxFrom) {
+      return { ok: false, stage: "parse" };
+    }
+    const record = decodeJournalRecordFrame(data.slice(idxFrom, idxTo), decoder);
+    if (record.ok === false) {
+      return record;
+    }
+    result.push(record.doc);
+    idxFrom = idxTo + 1;
+  }
+  return { ok: true, docs: result };
+}
+export {
+  decodeJournalRecords,
+  serializeDoc
+};

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

@@ -1,7 +1,19 @@
 import type { LiveSyncEventHub } from "../../hub/hub.js";
+import { type ReactiveValue } from "octagonal-wheels/dataobject/reactive_v2";
 import type { P2PReplicationProgress } from "./TrysteroReplicator.js";
 export declare class P2PLogCollector {
+    private readonly eventController;
+    private readonly statisticsSource;
+    readonly p2pReplicationStats: ReactiveValue<readonly P2PReplicationProgress[]>;
     constructor(events: LiveSyncEventHub);
+    private handleAdvertisementReceived;
+    private resetPeerState;
+    private handleDeviceLeaved;
+    private handleReplicationProgress;
+    private statisticsFor;
+    private publishStatistics;
+    /** Release this collector's event registrations without affecting another consumer. */
+    dispose(): void;
     p2pReplicationResult: Map<string, P2PReplicationProgress>;
     updateP2PReplicationLine(): void;
     p2pReplicationLine: import("octagonal-wheels/dataobject/reactive_v2").ReactiveSource<string>;

package/dist/replication/trystero/P2PLogCollector.js

@@ -1,3 +1,4 @@
+import { EVENT_PLATFORM_UNLOADED } from "../../events/coreEvents.js";
 import { reactiveSource } from "octagonal-wheels/dataobject/reactive_v2";
 import {
   EVENT_ADVERTISEMENT_RECEIVED,
@@ -6,83 +7,117 @@ import {
   EVENT_DEVICE_LEAVED,
   EVENT_P2P_REPLICATOR_PROGRESS
 } from "./TrysteroReplicatorP2PServer.js";
+function initialProgress(peerId, peerName) {
+  return {
+    peerId,
+    peerName,
+    fetching: { current: 0, max: 0, isActive: false },
+    sending: { current: 0, max: 0, isActive: false }
+  };
+}
+function applyReport(previous, report) {
+  if ("fetching" in report) {
+    if (report.fetching.isActive || report.fetching.statistics) {
+      previous.fetching = report.fetching;
+    } else {
+      previous.fetching.isActive = false;
+    }
+  }
+  if ("sending" in report) {
+    if (report.sending.isActive || report.sending.statistics) {
+      previous.sending = report.sending;
+    } else {
+      previous.sending.isActive = false;
+    }
+  }
+}
+function snapshotProgress(progress) {
+  const snapshotDirection = (direction) => Object.freeze({
+    ...direction,
+    ...direction.statistics ? { statistics: Object.freeze({ ...direction.statistics }) } : {}
+  });
+  return Object.freeze({
+    ...progress,
+    fetching: snapshotDirection(progress.fetching),
+    sending: snapshotDirection(progress.sending)
+  });
+}
+function renderProgressLine(progresses) {
+  const sortedProgresses = [...progresses].sort((a, b) => a.peerId.localeCompare(b.peerId));
+  const renderCount = (current, max) => {
+    if (current == max) {
+      return `${current}`;
+    }
+    return `${current} (${max})`;
+  };
+  return sortedProgresses.map(
+    (peer) => `${peer.fetching.isActive || peer.sending.isActive ? "\u26A1" : "\u{1F4A4}"} ${peer.peerName} \u2191 ${renderCount(peer.sending.current, peer.sending.max)} \u2193 ${renderCount(peer.fetching.current, peer.fetching.max)} `
+  ).join("\n");
+}
 class P2PLogCollector {
+  eventController = new AbortController();
+  statisticsSource = reactiveSource(Object.freeze([]));
+  p2pReplicationStats = this.statisticsSource;
   constructor(events) {
-    events.onEvent(EVENT_ADVERTISEMENT_RECEIVED, (data) => {
-      this.p2pReplicationResult.set(data.peerId, {
-        peerId: data.peerId,
-        peerName: data.name,
-        fetching: {
-          current: 0,
-          max: 0,
-          isActive: false
-        },
-        sending: {
-          current: 0,
-          max: 0,
-          isActive: false
-        }
-      });
-      this.updateP2PReplicationLine();
-    });
-    events.onEvent(EVENT_P2P_CONNECTED, () => {
-      this.p2pReplicationResult.clear();
-      this.updateP2PReplicationLine();
-    });
-    events.onEvent(EVENT_P2P_DISCONNECTED, () => {
-      this.p2pReplicationResult.clear();
-      this.updateP2PReplicationLine();
-    });
-    events.onEvent(EVENT_DEVICE_LEAVED, (peerId) => {
-      this.p2pReplicationResult.delete(peerId);
-      this.updateP2PReplicationLine();
-    });
-    events.onEvent(EVENT_P2P_REPLICATOR_PROGRESS, (data) => {
-      const prev = this.p2pReplicationResult.get(data.peerId) || {
-        peerId: data.peerId,
-        peerName: data.peerName,
-        fetching: {
-          current: 0,
-          max: 0,
-          isActive: false
-        },
-        sending: {
-          current: 0,
-          max: 0,
-          isActive: false
-        }
-      };
-      if ("fetching" in data) {
-        if (data.fetching.isActive) {
-          prev.fetching = data.fetching;
-        } else {
-          prev.fetching.isActive = false;
-        }
-      }
-      if ("sending" in data) {
-        if (data.sending.isActive) {
-          prev.sending = data.sending;
-        } else {
-          prev.sending.isActive = false;
-        }
-      }
-      this.p2pReplicationResult.set(data.peerId, prev);
-      this.updateP2PReplicationLine();
-    });
+    const options = { signal: this.eventController.signal };
+    events.onEvent(EVENT_ADVERTISEMENT_RECEIVED, (data) => this.handleAdvertisementReceived(data), options);
+    events.onEvent(EVENT_P2P_CONNECTED, () => this.resetPeerState(), options);
+    events.onEvent(EVENT_P2P_DISCONNECTED, () => this.resetPeerState(), options);
+    events.onEvent(EVENT_DEVICE_LEAVED, (peerId) => this.handleDeviceLeaved(peerId), options);
+    events.onEvent(EVENT_P2P_REPLICATOR_PROGRESS, (data) => this.handleReplicationProgress(data), options);
+    events.onEvent(EVENT_PLATFORM_UNLOADED, () => this.dispose(), options);
+  }
+  handleAdvertisementReceived(data) {
+    this.p2pReplicationResult.set(data.peerId, initialProgress(data.peerId, data.name));
+    this.updateP2PReplicationLine();
+    const statistics = this.statisticsFor(data.peerId, data.name);
+    statistics.peerName = data.name;
+    this.publishStatistics(statistics);
+  }
+  resetPeerState() {
+    this.p2pReplicationResult.clear();
+    this.updateP2PReplicationLine();
+    this.statisticsSource.value = Object.freeze([]);
+  }
+  handleDeviceLeaved(peerId) {
+    this.p2pReplicationResult.delete(peerId);
+    this.updateP2PReplicationLine();
+    this.statisticsSource.value = Object.freeze(
+      this.statisticsSource.value.filter((peer) => peer.peerId !== peerId)
+    );
+  }
+  handleReplicationProgress(data) {
+    const previous = this.p2pReplicationResult.get(data.peerId) ?? initialProgress(data.peerId, data.peerName);
+    applyReport(previous, data);
+    this.p2pReplicationResult.set(data.peerId, previous);
+    this.updateP2PReplicationLine();
+    const statistics = this.statisticsFor(data.peerId, data.peerName);
+    applyReport(statistics, data);
+    this.publishStatistics(statistics);
+  }
+  statisticsFor(peerId, peerName) {
+    const previous = this.statisticsSource.value.find((peer) => peer.peerId === peerId);
+    return previous ? {
+      ...previous,
+      fetching: { ...previous.fetching },
+      sending: { ...previous.sending }
+    } : initialProgress(peerId, peerName);
+  }
+  publishStatistics(progress) {
+    const snapshot = snapshotProgress(progress);
+    this.statisticsSource.value = Object.freeze(
+      [...this.statisticsSource.value.filter((peer) => peer.peerId !== progress.peerId), snapshot].sort(
+        (a, b) => a.peerId.localeCompare(b.peerId)
+      )
+    );
+  }
+  /** Release this collector's event registrations without affecting another consumer. */
+  dispose() {
+    this.eventController.abort();
   }
   p2pReplicationResult = /* @__PURE__ */ new Map();
   updateP2PReplicationLine() {
-    const p2pReplicationResultX = [...this.p2pReplicationResult.values()].sort(
-      (a, b) => a.peerId.localeCompare(b.peerId)
-    );
-    const renderProgress = (current, max) => {
-      if (current == max) return `${current}`;
-      return `${current} (${max})`;
-    };
-    const line = p2pReplicationResultX.map(
-      (e) => `${e.fetching.isActive || e.sending.isActive ? "\u26A1" : "\u{1F4A4}"} ${e.peerName} \u2191 ${renderProgress(e.sending.current, e.sending.max)} \u2193 ${renderProgress(e.fetching.current, e.fetching.max)} `
-    ).join("\n");
-    this.p2pReplicationLine.value = line;
+    this.p2pReplicationLine.value = renderProgressLine(this.p2pReplicationResult.values());
   }
   p2pReplicationLine = reactiveSource("");
 }

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

@@ -1,3 +1,4 @@
+import { type P2PDiagnosticReporter } from "../../p2p/p2pDiagnostics.js";
 import { type P2PSyncSetting } from "../../common/types.js";
 import type { LiveSyncReplicatorEnv } from "../LiveSyncAbstractReplicator.js";
 import { P2PRoomSession } from "./P2PRoomSession.js";
@@ -8,6 +9,7 @@ type P2PRoomSessionFactory = (env: ReplicatorHostEnv) => P2PRoomSession;
 export type PrepareP2PSettings = (settings: Readonly<P2PSyncSetting>, signal: AbortSignal) => Promise<P2PSyncSetting>;
 export interface P2PRoomSessionOwnerOptions {
     readonly prepareP2PSettings?: PrepareP2PSettings;
+    readonly onDiagnosticEvent?: P2PDiagnosticReporter;
 }
 export declare const P2P_SETTINGS_PREPARATION_TIMEOUT_MS = 30000;
 export declare const P2P_ICE_SERVER_EXPIRY_MARGIN_MS = 30000;
@@ -39,6 +41,7 @@ export declare class P2PRoomSessionOwner implements P2PRoomSessionAccess {
     private activeBinding?;
     private pendingPreparation?;
     private runtimeGeneration;
+    private diagnosticGeneration;
     constructor(env: LiveSyncReplicatorEnv, createSession?: P2PRoomSessionFactory, options?: P2PRoomSessionOwnerOptions);
     get currentSession(): P2PRoomSession | undefined;
     get isConnected(): boolean;
@@ -62,6 +65,7 @@ export declare class P2PRoomSessionOwner implements P2PRoomSessionAccess {
     private hasRoomDemand;
     private enqueueLifecycleOperation;
     private closeTransport;
+    private reportDiagnostic;
     private bindingsMatch;
     private connectionSettingsRemainUsable;
     private fencePreparationForCurrentSettings;