@decentnetwork/peer 0.1.104 → 0.1.105

package/dist/compat/filetransfer.js

@@ -239,17 +239,23 @@ export class FileTransferManager {
         }
         return inner;
     }
-    #freeNumber(friendId) {
+    #freeNumber(friendId, preferred = 0) {
         const inner = this.#map(this.#sending, friendId);
-        for (let i = 0; i < MAX_CONCURRENT_FILE_PIPES; i++)
+        // Start at a content-derived slot. Older receivers retain an incomplete
+        // receive slot in memory until it finishes or is killed. After the sender
+        // restarts, always reusing slot 0 makes a DIFFERENT new file look like a
+        // retransmitted offer for that stale slot, so the receiver silently ACKs
+        // the old file and the new UI stays at 0%. The same content keeps the same
+        // preferred slot (resume), while different content naturally avoids stale
+        // collisions; circular search still supports concurrent transfers.
+        for (let n = 0; n < MAX_CONCURRENT_FILE_PIPES; n++) {
+            const i = (preferred + n) % MAX_CONCURRENT_FILE_PIPES;
             if (!inner.has(i))
                 return i;
+        }
         return -1;
     }
     sendFile(friendId, data, opts) {
-        const fileNumber = this.#freeNumber(friendId);
-        if (fileNumber < 0)
-            return null;
         // Content-addressed fileId (sha256): re-sending the SAME file after a
         // restart or a dropped peer yields the SAME id, so the receiver can match
         // it against its persisted partial and resume from where it left off — the
@@ -257,6 +263,9 @@ export class FileTransferManager {
         const fileId = data.length > 0
             ? new Uint8Array(createHash("sha256").update(data).digest()).slice(0, FILE_ID_LENGTH)
             : randomBytes(FILE_ID_LENGTH);
+        const fileNumber = this.#freeNumber(friendId, fileId[0] ?? 0);
+        if (fileNumber < 0)
+            return null;
         const req = encodeFileSendRequest(fileNumber, opts.kind ?? FILEKIND.DATA, BigInt(data.length), fileId, opts.name);
         const lanPath = this.isLanPath(friendId);
         const st = {

package/dist/peer.js

@@ -2163,6 +2163,21 @@ export class Peer {
                     // syscall (that was the CCTV CPU regression) — safe at CCTV packet
                     // rates.
                     this.#adoptRemote(state, remote.address, remote.port);
+                    // A successfully decrypted packet arriving from a private address in
+                    // one of our physical subnets is stronger LAN proof than an endpoint
+                    // hint: it demonstrates that this exact host:port already reaches us.
+                    // Lock it immediately. Without this, duplicate public/relay copies
+                    // arriving a moment later overwrite `remote`, so file DATA travels on
+                    // the LAN but ACKs hairpin through the public Internet (observed as
+                    // ~38KB/s between mac-dev and WSL on the same 10.0.0.0/24).
+                    if (!state.lanRemoteHost &&
+                        isPrivateAddress(remote.address) &&
+                        !isCgnatAddress(remote.address) &&
+                        getPhysicalLanSubnets().some((s) => isInIpv4Subnet(remote.address, s))) {
+                        state.lanRemoteHost = remote.address;
+                        this.#rememberEndpointCandidate(state, remote.address, remote.port);
+                        this.#debugLog(`lan_lock_confirmed friend=${friendId} host=${remote.address}:${remote.port} (decrypted UDP source)`);
+                    }
                     if (!state.lastUdpRecvMs) {
                         this.#debugLog(`udp_confirmed friend=${friendId} via=${remote.address}:${remote.port} (direct UDP path live)`);
                     }
@@ -4559,10 +4574,17 @@ export class Peer {
         if (payload.length >= 18) {
             const lanHost = `${payload[12]}.${payload[13]}.${payload[14]}.${payload[15]}`;
             const lanPort = ((payload[16] << 8) | payload[17]) >>> 0;
+            // WSL sees only its 172.x virtual NIC, not the Windows host's physical
+            // 10.x subnet. In that topology a peer on the same real LAN is still
+            // safely identifiable because its server-reflexive address equals ours.
+            // Permit the advertised private candidate when both peers share the same
+            // public NAT; if it is a CGNAT/private collision and never validates, the
+            // normal 12s stale-LAN-lock breaker restores the public/relay path.
+            const samePublicNat = !!this.#srflxCache?.addr.host && this.#srflxCache.addr.host === host;
             const sameLan = lanPort !== 0 &&
                 isPrivateAddress(lanHost) &&
                 !isCgnatAddress(lanHost) &&
-                getPhysicalLanSubnets().some((s) => isInIpv4Subnet(lanHost, s)) &&
+                (getPhysicalLanSubnets().some((s) => isInIpv4Subnet(lanHost, s)) || samePublicNat) &&
                 !(getPhysicalLanAddresses().includes(lanHost) && this.#udp.localPort() === lanPort);
             if (sameLan) {
                 this.#rememberEndpointCandidate(session, lanHost, lanPort);

package/package.json

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