mega-stream-proxy 0.1.9

package/dist/proxy/sw/sw.js

@@ -0,0 +1,212 @@
+// public/sw.js
+// Web streaming proxy — the browser-side equivalent of the native
+// services/megaProxy.ts TCP server. The page registers this service worker
+// and tells it which MEGA parts to serve. The <video> element then loads
+// same-origin URLs like /__mmstream__/<session>/part-0.mp4 and makes HTTP
+// Range requests; this worker answers them one at a time by piping the
+// truncated, decrypted megajs download stream straight into the response —
+// exactly like the mobile proxy streams byte ranges from MEGA on demand.
+//
+// megajs is loaded via importScripts("megajs.browser.js") (the UMD build,
+// copied from node_modules — self-contained, works without window/document).
+
+importScripts("megajs.browser.js");
+
+const STREAM_MARKER = "/__mmstream__/";
+
+// Map<`${session}/${name}`, { url: string, promise?: Promise<{file,size}> }>
+const parts = new Map();
+
+/* ------------------------------------------------------------------ */
+/* Setup                                                               */
+/* ------------------------------------------------------------------ */
+
+self.addEventListener("install", () => {
+  self.skipWaiting();
+});
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});
+
+self.addEventListener("message", (event) => {
+  const data = (event && event.data) || {};
+  if (data.type === "parts" && data.session && Array.isArray(data.parts)) {
+    for (const p of data.parts) {
+      if (p && p.name && p.url) {
+        parts.set(`${data.session}/${p.name}`, { url: p.url });
+      }
+    }
+  } else if (data.type === "clear" && data.session) {
+    for (const key of parts.keys()) {
+      if (key.startsWith(`${data.session}/`)) parts.delete(key);
+    }
+  }
+});
+
+/* ------------------------------------------------------------------ */
+/* Helpers                                                             */
+/* ------------------------------------------------------------------ */
+
+function toView(chunk) {
+  // Copy the bytes: megajs may reuse its Buffers after the "data" event.
+  const src = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+  const out = new Uint8Array(src.byteLength);
+  out.set(src);
+  return out;
+}
+
+function textResponse(status, text, extraHeaders) {
+  const headers = Object.assign({ "Content-Type": "text/plain" }, extraHeaders);
+  return new Response(text, { status, headers });
+}
+
+async function loadPart(part) {
+  if (!part.promise) {
+    part.promise = (async () => {
+      const file = self.mega.File.fromURL(part.url);
+      await file.loadAttributes();
+      return { file, size: Number(file.size) || 0 };
+    })();
+  }
+  return part.promise;
+}
+
+/* ------------------------------------------------------------------ */
+/* Streaming — mirrors native serveSingleFile (HTTP Range over MEGA)   */
+/* ------------------------------------------------------------------ */
+
+async function handleStream(request, session, name) {
+  const key = `${session}/${name}`;
+  const part = parts.get(key);
+  if (!part) return textResponse(404, `Not Found: ${name}`);
+
+  let parsed;
+  try {
+    parsed = await loadPart(part);
+  } catch (e) {
+    console.warn("[mmstream] load failed:", name, e);
+    return textResponse(503, "MEGA load failed");
+  }
+  const { file, size } = parsed;
+  if (size <= 0) return textResponse(503, "Stream has no size");
+
+  // HTTP Range parsing — same rules as the native proxy.
+  let start = 0;
+  let end = size - 1;
+  let isPartial = false;
+
+  const rangeHeader = request.headers.get("range");
+  if (rangeHeader) {
+    const m = /^bytes=(\d*)-(\d*)$/i.exec(rangeHeader.trim());
+    if (!m || (m[1] === "" && m[2] === "")) {
+      return new Response(null, { status: 416 });
+    }
+    const rawStart = m[1] === "" ? -1 : Number(m[1]);
+    const rawEnd = m[2] === "" ? -1 : Number(m[2]);
+    if (Number.isNaN(rawStart) || Number.isNaN(rawEnd)) {
+      return new Response(null, { status: 416 });
+    }
+    if (rawStart === -1) {
+      // suffix range: last N bytes
+      start = Math.max(size - rawEnd, 0);
+      end = size - 1;
+    } else {
+      start = rawStart;
+      end = rawEnd === -1 || rawEnd >= size ? size - 1 : rawEnd;
+      if (start > end || start >= size) {
+        return new Response(null, { status: 416 });
+      }
+    }
+    isPartial = true;
+  }
+
+  const length = end - start + 1;
+  const headers = {
+    "Content-Type": "video/mp4",
+    "Accept-Ranges": "bytes",
+    "Content-Length": String(length),
+    "Cache-Control": "no-store",
+  };
+  if (isPartial) {
+    headers["Content-Range"] = `bytes ${start}-${end}/${size}`;
+  }
+
+  if (request.method === "HEAD") {
+    return new Response(null, { status: isPartial ? 206 : 200, headers });
+  }
+
+  console.log(`[mmstream] ${request.method} ${name} ${rangeHeader || "full"} -> ${start}-${end} of ${size}`);
+
+  // Stream the requested byte range from MEGA as it decrypts.
+  const stream = file.download({
+    start,
+    end,
+    maxConnections: 4, // same multi-connection path as the native proxy
+  });
+
+  let done = false;
+
+  const body = new ReadableStream({
+    start(controller) {
+      stream.on("data", (chunk) => {
+        if (done) return;
+        if (controller.desiredSize <= 0) {
+          try {
+            stream.pause();
+          } catch {}
+        }
+        try {
+          controller.enqueue(toView(chunk));
+        } catch (e) {
+          try {
+            stream.destroy();
+          } catch {}
+        }
+      });
+      stream.on("end", () => {
+        if (done) return;
+        done = true;
+        try {
+          controller.close();
+        } catch {}
+      });
+      stream.on("error", (e) => {
+        if (done) return;
+        done = true;
+        try {
+          controller.error(e);
+        } catch {}
+      });
+    },
+    pull() {
+      try {
+        stream.resume();
+      } catch {}
+    },
+    cancel() {
+      done = true;
+      try {
+        if (stream.destroy) stream.destroy();
+      } catch {}
+    },
+  });
+
+  return new Response(body, { status: isPartial ? 206 : 200, headers });
+}
+
+self.addEventListener("fetch", (event) => {
+  const url = new URL(event.request.url);
+  if (url.origin !== self.location.origin) return;
+  if (!url.pathname.startsWith(STREAM_MARKER)) return;
+
+  const rest = url.pathname.slice(STREAM_MARKER.length); // <session>/<name>
+  const slash = rest.indexOf("/");
+  if (slash < 0) {
+    event.respondWith(textResponse(404, "Not Found"));
+    return;
+  }
+  const session = rest.slice(0, slash);
+  const name = rest.slice(slash + 1);
+  event.respondWith(handleStream(event.request, session, name));
+});

package/dist/proxy/types.d.ts

@@ -0,0 +1,15 @@
+/** Minimal structural types so this package does not need megajs typings. */
+/** A MEGA file as returned by megajs `File.fromURL(url)` (after loadAttributes). */
+export interface MegaFileLike {
+    size?: number;
+    name?: string;
+    loadAttributes: () => Promise<unknown>;
+    download: (opts?: Record<string, unknown>) => StreamLike;
+}
+/** Event-emitter download stream returned by `MegaFileLike.download()`. */
+export interface StreamLike {
+    on: (event: string, listener: (...args: any[]) => void) => StreamLike;
+    pause?: () => void;
+    resume?: () => void;
+    destroy?: () => void;
+}

package/dist/proxy/types.js

@@ -0,0 +1,2 @@
+/** Minimal structural types so this package does not need megajs typings. */
+export {};

package/dist/proxy/web.d.ts

@@ -0,0 +1,24 @@
+import type { MegaFileLike } from "./types.js";
+type PlayableUrl = string;
+/** Idempotent: registers the Service Worker once per app lifetime (no-op after). */
+export declare function ensureProxy(): Promise<void>;
+/** Registers one MEGA link as its own keyed session; returns its playable URL. */
+export declare function createStream(megaUrl: string): Promise<{
+    url: PlayableUrl;
+    sessionId: string;
+}>;
+/**
+ * Returns the ordered URLs the player should play in sequence, plus the session
+ * id to release later. On the Service Worker path every URL is streamed from
+ * MEGA on demand (start + HTTP Range) exactly like the mobile proxy; nothing is
+ * downloaded up front.
+ */
+export declare function createStreams(megaUrls: string[]): Promise<{
+    urls: PlayableUrl[];
+    sessionId: string;
+}>;
+/** Tears down one session: clears its worker part map and revokes its Blob URLs. */
+export declare function releaseStream(sessionId: string): void;
+/** Tear-down for tests / HMR: clears every session and the worker cache. */
+export declare function stopProxy(): void;
+export type { MegaFileLike };

package/dist/proxy/web.js

@@ -0,0 +1,231 @@
+/**
+ * Web streaming proxy. Registers the bundled Service Worker (see ./sw) with
+ * the MEGA part list, then returns same-origin URLs like
+ * /__mmstream__/<session>/part-0.mp4. The <video> element performs HTTP Range
+ * requests against those URLs and the worker streams the truncated, decrypted
+ * megajs bytes on demand — playback starts in well under a second without
+ * downloading the file, exactly like the Android TCP proxy.
+ *
+ * The worker + SW session map is a singleton established once per app lifetime
+ * via `ensureProxy()`. Each `createStream(url)` / `createStreams(urls)` call
+ * registers its own keyed session and returns its session id; the sessions are
+ * independent, and `releaseStream(sessionId)` tears one down while the others
+ * keep streaming.
+ *
+ * Fallback: when a Service Worker cannot be used (no secure context), parts
+ * are fully downloaded + decrypted into Blob object URLs.
+ */
+import { collectMegaFileStream } from "../stream.js";
+import { SW_MARKER } from "../swDefine.js";
+function errMsg(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+function revokeUrls(urls) {
+    for (const url of urls) {
+        try {
+            URL.revokeObjectURL(url);
+        }
+        catch { }
+    }
+}
+const sessions = new Map();
+let swCache = null;
+let sessionCounter = 0;
+/** Collision-resistant session key: time base + monotonic counter + random tail. */
+function newSessionId() {
+    sessionCounter += 1;
+    const t = Date.now().toString(36);
+    const c = sessionCounter.toString(36);
+    const r = Math.random().toString(36).slice(2, 6);
+    return `${t}${c}${r}`;
+}
+/* ------------------------------------------------------------------ */
+/* Service Worker                                                      */
+/* ------------------------------------------------------------------ */
+function swAvailable() {
+    if (typeof window === "undefined" || typeof navigator === "undefined") {
+        return false;
+    }
+    if (!("serviceWorker" in navigator))
+        return false;
+    const proto = window.location.protocol;
+    const host = window.location.hostname;
+    return proto === "https:" || host === "localhost" || host === "127.0.0.1";
+}
+function origin() {
+    return typeof window === "undefined" ? "" : window.location.origin;
+}
+/** Registers + activates the streaming worker once; returns whether it controls the page. */
+function ensureSw() {
+    if (swCache)
+        return swCache;
+    swCache = (async () => {
+        if (!swAvailable() || !origin())
+            return false;
+        try {
+            await navigator.serviceWorker.register(`${origin()}/sw.js`, {
+                scope: `${origin()}/`,
+            });
+            await navigator.serviceWorker.ready;
+            if (navigator.serviceWorker.controller)
+                return true;
+            // The worker claims clients on activation; wait for control so the
+            // <video> fetches below are actually intercepted. If the page never
+            // becomes controlled, fall back to Blob URLs instead of a 404 stream.
+            return await new Promise((resolve) => {
+                const onControl = () => {
+                    navigator.serviceWorker.removeEventListener("controllerchange", onControl);
+                    resolve(true);
+                };
+                navigator.serviceWorker.addEventListener("controllerchange", onControl);
+                setTimeout(() => {
+                    navigator.serviceWorker.removeEventListener("controllerchange", onControl);
+                    resolve(false);
+                }, 3000);
+            });
+        }
+        catch (e) {
+            console.warn(`[megaStream] service worker unavailable: ${errMsg(e)}`);
+            return false;
+        }
+    })();
+    return swCache;
+}
+async function sendToSw(message) {
+    try {
+        if (typeof navigator === "undefined")
+            return;
+        const registration = await navigator.serviceWorker?.getRegistration();
+        if (registration?.active)
+            registration.active.postMessage(message);
+    }
+    catch (e) {
+        console.warn(`[megaStream] worker message failed: ${errMsg(e)}`);
+    }
+}
+async function startStreaming(sessionId, parts) {
+    await sendToSw({ type: "parts", session: sessionId, parts });
+    const out = parts.map((p) => `${origin()}${SW_MARKER}${sessionId}/${p.name}`);
+    console.log(`[megaStream] session ${sessionId}: streaming ${parts.length} parts (web, service worker) via ${out[0]}`);
+    return out;
+}
+/* ------------------------------------------------------------------ */
+/* Blob fallback (no Service Worker allowed)                           */
+/* ------------------------------------------------------------------ */
+/** Download + decrypt a MEGA part into a video Blob object URL (tracked by session). */
+async function megaToBlobUrl(url, blobUrls) {
+    const chunks = [];
+    await collectMegaFileStream(url.trim(), async (chunk) => {
+        chunks.push(new Uint8Array(chunk));
+    });
+    let total = 0;
+    for (const c of chunks)
+        total += c.length;
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) {
+        merged.set(c, offset);
+        offset += c.length;
+    }
+    const blob = new Blob([merged.buffer], { type: "video/mp4" });
+    const objectUrl = URL.createObjectURL(blob);
+    blobUrls.push(objectUrl);
+    return objectUrl;
+}
+/** Fully downloads every part into object URLs; resolves once part 1 is ready. */
+async function startBlobFallback(megaUrls, blobUrls) {
+    const urls = (megaUrls ?? []).map((u) => u?.trim()).filter(Boolean);
+    const out = new Array(urls.length).fill(null);
+    urls.forEach((u, i) => {
+        megaToBlobUrl(u, blobUrls)
+            .then((blobUrl) => {
+            out[i] = blobUrl;
+            console.log(`[megaStream] part ${i + 1}/${urls.length} ready`);
+        })
+            .catch((e) => console.warn(`[megaStream] part ${i + 1}/${urls.length} failed: ${errMsg(e)}`));
+    });
+    const deadline = Date.now() + 30_000;
+    while (out[0] == null && Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    if (out[0] == null) {
+        throw new Error("Failed to stream the first part from MEGA.");
+    }
+    return out;
+}
+/* ------------------------------------------------------------------ */
+/* Public contract (same signatures as the native proxy)               */
+/* ------------------------------------------------------------------ */
+/** Idempotent: registers the Service Worker once per app lifetime (no-op after). */
+export async function ensureProxy() {
+    await ensureSw();
+}
+/** Registers one MEGA link as its own keyed session; returns its playable URL. */
+export async function createStream(megaUrl) {
+    if (!megaUrl?.trim())
+        throw new Error("No MEGA file to stream.");
+    const sessionId = newSessionId();
+    const blobUrls = [];
+    let url;
+    try {
+        if (await ensureSw()) {
+            [url] = await startStreaming(sessionId, [{ name: "stream.mp4", url: megaUrl.trim() }]);
+        }
+        else {
+            console.warn("[megaStream] no service worker — falling back to full Blob download");
+            url = await megaToBlobUrl(megaUrl, blobUrls);
+            console.log(`[megaStream] session ${sessionId}: serving 1 file via ${url.slice(0, 40)}…`);
+        }
+    }
+    catch (e) {
+        revokeUrls(blobUrls);
+        throw e;
+    }
+    sessions.set(sessionId, { blobUrls });
+    return { url, sessionId };
+}
+/**
+ * Returns the ordered URLs the player should play in sequence, plus the session
+ * id to release later. On the Service Worker path every URL is streamed from
+ * MEGA on demand (start + HTTP Range) exactly like the mobile proxy; nothing is
+ * downloaded up front.
+ */
+export async function createStreams(megaUrls) {
+    const clean = (megaUrls ?? []).map((u) => u?.trim()).filter(Boolean);
+    if (!clean.length)
+        throw new Error("No video parts to stream.");
+    const sessionId = newSessionId();
+    const blobUrls = [];
+    let urls;
+    try {
+        if (await ensureSw()) {
+            urls = await startStreaming(sessionId, clean.map((u, i) => ({ name: `part-${i}.mp4`, url: u })));
+        }
+        else {
+            console.warn("[megaStream] no service worker — falling back to full Blob download");
+            urls = await startBlobFallback(clean, blobUrls);
+        }
+    }
+    catch (e) {
+        revokeUrls(blobUrls);
+        throw e;
+    }
+    sessions.set(sessionId, { blobUrls });
+    return { urls, sessionId };
+}
+/** Tears down one session: clears its worker part map and revokes its Blob URLs. */
+export function releaseStream(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session)
+        return;
+    sessions.delete(sessionId);
+    void sendToSw({ type: "clear", session: sessionId });
+    revokeUrls(session.blobUrls);
+    console.log(`[megaStream] released session ${sessionId}`);
+}
+/** Tear-down for tests / HMR: clears every session and the worker cache. */
+export function stopProxy() {
+    for (const id of Array.from(sessions.keys()))
+        releaseStream(id);
+    swCache = null;
+}

package/dist/ranges.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared HTTP Range parsing used by BOTH the native TCP proxy and the web
+ * Service Worker, so every platform answers `Range` headers identically.
+ */
+export type RangeResult = {
+    satisfiable: true;
+    start: number;
+    end: number;
+    length: number;
+    partial: boolean;
+} | {
+    satisfiable: false;
+};
+/**
+ * Parses an HTTP `Range` request header (`bytes=...`) against a known size.
+ *
+ * - `bytes=start-end`   explicit window
+ * - `bytes=start-`      open-ended
+ * - `bytes=-N`          suffix (last N bytes)
+ * - no header / `null`  full body (200)
+ * - invalid / out of range → `{ satisfiable: false }` (answer 416)
+ */
+export declare function parseRange(rangeHeader: string | null | undefined, size: number): RangeResult;
+/** Breaks a range into the MEGA byte offsets consumeable by file.download({start,end}). */
+export declare function toMegaRange(r: RangeResult): {
+    start: number;
+    end: number;
+} | null;
+/** Response headers for a range-capable stream of one file. */
+export declare function rangeHeaders(r: RangeResult, size: number, contentType?: string): Record<string, string>;

package/dist/ranges.js

@@ -0,0 +1,63 @@
+/**
+ * Shared HTTP Range parsing used by BOTH the native TCP proxy and the web
+ * Service Worker, so every platform answers `Range` headers identically.
+ */
+/**
+ * Parses an HTTP `Range` request header (`bytes=...`) against a known size.
+ *
+ * - `bytes=start-end`   explicit window
+ * - `bytes=start-`      open-ended
+ * - `bytes=-N`          suffix (last N bytes)
+ * - no header / `null`  full body (200)
+ * - invalid / out of range → `{ satisfiable: false }` (answer 416)
+ */
+export function parseRange(rangeHeader, size) {
+    if (!rangeHeader) {
+        return { satisfiable: true, start: 0, end: size - 1, length: size, partial: false };
+    }
+    if (size < 0)
+        return { satisfiable: false };
+    const m = /^bytes=(\d*)-(\d*)$/i.exec(rangeHeader.trim());
+    if (!m || (m[1] === "" && m[2] === ""))
+        return { satisfiable: false };
+    const rawStart = m[1] === "" ? -1 : Number(m[1]);
+    const rawEnd = m[2] === "" ? -1 : Number(m[2]);
+    if (Number.isNaN(rawStart) || Number.isNaN(rawEnd) || size === 0) {
+        return { satisfiable: false };
+    }
+    let start;
+    let end;
+    if (rawStart === -1) {
+        // suffix range: last N bytes
+        start = Math.max(size - rawEnd, 0);
+        end = size - 1;
+    }
+    else {
+        start = rawStart;
+        end = rawEnd === -1 || rawEnd >= size ? size - 1 : rawEnd;
+        if (start > end || start >= size)
+            return { satisfiable: false };
+    }
+    // Any explicit Range header (even bytes=0-) is answered with a 206,
+    // matching what range-capable servers (nginx, lighttpd) do.
+    return { satisfiable: true, start, end, length: end - start + 1, partial: true };
+}
+/** Breaks a range into the MEGA byte offsets consumeable by file.download({start,end}). */
+export function toMegaRange(r) {
+    if (!r.satisfiable)
+        return null;
+    return { start: r.start, end: r.end };
+}
+/** Response headers for a range-capable stream of one file. */
+export function rangeHeaders(r, size, contentType = "video/mp4") {
+    const headers = {
+        "Content-Type": contentType,
+        "Accept-Ranges": "bytes",
+        "Content-Length": String(r.satisfiable ? r.length : 0),
+        "Cache-Control": "no-store",
+    };
+    if (r.satisfiable && r.partial) {
+        headers["Content-Range"] = `bytes ${r.start}-${r.end}/${size}`;
+    }
+    return headers;
+}

package/dist/stream.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Downloads + decrypts a MEGA link, invoking onChunk for each ~1MB chunk as it
+ * arrives (backpressure-aware). Used by the web proxy's Blob fallback and by
+ * consumers that want the raw bytes. No files are written by this function.
+ */
+export declare function collectMegaFileStream(url: string, onChunk: (chunk: Uint8Array) => Promise<void>): Promise<{
+    name: string;
+    size: number;
+}>;

package/dist/stream.js

@@ -0,0 +1,100 @@
+import { withTimeout } from "./megaFile.js";
+const ATTRS_TIMEOUT_MS = 30_000;
+const STALL_TIMEOUT_MS = 60_000;
+const CHUNK_SIZE = 1024 * 1024; // 1MB flush target
+/**
+ * Downloads + decrypts a MEGA link, invoking onChunk for each ~1MB chunk as it
+ * arrives (backpressure-aware). Used by the web proxy's Blob fallback and by
+ * consumers that want the raw bytes. No files are written by this function.
+ */
+export async function collectMegaFileStream(url, onChunk) {
+    const file = await loadFileFromUrl(url);
+    await withTimeout(file.loadAttributes(), ATTRS_TIMEOUT_MS, "MEGA did not respond. Check your connection and try again.");
+    const name = file.name || "mega-download";
+    const size = Number(file.size ?? 0);
+    return new Promise((resolve, reject) => {
+        let totalBytes = 0;
+        let lastDataAt = Date.now();
+        let paused = false;
+        let buffer = [];
+        let bufferSize = 0;
+        let ended = false;
+        let stream;
+        const fail = (err) => {
+            clearInterval(watchdog);
+            try {
+                stream?.destroy?.();
+            }
+            catch { }
+            reject(err);
+        };
+        const flush = async () => {
+            if (buffer.length === 0)
+                return;
+            paused = true;
+            let total = 0;
+            for (const c of buffer)
+                total += c.length;
+            const combined = new Uint8Array(total);
+            let offset = 0;
+            for (const c of buffer) {
+                combined.set(c, offset);
+                offset += c.length;
+            }
+            buffer = [];
+            bufferSize = 0;
+            try {
+                await onChunk(combined);
+                paused = false;
+                if (!ended)
+                    stream?.resume?.();
+            }
+            catch (error) {
+                fail(error instanceof Error ? error : new Error(String(error)));
+            }
+        };
+        const watchdog = setInterval(() => {
+            const elapsed = Date.now() - lastDataAt;
+            if (elapsed > STALL_TIMEOUT_MS && !paused) {
+                fail(new Error("Download stalled (no data received)."));
+            }
+        }, 5000);
+        try {
+            stream = file.download({});
+        }
+        catch (e) {
+            clearInterval(watchdog);
+            reject(e instanceof Error ? e : new Error(String(e)));
+            return;
+        }
+        stream.on("data", (chunk) => {
+            lastDataAt = Date.now();
+            totalBytes += chunk.length;
+            const copy = new Uint8Array(chunk.byteLength);
+            copy.set(chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+            buffer.push(copy);
+            bufferSize += copy.length;
+            if (bufferSize >= CHUNK_SIZE)
+                void flush();
+        });
+        stream.on("error", (e) => {
+            fail(e instanceof Error ? e : new Error(String(e)));
+        });
+        stream.on("end", async () => {
+            ended = true;
+            clearInterval(watchdog);
+            await flush();
+            resolve({ name, size: totalBytes || size });
+        });
+        stream.resume?.();
+    });
+}
+async function loadFileFromUrl(url) {
+    try {
+        const { File } = (await import("megajs"));
+        return File.fromURL(url.trim());
+    }
+    catch {
+        throw new Error("Invalid MEGA link.");
+    }
+}