@odori/cli 0.0.2

package/src/project.ts

@@ -0,0 +1,196 @@
+import {resolve} from "node:path";
+import {pathToFileURL} from "node:url";
+import {
+  createRenderManifest,
+  entryDurationInFrames,
+  resolveEntryLayout,
+  resolveVideoId,
+  type AudioCue,
+  type ManifestAudioCue,
+  type RenderManifest,
+  type VideoEntry,
+} from "odori";
+import type {ResolvedConfig} from "./config";
+import type {ProjectGraph} from "./discovery";
+import {createIntegrityResolver} from "./integrity";
+import {readPrepareCache, writePrepareCache} from "./prepare-cache";
+import {log} from "./log";
+import {renderToolchain} from "./binaries";
+
+export type LoadedVideo = {
+  entry: VideoEntry;
+  file: string;
+  relativeFile: string;
+  durationInFrames: number;
+};
+
+/**
+ * Load discovered entries in Node so the CLI can inspect metadata, validate
+ * inputs, and freeze a manifest without opening a browser.
+ */
+export const loadVideos = async (graph: ProjectGraph): Promise<LoadedVideo[]> => {
+  const loaded: LoadedVideo[] = [];
+  for (const discovered of graph.videos) {
+    const module = (await import(pathToFileURL(discovered.file).href)) as {
+      default?: VideoEntry["component"];
+      metadata?: VideoEntry["metadata"];
+    };
+    if (!module.default || !module.metadata) {
+      throw new Error(`${discovered.relativeFile} must export metadata and a default React component.`);
+    }
+    const entry: VideoEntry = {
+      component: module.default,
+      metadata: {...module.metadata, id: resolveVideoId(module.metadata.id, discovered.slug)},
+    };
+    loaded.push({
+      entry,
+      file: discovered.file,
+      relativeFile: discovered.relativeFile,
+      durationInFrames: entryDurationInFrames(entry, resolveEntryLayout(entry)),
+    });
+  }
+  const byId = new Map<string, string>();
+  for (const video of loaded) {
+    const id = video.entry.metadata.id;
+    const first = byId.get(id);
+    // Path-derived ids are unique by construction, so a collision here is
+    // always an explicit override pointing at another entry's id.
+    if (first) throw new Error(`Duplicate video id "${id}":\n  ${first}\n  ${video.relativeFile}`);
+    byId.set(id, video.relativeFile);
+  }
+  return loaded;
+};
+
+export {outputName} from "./paths";
+
+export const findVideo = (videos: LoadedVideo[], id: string): LoadedVideo => {
+  const found = videos.find((video) => video.entry.metadata.id === id);
+  if (!found) {
+    throw new Error(
+      `Unknown video "${id}". Known videos: ${videos.map((video) => video.entry.metadata.id).join(", ") || "none"}`,
+    );
+  }
+  return found;
+};
+
+/**
+ * Run prepare.ts beside a video entry, if it exists.
+ *
+ * Results are cached on disk by source hash, validated input, and prepare
+ * version, so repeated stills and exports of an approved cut do not refetch.
+ */
+export const runPrepare = async (
+  video: LoadedVideo,
+  config: ResolvedConfig,
+  graph: ProjectGraph,
+  input: Record<string, unknown>,
+  options: {refresh?: boolean} = {},
+): Promise<unknown> => {
+  const prepareFile = resolve(video.file, "..", "prepare.ts");
+  let prepare: {run(context: unknown): Promise<unknown>; version?: string} | undefined;
+
+  try {
+    const module = (await import(pathToFileURL(prepareFile).href)) as {
+      prepare?: {run(context: unknown): Promise<unknown>; version?: string};
+      default?: {run(context: unknown): Promise<unknown>; version?: string};
+    };
+    prepare = module.prepare ?? module.default;
+  } catch (error) {
+    if ((error as {code?: string}).code === "ERR_MODULE_NOT_FOUND") return undefined;
+    throw error;
+  }
+  if (!prepare) return undefined;
+
+  const key = {
+    videoId: video.entry.metadata.id,
+    sourceHash: graph.sourceHash,
+    input,
+    version: prepare.version ?? "1",
+  };
+
+  if (!options.refresh) {
+    const cached = await readPrepareCache(config, key);
+    if (cached.hit) return cached.value;
+  }
+
+  const memo = new Map<string, unknown>();
+  const value = await prepare.run({
+    input,
+    assets: {
+      resolve: async (reference: string) => {
+        const asset = (config.assets ?? []).find((item) => item.reference === reference);
+        if (!asset) throw new Error(`Unknown asset reference: ${reference}`);
+        return asset.url;
+      },
+    },
+    cache: {
+      getOrSet: async (cacheKey: string, factory: () => Promise<unknown>) => {
+        if (!memo.has(cacheKey)) memo.set(cacheKey, await factory());
+        return memo.get(cacheKey);
+      },
+    },
+  });
+
+  await writePrepareCache(config, key, value);
+  return value;
+};
+
+export type FreezeOptions = {
+  scenes?: RenderManifest["scenes"];
+  audio?: AudioCue[];
+  refreshPrepare?: boolean;
+};
+
+export const freezeManifest = async (
+  video: LoadedVideo,
+  graph: ProjectGraph,
+  config: ResolvedConfig,
+  rawInput: Record<string, unknown>,
+  options: FreezeOptions = {},
+): Promise<{manifest: RenderManifest; input: Record<string, unknown>; prepared: unknown}> => {
+  const layout = resolveEntryLayout(video.entry);
+  const merged = {...video.entry.metadata.defaultProps, ...rawInput};
+  const input = video.entry.metadata.schema
+    ? (video.entry.metadata.schema.parse(merged) as Record<string, unknown>)
+    : merged;
+  const prepared = await runPrepare(video, config, graph, input, {refresh: options.refreshPrepare});
+
+  const integrity = await createIntegrityResolver(config);
+  const assets = await Promise.all(
+    (config.assets ?? []).map(async (asset) => ({...asset, integrity: await integrity.resolve(asset.url)})),
+  );
+  const audio: ManifestAudioCue[] = await Promise.all(
+    (options.audio ?? []).map(async (cue) => ({...cue, integrity: await integrity.resolve(cue.src)})),
+  );
+  const fonts = await Promise.all(
+    layout.brand.fonts.map(async (font) => ({
+      family: font.family,
+      url: font.url,
+      integrity: await integrity.resolve(font.url),
+    })),
+  );
+  await integrity.flush();
+
+  for (const cue of audio) {
+    if (cue.integrity === "unresolved") log.warn(`Audio source could not be resolved for hashing: ${cue.src}`);
+  }
+
+  const manifest = createRenderManifest({
+    entry: video.entry,
+    layout,
+    input,
+    prepared,
+    sourceHash: graph.sourceHash,
+    durationInFrames: video.durationInFrames,
+    scenes: options.scenes ?? [],
+    audio,
+    assets,
+    fonts,
+    // Which Chrome drew it and which FFmpeg encoded it. Two files that differ
+    // are then a question with an answer rather than a mystery.
+    toolchain: await renderToolchain(config),
+    createdAt: new Date().toISOString(),
+  });
+
+  return {manifest, input, prepared};
+};