@decentnetwork/peer 0.1.109 → 0.1.111

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,
@@ -783,12 +785,14 @@ export class FileTransferManager {
                 // One paced round completed (the timed frontier byte's ack landed).
                 const rtt = nowT - st.probeSentMs;
                 st.probeOffset = -1;
+                const pathKindAtProbe = this.pathKind(friendId);
                 // A single very-low sample can be a batched/late ACK that makes a probe
                 // look newer than it is. But several consecutive low samples mean the
-                // path genuinely improved (most importantly tcp-relay → LAN UDP). The
-                // old code rejected every such sample against the permanently-high srtt,
-                // so startup stayed pinned near 120 KB/s forever. Promote a stable lower
-                // RTT after three samples and rebase srtt/RTprop to the new path.
+                // path genuinely improved when we are moving onto a validated LAN path.
+                // Do NOT do this on public UDP-direct: cross-border ACK compression can
+                // produce several falsely-low samples, and rebasing RTprop there shrinks
+                // the BDP window to the floor, collapsing a good remote transfer to
+                // tens of KB/s.
                 const lowSample = st.srttMs > 0 && rtt > 0 && rtt < st.srttMs * 0.4;
                 if (lowSample) {
                     st.lowRttCount++;
@@ -798,7 +802,7 @@ export class FileTransferManager {
                     st.lowRttCount = 0;
                     st.lowRttMinMs = Infinity;
                 }
-                const promoteLowPath = lowSample && st.lowRttCount >= 3;
+                const promoteLowPath = pathKindAtProbe === "lan" && lowSample && st.lowRttCount >= 3;
                 const acceptedRtt = promoteLowPath ? st.lowRttMinMs : rtt;
                 if (promoteLowPath) {
                     st.srttMs = acceptedRtt;
@@ -821,7 +825,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 = pathKindAtProbe;
+                        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 +867,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 —
@@ -961,6 +998,7 @@ export class FileTransferManager {
                         ` pace=${Math.round(st.paceRateBps)}Bps bw=${Math.round(st.btlBwBps)}Bps` +
                         ` cwnd=${st.cwnd} phase=${st.bbrPhase} slow=${st.fullBwRounds}` +
                         ` loss=${(st.lossEwma * 100).toFixed(1)}% rounds=${st.roundCount}` +
+                        ` path=${pathKindAtProbe}` +
                         ` lanNow=${st.dbgLanNow} lanPath=${st.lanPath ? 1 : 0}` +
                         ` sampleMs=${st.dbgSampleMs} roundRate=${st.dbgRoundRate}` +
                         ` measuredRate=${st.dbgMeasuredRate} rawQueue=${st.dbgRawQueue}` +

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();
@@ -4012,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
@@ -4030,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);
@@ -4041,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.109",
+  "version": "0.1.111",
   "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",