@decentnetwork/peer 0.1.61 → 0.1.63

package/dist/peer.js

@@ -1636,22 +1636,18 @@ export class Peer {
                     innerKind === PACKET_ID_FILE_SENDREQUEST ||
                     innerKind === PACKET_ID_FILE_CONTROL ||
                     innerKind === PACKET_ID_FILE_DATA;
-                if (!isSingleTransportKind && opened.packetNumber < (state.receiveBufferStart ?? 0)) {
-                    continue;
-                }
-                state.peerBaseNonce[state.peerBaseNonce.length - 2] = packet[1];
-                state.peerBaseNonce[state.peerBaseNonce.length - 1] = packet[2];
-                incrementNonce(state.peerBaseNonce);
+                // 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
+                // duplicate UDP copy (the relay copy already advanced the buffer) is
+                // dropped without ever marking the direct-UDP path live → lastUdpRecvMs
+                // stays unset → udpFresh false → bulk data (files) never ride the LAN
+                // even when LAN UDP is flowing both ways (the snoopy slow-file bug).
                 state.lastPingRecvMs = Date.now();
-                // Same TCP-vs-UDP rule as the handshake handlers: don't poison
-                // the UDP send-back endpoint when this packet came in via TCP.
                 if (this.#remoteIsTcp(remote)) {
                     state.hasTcpRoute = true;
                 }
                 else if (viaRelay) {
-                    // Arrived over the TURN relay. Track relay freshness separately;
-                    // do NOT set state.remote (that's the direct endpoint). The relay
-                    // address it came from is already in state.relayRemote.
                     if (!state.lastRelayRecvMs) {
                         this.#debugLog(`relay_confirmed friend=${friendId} via=${remote.address}:${remote.port} (TURN relay path live)`);
                     }
@@ -1659,10 +1655,9 @@ export class Peer {
                 }
                 else {
                     // Adopt the source as our send endpoint — but NEVER downgrade from a
-                    // same-LAN (physical) path to a non-LAN source. A packet that loops in
-                    // via the peer's public / Tailscale-exit endpoint must not knock us off
-                    // the direct LAN path, which is strictly better. (This is the other
-                    // half of the "use the physical LAN, not Tailscale" rule.)
+                    // same-LAN (physical) path to a non-LAN source (a hairpin packet via
+                    // the peer's public / Tailscale-exit endpoint must not knock us off
+                    // the direct LAN path, which is strictly better).
                     const cur = state.remote?.host;
                     const onSameLanAlready = !!cur && !cur.startsWith("tcp:") && isPrivateAddress(cur) && !isCgnatAddress(cur) &&
                         getPhysicalLanSubnets().some((s) => isInIpv4Subnet(cur, s));
@@ -1676,6 +1671,15 @@ export class Peer {
                     }
                     state.lastUdpRecvMs = Date.now();
                 }
+                // De-duplicate: skip the DISPATCH + nonce advance for an already-seen
+                // packet number. The transport confirmation above already ran, so a
+                // duplicate still keeps the path fresh.
+                if (!isSingleTransportKind && opened.packetNumber < (state.receiveBufferStart ?? 0)) {
+                    continue;
+                }
+                state.peerBaseNonce[state.peerBaseNonce.length - 2] = packet[1];
+                state.peerBaseNonce[state.peerBaseNonce.length - 1] = packet[2];
+                incrementNonce(state.peerBaseNonce);
                 state.receiveBufferStart = Math.max(state.receiveBufferStart ?? 0, (opened.packetNumber + 1) >>> 0);
                 const kind = opened.payload[0];
                 const inner = opened.payload.slice(1);
@@ -3472,7 +3476,14 @@ export class Peer {
         // upgrading the path to direct UDP in both directions with no new
         // handshake. If UDP never works, the periodic offer re-punches.
         const haveRealUdp = session.remote && !session.remote.host?.startsWith("tcp:") && session.remote.port !== 0;
-        if (!haveRealUdp) {
+        // NEVER point the session at the public srflx when we know a same-LAN
+        // candidate for this peer: the physical LAN is strictly better, and letting
+        // the srflx win here caused a LAN↔public FLAP (the LAN block above set
+        // remote=LAN, then this overwrote it with the Tailscale-exit public IP),
+        // so the direct LAN path never stabilised and udpRecv never confirmed.
+        const haveLanCandidate = (session.endpointCandidates ?? []).some((c) => isPrivateAddress(c.host) && !isCgnatAddress(c.host) &&
+            getPhysicalLanSubnets().some((s) => isInIpv4Subnet(c.host, s)));
+        if (!haveRealUdp && !haveLanCandidate) {
             session.remote = { host, port };
         }
         // Nudge a keepalive out immediately so the upgrade doesn't wait for

package/package.json

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