@decentnetwork/peer 0.1.66 → 0.1.68

package/dist/peer.d.ts

@@ -194,10 +194,17 @@ export declare class Peer {
          *  tcp-relay, discovery itself is broken — we don't even know
          *  where to send a cookie request. */
         endpointCandidatesCount: number;
+        /** The actual candidate endpoints (host:port) — lets diag see whether a
+         *  same-LAN host candidate (e.g. 10.0.0.x) was received but not adopted. */
+        endpointCandidates: string[];
         /** Last time we sent an outbound cookie request via UDP for this
          *  peer (null = never). Used to confirm Phase 1.2 retries are
          *  actually firing. */
         cookieRequestSentMs: number | null;
+        /** The peer's physical-LAN host we've locked onto (set by the periodic
+         *  offer/maintenance LAN-adoption code). When set and equal to udpRemote's
+         *  host, the per-packet receive path refuses a public/hairpin downgrade. */
+        lanRemoteHost: string | null;
     } | null;
     waitForFriendRequest(timeoutMs?: number): Promise<FriendRequest>;
     /**

package/dist/peer.js

@@ -82,6 +82,28 @@ const FRIEND_PING_INTERVAL_MS = readEnvInt("DECENT_FRIEND_PING_INTERVAL_MS", 400
 // slow enough not to burn CPU on idle peers. Tunable via env.
 const FRIEND_CONNECTION_LOOP_MS = readEnvInt("DECENT_FRIEND_CONNECTION_LOOP_MS", 250);
 const FRIEND_TIMEOUT_MS = readEnvInt("DECENT_FRIEND_TIMEOUT_MS", 32000);
+// How long the direct UDP path may go without an inbound packet before we
+// release a physical-LAN lock (so a peer that left the LAN can recover onto the
+// public/relay path). 12s ≈ 3 missed 4s keepalives — long enough to never trip
+// on a healthy same-LAN path, short enough to recover quickly.
+const LAN_LOCK_STALE_MS = readEnvInt("DECENT_LAN_LOCK_STALE_MS", 12000);
+// Half-open breaker: if the peer proposes a NEW session key this many times over
+// this long while our session looks "alive", accept it (the peer can't decrypt
+// our current session — a desynced half-open session, observed as a flood of
+// "no session matched"). Each handshake carries a fresh cookie so these are
+// genuine attempts, not replays. Bounded so it never fires on a healthy session.
+const REHS_ACCEPT_COUNT = readEnvInt("DECENT_REHS_ACCEPT_COUNT", 4);
+const REHS_ACCEPT_MS = readEnvInt("DECENT_REHS_ACCEPT_MS", 2500);
+const REHS_WINDOW_MS = readEnvInt("DECENT_REHS_WINDOW_MS", 8000);
+// Re-handshake when we keep receiving undecryptable crypto data from a known
+// friend's endpoint (desynced sessions), rate-limited per friend.
+// Conservative: deleting a session forces a re-handshake which ROTATES our
+// ephemeral key, so doing it too eagerly turns a transient blip into a
+// rotate→desync→delete thrash. Only nuke a session that's been UNABLE to
+// decrypt anything for a long time (genuinely dead, well past any
+// establishment-transition window), and at most once per long interval.
+const REINIT_ON_DESYNC_MS = readEnvInt("DECENT_REINIT_ON_DESYNC_MS", 12000);
+const REINIT_STUCK_MS = readEnvInt("DECENT_REINIT_STUCK_MS", 20000);
 // How long a relay path stays "confirmed" (carrying bulk data on its own, no
 // tcp-relay fan-out) after the last packet received over it. The relay
 // keepalive refreshes this every ~4s on a healthy path, so a generous window
@@ -256,6 +278,9 @@ export class Peer {
     // #initiateSession every few seconds for every friend; without this
     // dedupe, lower-pubkey side floods the log with "deferring to peer".
     #initiateSkipLogged = new Set();
+    // Per-friend last time we deleted a desynced session (rate-limit; survives the
+    // session deletion, unlike a field on the session object itself).
+    #lastDesyncDeleteMs = new Map();
     // Cached server-reflexive (public) UDP endpoint of our #udp socket,
     // learned via STUN. Cone-NAT mappings are stable for the socket
     // lifetime, so we only re-probe every ~60s. Used to tell friends where
@@ -1062,7 +1087,9 @@ export class Peer {
             ourLocalUdpPort: this.#udp?.localPort() ?? null,
             friendUdpEndpoint: friendUdp,
             endpointCandidatesCount: s.endpointCandidates?.length ?? 0,
+            endpointCandidates: (s.endpointCandidates ?? []).map((c) => `${c.host}:${c.port}`),
             cookieRequestSentMs: s.cookieRequestSentMs ?? null,
+            lanRemoteHost: s.lanRemoteHost ?? null,
         };
     }
     waitForFriendRequest(timeoutMs = 30000) {
@@ -1365,7 +1392,13 @@ export class Peer {
                     state.hasTcpRoute = true;
                 }
                 else {
-                    state.remote = { host: remote.address, port: remote.port };
+                    // Same LAN-lock guard as the crypto-data path: a duplicate handshake
+                    // retransmitted via the public/hairpin endpoint must not knock us off
+                    // a locked physical-LAN path. Cheap string compare — no syscall.
+                    const lockedOnLan = !!state.lanRemoteHost && state.remote?.host === state.lanRemoteHost;
+                    if (!lockedOnLan || remote.address === state.lanRemoteHost) {
+                        state.remote = { host: remote.address, port: remote.port };
+                    }
                 }
                 state.lastPingRecvMs = Date.now();
                 this.#debugVerboseLog(`hs_recv duplicate friend=${friendId} remote=${remote.address}:${remote.port} (session preserved)`);
@@ -1435,9 +1468,10 @@ export class Peer {
                 const lastAlive = state.lastPingRecvMs ?? state.sessionEstablishedAtMs;
                 const currentSessionAlive = Date.now() - lastAlive < FRIEND_TIMEOUT_MS;
                 if (sinceEstablished > 1000 && currentSessionAlive) {
-                    // Verbose only — peers retransmit handshakes aggressively, so
-                    // this line fires dozens of times per minute on a stuck pair
-                    // and drowns out signal. Visible with DECENT_DEBUG_VERBOSE=1.
+                    // Reject a new-key handshake while our session is alive — toxcore does
+                    // the same. (The "half-open breaker" that accepted these after N tries
+                    // was reverted: accepting a new key ROTATES the session, which churned
+                    // healthy sessions; the real fix was the TURN-crash fix, not this.)
                     this.#debugVerboseLog(`hs_recv ignored friend=${friendId} (new session pubkey on live established session, ${sinceEstablished}ms after establish)`);
                     return;
                 }
@@ -1454,7 +1488,13 @@ export class Peer {
                 // Don't set state.remote — there's no UDP endpoint for this peer.
             }
             else {
-                state.remote = { host: remote.address, port: remote.port };
+                // LAN-lock guard (see crypto-data path): don't let an establish/
+                // re-handshake arriving over the public/hairpin endpoint downgrade us
+                // off a locked physical-LAN path. Cheap string compare — no syscall.
+                const lockedOnLan = !!state.lanRemoteHost && state.remote?.host === state.lanRemoteHost;
+                if (!lockedOnLan || remote.address === state.lanRemoteHost) {
+                    state.remote = { host: remote.address, port: remote.port };
+                }
             }
             if (isNewSession) {
                 state.sendPacketNumber = 0;
@@ -1470,13 +1510,21 @@ export class Peer {
             this.#debugLog(`hs_recv friend=${friendId} initiated=${weInitiated ? 1 : 0} remote=${remote.address}:${remote.port}`);
             if (!wasEstablished) {
                 this.#debugLog(`friend_connected friend=${friendId} remote=${remote.address}:${remote.port}`);
-                // If we only have a TCP-relay path, immediately tell the peer our
-                // public UDP endpoint so they can hole-punch — don't wait for the
-                // 15s UDP-retry loop, which can miss a flapping relay session's
-                // short-lived establishment window. Both sides do this on every
-                // (re)establishment, so a brief tcp-relay window is enough to
-                // bootstrap the direct UDP path. See docs/UDP-DIRECT-PLAN.md.
-                if (state.hasTcpRoute && !state.remote) {
+                // Send our UDP endpoint offer (public srflx + LAN host candidate)
+                // whenever the current path isn't already a same-LAN direct one:
+                //  - relay-only sessions need it to bootstrap a direct UDP path; and
+                //  - sessions that came up over a PUBLIC UDP endpoint (internet
+                //    hairpin) when both peers are actually on the SAME LAN — without
+                //    the offer they never learn each other's 10.x/192.168.x address and
+                //    stay stuck on the public path, which a symmetric / hairpin NAT
+                //    breaks one-way (observed: two boxes on one LAN where each only saw
+                //    the other one-directionally). The peer's same-subnet filter drops
+                //    the LAN candidate when it doesn't apply, so offering is always safe.
+                const r = state.remote;
+                const remoteIsSameLan = !!r && isPrivateAddress(r.host) && !isCgnatAddress(r.host) &&
+                    getPhysicalLanSubnets().some((s) => isInIpv4Subnet(r.host, s));
+                const haveLanToOffer = getPhysicalLanAddresses().some((ip) => isPrivateAddress(ip) && !isCgnatAddress(ip));
+                if ((state.hasTcpRoute && !r) || (!remoteIsSameLan && haveLanToOffer)) {
                     void this.#sendUdpEndpointOffer(friendId).catch(() => undefined);
                 }
             }
@@ -1598,34 +1646,54 @@ 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)`);
                     }
                     state.lastRelayRecvMs = Date.now();
                 }
                 else {
-                    state.remote = { host: remote.address, port: remote.port };
+                    // Adopt the source as our send endpoint — but NEVER downgrade from a
+                    // locked 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).
+                    //
+                    // CCTV-safe: the LAN decision (which needs a networkInterfaces() syscall)
+                    // is made ONLY in the periodic offer/maintenance paths, which record the
+                    // locked peer LAN host in state.lanRemoteHost. Here in the per-packet hot
+                    // path we do a single string compare — NO interface syscall — so a
+                    // high-rate stream (CCTV: thousands of packets/sec) never pays for it.
+                    // (The per-packet getPhysicalLanSubnets() call this replaces was the
+                    // CCTV CPU regression.)
+                    const lockedOnLan = !!state.lanRemoteHost && state.remote?.host === state.lanRemoteHost;
+                    if (!lockedOnLan || remote.address === state.lanRemoteHost) {
+                        state.remote = { host: remote.address, port: remote.port };
+                    }
                     if (!state.lastUdpRecvMs) {
                         this.#debugLog(`udp_confirmed friend=${friendId} via=${remote.address}:${remote.port} (direct UDP path live)`);
                     }
                     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);
@@ -1778,7 +1846,16 @@ export class Peer {
                 this.#debugVerboseLog(`unknown messenger packet kind ${kind} from ${friendId}`);
                 return;
             }
-            this.#debugLog(`crypto data received from ${remote.address}:${remote.port} but no session matched`);
+            // Reverted: we used to DELETE a "desynced" session here to force a clean
+            // re-handshake. It caused more harm than good — deleting a session
+            // interrupts the data plane, and a transient/late undecryptable packet
+            // (common over the relay) triggered a delete→re-key→re-desync thrash that
+            // churned MANY friends' sessions (observed: CCTV jitter + slow file
+            // transfer to 4090, not just snoopy). The real instability was the daemon
+            // CRASH (TURN DNS); with that fixed, sessions stay converged on their own.
+            // Just drop the undecryptable packet — net_crypto's normal re-handshake
+            // path recovers a genuinely dead session.
+            this.#debugVerboseLog(`crypto data received from ${remote.address}:${remote.port} but no session matched`);
             return;
         }
         if (packet[0] === NET_PACKET_ONION_DATA_RESPONSE && this.#announceDataKey) {
@@ -3085,6 +3162,15 @@ export class Peer {
         session.endpointCandidates = next
             .sort((a, b) => b.updatedMs - a.updatedMs)
             .slice(0, 12);
+        // The moment we learn the peer's physical-LAN host candidate, record it as
+        // the LAN lock so the per-packet/handshake hot paths refuse a public/hairpin
+        // downgrade (cheap string compare there, no syscall). This runs at
+        // candidate-learn time (offer/discovery), not per packet, so the cached
+        // getPhysicalLanSubnets() call is fine here.
+        if (isPrivateAddress(host) && !isCgnatAddress(host) &&
+            getPhysicalLanSubnets().some((s) => isInIpv4Subnet(host, s))) {
+            session.lanRemoteHost = host;
+        }
     }
     /**
      * Learn our own server-reflexive (public) UDP endpoint by sending a
@@ -3177,11 +3263,13 @@ export class Peer {
                             resolve();
                         });
                     });
-                    // CRITICAL: persistent 'error' listener. A TURN send to an unresolvable
-                    // host (transient DNS NXDOMAIN, e.g. tokyo.fi.chat) emits an 'error' on
-                    // this dgram socket; with no listener Node re-throws it as an uncaught
-                    // exception and CRASHES THE WHOLE DAEMON (every session dropped, mass
-                    // re-handshake churn). Swallow it — the relay just won't allocate here.
+                    // CRITICAL: a persistent 'error' listener. A TURN send to an
+                    // unresolvable host (DNS NXDOMAIN — e.g. tokyo.fi.chat on a box whose
+                    // resolver doesn't know it) emits an 'error' on this dgram socket;
+                    // with no listener, Node re-throws it as an uncaught exception and
+                    // CRASHES THE ENTIRE DAEMON (observed: snoopy repeatedly dying on
+                    // "getaddrinfo ENOTFOUND tokyo.fi.chat", which churned every session).
+                    // Swallow it — the relay simply won't allocate/relay over this server.
                     sock.on("error", (e) => this.#debugLog(`turn socket error (${srv.host}): ${e.message}`));
                     const client = new TurnClient({
                         sock,
@@ -3351,10 +3439,24 @@ export class Peer {
                     if (++ln >= 6)
                         clearInterval(lanTimer);
                 }, 120);
-                const haveRealUdp = session.remote && !session.remote.host?.startsWith("tcp:") && session.remote.port !== 0;
-                if (!haveRealUdp) {
+                // The physical LAN is strictly better than ANY public path — direct, no
+                // NAT, no relay, and crucially no Tailscale-exit hairpin (a peer whose
+                // internet egresses via Tailscale advertises its exit's public IP as
+                // its srflx, so the "direct" public path actually loops out through
+                // Tailscale and back). So adopt the LAN candidate as session.remote even
+                // when we already have a public "real UDP" remote — UNLESS we're already
+                // on a same-LAN address (don't flap between two LAN candidates). Without
+                // this the session stuck to the public/Tailscale endpoint and never sent
+                // over the LAN (observed: session.remote stayed public, data on relay).
+                const cur = session.remote?.host;
+                const onSameLanAlready = !!cur && !cur.startsWith("tcp:") && isPrivateAddress(cur) && !isCgnatAddress(cur) &&
+                    getPhysicalLanSubnets().some((s) => isInIpv4Subnet(cur, s));
+                if (!onSameLanAlready) {
                     session.remote = { host: lanHost, port: lanPort };
                 }
+                // Record the locked LAN host so the per-packet receive path can refuse a
+                // public/hairpin downgrade with a plain string compare (no syscall).
+                session.lanRemoteHost = lanHost;
                 if (session.established) {
                     void this.#sendMessengerPacket(friendId, PACKET_ID_ALIVE, new Uint8Array()).catch(() => undefined);
                 }
@@ -3389,7 +3491,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
@@ -3967,6 +4076,57 @@ export class Peer {
             if (!node.isTcp)
                 void this.#sendDhtPing(node);
         }
+        // 4. LAN-direct upgrade. Re-offer our endpoint (public srflx + LAN host
+        //    candidate) to any established friend whose current path is NOT already
+        //    a same-LAN address, as long as we have a LAN address to advertise. This
+        //    upgrades sessions that came up over a public UDP endpoint (internet
+        //    hairpin) to the direct LAN path even without a re-establish, and self-
+        //    stops once the path becomes same-LAN. The peer's same-subnet filter
+        //    drops the candidate when it doesn't apply, so this is always safe.
+        const haveLan = getPhysicalLanAddresses().some((ip) => isPrivateAddress(ip) && !isCgnatAddress(ip));
+        if (haveLan) {
+            for (const [friendId, session] of this.#friendSessions.entries()) {
+                if (!session.established)
+                    continue;
+                // Release a stale LAN lock. If we're locked onto a LAN host but the
+                // direct UDP path has gone quiet (peer left the LAN / changed network),
+                // the lock would otherwise block recovery onto the public/relay path.
+                // Clearing it lets the hot-path guard adopt a working endpoint again.
+                if (session.lanRemoteHost &&
+                    session.remote?.host === session.lanRemoteHost &&
+                    session.lastUdpRecvMs !== undefined &&
+                    Date.now() - session.lastUdpRecvMs > LAN_LOCK_STALE_MS) {
+                    this.#debugLog(`lan_lock_released friend=${friendId} host=${session.lanRemoteHost} (no direct UDP recv for >${LAN_LOCK_STALE_MS}ms)`);
+                    session.lanRemoteHost = undefined;
+                }
+                const r = session.remote;
+                const remoteIsSameLan = !!r && isPrivateAddress(r.host) && !isCgnatAddress(r.host) &&
+                    getPhysicalLanSubnets().some((s) => isInIpv4Subnet(r.host, s));
+                if (remoteIsSameLan) {
+                    // Already on a physical-LAN path (e.g. the session established directly
+                    // over LAN). Lock it so the per-packet hot path's cheap string-compare
+                    // guard refuses any later public/hairpin downgrade — no syscall there.
+                    session.lanRemoteHost = r.host;
+                }
+                if (!remoteIsSameLan) {
+                    // If we ALREADY hold a same-LAN candidate for this peer (learned from
+                    // an earlier offer), switch the session onto it NOW — don't wait to
+                    // receive yet another offer at exactly the right moment. That delay is
+                    // what kept sessions stuck on the public/Tailscale-hairpin path after
+                    // the staggered restarts. Then send a keepalive over the LAN so the
+                    // peer learns our LAN source and replies over it; the downgrade guard
+                    // keeps us there once it sticks.
+                    const lanCand = (session.endpointCandidates ?? []).find((c) => isPrivateAddress(c.host) && !isCgnatAddress(c.host) &&
+                        getPhysicalLanSubnets().some((s) => isInIpv4Subnet(c.host, s)));
+                    if (lanCand) {
+                        session.remote = { host: lanCand.host, port: lanCand.port };
+                        session.lanRemoteHost = lanCand.host;
+                        void this.#sendMessengerPacket(friendId, PACKET_ID_ALIVE, new Uint8Array()).catch(() => undefined);
+                    }
+                    void this.#sendUdpEndpointOffer(friendId).catch(() => undefined);
+                }
+            }
+        }
     }
     /**
      * Send an onion DHT-PK announcement to a friend so they learn our DHT
@@ -4899,7 +5059,15 @@ function isInIpv4Subnet(host, subnet) {
 // path onto the overlay or loops into our own mesh, then silently falls back to
 // the relay — the snoopy/lili "lastUdpRecv=never -> bufferbloat" path. (lili
 // runs Tailscale; that's exactly this.)
-const VIRTUAL_IFACE_RE = /^(utun|tun|tap|wg|tailscale|zt|ham|agentnet|awdl|llw|gif|stf|bridge|vnic|vmnet|veth|docker)/i;
+// Names of interfaces that are NOT a real physical LAN — overlays (tailscale,
+// zerotier, wireguard, the agentnet TUN), and especially container/VM bridges.
+// Docker creates `docker0` AND per-network `br-<hash>` bridges (172.x); libvirt
+// `virbr0`; k8s `cni0`/`flannel`/`kube`. These were leaking their 172.x address
+// into the LAN host-candidate offer, so a peer on a real 10.x LAN advertised a
+// Docker-bridge IP its LAN partner could never match → LAN-direct never engaged
+// (observed: two boxes on one 10.0.0.0/24 stuck hairpinning through the public
+// internet). `^bridge` did NOT cover `br-…`.
+const VIRTUAL_IFACE_RE = /^(utun|tun|tap|wg|tailscale|zt|ham|agentnet|awdl|llw|gif|stf|bridge|br-|virbr|cni|flannel|weave|kube|vnet|vnic|vmnet|veth|docker)/i;
 /** True for RFC 6598 carrier-grade-NAT space 100.64.0.0/10 (Tailscale's range). */
 function isCgnatAddress(host) {
     const o = host.split(".");
@@ -4911,50 +5079,53 @@ function isCgnatAddress(host) {
 }
 /** Local IPv4 addresses on PHYSICAL interfaces only (excludes overlay/virtual
  *  interfaces by name and the CGNAT range). Used for LAN-direct host candidates. */
-function getPhysicalLanAddresses() {
-    const out = [];
+// CACHED interface enumeration. getPhysicalLanSubnets/Addresses are called on
+// the receive hot path (the same-LAN downgrade guard runs per packet); calling
+// networkInterfaces() — a syscall — for every CRYPTO_DATA packet pegged the CPU
+// on a high-rate stream (CCTV jitter/instability). Cache the result for 5s; LAN
+// interfaces almost never change, so this is safe and ~free.
+let _lanIfaceCacheMs = 0;
+let _lanAddrsCache = [];
+let _lanSubnetsCache = [];
+function refreshLanIfaceCache() {
+    const now = Date.now();
+    if (_lanIfaceCacheMs !== 0 && now - _lanIfaceCacheMs < 5000)
+        return;
+    _lanIfaceCacheMs = now;
+    const addrs = [];
+    const subnets = [];
     try {
         for (const [name, list] of Object.entries(networkInterfaces())) {
             if (!list || VIRTUAL_IFACE_RE.test(name))
                 continue;
             for (const info of list) {
-                if (info.family !== "IPv4" || info.internal)
-                    continue;
-                if (isCgnatAddress(info.address))
+                if (info.family !== "IPv4" || info.internal || isCgnatAddress(info.address))
                     continue;
-                out.push(info.address);
+                addrs.push(info.address);
+                const addr = ipv4ToInt(info.address);
+                const mask = netmaskToInt(info.netmask);
+                if (addr !== undefined && mask !== undefined && mask !== 0) {
+                    subnets.push({ networkBits: (addr & mask) >>> 0, maskBits: mask });
+                }
             }
         }
     }
     catch {
         // best-effort
     }
-    return out;
+    _lanAddrsCache = addrs;
+    _lanSubnetsCache = subnets;
+}
+function getPhysicalLanAddresses() {
+    refreshLanIfaceCache();
+    return _lanAddrsCache;
 }
 /** Subnets of PHYSICAL interfaces only — for matching a peer's host candidate
  *  to OUR real LAN (so we never match a peer's Tailscale/TUN address against our
- *  own overlay subnet). */
+ *  own overlay subnet). Cached (see refreshLanIfaceCache). */
 function getPhysicalLanSubnets() {
-    const out = [];
-    try {
-        for (const [name, list] of Object.entries(networkInterfaces())) {
-            if (!list || VIRTUAL_IFACE_RE.test(name))
-                continue;
-            for (const info of list) {
-                if (info.family !== "IPv4" || info.internal || isCgnatAddress(info.address))
-                    continue;
-                const addr = ipv4ToInt(info.address);
-                const mask = netmaskToInt(info.netmask);
-                if (addr === undefined || mask === undefined || mask === 0)
-                    continue;
-                out.push({ networkBits: (addr & mask) >>> 0, maskBits: mask });
-            }
-        }
-    }
-    catch {
-        // best-effort
-    }
-    return out;
+    refreshLanIfaceCache();
+    return _lanSubnetsCache;
 }
 function isPrivateAddress(host) {
     // RFC1918 IPv4: 10/8, 172.16/12, 192.168/16; loopback 127/8;

package/package.json

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