@odori/cli 0.0.2

package/src/contracts.ts

@@ -0,0 +1,159 @@
+import {existsSync} from "node:fs";
+import {readdir} from "node:fs/promises";
+import {resolve} from "node:path";
+import {cueUrl, isCueDefinition, resolveEntryLayout, type AudioCue, type Brand, type CueDefinition} from "odori";
+import type {LoadedVideo} from "./project";
+import type {ResolvedConfig} from "./config";
+import {readProvenance} from "./commands/update";
+import {resolveRegistry, type RegistryComponent} from "./registry-source";
+
+export type ContractFailure = {video: string; message: string};
+
+/**
+ * The first family name in a CSS font stack, which is what a `@font-face`
+ * family has to match for the brand to actually load it.
+ */
+const primaryFamily = (stack: string): string =>
+  (stack.split(",")[0] ?? "").trim().replace(/^["']|["']$/g, "");
+
+/** Faces the platform provides, which never need a file. */
+const SYSTEM_FAMILIES = new Set([
+  "system-ui",
+  "ui-sans-serif",
+  "ui-monospace",
+  "ui-serif",
+  "ui-rounded",
+  "sans-serif",
+  "serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "-apple-system",
+  "BlinkMacSystemFont",
+]);
+
+const isSystemFamily = (family: string): boolean => SYSTEM_FAMILIES.has(family);
+
+/**
+ * A component's contract names the cues and font roles it needs. The brand is
+ * what answers, so the two can only be checked together. Anything missing is
+ * reported against the video whose brand fell short, because that is the file
+ * an author would open to fix it.
+ */
+export const checkComponentRequirements = (
+  installed: RegistryComponent[],
+  brand: Brand,
+  videoId: string,
+): ContractFailure[] => {
+  const failures: ContractFailure[] = [];
+
+  for (const component of installed) {
+    for (const cue of component.contract.requires.audio) {
+      if (brand.audio.cues[cue] === undefined) {
+        failures.push({
+          video: videoId,
+          message: `${component.namespaced} needs an audio cue named "${cue}". Add it to brand.audio.cues, or remove the component.`,
+        });
+      }
+    }
+
+    for (const role of component.contract.requires.fonts) {
+      const stack = brand.typography[role as keyof Brand["typography"]];
+      if (!stack) {
+        failures.push({
+          video: videoId,
+          message: `${component.namespaced} needs a "${role}" font. Add brand.typography.${role}.`,
+        });
+        continue;
+      }
+      // A stack with no matching face renders through a system fallback, so the
+      // export and the designer's screen quietly disagree. A stack that leads
+      // with a system keyword is not making that mistake — it is asking for
+      // whatever the machine has, on purpose, and every machine has one.
+      const family = primaryFamily(stack);
+      if (family && !isSystemFamily(family) && !brand.fonts.some((font) => font.family === family)) {
+        failures.push({
+          video: videoId,
+          message: `${component.namespaced} uses the "${role}" font "${family}", which has no file in brand.fonts. Preview and export will fall back to a system face.`,
+        });
+      }
+    }
+  }
+
+  return failures;
+};
+
+/**
+ * A placed cue that outlasts the sound behind it.
+ *
+ * A generated cue renders exactly one phrase. If the window it is placed in is
+ * longer than that phrase and the placement does not repeat, everything after
+ * the phrase is silence — which sounds like a bug in the video rather than a
+ * decision, and nothing else in the pipeline reports it. Only generated cues
+ * can be checked: the length of a file on disk is not knowable here, and a
+ * brand may legitimately point a name at a two hour recording.
+ */
+export const checkAudioWindows = (cues: AudioCue[], brand: Brand, videoId: string): ContractFailure[] => {
+  const generated = new Map<string, {name: string; definition: CueDefinition}>();
+  for (const [name, value] of Object.entries(brand.audio.cues)) {
+    if (isCueDefinition(value)) generated.set(cueUrl(value), {name, definition: value});
+  }
+
+  const failures: ContractFailure[] = [];
+  for (const cue of cues) {
+    const match = generated.get(cue.src);
+    if (!match || cue.loop) continue;
+    if (cue.durationInFrames <= match.definition.durationInFrames) continue;
+    failures.push({
+      video: videoId,
+      message:
+        `"${match.name}" is ${match.definition.durationInFrames} frames long but is placed over ` +
+        `${cue.durationInFrames}. The rest is silence: declare loops on the cue, pass loop to <Audio>, ` +
+        `or shorten the window with duration.`,
+    });
+  }
+  return failures;
+};
+
+/**
+ * Every installed component checked against every discovered video's brand. A
+ * video does not declare which components it uses, so this is deliberately
+ * project wide: a cue that no brand provides is a problem wherever it is used.
+ */
+export const checkInstalledContracts = async (
+  config: ResolvedConfig,
+  videos: LoadedVideo[],
+): Promise<ContractFailure[]> => {
+  // What is installed is what is on disk. Provenance only exists when a
+  // component arrived through `odori add`, and a copied directory counts too.
+  const componentsDir = resolve(config.root, config.componentsDir);
+  const onDisk = existsSync(componentsDir)
+    ? (await readdir(componentsDir, {withFileTypes: true}))
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+    : [];
+  const names = new Set([...Object.keys(await readProvenance(config)), ...onDisk]);
+  if (names.size === 0) return [];
+
+  // Validation never reaches for the network: whether a video is correct must
+  // not depend on a connection. The cache or the built-in snapshot answers.
+  const {items} = await resolveRegistry(config, {allowNetwork: false});
+  const installed = items.filter((component) => names.has(component.name));
+  if (installed.length === 0) return [];
+
+  const seen = new Set<string>();
+  const failures: ContractFailure[] = [];
+
+  for (const video of videos) {
+    const {brand} = resolveEntryLayout(video.entry);
+    for (const failure of checkComponentRequirements(installed, brand, video.entry.metadata.id)) {
+      // One brand shared by many videos should report once, not once per video.
+      const key = `${brand.name}:${failure.message}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      failures.push(failure);
+    }
+  }
+
+  return failures;
+};

package/src/cues.ts

@@ -0,0 +1,141 @@
+import {existsSync, statSync} from "node:fs";
+import {mkdir, writeFile} from "node:fs/promises";
+import {basename, resolve} from "node:path";
+import {pathToFileURL} from "node:url";
+import {
+  SAMPLE_RATE,
+  cueSamples,
+  cueUrl,
+  defaultLayout,
+  encodeWav,
+  isCueDefinition,
+  resolveEntryLayout,
+  type Brand,
+  type CueDefinition,
+} from "odori";
+import type {ResolvedConfig} from "./config";
+import type {ProjectGraph} from "./discovery";
+import {log} from "./log";
+import {loadVideos} from "./project";
+
+/** Where a rendered cue lands. Content addressed, so it is written once. */
+export const cueCacheDir = (config: ResolvedConfig) => resolve(config.root, config.outDir, "cues");
+
+export const cueFile = (config: ResolvedConfig, url: string) => resolve(cueCacheDir(config), basename(url));
+
+/**
+ * Render every generated cue a brand declares, once, into the build cache.
+ *
+ * The score runs here exactly as it runs in the browser, so the file the mix
+ * reads is the sound the author previewed. A cue whose file already exists is
+ * skipped: the name carries a hash of the score, so an unchanged cue is never
+ * rendered twice and a changed one can never collide with the old bytes.
+ */
+export const materializeCues = async (
+  config: ResolvedConfig,
+  brands: Brand[],
+  fps: number,
+): Promise<Array<{cue: CueDefinition; file: string; rendered: boolean}>> => {
+  const seen = new Map<string, CueDefinition>();
+  for (const brand of brands) {
+    for (const value of Object.values(brand.audio.cues)) {
+      if (isCueDefinition(value)) seen.set(cueUrl(value), value);
+    }
+  }
+  if (seen.size === 0) return [];
+
+  await mkdir(cueCacheDir(config), {recursive: true});
+  const written: Array<{cue: CueDefinition; file: string; rendered: boolean}> = [];
+
+  for (const [url, cue] of seen) {
+    const file = cueFile(config, url);
+    if (existsSync(file)) {
+      written.push({cue, file, rendered: false});
+      continue;
+    }
+    const samples = cueSamples(cue, fps);
+    const signal = cue.render({samples, sampleRate: SAMPLE_RATE});
+    await writeFile(file, encodeWav(signal));
+    written.push({cue, file, rendered: true});
+  }
+
+  return written;
+};
+
+/**
+ * Cues the dev server can answer for. Discovery fills this once the project's
+ * brands are known; the server renders on first request and keeps the bytes,
+ * because the URL is content addressed and can never mean a different sound.
+ */
+const known = new Map<string, {cue: CueDefinition; fps: number}>();
+const rendered = new Map<string, Uint8Array>();
+
+export const registerCues = (brands: Brand[], fps: number): number => {
+  for (const brand of brands) {
+    for (const value of Object.values(brand.audio.cues)) {
+      if (isCueDefinition(value)) known.set(cueUrl(value), {cue: value, fps});
+    }
+  }
+  return known.size;
+};
+
+export const renderedCue = (url: string): Uint8Array | null => {
+  const cached = rendered.get(url);
+  if (cached) return cached;
+  const entry = known.get(url);
+  if (!entry) return null;
+  const signal = entry.cue.render({samples: cueSamples(entry.cue, entry.fps), sampleRate: SAMPLE_RATE});
+  const wav = encodeWav(signal);
+  rendered.set(url, wav);
+  return wav;
+};
+
+const isBrand = (value: unknown): value is Brand =>
+  typeof value === "object" && value !== null && (value as Brand).kind === "odori-brand";
+
+/**
+ * Import a source file fresh.
+ *
+ * Node caches modules by URL for the life of the process, so a dev server that
+ * re-reads a brand after an edit would otherwise keep the scores it saw at
+ * boot. The file's mtime in the specifier makes an edited file a new module
+ * and an untouched one a cache hit.
+ */
+const importFresh = async (file: string): Promise<Record<string, unknown>> =>
+  (await import(`${pathToFileURL(file).href}?odori=${statSync(file).mtimeMs}`)) as Record<string, unknown>;
+
+/**
+ * Teach the server every cue the project declares, so a preview can ask for
+ * one by content hash the moment Studio loads.
+ *
+ * Discovery is the source of truth on both halves. The brand modules are what
+ * make a cue exist at all, including a brand no video has adopted yet, and
+ * they are registered first at the default frame rate. The video entries are
+ * then loaded for their layouts, because the frame rate decides how many
+ * samples a cue occupies and only an entry knows its own. A project that
+ * cannot be loaded — a half-written entry mid-edit — leaves the brand pass in
+ * place rather than taking the server down.
+ */
+export const registerProjectCues = async (graph: ProjectGraph): Promise<number> => {
+  for (const discovered of graph.brands) {
+    try {
+      const module = await importFresh(discovered.file);
+      registerCues(Object.values(module).filter(isBrand), defaultLayout.format.fps);
+    } catch (error) {
+      log.warn(`[odori] could not read cues from ${discovered.relativeFile}: ${message(error)}`);
+    }
+  }
+
+  try {
+    for (const video of await loadVideos(graph)) {
+      const layout = resolveEntryLayout(video.entry);
+      registerCues([layout.brand], layout.format.fps);
+    }
+  } catch (error) {
+    log.warn(`[odori] generated cues may use the default frame rate: ${message(error)}`);
+  }
+
+  return known.size;
+};
+
+const message = (error: unknown) => (error instanceof Error ? error.message : String(error));

package/src/determinism.ts

@@ -0,0 +1,82 @@
+import {readdir, readFile} from "node:fs/promises";
+import {existsSync} from "node:fs";
+import {join, relative, resolve} from "node:path";
+import type {ResolvedConfig} from "./config";
+
+export type DeterminismFinding = {file: string; line: number; source: string; message: string};
+
+/**
+ * Calls that make a frame depend on something other than its number.
+ *
+ * The frame contract is the whole product: the same frame number produces the
+ * same pixels, in Studio, in a still, and in every one of the parallel workers
+ * an export runs. These break it silently. `Math.random()` gives each worker
+ * its own numbers, so particles jump at chunk boundaries. `Date.now()` gives
+ * each render a different answer, so a countdown is correct on the machine
+ * that made it and wrong everywhere else.
+ *
+ * Both have deterministic replacements, which is why this is an error rather
+ * than a style note.
+ */
+const FORBIDDEN: Array<{pattern: RegExp; message: string}> = [
+  {
+    pattern: /\bMath\.random\s*\(/,
+    message: 'Math.random() differs per render worker. Use random("a-seed") from odori, which is stable for a seed.',
+  },
+  {
+    pattern: /\bDate\.now\s*\(/,
+    message: "Date.now() makes the frame depend on when it rendered. Derive time from useFrame(), or pass it through the video's input schema.",
+  },
+  {
+    pattern: /\bnew\s+Date\s*\(\s*\)/,
+    message: "new Date() with no argument reads the wall clock. Pass the date through the video's input schema so a re-render produces the same frame.",
+  },
+  {
+    pattern: /\bperformance\.now\s*\(/,
+    message: "performance.now() is wall clock. A frame's timing comes from useFrame() and the video's fps.",
+  },
+];
+
+/** Lines that are only a comment cannot call anything. */
+const isComment = (line: string): boolean => /^\s*(\/\/|\*|\/\*)/.test(line);
+
+const scanSource = (source: string, file: string): DeterminismFinding[] => {
+  const findings: DeterminismFinding[] = [];
+  source.split("\n").forEach((text, index) => {
+    if (isComment(text)) return;
+    // An explicit opt-out, for the rare case where a value genuinely should
+    // not be reproducible and the author has thought about it.
+    if (/odori-allow-nondeterminism/.test(text)) return;
+    for (const {pattern, message} of FORBIDDEN) {
+      if (pattern.test(text)) findings.push({file, line: index + 1, source: text.trim(), message});
+    }
+  });
+  return findings;
+};
+
+const walk = async (directory: string, files: string[] = []): Promise<string[]> => {
+  for (const entry of await readdir(directory, {withFileTypes: true})) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const full = join(directory, entry.name);
+    if (entry.isDirectory()) await walk(full, files);
+    else if (/\.(tsx|ts|jsx|js)$/.test(entry.name) && !/\.preview\.(tsx|jsx)$/.test(entry.name)) files.push(full);
+  }
+  return files;
+};
+
+/**
+ * Every module under the source root, checked for the calls above.
+ *
+ * Preview fixtures are skipped: they are development-only, never in a render,
+ * and a fixture that wants a throwaway value is not lying to anyone.
+ */
+export const checkDeterminism = async (config: ResolvedConfig): Promise<DeterminismFinding[]> => {
+  const root = resolve(config.root, config.videosDir);
+  if (!existsSync(root)) return [];
+
+  const files = await walk(root);
+  const findings = await Promise.all(
+    files.map(async (file) => scanSource(await readFile(file, "utf8"), relative(config.root, file))),
+  );
+  return findings.flat();
+};

package/src/diff.ts

@@ -0,0 +1,71 @@
+/**
+ * A minimal unified diff.
+ *
+ * Component updates need to show what upstream changed without pulling a diff
+ * library into the CLI, and the output only has to be readable in a terminal.
+ */
+const lcs = (left: string[], right: string[]): number[][] => {
+  const table = Array.from({length: left.length + 1}, () => new Array<number>(right.length + 1).fill(0));
+  for (let i = left.length - 1; i >= 0; i -= 1) {
+    for (let j = right.length - 1; j >= 0; j -= 1) {
+      table[i][j] = left[i] === right[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+    }
+  }
+  return table;
+};
+
+export type DiffLine = {type: "context" | "add" | "remove"; text: string};
+
+export const diffLines = (before: string, after: string): DiffLine[] => {
+  const left = before.split("\n");
+  const right = after.split("\n");
+  const table = lcs(left, right);
+  const output: DiffLine[] = [];
+
+  let i = 0;
+  let j = 0;
+  while (i < left.length && j < right.length) {
+    if (left[i] === right[j]) {
+      output.push({type: "context", text: left[i]});
+      i += 1;
+      j += 1;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      output.push({type: "remove", text: left[i]});
+      i += 1;
+    } else {
+      output.push({type: "add", text: right[j]});
+      j += 1;
+    }
+  }
+  while (i < left.length) output.push({type: "remove", text: left[i++]});
+  while (j < right.length) output.push({type: "add", text: right[j++]});
+  return output;
+};
+
+export const countChanges = (lines: DiffLine[]) => ({
+  added: lines.filter((line) => line.type === "add").length,
+  removed: lines.filter((line) => line.type === "remove").length,
+});
+
+/** Collapse unchanged runs so a small edit does not print the whole file. */
+export const formatDiff = (lines: DiffLine[], context = 2): string[] => {
+  const keep = new Set<number>();
+  lines.forEach((line, index) => {
+    if (line.type === "context") return;
+    for (let offset = -context; offset <= context; offset += 1) keep.add(index + offset);
+  });
+
+  const output: string[] = [];
+  let skipping = false;
+  lines.forEach((line, index) => {
+    if (!keep.has(index)) {
+      if (!skipping) output.push("  ...");
+      skipping = true;
+      return;
+    }
+    skipping = false;
+    const marker = line.type === "add" ? "+" : line.type === "remove" ? "-" : " ";
+    output.push(`${marker} ${line.text}`);
+  });
+  return output;
+};

package/src/discovery.ts

@@ -0,0 +1,216 @@
+import {mkdir, readdir, readFile, stat, writeFile} from "node:fs/promises";
+import {existsSync} from "node:fs";
+import {join, relative, resolve, sep} from "node:path";
+import {hashString} from "odori";
+import type {ResolvedConfig} from "./config";
+
+export type DiscoveredVideo = {
+  /** Directory-derived id used before the module is loaded. */
+  slug: string;
+  file: string;
+  relativeFile: string;
+  importPath: string;
+  identifier: string;
+};
+
+export type DiscoveredPreview = {
+  name: string;
+  file: string;
+  relativeFile: string;
+  importPath: string;
+  identifier: string;
+};
+
+export type DiscoveredBrandModule = {
+  name: string;
+  file: string;
+  relativeFile: string;
+  identifier: string;
+};
+
+export type DiscoveredAudio = {
+  /** Path under the audio directory, without extension. */
+  name: string;
+  /** The URL the dev server and the render worker both serve. */
+  url: string;
+  relativeFile: string;
+  bytes: number;
+};
+
+export type ProjectGraph = {
+  videos: DiscoveredVideo[];
+  previews: DiscoveredPreview[];
+  brands: DiscoveredBrandModule[];
+  audio: DiscoveredAudio[];
+  sourceHash: string;
+};
+
+const IGNORED = new Set(["node_modules", ".git", ".odori", "out", "dist", ".next"]);
+
+const walk = async (directory: string, files: string[] = []): Promise<string[]> => {
+  const entries = await readdir(directory, {withFileTypes: true});
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || IGNORED.has(entry.name)) continue;
+    const full = join(directory, entry.name);
+    if (entry.isDirectory()) await walk(full, files);
+    else files.push(full);
+  }
+  return files;
+};
+
+const toIdentifier = (value: string, prefix: string) => {
+  const cleaned = value.replace(/[^a-zA-Z0-9]+(.)?/g, (_, character: string | undefined) =>
+    character ? character.toUpperCase() : "",
+  );
+  return `${prefix}${cleaned.charAt(0).toUpperCase()}${cleaned.slice(1)}`;
+};
+
+const AUDIO_EXTENSIONS = /\.(m4a|mp3|wav|aac|ogg|opus|flac)$/i;
+
+/**
+ * The audio library is a directory of files, not a module graph, so it is
+ * listed rather than imported. It lives under `public/` because that is the
+ * one place a URL means the same thing in Studio, in a still, and in the
+ * export worker.
+ */
+export const discoverAudio = async (config: ResolvedConfig): Promise<DiscoveredAudio[]> => {
+  const root = resolve(config.root, config.audioDir);
+  if (!existsSync(root)) return [];
+  const publicRoot = resolve(config.root, "public");
+  const files = (await walk(root)).filter((file) => AUDIO_EXTENSIONS.test(file)).sort();
+
+  return Promise.all(
+    files.map(async (file) => ({
+      name: relative(root, file).replace(AUDIO_EXTENSIONS, "").split(sep).join("/"),
+      url: file.startsWith(`${publicRoot}${sep}`)
+        ? `/${relative(publicRoot, file).split(sep).join("/")}`
+        : `/${relative(config.root, file).split(sep).join("/")}`,
+      relativeFile: relative(config.root, file),
+      bytes: (await stat(file)).size,
+    })),
+  );
+};
+
+/**
+ * Discovery is filesystem based and filename driven, exactly as documented:
+ * `videos/**\/video.tsx` are exportable videos and `videos/**\/*.preview.tsx`
+ * are development-only component fixtures. Directory names carry no meaning.
+ */
+export const discoverProject = async (config: ResolvedConfig): Promise<ProjectGraph> => {
+  const videosRoot = resolve(config.root, config.videosDir);
+  if (!existsSync(videosRoot)) {
+    throw new Error(`No ${config.videosDir}/ directory found in ${config.root}. Run "odori init" first.`);
+  }
+
+  const files = (await walk(videosRoot)).sort();
+  const audio = await discoverAudio(config);
+  const videos: DiscoveredVideo[] = [];
+  const previews: DiscoveredPreview[] = [];
+  const brands: DiscoveredBrandModule[] = [];
+  const hashParts: string[] = [];
+
+  for (const file of files) {
+    const relativeFile = relative(config.root, file);
+    if (/\.(tsx|ts|css|json)$/.test(file)) {
+      const contents = await readFile(file, "utf8");
+      hashParts.push(`${relativeFile}:${hashString(contents)}`);
+    }
+
+    const base = file.split(sep).pop() ?? "";
+    if (base === "video.tsx") {
+      // The path under videos/ is the id, the way a route is a path.
+      const slug = relative(videosRoot, file).replace(/\/?video\.tsx$/, "").split(sep).join("/") || "video";
+      videos.push({
+        slug,
+        file,
+        relativeFile,
+        importPath: file,
+        identifier: toIdentifier(slug, "video"),
+      });
+    } else if (file.split(sep).includes("brands") && /\.tsx?$/.test(base) && !base.endsWith(".preview.tsx")) {
+      const name = base.replace(/\.tsx?$/, "");
+      brands.push({
+        name,
+        file,
+        relativeFile,
+        identifier: toIdentifier(`${name}-module`, "brands"),
+      });
+    } else if (base.endsWith(".preview.tsx")) {
+      const name = base.replace(/\.preview\.tsx$/, "");
+      previews.push({
+        name,
+        file,
+        relativeFile,
+        importPath: file,
+        identifier: toIdentifier(`${relative(videosRoot, file).split(sep).join("-")}`, "preview"),
+      });
+    }
+  }
+
+  return {videos, previews, brands, audio, sourceHash: hashString(hashParts.join("|"))};
+};
+
+/**
+ * Static imports keep the module graph compatible with Next.js, tests,
+ * browsers, and Node render workers.
+ */
+export const generateImports = (graph: ProjectGraph, outDir: string): string => {
+  const importPath = (file: string) => {
+    const relativePath = relative(outDir, file).split(sep).join("/");
+    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+  };
+
+  const lines = [
+    "// Generated by odori. Do not edit.",
+    'import type {VideoEntry} from "odori";',
+    "",
+    ...graph.videos.map(
+      (video) => `import ${video.identifier}, {metadata as ${video.identifier}Metadata} from "${importPath(video.file)}";`,
+    ),
+    ...graph.previews.map((preview) => `import ${preview.identifier} from "${importPath(preview.file)}";`),
+    ...graph.brands.map((brand) => `import * as ${brand.identifier} from "${importPath(brand.file)}";`),
+    "",
+    "export const videos: VideoEntry[] = [",
+    ...graph.videos.map(
+      (video) =>
+        `  {component: ${video.identifier}, metadata: {...${video.identifier}Metadata, id: ${video.identifier}Metadata.id || ${JSON.stringify(video.slug)}}},`,
+    ),
+    "];",
+    "",
+    "export const componentPreviews = [",
+    ...graph.previews.map((preview) => `  {id: ${JSON.stringify(preview.name)}, preview: ${preview.identifier}},`,),
+    "];",
+    "",
+    "export const brands = [",
+    ...graph.brands.map(
+      (brand) =>
+        `  ...Object.values(${brand.identifier}).filter((value) => (value as {kind?: string})?.kind === "odori-brand"),`,
+    ),
+    "];",
+    "",
+  ];
+  return lines.join("\n");
+};
+
+export const writeGenerated = async (config: ResolvedConfig, graph: ProjectGraph): Promise<string> => {
+  const outDir = resolve(config.root, config.outDir);
+  await mkdir(outDir, {recursive: true});
+  const target = join(outDir, "imports.generated.ts");
+  await writeFile(target, generateImports(graph, outDir), "utf8");
+  await writeFile(
+    join(outDir, "catalog.json"),
+    `${JSON.stringify(
+      {
+        sourceHash: graph.sourceHash,
+        videos: graph.videos.map((video) => ({slug: video.slug, file: video.relativeFile})),
+        previews: graph.previews.map((preview) => ({name: preview.name, file: preview.relativeFile})),
+        brands: graph.brands.map((brand) => ({name: brand.name, file: brand.relativeFile})),
+        audio: graph.audio.map((entry) => ({name: entry.name, url: entry.url, file: entry.relativeFile})),
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+  return target;
+};