@odori/cli 0.0.2

package/src/commands/doctor.ts

@@ -0,0 +1,162 @@
+import {constants} from "node:fs";
+import {access, mkdir, readFile, rm, writeFile} from "node:fs/promises";
+import {existsSync} from "node:fs";
+import {createRequire} from "node:module";
+import {relative, resolve} from "node:path";
+import {loadConfig} from "../config";
+import {CHROME_BUILD, cacheRoot, resolveBrowser, resolveFfmpeg} from "../binaries";
+import {log} from "../log";
+
+export type Check = {
+  name: string;
+  /** What was found. Printed on success and on failure alike. */
+  detail: string;
+  ok: boolean;
+  /** The command or edit that fixes it. Only read when `ok` is false. */
+  fix?: string;
+};
+
+/** The oldest Node the runtime is exercised on. Below this, nothing is promised. */
+const MINIMUM_NODE = 20;
+
+const version = (value: string): number[] => value.replace(/^v/, "").split(".").map(Number);
+
+/**
+ * Every fact a render depends on, checked before anything is authored.
+ *
+ * Chrome is resolved when a render starts and FFmpeg when an encode starts,
+ * which means a machine that cannot export says so an hour into the work, at
+ * the moment the work was supposed to pay off. This asks all of it up front
+ * and prints the fix beside whatever failed.
+ */
+export const runChecks = async (root: string): Promise<Check[]> => {
+  const checks: Check[] = [];
+  const config = await loadConfig(root);
+  const require = createRequire(resolve(root, "package.json"));
+
+  const [major] = version(process.version);
+  checks.push({
+    name: "Node",
+    detail: process.version,
+    ok: major >= MINIMUM_NODE,
+    fix: `Odori needs Node ${MINIMUM_NODE} or newer. Install it, for example with: nvm install ${MINIMUM_NODE}`,
+  });
+
+  let react = "not found";
+  let reactOk = false;
+  try {
+    const manifest = JSON.parse(await readFile(require.resolve("react/package.json"), "utf8")) as {version: string};
+    react = manifest.version;
+    reactOk = version(react)[0] >= 19;
+  } catch {
+    react = "not installed";
+  }
+  checks.push({
+    name: "React",
+    detail: react,
+    ok: reactOk,
+    fix: "The runtime needs React 19. Install it: npm install react@19 react-dom@19",
+  });
+
+  const videosDir = resolve(config.root, config.videosDir);
+  checks.push({
+    name: "Source root",
+    detail: existsSync(videosDir) ? relative(config.root, videosDir) + "/" : `no ${config.videosDir}/`,
+    ok: existsSync(videosDir),
+    fix: 'Run "odori init" to add the videos source root.',
+  });
+
+  checks.push({
+    name: "Config",
+    detail: config.configPath ? relative(config.root, config.configPath) : "defaults (no odori.config.ts)",
+    // Loading got this far, so a config that exists also parsed.
+    ok: true,
+  });
+
+  // Both binaries report where they came from, not only that they exist. Two
+  // machines that render differently are usually two machines resolving a
+  // different Chrome, and that is invisible unless it is printed.
+  const chrome = await resolveBrowser(config);
+  checks.push({
+    name: "Chrome",
+    detail: chrome
+      ? `${chrome.origin === "managed" ? `pinned ${CHROME_BUILD}` : `${chrome.origin}, version unpinned`} · ${chrome.path}`
+      : "not found",
+    ok: Boolean(chrome),
+    fix: 'Run "odori install" to download the pinned build, or set chromePath in odori.config.ts.',
+  });
+
+  const ffmpeg = await resolveFfmpeg(config);
+  checks.push({
+    name: "FFmpeg",
+    detail: ffmpeg
+      ? `${ffmpeg.origin === "managed" || ffmpeg.origin === "package" ? "pinned 5.3.0" : `${ffmpeg.origin}, version unpinned`} · ${ffmpeg.path}`
+      : "not found",
+    ok: Boolean(ffmpeg),
+    fix: 'Run "odori install" to download the pinned build, or set ffmpegPath in odori.config.ts.',
+  });
+
+  // Not a failure, but the thing a reader wants next: an unpinned binary still
+  // renders, it just cannot promise the same frames as another machine.
+  const unpinned = [chrome, ffmpeg].filter(
+    (binary) => binary && binary.origin !== "managed" && binary.origin !== "package",
+  );
+  checks.push({
+    name: "Reproducible",
+    detail:
+      unpinned.length === 0
+        ? `pinned binaries from ${cacheRoot()}`
+        : `${unpinned.length} of 2 from the host; frames may differ from another machine`,
+    ok: true,
+  });
+
+  // The generated directory holds the import graph, the cue renders, and the
+  // build cache. A read-only project fails at the first write, deep inside a
+  // render, so it is proved here with an actual write.
+  const generated = resolve(config.root, ".odori");
+  let writable = false;
+  try {
+    await mkdir(generated, {recursive: true});
+    const probe = resolve(generated, ".doctor");
+    await writeFile(probe, "", "utf8");
+    await access(probe, constants.W_OK);
+    await rm(probe, {force: true});
+    writable = true;
+  } catch {
+    writable = false;
+  }
+  checks.push({
+    name: "Generated cache",
+    detail: writable ? ".odori/ is writable" : ".odori/ cannot be written",
+    ok: writable,
+    fix: `Odori writes its import graph and render cache to ${relative(process.cwd(), generated) || ".odori"}. Check the directory's permissions.`,
+  });
+
+  return checks;
+};
+
+/**
+ * Print the checks. Exits non-zero on any failure, so it is usable as the
+ * first step of a CI job as well as the first thing a new project runs.
+ */
+export const doctorCommand = async (root = process.cwd()): Promise<number> => {
+  const checks = await runChecks(root);
+  const width = Math.max(...checks.map((check) => check.name.length));
+
+  log.title("odori doctor");
+  for (const check of checks) {
+    const label = check.name.padEnd(width);
+    if (check.ok) log.success(`${label}  ${check.detail}`);
+    else log.error(`${label}  ${check.detail}`);
+  }
+
+  const failed = checks.filter((check) => !check.ok);
+  if (failed.length === 0) {
+    log.detail("Everything a render needs is present.");
+    return 0;
+  }
+
+  log.info("");
+  for (const check of failed) log.warn(`${check.name}: ${check.fix}`);
+  return 1;
+};

package/src/commands/exportVideo.ts

@@ -0,0 +1,198 @@
+import {resolve} from "node:path";
+import {resolveEntryLayout, type ExportJob} from "odori";
+import type {ResolvedConfig} from "../config";
+import {log} from "../log";
+import {JobQueue, appendJobLog, createJob, listJobs, readJob, updateJob, type JobRecord} from "../jobs";
+import {findVideo, freezeManifest, outputName, type LoadedVideo} from "../project";
+import {resolveFormat, type VideoFormat} from "../formats";
+import {materializeCues} from "../cues";
+import {renderMovie} from "../render";
+import {compileInBrowser, createContext, targetFor, withServer} from "./shared";
+
+export const exportQueue = new JobQueue();
+
+/** Controllers for jobs running in this process, so a request can stop one. */
+const running = new Map<string, AbortController>();
+
+export const cancelJob = (id: string): boolean => {
+  const controller = running.get(id);
+  if (!controller) return false;
+  controller.abort();
+  return true;
+};
+
+/**
+ * Run one recorded job. Retries reuse the frozen manifest, so a failed export
+ * never silently re-resolves data or reruns prepare.
+ */
+export const runJob = async (
+  config: ResolvedConfig,
+  origin: string,
+  record: JobRecord,
+  video: LoadedVideo,
+  options: {
+    concurrency?: number;
+    preset?: string;
+    format?: VideoFormat;
+    skipUnchangedFrames?: boolean;
+    signal?: AbortSignal;
+    onProgress?: (job: ExportJob) => void;
+  } = {},
+): Promise<ExportJob> =>
+  exportQueue.enqueue(async () => {
+    const {manifest, output} = record;
+    const controller = new AbortController();
+    running.set(record.job.id, controller);
+    if (options.signal) options.signal.addEventListener("abort", () => controller.abort(), {once: true});
+
+    let current = await updateJob(config, {
+      ...record.job,
+      status: "rendering",
+      progress: 0,
+      attempts: record.job.attempts + 1,
+      pid: process.pid,
+      error: undefined,
+    });
+    options.onProgress?.(current);
+    await appendJobLog(config, current.id, `attempt ${current.attempts} started`);
+
+    try {
+      // Generated cues become files before the mix asks for them. The score
+      // ran in the browser for preview; it runs here for the encode.
+      const cues = await materializeCues(config, [resolveEntryLayout(video.entry).brand], manifest.format.fps);
+      const rendered = cues.filter((entry: {rendered: boolean}) => entry.rendered).length;
+      if (rendered > 0) await appendJobLog(config, current.id, `rendered ${rendered} generated cue(s)`);
+
+      await renderMovie(
+        origin,
+        // The frozen scene list drives chunking, so chunks follow scene cuts.
+        targetFor(
+          {...video, durationInFrames: manifest.format.durationInFrames},
+          manifest.input as Record<string, unknown>,
+          manifest.prepared,
+          manifest.audio,
+          manifest.scenes,
+        ),
+        output,
+        config,
+        (progress, stage) => {
+          const rounded = Math.round(progress * 100);
+          if (rounded % 5 !== 0 && progress < 1) return;
+          // updateJob serializes writes per job, so this cannot interleave.
+          void updateJob(config, {...current, status: stage, progress}).then((next) => {
+            current = next;
+            options.onProgress?.(next);
+          });
+        },
+        {
+          concurrency: options.concurrency,
+          preset: options.preset,
+          format: options.format,
+          skipUnchangedFrames: options.skipUnchangedFrames,
+          signal: controller.signal,
+          onTimings: (timings) => {
+            log.progressDone();
+            const reused = timings.reusedFrames > 0 ? `, ${timings.reusedFrames} reused` : "";
+            const cached = timings.cachedChunks > 0 ? `, ${timings.cachedChunks} chunks from cache` : "";
+            log.detail(
+              `captured ${timings.frames} frames in ${(timings.captureMs / 1000).toFixed(1)}s on ${
+                timings.concurrency
+              } workers across ${timings.chunks} chunks${reused}${cached}, joined in ${(
+                timings.encodeMs / 1000
+              ).toFixed(1)}s`,
+            );
+          },
+        },
+      );
+      current = await updateJob(config, {...current, status: "ready", progress: 1, pid: undefined, output});
+      await appendJobLog(config, current.id, `ready: ${output}`);
+      options.onProgress?.(current);
+      return current;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      current = await updateJob(config, {...current, status: "failed", pid: undefined, error: message});
+      await appendJobLog(config, current.id, `failed: ${message}`);
+      options.onProgress?.(current);
+      throw error;
+    } finally {
+      running.delete(record.job.id);
+    }
+  });
+
+export const exportCommand = async (
+  id: string,
+  options: {
+    output?: string;
+    input?: Record<string, unknown>;
+    concurrency?: number;
+    preset?: string;
+    format?: string;
+    skipUnchangedFrames?: boolean;
+    retry?: string;
+  } = {},
+) => {
+  const {config, graph, videos} = await createContext();
+  // Resolved before anything renders: an unknown format should cost a sentence,
+  // not twenty minutes of capture.
+  const format = resolveFormat(options.format ?? config.format, options.output);
+
+  return withServer(config, async (server) => {
+    const record = options.retry
+      ? await readJob(config, options.retry)
+      : await (async () => {
+          const video = findVideo(videos, id);
+          const compiled = await compileInBrowser(server.url, targetFor(video, options.input), config);
+          const {manifest} = await freezeManifest(
+            {...video, durationInFrames: compiled.durationInFrames},
+            graph,
+            config,
+            options.input ?? {},
+            {scenes: compiled.scenes, audio: compiled.audio},
+          );
+          const output = resolve(
+            config.root,
+            options.output ?? `${config.exportDir}/${outputName(id)}${format.extension}`,
+          );
+          return createJob(config, manifest, output);
+        })();
+
+    const video = findVideo(videos, record.manifest.videoId);
+    log.detail(`job ${record.job.id} manifest ${record.manifest.manifestHash}`);
+    if (options.retry) log.detail(`retrying attempt ${record.job.attempts + 1} from the frozen manifest`);
+    if (record.manifest.audio.length > 0) {
+      log.detail(`${record.manifest.audio.length} audio cue(s) at ${record.manifest.format.durationInFrames} frames`);
+    }
+
+    const job = await runJob(config, server.url, record, video, {
+      concurrency: options.concurrency,
+      preset: options.preset,
+      format,
+      skipUnchangedFrames: options.skipUnchangedFrames,
+      onProgress: (next) => {
+        if (next.status === "rendering" || next.status === "encoding") {
+          log.progress(`${next.status} ${Math.round(next.progress * 100)}%`);
+        }
+      },
+    });
+    log.progressDone();
+    log.success(`Exported ${job.videoId} to ${record.output}`);
+    return job;
+  });
+};
+
+export const jobsCommand = async () => {
+  const {config} = await createContext();
+  const jobs = await listJobs(config);
+  if (jobs.length === 0) {
+    log.detail("No export jobs recorded yet.");
+    return;
+  }
+  log.title(`${jobs.length} export job${jobs.length === 1 ? "" : "s"}`);
+  for (const job of jobs) {
+    const detail = job.status === "ready" ? job.output : job.error ?? `${Math.round(job.progress * 100)}%`;
+    log.info(
+      `  ${job.id}  ${job.videoId.padEnd(20)} ${job.status.padEnd(9)} attempts ${job.attempts}  ${detail ?? ""}`,
+    );
+  }
+  log.detail("Retry a failed job with: odori export --retry <job id>");
+};

package/src/commands/init.ts

@@ -0,0 +1,56 @@
+import {mkdir, writeFile} from "node:fs/promises";
+import {existsSync} from "node:fs";
+import {relative, resolve} from "node:path";
+import {defaultConfig} from "../config";
+import {log} from "../log";
+import {videoTemplate} from "./new";
+
+const CONFIG_TEMPLATE = `import {defineConfig} from "@odori/cli";
+
+export default defineConfig({
+  videosDir: "videos",
+  exportDir: "out",
+  port: 4300,
+});
+`;
+
+const LAYOUT_TEMPLATE = `import {defineBrand, defineVideoLayout} from "odori";
+
+export const productBrand = defineBrand({
+  name: "product",
+  colors: {background: "#08090b", surface: "#111318", foreground: "#f7f8fa", accent: "#7c8cff"},
+  // Empty on purpose: "odori add" writes installed cues into this block,
+  // and without it the only thing it can do is print the lines to paste.
+  audio: {cues: {}, targetLufs: -14},
+});
+
+export const productLayout = defineVideoLayout({
+  format: {width: 1920, height: 1080, fps: 30},
+  brand: productBrand,
+  safeArea: {x: 96, y: 72},
+});
+`;
+
+/** Add the videos source root and configuration to an existing project. */
+export const initCommand = async (root = process.cwd()) => {
+  const videosDir = resolve(root, defaultConfig.videosDir);
+  await mkdir(resolve(videosDir, "components"), {recursive: true});
+
+  const files: Array<[string, string]> = [
+    [resolve(root, "odori.config.ts"), CONFIG_TEMPLATE],
+    [resolve(videosDir, "layout.tsx"), LAYOUT_TEMPLATE],
+    [resolve(videosDir, "launch", "video.tsx"), videoTemplate("launch", true)],
+  ];
+
+  for (const [file, contents] of files) {
+    if (existsSync(file)) {
+      log.detail(`Kept existing ${relative(root, file)}`);
+      continue;
+    }
+    await mkdir(resolve(file, ".."), {recursive: true});
+    await writeFile(file, contents, "utf8");
+    log.success(`Created ${relative(root, file)}`);
+  }
+
+  log.detail("Next: odori doctor, then odori add @odori/title-reveal @odori/end-card, then odori dev.");
+};

package/src/commands/inspect.ts

@@ -0,0 +1,72 @@
+import {isOdoriSchema, resolveEntryLayout} from "odori";
+import {log} from "../log";
+import {findVideo} from "../project";
+import {freezeManifest} from "../project";
+import {compileInBrowser, createContext, targetFor, withServer} from "./shared";
+
+export const inspectCommand = async (id: string, options: {json?: boolean; input?: Record<string, unknown>} = {}) => {
+  const {config, graph, videos} = await createContext();
+  const video = findVideo(videos, id);
+  const layout = resolveEntryLayout(video.entry);
+
+  const {durationInFrames, scenes, audio} = await withServer(config, (server) =>
+    compileInBrowser(server.url, targetFor(video, options.input), config),
+  );
+  const {manifest, input, prepared} = await freezeManifest(
+    {...video, durationInFrames},
+    graph,
+    config,
+    options.input ?? {},
+    {scenes, audio},
+  );
+
+  if (options.json) {
+    log.info(JSON.stringify({metadata: {...video.entry.metadata, layout: undefined, schema: undefined}, layout, manifest}, null, 2));
+    return;
+  }
+
+  log.title(video.entry.metadata.title);
+  log.info(`  id           ${video.entry.metadata.id}`);
+  log.info(`  source       ${video.relativeFile}`);
+  log.info(`  format       ${layout.format.width}x${layout.format.height} at ${layout.format.fps} fps`);
+  log.info(`  duration     ${durationInFrames} frames (${(durationInFrames / layout.format.fps).toFixed(2)}s)`);
+  log.info(`  brand        ${layout.brand.name}`);
+  log.info(`  safe area    ${layout.safeArea.x} x ${layout.safeArea.y}`);
+  log.info(`  manifest     ${manifest.manifestHash}`);
+  log.info(`  source hash  ${manifest.sourceHash}`);
+  log.title("Scenes");
+  for (const scene of scenes) {
+    log.info(
+      `  ${scene.id.padEnd(16)} ${String(scene.start).padStart(5)} to ${String(
+        scene.start + scene.durationInFrames - 1,
+      ).padStart(5)}  (${scene.durationInFrames} frames)`,
+    );
+  }
+  if (scenes.length === 0) log.detail("  No structured scenes. The composition drives motion directly.");
+  log.title("Inputs");
+  if (isOdoriSchema(video.entry.metadata.schema)) {
+    for (const [name, field] of Object.entries(video.entry.metadata.schema.describe())) {
+      log.info(`  ${name.padEnd(16)} ${field.type.padEnd(8)} ${JSON.stringify(input[name])}`);
+    }
+  } else {
+    log.detail(`  ${JSON.stringify(input)}`);
+  }
+  if (prepared !== undefined) {
+    log.title("Prepared");
+    log.detail(`  ${JSON.stringify(prepared).slice(0, 400)}`);
+  }
+  log.title("Audio");
+  if (manifest.audio.length === 0) log.detail("  Silent. Add <Audio src=\"/audio/bed.mp3\" /> to score it.");
+  for (const cue of manifest.audio) {
+    log.info(
+      `  ${cue.src.padEnd(28)} ${String(cue.fromFrame).padStart(5)} to ${String(
+        cue.fromFrame + cue.durationInFrames - 1,
+      ).padStart(5)}  gain ${cue.gain}${cue.duckUnder ? " (ducked)" : ""}`,
+    );
+    log.detail(`    ${cue.integrity}`);
+  }
+  log.title("Assets");
+  if (manifest.assets.length === 0 && manifest.fonts.length === 0) log.detail("  None declared.");
+  for (const asset of manifest.assets) log.info(`  ${asset.reference ?? asset.url}`);
+  for (const font of manifest.fonts) log.info(`  font ${font.family} ${font.url} ${font.integrity}`);
+};

package/src/commands/list.ts

@@ -0,0 +1,22 @@
+import {resolveEntryLayout} from "odori";
+import {log} from "../log";
+import {createContext} from "./shared";
+
+export const listCommand = async () => {
+  const {videos, graph, config} = await createContext();
+  log.title(`${videos.length} video${videos.length === 1 ? "" : "s"} in ${config.videosDir}/`);
+  for (const video of videos) {
+    const layout = resolveEntryLayout(video.entry);
+    const seconds = video.durationInFrames / layout.format.fps;
+    log.info(
+      `  ${video.entry.metadata.id}  ${layout.format.width}x${layout.format.height}  ${layout.format.fps}fps  ${
+        video.durationInFrames ? `${seconds.toFixed(1)}s` : "duration from scenes"
+      }`,
+    );
+    log.detail(`    ${video.relativeFile}`);
+  }
+  if (graph.previews.length > 0) {
+    log.title(`${graph.previews.length} component preview${graph.previews.length === 1 ? "" : "s"}`);
+    for (const preview of graph.previews) log.info(`  ${preview.name}  ${preview.relativeFile}`);
+  }
+};

package/src/commands/new.ts

@@ -0,0 +1,126 @@
+import {mkdir, readdir, writeFile} from "node:fs/promises";
+import {existsSync} from "node:fs";
+import {relative, resolve} from "node:path";
+import {loadConfig, type ResolvedConfig} from "../config";
+import {log} from "../log";
+
+const titleCase = (value: string) =>
+  value
+    .split(/[-_\s]+/)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(" ");
+
+const pascalCase = (value: string) => titleCase(value).replace(/\s+/g, "");
+
+/**
+ * The fallback: no registry components installed, so the entry shows the
+ * runtime and nothing else. Correct, and deliberately plain.
+ */
+export const videoTemplate = (name: string, hasLayout: boolean) => `import {Scene, Video, defineVideoMetadata} from "odori";
+${hasLayout ? 'import {productLayout} from "../layout";\n' : ""}
+export const metadata = defineVideoMetadata({
+  id: "${name}",
+  title: "${titleCase(name)}",
+${hasLayout ? "  layout: productLayout,\n" : ""}  duration: "8s",
+});
+
+export default function ${pascalCase(name)}() {
+  return (
+    <Video>
+      <Scene id="opening" duration="5s">
+        <h1 style={{fontSize: 112, fontWeight: 650, letterSpacing: "-0.045em", margin: "auto", textAlign: "center"}}>
+          ${titleCase(name)}
+        </h1>
+      </Scene>
+      <Scene id="end" duration="3s">
+        <p style={{fontSize: 48, margin: "auto", opacity: 0.7}}>Built with odori</p>
+      </Scene>
+    </Video>
+  );
+}
+`;
+
+/**
+ * The entry a project with components installed should get: the first video
+ * someone reads is the one that teaches them how videos are written here, and
+ * that is composition, not inline styles on an `h1`.
+ */
+export const composedTemplate = (
+  name: string,
+  hasLayout: boolean,
+  parts: {title: boolean; end: boolean},
+) => {
+  const imports = [
+    'import {Scene, Video, defineVideoMetadata} from "odori";',
+    parts.title ? 'import {TitleReveal} from "../components/title-reveal/title-reveal";' : null,
+    parts.end ? 'import {EndCard} from "../components/end-card/end-card";' : null,
+    hasLayout ? 'import {productLayout} from "../layout";' : null,
+  ].filter(Boolean);
+
+  const opening = parts.title
+    ? `        <TitleReveal title="${titleCase(name)}" detail="Written in ${name}/video.tsx" />`
+    : `        <h1 style={{fontSize: 112, fontWeight: 650, margin: "auto", textAlign: "center"}}>${titleCase(name)}</h1>`;
+  const closing = parts.end
+    ? `        <EndCard title="Ship it" detail="odori export ${name}" />`
+    : `        <p style={{fontSize: 48, margin: "auto", opacity: 0.7}}>Built with odori</p>`;
+
+  return `${imports.join("\n")}
+
+export const metadata = defineVideoMetadata({
+  id: "${name}",
+  title: "${titleCase(name)}",
+${hasLayout ? "  layout: productLayout,\n" : ""}  duration: "8s",
+});
+
+export default function ${pascalCase(name)}() {
+  return (
+    <Video>
+      <Scene id="opening" duration="5s">
+${opening}
+      </Scene>
+      <Scene id="end" duration="3s">
+${closing}
+      </Scene>
+    </Video>
+  );
+}
+`;
+};
+
+/** Which of the components this template can use are actually on disk. */
+const installedParts = async (config: ResolvedConfig): Promise<{title: boolean; end: boolean}> => {
+  const componentsDir = resolve(config.root, config.componentsDir);
+  if (!existsSync(componentsDir)) return {title: false, end: false};
+  const entries = (await readdir(componentsDir, {withFileTypes: true}))
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+  return {title: entries.includes("title-reveal"), end: entries.includes("end-card")};
+};
+
+export const newCommand = async (name: string, options: {blank?: boolean} = {}) => {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) throw new Error("Use a lowercase, dash separated name.");
+  const config = await loadConfig(process.cwd());
+  const directory = resolve(config.root, config.videosDir, name);
+  const file = resolve(directory, "video.tsx");
+  if (existsSync(file)) throw new Error(`${relative(config.root, file)} already exists.`);
+
+  const hasLayout = existsSync(resolve(config.root, config.videosDir, "layout.tsx"));
+  const parts = options.blank === true ? {title: false, end: false} : await installedParts(config);
+  const composed = parts.title || parts.end;
+
+  await mkdir(directory, {recursive: true});
+  await writeFile(
+    file,
+    composed ? composedTemplate(name, hasLayout, parts) : videoTemplate(name, hasLayout),
+    "utf8",
+  );
+  log.success(`Created ${relative(config.root, file)}`);
+
+  if (composed) log.detail("Composed from the components this project has installed.");
+  else if (options.blank !== true) {
+    // Nothing to compose with is worth saying once, with the command that
+    // changes it, rather than leaving the plain entry to imply this is the way.
+    log.detail("No registry components installed yet: odori add @odori/title-reveal @odori/end-card");
+  }
+  log.detail("Run odori dev to preview it.");
+};