@decentnetwork/peer 0.1.97 → 0.1.98

package/dist/compat/filetransfer.js

@@ -86,48 +86,43 @@ export const FILEKIND = { DATA: 0, AVATAR: 1 };
 const WINDOW_CHUNKS = 768; // ~1 MB — the window CAP (fills a 200ms-RTT path at ~5 MB/s)
 const CWND_INIT_CHUNKS = 16; // ~22 KB start — small so the opening burst can't bloat a thin path
 const CWND_MIN_CHUNKS = 8; // ~11 KB floor — keeps a slow/flaky path's buffer shallow
-// Congestion control (TCP Vegas — DELAY-based). Loss/AIMD control fails on a
-// slow peer with a deep buffer (a user's laptop): ~1 MB in flight piles up as
-// 12-23 s of queue latency with NO loss, so it never backs off, and the stalls
-// trigger go-back-N resends that balloon the queue further. Vegas instead reads
-// how many chunks are QUEUED from the RTT inflation — cwnd × (1 − minRtt/RTT) —
-// and steers the window to keep that between ALPHA and BETA. When the queue is
-// below ALPHA there's spare capacity → grow (no self-limiting, unlike a
-// rate-based cap); above BETA the queue is too deep → shrink. It converges to
-// "pipe full + a couple chunks queued" on ANY path: a fast link gets a big
-// window, a thin flaky one a small window and a shallow queue, automatically.
-// Target the ABSOLUTE queue delay (rtt − minRtt), not a packet count: bound the
-// latency the transfer ADDS to the path to ≈ MAX_QUEUE_MS on ANY path. A fast
-// 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.
-// 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; 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_SAMPLE_MS = 200; // aggregate ACKs so one scheduler-jittered packet is not a "round"
 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)
+// A LAN receiver can coalesce a backlog of ACKs after its event loop wakes. The
+// resulting delivery sample is ACK rate, not link capacity: in practice a
+// 4 MB/s Windows path briefly reported 23 MB/s, startup chased that sample,
+// overflowed the receiver, and then collapsed to the minimum window. Bound how
+// quickly a validated-LAN estimate and startup pace may grow. Real capacity is
+// still discovered quickly (25% every 200 ms), without one ACK burst taking
+// over the controller.
+const LAN_SAMPLE_MAX_GAIN = 1.25;
+const LAN_STARTUP_MAX_GAIN = 1.15;
+const LAN_STARTUP_DELIVERY_GAIN = 1.5; // never probe above 1.5x recently delivered goodput
+const LAN_STARTUP_QUEUE_MS = 500; // unmistakable raw queue spike; smaller app-level RTT outliers are normal on Windows
+const LAN_STARTUP_KEEPUP = 0.70; // delivered goodput below 70% of pace means the receiver is no longer keeping up
+const LAN_STARTUP_SLOW_ROUNDS = 5; // require sustained saturation across Windows scheduler/ACK jitter
+// FILE ACKs are coalesced and handled by the remote JS event loop. On Windows
+// the effective ACK clock is commonly 20–120 ms even when an occasional probe
+// reports a 7 ms network RTT. Sizing cwnd from that lucky minimum made a
+// 1.7 MB/s pacer use an 18-chunk (~24 KB) window, which itself capped goodput
+// and falsely ended startup. Pacing remains the primary throttle, so this floor
+// only prevents the safety window from starving a validated LAN flow.
+const LAN_BDP_RTT_FLOOR_MS = 50;
 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)
 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 FINAL_ACK_GRACE_MS = 10000; // retry final cumulative ACK across loss/reorder/short session handover
 const SEND_GIVEUP_MS = 60000; // abandon a send after this long with no ack progress (peer gone)
 const PERSIST_INTERVAL_BYTES = 1024 * 1024; // flush the resume file at most once per this much progress
 function u32be(n) {
@@ -253,9 +248,9 @@ 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, parityHighBlock: -1, lastLossMs: 0, lossEwma: 0,
-            minRttMs: Infinity, minSrttMs: Infinity, srttMs: 0, probeOffset: -1, probeSentMs: 0,
+            minRttMs: 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,
+            btlBwBps: 0, bwSamples: [], fullBwRounds: 0, bbrPhase: 0, roundCount: 0,
             rateMarkMs: nowMs(), rateMarkAcked: 0, lowRttCount: 0, lowRttMinMs: Infinity, lastCcLogMs: 0,
             lanPath: this.isLanPath(friendId),
         };
@@ -599,7 +594,25 @@ export class FileTransferManager {
             clearInterval(st.reackTimer);
             st.reackTimer = undefined;
         }
-        this.#sendAck(friendId, st); // final ack so the sender completes
+        this.#sendAck(friendId, st); // first final ack so the sender completes
+        // A final ACK used to be the only ACK we sent exactly once. If it landed
+        // during UDP loss, packet reordering, or a short crypto-session handover,
+        // the receiver had the complete byte-exact file but the sender/UI remained
+        // stuck at its previous cumulative offset until timeout. Keep retrying the
+        // tiny cumulative ACK while the lightweight done-marker exists. This is
+        // idempotent, and the sender drops its state after the first one it receives.
+        st.reackTimer = setInterval(() => {
+            const cur = this.#map(this.#receiving, friendId).get(st.fileNumber);
+            if (cur !== st) {
+                if (st.reackTimer)
+                    clearInterval(st.reackTimer);
+                st.reackTimer = undefined;
+                return;
+            }
+            this.#sendAck(friendId, st);
+        }, REACK_MS);
+        if (typeof st.reackTimer.unref === "function")
+            st.reackTimer.unref();
         const data = st.buf;
         // Transfer complete → the resume file is no longer needed.
         if (st.partPath) {
@@ -616,9 +629,14 @@ export class FileTransferManager {
         st.got = new Uint8Array(0);
         const t = setTimeout(() => {
             const cur = this.#map(this.#receiving, friendId).get(st.fileNumber);
-            if (cur === st)
+            if (cur === st) {
+                if (st.reackTimer) {
+                    clearInterval(st.reackTimer);
+                    st.reackTimer = undefined;
+                }
                 this.#map(this.#receiving, friendId).delete(st.fileNumber);
-        }, 10000);
+            }
+        }, FINAL_ACK_GRACE_MS);
         if (typeof t.unref === "function")
             t.unref();
     }
@@ -745,21 +763,29 @@ export class FileTransferManager {
                         const roundRate = ((st.acked - st.rateMarkAcked) * 1000) / sampleMs;
                         st.rateMarkMs = nowT;
                         st.rateMarkAcked = st.acked;
-                        if (roundRate > 0) {
-                            st.bwSamples.push(roundRate);
+                        const lanNow = this.isLanPath(friendId);
+                        // On a paced LAN flow, sustainable delivery cannot suddenly be
+                        // many times faster than the bytes we are putting on the wire.
+                        // Such a sample is delayed/coalesced ACKs draining, not new
+                        // capacity. Relay samples keep their existing conservative cap.
+                        const measuredRate = lanNow
+                            ? Math.min(roundRate, Math.max(PACE_INIT_BPS, st.paceRateBps * LAN_SAMPLE_MAX_GAIN))
+                            : roundRate;
+                        if (measuredRate > 0) {
+                            st.bwSamples.push(measuredRate);
                             if (st.bwSamples.length > PACE_BW_WINDOW)
                                 st.bwSamples.shift();
                             st.btlBwBps = Math.max(...st.bwSamples);
                         }
-                        // 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));
-                        const lanNow = this.isLanPath(friendId);
+                        // On a lossy public/relay path, wire carries goodput + FEC parity +
+                        // retransmits, so compensate by 1/(1-loss). On a physical LAN,
+                        // loss is normally self-induced receiver/socket overflow; raising
+                        // pace in response creates a positive feedback loop (up to 2x).
+                        const lossMult = lanNow ? 1 : 1 / (1 - Math.min(0.5, st.lossEwma));
                         if (lanNow && !st.lanPath) {
                             // A transfer can begin on relay and then promote to a validated
                             // physical-LAN endpoint. Restart STARTUP from the measured rate.
                             st.bbrPhase = 0;
-                            st.fullBwBps = 0;
                             st.fullBwRounds = 0;
                         }
                         st.lanPath = lanNow;
@@ -778,22 +804,37 @@ export class FileTransferManager {
                             // 1 ms → 2 ms scheduler jitter looked like a 100% queue and pinned
                             // every transfer near PACE_INIT_BPS. The absolute, smoothed queue
                             // ceiling still protects a deep relay from runaway buffering.
-                            if (st.fullBwBps === 0 || st.btlBwBps >= st.fullBwBps * PACE_FULLBW_GROWTH) {
-                                st.fullBwBps = st.btlBwBps;
+                            // A paced flow initially delivers slightly less than its wire
+                            // pace, so max-filter plateau detection can exit at 120 KB/s
+                            // before it has actually probed the LAN. Instead, keep ramping
+                            // while the receiver sustains most of the offered rate. Stop
+                            // only after several under-delivery samples or a clear queue
+                            // spike. This is a direct closed loop: no guessed LAN speed cap.
+                            if (measuredRate >= st.paceRateBps * LAN_STARTUP_KEEPUP) {
                                 st.fullBwRounds = 0;
                             }
                             else {
                                 st.fullBwRounds++;
                             }
-                            const rawQueue = st.minRttMs !== Infinity ? st.srttMs - st.minRttMs : 0;
-                            if (st.fullBwRounds >= PACE_FULLBW_ROUNDS || rawQueue > MAX_QUEUE_MS) {
+                            const rawQueue = st.minRttMs !== Infinity ? acceptedRtt - st.minRttMs : 0;
+                            const startupOvershot = rawQueue > LAN_STARTUP_QUEUE_MS;
+                            const startupUnderDelivering = st.fullBwRounds >= LAN_STARTUP_SLOW_ROUNDS;
+                            if (startupUnderDelivering || startupOvershot) {
                                 st.bbrPhase = 2;
                             }
-                            if (st.bbrPhase === 0) {
-                                st.paceRateBps = Math.max(st.paceRateBps * 1.4, st.btlBwBps * PACE_STARTUP_GAIN * lossMult);
+                            if (startupUnderDelivering || startupOvershot) {
+                                // Forget ACK-compressed highs immediately and drain at 80% of
+                                // the pre-spike pace. Keeping the max-filtered high here made
+                                // the sender continue flooding for ~2 s and collapse cwnd.
+                                st.bwSamples = measuredRate > 0 ? [measuredRate] : [];
+                                st.btlBwBps = measuredRate > 0 ? measuredRate : PACE_INIT_BPS;
+                                st.paceRateBps = Math.max(PACE_INIT_BPS, Math.min(st.paceRateBps * 0.8, st.btlBwBps * 1.1));
+                            }
+                            else if (st.bbrPhase === 0) {
+                                st.paceRateBps = Math.max(st.paceRateBps, Math.min(st.paceRateBps * LAN_STARTUP_MAX_GAIN, Math.max(PACE_INIT_BPS, measuredRate * LAN_STARTUP_DELIVERY_GAIN)));
                             }
                             else {
-                                st.paceRateBps = Math.max(PACE_INIT_BPS * 0.5, st.btlBwBps * lossMult);
+                                st.paceRateBps = Math.max(PACE_INIT_BPS * 0.5, Math.min(st.paceRateBps, st.btlBwBps * lossMult));
                             }
                         }
                         else {
@@ -806,9 +847,13 @@ export class FileTransferManager {
                             st.paceRateBps = Math.min(st.paceRateBps, (WINDOW_CHUNKS * MAX_FILE_DATA_SIZE) / (st.minRttMs / 1000));
                         }
                         // cwnd = safety ceiling sized to 2× pace BDP. 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)));
+                        const bdpRttMs = st.minRttMs !== Infinity && st.minRttMs > 0
+                            ? (lanNow ? Math.max(st.minRttMs, LAN_BDP_RTT_FLOOR_MS) : st.minRttMs)
+                            : 0;
+                        const paceBdp = bdpRttMs > 0
+                            ? (st.paceRateBps * (bdpRttMs / 1000)) / MAX_FILE_DATA_SIZE : WINDOW_CHUNKS;
+                        const cwndFloor = lanNow ? CWND_INIT_CHUNKS : CWND_MIN_CHUNKS;
+                        st.cwnd = Math.max(cwndFloor, Math.min(WINDOW_CHUNKS, Math.ceil(paceBdp * 2)));
                     }
                 }
                 if (process.env.DECENT_DEBUG && nowT - st.lastCcLogMs >= 1000) {
@@ -816,7 +861,9 @@ export class FileTransferManager {
                     console.error(`[file-cc] friend=${friendId.slice(0, 8)} ack=${st.acked}/${st.size}` +
                         ` rtt=${rtt}ms srtt=${st.srttMs.toFixed(1)}ms low=${st.lowRttCount}` +
                         ` accepted=${(!lowSample || promoteLowPath) ? 1 : 0}` +
-                        ` pace=${Math.round(st.paceRateBps)}Bps cwnd=${st.cwnd} rounds=${st.roundCount}`);
+                        ` pace=${Math.round(st.paceRateBps)}Bps bw=${Math.round(st.btlBwBps)}Bps` +
+                        ` cwnd=${st.cwnd} phase=${st.bbrPhase} slow=${st.fullBwRounds}` +
+                        ` loss=${(st.lossEwma * 100).toFixed(1)}% rounds=${st.roundCount}`);
                 }
             }
             if (st.acked - st.lastProgressAcked >= 256 * 1024 || st.acked >= st.size) {

package/package.json

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