@odori/cli 0.0.2 → 0.0.4

package/src/commands/exportVideo.ts

@@ -4,7 +4,7 @@ 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 {resolveFormat, QUALITIES, type Quality, type VideoFormat} from "../formats";
 import {materializeCues} from "../cues";
 import {renderMovie} from "../render";
 import {compileInBrowser, createContext, targetFor, withServer} from "./shared";
@@ -33,6 +33,8 @@ export const runJob = async (
   options: {
     concurrency?: number;
     preset?: string;
+    quality?: Quality;
+    scale?: number;
     format?: VideoFormat;
     skipUnchangedFrames?: boolean;
     signal?: AbortSignal;
@@ -86,8 +88,12 @@ export const runJob = async (
         },
         {
           concurrency: options.concurrency,
-          preset: options.preset,
-          format: options.format,
+          // The record freezes how it should be encoded alongside what, so a
+          // retry from any surface produces the same file the first run would.
+          preset: options.preset ?? record.render?.preset,
+          quality: options.quality ?? (record.render?.quality as Quality | undefined),
+          scale: options.scale ?? record.render?.scale,
+          format: options.format ?? (record.render?.format ? resolveFormat(record.render.format, record.output) : undefined),
           skipUnchangedFrames: options.skipUnchangedFrames,
           signal: controller.signal,
           onTimings: (timings) => {
@@ -119,6 +125,22 @@ export const runJob = async (
     }
   });
 
+/** A named tier, or a sentence naming the tiers. */
+export const resolveQuality = (requested: string | undefined): Quality => {
+  if (!requested) return "studio";
+  if ((QUALITIES as string[]).includes(requested)) return requested as Quality;
+  throw new Error(`Unknown quality "${requested}". Available: ${QUALITIES.join(", ")}`);
+};
+
+/** A sane multiplier: enough for a half-size preview and a 2x retina cut. */
+export const resolveScale = (requested: number | undefined): number => {
+  if (requested === undefined) return 1;
+  if (!Number.isFinite(requested) || requested < 0.25 || requested > 2) {
+    throw new Error(`Scale ${requested} is out of range. Use a value between 0.25 and 2.`);
+  }
+  return requested;
+};
+
 export const exportCommand = async (
   id: string,
   options: {
@@ -126,6 +148,8 @@ export const exportCommand = async (
     input?: Record<string, unknown>;
     concurrency?: number;
     preset?: string;
+    quality?: string;
+    scale?: number;
     format?: string;
     skipUnchangedFrames?: boolean;
     retry?: string;
@@ -135,6 +159,8 @@ export const exportCommand = async (
   // 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);
+  const quality = resolveQuality(options.quality);
+  const scale = resolveScale(options.scale);
 
   return withServer(config, async (server) => {
     const record = options.retry
@@ -153,7 +179,12 @@ export const exportCommand = async (
             config.root,
             options.output ?? `${config.exportDir}/${outputName(id)}${format.extension}`,
           );
-          return createJob(config, manifest, output);
+          return createJob(config, manifest, output, {
+            format: format.name,
+            quality,
+            scale,
+            ...(options.preset ? {preset: options.preset} : {}),
+          });
         })();
 
     const video = findVideo(videos, record.manifest.videoId);
@@ -166,7 +197,10 @@ export const exportCommand = async (
     const job = await runJob(config, server.url, record, video, {
       concurrency: options.concurrency,
       preset: options.preset,
-      format,
+      // A retry keeps what its record froze; an explicit flag still wins.
+      quality: options.retry && options.quality === undefined ? undefined : quality,
+      scale: options.retry && options.scale === undefined ? undefined : scale,
+      format: options.retry ? undefined : format,
       skipUnchangedFrames: options.skipUnchangedFrames,
       onProgress: (next) => {
         if (next.status === "rendering" || next.status === "encoding") {

package/src/commands/{still.ts → frame.ts}

@@ -1,23 +1,37 @@
 import {resolve} from "node:path";
+import {framesFromOffset, resolveEntryLayout, type Duration} from "odori";
 import {log} from "../log";
 import {findVideo, freezeManifest, outputName} from "../project";
 import {renderStill} from "../render";
 import {compileInBrowser, createContext, targetFor, withServer} from "./shared";
 
-export const stillCommand = async (
+/**
+ * One frame of a video, as a PNG.
+ *
+ * `at` is a duration like everything else in Odori: a bare number is seconds,
+ * and `120f` is frame 120. Which frame that resolves to depends on the
+ * video's frame rate, and the frame rate belongs to the video's layout, so
+ * the position is checked for shape first and resolved once the video is
+ * loaded. A typo still costs nothing: no discovery, no dev server, no
+ * browser.
+ */
+export const frameCommand = async (
   id: string,
-  options: {frame?: number; output?: string; input?: Record<string, unknown>} = {},
+  options: {at?: Duration; output?: string; input?: Record<string, unknown>} = {},
 ) => {
-  const frame = options.frame ?? 0;
-  // A frame is an index into the timeline. Checking it first means a typo
-  // costs nothing: no discovery, no dev server, no browser.
-  if (!Number.isInteger(frame) || frame < 0) {
-    throw new Error(`Frame must be a whole number of frames from the start, got ${String(frame)}.`);
-  }
+  const at = options.at ?? 0;
+  // A position, not a length: frame zero is the first frame, so this is
+  // framesFromOffset rather than framesFromDuration, which floors at one. Any
+  // frame rate rejects a malformed duration, so this validates the shape
+  // before the work starts; the real rate resolves the number below.
+  framesFromOffset(at, 30);
 
   const {config, graph, videos} = await createContext();
   const video = findVideo(videos, id);
 
+  const fps = resolveEntryLayout(video.entry).format.fps;
+  const frame = framesFromOffset(at, fps);
+
   const output = await withServer(config, async (server) => {
     const {durationInFrames, scenes, audio} = await compileInBrowser(server.url, targetFor(video, options.input), config);
     const {manifest, input, prepared} = await freezeManifest(
@@ -35,6 +49,6 @@ export const stillCommand = async (
     return renderStill(server.url, target, frame, file, config);
   });
 
-  log.success(`Still frame ${frame} written to ${output}`);
+  log.success(`Frame ${frame} written to ${output}`);
   return output;
 };

package/src/commands/init.ts

@@ -52,5 +52,5 @@ export const initCommand = async (root = process.cwd()) => {
     log.success(`Created ${relative(root, file)}`);
   }
 
-  log.detail("Next: odori doctor, then odori add @odori/title-reveal @odori/end-card, then odori dev.");
+  log.detail("Next: odori doctor, then odori add title-reveal end-card, then odori dev.");
 };

package/src/commands/new.ts

@@ -120,7 +120,7 @@ export const newCommand = async (name: string, options: {blank?: boolean} = {})
   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("No registry components installed yet: odori add title-reveal end-card");
   }
   log.detail("Run odori dev to preview it.");
 };

package/src/cues.ts

@@ -12,11 +12,12 @@ import {
   resolveEntryLayout,
   type Brand,
   type CueDefinition,
+  type VideoEntry,
+  type VideoLayout,
 } 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");
@@ -93,15 +94,22 @@ export const renderedCue = (url: string): Uint8Array | null => {
 const isBrand = (value: unknown): value is Brand =>
   typeof value === "object" && value !== null && (value as Brand).kind === "odori-brand";
 
+const isLayout = (value: unknown): value is VideoLayout =>
+  typeof value === "object" && value !== null && (value as VideoLayout).kind === "odori-layout";
+
+/** How registration reads a source module. The dev server supplies Vite. */
+export type ModuleLoader = (file: string) => Promise<Record<string, unknown>>;
+
 /**
- * Import a source file fresh.
+ * Import a source file fresh, for callers with no dev server.
  *
- * 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.
+ * Node caches modules by URL for the life of the process; the file's mtime in
+ * the specifier makes an edited file a new module and an untouched one a cache
+ * hit. What this cannot do is see through an import: a brand whose score lives
+ * in another file keeps that child cached, which is why the dev server loads
+ * through Vite's module graph instead — Vite invalidates the whole chain.
  */
-const importFresh = async (file: string): Promise<Record<string, unknown>> =>
+export const importFresh: ModuleLoader = async (file) =>
   (await import(`${pathToFileURL(file).href}?odori=${statSync(file).mtimeMs}`)) as Record<string, unknown>;
 
 /**
@@ -109,30 +117,35 @@ const importFresh = async (file: string): Promise<Record<string, unknown>> =>
  * 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.
+ * make a cue exist at all, including a brand no video has adopted yet. They
+ * register first at the default frame rate; any layout exported beside a brand
+ * then re-registers it at the rate that layout pins, because the frame rate
+ * decides how many samples a cue occupies. The video entries come last for the
+ * same reason: only an entry knows the layout it actually plays under. A file
+ * that cannot be loaded — half-written mid-edit — leaves the passes that
+ * succeeded in place rather than taking the server down.
  */
-export const registerProjectCues = async (graph: ProjectGraph): Promise<number> => {
+export const registerProjectCues = async (graph: ProjectGraph, load: ModuleLoader = importFresh): Promise<number> => {
   for (const discovered of graph.brands) {
     try {
-      const module = await importFresh(discovered.file);
-      registerCues(Object.values(module).filter(isBrand), defaultLayout.format.fps);
+      const values = Object.values(await load(discovered.file));
+      registerCues(values.filter(isBrand), defaultLayout.format.fps);
+      for (const layout of values.filter(isLayout)) registerCues([layout.brand], layout.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);
+  for (const video of graph.videos) {
+    try {
+      const module = await load(video.file);
+      if (!module.default || !module.metadata) continue;
+      const entry = {component: module.default, metadata: module.metadata} as VideoEntry;
+      const layout = resolveEntryLayout(entry);
       registerCues([layout.brand], layout.format.fps);
+    } catch (error) {
+      log.warn(`[odori] generated cues in ${video.relativeFile} may use the default frame rate: ${message(error)}`);
     }
-  } catch (error) {
-    log.warn(`[odori] generated cues may use the default frame rate: ${message(error)}`);
   }
 
   return known.size;

package/src/discovery.ts

@@ -3,6 +3,7 @@ import {existsSync} from "node:fs";
 import {join, relative, resolve, sep} from "node:path";
 import {hashString} from "odori";
 import type {ResolvedConfig} from "./config";
+import {log} from "./log";
 
 export type DiscoveredVideo = {
   /** Directory-derived id used before the module is loaded. */
@@ -19,6 +20,8 @@ export type DiscoveredPreview = {
   relativeFile: string;
   importPath: string;
   identifier: string;
+  /** Video ids whose composition imports this component. Derived, not declared. */
+  usedBy?: string[];
 };
 
 export type DiscoveredBrandModule = {
@@ -37,11 +40,26 @@ export type DiscoveredAudio = {
   bytes: number;
 };
 
+/**
+ * A directory naming itself, from a `category.json` beside the components it
+ * holds. The path is what the filesystem already says; this is only how that
+ * level should read and where it should sit among its siblings.
+ */
+export type DiscoveredCategory = {
+  /** Directory path under the components directory: `product-ui/forms`. */
+  path: string;
+  /** What to call it. Without one, the directory name is read as words. */
+  name?: string;
+  /** Sort position among siblings. Unset sorts after, alphabetically. */
+  order?: number;
+};
+
 export type ProjectGraph = {
   videos: DiscoveredVideo[];
   previews: DiscoveredPreview[];
   brands: DiscoveredBrandModule[];
   audio: DiscoveredAudio[];
+  categories: DiscoveredCategory[];
   sourceHash: string;
 };
 
@@ -107,16 +125,52 @@ export const discoverProject = async (config: ResolvedConfig): Promise<ProjectGr
   const videos: DiscoveredVideo[] = [];
   const previews: DiscoveredPreview[] = [];
   const brands: DiscoveredBrandModule[] = [];
+  const categories: DiscoveredCategory[] = [];
   const hashParts: string[] = [];
+  const importedBy: Record<string, Set<string>> = {};
+  const componentsRoot = resolve(config.root, config.componentsDir);
 
   for (const file of files) {
     const relativeFile = relative(config.root, file);
+    let contents = "";
     if (/\.(tsx|ts|css|json)$/.test(file)) {
-      const contents = await readFile(file, "utf8");
+      contents = await readFile(file, "utf8");
       hashParts.push(`${relativeFile}:${hashString(contents)}`);
     }
 
     const base = file.split(sep).pop() ?? "";
+    if (base === "category.json") {
+      // Beside the components it holds, so a label lives with the thing it
+      // labels. A malformed one is reported and skipped: a typo in a display
+      // name must not take the project down.
+      const path = relative(componentsRoot, resolve(file, "..")).split(sep).join("/");
+      if (!path.startsWith("..")) {
+        try {
+          const declared = JSON.parse(contents) as {name?: unknown; order?: unknown};
+          categories.push({
+            path,
+            ...(typeof declared.name === "string" ? {name: declared.name} : {}),
+            ...(typeof declared.order === "number" ? {order: declared.order} : {}),
+          });
+        } catch (error) {
+          log.warn(
+            `${relativeFile} is not valid JSON, so that directory names itself: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+          );
+        }
+      }
+    }
+
+    if (base === "video.tsx") {
+      // The file is already read for the source hash, so the import graph
+      // costs nothing to take. A component's audience is a fact about the
+      // project rather than something an author should have to restate, and
+      // a restated one goes stale the moment a scene is deleted.
+      for (const match of contents.matchAll(/from\s+["'][^"']*\/components\/([^/"']+)\//g)) {
+        (importedBy[match[1]] ??= new Set()).add(relative(videosRoot, file).replace(/\/?video\.tsx$/, "") || "video");
+      }
+    }
     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";
@@ -127,13 +181,30 @@ export const discoverProject = async (config: ResolvedConfig): Promise<ProjectGr
         importPath: file,
         identifier: toIdentifier(slug, "video"),
       });
-    } else if (file.split(sep).includes("brands") && /\.tsx?$/.test(base) && !base.endsWith(".preview.tsx")) {
+    } else if (
+      // A brand module is recognized by what it does, not where it sits. The
+      // scaffold defines its brand in videos/layout.tsx, so a directory-name
+      // rule alone left the default project's brand invisible to everything
+      // that reads this list — most visibly the dev server's cue registry,
+      // which then answered new cue URLs with 404s until a restart. Installed
+      // component source is excluded the way brand-file.ts excludes it: a
+      // component may mention defineBrand without being where a brand lives.
+      /\.tsx?$/.test(base) &&
+      !base.endsWith(".preview.tsx") &&
+      !file.startsWith(componentsRoot + sep) &&
+      (file.split(sep).includes("brands") || contents.includes("defineBrand("))
+    ) {
       const name = base.replace(/\.tsx?$/, "");
       brands.push({
         name,
         file,
         relativeFile,
-        identifier: toIdentifier(`${name}-module`, "brands"),
+        // From the whole relative path, like previews: basenames repeat
+        // (`layout.tsx` beside `brands/layout.ts`), identifiers cannot.
+        identifier: toIdentifier(
+          `${relative(videosRoot, file).replace(/\.tsx?$/, "").split(sep).join("-")}-module`,
+          "brands",
+        ),
       });
     } else if (base.endsWith(".preview.tsx")) {
       const name = base.replace(/\.preview\.tsx$/, "");
@@ -147,7 +218,12 @@ export const discoverProject = async (config: ResolvedConfig): Promise<ProjectGr
     }
   }
 
-  return {videos, previews, brands, audio, sourceHash: hashString(hashParts.join("|"))};
+  for (const preview of previews) {
+    const users = importedBy[preview.name];
+    if (users) preview.usedBy = [...users].sort();
+  }
+
+  return {videos, previews, brands, audio, categories, sourceHash: hashString(hashParts.join("|"))};
 };
 
 /**
@@ -203,7 +279,11 @@ export const writeGenerated = async (config: ResolvedConfig, graph: ProjectGraph
       {
         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})),
+        previews: graph.previews.map((preview) => ({
+          name: preview.name,
+          file: preview.relativeFile,
+          usedBy: preview.usedBy ?? [],
+        })),
         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})),
       },

package/src/formats.ts

@@ -11,6 +11,29 @@
  * concatenated without re-encoding. `chunked: false` says a format has to be
  * encoded in one pass, which is slower and correct.
  */
+/** Compression tiers, named for where the file is going. */
+export type Quality = "studio" | "social" | "web";
+
+export const QUALITIES: Quality[] = ["studio", "social", "web"];
+
+export type EncodeOptions = {
+  /** x264-style speed preset. Orthogonal to quality: it trades time, not pixels. */
+  preset: string;
+  /** Compression tier. Codecs that are already lossless or mandated ignore it. */
+  quality: Quality;
+  /** Output scale multiplier. 1 is the composition's own size. */
+  scale: number;
+};
+
+/**
+ * A scale filter that lands on even dimensions, which yuv420p requires.
+ * Lanczos, because a product video is text and lines more than it is grain.
+ */
+const scaleFilter = (scale: number): string =>
+  `scale=trunc(iw*${scale}/2)*2:trunc(ih*${scale}/2)*2:flags=lanczos`;
+
+const scaleArgs = (scale: number): string[] => (scale === 1 ? [] : ["-vf", scaleFilter(scale)]);
+
 export type VideoFormat = {
   name: string;
   extension: string;
@@ -20,8 +43,8 @@ export type VideoFormat = {
   chunked: boolean;
   /** Whether the container carries an audio track at all. */
   audio: boolean;
-  /** FFmpeg arguments for the video stream, given the requested preset. */
-  args: (preset: string) => string[];
+  /** FFmpeg arguments for the video stream. */
+  args: (options: EncodeOptions) => string[];
   description: string;
 };
 
@@ -33,7 +56,17 @@ export const FORMATS: Record<string, VideoFormat> = {
     chunked: true,
     audio: true,
     description: "H.264 in MP4. Plays everywhere; the default.",
-    args: (preset) => ["-c:v", "libx264", "-crf", "17", "-preset", preset, "-pix_fmt", "yuv420p"],
+    args: ({preset, quality, scale}) => [
+      ...scaleArgs(scale),
+      "-c:v",
+      "libx264",
+      "-crf",
+      {studio: "17", social: "21", web: "27"}[quality],
+      "-preset",
+      preset,
+      "-pix_fmt",
+      "yuv420p",
+    ],
   },
   webm: {
     name: "webm",
@@ -43,7 +76,19 @@ export const FORMATS: Record<string, VideoFormat> = {
     chunked: true,
     audio: true,
     description: "VP9 in WebM, with alpha. For the web, and for overlays.",
-    args: () => ["-c:v", "libvpx-vp9", "-crf", "24", "-b:v", "0", "-pix_fmt", "yuva420p", "-row-mt", "1"],
+    args: ({quality, scale}) => [
+      ...scaleArgs(scale),
+      "-c:v",
+      "libvpx-vp9",
+      "-crf",
+      {studio: "24", social: "31", web: "38"}[quality],
+      "-b:v",
+      "0",
+      "-pix_fmt",
+      "yuva420p",
+      "-row-mt",
+      "1",
+    ],
   },
   prores: {
     name: "prores",
@@ -52,7 +97,19 @@ export const FORMATS: Record<string, VideoFormat> = {
     chunked: true,
     audio: true,
     description: "ProRes 4444 in MOV, with alpha. For handing to an editor.",
-    args: () => ["-c:v", "prores_ks", "-profile:v", "4444", "-pix_fmt", "yuva444p10le", "-alpha_bits", "8"],
+    // Quality is the profile here, and the profile is the point: an editor
+    // format that quietly compressed would defeat its own reason to exist.
+    args: ({scale}) => [
+      ...scaleArgs(scale),
+      "-c:v",
+      "prores_ks",
+      "-profile:v",
+      "4444",
+      "-pix_fmt",
+      "yuva444p10le",
+      "-alpha_bits",
+      "8",
+    ],
   },
   gif: {
     name: "gif",
@@ -63,9 +120,11 @@ export const FORMATS: Record<string, VideoFormat> = {
     chunked: false,
     audio: false,
     description: "An animated GIF, palette optimised. Silent, by the format.",
-    args: () => [
+    // The palette pass is a filter graph already, so scaling joins it rather
+    // than adding a second -vf that ffmpeg would silently drop.
+    args: ({scale}) => [
       "-vf",
-      "split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=3",
+      `${scale === 1 ? "" : `${scaleFilter(scale)},`}split[a][b];[a]palettegen=stats_mode=diff[p];[b][p]paletteuse=dither=bayer:bayer_scale=3`,
       "-loop",
       "0",
     ],
@@ -77,7 +136,7 @@ export const FORMATS: Record<string, VideoFormat> = {
     chunked: false,
     audio: false,
     description: "A numbered PNG sequence, with alpha. For a compositor.",
-    args: () => ["-c:v", "png", "-pix_fmt", "rgba"],
+    args: ({scale}) => [...scaleArgs(scale), "-c:v", "png", "-pix_fmt", "rgba"],
   },
 };
 

package/src/index.ts

@@ -46,7 +46,7 @@ export {clearPrepareCache, prepareCacheKey, readPrepareCache, writePrepareCache}
 export {devCommand} from "./commands/dev";
 export {cancelJob, exportCommand, jobsCommand, runJob, exportQueue} from "./commands/exportVideo";
 export {chunkFrames, planChunks, type ChunkPlan, type FrameChunk} from "./chunks";
-export {stillCommand} from "./commands/still";
+export {frameCommand} from "./commands/frame";
 export {testCommand} from "./commands/test";
 export {listCommand} from "./commands/list";
 export {inspectCommand} from "./commands/inspect";

package/src/jobs.ts

@@ -4,7 +4,10 @@ import {join, resolve} from "node:path";
 import type {ExportJob, RenderManifest} from "odori";
 import type {ResolvedConfig} from "./config";
 
-export type JobRecord = {job: ExportJob; manifest: RenderManifest; output: string};
+/** How a job should be encoded, frozen with it so a retry cannot drift. */
+export type JobRender = {format?: string; quality?: string; scale?: number; preset?: string};
+
+export type JobRecord = {job: ExportJob; manifest: RenderManifest; output: string; render?: JobRender};
 
 const buildsDir = (config: ResolvedConfig) => resolve(config.root, config.outDir, "builds");
 const jobFile = (config: ResolvedConfig, id: string) => join(buildsDir(config), `${id}.json`);
@@ -17,6 +20,7 @@ export const createJob = async (
   config: ResolvedConfig,
   manifest: RenderManifest,
   output: string,
+  render?: JobRender,
 ): Promise<JobRecord> => {
   await mkdir(buildsDir(config), {recursive: true});
   const now = new Date().toISOString();
@@ -31,7 +35,7 @@ export const createJob = async (
     createdAt: now,
     updatedAt: now,
   };
-  const record: JobRecord = {job, manifest, output};
+  const record: JobRecord = {job, manifest, output, ...(render ? {render} : {})};
   await writeFile(jobFile(config, job.id), `${JSON.stringify(record, null, 2)}\n`, "utf8");
   return record;
 };