@decentnetwork/peer 0.1.72 → 0.1.73

package/dist/compat/filetransfer.js

@@ -62,10 +62,14 @@ const CWND_MIN_CHUNKS = 8; // ~11 KB floor — keeps a slow/flaky path's buffer
 // link keeps a big window (it drains quickly, so a big window adds little
 // delay); a thin flaky one keeps a small window (a big window there would add
 // seconds). Growing whenever the added delay is low means no self-limiting.
-const MAX_QUEUE_MS = 150; // ceiling on added latency → when exceeded, drain
-const QUEUE_LOW_MS = 60; // below this there's spare capacity → grow
-const VEGAS_GROW = 1.3; // window ×this per RTT when under-filled
-const VEGAS_SHRINK = 0.85; // window ×this per RTT when the queue is too deep
+// The budget is generous on purpose: for a bulk transfer to a flaky peer,
+// ~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 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
 const WATCHDOG_MS = 150; // stall poll cadence / base no-progress patience
 const WATCHDOG_MAX_MS = 8000; // cap the RTT-adaptive stall patience (must exceed a slow path's RTT so acks aren't mistaken for a stall)
 const FAST_RT_MIN_MS = 40; // min gap between fast-retransmits of the same hole (≈1 RTT)
@@ -194,7 +198,7 @@ export class FileTransferManager {
             acked: 0, nextSend: 0, pumping: false, started: false, req, startMs: nowMs(),
             lastProgressAcked: 0, lastAckAdvanceMs: nowMs(), lastResendMs: 0,
             cwnd: CWND_INIT_CHUNKS, stalls: 0,
-            minRttMs: Infinity, srttMs: 0, probeOffset: -1, probeSentMs: 0,
+            minRttMs: Infinity, minSrttMs: Infinity, srttMs: 0, probeOffset: -1, probeSentMs: 0,
         };
         this.#map(this.#sending, friendId).set(fileNumber, st);
         void this.send(friendId, PACKET_ID_FILE_SENDREQUEST, req).catch(() => undefined);
@@ -498,15 +502,23 @@ export class FileTransferManager {
                     st.srttMs = st.srttMs === 0 ? rtt : 0.85 * st.srttMs + 0.15 * rtt;
                     if (rtt < st.minRttMs)
                         st.minRttMs = rtt;
-                    // Added latency this transfer is putting on the path = how deep the
-                    // queue is. Steer the window to keep it under MAX_QUEUE_MS.
-                    const queueDelayMs = st.minRttMs !== Infinity ? rtt - st.minRttMs : 0;
-                    if (queueDelayMs < QUEUE_LOW_MS) {
-                        st.cwnd = Math.min(WINDOW_CHUNKS, Math.ceil(st.cwnd * VEGAS_GROW)); // spare capacity → grow
+                    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.
+                    const smoothQueue = st.minSrttMs !== Infinity ? st.srttMs - st.minSrttMs : 0;
+                    const rawQueue = st.minRttMs !== Infinity ? rtt - st.minRttMs : 0;
+                    if (rawQueue > MAX_QUEUE_MS) {
+                        st.cwnd = Math.max(CWND_MIN_CHUNKS, Math.floor(st.cwnd * VEGAS_SHRINK)); // real queue too deep → drain
                     }
-                    else if (queueDelayMs > MAX_QUEUE_MS) {
-                        st.cwnd = Math.max(CWND_MIN_CHUNKS, Math.floor(st.cwnd * VEGAS_SHRINK)); // queue too deep → drain
-                    } // else hold: pipe full, queue shallow
+                    else if (smoothQueue < QUEUE_LOW_MS) {
+                        st.cwnd = Math.min(WINDOW_CHUNKS, Math.ceil(st.cwnd * VEGAS_GROW)); // spare capacity → grow
+                    } // else hold
                 }
             }
             if (st.acked - st.lastProgressAcked >= 256 * 1024 || st.acked >= st.size) {

package/package.json

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