@odori/cli 0.0.7 → 0.0.8

package/dist/cli.js

@@ -2,7 +2,7 @@ import {
   checkFlags,
   parseArgs,
   run
-} from "./chunk-STVORYOF.js";
+} from "./chunk-UPYHTDXP.js";
 export {
   checkFlags,
   parseArgs,

package/dist/index.d.ts

@@ -49,6 +49,13 @@ type OdoriConfig = {
     skipUnchangedFrames?: boolean;
     /** Reuse encoded chunks whose frames still look identical. Defaults to true. */
     cacheChunks?: boolean;
+    /**
+     * Default providers for `--generate`, by kind. The choice is committed like
+     * every other decision; the keys never are.
+     */
+    generation?: {
+        music?: string;
+    };
 };
 declare const resolveChromePath: (configured?: string) => string | undefined;
 type ResolvedConfig = OdoriConfig & {
@@ -251,15 +258,50 @@ type RenderTarget = {
         durationInFrames: number;
     }>;
 };
+/**
+ * Which graphics backend the render browser draws with.
+ *
+ * Not a menu of backend names. Remotion offers angle, swangle, egl, vulkan and
+ * two more, and the author has to learn ANGLE's taxonomy and then guess. The
+ * only question worth asking is whether this render is the artifact or a look
+ * at it, so that is the only question asked.
+ *
+ * `software` is ANGLE's SwiftShader: the same pixels on every machine, which
+ * is what a cache, a parallel render and a byte-for-byte test all depend on.
+ * `gpu` uses whatever the machine has.
+ *
+ * Measured on this pipeline at 1080p, 60 frames, frame skip off, and the
+ * reason both exist:
+ *
+ *   five full-screen post-processing passes   86ms software   81ms gpu
+ *   a raymarch that exits early on most rays  46ms software   38ms gpu
+ *   1500 fixed iterations, no early exit     507ms software   37ms gpu
+ *
+ * The GPU sits at under 40ms whatever the shader, because it is still waiting
+ * on the DOM capture and the encode rather than on itself. Software tracks the
+ * shader. So for post-processing the choice is worth nothing, and for work
+ * that is genuinely per-pixel expensive it is worth fourteen times, which is
+ * the difference between iterating and not.
+ */
+type Graphics = "software" | "gpu";
 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 openRenderPage: (origin: string, target: RenderTarget, config: ResolvedConfig, graphics?: Graphics) => Promise<RenderPage>;
+/**
+ * Seek through the readiness handshake instead of guessing with timeouts.
+ *
+ * A frame that throws never publishes its marker, so the wait runs out and
+ * Playwright reports that a selector did not appear, which says nothing about
+ * why. The page errors gathered since the mount are the actual answer, and
+ * passing them in is the difference between "locator timed out" and the name
+ * of the function that threw. One malformed interpolate() call cost an
+ * afternoon to a message that had already been collected and thrown away.
+ */
+declare const seekTo: (page: Page, frame: number, errors?: string[]) => Promise<void>;
 declare const readTimeline: (page: Page) => Promise<odori.CompiledTimeline | {
     scenes: never[];
     durationInFrames: number;
@@ -268,7 +310,7 @@ 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 renderStill: (origin: string, target: RenderTarget, frame: number, output: string, config: ResolvedConfig, graphics?: Graphics) => Promise<string>;
 declare const defaultConcurrency: () => number;
 type RenderProgress = (progress: number, stage: "rendering" | "encoding") => void;
 type RenderTimings = {
@@ -290,6 +332,8 @@ type RenderOptions = {
     /** Container and codec. Defaults to H.264 in MP4. */
     format?: VideoFormat;
     skipUnchangedFrames?: boolean;
+    /** Which graphics backend draws the frames. Defaults to software. */
+    graphics?: Graphics;
     /**
      * Mix the composition's cues into the file. Defaults to true, because the
      * score is part of the video. Set false for a silent cut: a loop for a
@@ -345,6 +389,7 @@ type JobRender = {
     scale?: number;
     preset?: string;
     audio?: boolean;
+    graphics?: string;
 };
 type JobRecord = {
     job: ExportJob;
@@ -547,6 +592,7 @@ declare const runJob: (config: ResolvedConfig, origin: string, record: JobRecord
     scale?: number;
     format?: VideoFormat;
     audio?: boolean;
+    graphics?: Graphics;
     skipUnchangedFrames?: boolean;
     signal?: AbortSignal;
     onProgress?: (job: ExportJob) => void;
@@ -561,6 +607,8 @@ declare const exportCommand: (id: string, options?: {
     format?: string;
     /** False writes the picture with no audio track. */
     audio?: boolean;
+    /** True draws on the machine's GPU instead of the reproducible backend. */
+    fast?: boolean;
     skipUnchangedFrames?: boolean;
     retry?: string;
 }) => Promise<ExportJob>;

package/dist/index.js

@@ -75,7 +75,7 @@ import {
   withServer,
   writeGenerated,
   writePrepareCache
-} from "./chunk-STVORYOF.js";
+} from "./chunk-UPYHTDXP.js";
 export {
   CHROME_BUILD,
   FORMATS,