@decentnetwork/peer 0.1.77 → 0.1.79

package/dist/compat/filetransfer.d.ts

@@ -54,6 +54,7 @@ export declare class FileTransferManager {
     }): string | null;
     accept(friendId: string, fileNumber: number): void;
     cancel(friendId: string, fileNumber: number, isSending: boolean): void;
+    cancelByFileId(friendId: string, fileIdHex: string, isSending: boolean): boolean;
     handlePacket(friendId: string, packetId: number, payload: Uint8Array): boolean;
     clearFriend(friendId: string): void;
 }

package/dist/compat/filetransfer.js

@@ -311,6 +311,20 @@ export class FileTransferManager {
         else
             this.#endRecv(friendId, fileNumber);
     }
+    // Cancel by content fileId (hex) — the daemon/UI tracks transfers by fileId,
+    // not the internal fileNumber, so it can stop a specific in-flight transfer.
+    cancelByFileId(friendId, fileIdHex, isSending) {
+        const inner = (isSending ? this.#sending : this.#receiving).get(friendId);
+        if (!inner)
+            return false;
+        for (const [fileNumber, st] of inner) {
+            if (hex(st.fileId) === fileIdHex) {
+                this.cancel(friendId, fileNumber, isSending);
+                return true;
+            }
+        }
+        return false;
+    }
     handlePacket(friendId, packetId, payload) {
         if (packetId === PACKET_ID_FILE_SENDREQUEST) {
             this.#onSendRequest(friendId, payload);
@@ -751,8 +765,7 @@ export class FileTransferManager {
             // 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)
-                st.nextSend = st.acked;
+            this.#rewindRetransmit(st);
         }
         if (st.acked >= st.size) {
             this.#completeSend(friendId, st);
@@ -760,6 +773,21 @@ export class FileTransferManager {
         }
         void this.#pump(friendId, st);
     }
+    // Rewind for a go-back-N retransmit: move the send cursor back to the ack point
+    // AND rewind the FEC high-water mark so the re-sent blocks get FRESH parity.
+    // Without the parity rewind a lossy TAIL freezes forever — re-sending the
+    // region drops new chunks faster than it fills the old holes, and the receiver
+    // has no parity to recover them locally (parity was emitted once, long gone).
+    // Re-emitting parity lets the receiver FEC-recover the holes, so the tail
+    // converges instead of stalling at 93% (observed on 100 MB+ files).
+    #rewindRetransmit(st) {
+        if (st.nextSend > st.acked)
+            st.nextSend = st.acked;
+        const ackBlock = Math.floor(st.acked / MAX_FILE_DATA_SIZE / FEC_K);
+        if (ackBlock - 1 < st.parityHighBlock)
+            st.parityHighBlock = ackBlock - 1;
+        st.lastLossMs = nowMs(); // keep FEC ON so the re-emit actually fires
+    }
     // Single send loop. Awaits each send so net_crypto / the UDP socket applies
     // backpressure (fire-and-forget blasted the whole window into the macOS UDP
     // buffer at once → systematic overflow/drops the retransmit couldn't dig out
@@ -803,8 +831,7 @@ export class FileTransferManager {
                 st.cwnd = Math.max(CWND_MIN_CHUNKS, Math.floor(st.cwnd / 2));
                 st.lastAckAdvanceMs = nowMs();
                 st.lastResendMs = nowMs();
-                if (st.nextSend > st.acked)
-                    st.nextSend = st.acked; // go-back-N
+                this.#rewindRetransmit(st); // go-back-N + re-emit tail parity
                 void this.#pump(friendId, st);
             }, WATCHDOG_MS);
             if (typeof st.timer.unref === "function")

package/dist/peer.d.ts

@@ -111,6 +111,8 @@ export declare class Peer {
     acceptFile(userid: string, fileNumber: number): void;
     /** Cancel a transfer (isSending = true if we're the sender). */
     cancelFile(userid: string, fileNumber: number, isSending?: boolean): void;
+    /** Cancel an in-flight transfer by its content fileId (hex). Returns true if found. */
+    cancelFileById(userid: string, fileId: string, isSending?: boolean): boolean;
     /** Incoming file offer: { friendId, fileNumber, fileId, name, size, kind }. */
     onFile(cb: (offer: {
         friendId: string;

package/dist/peer.js

@@ -1032,6 +1032,8 @@ export class Peer {
     acceptFile(userid, fileNumber) { this.#fileTransfer.accept(userid, fileNumber); }
     /** Cancel a transfer (isSending = true if we're the sender). */
     cancelFile(userid, fileNumber, isSending = false) { this.#fileTransfer.cancel(userid, fileNumber, isSending); }
+    /** Cancel an in-flight transfer by its content fileId (hex). Returns true if found. */
+    cancelFileById(userid, fileId, isSending = false) { return this.#fileTransfer.cancelByFileId(userid, fileId, isSending); }
     /** Incoming file offer: { friendId, fileNumber, fileId, name, size, kind }. */
     onFile(cb) { this.#events.on("file-offer", cb); }
     /** Transfer progress: { friendId, fileId, received, total, sending? }. */

package/package.json

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