@vrtmrz/livesync-commonlib 0.3.1 → 0.4.0

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>;

package/dist/replication/trystero/TrysteroReplicator.js

@@ -1,3 +1,15 @@
+import { reportP2PDiagnostic } from "../../p2p/p2pDiagnostics.js";
+import {
+  authenticationResultDiagnostic,
+  authenticationFailureDiagnostic,
+  pullResultDiagnostic,
+  pullFailureDiagnostic,
+  notificationFailureDiagnostic
+} from "./p2pReplicationDiagnostics.js";
+import {
+  projectDirectionProgress,
+  projectAcknowledgedAttempt
+} from "./p2pReplicationProgress.js";
 import { parsePeerPatterns } from "./peerPatterns.js";
 import {
   TweakValuesShouldMatchedTemplate,
@@ -42,6 +54,7 @@ async function encrypt(data, passphrase) {
 async function decrypt(encryptedData, passphrase) {
   return await decryptWithEphemeralSalt(encryptedData, passphrase);
 }
+let nextProgressAttempt = 0;
 const P2P_REPLICATION_COMPLETED = Object.freeze({ status: "completed", ok: true });
 const P2P_REPLICATION_CANCELLED = Object.freeze({ status: "cancelled" });
 function p2pReplicationFailed(error) {
@@ -59,11 +72,17 @@ class TrysteroReplicator {
   _env;
   finiteOperationOwner;
   disposed = false;
+  acknowledgedAttempts = /* @__PURE__ */ new Map();
   fallbackAutomationCoordinator = new P2PAutomationCoordinator();
   server;
   replicationStatus() {
     return {};
   }
+  reportDiagnostic(input) {
+    if (!this.disposed) {
+      reportP2PDiagnostic(this._env.reportDiagnostic, input);
+    }
+  }
   get settings() {
     return this._env.settings;
   }
@@ -137,6 +156,7 @@ class TrysteroReplicator {
   async close() {
     this.requestStatus();
     await this.server?.shutdown();
+    this.acknowledgedAttempts.clear();
     this._replicateFromPeers.clear();
     this._replicateToPeers.clear();
     this._watchingPeers.clear();
@@ -184,20 +204,46 @@ class TrysteroReplicator {
     const peerName = peer.name;
     const shouldAutoSync = this.autoSyncPeers.some((e) => e.test(peerName));
     const shouldAutoWatch = this.autoWatchPeers.some((e) => e.test(peerName));
-    if (!shouldAutoSync && !shouldAutoWatch) return;
+    if (!shouldAutoSync && !shouldAutoWatch) {
+      return;
+    }
     const acceptance = await this.server?.evaluatePeerAcceptance(peer.peerId);
-    if (acceptance !== "accepted") return;
+    if (acceptance !== "accepted") {
+      if (shouldAutoWatch) {
+        this.reportDiagnostic({
+          category: "sync",
+          code: "watch-skipped",
+          peerId: peer.peerId,
+          reason: "not-accepted"
+        });
+      }
+      return;
+    }
     if (shouldAutoSync) {
       await this.automationCoordinator.runBaseline(
         peerName,
         () => this.runFiniteReplicationActivity(() => this.sync(peer.peerId))
       );
     }
-    if (shouldAutoWatch && await this.getRemoteIsBroadcasting(peer.peerId) === true) {
-      this.watchPeer(peer.peerId);
+    if (shouldAutoWatch) {
+      await this.watchBroadcastingPeer(peer.peerId);
     }
   }
+  async watchBroadcastingPeer(peerId) {
+    const broadcasting = await this.getRemoteIsBroadcasting(peerId);
+    if (broadcasting === true) {
+      this.watchPeer(peerId);
+      return;
+    }
+    this.reportDiagnostic({
+      category: "sync",
+      code: "watch-skipped",
+      peerId,
+      reason: broadcasting === false ? "peer-not-broadcasting" : "peer-broadcast-unobserved"
+    });
+  }
   onPeerLeaved(peerId) {
+    this.acknowledgedAttempts.delete(peerId);
     void this.unwatchPeer(peerId);
   }
   _onSetup = false;
@@ -257,6 +303,12 @@ class TrysteroReplicator {
       },
       onProgress: async (fromPeerId) => {
         if (this._onSetup) {
+          this.reportDiagnostic({
+            category: "sync",
+            code: "change-notification-ignored",
+            peerId: fromPeerId,
+            reason: "setup-in-progress"
+          });
           return { error: toP2PWireError(new Error("The setup is in progress")) };
         }
         await this.onUpdateDatabase(fromPeerId);
@@ -300,9 +352,9 @@ class TrysteroReplicator {
         }
         return encrypt(JSON.stringify(setting), passphrase.trim());
       },
-      onProgressAcknowledged: async (fromPeerId, info) => {
+      onProgressAcknowledged: async (fromPeerId, info, acknowledgement) => {
         try {
-          await Promise.resolve(this.onProgressAcknowledged(fromPeerId, info));
+          await Promise.resolve(this.onProgressAcknowledged(fromPeerId, info, acknowledgement));
         } catch (e) {
           Logger("Error while acknowledging the progress", LOG_LEVEL_VERBOSE);
           Logger(e, LOG_LEVEL_VERBOSE);
@@ -341,8 +393,10 @@ class TrysteroReplicator {
         2e4,
         signal
       );
+      this.reportDiagnostic(authenticationResultDiagnostic(peerId, r));
       return r;
     } catch (e) {
+      this.reportDiagnostic(authenticationFailureDiagnostic(peerId, e, signal));
       Logger("Error while requesting authentication", LOG_LEVEL_VERBOSE);
       Logger(e, LOG_LEVEL_VERBOSE);
       return false;
@@ -402,9 +456,12 @@ class TrysteroReplicator {
   changes;
   _isBroadcasting = false;
   disableBroadcastChanges() {
+    const wasBroadcasting = this._isBroadcasting;
     this.changes?.cancel();
+    const needsDiagnostic = wasBroadcasting && this._isBroadcasting;
     this._isBroadcasting = false;
     this.dispatchStatus();
+    if (needsDiagnostic) this.reportDiagnostic({ category: "sync", code: "broadcast-disabled" });
   }
   enableBroadcastChanges() {
     if (this._isBroadcasting) return;
@@ -429,6 +486,7 @@ class TrysteroReplicator {
       await this.notifyProgress();
     });
     const closeChanges = (reason) => {
+      const wasBroadcasting = this._isBroadcasting;
       if (reason) {
         if (reason instanceof Error) {
           Logger(`Error while broadcasting the changes`, LOG_LEVEL_INFO);
@@ -443,9 +501,16 @@ class TrysteroReplicator {
       this.changes = void 0;
       this._isBroadcasting = false;
       this.dispatchStatus();
+      if (wasBroadcasting)
+        this.reportDiagnostic({
+          category: "sync",
+          code: "broadcast-disabled",
+          ...reason instanceof Error ? { reason: "replication-error" } : {}
+        });
     };
     void this.changes.on("error", closeChanges);
     void this.changes.on("complete", closeChanges);
+    this.reportDiagnostic({ category: "sync", code: "broadcast-enabled" });
     fireAndForget(async () => await this.notifyProgress());
   }
   /** Apply automatic broadcast policy without restarting this room. */
@@ -494,55 +559,51 @@ class TrysteroReplicator {
     this.onReplicationProgress(peerId, info);
   }
   onReplicationProgress(peerId, info) {
-    const name = this.server?._knownAdvertisements.get(peerId)?.name || peerId;
-    const stat = {
+    if (this.disposed) {
+      return false;
+    }
+    const name = this.server?._knownAdvertisements?.get(peerId)?.name || peerId;
+    this._env.events.emitEvent(EVENT_P2P_REPLICATOR_PROGRESS, {
       peerId,
       peerName: name,
-      fetching: {
-        max: 0,
-        current: 0,
-        isActive: false
-      }
-    };
-    if (info) {
-      stat.fetching = {
-        max: info.maxSeqInBatch,
-        current: info.lastSeq,
-        isActive: true
-      };
-    }
-    this._env.events.emitEvent(EVENT_P2P_REPLICATOR_PROGRESS, stat);
+      fetching: projectDirectionProgress(info)
+    });
     return true;
   }
-  onProgressAcknowledged(peerId, info) {
-    const name = this.server?._knownAdvertisements.get(peerId)?.name || peerId;
-    const ack = {
-      peerId,
-      peerName: name,
-      sending: {
-        max: 0,
-        current: 0,
-        isActive: false
+  onProgressAcknowledged(peerId, info, acknowledgement) {
+    if (this.disposed) {
+      return false;
+    }
+    if (acknowledgement) {
+      const next = projectAcknowledgedAttempt(this.acknowledgedAttempts.get(peerId), info, acknowledgement);
+      if (!next) {
+        return false;
       }
-    };
-    if (info) {
-      ack.sending = {
-        max: info.maxSeqInBatch,
-        current: info.lastSeq,
-        isActive: true
-      };
+      this.acknowledgedAttempts.set(peerId, next);
     }
-    this._env.events.emitEvent(EVENT_P2P_REPLICATOR_PROGRESS, ack);
+    const name = this.server?._knownAdvertisements?.get(peerId)?.name || peerId;
+    const sending = projectDirectionProgress(info ?? acknowledgement?.finalProgress);
+    sending.isActive = info != null;
+    this._env.events.emitEvent(EVENT_P2P_REPLICATOR_PROGRESS, {
+      peerId,
+      peerName: name,
+      sending
+    });
     return true;
   }
-  // Sending the progress to the remote peer
-  acknowledgeProgress(remotePeerId, info) {
-    if (!this.server) return;
-    const connection = this.server.getConnection(remotePeerId);
-    void connection.invokeRemoteFunction("onProgressAcknowledged", [this.server.serverPeerId, info], 500).catch((ex) => {
+  // Sending the progress to the remote peer.
+  acknowledgeProgress(remotePeerId, info, acknowledgement) {
+    if (!this.server || this.disposed) return;
+    try {
+      const connection = this.server.getConnection(remotePeerId);
+      void connection.invokeRemoteFunction("onProgressAcknowledged", [this.server.serverPeerId, info, acknowledgement], 500).catch((error) => {
+        Logger("Error while acknowledging the progress", LOG_LEVEL_VERBOSE);
+        Logger(error, LOG_LEVEL_VERBOSE);
+      });
+    } catch (error) {
       Logger("Error while acknowledging the progress", LOG_LEVEL_VERBOSE);
-      Logger(ex, LOG_LEVEL_VERBOSE);
-    });
+      Logger(error, LOG_LEVEL_VERBOSE);
+    }
   }
   async replicateFrom(remotePeer, showNotice = false, fromStart = false, skipOrdinaryReplicationPolicy = false, callerSignal) {
     return await this.runSessionFiniteOperation(
@@ -557,6 +618,23 @@ class TrysteroReplicator {
     );
   }
   async replicateFromWithinSession(remotePeer, showNotice, fromStart, skipOrdinaryReplicationPolicy, signal) {
+    this.reportDiagnostic({ category: "sync", code: "pull-started", peerId: remotePeer });
+    try {
+      const result = await this.pullFromWithinSession(
+        remotePeer,
+        showNotice,
+        fromStart,
+        skipOrdinaryReplicationPolicy,
+        signal
+      );
+      this.reportDiagnostic(pullResultDiagnostic(remotePeer, result.status));
+      return result;
+    } catch (error) {
+      this.reportDiagnostic(pullFailureDiagnostic(remotePeer, signal?.aborted ?? false));
+      throw error;
+    }
+  }
+  async pullFromWithinSession(remotePeer, showNotice, fromStart, skipOrdinaryReplicationPolicy, signal) {
     if (!skipOrdinaryReplicationPolicy && !await this.canStartOrdinaryReplication(showNotice)) {
       return p2pReplicationFailed(new Error("Replication is not ready"));
     }
@@ -571,14 +649,28 @@ class TrysteroReplicator {
     }
     this._replicateFromPeers.add(remotePeer);
     this.dispatchStatus();
+    const acknowledgement = { attempt: ++nextProgressAttempt };
+    let latestProgress = {
+      lastSeq: 0,
+      maxSeqInBatch: 0,
+      statistics: { documents: 0, checkedChanges: 0 }
+    };
+    this.dispatchReplicationProgress(remotePeer, latestProgress);
+    this.acknowledgeProgress(remotePeer, latestProgress, acknowledgement);
     try {
-      return await this.transferFromPeer(remotePeer, fromStart, logLevel, signal);
+      return await this.transferFromPeer(remotePeer, fromStart, logLevel, signal, (info) => {
+        latestProgress = info;
+        this.dispatchReplicationProgress(remotePeer, info);
+        this.acknowledgeProgress(remotePeer, info, acknowledgement);
+      });
     } catch (e) {
       if (signal?.aborted) return P2P_REPLICATION_CANCELLED;
       Logger("Error while P2P replicating", logLevel, "p2p-replicator");
       Logger(e, LOG_LEVEL_VERBOSE);
       return p2pReplicationFailed(e);
     } finally {
+      this.dispatchReplicationProgress(remotePeer);
+      this.acknowledgeProgress(remotePeer, void 0, { ...acknowledgement, finalProgress: latestProgress });
       this._replicateFromPeers.delete(remotePeer);
       this.dispatchStatus();
     }
@@ -605,7 +697,7 @@ class TrysteroReplicator {
     }
     return void 0;
   }
-  async transferFromPeer(remotePeer, fromStart, logLevel, signal) {
+  async transferFromPeer(remotePeer, fromStart, logLevel, signal, onStatistics) {
     if (!this.server) {
       throw new Error("Server is not available");
     }
@@ -640,8 +732,6 @@ class TrysteroReplicator {
       remoteDB,
       async (docs, info) => {
         await this._env.processReplicatedDocs(docs);
-        void this.dispatchReplicationProgress(remotePeer, info);
-        void this.acknowledgeProgress(remotePeer, info);
         void this.notifyProgress(remotePeer);
         Logger(
           `P2P Replication from ${remotePeer}
@@ -650,10 +740,14 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
           "p2p-replicator"
         );
       },
-      { live: false, rewind: fromStart, signal }
+      {
+        live: false,
+        rewind: fromStart,
+        signal,
+        onStatistics
+      }
     );
     Logger(`P2P replicateFrom replicateShim returned for ${remotePeer}`, LOG_LEVEL_VERBOSE, "p2p-replicator");
-    void this.acknowledgeProgress(remotePeer, void 0);
     if (outcome.status === "cancelled") {
       Logger(`P2P Replication from ${remotePeer} has been cancelled`, logLevel, "p2p-replicator");
       return P2P_REPLICATION_CANCELLED;
@@ -662,28 +756,43 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
     return P2P_REPLICATION_COMPLETED;
   }
   notifyProgress(excludePeerId) {
-    if (!this._isBroadcasting) return;
-    if (!this.server) return;
+    if (!this._isBroadcasting) {
+      return;
+    }
+    if (!this.server) {
+      return;
+    }
     for (const peer of this.server.knownAdvertisements) {
       const peerId = peer.peerId;
-      if (peerId === excludePeerId) continue;
-      void serialized(`notifyProgress-${peerId}`, async () => {
-        const isAcceptable = await this.server?.isAcceptablePeer(peerId);
-        if (isAcceptable) {
-          try {
-            const ret = await this.server?.getConnection(peerId).invokeRemoteFunction("onProgress", [this.server?.serverPeerId], 0);
-            return ret;
-          } catch (e) {
-            Logger(`Error while notifying progress to ${peerId}`, LOG_LEVEL_VERBOSE);
-            Logger(e, LOG_LEVEL_VERBOSE);
-          }
-        } else {
-          Logger(`Peer ${peerId} is not acceptable to notify progress`, LOG_LEVEL_VERBOSE);
-        }
-      });
+      if (peerId === excludePeerId) {
+        continue;
+      }
+      void serialized(`notifyProgress-${peerId}`, () => this.notifyPeerProgress(peerId));
     }
     return Promise.resolve();
   }
+  async notifyPeerProgress(peerId) {
+    const isAcceptable = await this.server?.isAcceptablePeer(peerId);
+    if (!isAcceptable) {
+      this.reportDiagnostic({
+        category: "sync",
+        code: "change-notification-ignored",
+        peerId,
+        reason: "not-accepted"
+      });
+      Logger(`Peer ${peerId} is not acceptable to notify progress`, LOG_LEVEL_VERBOSE);
+      return;
+    }
+    try {
+      const result = await this.server?.getConnection(peerId).invokeRemoteFunction("onProgress", [this.server?.serverPeerId], 0);
+      this.reportDiagnostic({ category: "sync", code: "change-notification-sent", peerId });
+      return result;
+    } catch (error) {
+      this.reportDiagnostic(notificationFailureDiagnostic(peerId, error));
+      Logger(`Error while notifying progress to ${peerId}`, LOG_LEVEL_VERBOSE);
+      Logger(error, LOG_LEVEL_VERBOSE);
+    }
+  }
   async requestBroadcastChanges(peerId) {
     return await this.server?.getConnection(peerId).invokeRemoteFunction("requestBroadcasting", [this.server.serverPeerId], 0);
   }
@@ -697,20 +806,33 @@ ${info.lastSeq} / ${info.maxSeqInBatch})`,
   }
   _watchingPeers = /* @__PURE__ */ new Set();
   watchPeer(peerId) {
+    if (!this._watchingPeers.has(peerId)) {
+      this.reportDiagnostic({ category: "sync", code: "watch-enabled", peerId });
+    }
     this._watchingPeers.add(peerId);
     this.dispatchStatus();
   }
   unwatchPeer(peerId) {
+    if (this._watchingPeers.has(peerId)) {
+      this.reportDiagnostic({ category: "sync", code: "watch-disabled", peerId });
+    }
     this._watchingPeers.delete(peerId);
     this.dispatchStatus();
   }
   async onUpdateDatabase(fromPeerId) {
     if (this._watchingPeers.has(fromPeerId)) {
+      this.reportDiagnostic({ category: "sync", code: "change-notification-received", peerId: fromPeerId });
       Logger(`Progress notification from ${fromPeerId}`, LOG_LEVEL_VERBOSE);
       return await serialized(`onProgress-${fromPeerId}`, async () => {
         return await this.runFiniteReplicationActivity(() => this.replicateFrom(fromPeerId));
       });
     }
+    this.reportDiagnostic({
+      category: "sync",
+      code: "change-notification-ignored",
+      peerId: fromPeerId,
+      reason: "not-watching"
+    });
     return false;
   }
   async getRemoteConfig(peerId) {

package/dist/replication/trystero/TrysteroReplicatorP2PServer.js

@@ -1,3 +1,4 @@
+import { reportP2PDiagnostic } from "../../p2p/p2pDiagnostics.js";
 import { parsePeerPatterns } from "./peerPatterns.js";
 import { selfId, joinRoom } from "@trystero-p2p/nostr";
 import { AutoAccepting, LOG_LEVEL_INFO, LOG_LEVEL_NOTICE } from "../../common/types.js";
@@ -225,7 +226,10 @@ class TrysteroReplicatorP2PServer {
     if (peerId === this.serverPeerId) return;
     if (data.peerId === this.serverPeerId) return;
     if (data.peerId !== peerId) return;
+    const isNewPeer = !this._knownAdvertisements.has(peerId);
     this._knownAdvertisements.set(peerId, data);
+    if (isNewPeer)
+      reportP2PDiagnostic(this._env.reportDiagnostic, { category: "peer", code: "peer-advertised", peerId });
     void this.dispatchConnectionStatus();
     void Promise.resolve().then(() => this._sessionPeerHandlers?.onAdvertisement(data)).catch((error) => Logger(error, LOG_LEVEL_VERBOSE));
     void this._env.events.emitEvent(EVENT_ADVERTISEMENT_RECEIVED, data);
@@ -368,6 +372,7 @@ You can chose as follows:
   _onPeerLeave(peerId) {
     if (this._hostLifetimeEnded) return;
     Logger(`Peer left: ${peerId}`, LOG_LEVEL_VERBOSE);
+    reportP2PDiagnostic(this._env.reportDiagnostic, { category: "peer", code: "peer-left", peerId });
     this._knownAdvertisements.delete(peerId);
     void Promise.resolve().then(() => this._sessionPeerHandlers?.onPeerLeft(peerId)).catch((error) => Logger(error, LOG_LEVEL_VERBOSE));
     void this._env.events.emitEvent(EVENT_DEVICE_LEAVED, peerId);
@@ -459,6 +464,12 @@ You can chose as follows:
     const room = joinRoom(options, roomId, {
       handshakeTimeoutMs: 3e4,
       onJoinError: (error) => {
+        if (!this._hostLifetimeEnded)
+          reportP2PDiagnostic(this._env.reportDiagnostic, {
+            category: "relay",
+            code: "room-join-error",
+            reason: "transport-error"
+          });
         Logger("Some peer Failed to join Trystero room");
         this.logTransportError(error);
       }