@decentnetwork/lan 0.1.192 → 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/package.json

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