@decentnetwork/peer 0.1.47 → 0.1.49

package/dist/peer.js

@@ -9,7 +9,7 @@ import { PACKET_TYPE_MESSAGE, PACKET_TYPE_FRIEND_REQUEST, PACKET_TYPE_USERINFO,
 import { NET_PACKET_ONION_ANNOUNCE_RESPONSE, NET_PACKET_ONION_DATA_RESPONSE, ONION_FRIEND_REQUEST_ID, createOnionAnnounceRequest, createOnionDataPacket, createOnionDataRequest, createOnionRequest0, openOnionAnnounceResponse, openOnionDataPacket, openOnionDataResponse } from "./compat/tox-onion.js";
 import { CRYPTO_PACKET_DHTPK, CRYPTO_PACKET_FRIEND_REQ, NET_PACKET_CRYPTO, createToxDhtCryptoRequest, openToxDhtCryptoRequest } from "./compat/tox-dht-crypto.js";
 import { NET_PACKET_PING_REQUEST, NET_PACKET_PING_RESPONSE, NET_PACKET_GET_NODES, NET_PACKET_SEND_NODES, encodeDhtRpc, decodeDhtRpc, buildPingPlain, parsePingPlain, buildGetNodesPlain, parseGetNodesPlain, buildSendNodesPlain, parseSendNodesNodeBytes, packUdpNodeV4 } from "./compat/dht-rpc.js";
-import { FileTransferManager } from "./compat/filetransfer.js";
+import { FileTransferManager, PACKET_ID_FILE_SENDREQUEST, PACKET_ID_FILE_CONTROL, PACKET_ID_FILE_DATA } from "./compat/filetransfer.js";
 import { NET_PACKET_CRYPTO_DATA, NET_PACKET_CRYPTO_HS, NET_PACKET_COOKIE_REQUEST, NET_PACKET_COOKIE_RESPONSE, createCookieRequest, createCookieResponse, createCryptoDataPacket, createCryptoHandshake, openCookieRequest, openCookieResponse, openCryptoDataPacket, openCryptoHandshake, incrementNonce } from "./compat/net-crypto.js";
 import { LegacyExpressClient } from "./compat/express.js";
 import { TcpRelayPool } from "./compat/tcp-relay-pool.js";
@@ -1551,14 +1551,26 @@ export class Peer {
                 if (!opened) {
                     continue;
                 }
-                // De-duplicate. The dual-send path delivers each lossless packet over
-                // BOTH the UDP and relay transports with the SAME packet number, so
-                // without this guard every chat message (and every file-data chunk) is
-                // dispatched — and stored / shown / appended — twice. Drop anything at or
-                // below the receive low-water mark, like toxcore net_crypto drops packets
-                // below buffer_start. Must run BEFORE the nonce advance below so a
-                // duplicate doesn't desync the receive nonce.
-                if (opened.packetNumber < (state.receiveBufferStart ?? 0)) {
+                // De-duplicate — but ONLY for dual-sent channels. The dual-send path
+                // delivers a lossless packet over BOTH UDP and relay with the SAME
+                // packet number, so without this guard a chat message is dispatched
+                // (stored / shown) twice. Drop anything at or below the receive
+                // low-water mark, like toxcore net_crypto drops below buffer_start.
+                //
+                // EXCEPT single-transport channels (bulk IP = bulkDataPacketId, and
+                // file transfer 80-82): they are NOT dual-sent, so they never produce
+                // duplicates — and the low-water mark would then only drop a
+                // legitimately REORDERED packet, which over a high-rate stream (CCTV
+                // over a long-haul China↔US path that reorders) is pure added loss /
+                // jitter. IP forwarding is order-independent (the TUN/TCP above
+                // reassembles), so deliver every packet. Must run BEFORE the nonce
+                // advance so a real duplicate doesn't desync the receive nonce.
+                const innerKind = opened.payload.length > 0 ? opened.payload[0] : -1;
+                const isSingleTransportKind = (this.#opts.bulkDataPacketId !== undefined && innerKind === this.#opts.bulkDataPacketId) ||
+                    innerKind === PACKET_ID_FILE_SENDREQUEST ||
+                    innerKind === PACKET_ID_FILE_CONTROL ||
+                    innerKind === PACKET_ID_FILE_DATA;
+                if (!isSingleTransportKind && opened.packetNumber < (state.receiveBufferStart ?? 0)) {
                     continue;
                 }
                 state.peerBaseNonce[state.peerBaseNonce.length - 2] = packet[1];
@@ -2785,8 +2797,23 @@ export class Peer {
         // e.g. decentlan IP=163) stays bulk / single-transport to avoid the relay
         // backlog + duplicate fan-out that high packet rates cause. Chat is sparse
         // and net_crypto dedups by packet number, so dual-send is safe here.
-        const isBulkData = this.#opts.bulkDataPacketId !== undefined && kind === this.#opts.bulkDataPacketId;
-        await this.#sendToFriend(friendId, encrypted, session, isBulkData);
+        // File transfer (80 sendrequest / 81 control / 82 data) is ALSO treated as
+        // bulk → single-transport. It is high-volume AND order-sensitive: the
+        // receiver reassembles chunks SEQUENTIALLY (position is implicit) and there
+        // is no retransmit queue. Dual-sending it over UDP + relay (two paths with
+        // different latency) reorders the chunks, and the receive-side low-water
+        // dedup then drops the late copies — so a large file (mp4) gets gaps /
+        // wrong order and never completes, while a tiny one (png, 1-2 chunks)
+        // happens to finish before reordering bites. Pinning file transfer to a
+        // single transport keeps the chunks in send order. (Reliability across a
+        // lossy path still wants a reorder buffer + retransmit — tracked separately.)
+        const isFileTransfer = kind === PACKET_ID_FILE_SENDREQUEST || kind === PACKET_ID_FILE_CONTROL || kind === PACKET_ID_FILE_DATA;
+        const isBulkData = (this.#opts.bulkDataPacketId !== undefined && kind === this.#opts.bulkDataPacketId) || isFileTransfer;
+        // File transfer rides the relay RELIABLY (never dropped under backpressure):
+        // a dropped IP/CCTV packet is fine (the stream moves on), but a dropped file
+        // chunk corrupts the file (no retransmit). So bulk IP data stays droppable
+        // while file transfer is queued.
+        await this.#sendToFriend(friendId, encrypted, session, isBulkData, isFileTransfer);
     }
     /**
      * Send `packet` to `friendId` over whichever transport(s) are
@@ -2796,7 +2823,7 @@ export class Peer {
      * receiving end (toxcore does the same when both transports are up).
      * Throws only if zero transports succeeded.
      */
-    async #sendToFriend(friendId, packet, session, isBulkData = false) {
+    async #sendToFriend(friendId, packet, session, isBulkData = false, reliableOnRelay = false) {
         const s = session ?? this.#friendSessions.get(friendId);
         let udpOk = false;
         let tcpOk = false;
@@ -2876,7 +2903,9 @@ export class Peer {
                 // Bulk IP data is droppable over the relay: under backpressure the
                 // relay client drops it (bounded queue) rather than buffering seconds
                 // of packets. Control frames pass isBulkData=false and always queue.
-                const sent = this.#tcpRelays.sendToFriend(tcpKey, packet, isBulkData);
+                // File transfer is bulk (single-transport routing) but must NOT be
+                // dropped — a lost chunk corrupts the file — so it is queued reliably.
+                const sent = this.#tcpRelays.sendToFriend(tcpKey, packet, isBulkData && !reliableOnRelay);
                 if (sent > 0) {
                     tcpOk = true;
                 }

package/package.json

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