@decentnetwork/peer 0.1.90 → 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.90";
+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
@@ -2033,23 +2033,25 @@ export class Peer {
                 // 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
+                // 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 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.
+                // 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)) {
-                    let isBulk = false;
+                    let reorderable = false;
                     if (innerKind === PACKET_ID_MESSAGE) {
                         try {
-                            isBulk = decodeCarrierPacket(opened.payload.slice(1)).type === PACKET_TYPE_BULKMSG;
+                            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 (!isBulk)
+                    if (!reorderable)
                         continue;
                 }
                 // Track the receive nonce from the EXACT nonce this packet used
@@ -3346,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", {
@@ -3359,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", {
@@ -3556,12 +3558,14 @@ export class Peer {
         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
-     *  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) {
+    /** 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)
@@ -3570,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.90",
+  "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",