@decentnetwork/peer 0.1.47 → 0.1.48

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";
@@ -2785,8 +2785,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 +2811,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 +2891,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.48",
   "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",