demoflow 0.0.0-stage → 0.1.0

package/dist/bin/main.js

@@ -0,0 +1,4442 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { realpathSync as realpathSync2 } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { Command, CommanderError, Option } from "commander";
+
+// src/config/errors.ts
+var EXIT_INVALID_INPUT = 2;
+var CliError = class extends Error {
+  code;
+  exitCode;
+  issues;
+  constructor(code, message, issues = [], exitCode = EXIT_INVALID_INPUT) {
+    super(message);
+    this.name = "CliError";
+    this.code = code;
+    this.exitCode = exitCode;
+    this.issues = issues;
+  }
+};
+
+// src/config/home.ts
+import { readFileSync } from "node:fs";
+
+// src/config/platform.ts
+import { homedir } from "node:os";
+import path from "node:path";
+function pathFor(platform) {
+  return platform === "win32" ? path.win32 : path.posix;
+}
+function absoluteEnv(host, name) {
+  const value = host.env[name];
+  if (value === void 0 || value === "") return void 0;
+  return pathFor(host.platform).isAbsolute(value) ? value : void 0;
+}
+function currentHost() {
+  return { platform: process.platform, env: process.env, homedir: homedir() };
+}
+
+// src/config/home.ts
+function runDir(home, runId, platform) {
+  return pathFor(platform).join(home, "runs", runId);
+}
+function globalConfigPath(host) {
+  const p = pathFor(host.platform);
+  if (host.platform === "darwin") {
+    return p.join(
+      host.homedir,
+      "Library",
+      "Application Support",
+      "demoflow",
+      "config.json"
+    );
+  }
+  if (host.platform === "win32") {
+    const appData = absoluteEnv(host, "APPDATA") ?? p.join(host.homedir, "AppData", "Roaming");
+    return p.join(appData, "demoflow", "config.json");
+  }
+  const configHome = absoluteEnv(host, "XDG_CONFIG_HOME") ?? p.join(host.homedir, ".config");
+  return p.join(configHome, "demoflow", "config.json");
+}
+function osDataDir(host) {
+  const p = pathFor(host.platform);
+  if (host.platform === "darwin") {
+    return p.join(host.homedir, "Library", "Application Support", "demoflow");
+  }
+  if (host.platform === "win32") {
+    const local = absoluteEnv(host, "LOCALAPPDATA") ?? p.join(host.homedir, "AppData", "Local");
+    return p.join(local, "demoflow");
+  }
+  const dataHome = absoluteEnv(host, "XDG_DATA_HOME") ?? p.join(host.homedir, ".local", "share");
+  return p.join(dataHome, "demoflow");
+}
+function loadGlobalConfig(host, readFile4 = (file) => readFileSync(file, "utf8")) {
+  const file = globalConfigPath(host);
+  let text;
+  try {
+    text = readFile4(file);
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw invalid(file, error instanceof Error ? error.message : String(error));
+  }
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    throw invalid(file, error instanceof Error ? error.message : String(error));
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw invalid(file, "expected a JSON object");
+  }
+  const { artifactsDir } = raw;
+  if (artifactsDir === void 0) return {};
+  if (typeof artifactsDir !== "string" || artifactsDir === "") {
+    throw invalid(file, '"artifactsDir" must be a non-empty string');
+  }
+  const p = pathFor(host.platform);
+  return { artifactsDir: p.resolve(p.dirname(file), artifactsDir) };
+}
+function invalid(file, reason) {
+  return new CliError(
+    "invalid-global-config",
+    `global config ${file} is invalid: ${reason}`
+  );
+}
+function resolveHome(input) {
+  const p = pathFor(input.platform);
+  if (input.out !== void 0 && input.out !== "") {
+    return { home: p.resolve(input.cwd, input.out), source: "out" };
+  }
+  const fromEnv = input.env.DEMOFLOW_HOME;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return { home: p.resolve(input.cwd, fromEnv), source: "env" };
+  }
+  if (input.projectConfig.artifactsDir !== void 0) {
+    return {
+      home: p.resolve(input.projectRoot, input.projectConfig.artifactsDir),
+      source: "project-config"
+    };
+  }
+  if (input.globalConfig.artifactsDir !== void 0) {
+    return { home: input.globalConfig.artifactsDir, source: "global-config" };
+  }
+  return { home: osDataDir(input), source: "os-data-dir" };
+}
+
+// src/config/project.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+
+// ../../packages/core/dist/common.js
+import { z } from "zod";
+var NonEmptyStringSchema = z.string().min(1);
+var HttpUrlSchema = z.url({
+  protocol: /^https?$/,
+  error: "expected an absolute http or https URL"
+}).meta({ pattern: "^[hH][tT][tT][pP][sS]?://" });
+var ViewportSchema = z.strictObject({
+  width: z.number().int().positive(),
+  height: z.number().int().positive()
+});
+var JsonSchemaRefSchema = z.string().optional();
+function exactlyOne(keys) {
+  return (value, ctx) => {
+    const present = keys.filter((key) => value[key] !== void 0);
+    if (present.length !== 1) {
+      ctx.addIssue({
+        code: "custom",
+        message: `expected exactly one of ${keys.join("|")}`
+      });
+    }
+  };
+}
+function exactlyOneJsonSchema(keys) {
+  return { oneOf: keys.map((key) => ({ required: [key] })) };
+}
+
+// ../../packages/core/dist/json-schema.js
+import { z as z6 } from "zod";
+
+// ../../packages/core/dist/project-config.js
+import { z as z2 } from "zod";
+var OriginSchema = HttpUrlSchema.refine((value) => new URL(value).origin === value, "expected an origin such as https://example.com, without a path");
+var RenderConfigSchema = z2.strictObject({
+  width: z2.number().int().positive().default(1920),
+  height: z2.number().int().positive().default(1080),
+  fps: z2.number().int().positive().default(30),
+  idle: z2.strictObject({
+    thresholdMs: z2.number().int().nonnegative().default(1e3),
+    compressToMs: z2.number().int().nonnegative().default(400)
+  }).prefault({})
+}).prefault({});
+var ProjectConfigSchema = z2.strictObject({
+  $schema: JsonSchemaRefSchema,
+  baseUrl: HttpUrlSchema,
+  // Defaults to the origin of `baseUrl`.
+  allowedOrigins: z2.array(OriginSchema).optional(),
+  devCommand: z2.strictObject({
+    command: NonEmptyStringSchema,
+    args: z2.array(z2.string()).optional(),
+    readyUrl: HttpUrlSchema,
+    timeoutMs: z2.number().int().positive().optional()
+  }).optional(),
+  artifactsDir: NonEmptyStringSchema.optional(),
+  render: RenderConfigSchema
+}).transform(({ allowedOrigins, ...config }) => ({
+  ...config,
+  allowedOrigins: allowedOrigins ?? [new URL(config.baseUrl).origin]
+})).meta({
+  title: "DemoFlow project config",
+  description: "demoflow.config.json at the project root."
+});
+
+// ../../packages/core/dist/scenario.js
+import { z as z5 } from "zod";
+
+// ../../packages/core/dist/step.js
+import { z as z4 } from "zod";
+
+// ../../packages/core/dist/locator.js
+import { z as z3 } from "zod";
+var LOCATOR_KEYS = [
+  "role",
+  "label",
+  "testId",
+  "text",
+  "placeholder",
+  "css"
+];
+var exact = z3.boolean().optional();
+var LocatorSchema = z3.union([
+  // getByRole — `role` is an ARIA role.
+  z3.strictObject({
+    role: NonEmptyStringSchema,
+    name: z3.string().optional(),
+    exact
+  }),
+  z3.strictObject({ label: NonEmptyStringSchema, exact }),
+  z3.strictObject({ testId: NonEmptyStringSchema }),
+  z3.strictObject({ text: NonEmptyStringSchema, exact }),
+  z3.strictObject({ placeholder: NonEmptyStringSchema, exact }),
+  z3.strictObject({ css: NonEmptyStringSchema })
+], { error: `expected exactly one of ${LOCATOR_KEYS.join("|")}` });
+function isCssLocator(locator) {
+  return "css" in locator;
+}
+
+// ../../packages/core/dist/step.js
+var STEP_ACTIONS = [
+  "navigate",
+  "waitFor",
+  "click",
+  "fill",
+  "select",
+  "hover",
+  "scroll",
+  "assertVisible",
+  "assertText",
+  "screenshot",
+  "marker",
+  "wait"
+];
+var StepActionSchema = z4.enum(STEP_ACTIONS);
+var MarkerKindSchema = z4.enum(["scene", "caption"]);
+var common = {
+  caption: z4.string().max(120).optional(),
+  timeoutMs: z4.number().int().min(100).max(6e4).default(1e4)
+};
+function step(action, shape2) {
+  return z4.strictObject({ action: z4.literal(action), ...shape2, ...common });
+}
+var navigateKeys = ["path", "url"];
+var fillKeys = ["value", "valueFrom"];
+var scrollKeys = ["to", "target"];
+var StepSchema = z4.discriminatedUnion("action", [
+  step("navigate", {
+    // `//host` and `/\host` are protocol-relative: they leave the origin.
+    path: z4.string().regex(/^\/(?![/\\])/, "expected a path starting with a single /").optional(),
+    url: HttpUrlSchema.optional()
+  }).superRefine(exactlyOne(navigateKeys)).meta(exactlyOneJsonSchema(navigateKeys)),
+  step("waitFor", {
+    target: LocatorSchema,
+    state: z4.enum(["visible", "hidden"]).default("visible")
+  }),
+  step("click", { target: LocatorSchema }),
+  step("fill", {
+    target: LocatorSchema,
+    value: z4.string().optional(),
+    // Secrets never appear in a scenario (ADR-0003 §5).
+    valueFrom: z4.strictObject({
+      env: z4.string().regex(/^[A-Z_][A-Z0-9_]*$/, "expected an environment variable name (A-Z, 0-9, _)")
+    }).optional()
+  }).superRefine(exactlyOne(fillKeys)).meta(exactlyOneJsonSchema(fillKeys)),
+  step("select", { target: LocatorSchema, option: z4.string() }),
+  step("hover", { target: LocatorSchema }),
+  step("scroll", {
+    to: z4.enum(["top", "bottom"]).optional(),
+    target: LocatorSchema.optional(),
+    // Scroll inside this container instead of the page.
+    within: LocatorSchema.optional()
+  }).superRefine(exactlyOne(scrollKeys)).meta(exactlyOneJsonSchema(scrollKeys)),
+  step("assertVisible", { target: LocatorSchema }),
+  step("assertText", {
+    target: LocatorSchema,
+    text: NonEmptyStringSchema,
+    match: z4.enum(["exact", "contains"]).default("contains")
+  }),
+  step("screenshot", {
+    name: z4.string().regex(/^[a-z0-9-]+$/, "expected lowercase letters, digits and -")
+  }),
+  step("marker", {
+    title: NonEmptyStringSchema,
+    kind: MarkerKindSchema.default("scene")
+  }),
+  step("wait", { ms: z4.number().int().min(1).max(5e3) })
+], { error: `expected action to be one of ${STEP_ACTIONS.join("|")}` });
+
+// ../../packages/core/dist/scenario.js
+var ScenarioSchema = z5.strictObject({
+  $schema: JsonSchemaRefSchema,
+  schemaVersion: z5.literal(1),
+  name: NonEmptyStringSchema,
+  description: z5.string().optional(),
+  browser: z5.literal("chromium").default("chromium"),
+  baseUrl: HttpUrlSchema.optional(),
+  viewport: ViewportSchema.default({ width: 1920, height: 1080 }),
+  steps: z5.array(StepSchema).min(1, "expected at least one step").max(200, "expected at most 200 steps")
+}).meta({
+  title: "DemoFlow scenario",
+  description: "A scenario DemoFlow runs, records and renders."
+});
+
+// ../../packages/core/dist/parse.js
+import { z as z7 } from "zod";
+function formatPath(path16) {
+  let out = "";
+  for (const segment of path16) {
+    if (typeof segment === "number") {
+      out += `[${segment}]`;
+    } else {
+      const key = String(segment);
+      if (/^[A-Za-z_$][\w$]*$/.test(key)) {
+        out += out === "" ? key : `.${key}`;
+      } else {
+        out += `[${JSON.stringify(key)}]`;
+      }
+    }
+  }
+  return out;
+}
+function toIssues(issues, prefix = []) {
+  return issues.flatMap((issue) => {
+    const path16 = [...prefix, ...issue.path];
+    if (issue.code === "unrecognized_keys") {
+      return issue.keys.map((key) => ({
+        path: formatPath([...path16, key]),
+        code: issue.code,
+        message: "unknown field"
+      }));
+    }
+    if (issue.code === "invalid_union") {
+      const candidates = issue.errors.filter((branch) => branch.every((inner) => inner.path.length > 0));
+      if (candidates.length === 1)
+        return toIssues(candidates[0], path16);
+    }
+    return [
+      { path: formatPath(path16), code: issue.code, message: issue.message }
+    ];
+  });
+}
+function parseWith(schema, input) {
+  const result = schema.safeParse(input);
+  return result.success ? { ok: true, value: result.data } : { ok: false, errors: toIssues(result.error.issues) };
+}
+function parseScenario(input) {
+  const result = parseWith(ScenarioSchema, input);
+  if (!result.ok)
+    return result;
+  const warnings = [];
+  result.value.steps.forEach((step2, index) => {
+    const locators = [
+      ["target", "target" in step2 ? step2.target : void 0],
+      ["within", "within" in step2 ? step2.within : void 0]
+    ];
+    for (const [key, locator] of locators) {
+      if (locator !== void 0 && isCssLocator(locator)) {
+        warnings.push({
+          path: formatPath(["steps", index, key]),
+          code: "css-locator",
+          message: "a CSS selector breaks when the markup changes; prefer role, label, testId, text or placeholder"
+        });
+      }
+    }
+  });
+  return { ok: true, value: result.value, warnings };
+}
+function parseProjectConfig(input) {
+  const result = parseWith(ProjectConfigSchema, input);
+  return result.ok ? { ...result, warnings: [] } : result;
+}
+
+// ../../packages/core/dist/run-result.js
+import { z as z8 } from "zod";
+var StageStatusSchema = z8.enum([
+  "pending",
+  "running",
+  "passed",
+  "failed",
+  "skipped"
+]);
+var STAGE_NAMES = [
+  "readiness",
+  "execution",
+  "verification",
+  "recording",
+  "rendering",
+  "storage"
+];
+var RunStatusSchema = z8.enum([
+  "completed",
+  "completed_with_warnings",
+  "failed",
+  "running"
+]);
+var TimestampSchema = z8.iso.datetime({ offset: true });
+var StageSchema = z8.strictObject({
+  status: StageStatusSchema,
+  startedAt: TimestampSchema.optional(),
+  finishedAt: TimestampSchema.optional(),
+  error: z8.strictObject({
+    message: z8.string(),
+    stepIndex: z8.number().int().nonnegative().optional()
+  }).optional()
+});
+var StagesSchema = z8.strictObject({
+  readiness: StageSchema,
+  execution: StageSchema,
+  verification: StageSchema,
+  recording: StageSchema,
+  rendering: StageSchema,
+  storage: StageSchema
+});
+function deriveRunStatus(stages, warnings = []) {
+  const statuses = STAGE_NAMES.map((name) => stages[name].status);
+  if (statuses.includes("failed"))
+    return "failed";
+  if (statuses.some((status) => status === "running" || status === "pending")) {
+    return "running";
+  }
+  return warnings.length > 0 ? "completed_with_warnings" : "completed";
+}
+var RenderOutputSchema = z8.strictObject({
+  renderer: NonEmptyStringSchema,
+  // Relative to the run directory.
+  file: NonEmptyStringSchema,
+  durationMs: z8.number().nonnegative(),
+  sizeBytes: z8.number().int().nonnegative(),
+  width: z8.number().int().positive(),
+  height: z8.number().int().positive(),
+  fps: z8.number().positive()
+});
+var RunResultSchema = z8.strictObject({
+  schemaVersion: z8.literal(1),
+  runId: NonEmptyStringSchema,
+  // The scenario's path relative to the project root (ADR-0003 §2).
+  scenarioId: NonEmptyStringSchema,
+  scenarioName: NonEmptyStringSchema,
+  startedAt: TimestampSchema,
+  finishedAt: TimestampSchema,
+  status: RunStatusSchema,
+  stages: StagesSchema,
+  renders: z8.array(RenderOutputSchema),
+  warnings: z8.array(z8.string())
+}).refine((result) => result.status === deriveRunStatus(result.stages, result.warnings), {
+  message: "expected status to match the status derived from the stages",
+  path: ["status"]
+});
+
+// ../../packages/core/dist/timeline.js
+import { z as z9 } from "zod";
+var MASKED_VALUE = "***";
+var PointSchema = z9.strictObject({ x: z9.number(), y: z9.number() });
+var BoxSchema = z9.strictObject({
+  x: z9.number(),
+  y: z9.number(),
+  width: z9.number().nonnegative(),
+  height: z9.number().nonnegative()
+});
+var msSchema = z9.number().nonnegative();
+var MaskIntervalSchema = z9.strictObject({
+  startMs: msSchema,
+  // Absent: still on the page when the run ended.
+  endMs: msSchema.optional(),
+  box: BoxSchema
+}).refine((interval) => (interval.endMs ?? Infinity) >= interval.startMs, {
+  message: "expected endMs to be at or after startMs",
+  path: ["endMs"]
+});
+var MaskVisibilitySchema = z9.array(MaskIntervalSchema).superRefine((intervals, ctx) => {
+  for (const [index, interval] of intervals.entries()) {
+    const previous = intervals[index - 1];
+    if (previous === void 0)
+      continue;
+    if (previous.endMs === void 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: "expected only the last interval to be open",
+        path: [index - 1, "endMs"]
+      });
+    } else if (interval.startMs < previous.startMs) {
+      ctx.addIssue({
+        code: "custom",
+        message: "expected intervals ordered by startMs",
+        path: [index, "startMs"]
+      });
+    }
+  }
+});
+var TimelineEventSchema = z9.strictObject({
+  stepIndex: z9.number().int().nonnegative(),
+  action: StepActionSchema,
+  startMs: msSchema,
+  endMs: msSchema,
+  target: z9.strictObject({ box: BoxSchema }).optional(),
+  // The real pointer path (ADR-0004 §2).
+  pointer: z9.strictObject({ from: PointSchema, to: PointSchema }).optional(),
+  scroll: z9.strictObject({
+    before: PointSchema,
+    after: PointSchema,
+    container: BoxSchema.optional()
+  }).optional(),
+  // A `fill` from `valueFrom.env`.
+  masked: z9.boolean().optional(),
+  // `***` when masked; omitted for anything but `fill`.
+  value: z9.string().optional(),
+  assertion: z9.strictObject({ passed: z9.boolean(), message: z9.string().optional() }).optional(),
+  // Relative to the run directory.
+  screenshot: NonEmptyStringSchema.optional(),
+  marker: z9.strictObject({ title: NonEmptyStringSchema, kind: MarkerKindSchema }).optional(),
+  caption: z9.string().optional(),
+  error: z9.strictObject({ message: z9.string() }).optional(),
+  // Only on a masked `fill`: when its field was on the page (ADR-0004; #18).
+  maskVisibility: MaskVisibilitySchema.optional()
+}).refine((event) => event.endMs >= event.startMs, {
+  message: "expected endMs to be at or after startMs",
+  path: ["endMs"]
+}).refine((event) => event.masked !== true || event.value === void 0 || event.value === MASKED_VALUE, {
+  message: `expected a masked value to be written as ${MASKED_VALUE}`,
+  path: ["value"]
+}).refine((event) => event.maskVisibility === void 0 || event.masked === true, {
+  message: "expected maskVisibility only on a masked event",
+  path: ["maskVisibility"]
+});
+var TimelineSchema = z9.strictObject({
+  schemaVersion: z9.literal(1),
+  viewport: ViewportSchema,
+  deviceScaleFactor: z9.number().positive(),
+  videoFile: NonEmptyStringSchema,
+  events: z9.array(TimelineEventSchema),
+  // Painted at clock zero, cleared before step 0; the renderer measures the
+  // video/clock offset from it (#19).
+  syncMark: z9.strictObject({
+    colour: z9.string().regex(/^#[0-9a-f]{6}$/),
+    onMs: msSchema,
+    offMs: msSchema
+  }).refine((mark) => mark.offMs > mark.onMs, {
+    message: "expected offMs to be after onMs",
+    path: ["offMs"]
+  }).optional()
+}).refine((timeline) => {
+  const first = timeline.events[0];
+  return timeline.syncMark === void 0 || first === void 0 || timeline.syncMark.offMs <= first.startMs;
+}, {
+  message: "expected the sync mark to be cleared before the first event",
+  path: ["syncMark", "offMs"]
+});
+
+// src/config/project.ts
+var PROJECT_CONFIG_FILE = "demoflow.config.json";
+function findProjectRoot(scenarioPath, fileExists = existsSync, pathApi = path2) {
+  let dir = pathApi.dirname(pathApi.resolve(scenarioPath));
+  for (; ; ) {
+    if (fileExists(pathApi.join(dir, PROJECT_CONFIG_FILE))) return dir;
+    const parent = pathApi.dirname(dir);
+    if (parent === dir) {
+      throw new CliError(
+        "no-project-config",
+        `no ${PROJECT_CONFIG_FILE} found in ${scenarioPath} or any parent directory`
+      );
+    }
+    dir = parent;
+  }
+}
+function projectRootAt(dir, fileExists = existsSync, pathApi = path2) {
+  if (!fileExists(pathApi.join(dir, PROJECT_CONFIG_FILE))) {
+    throw new CliError(
+      "no-project-config",
+      `no ${PROJECT_CONFIG_FILE} found in ${dir}`
+    );
+  }
+  return dir;
+}
+function scenarioId(root, scenarioPath, pathApi = path2) {
+  const file = pathApi.resolve(root, scenarioPath);
+  const relative = pathApi.relative(root, file);
+  if (relative === ".." || relative.startsWith(`..${pathApi.sep}`) || pathApi.isAbsolute(relative)) {
+    return `inline/${pathApi.basename(file)}`;
+  }
+  return relative.split(pathApi.sep).join("/");
+}
+function loadProjectConfig(root) {
+  const file = path2.join(root, PROJECT_CONFIG_FILE);
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync2(file, "utf8"));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new CliError(
+      "invalid-config",
+      `cannot read ${PROJECT_CONFIG_FILE}: ${reason}`
+    );
+  }
+  const parsed = parseProjectConfig(raw);
+  if (!parsed.ok) {
+    throw new CliError(
+      "invalid-config",
+      `${PROJECT_CONFIG_FILE} is invalid`,
+      parsed.errors
+    );
+  }
+  return parsed.value;
+}
+
+// src/commands/errors.ts
+var CommandError = class extends Error {
+  code;
+  exitCode = EXIT_INVALID_INPUT;
+  issues;
+  constructor(code, message, issues = []) {
+    super(message);
+    this.name = "CommandError";
+    this.code = code;
+    this.issues = issues;
+  }
+};
+var EXIT_STAGE_FAILED = 3;
+function isInputError(error) {
+  return error instanceof CliError || error instanceof CommandError;
+}
+function describeError(error) {
+  const lines = [`${error.code}: ${error.message}`];
+  for (const issue of error.issues) {
+    lines.push(
+      `  ${issue.path === "" ? "(root)" : issue.path}: ${issue.message}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/commands/io.ts
+var processIo = {
+  stdout: (text) => {
+    process.stdout.write(text);
+  },
+  stderr: (text) => {
+    process.stderr.write(text);
+  }
+};
+
+// src/commands/run.ts
+import { existsSync as existsSync4 } from "node:fs";
+import path10 from "node:path";
+
+// ../../packages/engine/dist/capture/observer.js
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import path3 from "node:path";
+var RUN_FILES = {
+  video: "source.webm",
+  timeline: "timeline.json",
+  scenario: "scenario.json",
+  result: "result.json",
+  screenshotsDir: "screenshots"
+};
+function createCaptureObserver(options) {
+  let runDir2 = "";
+  let scenario;
+  let recording;
+  return {
+    async onRunStarted(event) {
+      runDir2 = event.runDir;
+      scenario = event.scenario;
+      recording = event.recording;
+      await mkdir(runDir2, { recursive: true });
+      await writeJson(path3.join(runDir2, RUN_FILES.scenario), event.scenario);
+    },
+    async onScreenshot({ name, png }) {
+      const dir = path3.join(runDir2, RUN_FILES.screenshotsDir);
+      await mkdir(dir, { recursive: true });
+      await writeFile(path3.join(dir, `${name}.png`), png);
+      return `${RUN_FILES.screenshotsDir}/${name}.png`;
+    },
+    async onRunFinished({ outcome }) {
+      if (scenario === void 0 || recording === void 0)
+        return;
+      if (outcome.videoPath !== void 0) {
+        await rename(outcome.videoPath, path3.join(runDir2, RUN_FILES.video));
+        const timeline = TimelineSchema.parse({
+          schemaVersion: 1,
+          viewport: recording.viewport,
+          deviceScaleFactor: recording.deviceScaleFactor,
+          videoFile: RUN_FILES.video,
+          events: outcome.events,
+          ...outcome.syncMark === void 0 ? {} : { syncMark: outcome.syncMark }
+        });
+        await writeJson(path3.join(runDir2, RUN_FILES.timeline), timeline);
+      }
+      await writeJson(path3.join(runDir2, RUN_FILES.result), runResult(outcome, scenario, {
+        runId: options.runId ?? path3.basename(runDir2),
+        scenarioId: options.scenarioId
+      }));
+    }
+  };
+}
+function runResult(outcome, scenario, ids) {
+  return RunResultSchema.parse({
+    schemaVersion: 1,
+    runId: ids.runId,
+    scenarioId: ids.scenarioId,
+    scenarioName: scenario.name,
+    startedAt: outcome.startedAt,
+    finishedAt: outcome.finishedAt,
+    status: outcome.status,
+    stages: outcome.stages,
+    renders: [],
+    warnings: outcome.warnings
+  });
+}
+async function writeJson(file, value) {
+  await writeFile(file, `${JSON.stringify(value, null, 2)}
+`);
+}
+
+// ../../packages/engine/dist/execute/actions.js
+import { setTimeout as sleep } from "node:timers/promises";
+
+// ../../packages/engine/dist/execute/locator.js
+function resolveLocator(page, locator) {
+  if ("role" in locator) {
+    return page.getByRole(locator.role, {
+      name: locator.name,
+      exact: locator.exact
+    });
+  }
+  if ("label" in locator) {
+    return page.getByLabel(locator.label, { exact: locator.exact });
+  }
+  if ("testId" in locator)
+    return page.getByTestId(locator.testId);
+  if ("text" in locator) {
+    return page.getByText(locator.text, { exact: locator.exact });
+  }
+  if ("placeholder" in locator) {
+    return page.getByPlaceholder(locator.placeholder, {
+      exact: locator.exact
+    });
+  }
+  return page.locator(locator.css);
+}
+function describeLocator(locator) {
+  return JSON.stringify(locator);
+}
+
+// ../../packages/engine/dist/execute/pointer.js
+function moveSteps(from, to) {
+  const distance2 = Math.hypot(to.x - from.x, to.y - from.y);
+  return Math.min(40, Math.max(8, Math.round(distance2 / 12)));
+}
+function viewportCentre(viewport) {
+  return { x: viewport.width / 2, y: viewport.height / 2 };
+}
+function boxCentre(box) {
+  return { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+}
+
+// ../../packages/engine/dist/execute/readiness.js
+var OriginGuard = class {
+  #allowed;
+  constructor(allowedOrigins) {
+    this.#allowed = new Set(allowedOrigins.map((value) => originOf(value)));
+  }
+  /** Returns the offending origin, or `undefined` when the URL may be opened. */
+  check(url) {
+    if (url.startsWith("about:") || url.startsWith("chrome-error:")) {
+      return void 0;
+    }
+    const origin = originOf(url);
+    return this.#allowed.has(origin) ? void 0 : origin;
+  }
+};
+function originOf(url) {
+  try {
+    const origin = new URL(url).origin;
+    return origin === "null" ? `${new URL(url).protocol}` : origin;
+  } catch {
+    return url;
+  }
+}
+function originNotAllowed(origin) {
+  return `origin-not-allowed ${origin}`;
+}
+function navigateUrl(step2, baseUrl) {
+  if (step2.url !== void 0)
+    return step2.url;
+  if (step2.path === void 0 || baseUrl === void 0)
+    return void 0;
+  return new URL(step2.path, baseUrl).href;
+}
+function checkReadiness(scenario, input) {
+  const guard = new OriginGuard(input.allowedOrigins);
+  if (input.baseUrl !== void 0) {
+    const origin = guard.check(input.baseUrl);
+    if (origin !== void 0) {
+      return { ok: false, problem: { message: originNotAllowed(origin) } };
+    }
+  }
+  const secrets = /* @__PURE__ */ new Map();
+  for (const [stepIndex, step2] of scenario.steps.entries()) {
+    if (step2.action === "navigate") {
+      const url = navigateUrl(step2, input.baseUrl);
+      if (url === void 0) {
+        return {
+          ok: false,
+          problem: { message: `missing-base-url ${step2.path}`, stepIndex }
+        };
+      }
+      const origin = guard.check(url);
+      if (origin !== void 0) {
+        return {
+          ok: false,
+          problem: { message: originNotAllowed(origin), stepIndex }
+        };
+      }
+    }
+    if (step2.action === "fill" && step2.valueFrom !== void 0) {
+      const name = step2.valueFrom.env;
+      const value = input.env[name];
+      if (value === void 0 || value === "") {
+        return {
+          ok: false,
+          problem: { message: `missing-env ${name}`, stepIndex }
+        };
+      }
+      secrets.set(stepIndex, value);
+    }
+  }
+  return { ok: true, secrets };
+}
+
+// ../../packages/engine/dist/execute/actions.js
+var TYPING_DELAY_MS = 35;
+var SCROLL_FRAME_FALLBACK_MS = 100;
+var MAX_REAIMS = 3;
+var NAVIGATION_START_MS = 100;
+var StepFailure = class extends Error {
+  stage;
+  detail;
+  constructor(stage, message, detail = {}) {
+    super(message);
+    this.stage = stage;
+    this.detail = detail;
+  }
+};
+async function runAction(step2, ctx) {
+  switch (step2.action) {
+    case "navigate": {
+      const url = navigateUrl(step2, ctx.baseUrl);
+      if (url === void 0) {
+        throw new StepFailure("execution", `missing-base-url ${step2.path}`);
+      }
+      const origin = ctx.guard.check(url);
+      if (origin !== void 0) {
+        throw new StepFailure("execution", originNotAllowed(origin));
+      }
+      await ctx.page.goto(url, { timeout: step2.timeoutMs });
+      return {};
+    }
+    case "waitFor": {
+      const target = locate(ctx, step2.target);
+      await target.waitFor({ state: step2.state, timeout: step2.timeoutMs });
+      return step2.state === "visible" ? withBox(await measure(target)) : {};
+    }
+    case "click":
+    case "hover": {
+      const target = locate(ctx, step2.target);
+      if (step2.action === "click") {
+        await target.click({ trial: true, timeout: step2.timeoutMs });
+      } else {
+        await target.hover({ trial: true, timeout: step2.timeoutMs });
+      }
+      const { box, from, to } = await glide(ctx, target, step2.target);
+      if (step2.action === "click") {
+        await ctx.page.mouse.down();
+        await ctx.page.mouse.up();
+        await navigationStart(ctx.page);
+      }
+      return { target: { box }, pointer: { from, to } };
+    }
+    case "fill": {
+      const target = locate(ctx, step2.target);
+      const masked = step2.valueFrom !== void 0;
+      const value = masked ? ctx.secret : step2.value;
+      if (value === void 0) {
+        throw new StepFailure("execution", "fill has no value", masked ? { masked: true, value: MASKED_VALUE } : {});
+      }
+      if (!masked) {
+        await target.fill("", { timeout: step2.timeoutMs });
+        const box2 = await measure(target);
+        await type(target, value, step2.timeoutMs);
+        return { ...withBox(box2), value };
+      }
+      let box = null;
+      try {
+        await target.fill("", { timeout: step2.timeoutMs });
+        box = await measure(target);
+        await type(target, value, step2.timeoutMs);
+      } catch (error) {
+        box ??= await measure(target);
+        throw maskedFailure(error, withBox(box));
+      }
+      return { ...withBox(box), masked: true, value: MASKED_VALUE };
+    }
+    case "select": {
+      const target = locate(ctx, step2.target);
+      await target.selectOption(step2.option, { timeout: step2.timeoutMs });
+      return withBox(await measure(target));
+    }
+    case "scroll":
+      return scroll(ctx, step2);
+    case "assertVisible": {
+      const target = locate(ctx, step2.target);
+      try {
+        await target.waitFor({ state: "visible", timeout: step2.timeoutMs });
+      } catch {
+        const message = `expected ${describeLocator(step2.target)} to be visible`;
+        throw new StepFailure("verification", message, {
+          assertion: { passed: false, message }
+        });
+      }
+      return { ...withBox(await measure(target)), assertion: { passed: true } };
+    }
+    case "assertText":
+      return assertText(ctx, step2);
+    case "screenshot": {
+      const png = await ctx.page.screenshot({ type: "png" });
+      let screenshot;
+      for (const observer of ctx.observers) {
+        const stored = await observer.onScreenshot?.({
+          stepIndex: ctx.stepIndex,
+          name: step2.name,
+          png
+        });
+        screenshot ??= stored;
+      }
+      return screenshot === void 0 ? {} : { screenshot };
+    }
+    case "marker":
+      return { marker: { title: step2.title, kind: step2.kind } };
+    case "wait":
+      await sleep(step2.ms);
+      return {};
+  }
+}
+function locate(ctx, locator) {
+  return resolveLocator(ctx.page, locator);
+}
+async function measure(target) {
+  return target.boundingBox({ timeout: 1e3 }).catch(() => null);
+}
+function withBox(box) {
+  return box === null ? {} : { target: { box } };
+}
+async function type(target, value, timeoutMs) {
+  await target.pressSequentially(value, {
+    delay: TYPING_DELAY_MS,
+    timeout: timeoutMs + value.length * TYPING_DELAY_MS
+  });
+}
+function maskedFailure(error, target) {
+  const detail = { ...target, masked: true, value: MASKED_VALUE };
+  if (error instanceof StepFailure) {
+    return new StepFailure(error.stage, error.message, {
+      ...error.detail,
+      ...detail
+    });
+  }
+  const [firstLine = ""] = errorMessage(error).split("\n");
+  return new StepFailure("execution", firstLine, detail);
+}
+async function glide(ctx, target, locator) {
+  const from = ctx.pointer;
+  let box = await requireBox(target, locator);
+  let to = boxCentre(box);
+  await ctx.page.mouse.move(to.x, to.y, { steps: moveSteps(from, to) });
+  ctx.pointer = to;
+  for (let attempt = 0; attempt < MAX_REAIMS; attempt++) {
+    const now = await requireBox(target, locator);
+    const moved = Math.abs(now.x - box.x) > 0.5 || Math.abs(now.y - box.y) > 0.5 || Math.abs(now.width - box.width) > 0.5 || Math.abs(now.height - box.height) > 0.5;
+    box = now;
+    if (!moved)
+      break;
+    const next = boxCentre(box);
+    await ctx.page.mouse.move(next.x, next.y, {
+      steps: moveSteps(to, next)
+    });
+    to = next;
+    ctx.pointer = to;
+  }
+  return { box, from, to };
+}
+async function navigationStart(page) {
+  await page.waitForEvent("request", {
+    predicate: (request) => request.isNavigationRequest() && request.frame() === page.mainFrame(),
+    timeout: NAVIGATION_START_MS
+  }).catch(() => void 0);
+}
+async function requireBox(target, locator) {
+  const box = await measure(target);
+  if (box === null) {
+    throw new StepFailure("execution", `${describeLocator(locator)} has no box to point at`);
+  }
+  return box;
+}
+async function scroll(ctx, step2) {
+  const container = step2.within === void 0 ? void 0 : locate(ctx, step2.within);
+  await container?.waitFor({ state: "visible", timeout: step2.timeoutMs });
+  const target = step2.target === void 0 ? void 0 : locate(ctx, step2.target);
+  await target?.waitFor({ state: "attached", timeout: step2.timeoutMs });
+  const handles = await Promise.all([
+    container?.elementHandle({ timeout: step2.timeoutMs }) ?? null,
+    target?.elementHandle({ timeout: step2.timeoutMs }) ?? null
+  ]);
+  try {
+    const [scroller, element] = handles;
+    const { before, after } = await ctx.page.evaluate(scrollAndSettle, {
+      scroller,
+      target: element,
+      edge: step2.to ?? null,
+      timeoutMs: step2.timeoutMs,
+      fallbackMs: SCROLL_FRAME_FALLBACK_MS
+    });
+    const containerBox = container === void 0 ? null : await measure(container);
+    return {
+      scroll: containerBox === null ? { before, after } : { before, after, container: containerBox }
+    };
+  } finally {
+    await Promise.all(handles.map((handle) => handle?.dispose()));
+  }
+}
+async function scrollAndSettle({ scroller, target, edge: edge2, timeoutMs, fallbackMs }) {
+  const root = document.scrollingElement ?? document.documentElement;
+  const read = () => scroller === null ? { x: window.scrollX, y: window.scrollY } : { x: scroller.scrollLeft, y: scroller.scrollTop };
+  const before = read();
+  const box = scroller ?? root;
+  const maxX = box.scrollWidth - box.clientWidth;
+  const maxY = box.scrollHeight - box.clientHeight;
+  const clamp2 = (value, max) => Math.min(Math.max(value, 0), Math.max(max, 0));
+  let destination;
+  if (target === null) {
+    destination = { x: before.x, y: edge2 === "top" ? 0 : maxY };
+  } else {
+    const rect = target.getBoundingClientRect();
+    const frame = scroller?.getBoundingClientRect();
+    const left = frame === void 0 ? 0 : frame.left + box.clientLeft;
+    const top = frame === void 0 ? 0 : frame.top + box.clientTop;
+    const width = scroller === null ? window.innerWidth : box.clientWidth;
+    const height = scroller === null ? window.innerHeight : box.clientHeight;
+    let dx = 0;
+    if (rect.left < left)
+      dx = rect.left - left;
+    else if (rect.right > left + width)
+      dx = rect.right - (left + width);
+    destination = {
+      x: clamp2(before.x + dx, maxX),
+      y: clamp2(before.y + rect.top - top + rect.height / 2 - height / 2, maxY)
+    };
+  }
+  const reached = (at) => Math.abs(at.x - destination.x) <= 1 && Math.abs(at.y - destination.y) <= 1;
+  let endedAt;
+  const onScrollEnd = () => {
+    endedAt = read();
+  };
+  const events = scroller ?? document;
+  events.addEventListener("scrollend", onScrollEnd);
+  if (target !== null) {
+    target.scrollIntoView({ behavior: "smooth", block: "center" });
+  } else {
+    (scroller ?? window).scrollTo({ top: destination.y, behavior: "smooth" });
+  }
+  const nextFrame = () => new Promise((resolve) => {
+    requestAnimationFrame(() => resolve());
+    setTimeout(resolve, fallbackMs);
+  });
+  const deadline = performance.now() + timeoutMs;
+  let last = read();
+  while (performance.now() < deadline) {
+    await nextFrame();
+    const now = read();
+    const still = now.x === last.x && now.y === last.y;
+    const moved = now.x !== before.x || now.y !== before.y;
+    const ended = endedAt?.x === now.x && endedAt.y === now.y;
+    last = now;
+    if (still && (moved ? ended : reached(now)))
+      break;
+  }
+  events.removeEventListener("scrollend", onScrollEnd);
+  return { before, after: last };
+}
+async function assertText(ctx, step2) {
+  const target = locate(ctx, step2.target);
+  const deadline = Date.now() + step2.timeoutMs;
+  await target.waitFor({ state: "visible", timeout: step2.timeoutMs });
+  let actual = "";
+  for (; ; ) {
+    actual = normalise(await target.innerText({ timeout: step2.timeoutMs }));
+    if (textMatches(actual, step2.text, step2.match)) {
+      return {
+        ...withBox(await measure(target)),
+        assertion: { passed: true }
+      };
+    }
+    if (Date.now() >= deadline)
+      break;
+    await sleep(100);
+  }
+  const verb = step2.match === "exact" ? "to be" : "to contain";
+  const message = `expected ${describeLocator(step2.target)} ${verb} ${JSON.stringify(step2.text)}, got ${JSON.stringify(actual)}`;
+  throw new StepFailure("verification", message, {
+    ...withBox(await measure(target)),
+    assertion: { passed: false, message }
+  });
+}
+function normalise(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function textMatches(actual, expected, match) {
+  const wanted = normalise(expected);
+  return match === "exact" ? actual === wanted : actual.includes(wanted);
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../../packages/engine/dist/execute/recording.js
+var DEVICE_SCALE_FACTOR = 2;
+function recordingOptions(scenario, runDir2) {
+  return {
+    viewport: scenario.viewport,
+    deviceScaleFactor: DEVICE_SCALE_FACTOR,
+    videoDir: runDir2,
+    videoSize: { ...scenario.viewport }
+  };
+}
+function toContextOptions(recording) {
+  return {
+    viewport: recording.viewport,
+    deviceScaleFactor: recording.deviceScaleFactor,
+    recordVideo: { dir: recording.videoDir, size: recording.videoSize }
+  };
+}
+
+// ../../packages/engine/dist/execute/sync-mark.js
+var SYNC_MARK_COLOUR = "#ff00ff";
+var SYNC_MARK_REPAINT_MS = 200;
+var SYNC_MARK_HOLD_MS = 400;
+var SYNC_EXCHANGES = 5;
+var ELEMENT_ID = "__demoflow_sync_mark__";
+var REPAINT_COLOUR = "#fe00fe";
+async function recordSyncMark(page, clock) {
+  try {
+    const edges = await page.evaluate(showMark, {
+      id: ELEMENT_ID,
+      colour: SYNC_MARK_COLOUR,
+      repaintColour: REPAINT_COLOUR,
+      repaintMs: SYNC_MARK_REPAINT_MS,
+      holdMs: SYNC_MARK_HOLD_MS
+    });
+    const exchanges = [];
+    for (let i = 0; i < SYNC_EXCHANGES; i++) {
+      const sentMs = clock.now();
+      const pageMs = await page.evaluate(() => performance.now());
+      exchanges.push({ sentMs, pageMs, receivedMs: clock.now() });
+    }
+    return toSyncMark(edges, exchanges);
+  } catch {
+    return void 0;
+  }
+}
+function toSyncMark(edges, exchanges) {
+  if (!(edges.offMs > edges.onMs))
+    return void 0;
+  const shiftMs = pageToClockShift(exchanges);
+  const mappedOnMs = edges.onMs + shiftMs;
+  if (mappedOnMs >= 0) {
+    return {
+      colour: SYNC_MARK_COLOUR,
+      onMs: mappedOnMs,
+      offMs: edges.offMs + shiftMs
+    };
+  }
+  return {
+    colour: SYNC_MARK_COLOUR,
+    onMs: 0,
+    offMs: edges.offMs - edges.onMs
+  };
+}
+function pageToClockShift(exchanges) {
+  let best;
+  for (const exchange of exchanges) {
+    const roundTrip = exchange.receivedMs - exchange.sentMs;
+    if (best === void 0 || roundTrip < best.receivedMs - best.sentMs) {
+      best = exchange;
+    }
+  }
+  if (best === void 0)
+    throw new Error("no clock exchange");
+  return (best.sentMs + best.receivedMs) / 2 - best.pageMs;
+}
+function showMark(input) {
+  const mark = document.createElement("div");
+  mark.id = input.id;
+  mark.setAttribute("style", `position:fixed;inset:0;z-index:2147483647;background:${input.colour}`);
+  document.documentElement.appendChild(mark);
+  return new Promise((resolve) => {
+    let onMs;
+    let odd = false;
+    const frame = (atMs) => {
+      if (onMs === void 0)
+        onMs = atMs;
+      if (atMs - onMs < input.holdMs) {
+        odd = atMs - onMs < input.repaintMs && !odd;
+        mark.style.background = odd ? input.repaintColour : input.colour;
+        requestAnimationFrame(frame);
+        return;
+      }
+      mark.remove();
+      const shownMs = onMs;
+      requestAnimationFrame(() => resolve({ onMs: shownMs, offMs: atMs }));
+    };
+    requestAnimationFrame(frame);
+  });
+}
+
+// ../../packages/engine/dist/run.js
+import { mkdir as mkdir2 } from "node:fs/promises";
+import { chromium } from "playwright";
+
+// ../../packages/engine/dist/execute/clock.js
+import { performance as performance2 } from "node:perf_hooks";
+function startClock() {
+  const zero = performance2.now();
+  return { now: () => Math.max(0, performance2.now() - zero) };
+}
+
+// ../../packages/engine/dist/execute/mask.js
+var MaskTracker = class {
+  page;
+  fields = [];
+  navigated = false;
+  constructor(page) {
+    this.page = page;
+    page.on("framenavigated", (frame) => {
+      if (frame === page.mainFrame())
+        this.navigated = true;
+    });
+  }
+  /**
+   * Starts tracking a masked fill's field from the fill itself. The event's
+   * `maskVisibility` is the tracker's own list: later steps extend it.
+   */
+  track(event, locator) {
+    const box = event.target?.box;
+    if (event.masked !== true || box === void 0)
+      return;
+    const intervals = [{ startMs: event.startMs, box }];
+    event.maskVisibility = intervals;
+    this.fields.push({ locator, intervals });
+  }
+  /**
+   * Checks every tracked field. Called after each step, before its `endMs`
+   * is stamped, so a field seen gone here is gone by that `endMs`.
+   */
+  async look() {
+    const navigated = this.navigated;
+    this.navigated = false;
+    const fields = await Promise.all(this.fields.map(async (field) => ({
+      field,
+      sighting: await this.sight(field.locator)
+    })));
+    return { navigated, fields };
+  }
+  record(sightings, startMs, endMs) {
+    for (const { field, sighting } of sightings.fields) {
+      const open = field.intervals.at(-1);
+      const isOpen = open !== void 0 && open.endMs === void 0;
+      if (isOpen && (sightings.navigated || sighting === "gone")) {
+        open.endMs = endMs;
+      }
+      const isClosed = open === void 0 || open.endMs !== void 0;
+      if (isClosed && sighting !== void 0 && sighting !== "gone") {
+        field.intervals.push({ startMs, box: sighting });
+      }
+    }
+  }
+  /** Any visible match counts as the field: the conservative reading. */
+  async sight(locator) {
+    const visible = resolveLocator(this.page, locator).filter({ visible: true }).first();
+    let shown;
+    try {
+      shown = await visible.isVisible();
+    } catch {
+      return void 0;
+    }
+    if (!shown)
+      return "gone";
+    const box = await visible.boundingBox({ timeout: 1e3 }).catch(() => null);
+    return box ?? "gone";
+  }
+};
+
+// ../../packages/engine/dist/run.js
+var ASSERTIONS = /* @__PURE__ */ new Set(["assertVisible", "assertText"]);
+async function runScenario(scenario, options) {
+  const observers = options.observers ?? [];
+  const emit = async (hook, event) => {
+    for (const observer of observers) {
+      const handler = observer[hook];
+      await handler?.call(observer, event);
+    }
+  };
+  const startedAt = timestamp();
+  const stages = pendingStages();
+  const recording = recordingOptions(scenario, options.runDir);
+  const baseUrl = scenario.baseUrl ?? options.baseUrl;
+  await mkdir2(options.runDir, { recursive: true });
+  await emit("onRunStarted", {
+    scenario,
+    runDir: options.runDir,
+    recording,
+    startedAt
+  });
+  stages.readiness = { status: "running", startedAt };
+  const readiness = checkReadiness(scenario, {
+    baseUrl,
+    allowedOrigins: options.allowedOrigins,
+    env: options.env ?? process.env
+  });
+  if (!readiness.ok) {
+    stages.readiness = finish(stages.readiness, "failed", readiness.problem);
+    for (const name of ["execution", "verification", "recording"]) {
+      stages[name] = { status: "skipped" };
+    }
+    const outcome = conclude(startedAt, stages, []);
+    await emit("onRunFinished", { outcome, video: null });
+    return outcome;
+  }
+  stages.readiness = finish(stages.readiness, "passed");
+  const secrets = [...readiness.secrets.values()];
+  const scrub = (message) => secrets.reduce((text, secret) => text.replaceAll(secret, "***"), message);
+  const browser = await chromium.launch({
+    headless: options.headless ?? true
+  });
+  try {
+    await emit("onBrowserLaunched", { browser });
+    const context = await browser.newContext(toContextOptions(recording));
+    const guard = new OriginGuard(options.allowedOrigins);
+    const navigation = watchNavigation(context, guard);
+    stages.recording = { status: "running", startedAt: timestamp() };
+    const page = await context.newPage();
+    const clock = startClock();
+    await emit("onPageCreated", { page, recording });
+    const syncMark = await recordSyncMark(page, clock);
+    const events = [];
+    const hasAssertions = scenario.steps.some((step2) => ASSERTIONS.has(step2.action));
+    stages.execution = { status: "running", startedAt: timestamp() };
+    if (hasAssertions) {
+      stages.verification = { status: "running", startedAt: timestamp() };
+    }
+    const failure2 = await executeSteps({
+      scenario,
+      page,
+      clock,
+      baseUrl,
+      guard,
+      secrets: readiness.secrets,
+      pointer: viewportCentre(scenario.viewport),
+      observers,
+      events,
+      navigation,
+      masks: new MaskTracker(page),
+      scrub,
+      emit
+    });
+    if (failure2 === void 0) {
+      stages.execution = finish(stages.execution, "passed");
+      stages.verification = hasAssertions ? finish(stages.verification, "passed") : { status: "skipped" };
+    } else {
+      const other = failure2.stage === "execution" ? "verification" : "execution";
+      stages[failure2.stage] = finish(stages[failure2.stage], "failed", {
+        message: failure2.message,
+        stepIndex: failure2.stepIndex
+      });
+      stages[other] = { ...stages[other], status: "skipped" };
+    }
+    await context.close();
+    const video = page.video();
+    let videoPath;
+    try {
+      videoPath = video === null ? void 0 : await video.path();
+      stages.recording = finish(stages.recording, videoPath === void 0 ? "failed" : "passed", videoPath === void 0 ? { message: "no video recorded" } : void 0);
+    } catch (error) {
+      stages.recording = finish(stages.recording, "failed", {
+        message: errorMessage(error)
+      });
+    }
+    const outcome = conclude(startedAt, stages, events, videoPath, syncMark);
+    await emit("onRunFinished", { outcome, video });
+    return outcome;
+  } finally {
+    await browser.close();
+  }
+}
+async function executeSteps(input) {
+  const { clock, emit, scrub } = input;
+  let pointer = input.pointer;
+  for (const [stepIndex, step2] of input.scenario.steps.entries()) {
+    const startMs = clock.now();
+    await emit("onStepStarted", { stepIndex, step: step2, startMs });
+    const ctx = {
+      page: input.page,
+      stepIndex,
+      baseUrl: input.baseUrl,
+      guard: input.guard,
+      secret: input.secrets.get(stepIndex),
+      pointer,
+      observers: input.observers
+    };
+    let failure2;
+    let result = {};
+    let foreign = input.navigation.take();
+    if (foreign === void 0) {
+      try {
+        result = await runAction(step2, ctx);
+      } catch (error) {
+        failure2 = error instanceof StepFailure ? error : new StepFailure("execution", errorMessage(error));
+      }
+      pointer = ctx.pointer;
+      foreign = input.navigation.take();
+    }
+    if (foreign !== void 0) {
+      failure2 = new StepFailure("execution", originNotAllowed(foreign));
+    }
+    const sightings = await input.masks.look();
+    const endMs = Math.max(startMs, clock.now());
+    input.masks.record(sightings, startMs, endMs);
+    const event = {
+      stepIndex,
+      action: step2.action,
+      startMs,
+      endMs,
+      ...result,
+      ...failure2 === void 0 ? {} : failure2.detail,
+      ...step2.caption === void 0 ? {} : { caption: step2.caption }
+    };
+    if (failure2 !== void 0 && failure2.stage === "execution") {
+      event.error = { message: scrub(failure2.message) };
+    }
+    if (event.assertion?.message !== void 0) {
+      event.assertion = {
+        ...event.assertion,
+        message: scrub(event.assertion.message)
+      };
+    }
+    if (step2.action === "fill") {
+      input.masks.track(event, step2.target);
+    }
+    input.events.push(event);
+    await emit("onStepFinished", { stepIndex, step: step2, event });
+    if (failure2 !== void 0) {
+      return {
+        stage: failure2.stage,
+        message: scrub(failure2.message),
+        stepIndex
+      };
+    }
+  }
+  return void 0;
+}
+function watchNavigation(context, guard) {
+  let foreign;
+  const note = (url) => {
+    foreign ??= guard.check(url);
+  };
+  context.on("request", (request) => {
+    if (request.isNavigationRequest() && request.frame().parentFrame() === null) {
+      note(request.url());
+    }
+  });
+  context.on("page", (page) => {
+    page.on("framenavigated", (frame) => {
+      if (frame.parentFrame() === null)
+        note(frame.url());
+    });
+  });
+  return {
+    take() {
+      const origin = foreign;
+      foreign = void 0;
+      return origin;
+    }
+  };
+}
+function pendingStages() {
+  return {
+    readiness: { status: "pending" },
+    execution: { status: "pending" },
+    verification: { status: "pending" },
+    recording: { status: "pending" },
+    rendering: { status: "pending" },
+    storage: { status: "pending" }
+  };
+}
+function finish(stage, status, error) {
+  return {
+    ...stage,
+    status,
+    finishedAt: timestamp(),
+    ...error === void 0 ? {} : { error }
+  };
+}
+function conclude(startedAt, stages, events, videoPath, syncMark) {
+  const warnings = [];
+  return {
+    startedAt,
+    finishedAt: timestamp(),
+    status: deriveRunStatus(stages, warnings),
+    stages,
+    events,
+    warnings,
+    ...syncMark === void 0 ? {} : { syncMark },
+    ...videoPath === void 0 ? {} : { videoPath }
+  };
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// ../../packages/renderer/dist/ffmpeg/index.js
+import path6 from "node:path";
+
+// ../../packages/renderer/dist/renderer.js
+import { mkdir as mkdir3, readFile as readFile2, rename as rename2, stat, writeFile as writeFile2 } from "node:fs/promises";
+import path5 from "node:path";
+
+// ../../packages/renderer/dist/plan/ffmpeg.js
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { createRequire } from "node:module";
+var resolved;
+function resolveFfmpeg() {
+  if (resolved !== void 0)
+    return resolved;
+  const system = spawnSync("ffmpeg", ["-hide_banner", "-encoders"], {
+    encoding: "utf8",
+    windowsHide: true
+  });
+  if (system.status === 0 && /\slibx264\s/.test(system.stdout)) {
+    resolved = "ffmpeg";
+    return resolved;
+  }
+  const bundled = createRequire(import.meta.url)("ffmpeg-static");
+  if (bundled === null || !existsSync2(bundled)) {
+    throw new Error("no FFmpeg: none on PATH, and ffmpeg-static has no binary (was its install script blocked?)");
+  }
+  resolved = bundled;
+  return resolved;
+}
+async function runFfmpeg(args) {
+  const { stdout, stderr } = await runFfmpegRaw(args);
+  return { stdout: stdout.toString("utf8"), stderr };
+}
+function runFfmpegRaw(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(resolveFfmpeg(), ["-hide_banner", "-nostdin", ...args], {
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const stdout = [];
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout.push(chunk);
+    });
+    child.stderr.setEncoding("utf8").on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve({ stdout: Buffer.concat(stdout), stderr });
+      } else {
+        const tail = stderr.trim().split("\n").slice(-5).join("\n");
+        reject(new Error(`ffmpeg exited with ${code}: ${tail}`));
+      }
+    });
+  });
+}
+var FREEZE_MAX_DIFF = 24;
+var FRAME_DIFF = "tblend=all_mode=difference,signalstats,metadata=mode=print:key=lavfi.signalstats.YMAX";
+async function probeVideo(file, options = {}) {
+  const filter = options.freezes === void 0 ? ["-c", "copy"] : ["-vf", FRAME_DIFF];
+  const { stdout, stderr } = await runFfmpeg([
+    "-i",
+    file,
+    "-map",
+    "0:v:0",
+    ...filter,
+    "-f",
+    "null",
+    "-progress",
+    "pipe:1",
+    "-nostats",
+    "-"
+  ]);
+  return parseProbe(stdout, stderr, options.freezes);
+}
+function parseProbe(progress, log, freezeOptions) {
+  const stream = /Stream #\d+:\d+[^\n]*?: Video: ([^\n]+)/.exec(log);
+  if (stream === null)
+    throw new Error("ffmpeg reported no video stream");
+  const details = stream[1];
+  const codec = /^(\w+)/.exec(details)?.[1] ?? "unknown";
+  const size = /, (\d{2,5})x(\d{2,5})/.exec(details);
+  if (size === null)
+    throw new Error(`no frame size in "${details}"`);
+  const rate = /([\d.]+) (?:fps|tbr)/.exec(details);
+  if (rate === null)
+    throw new Error(`no frame rate in "${details}"`);
+  const fps = Number(rate[1]);
+  const pixelFormat = /^\w+(?: \([^)]*\))*, (\w+)/.exec(details)?.[1];
+  const durationMs = readDuration(progress, log, fps);
+  return {
+    width: Number(size[1]),
+    height: Number(size[2]),
+    fps,
+    durationMs,
+    codec,
+    ...pixelFormat === void 0 ? {} : { pixelFormat },
+    freezes: freezeOptions === void 0 ? [] : readFreezes(log, fps, durationMs, freezeOptions)
+  };
+}
+function readFreezes(log, fps, durationMs, options) {
+  const maxDiff = options.maxDiff ?? FREEZE_MAX_DIFF;
+  const frameMs = 1e3 / fps;
+  const freezes = [];
+  let run;
+  const close = () => {
+    if (run !== void 0 && run.endMs - run.startMs >= options.minMs) {
+      freezes.push(run);
+    }
+    run = void 0;
+  };
+  for (const match of log.matchAll(/pts_time:([\d.]+)\s*\n[^\n]*lavfi\.signalstats\.YMAX=(\d+)/g)) {
+    const atMs = Number(match[1]) * 1e3;
+    if (Number(match[2]) > maxDiff) {
+      close();
+    } else if (run === void 0) {
+      run = {
+        startMs: Math.max(0, atMs - frameMs),
+        endMs: Math.min(durationMs, atMs + frameMs)
+      };
+    } else {
+      run.endMs = Math.min(durationMs, atMs + frameMs);
+    }
+  }
+  close();
+  return freezes;
+}
+function readDuration(progress, log, fps) {
+  const header = /Duration: (\d+):(\d+):([\d.]+)/.exec(log);
+  if (header !== null) {
+    const [, h, m, s] = header;
+    return (Number(h) * 3600 + Number(m) * 60 + Number(s)) * 1e3;
+  }
+  const frames = [...progress.matchAll(/^frame=(\d+)$/gm)].at(-1)?.[1];
+  if (frames === void 0)
+    throw new Error("ffmpeg reported no duration");
+  return Number(frames) / fps * 1e3;
+}
+
+// ../../packages/renderer/dist/plan/plan.js
+import { readFile } from "node:fs/promises";
+import path4 from "node:path";
+
+// ../../packages/renderer/dist/plan/sync-mark.js
+var SYNC_GRID = 4;
+var SYNC_TOLERANCE = 64;
+var MAX_SYNC_OFFSET_MS = 500;
+var SEARCH_PAST_OFF_MS = 1e3;
+function parseColour(hex2) {
+  const value = Number.parseInt(hex2.slice(1), 16);
+  return [value >> 16 & 255, value >> 8 & 255, value & 255];
+}
+function syncClearFrame(frames, colour) {
+  const marked = frames.map((cells) => cells.length > 0 && cells.every((cell) => cell.every((channel, index) => Math.abs(channel - colour[index]) <= SYNC_TOLERANCE)));
+  const first = marked.indexOf(true);
+  if (first === -1)
+    return void 0;
+  const clear = marked.findIndex((isMarked, index) => index > first && !isMarked);
+  return clear === -1 ? void 0 : clear;
+}
+async function findSyncClear(file, fps, mark) {
+  try {
+    const { stdout } = await runFfmpegRaw([
+      "-loglevel",
+      "error",
+      "-t",
+      String((mark.offMs + SEARCH_PAST_OFF_MS) / 1e3),
+      "-i",
+      file,
+      "-map",
+      "0:v:0",
+      "-vf",
+      `fps=${fps},crop=iw/2:ih/2:0:0,scale=${SYNC_GRID}:${SYNC_GRID}:flags=area`,
+      "-f",
+      "rawvideo",
+      "-pix_fmt",
+      "rgb24",
+      "pipe:1"
+    ]);
+    const frameBytes = SYNC_GRID * SYNC_GRID * 3;
+    const frames = [];
+    for (let at = 0; at + frameBytes <= stdout.length; at += frameBytes) {
+      const cells = [];
+      for (let cell = at; cell < at + frameBytes; cell += 3) {
+        cells.push([stdout[cell], stdout[cell + 1], stdout[cell + 2]]);
+      }
+      frames.push(cells);
+    }
+    const clear = syncClearFrame(frames, parseColour(mark.colour));
+    return clear === void 0 ? void 0 : clear * 1e3 / fps;
+  } catch {
+    return void 0;
+  }
+}
+function syncOffset(mark, clearMs) {
+  if (clearMs === void 0)
+    return void 0;
+  const offsetMs = clearMs - mark.offMs;
+  return Math.abs(offsetMs) <= MAX_SYNC_OFFSET_MS ? offsetMs : void 0;
+}
+
+// ../../packages/renderer/dist/plan/time-map.js
+function idleStretches(freezes, active, thresholdMs, endMs) {
+  const idle = [];
+  for (const freeze of freezes) {
+    let pieces = [
+      {
+        startMs: Math.max(0, freeze.startMs),
+        endMs: Math.min(endMs, freeze.endMs)
+      }
+    ];
+    for (const window2 of active) {
+      pieces = pieces.flatMap((piece) => subtract(piece, window2));
+    }
+    idle.push(...pieces.filter((piece) => piece.endMs - piece.startMs >= thresholdMs));
+  }
+  return mergeSorted(idle);
+}
+function subtract(piece, cut) {
+  if (cut.endMs <= piece.startMs || cut.startMs >= piece.endMs)
+    return [piece];
+  const out = [];
+  if (cut.startMs > piece.startMs) {
+    out.push({ startMs: piece.startMs, endMs: cut.startMs });
+  }
+  if (cut.endMs < piece.endMs) {
+    out.push({ startMs: cut.endMs, endMs: piece.endMs });
+  }
+  return out;
+}
+function mergeSorted(intervals) {
+  const sorted = [...intervals].sort((a, b) => a.startMs - b.startMs);
+  const out = [];
+  for (const interval of sorted) {
+    const last = out.at(-1);
+    if (last !== void 0 && interval.startMs <= last.endMs) {
+      last.endMs = Math.max(last.endMs, interval.endMs);
+    } else {
+      out.push({ ...interval });
+    }
+  }
+  return out;
+}
+function buildTimeMap(idle, endMs, compressToMs, startMs = 0) {
+  const segments = [];
+  let source = startMs;
+  let output = 0;
+  const push = (sourceEndMs, outputLength) => {
+    if (sourceEndMs <= source)
+      return;
+    segments.push({
+      outputStartMs: output,
+      outputEndMs: output + outputLength,
+      sourceStartMs: source,
+      sourceEndMs
+    });
+    source = sourceEndMs;
+    output += outputLength;
+  };
+  for (const stretch of idle) {
+    if (stretch.startMs >= endMs)
+      break;
+    const stretchStart = Math.max(stretch.startMs, source);
+    push(stretchStart, stretchStart - source);
+    const stretchEnd = Math.min(stretch.endMs, endMs);
+    push(stretchEnd, Math.min(compressToMs, stretchEnd - stretchStart));
+  }
+  push(endMs, endMs - source);
+  return segments;
+}
+function toOutputMs(map, sourceMs) {
+  const first = map[0];
+  const last = map.at(-1);
+  if (first === void 0 || last === void 0)
+    return 0;
+  if (sourceMs <= first.sourceStartMs)
+    return first.outputStartMs;
+  if (sourceMs >= last.sourceEndMs)
+    return last.outputEndMs;
+  const segment = map.find((s) => sourceMs >= s.sourceStartMs && sourceMs < s.sourceEndMs) ?? last;
+  return lerp(sourceMs, segment.sourceStartMs, segment.sourceEndMs, segment.outputStartMs, segment.outputEndMs);
+}
+function toSourceMs(map, outputMs) {
+  const first = map[0];
+  const last = map.at(-1);
+  if (first === void 0 || last === void 0)
+    return 0;
+  if (outputMs <= first.outputStartMs)
+    return first.sourceStartMs;
+  if (outputMs >= last.outputEndMs)
+    return last.sourceEndMs;
+  const segment = map.find((s) => outputMs >= s.outputStartMs && outputMs < s.outputEndMs) ?? last;
+  return lerp(outputMs, segment.outputStartMs, segment.outputEndMs, segment.sourceStartMs, segment.sourceEndMs);
+}
+function lerp(value, a0, a1, b0, b1) {
+  return a1 === a0 ? b0 : b0 + (value - a0) / (a1 - a0) * (b1 - b0);
+}
+
+// ../../packages/renderer/dist/plan/plan.js
+var PLAN_INPUTS = {
+  timeline: "timeline.json",
+  result: "result.json"
+};
+var DEFAULT_OFFSET_MS = -100;
+var DEFAULTS = {
+  idleThresholdMs: 1e3,
+  idleCompressToMs: 400,
+  output: { width: 1920, height: 1080, fps: 30 },
+  /** Zoom on a source with at least two pixels per CSS pixel (ADR-0004 §1). */
+  zoom: 1.6,
+  /** Zoom on a 1× source: past the source pixels already, so kept gentle (spec 4, Risks). */
+  zoomOnLowResSource: 1.25
+};
+var TIMING = {
+  clickRingMs: 300,
+  zoomInMs: 500,
+  zoomOutMs: 400,
+  captionTailMs: 800,
+  endCardMs: 3e3,
+  /** A target whose centre is closer than this to the previous one keeps the zoom and pans. */
+  keepZoomWithinPx: 400,
+  /** A pan never whips across in less than this. */
+  minPanMs: 400,
+  /** The engine waits up to this long for a navigation after the press. */
+  pressToEndMs: 100,
+  /** Masks start this early, to absorb the residual clock offset; one source frame when it is measured. */
+  maskLeadMs: 200,
+  /** Masks end this late, for the same reason: an early end leaks, a late one is safe (#48). */
+  maskTrailMs: 200,
+  /** Masks overhang the field's box by this much on every side. */
+  maskMarginPx: 4,
+  /** A successful run keeps this much video after its last event. */
+  tailMs: 1e3,
+  /** A target box fills at most this share of the zoomed view. */
+  targetFill: 0.9
+};
+var ACTIVE = /* @__PURE__ */ new Set([
+  "navigate",
+  "click",
+  "hover",
+  "fill",
+  "select",
+  "scroll"
+]);
+var CAMERA = /* @__PURE__ */ new Set(["click", "fill", "select"]);
+async function buildRenderPlan(runDir2, options = {}) {
+  const timeline = TimelineSchema.parse(await readJson(path4.join(runDir2, PLAN_INPUTS.timeline)));
+  const result = RunResultSchema.parse(await readJson(path4.join(runDir2, PLAN_INPUTS.result)));
+  const videoFile = path4.join(runDir2, timeline.videoFile);
+  const source = await probeVideo(videoFile, {
+    freezes: {
+      minMs: options.idle?.thresholdMs ?? DEFAULTS.idleThresholdMs
+    }
+  });
+  const syncClearMs = timeline.syncMark === void 0 ? void 0 : await findSyncClear(videoFile, source.fps, timeline.syncMark);
+  return planRender({
+    timeline,
+    result,
+    source,
+    ...syncClearMs === void 0 ? {} : { syncClearMs }
+  }, options);
+}
+async function readJson(file) {
+  return JSON.parse(await readFile(file, "utf8"));
+}
+function planRender(input, options = {}) {
+  const { timeline, result, source } = input;
+  const measuredMs = timeline.syncMark === void 0 ? void 0 : syncOffset(timeline.syncMark, input.syncClearMs);
+  const offsetMs = options.offsetMs ?? measuredMs ?? DEFAULT_OFFSET_MS;
+  const offsetMeasured = options.offsetMs === void 0 && measuredMs !== void 0;
+  const maskLeadMs = offsetMeasured ? 1e3 / source.fps : TIMING.maskLeadMs;
+  const maskTrailMs = offsetMeasured ? 1e3 / source.fps : TIMING.maskTrailMs;
+  const startMs = measuredMs === void 0 ? 0 : clamp(input.syncClearMs ?? 0, 0, source.durationMs);
+  const thresholdMs = options.idle?.thresholdMs ?? DEFAULTS.idleThresholdMs;
+  const compressToMs = options.idle?.compressToMs ?? DEFAULTS.idleCompressToMs;
+  const output = {
+    width: options.output?.width ?? DEFAULTS.output.width,
+    height: options.output?.height ?? DEFAULTS.output.height,
+    fps: options.output?.fps ?? DEFAULTS.output.fps
+  };
+  const viewport = timeline.viewport;
+  const sourceScale = source.width / viewport.width;
+  const maxZoom = options.zoom ?? (sourceScale >= 2 ? DEFAULTS.zoom : DEFAULTS.zoomOnLowResSource);
+  const events = timeline.events;
+  const failure2 = failedStage(result);
+  const toSource = (timelineMs) => clamp(timelineMs + offsetMs, 0, source.durationMs);
+  const failedEvent = failure2?.stepIndex === void 0 ? void 0 : events.find((event) => event.stepIndex === failure2.stepIndex);
+  const lastEvent = events.at(-1);
+  const sourceEndMs = failure2 !== void 0 ? toSource(failedEvent?.endMs ?? lastEvent?.endMs ?? source.durationMs) : lastEvent === void 0 ? source.durationMs : toSource(lastEvent.endMs + TIMING.tailMs);
+  const active = events.filter((event) => ACTIVE.has(event.action)).map((event) => ({
+    startMs: toSource(event.startMs),
+    endMs: toSource(event.endMs)
+  }));
+  const idle = idleStretches(source.freezes, active, thresholdMs, sourceEndMs);
+  const timeMap = buildTimeMap(idle, sourceEndMs, compressToMs, startMs);
+  const out = (timelineMs) => toOutputMs(timeMap, toSource(timelineMs));
+  const videoEndMs = timeMap.at(-1)?.outputEndMs ?? 0;
+  const failureSpec = failure2 === void 0 ? void 0 : failureCard(failure2, videoEndMs, TIMING.endCardMs);
+  return {
+    version: 1,
+    output: {
+      ...output,
+      codec: "h264",
+      pixelFormat: "yuv420p",
+      faststart: true
+    },
+    source: {
+      file: timeline.videoFile,
+      width: source.width,
+      height: source.height,
+      fps: source.fps,
+      durationMs: source.durationMs,
+      scale: sourceScale
+    },
+    viewport,
+    fit: fitInto(viewport, output),
+    offsetMs,
+    offsetMeasured,
+    maskLeadMs,
+    maskTrailMs,
+    durationMs: videoEndMs + (failureSpec?.endCard.durationMs ?? 0),
+    timeMap,
+    cursor: cursorMoves(events, out),
+    clicks: clickRings(events, out),
+    camera: cameraKeyframes(events, out, viewport, maxZoom),
+    masks: maskSpans(events, out, viewport, videoEndMs, {
+      leadMs: maskLeadMs,
+      trailMs: maskTrailMs
+    }),
+    captions: captions(events, out, videoEndMs),
+    ...failureSpec === void 0 ? {} : { failure: failureSpec }
+  };
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function failedStage(result) {
+  for (const stage of [
+    "readiness",
+    "execution",
+    "verification",
+    "recording"
+  ]) {
+    const state = result.stages[stage];
+    if (state.status === "failed") {
+      return {
+        stage,
+        message: state.error?.message ?? "no message",
+        ...state.error?.stepIndex === void 0 ? {} : { stepIndex: state.error.stepIndex }
+      };
+    }
+  }
+  return void 0;
+}
+function failureCard(failure2, startMs, durationMs) {
+  const stage = failure2.stage[0].toUpperCase() + failure2.stage.slice(1);
+  const stepNumber = failure2.stepIndex === void 0 ? void 0 : failure2.stepIndex + 1;
+  const where = stepNumber === void 0 ? "" : ` at step ${stepNumber}`;
+  return {
+    stage: failure2.stage,
+    ...stepNumber === void 0 ? {} : { stepNumber },
+    message: failure2.message,
+    watermark: true,
+    endCard: {
+      startMs,
+      durationMs,
+      text: `${stage} failed${where}: ${failure2.message}`
+    }
+  };
+}
+function fitInto(viewport, output) {
+  const scale = Math.min(output.width / viewport.width, output.height / viewport.height);
+  return {
+    x: (output.width - viewport.width * scale) / 2,
+    y: (output.height - viewport.height * scale) / 2,
+    scale
+  };
+}
+function pressMs(event) {
+  return event.action === "click" ? Math.max(event.startMs, event.endMs - TIMING.pressToEndMs) : event.endMs;
+}
+function cursorMoves(events, out) {
+  return events.flatMap((event) => event.pointer === void 0 ? [] : [
+    {
+      startMs: out(event.startMs),
+      endMs: out(pressMs(event)),
+      from: event.pointer.from,
+      to: event.pointer.to
+    }
+  ]);
+}
+function clickRings(events, out) {
+  return events.flatMap((event) => event.action !== "click" || event.pointer === void 0 ? [] : [
+    {
+      atMs: out(pressMs(event)),
+      durationMs: TIMING.clickRingMs,
+      point: event.pointer.to
+    }
+  ]);
+}
+function cameraKeyframes(events, out, viewport, maxZoom) {
+  const shots = events.flatMap((event) => {
+    if (!CAMERA.has(event.action) || event.target === void 0)
+      return [];
+    const { box } = event.target;
+    const zoom = Math.max(1, Math.min(maxZoom, TIMING.targetFill * viewport.width / Math.max(box.width, 1), TIMING.targetFill * viewport.height / Math.max(box.height, 1)));
+    const action = event.action === "click" ? { startMs: out(pressMs(event)), endMs: out(pressMs(event)) } : { startMs: out(event.startMs), endMs: out(event.endMs) };
+    return [{ ...action, centre: centreOf(box), zoom }];
+  });
+  const keys = [];
+  const push = (atMs, centre, zoom) => {
+    const last = keys.at(-1);
+    keys.push({ atMs: Math.max(atMs, last?.atMs ?? 0, 0), centre, zoom });
+  };
+  const zoomOut = (shot) => {
+    push(shot.endMs, shot.centre, shot.zoom);
+    push(shot.endMs + TIMING.zoomOutMs, shot.centre, 1);
+  };
+  let previous;
+  for (const shot of shots) {
+    let arriveMs = shot.startMs;
+    if (previous === void 0) {
+      const fromMs = Math.max(0, shot.startMs - TIMING.zoomInMs);
+      push(fromMs, shot.centre, 1);
+      arriveMs = Math.max(arriveMs, fromMs + TIMING.zoomInMs);
+    } else if (distance(previous.centre, shot.centre) < TIMING.keepZoomWithinPx || shot.startMs - TIMING.zoomInMs < previous.endMs + TIMING.zoomOutMs) {
+      const fromMs = clamp(shot.startMs - TIMING.zoomInMs, previous.startMs, previous.endMs);
+      push(fromMs, previous.centre, previous.zoom);
+      arriveMs = Math.max(arriveMs, fromMs + TIMING.minPanMs);
+    } else {
+      zoomOut(previous);
+      push(shot.startMs - TIMING.zoomInMs, shot.centre, 1);
+    }
+    push(arriveMs, shot.centre, shot.zoom);
+    previous = shot;
+  }
+  if (previous !== void 0)
+    zoomOut(previous);
+  return keys;
+}
+function centreOf(box) {
+  return { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+}
+function distance(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function maskSpans(events, out, viewport, videoEndMs, { leadMs, trailMs }) {
+  const spans = [];
+  for (const [index, event] of events.entries()) {
+    if (event.masked !== true)
+      continue;
+    if (event.maskVisibility !== void 0) {
+      for (const interval of event.maskVisibility) {
+        const startMs2 = Math.max(0, out(interval.startMs) - leadMs);
+        const endMs2 = interval.endMs === void 0 ? videoEndMs : Math.min(out(interval.endMs) + trailMs, videoEndMs);
+        let box2 = grow(interval.box, TIMING.maskMarginPx);
+        const keys2 = [{ atMs: startMs2, box: box2 }];
+        for (const later of events.slice(index + 1)) {
+          const scroll2 = later.scroll;
+          if (scroll2 === void 0 || scroll2.container !== void 0)
+            continue;
+          if (later.startMs < interval.startMs || interval.endMs !== void 0 && later.startMs >= interval.endMs) {
+            continue;
+          }
+          keys2.push({ atMs: Math.min(out(later.startMs), endMs2), box: box2 });
+          box2 = {
+            ...box2,
+            x: box2.x - (scroll2.after.x - scroll2.before.x),
+            y: box2.y - (scroll2.after.y - scroll2.before.y)
+          };
+          keys2.push({ atMs: Math.min(out(later.endMs), endMs2), box: box2 });
+        }
+        spans.push({ startMs: startMs2, endMs: endMs2, keys: keys2 });
+      }
+      continue;
+    }
+    if (event.target === void 0) {
+      spans.push(wholeViewport(event, out, viewport, videoEndMs, leadMs));
+      continue;
+    }
+    let box = grow(event.target.box, TIMING.maskMarginPx);
+    const startMs = Math.max(0, out(event.startMs) - leadMs);
+    const keys = [{ atMs: startMs, box }];
+    let endMs = videoEndMs;
+    for (const later of events.slice(index + 1)) {
+      if (later.action === "navigate") {
+        endMs = out(later.endMs) + trailMs;
+        break;
+      }
+      const scroll2 = later.scroll;
+      if (scroll2 === void 0 || scroll2.container !== void 0)
+        continue;
+      keys.push({ atMs: out(later.startMs), box });
+      box = {
+        ...box,
+        x: box.x - (scroll2.after.x - scroll2.before.x),
+        y: box.y - (scroll2.after.y - scroll2.before.y)
+      };
+      keys.push({ atMs: out(later.endMs), box });
+      if (!overlaps(box, viewport)) {
+        endMs = out(later.endMs) + trailMs;
+        break;
+      }
+    }
+    spans.push({ startMs, endMs: Math.min(endMs, videoEndMs), keys });
+  }
+  return spans;
+}
+function wholeViewport(event, out, viewport, videoEndMs, leadMs) {
+  const startMs = Math.max(0, out(event.startMs) - leadMs);
+  const box = grow({ x: 0, y: 0, width: viewport.width, height: viewport.height }, TIMING.maskMarginPx);
+  return { startMs, endMs: videoEndMs, keys: [{ atMs: startMs, box }] };
+}
+function grow(box, by) {
+  return {
+    x: box.x - by,
+    y: box.y - by,
+    width: box.width + 2 * by,
+    height: box.height + 2 * by
+  };
+}
+function overlaps(box, viewport) {
+  return box.x < viewport.width && box.y < viewport.height && box.x + box.width > 0 && box.y + box.height > 0;
+}
+function captions(events, out, videoEndMs) {
+  const list = events.flatMap((event) => {
+    const text = event.marker?.kind === "caption" ? event.marker.title : event.caption;
+    if (text === void 0 || text.trim() === "")
+      return [];
+    return [
+      {
+        startMs: out(event.startMs),
+        endMs: Math.min(videoEndMs, out(event.endMs) + TIMING.captionTailMs),
+        text
+      }
+    ];
+  });
+  for (const [index, caption] of list.entries()) {
+    const next = list[index + 1];
+    if (next !== void 0) {
+      caption.endMs = Math.min(caption.endMs, next.startMs);
+    }
+  }
+  return list.filter((caption) => caption.endMs > caption.startMs);
+}
+
+// ../../packages/renderer/dist/renderer.js
+function renderPath(runDir2, renderer) {
+  return path5.join(runDir2, "render", `${renderer}.mp4`);
+}
+async function recordRender(runDir2, renderer, file, draw) {
+  await updateResult(runDir2, (result) => {
+    result.stages.rendering = { status: "running", startedAt: timestamp2() };
+  });
+  try {
+    await mkdir3(path5.dirname(file), { recursive: true });
+    await draw();
+    const probe = await probeVideo(file);
+    const output = {
+      renderer,
+      // Run-relative and `/`-separated on every platform: it goes into JSON.
+      file: path5.relative(runDir2, file).split(path5.sep).join("/"),
+      durationMs: Math.round(probe.durationMs),
+      sizeBytes: (await stat(file)).size,
+      width: probe.width,
+      height: probe.height,
+      fps: probe.fps
+    };
+    await updateResult(runDir2, (result) => {
+      result.renders = [
+        ...result.renders.filter((entry2) => entry2.renderer !== renderer),
+        output
+      ];
+      result.stages.rendering = finish2(result.stages.rendering, "passed");
+    });
+    return output;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    await updateResult(runDir2, (result) => {
+      result.stages.rendering = finish2(result.stages.rendering, "failed", {
+        message
+      });
+    });
+    throw error;
+  }
+}
+var queues = /* @__PURE__ */ new Map();
+function updateResult(runDir2, change) {
+  const file = path5.resolve(runDir2, PLAN_INPUTS.result);
+  const run = async () => {
+    const result = RunResultSchema.parse(JSON.parse(await readFile2(file, "utf8")));
+    change(result);
+    result.status = deriveRunStatus(result.stages, result.warnings);
+    const valid = RunResultSchema.parse(result);
+    const temporary = `${file}.${process.pid}.tmp`;
+    await writeFile2(temporary, `${JSON.stringify(valid, null, 2)}
+`);
+    await rename2(temporary, file);
+  };
+  const next = (queues.get(file) ?? Promise.resolve()).then(run, run);
+  queues.set(file, next.catch(() => void 0));
+  return next;
+}
+function finish2(stage, status, error) {
+  return {
+    ...stage,
+    status,
+    finishedAt: timestamp2(),
+    ...error === void 0 ? {} : { error }
+  };
+}
+function timestamp2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// ../../packages/renderer/dist/ffmpeg/pipeline.js
+import { spawn as spawn2 } from "node:child_process";
+
+// ../../packages/renderer/dist/plan/frame.js
+function frameCount(plan) {
+  return Math.max(1, Math.round(plan.durationMs / 1e3 * plan.output.fps));
+}
+function easeInOut(t) {
+  const x = Math.min(1, Math.max(0, t));
+  return x < 0.5 ? 4 * x * x * x : 1 - (-2 * x + 2) ** 3 / 2;
+}
+function frameAt(plan, frame) {
+  const atMs = frame * 1e3 / plan.output.fps;
+  const card = plan.failure?.endCard;
+  const onCard = card !== void 0 && atMs >= card.startMs;
+  const view = cameraAt(plan, onCard ? card.startMs : atMs);
+  const { fit, viewport, source } = plan;
+  const content = {
+    x: fit.x,
+    y: fit.y,
+    width: viewport.width * fit.scale,
+    height: viewport.height * fit.scale
+  };
+  const scale = content.width / view.width;
+  const toOutput = (point) => ({
+    x: content.x + (point.x - view.x) * scale,
+    y: content.y + (point.y - view.y) * scale
+  });
+  const crop = {
+    x: view.x * source.scale,
+    y: view.y * source.scale,
+    width: view.width * source.scale,
+    height: view.height * source.scale
+  };
+  const watermark = plan.failure !== void 0;
+  if (onCard) {
+    return {
+      sourceMs: null,
+      crop,
+      content,
+      scale,
+      rings: [],
+      masks: [],
+      watermark,
+      endCard: card.text
+    };
+  }
+  const cursor = cursorAt(plan.cursor, atMs);
+  const rings = plan.clicks.flatMap((ring) => {
+    const progress = (atMs - ring.atMs) / ring.durationMs;
+    return progress >= 0 && progress < 1 ? [{ point: toOutput(ring.point), progress }] : [];
+  });
+  const masks = plan.masks.flatMap((mask) => {
+    if (atMs < mask.startMs || atMs >= mask.endMs)
+      return [];
+    const box = maskBoxAt(mask, atMs);
+    const corner = toOutput(box);
+    const clipped = intersect({
+      x: corner.x,
+      y: corner.y,
+      width: box.width * scale,
+      height: box.height * scale
+    }, content);
+    return clipped === void 0 ? [] : [clipped];
+  });
+  const caption = plan.captions.find((entry2) => atMs >= entry2.startMs && atMs < entry2.endMs)?.text;
+  return {
+    sourceMs: toSourceMs(plan.timeMap, atMs),
+    crop,
+    content,
+    scale,
+    ...cursor === void 0 ? {} : { cursor: toOutput(cursor) },
+    rings,
+    masks,
+    ...caption === void 0 ? {} : { caption },
+    watermark
+  };
+}
+function cameraAt(plan, atMs) {
+  const { centre, zoom } = cameraStateAt(plan.camera, atMs);
+  const { width: vw, height: vh } = plan.viewport;
+  const width = vw / zoom;
+  const height = vh / zoom;
+  return {
+    x: Math.min(vw - width, Math.max(0, centre.x - width / 2)),
+    y: Math.min(vh - height, Math.max(0, centre.y - height / 2)),
+    width,
+    height
+  };
+}
+function cameraStateAt(keys, atMs) {
+  const next = keys.findIndex((key) => key.atMs > atMs);
+  if (next === 0 || keys.length === 0) {
+    return { centre: keys[0]?.centre ?? { x: 0, y: 0 }, zoom: 1 };
+  }
+  if (next === -1) {
+    const last = keys[keys.length - 1];
+    return { centre: last.centre, zoom: last.zoom };
+  }
+  const a = keys[next - 1];
+  const b = keys[next];
+  const t = easeInOut((atMs - a.atMs) / (b.atMs - a.atMs));
+  return {
+    centre: mix(a.centre, b.centre, t),
+    zoom: a.zoom + (b.zoom - a.zoom) * t
+  };
+}
+function cursorAt(moves, atMs) {
+  let current;
+  for (const move of moves) {
+    if (move.startMs > atMs)
+      break;
+    current = move;
+  }
+  if (current === void 0)
+    return void 0;
+  const length = current.endMs - current.startMs;
+  const t = length <= 0 ? 1 : easeInOut((atMs - current.startMs) / length);
+  return mix(current.from, current.to, t);
+}
+function maskBoxAt(mask, atMs) {
+  const next = mask.keys.findIndex((key) => key.atMs > atMs);
+  if (next === 0)
+    return mask.keys[0].box;
+  if (next === -1)
+    return mask.keys[mask.keys.length - 1].box;
+  const a = mask.keys[next - 1];
+  const b = mask.keys[next];
+  const t = b.atMs === a.atMs ? 1 : (atMs - a.atMs) / (b.atMs - a.atMs);
+  return { ...a.box, ...mix(a.box, b.box, t) };
+}
+function mix(a, b, t) {
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}
+function intersect(a, b) {
+  const x = Math.max(a.x, b.x);
+  const y = Math.max(a.y, b.y);
+  const right = Math.min(a.x + a.width, b.x + b.width);
+  const bottom = Math.min(a.y + a.height, b.y + b.height);
+  return right > x && bottom > y ? { x, y, width: right - x, height: bottom - y } : void 0;
+}
+
+// ../../packages/renderer/dist/ffmpeg/font.js
+import { fileURLToPath } from "node:url";
+
+// ../../packages/renderer/dist/ffmpeg/opentype.js
+import { readFileSync as readFileSync3 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+var opentype = createRequire2(import.meta.url)("opentype.js");
+function loadFont(file) {
+  const bytes = readFileSync3(file);
+  return opentype.parse(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+}
+
+// ../../packages/renderer/dist/ffmpeg/outline.js
+var TOLERANCE = 0.05;
+function fillPath(commands, scale, dx) {
+  const lines = flatten(commands, scale, dx);
+  if (lines.length === 0) {
+    return { x: 0, y: 0, width: 0, height: 0, alpha: new Float32Array(0) };
+  }
+  let left = Number.POSITIVE_INFINITY;
+  let top = Number.POSITIVE_INFINITY;
+  let right = Number.NEGATIVE_INFINITY;
+  let bottom = Number.NEGATIVE_INFINITY;
+  for (let i = 0; i < lines.length; i += 2) {
+    left = Math.min(left, lines[i]);
+    right = Math.max(right, lines[i]);
+    top = Math.min(top, lines[i + 1]);
+    bottom = Math.max(bottom, lines[i + 1]);
+  }
+  const x = Math.floor(left);
+  const y = Math.floor(top);
+  const width = Math.max(1, Math.ceil(right) - x);
+  const height = Math.max(1, Math.ceil(bottom) - y);
+  const stride = width + 2;
+  const accumulation = new Float32Array(stride * height);
+  for (let i = 0; i + 3 < lines.length; i += 4) {
+    accumulate(accumulation, stride, height, lines[i] - x, lines[i + 1] - y, lines[i + 2] - x, lines[i + 3] - y);
+  }
+  const alpha = new Float32Array(width * height);
+  for (let row = 0; row < height; row++) {
+    let sum = 0;
+    for (let column = 0; column < width; column++) {
+      sum += accumulation[row * stride + column];
+      alpha[row * width + column] = Math.round(Math.min(1, Math.abs(sum)) * 255) / 255;
+    }
+  }
+  return { x, y, width, height, alpha };
+}
+function flatten(commands, scale, dx) {
+  const out = [];
+  let startX = 0;
+  let startY = 0;
+  let penX = 0;
+  let penY = 0;
+  let open = false;
+  const lineTo = (x, y) => {
+    if (x !== penX || y !== penY)
+      out.push(penX, penY, x, y);
+    penX = x;
+    penY = y;
+  };
+  const close = () => {
+    if (open)
+      lineTo(startX, startY);
+    open = false;
+  };
+  const px = (x) => dx + x * scale;
+  const py = (y) => -y * scale;
+  for (const command of commands) {
+    switch (command.type) {
+      case "M":
+        close();
+        startX = penX = px(command.x);
+        startY = penY = py(command.y);
+        open = true;
+        break;
+      case "L":
+        lineTo(px(command.x), py(command.y));
+        break;
+      case "Q": {
+        const x0 = penX;
+        const y0 = penY;
+        const x1 = px(command.x1);
+        const y1 = py(command.y1);
+        const x2 = px(command.x);
+        const y2 = py(command.y);
+        const bend = Math.hypot(x0 - 2 * x1 + x2, y0 - 2 * y1 + y2);
+        const n = Math.max(1, Math.ceil(Math.sqrt(bend / (4 * TOLERANCE))));
+        for (let i = 1; i <= n; i++) {
+          const t = i / n;
+          const u = 1 - t;
+          lineTo(u * u * x0 + 2 * u * t * x1 + t * t * x2, u * u * y0 + 2 * u * t * y1 + t * t * y2);
+        }
+        break;
+      }
+      case "C": {
+        const x0 = penX;
+        const y0 = penY;
+        const x1 = px(command.x1);
+        const y1 = py(command.y1);
+        const x2 = px(command.x2);
+        const y2 = py(command.y2);
+        const x3 = px(command.x);
+        const y3 = py(command.y);
+        const bend = Math.max(Math.hypot(x0 - 2 * x1 + x2, y0 - 2 * y1 + y2), Math.hypot(x1 - 2 * x2 + x3, y1 - 2 * y2 + y3));
+        const n = Math.max(1, Math.ceil(Math.sqrt(0.75 * bend / TOLERANCE)));
+        for (let i = 1; i <= n; i++) {
+          const t = i / n;
+          const u = 1 - t;
+          lineTo(u * u * u * x0 + 3 * u * u * t * x1 + 3 * u * t * t * x2 + t * t * t * x3, u * u * u * y0 + 3 * u * u * t * y1 + 3 * u * t * t * y2 + t * t * t * y3);
+        }
+        break;
+      }
+      case "Z":
+        close();
+        break;
+    }
+  }
+  close();
+  return out;
+}
+function accumulate(buffer, stride, height, ax, ay, bx, by) {
+  if (ay === by)
+    return;
+  let x0 = ax;
+  let y0 = ay;
+  let x1 = bx;
+  let y1 = by;
+  let direction = 1;
+  if (y0 > y1) {
+    direction = -1;
+    [x0, y0, x1, y1] = [x1, y1, x0, y0];
+  }
+  const slope = (x1 - x0) / (y1 - y0);
+  let x = x0;
+  if (y0 < 0) {
+    x -= y0 * slope;
+    y0 = 0;
+  }
+  const last = Math.min(height, Math.ceil(y1));
+  for (let row = Math.max(0, Math.floor(y0)); row < last; row++) {
+    const base = row * stride;
+    const dy = Math.min(row + 1, y1) - Math.max(row, y0);
+    const next = x + slope * dy;
+    const d = dy * direction;
+    const lo = Math.min(x, next);
+    const hi = Math.max(x, next);
+    const loCell = Math.floor(lo);
+    const hiCell = Math.ceil(hi);
+    if (hiCell <= loCell + 1) {
+      const share = (x + next) / 2 - loCell;
+      buffer[base + loCell] += d - d * share;
+      buffer[base + loCell + 1] += d * share;
+    } else {
+      const s = 1 / (hi - lo);
+      const loFraction = lo - loCell;
+      const first = 0.5 * s * (1 - loFraction) * (1 - loFraction);
+      const hiFraction = hi - hiCell + 1;
+      const end = 0.5 * s * hiFraction * hiFraction;
+      buffer[base + loCell] += d * first;
+      if (hiCell === loCell + 2) {
+        buffer[base + loCell + 1] += d * (1 - first - end);
+      } else {
+        const second = s * (1.5 - loFraction);
+        buffer[base + loCell + 1] += d * (second - first);
+        for (let cell = loCell + 2; cell < hiCell - 1; cell++) {
+          buffer[base + cell] += d * s;
+        }
+        const before = second + (hiCell - loCell - 3) * s;
+        buffer[base + hiCell - 1] += d * (1 - before - end);
+      }
+      buffer[base + hiCell] += d * end;
+    }
+    x = next;
+  }
+}
+
+// ../../packages/renderer/dist/ffmpeg/font.js
+var FILES = {
+  regular: "Inter-Regular.ttf",
+  semibold: "Inter-SemiBold.ttf"
+};
+var faces = /* @__PURE__ */ new Map();
+function face(weight) {
+  let loaded = faces.get(weight);
+  if (loaded === void 0) {
+    const font = loadFont(fileURLToPath(new URL(`../../fonts/${FILES[weight]}`, import.meta.url)));
+    loaded = {
+      font,
+      capUnits: font.tables.os2.sCapHeight,
+      descentUnits: -font.descender,
+      fallback: font.charToGlyphIndex("?")
+    };
+    faces.set(weight, loaded);
+  }
+  return loaded;
+}
+var CAP_RATIO = 0.72;
+function capHeight(style) {
+  return Math.round(style.fontPx * CAP_RATIO);
+}
+function unitOf(style) {
+  return capHeight(style) / face(style.weight).capUnits;
+}
+function shape(text, weight) {
+  const { font, fallback } = face(weight);
+  const shaped = [];
+  let pen = 0;
+  let previous = -1;
+  for (const char of text) {
+    const index = font.charToGlyphIndex(char);
+    const glyph = index === 0 ? fallback : index;
+    if (previous >= 0)
+      pen += font.getKerningValue(previous, glyph);
+    shaped.push({ glyph, at: pen });
+    pen += font.glyphs.get(glyph).advanceWidth ?? 0;
+    previous = glyph;
+  }
+  shaped.push({ glyph: -1, at: pen });
+  return shaped;
+}
+function measureText(text, style) {
+  const shaped = shape(text, style.weight);
+  return shaped[shaped.length - 1].at * unitOf(style);
+}
+function wrapText(text, style, maxWidth) {
+  const lines = [];
+  for (const paragraph of text.split("\n")) {
+    let line = "";
+    for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+      const candidate = line === "" ? word : `${line} ${word}`;
+      if (measureText(candidate, style) <= maxWidth) {
+        line = candidate;
+        continue;
+      }
+      if (line !== "")
+        lines.push(line);
+      line = "";
+      for (const char of word) {
+        if (line !== "" && measureText(line + char, style) > maxWidth) {
+          lines.push(line);
+          line = "";
+        }
+        line += char;
+      }
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function lineHeight(style) {
+  return style.fontPx * 1.25;
+}
+function descent(style) {
+  return unitOf(style) * face(style.weight).descentUnits;
+}
+var PHASES = 4;
+var bitmaps = /* @__PURE__ */ new Map();
+function bitmap(weight, unit, glyph, phase) {
+  const key = `${weight}/${unit}/${glyph}/${phase}`;
+  let mask = bitmaps.get(key);
+  if (mask === void 0) {
+    const { commands } = face(weight).font.glyphs.get(glyph).path;
+    mask = fillPath(commands, unit, phase / PHASES);
+    bitmaps.set(key, mask);
+  }
+  return mask;
+}
+function textGlyphs(text, style, x, y) {
+  const unit = unitOf(style);
+  const baseline = Math.round(y);
+  const placed = [];
+  for (const { glyph, at } of shape(text, style.weight)) {
+    if (glyph < 0)
+      break;
+    const steps = Math.round((x + at * unit) * PHASES);
+    const whole = Math.floor(steps / PHASES);
+    const mask = bitmap(style.weight, unit, glyph, steps - whole * PHASES);
+    if (mask.width > 0)
+      placed.push({ mask, x: whole, y: baseline });
+  }
+  return placed;
+}
+
+// ../../packages/renderer/dist/ffmpeg/raster.js
+function hex(value) {
+  const n = Number.parseInt(value.slice(1), 16);
+  return { r: n >> 16 & 255, g: n >> 8 & 255, b: n & 255 };
+}
+function createPicture(width, height) {
+  return { width, height, data: new Uint8Array(width * height * 3) };
+}
+function fill(picture, colour) {
+  const { data } = picture;
+  for (let i = 0; i < data.length; i += 3) {
+    data[i] = colour.r;
+    data[i + 1] = colour.g;
+    data[i + 2] = colour.b;
+  }
+}
+function blendAt(data, index, colour, alpha) {
+  const keep = 1 - alpha;
+  data[index] = data[index] * keep + colour.r * alpha;
+  data[index + 1] = data[index + 1] * keep + colour.g * alpha;
+  data[index + 2] = data[index + 2] * keep + colour.b * alpha;
+}
+function pixelBounds(picture, box) {
+  return [
+    Math.max(0, Math.round(box.x)),
+    Math.max(0, Math.round(box.y)),
+    Math.min(picture.width, Math.round(box.x + box.width)),
+    Math.min(picture.height, Math.round(box.y + box.height))
+  ];
+}
+function drawScaled(target, source, crop, content) {
+  const [x0, y0, x1, y1] = pixelBounds(target, content);
+  const columns = samples(x0, x1, content.x, crop.x, crop.width / content.width, source.width);
+  const rows = samples(y0, y1, content.y, crop.y, crop.height / content.height, source.height);
+  const src = source.data;
+  const dst = target.data;
+  const stride = source.width * 3;
+  for (let y = y0; y < y1; y++) {
+    const top = rows.from[y - y0] * stride;
+    const bottom = rows.to[y - y0] * stride;
+    const fy = rows.weight[y - y0];
+    let out = (y * target.width + x0) * 3;
+    for (let x = 0; x < x1 - x0; x++) {
+      const left = columns.from[x] * 3;
+      const right = columns.to[x] * 3;
+      const fx = columns.weight[x];
+      for (let c = 0; c < 3; c++) {
+        const a = src[top + left + c];
+        const b = src[top + right + c];
+        const d = src[bottom + left + c];
+        const e = src[bottom + right + c];
+        const upper = a + (b - a) * fx;
+        const lower = d + (e - d) * fx;
+        dst[out + c] = upper + (lower - upper) * fy + 0.5;
+      }
+      out += 3;
+    }
+  }
+}
+function samples(start, end, contentStart, cropStart, step2, size) {
+  const count = Math.max(0, end - start);
+  const from = new Int32Array(count);
+  const to = new Int32Array(count);
+  const weight = new Float32Array(count);
+  for (let i = 0; i < count; i++) {
+    const at = Math.min(size - 1, Math.max(0, cropStart + (start + i + 0.5 - contentStart) * step2 - 0.5));
+    from[i] = Math.floor(at);
+    to[i] = Math.min(size - 1, from[i] + 1);
+    weight[i] = at - from[i];
+  }
+  return { from, to, weight };
+}
+function fillBox(picture, box, colour, alpha) {
+  const [x0, y0, x1, y1] = pixelBounds(picture, box);
+  for (let y = y0; y < y1; y++) {
+    for (let x = x0; x < x1; x++) {
+      blendAt(picture.data, (y * picture.width + x) * 3, colour, alpha);
+    }
+  }
+}
+function blurBox(picture, box, sigma) {
+  const [bx0, by0, bx1, by1] = pixelBounds(picture, box);
+  if (bx1 <= bx0 || by1 <= by0)
+    return;
+  const margin = Math.ceil(sigma * 3);
+  const x0 = Math.max(0, bx0 - margin);
+  const y0 = Math.max(0, by0 - margin);
+  const x1 = Math.min(picture.width, bx1 + margin);
+  const y1 = Math.min(picture.height, by1 + margin);
+  const width = x1 - x0;
+  const height = y1 - y0;
+  const channels = [0, 1, 2].map((c) => {
+    const plane = new Float32Array(width * height);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        plane[y * width + x] = picture.data[((y + y0) * picture.width + x + x0) * 3 + c];
+      }
+    }
+    return plane;
+  });
+  const scratch = new Float32Array(width * height);
+  for (const size of gaussBoxes(sigma, 3)) {
+    const radius = (size - 1) / 2;
+    for (const plane of channels) {
+      boxPass(plane, scratch, width, height, radius, true);
+      boxPass(scratch, plane, width, height, radius, false);
+    }
+  }
+  for (let y = by0; y < by1; y++) {
+    for (let x = bx0; x < bx1; x++) {
+      const at = (y - y0) * width + (x - x0);
+      const index = (y * picture.width + x) * 3;
+      for (let c = 0; c < 3; c++)
+        picture.data[index + c] = channels[c][at];
+    }
+  }
+}
+function gaussBoxes(sigma, n) {
+  const ideal = Math.sqrt(12 * sigma * sigma / n + 1);
+  let lower = Math.floor(ideal);
+  if (lower % 2 === 0)
+    lower--;
+  const upper = lower + 2;
+  const m = Math.round((12 * sigma * sigma - n * lower * lower - 4 * n * lower - 3 * n) / (-4 * lower - 4));
+  return Array.from({ length: n }, (_, i) => i < m ? lower : upper);
+}
+function boxPass(from, to, width, height, radius, horizontal) {
+  const length = horizontal ? width : height;
+  const lines = horizontal ? height : width;
+  const step2 = horizontal ? 1 : width;
+  const scale = 1 / (2 * radius + 1);
+  for (let line = 0; line < lines; line++) {
+    const base = horizontal ? line * width : line;
+    const at = (i) => from[base + Math.min(length - 1, Math.max(0, i)) * step2];
+    let sum = 0;
+    for (let i = -radius; i <= radius; i++)
+      sum += at(i);
+    for (let i = 0; i < length; i++) {
+      to[base + i * step2] = sum * scale;
+      sum += at(i + radius + 1) - at(i - radius);
+    }
+  }
+}
+function paint(picture, bounds, colour, alpha, coverage) {
+  const x0 = Math.max(0, Math.floor(bounds.x));
+  const y0 = Math.max(0, Math.floor(bounds.y));
+  const x1 = Math.min(picture.width, Math.ceil(bounds.x + bounds.width));
+  const y1 = Math.min(picture.height, Math.ceil(bounds.y + bounds.height));
+  for (let y = y0; y < y1; y++) {
+    for (let x = x0; x < x1; x++) {
+      const amount = coverage(x + 0.5, y + 0.5) * alpha;
+      if (amount > 0) {
+        blendAt(picture.data, (y * picture.width + x) * 3, colour, amount);
+      }
+    }
+  }
+}
+function edge(distance2) {
+  return Math.min(1, Math.max(0, distance2 + 0.5));
+}
+function roundRectDistance(box, radius, x, y) {
+  const hx = box.width / 2 - radius;
+  const hy = box.height / 2 - radius;
+  const dx = Math.abs(x - (box.x + box.width / 2)) - hx;
+  const dy = Math.abs(y - (box.y + box.height / 2)) - hy;
+  const outside = Math.hypot(Math.max(dx, 0), Math.max(dy, 0));
+  return outside + Math.min(Math.max(dx, dy), 0) - radius;
+}
+function polygonDistance(points, x, y) {
+  let nearest = Number.POSITIVE_INFINITY;
+  let inside = false;
+  for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+    const a = points[j];
+    const b = points[i];
+    nearest = Math.min(nearest, segmentDistance(a.x, a.y, b.x, b.y, x, y));
+    if (a.y > y !== b.y > y && x < (b.x - a.x) * (y - a.y) / (b.y - a.y) + a.x) {
+      inside = !inside;
+    }
+  }
+  return inside ? -nearest : nearest;
+}
+function segmentDistance(x1, y1, x2, y2, x, y) {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  const length = dx * dx + dy * dy;
+  const t = length === 0 ? 0 : Math.min(1, Math.max(0, ((x - x1) * dx + (y - y1) * dy) / length));
+  return Math.hypot(x - (x1 + t * dx), y - (y1 + t * dy));
+}
+function mergeMasks(parts) {
+  if (parts.length === 0) {
+    return { x: 0, y: 0, width: 0, height: 0, alpha: new Float32Array(0) };
+  }
+  let left = Number.POSITIVE_INFINITY;
+  let top = Number.POSITIVE_INFINITY;
+  let right = Number.NEGATIVE_INFINITY;
+  let bottom = Number.NEGATIVE_INFINITY;
+  for (const { mask, x, y } of parts) {
+    left = Math.min(left, mask.x + x);
+    top = Math.min(top, mask.y + y);
+    right = Math.max(right, mask.x + x + mask.width);
+    bottom = Math.max(bottom, mask.y + y + mask.height);
+  }
+  const width = right - left;
+  const alpha = new Float32Array(width * (bottom - top));
+  for (const { mask, x, y } of parts) {
+    const ox = mask.x + x - left;
+    const oy = mask.y + y - top;
+    for (let my = 0; my < mask.height; my++) {
+      const row = (oy + my) * width + ox;
+      for (let mx = 0; mx < mask.width; mx++) {
+        const amount = mask.alpha[my * mask.width + mx];
+        if (amount > 0)
+          alpha[row + mx] = Math.min(1, alpha[row + mx] + amount);
+      }
+    }
+  }
+  return { x: left, y: top, width, height: bottom - top, alpha };
+}
+function paintMask(picture, mask, colour, dx = 0, dy = 0) {
+  const ox = mask.x + Math.round(dx);
+  const oy = mask.y + Math.round(dy);
+  for (let my = 0; my < mask.height; my++) {
+    const y = oy + my;
+    if (y < 0 || y >= picture.height)
+      continue;
+    for (let mx = 0; mx < mask.width; mx++) {
+      const x = ox + mx;
+      if (x < 0 || x >= picture.width)
+        continue;
+      const amount = mask.alpha[my * mask.width + mx];
+      if (amount > 0) {
+        blendAt(picture.data, (y * picture.width + x) * 3, colour, amount);
+      }
+    }
+  }
+}
+
+// ../../packages/renderer/dist/ffmpeg/compose.js
+var WHITE = hex("#ffffff");
+var BLACK = hex("#000000");
+var LOOK = {
+  mask: { sigma: 12, wash: hex("#808080"), washAlpha: 0.35 },
+  cursor: { fill: WHITE, outline: hex("#111111"), outlineWidth: 2 },
+  ring: { colour: WHITE, width: 4, fromRadius: 12, toRadius: 36 },
+  caption: {
+    panel: BLACK,
+    panelAlpha: 0.6,
+    padding: 16,
+    radius: 12,
+    bottom: 64,
+    maxWidth: 1600,
+    text: { fontPx: 40, weight: "regular" }
+  },
+  watermark: {
+    fill: hex("#d93025"),
+    margin: 24,
+    paddingX: 16,
+    paddingY: 8,
+    radius: 12,
+    label: "FAILED",
+    text: { fontPx: 32, weight: "semibold" }
+  },
+  endCard: {
+    background: hex("#111111"),
+    maxWidth: 1600,
+    text: { fontPx: 48, weight: "regular" }
+  }
+};
+var ARROW = [
+  { x: 0, y: 0 },
+  { x: 0, y: 23 },
+  { x: 5.5, y: 18 },
+  { x: 9.5, y: 27.6 },
+  { x: 13.2, y: 26 },
+  { x: 9.3, y: 16.6 },
+  { x: 16.6, y: 16.6 }
+];
+function createCompositor(output) {
+  const captions2 = /* @__PURE__ */ new Map();
+  const cards = /* @__PURE__ */ new Map();
+  const badge = layBadge(output);
+  return {
+    compose(target, state, source) {
+      if (state.endCard !== void 0) {
+        fill(target, LOOK.endCard.background);
+        const card = cached(cards, state.endCard, (text) => layEndCard(text, output));
+        paintMask(target, card.mask, WHITE);
+      } else {
+        fill(target, BLACK);
+        if (source !== void 0) {
+          drawScaled(target, source, state.crop, state.content);
+        }
+        for (const box of state.masks) {
+          blurBox(target, box, LOOK.mask.sigma);
+          fillBox(target, box, LOOK.mask.wash, LOOK.mask.washAlpha);
+        }
+        for (const ring of state.rings) {
+          drawRing(target, ring.point, ring.progress, state.scale);
+        }
+        if (state.cursor !== void 0) {
+          drawCursor(target, state.cursor, state.scale);
+        }
+        if (state.caption !== void 0) {
+          const caption = cached(captions2, state.caption, (text) => layCaption(text, output));
+          const { panel } = LOOK.caption;
+          drawPanel(target, caption.panel, panel, LOOK.caption.panelAlpha);
+          paintMask(target, caption.mask, WHITE);
+        }
+      }
+      if (state.watermark) {
+        drawPanel(target, badge.panel, LOOK.watermark.fill, 1);
+        paintMask(target, badge.mask, WHITE);
+      }
+    }
+  };
+}
+function cached(store, text, lay) {
+  let laid = store.get(text);
+  if (laid === void 0) {
+    laid = lay(text);
+    store.set(text, laid);
+  }
+  return laid;
+}
+function drawRing(target, point, progress, scale) {
+  const { colour, width, fromRadius, toRadius } = LOOK.ring;
+  const radius = (fromRadius + (toRadius - fromRadius) * progress) * scale;
+  const half = width * scale / 2;
+  const reach = radius + half + 1;
+  paint(target, {
+    x: point.x - reach,
+    y: point.y - reach,
+    width: reach * 2,
+    height: reach * 2
+  }, colour, 1 - progress, (x, y) => edge(half - Math.abs(Math.hypot(x - point.x, y - point.y) - radius)));
+}
+function drawCursor(target, tip, scale) {
+  const shape2 = ARROW.map((p) => ({
+    x: tip.x + p.x * scale,
+    y: tip.y + p.y * scale
+  }));
+  const outline = LOOK.cursor.outlineWidth * scale;
+  const xs = shape2.map((p) => p.x);
+  const ys = shape2.map((p) => p.y);
+  const bounds = {
+    x: Math.min(...xs) - outline - 1,
+    y: Math.min(...ys) - outline - 1,
+    width: Math.max(...xs) - Math.min(...xs) + 2 * outline + 2,
+    height: Math.max(...ys) - Math.min(...ys) + 2 * outline + 2
+  };
+  paint(target, bounds, LOOK.cursor.outline, 1, (x, y) => edge(outline - polygonDistance(shape2, x, y)));
+  paint(target, bounds, LOOK.cursor.fill, 1, (x, y) => edge(-polygonDistance(shape2, x, y)));
+}
+function drawPanel(target, panel, colour, alpha) {
+  const radius = Math.min(LOOK.caption.radius, panel.height / 2);
+  paint(target, panel, colour, alpha, (x, y) => edge(-roundRectDistance(panel, radius, x, y)));
+}
+function textMask(lines, style, centreX, baseline) {
+  const glyphs = lines.flatMap((line, index) => textGlyphs(line, style, centreX - measureText(line, style) / 2, baseline + index * lineHeight(style)));
+  return mergeMasks(glyphs);
+}
+function blockHeight(lines, style) {
+  return (lines.length - 1) * lineHeight(style) + capHeight(style) + descent(style);
+}
+function layCaption(text, output) {
+  const { padding, bottom, maxWidth, text: style } = LOOK.caption;
+  const lines = wrapText(text, style, maxWidth - 2 * padding);
+  const width = Math.max(...lines.map((line) => measureText(line, style))) + 2 * padding;
+  const height = blockHeight(lines, style) + 2 * padding;
+  const panel = {
+    x: (output.width - width) / 2,
+    y: output.height - bottom - height,
+    width,
+    height
+  };
+  return {
+    panel,
+    mask: textMask(lines, style, output.width / 2, panel.y + padding + capHeight(style))
+  };
+}
+function layBadge(output) {
+  const { margin, paddingX, paddingY, label, text: style } = LOOK.watermark;
+  const width = measureText(label, style) + 2 * paddingX;
+  const height = capHeight(style) + 2 * paddingY;
+  const panel = {
+    x: output.width - margin - width,
+    y: margin,
+    width,
+    height
+  };
+  return {
+    panel,
+    mask: textMask([label], style, panel.x + width / 2, panel.y + paddingY + capHeight(style))
+  };
+}
+function layEndCard(text, output) {
+  const { maxWidth, text: style } = LOOK.endCard;
+  const lines = wrapText(text, style, maxWidth);
+  const height = (lines.length - 1) * lineHeight(style) + capHeight(style);
+  const top = (output.height - height) / 2;
+  const panel = { x: 0, y: 0, width: output.width, height: output.height };
+  return {
+    panel,
+    mask: textMask(lines, style, output.width / 2, top + capHeight(style))
+  };
+}
+
+// ../../packages/renderer/dist/ffmpeg/pipeline.js
+async function drawPlan(sourceFile, plan, out) {
+  const { output } = plan;
+  const compositor = createCompositor(output);
+  const source = openSource(sourceFile, plan.source);
+  const encoder = startEncoder(plan, out);
+  const pictures = [0, 1].map(() => createPicture(output.width, output.height));
+  const pending = [void 0, void 0];
+  try {
+    const frames = frameCount(plan);
+    for (let frame = 0; frame < frames; frame++) {
+      const slot = frame % 2;
+      await pending[slot];
+      const state = frameAt(plan, frame);
+      const picture = state.sourceMs === null ? void 0 : await source.at(sourceFrameIndex(state.sourceMs, plan.source));
+      compositor.compose(pictures[slot], state, picture);
+      pending[slot] = write(encoder.input, pictures[slot].data);
+    }
+    await Promise.all(pending);
+    encoder.input.end();
+    await encoder.done;
+  } catch (error) {
+    if (isPipeError(error))
+      await encoder.done;
+    encoder.input.destroy();
+    await release(encoder.process, encoder.done);
+    throw error;
+  } finally {
+    await source.close();
+  }
+}
+function sourceFrameIndex(sourceMs, source) {
+  return Math.max(0, Math.floor(sourceMs * source.fps / 1e3 + 1e-6));
+}
+function openSource(file, spec) {
+  const child = spawn2(resolveFfmpeg(), [
+    "-hide_banner",
+    "-nostdin",
+    "-loglevel",
+    "error",
+    "-i",
+    file,
+    "-map",
+    "0:v:0",
+    // Constant rate: frame `i` is the picture at `i / fps`.
+    "-vf",
+    `fps=${spec.fps},scale=${spec.width}:${spec.height}`,
+    "-f",
+    "rawvideo",
+    "-pix_fmt",
+    "rgb24",
+    "pipe:1"
+  ], { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+  const failed = exited(child, "decoding the source");
+  failed.catch(() => void 0);
+  const frames = readFrames(child, spec.width * spec.height * 3);
+  let index = -1;
+  let current;
+  let ended = false;
+  return {
+    async at(wanted) {
+      while (index < wanted && !ended) {
+        const next = await frames.next();
+        if (next.done) {
+          ended = true;
+          await failed;
+        } else {
+          current = {
+            width: spec.width,
+            height: spec.height,
+            data: next.value
+          };
+          index++;
+        }
+      }
+      if (current === void 0)
+        throw new Error("the source has no frames");
+      return current;
+    },
+    close() {
+      child.stdout?.destroy();
+      return release(child, failed);
+    }
+  };
+}
+async function release(child, exit) {
+  if (child.exitCode === null && child.signalCode === null)
+    child.kill();
+  await exit.catch(() => void 0);
+}
+async function* readFrames(child, size) {
+  if (child.stdout === null)
+    throw new Error("the decoder has no stdout");
+  let frame = new Uint8Array(size);
+  let filled = 0;
+  for await (const chunk of child.stdout) {
+    let offset = 0;
+    while (offset < chunk.length) {
+      const take = Math.min(size - filled, chunk.length - offset);
+      frame.set(chunk.subarray(offset, offset + take), filled);
+      filled += take;
+      offset += take;
+      if (filled === size) {
+        yield frame;
+        frame = new Uint8Array(size);
+        filled = 0;
+      }
+    }
+  }
+}
+function startEncoder(plan, out) {
+  const { output } = plan;
+  const child = spawn2(resolveFfmpeg(), [
+    "-hide_banner",
+    "-loglevel",
+    "error",
+    "-y",
+    "-f",
+    "rawvideo",
+    "-pix_fmt",
+    "rgb24",
+    "-s",
+    `${output.width}x${output.height}`,
+    "-r",
+    String(output.fps),
+    "-i",
+    "pipe:0",
+    // BT.709, limited range, tagged in the stream: FFmpeg's
+    // default RGB → YUV conversion is BT.601 and leaves the file untagged.
+    "-vf",
+    `scale=in_range=pc:out_range=tv:out_color_matrix=bt709,format=${output.pixelFormat}`,
+    "-colorspace",
+    "bt709",
+    "-color_primaries",
+    "bt709",
+    "-color_trc",
+    "bt709",
+    "-color_range",
+    "tv",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "medium",
+    "-crf",
+    "18",
+    "-pix_fmt",
+    output.pixelFormat,
+    ...output.faststart ? ["-movflags", "+faststart"] : [],
+    out
+  ], { stdio: ["pipe", "ignore", "pipe"], windowsHide: true });
+  if (child.stdin === null)
+    throw new Error("the encoder has no stdin");
+  child.stdin.on("error", () => void 0);
+  const done = exited(child, "encoding the MP4");
+  done.catch(() => void 0);
+  return { process: child, input: child.stdin, done };
+}
+function exited(child, doing) {
+  let stderr = "";
+  child.stderr?.setEncoding("utf8").on("data", (chunk) => {
+    stderr += chunk;
+  });
+  return new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code, signal) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        const tail = stderr.trim().split("\n").slice(-5).join("\n");
+        reject(new Error(`ffmpeg failed ${doing} (${signal ?? `exit ${code}`}): ${tail}`));
+      }
+    });
+  });
+}
+function isPipeError(error) {
+  const code = error?.code;
+  return code === "EPIPE" || code === "ERR_STREAM_DESTROYED";
+}
+function write(stream, data) {
+  return new Promise((resolve, reject) => {
+    stream.write(data, (error) => error ? reject(error) : resolve());
+  });
+}
+
+// ../../packages/renderer/dist/ffmpeg/index.js
+var ffmpegRenderer = {
+  name: "ffmpeg",
+  render(runDir2, plan, out = renderPath(runDir2, "ffmpeg")) {
+    return recordRender(runDir2, "ffmpeg", out, () => drawPlan(path6.resolve(runDir2, plan.source.file), plan, out));
+  }
+};
+
+// src/commands/browser.ts
+import { spawn as spawn3 } from "node:child_process";
+import { existsSync as existsSync3 } from "node:fs";
+import { createRequire as createRequire3 } from "node:module";
+import path7 from "node:path";
+import { chromium as chromium2 } from "playwright";
+var defaultBrowserDeps = {
+  executablePath: () => chromium2.executablePath(),
+  install: installChromium
+};
+function chromiumPresent(deps = defaultBrowserDeps) {
+  return existsSync3(deps.executablePath());
+}
+async function ensureChromium(io, deps = defaultBrowserDeps) {
+  if (chromiumPresent(deps)) return "present";
+  io.stderr("Chromium is not installed: downloading it once (~250 MB)\n");
+  const code = await deps.install(io);
+  if (code === 0 && chromiumPresent(deps)) {
+    io.stderr("Chromium installed\n");
+    return "installed";
+  }
+  io.stderr(
+    `Chromium could not be installed (the installer exited ${code}); run \`demoflow setup\` to retry
+`
+  );
+  return "failed";
+}
+function installChromium(io) {
+  const manifest = createRequire3(import.meta.url).resolve(
+    "playwright/package.json"
+  );
+  const cli = path7.join(path7.dirname(manifest), "cli.js");
+  return new Promise((resolve) => {
+    const child = spawn3(process.execPath, [cli, "install", "chromium"], {
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    for (const stream of [child.stdout, child.stderr]) {
+      stream.setEncoding("utf8");
+      stream.on("data", (chunk) => io.stderr(chunk));
+    }
+    child.on("error", (error) => {
+      io.stderr(`${error.message}
+`);
+      resolve(1);
+    });
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+
+// src/commands/exit.ts
+function exitCodeFor(result) {
+  const { stages } = result;
+  if (stages.readiness.status === "failed") return EXIT_INVALID_INPUT;
+  if (stages.execution.status === "failed" || stages.verification.status === "failed") {
+    return 1;
+  }
+  const others = [stages.recording, stages.rendering, stages.storage];
+  if (others.some((stage) => stage.status === "failed")) {
+    return EXIT_STAGE_FAILED;
+  }
+  return 0;
+}
+
+// src/commands/output.ts
+import path8 from "node:path";
+function formatJson(result, runDir2) {
+  return `${JSON.stringify({ ...result, runDir: runDir2 })}
+`;
+}
+function formatSummary(result, runDir2) {
+  const lines = [`Run ${result.runId}: ${result.status}`];
+  const width = Math.max(...STAGE_NAMES.map((name) => name.length));
+  for (const name of STAGE_NAMES) {
+    const stage = result.stages[name];
+    const detail = stage.error === void 0 ? "" : `  ${stage.error.message}`;
+    lines.push(`  ${name.padEnd(width)}  ${stage.status}${detail}`);
+  }
+  for (const warning of result.warnings) lines.push(`warning: ${warning}`);
+  for (const render of result.renders) {
+    lines.push(`Video: ${path8.join(runDir2, ...render.file.split("/"))}`);
+  }
+  lines.push(`Run directory: ${runDir2}`);
+  return `${lines.join("\n")}
+`;
+}
+
+// src/commands/run-id.ts
+import { randomBytes } from "node:crypto";
+var BASE32 = "abcdefghijklmnopqrstuvwxyz234567";
+function generateRunId(now = /* @__PURE__ */ new Date(), random = randomBytes) {
+  const iso = now.toISOString();
+  const date = iso.slice(0, 10).replaceAll("-", "");
+  const time = iso.slice(11, 19).replaceAll(":", "");
+  const suffix = Array.from(random(6), (byte) => BASE32[byte % 32]).join("");
+  return `${date}-${time}-${suffix}`;
+}
+var SAFE_RUN_ID = /^[A-Za-z0-9_][A-Za-z0-9._-]*$/;
+function assertSafeRunId(id) {
+  if (!SAFE_RUN_ID.test(id)) {
+    throw new CommandError(
+      "invalid-run-id",
+      `--run-id must be a plain directory name (letters, digits, "_", ".", "-"): ${JSON.stringify(id)}`
+    );
+  }
+}
+
+// src/commands/scenario-file.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+function loadScenario(file) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync4(file, "utf8"));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new CommandError(
+      "scenario-unreadable",
+      `cannot read ${file}: ${reason}`
+    );
+  }
+  const parsed = parseScenario(raw);
+  if (!parsed.ok) {
+    throw new CommandError(
+      "invalid-scenario",
+      `${file} is not a valid scenario`,
+      parsed.errors
+    );
+  }
+  return { scenario: parsed.value, warnings: parsed.warnings };
+}
+
+// src/commands/settle.ts
+import { readFile as readFile3, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
+import path9 from "node:path";
+var RESULT_FILE = "result.json";
+async function readResult(runDir2) {
+  return RunResultSchema.parse(
+    JSON.parse(await readFile3(path9.join(runDir2, RESULT_FILE), "utf8"))
+  );
+}
+async function settleRun(runDir2) {
+  const result = await readResult(runDir2);
+  if (result.stages.rendering.status === "pending") {
+    result.stages.rendering = { status: "skipped" };
+  }
+  if (result.stages.storage.status === "pending") {
+    result.stages.storage = { status: "skipped" };
+  }
+  result.status = deriveRunStatus(result.stages, result.warnings);
+  const valid = RunResultSchema.parse(result);
+  const file = path9.join(runDir2, RESULT_FILE);
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile3(temporary, `${JSON.stringify(valid, null, 2)}
+`);
+  await rename3(temporary, file);
+  return valid;
+}
+
+// src/commands/run.ts
+function defaultRunDeps() {
+  return { host: currentHost(), cwd: process.cwd(), runId: generateRunId };
+}
+async function runCommand(file, flags, io, deps = defaultRunDeps()) {
+  const { host } = deps;
+  const root = flags.project === void 0 ? findProjectRoot(file) : projectRootAt(path10.resolve(deps.cwd, flags.project));
+  const config = loadProjectConfig(root);
+  const { home } = resolveHome({
+    ...host,
+    out: flags.out,
+    cwd: deps.cwd,
+    projectRoot: root,
+    projectConfig: config,
+    globalConfig: loadGlobalConfig(host)
+  });
+  const { scenario, warnings } = loadScenario(file);
+  for (const warning of warnings) {
+    io.stderr(`warning ${warning.path}: ${warning.message}
+`);
+  }
+  const runId = flags.runId ?? deps.runId();
+  if (flags.runId !== void 0) assertSafeRunId(flags.runId);
+  const runDir2 = runDir(home, runId, host.platform);
+  if (flags.runId !== void 0 && existsSync4(runDir2)) {
+    throw new CommandError(
+      "invalid-run-id",
+      `run directory already exists: ${runDir2}`
+    );
+  }
+  if (await ensureChromium(io, deps.browser) === "failed") {
+    return EXIT_STAGE_FAILED;
+  }
+  io.stderr(`Running ${scenarioId(root, file)} (${runId})
+`);
+  await runScenario(scenario, {
+    runDir: runDir2,
+    baseUrl: flags.baseUrl ?? config.baseUrl,
+    allowedOrigins: config.allowedOrigins,
+    env: host.env,
+    headless: flags.headed !== true,
+    observers: [
+      createCaptureObserver({ scenarioId: scenarioId(root, file), runId })
+    ]
+  });
+  let renderError;
+  if (existsSync4(path10.join(runDir2, RUN_FILES.video))) {
+    io.stderr("Rendering\n");
+    try {
+      const plan = await buildRenderPlan(runDir2, {
+        idle: config.render.idle,
+        output: {
+          width: config.render.width,
+          height: config.render.height,
+          fps: config.render.fps
+        }
+      });
+      await ffmpegRenderer.render(runDir2, plan);
+    } catch (error) {
+      renderError = error;
+    }
+  }
+  const result = await settleRun(runDir2);
+  if (renderError !== void 0) {
+    const reason = renderError instanceof Error ? renderError.message : String(renderError);
+    io.stderr(`rendering failed: ${reason}
+`);
+  }
+  io.stdout(
+    flags.json === true ? formatJson(result, runDir2) : formatSummary(result, runDir2)
+  );
+  const code = exitCodeFor(result);
+  return code === 0 && renderError !== void 0 ? EXIT_STAGE_FAILED : code;
+}
+
+// src/commands/setup.ts
+async function setupCommand(io, deps = defaultBrowserDeps) {
+  const outcome = await ensureChromium(io, deps);
+  if (outcome === "failed") return EXIT_STAGE_FAILED;
+  io.stdout(
+    `Chromium ${outcome === "present" ? "is installed" : "installed"}: ${deps.executablePath()}
+`
+  );
+  return 0;
+}
+
+// src/commands/validate.ts
+function formatIssue(issue) {
+  return `  ${issue.path === "" ? "(root)" : issue.path}: ${issue.message}`;
+}
+function validateCommand(file, io) {
+  const { warnings } = loadScenario(file);
+  for (const warning of warnings) {
+    io.stderr(`warning ${warning.code}:
+${formatIssue(warning)}
+`);
+  }
+  io.stdout(`${file} is valid
+`);
+  return 0;
+}
+
+// src/mcp/command.ts
+import { rm } from "node:fs/promises";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/child.ts
+import { spawn as spawn4 } from "node:child_process";
+
+// src/entry.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var CLI_ENTRY = fileURLToPath2(new URL("./main.js", import.meta.url));
+
+// src/mcp/child.ts
+var KILL_GRACE_MS = 5e3;
+var STDERR_TAIL = 8 * 1024;
+var spawnRun = (args, cwd) => {
+  const child = spawn4(process.execPath, [CLI_ENTRY, ...args], {
+    cwd,
+    env: process.env,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: process.platform !== "win32",
+    windowsHide: true
+  });
+  let stderr = "";
+  child.stdout?.resume();
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk) => {
+    stderr = (stderr + chunk).slice(-STDERR_TAIL);
+  });
+  let done = false;
+  const exited2 = new Promise((resolve) => {
+    child.on("error", (error) => {
+      stderr += `
+${error.message}`;
+      if (child.pid === void 0) {
+        done = true;
+        resolve({ code: null, stderrTail: stderr });
+      }
+    });
+    child.on("close", (code) => {
+      done = true;
+      resolve({ code, stderrTail: stderr });
+    });
+  });
+  return {
+    pid: child.pid,
+    exited: exited2,
+    kill: async () => {
+      if (done) return;
+      killTree(child, "SIGTERM");
+      const timer = setTimeout(() => killTree(child, "SIGKILL"), KILL_GRACE_MS);
+      await exited2;
+      clearTimeout(timer);
+      if (process.platform !== "win32") killTree(child, "SIGKILL");
+    }
+  };
+};
+function killTree(child, signal) {
+  const { pid } = child;
+  if (pid === void 0) return;
+  if (process.platform === "win32") {
+    const taskkill = spawn4("taskkill", ["/PID", String(pid), "/T", "/F"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    taskkill.on("error", () => child.kill());
+    return;
+  }
+  try {
+    process.kill(-pid, signal);
+  } catch {
+  }
+}
+
+// src/mcp/server.ts
+import { existsSync as existsSync9 } from "node:fs";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+import path15 from "node:path";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { z as z10 } from "zod";
+
+// src/version.ts
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
+import path11 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+function packageVersion(from = import.meta.url) {
+  let dir = path11.dirname(fileURLToPath3(from));
+  for (; ; ) {
+    const file = path11.join(dir, "package.json");
+    if (existsSync5(file)) {
+      const manifest = JSON.parse(readFileSync5(file, "utf8"));
+      if (manifest.name === "demoflow" && typeof manifest.version === "string")
+        return manifest.version;
+    }
+    const parent = path11.dirname(dir);
+    if (parent === dir)
+      throw new Error(`no demoflow package.json above ${from}`);
+    dir = parent;
+  }
+}
+
+// src/mcp/errors.ts
+var ToolError = class extends Error {
+  code;
+  hint;
+  issues;
+  constructor(code, message, hint, issues = []) {
+    super(message);
+    this.name = "ToolError";
+    this.code = code;
+    this.hint = hint;
+    this.issues = issues;
+  }
+  toPayload() {
+    const payload = {
+      code: this.code,
+      message: this.message,
+      hint: this.hint
+    };
+    if (this.issues.length > 0) {
+      payload.issues = this.issues.map((issue) => ({
+        path: issue.path === "" ? "(root)" : issue.path,
+        message: issue.message
+      }));
+    }
+    return payload;
+  }
+};
+
+// src/mcp/project.ts
+import { existsSync as existsSync6, realpathSync, statSync } from "node:fs";
+import path12 from "node:path";
+function resolveProject(project, cwd, host) {
+  if (project !== void 0 && !path12.isAbsolute(project)) {
+    throw new ToolError(
+      "project-not-found",
+      `project must be an absolute path: ${JSON.stringify(project)}`,
+      "Pass the absolute path of the directory that holds demoflow.config.json."
+    );
+  }
+  const start = project ?? cwd;
+  if (!isDirectory(start)) {
+    throw new ToolError(
+      "project-not-found",
+      `no such directory: ${start}`,
+      "Pass the absolute path of the directory that holds demoflow.config.json."
+    );
+  }
+  let root;
+  try {
+    root = findProjectRoot(path12.join(start, PROJECT_CONFIG_FILE));
+  } catch (error) {
+    if (!(error instanceof CliError)) throw error;
+    throw new ToolError(
+      "project-not-found",
+      `no ${PROJECT_CONFIG_FILE} in ${start} or any parent directory`,
+      project === void 0 ? "Pass `project`: the server was not started inside a DemoFlow project." : `Create ${PROJECT_CONFIG_FILE} in the project, or pass another path.`
+    );
+  }
+  try {
+    const config = loadProjectConfig(root);
+    const { home } = resolveHome({
+      ...host,
+      cwd: root,
+      projectRoot: root,
+      projectConfig: config,
+      globalConfig: loadGlobalConfig(host)
+    });
+    return { root, config, home };
+  } catch (error) {
+    if (!(error instanceof CliError)) throw error;
+    throw new ToolError(
+      "invalid-project-config",
+      error.message,
+      `Fix ${PROJECT_CONFIG_FILE} (or the global config) and call again.`,
+      error.issues
+    );
+  }
+}
+function resolveScenarioFile(root, file) {
+  const absolute = path12.resolve(root, file);
+  const outside = new ToolError(
+    "file-not-in-project",
+    `${file} is not a *.demo.json file inside ${root}`,
+    "Pass the path of a *.demo.json file inside the project, or an inline `scenario`."
+  );
+  if (!absolute.endsWith(".demo.json") || !isInside(root, absolute)) {
+    throw outside;
+  }
+  if (!existsSync6(absolute)) {
+    throw new ToolError(
+      "scenario-unreadable",
+      `no such file: ${absolute}`,
+      "Check the path; it is resolved against the project root."
+    );
+  }
+  if (!isInside(realpathSync(root), realpathSync(absolute))) throw outside;
+  try {
+    loadScenario(absolute);
+  } catch (error) {
+    if (!(error instanceof CommandError)) throw error;
+    throw new ToolError(
+      error.code === "invalid-scenario" ? "invalid-scenario" : "scenario-unreadable",
+      error.message,
+      error.code === "invalid-scenario" ? "Fix the scenario at the paths in `issues` and call again." : "The file must be readable JSON.",
+      error.issues
+    );
+  }
+  return absolute;
+}
+function checkInlineScenario(raw) {
+  const parsed = parseScenario(raw);
+  if (!parsed.ok) {
+    throw new ToolError(
+      "invalid-scenario",
+      "the inline scenario is not a valid scenario",
+      "Fix the scenario at the paths in `issues` and call again.",
+      parsed.errors
+    );
+  }
+}
+function isInside(root, file) {
+  const relative = path12.relative(root, file);
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path12.sep}`) && !path12.isAbsolute(relative);
+}
+function isDirectory(dir) {
+  try {
+    return statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/mcp/readonly.ts
+import { existsSync as existsSync7 } from "node:fs";
+import { readdir } from "node:fs/promises";
+import path13 from "node:path";
+var DEFAULT_LIST_LIMIT = 20;
+var MAX_LIST_LIMIT = 100;
+var SCENARIO_DIR = "demoflow";
+function validateScenario(input, cwd, host) {
+  const inline = input.scenario !== void 0;
+  if (inline === (input.file !== void 0)) {
+    throw new ToolError(
+      "both-or-neither-scenario",
+      inline ? "both `scenario` and `file` were given" : "neither `scenario` nor `file` was given",
+      "Pass exactly one: an inline `scenario` object, or the `file` of a *.demo.json in the project."
+    );
+  }
+  if (input.file !== void 0) {
+    const project = resolveProject(input.project, cwd, host);
+    resolveScenarioFile(project.root, input.file);
+  } else {
+    checkInlineScenario(input.scenario);
+  }
+  return { valid: true };
+}
+async function listDemos(input, cwd, host) {
+  const project = resolveProject(input.project, cwd, host);
+  const limit = input.limit ?? DEFAULT_LIST_LIMIT;
+  const runsDir = path13.dirname(runDir(project.home, "x", host.platform));
+  let names;
+  try {
+    names = await readdir(runsDir);
+  } catch {
+    return { demos: [] };
+  }
+  const demos = [];
+  for (const name of names) {
+    const runDir2 = runDir(project.home, name, host.platform);
+    try {
+      const result = await readResult(runDir2);
+      const demo = {
+        taskId: name,
+        scenarioName: result.scenarioName,
+        status: result.status,
+        startedAt: result.startedAt
+      };
+      const render = result.renders[0];
+      if (render !== void 0) {
+        demo.durationMs = render.durationMs;
+        const video = path13.join(runDir2, ...render.file.split("/"));
+        if (existsSync7(video)) demo.video = video;
+      }
+      demos.push(demo);
+    } catch {
+    }
+  }
+  demos.sort(
+    (a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt) || (a.taskId < b.taskId ? 1 : a.taskId > b.taskId ? -1 : 0)
+  );
+  return { demos: demos.slice(0, limit) };
+}
+async function checkProject(input, cwd, host) {
+  const project = resolveProject(input.project, cwd, host);
+  return {
+    root: project.root,
+    configValid: true,
+    scenarios: await scenarioFiles(project.root),
+    ffmpeg: ffmpegAvailability(),
+    browser: await browserAvailability()
+  };
+}
+async function scenarioFiles(root) {
+  let entries;
+  try {
+    entries = (await readdir(path13.join(root, SCENARIO_DIR), { recursive: true })).map(String);
+  } catch {
+    return [];
+  }
+  return entries.filter((entry2) => entry2.endsWith(".demo.json")).map((entry2) => [SCENARIO_DIR, ...entry2.split(path13.sep)].join("/")).sort();
+}
+function ffmpegAvailability() {
+  try {
+    return resolveFfmpeg() === "ffmpeg" ? "system" : "bundled";
+  } catch {
+    return "missing";
+  }
+}
+async function browserAvailability() {
+  try {
+    const { chromium: chromium3 } = await import("playwright");
+    return existsSync7(chromium3.executablePath()) ? "installed" : "missing";
+  } catch {
+    return "missing";
+  }
+}
+
+// src/mcp/view.ts
+import { existsSync as existsSync8 } from "node:fs";
+import path14 from "node:path";
+function taskView(input) {
+  const { taskId, status, runDir: runDir2, result } = input;
+  const view = { taskId, status };
+  if (input.position !== void 0) view.position = input.position;
+  if (input.message !== void 0) view.message = input.message;
+  if (result !== void 0) {
+    view.stages = result.stages;
+    const failedStep = failedStepOf(result.stages);
+    if (failedStep !== void 0) view.failedStep = failedStep;
+  }
+  if (status !== "queued" && existsSync8(runDir2)) {
+    view.artifacts = artifactsOf(runDir2, result);
+  }
+  return view;
+}
+function failedStepOf(stages) {
+  for (const name of STAGE_NAMES) {
+    const error = stages[name].error;
+    if (error?.stepIndex !== void 0) {
+      return { stepIndex: error.stepIndex, message: error.message };
+    }
+  }
+  return void 0;
+}
+function artifactsOf(runDir2, result) {
+  const artifacts = { runDir: runDir2 };
+  const render = result?.renders[0];
+  const video = render === void 0 ? void 0 : path14.join(runDir2, ...render.file.split("/"));
+  if (video !== void 0 && existsSync8(video)) artifacts.video = video;
+  const timeline = path14.join(runDir2, RUN_FILES.timeline);
+  if (existsSync8(timeline)) artifacts.timeline = timeline;
+  const source = path14.join(runDir2, RUN_FILES.video);
+  if (existsSync8(source)) artifacts.source = source;
+  return artifacts;
+}
+
+// src/mcp/server.ts
+var DEFAULT_TIMEOUT_MINUTES = 15;
+var MINUTE_MS = 6e4;
+var MAX_WAIT_SECONDS = 50;
+var GenerateDemoInput = z10.strictObject({
+  project: z10.string().optional().describe(
+    "Absolute path of the project (the directory with demoflow.config.json); default: the server's working directory."
+  ),
+  scenario: ScenarioSchema.optional().describe(
+    "An inline scenario. Exactly one of `scenario` and `file`."
+  ),
+  file: z10.string().optional().describe(
+    "A *.demo.json file inside the project, relative to its root or absolute. Exactly one of `scenario` and `file`."
+  ),
+  timeoutMinutes: z10.number().int().min(1).max(60).optional().describe(
+    `The task is killed and timed_out after this long; default ${DEFAULT_TIMEOUT_MINUTES}.`
+  )
+});
+var GenerateDemoArgs = GenerateDemoInput.extend({
+  scenario: z10.unknown().optional()
+});
+var GetTaskInput = z10.strictObject({
+  taskId: z10.string().describe("The ID returned by generate_demo."),
+  waitSeconds: z10.number().min(0).max(MAX_WAIT_SECONDS).optional().describe(
+    `Hold the reply until the task finishes or this many seconds pass (0\u2013${MAX_WAIT_SECONDS}, default 0). Poll again to wait longer.`
+  )
+});
+var CancelTaskInput = z10.strictObject({
+  taskId: z10.string().describe("The ID returned by generate_demo.")
+});
+var PROJECT_DESCRIPTION = "Absolute path of the project (the directory with demoflow.config.json); default: the server's working directory.";
+var ValidateScenarioInput = z10.strictObject({
+  project: z10.string().optional().describe(PROJECT_DESCRIPTION),
+  scenario: ScenarioSchema.optional().describe(
+    "An inline scenario. Exactly one of `scenario` and `file`."
+  ),
+  file: z10.string().optional().describe(
+    "A *.demo.json file inside the project, relative to its root or absolute. Exactly one of `scenario` and `file`."
+  )
+});
+var ValidateScenarioArgs = ValidateScenarioInput.extend({
+  scenario: z10.unknown().optional()
+});
+var ListDemosInput = z10.strictObject({
+  project: z10.string().optional().describe(PROJECT_DESCRIPTION),
+  limit: z10.number().int().min(1).max(MAX_LIST_LIMIT).optional().describe(
+    `How many runs to return, newest first (1\u2013${MAX_LIST_LIMIT}, default ${DEFAULT_LIST_LIMIT}).`
+  )
+});
+var CheckProjectInput = z10.strictObject({
+  project: z10.string().optional().describe(PROJECT_DESCRIPTION)
+});
+var TOOLS = [
+  {
+    name: "generate_demo",
+    description: "Queue a demo video run of a DemoFlow scenario in a local project. Returns a task ID at once; poll it with get_task. Runs execute one at a time. The first run on a machine may download the browser (~250 MB) and take longer.",
+    inputSchema: inputSchema(GenerateDemoInput)
+  },
+  {
+    name: "get_task",
+    description: `A task's status, stage results and artifact paths (video, timeline, source, run directory). Can wait up to ${MAX_WAIT_SECONDS} s for it to finish.`,
+    inputSchema: inputSchema(GetTaskInput)
+  },
+  {
+    name: "cancel_task",
+    description: "Cancel a task: a queued one never starts, a running one is killed; a finished one is unchanged.",
+    inputSchema: inputSchema(CancelTaskInput)
+  },
+  {
+    name: "validate_scenario",
+    description: "Check a scenario (inline or a *.demo.json in the project) against the scenario schema without running it. Returns { valid: true } or an invalid-scenario error with issue paths.",
+    inputSchema: inputSchema(ValidateScenarioInput)
+  },
+  {
+    name: "list_demos",
+    description: "Recent demo runs of the project's artifacts home, newest first: task ID, scenario name, status, start time, duration and video path.",
+    inputSchema: inputSchema(ListDemosInput)
+  },
+  {
+    name: "check_project",
+    description: "Whether a project is ready to run demos: its scenario files, a valid config, and FFmpeg and browser availability.",
+    inputSchema: inputSchema(CheckProjectInput)
+  }
+];
+function createMcpServer(deps) {
+  const { queue, host, cwd } = deps;
+  const newTaskId = deps.newTaskId ?? (() => generateRunId());
+  const homes = /* @__PURE__ */ new Set();
+  const server = new Server(
+    { name: "demoflow", version: packageVersion() },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: TOOLS }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const args = request.params.arguments ?? {};
+    try {
+      switch (request.params.name) {
+        case "generate_demo":
+          return ok(await generateDemo(parse(GenerateDemoArgs, args)));
+        case "get_task":
+          return ok(await getTask(parse(GetTaskInput, args)));
+        case "cancel_task":
+          return ok(await cancelTask(parse(CancelTaskInput, args)));
+        case "validate_scenario":
+          return ok(
+            validateScenario(parse(ValidateScenarioArgs, args), cwd, host)
+          );
+        case "list_demos":
+          return ok(await listDemos(parse(ListDemosInput, args), cwd, host));
+        case "check_project":
+          return ok(
+            await checkProject(parse(CheckProjectInput, args), cwd, host)
+          );
+        default:
+          throw new ToolError(
+            "invalid-input",
+            `unknown tool: ${request.params.name}`,
+            `Call one of: ${TOOLS.map((tool) => tool.name).join(", ")}.`
+          );
+      }
+    } catch (error) {
+      if (error instanceof ToolError) return failure(error);
+      throw error;
+    }
+  });
+  async function generateDemo(input) {
+    const inline = input.scenario !== void 0;
+    if (inline === (input.file !== void 0)) {
+      throw new ToolError(
+        "both-or-neither-scenario",
+        inline ? "both `scenario` and `file` were given" : "neither `scenario` nor `file` was given",
+        "Pass exactly one: an inline `scenario` object, or the `file` of a *.demo.json in the project."
+      );
+    }
+    const project = resolveProject(input.project, cwd, host);
+    let scenarioFile;
+    if (input.file !== void 0) {
+      scenarioFile = resolveScenarioFile(project.root, input.file);
+    } else {
+      checkInlineScenario(input.scenario);
+    }
+    let taskId = newTaskId();
+    while (queue.get(taskId) !== void 0 || existsSync9(runDir(project.home, taskId, host.platform))) {
+      taskId = newTaskId();
+    }
+    const runDir2 = runDir(project.home, taskId, host.platform);
+    let staged;
+    if (scenarioFile === void 0) {
+      staged = path15.join(project.home, "mcp", `${taskId}.demo.json`);
+      await mkdir4(path15.dirname(staged), { recursive: true });
+      await writeFile4(staged, `${JSON.stringify(input.scenario, null, 2)}
+`);
+      scenarioFile = staged;
+    }
+    homes.add(project.home);
+    const task = queue.submit({
+      taskId,
+      root: project.root,
+      runDir: runDir2,
+      scenarioFile,
+      staged,
+      timeoutMs: (input.timeoutMinutes ?? DEFAULT_TIMEOUT_MINUTES) * MINUTE_MS
+    });
+    return { taskId, status: task.status, position: queue.position(taskId) };
+  }
+  async function getTask(input) {
+    checkTaskId(input.taskId);
+    const task = queue.get(input.taskId);
+    if (task === void 0) return fromDisk(input.taskId);
+    const waitSeconds = Math.min(input.waitSeconds ?? 0, MAX_WAIT_SECONDS);
+    await queue.wait(input.taskId, waitSeconds * 1e3);
+    return taskView({
+      taskId: input.taskId,
+      status: task.status,
+      runDir: task.spec.runDir,
+      result: task.result,
+      message: task.message,
+      position: task.status === "queued" ? queue.position(input.taskId) : void 0
+    });
+  }
+  async function cancelTask(input) {
+    checkTaskId(input.taskId);
+    const task = await queue.cancel(input.taskId);
+    if (task !== void 0)
+      return { taskId: input.taskId, status: task.status };
+    const { status } = await fromDisk(input.taskId);
+    return { taskId: input.taskId, status };
+  }
+  async function fromDisk(taskId) {
+    for (const home of candidateHomes()) {
+      const runDir2 = runDir(home, taskId, host.platform);
+      if (!existsSync9(runDir2)) continue;
+      try {
+        const result = await readResult(runDir2);
+        const finished = result.status === "completed" || result.status === "completed_with_warnings";
+        return taskView({
+          taskId,
+          status: finished ? "completed" : "failed",
+          runDir: runDir2,
+          result,
+          message: result.status === "running" ? "the run never finished: the server that ran it stopped" : void 0
+        });
+      } catch {
+        return taskView({
+          taskId,
+          status: "failed",
+          runDir: runDir2,
+          message: "the run directory has no readable result.json"
+        });
+      }
+    }
+    throw new ToolError(
+      "task-not-found",
+      `no task ${taskId}`,
+      "Use a task ID returned by generate_demo. Unfinished tasks of a stopped server are gone; a finished one is found when its project is the server working directory or was used since the start."
+    );
+  }
+  function candidateHomes() {
+    const env = host.env.DEMOFLOW_HOME;
+    const candidates = [
+      ...homes,
+      tryOrUndefined(() => resolveProject(void 0, cwd, host).home),
+      env === void 0 || env === "" ? void 0 : path15.resolve(cwd, env),
+      tryOrUndefined(() => loadGlobalConfig(host).artifactsDir),
+      osDataDir(host)
+    ];
+    return new Set(
+      candidates.filter((home) => home !== void 0)
+    );
+  }
+  return server;
+}
+function checkTaskId(taskId) {
+  try {
+    assertSafeRunId(taskId);
+  } catch (error) {
+    if (!(error instanceof CommandError)) throw error;
+    throw new ToolError(
+      "task-not-found",
+      `no task ${JSON.stringify(taskId)}`,
+      "Use a task ID returned by generate_demo."
+    );
+  }
+}
+function parse(schema, args) {
+  const parsed = schema.safeParse(args);
+  if (parsed.success) return parsed.data;
+  const issues = parsed.error.issues.map((issue) => ({
+    path: formatPath(issue.path),
+    code: issue.code,
+    message: issue.message
+  }));
+  throw new ToolError(
+    "invalid-input",
+    "the tool arguments do not match its input schema",
+    "Fix the arguments at the paths in `issues` and call again.",
+    issues
+  );
+}
+function inputSchema(schema) {
+  const { $schema: _, ...json } = z10.toJSONSchema(schema, {
+    io: "input",
+    target: "draft-2020-12"
+  });
+  return { ...json, type: "object" };
+}
+function ok(value) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(value) }],
+    structuredContent: value
+  };
+}
+function failure(error) {
+  const payload = error.toPayload();
+  return {
+    isError: true,
+    content: [{ type: "text", text: JSON.stringify(payload) }],
+    structuredContent: { ...payload }
+  };
+}
+function tryOrUndefined(read) {
+  try {
+    return read();
+  } catch (error) {
+    if (error instanceof ToolError || error instanceof CliError)
+      return void 0;
+    throw error;
+  }
+}
+
+// src/mcp/tasks.ts
+function isTerminal(status) {
+  return status !== "queued" && status !== "running";
+}
+var TaskQueue = class {
+  tasks = /* @__PURE__ */ new Map();
+  queue = [];
+  waiters = /* @__PURE__ */ new Map();
+  running;
+  closed = false;
+  deps;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  submit(spec) {
+    const task = { spec, status: "queued" };
+    this.tasks.set(spec.taskId, task);
+    if (this.closed) {
+      this.end(task, "cancelled");
+      return task;
+    }
+    this.queue.push(task);
+    this.pump();
+    return task;
+  }
+  get(taskId) {
+    return this.tasks.get(taskId);
+  }
+  /** Tasks ahead of this one: `0` while it runs or is next. */
+  position(taskId) {
+    const index = this.queue.findIndex((task) => task.spec.taskId === taskId);
+    if (index === -1) return 0;
+    return index + (this.running === void 0 ? 0 : 1);
+  }
+  /** Resolves when the task reaches a terminal status, or after `ms`. */
+  async wait(taskId, ms) {
+    const task = this.tasks.get(taskId);
+    if (task === void 0 || isTerminal(task.status) || ms <= 0) return;
+    await new Promise((resolve) => {
+      const waiters = this.waiters.get(taskId) ?? /* @__PURE__ */ new Set();
+      this.waiters.set(taskId, waiters);
+      const done = () => {
+        clearTimeout(timer);
+        waiters.delete(done);
+        resolve();
+      };
+      const timer = setTimeout(done, ms);
+      waiters.add(done);
+    });
+  }
+  /**
+   * A queued task is removed and never starts; a running one's child is
+   * killed; a finished one is unchanged. Resolves with the task's status set.
+   */
+  async cancel(taskId) {
+    const task = this.tasks.get(taskId);
+    if (task === void 0) return void 0;
+    if (task.status === "queued") {
+      this.queue.splice(this.queue.indexOf(task), 1);
+      this.end(task, "cancelled");
+    } else if (this.running?.task === task) {
+      await this.stop(this.running, "cancelled");
+    }
+    return task;
+  }
+  /** Shutdown: nothing new starts, the queue is cancelled, the child is killed. */
+  async close() {
+    this.closed = true;
+    for (const task of this.queue.splice(0)) this.end(task, "cancelled");
+    if (this.running !== void 0) await this.stop(this.running, "cancelled");
+  }
+  pump() {
+    if (this.closed || this.running !== void 0) return;
+    const task = this.queue.shift();
+    if (task === void 0) return;
+    const { spec } = task;
+    task.status = "running";
+    const child = this.deps.spawn(
+      [
+        "run",
+        spec.scenarioFile,
+        "--json",
+        "--run-id",
+        spec.taskId,
+        "--project",
+        spec.root
+      ],
+      spec.root
+    );
+    this.deps.log?.(`task ${spec.taskId} started (pid ${child.pid ?? "?"})`);
+    const timer = setTimeout(() => {
+      void this.stop(running, "timed_out");
+    }, spec.timeoutMs);
+    const running = {
+      task,
+      child,
+      settled: child.exited.then(async (exit) => {
+        clearTimeout(timer);
+        await this.finish(running, exit);
+      })
+    };
+    this.running = running;
+  }
+  async stop(running, reason) {
+    running.ending ??= reason;
+    await running.child.kill();
+    await running.settled;
+  }
+  async finish(running, exit) {
+    const { task } = running;
+    try {
+      task.result = await this.deps.readResult(task.spec.runDir);
+    } catch {
+    }
+    let status;
+    if (running.ending !== void 0) {
+      status = running.ending;
+    } else if (task.result?.status === "completed" || task.result?.status === "completed_with_warnings") {
+      status = "completed";
+    } else {
+      status = "failed";
+      if (task.result === void 0) {
+        task.message = failureMessage(exit);
+      }
+    }
+    this.running = void 0;
+    this.end(task, status);
+    this.pump();
+  }
+  end(task, status) {
+    task.status = status;
+    this.deps.log?.(`task ${task.spec.taskId} ${status}`);
+    if (task.spec.staged !== void 0) {
+      this.deps.removeFile(task.spec.staged).catch(() => void 0);
+    }
+    for (const waiter of this.waiters.get(task.spec.taskId) ?? []) waiter();
+    this.waiters.delete(task.spec.taskId);
+  }
+};
+function failureMessage(exit) {
+  const lines = exit.stderrTail.trim().split("\n").slice(-5).join("\n");
+  return `demoflow run exited with code ${exit.code ?? "null"}${lines === "" ? "" : `: ${lines}`}`;
+}
+
+// src/mcp/command.ts
+var SHUTDOWN_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+async function mcpCommand(io) {
+  const queue = new TaskQueue({
+    spawn: spawnRun,
+    readResult,
+    removeFile: (file) => rm(file, { force: true }),
+    log: (line) => io.stderr(`demoflow mcp: ${line}
+`)
+  });
+  const server = createMcpServer({
+    queue,
+    host: currentHost(),
+    cwd: process.cwd()
+  });
+  const transport = new StdioServerTransport();
+  let stop = () => void 0;
+  const stopped = new Promise((resolve) => {
+    stop = resolve;
+  });
+  const onSignal = (signal) => stop(signal);
+  const onEnd = () => stop("stdin closed");
+  for (const signal of SHUTDOWN_SIGNALS) process.on(signal, onSignal);
+  process.stdin.on("end", onEnd);
+  process.stdin.on("close", onEnd);
+  server.onclose = () => stop("transport closed");
+  await server.connect(transport);
+  io.stderr("demoflow mcp: serving on stdio\n");
+  if (!chromiumPresent()) {
+    io.stderr(
+      "demoflow mcp: Chromium is not installed; the first generate_demo downloads it (or run `demoflow setup`)\n"
+    );
+  }
+  const reason = await stopped;
+  for (const signal of SHUTDOWN_SIGNALS) process.off(signal, onSignal);
+  process.stdin.off("end", onEnd);
+  process.stdin.off("close", onEnd);
+  await queue.close();
+  await server.close();
+  process.stdin.destroy();
+  io.stderr(`demoflow mcp: stopped (${reason})
+`);
+  return 0;
+}
+
+// src/main.ts
+async function main(argv, io = processIo) {
+  let exitCode = 0;
+  const program = new Command("demoflow").description("Turn a scenario into a demo video").version(packageVersion()).exitOverride().configureOutput({
+    writeOut: (text) => io.stdout(text),
+    writeErr: (text) => io.stderr(text)
+  });
+  program.command("validate").description("Check a scenario against the schema").argument("<scenario>", "path to a .demo.json file").action((scenario) => {
+    exitCode = validateCommand(scenario, io);
+  });
+  program.command("run").description("Run a scenario and render its video").argument("<scenario>", "path to a .demo.json file").option("--base-url <url>", "override baseUrl from demoflow.config.json").option("--out <dir>", "artifacts directory (the home of runs/)").option("--headed", "show the browser window").option("--json", "print the result as one JSON object on stdout").addOption(new Option("--run-id <id>", "name the run directory").hideHelp()).addOption(new Option("--project <dir>", "the project root").hideHelp()).action(
+    async (scenario, flags) => {
+      exitCode = await runCommand(scenario, flags, io);
+    }
+  );
+  program.command("setup").description("Install Chromium now instead of on the first run").action(async () => {
+    exitCode = await setupCommand(io);
+  });
+  program.command("mcp").description("Serve demo generation to MCP clients over stdio").addHelpText(
+    "after",
+    "\nRegister with Claude Code:\n  claude mcp add demoflow -- npx demoflow mcp\n"
+  ).action(async () => {
+    exitCode = await mcpCommand(io);
+  });
+  try {
+    await program.parseAsync(argv, { from: "user" });
+    return exitCode;
+  } catch (error) {
+    if (isInputError(error)) {
+      io.stderr(`${describeError(error)}
+`);
+      return error.exitCode;
+    }
+    if (isCommanderError(error))
+      return error.exitCode === 1 ? 2 : error.exitCode;
+    io.stderr(
+      `${error instanceof Error ? error.stack ?? error.message : String(error)}
+`
+    );
+    return EXIT_STAGE_FAILED;
+  }
+}
+function isCommanderError(error) {
+  return error instanceof CommanderError;
+}
+var entry = process.argv[1];
+if (entry !== void 0 && import.meta.url === pathToFileURL(realpathSync2(entry)).href) {
+  process.exitCode = await main(process.argv.slice(2));
+}
+export {
+  main
+};