@decentnetwork/peer 0.1.108 → 0.1.110

package/dist/compat/filetransfer.d.ts

@@ -41,12 +41,15 @@ export declare function parseFileData(p: Uint8Array): {
 export type FtSend = (friendId: string, packetId: number, payload: Uint8Array) => Promise<unknown>;
 export type FtEmit = (event: string, payload: Record<string, unknown>) => void;
 export type FtIsLanPath = (friendId: string) => boolean;
+export type FtPathKind = "lan" | "udp-direct" | "relay";
+export type FtPathKindFn = (friendId: string) => FtPathKind;
 export declare class FileTransferManager {
     #private;
     private readonly send;
     private readonly emit;
     private readonly isLanPath;
-    constructor(send: FtSend, emit: FtEmit, isLanPath?: FtIsLanPath);
+    private readonly pathKind;
+    constructor(send: FtSend, emit: FtEmit, isLanPath?: FtIsLanPath, pathKind?: FtPathKindFn);
     /** Enable resumable receives: partials are persisted under `dir` and matched
      *  on re-offer by content-hash fileId. Unset = in-memory only (no resume). */
     setResumeDir(dir: string): void;

package/dist/compat/filetransfer.js

@@ -209,15 +209,17 @@ export class FileTransferManager {
     send;
     emit;
     isLanPath;
+    pathKind;
     #sending = new Map();
     #receiving = new Map();
     // When set, incoming transfers persist their contiguous prefix here so a
     // dropped/restarted transfer resumes instead of restarting (断点续传).
     #resumeDir;
-    constructor(send, emit, isLanPath = () => false) {
+    constructor(send, emit, isLanPath = () => false, pathKind = (friendId) => (this.isLanPath(friendId) ? "lan" : "relay")) {
         this.send = send;
         this.emit = emit;
         this.isLanPath = isLanPath;
+        this.pathKind = pathKind;
     }
     /** Enable resumable receives: partials are persisted under `dir` and matched
      *  on re-offer by content-hash fileId. Unset = in-memory only (no resume). */
@@ -279,7 +281,7 @@ export class FileTransferManager {
             minRttMs: Infinity, srttMs: 0, probeOffset: -1, probeSentMs: 0,
             paceRateBps: lanPath ? LAN_PACE_INIT_BPS : PACE_INIT_BPS,
             paceTokens: 0, lastPaceMs: nowMs(),
-            btlBwBps: 0, bwSamples: [], fullBwRounds: 0, startupQueueRounds: 0, bbrPhase: 0, roundCount: 0,
+            btlBwBps: 0, bwSamples: [], fullBwBps: 0, 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,
@@ -821,7 +823,9 @@ export class FileTransferManager {
                         const roundRate = ((st.acked - st.rateMarkAcked) * 1000) / sampleMs;
                         st.rateMarkMs = nowT;
                         st.rateMarkAcked = st.acked;
-                        const lanNow = this.isLanPath(friendId);
+                        const pathKind = this.pathKind(friendId);
+                        const lanNow = pathKind === "lan";
+                        const udpDirectNow = pathKind === "udp-direct";
                         // On a paced LAN flow, sustainable delivery cannot suddenly be
                         // many times faster than the bytes we are putting on the wire.
                         // Such a sample is delayed/coalesced ACKs draining, not new
@@ -861,15 +865,46 @@ export class FileTransferManager {
                         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
+                        if (!lanNow && !udpDirectNow) {
+                            // TCP-relay-only file traffic must remain conservative. A short
                             // ACK burst can wildly overstate bandwidth there; allowing LAN's
                             // exponential STARTUP filled the TCP relay with an 8.7 s queue.
-                            // This affects only file DATA/FEC — IP/video has its own path.
+                            // A confirmed public UDP-direct path is different: it is the old
+                            // long-haul file path with FEC and BBR-style pacing, so do not
+                            // pin it to 120-240 KB/s.
                             st.bbrPhase = 2;
                             const gain = PACE_CYCLE_GAINS[st.roundCount % PACE_CYCLE_GAINS.length];
                             st.paceRateBps = Math.max(PACE_INIT_BPS, Math.min(PACE_INIT_BPS * 2, st.btlBwBps * gain * lossMult));
                         }
+                        else if (udpDirectNow) {
+                            // Public UDP direct: restore the pre-LAN-regression remote path.
+                            // It keeps FEC loss compensation and paced BBR startup/probe, but
+                            // does NOT use LAN's aggressive 2 MB/s initial probe or ACK-burst
+                            // sample cap. Queue growth still exits STARTUP quickly, so this
+                            // does not recreate the deep TCP-relay bufferbloat issue.
+                            if (st.bbrPhase === 0) {
+                                if (st.fullBwBps === 0 || st.btlBwBps >= st.fullBwBps * 1.20) {
+                                    st.fullBwBps = st.btlBwBps;
+                                    st.fullBwRounds = 0;
+                                }
+                                else {
+                                    st.fullBwRounds++;
+                                }
+                                if (st.fullBwRounds >= 3 || rawQueue > 350) {
+                                    st.bbrPhase = 2;
+                                }
+                                if (st.bbrPhase === 0) {
+                                    st.paceRateBps = Math.max(st.paceRateBps * 1.4, st.btlBwBps * 2.0 * lossMult);
+                                }
+                                else {
+                                    st.paceRateBps = Math.max(PACE_INIT_BPS * 0.5, st.btlBwBps * lossMult);
+                                }
+                            }
+                            else {
+                                const gain = PACE_CYCLE_GAINS[st.roundCount % PACE_CYCLE_GAINS.length];
+                                st.paceRateBps = Math.max(PACE_INIT_BPS * 0.5, st.btlBwBps * gain * lossMult);
+                            }
+                        }
                         else if (st.bbrPhase === 0) {
                             // BBR full-bandwidth detection: remain in STARTUP while delivered
                             // bandwidth grows. A relative RTT threshold is unusable on LAN —

package/dist/peer.js

@@ -230,6 +230,16 @@ export class Peer {
     }, (event, payload) => { this.#events.emit(event, payload); }, (friendId) => {
         const session = this.#friendSessions.get(friendId);
         return !!session?.lanRemoteHost && session.remote?.host === session.lanRemoteHost;
+    }, (friendId) => {
+        const session = this.#friendSessions.get(friendId);
+        const realUdpRemote = session?.remote && !session.remote.host?.startsWith("tcp:") && session.remote.port !== 0;
+        if (realUdpRemote && session.lanRemoteHost && session.remote?.host === session.lanRemoteHost)
+            return "lan";
+        if (realUdpRemote &&
+            session.lastUdpRecvMs !== undefined &&
+            Date.now() - session.lastUdpRecvMs < 4_000)
+            return "udp-direct";
+        return "relay";
     });
     #keyPair;
     #udp = new UdpTransport();
@@ -2169,17 +2179,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).
+                    // A successfully decrypted packet arriving from a private address is
+                    // stronger proof than an endpoint hint: it demonstrates that this
+                    // exact host:port already reaches us. Do not require the address to be
+                    // in one of this process' physical subnets. WSL commonly has only a
+                    // 172.16/12 vNIC while the real LAN peer is 10.0.0.x via the Windows
+                    // host NAT; direct UDP is confirmed, but a strict same-subnet check
+                    // leaves file transfer on the conservative public/relay pacer.
+                    //
+                    // Unverified private candidates still require same-subnet matching at
+                    // candidate-learn time. This relaxed lock is only for decrypted UDP,
+                    // so it cannot promote a spoofed or merely advertised private host.
                     if (!state.lanRemoteHost &&
                         isPrivateAddress(remote.address) &&
                         !isCgnatAddress(remote.address) &&
-                        getPhysicalLanSubnets().some((s) => isInIpv4Subnet(remote.address, s))) {
+                        !this.#isUnroutableSelfSource(remote.address, remote.port)) {
                         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)`);
@@ -4008,15 +4022,16 @@ export class Peer {
             Date.now() - s.lastUdpRecvMs < 4_000;
         const forceFileRelay = (this.#fileRelayNegotiationUntil.get(friendId) ?? 0) > Date.now() &&
             !(s?.lanRemoteHost && s.remote?.host === s.lanRemoteHost);
-        // A freshly-received UDP packet proves only the peer -> us direction.
-        // That is enough for lossy IP/video bulk, whose inner TCP stream can
-        // recover a dropped packet, but not for reliable file data: returning
-        // UDP-only on a one-way public/NAT endpoint silently black-holes every
-        // chunk. A physical-LAN lock is stronger evidence because the candidate
-        // was validated against the local subnet; otherwise file bulk continues
-        // to TURN/TCP below.
-        const fileUdpOnlyConfirmed = !reliableOnRelay ||
-            (!!s?.lanRemoteHost && s.remote?.host === s.lanRemoteHost);
+        // File DATA/FEC is reliable at the file layer: FEC + ACK/retransmit repair
+        // loss. It should use a fresh decrypted UDP-direct path, including public
+        // long-haul peers. A previous LAN fix accidentally required a LAN lock here,
+        // which forced China/US file sends back onto TCP relay and destroyed the
+        // already-tuned remote-transfer path.
+        //
+        // The one-way-public-UDP blackhole is handled by keeping SENDREQUEST/CONTROL
+        // on relay during negotiation (`forceFileRelay`) until a CONTROL packet
+        // proves the receiver is responding. Once `lastUdpRecvMs` is fresh, bulk may
+        // ride UDP only; if it goes stale, we fall back to relay/TCP.
         // Bulk IP data rides the direct path ONLY while it's fresh. When it
         // goes stale (likely a NAT remap mid-stream), we do NOT keep firing
         // into the dead endpoint and we do NOT duplicate onto UDP — we bridge
@@ -4026,7 +4041,7 @@ export class Peer {
         // (to keep the NAT mapping warm) so we still try UDP for them.
         const tryUdp = !forceFileRelay &&
             realUdpRemote &&
-            (isBulkData ? udpFresh && fileUdpOnlyConfirmed : true);
+            (isBulkData ? udpFresh : true);
         if (tryUdp && s?.remote) {
             try {
                 await this.#sendPacket(packet, s.remote);
@@ -4037,8 +4052,9 @@ export class Peer {
             }
         }
         // Fresh confirmed direct path → send over UDP only, but ONLY for bulk.
-        // For files, `tryUdp` above requires the physical-LAN lock; a merely-fresh
-        // public endpoint deliberately falls through to reliable TURN/TCP.
+        // For files this includes public UDP-direct, not only LAN; the file layer
+        // handles loss and retransmit. Sparse control/chat still also go over relay
+        // because inbound UDP freshness alone does not prove outbound reachability.
         //
         // Low-volume traffic (chat 64 + control keepalives / endpoint offers /
         // profile) instead ALSO goes over the relay even when the direct path

package/package.json

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