@decentnetwork/peer 0.1.54 → 0.1.55

package/dist/compat/filetransfer.js

@@ -138,7 +138,7 @@ export class FileTransferManager {
         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, highestSent: 0, started: false, req, startMs: 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);
@@ -369,23 +369,27 @@ export class FileTransferManager {
             }
         }
         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. Fast-retransmit
-            // the hole region immediately (rate-limited to ~1 RTT so a burst of
-            // dup-acks for one loss doesn't storm). No window backoff: file-path loss
-            // is treated as random, not congestion.
+            // 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();
-            this.#resendRange(friendId, st, st.acked, maxRecv);
+            if (st.nextSend > st.acked)
+                st.nextSend = st.acked;
         }
         if (st.acked >= st.size) {
             this.#completeSend(friendId, st);
             return;
         }
-        this.#pump(friendId, st); // send new data
+        void this.#pump(friendId, st);
     }
-    #pump(friendId, st) {
-        // Watchdog: if the ack hasn't advanced within WATCHDOG_MS, a chunk (or the
-        // fast-retransmit) was lost → go-back-N resend from the ack point. Backstop
-        // to the dup-ack fast-retransmit above.
+    // 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.timer) {
             let stalledSinceMs = nowMs();
             st.timer = setInterval(() => {
@@ -408,44 +412,36 @@ export class FileTransferManager {
                     return;
                 }
                 st.lastAckAdvanceMs = nowMs();
-                st.highestSent = st.acked; // go-back-N: re-send from the ack point
                 st.lastResendMs = nowMs();
-                this.#pumpFrom(friendId, st, st.acked);
+                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();
         }
-        // Send only NEW data, from the high-water mark up to the fixed window edge.
-        this.#pumpFrom(friendId, st, Math.max(st.acked, st.highestSent));
-    }
-    // Fire chunks from `from` up to the window edge. Fire-and-forget: the fixed
-    // window bounds in-flight bytes and the 4 MB socket buffer absorbs the burst,
-    // so we don't serialize on a per-chunk await (which capped throughput at one
-    // chunk per event-loop turn → minutes for a big file).
-    #pumpFrom(friendId, st, from) {
-        const windowEnd = Math.min(st.acked + WINDOW_CHUNKS * 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);
-            void this.send(friendId, PACKET_ID_FILE_DATA, encodeFileData(st.fileNumber, off, st.data.subarray(off, end))).catch(() => undefined);
-            off = end;
+        if (st.pumping)
+            return;
+        st.pumping = true;
+        try {
+            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
+            }
         }
-        if (off > st.highestSent)
-            st.highestSent = off;
-    }
-    // Re-send the chunks in [from, to) — the gap region the receiver is missing.
-    // Already-received chunks are idempotent (placed by offset on the receiver).
-    #resendRange(friendId, st, from, to) {
-        let off = from;
-        const end0 = Math.min(to, st.size);
-        while (off < end0) {
-            if (!this.#map(this.#sending, friendId).has(st.fileNumber))
-                return;
-            const end = Math.min(off + MAX_FILE_DATA_SIZE, st.size);
-            void this.send(friendId, PACKET_ID_FILE_DATA, encodeFileData(st.fileNumber, off, st.data.subarray(off, end))).catch(() => undefined);
-            off = end;
+        finally {
+            st.pumping = false;
         }
     }
     #completeSend(friendId, st) {

package/package.json

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