@koda-sl/baker-cli 0.270.0 → 0.270.1-dev.0c9e3df08

package/README.md

@@ -1248,7 +1248,7 @@ Shared flags: `--days <n>` (default 30) or `--start-date` / `--end-date` (`YYYY-
 - The `sparkline` on `landings` is dropped unless `--full`, and resampled to 30 points when present. It is bucketed by `--granularity` upstream, so ninety days at `hour` is 2,160 numbers per page.
 - Past ~25 rows the response carries a hint naming the row count and pointing at `--output md`.
 
-**Paging the list reports.** `people`, `submissions` and `delivery` are lists of individual things rather than breakdowns — `delivery` and `submissions` are the ones the CLI exposes, `people` backs the dashboard's People screen over the same wire — and only they take `--page <n>` (1-based) and `--page-size <n>` (up to 200, default 50). The response carries `pageInfo` with `hasMore` — when it is true there **are** more rows, so a total must never be reported from one page. Pass neither flag and a list comes back at the size it always did.
+**Paging the list reports.** `people`, `submissions` and `delivery` are lists of individual things rather than breakdowns — `delivery` and `submissions` are the ones the CLI exposes, `people` backs the People section of the dashboard's landing Analytics screen over the same wire — and only they take `--page <n>` (1-based) and `--page-size <n>` (up to 200, default 50). The response carries `pageInfo` with `hasMore` — when it is true there **are** more rows, so a total must never be reported from one page. Pass neither flag and a list comes back at the size it always did.
 
 **A conversion is a company-level named event, not a property of a Form.** `baker analytics conversions` is the only place "what counts" is decided, and an empty `definitions` list means every conversion number in every other report is zero — not because nobody converted, but because nothing is named as an outcome and Baker never guesses which event is the point of a page. `--candidates` lists every event these pages actually produced — each Form step and trigger, every `data-baker-*` event, every outbound destination — with volume and whether it is already counted; that list is where an event key comes from, so never invent one. `--event <key> --name "Booked a call"` starts counting it **immediately and retroactively**: the whole stored history is rescored, so naming the right event today also fixes last month. Nothing here is staged and publishing is not involved. Two events given the same `--name` become one row and one number, which is how a call booked on three different Forms reads as one outcome. `--count-mode every_time` is for the outcomes people genuinely repeat (a guide downloaded twice is two downloads); the default counts once per visit. One outcome per call — repeating `--event` is refused rather than silently keeping the last one.
 
@@ -2820,7 +2820,7 @@ baker avatars create --name "Marta" --subject "…" \
   --source-image "<imageId1>,<imageId2>" --likeness-confirmed
 ```
 
-Optional: `--handle`, `--speech`, `--motion`, `--setting`, `--voice-id`, `--voice-description`. Returns `{ avatarId, handle, likeness, status }`.
+Optional: `--handle`, `--speech`, `--motion`, `--setting`, `--accent`. Returns `{ avatarId, handle, likeness, status }`.
 
 #### `baker avatars update <handle>`
 
@@ -2829,7 +2829,7 @@ Edit an avatar. Profile flags are merged over the stored profile, so `--persona`
 ```bash
 baker avatars update marta --wardrobe "charcoal blazer over a white tee"
 baker avatars update marta --subject "woman in her early 50s, silver bob, …" --regenerate-sheet
-baker avatars update marta --new-handle marta-founder --voice-id <voiceId>
+baker avatars update marta --new-handle marta-founder --accent "Spanish from Spain, Madrid accent"
 ```
 
 #### `baker avatars delete <handle>`
@@ -3521,6 +3521,7 @@ Reach for it when you are relaying the **client's** own words. When you are writ
 
 ```bash
 baker studio animate "slow push in, model turns to camera and smiles" --image j57abc123def456ghi789
+baker studio animate "she looks to camera and says: \"Hola, soy Elena\"" --avatar elena --quality 720p --aspect-ratio 9:16
 baker studio animate "handheld drift right, steam rising from the cup" \
   --image ./out/hero.png --duration 6 --quality 1080p
 baker studio animate "product rotates once on a turntable" --image j57abc…,j57def… --from references
@@ -3670,6 +3671,65 @@ baker canvas set-prompt my-canvas.json s0_start --text "Close-up, flushed and br
 baker canvas set-prompt my-canvas.json s0_start --text-file ./hook-frame.txt
 ```
 
+#### The brand, the ending and the cast are drawn, not generated
+
+`baker canvas scaffold-ad` renders everything with a known, fixed appearance locally,
+because a video model garbles a wordmark every time:
+
+- **`brand.logo`** — the repo path to the mark. It is copied into the overlay composition
+  and drawn as a real `<img>`: small top-left for the whole ad, large on the closing card.
+- **`end_card`** — on by default whenever the spec carries a brand. The last beat's PICTURE
+  becomes a flat brand colour plate (rendered by ffmpeg, not generated), with the mark and
+  the call to action over it. `end_card: false` keeps the footage; `end_card: { cta }` sets
+  the words on the button, which otherwise default to the last line of the script.
+- **The brand fills itself.** When the spec leaves `brand.logo` or `brand.palette` empty,
+  they are read from the workspace — `src/brand/BRAND.md` for the colours (in document
+  order, page-furniture whites and blacks dropped) and `src/brand/logos/` for the mark
+  (vector first, plain mark over a mono/white/icon variant). Pass them yourself only when
+  the ad needs something other than the client's default.
+- **The spoken language is read off the script** when the spec does not declare it, so a
+  Spanish ad is cast from Spanish voices without anyone having to say so.
+- **`sound`** (per beat) — one sound effect for that shot, rendered by ElevenLabs
+  alongside the music bed. Most beats should not have one: it belongs where the picture
+  shows a specific physical event (a drill, a door, rain on glass), not on a talking head
+  or a calm lifestyle shot. A bed plus two well-placed effects beats eight.
+- **A real brand mark is required.** `scaffold-ad` refuses to build without one in
+  `src/brand/logos/` (SVG or PNG): the mark is drawn on every frame and on the closing
+  card, so a stand-in ships an ad wearing the wrong brand.
+- **An avatar with no pinned voice cannot speak on camera.** Their lines would be read by
+  a separately cast voice, which is dubbing and looks like it.
+- **`voiceover: false`** — a music-led ad. No voice, no transcription: the `say` lines
+  become on-screen text and are captioned straight from the script, so the words are
+  exact. Give it `music` too.
+- **`--avatar <handle>`** — the same flag as on `studio generate` / `studio animate`, and the way to cast a person into an ad. Overrides `cast.avatar` in the spec.
+- **`cast.avatar`** — the handle of a cast Avatar (`baker avatars list`). The ad grounds
+  every beat they appear in on that avatar's identity sheet and copies its subject
+  description verbatim, so the ad shows the same face as the rest of the company's work.
+  This is the whole journey: `baker avatars create` → `cast.avatar` in the spec → render.
+- **`cast.description`** — a person described in words, when there is no avatar.
+
+Each of these also removes a generation: the closing beat costs no image and no clip.
+
+#### The finished video is reviewed
+
+When a run's output is a video, `baker canvas run` samples twelve frames across it and
+looks at them before reporting success. It reports, never blocks — the clips are already
+paid for by the time it runs — and the findings come back as `review` and `hints`:
+
+- **Per frame:** anything that could not physically happen, or shows a job being done
+  incorrectly, plus objects floating unattached in shot. Malformed hands and limbs are
+  rolled up into one finding across the whole render rather than repeated per frame.
+- **Across the reel:** whether the cast stays the same people, whether a brand mark is
+  visible anywhere, and whether the last frames close the ad or simply stop.
+
+Each per-frame finding names the **scene file** that produced that second, so a defect is
+an edit rather than a hunt — and re-running re-renders only the scenes you changed.
+
+It needs `GEMINI_API_KEY` (the Runtime receives it automatically). Without one the run
+says the video was **not** reviewed rather than reporting it clean, and a frame that
+could not be read is reported as unchecked for the same reason.
+
+
 > Scaffolded canvases use **workspace-relative** composition/asset paths and are validated
 > against the engine's hyperframe pre-render gate at `validate` time, so a broken overlay
 > (or a moved/renamed workspace) is caught before any billed clip. The scaffold also adds
@@ -5831,7 +5891,18 @@ This CLI is designed for AI agent consumption. Key patterns:
 
 - **0.217.0**: new family `baker avatars list|get|create|update|delete`, plus `--avatar <handle>` on `baker studio generate` and `baker studio animate` — company-scoped reusable presenters, typed from the shared `@baker/api` avatars contract. `--avatar` is the way to cast one: it grounds the render on the identity sheet, reuses the subject description verbatim, and records the avatar on the batch. Passing the sheet through `--reference` instead does none of those and leaves the batch unattributed, so the avatar can never show what it has appeared in; the route refuses a handle that is not `ready`, because generating a stranger is worse than an error. `get` returns the sheet URL and that description; every command's `hints` carry the next move (still building → re-check with `get`; changed `--subject` without `--regenerate-sheet` → the sheet is stale). `create` refuses `--source-image` without `--likeness-confirmed` and returns an `error.fix` telling the agent to ask the user for that permission, since only they can give it; an unknown handle returns an `error.fix` pointing at `baker avatars list`. Profile flags on `update` merge over the stored profile instead of replacing it.
 
-## Publishing
+- **0.250.1**: `--avatar <handle>` on `baker studio generate` and `baker studio animate` never worked. Both were declared in `registerSchema` and read at the call site, but neither was in the command's own citty `args` — and citty does not reject an undeclared flag, it keeps it and sets it to `true`. So `--avatar elena` reached the route as `avatar: true` with `elena` dropped as a stray positional, and the body schema (`z.string()`) refused it. Documented since 0.217.0, broken since 0.217.0: casting an avatar into a render was not possible from the CLI at all, which is why a clip of a named presenter came back with neither the identity sheet nor the voice. Both flags are now declared. A new test in `command-reference-integrity` compares every registered schema against the args of the command that parses it, so the two cannot drift again — it found a third case on the way, `actions status`, whose schema advertised a `--refs` flag for what the command actually takes as positionals.
+- **0.251.0**: `--accent` on `baker avatars create|update` — the region an avatar's voice comes from, e.g. `"Spanish from Spain, Madrid accent"`. Its own field rather than a sentence inside `--speech`, because that is where it went to die: asked for "pace, register, accent", the agent wrote *"clear Spanish accent"* for a Madrid presenter, the video model read that as no accent, and the clip came out sounding like nowhere. A place can be checked; an adjective cannot. It reaches the render through `buildDeliveryDirection` as its own `ACCENT:` instruction, and `thinProfileHint` now names it first among the missing fields since it is the only one that fails silently — a clip with no accent still looks finished.
+- **0.252.0**: avatar voices removed. `--voice-id` / `--voice-description` are gone from `baker avatars create|update`, and an avatar no longer holds a voice at all — every clip is voiced by the video model as it renders, directed by the profile's `--accent`. The picker they replaced offered a voice, played its preview, and then shipped a clip that did not sound like it: the re-voice was speech-to-speech, which replaces timbre and keeps pronunciation, so the accent the user picked could never survive. Three other routes were built and judged on video before removing it — TTS + lip-sync (mouth), audio-driven avatar models (picture), and Seedance 2.5 driven by audio (refuses AI faces). Reasoning and the re-open condition: `docs/adr/0005-an-avatar-is-a-face-not-a-voice.md`.
+- **0.253.0**: the pre-render gate runs `hyperframes check` — lint, runtime, layout, motion and contrast in one browser session, sampled at transition seams — instead of the static `lint` + `inspect` pair, falling back to them when the installed binary predates `check`. The browser half is signal the parser could never produce: measured on HyperFrames' own `warm-grain` example, lint/runtime/layout/motion all reported `ok: true` while the composition rendered an almost entirely blank ten-second video, the only trace being six `GSAP target #a-roll not found` warnings — a tween pointed at an element that does not exist, so nothing it animates ever appears. Baker promotes that warning to blocking, alongside `sweep_static` ("the timeline never advanced", i.e. a still image billed as a video). Warnings are grouped by code with a count (one run returned 62, 53 of them identical) and the highest-value findings carry advice on what to do rather than only what was seen. Requires `hyperframes@0.8.17` in the sandbox, bumped from 0.7.5 in the same change. Reasoning: `docs/adr/0007-the-render-gate-runs-in-a-browser.md`.
+- **0.254.0**: the nested-composition smoke test now looks at the frames instead of trusting the exit code — exiting 0 is what a blank render does too. `hyperframes snapshot --describe` sends the captured frames to Gemini and writes back what is actually in them, and the credential Studio already uses for Gemini and Omni (`GOOGLE_GENERATIVE_AI_API_KEY`) is the `GEMINI_API_KEY` it reads; the backend now ships it to the sandbox by omission, so a deployment without one keeps the plain smoke test. Verified against a real render: the pass reported "the image is completely empty" and named the single visible element without being told what to look for. Frame verdicts are condensed into the node log, one line per frame — a file the agent would have to know to open is a file it does not read.
+- **0.263.0**: shot briefs refuse the frame that contradicts its own caption, and the vision pass reads the numbers back. Observed verbatim: a phone screen reading "$215.40 SAVED THIS MONTH" under a caption reading "Save over £900 a year" — wrong currency, and a figure that contradicts the claim it sits beneath, since 215.40 a month is 2,584 a year. The model invents a number whenever a screen or document is in shot, so the frames no longer carry legible text at all: the caption track is where an ad's numbers live. Same brief also pins each object's real-world FORM after a phone rendered with a second screen on its back, and names the market's currency for anything unavoidably visible. The frame-vision question now reads out every number and word inside the picture and says whether it contradicts the caption — the defect only exists between the two, so neither alone can see it.
+- **0.262.0**: `scaffold-ad` carries the brand. The spec takes `brand.palette` (hex tokens) and `brand.logo` (repo path to the mark), and emits them as the `style.palette` and `branding` the engine already reads to colour its brand plate and CTA. The palette dresses the plate and the type and is deliberately kept OUT of the shot briefs — hex in a frame prompt makes the model paint the whole scene that colour, which reads as a filter. Also takes `market`, since an ad that does not say where it is set is an ad the model sets wherever it likes.
+- **0.261.0**: four defects that reached a finished ad, fixed in `scaffold-ad` where they originate. Frames render on **`openai/gpt-image-2`**, pinned rather than inheriting the catalogue default (Gemini Flash — right for cheap high-volume work, wrong for the opening still a five-second clip is built from). Every shot brief now states the MARKET, inferred from the voice language when unstated: an ad for Spain came back full of British houses because nothing said where it was. Every shot brief also rules out the impossible — paper and screens are opaque, objects are at real-world scale — after a bill rendered with the text from its reverse showing through, and a solar panel five metres tall. And beat durations snap to lengths the video model can actually render: free-form durations were rounded down per clip, so 11 beats summed to 27.0s of picture against a 31.4s timeline and the 4.4s difference rendered as a black tail. The read rate was re-measured off a real Spanish ad (81 words in 26.48s = 3.06 w/s); the old 2.6 over-predicted every beat by 18%.
+- **0.260.0**: burned-in captions break where the script punctuates instead of every N words. The karaoke composition sliced the transcript into fixed groups, and a word count knows nothing about the sentence it is cutting — an ad the engine rendered showed cards reading "OTRA VEZ, EN" and "TU CASA GENERA", half-thoughts ending on a preposition. A card now closes when the clause does; the word count stays as a ceiling so a long clause is still split, and a linking word ("de", "al", "y") never ends a card because it belongs to what follows. Same rule the pre-render gate already checked for, now enforced where the cards are actually built.
+- **0.259.0**: `baker canvas scaffold-ad` is listed in `baker canvas --help` with a description, and the three video routes are separated in the skill. It had a usage line and no description row, so an agent reading help saw two scaffolders explained and a bare name — and three runs from the same prompt took three different wrong paths: hand-directing the flow, reproducing a competitor ad found via `winning-ads`, and hand-authoring a canvas. The routes now state their own boundary: `scaffold-ad` is the default for a new ad, `scaffold-video` only reproduces a video the USER supplied, and `video-flow.md` opens by saying so rather than calling itself the default eleven times.
+- **0.257.0**: the frame-vision pass now asks whether what is on screen could physically happen, not just whether the frame is empty. The defect that motivated it was a generated shot of a solar panel roughly five metres tall being lifted onto a roof by one person — well lit, on brief, perfectly legible, and impossible. That is what reads loudest as "AI-generated", and the previous question could not see it: nothing was missing, something present was the wrong size. Asked the new question, the pass called the rejected shot *"physically implausible due to the immense weight and surface area"* and the replacement *"consistent with what two people could reasonably maneuver"* — the same verdict a person reached, unprompted.
+- **0.256.0**: the pre-render gate reports caption cards that end mid-clause. The first cut of this check asked for consistency and got it the wrong way round — stripping terminal punctuation makes the cards agree and leaves them wrong, because "En solo nueve días tu casa" is not a line anyone wrote, it is a sentence halved by a word count. Captions split where the script punctuates; each card is then a clause carrying its own mark, grammatical, and consistent as a by-product. The last card is exempt, since a CTA legitimately ends bare. Reported, never rewritten — the copy belongs to whoever wrote it.
 
 ### Auto-publish (CI)
 

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

@@ -35,6 +35,10 @@
 
       .caption-group {
         position: absolute;
+        /* Absolutely positioned with no width, a card sizes to its content and
+           runs off the 1080px frame rather than wrapping. Matches the container's
+           60px gutters, so a long clause becomes two lines instead of an overflow. */
+        max-width: 960px;
         font-family: 'Arial Black', 'Helvetica Neue', sans-serif;
         font-size: {{font_size}}px;
         font-weight: 900;
@@ -80,10 +84,27 @@
         const container = document.getElementById('captions');
         const tl = gsap.timeline({ paused: true });
 
+        // A card closes where the SCRIPT closes, not on a word count. Slicing every
+        // N words gave cards reading "OTRA VEZ, EN" — half a thought ending on a
+        // preposition. The count stays as a ceiling (a long clause still has to be
+        // split), and a linking word never ends a card: it belongs to what follows.
+        const CLOSES = /[.,;:!?\u2026]$/;
+        const CARRIES_ON = new Set([
+          'de','del','al','a','en','y','e','o','u','que','la','el','los','las','un','una',
+          'con','por','para','su','tu','mi','más','mas','the','of','to','and','in','for','your',
+        ]);
+        const carriesOn = (w) => CARRIES_ON.has(String(w.text || '').replace(/[.,;:!?\u2026]$/, '').toLowerCase());
+
         const groups = [];
-        for (let i = 0; i < transcript.length; i += WORDS_PER_GROUP) {
-          groups.push(transcript.slice(i, i + WORDS_PER_GROUP));
+        let current = [];
+        for (const word of transcript) {
+          current.push(word);
+          const last = current[current.length - 1];
+          const closes = CLOSES.test(String(last.text || '')) ||
+            (current.length >= WORDS_PER_GROUP && !carriesOn(last));
+          if (closes) { groups.push(current); current = []; }
         }
+        if (current.length > 0) groups.push(current);
 
         groups.forEach((group, gi) => {
           const el = document.createElement('div');

package/dist/{chunk-2IB3IL4K.js → chunk-2IUN3S3E.js}

@@ -1,6 +1,6 @@
 import {
   debugLogSetting
-} from "./chunk-DZUVUGEP.js";
+} from "./chunk-WFWU3CHS.js";
 
 // src/debugLog.ts
 import { appendFileSync, mkdirSync, renameSync, statSync } from "fs";
@@ -150,4 +150,4 @@ export {
   readBodyForLog,
   installStreamTaps
 };
-//# sourceMappingURL=chunk-2IB3IL4K.js.map
+//# sourceMappingURL=chunk-2IUN3S3E.js.map

package/dist/{chunk-6F52WYB7.js → chunk-ARUM5SYE.js}

@@ -1,10 +1,10 @@
 import {
   ApiError,
   apiGet
-} from "./chunk-GU7IWEBC.js";
+} from "./chunk-KDTHRRAC.js";
 import {
   getEnv
-} from "./chunk-DZUVUGEP.js";
+} from "./chunk-WFWU3CHS.js";
 
 // src/error-handler.ts
 var REQUEST_CONNECTION_PLATFORM = {
@@ -295,4 +295,4 @@ export {
   writeAdsOutput,
   resolveCustomerId
 };
-//# sourceMappingURL=chunk-6F52WYB7.js.map
+//# sourceMappingURL=chunk-ARUM5SYE.js.map

package/dist/{chunk-KSOGK7SJ.js → chunk-IK3GODKH.js}

@@ -2,13 +2,13 @@ import {
   handleConnectionError,
   needsConnectionFix,
   writeAdsJson
-} from "./chunk-6F52WYB7.js";
+} from "./chunk-ARUM5SYE.js";
 import {
   ApiError
-} from "./chunk-GU7IWEBC.js";
+} from "./chunk-KDTHRRAC.js";
 import {
   getEnv
-} from "./chunk-DZUVUGEP.js";
+} from "./chunk-WFWU3CHS.js";
 
 // src/commands/ads/meta/shared.ts
 var DAY_MS = 864e5;
@@ -108,4 +108,4 @@ export {
   csvOrJson,
   resolveEffectiveStatus
 };
-//# sourceMappingURL=chunk-KSOGK7SJ.js.map
+//# sourceMappingURL=chunk-IK3GODKH.js.map

package/dist/{chunk-GU7IWEBC.js → chunk-KDTHRRAC.js}

@@ -1,10 +1,10 @@
 import {
   debugLogHttp,
   readBodyForLog
-} from "./chunk-2IB3IL4K.js";
+} from "./chunk-2IUN3S3E.js";
 import {
   getEnv
-} from "./chunk-DZUVUGEP.js";
+} from "./chunk-WFWU3CHS.js";
 
 // src/client.ts
 var MAX_RATE_LIMIT_RETRIES = 3;
@@ -205,4 +205,4 @@ export {
   apiGet,
   apiPost
 };
-//# sourceMappingURL=chunk-GU7IWEBC.js.map
+//# sourceMappingURL=chunk-KDTHRRAC.js.map

package/dist/{chunk-36KVUYVL.js → chunk-LDDTPUYV.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;
@@ -3135,7 +3141,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,
@@ -7253,6 +7259,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,
@@ -7321,6 +7345,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"];
 }
@@ -7352,8 +7444,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, "");
@@ -7382,44 +7479,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"})`);
 }
 
@@ -8926,7 +9045,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.',
@@ -8937,6 +9063,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(),
@@ -9154,4 +9285,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-36KVUYVL.js.map
+//# sourceMappingURL=chunk-LDDTPUYV.js.map