@simon_he/vue-tui 1.1.1 → 1.1.2

package/dist/experimental/video/node.cjs

@@ -0,0 +1,497 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+
+// src/experimental/video/node.ts
+var node_exports = {};
+__export(node_exports, {
+  createFfmpegVideoFrameSource: () => createFfmpegVideoFrameSource,
+  createYtDlpVideoFrameSource: () => createYtDlpVideoFrameSource
+});
+module.exports = __toCommonJS(node_exports);
+
+// src/cli/video/png-frame-parser.ts
+var PNG_SIGNATURE = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+function readUint32(bytes, offset) {
+  return bytes[offset] * 16777216 + (bytes[offset + 1] << 16) + (bytes[offset + 2] << 8) + bytes[offset + 3] >>> 0;
+}
+function hasPngSignature(bytes, offset) {
+  for (let index = 0; index < PNG_SIGNATURE.length; index++)
+    if (bytes[offset + index] !== PNG_SIGNATURE[index])
+      return !1;
+  return !0;
+}
+function isChunkType(bytes, offset, type) {
+  return bytes[offset] === type.charCodeAt(0) && bytes[offset + 1] === type.charCodeAt(1) && bytes[offset + 2] === type.charCodeAt(2) && bytes[offset + 3] === type.charCodeAt(3);
+}
+function validatePngHeader(bytes, offset, maxDimension) {
+  if (readUint32(bytes, offset + 8) !== 13 || !isChunkType(bytes, offset + 12, "IHDR"))
+    throw new Error("FFmpeg emitted a PNG without a valid IHDR chunk");
+  let width = readUint32(bytes, offset + 16), height = readUint32(bytes, offset + 20);
+  if (width <= 0 || height <= 0 || width > maxDimension || height > maxDimension)
+    throw new Error(`FFmpeg emitted an unsupported PNG size: ${width}x${height}`);
+}
+async function* parsePngFrames(chunks, options) {
+  let pending = new Uint8Array(Math.min(65536, options.maxFrameBytes)), length = 0, frameStart = 0, cursor = 0, headerValidated = !1;
+  for await (let chunk of chunks) {
+    frameStart > 0 && (pending.copyWithin(0, frameStart, length), length -= frameStart, cursor -= frameStart, frameStart = 0);
+    let required = length + chunk.length;
+    if (required > pending.length) {
+      let capacity = Math.max(1, pending.length);
+      for (; capacity < required && capacity < options.maxFrameBytes; )
+        capacity = Math.min(options.maxFrameBytes, capacity * 2);
+      let grown = new Uint8Array(Math.max(required, capacity));
+      grown.set(pending.subarray(0, length)), pending = grown;
+    }
+    for (pending.set(chunk, length), length = required; length - frameStart >= PNG_SIGNATURE.length; ) {
+      if (cursor === frameStart) {
+        if (!hasPngSignature(pending, frameStart))
+          throw new Error("FFmpeg emitted invalid PNG data");
+        cursor = frameStart + PNG_SIGNATURE.length;
+      }
+      if (!headerValidated) {
+        if (length - frameStart < 33)
+          break;
+        validatePngHeader(pending, frameStart, options.maxDimension), headerValidated = !0;
+      }
+      if (length - cursor < 12)
+        break;
+      let chunkBytes = readUint32(pending, cursor), chunkEnd = cursor + 12 + chunkBytes;
+      if (chunkEnd - frameStart > options.maxFrameBytes)
+        throw new Error(`FFmpeg PNG frame exceeded ${options.maxFrameBytes} bytes`);
+      if (chunkEnd > length)
+        break;
+      if (isChunkType(pending, cursor + 4, "IEND")) {
+        if (chunkBytes !== 0)
+          throw new Error("FFmpeg emitted an invalid PNG IEND chunk");
+        yield new Uint8Array(pending.subarray(frameStart, chunkEnd)), frameStart = chunkEnd, cursor = frameStart, headerValidated = !1, frameStart === length && (length = 0, frameStart = 0, cursor = 0);
+        continue;
+      }
+      cursor = chunkEnd;
+    }
+    if (length - frameStart > options.maxFrameBytes)
+      throw new Error(`FFmpeg PNG frame exceeded ${options.maxFrameBytes} bytes`);
+  }
+  if (length !== frameStart)
+    throw new Error("FFmpeg PNG stream ended with a truncated frame");
+}
+
+// src/cli/video/raw-frame-parser.ts
+async function* parseRawFrames(chunks, frameBytes) {
+  if (!Number.isSafeInteger(frameBytes) || frameBytes <= 0)
+    throw new Error("FFmpeg raw video frame size must be a positive integer");
+  let frame = new Uint8Array(frameBytes), frameOffset = 0;
+  for await (let chunk of chunks) {
+    let chunkOffset = 0;
+    for (; chunkOffset < chunk.length; ) {
+      let copyBytes = Math.min(frameBytes - frameOffset, chunk.length - chunkOffset);
+      frame.set(chunk.subarray(chunkOffset, chunkOffset + copyBytes), frameOffset), frameOffset += copyBytes, chunkOffset += copyBytes, frameOffset === frameBytes && (yield frame, frame = new Uint8Array(frameBytes), frameOffset = 0);
+    }
+  }
+  if (frameOffset !== 0)
+    throw new Error("FFmpeg raw video stream ended with a truncated frame");
+}
+
+// src/cli/video/ffmpeg-frame-source.ts
+var DEFAULT_MAX_FRAME_BYTES = 8 * 1024 * 1024, MAX_PNG_DIMENSION = 4096, MAX_STDERR_CHARS = 16384, KILL_TIMEOUT_MS = 1e3, MIN_FPS = 1e-3;
+function positiveInt(value, fallback, max) {
+  let parsed = Math.floor(Number(value));
+  return !Number.isFinite(parsed) || parsed <= 0 ? fallback : Math.min(max, parsed);
+}
+function positiveNumber(value, fallback, max) {
+  let parsed = Number(value);
+  return !Number.isFinite(parsed) || parsed <= 0 ? fallback : Math.max(MIN_FPS, Math.min(max, parsed));
+}
+function ffmpegNumber(value) {
+  return Number(value.toFixed(3)).toString();
+}
+function ffmpegHttpHeaders(headers) {
+  if (!headers)
+    return "";
+  let lines = [];
+  for (let [name, value] of Object.entries(headers)) {
+    let hasControlCharacter = [...value].some((character) => {
+      let code = character.charCodeAt(0);
+      return code <= 31 || code === 127;
+    });
+    if (!/^[!#$%&'*+.^_`|~\w-]+$/u.test(name) || hasControlCharacter)
+      throw new Error("Invalid FFmpeg HTTP header");
+    lines.push(`${name}: ${value}`);
+  }
+  return lines.length ? `${lines.join(`\r
+`)}\r
+` : "";
+}
+function classifyInput(src, live) {
+  var _a, _b;
+  if (!src.trim())
+    throw new Error("TVideo src must not be empty");
+  if (/^[a-zA-Z]:[\\/]/u.test(src))
+    return { protocolWhitelist: "file", readAtNativeRate: !live };
+  let scheme = (_b = (_a = /^([a-zA-Z][a-zA-Z\d+.-]*):/u.exec(src)) == null ? void 0 : _a[1]) == null ? void 0 : _b.toLowerCase();
+  if (!scheme || scheme === "file")
+    return { protocolWhitelist: "file", readAtNativeRate: !live };
+  if (scheme === "http" || scheme === "https")
+    return {
+      protocolWhitelist: "http,https,httpproxy,tcp,tls",
+      readAtNativeRate: !live
+    };
+  throw new Error(`Unsupported TVideo source protocol: ${scheme}`);
+}
+function pngDimensions(png) {
+  return {
+    width: png[16] * 16777216 + (png[17] << 16) + (png[18] << 8) + png[19] >>> 0,
+    height: png[20] * 16777216 + (png[21] << 16) + (png[22] << 8) + png[23] >>> 0
+  };
+}
+function sanitizeProcessError(value) {
+  let out = "";
+  for (let character of value) {
+    let code = character.charCodeAt(0);
+    code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code >= 127 && code <= 159 || (out += character);
+  }
+  return out.trim();
+}
+function abortError() {
+  let error = new Error("FFmpeg video decoding aborted");
+  return error.name = "AbortError", error;
+}
+function buildFfmpegVideoArgs(context, options = {}) {
+  let live = options.live === !0, realtime = options.realtime !== !1, input = classifyInput(context.src, live), fps = positiveNumber(context.maxFps, 12, 60), playbackRate = positiveNumber(context.playbackRate, 1, 3), width = positiveInt(context.pixelWidth, 320, MAX_PNG_DIMENSION), height = positiveInt(context.pixelHeight, 180, MAX_PNG_DIMENSION), preferredFormat = context.preferredFormat ?? "png", startAtMs = Math.max(0, Number(context.startAtMs) || 0), httpHeaders = input.protocolWhitelist === "file" ? "" : ffmpegHttpHeaders(options.httpHeaders), filters = [
+    playbackRate === 1 ? "setpts=PTS-STARTPTS" : `setpts=(PTS-STARTPTS)/${ffmpegNumber(playbackRate)}`,
+    `fps=${ffmpegNumber(fps)}`,
+    ...realtime ? ["realtime"] : [],
+    `scale=${width}:${height}:force_original_aspect_ratio=decrease:flags=fast_bilinear`,
+    `pad=${width}:${height}:(ow-iw)/2:(oh-ih)/2`
+  ];
+  return [
+    "-nostdin",
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    ...context.loop || options.loop ? ["-stream_loop", "-1"] : [],
+    ...startAtMs > 0 && !live ? ["-ss", ffmpegNumber(startAtMs / 1e3)] : [],
+    ...realtime && input.readAtNativeRate ? ["-readrate", ffmpegNumber(playbackRate)] : [],
+    "-protocol_whitelist",
+    input.protocolWhitelist,
+    ...httpHeaders ? ["-headers", httpHeaders] : [],
+    "-i",
+    context.src,
+    "-map",
+    "0:V:0",
+    "-an",
+    "-sn",
+    "-dn",
+    "-vf",
+    filters.join(","),
+    "-fps_mode",
+    "passthrough",
+    "-threads",
+    "1",
+    ...preferredFormat === "gray8" ? ["-f", "rawvideo", "-c:v", "rawvideo", "-pix_fmt", "gray"] : ["-f", "image2pipe", "-c:v", "png", "-pix_fmt", "rgb24", "-compression_level", "1"],
+    "pipe:1"
+  ];
+}
+function createFfmpegVideoFrameSource(options = {}) {
+  return async function* (context) {
+    var _a;
+    if (context.signal.aborted)
+      throw abortError();
+    let fps = positiveNumber(context.maxFps, 12, 60), playbackRate = positiveNumber(context.playbackRate, 1, 3), startAtMs = Math.max(0, Number(context.startAtMs) || 0), width = positiveInt(context.pixelWidth, 320, MAX_PNG_DIMENSION), height = positiveInt(context.pixelHeight, 180, MAX_PNG_DIMENSION), preferredFormat = context.preferredFormat ?? "png", maxFrameBytes = positiveInt(
+      options.maxFrameBytes,
+      DEFAULT_MAX_FRAME_BYTES,
+      DEFAULT_MAX_FRAME_BYTES
+    ), rawFrameBytes = width * height;
+    if (preferredFormat === "gray8" && rawFrameBytes > maxFrameBytes)
+      throw new Error(`FFmpeg raw video frame exceeded ${maxFrameBytes} bytes`);
+    let { spawn } = await import("node:child_process");
+    if (context.signal.aborted)
+      throw abortError();
+    let executable = ((_a = options.ffmpegPath) == null ? void 0 : _a.trim()) || "ffmpeg", args = buildFfmpegVideoArgs(context, options), child = spawn(executable, args, {
+      shell: !1,
+      windowsHide: !0,
+      stdio: ["ignore", "pipe", "pipe"]
+    }), stdout = child.stdout, stderr = child.stderr, decoder = new TextDecoder(), stderrTail = "", spawnError, closed = !1, aborted = !1, killTimer = null;
+    stderr.on("data", (chunk) => {
+      stderrTail = `${stderrTail}${decoder.decode(chunk, { stream: !0 })}`.slice(
+        -MAX_STDERR_CHARS
+      );
+    });
+    let closePromise = new Promise((resolve) => {
+      child.once("error", (error) => {
+        spawnError = error;
+      }), child.once("close", (code, signal) => {
+        closed = !0, killTimer != null && clearTimeout(killTimer), killTimer = null, stderrTail = `${stderrTail}${decoder.decode()}`.slice(-MAX_STDERR_CHARS), resolve({ code, signal });
+      });
+    }), terminate = () => {
+      var _a2;
+      closed || (child.kill("SIGTERM"), killTimer == null && (killTimer = setTimeout(() => {
+        closed || child.kill("SIGKILL");
+      }, KILL_TIMEOUT_MS), (_a2 = killTimer.unref) == null || _a2.call(killTimer)));
+    }, onAbort = () => {
+      aborted = !0, terminate();
+    };
+    context.signal.addEventListener("abort", onAbort, { once: !0 }), context.signal.aborted && onAbort();
+    let frameIndex = 0;
+    try {
+      if (preferredFormat === "gray8")
+        for await (let pixels of parseRawFrames(stdout, rawFrameBytes)) {
+          if (aborted || context.signal.aborted)
+            throw abortError();
+          let timestampMs = startAtMs + frameIndex * 1e3 * playbackRate / fps;
+          frameIndex++, yield {
+            format: "gray8",
+            pixels,
+            timestampMs,
+            pixelWidth: width,
+            pixelHeight: height
+          };
+        }
+      else
+        for await (let png of parsePngFrames(stdout, {
+          maxFrameBytes,
+          maxDimension: MAX_PNG_DIMENSION
+        })) {
+          if (aborted || context.signal.aborted)
+            throw abortError();
+          let timestampMs = startAtMs + frameIndex * 1e3 * playbackRate / fps;
+          frameIndex++;
+          let dimensions = pngDimensions(png);
+          yield {
+            png,
+            timestampMs,
+            pixelWidth: dimensions.width,
+            pixelHeight: dimensions.height
+          };
+        }
+      let exit = await closePromise;
+      if (aborted || context.signal.aborted)
+        throw abortError();
+      if (spawnError)
+        throw spawnError;
+      if (exit.code !== 0) {
+        let details = sanitizeProcessError(stderrTail);
+        throw new Error(
+          details ? `FFmpeg video decoding failed (${exit.code ?? exit.signal}): ${details}` : `FFmpeg video decoding failed (${exit.code ?? exit.signal})`
+        );
+      }
+    } catch (error) {
+      throw closed || terminate(), await closePromise, aborted || context.signal.aborted ? abortError() : spawnError || error;
+    } finally {
+      context.signal.removeEventListener("abort", onAbort), closed || terminate();
+    }
+  };
+}
+
+// src/cli/video/yt-dlp-frame-source.ts
+var DEFAULT_MAX_SOURCE_HEIGHT = 720, MAX_SOURCE_HEIGHT = 4320, MAX_METADATA_BYTES = 128 * 1024, MAX_STDERR_CHARS2 = 16384, KILL_TIMEOUT_MS2 = 1e3, RESOLVED_INPUT_TTL_MS = 5 * 60 * 1e3, METADATA_TEMPLATE = "%(.{url,http_headers,protocol,width,height,fps,vcodec,duration})j", COMMON_SOURCE_HEIGHTS = [144, 240, 360, 480, 720, 1080, 1440, 2160, 4320];
+function positiveInt2(value, fallback, max) {
+  let parsed = Math.floor(Number(value));
+  return !Number.isFinite(parsed) || parsed <= 0 ? fallback : Math.min(max, parsed);
+}
+function resolveSourceHeight(options, context) {
+  let maxSourceHeight = positiveInt2(
+    options.maxSourceHeight,
+    DEFAULT_MAX_SOURCE_HEIGHT,
+    MAX_SOURCE_HEIGHT
+  );
+  if (!context)
+    return maxSourceHeight;
+  let minimum = context.preferredFormat === "gray8" ? 144 : 360, requested = Math.max(minimum, positiveInt2(context.pixelHeight, minimum, MAX_SOURCE_HEIGHT)), rounded = COMMON_SOURCE_HEIGHTS.find((height) => height >= requested) ?? MAX_SOURCE_HEIGHT;
+  return Math.min(maxSourceHeight, rounded);
+}
+function resolveSourceFps(context) {
+  let requested = Number(context == null ? void 0 : context.maxFps);
+  return Math.max(30, Number.isFinite(requested) && requested > 0 ? Math.ceil(requested) : 30);
+}
+function abortError2() {
+  let error = new Error("yt-dlp video URL resolution aborted");
+  return error.name = "AbortError", error;
+}
+function sanitizeProcessError2(value) {
+  let out = "";
+  for (let character of value) {
+    let code = character.charCodeAt(0);
+    code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31 || code >= 127 && code <= 159 || (out += character);
+  }
+  return out.trim();
+}
+function assertHttpUrl(value, label) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`${label} must be an HTTP(S) URL`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:")
+    throw new Error(`${label} must be an HTTP(S) URL`);
+  return url.href;
+}
+function buildYtDlpVideoArgs(src, options = {}, context) {
+  var _a;
+  let source = assertHttpUrl(src, "yt-dlp source"), sourceHeight = resolveSourceHeight(options, context), sourceFps = resolveSourceFps(context), format = ((_a = options.format) == null ? void 0 : _a.trim()) || [
+    `bestvideo[height<=${sourceHeight}][fps<=${sourceFps}][protocol^=http][vcodec^=avc1]`,
+    `bestvideo[height<=${sourceHeight}][fps<=${sourceFps}][protocol^=http]`,
+    `bestvideo[height<=${sourceHeight}][protocol^=http][vcodec^=avc1]`,
+    `bestvideo[height<=${sourceHeight}][protocol^=http]`,
+    `best[height<=${sourceHeight}][fps<=${sourceFps}][protocol^=http]`,
+    `best[height<=${sourceHeight}][protocol^=http]`
+  ].join("/");
+  return [
+    "--no-config",
+    "--no-playlist",
+    "--no-warnings",
+    "--simulate",
+    "--print",
+    METADATA_TEMPLATE,
+    "--format",
+    format,
+    "--",
+    source
+  ];
+}
+async function resolveYtDlpVideoInput(src, signal, options, context) {
+  var _a;
+  if (signal.aborted)
+    throw abortError2();
+  let { spawn } = await import("node:child_process");
+  if (signal.aborted)
+    throw abortError2();
+  let executable = ((_a = options.ytDlpPath) == null ? void 0 : _a.trim()) || "yt-dlp", child = spawn(executable, buildYtDlpVideoArgs(src, options, context), {
+    shell: !1,
+    windowsHide: !0,
+    stdio: ["ignore", "pipe", "pipe"]
+  }), decoder = new TextDecoder(), stderrDecoder = new TextDecoder(), stdout = "", stdoutBytes = 0, stderrTail = "", spawnError, metadataTooLarge = !1, closed = !1, aborted = !1, killTimer = null, terminate = () => {
+    var _a2;
+    closed || (child.kill("SIGTERM"), killTimer == null && (killTimer = setTimeout(() => {
+      closed || child.kill("SIGKILL");
+    }, KILL_TIMEOUT_MS2), (_a2 = killTimer.unref) == null || _a2.call(killTimer)));
+  };
+  child.stdout.on("data", (chunk) => {
+    if (stdoutBytes += chunk.byteLength, stdoutBytes > MAX_METADATA_BYTES) {
+      metadataTooLarge = !0, terminate();
+      return;
+    }
+    stdout += decoder.decode(chunk, { stream: !0 });
+  }), child.stderr.on("data", (chunk) => {
+    stderrTail = `${stderrTail}${stderrDecoder.decode(chunk, { stream: !0 })}`.slice(
+      -MAX_STDERR_CHARS2
+    );
+  });
+  let closePromise = new Promise(
+    (resolve) => {
+      child.once("error", (error) => {
+        spawnError = error;
+      }), child.once("close", (code, closeSignal) => {
+        closed = !0, killTimer != null && clearTimeout(killTimer), killTimer = null, stdout += decoder.decode(), stderrTail = `${stderrTail}${stderrDecoder.decode()}`.slice(-MAX_STDERR_CHARS2), resolve({ code, signal: closeSignal });
+      });
+    }
+  ), onAbort = () => {
+    aborted = !0, terminate();
+  };
+  signal.addEventListener("abort", onAbort, { once: !0 }), signal.aborted && onAbort();
+  try {
+    let exit = await closePromise;
+    if (aborted || signal.aborted)
+      throw abortError2();
+    if (metadataTooLarge)
+      throw new Error("yt-dlp video metadata exceeded 131072 bytes");
+    if (spawnError) {
+      let details = spawnError instanceof Error ? spawnError.message : String(spawnError);
+      throw new Error(`yt-dlp video URL resolution failed: ${details}`);
+    }
+    if (exit.code !== 0) {
+      let details = sanitizeProcessError2(stderrTail);
+      throw new Error(
+        details ? `yt-dlp video URL resolution failed (${exit.code ?? exit.signal}): ${details}` : `yt-dlp video URL resolution failed (${exit.code ?? exit.signal})`
+      );
+    }
+    let lines = stdout.trim().split(/\r?\n/u).filter(Boolean);
+    if (lines.length !== 1)
+      throw new Error("yt-dlp returned invalid video metadata");
+    let metadata;
+    try {
+      metadata = JSON.parse(lines[0]);
+    } catch {
+      throw new Error("yt-dlp returned invalid video metadata");
+    }
+    if (!metadata || typeof metadata != "object")
+      throw new Error("yt-dlp returned invalid video metadata");
+    let raw = metadata;
+    if (typeof raw.url != "string")
+      throw new Error("yt-dlp returned invalid video metadata");
+    let url = assertHttpUrl(raw.url, "yt-dlp resolved video URL"), httpHeaders = {};
+    if (raw.http_headers != null) {
+      if (typeof raw.http_headers != "object" || Array.isArray(raw.http_headers))
+        throw new Error("yt-dlp returned invalid video metadata");
+      for (let [name, value] of Object.entries(raw.http_headers)) {
+        if (typeof value != "string")
+          throw new Error("yt-dlp returned invalid video metadata");
+        httpHeaders[name] = value;
+      }
+    }
+    let durationMs;
+    if (raw.duration != null) {
+      if (typeof raw.duration != "number" || !Number.isFinite(raw.duration) || raw.duration < 0)
+        throw new Error("yt-dlp returned invalid video metadata");
+      durationMs = Math.round(raw.duration * 1e3);
+    }
+    return { url, httpHeaders, durationMs };
+  } finally {
+    signal.removeEventListener("abort", onAbort), closed || terminate();
+  }
+}
+function createYtDlpVideoFrameSource(options = {}) {
+  let resolvedInputs = /* @__PURE__ */ new Map();
+  return async function* (context) {
+    if (context.signal.aborted)
+      throw abortError2();
+    let cacheKey = JSON.stringify(buildYtDlpVideoArgs(context.src, options, context)), cached = resolvedInputs.get(cacheKey), input;
+    cached && cached.expiresAtMs > Date.now() ? input = cached.input : (cached && resolvedInputs.delete(cacheKey), input = await resolveYtDlpVideoInput(context.src, context.signal, options, context), resolvedInputs.set(cacheKey, {
+      input,
+      expiresAtMs: Date.now() + RESOLVED_INPUT_TTL_MS
+    }));
+    let frames = await createFfmpegVideoFrameSource({
+      ffmpegPath: options.ffmpegPath,
+      live: options.live,
+      realtime: options.realtime,
+      maxFrameBytes: options.maxFrameBytes,
+      httpHeaders: input.httpHeaders
+    })({ ...context, src: input.url });
+    try {
+      if (input.durationMs == null) {
+        yield* frames;
+        return;
+      }
+      for await (let frame of frames)
+        yield { ...frame, durationMs: input.durationMs };
+    } catch (error) {
+      throw error instanceof Error && error.name === "AbortError" || resolvedInputs.delete(cacheKey), error;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFfmpegVideoFrameSource,
+  createYtDlpVideoFrameSource
+});

package/dist/experimental/video/node.d.cts

@@ -0,0 +1,4 @@
+export { createFfmpegVideoFrameSource } from "../../cli/video/ffmpeg-frame-source.js";
+export type { FfmpegVideoFrameSourceOptions } from "../../cli/video/ffmpeg-frame-source.js";
+export { createYtDlpVideoFrameSource } from "../../cli/video/yt-dlp-frame-source.js";
+export type { YtDlpVideoFrameSourceOptions } from "../../cli/video/yt-dlp-frame-source.js";

package/dist/experimental/video/node.d.ts

@@ -0,0 +1,4 @@
+export { createFfmpegVideoFrameSource } from "../../cli/video/ffmpeg-frame-source.js";
+export type { FfmpegVideoFrameSourceOptions } from "../../cli/video/ffmpeg-frame-source.js";
+export { createYtDlpVideoFrameSource } from "../../cli/video/yt-dlp-frame-source.js";
+export type { YtDlpVideoFrameSourceOptions } from "../../cli/video/yt-dlp-frame-source.js";