@flow-player/test-streams 0.6.0 → 0.6.1

package/{src/cli/extend-vod.ts → dist/cli/extend-vod.js}

@@ -1,38 +1,30 @@
 #!/usr/bin/env node
-// 单独生成 30s/段、1s GOP 的 H.264 + AAC LC MP4 fixture,
-// 复制到 vod/sample-1.mp4 与 vod/sample-2.mp4,
-// 并把 vod 段总时长写进 manifest.json(供 /streams/vod-list 端点使用)。
-//
-// 跟 generate.ts 解耦:不重跑 codec × format 矩阵,只补充 VOD 段。
-// 不改 fixture 矩阵(gop=5*25 锁单 GOP,保持 fast feedback),只让 VOD 段足够长
-// 供 e2e / 人工验证多 GOP 倒放语义。每段 30s、GOP=1s,30 段共 15 分钟素材。
-// 倒放 1s GOP 间隔保留:每段 30 GOP,跨段 GOP 序号连续,worker gopBuffer
-// 30 GOP 窗口下足以验证任意点倒放回跳。
+
+// packages/test-streams/src/cli/extend-vod.ts
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { join, resolve } from "node:path";
-import { DEFAULT_FIXTURE_DIR, type Manifest } from "../index.ts";
 
-type Options = {
-  fixtureDir: string;
-  segmentSeconds: number;
-  segmentCount: number;
-  gopSeconds: number;
-  width: number;
-  height: number;
-  fps: number;
-};
+// packages/test-streams/src/config.ts
+var DEFAULT_FIXTURE_DIR = "fixtures";
+var ALL_CODECS = ["h264", "hevc"];
+var ALL_FORMATS = ["flv", "hls", "mp4", "fmp4", "ts"];
+
+// packages/test-streams/src/server/routes.ts
+var FORMAT_SET = Object.fromEntries(ALL_FORMATS.map((f) => [f, true]));
+var CODEC_SET = Object.fromEntries(ALL_CODECS.map((c) => [c, true]));
 
-function parseArgs(argv: ReadonlyArray<string>): Options & { help: boolean } {
-  const opts: Options = {
+// packages/test-streams/src/cli/extend-vod.ts
+function parseArgs(argv) {
+  const opts = {
     fixtureDir: DEFAULT_FIXTURE_DIR,
     segmentSeconds: 30,
     segmentCount: 20,
     gopSeconds: 1,
     width: 1280,
     height: 720,
-    fps: 25,
+    fps: 25
   };
   let help = false;
   for (let i = 0; i < argv.length; i += 1) {
@@ -56,8 +48,7 @@ function parseArgs(argv: ReadonlyArray<string>): Options & { help: boolean } {
   }
   return { ...opts, help };
 }
-
-const USAGE = `Usage:
+var USAGE = `Usage:
   pnpm --filter @flow-player/test-streams run extend-vod [-- <args>]
 
 Options:
@@ -68,13 +59,11 @@ Options:
   --width <px>             Video width (default: 1280)
   --height <px>            Video height (default: 720)
  `;
-
-function hashFile(abs: string): string {
+function hashFile(abs) {
   return createHash("sha256").update(readFileSync(abs)).digest("hex");
 }
-
-async function runFfmpeg(ffmpegPath: string, args: ReadonlyArray<string>): Promise<number> {
-  return await new Promise<number>((resolveRun, rejectRun) => {
+async function runFfmpeg(ffmpegPath, args) {
+  return await new Promise((resolveRun, rejectRun) => {
     const child = spawn(ffmpegPath, args, { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     child.stderr.on("data", (b) => {
@@ -89,8 +78,7 @@ async function runFfmpeg(ffmpegPath: string, args: ReadonlyArray<string>): Promi
     });
   });
 }
-
-async function findFfmpeg(): Promise<string | null> {
+async function findFfmpeg() {
   const candidates = ["ffmpeg", "/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg"];
   for (const path of candidates) {
     const code = await runFfmpeg(path, ["-version"]);
@@ -98,8 +86,7 @@ async function findFfmpeg(): Promise<string | null> {
   }
   return null;
 }
-
-async function main(): Promise<number> {
+async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (args.help) {
     process.stdout.write(USAGE);
@@ -115,22 +102,15 @@ async function main(): Promise<number> {
   mkdirSync(vodDir, { recursive: true });
   const gop = String(args.gopSeconds * args.fps);
   process.stdout.write(
-    `[extend-vod] generating ${args.segmentCount} segments x ${args.segmentSeconds}s ` +
-      `${args.width}x${args.height}@${args.fps} mp4 h264+aac, gop=${gop} frames ` +
-      `(${args.gopSeconds}s); total VOD=${args.segmentCount * args.segmentSeconds}s\n`,
+    `[extend-vod] generating ${args.segmentCount} segments x ${args.segmentSeconds}s ${args.width}x${args.height}@${args.fps} mp4 h264+aac, gop=${gop} frames (${args.gopSeconds}s); total VOD=${args.segmentCount * args.segmentSeconds}s
+`
   );
-  const segments: Array<{ index: number; path: string; size: number; sha256: string }> = [];
+  const segments = [];
   for (let i = 0; i < args.segmentCount; i += 1) {
     const index = i + 1;
     const file = join(vodDir, `seg-${String(index).padStart(3, "0")}.mp4`);
-    // 每段用不同音高 + 起始时间偏移,让相邻段可视/可听差异化,便于人工验证
-    // 段间的 monotonic start time 让 GOP / 帧序号跨越段连续
     const startSec = i * args.segmentSeconds;
     const frequency = 220 + i * 40;
-    // D 轨: 输出 fragmented MP4 (fMP4) 让 MSE 模式可直接 appendBuffer。
-    // 非 fragmented MP4 的 mdat 偏移依赖 stco, MSE 的 SourceBuffer demuxer 解析时会失败
-    // (典型症状: video.error = "PIPELINE_ERROR_DECODE: Failed to send audio packet for decoding")。
-    // +empty_moov 把 moov 写到开头; +frag_keyframe 在每个关键帧边界开 fragment。
     const ffmpegArgs = [
       "-y",
       "-f",
@@ -171,51 +151,49 @@ async function main(): Promise<number> {
       "+faststart",
       "-metadata",
       `start_time=${startSec}`,
-      file,
+      file
     ];
     const code = await runFfmpeg(ffmpegPath, ffmpegArgs);
     const size = statSync(file).size;
     const sha256 = hashFile(file);
     segments.push({ index, path: `vod/seg-${String(index).padStart(3, "0")}.mp4`, size, sha256 });
   }
-  // 写 vod-list.json 让 handleVodList 端点能返回 N 段
   const vodList = {
     version: 1,
-    generatedAt: new Date().toISOString(),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     segmentSeconds: args.segmentSeconds,
     segmentCount: args.segmentCount,
     gopSeconds: args.gopSeconds,
-    entries: segments,
+    entries: segments
   };
   const vodListPath = join(vodDir, "vod-list.json");
   writeFileSync(vodListPath, JSON.stringify(vodList, null, 2));
-  process.stdout.write(`[extend-vod] wrote ${vodListPath}\n`);
-  // 更新 manifest.json 的 durationSeconds 为 "per-segment duration",
-  // 并附带 segmentCount 字段,让 handleVodList 知道总段数。
+  process.stdout.write(`[extend-vod] wrote ${vodListPath}
+`);
   const manifestPath = join(fixtureDir, "manifest.json");
   if (existsSync(manifestPath)) {
-    const manifest = JSON.parse(readFileSync(manifestPath, "utf8")) as Manifest;
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
     manifest.durationSeconds = args.segmentSeconds;
-    manifest.generatedAt = new Date().toISOString();
-    (manifest as Manifest & { segmentCount?: number }).segmentCount = args.segmentCount;
+    manifest.generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    manifest.segmentCount = args.segmentCount;
     writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
     process.stdout.write(
-      `[extend-vod] updated ${manifestPath} durationSeconds=${args.segmentSeconds} ` +
-        `segmentCount=${args.segmentCount}\n`,
+      `[extend-vod] updated ${manifestPath} durationSeconds=${args.segmentSeconds} segmentCount=${args.segmentCount}
+`
     );
   } else {
     process.stdout.write(
-      `[extend-vod] ${manifestPath} not found; skipping manifest update ` +
-        `(run pnpm run generate first)\n`,
+      `[extend-vod] ${manifestPath} not found; skipping manifest update (run pnpm run generate first)
+`
     );
   }
   return 0;
 }
-
 void main().then(
   (code) => process.exit(code),
-  (err: unknown) => {
-    process.stderr.write(`[extend-vod] unexpected error: ${String(err)}\n`);
+  (err) => {
+    process.stderr.write(`[extend-vod] unexpected error: ${String(err)}
+`);
     process.exit(2);
-  },
+  }
 );

package/dist/cli/generate.js

@@ -0,0 +1,473 @@
+#!/usr/bin/env node
+
+// packages/test-streams/src/cli/generate.ts
+import { dirname, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// packages/test-streams/src/config.ts
+var DEFAULT_FIXTURE_DIR = "fixtures";
+var DEFAULT_DURATION_SECONDS = 5;
+var ALL_CODECS = ["h264", "hevc"];
+var ALL_FORMATS = ["flv", "hls", "mp4", "fmp4", "ts"];
+
+// packages/test-streams/src/fixtures/generate.ts
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { spawn } from "node:child_process";
+import { join as join3, resolve } from "node:path";
+
+// packages/test-streams/src/fixtures/matrix.ts
+import { join as join2 } from "node:path";
+
+// packages/test-streams/src/fixtures/codec.ts
+var CODEC_SPEC = {
+  h264: {
+    codec: "h264",
+    encoder: "libx264",
+    videoArgs: ["-profile:v", "high", "-preset", "veryfast"],
+    audioArgs: ["-c:a", "aac", "-b:a", "128k"],
+    pixelFormat: "yuv420p"
+  },
+  hevc: {
+    codec: "hevc",
+    encoder: "libx265",
+    // 注意:FLV / TS 容器用 enhanced-rtmp 1cvh tag,不能强行写 hvc1;
+    // MP4 / fMP4 / HLS 走 hvc1。containerArgs 在 buildPlan 时按 format 决定。
+    videoArgs: ["-preset", "veryfast"],
+    audioArgs: ["-c:a", "aac", "-b:a", "128k"],
+    pixelFormat: "yuv420p"
+  }
+};
+function containerExtraArgs(format, codec) {
+  if (codec !== "hevc") return [];
+  if (format === "mp4") return ["-tag:v", "hvc1"];
+  return [];
+}
+
+// packages/test-streams/src/fixtures/format.ts
+import { join } from "node:path";
+function formatSpecific(format) {
+  if (format === "flv") return ["-f", "flv"];
+  if (format === "hls") {
+    return [
+      "-f",
+      "hls",
+      "-hls_time",
+      "2",
+      "-hls_playlist_type",
+      "vod",
+      "-hls_segment_type",
+      "mpegts",
+      "-hls_flags",
+      "independent_segments"
+    ];
+  }
+  if (format === "mp4") return ["-f", "mp4", "-movflags", "+faststart"];
+  if (format === "fmp4") {
+    return [
+      "-f",
+      "mp4",
+      "-movflags",
+      "frag_keyframe+empty_moov+default_base_moof",
+      "-frag_duration",
+      "2000000"
+    ];
+  }
+  if (format === "ts") return ["-f", "mpegts"];
+  throw new Error(`Unknown format: ${String(format)}`);
+}
+function layoutFor(codec, format) {
+  if (format === "hls") {
+    return {
+      format,
+      mime: "application/vnd.apple.mpegurl",
+      mainFileName: "master.m3u8",
+      containerArgs: formatSpecific(format),
+      isContainerDirectory: true,
+      sideFiles: ["seg-00000.ts", "seg-00001.ts", "seg-00002.ts"]
+    };
+  }
+  if (format === "fmp4") {
+    return {
+      format,
+      mime: "video/iso.segment",
+      mainFileName: "init.mp4",
+      containerArgs: formatSpecific(format),
+      isContainerDirectory: true,
+      sideFiles: ["seg-00000.m4s", "seg-00001.m4s", "seg-00002.m4s"]
+    };
+  }
+  if (format === "flv") {
+    return {
+      format,
+      mime: "video/x-flv",
+      mainFileName: `${codec}.flv`,
+      containerArgs: formatSpecific(format),
+      isContainerDirectory: false,
+      sideFiles: []
+    };
+  }
+  if (format === "mp4") {
+    return {
+      format,
+      mime: "video/mp4",
+      mainFileName: `${codec}.mp4`,
+      containerArgs: formatSpecific(format),
+      isContainerDirectory: false,
+      sideFiles: []
+    };
+  }
+  if (format === "ts") {
+    return {
+      format,
+      mime: "video/mp2t",
+      mainFileName: `${codec}.ts`,
+      containerArgs: formatSpecific(format),
+      isContainerDirectory: false,
+      sideFiles: []
+    };
+  }
+  throw new Error(`Unknown format: ${String(format)}`);
+}
+function singleFileRelative(codec, format) {
+  return join(format, `${codec}.${format}`);
+}
+function containerRelativeDir(codec, format) {
+  return join(format, codec);
+}
+function containerRelativePath(codec, format, name) {
+  return join(containerRelativeDir(codec, format), name);
+}
+
+// packages/test-streams/src/fixtures/matrix.ts
+function buildPlan(codec, format, durationSeconds) {
+  const layout = layoutFor(codec, format);
+  const spec = CODEC_SPEC[codec];
+  const gop = String(durationSeconds * 25);
+  const videoInput = `testsrc2=size=1280x720:rate=25,format=yuv420p`;
+  const audioInput = `sine=frequency=1000:sample_rate=44100`;
+  const ffmpegOutputArgs = [
+    "-y",
+    "-f",
+    "lavfi",
+    "-i",
+    videoInput,
+    "-f",
+    "lavfi",
+    "-i",
+    audioInput,
+    "-t",
+    String(durationSeconds),
+    "-c:v",
+    spec.encoder,
+    ...spec.videoArgs,
+    "-pix_fmt",
+    spec.pixelFormat,
+    "-g",
+    gop,
+    "-keyint_min",
+    gop,
+    "-sc_threshold",
+    "0",
+    ...containerExtraArgs(format, codec),
+    ...spec.audioArgs,
+    ...layout.containerArgs
+  ];
+  if (layout.isContainerDirectory) {
+    const containerDir2 = containerRelativeDir(codec, format);
+    const mainFile2 = containerRelativePath(codec, format, layout.mainFileName);
+    const files = [
+      mainFile2,
+      ...layout.sideFiles.map((s) => containerRelativePath(codec, format, s))
+    ];
+    return { codec, format, layout, containerDir: containerDir2, mainFile: mainFile2, files, ffmpegOutputArgs };
+  }
+  const mainFile = singleFileRelative(codec, format);
+  const containerDir = join2(mainFile.split("/").slice(0, -1).join("/"));
+  return { codec, format, layout, containerDir, mainFile, files: [mainFile], ffmpegOutputArgs };
+}
+function expandMatrix(opts) {
+  const codecs = opts?.codecs ?? ALL_CODECS;
+  const formats = opts?.formats ?? ALL_FORMATS;
+  const duration = opts?.durationSeconds ?? 5;
+  const plans = [];
+  for (const codec of codecs) {
+    for (const format of formats) {
+      plans.push(buildPlan(codec, format, duration));
+    }
+  }
+  return plans;
+}
+var VOD_SAMPLE_RELATIVE = "mp4/h264.mp4";
+
+// packages/test-streams/src/fixtures/generate.ts
+var FFMPEG_PROBE_ARGS = ["-version"];
+async function generateFixtures(opts = {}) {
+  const ffmpegPath = opts.ffmpegPath ?? await findFfmpeg();
+  if (!ffmpegPath) {
+    return {
+      fixtureDir: resolve(opts.fixtureDir ?? DEFAULT_FIXTURE_DIR),
+      manifest: emptyManifest(opts.durationSeconds ?? DEFAULT_DURATION_SECONDS),
+      generated: 0,
+      skipped: 0,
+      ffmpegPath: "ffmpeg",
+      ffmpegMissing: true
+    };
+  }
+  const fixtureDir = resolve(opts.fixtureDir ?? DEFAULT_FIXTURE_DIR);
+  mkdirSync(fixtureDir, { recursive: true });
+  const duration = opts.durationSeconds ?? DEFAULT_DURATION_SECONDS;
+  const plans = expandMatrix({
+    codecs: opts.codecs ?? ALL_CODECS,
+    formats: opts.formats ?? ALL_FORMATS,
+    durationSeconds: duration
+  });
+  const manifestItems = [];
+  let generated = 0;
+  let skipped = 0;
+  for (const plan of plans) {
+    const item = await generateOne(
+      plan,
+      fixtureDir,
+      ffmpegPath,
+      opts.quiet ?? false,
+      opts.overwrite ?? false
+    );
+    if (item) {
+      manifestItems.push(item);
+      generated += 1;
+    } else {
+      skipped += 1;
+    }
+  }
+  copyVodSamples(fixtureDir);
+  const manifest = {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    durationSeconds: duration,
+    fixtures: manifestItems
+  };
+  writeFileSync(join3(fixtureDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+  return { fixtureDir, manifest, generated, skipped, ffmpegPath, ffmpegMissing: false };
+}
+async function generateOne(plan, fixtureDir, ffmpegPath, quiet, overwrite) {
+  const outDir = join3(fixtureDir, plan.containerDir);
+  mkdirSync(outDir, { recursive: true });
+  const outFile = join3(fixtureDir, plan.mainFile);
+  if (!overwrite && existsSync(outFile)) {
+    return collectExisting(plan, fixtureDir);
+  }
+  if (plan.layout.isContainerDirectory) {
+    for (const f of readdirSync(outDir)) {
+      if (f === plan.layout.mainFileName) continue;
+      rmIfExists(join3(outDir, f));
+    }
+  }
+  const args = plan.ffmpegOutputArgs.concat([outFile]);
+  if (!quiet) {
+    process.stdout.write(`[generate] ${plan.codec}/${plan.format} -> ${plan.mainFile}
+`);
+  }
+  const code = await runFfmpeg(ffmpegPath, args, quiet);
+  if (code !== 0) {
+    throw new Error(`ffmpeg exited with code ${code} for ${plan.codec}/${plan.format}`);
+  }
+  return collectExisting(plan, fixtureDir);
+}
+function collectExisting(plan, fixtureDir) {
+  const entries = [];
+  for (const rel of plan.files) {
+    const abs = join3(fixtureDir, rel);
+    if (!existsSync(abs)) continue;
+    entries.push({ path: rel, size: statSync(abs).size, sha256: hashFile(abs) });
+  }
+  if (plan.layout.isContainerDirectory) {
+    const absDir = join3(fixtureDir, plan.containerDir);
+    if (existsSync(absDir)) {
+      for (const name of readdirSync(absDir).sort()) {
+        if (name === plan.layout.mainFileName) continue;
+        const rel = join3(plan.containerDir, name);
+        if (entries.find((e) => e.path === rel)) continue;
+        const abs = join3(absDir, name);
+        if (!statSync(abs).isFile()) continue;
+        entries.push({ path: rel, size: statSync(abs).size, sha256: hashFile(abs) });
+      }
+    }
+  }
+  return { codec: plan.codec, format: plan.format, entries };
+}
+function copyVodSamples(fixtureDir) {
+  const src = join3(fixtureDir, VOD_SAMPLE_RELATIVE);
+  if (!existsSync(src)) return;
+  const vodDir = join3(fixtureDir, "vod");
+  mkdirSync(vodDir, { recursive: true });
+  for (const name of ["sample-1.mp4", "sample-2.mp4"]) {
+    const dst = join3(vodDir, name);
+    writeFileSync(dst, readFileSync(src));
+  }
+}
+function rmIfExists(abs) {
+  if (!existsSync(abs)) return;
+  try {
+    unlinkSync(abs);
+  } catch {
+  }
+}
+function runFfmpeg(ffmpegPath, args, quiet) {
+  const { promise, resolve: resolve3, reject } = Promise.withResolvers();
+  const proc = spawn(ffmpegPath, args, {
+    stdio: quiet ? ["ignore", "ignore", "ignore"] : "inherit"
+  });
+  proc.once("error", reject);
+  proc.once("exit", (code) => resolve3(code ?? 1));
+  return promise;
+}
+async function findFfmpeg() {
+  const candidates = [
+    "ffmpeg",
+    "/opt/homebrew/bin/ffmpeg",
+    "/usr/local/bin/ffmpeg",
+    "/usr/bin/ffmpeg"
+  ];
+  for (const candidate of candidates) {
+    if (await canRun(candidate)) return candidate;
+  }
+  return null;
+}
+async function canRun(path) {
+  const { promise, resolve: resolve3 } = Promise.withResolvers();
+  const proc = spawn(path, FFMPEG_PROBE_ARGS, { stdio: "ignore" });
+  proc.once("error", () => resolve3(false));
+  proc.once("exit", (code) => resolve3(code === 0));
+  return promise;
+}
+function hashFile(abs) {
+  const hash = createHash("sha256");
+  hash.update(readFileSync(abs));
+  return hash.digest("hex");
+}
+function emptyManifest(duration) {
+  return {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+    durationSeconds: duration,
+    fixtures: []
+  };
+}
+
+// packages/test-streams/src/cli/generate.ts
+var here = dirname(fileURLToPath(import.meta.url));
+var repoRoot = resolve2(here, "..", "..", "..");
+var CODEC_SET = { h264: true, hevc: true };
+var FORMAT_SET = { flv: true, hls: true, mp4: true, fmp4: true, ts: true };
+function parseArgs(argv) {
+  const parsed = {
+    codecs: ALL_CODECS,
+    formats: ALL_FORMATS,
+    durationSeconds: DEFAULT_DURATION_SECONDS,
+    fixtureDir: resolve2(here, "..", "..", DEFAULT_FIXTURE_DIR),
+    overwrite: false,
+    help: false
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    switch (arg) {
+      case "--codecs": {
+        const value = argv[++i] ?? "";
+        const list = value.split(",").map((s) => s.trim()).filter((s) => CODEC_SET[s] === true);
+        if (list.length === 0) throw new Error(`--codecs invalid: ${value}`);
+        parsed.codecs = list;
+        break;
+      }
+      case "--formats": {
+        const value = argv[++i] ?? "";
+        const list = value.split(",").map((s) => s.trim()).filter((s) => FORMAT_SET[s] === true);
+        if (list.length === 0) throw new Error(`--formats invalid: ${value}`);
+        parsed.formats = list;
+        break;
+      }
+      case "--duration": {
+        const value = Number(argv[++i]);
+        if (!Number.isFinite(value) || value <= 0)
+          throw new Error(`--duration must be positive, got ${argv[i]}`);
+        parsed.durationSeconds = value;
+        break;
+      }
+      case "--fixture-dir": {
+        parsed.fixtureDir = resolve2(argv[++i] ?? "");
+        break;
+      }
+      case "--overwrite":
+        parsed.overwrite = true;
+        break;
+      case "--help":
+      case "-h":
+        parsed.help = true;
+        break;
+      default:
+        throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return parsed;
+}
+var USAGE = `Usage:
+  pnpm --filter @flow-player/test-streams run generate [-- <args>]
+
+Options:
+  --codecs <h264,hevc>          Codecs to generate (default: h264,hevc)
+  --formats <flv,hls,mp4,fmp4,ts>
+                                Container formats to generate (default: all 5)
+  --duration <seconds>          Per-fixture duration (default: 5)
+  --fixture-dir <path>          Output directory (default: packages/test-streams/fixtures)
+  --overwrite                   Re-run ffmpeg even if output exists
+  --help, -h                    Show this help
+`;
+async function main() {
+  let args;
+  try {
+    args = parseArgs(process.argv.slice(2));
+  } catch (err) {
+    process.stderr.write(`${err.message}
+${USAGE}`);
+    return 1;
+  }
+  if (args.help) {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+  const result = await generateFixtures({
+    codecs: args.codecs,
+    formats: args.formats,
+    durationSeconds: args.durationSeconds,
+    fixtureDir: args.fixtureDir,
+    overwrite: args.overwrite
+  });
+  if (result.ffmpegMissing) {
+    process.stderr.write(
+      "ffmpeg not found in PATH. Install ffmpeg (brew install ffmpeg) and re-run.\n"
+    );
+    return 0;
+  }
+  process.stdout.write(
+    `Generated ${result.generated} fixture(s) under ${result.fixtureDir}
+Manifest: ${resolve2(result.fixtureDir, "manifest.json")}
+`
+  );
+  return 0;
+}
+main().then(
+  (code) => process.exit(code),
+  (err) => {
+    process.stderr.write(`${err.message}
+`);
+    process.exit(1);
+  }
+);