@koda-sl/baker-cli 0.384.0-dev.4699b7308 → 0.384.0-dev.557795bef

package/dist/engine/index.d.ts

@@ -28,8 +28,10 @@ type ExecResponse = {
 /** A resumable run as reported by `GET /api/canvas/runs/active`. */
 type ActiveRunInfo = {
     runId: string;
-    status: "running" | "completed" | "failed";
+    status: "running" | "completed" | "failed" | "awaiting_approval";
     interrupted?: boolean;
+    /** The backend's verdict: an unfinished run another sandbox may take over. */
+    adoptable?: boolean;
     updatedAt?: number;
     canvasSha?: string;
     canvasSnapshotUrl?: string;
@@ -37,7 +39,7 @@ type ActiveRunInfo = {
 /** The newest snapshot-bearing run for a creative — `GET /api/canvas/runs/latest`. */
 type SnapshotRunInfo = {
     runId: string;
-    status: "running" | "completed" | "failed";
+    status: "running" | "completed" | "failed" | "awaiting_approval";
     interrupted?: boolean;
     canvasSha?: string;
     canvasSnapshotUrl: string;
@@ -64,9 +66,10 @@ declare class BackendClient$1 {
     });
     exec(req: ExecRequest, signal?: AbortSignal): Promise<ExecResponse>;
     private pollJob;
-    presignAssetUpload(sha256: string, mime: string, signal?: AbortSignal, purpose?: "output" | "source" | "blueprint"): Promise<{
+    presignAssetUpload(sha256: string, mime: string, signal?: AbortSignal, purpose?: "output" | "source" | "blueprint", conditional?: boolean): Promise<{
         putUrl: string;
         publicUrl: string;
+        conditional?: boolean;
     }>;
     /** Remote cache lookup. A miss (404) — or an old backend without the route — returns null. */
     getCacheEntry<T>(cacheKey: string, signal?: AbortSignal): Promise<T | null>;
@@ -130,81 +133,6 @@ type NodeFailureDetail = {
     retryable?: boolean;
 };
 
-declare const CanvasSchema: z.ZodObject<{
-    schema: z.ZodLiteral<"baker-canvas/1">;
-    cache_salt: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodObject<{
-        name: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        todo: z.ZodOptional<z.ZodUnknown>;
-        video: z.ZodOptional<z.ZodObject<{
-            duration_s: z.ZodNumber;
-            timeline: z.ZodOptional<z.ZodObject<{
-                spine_node: z.ZodString;
-                expected_total_s: z.ZodNumber;
-                audio_mix_node: z.ZodOptional<z.ZodString>;
-            }, z.core.$strict>>;
-            vo_segments: z.ZodDefault<z.ZodArray<z.ZodObject<{
-                slot: z.ZodString;
-                start_s: z.ZodNumber;
-                end_s: z.ZodNumber;
-                scene: z.ZodOptional<z.ZodNumber>;
-                speaker: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
-            talking_scenes: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
-                scene: z.ZodNumber;
-                voice_convert_node: z.ZodString;
-                scene_s: z.ZodOptional<z.ZodNumber>;
-                est_speech_s: z.ZodOptional<z.ZodNumber>;
-                speech_words: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>, z.ZodObject<{
-                scene: z.ZodNumber;
-                lipsync_node: z.ZodString;
-            }, z.core.$strip>]>>>;
-            lip_sync_caution: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                scene: z.ZodNumber;
-                speaker: z.ZodString;
-                tts_over_native: z.ZodArray<z.ZodString>;
-            }, z.core.$strip>>>;
-            motion_board: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
-            elements: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                ref: z.ZodString;
-                label: z.ZodString;
-                type: z.ZodString;
-                description: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
-            clip_spans: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                node: z.ZodString;
-                span_s: z.ZodNumber;
-            }, z.core.$strip>>>;
-            graph_stats: z.ZodOptional<z.ZodObject<{
-                nodes_total: z.ZodNumber;
-                nodes_billable: z.ZodNumber;
-                node_types: z.ZodRecord<z.ZodString, z.ZodNumber>;
-                scene_routes: z.ZodArray<z.ZodObject<{
-                    scene: z.ZodNumber;
-                    route: z.ZodString;
-                    window_s: z.ZodNumber;
-                }, z.core.$strip>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    nodes: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        type: z.ZodString;
-        version: z.ZodOptional<z.ZodString>;
-        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        when: z.ZodOptional<z.ZodUnknown>;
-        regenerate: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    }, z.core.$strict>>;
-    output: z.ZodOptional<z.ZodObject<{
-        node: z.ZodString;
-        output: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-type Canvas = z.infer<typeof CanvasSchema>;
-
 declare const AssetRef: z.ZodDiscriminatedUnion<[z.ZodObject<{
     url: z.ZodOptional<z.ZodString>;
     path: z.ZodOptional<z.ZodString>;
@@ -297,27 +225,6 @@ declare class LocalAssetStore$1 implements AssetStore {
     ingestRemote(args: IngestRemoteArgs): Promise<AssetRef>;
 }
 
-type CacheEntry = {
-    cacheKey: string;
-    nodeType: string;
-    nodeVersion: string;
-    outputs: Record<string, unknown>;
-    refs: string[];
-    createdAt: number;
-};
-interface CacheStore {
-    rootDir: string;
-    get(cacheKey: string): Promise<CacheEntry | null>;
-    put(entry: CacheEntry): Promise<void>;
-}
-declare class LocalCacheStore$1 implements CacheStore {
-    rootDir: string;
-    constructor(rootDir: string);
-    private filePath;
-    get(cacheKey: string): Promise<CacheEntry | null>;
-    put(entry: CacheEntry): Promise<void>;
-}
-
 type LogFn = (line: string) => void;
 type ExecCtx = {
     canvasRunId: string;
@@ -338,15 +245,30 @@ type ExecCtx = {
     assets: AssetStore;
     log: LogFn;
     signal?: AbortSignal;
+    /**
+     * Report credits the backend actually charged for this node. Kept off the
+     * node's outputs because those are cached, and a cache hit costs nothing.
+     * Called once per backend call; the executor sums them.
+     */
+    reportCharge?: (credits: number) => void;
 };
 
 type CostEstimate = {
     credits: number;
     seconds_estimate: number;
 };
-type CostFn<P> = (args: {
+/**
+ * A function of a node's params, declared as a METHOD so it is checked
+ * bivariantly: that is what lets a concrete `NodeDefinition<I, P, O>` stand in
+ * for the type-erased `AnyNodeDefinition` a registry holds, with no cast at every
+ * registration. The registry only ever calls it with params its own schema parsed.
+ */
+type ParamsFn<P, R> = {
+    fn(params: P): R;
+}["fn"];
+type CostFn<P> = ParamsFn<{
     params: P;
-}) => CostEstimate;
+}, CostEstimate>;
 type ExecuteArgs<I, P> = {
     inputs: I;
     params: P;
@@ -363,9 +285,27 @@ type ValidateExtraIssue = {
     path: string;
     message: string;
 };
+/**
+ * What a raw input will hold at run time, as far as the graph says before the
+ * run: an asset kind, `list` (a whole list output rather than one element of it),
+ * `value` (not an asset at all), or `unknown` (only running it would tell).
+ */
+type StaticInputKind = AssetRef["kind"] | "list" | "value" | "unknown";
+/** Where an input's file comes from before the run: a workspace file or a URL an `ingest` reads. */
+type InputSource = {
+    path: string;
+} | {
+    url: string;
+};
 type ValidateExtraFn = (args: {
     rawParams: unknown;
     rawInputs: unknown;
+    /** The canvas node id, when validating a whole canvas. */
+    nodeId?: string;
+    /** Reads a raw input value's kind off the node it references. */
+    inputKindOf?: (value: unknown) => StaticInputKind;
+    /** Where a raw input's file comes from before the run; undefined for one a node generates. */
+    inputSourceOf?: (value: unknown) => InputSource | undefined;
 }) => Promise<ValidateExtraIssue[]> | ValidateExtraIssue[];
 /**
  * Node-supplied cache-key extras hook. Returns extra fields the executor
@@ -384,7 +324,27 @@ type CacheKeyExtrasFn = (args: {
  * without running the node. Remote nodes also use it at runtime so the
  * delegate ingestor knows how to wrap returned bytes.
  */
-type OutputKindsSpec<P> = Record<string, AssetRef["kind"]> | ((params: P) => Record<string, AssetRef["kind"]>);
+type OutputKindsSpec<P> = Record<string, AssetRef["kind"]> | ParamsFn<P, Record<string, AssetRef["kind"]>>;
+/**
+ * What a node's output will measure, known before anything runs: its length and
+ * raster. Each field is present only when the params (and the timing of what is
+ * wired in) settle it; an absent field means "only running it would tell".
+ */
+type StaticTiming = {
+    duration_s?: number;
+    width?: number;
+    height?: number;
+};
+/**
+ * Node-supplied static timing hook: the output's length and size from its parsed
+ * params plus the static timing of each wired input (keyed by input slot, absent
+ * when upstream cannot say). Pure; `canvas validate` calls it to prove the
+ * timeline without running anything.
+ */
+type StaticTimingFn<P> = ParamsFn<{
+    params: P;
+    inputs: Readonly<Record<string, StaticTiming | undefined>>;
+}, StaticTiming>;
 type NodeDefinition<I = unknown, P = unknown, O = unknown> = {
     id: string;
     version: string;
@@ -406,17 +366,140 @@ type NodeDefinition<I = unknown, P = unknown, O = unknown> = {
     validateExtra?: ValidateExtraFn;
     cacheKeyExtras?: CacheKeyExtrasFn;
     outputKinds?: OutputKindsSpec<P>;
-    execute: (args: ExecuteArgs<I, P>) => Promise<O>;
+    staticTiming?: StaticTimingFn<P>;
+    execute: ParamsFn<ExecuteArgs<I, P>, Promise<O>>;
 };
+/**
+ * Any node definition, its input/param/output types erased: what a registry
+ * holds and the executor runs. Every `defineNode(...)` result is assignable to it.
+ */
+type AnyNodeDefinition = NodeDefinition<unknown, unknown, unknown>;
+
+type NodeCredits = {
+    node_id: string;
+    node_type: string;
+    credits: number;
+};
+
+declare const CanvasSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"baker-canvas/1">;
+    cache_salt: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        todo: z.ZodOptional<z.ZodUnknown>;
+        video: z.ZodOptional<z.ZodObject<{
+            duration_s: z.ZodNumber;
+            timeline: z.ZodOptional<z.ZodObject<{
+                spine_node: z.ZodString;
+                expected_total_s: z.ZodNumber;
+                audio_mix_node: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            vo_segments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                slot: z.ZodString;
+                start_s: z.ZodNumber;
+                end_s: z.ZodNumber;
+                scene: z.ZodOptional<z.ZodNumber>;
+                speaker: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            talking_scenes: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                scene: z.ZodNumber;
+                voice_convert_node: z.ZodString;
+                scene_s: z.ZodOptional<z.ZodNumber>;
+                est_speech_s: z.ZodOptional<z.ZodNumber>;
+                speech_words: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>, z.ZodObject<{
+                scene: z.ZodNumber;
+                lipsync_node: z.ZodString;
+            }, z.core.$strip>]>>>;
+            lip_sync_caution: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                scene: z.ZodNumber;
+                speaker: z.ZodString;
+                tts_over_native: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>>;
+            motion_board: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+            elements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                ref: z.ZodString;
+                label: z.ZodString;
+                type: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            clip_spans: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                node: z.ZodString;
+                span_s: z.ZodNumber;
+            }, z.core.$strip>>>;
+            graph_stats: z.ZodOptional<z.ZodObject<{
+                nodes_total: z.ZodNumber;
+                nodes_billable: z.ZodNumber;
+                node_types: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                scene_routes: z.ZodArray<z.ZodObject<{
+                    scene: z.ZodNumber;
+                    route: z.ZodString;
+                    window_s: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        series: z.ZodOptional<z.ZodObject<{
+            lead: z.ZodString;
+            run_id: z.ZodString;
+            copy: z.ZodArray<z.ZodObject<{
+                text: z.ZodString;
+                role: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            design: z.ZodOptional<z.ZodString>;
+            language: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        regenerate: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+        tags: z.ZodOptional<z.ZodObject<{
+            scene: z.ZodOptional<z.ZodNumber>;
+            role: z.ZodOptional<z.ZodString>;
+            region: z.ZodOptional<z.ZodNumber>;
+            on_camera: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    output: z.ZodOptional<z.ZodObject<{
+        node: z.ZodString;
+        output: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type Canvas = z.infer<typeof CanvasSchema>;
+
+type CacheEntry = {
+    cacheKey: string;
+    nodeType: string;
+    nodeVersion: string;
+    outputs: Record<string, unknown>;
+    refs: string[];
+    createdAt: number;
+};
+interface CacheStore {
+    rootDir: string;
+    get(cacheKey: string): Promise<CacheEntry | null>;
+    put(entry: CacheEntry): Promise<void>;
+}
+declare class LocalCacheStore$1 implements CacheStore {
+    rootDir: string;
+    constructor(rootDir: string);
+    private filePath;
+    get(cacheKey: string): Promise<CacheEntry | null>;
+    put(entry: CacheEntry): Promise<void>;
+}
 
 declare class NodeRegistry {
     private readonly byId;
-    register(def: NodeDefinition): void;
-    registerAll(defs: readonly NodeDefinition[]): void;
-    get(id: string): NodeDefinition | undefined;
+    register(def: AnyNodeDefinition): void;
+    registerAll(defs: readonly AnyNodeDefinition[]): void;
+    get(id: string): AnyNodeDefinition | undefined;
     has(id: string): boolean;
     ids(): string[];
-    all(): NodeDefinition[];
+    all(): AnyNodeDefinition[];
 }
 
 type RunResult = {
@@ -452,6 +535,7 @@ type RunProgressEvent = {
         node_type: string;
         deps: string[];
         params: unknown;
+        role?: string;
     }>;
 } | {
     kind: "node_start";
@@ -469,16 +553,8 @@ type RunOptions = {
     signal?: AbortSignal;
     run_id?: string;
     cache_policy?: "read_write" | "bypass" | "read_only";
-    /** Max nodes of one layer in flight at once; invalid or missing → 8 (DEFAULT_CONCURRENCY). */
+    /** Max nodes in flight at once; invalid or missing → 8 (DEFAULT_CONCURRENCY). */
     concurrency?: number;
-    /**
-     * Credit ceiling (`--max-credits`). Enforced pre-flight against the deep
-     * validator's estimate (nothing billed) and at layer boundaries against
-     * actual spend — a boundary is the only point with no async job in flight,
-     * so aborting there strands nothing. Cached nodes cost 0, so a capped run
-     * retried with a higher cap loses no completed work.
-     */
-    max_credits?: number;
     /**
      * Node ids to force fresh for THIS run only (the `--regenerate` flag). Folds
      * the run id into each named node's cache key so it re-renders regardless of
@@ -494,11 +570,18 @@ type RunOptions = {
      * them. This is what lets someone see those first: the run settles everything cheap and
      * stops on the doorstep of the expensive half.
      *
-     * Deliberately the same shape as the cost cap: it raises `RunAbortedError`, the completed
+     * It raises `RunAbortedError`, the completed
      * nodes are already cached, and continuing is re-running the same `--run-id`, which pays
      * for none of them twice.
      */
     stop_before_kinds?: ReadonlySet<string>;
+    /**
+     * Outputs an earlier run already made, by node id: those nodes are never executed (nor looked
+     * up in the cache), their outputs passed on as a free, cached step. A version grown from the
+     * one before it keeps that version's renders in its graph this way, whatever has changed in
+     * the inputs they were made from since (`static-history.ts`).
+     */
+    pinned?: Readonly<Record<string, Record<string, unknown>>>;
     onProgress?: (event: RunProgressEvent) => void;
 };
 type EngineOptions = {
@@ -544,14 +627,12 @@ declare class Engine$1 {
         ok: false;
         issues: ValidationIssue[];
     }) & {
-        perNodeCredits?: Array<{
-            node_id: string;
-            node_type: string;
-            credits: number;
-        }>;
+        perNodeCredits?: NodeCredits[];
     }>;
     run(input: unknown, opts?: RunOptions): Promise<RunResult>;
     private runLayers;
+    /** A settled node counted, recorded and announced. */
+    private recordRun;
     /** Progress consumers are observers only — an exception there must never fail the run. */
     private emitProgress;
     /**
@@ -563,6 +644,15 @@ declare class Engine$1 {
     private pruneToOutput;
     private writeFinal;
     private executeOne;
+    /** A cache hit replayed as this node's result: its outputs written, and free. */
+    private replayCached;
+    /**
+     * An earlier run's outputs replayed as this node's result: free, and never rendered again. A
+     * local file that is gone falls back to the durable URL, downloaded when a local node needs it.
+     */
+    private replayPinned;
+    /** Best-effort: a failed upload keeps the outputs local-only, never fails the node. */
+    private persistOutputs;
     /**
      * Print the warnings a node left on its outputs' metadata — a `voice_select` that
      * could not honor the requested gender, say. Left in the metadata alone they were
@@ -591,11 +681,7 @@ type ValidationResult = {
 };
 type ValidationDeep = ValidationResult & {
     /** Per-node credit estimate, in canvas order. Useful for `validate` cost previews. */
-    perNodeCredits?: Array<{
-        node_id: string;
-        node_type: string;
-        credits: number;
-    }>;
+    perNodeCredits?: NodeCredits[];
 };
 /**
  * Async second pass that lets each node run its own `validateExtra` hook.

package/dist/engine/index.js

@@ -1,5 +1,5 @@
 import {
-  BackendClient2 as BackendClient,
+  BackendClient,
   Engine,
   LocalAssetStore,
   LocalCacheStore,
@@ -8,9 +8,23 @@ import {
   defaultRegistry,
   generateCatalog,
   validateCanvasDeep
-} from "../chunk-CHJOTJTZ.js";
-import "../chunk-VZEDAFAR.js";
-import "../chunk-HJEMOSPH.js";
+} from "../chunk-JLWBK3VC.js";
+import "../chunk-ZJ7TQUCU.js";
+import "../chunk-K6TDB2KV.js";
+import "../chunk-DGCUPJZD.js";
+import "../chunk-YMBB4JBD.js";
+import "../chunk-CAMX6OHF.js";
+import "../chunk-SYULM665.js";
+import "../chunk-5HYSKH77.js";
+import "../chunk-KIGGMKAE.js";
+import "../chunk-AIRIT4GF.js";
+import "../chunk-3VXQYDJN.js";
+import "../chunk-W4SA4CMR.js";
+import "../chunk-JXMZEOHV.js";
+import "../chunk-6YYSUISH.js";
+import "../chunk-I4FTS5EE.js";
+import "../chunk-MYTDK3AL.js";
+import "../chunk-YQSBHWOI.js";
 export {
   BackendClient,
   Engine,

package/dist/{env-4P5HOGNA.js → env-TQ2XS2KY.js}

@@ -1,4 +1,6 @@
 import {
+  MissingChatIdError,
+  canvasAssetOriginsSetting,
   captureBudgetMs,
   captureProxyCredentials,
   captureVimeoCookie,
@@ -10,11 +12,17 @@ import {
   hasOpenRouterKey,
   openRouterKey,
   optionalChatId,
+  optionalConnection,
+  optionalTurnId,
   requireChatId,
   requireConnection,
   resolveChatId
-} from "./chunk-HJEMOSPH.js";
+} from "./chunk-I4FTS5EE.js";
+import "./chunk-MYTDK3AL.js";
+import "./chunk-YQSBHWOI.js";
 export {
+  MissingChatIdError,
+  canvasAssetOriginsSetting,
   captureBudgetMs,
   captureProxyCredentials,
   captureVimeoCookie,
@@ -26,8 +34,10 @@ export {
   hasOpenRouterKey,
   openRouterKey,
   optionalChatId,
+  optionalConnection,
+  optionalTurnId,
   requireChatId,
   requireConnection,
   resolveChatId
 };
-//# sourceMappingURL=env-4P5HOGNA.js.map
+//# sourceMappingURL=env-TQ2XS2KY.js.map

package/dist/env-TQ2XS2KY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}