@decentnetwork/lan 0.1.196 → 0.1.198

package/dist/proxy/hls-prefetch.d.ts

@@ -29,6 +29,14 @@ export declare function capM3u8Variants(playlist: string, maxBandwidth: number):
  * reloading the capped master playlist. The proxy can use this map to fetch the
  * safe media playlist while preserving the browser-facing request URL. */
 export declare function buildM3u8VariantFallbacks(playlist: string, baseUrl: string, maxBandwidth: number): Map<string, string>;
+/** Resolve one HTTP byte-range against a complete cached body. Multiple ranges
+ * are intentionally rejected (the CCTV player uses only a single range). */
+export declare function sliceHttpByteRange(body: Buffer, header: string): {
+    body: Buffer;
+    start: number;
+    end: number;
+    total: number;
+} | null;
 /**
  * Extract the media-segment URLs from an m3u8 playlist, resolved against the
  * playlist's own URL. Returns [] for master playlists (variant lists) — those

package/dist/proxy/hls-prefetch.js

@@ -128,6 +128,31 @@ export function buildM3u8VariantFallbacks(playlist, baseUrl, maxBandwidth) {
     }
     return out;
 }
+/** Resolve one HTTP byte-range against a complete cached body. Multiple ranges
+ * are intentionally rejected (the CCTV player uses only a single range). */
+export function sliceHttpByteRange(body, header) {
+    const match = /^bytes=(\d*)-(\d*)$/i.exec(header.trim());
+    if (!match || (match[1] === "" && match[2] === "") || body.length === 0)
+        return null;
+    const total = body.length;
+    let start;
+    let end;
+    if (match[1] === "") {
+        const suffix = Number(match[2]);
+        if (!Number.isSafeInteger(suffix) || suffix <= 0)
+            return null;
+        start = Math.max(0, total - suffix);
+        end = total - 1;
+    }
+    else {
+        start = Number(match[1]);
+        end = match[2] === "" ? total - 1 : Number(match[2]);
+        if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || start >= total || end < start)
+            return null;
+        end = Math.min(end, total - 1);
+    }
+    return { body: body.subarray(start, end + 1), start, end, total };
+}
 /**
  * Extract the media-segment URLs from an m3u8 playlist, resolved against the
  * playlist's own URL. Returns [] for master playlists (variant lists) — those
@@ -154,6 +179,8 @@ export class HlsPrefetcher {
     #cache = new Map(); // Map preserves insertion order → LRU-ish
     #cacheBytes = 0;
     #inflight = new Map();
+    #background = new Map();
+    #playlistGeneration = 0;
     #liveBufferPrimed = false;
     #fetcher;
     #maxBytes;
@@ -241,7 +268,7 @@ export class HlsPrefetcher {
      *  losing request is aborted immediately so the rescue does not keep splitting
      *  bandwidth after a winner is available. Redemption probes are separate,
      *  forced-exit requests and are never aborted by this path. */
-    #whole(u, extra) {
+    #whole(u, extra, outerSignal) {
         const one = (signal, label) => this.#fetcher(u, { ...extra, host: u.host }, label, signal);
         return new Promise((resolve, reject) => {
             let settled = false;
@@ -250,12 +277,25 @@ export class HlsPrefetcher {
             let timer = null;
             const first = new AbortController();
             let hedge = null;
+            const cleanup = () => outerSignal?.removeEventListener("abort", onOuterAbort);
+            const onOuterAbort = () => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                first.abort();
+                hedge?.abort();
+                cleanup();
+                reject(new Error("aborted"));
+            };
             const win = (winner) => (r) => {
                 if (settled)
                     return;
                 settled = true;
                 if (timer)
                     clearTimeout(timer);
+                cleanup();
                 (winner === first ? hedge : first)?.abort();
                 // Keep the winner alive through resolution; aborting a fully consumed
                 // response would only discard its reusable keep-alive socket.
@@ -273,6 +313,7 @@ export class HlsPrefetcher {
                 }
                 else if (pending === 0) {
                     settled = true;
+                    cleanup();
                     reject(e);
                 }
             };
@@ -284,6 +325,11 @@ export class HlsPrefetcher {
                 pending++;
                 one(hedge.signal, "prefetch-hedge").then(win(hedge), lose);
             };
+            if (outerSignal?.aborted) {
+                onOuterAbort();
+                return;
+            }
+            outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
             one(first.signal, "prefetch").then(win(first), lose);
             timer = setTimeout(() => {
                 timer = null;
@@ -297,7 +343,7 @@ export class HlsPrefetcher {
      *  STRIPE_TRIES exits. Returns null only if every try failed. `exactLen`, when
      *  given, rejects a 206 whose body isn't exactly that long (so assembly is
      *  byte-correct); the probe passes it undefined to accept whatever 206 arrives. */
-    #fetchRange(u, start, end, extra, exactLen, exitHint) {
+    #fetchRange(u, start, end, extra, exactLen, exitHint, outerSignal) {
         return new Promise((resolve) => {
             let settled = false;
             let launched = 0;
@@ -313,11 +359,13 @@ export class HlsPrefetcher {
                     return;
                 settled = true;
                 clearHedge();
+                outerSignal?.removeEventListener("abort", onOuterAbort);
                 for (const ac of controllers)
                     if (ac !== winner)
                         ac.abort();
                 resolve(r);
             };
+            const onOuterAbort = () => finish(null);
             const scheduleHedge = () => {
                 if (settled || launched >= STRIPE_TRIES || hedgeTimer)
                     return;
@@ -362,6 +410,11 @@ export class HlsPrefetcher {
                 if (finished >= launched)
                     finish(null);
             };
+            if (outerSignal?.aborted) {
+                finish(null);
+                return;
+            }
+            outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
             launch();
         });
     }
@@ -369,25 +422,29 @@ export class HlsPrefetcher {
      *  each hedged. Assembles them into the full body with a corrected
      *  content-length. Falls back to one whole fetch if the origin ignores Range or
      *  any stripe truly can't be fetched (correctness over speed). */
-    async #stripeFetch(u, extra) {
+    async #stripeFetch(u, extra, signal) {
+        if (signal?.aborted)
+            throw new Error("aborted");
         const stripeCount = this.#stripeCount();
         // A count of one explicitly disables striping (emergency rollback or an
         // origin/path known not to benefit from parallel range connections).
         if (stripeCount <= 1)
-            return this.#whole(u, extra);
+            return this.#whole(u, extra, signal);
         // Tiny probe (2 bytes): learn the total size + confirm the origin honors
         // Range, cheaply — a big sequential probe would add a whole round-trip of
         // latency before any stripe starts and starve the live buffer.
-        const probe = await this.#fetchRange(u, 0, 1, extra);
+        const probe = await this.#fetchRange(u, 0, 1, extra, undefined, undefined, signal);
+        if (signal?.aborted)
+            throw new Error("aborted");
         if (!probe)
-            return this.#whole(u, extra);
+            return this.#whole(u, extra, signal);
         if (probe.status === 200)
             return probe; // range ignored → whole body already here
         if (probe.status !== 206)
-            return this.#whole(u, extra);
+            return this.#whole(u, extra, signal);
         const total = contentRangeTotal(probe.headers["content-range"]);
         if (!total || total <= 0)
-            return this.#whole(u, extra);
+            return this.#whole(u, extra, signal);
         const headers = { ...probe.headers };
         delete headers["content-range"];
         // Split the WHOLE body into N equal stripes, fetched IN PARALLEL across the
@@ -402,13 +459,15 @@ export class HlsPrefetcher {
             if (start > end)
                 return Promise.resolve(Buffer.alloc(0));
             const want = end - start + 1;
-            return this.#fetchRange(u, start, end, extra, want, i).then((r) => (r && r.body.length === want ? r.body : null));
+            return this.#fetchRange(u, start, end, extra, want, i, signal).then((r) => (r && r.body.length === want ? r.body : null));
         }));
+        if (signal?.aborted)
+            throw new Error("aborted");
         if (parts.some((p) => p === null))
-            return this.#whole(u, extra); // a stripe couldn't be fetched → whole for integrity
+            return this.#whole(u, extra, signal); // a stripe couldn't be fetched → whole for integrity
         const body = Buffer.concat(parts);
         if (body.length !== total)
-            return this.#whole(u, extra);
+            return this.#whole(u, extra, signal);
         headers["content-length"] = String(body.length);
         return { status: 200, headers, body };
     }
@@ -498,12 +557,35 @@ export class HlsPrefetcher {
         const segs = parseM3u8Segments(body, playlistUrl);
         if (segs.length === 0)
             return;
+        const generation = ++this.#playlistGeneration;
         // For a live playlist the tail is "upcoming"; for VOD the player walks the
         // list from wherever it is, and refetches of the playlist don't happen —
         // prefetching the head of the list still fills the startup buffer. Either
         // way: take the last `ahead` entries we don't already hold.
+        const tail = segs.slice(-this.#ahead);
+        const wanted = new Set(tail);
+        const cancelled = [];
+        for (const [url, controller] of this.#background) {
+            if (wanted.has(url))
+                continue;
+            controller.abort();
+            this.#background.delete(url);
+            const p = this.#inflight.get(url);
+            if (p)
+                cancelled.push(p);
+        }
+        if (cancelled.length > 0) {
+            void Promise.allSettled(cancelled).then(() => {
+                if (this.#playlistGeneration === generation)
+                    this.#schedulePrefetch(tail);
+            });
+            return;
+        }
+        this.#schedulePrefetch(tail);
+    }
+    #schedulePrefetch(segs) {
         const conc = Math.max(1, Math.floor(this.#concurrencyFn ? this.#concurrencyFn() : this.#concurrency));
-        const want = segs.slice(-this.#ahead).filter((u) => !this.#peek(u) && !this.#inflight.has(u));
+        const want = segs.filter((u) => !this.#peek(u) && !this.#inflight.has(u));
         for (const u of want) {
             if (this.#inflight.size >= conc)
                 break;
@@ -511,10 +593,13 @@ export class HlsPrefetcher {
         }
     }
     #prefetch(url) {
-        const p = (async () => {
+        const controller = new AbortController();
+        this.#background.set(url, controller);
+        let p;
+        p = (async () => {
             try {
                 const u = new URL(url);
-                const res = await this.#stripeFetch(u, {});
+                const res = await this.#stripeFetch(u, {}, controller.signal);
                 if (res.status !== 200 || res.body.length === 0 || res.body.length > this.#maxEntryBytes)
                     return null;
                 const ct = res.headers["content-type"];
@@ -530,7 +615,10 @@ export class HlsPrefetcher {
                 return null;
             }
             finally {
-                this.#inflight.delete(url);
+                if (this.#inflight.get(url) === p)
+                    this.#inflight.delete(url);
+                if (this.#background.get(url) === controller)
+                    this.#background.delete(url);
             }
         })();
         this.#inflight.set(url, p);

package/dist/proxy/multi-exit-router.d.ts

@@ -50,6 +50,7 @@ export interface MultiExitRouterOptions {
 }
 export declare const BUILTIN_REGION_DOMAINS: Record<string, string[]>;
 export declare function isUsefulRecoverySample(peakBps: number, averageBps: number, minBps?: number): boolean;
+export declare function redemptionProbeQuietDelay(lastForegroundMs: number, nowMs?: number, quietMs?: number): number;
 interface HlsExitScore {
     speedEwma: number | null;
     flooredAtMs: number | null;

package/dist/proxy/multi-exit-router.js

@@ -21,7 +21,7 @@ import https from "node:https";
 import net from "node:net";
 import tls from "node:tls";
 import { egressConnect } from "./egress.js";
-import { HlsPrefetcher, buildM3u8VariantFallbacks, capM3u8Variants, looksLikePlaylist, looksLikeSegment, parseM3u8Variants, parseM3u8Segments } from "./hls-prefetch.js";
+import { HlsPrefetcher, buildM3u8VariantFallbacks, capM3u8Variants, looksLikePlaylist, looksLikeSegment, parseM3u8Variants, parseM3u8Segments, sliceHttpByteRange } from "./hls-prefetch.js";
 import { RouteLearner } from "./route-learner.js";
 import { GeoCnClassifier } from "./geo-cn.js";
 import { MitmGateway } from "./mitm-gateway.js";
@@ -164,15 +164,16 @@ const NEAR_DEAD_EXIT_BPS = 60_000;
 // threshold admitted 10.86.15.133 on a short peak even though its full CCTV
 // segments averaged only 0.7-1.2 Mbit/s, causing each half-range to take 4-6s.
 const HLS_DELIVERY_BPS = 200_000;
-// Below this speed even the capped 0.9 Mbps stream has no useful headroom. If
+// Below this speed even a 0.9 Mbps stream has no useful headroom. If
 // unproven exits remain, keep exploring them instead of locking startup onto
 // the first measured-but-dead path (observed: 0.3 Mbps 15.133 hid the actually
 // usable 134.139 for the remainder of the router process).
 const HLS_STARTUP_EXPLORE_BPS = 100_000;
-// Stability-first default for constrained exit pools. Set 0 to expose every
-// origin variant, or 1800000 to restore CCTV 720P when another fast exit joins.
+// Quality selection belongs to the player/user by default. Operators may set a
+// positive value to impose an explicit site-local ceiling; 0 exposes every
+// origin variant.
 const HLS_MAX_VARIANT_BPS = process.env.AGENTNET_HLS_MAX_BPS === undefined
-    ? 900_000
+    ? 0
     : Math.max(0, Number(process.env.AGENTNET_HLS_MAX_BPS));
 export function isUsefulRecoverySample(peakBps, averageBps, minBps = HLS_DELIVERY_BPS) {
     return peakBps >= minBps && averageBps >= minBps;
@@ -238,6 +239,14 @@ const REDEMPTION_MS = 90_000;
 // exit is tested with a duplicate background segment while the player's normal
 // fetch remains on proven exits, so recovery discovery cannot stall playback.
 const REDEMPTION_PROBE_GAP_MS = 15_000;
+// A recovery test is deliberately background work: never let it overlap an
+// active live stream.  Each foreground segment pushes the timer back; once the
+// player has been quiet for this long, the most recent segment is safe to reuse
+// as a realistic recovery sample.
+const REDEMPTION_PROBE_QUIET_MS = 10_000;
+export function redemptionProbeQuietDelay(lastForegroundMs, nowMs = Date.now(), quietMs = REDEMPTION_PROBE_QUIET_MS) {
+    return Math.max(0, quietMs - Math.max(0, nowMs - lastForegroundMs));
+}
 function floorExit(exit) {
     exit.speedEwma = exit.speedEwma === null ? FLOOR_BPS : Math.min(exit.speedEwma, FLOOR_BPS);
     exit.flooredAtMs = Date.now();
@@ -1136,6 +1145,38 @@ export function startMultiExitRouter(opts) {
     // Fetch one URL through the region's exit pool, buffered, with failover.
     let redemptionProbeInFlight = false;
     let lastRedemptionProbeMs = 0;
+    let lastForegroundHlsMs = 0;
+    let redemptionProbeTimer = null;
+    let pendingRedemptionProbe = null;
+    function armRedemptionProbe(delayMs) {
+        if (redemptionProbeTimer)
+            clearTimeout(redemptionProbeTimer);
+        redemptionProbeTimer = setTimeout(() => {
+            redemptionProbeTimer = null;
+            const quietDelay = redemptionProbeQuietDelay(lastForegroundHlsMs);
+            if (quietDelay > 0) {
+                armRedemptionProbe(quietDelay);
+                return;
+            }
+            const pending = pendingRedemptionProbe;
+            if (!pending)
+                return;
+            if (redemptionProbeInFlight || Date.now() - lastRedemptionProbeMs < REDEMPTION_PROBE_GAP_MS) {
+                armRedemptionProbe(REDEMPTION_PROBE_GAP_MS);
+                return;
+            }
+            maybeStartRedemptionProbe(pending.u, pending.extraHeaders, pending.region);
+            // Keep checking while the player remains idle: an exit may not become
+            // redemption-eligible until its 90-second floor expires.
+            armRedemptionProbe(REDEMPTION_PROBE_GAP_MS);
+        }, Math.max(1, delayMs));
+        redemptionProbeTimer.unref?.();
+    }
+    function deferRedemptionProbeUntilIdle(u, extraHeaders, region) {
+        lastForegroundHlsMs = Date.now();
+        pendingRedemptionProbe = { u: new URL(u.toString()), extraHeaders: { ...extraHeaders }, region };
+        armRedemptionProbe(REDEMPTION_PROBE_QUIET_MS);
+    }
     function maybeStartRedemptionProbe(u, extraHeaders, region) {
         const now = Date.now();
         if (redemptionProbeInFlight || now - lastRedemptionProbeMs < REDEMPTION_PROBE_GAP_MS)
@@ -1204,7 +1245,7 @@ export function startMultiExitRouter(opts) {
                 return;
             }
             if (!forcedExit && label === "prefetch")
-                maybeStartRedemptionProbe(u, extraHeaders, region);
+                deferRedemptionProbeUntilIdle(u, extraHeaders, region);
             const base0 = forcedExit ? [forcedExit] : pickOrder(region);
             if (base0.length === 0) {
                 reject(new Error("no healthy exit"));
@@ -1376,17 +1417,14 @@ export function startMultiExitRouter(opts) {
             tryIdx(0);
         });
     }
-    // Striping ON — PROVEN to aggregate: a 600KB range that takes 8.5s on one
-    // China exit (0.57 Mbps) lands in 3.9s when split 3 ways across exits
-    // (1.24 Mbps, 2.2×). The GFW throttles PER-CONNECTION, so parallel ranges on
-    // separate exit tunnels sum. A tiny 2-byte probe learns the size, then the
-    // whole body is pulled as parallel byte-ranges; each range is hedged
-    // (timeout → retry another exit) and the empty-body trip + min-throughput
-    // deadline in fetchViaRegionBuffered keep a dead/trickling exit from stalling
-    // it. Player requests JOIN an in-flight prefetch (dedup) so bandwidth isn't
-    // split fetching the same segment twice. concurrency:2 keeps at most 2
-    // segments (≈6 stripes over ~3 exits) in flight so the pool isn't overwhelmed.
-    const AGG = process.env.AGENTNET_HLS_STRIPES ? Math.max(1, Number(process.env.AGENTNET_HLS_STRIPES)) : 3;
+    // Striping can aggregate genuinely independent exits, but it is harmful when
+    // every range converges on one useful shared exit. Three stripes, a hedge per
+    // stripe, and retries produced 6-11 simultaneous requests to 10.86.134.139;
+    // its measured throughput collapsed from ~2 Mbps to ~0.3 Mbps and every
+    // client sharing that exit stalled. Default to one whole-segment fetch (with
+    // the existing single late hedge). Operators may explicitly opt into more
+    // stripes after proving their exits have independent capacity.
+    const AGG = process.env.AGENTNET_HLS_STRIPES ? Math.max(1, Number(process.env.AGENTNET_HLS_STRIPES)) : 1;
     // How many china exits are ACTUALLY delivering right now — healthy (or with
     // live traffic), not tripped, and not speed-penalized (an exit that returned
     // empty/0-byte gets its score floored, so it drops out here until it serves
@@ -1408,14 +1446,11 @@ export function startMultiExitRouter(opts) {
         return exits.some((e) => e.region === fallbackRegion && e.trippedUntil <= now &&
             e.flooredAtMs === null && e.speedEwma !== null && e.speedEwma >= HLS_STARTUP_EXPLORE_BPS);
     };
-    // Stripe count is a connection count, not a distinct-exit count. Keep three
-    // parallel ranges even when only one exit is qualified: two ranges still
-    // delivered CCTV's 1800 stream in 3.6-4.9s, which is marginal for a 4s live
-    // segment, while one connection repeatedly showed 6-10s tails. During
-    // startup, keep whole-segment mode until at least one
-    // exit has delivered a real fast sample; otherwise the unproven startup pool
-    // would scatter half-ranges onto every slow exit and hold assembly hostage.
-    // Set AGENTNET_HLS_STRIPES=1 for an emergency rollback.
+    // Stripe count is a connection count, not a distinct-exit count. During
+    // startup, keep whole-segment mode until at least one exit has delivered a
+    // real fast sample; otherwise the unproven startup pool would scatter ranges
+    // onto every slow exit and hold assembly hostage. AGENTNET_HLS_STRIPES=N is
+    // an explicit opt-in for pools where N independent exits are proven useful.
     const usableChinaExits = () => AGG <= 1 || !hasMeasuredChinaExit() ? 1 : AGG;
     const hlsConcurrency = () => hasMeasuredChinaExit() ? deliveringChinaExits() : 1;
     // Prefetch parallelism = the number of exits ACTUALLY delivering right now
@@ -1483,23 +1518,36 @@ export function startMultiExitRouter(opts) {
             res.end();
             return;
         }
-        const cacheable = method === "GET" && !headers["range"];
+        const isPlaylist = looksLikePlaylist(u.pathname || "");
+        const isSegment = looksLikeSegment(u.pathname || "");
+        const requestedRange = typeof headers["range"] === "string" ? headers["range"] : null;
+        const cacheable = method === "GET";
         if (cacheable) {
             const hit = hls.lookup(fullUrl);
             if (hit) {
+                const ranged = requestedRange && isSegment ? sliceHttpByteRange(hit.body, requestedRange) : null;
+                if (requestedRange && isSegment && !ranged) {
+                    const hh = { "content-range": `bytes */${hit.body.length}`, "content-length": 0 };
+                    addCors(hh);
+                    res.writeHead(416, hh);
+                    res.end();
+                    return;
+                }
+                const body = ranged?.body ?? hit.body;
                 const hh = {
                     "content-type": hit.contentType ?? "application/octet-stream",
-                    "content-length": hit.body.length,
+                    "content-length": body.length,
                     "x-agentnet-cache": "hit",
+                    "accept-ranges": "bytes",
                 };
+                if (ranged)
+                    hh["content-range"] = `bytes ${ranged.start}-${ranged.end}/${ranged.total}`;
                 addCors(hh);
-                res.writeHead(200, hh);
-                res.end(hit.body);
+                res.writeHead(ranged ? 206 : 200, hh);
+                res.end(body);
                 bumpHlsStats();
                 return;
             }
-            const isPlaylist = looksLikePlaylist(u.pathname || "");
-            const isSegment = looksLikeSegment(u.pathname || "");
             if (isPlaylist || isSegment) {
                 const fwd = {};
                 for (const [k, v] of Object.entries(headers)) {
@@ -1545,17 +1593,33 @@ export function startMultiExitRouter(opts) {
                                 log(`  playlist ${host} is MEDIA — ${segs.length} segments, prefetching ahead`);
                         }
                     }
-                    log(`  MITM ${method} ${host}${(path || "/").slice(0, 80)} → ${r.status} (${r.body.length}B)`);
+                    let responseStatus = r.status;
+                    let responseBody = r.body;
+                    const outHeaders = { ...r.headers };
+                    if (requestedRange && isSegment && r.status === 200) {
+                        const ranged = sliceHttpByteRange(r.body, requestedRange);
+                        if (!ranged) {
+                            responseStatus = 416;
+                            responseBody = Buffer.alloc(0);
+                            outHeaders["content-range"] = `bytes */${r.body.length}`;
+                        }
+                        else {
+                            responseStatus = 206;
+                            responseBody = ranged.body;
+                            outHeaders["content-range"] = `bytes ${ranged.start}-${ranged.end}/${ranged.total}`;
+                            outHeaders["accept-ranges"] = "bytes";
+                        }
+                    }
+                    log(`  MITM ${method} ${host}${(path || "/").slice(0, 80)} → ${responseStatus} (${responseBody.length}B)`);
                     if (r.status >= 400) {
                         const snip = r.body.slice(0, 300).toString("utf8").replace(/\s+/g, " ");
                         log(`    body: ${snip}`);
                     }
-                    const outHeaders = { ...r.headers };
                     delete outHeaders["transfer-encoding"];
-                    outHeaders["content-length"] = r.body.length;
+                    outHeaders["content-length"] = responseBody.length;
                     addCors(outHeaders); // cache/dedup/striped paths drop the CDN's CORS header — always re-add
-                    res.writeHead(r.status, outHeaders);
-                    res.end(r.body);
+                    res.writeHead(responseStatus, outHeaders);
+                    res.end(responseBody);
                     if (r.status === 200) {
                         const ct = r.headers["content-type"];
                         if (isPlaylist) {
@@ -1750,6 +1814,13 @@ export function startMultiExitRouter(opts) {
         server.on("close", () => clearInterval(reporter));
     }
     return {
-        stop: () => { stopped = true; server.close(); },
+        stop: () => {
+            stopped = true;
+            if (redemptionProbeTimer)
+                clearTimeout(redemptionProbeTimer);
+            redemptionProbeTimer = null;
+            pendingRedemptionProbe = null;
+            server.close();
+        },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.196",
+  "version": "0.1.198",
   "description": "Private virtual LAN for self-hosted services and AI agents, built on Elastos Carrier. NAT-traversal, name service, ACL, all over a peer-to-peer mesh — no public IP required.",
   "type": "module",
   "main": "./dist/index.js",