@decentnetwork/lan 0.1.184 → 0.1.185

package/dist/proxy/hls-prefetch.js

@@ -121,42 +121,57 @@ export class HlsPrefetcher {
         const whole = () => this.#fetcher(u, { host: u.host }, "prefetch");
         if (this.#stripes <= 1)
             return whole();
-        const guess = this.#stripeChunkBytes;
-        let first;
-        try {
-            first = await this.#fetcher(u, { host: u.host, range: `bytes=0-${guess - 1}` }, "stripe");
-        }
-        catch {
-            return whole();
-        }
-        if (first.status === 200)
-            return first; // origin ignored Range → whole body already
-        if (first.status !== 206)
+        // Tiny probe to learn total size + confirm Range support (hedged so a dead
+        // exit doesn't stall the whole segment before parallelism starts).
+        const probe = await this.#fetchRange(u, "bytes=0-1", 2000, 3);
+        if (!probe || probe.status !== 206)
             return whole();
-        const total = contentRangeTotal(first.headers["content-range"]);
-        const outHeaders = { ...first.headers };
+        const total = contentRangeTotal(probe.headers["content-range"]);
+        const outHeaders = { ...probe.headers };
         delete outHeaders["content-range"];
-        if (!total || total <= first.body.length)
-            return { status: 200, headers: outHeaders, body: first.body };
-        const remaining = total - first.body.length;
-        const n = Math.max(1, Math.min(this.#stripes - 1, Math.ceil(remaining / guess)));
-        const chunk = Math.ceil(remaining / n);
+        if (!total)
+            return whole();
+        if (total <= this.#stripeChunkBytes) {
+            // Small segment — one range fetch (hedged) is enough.
+            const one = await this.#fetchRange(u, `bytes=0-${total - 1}`, 6000, 3);
+            return one && one.body.length === total ? { status: 200, headers: outHeaders, body: one.body } : whole();
+        }
+        const n = Math.max(2, Math.min(this.#stripes, Math.ceil(total / this.#stripeChunkBytes)));
+        const chunk = Math.ceil(total / n);
+        // Timeout scales with chunk size: allow ~0.3 Mbps before we give up on an
+        // exit and retry the SAME range on another (kills the dead-exit straggler
+        // that otherwise holds the whole segment hostage).
+        const rangeTimeout = Math.max(3000, Math.round((chunk * 8) / 300)); // ms at 0.3 Mbps
         const parts = await Promise.all(Array.from({ length: n }, (_, i) => {
-            const start = first.body.length + i * chunk;
+            const start = i * chunk;
             const end = Math.min(start + chunk - 1, total - 1);
             if (start > end)
                 return Promise.resolve(Buffer.alloc(0));
-            return this.#fetcher(u, { host: u.host, range: `bytes=${start}-${end}` }, "stripe")
-                .then((r) => ((r.status === 206 || r.status === 200) && r.body.length === end - start + 1 ? r.body : null))
-                .catch(() => null);
+            return this.#fetchRange(u, `bytes=${start}-${end}`, rangeTimeout, 3)
+                .then((r) => (r && r.body.length === end - start + 1 ? r.body : null));
         }));
         if (parts.some((p) => p === null))
-            return whole(); // a stripe failed → refetch whole for integrity
-        const body = Buffer.concat([first.body, ...parts]);
+            return whole(); // a range never landed → refetch whole for integrity
+        const body = Buffer.concat(parts);
         if (body.length !== total)
             return whole();
         return { status: 200, headers: outHeaders, body };
     }
+    /** Fetch one byte-range with a slow-transfer TIMEOUT + retry on another exit.
+     *  A stripe stuck on a dead exit (0.0 Mbps) times out and is re-issued (the
+     *  router rotates to a different exit), so one bad exit can't stall a segment. */
+    async #fetchRange(u, range, timeoutMs, tries) {
+        for (let t = 0; t < tries; t++) {
+            const got = await Promise.race([
+                this.#fetcher(u, { host: u.host, range }, "stripe").catch(() => null),
+                new Promise((res) => setTimeout(() => res("timeout"), timeoutMs)),
+            ]);
+            if (got && got !== "timeout" && (got.status === 206 || got.status === 200))
+                return got;
+            // timed out (slow exit) or errored → loop; the next fetch rotates exits.
+        }
+        return null;
+    }
     get stats() {
         return { hits: this.#hits, misses: this.#misses, entries: this.#cache.size, bytes: this.#cacheBytes };
     }

package/package.json

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