@vrtmrz/livesync-commonlib 0.3.2 → 0.4.0

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;

package/dist/replication/trystero/P2PRoomSessionOwner.js

@@ -1,3 +1,4 @@
+import { reportP2PDiagnostic } from "../../p2p/p2pDiagnostics.js";
 import { Logger } from "../../common/logger.js";
 import {
   LOG_LEVEL_NOTICE,
@@ -39,6 +40,7 @@ class P2PRoomSessionOwner {
   activeBinding;
   pendingPreparation;
   runtimeGeneration = 0;
+  diagnosticGeneration = 0;
   get currentSession() {
     return this.current;
   }
@@ -105,7 +107,9 @@ class P2PRoomSessionOwner {
   /** Arbitrate a complete signalling probe on the room lifecycle queue. */
   runConnectionProbe(trialSettings, runOwnedTrial) {
     try {
-      assertSupportedPathNormalizationVersion(this.env.services.setting.currentSettings().pathNormalizationVersion);
+      assertSupportedPathNormalizationVersion(
+        this.env.services.setting.currentSettings().pathNormalizationVersion
+      );
     } catch (error) {
       return Promise.reject(error);
     }
@@ -154,6 +158,7 @@ class P2PRoomSessionOwner {
       }
       let candidate;
       const operationGeneration = this.runtimeGeneration;
+      this.reportDiagnostic({ category: "relay", code: "room-opening", reason: "relay-details-unobserved" });
       try {
         const connectionSettings = await this.prepareConnectionSettings(binding, operationGeneration);
         await this.assertReconciliationCurrent(binding, operationGeneration, connectionSettings);
@@ -169,13 +174,21 @@ class P2PRoomSessionOwner {
         }
         const currentBinding = await this.getEffectiveBinding();
         if (!currentBinding.enabled || !this.hasRoomDemand() || !this.bindingsMatch(binding, currentBinding) || operationGeneration !== this.runtimeGeneration || !this.connectionSettingsRemainUsable(connectionSettings)) {
+          this.diagnosticGeneration += 1;
           await candidate.retire();
+          this.reportDiagnostic({
+            category: "relay",
+            code: "room-open-cancelled",
+            reason: "operation-cancelled"
+          });
           return;
         }
         this.current = candidate;
         this.activeBinding = connectionBinding;
         this.reconcileCurrentSessionPolicy(candidate);
+        this.reportDiagnostic({ category: "relay", code: "room-opened", reason: "relay-details-unobserved" });
       } catch (error) {
+        this.diagnosticGeneration += 1;
         await candidate?.retire(error).catch((retirementError) => {
           if (hasManagedP2PTurnConfiguration(binding.settings)) {
             Logger("The managed P2P room could not be retired cleanly.", LOG_LEVEL_VERBOSE);
@@ -186,8 +199,14 @@ class P2PRoomSessionOwner {
         this.current = void 0;
         this.activeBinding = void 0;
         if (error instanceof StaleRoomReconciliationError || operationGeneration !== this.runtimeGeneration) {
+          this.reportDiagnostic({
+            category: "relay",
+            code: "room-open-cancelled",
+            reason: "operation-cancelled"
+          });
           return;
         }
+        this.reportDiagnostic({ category: "relay", code: "room-open-failed", reason: "transport-error" });
         if (hasManagedP2PTurnConfiguration(binding.settings)) {
           Logger("The managed P2P room could not be prepared or opened.", LOG_LEVEL_NOTICE);
           Logger("Managed P2P room failure details were omitted.", LOG_LEVEL_VERBOSE);
@@ -222,9 +241,19 @@ class P2PRoomSessionOwner {
     this.current = void 0;
     this.activeBinding = void 0;
     if (session) {
-      await session.retire();
+      this.diagnosticGeneration += 1;
+      try {
+        await session.retire();
+        this.reportDiagnostic({ category: "relay", code: "room-closed", reason: "relay-details-unobserved" });
+      } catch (error) {
+        this.reportDiagnostic({ category: "relay", code: "room-close-failed", reason: "transport-error" });
+        throw error;
+      }
     }
   }
+  reportDiagnostic(input) {
+    reportP2PDiagnostic(this.options.onDiagnosticEvent, input);
+  }
   bindingsMatch(current, candidate) {
     return current?.database === candidate.database && current.signature === candidate.signature;
   }
@@ -413,7 +442,15 @@ class P2PRoomSessionOwner {
   }
   buildSessionEnv(binding) {
     const services = this.env.services;
+    const diagnosticGeneration = ++this.diagnosticGeneration;
     return {
+      reportDiagnostic: (event) => {
+        if (diagnosticGeneration !== this.diagnosticGeneration) return;
+        try {
+          this.options.onDiagnosticEvent?.(event);
+        } catch {
+        }
+      },
       events: services.context.events,
       translate: services.context.translate,
       settings: binding.settings,

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

@@ -1,6 +1,7 @@
+import { type ProgressAcknowledgement } from "./p2pReplicationProgress.js";
 import { type EntryDoc, type ObsidianLiveSyncSettings, type P2PSyncSetting } from "../../common/types.js";
 import { type LOG_LEVEL } from "octagonal-wheels/common/logger";
-import { type ProgressInfo } from "../../pouchdb/ReplicatorShim.js";
+import { type ProgressInfo, type ReplicationStatistics } from "../../pouchdb/ReplicatorShim.js";
 import type { Confirm } from "../../interfaces/Confirm.js";
 import { type Advertisement, type ReplicatorHostEnv } from "./types.js";
 import { EVENT_P2P_REPLICATOR_PROGRESS, EVENT_P2P_REPLICATOR_STATUS, P2PHost } from "./TrysteroReplicatorP2PServer.js";
@@ -12,35 +13,26 @@ export type P2PReplicatorStatus = {
     replicatingFrom: string[];
     watchingPeers: string[];
 };
+/** Sequence progress retained for compatibility, with independently observed work counts. */
+export type P2PReplicationDirectionProgress = {
+    max: number;
+    current: number;
+    isActive: boolean;
+    statistics?: ReplicationStatistics;
+};
 export type P2PReplicationProgress = {
     peerId: string;
     peerName: string;
-    fetching: {
-        max: number;
-        current: number;
-        isActive: boolean;
-    };
-    sending: {
-        max: number;
-        current: number;
-        isActive: boolean;
-    };
+    fetching: P2PReplicationDirectionProgress;
+    sending: P2PReplicationDirectionProgress;
 };
 export type P2PReplicationReport = {
     peerId: string;
     peerName: string;
 } & ({
-    fetching: {
-        max: number;
-        current: number;
-        isActive: boolean;
-    };
+    fetching: P2PReplicationDirectionProgress;
 } | {
-    sending: {
-        max: number;
-        current: number;
-        isActive: boolean;
-    };
+    sending: P2PReplicationDirectionProgress;
 });
 /**
  * In-process outcome of one P2P replication request.
@@ -112,9 +104,11 @@ export declare class TrysteroReplicator {
     _env: ReplicatorHostEnv;
     private readonly finiteOperationOwner?;
     private disposed;
+    private readonly acknowledgedAttempts;
     private readonly fallbackAutomationCoordinator;
     server?: P2PHost;
     replicationStatus(): {};
+    private reportDiagnostic;
     get settings(): P2PSyncSetting;
     /** Latest room-local policy settings supplied by the owning host. */
     get currentSettings(): P2PSyncSetting;
@@ -136,6 +130,7 @@ export declare class TrysteroReplicator {
     get autoSyncPeers(): RegExp[];
     get autoWatchPeers(): RegExp[];
     onNewPeer(peer: Advertisement): Promise<void>;
+    private watchBroadcastingPeer;
     onPeerLeaved(peerId: string): void;
     _onSetup: boolean;
     setOnSetup(): void;
@@ -524,7 +519,7 @@ export declare class TrysteroReplicator {
         getAllConfig: (fromPeerId: string) => Promise<string | {
             error: import("../../rpc/types.js").RpcErrorShape;
         }>;
-        onProgressAcknowledged: (fromPeerId: string, info: ProgressInfo) => Promise<void>;
+        onProgressAcknowledged: (fromPeerId: string, info?: ProgressInfo | null, acknowledgement?: ProgressAcknowledgement) => Promise<void>;
         getIsBroadcasting: () => Promise<boolean>;
         requestBroadcasting: (peerId: string) => Promise<true | {
             error: import("../../rpc/types.js").RpcErrorShape;
@@ -551,13 +546,15 @@ export declare class TrysteroReplicator {
     _replicateFromPeers: Set<string>;
     dispatchReplicationProgress(peerId: string, info?: ProgressInfo): void;
     onReplicationProgress(peerId: string, info?: ProgressInfo): boolean;
-    onProgressAcknowledged(peerId: string, info?: ProgressInfo): boolean;
-    acknowledgeProgress(remotePeerId: string, info?: ProgressInfo): void;
+    onProgressAcknowledged(peerId: string, info?: ProgressInfo | null, acknowledgement?: ProgressAcknowledgement): boolean;
+    acknowledgeProgress(remotePeerId: string, info?: ProgressInfo, acknowledgement?: ProgressAcknowledgement): void;
     replicateFrom(remotePeer: string, showNotice?: boolean, fromStart?: boolean, skipOrdinaryReplicationPolicy?: boolean, callerSignal?: AbortSignal): Promise<P2PReplicationResult>;
     private replicateFromWithinSession;
+    private pullFromWithinSession;
     private checkPeerForReplication;
     private transferFromPeer;
     notifyProgress(excludePeerId?: string): Promise<void>;
+    private notifyPeerProgress;
     requestBroadcastChanges(peerId: string): Promise<unknown>;
     getRemoteIsBroadcasting(peerId: string): Promise<unknown>;
     _watchingPeers: Set<string>;