@decentnetwork/lan 0.1.183 → 0.1.185

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

@@ -41,6 +41,13 @@ export interface HlsPrefetcherOptions {
     concurrency?: number;
     /** Skip caching bodies larger than this (default 32 MB). */
     maxEntryBytes?: number;
+    /** Split each segment into this many parallel byte-range stripes across the
+     *  exit pool (default 6). 1 disables striping. Lets ONE segment ride the SUM
+     *  of the exits' bandwidth instead of a single throttled connection. */
+    stripes?: number;
+    /** Stripe chunk size — also the first probe chunk (default 192 KB). Segments
+     *  smaller than this aren't striped. */
+    stripeChunkBytes?: number;
 }
 export declare class HlsPrefetcher {
     #private;

package/dist/proxy/hls-prefetch.js

@@ -17,6 +17,12 @@
 // master playlist (#EXT-X-STREAM-INF) lists variants, not segments.
 //
 const SEGMENT_EXTS = [".ts", ".m4s", ".m4a", ".m4v", ".aac", ".mp3", ".mp4", ".vtt"];
+/** Parse the total size out of a `Content-Range: bytes 0-N/TOTAL` header. */
+function contentRangeTotal(cr) {
+    const s = Array.isArray(cr) ? cr[0] : cr;
+    const m = s ? /\/(\d+)\s*$/.exec(s) : null;
+    return m ? Number(m[1]) : 0;
+}
 export function looksLikePlaylist(pathname) {
     const p = pathname.toLowerCase();
     return p.endsWith(".m3u8") || p.endsWith(".m3u");
@@ -91,6 +97,8 @@ export class HlsPrefetcher {
     #ahead;
     #concurrency;
     #maxEntryBytes;
+    #stripes;
+    #stripeChunkBytes;
     #hits = 0;
     #misses = 0;
     constructor(fetcher, opts = {}) {
@@ -100,6 +108,69 @@ export class HlsPrefetcher {
         this.#ahead = opts.prefetchAhead ?? 4;
         this.#concurrency = opts.concurrency ?? 4;
         this.#maxEntryBytes = opts.maxEntryBytes ?? 32 * 1024 * 1024;
+        this.#stripes = Math.max(1, opts.stripes ?? 6);
+        this.#stripeChunkBytes = opts.stripeChunkBytes ?? 192 * 1024;
+    }
+    /** Fetch `u` as PARALLEL byte-range stripes. Each range is a separate
+     *  `#fetcher` call, which the router load-balances onto a DIFFERENT exit — so
+     *  one segment downloads at the SUM of the pool's bandwidth, beating the GFW
+     *  per-connection throttle (the reason a single stream stalls even with many
+     *  exits). Falls back to one whole-body fetch if the origin ignores Range or
+     *  any stripe fails (correctness over speed). */
+    async #stripeFetch(u) {
+        const whole = () => this.#fetcher(u, { host: u.host }, "prefetch");
+        if (this.#stripes <= 1)
+            return whole();
+        // 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(probe.headers["content-range"]);
+        const outHeaders = { ...probe.headers };
+        delete outHeaders["content-range"];
+        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 = i * chunk;
+            const end = Math.min(start + chunk - 1, total - 1);
+            if (start > end)
+                return Promise.resolve(Buffer.alloc(0));
+            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 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 };
@@ -158,7 +229,7 @@ export class HlsPrefetcher {
         const p = (async () => {
             try {
                 const u = new URL(url);
-                const res = await this.#fetcher(u, { host: u.host }, "prefetch");
+                const res = await this.#stripeFetch(u);
                 if (res.status !== 200 || res.body.length === 0 || res.body.length > this.#maxEntryBytes)
                     return null;
                 const ct = res.headers["content-type"];

package/package.json

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