@koda-sl/baker-cli 0.389.0 → 0.391.0

package/README.md

@@ -4067,7 +4067,7 @@ baker canvas set-prompt my-canvas.json s0_start --text-file ./hook-frame.txt
 `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
+- **`brand.logo`** — the repo path to the mark. It is copied into the caption 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
@@ -4087,9 +4087,24 @@ because a video model garbles a wordmark every time:
   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.
+- **The logo is optional.** With no mark in `src/brand/logos/` (and none confirmed for the
+  company's own domain), the ad is built without the corner mark, and one hint says so and
+  how to add one: put the client's logo file in `src/brand/logos/` and re-run. Meta shows
+  the page name and picture above every ad either way. The closing card still carries the
+  call to action when the spec has a `cta`; with neither a mark nor a `cta`, the last beat
+  keeps its footage. A typed stand-in (an SVG wordmark in live `<text>`) is still refused,
+  and `--no-brand` still means no brand layer at all: no mark and no closing card.
+- **Captions and the mark sit inside the safe area.** On 9:16 the caption cards end above
+  the bottom 37% of the frame (Reels covers the bottom 35%) and the mark starts below the
+  top 16% (the Stories and Reels header); 4:5 and 1:1 use modest feed margins. The closing
+  card is centred in the same area. Every composition is sized to the spec's
+  `format.aspect_ratio`, so a 4:5 ad lays its captions out on a 4:5 frame.
+- **Captions and the closing button are set in the brand's face**: a font file in
+  `src/brand/fonts/`, else the typeface `tokens.json` or `BRAND.md` names, loaded as a web
+  font. With neither, they keep the default heavy sans.
+- **A spoken ad's captions print the script.** The voice track is transcribed only to time
+  the words: each caption word is the `say` line as written, at the moment it was said, so
+  a word the recogniser mishears never reaches the screen.
 - **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
@@ -5075,6 +5090,7 @@ Word-level transcription of a video OR a bare audio track (the `video` input acc
 | `language` | string | no | auto | ISO 639-1, 2–8 chars (e.g. `en`, `es`) |
 | `transcriber` | enum | no | `groq` | `groq` (Whisper) \| `deepgram` (Nova-3, adds the `rich` output) |
 | `keyterms` | string[] | no | — | Up to 30 names the recogniser must not mangle — a product, a person, a phrase the script coins. The **company's own name is always applied server-side**, so it never needs listing here |
+| `script` | string | no | — | The words the track was asked to say. Given, the `transcript` output is the script's words, spelled as written, at the times the recogniser heard them: aligned locally (misheard words, fillers, accents and numbers said as words are all tolerated), never sent to the recogniser. `scaffold-ad` sets it on every spoken ad |
 
 **Outputs**
 
@@ -5632,7 +5648,7 @@ It then scaffolds a canvas that draws **only what `prompt.json` holds**; no elem
 
 **Placement formats.** The canvas delivers the platform's full placement set, each format at its exact size, collected under `final` with the format as its label. The set is derived from `--platform` (`meta` → 4:5 + 9:16, `google` → 1:1 + 4:5 + 16:9, `linkedin` → 1:1, `tiktok` → 9:16, `youtube` → 16:9); override it with `--placements <preset>` or `--placements none` for a single format. The report's `aspect_ratio` is the ratio the plates really render at (the model's nearest to the lead format), and `format_plan` says how each format is made.
 
-**After a run** the CLI reads the finished ad back on what makes a static win, not a checklist of elements: every delivered image's pixel shape against its format, and one vision pass that reads each word against the copy `prompt.json` holds and checks one dominant idea, clipping, artifacts, the brand with the logo covered and the concept's mechanisms, with every format shown a second time at phone-feed thumbnail size (240px wide, same call): a lead message unreadable at that size is blocking. A missing logo, CTA or copy is never a finding; a logo that is drawn and broken is. stdout carries `verdict` (`ready` | `ready_with_notes` | `needs_fixes` | `not_reviewed`), `judge` (the per-plate scores) and hints that end with what the run made; the findings are stored on the run as its `review`. `needs_fixes` means the ad is not done even though every node completed.
+**After a run** the CLI reads the finished ad back on what makes a static win, not a checklist of elements: every delivered image's pixel shape against its format, and one vision pass that reads each word against the copy `prompt.json` holds and checks one dominant idea, clipping, artifacts, the brand with the logo covered and the concept's mechanisms, with every format shown a second time at phone-feed thumbnail size (240px wide, same call): a lead message unreadable at that size is blocking. A missing logo, CTA or copy is never a finding; a logo that is drawn and broken is. stdout carries `verdict` (`ready` | `ready_with_notes` | `needs_fixes` | `not_reviewed`), `judge` (the per-plate scores) and hints that end with what the run made; the findings are stored on the run as its `review`. `needs_fixes` means the ad is not done even though every node completed; its hints name the cheapest fix (overlapping or unreadable copy is fixed with a smaller `size`, a `highlight` or `sticker` treatment or shorter words, which re-draw the formats from the cached plates). **Render budget:** a static ad gets 3 renders per creative in a chat before the person reacts; the fourth exits 2 with `RENDER_BUDGET` without rendering, and `baker creatives feedback record` or `baker creatives select` on that creative opens a new round. Resuming an interrupted run does not count again, and a run that died only on an outage (timeout, network, a provider that says retry) gives its render back.
 
 The logo is never a slot to fill: use the company's committed logo in `src/brand/logos/` (per `BRAND.md`), never `baker images logo <domain>`, whose Brandfetch CDN often serves an outdated mark.
 
@@ -6158,27 +6174,31 @@ import {
 
 ## Creatives
 
-Publish an approved canvas render as a first-class Baker creative. The image uploads to the Baker image library (tagged `creative`), a creative record is created/updated, and the command prints the creative reference JSON the dashboard renders in chat.
+Publish an approved canvas render as a first-class Baker creative: a static image (PNG, JPG, WebP) or a finished video (MP4, MOV, WebM). An image uploads to the Baker image library (tagged `creative`); a video uploads to the Baker video library and is saved once it plays (bounded at 3 minutes). A creative record is created/updated, and the command prints the creative reference JSON the dashboard renders in chat.
 
 ```bash
 baker creatives publish ./canvas/<run_id>/<final>.png --title "Spring Offer 4x5" \
   --slug spring-offer-4x5 --run-id r_01JXYZ... \
   --source-reference-url "https://www.facebook.com/ads/library/?id=..."
+baker creatives publish ./canvas/<run_id>/final.mp4 --title "Spring Offer Reel" \
+  --slug spring-offer-reel --run-id r_01JXYZ...
 ```
 
 | Flag | Effect |
 |---|---|
 | `--title <text>` | Required. Human title for the creative. |
-| `--slug <slug>` | Creative slug (`src/creatives/<slug>/`) — attaches the image to that creative's row, marks it `published`. |
+| `--slug <slug>` | Creative slug (`src/creatives/<slug>/`): attaches the image or video to that creative's row, marks it `published`. Required for a video. |
 | `--run-id <r_…>` | Pins the approved generation from the creative's run history as the published one. |
 | `--source-reference-url <url>` | Original reference ad URL, recorded on the creative. |
-| `--context <text>` | Optional describe context for the uploaded image asset. |
+| `--context <text>` | Optional describe context for the uploaded image or video. |
 
-Without `--slug` the command behaves as before (one creative record per published image). With `--slug` it upserts the repo-convention row — the same one the dashboard's Creatives tab and the `src/creatives/{slug}/` folder describe — so publish, repo sync, and run history all land on a single record regardless of order.
+An image prints `{ ok, data: { creativeId, imageId, reference } }`. A video prints `{ ok, data: { creativeId, videoId, reference }, hints }`, where `reference.asset.kind` is `video` (with `videoId`, `muxPlaybackId`, the poster as `thumbnailUrl`, size and duration) and `hints` names the next step to put it in a Meta ad: `baker ads meta media upload --kind video --video-id <videoId>`.
+
+Without `--slug` an image behaves as before (one creative record per published image). With `--slug` it upserts the repo-convention row — the same one the dashboard's Creatives tab and the `src/creatives/{slug}/` folder describe — so publish, repo sync, and run history all land on a single record regardless of order.
 
 ### `baker creatives performance`
 
-How each published creative is doing in the live Meta ads that show it. A creative is linked to an ad when a chat's publish uploads its image to Meta and creates an ad with it (or swaps an existing ad onto it); the results are read live from Meta.
+How each published creative is doing in the live Meta ads that show it. A creative is linked to an ad when a chat's publish uploads its image or video to Meta and creates an ad with it (or swaps an existing ad onto it); the results are read live from Meta.
 
 ```bash
 baker creatives performance                      # every creative in an ad, last 30 days
@@ -6190,9 +6210,9 @@ baker creatives performance --days 14 --full     # + ids, last-7-day figures, on
 |---|---|
 | `--slug <slug>` | Only this creative. |
 | `--days <n>` | Window ending today, 1-90 (default 30). |
-| `--full` | Adds creative and image ids, result type, days live, last-7-day CTR and cost per result, and one row per ad. |
+| `--full` | Adds creative, image and video ids, result type, days live, last-7-day CTR and cost per result, a video's watch funnel (`video`: 3-second views, ThruPlays, 25/50/75/100% watched), and one row per ad. |
 
-Each creative reports `spend`, `impressions`, `ctr` (percent), `cpc`, `results`, `costPerResult`, `frequency`, a `fatigue` verdict (`fresh`, `fading`, `fatigued`, `dead`, `too_early`, `no_delivery`) with its reason, and `definition`: the angle, hook, mechanism, dominantSlot, persona, awareness, hypothesis and reference fields read from the local `src/creatives/<slug>/_definition.md`. `hints` name worn-out creatives, the angle, mechanism and dominant slot with the lowest cost per result (each ranked once two or more values have results), and unreadable ad accounts.
+Each creative reports `spend`, `impressions`, `ctr` (percent), `cpc`, `results`, `costPerResult`, `frequency`, a `fatigue` verdict (`fresh`, `fading`, `fatigued`, `dead`, `too_early`, `no_delivery`) with its reason, and `definition`: the angle, hook, mechanism, dominantSlot, persona, awareness, hypothesis and reference fields read from the local `src/creatives/<slug>/_definition.md`. A video creative also reports `hookRate` (percent of impressions that watched 3 seconds) and `holdRate` (percent of those that reached a ThruPlay); a static one carries neither. `hints` name worn-out creatives, videos whose hook rate is under 25% (the first 3 seconds need new hooks) or whose hold rate is under 30% behind a working hook (the body loses people), the angle, mechanism and dominant slot with the lowest cost per result (each ranked once two or more values have results), and unreadable ad accounts.
 
 ### `baker creatives feedback [--slug <slug>] [--full]`
 
@@ -6221,7 +6241,7 @@ baker creatives feedback record --slug spring-offer --run r_01K… --option 2 --
 | `--run <r_…>` | Required. The version. |
 | `--verdict approved\|rejected` | Required. |
 | `--option <o>` | One option of a version that made several: its label, its number (`2`) or its slot. |
-| `--reasons <a,b>` | Comma-separated: `text_mistakes`, `logo_or_brand_wrong`, `weak_hook`, `wrong_message`, `looks_fake`, `not_our_style`, `other`. A rejection needs reasons or a note. |
+| `--reasons <a,b>` | Comma-separated: `text_mistakes`, `logo_or_brand_wrong`, `weak_hook`, `wrong_message`, `looks_fake`, `not_our_style`, `voice_or_sound`, `pacing`, `other`. The two video reasons: `voice_or_sound` (the voiceover, music or mix) and `pacing` (too slow, too fast, the hook lands late). A rejection needs reasons or a note. |
 | `--note <text>` | The person's own words (stored up to 1000 characters). |
 
 After a rejection, `hints[]` restates what to change, starting from that version.

package/dist/{chunk-IOWWKZRF.js → chunk-SZKTVOR7.js}

@@ -1023,6 +1023,10 @@ function runFailureCode(e) {
   const reasons = e instanceof LayerExecutionError ? e.failures.map((f) => f.reason) : [e];
   return reasons.length > 0 && reasons.every(isInputRejection) ? "input_invalid" : "runtime";
 }
+function failedOnlyOnTransientErrors(e) {
+  const reasons = e instanceof LayerExecutionError ? e.failures.map((f) => f.reason) : [e];
+  return reasons.length > 0 && reasons.every((r) => r instanceof NodeExecutionError && failureDetail(r).retryable === true);
+}
 function failureDetail(reason) {
   if (reason instanceof NodeExecutionError) {
     const c = reason.cause;
@@ -3657,13 +3661,13 @@ function spineInputFlags(work, lenS) {
 function spineInputOps(work, lenS, dims) {
   const fit = work.still?.fit ?? "fill";
   const scale = fit === "pad" ? `scale=${dims.w}:${dims.h}:force_original_aspect_ratio=decrease,pad=${dims.w}:${dims.h}:(ow-iw)/2:(oh-ih)/2:color=black` : `scale=${dims.w}:${dims.h}:force_original_aspect_ratio=increase,crop=${dims.w}:${dims.h}`;
-  const normalize = `${scale},format=yuv420p,fps=30,setsar=1,settb=AVTB`;
+  const normalize2 = `${scale},format=yuv420p,fps=30,setsar=1,settb=AVTB`;
   if (work.trim) {
     const start = work.trim.offset_s > 0 ? `start=${work.trim.offset_s.toFixed(3)}:` : "";
-    return `${normalize},trim=${start}duration=${lenS.toFixed(3)},setpts=PTS-STARTPTS`;
+    return `${normalize2},trim=${start}duration=${lenS.toFixed(3)},setpts=PTS-STARTPTS`;
   }
-  if (work.still) return `${normalize},trim=duration=${lenS.toFixed(3)}`;
-  return normalize;
+  if (work.still) return `${normalize2},trim=duration=${lenS.toFixed(3)}`;
+  return normalize2;
 }
 function parseSpineInputLens(args) {
   const lens = /* @__PURE__ */ new Map();
@@ -7382,10 +7386,10 @@ function applyDuck(params, labelFor, filterChains) {
   }
   const th = duck.threshold ?? 0.03;
   const ra = duck.ratio ?? 8;
-  const at = duck.attack ?? 5;
+  const at2 = duck.attack ?? 5;
   const re = duck.release ?? 300;
   filterChains.push(
-    `[${labelFor[trackIdx]}]${keyOut}sidechaincompress=threshold=${th}:ratio=${ra}:attack=${at}:release=${re}[ducked]`
+    `[${labelFor[trackIdx]}]${keyOut}sidechaincompress=threshold=${th}:ratio=${ra}:attack=${at2}:release=${re}[ducked]`
   );
   labelFor[trackIdx] = "ducked";
 }
@@ -8069,6 +8073,9 @@ var FINDING_ADVICE = {
   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.",
+  // The most common reason a static ad failed its render in production (Sept 2026), and the
+  // agent answered it by re-painting all three pictures when only the composition was wrong.
+  content_overlap: "two lines of copy collide. In a static ad, make one smaller (`size` in its layout region's `text` in prompt.json) or shorten it: the formats re-draw from the cached pictures. Moving a layout region instead re-paints every picture.",
   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) {
@@ -9656,6 +9663,165 @@ ${detail.slice(-4e3)}`);
   }
 }
 
+// src/engine/lib/spell-number.ts
+import { toCardinal as nwAr } from "n2words/ar-SA";
+import { toCardinal as nwDe } from "n2words/de-DE";
+import { toCardinal as nwEn } from "n2words/en-US";
+import { toCardinal as nwEs } from "n2words/es-ES";
+import { toCardinal as nwFr } from "n2words/fr-FR";
+import { toCardinal as nwHi } from "n2words/hi-IN";
+import { toCardinal as nwIt } from "n2words/it-IT";
+import { toCardinal as nwJa } from "n2words/ja-JP";
+import { toCardinal as nwKo } from "n2words/ko-KR";
+import { toCardinal as nwNl } from "n2words/nl-NL";
+import { toCardinal as nwPl } from "n2words/pl-PL";
+import { toCardinal as nwPt } from "n2words/pt-PT";
+var INTEGER_SPELLERS = {
+  fr: nwFr,
+  es: nwEs,
+  en: nwEn,
+  de: nwDe,
+  it: nwIt,
+  pt: nwPt,
+  nl: nwNl,
+  pl: nwPl,
+  ar: nwAr,
+  ja: nwJa,
+  ko: nwKo,
+  hi: nwHi
+};
+function canSpellNumbers(langCode) {
+  return langCode in INTEGER_SPELLERS;
+}
+function spellNumber(langCode, n) {
+  const spell = langCode ? INTEGER_SPELLERS[langCode] : void 0;
+  if (!spell || !Number.isFinite(n)) return String(n);
+  try {
+    return spell(n);
+  } catch {
+    return String(n);
+  }
+}
+
+// src/engine/nodes/local/lib/script-word-timing.ts
+var UNBOUNDED_WORD_S = 0.3;
+var EXACT = 3;
+var NEAR = 2;
+var SUBSTITUTE = -1;
+var SKIP = -2;
+var NEAR_SIMILARITY = 0.7;
+function normalize(word) {
+  return word.normalize("NFD").replace(new RegExp("\\p{M}", "gu"), "").toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
+}
+function tokensOf(word, index, language) {
+  const key = normalize(word);
+  if (!key) return [];
+  if (language && /^\d{1,9}$/.test(key)) {
+    const spoken = spellNumber(language, Number.parseInt(key, 10));
+    if (spoken !== key) {
+      const parts = spoken.split(/[\s-]+/).map(normalize).filter(Boolean);
+      if (parts.length > 0) return parts.map((part) => ({ key: part, word: index }));
+    }
+  }
+  return [{ key, word: index }];
+}
+function similarity(a, b) {
+  if (a === b) return 1;
+  const longest = Math.max(a.length, b.length);
+  if (longest === 0) return 1;
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      row[j] = Math.min((prev[j] ?? 0) + 1, (row[j - 1] ?? 0) + 1, (prev[j - 1] ?? 0) + cost);
+    }
+    prev = row;
+  }
+  return 1 - (prev[b.length] ?? longest) / longest;
+}
+function pairScore(a, b) {
+  if (a === b) return EXACT;
+  return similarity(a, b) >= NEAR_SIMILARITY ? NEAR : SUBSTITUTE;
+}
+var at = (grid, i, j) => grid[i]?.[j] ?? 0;
+function diagonal(grid, script, transcript, i, j) {
+  return at(grid, i - 1, j - 1) + pairScore(script[i - 1]?.key ?? "", transcript[j - 1]?.key ?? "");
+}
+function scoreGrid(script, transcript) {
+  const grid = Array.from(
+    { length: script.length + 1 },
+    (_, i) => Array.from({ length: transcript.length + 1 }, (_2, j) => i === 0 ? j * SKIP : i * SKIP)
+  );
+  for (let i = 1; i <= script.length; i++) {
+    const row = grid[i];
+    for (let j = 1; j <= transcript.length; j++) {
+      row[j] = Math.max(diagonal(grid, script, transcript, i, j), at(grid, i - 1, j) + SKIP, at(grid, i, j - 1) + SKIP);
+    }
+  }
+  return grid;
+}
+function align(script, transcript) {
+  const grid = scoreGrid(script, transcript);
+  const pairs = new Array(script.length).fill(-1);
+  let i = script.length;
+  let j = transcript.length;
+  while (i > 0 && j > 0) {
+    const here = at(grid, i, j);
+    if (here === diagonal(grid, script, transcript, i, j)) {
+      pairs[i - 1] = j - 1;
+      i--;
+      j--;
+    } else if (here === at(grid, i - 1, j) + SKIP) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+  return pairs;
+}
+var round = (s) => Math.round(s * 1e3) / 1e3;
+function pairedSpans(wordCount, scriptTokens, heardTokens, pairs, transcript) {
+  const spans = new Array(wordCount).fill(null);
+  pairs.forEach((heardIndex, t) => {
+    const token = scriptTokens[t];
+    const said = heardIndex >= 0 ? transcript[heardTokens[heardIndex]?.word ?? -1] : void 0;
+    if (!token || !said) return;
+    const current = spans[token.word];
+    spans[token.word] = current ? { start: Math.min(current.start, said.start), end: Math.max(current.end, said.end) } : { start: said.start, end: said.end };
+  });
+  return spans;
+}
+function fillRun(spans, first, end) {
+  const before = first > 0 ? spans[first - 1] : null;
+  const after = end < spans.length ? spans[end] : null;
+  const count = end - first;
+  const from = before ? before.end : Math.max(0, (after?.start ?? 0) - count * UNBOUNDED_WORD_S);
+  const to = after ? Math.max(after.start, from) : from + count * UNBOUNDED_WORD_S;
+  const each = (to - from) / count;
+  for (let w = first; w < end; w++) spans[w] = { start: from + (w - first) * each, end: from + (w - first + 1) * each };
+}
+function fillDropped(spans) {
+  const filled = [...spans];
+  let i = 0;
+  while (i < filled.length) {
+    let end = i;
+    while (end < filled.length && !filled[end]) end++;
+    if (end > i) fillRun(filled, i, end);
+    i = end + 1;
+  }
+  return filled.map((span) => span ?? { start: 0, end: 0 });
+}
+function timeScriptWords(script, transcript, language) {
+  const words = script.split(/\s+/).filter(Boolean);
+  if (words.length === 0 || transcript.length === 0) return [];
+  const scriptTokens = words.flatMap((word, i) => tokensOf(word, i, language));
+  const heardTokens = transcript.flatMap((w, i) => tokensOf(String(w.text ?? ""), i, language));
+  const pairs = align(scriptTokens, heardTokens);
+  const spans = fillDropped(pairedSpans(words.length, scriptTokens, heardTokens, pairs, transcript));
+  return words.map((text, i) => ({ text, start: round(spans[i]?.start ?? 0), end: round(spans[i]?.end ?? 0) }));
+}
+
 // src/engine/nodes/remote/videoTranscribe.ts
 var VideoTranscribeParams = z33.object({
   language: z33.string().min(2).max(8).optional(),
@@ -9665,6 +9831,9 @@ var VideoTranscribeParams = z33.object({
   transcriber: z33.enum(["groq", "deepgram"]).optional(),
   keyterms: z33.array(z33.string().min(2).max(60)).max(30).optional().describe(
     "Names the recogniser must not mangle \u2014 a product, a person, a phrase the script coins. The COMPANY'S OWN NAME is always applied server-side, so you never list it: this is for the rest. Every term is biased into the request AND its spelling enforced on the way out, because a caption prints a mishearing at full size over the ad (a real cut shipped with the brand name spelled wrong). Never patch a misspelling inside a caption composition \u2014 that fix dies with that one creative."
+  ),
+  script: z33.string().min(1).optional().describe(
+    "The words the track was asked to say, when there is a script: the transcript's words are then the script's, spelled as written, at the times the recogniser heard them. A misheard word stops being a typo on screen, and a word the recogniser added (a filler) is never printed. Aligned locally, never sent."
   )
 }).strict();
 var VideoTranscribeInputs = z33.object({
@@ -9695,16 +9864,40 @@ var videoTranscribeNode = defineNode({
   async execute({ inputs, params, ctx }) {
     const audioInput = await tryExtractAudio(inputs, ctx);
     const effectiveInputs = audioInput ?? inputs;
-    return await callBackendExec({
+    const { script, ...recogniserParams } = params;
+    const outputs = await callBackendExec({
       nodeType: "video_transcribe",
       nodeVersion: "2.4.0",
-      params,
+      params: recogniserParams,
       inputs: effectiveInputs,
       outputKinds: { transcript: "json", rich: "json" },
       ctx
     });
+    if (!script) return outputs;
+    return { ...outputs, transcript: await scriptTranscript(outputs.transcript, script, params.language, ctx) };
   }
 });
+async function scriptTranscript(heardRef, script, language, ctx) {
+  const local = heardRef.path ? heardRef : await ctx.assets.ingestRemote({
+    kind: "json",
+    url: String(heardRef.url),
+    sha256: heardRef.sha256,
+    mime: heardRef.mime
+  });
+  const heard = JSON.parse(await readFile13(String(local.path), "utf8"));
+  const words = Array.isArray(heard) ? heard.filter(isTimedWord) : [];
+  const timed = timeScriptWords(script, words, language);
+  ctx.log(`video_transcribe: ${timed.length} script words timed off ${words.length} heard`);
+  const bytes = Buffer.from(JSON.stringify(timed));
+  const metadata = { ...heardRef.metadata, text_of_record: "script", heard_sha256: heardRef.sha256 };
+  return uploadAndIngest({ bytes, kind: "json", mime: "application/json", metadata, ctx }).catch(
+    () => ctx.assets.ingestBytes({ bytes, kind: "json", mime: "application/json", metadata })
+  );
+}
+function isTimedWord(value) {
+  const w = value;
+  return Boolean(w) && typeof w?.start === "number" && typeof w?.end === "number" && w?.text !== void 0;
+}
 async function tryExtractAudio(inputs, ctx) {
   const video = inputs.video;
   if (!video.path || !video.mime?.startsWith("video/")) return null;
@@ -10025,6 +10218,7 @@ export {
   LayerExecutionError,
   describeFailureReason,
   runFailureCode,
+  failedOnlyOnTransientErrors,
   AD_FORMAT_PLATFORMS,
   platformFormats,
   resolveAdaptFormats,
@@ -10084,6 +10278,8 @@ export {
   coercePathUrlToUrl,
   toModelSafeImage,
   loadCompositionMeta,
+  canSpellNumbers,
+  spellNumber,
   catalogView,
   BackendClient2,
   Engine2 as Engine,
@@ -10095,4 +10291,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-IOWWKZRF.js.map
+//# sourceMappingURL=chunk-SZKTVOR7.js.map