@decentnetwork/peer 0.1.75 → 0.1.76

package/dist/compat/filetransfer.js

@@ -105,7 +105,7 @@ const CWND_MIN_CHUNKS = 8; // ~11 KB floor — keeps a slow/flaky path's buffer
 // ~0.5s of added latency keeps ping well under a second (fine — the peer stays
 // usable), and buys far more throughput on a jittery path than a tight 150ms
 // bound, which collapsed the window to the floor (~17 KB/s observed on lili).
-const MAX_QUEUE_MS = 350; // raw-queue ceiling before draining (bulk transfer tolerates ~0.35s added latency)
+const MAX_QUEUE_MS = 350; // raw-queue ceiling before draining (bulk transfer tolerates ~0.35s added latency; a tighter bound collapses the window on a 40%-loss path where recovery makes RTT noisy)
 const QUEUE_LOW_MS = 150; // grow while the smoothed (jitter-free) queue is under this
 const VEGAS_GROW = 1.25; // window ×this per RTT when under-filled
 const VEGAS_SHRINK = 0.8; // window ×this per RTT when the queue is too deep
@@ -674,12 +674,8 @@ export class FileTransferManager {
                     if (st.srttMs < st.minSrttMs)
                         st.minSrttMs = st.srttMs;
                     // Hybrid signal, so per-packet JITTER doesn't masquerade as a queue:
-                    //  • GROW on the SMOOTHED queue (srtt − minSrtt): jitter averages out,
-                    //    so a flaky path that isn't really queuing keeps growing instead
-                    //    of collapsing to the floor (~17 KB/s observed on lili).
-                    //  • SHRINK on the RAW queue (rtt − minRtt) against a higher ceiling:
-                    //    fast reaction to genuine bufferbloat, but the ceiling sits above
-                    //    the jitter band so a lone jittery sample doesn't trigger it.
+                    //  • GROW on the SMOOTHED queue (srtt − minSrtt): jitter averages out.
+                    //  • SHRINK on the RAW queue (rtt − minRtt) against a higher ceiling.
                     const smoothQueue = st.minSrttMs !== Infinity ? st.srttMs - st.minSrttMs : 0;
                     const rawQueue = st.minRttMs !== Infinity ? rtt - st.minRttMs : 0;
                     if (rawQueue > MAX_QUEUE_MS) {
@@ -695,11 +691,16 @@ export class FileTransferManager {
                 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.
+        else if (maxRecv > st.acked + Math.max(4, st.cwnd >> 2) * MAX_FILE_DATA_SIZE && nowMs() - st.lastResendMs >= FAST_RT_MIN_MS) {
+            // Duplicate ack WITH a gap bigger than the REORDER window (≈¼ of the flight)
+            // → the chunk at `acked` is genuinely lost, not just reordered. Requiring a
+            // real gap is what unlocked throughput on jittery GFW paths: a 1-chunk
+            // trigger fired constantly on per-packet jitter (packets arrive out of
+            // order), each firing a go-back-N rewind that re-sent bytes the receiver
+            // already had and pinned the window near the floor. Now FEC repairs the
+            // occasional true hole locally, so waiting a few chunks before retransmit
+            // costs nothing. Rewind the send cursor to the hole (rate-limited to ~1 RTT
+            // so a dup-ack burst can't storm). No window backoff: loss ≠ congestion.
             st.lastResendMs = nowMs();
             st.lastLossMs = nowMs(); // the path is lossy → turn adaptive FEC on
             if (st.nextSend > st.acked)

package/package.json

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