@odori/cli 0.0.2

package/dist/cli.d.ts

@@ -0,0 +1,10 @@
+type Flags = Record<string, string | boolean>;
+declare const parseArgs: (argv: string[]) => {
+    command: string;
+    positionals: string[];
+    flags: Flags;
+};
+declare const checkFlags: (command: string, flags: Flags) => void;
+declare const run: (argv: string[]) => Promise<number>;
+
+export { checkFlags, parseArgs, run };

package/dist/cli.js

@@ -0,0 +1,10 @@
+import {
+  checkFlags,
+  parseArgs,
+  run
+} from "./chunk-7XJL2BYO.js";
+export {
+  checkFlags,
+  parseArgs,
+  run
+};

package/dist/index.d.ts

@@ -0,0 +1,622 @@
+import { ViteDevServer } from 'vite';
+import * as odori from 'odori';
+import { VideoEntry, RenderManifest, AudioCue, ManifestAudioCue, ExportJob } from 'odori';
+import { Browser, Page } from 'playwright-core';
+export { parseArgs, run } from './cli.js';
+
+type OdoriConfig = {
+    /** Source root that contains video entries and video components. */
+    videosDir: string;
+    /** Generated output directory. Never edited or committed. */
+    outDir: string;
+    /** Where exports are written. */
+    exportDir: string;
+    /** Registry components are copied here. */
+    componentsDir: string;
+    /** Audio library, discovered so Studio can list and audition it. Served from public/. */
+    audioDir: string;
+    /** Studio dev server port. */
+    port: number;
+    /** Where Studio's docs link points. Defaults to the hosted docs site. */
+    docsUrl: string;
+    /** Open Studio in the default browser when `odori dev` starts. */
+    open?: boolean;
+    /** Chrome or Chromium executable used by the render worker. */
+    chromePath?: string;
+    /**
+     * FFmpeg executable used to encode. Set it to pin a build; leave it and
+     * Odori uses its own managed copy, which is what keeps two machines
+     * producing the same file.
+     */
+    ffmpegPath?: string;
+    /** Static asset references available to every video. */
+    assets?: Array<{
+        reference: string;
+        url: string;
+    }>;
+    /** Parallel render workers. Defaults to the machine's spare cores, capped at four. */
+    concurrency?: number;
+    /** x264 preset for exports. Defaults to medium. */
+    preset?: string;
+    /** Default container and codec: mp4, webm, prores, gif, or png. */
+    format?: string;
+    /**
+     * Where `odori add` fetches components from. Point it at a fork, a mirror,
+     * or a pinned version; `ODORI_REGISTRY` overrides it for one command.
+     */
+    registryUrl?: string;
+    /** Reuse the previous frame when the rendered picture is unchanged. Defaults to true. */
+    skipUnchangedFrames?: boolean;
+    /** Reuse encoded chunks whose frames still look identical. Defaults to true. */
+    cacheChunks?: boolean;
+};
+declare const resolveChromePath: (configured?: string) => string | undefined;
+type ResolvedConfig = OdoriConfig & {
+    root: string;
+    configPath?: string;
+};
+declare const loadConfig: (root: string) => Promise<ResolvedConfig>;
+declare const defineConfig: (config: Partial<OdoriConfig>) => Partial<OdoriConfig>;
+
+type DiscoveredVideo = {
+    /** Directory-derived id used before the module is loaded. */
+    slug: string;
+    file: string;
+    relativeFile: string;
+    importPath: string;
+    identifier: string;
+};
+type DiscoveredPreview = {
+    name: string;
+    file: string;
+    relativeFile: string;
+    importPath: string;
+    identifier: string;
+};
+type DiscoveredBrandModule = {
+    name: string;
+    file: string;
+    relativeFile: string;
+    identifier: string;
+};
+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;
+};
+type ProjectGraph = {
+    videos: DiscoveredVideo[];
+    previews: DiscoveredPreview[];
+    brands: DiscoveredBrandModule[];
+    audio: DiscoveredAudio[];
+    sourceHash: string;
+};
+/**
+ * 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.
+ */
+declare const discoverProject: (config: ResolvedConfig) => Promise<ProjectGraph>;
+/**
+ * Static imports keep the module graph compatible with Next.js, tests,
+ * browsers, and Node render workers.
+ */
+declare const generateImports: (graph: ProjectGraph, outDir: string) => string;
+declare const writeGenerated: (config: ResolvedConfig, graph: ProjectGraph) => Promise<string>;
+
+type StudioServer = {
+    vite: ViteDevServer;
+    url: string;
+    graph: ProjectGraph;
+    close(): Promise<void>;
+};
+declare const startStudioServer: (initialConfig: ResolvedConfig, options?: {
+    port?: number;
+    strictPort?: boolean;
+    middleware?: (server: ViteDevServer) => void;
+}) => Promise<StudioServer>;
+
+/**
+ * Video ids are paths under `videos/`; files on disk are flat.
+ *
+ * Two encodings, deliberately different. An output file is something a person
+ * hands to someone else, so `social/announcement` becomes the readable
+ * `social-announcement`. A cache file is addressed, not read, so it encodes
+ * the separator instead of replacing it: `social+announcement` cannot collide
+ * with a video genuinely named `social-announcement`.
+ */
+declare const outputName: (id: string) => string;
+declare const fileKey: (id: string) => string;
+
+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.
+ */
+declare const loadVideos: (graph: ProjectGraph) => Promise<LoadedVideo[]>;
+
+declare const findVideo: (videos: LoadedVideo[], id: string) => LoadedVideo;
+/**
+ * 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.
+ */
+declare const runPrepare: (video: LoadedVideo, config: ResolvedConfig, graph: ProjectGraph, input: Record<string, unknown>, options?: {
+    refresh?: boolean;
+}) => Promise<unknown>;
+type FreezeOptions = {
+    scenes?: RenderManifest["scenes"];
+    audio?: AudioCue[];
+    refreshPrepare?: boolean;
+};
+declare const freezeManifest: (video: LoadedVideo, graph: ProjectGraph, config: ResolvedConfig, rawInput: Record<string, unknown>, options?: FreezeOptions) => Promise<{
+    manifest: RenderManifest;
+    input: Record<string, unknown>;
+    prepared: unknown;
+}>;
+
+/**
+ * What an export can produce.
+ *
+ * One codec is enough until it is not: an overlay needs an alpha channel that
+ * H.264 cannot carry, an editor wants ProRes, a README wants a GIF, and a
+ * thumbnail sheet wants frames. Each of those is a different container and a
+ * different pixel format, so the choice belongs in one table rather than in a
+ * flag that quietly means five things.
+ *
+ * Chunked capture is how a render stays fast, and only some codecs can be
+ * concatenated without re-encoding. `chunked: false` says a format has to be
+ * encoded in one pass, which is slower and correct.
+ */
+type VideoFormat = {
+    name: string;
+    extension: string;
+    /** Whether the codec supports an alpha channel. */
+    alpha: boolean;
+    /** Whether chunks can be joined with a stream copy. */
+    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[];
+    description: string;
+};
+declare const FORMATS: Record<string, VideoFormat>;
+declare const formatNames: () => string[];
+/**
+ * The format for an export.
+ *
+ * An explicit `--format` wins. Otherwise the output's extension decides, so
+ * `--output cut.webm` does what it looks like it does rather than writing
+ * H.264 into a file named `.webm`.
+ */
+declare const resolveFormat: (requested: string | undefined, output: string | undefined) => VideoFormat;
+/**
+ * Whether a composition's transparency can survive into the file.
+ *
+ * A video with a transparent background exported to MP4 is not an error, it is
+ * a black rectangle — the alpha is composited away by the pixel format. Worth
+ * saying out loud at the point the choice is made.
+ */
+declare const alphaWarning: (format: VideoFormat, transparent: boolean) => string | null;
+
+type RenderTarget = {
+    videoId: string;
+    width: number;
+    height: number;
+    fps: number;
+    durationInFrames: number;
+    input?: Record<string, unknown>;
+    prepared?: unknown;
+    audio?: ManifestAudioCue[];
+    targetLufs?: number;
+    scenes?: Array<{
+        id: string;
+        start: number;
+        durationInFrames: number;
+    }>;
+};
+type RenderPage = {
+    browser: Browser;
+    page: Page;
+    errors: string[];
+};
+/** Open one video in render mode and wait for its first frame to mount. */
+declare const openRenderPage: (origin: string, target: RenderTarget, config: ResolvedConfig) => Promise<RenderPage>;
+/** Seek through the readiness handshake instead of guessing with timeouts. */
+declare const seekTo: (page: Page, frame: number) => Promise<void>;
+declare const readTimeline: (page: Page) => Promise<odori.CompiledTimeline>;
+declare const readAudio: (page: Page) => Promise<odori.AudioTrack>;
+declare const probeSignatures: (page: Page, frames: number[]) => Promise<string[]>;
+/** Kept for callers that only want to know an encoder exists. */
+declare const ensureFfmpeg: (config: ResolvedConfig) => Promise<void>;
+declare const renderStill: (origin: string, target: RenderTarget, frame: number, output: string, config: ResolvedConfig) => Promise<string>;
+declare const defaultConcurrency: () => number;
+type RenderProgress = (progress: number, stage: "rendering" | "encoding") => void;
+type RenderTimings = {
+    captureMs: number;
+    encodeMs: number;
+    frames: number;
+    reusedFrames: number;
+    cachedChunks: number;
+    chunks: number;
+    concurrency: number;
+};
+type RenderOptions = {
+    concurrency?: number;
+    preset?: string;
+    /** Container and codec. Defaults to H.264 in MP4. */
+    format?: VideoFormat;
+    skipUnchangedFrames?: boolean;
+    /** Reuse encoded chunks whose frames still look identical. */
+    cache?: boolean;
+    signal?: AbortSignal;
+    /** Where frames and chunk files are written. Defaults to the generated directory. */
+    workDir?: string;
+    onTimings?: (timings: RenderTimings) => void;
+};
+declare const renderMovie: (origin: string, target: RenderTarget, output: string, config: ResolvedConfig, onProgress?: RenderProgress, options?: RenderOptions) => Promise<string>;
+
+type Context = {
+    config: ResolvedConfig;
+    graph: ProjectGraph;
+    videos: LoadedVideo[];
+};
+declare const createContext: (root?: string) => Promise<Context>;
+declare const targetFor: (video: LoadedVideo, input?: Record<string, unknown>, prepared?: unknown, audio?: ManifestAudioCue[], scenes?: Array<{
+    id: string;
+    start: number;
+    durationInFrames: number;
+}>) => RenderTarget;
+/**
+ * `metadata.duration` is authoritative. When it is absent, the compiled
+ * timeline reported by the runtime is used instead.
+ */
+type CompileResult = {
+    durationInFrames: number;
+    scenes: Array<{
+        id: string;
+        start: number;
+        durationInFrames: number;
+    }>;
+    audio: AudioCue[];
+};
+/**
+ * Compile the timeline and the audio track in the browser, where the runtime
+ * already knows how to lay both out. `metadata.duration` stays authoritative
+ * when it is declared.
+ */
+declare const compileInBrowser: (origin: string, target: RenderTarget, config: ResolvedConfig) => Promise<CompileResult>;
+declare const withServer: <Value>(config: ResolvedConfig, handler: (server: StudioServer) => Promise<Value>) => Promise<Value>;
+
+type JobRecord = {
+    job: ExportJob;
+    manifest: RenderManifest;
+    output: string;
+};
+/**
+ * An export job records the frozen manifest, progress, attempts, and result,
+ * so a retry reuses the approved inputs instead of resolving them again.
+ */
+declare const createJob: (config: ResolvedConfig, manifest: RenderManifest, output: string) => Promise<JobRecord>;
+declare const readJob: (config: ResolvedConfig, id: string) => Promise<JobRecord>;
+declare const updateJob: (config: ResolvedConfig, job: ExportJob) => Promise<ExportJob>;
+declare const appendJobLog: (config: ResolvedConfig, id: string, message: string) => Promise<ExportJob>;
+/**
+ * A killed process leaves its job claiming to be rendering forever. Anything
+ * that reads job state reconciles first, so `odori jobs` never reports a lie.
+ */
+declare const reconcileJobs: (config: ResolvedConfig) => Promise<number>;
+declare const listJobs: (config: ResolvedConfig, options?: {
+    reconcile?: boolean;
+}) => Promise<ExportJob[]>;
+/**
+ * A single-lane queue.
+ *
+ * Rendering saturates the machine's cores already, so jobs run one at a time
+ * in submission order. The queue is a promise chain rather than a daemon, which
+ * keeps `odori export` and the Studio export button on exactly the same path.
+ */
+declare class JobQueue {
+    private chain;
+    enqueue<Value>(task: () => Promise<Value>): Promise<Value>;
+}
+
+type MixInput = {
+    file: string;
+    cue: ManifestAudioCue;
+};
+/**
+ * Resolve a cue source to a local file. Sources are project-relative or
+ * public-relative paths, which is what the dev server and the render worker
+ * both serve.
+ */
+declare const resolveCueFile: (config: ResolvedConfig, src: string) => string | null;
+declare const buildAudioFilter: (inputs: MixInput[], options: {
+    fps: number;
+    durationInFrames: number;
+    targetLufs: number;
+}) => {
+    filter: string;
+    label: string;
+};
+
+type DeterminismFinding = {
+    file: string;
+    line: number;
+    source: string;
+    message: string;
+};
+/**
+ * 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.
+ */
+declare const checkDeterminism: (config: ResolvedConfig) => Promise<DeterminismFinding[]>;
+
+/**
+ * The two programs a render actually runs.
+ *
+ * Both are pinned. A video is supposed to be reproducible from its source, and
+ * that promise is only as good as the software that draws and encodes it: a
+ * different Chrome lays out text a fraction differently, and a different
+ * FFmpeg build can be compiled with different defaults. A machine that resolves
+ * "whatever is installed" produces frames that are almost the same, which is
+ * the worst kind of difference — invisible in review, present in the file.
+ *
+ * So Odori manages its own copies, keyed by version, in a cache outside the
+ * project. Local and cloud converge on the same bytes because they download
+ * the same bytes.
+ */
+/** Chrome build the runtime is exercised against. Changing it changes frames. */
+declare const CHROME_BUILD = "131.0.6778.204";
+type BinaryOrigin = "configured" | "environment" | "managed" | "package" | "system";
+type ResolvedBinary = {
+    path: string;
+    origin: BinaryOrigin;
+    /** Pinned version for managed copies; whatever the host has otherwise. */
+    version: string;
+};
+/**
+ * Where managed binaries live. Outside the project on purpose: one download
+ * serves every project on the machine, and a `node_modules` wipe does not cost
+ * a 150 MB round trip. `ODORI_CACHE` moves it, which is what a CI cache key or
+ * a Docker layer wants.
+ */
+declare const cacheRoot: () => string;
+/**
+ * Chrome, in the order a reader would guess: what the project configured, what
+ * the environment overrode, the managed copy, then whatever the machine has.
+ *
+ * The system fallback is last and deliberate. It keeps a machine that already
+ * has Chrome working with no download, and `odori doctor` says which one was
+ * used so an unexplained difference between two renders has somewhere to start.
+ */
+declare const resolveBrowser: (config: ResolvedConfig) => Promise<ResolvedBinary | null>;
+declare const resolveFfmpeg: (config: ResolvedConfig) => Promise<ResolvedBinary | null>;
+/**
+ * Download the pinned Chrome if it is not already cached.
+ *
+ * `chrome-headless-shell` rather than full Chrome: it is the build made for
+ * exactly this — rendering frames with no window, no profile, and no updater —
+ * and it is a third of the download.
+ */
+declare const installBrowser: (options?: {
+    onProgress?: (fraction: number) => void;
+}) => Promise<string>;
+/**
+ * Download the pinned FFmpeg if it is not already cached.
+ *
+ * The static build is fetched through its own package rather than from a URL
+ * we maintain, so the platform matrix and the checksums stay somebody else's
+ * job. It runs here instead of at install time because package managers now
+ * block install scripts by default, and a binary that only arrives when a
+ * postinstall is allowed is a binary that is missing on half of all machines.
+ */
+declare const installFfmpeg: () => Promise<string>;
+/**
+ * What a render will use, as a line of provenance.
+ *
+ * This goes in the manifest. Two renders of the same source that differ are
+ * either a bug or a different toolchain, and without this there is no way to
+ * tell which from the artefacts alone.
+ */
+declare const renderToolchain: (config: ResolvedConfig) => Promise<{
+    chrome: string;
+    chromeOrigin: BinaryOrigin | "missing";
+    ffmpeg: string;
+    ffmpegOrigin: BinaryOrigin | "missing";
+}>;
+
+/** Local candidates for a project-relative or public-relative URL. */
+declare const localCandidates: (config: ResolvedConfig, url: string) => string[];
+/**
+ * Content addressing for everything a render depends on.
+ *
+ * Local files hash their bytes. Remote files are fetched once and cached by
+ * URL, so a manifest stays comparable across runs without refetching on every
+ * export. A source that cannot be read is recorded as unresolved rather than
+ * silently pretending to be verified.
+ */
+declare const createIntegrityResolver: (config: ResolvedConfig) => Promise<{
+    resolve: (url: string) => Promise<string>;
+    flush: () => Promise<void>;
+}>;
+
+type PrepareCacheKey = {
+    videoId: string;
+    sourceHash: string;
+    input: unknown;
+    version: string;
+    dependencies?: unknown;
+};
+/**
+ * Prepared data is cached by video source hash, validated input, prepare
+ * version, and declared dependencies. Changing scene styling does not refetch
+ * source data, and changing a data dependency invalidates deterministically.
+ */
+declare const prepareCacheKey: (key: PrepareCacheKey) => string;
+declare const readPrepareCache: (config: ResolvedConfig, key: PrepareCacheKey) => Promise<{
+    hit: boolean;
+    value: unknown;
+}>;
+declare const writePrepareCache: (config: ResolvedConfig, key: PrepareCacheKey, value: unknown) => Promise<void>;
+/** Remove cached preparations for a video, or for the whole project. */
+declare const clearPrepareCache: (config: ResolvedConfig, videoId?: string) => Promise<number>;
+
+/**
+ * Studio previews without encoding. These endpoints exist so an explicit
+ * export action in the browser reaches the same queue and render worker the
+ * CLI uses.
+ */
+declare const devCommand: (options?: {
+    port?: number;
+    root?: string;
+    open?: boolean;
+}) => Promise<StudioServer>;
+
+declare const exportQueue: JobQueue;
+declare const cancelJob: (id: string) => boolean;
+/**
+ * Run one recorded job. Retries reuse the frozen manifest, so a failed export
+ * never silently re-resolves data or reruns prepare.
+ */
+declare const runJob: (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>;
+declare const exportCommand: (id: string, options?: {
+    output?: string;
+    input?: Record<string, unknown>;
+    concurrency?: number;
+    preset?: string;
+    format?: string;
+    skipUnchangedFrames?: boolean;
+    retry?: string;
+}) => Promise<ExportJob>;
+declare const jobsCommand: () => Promise<void>;
+
+type FrameChunk = {
+    index: number;
+    start: number;
+    end: number;
+    sceneId?: string;
+};
+type ChunkPlan = {
+    chunks: FrameChunk[];
+    lanes: FrameChunk[][];
+};
+type PlanOptions = {
+    durationInFrames: number;
+    scenes?: Array<{
+        id: string;
+        start: number;
+        durationInFrames: number;
+    }>;
+    concurrency: number;
+    /** Scenes longer than this are split so one long scene cannot own a worker. */
+    maxChunkFrames?: number;
+};
+/**
+ * Split a timeline into contiguous chunks, then deal them out to workers.
+ *
+ * Chunks follow scene boundaries because a scene is the unit the runtime
+ * already names, which is what lets a chunk be encoded on its own, cached, or
+ * rendered on another machine. Long scenes are split so a single expensive
+ * scene cannot pin one worker while the others idle.
+ */
+declare const planChunks: ({ durationInFrames, scenes, concurrency, maxChunkFrames, }: PlanOptions) => ChunkPlan;
+declare const chunkFrames: (chunk: FrameChunk) => number[];
+
+declare const stillCommand: (id: string, options?: {
+    frame?: number;
+    output?: string;
+    input?: Record<string, unknown>;
+}) => Promise<string>;
+
+declare const testCommand: (id?: string, options?: {
+    json?: boolean;
+}) => Promise<void>;
+
+declare const listCommand: () => Promise<void>;
+
+declare const inspectCommand: (id: string, options?: {
+    json?: boolean;
+    input?: Record<string, unknown>;
+}) => Promise<void>;
+
+/**
+ * Installation copies source into the project. Provenance is recorded so the
+ * CLI can report upstream changes, but a locally modified component is never
+ * replaced without an explicit decision.
+ */
+declare const addCommand: (names: string[], options?: {
+    force?: boolean;
+    dryRun?: boolean;
+}) => Promise<void>;
+
+type ComponentState = "pristine" | "modified" | "outdated" | "diverged" | "missing";
+type ComponentStatus = {
+    name: string;
+    state: ComponentState;
+    files: Array<{
+        file: string;
+        localPath: string;
+        /** Upstream source itself. The registry is documents now, not a directory. */
+        content: string;
+        local: string | null;
+        installed: string | null;
+        upstream: string;
+    }>;
+};
+/**
+ * Compare installed component source with the version that was installed and
+ * with the version the registry ships today.
+ *
+ * - pristine: identical everywhere
+ * - modified: the project edited it, upstream has not moved
+ * - outdated: upstream moved, the project did not edit it
+ * - diverged: both moved, so an update would overwrite local work
+ */
+declare const componentStatus: (config: ResolvedConfig, only?: string[]) => Promise<ComponentStatus[]>;
+declare const diffCommand: (names: string[], options?: {
+    full?: boolean;
+}) => Promise<void>;
+declare const updateCommand: (names: string[], options?: {
+    force?: boolean;
+}) => Promise<void>;
+
+type DiffLine = {
+    type: "context" | "add" | "remove";
+    text: string;
+};
+declare const diffLines: (before: string, after: string) => DiffLine[];
+declare const countChanges: (lines: DiffLine[]) => {
+    added: number;
+    removed: number;
+};
+/** Collapse unchanged runs so a small edit does not print the whole file. */
+declare const formatDiff: (lines: DiffLine[], context?: number) => string[];
+
+declare const newCommand: (name: string, options?: {
+    blank?: boolean;
+}) => Promise<void>;
+
+/** Add the videos source root and configuration to an existing project. */
+declare const initCommand: (root?: string) => Promise<void>;
+
+export { CHROME_BUILD, type ChunkPlan, type CompileResult, type ComponentStatus, type Context, type DeterminismFinding, type DiffLine, FORMATS, type FrameChunk, JobQueue, type JobRecord, type LoadedVideo, type MixInput, type OdoriConfig, type ProjectGraph, type RenderOptions, type RenderTarget, type RenderTimings, type ResolvedBinary, type ResolvedConfig, type StudioServer, type VideoFormat, addCommand, alphaWarning, appendJobLog, buildAudioFilter, cacheRoot, cancelJob, checkDeterminism, chunkFrames, clearPrepareCache, compileInBrowser, componentStatus, countChanges, createContext, createIntegrityResolver, createJob, defaultConcurrency, defineConfig, devCommand, diffCommand, diffLines, discoverProject, ensureFfmpeg, exportCommand, exportQueue, fileKey, findVideo, formatDiff, formatNames, freezeManifest, generateImports, initCommand, inspectCommand, installBrowser, installFfmpeg, jobsCommand, listCommand, listJobs, loadConfig, loadVideos, localCandidates, newCommand, openRenderPage, outputName, planChunks, prepareCacheKey, probeSignatures, readAudio, readJob, readPrepareCache, readTimeline, reconcileJobs, renderMovie, renderStill, renderToolchain, resolveBrowser, resolveChromePath, resolveCueFile, resolveFfmpeg, resolveFormat, runJob, runPrepare, seekTo, startStudioServer, stillCommand, targetFor, testCommand, updateCommand, updateJob, withServer, writeGenerated, writePrepareCache };