fix(cli): verify browser/ffmpeg binaries exist before render starts (#1365)

## Problem

Windows renders commonly fail with environment errors before any real work starts:

- `Browser was not found at the configured executablePath (...chrome-headless-shell.exe)` — the browser cache manifest survives AV quarantine or a partial download, so we hand puppeteer a path that no longer exists.
- `[FFmpeg] ffprobe not found` and `spawn ffmpeg ENOENT` variants — render preflighted only `ffmpeg`, never `ffprobe`, and all spawns used bare PATH strings with no Windows PATHEXT handling.

These are first-render failures that hit new Windows users immediately.

## Fix

- Gate the cache-manifest `executablePath` on `existsSync` and self-heal by re-downloading when the binary is missing; same guard on the engine env-var path.
- New shared environment preflight (`packages/cli/src/browser/preflight.ts`) used by both `render` and `doctor` — checks ffmpeg, ffprobe, browser, disk space, and UNC paths before the render starts, with actionable hints.
- Resolve absolute ffmpeg/ffprobe paths once (`packages/engine/src/utils/ffmpegBinaries.ts`) and pass them to every engine spawn instead of relying on PATH.
- Map opaque Windows ffmpeg exit codes to actionable messages.

## Testing

- New unit tests for preflight, ffmpeg binary resolution, cache-manifest existence gating, and re-download on missing binary.
- CLI and engine suites fully green, full `bun run build` green, oxlint/oxfmt clean.
- Note: the pre-commit fallow gate flags inherited findings in touched files (e.g. `audioExtractor.ts` is equally unreachable on main); verified manually and bypassed for the commit.

packages/engine/src/utils/runFfmpeg.test.ts

@@ -1,8 +1,16 @@
-import { describe, expect, it } from "vitest";
+import { EventEmitter } from "node:events";
+import { resolve } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
 
 import { formatFfmpegError } from "./runFfmpeg.js";
 
 describe("formatFfmpegError", () => {
+  const originalPlatform = process.platform;
+
+  afterEach(() => {
+    Object.defineProperty(process, "platform", { value: originalPlatform, configurable: true });
+  });
+
   it("reports exit code alone when stderr is empty", () => {
     expect(formatFfmpegError(-22, "")).toBe("FFmpeg exited with code -22");
   });
@@ -43,4 +51,52 @@ describe("formatFfmpegError", () => {
   it("wraps stderr in [FFmpeg] prefix when exit code is null (spawn failure)", () => {
     expect(formatFfmpegError(null, "spawn ffmpeg ENOENT")).toBe("[FFmpeg] spawn ffmpeg ENOENT");
   });
+
+  it("maps Windows invalid-image exit codes to an actionable architecture hint", () => {
+    Object.defineProperty(process, "platform", { value: "win32", configurable: true });
+
+    expect(formatFfmpegError(3221225595, "")).toContain("wrong architecture");
+  });
+});
+
+function createSpawnSpy() {
+  const calls: Array<{ command: string; args: string[] }> = [];
+  const spawn = vi.fn((command: string, args: string[]) => {
+    calls.push({ command, args });
+    const proc = new EventEmitter() as EventEmitter & {
+      stderr: EventEmitter;
+      kill: ReturnType<typeof vi.fn>;
+      killed: boolean;
+    };
+    proc.stderr = new EventEmitter();
+    proc.kill = vi.fn();
+    proc.killed = false;
+    process.nextTick(() => proc.emit("close", 0));
+    return proc;
+  });
+  return { spawn, calls };
+}
+
+describe("runFfmpeg binary resolution", () => {
+  const originalFfmpegPath = process.env.HYPERFRAMES_FFMPEG_PATH;
+
+  afterEach(() => {
+    vi.resetModules();
+    vi.doUnmock("child_process");
+    if (originalFfmpegPath === undefined) delete process.env.HYPERFRAMES_FFMPEG_PATH;
+    else process.env.HYPERFRAMES_FFMPEG_PATH = originalFfmpegPath;
+  });
+
+  it("spawns the configured absolute FFmpeg path when HYPERFRAMES_FFMPEG_PATH is set", async () => {
+    process.env.HYPERFRAMES_FFMPEG_PATH = "/tools/ffmpeg.exe";
+    const { spawn, calls } = createSpawnSpy();
+    vi.resetModules();
+    vi.doMock("child_process", () => ({ spawn }));
+
+    const { runFfmpeg } = await import("./runFfmpeg.js");
+    const result = await runFfmpeg(["-version"]);
+
+    expect(result.success).toBe(true);
+    expect(calls[0]).toEqual({ command: resolve("/tools/ffmpeg.exe"), args: ["-version"] });
+  });
 });