@decentnetwork/peer 0.1.155 → 0.1.157

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.
@@ -521,6 +527,10 @@ export class Peer {
     // #initiateSession every few seconds for every friend; without this
     // dedupe, lower-pubkey side floods the log with "deferring to peer".
     #initiateSkipLogged = new Set();
+    /** Recently COMPLETED bulkmsg assemblies, same key, kept for the same 60s
+     *  the assembly itself lives. Without it a retransmitted message reassembles
+     *  a second time and is delivered twice. */
+    #bulkCompleted = new Map();
     // In-flight Carrier BULKMSG reassemblies, keyed `${friendId}:${tid}`.
     // Fragments are appended in arrival order (the lossless stream keeps
     // them ordered) and the message completes when totalsz bytes arrived.
@@ -1101,6 +1111,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(() => { });
             }
@@ -1600,6 +1617,29 @@ export class Peer {
                 return;
             }
         }
+        // Inline files ride the TEXT channel, and the delivery envelope wraps them.
+        //
+        // The call sites check for an inline file BEFORE this function, i.e. before
+        // the envelope comes off — so they were looking at "\x1eDNPACK1:<base64>",
+        // which does not start with "{", and every inline file sent with delivery
+        // tracking was reported as a text message instead. Measured 2026-08-31,
+        // peer to peer: a 95-byte PNG arrived as 200 characters of JSON, and a
+        // 300 KB one as 409,672 characters. Both transferred perfectly; both were
+        // handed to the application as a wall of base64.
+        //
+        // The check belongs here, on the unwrapped text, where it sees what the
+        // sender actually wrote. The call-site checks stay for envelope-less
+        // senders (iOS and Android do not speak this envelope).
+        //
+        // ACK first: an inline file is delivered, and skipping the ACK because we
+        // did not run the text handlers would make the sender retransmit forever.
+        if (this.#tryEmitInlineFile(msg.pubkey, text, msg.via === "offline" ? "offline" : "online")) {
+            if (deliveryId) {
+                this.#rememberDeliveredTextId(deliveryId);
+                void this.#sendTextAck(msg.pubkey, deliveryId).catch(() => undefined);
+            }
+            return;
+        }
         if (this.#textHandlers.size === 0) {
             if (deliveryId)
                 this.#debugLog(`text delivery ${deliveryId} from ${msg.pubkey} has no onText handlers; not ACKing`);
@@ -3166,13 +3206,22 @@ export class Peer {
         try {
             const decoded = decodeCarrierPacket(carrierPacket);
             if (decoded.type !== PACKET_TYPE_FRIEND_REQUEST) {
+                // Was a bare `return`. An onion friend-request that arrived and did not
+                // parse left NOTHING anywhere — the sender saw success, the recipient
+                // saw no request, and there was no way to tell "never arrived" from
+                // "arrived and was dropped". That is the single most-reported symptom
+                // on this project and it was undiagnosable by construction.
+                this.#debugLog(`friend-request from ${carrierIdFromPublicKey(senderPublicKey)} DROPPED: ` +
+                    `decoded as packet type ${decoded.type}, expected ${PACKET_TYPE_FRIEND_REQUEST}`);
                 return;
             }
             hello = decoded.hello;
             name = decoded.name;
             description = decoded.descr;
         }
-        catch {
+        catch (error) {
+            this.#debugLog(`friend-request from ${carrierIdFromPublicKey(senderPublicKey)} DROPPED: ` +
+                `undecodable (${carrierPacket.length} bytes): ${error.message}`);
             return;
         }
         const userid = carrierIdFromPublicKey(senderPublicKey);
@@ -3214,13 +3263,17 @@ export class Peer {
         try {
             const decoded = decodeCarrierPacket(packet);
             if (decoded.type !== PACKET_TYPE_FRIEND_REQUEST) {
+                this.#debugLog(`offline friend-request from ${fromUserId} DROPPED: decoded as packet ` +
+                    `type ${decoded.type}, expected ${PACKET_TYPE_FRIEND_REQUEST}`);
                 return;
             }
             helloText = decoded.hello;
             name = decoded.name;
             description = decoded.descr;
         }
-        catch {
+        catch (error) {
+            this.#debugLog(`offline friend-request from ${fromUserId} DROPPED: undecodable ` +
+                `(${packet.length} bytes): ${error.message}`);
             return;
         }
         // Already an established friend? Ignore this (re-)request. Auto-friend
@@ -4750,6 +4803,24 @@ export class Peer {
                 this.#bulkAssembly.delete(key);
         }
         const key = `${friendId}:${frag.tid.toString()}`;
+        // A completed assembly is deleted, so a second copy of the same fragments
+        // starts a fresh entry and completes AGAIN — the application gets the same
+        // message twice. Duplicate FRAGMENTS were already ignored; a duplicate
+        // whole MESSAGE was not.
+        //
+        // It shows up on the plain send path (a native peer, or a JS peer before
+        // userinfo has settled), because that path carries no delivery id and the
+        // text-level dedupe has nothing to key on. Measured 2026-08-31: one
+        // sendInlineFile call, two `bulkmsg complete (409672 bytes)` and two
+        // identical 300 KB images delivered.
+        for (const [k, at] of this.#bulkCompleted) {
+            if (at < now - 60_000)
+                this.#bulkCompleted.delete(k);
+        }
+        if (this.#bulkCompleted.has(key)) {
+            this.#debugLog(`bulkmsg ${key} already completed — dropping duplicate`);
+            return undefined;
+        }
         let entry = this.#bulkAssembly.get(key);
         if (!entry) {
             entry = { total: 0, frags: new Map(), got: 0, expireAtMs: now + 60_000 };
@@ -4774,6 +4845,7 @@ export class Peer {
         if (entry.total === 0 || entry.got < entry.total)
             return undefined;
         this.#bulkAssembly.delete(key);
+        this.#bulkCompleted.set(key, now);
         if (entry.got > entry.total) {
             this.#debugLog(`bulkmsg from ${friendId} got ${entry.got} > total ${entry.total} — dropped`);
             return undefined;
@@ -7347,11 +7419,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.157",
   "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",