@decentnetwork/peer 0.1.100 → 0.1.103

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

@@ -430,7 +430,7 @@ export class Peer {
             });
         }
         this.#udp.on("datagram", this.#onDatagram);
-        await this.#udp.start();
+        await this.#udp.start({ port: this.#opts.udpPort });
         // Spin up the TCP relay pool. We pass the same bootstrap node list
         // we already have — every Carrier bootstrap is also a TCP relay
         // server on the same pubkey. The pool opens up to 3 connections in

package/dist/types/peer.d.ts

@@ -25,6 +25,12 @@ export type NetworkNode = {
 };
 export type PeerOptions = {
     keyFile: string;
+    /**
+     * Stable UDP listen port. Long-lived service peers (Dora registries,
+     * relays/exits) should set this so friends' cached DHT endpoints remain
+     * usable across process restarts. Omit or set 0 for an ephemeral port.
+     */
+    udpPort?: number;
     friendStoreFile?: string;
     bootstrapNodes: NetworkNode[];
     expressNodes?: NetworkNode[];

package/package.json

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