@decentnetwork/peer 0.1.73 → 0.1.75

package/dist/compat/filetransfer.d.ts

@@ -1,6 +1,7 @@
 export declare const PACKET_ID_FILE_SENDREQUEST = 80;
 export declare const PACKET_ID_FILE_CONTROL = 81;
 export declare const PACKET_ID_FILE_DATA = 82;
+export declare const PACKET_ID_FILE_FEC = 83;
 export declare const FILE_ID_LENGTH = 32;
 export declare const MAX_FILENAME_LENGTH = 255;
 export declare const MAX_CONCURRENT_FILE_PIPES = 256;

package/dist/compat/filetransfer.js

@@ -23,14 +23,53 @@ import { concatBytes, randomBytes } from "../utils/bytes.js";
 import { createHash } from "node:crypto";
 import { existsSync, statSync, readFileSync, appendFileSync, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { rsEncode, rsDecode } from "./reed-solomon.js";
 export const PACKET_ID_FILE_SENDREQUEST = 80;
 export const PACKET_ID_FILE_CONTROL = 81;
 export const PACKET_ID_FILE_DATA = 82;
+export const PACKET_ID_FILE_FEC = 83; // FEC parity shard (forward error correction)
 export const FILE_ID_LENGTH = 32;
 export const MAX_FILENAME_LENGTH = 255;
 export const MAX_CONCURRENT_FILE_PIPES = 256;
 // MAX_CRYPTO_DATA_SIZE (1373) − 1 (kind) − 1 (filenum) − 4 (offset).
 export const MAX_FILE_DATA_SIZE = 1367;
+// FEC: a block is K data chunks; the sender adds M parity chunks so the receiver
+// can reconstruct up to M lost chunks per block locally (no retransmit) — the
+// key to bulk transfer over a lossy GFW path (measured 15-50% loss). ~37%
+// overhead handles bursty ~15% loss with margin; the retransmit path remains a
+// backstop for blocks that exceed FEC capacity.
+const FEC_K = 16;
+// 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.
+const FEC_ACTIVE_WINDOW_MS = 4000;
+// FEC packet payload: [filenum(1)][blockIndex u32][parityIndex(1)][parity bytes].
+// k (data chunks in the block) and m are NOT sent — both ends share FEC_K/FEC_M
+// constants and derive the last block's k from the file size — so the 6-byte
+// header + a full 1367-byte parity shard fits the 1373-byte crypto limit exactly
+// and the data chunk size (MAX_FILE_DATA_SIZE) stays unchanged (0.1.73-compatible).
+function encodeFec(fileNumber, blockIndex, parityIndex, parity) {
+    return concatBytes([Uint8Array.of(fileNumber & 0xff), u32be(blockIndex), Uint8Array.of(parityIndex & 0xff), parity]);
+}
+function parseFec(p) {
+    if (p.length < 6)
+        return undefined;
+    return { fileNumber: p[0], blockIndex: readU32be(p, 1), parityIndex: p[5], parity: p.slice(6) };
+}
+// How many data chunks are in block b of a file with `totalChunks` chunks.
+function fecBlockK(blockIndex, totalChunks) {
+    return Math.min(FEC_K, totalChunks - blockIndex * FEC_K);
+}
 export const FILECONTROL = { ACCEPT: 0, PAUSE: 1, KILL: 2, SEEK: 3, ACK: 4 };
 export const FILEKIND = { DATA: 0, AVATAR: 1 };
 // Reliability tuning. We RAMP an in-flight window (AIMD-lite) rather than pin it:
@@ -197,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,
+            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);
@@ -269,6 +308,10 @@ export class FileTransferManager {
             this.#onData(friendId, payload);
             return true;
         }
+        if (packetId === PACKET_ID_FILE_FEC) {
+            this.#onFec(friendId, payload);
+            return true;
+        }
         return false;
     }
     #onSendRequest(friendId, payload) {
@@ -283,8 +326,8 @@ 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)),
-            contiguous: 0, maxByte: 0, persisted: 0, partPath: this.#partPath(r.fileId), done: false, ackDirty: false,
+            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
         // by content-hash fileId) before a drop/restart, load it and resume — our
@@ -300,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;
@@ -382,23 +427,118 @@ 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;
-            // Advance the contiguous prefix.
-            let i = Math.floor(st.contiguous / MAX_FILE_DATA_SIZE);
-            while (i < st.got.length && st.got[i])
-                i++;
-            st.contiguous = Math.min(i * MAX_FILE_DATA_SIZE, st.size);
+            this.#advanceContiguous(friendId, st);
+        }
+        // This chunk may complete a FEC block enough to reconstruct its other holes.
+        this.#tryRecoverBlock(friendId, st, Math.floor(idx / FEC_K));
+        this.#finishOrAck(friendId, st);
+    }
+    // Advance the contiguous prefix over received/recovered chunks, emitting
+    // progress and flushing the resume file. Does not finish or ack.
+    #advanceContiguous(friendId, st) {
+        let i = Math.floor(st.contiguous / MAX_FILE_DATA_SIZE);
+        while (i < st.got.length && st.got[i])
+            i++;
+        const nc = Math.min(i * MAX_FILE_DATA_SIZE, st.size);
+        if (nc > st.contiguous) {
+            st.contiguous = nc;
             this.emit("file-progress", { friendId, fileId: hex(st.fileId), received: st.contiguous, total: st.size });
             this.#persistPartial(st);
         }
+    }
+    #finishOrAck(friendId, st) {
+        if (st.done)
+            return;
         if (st.contiguous >= st.size) {
             this.#finishRecv(friendId, st);
             return;
         }
         this.#scheduleAck(friendId, st);
     }
+    // A parity shard arrived → store it and try to repair its block.
+    #onFec(friendId, payload) {
+        const f = parseFec(payload);
+        if (!f)
+            return;
+        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_MAX)
+            return;
+        let arr = st.fecParity.get(f.blockIndex);
+        if (!arr) {
+            arr = new Array(FEC_M_MAX).fill(undefined);
+            st.fecParity.set(f.blockIndex, arr);
+        }
+        if (!arr[f.parityIndex])
+            arr[f.parityIndex] = f.parity;
+        this.#tryRecoverBlock(friendId, st, f.blockIndex);
+        this.#finishOrAck(friendId, st);
+    }
+    // If FEC block `b` has at least K of its K+M shards (data + parity), rebuild
+    // the missing data chunks LOCALLY — no retransmit, so the sender's window
+    // never stalls waiting for the lost chunk.
+    #tryRecoverBlock(friendId, st, b) {
+        if (st.done || b < 0)
+            return;
+        const totalChunks = chunkCount(st.size);
+        if (b * FEC_K >= totalChunks)
+            return;
+        const k = fecBlockK(b, totalChunks);
+        const base = b * FEC_K;
+        const missing = [];
+        for (let i = 0; i < k; i++)
+            if (!st.got[base + i])
+                missing.push(i);
+        if (missing.length === 0) {
+            st.fecParity.delete(b);
+            return;
+        } // block already whole
+        const parityArr = st.fecParity.get(b);
+        const parityPresent = parityArr ? parityArr.reduce((n, s) => n + (s ? 1 : 0), 0) : 0;
+        if ((k - missing.length) + parityPresent < k)
+            return; // not enough shards yet
+        if (missing.length > parityPresent)
+            return; // can't cover this many holes
+        // Assemble the K+M shard array (present data padded to a full chunk).
+        const shards = [];
+        for (let i = 0; i < k; i++) {
+            if (st.got[base + i]) {
+                const off = (base + i) * MAX_FILE_DATA_SIZE;
+                const chunk = st.buf.subarray(off, Math.min(off + MAX_FILE_DATA_SIZE, st.size));
+                if (chunk.length === MAX_FILE_DATA_SIZE)
+                    shards.push(chunk);
+                else {
+                    const padded = new Uint8Array(MAX_FILE_DATA_SIZE);
+                    padded.set(chunk);
+                    shards.push(padded);
+                }
+            }
+            else
+                shards.push(null);
+        }
+        for (let pi = 0; pi < FEC_M_MAX; pi++)
+            shards.push(parityArr?.[pi] ?? null);
+        const recovered = rsDecode(shards, k, FEC_M_MAX, MAX_FILE_DATA_SIZE);
+        if (!recovered)
+            return;
+        for (const i of missing) {
+            const off = (base + i) * MAX_FILE_DATA_SIZE;
+            const realLen = Math.min(MAX_FILE_DATA_SIZE, st.size - off);
+            if (realLen <= 0)
+                continue;
+            st.buf.set(recovered[i].subarray(0, realLen), off);
+            st.got[base + i] = 1;
+            if (off + realLen > st.maxByte)
+                st.maxByte = off + realLen;
+        }
+        st.fecParity.delete(b); // recovered — free the parity
+        this.#advanceContiguous(friendId, st);
+    }
     // Flush the newly-contiguous bytes to the resume file, throttled so we do at
     // most one append per PERSIST_INTERVAL_BYTES of progress (not per chunk).
     #persistPartial(st, force = false) {
@@ -458,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 ────────────────────────────────────────────────────────
@@ -474,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).
@@ -532,6 +701,7 @@ export class FileTransferManager {
             // ~1 RTT so dup-ack bursts for one loss don't storm). No window backoff:
             // file-path loss is treated as random, not congestion.
             st.lastResendMs = nowMs();
+            st.lastLossMs = nowMs(); // the path is lossy → turn adaptive FEC on
             if (st.nextSend > st.acked)
                 st.nextSend = st.acked;
         }
@@ -616,11 +786,61 @@ export class FileTransferManager {
                     st.probeSentMs = nowMs();
                 }
             }
+            // After sending data, emit FEC parity for any block whose data is now all
+            // sent, so the receiver can repair losses locally instead of stalling.
+            this.#emitParity(friendId, st);
         }
         finally {
             st.pumping = false;
         }
     }
+    // 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.
+    #emitParity(friendId, st) {
+        const totalChunks = chunkCount(st.size);
+        const totalBlocks = Math.ceil(totalChunks / FEC_K);
+        // Adaptive: only protect blocks while the path is actually lossy. On a clean
+        // path this sends zero parity (no overhead); the counter still advances so
+        // we never revisit a block.
+        const fecOn = nowMs() - st.lastLossMs < FEC_ACTIVE_WINDOW_MS;
+        while (st.parityHighBlock + 1 < totalBlocks) {
+            const b = st.parityHighBlock + 1;
+            const kActual = fecBlockK(b, totalChunks);
+            const blockEndByte = Math.min((b * FEC_K + kActual) * MAX_FILE_DATA_SIZE, st.size);
+            if (st.nextSend < blockEndByte)
+                break; // block's data not all sent yet
+            if (!fecOn) {
+                st.parityHighBlock = b;
+                continue;
+            } // clean path → skip 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;
+                const chunk = st.data.subarray(off, Math.min(off + MAX_FILE_DATA_SIZE, st.size));
+                if (chunk.length === MAX_FILE_DATA_SIZE)
+                    shards.push(chunk);
+                else {
+                    const padded = new Uint8Array(MAX_FILE_DATA_SIZE);
+                    padded.set(chunk);
+                    shards.push(padded);
+                }
+            }
+            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);
+            }
+            st.parityHighBlock = b;
+        }
+    }
     #completeSend(friendId, st) {
         const durationMs = nowMs() - st.startMs;
         const mbps = durationMs > 0 ? st.size / 1024 / 1024 / (durationMs / 1000) : 0;

package/dist/compat/reed-solomon.d.ts

@@ -0,0 +1,9 @@
+/** Encode: given K equal-length data shards, return M parity shards. */
+export declare function rsEncode(data: Uint8Array[], m: number): Uint8Array[];
+/**
+ * Recover the K data shards from any K present shards (data and/or parity).
+ * `shards` is the full K+M array with missing entries as null; `len` is the
+ * shard length. Returns the K reconstructed data shards, or null if fewer than
+ * K shards are present (unrecoverable).
+ */
+export declare function rsDecode(shards: Array<Uint8Array | null>, k: number, m: number, len: number): Uint8Array[] | null;

package/dist/compat/reed-solomon.js

@@ -0,0 +1,198 @@
+//
+// Reed-Solomon ERASURE coding over GF(256), for FEC on lossy paths.
+//
+// The file transfer runs over a best-effort channel that, on a GFW-grade path,
+// drops 15-50% of packets. Retransmit-based recovery collapses throughput
+// (measured: ~1% of the link's real 1.3 MB/s). FEC instead sends a few PARITY
+// shards alongside each block of K data shards; the receiver reconstructs any
+// missing data shards LOCALLY as long as it got at least K of the K+M shards —
+// no round-trip, so the send window never stalls on loss.
+//
+// This is *erasure* coding, not error correction: the receiver knows exactly
+// which shards are missing (each chunk carries its offset), so recovery is just
+// solving a linear system — no syndromes or error locators. We use a systematic
+// Cauchy-Reed-Solomon matrix: the first K rows are the identity (data shards
+// pass through untouched), the last M rows are a Cauchy matrix (the parity).
+//
+// All shards in a block must be the same length; the caller zero-pads.
+//
+// ── GF(256) with primitive polynomial 0x11d (x^8+x^4+x^3+x^2+1) ──────────────
+const EXP = new Uint8Array(512);
+const LOG = new Uint8Array(256);
+(function initTables() {
+    let x = 1;
+    for (let i = 0; i < 255; i++) {
+        EXP[i] = x;
+        LOG[x] = i;
+        x <<= 1;
+        if (x & 0x100)
+            x ^= 0x11d;
+    }
+    for (let i = 255; i < 512; i++)
+        EXP[i] = EXP[i - 255];
+})();
+function gmul(a, b) {
+    if (a === 0 || b === 0)
+        return 0;
+    return EXP[LOG[a] + LOG[b]];
+}
+function gdiv(a, b) {
+    if (b === 0)
+        throw new Error("gf div by zero");
+    if (a === 0)
+        return 0;
+    return EXP[LOG[a] + 255 - LOG[b]];
+}
+function ginv(a) {
+    if (a === 0)
+        throw new Error("gf inv of zero");
+    return EXP[255 - LOG[a]];
+}
+// Build the M×K Cauchy parity matrix. Cauchy element = 1 / (x_i XOR y_j) with
+// disjoint x (parity index space) and y (data index space). Guaranteed
+// invertible submatrices → any K of K+M shards recover the data.
+function cauchyParityMatrix(k, m) {
+    const rows = [];
+    for (let i = 0; i < m; i++) {
+        const row = new Uint8Array(k);
+        const xi = k + i; // parity nodes live at k..k+m-1
+        for (let j = 0; j < k; j++) {
+            row[j] = ginv(xi ^ j); // xi ^ j is never 0 since xi >= k > j
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+/** Encode: given K equal-length data shards, return M parity shards. */
+export function rsEncode(data, m) {
+    const k = data.length;
+    if (k === 0 || m === 0)
+        return [];
+    const len = data[0].length;
+    const parity = cauchyParityMatrix(k, m);
+    const out = [];
+    for (let i = 0; i < m; i++) {
+        const shard = new Uint8Array(len);
+        const row = parity[i];
+        for (let j = 0; j < k; j++) {
+            const coeff = row[j];
+            if (coeff === 0)
+                continue;
+            const src = data[j];
+            const lc = LOG[coeff];
+            for (let b = 0; b < len; b++) {
+                const s = src[b];
+                if (s !== 0)
+                    shard[b] ^= EXP[lc + LOG[s]];
+            }
+        }
+        out.push(shard);
+    }
+    return out;
+}
+// Invert a K×K matrix in GF(256) via Gauss-Jordan. Returns null if singular
+// (shouldn't happen for a Cauchy-derived submatrix, but guard anyway).
+function invert(matrix, k) {
+    // Augment [M | I].
+    const a = matrix.map((r) => Uint8Array.from(r));
+    const inv = Array.from({ length: k }, (_, i) => {
+        const r = new Uint8Array(k);
+        r[i] = 1;
+        return r;
+    });
+    for (let col = 0; col < k; col++) {
+        // Find a pivot.
+        let piv = col;
+        while (piv < k && a[piv][col] === 0)
+            piv++;
+        if (piv === k)
+            return null;
+        if (piv !== col) {
+            [a[piv], a[col]] = [a[col], a[piv]];
+            [inv[piv], inv[col]] = [inv[col], inv[piv]];
+        }
+        // Normalize the pivot row.
+        const pv = a[col][col];
+        const pvInv = ginv(pv);
+        for (let j = 0; j < k; j++) {
+            a[col][j] = gmul(a[col][j], pvInv);
+            inv[col][j] = gmul(inv[col][j], pvInv);
+        }
+        // Eliminate the column from all other rows.
+        for (let row = 0; row < k; row++) {
+            if (row === col)
+                continue;
+            const f = a[row][col];
+            if (f === 0)
+                continue;
+            const lf = LOG[f];
+            for (let j = 0; j < k; j++) {
+                if (a[col][j] !== 0)
+                    a[row][j] ^= EXP[lf + LOG[a[col][j]]];
+                if (inv[col][j] !== 0)
+                    inv[row][j] ^= EXP[lf + LOG[inv[col][j]]];
+            }
+        }
+    }
+    return inv;
+}
+/**
+ * Recover the K data shards from any K present shards (data and/or parity).
+ * `shards` is the full K+M array with missing entries as null; `len` is the
+ * shard length. Returns the K reconstructed data shards, or null if fewer than
+ * K shards are present (unrecoverable).
+ */
+export function rsDecode(shards, k, m, len) {
+    // Fast path: all K data shards present.
+    if (shards.slice(0, k).every((s) => s !== null))
+        return shards.slice(0, k);
+    // Collect the first K present shards and the rows of the full encoding matrix
+    // (identity for data rows, Cauchy for parity rows) that produced them.
+    const parity = cauchyParityMatrix(k, m);
+    const encRow = (idx) => {
+        if (idx < k) {
+            const r = new Uint8Array(k);
+            r[idx] = 1;
+            return r;
+        } // identity row
+        return parity[idx - k];
+    };
+    const subMatrix = [];
+    const present = [];
+    for (let idx = 0; idx < k + m && subMatrix.length < k; idx++) {
+        const s = shards[idx];
+        if (s) {
+            subMatrix.push(encRow(idx));
+            present.push(s);
+        }
+    }
+    if (subMatrix.length < k)
+        return null; // not enough shards
+    const invMatrix = invert(subMatrix, k);
+    if (!invMatrix)
+        return null;
+    // data = inv(subMatrix) × present.
+    const data = [];
+    for (let i = 0; i < k; i++) {
+        if (shards[i]) {
+            data.push(shards[i]);
+            continue;
+        } // already have it
+        const shard = new Uint8Array(len);
+        const row = invMatrix[i];
+        for (let j = 0; j < k; j++) {
+            const coeff = row[j];
+            if (coeff === 0)
+                continue;
+            const src = present[j];
+            const lc = LOG[coeff];
+            for (let b = 0; b < len; b++) {
+                const sv = src[b];
+                if (sv !== 0)
+                    shard[b] ^= EXP[lc + LOG[sv]];
+            }
+        }
+        data.push(shard);
+    }
+    return data;
+}

package/dist/peer.js

@@ -9,7 +9,7 @@ import { PACKET_TYPE_MESSAGE, PACKET_TYPE_FRIEND_REQUEST, PACKET_TYPE_USERINFO,
 import { NET_PACKET_ONION_ANNOUNCE_RESPONSE, NET_PACKET_ONION_DATA_RESPONSE, ONION_FRIEND_REQUEST_ID, createOnionAnnounceRequest, createOnionDataPacket, createOnionDataRequest, createOnionRequest0, openOnionAnnounceResponse, openOnionDataPacket, openOnionDataResponse } from "./compat/tox-onion.js";
 import { CRYPTO_PACKET_DHTPK, CRYPTO_PACKET_FRIEND_REQ, NET_PACKET_CRYPTO, createToxDhtCryptoRequest, openToxDhtCryptoRequest } from "./compat/tox-dht-crypto.js";
 import { NET_PACKET_PING_REQUEST, NET_PACKET_PING_RESPONSE, NET_PACKET_GET_NODES, NET_PACKET_SEND_NODES, encodeDhtRpc, decodeDhtRpc, buildPingPlain, parsePingPlain, buildGetNodesPlain, parseGetNodesPlain, buildSendNodesPlain, parseSendNodesNodeBytes, packUdpNodeV4 } from "./compat/dht-rpc.js";
-import { FileTransferManager, PACKET_ID_FILE_SENDREQUEST, PACKET_ID_FILE_CONTROL, PACKET_ID_FILE_DATA } from "./compat/filetransfer.js";
+import { FileTransferManager, PACKET_ID_FILE_SENDREQUEST, PACKET_ID_FILE_CONTROL, PACKET_ID_FILE_DATA, PACKET_ID_FILE_FEC } from "./compat/filetransfer.js";
 import { NET_PACKET_CRYPTO_DATA, NET_PACKET_CRYPTO_HS, NET_PACKET_COOKIE_REQUEST, NET_PACKET_COOKIE_RESPONSE, createCookieRequest, createCookieResponse, createCryptoDataPacket, createCryptoHandshake, openCookieRequest, openCookieResponse, openCryptoDataPacket, openCryptoHandshake, incrementNonce } from "./compat/net-crypto.js";
 import { LegacyExpressClient } from "./compat/express.js";
 import { TcpRelayPool } from "./compat/tcp-relay-pool.js";
@@ -1649,7 +1649,8 @@ export class Peer {
                 const isSingleTransportKind = (this.#opts.bulkDataPacketId !== undefined && innerKind === this.#opts.bulkDataPacketId) ||
                     innerKind === PACKET_ID_FILE_SENDREQUEST ||
                     innerKind === PACKET_ID_FILE_CONTROL ||
-                    innerKind === PACKET_ID_FILE_DATA;
+                    innerKind === PACKET_ID_FILE_DATA ||
+                    innerKind === PACKET_ID_FILE_FEC;
                 // Confirm the transport path + liveness for EVERY decrypted packet —
                 // INCLUDING a dual-send duplicate. Receiving over this transport proves
                 // it works, so this MUST run BEFORE the dedup drop below. Otherwise the
@@ -2922,7 +2923,7 @@ export class Peer {
         // happens to finish before reordering bites. Pinning file transfer to a
         // single transport keeps the chunks in send order. (Reliability across a
         // lossy path still wants a reorder buffer + retransmit — tracked separately.)
-        const isFileTransfer = kind === PACKET_ID_FILE_SENDREQUEST || kind === PACKET_ID_FILE_CONTROL || kind === PACKET_ID_FILE_DATA;
+        const isFileTransfer = kind === PACKET_ID_FILE_SENDREQUEST || kind === PACKET_ID_FILE_CONTROL || kind === PACKET_ID_FILE_DATA || kind === PACKET_ID_FILE_FEC;
         const isBulkData = (this.#opts.bulkDataPacketId !== undefined && kind === this.#opts.bulkDataPacketId) || isFileTransfer;
         // File transfer rides the relay RELIABLY (never dropped under backpressure):
         // a dropped IP/CCTV packet is fine (the stream moves on), but a dropped file

package/package.json

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