@decentnetwork/peer 0.1.105 → 0.1.108

package/dist/compat/filetransfer.d.ts

@@ -57,6 +57,12 @@ export declare class FileTransferManager {
     accept(friendId: string, fileNumber: number): void;
     cancel(friendId: string, fileNumber: number, isSending: boolean): void;
     cancelByFileId(friendId: string, fileIdHex: string, isSending: boolean): boolean;
+    /** Cancel in-flight sends matching both name and size.
+     *  This is a conservative registry-desync fallback after fileId/hash lookup. */
+    cancelSendsMatching(friendId: string, match: {
+        name?: string;
+        size: number;
+    }): string[];
     handlePacket(friendId: string, packetId: number, payload: Uint8Array): boolean;
     clearFriend(friendId: string): void;
 }

package/dist/compat/filetransfer.js

@@ -119,6 +119,8 @@ const LAN_STARTUP_QUEUE_MS = 500; // unmistakable raw queue spike; smaller app-l
 const LAN_STARTUP_HARD_QUEUE_MS = 2000; // one multi-second queue sample is unsafe
 const LAN_STARTUP_QUEUE_ROUNDS = 2; // tolerate one scheduler/session-handover outlier on LAN
 const LAN_STARTUP_KEEPUP = 0.70; // delivered goodput below 70% of pace means the receiver is no longer keeping up
+const LAN_RECOVERY_GAIN = 1.20; // after a LAN overshoot drains, climb out of the 120KB/s floor quickly but smoothly
+const LAN_RECOVERY_QUEUE_MS = 250; // only recover while queueing is clearly gone
 // Five 200 ms samples was still only about one Windows ACK scheduling cycle in
 // practice: a clean LAN (0% loss) exited STARTUP after ~3 MB and threw away a
 // healthy 2.3 MB/s probe. Require a few seconds of sustained under-delivery;
@@ -280,6 +282,8 @@ export class FileTransferManager {
             btlBwBps: 0, bwSamples: [], fullBwRounds: 0, startupQueueRounds: 0, bbrPhase: 0, roundCount: 0,
             rateMarkMs: nowMs(), rateMarkAcked: 0, lowRttCount: 0, lowRttMinMs: Infinity, lastCcLogMs: 0,
             lanPath,
+            dbgLanNow: lanPath ? 1 : 0, dbgSampleMs: 0, dbgRoundRate: 0, dbgMeasuredRate: 0,
+            dbgRawQueue: 0, dbgUnder: 0, dbgOvershot: 0,
         };
         this.#map(this.#sending, friendId).set(fileNumber, st);
         void this.send(friendId, PACKET_ID_FILE_SENDREQUEST, req).catch(() => undefined);
@@ -330,27 +334,54 @@ export class FileTransferManager {
         }
     }
     cancel(friendId, fileNumber, isSending) {
+        const inner = (isSending ? this.#sending : this.#receiving).get(friendId);
+        const st = inner?.get(fileNumber);
+        const fileId = st ? hex(st.fileId) : undefined;
         const sr = isSending ? 0 : 1;
         void this.send(friendId, PACKET_ID_FILE_CONTROL, encodeFileControl(sr, fileNumber, FILECONTROL.KILL)).catch(() => undefined);
         if (isSending)
             this.#endSend(friendId, fileNumber);
         else
             this.#endRecv(friendId, fileNumber);
+        // Local cancel used to tear down silently. The daemon tracks sends in
+        // activeSends and needs this event when the registry entry is already gone
+        // (or cancel raced with a progress tick) so the UI chip cannot stay "sending".
+        if (fileId)
+            this.emit("file-cancel", { friendId, fileId, sending: isSending, reason: "local" });
     }
     // 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 want = fileIdHex.trim().toLowerCase();
         const inner = (isSending ? this.#sending : this.#receiving).get(friendId);
         if (!inner)
             return false;
         for (const [fileNumber, st] of inner) {
-            if (hex(st.fileId) === fileIdHex) {
+            if (hex(st.fileId) === want) {
                 this.cancel(friendId, fileNumber, isSending);
                 return true;
             }
         }
         return false;
     }
+    /** Cancel in-flight sends matching both name and size.
+     *  This is a conservative registry-desync fallback after fileId/hash lookup. */
+    cancelSendsMatching(friendId, match) {
+        const inner = this.#sending.get(friendId);
+        if (!inner)
+            return [];
+        const candidates = [...inner].filter(([, st]) => st.size === match.size);
+        const named = match.name
+            ? candidates.filter(([, st]) => st.name === match.name)
+            : [];
+        const picked = named;
+        const killed = [];
+        for (const [fileNumber, st] of picked) {
+            killed.push(hex(st.fileId));
+            this.cancel(friendId, fileNumber, true);
+        }
+        return killed;
+    }
     handlePacket(friendId, packetId, payload) {
         if (packetId === PACKET_ID_FILE_SENDREQUEST) {
             this.#onSendRequest(friendId, payload);
@@ -798,6 +829,12 @@ export class FileTransferManager {
                         const measuredRate = lanNow
                             ? Math.min(roundRate, Math.max(PACE_INIT_BPS, st.paceRateBps * LAN_SAMPLE_MAX_GAIN))
                             : roundRate;
+                        st.dbgLanNow = lanNow ? 1 : 0;
+                        st.dbgSampleMs = Math.round(sampleMs);
+                        st.dbgRoundRate = Math.round(roundRate);
+                        st.dbgMeasuredRate = Math.round(measuredRate);
+                        st.dbgUnder = 0;
+                        st.dbgOvershot = 0;
                         if (measuredRate > 0) {
                             st.bwSamples.push(measuredRate);
                             if (st.bwSamples.length > PACE_BW_WINDOW)
@@ -822,6 +859,8 @@ export class FileTransferManager {
                             st.cwnd = Math.max(st.cwnd, LAN_CWND_INIT_CHUNKS);
                         }
                         st.lanPath = lanNow;
+                        const rawQueue = st.minRttMs !== Infinity ? acceptedRtt - st.minRttMs : 0;
+                        st.dbgRawQueue = Math.round(rawQueue);
                         if (!lanNow) {
                             // Relay/public-NAT file traffic must remain conservative. A short
                             // ACK burst can wildly overstate bandwidth there; allowing LAN's
@@ -849,7 +888,6 @@ export class FileTransferManager {
                             else {
                                 st.fullBwRounds++;
                             }
-                            const rawQueue = st.minRttMs !== Infinity ? acceptedRtt - st.minRttMs : 0;
                             if (rawQueue > LAN_STARTUP_QUEUE_MS) {
                                 st.startupQueueRounds++;
                             }
@@ -864,6 +902,8 @@ export class FileTransferManager {
                             const startupOvershot = rawQueue > LAN_STARTUP_HARD_QUEUE_MS ||
                                 st.startupQueueRounds >= LAN_STARTUP_QUEUE_ROUNDS;
                             const startupUnderDelivering = st.fullBwRounds >= LAN_STARTUP_SLOW_ROUNDS;
+                            st.dbgUnder = startupUnderDelivering ? 1 : 0;
+                            st.dbgOvershot = startupOvershot ? 1 : 0;
                             if (startupUnderDelivering || startupOvershot) {
                                 st.bbrPhase = 2;
                             }
@@ -885,8 +925,18 @@ export class FileTransferManager {
                         }
                         else {
                             // PROBE_BW cruise: one sample probes up, one drains, six cruise.
+                            // If LAN STARTUP hit one real overshoot (e.g. a 1s ACK pause with
+                            // high reported loss), the normal max-filter can be rebuilt from
+                            // tiny post-drain samples and then takes tens of seconds to climb
+                            // out of the 120KB/s floor. Once loss and queueing are gone, let
+                            // a validated LAN recover toward its safe initial probe rate. The
+                            // existing loss/queue brakes still stop a bad path immediately.
                             const gain = PACE_CYCLE_GAINS[st.roundCount % PACE_CYCLE_GAINS.length];
-                            st.paceRateBps = Math.max(PACE_INIT_BPS * 0.5, st.btlBwBps * gain * lossMult);
+                            const cruiseRate = Math.max(PACE_INIT_BPS * 0.5, st.btlBwBps * gain * lossMult);
+                            const healthyLan = lanNow && st.lossEwma < 0.02 && rawQueue < LAN_RECOVERY_QUEUE_MS;
+                            st.paceRateBps = healthyLan
+                                ? Math.max(cruiseRate, Math.min(LAN_PACE_INIT_BPS, Math.max(st.paceRateBps * LAN_RECOVERY_GAIN, measuredRate * LAN_STARTUP_DELIVERY_GAIN)))
+                                : cruiseRate;
                         }
                         // Hard safety cap: never pace faster than a full window drains in 1 RTT.
                         if (st.minRttMs !== Infinity && st.minRttMs > 0) {
@@ -904,15 +954,26 @@ export class FileTransferManager {
                 }
                 if (process.env.DECENT_DEBUG && nowT - st.lastCcLogMs >= 1000) {
                     st.lastCcLogMs = nowT;
+                    const windowEnd = Math.min(st.acked + st.cwnd * MAX_FILE_DATA_SIZE, st.size);
                     console.error(`[file-cc] friend=${friendId.slice(0, 8)} ack=${st.acked}/${st.size}` +
                         ` rtt=${rtt}ms srtt=${st.srttMs.toFixed(1)}ms low=${st.lowRttCount}` +
                         ` accepted=${(!lowSample || promoteLowPath) ? 1 : 0}` +
                         ` pace=${Math.round(st.paceRateBps)}Bps bw=${Math.round(st.btlBwBps)}Bps` +
                         ` cwnd=${st.cwnd} phase=${st.bbrPhase} slow=${st.fullBwRounds}` +
-                        ` loss=${(st.lossEwma * 100).toFixed(1)}% rounds=${st.roundCount}`);
+                        ` loss=${(st.lossEwma * 100).toFixed(1)}% rounds=${st.roundCount}` +
+                        ` lanNow=${st.dbgLanNow} lanPath=${st.lanPath ? 1 : 0}` +
+                        ` sampleMs=${st.dbgSampleMs} roundRate=${st.dbgRoundRate}` +
+                        ` measuredRate=${st.dbgMeasuredRate} rawQueue=${st.dbgRawQueue}` +
+                        ` startupQueueRounds=${st.startupQueueRounds}` +
+                        ` under=${st.dbgUnder} overshot=${st.dbgOvershot}` +
+                        ` rateMarkAcked=${st.rateMarkAcked} nextSend=${st.nextSend}` +
+                        ` windowEnd=${windowEnd} tokens=${Math.round(st.paceTokens)}`);
                 }
             }
-            if (st.acked - st.lastProgressAcked >= 256 * 1024 || st.acked >= st.size) {
+            // Small files (UI screenshots etc.) used to sit at 0% until the final
+            // byte because progress only fired every 256 KB. Emit at least every
+            // 16 KB or on completion so a 100–200 KB send shows movement.
+            if (st.acked - st.lastProgressAcked >= 16 * 1024 || st.acked >= st.size) {
                 st.lastProgressAcked = st.acked;
                 this.emit("file-progress", { friendId, fileId: hex(st.fileId), received: st.acked, total: st.size, sending: true });
             }

package/dist/peer.d.ts

@@ -164,6 +164,11 @@ export declare class Peer {
     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;
+    /** Cancel in-flight sends that match size/name (registry-desync fallback). */
+    cancelSendsMatching(userid: string, match: {
+        name?: string;
+        size: number;
+    }): string[];
     /** Incoming file offer: { friendId, fileNumber, fileId, name, size, kind }. */
     onFile(cb: (offer: {
         friendId: string;

package/dist/peer.js

@@ -1,4 +1,6 @@
 import { EventEmitter } from "node:events";
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile, rename } from "node:fs/promises";
 import { networkInterfaces } from "node:os";
 import { dirname, join } from "node:path";
@@ -1348,6 +1350,10 @@ export class Peer {
     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); }
+    /** Cancel in-flight sends that match size/name (registry-desync fallback). */
+    cancelSendsMatching(userid, match) {
+        return this.#fileTransfer.cancelSendsMatching(userid, match);
+    }
     /** Incoming file offer: { friendId, fileNumber, fileId, name, size, kind }. */
     onFile(cb) { this.#events.on("file-offer", cb); }
     /** Transfer progress: { friendId, fileId, received, total, sending? }. */
@@ -4489,7 +4495,11 @@ export class Peer {
         // office silently fall back to the TURN relay (~260ms for a <1ms hop).
         const lanIp = getPhysicalLanAddresses().find((ip) => isPrivateAddress(ip));
         const lanOctets = lanIp ? lanIp.split(".").map((s) => parseInt(s, 10)) : undefined;
-        const lanPort = this.#udp.localPort() ?? 0;
+        // WSL packets are NATed by Windows, so the physical host NIC must be paired
+        // with the observed server-reflexive port, not WSL's internal socket port.
+        const lanPort = lanIp && _wslHostAddrsCache.has(lanIp)
+            ? srflx.port
+            : (this.#udp.localPort() ?? 0);
         const lanValid = !!lanOctets && lanOctets.length === 4 && !lanOctets.some((o) => Number.isNaN(o)) && lanPort > 0;
         const size = lanValid ? 18 : relayValid ? 12 : 6;
         const payload = new Uint8Array(size);
@@ -6327,6 +6337,45 @@ let _lanAddrsCache = [];
 let _lanSubnetsCache = [];
 let _allOwnAddrsCache = new Set();
 let _ownVirtualAddrsCache = new Set();
+let _wslHostAddrsCache = new Set();
+let _wslHostCacheMs = 0;
+/** Discover the Windows host's physical NIC from WSL2. WSL itself only sees
+ * its 172.x Hyper-V NIC, which is unreachable from another LAN machine. */
+function getWslWindowsHostAddresses(localSubnets) {
+    const now = Date.now();
+    if (now - _wslHostCacheMs < 60_000)
+        return [..._wslHostAddrsCache];
+    _wslHostCacheMs = now;
+    const found = new Set();
+    const ipconfig = "/mnt/c/Windows/System32/ipconfig.exe";
+    if (process.platform !== "linux" || !existsSync(ipconfig)) {
+        _wslHostAddrsCache = found;
+        return [];
+    }
+    try {
+        const output = execFileSync(ipconfig, [], {
+            encoding: "utf8",
+            timeout: 2000,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "ignore"]
+        });
+        // "IPv4" remains in localized ipconfig output (including Chinese).
+        for (const match of output.matchAll(/IPv4[^:\r\n]*:\s*(\d+\.\d+\.\d+\.\d+)/gi)) {
+            const host = match[1];
+            if (!isPrivateAddress(host) || isCgnatAddress(host) || host.startsWith("127.") || host.startsWith("169.254."))
+                continue;
+            // Exclude WSL/Hyper-V addresses already visible inside Linux.
+            if (localSubnets.some((s) => isInIpv4Subnet(host, s)))
+                continue;
+            found.add(host);
+        }
+    }
+    catch {
+        // WSL interop can be disabled; ordinary interface discovery remains valid.
+    }
+    _wslHostAddrsCache = found;
+    return [...found];
+}
 function refreshLanIfaceCache() {
     const now = Date.now();
     if (_lanIfaceCacheMs !== 0 && now - _lanIfaceCacheMs < 5000)
@@ -6363,6 +6412,11 @@ function refreshLanIfaceCache() {
     catch {
         // best-effort
     }
+    // Prefer the physical Windows host NIC over WSL's internal eth0 address.
+    const wslHostAddrs = getWslWindowsHostAddresses(subnets);
+    for (const host of wslHostAddrs)
+        allOwn.add(host);
+    addrs.unshift(...wslHostAddrs);
     _lanAddrsCache = addrs;
     _lanSubnetsCache = subnets;
     _allOwnAddrsCache = allOwn;

package/package.json

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