@koda-sl/baker-cli 0.113.2 → 0.114.1

package/README.md

@@ -2530,12 +2530,25 @@ Auth: same `BAKER_API_KEY` + `BAKER_API_URL` as the rest of the CLI.
 ```bash
 # 1. Validate (free, never calls the API)
 baker canvas validate my-canvas.json
+#    Blocking issues exit non-zero. Advisory `warnings[]` (exit 0) flag likely-wrong-but-
+#    legal config to review before billing — a frame that describes a recurring element
+#    (a pet/product) but doesn't wire its reference (VIDEO_REFERENCE_MISSING), or a scene
+#    span that exceeds the assigned model's max clip duration (VIDEO_SPAN_EXCEEDS_MODEL).
 
 # 2. Run (executes nodes, writes files to ./canvas/<run_id>/)
 baker canvas run my-canvas.json
 #    Only nodes reachable from the declared output execute (orphaned nodes are skipped,
 #    not billed). Add --keep-runs N to prune old r_* run dirs, keeping the N newest.
 
+# 2b. Independent nodes ALREADY fan out in parallel — every node in the same
+#     topological layer (e.g. all the per-clip video_generate nodes) runs concurrently
+#     up to a bound. Raise it with --parallel N (alias: --concurrency N; default 5;
+#     env BAKER_CANVAS_CONCURRENCY). A single clip failing NO LONGER strands its
+#     siblings: the whole layer settles, cached siblings survive, and a re-run resumes
+#     from cache. There is no need to render clips one at a time or pin `output` to a
+#     single node — that old serial workaround is obsolete.
+baker canvas run my-canvas.json --parallel 8
+
 # 3. Inspect a finished run (per-node timing, file list, optional video thumbs)
 baker canvas inspect <run_id>
 
@@ -3279,6 +3292,15 @@ Ref-image MIMEs: `image/png`, `image/jpeg`, `image/webp`, `image/gif` (via OpenR
               "duration": 6, "resolution": "1080p", "aspect_ratio": "16:9", "enhance_prompt": true } }
 ```
 
+> **Switching a clip's model has cross-node constraints** — validate after every model edit. `validate` gates all of these before any billed run:
+> - **One aspect_ratio for the whole canvas.** Every `video_generate` node must agree (`VIDEO_ASPECT_MISMATCH`), or the composite silently crops/letterboxes. Switching one clip to Veo (which only offers `16:9`/`9:16`) forces every other clip to a shared ratio too.
+> - **`duration` is a per-model hard enum.** Seedance `4,5,6,8,10,12,15`; Veo `4,6,8` only. A value outside the model's set is rejected; a scene whose natural span exceeds the model's max is flagged (`VIDEO_SPAN_EXCEEDS_MODEL`, advisory) — a 9.2s scene can't fit Veo's 8s cap and would truncate; split the scene or keep it on a longer-max model.
+> - **`person_generation` differs.** Veo accepts only `allow_all`.
+>
+> A scaffolded canvas carries this table inline at `metadata.todo.model_constraints`.
+
+> **Content-policy blocks are deterministic, not flaky.** fal.ai/Seedance rejects any first/last frame that reads as a real-person likeness (even an AI-generated face) — surfaced as `content_policy_blocked` (HTTP 422, **non-retryable**), even when fal's proxy chain masks it as a 5xx. Retrying **never** succeeds and wastes credits. Fix the cause: switch the clip to the other curated model (Veo routes around fal's filter), or make the source frame less photorealistic.
+
 ---
 
 ##### `tts`

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

@@ -624,6 +624,7 @@ ${originalIndentation}`;
 import path15 from "path";
 
 // src/engine/client/http.ts
+var CONTENT_POLICY_CODE = "content_policy_blocked";
 var BackendHttpError = class extends Error {
   detail;
   constructor(detail) {
@@ -640,6 +641,8 @@ function describe(d) {
       return `invalid request: ${d.message}`;
     case "provider":
       return `provider error${d.provider ? ` (${d.provider})` : ""}: ${d.message}`;
+    case "content_policy":
+      return `content policy blocked${d.provider ? ` (${d.provider})` : ""}: ${d.message}`;
     case "timeout":
       return `provider timeout${d.provider ? ` (${d.provider})` : ""}: ${d.message}`;
     case "server":
@@ -736,6 +739,9 @@ async function parseErrorBody(res) {
   return classifyHttpError(res.status, errObj, errObj.message ?? `HTTP ${res.status}`);
 }
 function classifyHttpError(status, errObj, message) {
+  if (errObj.code === CONTENT_POLICY_CODE) {
+    return { kind: "content_policy", status, provider: errObj.provider, message };
+  }
   if (status === 401 || status === 403) {
     return { kind: "unauthorized", status, message };
   }
@@ -774,6 +780,24 @@ function isAsyncJob(res) {
   return typeof res.job_id === "string";
 }
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function failedJobError(error) {
+  if (error.code === CONTENT_POLICY_CODE) {
+    return new BackendHttpError({
+      kind: "content_policy",
+      status: error.status ?? 422,
+      provider: error.provider,
+      message: error.message ?? "content policy blocked"
+    });
+  }
+  return new BackendHttpError({
+    kind: "provider",
+    status: error.status ?? 502,
+    provider: error.provider,
+    code: error.code ?? "provider_error",
+    message: error.message ?? "deconstruct failed",
+    retryable: error.retryable ?? false
+  });
+}
 var JOB_POLL_INTERVAL_MS = 3e3;
 var JOB_POLL_MAX_MS = 20 * 60 * 1e3;
 var BackendClient = class {
@@ -797,16 +821,7 @@ var BackendClient = class {
       }
       const job = await this.http.getJson(path16, signal);
       if (job.status === "completed") return job.result;
-      if (job.status === "failed") {
-        throw new BackendHttpError({
-          kind: "provider",
-          status: job.error.status ?? 502,
-          provider: job.error.provider,
-          code: job.error.code ?? "provider_error",
-          message: job.error.message ?? "deconstruct failed",
-          retryable: job.error.retryable ?? false
-        });
-      }
+      if (job.status === "failed") throw failedJobError(job.error);
       if (Date.now() > deadline) {
         throw new BackendHttpError({ kind: "timeout", message: `job ${jobId} did not finish in time` });
       }
@@ -845,6 +860,9 @@ function requireCredentialsFromEnv(env = process.env) {
 }
 
 // src/engine/engine/errors.ts
+function isBlocking(issue) {
+  return issue.severity !== "warning";
+}
 var CanvasError = class extends Error {
   constructor(message) {
     super(message);
@@ -895,6 +913,8 @@ function describeCause(c) {
       return `timeout${c.provider ? ` (${c.provider})` : ""}`;
     case "network":
       return c.cause instanceof Error ? `network: ${c.cause.message}` : "network error";
+    case "content_policy":
+      return `CONTENT_POLICY_BLOCKED${c.provider ? ` (${c.provider})` : ""}: ${c.message}`;
     default: {
       const _exhaustive = c;
       return String(_exhaustive);
@@ -1638,7 +1658,23 @@ var VideoMeta = z.object({
   // on which spoken beat" map emitted by scaffold-video (per-scene window,
   // spoken line, storyboard frames, scheduled graphics). Free-form rows so the
   // schema stays decoupled from the scaffold's exact shape.
-  motion_board: z.array(z.unknown()).optional()
+  motion_board: z.array(z.unknown()).optional(),
+  // The recurring identity elements the scaffold wired (one shared reference slot
+  // per cast member / pet / product / logo). The reference-completeness check reads
+  // this to warn when a frame's description mentions an element whose ref isn't
+  // wired on that frame node (the wrong-identity-animal failure).
+  elements: z.array(
+    z.object({
+      ref: z.string(),
+      label: z.string(),
+      type: z.string(),
+      description: z.string().optional()
+    })
+  ).optional(),
+  // Per video_generate node: the scene's natural visual span. The validator warns
+  // when a clip's span exceeds the assigned model's max clip duration (e.g. a 9.2s
+  // scene on Veo, which caps at 8s) — the clip would truncate.
+  clip_spans: z.array(z.object({ node: z.string(), span_s: z.number() })).optional()
 }).strict().optional();
 var CanvasMetadata = z.object({
   name: z.string().optional(),
@@ -2136,8 +2172,11 @@ var STAGE_CODES = {
   AUDIO_DURATION: "VIDEO_AUDIO_DURATION",
   LIPSYNC_MISSING: "VIDEO_LIPSYNC_MISSING",
   SPEECH_OVERRUN: "VIDEO_SPEECH_OVERRUN",
-  ASPECT_MISMATCH: "VIDEO_ASPECT_MISMATCH"
+  ASPECT_MISMATCH: "VIDEO_ASPECT_MISMATCH",
+  REFERENCE_MISSING: "VIDEO_REFERENCE_MISSING",
+  SPAN_EXCEEDS_MODEL: "VIDEO_SPAN_EXCEEDS_MODEL"
 };
+var SPAN_MODEL_SLACK_S = 0.25;
 var VIDEO_TIME_SLACK_S = 0.75;
 var SPEECH_WORDS_PER_SECOND = 2.5;
 var SPEECH_OVERRUN_RATIO = 1.6;
@@ -2168,8 +2207,10 @@ function validateCanvas(input, registry) {
   const estimatedCredits = estimateCredits(ctx);
   checkOutputRef(ctx);
   checkVideoInvariants(ctx);
-  if (issues.length > 0) return { ok: false, issues };
-  return { ok: true, canvas, estimatedCredits };
+  const hasBlocking = issues.some(isBlocking);
+  if (hasBlocking) return { ok: false, issues };
+  const warnings = issues.filter((i) => !isBlocking(i));
+  return { ok: true, canvas, estimatedCredits, warnings: warnings.length > 0 ? warnings : void 0 };
 }
 async function validateCanvasDeep(input, registry) {
   const shallow = validateCanvas(input, registry);
@@ -2204,7 +2245,9 @@ async function validateCanvasDeep(input, registry) {
       });
     }
   }
-  if (issues.length > 0) return { ok: false, issues };
+  const hasBlocking = issues.some(isBlocking);
+  if (hasBlocking) return { ok: false, issues };
+  const warnings = [...shallow.warnings ?? [], ...issues.filter((i) => !isBlocking(i))];
   const perNodeCredits = canvas.nodes.map((n) => {
     const def = registry.get(n.type);
     let credits = 0;
@@ -2217,7 +2260,13 @@ async function validateCanvasDeep(input, registry) {
     }
     return { node_id: n.id, node_type: n.type, credits };
   });
-  return { ok: true, canvas, estimatedCredits: shallow.estimatedCredits, perNodeCredits };
+  return {
+    ok: true,
+    canvas,
+    estimatedCredits: shallow.estimatedCredits,
+    perNodeCredits,
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
 }
 function buildIdToIndex(canvas) {
   const m = /* @__PURE__ */ new Map();
@@ -2504,6 +2553,95 @@ function checkVideoInvariants(ctx) {
   }
   checkSpeechOverrun(ctx, meta.talking_scenes);
   checkAspectConsistency(ctx);
+  checkReferenceCompleteness(ctx, meta);
+  checkClipSpanFitsModel(ctx, meta);
+}
+var ELEMENT_TYPE_KEYWORDS = {
+  animal: ["dog", "puppy", "pup", "cat", "kitten", "kitty", "pet", "canine", "feline"],
+  logo: ["logo", "wordmark"],
+  badge: ["badge", "seal"],
+  product: []
+};
+var CHECKED_ELEMENT_TYPES = new Set(Object.keys(ELEMENT_TYPE_KEYWORDS));
+var KEYWORD_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "with",
+  "for",
+  "brand",
+  "logo",
+  "image",
+  "shot",
+  "main",
+  "hero",
+  "element",
+  "product",
+  "reference"
+]);
+function keywordTokens(text) {
+  if (!text) return [];
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 3 && !KEYWORD_STOPWORDS.has(t));
+}
+function keywordsForElement(el) {
+  const type = el.type.toLowerCase();
+  const typeWords = ELEMENT_TYPE_KEYWORDS[type] ?? [];
+  return [.../* @__PURE__ */ new Set([...typeWords, ...keywordTokens(el.label), ...keywordTokens(el.description)])];
+}
+function containsWord(text, word) {
+  const esc = word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\b${esc}\\b`, "i").test(text);
+}
+function checkFrameReferences(ctx, node, index, keyworded) {
+  const prompt = node.params?.prompt;
+  if (typeof prompt !== "string" || prompt.length === 0) return;
+  const inputsBlob = JSON.stringify(node.inputs ?? {});
+  for (const { el, keywords } of keyworded) {
+    if (inputsBlob.includes(el.ref)) continue;
+    const hit = keywords.find((kw) => containsWord(prompt, kw));
+    if (!hit) continue;
+    ctx.issues.push({
+      path: `nodes[${index}].inputs.reference`,
+      code: STAGE_CODES.REFERENCE_MISSING,
+      severity: "warning",
+      message: `frame "${node.id}" describes a "${hit}" but the "${el.label}" reference (${el.ref}) isn't wired on this node \u2014 the generator will invent a wrong-identity ${el.type} from prose. Add ${el.ref} to inputs.reference`,
+      node_id: node.id,
+      node_type: node.type
+    });
+  }
+}
+function checkReferenceCompleteness(ctx, meta) {
+  const elements = (meta.elements ?? []).filter((el) => CHECKED_ELEMENT_TYPES.has(el.type.toLowerCase()));
+  const keyworded = elements.map((el) => ({ el, keywords: keywordsForElement(el) })).filter((e) => e.keywords.length > 0);
+  if (keyworded.length === 0) return;
+  for (let i = 0; i < ctx.canvas.nodes.length; i++) {
+    const n = ctx.canvas.nodes[i];
+    if (n?.type === "image_generate") checkFrameReferences(ctx, n, i, keyworded);
+  }
+}
+function videoModelMaxDuration(model) {
+  const spec = MODEL_REGISTRY.video_generate[model];
+  const durations = spec?.params?.duration?.enum;
+  if (!durations) return void 0;
+  const nums = durations.filter((d) => typeof d === "number");
+  return nums.length > 0 ? Math.max(...nums) : void 0;
+}
+function checkClipSpanFitsModel(ctx, meta) {
+  for (const { node, span_s } of meta.clip_spans ?? []) {
+    const target = ctx.canvas.nodes.find((n) => n.id === node && n.type === "video_generate");
+    if (!target) continue;
+    const model = target.params?.model;
+    if (typeof model !== "string") continue;
+    const max = videoModelMaxDuration(model);
+    if (max === void 0 || span_s <= max + SPAN_MODEL_SLACK_S) continue;
+    ctx.issues.push({
+      path: `nodes[${ctx.idToIndex.get(node) ?? -1}].params.duration`,
+      code: STAGE_CODES.SPAN_EXCEEDS_MODEL,
+      severity: "warning",
+      message: `scene for clip "${node}" needs ~${span_s}s but ${model} caps clips at ${max}s \u2014 the clip will truncate. Split the scene, or keep it on a model whose max duration covers the span`,
+      node_id: node,
+      node_type: "video_generate"
+    });
+  }
 }
 function speechOverrunOf(node) {
   const params = node.params;
@@ -2684,6 +2822,9 @@ var Engine = class {
     const writer = new OutputWriter({ outputsDir: this.outputsDir, runId });
     await writer.ensure();
     this.log(`[validate] ok (${canvas.nodes.length} nodes, est. ${validation.estimatedCredits} credits)`);
+    for (const w of validation.warnings ?? []) {
+      this.log(`[warn    ] ${w.code}${w.node_id ? ` (${w.node_id})` : ""}: ${w.message}`);
+    }
     const t0 = Date.now();
     const outputs = {};
     const counters = { cachedNodes: 0, totalCredits: 0 };
@@ -3253,6 +3394,13 @@ function mapClientError(ctx, e) {
         provider: d.provider
       });
     }
+    if (d.kind === "content_policy") {
+      return new NodeExecutionError(ctx.nodeId, ctx.nodeType, {
+        kind: "content_policy",
+        provider: d.provider,
+        message: d.message
+      });
+    }
     if (d.kind === "timeout") {
       return new NodeExecutionError(ctx.nodeId, ctx.nodeType, { kind: "timeout", provider: d.provider });
     }
@@ -6351,4 +6499,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-7K2YAWUT.js.map
+//# sourceMappingURL=chunk-ZWMMCLJ4.js.map