@decentnetwork/peer 0.1.52 → 0.1.53

package/dist/compat/filetransfer.js

@@ -30,8 +30,16 @@ export const MAX_CONCURRENT_FILE_PIPES = 256;
 export const MAX_FILE_DATA_SIZE = 1367;
 export const FILECONTROL = { ACCEPT: 0, PAUSE: 1, KILL: 2, SEEK: 3, ACK: 4 };
 export const FILEKIND = { DATA: 0, AVATAR: 1 };
-// Reliability tuning.
-const WINDOW_CHUNKS = 192; // chunks in flight (≈ 256 KB) for throughput on high-BDP paths
+// Reliability + congestion control tuning. The window is a CONGESTION WINDOW
+// (cwnd, in chunks) that slow-starts from small and grows with acks, halving on
+// a loss/stall — TCP-style AIMD. Starting at a fixed large window blasted an
+// initial burst that a slow/lossy long-haul path (China↔US) couldn't absorb, so
+// the front chunks kept dropping and go-back-N re-burst the same → a big file
+// stuck at 0%. Slow-start makes the first send tiny (fits any path), then it
+// self-clocks to the path's capacity via the ack stream.
+const INITIAL_CWND = 8; // chunks (~11 KB) — small enough for any path
+const MIN_CWND = 4;
+const MAX_CWND = 1024; // ~1.4 MB in flight cap
 const RETRANSMIT_MS = 600; // resend window from the ack point if no progress in this long
 const ACK_THROTTLE_MS = 25; // coalesce receiver acks
 const SEND_GIVEUP_MS = 60000; // abandon a send after this long with no ack progress (peer gone)
@@ -129,7 +137,8 @@ export class FileTransferManager {
         const fileId = randomBytes(FILE_ID_LENGTH);
         const st = {
             fileNumber, fileId, name: opts.name, data, size: data.length,
-            acked: 0, pumping: false, lastProgressAcked: 0, lastAckAdvanceMs: nowMs(),
+            acked: 0, cwnd: INITIAL_CWND, ssthresh: MAX_CWND,
+            pumping: false, lastProgressAcked: 0, lastAckAdvanceMs: nowMs(),
         };
         this.#map(this.#sending, friendId).set(fileNumber, st);
         const req = encodeFileSendRequest(fileNumber, opts.kind ?? FILEKIND.DATA, BigInt(data.length), fileId, opts.name);
@@ -194,7 +203,7 @@ export class FileTransferManager {
         const st = {
             fileNumber: r.fileNumber, fileId: r.fileId, name: r.filename, size,
             buf: new Uint8Array(size), got: new Uint8Array(chunkCount(size)),
-            contiguous: 0, done: false, ackDirty: false,
+            contiguous: 0, maxByte: 0, done: false, ackDirty: false,
         };
         this.#map(this.#receiving, friendId).set(r.fileNumber, st);
         this.emit("file-offer", { friendId, fileNumber: r.fileNumber, fileId: hex(r.fileId), name: r.filename, size, kind: r.fileType });
@@ -249,6 +258,8 @@ export class FileTransferManager {
         const idx = Math.floor(offset / MAX_FILE_DATA_SIZE);
         if (offset % MAX_FILE_DATA_SIZE !== 0 || idx >= st.got.length)
             return; // not a chunk boundary
+        if (offset + data.length > st.maxByte)
+            st.maxByte = offset + data.length;
         if (!st.got[idx]) {
             st.buf.set(data, offset);
             st.got[idx] = 1;
@@ -304,17 +315,36 @@ export class FileTransferManager {
     #sendAck(friendId, st) {
         st.ackDirty = false;
         // send_receive=1: the ACK refers to a file the PEER is SENDING (it lives in
-        // the peer's #sending table), so its #onControl routes it there.
-        void this.send(friendId, PACKET_ID_FILE_CONTROL, encodeFileControl(1, st.fileNumber, FILECONTROL.ACK, u32be(st.contiguous))).catch(() => undefined);
+        // the peer's #sending table). Carries [contiguous][maxByte] so the sender
+        // sees the gap (maxByte − contiguous) = loss/reorder, for congestion control.
+        const body = new Uint8Array(8);
+        body.set(u32be(st.contiguous), 0);
+        body.set(u32be(st.maxByte), 4);
+        void this.send(friendId, PACKET_ID_FILE_CONTROL, encodeFileControl(1, st.fileNumber, FILECONTROL.ACK, body)).catch(() => undefined);
     }
     // ── sender ────────────────────────────────────────────────────────
     #onAck(friendId, st, data) {
         if (data.length < 4)
             return;
         const ackedOffset = readU32be(data, 0);
+        const maxRecv = data.length >= 8 ? readU32be(data, 4) : ackedOffset;
+        // Gap = bytes the receiver has seen BEYOND the contiguous point that are
+        // still missing below maxRecv → loss (or reorder). A gap bigger than half
+        // the window means we're overrunning the path → back off (multiplicative
+        // decrease). Otherwise the path is keeping up → grow (slow-start / linear).
+        const gapChunks = Math.max(0, maxRecv - ackedOffset) / MAX_FILE_DATA_SIZE;
         if (ackedOffset > st.acked) {
             st.acked = Math.min(ackedOffset, st.size);
             st.lastAckAdvanceMs = nowMs();
+            if (gapChunks > st.cwnd * 0.5) {
+                st.ssthresh = Math.max(MIN_CWND, st.cwnd >> 1);
+                st.cwnd = st.ssthresh;
+            }
+            else {
+                st.cwnd = st.cwnd < st.ssthresh
+                    ? Math.min(st.cwnd * 2, st.ssthresh)
+                    : Math.min(st.cwnd + 1, MAX_CWND);
+            }
             if (st.acked - st.lastProgressAcked >= 64 * 1024 || st.acked >= st.size) {
                 st.lastProgressAcked = st.acked;
                 this.emit("file-progress", { friendId, fileId: hex(st.fileId), received: st.acked, total: st.size, sending: true });
@@ -357,6 +387,10 @@ export class FileTransferManager {
                     this.emit("file-cancel", { friendId, fileId: hex(st.fileId), sending: true, reason: "timeout" });
                     return;
                 }
+                // Loss/stall detected → multiplicative decrease (back off), then resend
+                // from the ack point. This is the AIMD that paces us to the path.
+                st.ssthresh = Math.max(MIN_CWND, st.cwnd >> 1);
+                st.cwnd = st.ssthresh;
                 st.lastAckAdvanceMs = nowMs();
                 void this.#pumpFrom(friendId, st, st.acked);
             }, Math.ceil(RETRANSMIT_MS / 2));
@@ -370,9 +404,9 @@ export class FileTransferManager {
             st.pumping = false;
         }
     }
-    // Send chunks from `from` up to the window edge (acked + window).
+    // Send chunks from `from` up to the congestion-window edge (acked + cwnd).
     async #pumpFrom(friendId, st, from) {
-        const windowEnd = Math.min(st.acked + WINDOW_CHUNKS * MAX_FILE_DATA_SIZE, st.size);
+        const windowEnd = Math.min(st.acked + Math.max(MIN_CWND, st.cwnd | 0) * MAX_FILE_DATA_SIZE, st.size);
         let off = from;
         while (off < windowEnd) {
             if (!this.#map(this.#sending, friendId).has(st.fileNumber))

package/package.json

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