@flow-player/test-streams 0.6.0 → 0.6.2

package/src/fixtures/generate.ts

@@ -1,209 +0,0 @@
-// ffmpeg 驱动的 fixture 生成器。按 codec × format 矩阵顺序执行 ffmpeg,
-// 把每个 plan 的输出写到 fixtureDir,写完后输出 manifest.json。
-// 设计:不引入 npm 依赖,直接 spawn ffmpeg 子进程。
-import { createHash } from "node:crypto";
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { spawn } from "node:child_process";
-import { join, resolve } from "node:path";
-import {
-  ALL_CODECS,
-  ALL_FORMATS,
-  DEFAULT_DURATION_SECONDS,
-  DEFAULT_FIXTURE_DIR,
-  type GenerateOptions,
-} from "../config.ts";
-import { type FixturePlan, expandMatrix, VOD_SAMPLE_RELATIVE } from "./matrix.ts";
-import { type Manifest, type ManifestEntry, type ManifestItem } from "./catalog.ts";
-
-export type GenerateResult = {
-  fixtureDir: string;
-  manifest: Manifest;
-  generated: number;
-  skipped: number;
-  ffmpegPath: string;
-  ffmpegMissing: boolean;
-};
-
-const FFMPEG_PROBE_ARGS = ["-version"] as const;
-
-export async function generateFixtures(opts: GenerateOptions = {}): Promise<GenerateResult> {
-  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: ManifestItem[] = [];
-  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: Manifest = {
-    version: 1,
-    generatedAt: new Date().toISOString(),
-    durationSeconds: duration,
-    fixtures: manifestItems,
-  };
-  writeFileSync(join(fixtureDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-  return { fixtureDir, manifest, generated, skipped, ffmpegPath, ffmpegMissing: false };
-}
-
-async function generateOne(
-  plan: FixturePlan,
-  fixtureDir: string,
-  ffmpegPath: string,
-  quiet: boolean,
-  overwrite: boolean,
-): Promise<ManifestItem | null> {
-  const outDir = join(fixtureDir, plan.containerDir);
-  mkdirSync(outDir, { recursive: true });
-  const outFile = join(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(join(outDir, f));
-    }
-  }
-  const args = plan.ffmpegOutputArgs.concat([outFile]);
-  if (!quiet) {
-    process.stdout.write(`[generate] ${plan.codec}/${plan.format} -> ${plan.mainFile}\n`);
-  }
-  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: FixturePlan, fixtureDir: string): ManifestItem {
-  const entries: ManifestEntry[] = [];
-  for (const rel of plan.files) {
-    const abs = join(fixtureDir, rel);
-    if (!existsSync(abs)) continue;
-    entries.push({ path: rel, size: statSync(abs).size, sha256: hashFile(abs) });
-  }
-  if (plan.layout.isContainerDirectory) {
-    // HLS / fMP4 容器目录内 ffmpeg 会按命名规则追加 segment(实际文件名不一定
-    // 等于 plan.files 预定义的 seg-00000.ts / seg-00000.m4s,可能形如 master0.ts)。
-    const absDir = join(fixtureDir, plan.containerDir);
-    if (existsSync(absDir)) {
-      for (const name of readdirSync(absDir).sort()) {
-        if (name === plan.layout.mainFileName) continue;
-        const rel = join(plan.containerDir, name);
-        if (entries.find((e) => e.path === rel)) continue;
-        const abs = join(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: string): void {
-  const src = join(fixtureDir, VOD_SAMPLE_RELATIVE);
-  if (!existsSync(src)) return;
-  const vodDir = join(fixtureDir, "vod");
-  mkdirSync(vodDir, { recursive: true });
-  for (const name of ["sample-1.mp4", "sample-2.mp4"]) {
-    const dst = join(vodDir, name);
-    writeFileSync(dst, readFileSync(src));
-  }
-}
-
-function rmIfExists(abs: string): void {
-  if (!existsSync(abs)) return;
-  try {
-    unlinkSync(abs);
-  } catch {
-    // ignore
-  }
-}
-
-function runFfmpeg(
-  ffmpegPath: string,
-  args: ReadonlyArray<string>,
-  quiet: boolean,
-): Promise<number> {
-  const { promise, resolve, reject } = Promise.withResolvers<number>();
-  const proc = spawn(ffmpegPath, args, {
-    stdio: quiet ? ["ignore", "ignore", "ignore"] : "inherit",
-  });
-  proc.once("error", reject);
-  proc.once("exit", (code) => resolve(code ?? 1));
-  return promise;
-}
-
-async function findFfmpeg(): Promise<string | null> {
-  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: string): Promise<boolean> {
-  const { promise, resolve } = Promise.withResolvers<boolean>();
-  const proc = spawn(path, FFMPEG_PROBE_ARGS as unknown as string[], { stdio: "ignore" });
-  proc.once("error", () => resolve(false));
-  proc.once("exit", (code) => resolve(code === 0));
-  return promise;
-}
-
-function hashFile(abs: string): string {
-  const hash = createHash("sha256");
-  hash.update(readFileSync(abs));
-  return hash.digest("hex");
-}
-
-function emptyManifest(duration: number): Manifest {
-  return {
-    version: 1,
-    generatedAt: new Date(0).toISOString(),
-    durationSeconds: duration,
-    fixtures: [],
-  };
-}

package/src/fixtures/matrix.ts

@@ -1,94 +0,0 @@
-// 完整的 codec × format 矩阵 + 单条 fixture plan。
-// 仅依赖 codec.ts / format.ts / config.ts;不引入 ffmpeg,以便单测可脱机运行。
-import { join } from "node:path";
-import { ALL_CODECS, ALL_FORMATS, type CodecId, type FormatId } from "../config.ts";
-import { CODEC_SPEC, containerExtraArgs } from "./codec.ts";
-import {
-  containerRelativeDir,
-  containerRelativePath,
-  layoutFor,
-  singleFileRelative,
-  type FormatLayout,
-} from "./format.ts";
-
-export type FixturePlan = {
-  codec: CodecId;
-  format: FormatId;
-  layout: FormatLayout;
-  containerDir: string;
-  mainFile: string;
-  files: ReadonlyArray<string>;
-  ffmpegOutputArgs: ReadonlyArray<string>;
-};
-
-export function buildPlan(codec: CodecId, format: FormatId, durationSeconds: number): FixturePlan {
-  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`;
-
-  // 关键 GOP 锁:25 fps × duration,保证每个 fixture 至少一个 IDR。
-  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 containerDir = containerRelativeDir(codec, format);
-    const mainFile = containerRelativePath(codec, format, layout.mainFileName);
-    const files = [
-      mainFile,
-      ...layout.sideFiles.map((s) => containerRelativePath(codec, format, s)),
-    ];
-    return { codec, format, layout, containerDir, mainFile, files, ffmpegOutputArgs };
-  }
-  // 单文件格式
-  const mainFile = singleFileRelative(codec, format);
-  const containerDir = join(mainFile.split("/").slice(0, -1).join("/"));
-  return { codec, format, layout, containerDir, mainFile, files: [mainFile], ffmpegOutputArgs };
-}
-
-export function expandMatrix(opts?: {
-  codecs?: ReadonlyArray<CodecId>;
-  formats?: ReadonlyArray<FormatId>;
-  durationSeconds?: number;
-}): ReadonlyArray<FixturePlan> {
-  const codecs = opts?.codecs ?? ALL_CODECS;
-  const formats = opts?.formats ?? ALL_FORMATS;
-  const duration = opts?.durationSeconds ?? 5;
-  const plans: FixturePlan[] = [];
-  for (const codec of codecs) {
-    for (const format of formats) {
-      plans.push(buildPlan(codec, format, duration));
-    }
-  }
-  return plans;
-}
-
-// VOD 段默认从 mp4/h264.mp4 派生(同 fixture)。generate.ts 在生成结束后
-// 把真实 fileSize 写进 vodList.example.json;此处只描述派生约定。
-export const VOD_SAMPLE_RELATIVE = "mp4/h264.mp4";

package/src/index.ts

@@ -1,41 +0,0 @@
-// 公共 API 入口。generate / serve / catalog / server 各模块在此 re-export。
-export {
-  buildPlan,
-  expandMatrix,
-  VOD_SAMPLE_RELATIVE,
-  type FixturePlan,
-} from "./fixtures/matrix.ts";
-export {
-  loadManifest,
-  lookupFixture,
-  summarizeCatalog,
-  verifyEntryOnDisk,
-  type CatalogSummary,
-  type FixtureLookup,
-  type Manifest,
-  type ManifestEntry,
-  type ManifestItem,
-} from "./fixtures/catalog.ts";
-export { CODEC_SPEC, type CodecSpec } from "./fixtures/codec.ts";
-export {
-  layoutFor,
-  containerRelativeDir,
-  containerRelativePath,
-  type FormatLayout,
-} from "./fixtures/format.ts";
-export {
-  ALL_CODECS,
-  ALL_FORMATS,
-  DEFAULT_DURATION_SECONDS,
-  DEFAULT_FIXTURE_DIR,
-  DEFAULT_HLS_SEGMENT_SECONDS,
-  DEFAULT_HOST,
-  DEFAULT_PORT,
-  type CodecId,
-  type FormatId,
-  type GenerateOptions,
-  type ServeOptions,
-} from "./config.ts";
-export { createStreamsServer, type StreamsServerHandle } from "./server/server.ts";
-export { generateFixtures, type GenerateResult } from "./fixtures/generate.ts";
-export { handleLiveStream, matchLivePath, type LiveStreamOptions } from "./server/live.ts";

package/src/server/live.ts

@@ -1,220 +0,0 @@
-// /streams/live/<format>/<codec> 路径按需 spawn ffmpeg 子进程,
-// pipe stdout 给 HTTP response,stream 永远不 EOF。
-// ffmpeg 用 -stream_loop -1 + -re 实时速率无限循环,让浏览器端 fetch
-// 持续拿到新字节,player.metrics 长时间累计,模拟真实 live 验收。
-import { type ChildProcessByStdio, spawn } from "node:child_process";
-import { type IncomingMessage, type ServerResponse } from "node:http";
-import { type Readable } from "node:stream";
-import { type CodecId, type FormatId } from "../config.ts";
-import { CODEC_SPEC } from "../fixtures/codec.ts";
-import { writeJson } from "./static.ts";
-
-const LIVE_MIME: Record<FormatId, string> = {
-  flv: "video/x-flv",
-  hls: "application/vnd.apple.mpegurl",
-  mp4: "video/mp4",
-  fmp4: "video/iso.segment",
-  ts: "video/mp2t",
-};
-
-const CODEC_SET: Record<string, true> = { h264: true, hevc: true };
-const FORMAT_SET: Record<string, true> = { flv: true, hls: true, mp4: true, fmp4: true, ts: true };
-
-const LIVE_PATTERN = /^\/streams\/live\/([a-z0-9]+)\/([a-z0-9]+)\/?$/;
-
-export function matchLivePath(path: string): { format: FormatId; codec: CodecId } | null {
-  const match = LIVE_PATTERN.exec(path);
-  if (!match) return null;
-  const [, formatRaw, codecRaw] = match;
-  if (!FORMAT_SET[formatRaw] || !CODEC_SET[codecRaw]) return null;
-  return { format: formatRaw as FormatId, codec: codecRaw as CodecId };
-}
-
-export type LiveStreamOptions = {
-  ffmpegPath?: string;
-  width?: number;
-  height?: number;
-  fps?: number;
-  bitrate?: string;
-};
-
-export function handleLiveStream(
-  req: IncomingMessage,
-  res: ServerResponse,
-  format: FormatId,
-  codec: CodecId,
-  options: LiveStreamOptions = {},
-): void {
-  if (req.method !== "GET" && req.method !== "HEAD") {
-    res.writeHead(405, { Allow: "GET, HEAD, OPTIONS" });
-    res.end("Method Not Allowed\n");
-    return;
-  }
-  if (format === "hls") {
-    writeJson(res, 501, {
-      error: "HLS live streaming not yet supported in this build",
-      reason:
-        "use /streams/live/flv/hevc etc. for non-HLS live, or /streams/hls/hevc/master.m3u8 for VOD HLS",
-    });
-    return;
-  }
-  const ffmpegPath = options.ffmpegPath ?? "ffmpeg";
-  const width = options.width ?? 1280;
-  const height = options.height ?? 720;
-  const fps = options.fps ?? 25;
-  const bitrate = options.bitrate ?? "1500k";
-  const spec = CODEC_SPEC[codec];
-  const mime = LIVE_MIME[format];
-  const ffmpegArgs = buildLiveFfmpegArgs(format, codec, spec, {
-    width,
-    height,
-    fps,
-    bitrate,
-  });
-
-  if (req.method === "HEAD") {
-    res.writeHead(200, {
-      "Content-Type": mime,
-      "Access-Control-Allow-Origin": "*",
-      "X-Live-Source": "ffmpeg-stream-loop",
-    });
-    res.end();
-    return;
-  }
-
-  let proc: ChildProcessByStdio<null, Readable, Readable>;
-  try {
-    proc = spawn(ffmpegPath, ffmpegArgs, { stdio: ["ignore", "pipe", "pipe"] });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    writeJson(res, 503, { error: "ffmpeg spawn failed", reason: message });
-    return;
-  }
-
-  proc.once("error", (err) => {
-    if (!res.headersSent) {
-      writeJson(res, 503, { error: "ffmpeg failed to start", reason: err.message });
-      return;
-    }
-    res.destroy(err);
-  });
-
-  // ffmpeg 第一帧到达前 stderr 经常有 stat 消息;等 stdout 第一字节再发 head。
-  proc.stdout.once("data", () => {
-    if (!res.headersSent) {
-      res.writeHead(200, {
-        "Content-Type": mime,
-        "Access-Control-Allow-Origin": "*",
-        "Transfer-Encoding": "chunked",
-        "X-Live-Source": "ffmpeg-stream-loop",
-      });
-    }
-  });
-
-  proc.stdout.pipe(res);
-
-  const cleanup = (): void => {
-    if (!proc.killed) proc.kill("SIGKILL");
-  };
-  req.once("close", cleanup);
-  res.once("close", cleanup);
-}
-
-type FfmpegSpec = {
-  encoder: string;
-  videoArgs: ReadonlyArray<string>;
-  audioArgs: ReadonlyArray<string>;
-  pixelFormat: string;
-};
-
-type LiveFfmpegOptions = {
-  width: number;
-  height: number;
-  fps: number;
-  bitrate: string;
-};
-
-function buildLiveFfmpegArgs(
-  format: FormatId,
-  codec: CodecId,
-  spec: FfmpegSpec,
-  opts: LiveFfmpegOptions,
-): string[] {
-  const gop = String(opts.fps);
-  const videoInput = `testsrc2=size=${opts.width}x${opts.height}:rate=${opts.fps},format=yuv420p`;
-  const audioInput = `sine=frequency=1000:sample_rate=44100`;
-  const hevcTag = codec === "hevc" && format === "mp4" ? ["-tag:v", "hvc1"] : [];
-
-  const baseArgs = [
-    "-hide_banner",
-    "-loglevel",
-    "error",
-    "-fflags",
-    "+genpts",
-    "-re",
-    "-stream_loop",
-    "-1",
-    "-f",
-    "lavfi",
-    "-i",
-    videoInput,
-    "-f",
-    "lavfi",
-    "-i",
-    audioInput,
-    "-c:v",
-    spec.encoder,
-    ...spec.videoArgs,
-    ...liveLowLatencyVideoArgs(codec),
-    "-pix_fmt",
-    spec.pixelFormat,
-    "-g",
-    gop,
-    "-keyint_min",
-    gop,
-    "-sc_threshold",
-    "0",
-    "-b:v",
-    opts.bitrate,
-    ...hevcTag,
-    ...spec.audioArgs,
-  ];
-
-  if (format === "flv") {
-    return [...baseArgs, "-f", "flv", "-flvflags", "no_sequence_end", "-"];
-  }
-  if (format === "mp4") {
-    return [
-      ...baseArgs,
-      "-f",
-      "mp4",
-      "-movflags",
-      "+faststart+frag_keyframe+empty_moov+default_base_moof",
-      "-",
-    ];
-  }
-  if (format === "fmp4") {
-    return [
-      ...baseArgs,
-      "-f",
-      "mp4",
-      "-movflags",
-      "frag_keyframe+empty_moov+default_base_moof",
-      "-frag_duration",
-      "2000000",
-      "-",
-    ];
-  }
-  if (format === "ts") {
-    return [...baseArgs, "-f", "mpegts", "-"];
-  }
-  // hls 已在 handleLiveStream 早返;此处 unreachable。
-  throw new Error(`Unknown format: ${String(format)}`);
-}
-
-function liveLowLatencyVideoArgs(codec: CodecId): string[] {
-  if (codec === "h264" || codec === "hevc") {
-    return ["-tune", "zerolatency"];
-  }
-  return [];
-}

package/src/server/routes.ts

@@ -1,141 +0,0 @@
-// 路由表:/streams/health、/streams/list、/streams/vod-list、/streams/:format/:codec、
-// /streams/(hls|fmp4)/:codec/...、/streams/vod/:name。
-// resolveRoute() 把 path 解析成 fixture-relative 路径;handleXxx 负责写 JSON 响应。
-import { type ServerResponse } from "node:http";
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { ALL_CODECS, ALL_FORMATS, type CodecId, type FormatId } from "../config.ts";
-import { type Manifest, summarizeCatalog } from "../fixtures/catalog.ts";
-import { writeJson } from "./static.ts";
-
-const FORMAT_SET: Record<string, true> = Object.fromEntries(ALL_FORMATS.map((f) => [f, true]));
-const CODEC_SET: Record<string, true> = Object.fromEntries(ALL_CODECS.map((c) => [c, true]));
-const HLS_FMP4: Record<string, true> = { hls: true, fmp4: true };
-
-const SINGLE = /^\/streams\/([a-z0-9]+)\/([a-z0-9]+)\/?$/;
-const PLAYLIST = /^\/streams\/(hls|fmp4)\/([a-z0-9]+)\/(.+)$/;
-const VOD = /^\/streams\/vod\/([a-zA-Z0-9._-]+)\/?$/;
-
-export function resolveRoute(path: string): string | null {
-  // 单文件:/streams/flv/h264、/streams/mp4/hevc、/streams/ts/h264
-  const single = SINGLE.exec(path);
-  if (single) {
-    const [, formatRaw, codecRaw] = single;
-    if (!FORMAT_SET[formatRaw] || !CODEC_SET[codecRaw]) return null;
-    if (HLS_FMP4[formatRaw]) return null; // hls/fmp4 必须带子文件路径
-    const format = formatRaw as FormatId;
-    const codec = codecRaw as CodecId;
-    return join(format, `${codec}.${format}`);
-  }
-  // playlist 内子文件
-  const playlist = PLAYLIST.exec(path);
-  if (playlist) {
-    const [, formatRaw, codecRaw, rest] = playlist;
-    if (!FORMAT_SET[formatRaw] || !CODEC_SET[codecRaw]) return null;
-    return join(formatRaw, codecRaw, rest);
-  }
-  // /streams/vod/:name
-  const vod = VOD.exec(path);
-  if (vod) {
-    const [, name] = vod;
-    return join("vod", name);
-  }
-  return null;
-}
-
-export function handleHealth(
-  res: ServerResponse,
-  manifest: Manifest | null,
-  fixtureDir: string,
-): void {
-  const summary = summarizeCatalog(fixtureDir);
-  const status = manifest ? 200 : 503;
-  writeJson(res, status, {
-    status: summary.exists ? "ok" : "down",
-    codecs: summary.codecs,
-    formats: summary.formats,
-    fixtures: summary.fixtureCount,
-    reason: manifest ? undefined : summary.reason,
-  });
-}
-
-export function handleList(res: ServerResponse, manifest: Manifest | null): void {
-  if (!manifest) {
-    writeJson(res, 503, { error: "manifest not found" });
-    return;
-  }
-  writeJson(res, 200, manifest);
-}
-
-export type VodSegmentDescriptor = {
-  url: string;
-  startTimestamp: number;
-  endTimestamp: number;
-  timeLen: number;
-  fileSize: number;
-  channelID: number;
-  RecordType: number;
-};
-
-export type VodListResponse = {
-  segments: ReadonlyArray<VodSegmentDescriptor>;
-};
-
-export function handleVodList(
-  res: ServerResponse,
-  manifest: Manifest | null,
-  fixtureDir: string,
-): void {
-  // 优先读 vod-list.json(由 extend-vod CLI 生成),支持任意段数 + 段长。
-  const vodListPath = join(fixtureDir, "vod", "vod-list.json");
-  if (existsSync(vodListPath)) {
-    try {
-      const raw = JSON.parse(readFileSync(vodListPath, "utf8")) as {
-        entries: ReadonlyArray<{ path: string; size: number }>;
-      };
-      const segMs = manifest?.durationSeconds ? manifest.durationSeconds * 1000 : 0;
-      const segments: VodSegmentDescriptor[] = raw.entries.map((e, i) => ({
-        url: `/streams/${e.path}`,
-        startTimestamp: i * segMs,
-        endTimestamp: (i + 1) * segMs,
-        timeLen: segMs,
-        fileSize: e.size,
-        channelID: 1,
-        RecordType: 1,
-      }));
-      writeJson(res, 200, { segments });
-      return;
-    } catch {
-      // fallthrough to legacy 2-segment path
-    }
-  }
-  if (!manifest) {
-    writeJson(res, 503, { error: "manifest not found" });
-    return;
-  }
-  const h264mp4 = manifest.fixtures.find((f) => f.codec === "h264" && f.format === "mp4");
-  const fileSize = h264mp4?.entries[0]?.size ?? 0;
-  const durMs = manifest.durationSeconds * 1000;
-  writeJson(res, 200, {
-    segments: [
-      {
-        url: "/streams/vod/sample-1.mp4",
-        startTimestamp: 0,
-        endTimestamp: durMs,
-        timeLen: durMs,
-        fileSize,
-        channelID: 1,
-        RecordType: 1,
-      },
-      {
-        url: "/streams/vod/sample-2.mp4",
-        startTimestamp: durMs,
-        endTimestamp: durMs * 2,
-        timeLen: durMs,
-        fileSize,
-        channelID: 1,
-        RecordType: 1,
-      },
-    ],
-  });
-}