@decentnetwork/peer 0.1.53 → 0.1.55

package/dist/compat/filetransfer.js

@@ -30,18 +30,18 @@ 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 + 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
+// Reliability tuning. We use a FIXED in-flight window (not TCP-style AIMD): a
+// file transfer over a private direct path should treat packet loss as RANDOM
+// (lossy Wi-Fi / long-haul jitter), NOT as congestion — backing the window off
+// on every random drop collapsed throughput to a crawl (minutes for a big
+// file). Instead, keep the window large and just retransmit the gaps fast. The
+// 4 MB UDP socket buffer absorbs the burst; the receiver buffers by offset, so
+// reordering is free.
+const WINDOW_CHUNKS = 768; // ~1 MB in flight — fills a 200ms-RTT path at ~5 MB/s
+const WATCHDOG_MS = 150; // resend from the ack point if no progress this long
+const FAST_RT_MIN_MS = 40; // min gap between fast-retransmits of the same hole (≈1 RTT)
+const ACK_THROTTLE_MS = 15; // coalesce receiver acks (fast enough to drive fast-retransmit)
+const REACK_MS = 200; // receiver keep-alive re-ack cadence
 const SEND_GIVEUP_MS = 60000; // abandon a send after this long with no ack progress (peer gone)
 function u32be(n) {
     const b = new Uint8Array(4);
@@ -135,14 +135,34 @@ export class FileTransferManager {
         if (fileNumber < 0)
             return null;
         const fileId = randomBytes(FILE_ID_LENGTH);
+        const req = encodeFileSendRequest(fileNumber, opts.kind ?? FILEKIND.DATA, BigInt(data.length), fileId, opts.name);
         const st = {
             fileNumber, fileId, name: opts.name, data, size: data.length,
-            acked: 0, cwnd: INITIAL_CWND, ssthresh: MAX_CWND,
-            pumping: false, lastProgressAcked: 0, lastAckAdvanceMs: nowMs(),
+            acked: 0, nextSend: 0, pumping: false, started: false, req, startMs: nowMs(),
+            lastProgressAcked: 0, lastAckAdvanceMs: nowMs(), lastResendMs: 0,
         };
         this.#map(this.#sending, friendId).set(fileNumber, st);
-        const req = encodeFileSendRequest(fileNumber, opts.kind ?? FILEKIND.DATA, BigInt(data.length), fileId, opts.name);
         void this.send(friendId, PACKET_ID_FILE_SENDREQUEST, req).catch(() => undefined);
+        // Retransmit the offer until the receiver responds — on a lossy path the
+        // offer itself can drop and nothing else would start the transfer.
+        let offerSinceMs = nowMs();
+        st.offerTimer = setInterval(() => {
+            const cur = this.#map(this.#sending, friendId).get(fileNumber);
+            if (!cur || cur.started) {
+                if (st.offerTimer)
+                    clearInterval(st.offerTimer);
+                st.offerTimer = undefined;
+                return;
+            }
+            if (nowMs() - offerSinceMs >= SEND_GIVEUP_MS) {
+                this.#endSend(friendId, fileNumber);
+                this.emit("file-cancel", { friendId, fileId: hex(fileId), sending: true, reason: "no-response" });
+                return;
+            }
+            void this.send(friendId, PACKET_ID_FILE_SENDREQUEST, cur.req).catch(() => undefined);
+        }, WATCHDOG_MS * 3);
+        if (typeof st.offerTimer.unref === "function")
+            st.offerTimer.unref();
         return hex(fileId);
     }
     accept(friendId, fileNumber) {
@@ -164,7 +184,7 @@ export class FileTransferManager {
                     return;
                 }
                 this.#sendAck(friendId, cur);
-            }, RETRANSMIT_MS);
+            }, REACK_MS);
             if (typeof st.reackTimer.unref === "function")
                 st.reackTimer.unref();
         }
@@ -198,8 +218,10 @@ export class FileTransferManager {
             return;
         const size = Number(r.fileSize);
         const existing = this.#map(this.#receiving, friendId).get(r.fileNumber);
-        if (existing && !existing.done)
-            return; // active transfer already on this slot
+        if (existing && !existing.done) {
+            this.#sendAck(friendId, existing);
+            return;
+        } // re-offer (our accept/ack lost) → re-ack
         const st = {
             fileNumber: r.fileNumber, fileId: r.fileId, name: r.filename, size,
             buf: new Uint8Array(size), got: new Uint8Array(chunkCount(size)),
@@ -219,8 +241,17 @@ export class FileTransferManager {
             const st = this.#map(this.#sending, friendId).get(c.fileNumber);
             if (!st)
                 return;
+            if (c.controlType === FILECONTROL.ACCEPT || c.controlType === FILECONTROL.ACK) {
+                if (!st.started) {
+                    st.started = true;
+                    if (st.offerTimer) {
+                        clearInterval(st.offerTimer);
+                        st.offerTimer = undefined;
+                    }
+                }
+            }
             if (c.controlType === FILECONTROL.ACCEPT) {
-                void this.#pump(friendId, st);
+                this.#pump(friendId, st);
             }
             else if (c.controlType === FILECONTROL.ACK) {
                 this.#onAck(friendId, st, c.data);
@@ -328,41 +359,37 @@ export class FileTransferManager {
             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) {
+            // Progress.
             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) {
+            if (st.acked - st.lastProgressAcked >= 256 * 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 });
             }
         }
+        else if (maxRecv > st.acked + MAX_FILE_DATA_SIZE && nowMs() - st.lastResendMs >= FAST_RT_MIN_MS) {
+            // Duplicate ack WITH a gap → the chunk at `acked` was lost. Rewind the send
+            // cursor to the ack point so the loop re-sends the hole (rate-limited to
+            // ~1 RTT so dup-ack bursts for one loss don't storm). No window backoff:
+            // file-path loss is treated as random, not congestion.
+            st.lastResendMs = nowMs();
+            if (st.nextSend > st.acked)
+                st.nextSend = st.acked;
+        }
         if (st.acked >= st.size) {
             this.#completeSend(friendId, st);
             return;
         }
-        void this.#pump(friendId, st); // window slid → send more
+        void this.#pump(friendId, st);
     }
+    // Single send loop. Awaits each send so net_crypto / the UDP socket applies
+    // backpressure (fire-and-forget blasted the whole window into the macOS UDP
+    // buffer at once → systematic overflow/drops the retransmit couldn't dig out
+    // of → a big file "failed"). Sends from `nextSend`, which the ack handler and
+    // watchdog rewind to `acked` to retransmit a hole (go-back-N). The fixed
+    // window bounds in-flight bytes; throughput self-clocks to the path.
     async #pump(friendId, st) {
-        if (st.pumping)
-            return;
-        st.pumping = true;
-        // Retransmit watchdog: if the ack hasn't advanced within RETRANSMIT_MS,
-        // rewind the send cursor to the ack point (go-back-N) so the lost chunk and
-        // anything after it are re-sent. Cumulative acks make this self-correcting.
         if (!st.timer) {
             let stalledSinceMs = nowMs();
             st.timer = setInterval(() => {
@@ -375,57 +402,54 @@ export class FileTransferManager {
                 }
                 if (st.acked >= st.size)
                     return;
-                const sinceAck = nowMs() - st.lastAckAdvanceMs;
-                if (sinceAck < RETRANSMIT_MS) {
+                if (nowMs() - st.lastAckAdvanceMs < WATCHDOG_MS) {
                     stalledSinceMs = nowMs();
                     return;
                 }
-                // Give up if the receiver has gone silent for too long (disconnected /
-                // closed the app) rather than retransmitting forever.
                 if (nowMs() - stalledSinceMs >= SEND_GIVEUP_MS) {
                     this.#endSend(friendId, st.fileNumber);
                     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));
+                st.lastResendMs = nowMs();
+                if (st.nextSend > st.acked)
+                    st.nextSend = st.acked; // go-back-N
+                void this.#pump(friendId, st);
+            }, WATCHDOG_MS);
             if (typeof st.timer.unref === "function")
                 st.timer.unref();
         }
+        if (st.pumping)
+            return;
+        st.pumping = true;
         try {
-            await this.#pumpFrom(friendId, st, st.acked);
+            while (this.#map(this.#sending, friendId).has(st.fileNumber) && st.acked < st.size) {
+                const windowEnd = Math.min(st.acked + WINDOW_CHUNKS * MAX_FILE_DATA_SIZE, st.size);
+                if (st.nextSend >= windowEnd)
+                    break; // window full / all sent — wait for acks
+                const off = st.nextSend;
+                const end = Math.min(off + MAX_FILE_DATA_SIZE, st.size);
+                try {
+                    await this.send(friendId, PACKET_ID_FILE_DATA, encodeFileData(st.fileNumber, off, st.data.subarray(off, end)));
+                }
+                catch {
+                    break; // transport down; the watchdog re-kicks
+                }
+                if (st.nextSend === off)
+                    st.nextSend = end; // unless a rewind moved it
+            }
         }
         finally {
             st.pumping = false;
         }
     }
-    // Send chunks from `from` up to the congestion-window edge (acked + cwnd).
-    async #pumpFrom(friendId, st, from) {
-        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))
-                return; // cancelled
-            const end = Math.min(off + MAX_FILE_DATA_SIZE, st.size);
-            const chunk = st.data.subarray(off, end);
-            try {
-                await this.send(friendId, PACKET_ID_FILE_DATA, encodeFileData(st.fileNumber, off, chunk));
-            }
-            catch {
-                return; // transport down; the watchdog will retry from the ack point
-            }
-            off = end;
-        }
-    }
     #completeSend(friendId, st) {
+        const durationMs = nowMs() - st.startMs;
+        const mbps = durationMs > 0 ? st.size / 1024 / 1024 / (durationMs / 1000) : 0;
         this.#endSend(friendId, st.fileNumber);
         this.emit("file-progress", { friendId, fileId: hex(st.fileId), received: st.size, total: st.size, sending: true });
-        this.emit("file-complete", { friendId, fileId: hex(st.fileId), name: st.name, size: st.size, sending: true });
+        this.emit("file-complete", { friendId, fileId: hex(st.fileId), name: st.name, size: st.size, sending: true, durationMs, mbps });
     }
     #endSend(friendId, fileNumber) {
         const st = this.#map(this.#sending, friendId).get(fileNumber);
@@ -433,6 +457,10 @@ export class FileTransferManager {
             clearInterval(st.timer);
             st.timer = undefined;
         }
+        if (st?.offerTimer) {
+            clearInterval(st.offerTimer);
+            st.offerTimer = undefined;
+        }
         this.#map(this.#sending, friendId).delete(fileNumber);
     }
     #endRecv(friendId, fileNumber) {
@@ -448,9 +476,12 @@ export class FileTransferManager {
         this.#map(this.#receiving, friendId).delete(fileNumber);
     }
     clearFriend(friendId) {
-        for (const st of this.#map(this.#sending, friendId).values())
+        for (const st of this.#map(this.#sending, friendId).values()) {
             if (st.timer)
                 clearInterval(st.timer);
+            if (st.offerTimer)
+                clearInterval(st.offerTimer);
+        }
         for (const st of this.#map(this.#receiving, friendId).values()) {
             if (st.ackTimer)
                 clearTimeout(st.ackTimer);

package/package.json

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