@decentnetwork/lan 0.1.191 → 0.1.193

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

@@ -59,6 +59,9 @@ export interface HlsPrefetcherOptions {
      *  exit just serializes and stalls); as exits recover it rises and aggregation
      *  resumes. Overrides `stripes` when provided. */
     stripesFn?: () => number;
+    /** Delay before duplicating a slow whole-segment fetch. Primarily exposed for
+     *  deterministic tests; default 3.5s is just below CCTV's 4s live segment. */
+    wholeHedgeMs?: number;
     /** Stripe chunk size — also the first probe chunk (default 256 KB). Segments
      *  smaller than this aren't striped. */
     stripeChunkBytes?: number;

package/dist/proxy/hls-prefetch.js

@@ -27,7 +27,7 @@ const STRIPE_TRIES = 3;
  *  landed in this long is late (a healthy exit delivers in 1-3.5s), so a
  *  parallel duplicate on another exit is launched. Rarely fires in steady
  *  state; mainly absorbs redemption probes trapped by a still-bad exit. */
-const WHOLE_HEDGE_MS = 5000;
+const WHOLE_HEDGE_MS = 3500;
 /** Total size from a `Content-Range: bytes 0-255/900000` header, or null. */
 function contentRangeTotal(h) {
     const v = Array.isArray(h) ? h[0] : h;
@@ -114,6 +114,7 @@ export class HlsPrefetcher {
     #stripes;
     #stripesFn;
     #stripeChunkBytes;
+    #wholeHedgeMs;
     #hits = 0;
     #misses = 0;
     constructor(fetcher, opts = {}) {
@@ -127,6 +128,7 @@ export class HlsPrefetcher {
         this.#stripes = Math.max(1, opts.stripes ?? 4);
         this.#stripesFn = opts.stripesFn;
         this.#stripeChunkBytes = opts.stripeChunkBytes ?? 256 * 1024;
+        this.#wholeHedgeMs = opts.wholeHedgeMs ?? WHOLE_HEDGE_MS;
     }
     /** Effective stripe count right now (dynamic if a stripesFn was provided). */
     #stripeCount() {
@@ -179,41 +181,61 @@ export class HlsPrefetcher {
      *  the origin ignores Range or a stripe can't be completed. No deadline: if
      *  every exit is slow, a slow whole body still beats a corrupt/empty one.
      *
-     *  HEDGED when ≥2 exits are delivering: if the body hasn't landed within
-     *  WHOLE_HEDGE_MS, launch a PARALLEL duplicate (the router's load-aware pick
-     *  sends it to the best other exit) and take whichever finishes first. This
-     *  absorbs the redemption probe: a just-redeemed exit that traps its probe
-     *  segment for 13-15s used to stall playback every REDEMPTION cycle — now
-     *  the hedge covers the segment while the probe runs to its deadline and
-     *  floors the bad exit properly (the loser is NOT aborted, on purpose: an
-     *  aborted probe never gets floored and would be re-probed forever). */
+     *  HEDGED even when only one exit is currently qualified: if the body hasn't
+     *  landed within 3.5s, launch a second connection and take whichever finishes
+     *  first. A single proven exit still showed occasional 7-10s per-connection
+     *  tails; waiting for it alone drained CCTV's four-second live buffer. The
+     *  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) {
-        const one = () => this.#fetcher(u, { ...extra, host: u.host }, "prefetch");
-        const canHedge = (this.#concurrencyFn ? this.#concurrencyFn() : this.#concurrency) >= 2;
-        if (!canHedge)
-            return one(); // single exit: a duplicate would just split its bandwidth
+        const one = (signal, label) => this.#fetcher(u, { ...extra, host: u.host }, label, signal);
         return new Promise((resolve, reject) => {
             let settled = false;
-            let fails = 0;
-            let hedged = false;
+            let pending = 1;
+            let hedgeStarted = false;
             let timer = null;
-            const win = (r) => { if (settled)
-                return; settled = true; if (timer)
-                clearTimeout(timer); resolve(r); };
-            const lose = (e) => { fails++; if (!settled && fails >= (hedged ? 2 : 1)) {
+            const first = new AbortController();
+            let hedge = null;
+            const win = (winner) => (r) => {
+                if (settled)
+                    return;
                 settled = true;
                 if (timer)
                     clearTimeout(timer);
-                reject(e);
-            } };
-            one().then(win, lose);
-            timer = setTimeout(() => {
-                timer = null;
+                (winner === first ? hedge : first)?.abort();
+                // Keep the winner alive through resolution; aborting a fully consumed
+                // response would only discard its reusable keep-alive socket.
+                void winner;
+                resolve(r);
+            };
+            const lose = (e) => {
                 if (settled)
                     return;
-                hedged = true;
-                this.#fetcher(u, { ...extra, host: u.host }, "prefetch-hedge").then(win, lose);
-            }, WHOLE_HEDGE_MS);
+                pending--;
+                if (!hedgeStarted) {
+                    if (timer)
+                        clearTimeout(timer);
+                    startHedge();
+                }
+                else if (pending === 0) {
+                    settled = true;
+                    reject(e);
+                }
+            };
+            const startHedge = () => {
+                if (settled || hedgeStarted)
+                    return;
+                hedgeStarted = true;
+                hedge = new AbortController();
+                pending++;
+                one(hedge.signal, "prefetch-hedge").then(win(hedge), lose);
+            };
+            one(first.signal, "prefetch").then(win(first), lose);
+            timer = setTimeout(() => {
+                timer = null;
+                startHedge();
+            }, this.#wholeHedgeMs);
             timer.unref?.();
         });
     }

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

@@ -49,6 +49,7 @@ export interface MultiExitRouterOptions {
     log?: (msg: string) => void;
 }
 export declare const BUILTIN_REGION_DOMAINS: Record<string, string[]>;
+export declare function isUsefulRecoverySample(peakBps: number, averageBps: number, minBps?: number): boolean;
 interface HlsExitScore {
     speedEwma: number | null;
     flooredAtMs: number | null;

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

@@ -149,6 +149,16 @@ const NEVER_LEARN = /(^|\.)(google|gstatic|googleapis|googleusercontent|ggpht|gv
 // (≈0.5 Mbit/s) keeps every usable exit in and sits safely ABOVE the 40 KB/s
 // deprioritize floor so a floored exit still drops out.
 const NEAR_DEAD_EXIT_BPS = 60_000;
+// Foreground HLS needs a materially stronger exit than ordinary browsing.
+// CCTV's 720p variant is 1.8 Mbit/s; an exit below ~1.2 Mbit/s cannot deliver
+// one four-second segment quickly enough to be useful even with a small live
+// buffer. Keep such exits available for last-resort failover, but do not count
+// them as HLS delivery capacity or let a slow redemption probe re-enable them.
+// This is bytes/sec (150 KB/s = 1.2 Mbit/s).
+const HLS_DELIVERY_BPS = 150_000;
+export function isUsefulRecoverySample(peakBps, averageBps, minBps = HLS_DELIVERY_BPS) {
+    return peakBps >= minBps && averageBps >= minBps;
+}
 // A buffered segment fetch is given a deadline sized to deliver its body at
 // roughly this bitrate; an exit that can't keep up is abandoned and the next is
 // tried. Live HLS needs each ~4s segment in a few seconds, so this is set near
@@ -217,7 +227,7 @@ function floorExit(exit) {
 /** Feed one tunnel's rate meter into the exit's speed EWMA (peak-window based).
  *  Only transfers past SPEED_MIN_BYTES count — smaller ones never reveal path
  *  capacity on a high-RTT link. */
-function sampleSpeed(exit, meter, durMs) {
+function sampleSpeed(exit, meter, durMs, recoveryMinBps = NEAR_DEAD_EXIT_BPS) {
     exit.bytesDown += meter.total;
     if (meter.total < SPEED_MIN_BYTES)
         return;
@@ -229,7 +239,12 @@ function sampleSpeed(exit, meter, durMs) {
         // replaces it with the fresh measurement instead of blending the floor into
         // the result. Only a useful-speed transfer proves recovery; a completed but
         // still-too-slow probe remains floored for another redemption interval.
-        if (bps >= NEAR_DEAD_EXIT_BPS) {
+        // Peak-window speed is useful for ranking paths, but HLS redemption must
+        // also prove whole-segment average throughput. A probe observed at a 0.9
+        // Mbit/s peak but only 0.6 Mbit/s average caused six-way prefetch/hedge
+        // congestion when it rejoined a 1.8 Mbit/s stream.
+        const averageBps = durMs > 0 ? (meter.total / durMs) * 1000 : 0;
+        if (isUsefulRecoverySample(bps, averageBps, recoveryMinBps)) {
             exit.speedEwma = bps;
             exit.flooredAtMs = null;
         }
@@ -247,7 +262,7 @@ function sampleSpeed(exit, meter, durMs) {
  * exit is degraded, keep the original pool as a last resort. Exported for the
  * policy regression tests. */
 export function selectHlsPrimaryPool(pool) {
-    const proven = pool.filter((e) => e.flooredAtMs === null && e.speedEwma !== null && e.speedEwma >= NEAR_DEAD_EXIT_BPS);
+    const proven = pool.filter((e) => e.flooredAtMs === null && e.speedEwma !== null && e.speedEwma >= HLS_DELIVERY_BPS);
     if (proven.length > 0)
         return proven;
     const unproven = pool.filter((e) => e.flooredAtMs === null && e.speedEwma === null);
@@ -255,7 +270,10 @@ export function selectHlsPrimaryPool(pool) {
 }
 /** Dynamic prefetch concurrency follows only the foreground-safe pool. */
 export function countHlsDeliveryExits(pool) {
-    return Math.max(1, selectHlsPrimaryPool(pool).length);
+    // Two adjacent live segments in flight keep the buffer moving without the
+    // runaway 6-8 request fan-out seen when every marginal exit increased both
+    // prefetch concurrency and whole-segment hedging.
+    return Math.min(2, Math.max(1, selectHlsPrimaryPool(pool).length));
 }
 function fmtMbps(bps) {
     return bps === null ? "?" : `${((bps * 8) / 1e6).toFixed(1)}Mbps`;
@@ -1274,7 +1292,7 @@ export function startMultiExitRouter(opts) {
                             nextExit(`empty ${status}`);
                             return;
                         }
-                        sampleSpeed(exit, meter, durMs);
+                        sampleSpeed(exit, meter, durMs, HLS_DELIVERY_BPS);
                         if (label) {
                             const kb = (body.length / 1024).toFixed(0);
                             const mbps = durMs > 0 ? ((body.length * 8) / durMs / 1000).toFixed(1) : "?";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.191",
+  "version": "0.1.193",
   "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",