@koda-sl/baker-cli 0.290.3 → 0.293.0-dev.cf9d5462d

package/dist/{chunk-NNQDWCFG.js → chunk-LTXNRRXW.js}

@@ -1,24 +1,25 @@
 import {
   debugLogHttp,
   readBodyForLog
-} from "./chunk-2IB3IL4K.js";
+} from "./chunk-2IUN3S3E.js";
 import {
   DIRECT_ROUTE,
   __commonJS,
   __toESM,
   captureProxyCredentials,
   childEnvWith,
+  hasFrameVisionKey,
   isChallengeBody,
   isPrivateAddress,
   isProxyFailure,
   plannedRoutes,
   refuseNonPublicUrl,
   shouldEscalate
-} from "./chunk-DZUVUGEP.js";
+} from "./chunk-WFWU3CHS.js";
 
-// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js
+// ../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/88b6d0c76c4dff408de4044be85791896193f2435af7c280bc59312c3fb9649c/node_modules/safe-stable-stringify/index.js
 var require_safe_stable_stringify = __commonJS({
-  "../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js"(exports, module) {
+  "../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/88b6d0c76c4dff408de4044be85791896193f2435af7c280bc59312c3fb9649c/node_modules/safe-stable-stringify/index.js"(exports, module) {
     "use strict";
     var { hasOwnProperty } = Object.prototype;
     var stringify = configure2();
@@ -1033,12 +1034,17 @@ function failureDetail(reason) {
   }
   return { message: describeFailureReason(reason) };
 }
+function retryVerdict(retryable) {
+  if (retryable === true) return "transient \u2014 retry the run";
+  if (retryable === false) return "not retryable \u2014 retrying will not help, fix the input";
+  return "retryability unknown";
+}
 function describeCause(c) {
   switch (c.kind) {
     case "local":
       return c.cause instanceof Error ? c.cause.message : String(c.cause);
     case "remote":
-      return `[${c.code}] ${c.message}${c.provider ? ` (${c.provider})` : ""}`;
+      return `[${c.code}] ${c.message}${c.provider ? ` (${c.provider})` : ""} \u2014 ${retryVerdict(c.retryable)}`;
     case "timeout":
       return `timeout${c.provider ? ` (${c.provider})` : ""}`;
     case "network":
@@ -1092,7 +1098,7 @@ function resolveAdaptFormats(params) {
   return params.formats ?? [];
 }
 
-// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/esm/wrapper.js
+// ../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/88b6d0c76c4dff408de4044be85791896193f2435af7c280bc59312c3fb9649c/node_modules/safe-stable-stringify/esm/wrapper.js
 var import__ = __toESM(require_safe_stable_stringify(), 1);
 var configure = import__.default.configure;
 var wrapper_default = import__.default;
@@ -1133,6 +1139,14 @@ function normalizeForCanonical(value) {
   return void 0;
 }
 
+// ../canvas-contract/src/frameRealism.ts
+function frameRealismDirection(opts = {}) {
+  return " Everything obeys real-world physics: paper, card and screens are OPAQUE with nothing showing through from behind, every object is at believable real-world scale next to the people handling it, and every object has its real-world form and construction \u2014 a phone has ONE screen and it is on the front. NO readable text or numbers anywhere in frame \u2014 phone screens, documents and signage stay illegible or out of focus, because any figure the model invents will contradict the script. Hands are kept simple: no close-up of fingers manipulating small parts, no hand gripping the edge of an object, and each person has exactly TWO arms and TWO legs, all attached and all visible or all out of frame. Anyone working does so the way the trade actually does it: nobody stands or kneels on the equipment being installed, nothing is fitted overhanging an edge or floating unsupported, and every part rests on the structure that would really carry it." + // The newest clause, and the one no route had. A testimonial came back with the customer
+  // repairing the panel herself: nothing said she was not the installer, so the model cast
+  // her as one. Who someone IS in the picture has to be stated, or it is guessed.
+  (opts.role ? ` The person on camera is ${opts.role} \u2014 they are shown as that and never doing somebody else's job.` : "") + (opts.currency ? ` If a currency is unavoidably visible it is ${opts.currency}.` : "");
+}
+
 // ../canvas-contract/src/registry.ts
 var OPENROUTER_IMAGE_AR = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"];
 var OPENROUTER_IMAGE_AR_EXTREME = [...OPENROUTER_IMAGE_AR, "1:4", "4:1", "1:8", "8:1"];
@@ -1152,6 +1166,7 @@ var OPENROUTER_IMAGE_SIZES = ["0.5K", ...OPENROUTER_IMAGE_SIZE];
 var OPENROUTER_IMAGE_SIZE_EXTENDED = OPENROUTER_IMAGE_SIZES;
 var GEMINI_LITE_IMAGE_SIZE = ["1K"];
 var OPENROUTER_IMAGE_QUALITY = ["auto", "low", "medium", "high"];
+var OPENROUTER_IMAGE_QUALITY_25 = ["auto", "low", "medium", "high", "xhigh", "max"];
 var RECRAFT_IMAGE_AR = ["1:1", "4:3", "3:4", "16:9", "9:16"];
 var SEEDANCE_DURATIONS = [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
 var SEEDANCE_25_DURATIONS = [
@@ -1214,6 +1229,7 @@ var REPLICATE_VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
 var DECONSTRUCT_VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
 var REPLICATE_AUDIO_MIMES = ["audio/wav", "audio/mpeg", "audio/mp3"];
 var IMAGE_GENERATE_MODELS = [
+  "openai/gpt-image-2.5-sunburst",
   "openai/gpt-image-2",
   "openai/gpt-5.4-image-2",
   "google/gemini-3.1-flash-image-preview",
@@ -1359,6 +1375,20 @@ var MODEL_REGISTRY = {
     // images as a side effect. Notable capability gaps vs the Gemini entries:
     // no `image_size` (OpenAI picks the pixel dimensions from the ratio, and a
     // `resolution` is silently ignored) and the narrower `..._AR_GPT` ratio set.
+    "openai/gpt-image-2.5-sunburst": {
+      // Identical to the gpt-image-2 entry below except for the quality ladder — the
+      // ratio set, the 16-reference ceiling, the missing `image_size` and the reasons
+      // `background` / `output_compression` stay undeclared all carry over unchanged.
+      label: "OpenAI GPT Image 2.5",
+      inputs: [],
+      optional_inputs: [{ kind: "image", mimes: OPENROUTER_IMAGE_MIMES, max: GPT_IMAGE_MAX_REFERENCES }],
+      required: ["prompt"],
+      params: {
+        prompt: { kind: "string", maxLength: GPT_IMAGE_PROMPT_MAX },
+        aspect_ratio: { kind: "string", enum: OPENROUTER_IMAGE_AR_GPT },
+        quality: { kind: "string", enum: OPENROUTER_IMAGE_QUALITY_25 }
+      }
+    },
     "openai/gpt-image-2": {
       // Its live endpoint also advertises `background` (auto|opaque) and
       // `output_compression` (0-100), which we deliberately do not declare. Not an
@@ -2033,6 +2063,19 @@ function maxInputSlot(kind, model, inputKind) {
 function maxInputReferences(kind, model) {
   return maxInputSlot(kind, model, "image");
 }
+function supportedQualities(kind, model) {
+  const schema = MODEL_REGISTRY[kind]?.[model]?.params.quality;
+  return schema?.kind === "string" ? schema.enum : void 0;
+}
+function bestSupportedQuality(kind, model, want) {
+  const supported = supportedQualities(kind, model);
+  if (!supported) return void 0;
+  if (supported.includes(want)) return want;
+  const ladder = supported.filter((step) => step !== "auto");
+  const ceiling = ladder.indexOf(want);
+  const reachable = ceiling === -1 ? ladder : ladder.slice(0, ceiling);
+  return reachable[reachable.length - 1];
+}
 function supportedAspectRatios(kind, model) {
   const schema = MODEL_REGISTRY[kind]?.[model]?.params.aspect_ratio;
   return schema?.kind === "string" ? schema.enum : void 0;
@@ -3117,6 +3160,16 @@ function dfsCycle(u, color, stack, reverseAdj) {
   stack.pop();
   return null;
 }
+function nodesBeforeCheckpoint(graph, types, stopKinds) {
+  const all = new Set(graph.keys());
+  if (!stopKinds?.size) return all;
+  const running = /* @__PURE__ */ new Set();
+  for (const layer of topologicalLayers(graph)) {
+    if (layer.some((id) => stopKinds.has(types.get(id) ?? ""))) return running;
+    for (const id of layer) running.add(id);
+  }
+  return running;
+}
 
 // src/engine/engine/validator.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -3135,7 +3188,7 @@ var VEO_DURATIONS = [4, 6, 8];
 var KLING_DURATIONS2 = [5, 10];
 var KLING_NEGATIVE_PROMPT = "warped face, distorted hands, extra fingers, morphing, flicker, on-screen text, watermark, low quality";
 var KLING_CFG_SCALE = 0.7;
-var SPEAKS_PROSE = (line) => `The person speaks to camera; lip-sync follows the dialogue verbatim, with delivery and emotion carried in the wording itself (no bracketed cues). Dialogue: "${line}"`;
+var SPEAKS_PROSE = (line, accent) => `The person speaks to camera; lip-sync follows the dialogue verbatim, with delivery and emotion carried in the wording itself (no bracketed cues).${accent ? ` The speech is in ${accent}.` : ""} Dialogue: "${line}"`;
 var SEEDANCE_PROFILE = {
   id: "seedance",
   dialogueDirective: SPEAKS_PROSE,
@@ -3236,9 +3289,14 @@ var GPT_IMAGE_PROFILE = {
   id: "gpt-image",
   constraintPlacement: "last",
   photorealCue: true,
-  // OpenRouter forwards `quality`; gpt-image-2 already processes inputs at high
-  // fidelity automatically, so we deliberately do NOT send `input_fidelity`.
-  paramDefaults: { quality: "high" }
+  // OpenRouter forwards `quality`; gpt-image already processes inputs at high fidelity
+  // automatically, so we deliberately do NOT send `input_fidelity`.
+  //
+  // No `quality` here any more: it is the one default that depends on WHICH gpt-image is
+  // pinned. 2.5 added `xhigh` and `max` above `high`, and the older entries would refuse
+  // them at validate — so callers ask for the step they want through
+  // `bestSupportedQuality` and get the best the chosen model actually has.
+  paramDefaults: {}
 };
 var GEMINI_IMAGE_PROFILE = {
   id: "gemini",
@@ -3749,6 +3807,19 @@ function checkSlotsForNode(ctx, n, _i) {
     });
   }
 }
+function estimateCreditsFor(canvas, registry, ids) {
+  let total = 0;
+  for (const n of canvas.nodes) {
+    if (!ids.has(n.id)) continue;
+    const def = registry.get(n.type);
+    if (!def?.cost) continue;
+    try {
+      total += def.cost({ params: def.params.parse(n.params ?? {}) }).credits;
+    } catch {
+    }
+  }
+  return total;
+}
 function estimateCredits(ctx) {
   let total = 0;
   for (const n of ctx.canvas.nodes) {
@@ -4055,7 +4126,7 @@ function checkAudioTimelineTotals(ctx, audioMixNode, expected) {
   if (audioMixNode) mustBeFullLength.add(audioMixNode);
   ctx.canvas.nodes.forEach((n) => {
     if (n.type !== "audio_voice_convert") return;
-    const track = refNodeOf(ctx, (n.inputs ?? {}).audio);
+    const track = refNodeOf(ctx, n.inputs?.audio);
     if (track?.type === "audio_timeline") mustBeFullLength.add(track.id);
   });
   for (const id of mustBeFullLength) {
@@ -4076,11 +4147,11 @@ function checkAudioTimelineTotals(ctx, audioMixNode, expected) {
 function checkNativeSegOverlap(ctx) {
   for (const conv of ctx.canvas.nodes) {
     if (conv.type !== "audio_voice_convert") continue;
-    const track = refNodeOf(ctx, (conv.inputs ?? {}).audio);
+    const track = refNodeOf(ctx, conv.inputs?.audio);
     if (track?.type !== "audio_timeline") continue;
     const params = track.params;
     const windows = (params.tracks ?? []).map((t) => {
-      const extract = refNodeOf(ctx, (track.inputs ?? {})[t.slot]);
+      const extract = refNodeOf(ctx, track.inputs?.[t.slot]);
       const len = t.duration_s ?? (extract ? ffmpegTrimSeconds(extract) : null);
       return len === null ? null : { slot: t.slot, start: t.start_s, end: t.start_s + len };
     }).filter((w) => w !== null).sort((a, b) => a.start - b.start);
@@ -4573,6 +4644,13 @@ function unwrap(schema) {
 }
 
 // src/engine/engine/executor.ts
+function heldByCheckpoint(canvas, layer, kinds) {
+  if (!kinds?.size) return [];
+  return layer.filter((id) => {
+    const type = canvas.nodes.find((n) => n.id === id)?.type;
+    return type !== void 0 && kinds.has(type);
+  });
+}
 var Engine = class {
   registry;
   client;
@@ -4600,7 +4678,7 @@ var Engine = class {
   async run(input, opts = {}) {
     const validation = await this.validateDeep(input);
     if (!validation.ok) throw new ValidationError(validation.issues);
-    if (opts.max_credits !== void 0 && validation.estimatedCredits > opts.max_credits) {
+    if (!opts.stop_before_kinds?.size && opts.max_credits !== void 0 && validation.estimatedCredits > opts.max_credits) {
       throw new RunAbortedError(
         "cost_cap",
         `estimated ${validation.estimatedCredits} credits exceeds the ${opts.max_credits}-credit cap \u2014 nothing was billed; raise --max-credits or shrink the canvas`
@@ -4619,6 +4697,20 @@ var Engine = class {
     const counters = { cachedNodes: 0, totalCredits: 0 };
     const nodeRuns = [];
     const graph = this.pruneToOutput(canvas, buildGraph(canvas));
+    if (opts.max_credits !== void 0 && opts.stop_before_kinds?.size) {
+      const willRun = nodesBeforeCheckpoint(
+        graph,
+        new Map(canvas.nodes.map((n) => [n.id, n.type])),
+        opts.stop_before_kinds
+      );
+      const estimate = estimateCreditsFor(canvas, this.registry, willRun);
+      if (estimate > opts.max_credits) {
+        throw new RunAbortedError(
+          "cost_cap",
+          `estimated ${estimate} credits exceeds the ${opts.max_credits}-credit cap \u2014 nothing was billed; raise --max-credits or shrink the canvas`
+        );
+      }
+    }
     const needsBytes = computeNeedsLocalBytes(canvas, graph, this.registry);
     this.emitProgress(opts, {
       kind: "plan",
@@ -4663,6 +4755,13 @@ var Engine = class {
           `spent ${counters.totalCredits} credits, over the ${opts.max_credits}-credit cap \u2014 completed nodes are cached; raise --max-credits to continue where this stopped`
         );
       }
+      const held = heldByCheckpoint(canvas, layer, opts.stop_before_kinds);
+      if (held.length > 0) {
+        throw new RunAbortedError(
+          "checkpoint",
+          `stopped before ${held.join(", ")} \u2014 everything up to here is done and cached, so continuing this run id pays for none of it again`
+        );
+      }
       const settled = await mapWithConcurrency(layer, limit, (nodeId) => {
         if (opts.signal?.aborted) {
           return Promise.reject(new RunAbortedError("signal", "run aborted before node dispatch"));
@@ -6022,8 +6121,9 @@ async function ingestImageUrl(url, ctx) {
   } catch (e) {
     throw localExecError(ctx, `${url}: ${e.message}`);
   }
-  const note = normalizationNote(normalized);
-  if (note) ctx.log(`ingest: ${url} ${note}`);
+  if (normalized.rasterizedFrom) {
+    ctx.log(`ingest: normalized ${normalized.rasterizedFrom} URL -> PNG (${normalized.bytes.length}B)`);
+  }
   return uploadAndIngest({
     bytes: normalized.bytes,
     kind: "image",
@@ -6133,69 +6233,23 @@ async function rasterizeSvgToPng(bytes) {
   return await sharp(bytes, { density }).png({ force: true, palette: false }).toBuffer();
 }
 var MODEL_SAFE_IMAGE_MIMES = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
-var MAX_MODEL_REFERENCE_BYTES = 30 * 1024 * 1024;
-async function fitWithinReferenceLimit(bytes, mime, maxBytes) {
-  if (bytes.byteLength <= maxBytes) return { bytes, mime };
-  const { default: sharp } = await import("sharp");
-  const read = () => sharp(bytes, { animated: true });
-  const meta = await read().metadata();
-  const animated = (meta.pages ?? 1) > 1;
-  const keepAlpha = meta.hasAlpha === true;
-  const width = meta.width ?? 0;
-  const encode = async (scale2) => {
-    let pipeline2 = read();
-    if (scale2 < 1 && width > 0) pipeline2 = pipeline2.resize({ width: Math.max(256, Math.round(width * scale2)) });
-    if (animated && mime === "image/gif") return { bytes: await pipeline2.gif().toBuffer(), mime: "image/gif" };
-    if (animated || keepAlpha) return { bytes: await pipeline2.webp({ quality: 90 }).toBuffer(), mime: "image/webp" };
-    return { bytes: await pipeline2.jpeg({ quality: 90, mozjpeg: true }).toBuffer(), mime: "image/jpeg" };
-  };
-  let out = await encode(1);
-  let scale = 1;
-  for (let pass = 0; pass < 4 && out.bytes.byteLength > maxBytes; pass++) {
-    scale *= Math.min(0.9, Math.sqrt(maxBytes / out.bytes.byteLength));
-    out = await encode(scale);
-  }
-  return out;
-}
-async function toModelSafeImage(bytes, opts) {
-  const maxBytes = opts?.maxBytes ?? MAX_MODEL_REFERENCE_BYTES;
-  const fit = async (candidate, mime, rasterizedFrom) => {
-    const fitted = await fitWithinReferenceLimit(candidate, mime, maxBytes);
-    return {
-      bytes: fitted.bytes,
-      mime: fitted.mime,
-      ...rasterizedFrom ? { rasterizedFrom } : {},
-      ...fitted.bytes === candidate ? {} : { shrunkFromBytes: candidate.byteLength }
-    };
-  };
+async function toModelSafeImage(bytes) {
   const safe = sniffImageMime(bytes);
   if (safe && MODEL_SAFE_IMAGE_MIMES.has(safe)) {
-    return await fit(bytes, safe);
+    return { bytes, mime: safe };
   }
   if (sniffSvg(bytes)) {
-    return await fit(await rasterizeSvgToPng(bytes), "image/png", "svg");
+    return { bytes: await rasterizeSvgToPng(bytes), mime: "image/png", rasterizedFrom: "svg" };
   }
   const { default: sharp } = await import("sharp");
-  let png;
-  let format;
   try {
     const img = sharp(bytes);
-    format = (await img.metadata()).format ?? "unknown";
-    png = await img.png({ force: true }).toBuffer();
+    const format = (await img.metadata()).format;
+    const png = await img.png({ force: true }).toBuffer();
+    return { bytes: png, mime: "image/png", rasterizedFrom: format ?? "unknown" };
   } catch (e) {
     throw new Error(`bytes are not a decodable image (${e.message})`);
   }
-  return await fit(png, "image/png", format);
-}
-function normalizationNote(image) {
-  const parts = [];
-  if (image.rasterizedFrom) parts.push(`normalized ${image.rasterizedFrom} -> ${image.mime}`);
-  if (image.shrunkFromBytes !== void 0) {
-    parts.push(
-      `fitted ${image.shrunkFromBytes}B -> ${image.bytes.length}B as ${image.mime} (providers refuse a reference over ${MAX_MODEL_REFERENCE_BYTES}B)`
-    );
-  }
-  return parts.length > 0 ? parts.join("; ") : null;
 }
 function hasAscii(buf, offset, sig) {
   return buf.length >= offset + sig.length && buf.toString("ascii", offset, offset + sig.length) === sig;
@@ -6325,8 +6379,7 @@ async function execLocalFile(params, ctx) {
     outBytes = normalized.bytes;
     outMime = normalized.mime;
     rasterizedFrom = normalized.rasterizedFrom;
-    const note = normalizationNote(normalized);
-    if (note) ctx.log(`ingest: ${note}`);
+    if (rasterizedFrom) ctx.log(`ingest: normalized ${rasterizedFrom} -> PNG (${outBytes.length}B)`);
   }
   const durationMs = probeVideoDurationMs(params.expect, outBytes, ctx);
   const ref = await uploadAndIngest({
@@ -7298,6 +7351,24 @@ import { execFile as execFile3 } from "child_process";
 import { readFile as readFile9 } from "fs/promises";
 import path12 from "path";
 import { promisify as promisify3 } from "util";
+
+// src/engine/nodes/local/lib/caption-style.ts
+var TERMINAL = /[.,;:!?…]$/;
+function captionTextsFrom(html) {
+  const cards = html.match(/<div[^>]*class="[^"]*\bcaption\b[^"]*"[\s\S]*?<\/div>/g) ?? [];
+  return cards.map(
+    (card) => card.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim()
+  ).filter((text) => text.length > 0);
+}
+function fragmentedCaptions(texts) {
+  if (texts.length < 2) return null;
+  const fragments = texts.slice(0, -1).filter((t) => !TERMINAL.test(t));
+  if (fragments.length === 0) return null;
+  const example = fragments[0];
+  return `${fragments.length} of ${texts.length} caption cards end mid-clause, e.g. "${example}". Split captions where the script punctuates, not on a word count \u2014 a card that ends bare is a sentence cut in half by a timing decision, and it reads as one.`;
+}
+
+// src/engine/nodes/local/lib/hyperframe-check.ts
 var execFileAsync = promisify3(execFile3);
 var NEVER_BLOCK = [
   /contrast/i,
@@ -7366,6 +7437,74 @@ function classifyCheckOutput(lintRaw, inspectRaw) {
     warnings: findings.filter((f) => f.severity === "warning")
   };
 }
+var GATE_SECTIONS = ["lint", "runtime", "layout", "motion", "contrast"];
+function buildCheckArgs(dir, samples) {
+  return ["hyperframes", "check", dir, "--json", "--samples", String(samples), "--at-transitions"];
+}
+var PROMOTE_TO_BLOCKING = /GSAP target [^ ]+ not found|no deterministic font mapping/i;
+function toGateFinding(section, entry) {
+  const f = entry;
+  const code = typeof f.code === "string" ? f.code : "unknown";
+  const message2 = typeof f.message === "string" ? f.message : "";
+  const isError = f.severity === "error" || PROMOTE_TO_BLOCKING.test(message2);
+  const fatal = PROMOTE_TO_BLOCKING.test(message2);
+  return {
+    source: section,
+    code,
+    message: message2,
+    severity: fatal || isError && !isAdvisory(code, message2) ? "blocking" : "warning"
+  };
+}
+function classifyGateOutput(raw) {
+  const parsed = parseCheckJson(raw);
+  const findings = GATE_SECTIONS.flatMap((section) => {
+    const block = parsed?.[section];
+    const entries = Array.isArray(block?.findings) ? block.findings : [];
+    return entries.map((entry) => toGateFinding(section, entry));
+  });
+  return {
+    blocking: findings.filter((f) => f.severity === "blocking"),
+    warnings: findings.filter((f) => f.severity === "warning")
+  };
+}
+function summariseWarnings(warnings) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const w of warnings) {
+    const key = `${w.source}/${w.code}`;
+    const seen = groups.get(key);
+    if (seen) seen.count += 1;
+    else groups.set(key, { count: 1, message: w.message });
+  }
+  return [...groups.entries()].sort((a, b) => b[1].count - a[1].count).map(([key, g]) => `${g.count}\xD7 [${key}] ${g.message}`);
+}
+var FINDING_ADVICE = {
+  sweep_static: "the timeline never advanced, so this renders as a STILL IMAGE while billing like a video \u2014 and every other green verdict in this run is unreliable. Check the composition registers a paused timeline on `window.__timelines[<composition-id>]` and that the tweens target elements that exist.",
+  console_error: "the composition threw in the browser, so whatever that script was driving did not happen.",
+  page_error: "a script failed to evaluate \u2014 animations and any JS-driven layout in this composition did not run.",
+  http_error: "an asset 404ed at render time; it will be missing from the frame, not substituted.",
+  console_warning: "if this names a GSAP target, the element it animates does not exist, so that tween is a no-op and whatever it was meant to reveal never appears. Fix the selector or add the element before rendering."
+};
+function explainGateFinding(finding) {
+  const advice = FINDING_ADVICE[finding.code];
+  return advice ? `${finding.message} \u2014 ${advice}` : finding.message;
+}
+function condenseFrameDescriptions(markdown) {
+  const lines = [];
+  let frame = null;
+  for (const line of markdown.split("\n")) {
+    const heading = line.match(/^## (.+)$/);
+    if (heading) {
+      frame = heading[1] ?? null;
+      continue;
+    }
+    const text = line.trim();
+    if (frame && text) {
+      lines.push(`${frame}: ${text}`);
+      frame = null;
+    }
+  }
+  return lines;
+}
 function buildLintArgs(dir) {
   return ["hyperframes", "lint", dir, "--json"];
 }
@@ -7397,8 +7536,13 @@ async function lintStructuralIssues(dir, timeoutMs) {
 function buildInspectArgs(dir, samples) {
   return ["hyperframes", "inspect", dir, "--json", "--samples", String(samples)];
 }
-function buildSnapshotArgs(dir, frames) {
-  return ["hyperframes", "snapshot", dir, "--frames", String(frames), "--describe", "false"];
+function buildSnapshotArgs(dir, frames, vision) {
+  const base = ["hyperframes", "snapshot", dir, "--frames", String(frames)];
+  return vision ? [
+    ...base,
+    "--describe",
+    "Answer four things about this frame. (1) Is it empty or near-empty? Name every element actually visible. (2) Could what is shown physically happen \u2014 object sizes, human scale, and whether every object has its real-world form (a phone has ONE screen, on its front). Say so plainly if something is impossible. (3) Read out every number, currency symbol and word visible INSIDE the picture \u2014 phone screens, documents, signage \u2014 and say whether any of it contradicts the caption on this frame. (4) Is the caption legible against what is behind it?"
+  ] : [...base, "--describe", "false"];
 }
 function usesNestedCompositions(indexHtml) {
   const withoutComments = indexHtml.replace(/<!--[\s\S]*?-->/g, "");
@@ -7427,44 +7571,66 @@ async function runSnapshotSmoke(args, timeoutMs) {
     return { ok: false, unavailable: false, message: (err.stderr || err.message || "snapshot failed").slice(0, 800) };
   }
 }
-async function runHyperframesCheck(opts) {
-  const { dir, nodeId, ctx, timeoutMs, samples = 5 } = opts;
+async function runNestedCompositionSmoke(opts) {
+  const { dir, nodeId, ctx, timeoutMs, samples } = opts;
+  const indexHtml = await readFile9(path12.join(dir, "index.html"), "utf-8").catch(() => "");
+  if (!indexHtml || !usesNestedCompositions(indexHtml)) return;
+  const snap = await runSnapshotSmoke(
+    buildSnapshotArgs(dir, Math.min(samples, 3), hasFrameVisionKey()),
+    Math.max(timeoutMs, 12e4)
+  );
+  if (snap.unavailable) {
+    ctx.log(`${nodeId}: hyperframes snapshot unavailable \u2014 skipping nested-composition smoke test`);
+    return;
+  }
+  if (!snap.ok) {
+    throw new Error(
+      `${nodeId}: nested-composition smoke test failed \u2014 an embedded block did not render. Check the host\u2194block id match, that the block's <style>/<script> live inside its <template>, and that it styles #root (not a class).
+${snap.message}`
+    );
+  }
+  const described = await readFile9(path12.join(dir, "snapshots", "descriptions.md"), "utf-8").catch(() => "");
+  for (const line of condenseFrameDescriptions(described)) {
+    ctx.log(`${nodeId}: frame check \u2014 ${line}`);
+  }
+  ctx.log(`${nodeId}: nested-composition smoke test passed`);
+}
+async function runGate(dir, timeoutMs, samples) {
+  const checkRaw = await runOne(buildCheckArgs(dir, samples), timeoutMs);
+  if (checkRaw !== null) return classifyGateOutput(checkRaw);
   const [lintRaw, inspectRaw] = await Promise.all([
     runOne(buildLintArgs(dir), timeoutMs),
     runOne(buildInspectArgs(dir, samples), timeoutMs)
   ]);
-  if (lintRaw === null && inspectRaw === null) {
-    ctx.log(`${nodeId}: hyperframes lint/inspect unavailable \u2014 skipping pre-render check`);
+  if (lintRaw === null && inspectRaw === null) return null;
+  return classifyCheckOutput(lintRaw ?? "", inspectRaw ?? "");
+}
+async function runHyperframesCheck(opts) {
+  const { dir, nodeId, ctx, timeoutMs, samples = 5 } = opts;
+  const gate = await runGate(dir, timeoutMs, samples);
+  if (gate === null) {
+    ctx.log(`${nodeId}: hyperframes check/lint/inspect unavailable \u2014 skipping pre-render check`);
     return;
   }
-  const { blocking, warnings } = classifyCheckOutput(lintRaw ?? "", inspectRaw ?? "");
-  for (const w of warnings) {
-    ctx.log(`${nodeId}: hyperframe check warning [${w.source}/${w.code}] ${w.message}`);
+  const { blocking, warnings } = gate;
+  for (const line of summariseWarnings(warnings)) {
+    ctx.log(`${nodeId}: hyperframe check warning ${line}`);
   }
   if (blocking.length > 0) {
-    const detail = blocking.map((b) => `\u2022 [${b.source}/${b.code}] ${b.message}`).join("\n");
-    throw new Error(`${nodeId}: pre-render check failed (${blocking.length} blocking)
-${detail}`);
-  }
-  let indexHtml = "";
-  try {
-    indexHtml = await readFile9(path12.join(dir, "index.html"), "utf-8");
-  } catch {
-    indexHtml = "";
+    const seen = /* @__PURE__ */ new Map();
+    for (const b of blocking) seen.set(`${b.source}/${b.code}/${b.message}`, b);
+    const detail = [...seen.values()].map((b) => `\u2022 [${b.source}/${b.code}] ${explainGateFinding(b)}`).join("\n");
+    throw new Error(
+      `${nodeId}: pre-render check failed (${blocking.length} blocking, ${seen.size} distinct)
+${detail}`
+    );
   }
-  if (indexHtml && usesNestedCompositions(indexHtml)) {
-    const snap = await runSnapshotSmoke(buildSnapshotArgs(dir, Math.min(samples, 3)), Math.max(timeoutMs, 12e4));
-    if (snap.unavailable) {
-      ctx.log(`${nodeId}: hyperframes snapshot unavailable \u2014 skipping nested-composition smoke test`);
-    } else if (!snap.ok) {
-      throw new Error(
-        `${nodeId}: nested-composition smoke test failed \u2014 an embedded block did not render. Check the host\u2194block id match, that the block's <style>/<script> live inside its <template>, and that it styles #root (not a class).
-${snap.message}`
-      );
-    } else {
-      ctx.log(`${nodeId}: nested-composition smoke test passed`);
-    }
+  const composition = await readFile9(path12.join(dir, "index.html"), "utf-8").catch(() => "");
+  const captionComplaint = fragmentedCaptions(captionTextsFrom(composition));
+  if (captionComplaint) {
+    ctx.log(`${nodeId}: caption style \u2014 ${captionComplaint}`);
   }
+  await runNestedCompositionSmoke({ dir, nodeId, ctx, timeoutMs, samples });
   ctx.log(`${nodeId}: pre-render check passed (${warnings.length} warning${warnings.length === 1 ? "" : "s"})`);
 }
 
@@ -8971,7 +9137,14 @@ async function tryExtractAudio(inputs, ctx) {
 import { z as z34 } from "zod";
 var voiceSelectNode = delegated({
   id: "voice_select",
-  version: "1.0.0",
+  // 1.1.0: a pinned voice used to come back as an inline `{ kind, text }` with no sha256
+  // and no mime, which every consumer taking the id as an INPUT rejected —
+  // `audio_voice_convert` died on `voice_ref.sha256: expected string, received undefined`.
+  // The backend now uploads it as a real asset like the ranked branch, and the version has
+  // to move with it: the cache key is built from this string, so entries written under
+  // 1.0.0 kept replaying the broken shape long after the fix was deployed. A node whose
+  // OUTPUT shape changes has to bump, not only one whose behaviour does.
+  version: "1.1.0",
   category: "audio",
   summary: 'Cast an ElevenLabs voice from a natural-language description (e.g. "warm, authoritative female narrator, American accent"). Lists the account\'s voices and ranks them against the brief, emitting the best `voice_id` as a bare-string text asset plus a ranked `candidates` JSON.',
   when_to_use: 'Use to turn a voice description (e.g. from a `video_deconstruct` blueprint\'s `voice_description`) into a usable ElevenLabs voice id, then feed it into a `tts` node by wiring `inputs.voice_ref: $ref:<this>.voice_id` and setting `params.voice: "{{voice_ref}}"` \u2014 the engine splices the id in at run time. Review `candidates` (json) to pick a different voice. Optional `gender`/`age`/`accent`/`language` hints sharpen the ranking.',
@@ -8982,6 +9155,11 @@ var voiceSelectNode = delegated({
     age: z34.string().optional(),
     accent: z34.string().optional(),
     language: z34.string().optional(),
+    /**
+     * A voice already chosen — an Avatar's pinned one. Given, nothing is cast: the
+     * ranking is skipped and this id is emitted as-is.
+     */
+    voice_id: z34.string().min(1).max(120).optional(),
     limit: z34.number().int().min(1).max(20).optional()
   }).strict(),
   outputs: z34.object({ voice_id: TextRef, candidates: JsonRef }).strict(),
@@ -9144,6 +9322,7 @@ export {
   describeFailureReason,
   AD_FORMAT_PLATFORMS,
   platformFormats,
+  frameRealismDirection,
   SEEDANCE_DURATIONS,
   ELEVENLABS_MAX_MUSIC_LENGTH_MS,
   IMAGE_GENERATE_MODELS,
@@ -9159,6 +9338,7 @@ export {
   promptMaxLength,
   maxInputSlot,
   maxInputReferences,
+  bestSupportedQuality,
   nearestSupportedAspectRatio,
   nearestSupportedImageSize,
   estimateVideoCredits,
@@ -9199,4 +9379,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-NNQDWCFG.js.map
+//# sourceMappingURL=chunk-LTXNRRXW.js.map