@decentnetwork/peer 0.1.54 → 0.1.56

package/dist/compat/filetransfer.js

@@ -138,7 +138,7 @@ export class FileTransferManager {
         const req = encodeFileSendRequest(fileNumber, opts.kind ?? FILEKIND.DATA, BigInt(data.length), fileId, opts.name);
         const st = {
             fileNumber, fileId, name: opts.name, data, size: data.length,
-            acked: 0, highestSent: 0, started: false, req, startMs: nowMs(),
+            acked: 0, nextSend: 0, pumping: false, started: false, req, startMs: nowMs(),
             lastProgressAcked: 0, lastAckAdvanceMs: nowMs(), lastResendMs: 0,
         };
         this.#map(this.#sending, friendId).set(fileNumber, st);
@@ -369,23 +369,27 @@ export class FileTransferManager {
             }
         }
         else if (maxRecv > st.acked + MAX_FILE_DATA_SIZE && nowMs() - st.lastResendMs >= FAST_RT_MIN_MS) {
-            // Duplicate ack WITH a gap → the chunk at `acked` was lost. Fast-retransmit
-            // the hole region immediately (rate-limited to ~1 RTT so a burst of
-            // dup-acks for one loss doesn't storm). No window backoff: file-path loss
-            // is treated as random, not congestion.
+            // Duplicate ack WITH a gap → the chunk at `acked` was lost. Rewind the send
+            // cursor to the ack point so the loop re-sends the hole (rate-limited to
+            // ~1 RTT so dup-ack bursts for one loss don't storm). No window backoff:
+            // file-path loss is treated as random, not congestion.
             st.lastResendMs = nowMs();
-            this.#resendRange(friendId, st, st.acked, maxRecv);
+            if (st.nextSend > st.acked)
+                st.nextSend = st.acked;
         }
         if (st.acked >= st.size) {
             this.#completeSend(friendId, st);
             return;
         }
-        this.#pump(friendId, st); // send new data
+        void this.#pump(friendId, st);
     }
-    #pump(friendId, st) {
-        // Watchdog: if the ack hasn't advanced within WATCHDOG_MS, a chunk (or the
-        // fast-retransmit) was lost → go-back-N resend from the ack point. Backstop
-        // to the dup-ack fast-retransmit above.
+    // Single send loop. Awaits each send so net_crypto / the UDP socket applies
+    // backpressure (fire-and-forget blasted the whole window into the macOS UDP
+    // buffer at once → systematic overflow/drops the retransmit couldn't dig out
+    // of → a big file "failed"). Sends from `nextSend`, which the ack handler and
+    // watchdog rewind to `acked` to retransmit a hole (go-back-N). The fixed
+    // window bounds in-flight bytes; throughput self-clocks to the path.
+    async #pump(friendId, st) {
         if (!st.timer) {
             let stalledSinceMs = nowMs();
             st.timer = setInterval(() => {
@@ -408,44 +412,36 @@ export class FileTransferManager {
                     return;
                 }
                 st.lastAckAdvanceMs = nowMs();
-                st.highestSent = st.acked; // go-back-N: re-send from the ack point
                 st.lastResendMs = nowMs();
-                this.#pumpFrom(friendId, st, st.acked);
+                if (st.nextSend > st.acked)
+                    st.nextSend = st.acked; // go-back-N
+                void this.#pump(friendId, st);
             }, WATCHDOG_MS);
             if (typeof st.timer.unref === "function")
                 st.timer.unref();
         }
-        // Send only NEW data, from the high-water mark up to the fixed window edge.
-        this.#pumpFrom(friendId, st, Math.max(st.acked, st.highestSent));
-    }
-    // Fire chunks from `from` up to the window edge. Fire-and-forget: the fixed
-    // window bounds in-flight bytes and the 4 MB socket buffer absorbs the burst,
-    // so we don't serialize on a per-chunk await (which capped throughput at one
-    // chunk per event-loop turn → minutes for a big file).
-    #pumpFrom(friendId, st, from) {
-        const windowEnd = Math.min(st.acked + WINDOW_CHUNKS * MAX_FILE_DATA_SIZE, st.size);
-        let off = from;
-        while (off < windowEnd) {
-            if (!this.#map(this.#sending, friendId).has(st.fileNumber))
-                return; // cancelled
-            const end = Math.min(off + MAX_FILE_DATA_SIZE, st.size);
-            void this.send(friendId, PACKET_ID_FILE_DATA, encodeFileData(st.fileNumber, off, st.data.subarray(off, end))).catch(() => undefined);
-            off = end;
+        if (st.pumping)
+            return;
+        st.pumping = true;
+        try {
+            while (this.#map(this.#sending, friendId).has(st.fileNumber) && st.acked < st.size) {
+                const windowEnd = Math.min(st.acked + WINDOW_CHUNKS * MAX_FILE_DATA_SIZE, st.size);
+                if (st.nextSend >= windowEnd)
+                    break; // window full / all sent — wait for acks
+                const off = st.nextSend;
+                const end = Math.min(off + MAX_FILE_DATA_SIZE, st.size);
+                try {
+                    await this.send(friendId, PACKET_ID_FILE_DATA, encodeFileData(st.fileNumber, off, st.data.subarray(off, end)));
+                }
+                catch {
+                    break; // transport down; the watchdog re-kicks
+                }
+                if (st.nextSend === off)
+                    st.nextSend = end; // unless a rewind moved it
+            }
         }
-        if (off > st.highestSent)
-            st.highestSent = off;
-    }
-    // Re-send the chunks in [from, to) — the gap region the receiver is missing.
-    // Already-received chunks are idempotent (placed by offset on the receiver).
-    #resendRange(friendId, st, from, to) {
-        let off = from;
-        const end0 = Math.min(to, st.size);
-        while (off < end0) {
-            if (!this.#map(this.#sending, friendId).has(st.fileNumber))
-                return;
-            const end = Math.min(off + MAX_FILE_DATA_SIZE, st.size);
-            void this.send(friendId, PACKET_ID_FILE_DATA, encodeFileData(st.fileNumber, off, st.data.subarray(off, end))).catch(() => undefined);
-            off = end;
+        finally {
+            st.pumping = false;
         }
     }
     #completeSend(friendId, st) {

package/dist/peer.js

@@ -1470,13 +1470,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);
                 }
             }
@@ -3961,6 +3969,25 @@ 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;
+                const r = session.remote;
+                const remoteIsSameLan = !!r && isPrivateAddress(r.host) && !isCgnatAddress(r.host) &&
+                    getPhysicalLanSubnets().some((s) => isInIpv4Subnet(r.host, s));
+                if (!remoteIsSameLan)
+                    void this.#sendUdpEndpointOffer(friendId).catch(() => undefined);
+            }
+        }
     }
     /**
      * Send an onion DHT-PK announcement to a friend so they learn our DHT

package/package.json

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