@decentnetwork/peer 0.1.155 → 0.1.156

package/dist/peer.js

@@ -93,6 +93,12 @@ const SELF_ANNOUNCE_INTERVAL_MS = readEnvInt("DECENT_SELF_ANNOUNCE_INTERVAL_MS",
 // abandoned run is left to finish or hang on its own; what matters is that the
 // NEXT tick is allowed to start.
 const SELF_ANNOUNCE_WATCHDOG_MARGIN_MS = readEnvInt("DECENT_SELF_ANNOUNCE_WATCHDOG_MARGIN_MS", 15000);
+// Longest a self-announce pause may hold before it releases itself. The only
+// caller wraps a single friend-request send, which has its own 8s announce
+// deadline plus route discovery; 60s is well clear of a slow-but-working send
+// and well short of "the peer is now invisible".
+const SELF_ANNOUNCE_PAUSE_MAX_MS = readEnvInt("DECENT_SELF_ANNOUNCE_PAUSE_MAX_MS", 60_000);
+const FAULT_REQUEST_HANG = process.env.DECENT_FAULT_REQUEST_HANG === "1";
 // How long a stored announce entry stays useful to someone looking us up.
 // toxcore expires announce entries on roughly this timescale, so a node that
 // acknowledged a store longer ago than this can no longer be counted on.
@@ -1101,6 +1107,13 @@ export class Peer {
         }
         const resumeSelfAnnounce = this.#pauseSelfAnnounce();
         try {
+            // Fault injection, off unless DECENT_FAULT_REQUEST_HANG=1. Hangs inside
+            // the paused region — the shape that killed self-announce in the
+            // browser — so the pause expiry can be tested rather than argued for.
+            if (FAULT_REQUEST_HANG) {
+                this.#debugLog("FAULT: hanging inside the self-announce pause forever");
+                await new Promise(() => { });
+            }
             if (this.#selfAnnouncePromise) {
                 await this.#selfAnnouncePromise.catch(() => { });
             }
@@ -7347,11 +7360,42 @@ export class Peer {
         const recentBonus = Date.now() - h.lastOkMs < 60_000 ? 2 : 0;
         return (h.ok * 2) - h.fail + recentBonus;
     }
+    /**
+     * Pause the self-announce loop, with an expiry.
+     *
+     * The pause is released in a `finally`, which is correct right up until the
+     * guarded body never finishes. sendFriendRequest awaits a relay send inside
+     * that body, and in a browser a backgrounded tab can leave that socket
+     * neither open nor errored — so the `finally` never runs, the depth stays at
+     * 1, and self-announce is dead forever.
+     *
+     * This latch sits BEFORE the watchdog in #ensureSelfAnnounceLoop: the tick
+     * returns on pause depth without ever calling #runSelfAnnounce, so bounding
+     * the run was not enough on its own. Measured on app.beagle.chat after the
+     * watchdog shipped: announce age still climbing past 700s while the page's
+     * other timers ran normally.
+     *
+     * A pause is a short-lived thing — a few seconds around one send. One that
+     * outlives this window is a bug somewhere upstream, and the loop matters
+     * more than the pause does.
+     */
     #pauseSelfAnnounce() {
         this.#selfAnnouncePauseDepth += 1;
-        return () => {
+        let released = false;
+        const release = (viaTimeout) => {
+            if (released)
+                return;
+            released = true;
+            clearTimeout(expiry);
             this.#selfAnnouncePauseDepth = Math.max(0, this.#selfAnnouncePauseDepth - 1);
+            if (viaTimeout) {
+                this.#debugLog(`self-announce pause expired after ${Math.round(SELF_ANNOUNCE_PAUSE_MAX_MS / 1000)}s — ` +
+                    `releasing it; whoever took it never gave it back`);
+            }
         };
+        const expiry = setTimeout(() => release(true), SELF_ANNOUNCE_PAUSE_MAX_MS);
+        expiry.unref?.();
+        return () => release(false);
     }
     async #runSelfAnnounce(force, deadlineMs) {
         if (this.#selfAnnouncePromise) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.155",
+  "version": "0.1.156",
   "description": "Pure TypeScript port of Elastos Carrier (toxcore-derived) P2P messaging. DHT, onion routing, TCP relay, FlatBuffers app payloads, Express offline relay. Wire-compatible with iOS Beagle and the Carrier C SDK.",
   "type": "module",
   "main": "./dist/index.js",