@decentnetwork/peer 0.1.74 → 0.1.75

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.
@@ -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).
@@ -773,7 +814,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 +834,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.75",
   "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",