@koda-sl/baker-cli 0.112.1 → 0.113.1

package/README.md

@@ -3768,6 +3768,9 @@ Validate, then execute the graph. Blocks until done. Logs one line per node. Ret
 | `--outputs-dir <path>` | `./canvas` | Root for per-run output directories. |
 | `--run-id <id>` | auto ULID | Override the generated run id. |
 | `--cache-policy <policy>` | `read_write` | `read_write`, `bypass`, or `read_only`. |
+| `--concurrency <n>` | `5` (or `BAKER_CANVAS_CONCURRENCY`) | Max nodes executing at once within a layer. |
+
+**Failures don't abandon sibling work.** Nodes in a layer run under the concurrency cap and every one **settles** — a failed clip no longer kills its in-flight siblings, whose finished results still land in the content-addressed cache. One failure re-throws as-is; several are reported together (each failed node named). Re-running `baker canvas run` resumes from the cache and re-executes **only** the failed nodes and their descendants — never hand-orchestrate per-node renders. Long `video_generate` clips execute as **backend jobs** (the CLI polls; a CDN/proxy timeout can no longer kill a generation mid-flight).
 
 #### `baker canvas scaffold-video <video> [flags]`
 
@@ -3784,6 +3787,8 @@ It then scaffolds the full pipeline like an **editing timeline**: each clip gets
 
 **Composited scenes (split-screen / picture-in-picture / keyed presenter).** Real ads aren't always one full-frame shot — a frame can be **persistently divided** (b-roll on top, a presenter talking on the bottom) or **layer a presenter** over background footage (boxed in a corner, or green-screen keyed). The deconstruct now reports this per scene as `scene.composition` (`layout: split_screen | pip | keyed_overlay`, with one `region` per stream — each its own clean-plate frame + motion brief, the talking-head region flagged `is_presenter`). The scaffold reproduces a composited scene by building **one clip per region** (`s<i>_r0_*`, `s<i>_r1_*`, …) and compositing them with ffmpeg: a split-screen `vstack`/`hstack` (stack direction read from the region **panels**, so a top/bottom split always stacks vertically), or a picture-in-picture `overlay` of the presenter inset at its corner. A **keyed** presenter is first cut to transparency by `video_background_remove` (`s<i>_key`), then overlaid. The presenter region carries the native lip-synced voice; b-roll/render panels stay silent. To change a layout, edit `composition` in `prompt.json` and re-scaffold, or hand-edit the `s<i>_composite` ffmpeg args. Plain full-frame scenes (the default) are unaffected.
 
+**True output aspect, even when the video model can't generate it.** The scaffold resolves TWO ratios: the ad's **output** ratio (the source video's detected `aspect_ratio`, or **`--aspect`**, e.g. `4:5` → a 1080×1350 canvas) and the **generation** ratio — the nearest ratio the video model supports (Seedance has no 4:5, so clips + conditioning keyframes generate at `3:4`). When they differ the scaffold warns loudly, records `metadata.todo.aspect_remap`, normalizes **every clip** onto the output canvas (scale-to-fill, center-crop — keep subjects centered), sizes every ffmpeg plate/still/composite to the output dims, and stamps the copied overlay/caption compositions' `meta.json` to match. Nothing is silently dropped: an unknown ratio snaps to the nearest known one and stays explicit on every node.
+
 **Montage flashes held as stills.** A rapid-cut beat shorter than ~2s with no spoken line is a **flash** — Seedance's shortest clip is 4s, so generating one (then trimming away most of it) burns credits for motion no viewer perceives. The scaffold instead **holds one keyframe as a still** for the scene length (a cheap ffmpeg loop, no billed `video_generate`), same look at a fraction of the cost. Talking/ambient beats keep a real clip (they need motion + native audio).
 
 **The phrase model (voice cut at pauses, not at visual cuts).** The voice is grouped into **phrases** — runs of continuous speech with no real pause, which may span several visual scenes. A phrase is voiced ONCE (so a sentence the deconstruct split at a visual cut never breaks mid-word): if the speaker is **shown** anywhere in the phrase it's a single Seedance clip (`s<anchor>_clip`, native lip-sync + audio) re-voiced to the brand voice; if the speaker is **never shown** it's one ElevenLabs `tts` read. The picture is then assembled **scene by scene**: a scene that shows the speaker **slices its window** out of the phrase clip (`s<i>_seg`, an ffmpeg `-ss`/`-t` cut — video and audio come from the *same* clip, so lip-sync holds), and a **b-roll cutaway** gets its own silent clip while the phrase's voice plays underneath. "Shown" is decided by the **presenter element's per-scene presence**, not just who's speaking — a scene where a cast member narrates over b-roll (their element absent) is treated as a cutaway, so the talking head never appears where the original cut away. A presenter run longer than the **gateway-safe ~10s clip ceiling splits at a scene boundary** into contiguous takes (each its own clip + convert), so a sliced window never reads past its clip. (Seedance's *API* max is 15s, but the generation gateway frequently times out — **HTTP 524** — before it can deliver a clip longer than ~10s, so the scaffold never asks for one that long; 10s is a Seedance-allowed duration, so the split clip still snaps cleanly.) A b-roll cutaway *inside* a phrase lands at an **approximate** time (Seedance exposes no word timing) — nudge the scene boundary if it's off its beat.
@@ -3808,7 +3813,7 @@ It then scaffolds the full pipeline like an **editing timeline**: each clip gets
 
 **Re-craft the script — the hook is the #1 decision.** A reproduction is *inspiration* from a proven ad, not a clone: its structure (hook → body → CTA) carries the persuasion, and the hook is *targeting*, so a competitor's hook often does **not** transfer. `metadata.todo.script_recraft` tags each scene with its `narrative_role` (from the deconstruct, else inferred) and carries the original line **flagged** so it is never shipped as-is — and the per-scene `recraft` instruction is **role-aware**: the **hook** scene's entry carries the diagnose → decide (keep/adapt/rebuild) → criteria (statement not question, benefit by ~2s, first frame legible **sound-off** in ~1s, no bait-and-switch) inline and routes to the skill's `references/hook-craft.md`. A dedicated top-level **`metadata.todo.hook`** key foregrounds it as the highest-leverage beat, mapped onto scene-0's artifacts (`s0_start` first frame, scene-0 overlay text, `s0_clip` line, micro-hook, hook-ramp).
 
-The emitted canvas is validated (`validateCanvasDeep`) before it's written, so it always runs. It also carries a **`metadata.video`** timing plan that `baker canvas validate` proves **statically, before any billed render**: no two voiceover turns overlap, the audio length ≈ the video length, and every single-on-camera-speaker scene is a native talking head (its clip carries `generate_audio` and is wired to an `audio_voice_convert` node). The full editable checklist is embedded as **`metadata.todo`** (with a step-by-step guide in `metadata.description`). stdout returns `{ ok, canvas_path, prompt_path, models, stats, checklist }`.
+The emitted canvas is validated (`validateCanvasDeep`) before it's written, so it always runs. It also carries a **`metadata.video`** timing plan that `baker canvas validate` proves **statically, before any billed render**: no two voiceover turns overlap, the audio length ≈ the video length, every single-on-camera-speaker scene is a native talking head (its clip carries `generate_audio` and is wired to an `audio_voice_convert` node), **no re-crafted line physically overruns its clip** (`VIDEO_SPEECH_OVERRUN` — est. speech > ~1.6× the clip duration fails validate, since Seedance crams or dies on it), and **every clip agrees on one aspect ratio** (`VIDEO_ASPECT_MISMATCH`). The full editable checklist is embedded as **`metadata.todo`** (with a step-by-step guide in `metadata.description`). stdout returns `{ ok, canvas_path, prompt_path, models, stats, checklist }`.
 
 ```bash
 baker canvas scaffold-video ./reference-ad.mp4 --focus "competitor UGC ad for <brand>"

package/canvas/tiktok-captions-composition/index.html

@@ -66,7 +66,10 @@
       data-height="1920"
     >
       <video id="bg" class="clip" src="background.mp4" data-start="0" data-duration="{{duration}}" muted></video>
-      <div class="caption-container" id="captions"></div>
+      <!-- Captions intentionally paint over the full-bleed background video —
+           tell the pre-render occlusion check that's by design (it otherwise
+           flags any text sitting over an opaque full-canvas element). -->
+      <div class="caption-container" id="captions" data-layout-allow-occlusion></div>
     </div>
 
     <script>

package/canvas/video-overlay-composition/index.html

@@ -101,7 +101,10 @@
   <body>
     <div id="root" data-composition-id="main" data-start="0" data-duration="{{duration}}" data-width="1080" data-height="1920">
       <video id="bg" class="clip" src="background.mp4" data-start="0" data-duration="{{duration}}" muted></video>
-      <div id="overlay-root">
+      <!-- Overlays intentionally paint over the full-bleed background video —
+           tell the pre-render occlusion check that's by design (it otherwise
+           flags any text sitting over an opaque full-canvas element). -->
+      <div id="overlay-root" data-layout-allow-occlusion>
 <!--OVERLAYS-->
 
         <!-- NESTED BLOCK SLOT (optional): for an ANIMATED graphic (lower-third,

package/dist/{chunk-3JVYU72O.js → chunk-7K2YAWUT.js}

@@ -873,6 +873,18 @@ var NodeExecutionError = class extends CanvasError {
     this.cause = cause;
   }
 };
+var LayerExecutionError = class extends CanvasError {
+  failures;
+  constructor(failures) {
+    const ids = failures.map((f) => f.nodeId).join(", ");
+    super(`${failures.length} nodes failed in one layer: ${ids}`);
+    this.name = "LayerExecutionError";
+    this.failures = failures;
+  }
+};
+function describeFailureReason(reason) {
+  return reason instanceof Error ? reason.message : String(reason);
+}
 function describeCause(c) {
   switch (c.kind) {
     case "local":
@@ -1488,6 +1500,34 @@ function validateValue(key, value, schema, model) {
   }
 }
 
+// src/engine/lib/concurrency.ts
+var DEFAULT_CONCURRENCY = 5;
+function resolveConcurrency(...candidates) {
+  for (const candidate of candidates) {
+    if (candidate === void 0 || candidate === "") continue;
+    const n = typeof candidate === "number" ? candidate : Number(candidate);
+    if (Number.isFinite(n) && n >= 1) return Math.floor(n);
+  }
+  return DEFAULT_CONCURRENCY;
+}
+async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const index = next++;
+      try {
+        results[index] = { status: "fulfilled", value: await fn(items[index], index) };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  };
+  const workers = Array.from({ length: Math.min(limit, items.length) }, worker);
+  await Promise.all(workers);
+  return results;
+}
+
 // src/engine/lib/ulid.ts
 import { randomBytes } from "crypto";
 var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
@@ -2094,9 +2134,18 @@ var STAGE_CODES = {
   OUTPUT: "OUTPUT_REF_INVALID",
   VO_OVERLAP: "VIDEO_VO_OVERLAP",
   AUDIO_DURATION: "VIDEO_AUDIO_DURATION",
-  LIPSYNC_MISSING: "VIDEO_LIPSYNC_MISSING"
+  LIPSYNC_MISSING: "VIDEO_LIPSYNC_MISSING",
+  SPEECH_OVERRUN: "VIDEO_SPEECH_OVERRUN",
+  ASPECT_MISMATCH: "VIDEO_ASPECT_MISMATCH"
 };
 var VIDEO_TIME_SLACK_S = 0.75;
+var SPEECH_WORDS_PER_SECOND = 2.5;
+var SPEECH_OVERRUN_RATIO = 1.6;
+function nativeDialogueOf(prompt) {
+  if (typeof prompt !== "string") return void 0;
+  const m = prompt.match(/Dialogue: "(.*)"/);
+  return m?.[1]?.trim() || void 0;
+}
 function validateCanvas(input, registry) {
   const issues = [];
   const shape = CanvasSchema.safeParse(input);
@@ -2453,6 +2502,44 @@ function checkVideoInvariants(ctx) {
       });
     }
   }
+  checkSpeechOverrun(ctx, meta.talking_scenes);
+  checkAspectConsistency(ctx);
+}
+function speechOverrunOf(node) {
+  const params = node.params;
+  if (params?.generate_audio !== true) return null;
+  const line = nativeDialogueOf(params.prompt);
+  const duration = typeof params.duration === "number" ? params.duration : void 0;
+  if (!line || !duration) return null;
+  const estSpeechS = line.split(/\s+/).filter(Boolean).length / SPEECH_WORDS_PER_SECOND;
+  return estSpeechS > duration * SPEECH_OVERRUN_RATIO ? { estSpeechS, duration } : null;
+}
+function checkSpeechOverrun(ctx, talkingScenes) {
+  for (const entry of talkingScenes) {
+    if (typeof entry !== "object" || !("voice_convert_node" in entry)) continue;
+    const nativeClipRe = new RegExp(`^s${entry.scene}(_r\\d+)?_clip$`);
+    for (const n of ctx.canvas.nodes) {
+      if (!nativeClipRe.test(n.id) || n.type !== "video_generate") continue;
+      const overrun = speechOverrunOf(n);
+      if (!overrun) continue;
+      ctx.issues.push({
+        path: `nodes[${ctx.idToIndex.get(n.id) ?? -1}].params.prompt`,
+        code: STAGE_CODES.SPEECH_OVERRUN,
+        message: `"${n.id}" asks Seedance to speak ~${Math.round(overrun.estSpeechS * 10) / 10}s of dialogue inside a ${overrun.duration}s clip \u2014 the line cannot fit (>${SPEECH_OVERRUN_RATIO}\xD7 the clip). Shorten the line, split the scene, or lengthen the clip duration`
+      });
+    }
+  }
+}
+function checkAspectConsistency(ctx) {
+  const clips = ctx.canvas.nodes.filter((n) => n.type === "video_generate");
+  if (clips.length < 2) return;
+  const ratios = new Set(clips.map((n) => String(n.params?.aspect_ratio ?? "(unset)")));
+  if (ratios.size <= 1) return;
+  ctx.issues.push({
+    path: "nodes",
+    code: STAGE_CODES.ASPECT_MISMATCH,
+    message: `video_generate nodes disagree on aspect_ratio (${[...ratios].sort().join(", ")}) \u2014 the spine's segments would render at different shapes and the composite silently crops. Pin every clip to the same aspect_ratio`
+  });
 }
 function checkOutputRef(ctx) {
   const out = ctx.canvas.output;
@@ -2628,8 +2715,11 @@ var Engine = class {
   }
   async runLayers(canvas, outputs, runId, writer, opts, counters, nodeRuns) {
     const layers = topologicalLayers(this.pruneToOutput(canvas, buildGraph(canvas)));
+    const limit = resolveConcurrency(opts.concurrency);
     for (const layer of layers) {
-      const tasks = layer.map(
+      const settled = await mapWithConcurrency(
+        layer,
+        limit,
         (nodeId) => this.executeOne(canvas, nodeId, outputs, runId, writer, opts).then((r) => {
           if (r.cached) counters.cachedNodes++;
           counters.totalCredits += r.credits;
@@ -2645,7 +2735,13 @@ var Engine = class {
           }
         })
       );
-      await Promise.all(tasks);
+      const failures = [];
+      settled.forEach((result, i) => {
+        const nodeId = layer[i];
+        if (result.status === "rejected" && nodeId) failures.push({ nodeId, reason: result.reason });
+      });
+      if (failures.length === 1 && failures[0]) throw failures[0].reason;
+      if (failures.length > 1) throw new LayerExecutionError(failures);
     }
   }
   /**
@@ -6238,10 +6334,13 @@ function createEngineFromEnv(opts = {}) {
 }
 
 export {
+  LayerExecutionError,
+  describeFailureReason,
   SEEDANCE_DURATIONS,
   ELEVENLABS_MAX_MUSIC_LENGTH_MS,
   IMAGE_GENERATE_MODELS,
   MODEL_REGISTRY,
+  resolveConcurrency,
   BackendClient2 as BackendClient,
   Engine2 as Engine,
   LocalAssetStore2 as LocalAssetStore,
@@ -6252,4 +6351,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-3JVYU72O.js.map
+//# sourceMappingURL=chunk-7K2YAWUT.js.map