@decentnetwork/peer 0.1.74 → 0.1.76

package/dist/compat/filetransfer.js

@@ -39,7 +39,16 @@ export const MAX_FILE_DATA_SIZE = 1367;
 // overhead handles bursty ~15% loss with margin; the retransmit path remains a
 // backstop for blocks that exceed FEC capacity.
 const FEC_K = 16;
-const FEC_M = 6;
+// Parity is ADAPTIVE per block: the sender sizes it to the loss rate the
+// receiver reports (piggybacked on each ack). A fixed M=6 tolerated only
+// ~27% loss, so a 40%-loss path (measured on lili) blew past FEC capacity and
+// fell back to go-back-N retransmit — ~1% efficient. Now the sender sends just
+// enough parity that blocks recover LOCALLY at the current loss, so the
+// expensive retransmit path almost never fires.
+const FEC_M_MIN = 4; // parity the instant loss is first detected (before the report warms up)
+const FEC_M_MAX = 16; // ceiling on parity per K=16 block (covers ~50% loss)
+const FEC_MARGIN = 2; // extra shards over the estimate — absorbs burst variance
+const FEC_SAFETY = 1.15; // over-provision the loss estimate by 15%
 // Adaptive: only spend parity bandwidth while the path is actually losing
 // packets (a dup-ack was seen within this window). A clean path sends zero
 // parity → no overhead; a lossy path (lili) gets full protection.
@@ -96,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
@@ -227,7 +236,7 @@ export class FileTransferManager {
             fileNumber, fileId, name: opts.name, data, size: data.length,
             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,
+            cwnd: CWND_INIT_CHUNKS, stalls: 0, parityHighBlock: -1, lastLossMs: 0, lossEwma: 0,
             minRttMs: Infinity, minSrttMs: Infinity, srttMs: 0, probeOffset: -1, probeSentMs: 0,
         };
         this.#map(this.#sending, friendId).set(fileNumber, st);
@@ -317,7 +326,7 @@ export class FileTransferManager {
         } // re-offer (our accept/ack lost) → re-ack
         const st = {
             fileNumber: r.fileNumber, fileId: r.fileId, name: r.filename, size,
-            buf: new Uint8Array(size), got: new Uint8Array(chunkCount(size)),
+            buf: new Uint8Array(size), got: new Uint8Array(chunkCount(size)), netGot: new Uint8Array(chunkCount(size)), lossPctEwma: 0,
             contiguous: 0, maxByte: 0, persisted: 0, partPath: this.#partPath(r.fileId), fecParity: new Map(), done: false, ackDirty: false,
         };
         // 断点续传: if we persisted a contiguous prefix of this exact file (matched
@@ -334,8 +343,10 @@ export class FileTransferManager {
                 if (usable > 0) {
                     const partial = readFileSync(st.partPath);
                     st.buf.set(partial.subarray(0, usable), 0);
-                    for (let i = 0; i < chunks; i++)
+                    for (let i = 0; i < chunks; i++) {
                         st.got[i] = 1;
+                        st.netGot[i] = 1;
+                    }
                     st.contiguous = usable;
                     st.maxByte = usable;
                     st.persisted = usable;
@@ -416,6 +427,7 @@ export class FileTransferManager {
             return; // not a chunk boundary
         if (offset + data.length > st.maxByte)
             st.maxByte = offset + data.length;
+        st.netGot[idx] = 1; // genuine network arrival (even if a dup) → raw-loss denominator
         if (!st.got[idx]) {
             st.buf.set(data, offset);
             st.got[idx] = 1;
@@ -455,11 +467,11 @@ export class FileTransferManager {
         const st = this.#map(this.#receiving, friendId).get(f.fileNumber);
         if (!st || st.done)
             return;
-        if (f.parity.length !== MAX_FILE_DATA_SIZE || f.parityIndex >= FEC_M)
+        if (f.parity.length !== MAX_FILE_DATA_SIZE || f.parityIndex >= FEC_M_MAX)
             return;
         let arr = st.fecParity.get(f.blockIndex);
         if (!arr) {
-            arr = new Array(FEC_M).fill(undefined);
+            arr = new Array(FEC_M_MAX).fill(undefined);
             st.fecParity.set(f.blockIndex, arr);
         }
         if (!arr[f.parityIndex])
@@ -509,9 +521,9 @@ export class FileTransferManager {
             else
                 shards.push(null);
         }
-        for (let pi = 0; pi < FEC_M; pi++)
+        for (let pi = 0; pi < FEC_M_MAX; pi++)
             shards.push(parityArr?.[pi] ?? null);
-        const recovered = rsDecode(shards, k, FEC_M, MAX_FILE_DATA_SIZE);
+        const recovered = rsDecode(shards, k, FEC_M_MAX, MAX_FILE_DATA_SIZE);
         if (!recovered)
             return;
         for (const i of missing) {
@@ -586,14 +598,37 @@ export class FileTransferManager {
                 this.#sendAck(friendId, st);
         }, ACK_THROTTLE_MS);
     }
+    // Raw network loss (0..100) behind the frontier: the fraction of chunk slots
+    // between the contiguous prefix and the highest byte seen that have NOT arrived
+    // over the network (netGot=0). FEC-recovered holes still count as losses here
+    // (netGot stays 0), so the estimate doesn't collapse to zero the moment FEC
+    // patches a block — which would starve parity and reopen the hole. Self-
+    // correcting: under-provisioned parity leaves holes → the window fills with
+    // gaps → the reported loss rises → the sender adds parity.
+    #measureLoss(st) {
+        const lo = Math.floor(st.contiguous / MAX_FILE_DATA_SIZE);
+        const hi = Math.min(st.got.length, Math.ceil(st.maxByte / MAX_FILE_DATA_SIZE));
+        let span = 0, holes = 0;
+        for (let i = lo; i < hi && span < 4096; i++) {
+            span++;
+            if (!st.netGot[i])
+                holes++;
+        }
+        const inst = span > 0 ? holes / span : 0;
+        st.lossPctEwma = st.lossPctEwma === 0 ? inst : 0.7 * st.lossPctEwma + 0.3 * inst;
+        return Math.max(0, Math.min(100, Math.round(st.lossPctEwma * 100)));
+    }
     #sendAck(friendId, st) {
         st.ackDirty = false;
         // send_receive=1: the ACK refers to a file the PEER is SENDING (it lives in
-        // the peer's #sending table). Carries [contiguous][maxByte] so the sender
-        // sees the gap (maxByte − contiguous) = loss/reorder, for congestion control.
-        const body = new Uint8Array(8);
+        // the peer's #sending table). Carries [contiguous][maxByte][lossPct] so the
+        // sender sees the gap (for congestion control) and the raw loss rate (to size
+        // adaptive FEC parity). The 9th byte is additive — a pre-0.1.75 sender that
+        // reads only 8 bytes just ignores it.
+        const body = new Uint8Array(9);
         body.set(u32be(st.contiguous), 0);
         body.set(u32be(st.maxByte), 4);
+        body[8] = this.#measureLoss(st);
         void this.send(friendId, PACKET_ID_FILE_CONTROL, encodeFileControl(1, st.fileNumber, FILECONTROL.ACK, body)).catch(() => undefined);
     }
     // ── sender ────────────────────────────────────────────────────────
@@ -602,6 +637,12 @@ export class FileTransferManager {
             return;
         const ackedOffset = readU32be(data, 0);
         const maxRecv = data.length >= 8 ? readU32be(data, 4) : ackedOffset;
+        // Receiver-reported raw loss (0..100) → drives adaptive FEC parity. Lightly
+        // re-smoothed here so a single ack can't swing the parity budget.
+        if (data.length >= 9) {
+            const reported = data[8] / 100;
+            st.lossEwma = 0.6 * st.lossEwma + 0.4 * reported;
+        }
         if (ackedOffset > st.acked) {
             // Progress. The path is delivering → additively re-open the window (up to
             // the cap) and clear the stall streak (patience shrinks back to the base).
@@ -633,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) {
@@ -654,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)
@@ -773,7 +815,14 @@ export class FileTransferManager {
                 st.parityHighBlock = b;
                 continue;
             } // clean path → skip parity
-            // Build the k data shards (zero-padded to a full chunk) and encode M parity.
+            // Size parity to the reported loss p: to land k of (k+m) shards through a
+            // path dropping fraction p, need k+m ≥ k/(1−p) → m ≥ k·p/(1−p). Over-
+            // provision (SAFETY) and add a fixed MARGIN for burst variance; a fresh
+            // dup-ack (report not yet in) still gets FEC_M_MIN so we react immediately.
+            const p = Math.min(0.6, st.lossEwma); // cap so the divisor can't explode
+            const mNeed = Math.ceil((kActual * p / (1 - p)) * FEC_SAFETY) + FEC_MARGIN;
+            const mSend = Math.max(FEC_M_MIN, Math.min(FEC_M_MAX, mNeed));
+            // Build the k data shards (zero-padded to a full chunk) and encode mSend parity.
             const shards = [];
             for (let i = 0; i < kActual; i++) {
                 const off = (b * FEC_K + i) * MAX_FILE_DATA_SIZE;
@@ -786,7 +835,7 @@ export class FileTransferManager {
                     shards.push(padded);
                 }
             }
-            const parity = rsEncode(shards, FEC_M);
+            const parity = rsEncode(shards, mSend);
             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);
             }

package/package.json

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