@decentnetwork/lan 0.1.183 → 0.1.184

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,54 @@ 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();
+        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)
+            return whole();
+        const total = contentRangeTotal(first.headers["content-range"]);
+        const outHeaders = { ...first.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);
+        const parts = await Promise.all(Array.from({ length: n }, (_, i) => {
+            const start = first.body.length + 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);
+        }));
+        if (parts.some((p) => p === null))
+            return whole(); // a stripe failed → refetch whole for integrity
+        const body = Buffer.concat([first.body, ...parts]);
+        if (body.length !== total)
+            return whole();
+        return { status: 200, headers: outHeaders, body };
     }
     get stats() {
         return { hits: this.#hits, misses: this.#misses, entries: this.#cache.size, bytes: this.#cacheBytes };
@@ -158,7 +214,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.184",
   "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",