@decentnetwork/peer 0.1.75 → 0.1.77

package/dist/compat/filetransfer.js

@@ -105,10 +105,23 @@ 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
+// PACED control (BBR-style). The window-based Vegas controller blasted the whole
+// cwnd into the buffer each round, which on a DEEP buffer (the TCP relay's
+// China↔US queue) piled up to 7-15 s of latency — the feedback loop is longer
+// than a human's patience, so it can't react. The fix is to PACE: send at the
+// estimated bottleneck bandwidth so the buffer stays near-empty regardless of
+// its depth, and RAMP the rate in a startup phase to fill the pipe for speed.
+const PACE_STARTUP_GAIN = 2.0; // startup: pace at 2× measured rate to probe up fast (exits when bandwidth plateaus)
+const PACE_CYCLE_GAINS = [1.25, 0.8, 1, 1, 1, 1, 1, 1]; // steady PROBE_BW cycle: one round up, one round DRAINS the queue, six cruise → avg≈bandwidth, shallow queue
+const PACE_FULLBW_GROWTH = 1.20; // bandwidth still "rising" if ≥20% over the plateau mark
+const PACE_FULLBW_ROUNDS = 3; // leave startup after this many non-rising rounds
+const PACE_BW_WINDOW = 10; // rounds of delivered-rate history for the max-filter
+const PACE_INIT_BPS = 120_000; // initial pace rate (~120 KB/s) before any bandwidth estimate
+const PACE_BURST_MS = 20; // token-bucket burst allowance (keeps sends smooth, not bunched)
 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)
@@ -238,6 +251,9 @@ export class FileTransferManager {
             lastProgressAcked: 0, lastAckAdvanceMs: nowMs(), lastResendMs: 0,
             cwnd: CWND_INIT_CHUNKS, stalls: 0, parityHighBlock: -1, lastLossMs: 0, lossEwma: 0,
             minRttMs: Infinity, minSrttMs: Infinity, srttMs: 0, probeOffset: -1, probeSentMs: 0,
+            paceRateBps: PACE_INIT_BPS, paceTokens: 0, lastPaceMs: nowMs(),
+            btlBwBps: 0, bwSamples: [], fullBwBps: 0, fullBwRounds: 0, bbrPhase: 0, roundCount: 0,
+            rateMarkMs: nowMs(), rateMarkAcked: 0,
         };
         this.#map(this.#sending, friendId).set(fileNumber, st);
         void this.send(friendId, PACKET_ID_FILE_SENDREQUEST, req).catch(() => undefined);
@@ -660,34 +676,62 @@ export class FileTransferManager {
             // reported, overshooting). Estimate chunks queued from RTT inflation and
             // steer to keep it in [ALPHA, BETA].
             if (st.probeOffset >= 0 && st.acked >= st.probeOffset) {
+                // One paced round completed (the timed frontier byte's ack landed).
                 const rtt = nowT - st.probeSentMs;
                 st.probeOffset = -1;
-                // Reject glitch samples: a batched/late ack can make a probe byte look
-                // acked far sooner than it was really delivered, producing an RTT far
-                // below the smoothed value — which would corrupt minRtt and wreck the
-                // queue estimate. Only trust a sample within a sane band of srtt.
+                // Reject glitch samples: a batched / late / resume ack can make a probe
+                // byte look acked far sooner than it really was, giving a tiny rtt that
+                // would corrupt minRtt (RTprop) → shrink the BDP and collapse cwnd to the
+                // floor. Only trust a sample within a sane band of the smoothed RTT.
                 const glitch = st.srttMs > 0 && rtt < st.srttMs * 0.4;
                 if (!glitch && rtt > 0) {
+                    st.roundCount++;
+                    // RTprop = min RTT ever seen (loss/queue only RAISE rtt → min is robust).
                     st.srttMs = st.srttMs === 0 ? rtt : 0.85 * st.srttMs + 0.15 * rtt;
                     if (rtt < st.minRttMs)
                         st.minRttMs = rtt;
-                    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
+                    // BtlBw = max-filtered delivered GOODPUT rate. Loss/reorder ignored as a
+                    // rate signal (they don't reduce bytes/sec; FEC + reorder-tolerant
+                    // retransmit fix correctness), so the rate model never collapses.
+                    const dtSec = Math.max(0.05, (nowT - st.rateMarkMs) / 1000);
+                    const roundRate = (st.acked - st.rateMarkAcked) / dtSec;
+                    st.rateMarkMs = nowT;
+                    st.rateMarkAcked = st.acked;
+                    if (roundRate > 0) {
+                        st.bwSamples.push(roundRate);
+                        if (st.bwSamples.length > PACE_BW_WINDOW)
+                            st.bwSamples.shift();
+                        st.btlBwBps = Math.max(...st.bwSamples);
                     }
-                    else if (smoothQueue < QUEUE_LOW_MS) {
-                        st.cwnd = Math.min(WINDOW_CHUNKS, Math.ceil(st.cwnd * VEGAS_GROW)); // spare capacity → grow
-                    } // else hold
+                    // Wire carries goodput + FEC parity + retransmits, so to fill the LINK
+                    // we pace above goodput by the loss overhead: wire = goodput/(1 − loss).
+                    const lossMult = 1 / (1 - Math.min(0.5, st.lossEwma));
+                    // Two-phase paced control, tuned for STABILITY first (never bloat).
+                    if (st.bbrPhase === 0) {
+                        // STARTUP: ramp ×1.4/round until a real queue builds (rtt ≥1.35×RTprop
+                        // → pipe full), then cruise. The queue-based exit keeps latency
+                        // bounded: on a lossy path loss-recovery trips it sooner, so the fill
+                        // is slower — but it NEVER bloats. That's the right trade — fast on a
+                        // good path, graceful (stable, not 15 s of queue) on a bad one.
+                        const rawQueue = st.minRttMs !== Infinity ? rtt - st.minRttMs : 0;
+                        if (st.minRttMs !== Infinity && rawQueue > st.minRttMs * 0.35)
+                            st.bbrPhase = 2;
+                        st.paceRateBps = Math.max(st.paceRateBps * 1.4, st.btlBwBps * PACE_STARTUP_GAIN * lossMult);
+                    }
+                    else {
+                        // PROBE_BW cruise: one round probes up, one DRAINS (0.8×), six at 1× →
+                        // the AVERAGE pace is exactly bandwidth, so the queue stays shallow.
+                        const gain = PACE_CYCLE_GAINS[st.roundCount % PACE_CYCLE_GAINS.length];
+                        st.paceRateBps = Math.max(PACE_INIT_BPS * 0.5, st.btlBwBps * gain * lossMult);
+                    } // Hard safety cap: never pace faster than a full window drains in 1 RTT.
+                    if (st.minRttMs !== Infinity && st.minRttMs > 0) {
+                        st.paceRateBps = Math.min(st.paceRateBps, (WINDOW_CHUNKS * MAX_FILE_DATA_SIZE) / (st.minRttMs / 1000));
+                    }
+                    // cwnd = SAFETY ceiling sized to the PACE rate (2×paceRate×RTprop), NOT
+                    // the measured bandwidth (which would self-limit). Pacing is primary.
+                    const paceBdp = (st.minRttMs !== Infinity && st.minRttMs > 0)
+                        ? (st.paceRateBps * (st.minRttMs / 1000)) / MAX_FILE_DATA_SIZE : WINDOW_CHUNKS;
+                    st.cwnd = Math.max(CWND_MIN_CHUNKS, Math.min(WINDOW_CHUNKS, Math.ceil(paceBdp * 2)));
                 }
             }
             if (st.acked - st.lastProgressAcked >= 256 * 1024 || st.acked >= st.size) {
@@ -695,11 +739,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)
@@ -768,7 +817,18 @@ export class FileTransferManager {
             while (this.#map(this.#sending, friendId).has(st.fileNumber) && st.acked < st.size) {
                 const windowEnd = Math.min(st.acked + st.cwnd * MAX_FILE_DATA_SIZE, st.size);
                 if (st.nextSend >= windowEnd)
-                    break; // window full / all sent — wait for acks
+                    break; // window (safety cap) full — wait for acks
+                // Pacing gate: refill the token bucket; if we can't afford a chunk yet,
+                // re-arm the pump for exactly when we can. THIS is what keeps a deep
+                // buffer near-empty (bounded ping) instead of blasting the whole window.
+                const nowP = nowMs();
+                st.paceTokens = Math.min(st.paceTokens + ((nowP - st.lastPaceMs) / 1000) * st.paceRateBps, st.paceRateBps * (PACE_BURST_MS / 1000) + MAX_FILE_DATA_SIZE);
+                st.lastPaceMs = nowP;
+                if (st.paceTokens < MAX_FILE_DATA_SIZE) {
+                    const waitMs = Math.max(2, Math.ceil(((MAX_FILE_DATA_SIZE - st.paceTokens) / st.paceRateBps) * 1000));
+                    this.#schedulePace(friendId, st, waitMs);
+                    break;
+                }
                 const off = st.nextSend;
                 const end = Math.min(off + MAX_FILE_DATA_SIZE, st.size);
                 try {
@@ -777,6 +837,7 @@ export class FileTransferManager {
                 catch {
                     break; // transport down; the watchdog re-kicks
                 }
+                st.paceTokens -= end - off;
                 if (st.nextSend === off)
                     st.nextSend = end; // unless a rewind moved it
                 // Arm one RTT probe per round-trip: time this fresh frontier byte until
@@ -794,6 +855,19 @@ export class FileTransferManager {
             st.pumping = false;
         }
     }
+    // Re-kick the pump after `waitMs`, when the token bucket will have refilled
+    // enough for the next chunk. One timer at a time — pacing, not spinning.
+    #schedulePace(friendId, st, waitMs) {
+        if (st.paceTimer)
+            return;
+        st.paceTimer = setTimeout(() => {
+            st.paceTimer = undefined;
+            if (this.#map(this.#sending, friendId).has(st.fileNumber))
+                void this.#pump(friendId, st);
+        }, waitMs);
+        if (typeof st.paceTimer.unref === "function")
+            st.paceTimer.unref();
+    }
     // Send M parity shards for each FEC block whose K data chunks have all been
     // sent (once per block). Parity is computed from the source file, so no state
     // is kept beyond the high-water block index.
@@ -838,6 +912,9 @@ export class FileTransferManager {
             for (let pi = 0; pi < parity.length; pi++) {
                 void this.send(friendId, PACKET_ID_FILE_FEC, encodeFec(st.fileNumber, b, pi, parity[pi])).catch(() => undefined);
             }
+            // Parity rides the same paced budget as data — deduct its bytes so the
+            // TOTAL wire rate stays at paceRateBps and parity can't flood the buffer.
+            st.paceTokens -= parity.length * MAX_FILE_DATA_SIZE;
             st.parityHighBlock = b;
         }
     }
@@ -858,6 +935,10 @@ export class FileTransferManager {
             clearInterval(st.offerTimer);
             st.offerTimer = undefined;
         }
+        if (st?.paceTimer) {
+            clearTimeout(st.paceTimer);
+            st.paceTimer = undefined;
+        }
         this.#map(this.#sending, friendId).delete(fileNumber);
     }
     #endRecv(friendId, fileNumber) {

package/package.json

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