@decentnetwork/peer 0.1.89 → 0.1.91

package/dist/peer.js

@@ -174,7 +174,7 @@ const AGENTNET_PROTO_VERSION = 1;
 // Peer package version, advertised as the default appVersion when the embedder
 // doesn't override it. Read lazily so a bundler that inlines this file doesn't
 // need the package.json at runtime.
-const PEER_PKG_VERSION = "0.1.89";
+const PEER_PKG_VERSION = "0.1.91";
 // Toxcore Messenger.h packet IDs (live inside encrypted 0x1b crypto data plain payload)
 const PACKET_ID_PADDING = 0;
 const PACKET_ID_REQUEST = 1; // request retransmission of unreceived packets
@@ -2032,8 +2032,27 @@ export class Peer {
                 // De-duplicate: skip the DISPATCH + nonce advance for an already-seen
                 // packet number. The transport confirmation above already ran, so a
                 // duplicate still keeps the path fresh.
+                //
+                // EXCEPTION: multi-fragment reliable messages that reassemble by tid —
+                // BULKMSG (inline files) and INVITE_REQUEST/RESPONSE (WebRTC call SDPs) —
+                // can arrive REORDERED. The C SDK puts totalsz on the FIRST fragment, but
+                // over a dual/UDP path a later fragment can land first, advancing the
+                // low-water past the first fragment's number. Dropping the first fragment
+                // here makes every fragment read totalsz 0 → the message is lost or (for
+                // an SDP) scrambled, so a call gets stuck "connecting" and files vanish
+                // ("bulkmsg totalsz 0 — dropped"). Let those through; #assembleBulkMsg /
+                // #assembleInvite dedup AND order fragments by packet number.
                 if (!isSingleTransportKind && opened.packetNumber < (state.receiveBufferStart ?? 0)) {
-                    continue;
+                    let reorderable = false;
+                    if (innerKind === PACKET_ID_MESSAGE) {
+                        try {
+                            const t = decodeCarrierPacket(opened.payload.slice(1)).type;
+                            reorderable = t === PACKET_TYPE_BULKMSG || t === PACKET_TYPE_INVITE_REQUEST || t === PACKET_TYPE_INVITE_RESPONSE;
+                        }
+                        catch { /* not a carrier packet */ }
+                    }
+                    if (!reorderable)
+                        continue;
                 }
                 // Track the receive nonce from the EXACT nonce this packet used
                 // (openCryptoDataPacket reconstructs it with full carry/borrow).
@@ -2078,7 +2097,7 @@ export class Peer {
                 if (consumesReliableNumber) {
                     state.receiveBufferStart = Math.max(state.receiveBufferStart ?? 0, (opened.packetNumber + 1) >>> 0);
                 }
-                this.#deliverLosslessPayload(friendId, state, kind, inner, remote);
+                this.#deliverLosslessPayload(friendId, state, kind, inner, remote, opened.packetNumber);
                 return;
             }
             // Reverted: we used to DELETE a "desynced" session here to force a clean
@@ -3174,7 +3193,7 @@ export class Peer {
      *  out of the datagram handler so the receive reorder buffer can replay
      *  buffered packets through the exact same dispatch. `kind` is the first
      *  payload byte (never undefined here — the caller defaults it). */
-    #deliverLosslessPayload(friendId, state, kind, inner, remote) {
+    #deliverLosslessPayload(friendId, state, kind, inner, remote, packetNumber = 0) {
         // Toxcore file transfer (FILE_SENDREQUEST/CONTROL/DATA = 80/81/82).
         if (this.#fileTransfer.handlePacket(friendId, kind, inner))
             return;
@@ -3329,7 +3348,7 @@ export class Peer {
             // signals (SDP offers) fragment by tid like bulkmsg; reassemble then
             // surface as an "invite" event (NOT chat text).
             if (carrier?.type === PACKET_TYPE_INVITE_REQUEST) {
-                const complete = this.#assembleInvite(friendId, carrier);
+                const complete = this.#assembleInvite(friendId, carrier, packetNumber);
                 if (!complete)
                     return; // more fragments pending
                 this.#events.emit("invite", {
@@ -3342,7 +3361,7 @@ export class Peer {
                 return;
             }
             if (carrier?.type === PACKET_TYPE_INVITE_RESPONSE) {
-                const complete = carrier.status === 0 ? this.#assembleInvite(friendId, carrier) : new Uint8Array();
+                const complete = carrier.status === 0 ? this.#assembleInvite(friendId, carrier, packetNumber) : new Uint8Array();
                 if (carrier.status === 0 && !complete)
                     return; // more fragments pending
                 this.#events.emit("inviteResponse", {
@@ -3357,7 +3376,7 @@ export class Peer {
                 return;
             }
             if (carrier?.type === PACKET_TYPE_BULKMSG) {
-                const complete = this.#assembleBulkMsg(friendId, carrier);
+                const complete = this.#assembleBulkMsg(friendId, carrier, packetNumber);
                 if (!complete)
                     return; // more fragments pending
                 text = decodeUtf8Best(complete);
@@ -3487,11 +3506,19 @@ export class Peer {
         incrementNonce(state.ourBaseNonce);
         await this.#sendToFriend(friendId, encrypted, state, false, false);
     }
-    /** Append a Carrier BULKMSG fragment; returns the full reassembled
-     *  message when the last fragment lands, undefined while pending.
-     *  Mirrors the C SDK's handle_friend_bulkmsg: totalsz on the first
-     *  fragment sizes the buffer; fragments append in arrival order. */
-    #assembleBulkMsg(friendId, frag) {
+    /** Append a Carrier BULKMSG fragment and return the full reassembled message
+     *  once every fragment has landed (undefined while pending).
+     *
+     *  The C SDK's send_bulk_message puts totalsz on the FIRST fragment (index 1)
+     *  and sends the rest with totalsz 0, back-to-back with ascending reliable
+     *  packet numbers. Over a dual/UDP path those fragments can arrive REORDERED —
+     *  including the first (totalsz-bearing) one landing after later fragments. So
+     *  we key fragments by their PACKET NUMBER (dedup + order), record totalsz
+     *  whenever the first fragment shows up (in any order), and complete once we
+     *  hold every byte — then concatenate in packet-number order. This tolerates
+     *  reordering + duplicates WITHOUT stalling the reliable stream (a genuinely
+     *  lost fragment just expires this one message after 60s, nothing else). */
+    #assembleBulkMsg(friendId, frag, packetNumber) {
         const now = Date.now();
         // Lazy expiry sweep (C uses a 60s assembly timeout).
         for (const [key, entry] of this.#bulkAssembly) {
@@ -3501,31 +3528,44 @@ export class Peer {
         const key = `${friendId}:${frag.tid.toString()}`;
         let entry = this.#bulkAssembly.get(key);
         if (!entry) {
-            if (!frag.totalsz || frag.totalsz > CARRIER_MAX_APP_BULKMSG_LEN) {
-                this.#debugLog(`bulkmsg from ${friendId} with invalid/missing totalsz ${frag.totalsz} — dropped`);
+            entry = { total: 0, frags: new Map(), got: 0, expireAtMs: now + 60_000 };
+            this.#bulkAssembly.set(key, entry);
+        }
+        // The first fragment carries totalsz; it may arrive out of order.
+        if (frag.totalsz > 0) {
+            if (frag.totalsz > CARRIER_MAX_APP_BULKMSG_LEN) {
+                this.#debugLog(`bulkmsg from ${friendId} totalsz ${frag.totalsz} exceeds cap — dropped`);
+                this.#bulkAssembly.delete(key);
                 return undefined;
             }
-            entry = { total: frag.totalsz, chunks: [], got: 0, expireAtMs: now + 60_000 };
-            this.#bulkAssembly.set(key, entry);
+            entry.total = frag.totalsz;
         }
-        if (frag.data.length === 0 || entry.got + frag.data.length > entry.total) {
-            this.#debugLog(`bulkmsg fragment from ${friendId} overflows totalsz — dropped`);
-            this.#bulkAssembly.delete(key);
-            return undefined;
+        // Store by packet number; a duplicate (dual-send) fragment is ignored.
+        if (frag.data.length > 0 && !entry.frags.has(packetNumber)) {
+            entry.frags.set(packetNumber, frag.data);
+            entry.got += frag.data.length;
         }
-        entry.chunks.push(frag.data);
-        entry.got += frag.data.length;
-        if (entry.got < entry.total)
+        // Complete only once the totalsz-bearing fragment has arrived AND we hold
+        // every byte. Until then, keep buffering.
+        if (entry.total === 0 || entry.got < entry.total)
             return undefined;
         this.#bulkAssembly.delete(key);
-        return concatBytes(entry.chunks);
-    }
-    /** Append a Carrier invite fragment (INVITE_REQUEST/RESPONSE); returns the
-     *  full reassembled payload when the last fragment lands, undefined while
-     *  pending. Mirrors #assembleBulkMsg but caps at CARRIER_MAX_INVITE_DATA_LEN
-     *  (8192) and uses a separate buffer. Single-fragment invites (the common
-     *  case for small WebRTC signals) complete on the first call. */
-    #assembleInvite(friendId, frag) {
+        if (entry.got > entry.total) {
+            this.#debugLog(`bulkmsg from ${friendId} got ${entry.got} > total ${entry.total} — dropped`);
+            return undefined;
+        }
+        // Concatenate in ascending packet-number order (the fragments' send order).
+        const nums = [...entry.frags.keys()].sort((a, b) => a - b);
+        return concatBytes(nums.map((n) => entry.frags.get(n)));
+    }
+    /** Append a Carrier invite fragment (INVITE_REQUEST/RESPONSE) and return the
+     *  full reassembled payload once every fragment has landed. Like
+     *  #assembleBulkMsg, fragments are keyed + ordered by PACKET NUMBER so a
+     *  reordered multi-fragment WebRTC SDP (offer/answer >1280 bytes) reassembles
+     *  correctly instead of scrambling — a scrambled SDP left calls stuck
+     *  "connecting". Caps at CARRIER_MAX_INVITE_DATA_LEN (8192). Single-fragment
+     *  invites (the common case) complete on the first call. */
+    #assembleInvite(friendId, frag, packetNumber) {
         const now = Date.now();
         for (const [key, entry] of this.#inviteAssembly) {
             if (entry.expireAtMs < now)
@@ -3534,26 +3574,31 @@ export class Peer {
         const key = `${friendId}:${frag.tid.toString()}`;
         let entry = this.#inviteAssembly.get(key);
         if (!entry) {
-            // First fragment carries totalsz. A lone fragment whose data already
-            // equals totalsz completes immediately below.
-            if (!frag.totalsz || frag.totalsz > CARRIER_MAX_INVITE_DATA_LEN) {
-                this.#debugLog(`invite from ${friendId} with invalid/missing totalsz ${frag.totalsz} — dropped`);
+            entry = { total: 0, frags: new Map(), got: 0, expireAtMs: now + 60_000 };
+            this.#inviteAssembly.set(key, entry);
+        }
+        // The first fragment carries totalsz; it may arrive out of order.
+        if (frag.totalsz > 0) {
+            if (frag.totalsz > CARRIER_MAX_INVITE_DATA_LEN) {
+                this.#debugLog(`invite from ${friendId} totalsz ${frag.totalsz} exceeds cap — dropped`);
+                this.#inviteAssembly.delete(key);
                 return undefined;
             }
-            entry = { total: frag.totalsz, chunks: [], got: 0, expireAtMs: now + 60_000 };
-            this.#inviteAssembly.set(key, entry);
+            entry.total = frag.totalsz;
         }
-        if (frag.data.length === 0 || entry.got + frag.data.length > entry.total) {
-            this.#debugLog(`invite fragment from ${friendId} overflows totalsz — dropped`);
-            this.#inviteAssembly.delete(key);
-            return undefined;
+        if (frag.data.length > 0 && !entry.frags.has(packetNumber)) {
+            entry.frags.set(packetNumber, frag.data);
+            entry.got += frag.data.length;
         }
-        entry.chunks.push(frag.data);
-        entry.got += frag.data.length;
-        if (entry.got < entry.total)
+        if (entry.total === 0 || entry.got < entry.total)
             return undefined;
         this.#inviteAssembly.delete(key);
-        return concatBytes(entry.chunks);
+        if (entry.got > entry.total) {
+            this.#debugLog(`invite from ${friendId} got ${entry.got} > total ${entry.total} — dropped`);
+            return undefined;
+        }
+        const nums = [...entry.frags.keys()].sort((a, b) => a - b);
+        return concatBytes(nums.map((n) => entry.frags.get(n)));
     }
     /** iOS Beagle sends files inline as a JSON envelope over (bulk)messages:
      *  {"data":"<base64>","fileExtension":".jpg","fileName":"…","type":"image"}.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.89",
+  "version": "0.1.91",
   "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",
@@ -69,6 +69,7 @@
     "test:compat": "pnpm run build && node scripts/compat-selftest.mjs",
     "test:invite": "pnpm run build && node scripts/invite-selftest.mjs",
     "test:reorder": "pnpm run build && node scripts/reorder-selftest.mjs",
+    "test:bulkmsg": "pnpm run build && node scripts/bulkmsg-selftest.mjs",
     "test:userinfo": "pnpm run build && node scripts/userinfo-selftest.mjs",
     "test:tcp-onion": "pnpm run build && node scripts/tcp-onion-selftest.mjs",
     "smoke:join": "node scripts/smoke-join.mjs",