fix(cli): timeline probe is injectable and the fixture path works on windows

Two unit tests used real ffprobe, which the Ubuntu Test job lacks, and the audio

fixture path doubled the drive letter on Windows. describeProject now takes the

measure function, the tests pass a recorded fake, and one real-ffprobe test remains.

Author: miguel-heygen

packages/cli/src/timeline/describeProject.test.ts

@@ -1,4 +1,4 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import {
   copyFileSync,
   mkdirSync,
@@ -9,16 +9,20 @@ import {
   writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { basename, dirname, join } from "node:path";
 import { MEDIA_DURATION_FIXTURES } from "@hyperframes/parsers/media-duration-fixtures";
 import { fileURLToPath } from "node:url";
 import { afterEach, beforeAll, describe, expect, it } from "vitest";
 import { ensureDOMParser } from "../utils/dom.js";
-import { createProbeGate, describeProject } from "./describeProject.js";
+import { createProbeGate, describeProject, type MeasureMedia } from "./describeProject.js";
 import { formatTimeline } from "./formatTimeline.js";
 
-const REAL_AUDIO = new URL("../../../../skills/media-use/audio/assets/sfx/pop.mp3", import.meta.url)
-  .pathname;
+const REAL_AUDIO = fileURLToPath(
+  new URL("../../../../skills/media-use/audio/assets/sfx/pop.mp3", import.meta.url),
+);
+const hasFfprobe = spawnSync("ffprobe", ["-version"]).status === 0;
+/** Recorded ffprobe answer for pop.mp3 (0.72 s), so the resolver path runs on runners without ffprobe. */
+const POP_SECONDS = async () => 0.72;
 
 const INDEX = `<html><body>
 <div data-composition-id="main" data-width="1920" data-height="1080" data-duration="10">
@@ -38,12 +42,17 @@ const TINY_PNG = Buffer.from(
   "base64",
 );
 
-const rowsOf = async (html: string, withSting = false, setup?: (root: string) => void) => {
+const rowsOf = async (
+  html: string,
+  withSting = false,
+  setup?: (root: string) => void,
+  measure?: MeasureMedia,
+) => {
   const index = project();
   writeFileSync(index, html);
   if (withSting) copyFileSync(REAL_AUDIO, join(dir, "sting.mp3"));
   setup?.(dir);
-  const timeline = await describeProject(index);
+  const timeline = await describeProject(index, measure);
   return { rows: timeline.tracks.flatMap((t) => t.rows), text: formatTimeline(timeline) };
 };
 
@@ -243,26 +252,46 @@ describe("describeProject", () => {
     } = await rowsOf(
       `<div data-composition-id="m"><audio id="s" src="sting.mp3" data-start="0" data-playback-start="0.2" data-playback-rate="2"></audio></div>`,
       true,
+      undefined,
+      POP_SECONDS,
     );
     // (0.72 - 0.2) / 2, hand-computed
     expect(row!.duration).toBeCloseTo(0.26, 1);
   });
 
-  it("probes a media leaf's real duration when none is authored", async () => {
+  it("takes a media leaf's duration from the probe when none is authored", async () => {
+    const probed: string[] = [];
     const {
       rows: [row],
       text,
     } = await rowsOf(
       `<div data-composition-id="m"><audio id="sting" src="sting.mp3" data-start="0"></audio></div>`,
       true,
+      undefined,
+      async (file, tag) => {
+        probed.push(`${tag}:${basename(file)}`);
+        return POP_SECONDS();
+      },
     );
+    expect(probed).toEqual(["audio:sting.mp3"]);
     expect(row).toMatchObject({ durationAuthored: false, durationSource: "media" });
     expect(row!.pendingReason).toBeNull();
     expect(row!.duration).toBeCloseTo(0.72, 1);
     expect(row!.end).toBeCloseTo(0.72, 1);
     expect(text).toContain("duration=media");
   });
 
+  it.skipIf(!hasFfprobe)("measures a real audio file with ffprobe by default", async () => {
+    const {
+      rows: [row],
+    } = await rowsOf(
+      `<div data-composition-id="m"><audio id="sting" src="sting.mp3" data-start="0"></audio></div>`,
+      true,
+    );
+    expect(row).toMatchObject({ durationSource: "media" });
+    expect(row!.duration).toBeCloseTo(0.72, 1);
+  });
+
   it("reports pending with a reason instead of guessing when the source file is missing", async () => {
     const {
       rows: [row],

packages/cli/src/timeline/describeProject.ts

@@ -112,8 +112,16 @@ interface DocScope {
   file: string;
   /** Bounds concurrent ffprobe spawns for the whole run. Shared reference, not new per document. */
   withProbeSlot: <T>(fn: () => Promise<T>) => Promise<T>;
+  measure: MeasureMedia;
 }
 
+/** Source length in seconds of a media file. ffprobe in production; tests pass a recorded fake. */
+export type MeasureMedia = (file: string, tag: MediaTag) => Promise<number>;
+
+const measureWithFfprobe: MeasureMedia = async (file, tag) =>
+  (tag === "audio" ? await extractAudioMetadata(file) : await extractMediaMetadata(file))
+    .durationSeconds;
+
 const MEDIA_TAG = /^(video|audio|img)$/;
 const PROBE_CONCURRENCY = 4;
 
@@ -147,9 +155,7 @@ async function probeSource(scope: DocScope, el: Element, tag: MediaTag): Promise
   if (!file) return { ok: false, reason: "source file not found" };
   return scope.withProbeSlot(async () => {
     try {
-      const metadata =
-        tag === "audio" ? await extractAudioMetadata(file) : await extractMediaMetadata(file);
-      return { ok: true, seconds: metadata.durationSeconds } as const;
+      return { ok: true, seconds: await scope.measure(file, tag) } as const;
     } catch (err) {
       return { ok: false, reason: err instanceof Error ? err.message : String(err) } as const;
     }
@@ -287,6 +293,7 @@ async function readSubComposition(
     origin,
     file: relative(parent.projectDir, authored).split(sep).join("/"),
     withProbeSlot: parent.withProbeSlot,
+    measure: parent.measure,
   };
   const rows = await Promise.all(
     topLevelElements(toNode(root)).map((node) => describeRow(scope, node, 1)),
@@ -307,7 +314,10 @@ function realFileInside(projectDir: string, path: string): string | null {
 }
 
 /** Needs a global DOMParser (`ensureDOMParser`). Reads `index.html` and one level of sub-compositions. */
-export async function describeProject(indexPath: string): Promise<ProjectTimeline> {
+export async function describeProject(
+  indexPath: string,
+  measure: MeasureMedia = measureWithFfprobe,
+): Promise<ProjectTimeline> {
   const doc = new DOMParser().parseFromString(readFileSync(indexPath, "utf-8"), "text/html");
   const root = doc.querySelector("[data-composition-id]") ?? doc.body;
   const dir = dirname(indexPath);
@@ -319,6 +329,7 @@ export async function describeProject(indexPath: string): Promise<ProjectTimelin
     origin: 0,
     file: basename(indexPath),
     withProbeSlot: createProbeGate(PROBE_CONCURRENCY),
+    measure,
   };
   const rows = (
     await Promise.all(topLevelElements(toNode(root)).map((node) => describeRow(scope, node, 0)))