@decentnetwork/peer 0.1.89 → 0.1.90

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.90";
 // 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,25 @@ 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: a BULKMSG fragment (inline file from a native peer) 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 whole file is
+                // lost (the classic "bulkmsg totalsz 0 — dropped"). Let bulkmsg through;
+                // #assembleBulkMsg dedups AND orders fragments by packet number, so a
+                // reordered/duplicate fragment is handled correctly there instead.
                 if (!isSingleTransportKind && opened.packetNumber < (state.receiveBufferStart ?? 0)) {
-                    continue;
+                    let isBulk = false;
+                    if (innerKind === PACKET_ID_MESSAGE) {
+                        try {
+                            isBulk = decodeCarrierPacket(opened.payload.slice(1)).type === PACKET_TYPE_BULKMSG;
+                        }
+                        catch { /* not a carrier packet */ }
+                    }
+                    if (!isBulk)
+                        continue;
                 }
                 // Track the receive nonce from the EXACT nonce this packet used
                 // (openCryptoDataPacket reconstructs it with full carry/borrow).
@@ -2078,7 +2095,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 +3191,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;
@@ -3357,7 +3374,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 +3504,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,24 +3526,35 @@ 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);
+        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); returns the
      *  full reassembled payload when the last fragment lands, undefined while

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/peer",
-  "version": "0.1.89",
+  "version": "0.1.90",
   "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",