@decentnetwork/peer 0.1.72 → 0.1.74

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,44 @@ 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;
+const FEC_M = 6;
+// 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:
@@ -62,10 +92,14 @@ const CWND_MIN_CHUNKS = 8; // ~11 KB floor — keeps a slow/flaky path's buffer
 // 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.
-const MAX_QUEUE_MS = 150; // ceiling on added latency → when exceeded, drain
-const QUEUE_LOW_MS = 60; // below this there's spare capacity → grow
-const VEGAS_GROW = 1.3; // window ×this per RTT when under-filled
-const VEGAS_SHRINK = 0.85; // window ×this per RTT when the queue is too deep
+// 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)
+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
 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)
@@ -193,8 +227,8 @@ 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,
-            minRttMs: Infinity, srttMs: 0, probeOffset: -1, probeSentMs: 0,
+            cwnd: CWND_INIT_CHUNKS, stalls: 0, parityHighBlock: -1, lastLossMs: 0,
+            minRttMs: Infinity, minSrttMs: Infinity, srttMs: 0, probeOffset: -1, probeSentMs: 0,
         };
         this.#map(this.#sending, friendId).set(fileNumber, st);
         void this.send(friendId, PACKET_ID_FILE_SENDREQUEST, req).catch(() => undefined);
@@ -265,6 +299,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) {
@@ -280,7 +318,7 @@ export class FileTransferManager {
         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,
+            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
@@ -381,20 +419,114 @@ export class FileTransferManager {
         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)
+            return;
+        let arr = st.fecParity.get(f.blockIndex);
+        if (!arr) {
+            arr = new Array(FEC_M).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; pi++)
+            shards.push(parityArr?.[pi] ?? null);
+        const recovered = rsDecode(shards, k, FEC_M, 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) {
@@ -498,15 +630,23 @@ export class FileTransferManager {
                     st.srttMs = st.srttMs === 0 ? rtt : 0.85 * st.srttMs + 0.15 * rtt;
                     if (rtt < st.minRttMs)
                         st.minRttMs = rtt;
-                    // Added latency this transfer is putting on the path = how deep the
-                    // queue is. Steer the window to keep it under MAX_QUEUE_MS.
-                    const queueDelayMs = st.minRttMs !== Infinity ? rtt - st.minRttMs : 0;
-                    if (queueDelayMs < QUEUE_LOW_MS) {
-                        st.cwnd = Math.min(WINDOW_CHUNKS, Math.ceil(st.cwnd * VEGAS_GROW)); // spare capacity → grow
+                    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
                     }
-                    else if (queueDelayMs > MAX_QUEUE_MS) {
-                        st.cwnd = Math.max(CWND_MIN_CHUNKS, Math.floor(st.cwnd * VEGAS_SHRINK)); // queue too deep → drain
-                    } // else hold: pipe full, queue shallow
+                    else if (smoothQueue < QUEUE_LOW_MS) {
+                        st.cwnd = Math.min(WINDOW_CHUNKS, Math.ceil(st.cwnd * VEGAS_GROW)); // spare capacity → grow
+                    } // else hold
                 }
             }
             if (st.acked - st.lastProgressAcked >= 256 * 1024 || st.acked >= st.size) {
@@ -520,6 +660,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;
         }
@@ -604,11 +745,54 @@ 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
+            // Build the k data shards (zero-padded to a full chunk) and encode M 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, FEC_M);
+            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.72",
+  "version": "0.1.74",
   "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",