@decentnetwork/peer 0.1.101 → 0.1.104

package/dist/compat/filetransfer.js

@@ -96,6 +96,14 @@ const PACE_CYCLE_GAINS = [1.25, 0.8, 1, 1, 1, 1, 1, 1]; // steady PROBE_BW cycle
 const PACE_BW_WINDOW = 10; // rounds of delivered-rate history for the max-filter
 const PACE_SAMPLE_MS = 200; // aggregate ACKs so one scheduler-jittered packet is not a "round"
 const PACE_INIT_BPS = 120_000; // initial pace rate (~120 KB/s) before any bandwidth estimate
+// A subnet-validated endpoint is not an unknown Internet/relay path. Starting
+// it at 120 KB/s made a Windows ACK-scheduling wobble terminate STARTUP before
+// the controller had ever offered meaningful LAN load; transfers then stayed
+// around 200-500 KB/s despite a multi-MB/s physical path. 2 MB/s is a starting
+// probe, not a cap: the normal feedback loop can grow above it or immediately
+// drain below it on real loss/queueing. The 20 ms pacer limits the initial burst
+// to ~40 KB, so this does not recreate the old 1 MB window blast.
+const LAN_PACE_INIT_BPS = 2_000_000;
 const PACE_BURST_MS = 20; // token-bucket burst allowance (keeps sends smooth, not bunched)
 // A LAN receiver can coalesce a backlog of ACKs after its event loop wakes. The
 // resulting delivery sample is ACK rate, not link capacity: in practice a
@@ -111,7 +119,11 @@ const LAN_STARTUP_QUEUE_MS = 500; // unmistakable raw queue spike; smaller app-l
 const LAN_STARTUP_HARD_QUEUE_MS = 2000; // one multi-second queue sample is unsafe
 const LAN_STARTUP_QUEUE_ROUNDS = 2; // tolerate one scheduler/session-handover outlier on LAN
 const LAN_STARTUP_KEEPUP = 0.70; // delivered goodput below 70% of pace means the receiver is no longer keeping up
-const LAN_STARTUP_SLOW_ROUNDS = 5; // require sustained saturation across Windows scheduler/ACK jitter
+// Five 200 ms samples was still only about one Windows ACK scheduling cycle in
+// practice: a clean LAN (0% loss) exited STARTUP after ~3 MB and threw away a
+// healthy 2.3 MB/s probe. Require a few seconds of sustained under-delivery;
+// the independent queue/loss brakes still react immediately to a real overload.
+const LAN_STARTUP_SLOW_ROUNDS = 15;
 // FILE ACKs are coalesced and handled by the remote JS event loop. On Windows
 // the effective ACK clock is commonly 20–120 ms even when an occasional probe
 // reports a 7 ms network RTT. Sizing cwnd from that lucky minimum made a
@@ -119,6 +131,7 @@ const LAN_STARTUP_SLOW_ROUNDS = 5; // require sustained saturation across Window
 // and falsely ended startup. Pacing remains the primary throttle, so this floor
 // only prevents the safety window from starving a validated LAN flow.
 const LAN_BDP_RTT_FLOOR_MS = 50;
+const LAN_CWND_INIT_CHUNKS = Math.ceil((LAN_PACE_INIT_BPS * (LAN_BDP_RTT_FLOOR_MS / 1000) * 2) / MAX_FILE_DATA_SIZE);
 const WATCHDOG_MS = 150; // stall poll cadence / base no-progress patience
 const WATCHDOG_MAX_MS = 8000; // cap the RTT-adaptive stall patience (must exceed a slow path's RTT so acks aren't mistaken for a stall)
 const FAST_RT_MIN_MS = 40; // min gap between fast-retransmits of the same hole (≈1 RTT)
@@ -245,16 +258,19 @@ export class FileTransferManager {
             ? new Uint8Array(createHash("sha256").update(data).digest()).slice(0, FILE_ID_LENGTH)
             : randomBytes(FILE_ID_LENGTH);
         const req = encodeFileSendRequest(fileNumber, opts.kind ?? FILEKIND.DATA, BigInt(data.length), fileId, opts.name);
+        const lanPath = this.isLanPath(friendId);
         const st = {
             fileNumber, fileId, name: opts.name, data, size: data.length,
             acked: 0, nextSend: 0, pumping: false, started: false, req, startMs: nowMs(),
             lastProgressAcked: 0, lastAckAdvanceMs: nowMs(), lastResendMs: 0,
-            cwnd: CWND_INIT_CHUNKS, stalls: 0, parityHighBlock: -1, lastLossMs: 0, lossEwma: 0,
+            cwnd: lanPath ? LAN_CWND_INIT_CHUNKS : CWND_INIT_CHUNKS,
+            stalls: 0, parityHighBlock: -1, lastLossMs: 0, lossEwma: 0,
             minRttMs: Infinity, srttMs: 0, probeOffset: -1, probeSentMs: 0,
-            paceRateBps: PACE_INIT_BPS, paceTokens: 0, lastPaceMs: nowMs(),
+            paceRateBps: lanPath ? LAN_PACE_INIT_BPS : PACE_INIT_BPS,
+            paceTokens: 0, lastPaceMs: nowMs(),
             btlBwBps: 0, bwSamples: [], fullBwRounds: 0, startupQueueRounds: 0, bbrPhase: 0, roundCount: 0,
             rateMarkMs: nowMs(), rateMarkAcked: 0, lowRttCount: 0, lowRttMinMs: Infinity, lastCcLogMs: 0,
-            lanPath: this.isLanPath(friendId),
+            lanPath,
         };
         this.#map(this.#sending, friendId).set(fileNumber, st);
         void this.send(friendId, PACKET_ID_FILE_SENDREQUEST, req).catch(() => undefined);
@@ -786,10 +802,15 @@ export class FileTransferManager {
                         const lossMult = lanNow ? 1 : 1 / (1 - Math.min(0.5, st.lossEwma));
                         if (lanNow && !st.lanPath) {
                             // A transfer can begin on relay and then promote to a validated
-                            // physical-LAN endpoint. Restart STARTUP from the measured rate.
+                            // physical-LAN endpoint. Relay samples must not pin the new LAN
+                            // path near 120 KB/s: discard them and begin a safe LAN probe.
                             st.bbrPhase = 0;
                             st.fullBwRounds = 0;
                             st.startupQueueRounds = 0;
+                            st.bwSamples = [];
+                            st.btlBwBps = 0;
+                            st.paceRateBps = Math.max(st.paceRateBps, LAN_PACE_INIT_BPS);
+                            st.cwnd = Math.max(st.cwnd, LAN_CWND_INIT_CHUNKS);
                         }
                         st.lanPath = lanNow;
                         if (!lanNow) {

package/dist/peer.js

@@ -210,8 +210,22 @@ const RECV_REQUEST_MIN_INTERVAL_MS = 200;
 export class Peer {
     #opts;
     #events = new EventEmitter();
+    /** While negotiating a non-LAN file, temporarily stop sending this friend
+     *  UDP control traffic. Peer <=0.1.94 routes FILE_CONTROL UDP-only whenever
+     *  it has seen recent inbound UDP, even when that public/NAT path is one-way.
+     *  Repeated relay-only offers let that 4s freshness expire, after which the
+     *  old peer returns ACCEPT/ACK over its reliable TCP relay. */
+    #fileRelayNegotiationUntil = new Map();
     // Toxcore-standard file transfer (wire-compatible with native Carrier/toxcore).
-    #fileTransfer = new FileTransferManager((friendId, packetId, payload) => this.#sendMessengerPacket(friendId, packetId, payload), (event, payload) => { this.#events.emit(event, payload); }, (friendId) => {
+    #fileTransfer = new FileTransferManager((friendId, packetId, payload) => {
+        if (packetId === PACKET_ID_FILE_SENDREQUEST) {
+            const session = this.#friendSessions.get(friendId);
+            const lan = !!session?.lanRemoteHost && session.remote?.host === session.lanRemoteHost;
+            if (!lan)
+                this.#fileRelayNegotiationUntil.set(friendId, Date.now() + 6_000);
+        }
+        return this.#sendMessengerPacket(friendId, packetId, payload);
+    }, (event, payload) => { this.#events.emit(event, payload); }, (friendId) => {
         const session = this.#friendSessions.get(friendId);
         return !!session?.lanRemoteHost && session.remote?.host === session.lanRemoteHost;
     });
@@ -604,6 +618,7 @@ export class Peer {
             clearTimeout(timer);
         this.#profileRetryTimers.clear();
         this.#profileRetryAttempts.clear();
+        this.#fileRelayNegotiationUntil.clear();
         if (this.#expressPollTimer) {
             clearInterval(this.#expressPollTimer);
             this.#expressPollTimer = undefined;
@@ -980,6 +995,7 @@ export class Peer {
         }
         const existed = this.#friends.delete(friendId);
         this.#friendSessions.delete(friendId);
+        this.#fileRelayNegotiationUntil.delete(friendId);
         this.#pendingFriendRequests.delete(friendId);
         this.#cookieRetryCount.delete(friendId);
         this.#lastCookieSentKey.delete(friendId);
@@ -3345,6 +3361,11 @@ export class Peer {
      *  buffered packets through the exact same dispatch. `kind` is the first
      *  payload byte (never undefined here — the caller defaults it). */
     #deliverLosslessPayload(friendId, state, kind, inner, remote, packetNumber = 0) {
+        // Any file response proves the receiver can hear this session. Release the
+        // old-peer relay-only negotiation guard before the data pump chooses its
+        // normal LAN/reliable-public path.
+        if (kind === PACKET_ID_FILE_CONTROL)
+            this.#fileRelayNegotiationUntil.delete(friendId);
         // Toxcore file transfer (FILE_SENDREQUEST/CONTROL/DATA = 80/81/82).
         if (this.#fileTransfer.handlePacket(friendId, kind, inner))
             return;
@@ -3964,6 +3985,8 @@ export class Peer {
         const udpFresh = !!realUdpRemote &&
             s?.lastUdpRecvMs !== undefined &&
             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
@@ -3980,7 +4003,8 @@ export class Peer {
         // lastUdpRecvMs). This converts a multi-second blackout into a few
         // seconds of higher relay latency. Control packets always probe UDP
         // (to keep the NAT mapping warm) so we still try UDP for them.
-        const tryUdp = realUdpRemote &&
+        const tryUdp = !forceFileRelay &&
+            realUdpRemote &&
             (isBulkData ? udpFresh && fileUdpOnlyConfirmed : true);
         if (tryUdp && s?.remote) {
             try {

package/package.json

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