@decentnetwork/lan 0.1.197 → 0.1.198

package/dist/proxy/hls-prefetch.js

@@ -179,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;
@@ -266,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;
@@ -275,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.
@@ -298,6 +313,7 @@ export class HlsPrefetcher {
                 }
                 else if (pending === 0) {
                     settled = true;
+                    cleanup();
                     reject(e);
                 }
             };
@@ -309,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;
@@ -322,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;
@@ -338,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;
@@ -387,6 +410,11 @@ export class HlsPrefetcher {
                 if (finished >= launched)
                     finish(null);
             };
+            if (outerSignal?.aborted) {
+                finish(null);
+                return;
+            }
+            outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
             launch();
         });
     }
@@ -394,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
@@ -427,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 };
     }
@@ -523,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;
@@ -536,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"];
@@ -555,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

@@ -239,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();
@@ -1137,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)
@@ -1205,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"));
@@ -1774,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.197",
+  "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",