@decentnetwork/peer 0.1.132 → 0.1.133

package/dist/peer.js

@@ -3524,6 +3524,38 @@ export class Peer {
                 // keys; it must NOT keep a transportless relay session as a 180s
                 // zombie (iOS flap: peer sees us vanish while we still show them
                 // online and drop every send). Fast-track those to teardown.
+                // Self-heal a remote we could never have reached.
+                //
+                // The adoption guards keep a bad endpoint out, but a session that
+                // already holds one never re-examines it, and session.remote is sticky
+                // — so the daemon keeps addressing a host it cannot reach for as long
+                // as the session lives. It sits ABOVE the branches below on purpose:
+                // an established session is exactly the case that never re-evaluates,
+                // and putting this inside the not-yet-online branch (where it started)
+                // meant it never ran at all.
+                //
+                // tokyo held 10.0.0.245 for a laptop across the Pacific, through
+                // restarts, with lastUdpRecvMs null throughout. Visible as a link that
+                // alternates between fast and dead in runs of several seconds, because
+                // only some of the paths in play actually reach the peer.
+                //
+                // Both conditions are needed: an address outside every subnet we are
+                // on, AND no UDP ever received here. A real same-LAN peer fails the
+                // first; a peer we have genuinely heard from fails the second.
+                if (session.remote &&
+                    !session.remote.host.startsWith("tcp:") &&
+                    session.lastUdpRecvMs === undefined &&
+                    isPrivateAddress(session.remote.host) &&
+                    !isCgnatAddress(session.remote.host) &&
+                    !getPhysicalLanSubnets().some((sub) => isInIpv4Subnet(session.remote.host, sub))) {
+                    const dead = session.remote;
+                    this.#debugLog(`clearing unreachable remote ${dead.host}:${dead.port} for ${friendId} ` +
+                        `— private, off our LANs, and never received UDP from it`);
+                    session.remote = undefined;
+                    session.lanRemoteHost = undefined;
+                    // Drop it from the candidates too, or the next sweep re-adopts it.
+                    session.endpointCandidates = (session.endpointCandidates ?? []).filter((c) => !(c.host === dead.host && c.port === dead.port));
+                }
                 const relayOnly = !session.remote || session.remote.host.startsWith("tcp:");
                 const pathless = relayOnly && !session.hasTcpRoute;
                 const deadline = proven && !pathless ? PROVEN_SESSION_HARD_TIMEOUT_MS : FRIEND_TIMEOUT_MS;
@@ -3585,36 +3617,6 @@ export class Peer {
                 if (session.remote && friend.status !== "online") {
                     this.#setFriendOnline(friendId, session.remote.host, session.remote.port);
                 }
-                // Self-heal a remote that was poisoned before we knew better.
-                //
-                // The adoption guards stop a bad endpoint getting IN, but a session
-                // that already holds one never re-examines it — and session.remote is
-                // sticky, so the daemon keeps addressing a host it cannot reach for as
-                // long as the session lives. Seen between tokyo (Japan) and a laptop
-                // at home: udpRemote stayed 10.0.0.245 across restarts with
-                // lastUdpRecvMs null the whole time, while traffic limped along the
-                // relay. Symptom is a link that is fast when it works and dead in
-                // stretches, because only some paths reach the peer.
-                //
-                // The two conditions together are what make this safe: an address we
-                // could never route to, AND no UDP ever received on this session. A
-                // working same-LAN peer fails the first test; a peer we have actually
-                // heard from fails the second.
-                if (session.remote &&
-                    !session.remote.host.startsWith("tcp:") &&
-                    session.lastUdpRecvMs === undefined &&
-                    isPrivateAddress(session.remote.host) &&
-                    !isCgnatAddress(session.remote.host) &&
-                    !getPhysicalLanSubnets().some((sub) => isInIpv4Subnet(session.remote.host, sub))) {
-                    const dead = session.remote;
-                    this.#debugLog(`clearing unreachable remote ${dead.host}:${dead.port} for ${friendId} ` +
-                        `— private, off our LANs, and never received UDP from it`);
-                    session.remote = undefined;
-                    session.lanRemoteHost = undefined;
-                    // Drop it from the candidate list too, or the next sweep re-adopts
-                    // the same address and we are back where we started.
-                    session.endpointCandidates = (session.endpointCandidates ?? []).filter((c) => !(c.host === dead.host && c.port === dead.port));
-                }
                 // Phase 1.2: keep retrying UDP holepunch even after the session
                 // is already "established" via TCP relay. The toxcore-derived
                 // logic above stops trying once anybody is reachable, which is

package/package.json

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