@koda-sl/baker-cli 0.321.0 → 0.324.0-dev.593ae2dfd

package/README.md

@@ -4925,6 +4925,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 |
 
 **Outputs**
 
@@ -4933,6 +4934,8 @@ Word-level transcription of a video OR a bare audio track (the `video` input acc
 | `transcript` | json | `application/json` — array of `{text, start, end}` (Deepgram prefers the punctuated word form) |
 | `rich` | json | `application/json` — Deepgram only: `{text, words[], paragraphs[], duration_sec, language?}` with punctuated words, sentences, and speaker indices |
 
+**Known names are spelled the way the brand spells them.** Every term (the company's own name, plus `keyterms`) is biased into the request — Deepgram `keyterm`, Whisper `prompt` — and its spelling is then enforced on the words that come back, because bias is a probability and a caption prints the mistake at full size over the ad. Verified against the take that shipped wrong: the same Spanish clip returns "Cubicap" bare and "Cubicup" with the name applied. Corrections are listed on the output's `brand_spelling_corrections` metadata, so a rewrite is visible rather than silent. A short name (under 6 characters) gets the bias only — at that length ordinary words sit one edit away, and rewriting those to protect a brand would corrupt the line. **Never patch a mishearing inside a caption composition**: that fix dies with that one creative.
+
 **Cost** — 2 credits estimate; backend reports actual based on duration (Groq: $0.04/hr, 10s minimum; Deepgram Nova-3: $0.0043/min).
 
 **Requirements** — `ffmpeg` on PATH for audio extraction (already in the E2B sandbox image). Without it the node still works but uploads the full video and Groq's 100 MB cap applies.
@@ -5051,10 +5054,12 @@ Place and mix several audio clips onto one timeline — a music bed plus timed v
 | `tracks` | array | yes | `[{slot, start_s, duration_s?, gain_db?}]` — `slot` matches a wired input; `start_s` is absolute seconds; `duration_s` hard-caps the clip (trimmed BEFORE placement, so an over-long source can't bleed into the next track's window); `gain_db` sets the static level (e.g. `-20` for a music bed) |
 | `total_ms` | number | no | pins the final length (pad/trim) |
 | `output_format` | enum | no | `mp3` (default) / `wav` / `m4a` |
-| `duck` | object | no | sidechain-duck one track under others: `{ track, against: [...], threshold?, ratio?, attack?, release? }` — the `track` (music) drops while any `against` track (voice) carries signal and recovers in the gaps |
+| `duck` | object | no | sidechain-duck one track under others: `{ track, against: [...], threshold?, ratio?, attack?, release? }` — the `track` (music) drops while any `against` track (voice) carries signal and recovers in the gaps. `threshold` is linear 0–1; **`attack` and `release` are MILLISECONDS** (typical 5–50 / 200–800, defaults 5 / 300) |
 
 **Outputs** — `audio`. **Cost** — free (local). Requires `ffmpeg`.
 
+**The bed under a voice is two settled numbers, and `canvas validate` holds both.** A music bed sits at **−20 dB** and is sidechain-ducked against the speech; `AUDIO_MUSIC_BED_TOO_LOUD` warns above −18 dB (a hand-built cut at −13 dB was rejected by the client as too loud) and `AUDIO_MUSIC_BED_NOT_DUCKED` warns when the bed is mixed flat under speech. If a silent tail — an end card, a logo plate — sounds empty, **add the same bed as a second windowed track** (`start_s` + `duration_s`) with its own higher gain; never raise the bed that runs under the voice, which is what measuring loudness across the silent tail invites. `AUDIO_DUCK_UNITS` **blocks** a sub-millisecond `attack`/`release`: `release: 0.45` is a seconds value, and at 0.45 ms the bed snaps back to full level between syllables — which sounds exactly like music mixed too loud. `AUDIO_MUSIC_BED_SCORED_TO_ARC` warns when a `video-background-music-v1` bed's own brief asks for movement (a build, a climax, "follows her arc") under speech — see `music`. (`music-v1` is exempt: `scaffold-video` briefs it with the reference ad's own arc on purpose.)
+
 ---
 
 ##### `image_background_remove`
@@ -5091,6 +5096,8 @@ Strip background → transparent PNG. Powered by `men1scus/birefnet` (Replicate)
 
 Generate music from prompt OR score an existing video clip.
 
+**Both routes run on the `music_v2` engine** (`ELEVENLABS_MUSIC_ENGINE`), which is separate from the route names below — `elevenlabs/music-v1` still selects compose and `elevenlabs/video-background-music-v1` still selects video-to-music, so existing canvases keep their names. Measured on a real client cut before switching (same clips, same brief, only the engine different): over the 25s carrying speech v1's level wandered **16.3 dB** against v2's **3.9 dB**, v2 sits 1.7 dB further out of the 200 Hz–3 kHz speech band, and v2 ends at −32 dBFS where v1 collapses to −50 dB — that fade is what makes a correct bed read as "empty over the end card". v2 plays ~5× the note attacks, which is the one thing to listen for. Note the per-second **cost of v2 is unconfirmed**: ElevenLabs publishes no per-model music rate and returns no cost header, so `ELEVENLABS_MUSIC_USD_PER_SECOND` is still the v1 figure.
+
 **Inputs**
 
 | Slot | Kind | Required | Notes |
@@ -5129,10 +5136,12 @@ Score an existing video. Requires `inputs.video`.
 | Name | Type | Required | Notes |
 |---|---|---|---|
 | `model` | literal | yes | `"elevenlabs/video-background-music-v1"` |
-| `description` | string | no | max 1000 chars |
+| `description` | string | no | max 1000 chars — the score in **sound**, not in feelings (see below) |
 | `tags` | string[] | no | up to 10 style tags |
 | `output_format` | enum | no | mp3 family only (see `tts`) |
 
+**Under speech, a bed is furniture.** This model *watches* the cut, so it scores the footage's emotion unless told not to: name ONE steady character (instruments, tempo, texture) and forbid movement — no build, no drop, no climax, nothing that "follows the arc". A description that narrated the speaker's emotional arc ("quiet and tense while she is overwhelmed, opening as she walks, resolving warm and confident") came back as a film score, and the client's verdict was *"la musica que has elegido es muy dramática"*. Prefer tags that hold it still (`instrumental`, `understated`, `steady`, `no drums`) over tags that move it (`cinematic`, `epic`, `building`, `resolving`). The level and the ducking are separate, settled decisions — see `audio_timeline`.
+
 ---
 
 ##### `dialogue`

package/dist/{chunk-AEU5X443.js → chunk-63Q73JIN.js}

@@ -1,7 +1,7 @@
 import {
   ApiError,
   apiGet
-} from "./chunk-TTIGSGXE.js";
+} from "./chunk-OMUDHFUY.js";
 import {
   getEnv
 } from "./chunk-UIQJZGBG.js";
@@ -294,4 +294,4 @@ export {
   writeAdsOutput,
   resolveCustomerId
 };
-//# sourceMappingURL=chunk-AEU5X443.js.map
+//# sourceMappingURL=chunk-63Q73JIN.js.map

package/dist/{chunk-WHUKLAGW.js → chunk-BD4GLBWV.js}

@@ -17,9 +17,9 @@ import {
   shouldEscalate
 } from "./chunk-UIQJZGBG.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/766ad107c42df28eeadaf0ac2f9089c8a9e200f6ba0b2b1a817b8d536cbdcc49/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/766ad107c42df28eeadaf0ac2f9089c8a9e200f6ba0b2b1a817b8d536cbdcc49/node_modules/safe-stable-stringify/index.js"(exports, module) {
     "use strict";
     var { hasOwnProperty } = Object.prototype;
     var stringify = configure2();
@@ -1111,7 +1111,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/766ad107c42df28eeadaf0ac2f9089c8a9e200f6ba0b2b1a817b8d536cbdcc49/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;
@@ -3686,6 +3686,10 @@ var STAGE_CODES = {
   OVERLAY_OUT_OF_BOUNDS: "VIDEO_OVERLAY_OUT_OF_BOUNDS",
   ORPHAN_NODE: "ORPHAN_NODE",
   INGEST_PATH_URL_HEALED: "INGEST_PATH_URL_HEALED",
+  DUCK_UNITS: "AUDIO_DUCK_UNITS",
+  MUSIC_BED_TOO_LOUD: "AUDIO_MUSIC_BED_TOO_LOUD",
+  MUSIC_BED_NOT_DUCKED: "AUDIO_MUSIC_BED_NOT_DUCKED",
+  MUSIC_BED_SCORED_TO_ARC: "AUDIO_MUSIC_BED_SCORED_TO_ARC",
   PARALLEL_FORMAT_RENDERS: "IMAGE_PARALLEL_FORMAT_RENDERS"
 };
 var SPAN_MODEL_SLACK_S = 0.25;
@@ -3753,6 +3757,7 @@ function validateCanvas(input, registry) {
   checkOutputRef(ctx);
   checkOrphanNodes(ctx);
   checkParallelFormatRenders(ctx);
+  checkAudioBedMix(ctx);
   checkVideoInvariants(ctx);
   const hasBlocking = issues.some(isBlocking);
   if (hasBlocking) return { ok: false, issues };
@@ -4739,6 +4744,108 @@ function checkParallelFormatRenders(ctx) {
     });
   }
 }
+var MUSIC_BED_MAX_GAIN_DB = -18;
+var DUCK_MIN_ATTACK_MS = 0.5;
+var DUCK_MIN_RELEASE_MS = 10;
+var SPEECH_NODE_TYPES = /* @__PURE__ */ new Set(["tts", "dialogue", "audio_voice_convert", "video_lipsync"]);
+var SPEECH_SLOT_RE = /voice|speech|\bvo\b|^vo|_vo|dialog|narration/i;
+var MUSIC_SLOT_RE = /music|score|\bbed\b/i;
+function audioTimelineTracks(node) {
+  const tracks = node.params?.tracks;
+  if (!Array.isArray(tracks)) return [];
+  return tracks.filter(
+    (t) => typeof t === "object" && t !== null && typeof t.slot === "string"
+  );
+}
+function checkAudioBedMix(ctx) {
+  for (const n of ctx.canvas.nodes) {
+    if (n.type === "audio_timeline") checkOneAudioMix(ctx, n);
+  }
+}
+function checkOneAudioMix(ctx, node) {
+  const tracks = audioTimelineTracks(node);
+  if (tracks.length === 0) return;
+  const duck = node.params?.duck;
+  checkDuckUnits(ctx, node, duck);
+  const sourceType = (slot) => refNodeOf(ctx, node.inputs?.[slot])?.type ?? null;
+  const speech = tracks.filter((t) => {
+    const type = sourceType(t.slot);
+    return type !== null && SPEECH_NODE_TYPES.has(type) || SPEECH_SLOT_RE.test(t.slot);
+  });
+  if (speech.length === 0) return;
+  const beds = tracks.filter(
+    (t) => (sourceType(t.slot) === "music" || MUSIC_SLOT_RE.test(t.slot)) && t.duration_s === void 0
+  );
+  if (beds.length === 0) return;
+  checkBedLevels(ctx, node, beds);
+  checkBedDucked(ctx, node, beds, speech, duck);
+  for (const bed of beds) checkBedNotScored(ctx, node, refNodeOf(ctx, node.inputs?.[bed.slot]));
+}
+var MUSIC_ARC_RE = /\b(?:emotional arc|follows? (?:her|his|their|the) arc|swell(?:s|ing)?|crescendo|climax|build(?:s|ing) (?:to|into)|resolv(?:e|es|ing)|dramatic|epic|tense|tension)\b/i;
+function checkBedNotScored(ctx, node, source) {
+  if (source?.type !== "music") return;
+  const params = source.params;
+  if (params?.model !== "elevenlabs/video-background-music-v1") return;
+  const brief = [params?.description, params?.prompt].filter((v) => typeof v === "string").join(" ");
+  const found = MUSIC_ARC_RE.exec(brief);
+  if (!found) return;
+  ctx.issues.push({
+    path: `nodes[${ctx.idToIndex.get(source.id) ?? -1}].params.description`,
+    code: STAGE_CODES.MUSIC_BED_SCORED_TO_ARC,
+    severity: "warning",
+    node_id: source.id,
+    node_type: source.type,
+    message: `"${source.id}" briefs the bed with "${found[0]}", and "${node.id}" mixes it under speech \u2014 this model watches the cut, so movement asked for here comes back as a film score (a testimonial briefed that way was rejected as "muy dram\xE1tica"). Under a voice, name ONE steady character and forbid movement: no build, no drop, no climax, nothing that follows the arc`
+  });
+}
+function checkDuckUnits(ctx, node, duck) {
+  const index = ctx.idToIndex.get(node.id) ?? -1;
+  if (typeof duck?.attack === "number" && duck.attack < DUCK_MIN_ATTACK_MS) {
+    ctx.issues.push({
+      path: `nodes[${index}].params.duck.attack`,
+      code: STAGE_CODES.DUCK_UNITS,
+      node_id: node.id,
+      node_type: node.type,
+      message: `"${node.id}" ducks with attack ${duck.attack} \u2014 this parameter is MILLISECONDS, so that is instantaneous. Use 5-50 (default 5)`
+    });
+  }
+  if (typeof duck?.release === "number" && duck.release < DUCK_MIN_RELEASE_MS) {
+    ctx.issues.push({
+      path: `nodes[${index}].params.duck.release`,
+      code: STAGE_CODES.DUCK_UNITS,
+      node_id: node.id,
+      node_type: node.type,
+      message: `"${node.id}" ducks with release ${duck.release} \u2014 this parameter is MILLISECONDS, so the bed jumps back to full level between syllables and the mix sounds like the music is too loud. Use 200-800 (default 300); 0.45 is a seconds value`
+    });
+  }
+}
+function checkBedLevels(ctx, node, beds) {
+  const index = ctx.idToIndex.get(node.id) ?? -1;
+  for (const bed of beds) {
+    if ((bed.gain_db ?? 0) <= MUSIC_BED_MAX_GAIN_DB) continue;
+    const level = bed.gain_db === void 0 ? "full level (no gain_db)" : `${bed.gain_db} dB`;
+    ctx.issues.push({
+      path: `nodes[${index}].params.tracks`,
+      code: STAGE_CODES.MUSIC_BED_TOO_LOUD,
+      severity: "warning",
+      node_id: node.id,
+      node_type: node.type,
+      message: `"${node.id}" runs the music bed "${bed.slot}" at ${level} under speech \u2014 a bed belongs at ${MUSIC_BED_MAX_GAIN_DB} dB or below (the scaffolder pins -20; -13 was rejected by a client as too loud). If a silent tail sounds empty, add the same bed as a SECOND windowed track (start_s + duration_s) with its own higher gain instead of raising this one`
+    });
+  }
+}
+function checkBedDucked(ctx, node, beds, speech, duck) {
+  if (beds.some((bed) => bed.slot === duck?.track)) return;
+  const quoted = (list) => list.map((t) => `"${t.slot}"`).join(", ");
+  ctx.issues.push({
+    path: `nodes[${ctx.idToIndex.get(node.id) ?? -1}].params.duck`,
+    code: STAGE_CODES.MUSIC_BED_NOT_DUCKED,
+    severity: "warning",
+    node_id: node.id,
+    node_type: node.type,
+    message: `"${node.id}" mixes a music bed (${quoted(beds)}) under speech (${quoted(speech)}) with no sidechain duck on it \u2014 a flat bed fights the voice in every gap. Add params.duck { track: "${beds[0]?.slot}", against: [${quoted(speech)}] }`
+  });
+}
 function checkOrphanNodes(ctx) {
   const out = ctx.canvas.output;
   if (!out || !ctx.idToIndex.has(out.node)) return;
@@ -7031,16 +7138,28 @@ var Track = z6.object({
    * track that came back oversized) cannot bleed into the next track's window.
    */
   duration_s: z6.number().positive().optional(),
-  /** Optional level adjustment in dB (negative ducks, e.g. a music bed at -12). */
-  gain_db: z6.number().optional()
+  /**
+   * Level adjustment in dB — negative attenuates. A MUSIC BED under speech
+   * belongs at −20 dB (see the `describe` text: this number is a settled
+   * decision, not a per-cut judgement).
+   */
+  gain_db: z6.number().optional().describe(
+    "Level adjustment in dB (negative attenuates, 0 = untouched). A music bed under speech sits at \u221220 dB and is sidechain-ducked as well; \u221212 dB crowded the voice and \u221213 dB was rejected by the client as too loud. If a silent tail (an end card, a logo plate) sounds empty, do NOT raise the bed \u2014 wire the same bed as a SECOND track windowed over the tail with its own higher gain. Measuring loudness across a window that includes the silent tail is what makes a correct bed look quiet."
+  )
 }).strict();
 var DuckSpec = z6.object({
-  track: z6.string().min(1),
-  against: z6.array(z6.string().min(1)).min(1),
-  threshold: z6.number().min(0).max(1).optional(),
-  ratio: z6.number().min(1).max(20).optional(),
-  attack: z6.number().min(0.01).optional(),
-  release: z6.number().min(0.01).optional()
+  track: z6.string().min(1).describe("Slot to duck \u2014 the music bed."),
+  against: z6.array(z6.string().min(1)).min(1).describe("Key slots whose signal ducks it \u2014 the voice tracks."),
+  threshold: z6.number().min(0).max(1).optional().describe("Linear 0\u20131, not dB. Lower ducks more readily. Default 0.03."),
+  ratio: z6.number().min(1).max(20).optional().describe("How hard it ducks. Default 8; 12 for a firm hold."),
+  // MILLISECONDS is spelled out because a canvas shipped `attack: 0.05,
+  // release: 0.45` — read as seconds — which is a 0.45 ms release: the bed
+  // snapped back to full level between syllables and the client heard the
+  // music as "too loud" at a level that measured correct.
+  attack: z6.number().min(0.01).optional().describe("MILLISECONDS (not seconds). Typical 5\u201350; default 5. A value below 0.5 is a unit mistake."),
+  release: z6.number().min(0.01).optional().describe(
+    "MILLISECONDS (not seconds). Typical 200\u2013800; default 300. Anything under ~10 makes the bed pump back up between words and is a unit mistake."
+  )
 }).strict();
 var AudioTimelineParams = z6.object({
   tracks: z6.array(Track).min(1),
@@ -8924,15 +9043,29 @@ var MusicParams = z25.object({
   /**
    * video-to-music only — short description of the desired score
    * ("upbeat synth, fast cuts, 80s") used to bias the model.
+   *
+   * The `describe` text below is the one piece of craft this node can enforce
+   * nowhere else: a bed under somebody talking must be ONE steady character.
+   * A description that narrated the speaker's emotional arc ("quiet and tense
+   * while she is overwhelmed, opening as she walks, resolving warm and
+   * confident") came back as a film score and the client's verdict was "la
+   * musica que has elegido es muy dramática".
    */
-  description: z25.string().max(1e3).optional(),
+  description: z25.string().max(1e3).optional().describe(
+    "The score you want, in sound (instruments, tempo, texture) \u2014 not in feelings. Under speech, name ONE steady character and forbid movement: no build, no drop, no climax, no key change, nothing that 'follows the arc'. This model WATCHES the cut, so it will score the footage's emotion unless told not to \u2014 asking it to track a speaker's emotional arc is how a testimonial bed comes back dramatic. A bed is furniture; the voice carries the story."
+  ),
   /** video-to-music only — up to 10 style tags. */
-  tags: z25.array(z25.string()).max(10).optional(),
+  tags: z25.array(z25.string()).max(10).optional().describe(
+    "Style tags. Under speech, prefer tags that hold it still (instrumental, understated, steady, no drums) over tags that move it (cinematic, epic, building, resolving, trailer)."
+  ),
   output_format: z25.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
 }).strict();
 var musicNode = delegated({
   id: "music",
-  version: "1.1.0",
+  // 1.2.0: the ElevenLabs engine moved to `music_v2` (ELEVENLABS_MUSIC_ENGINE).
+  // The bump is not cosmetic — nodeVersion is part of the canvas cache key, so
+  // without it a re-run would serve the v1 bed the switch was made to replace.
+  version: "1.2.0",
   category: "audio",
   summary: "Generate music for ad creatives and website video content. `elevenlabs/music-v1` composes from a text prompt or structured composition plan; `elevenlabs/video-background-music-v1` scores an existing video clip provided via `inputs.video`.",
   when_to_use: "Use to produce background music or a full score for video ads, hero-section reels, or any motion content. Prefer the video-to-music model when you already have a cut and want music timed to it; use compose-detailed when you have only a brief or want section-level control (intro / hook / outro). Pair the resulting audio with `video_generate` or `video_lipsync` at compose time.",
@@ -9317,7 +9450,10 @@ var VideoTranscribeParams = z33.object({
   // Provider choice is explicit (no env-based silent branching). Default Groq
   // Whisper; "deepgram" routes to Deepgram Nova-3, which additionally emits a
   // `rich` JSON output with punctuated words + paragraph/sentence grouping.
-  transcriber: z33.enum(["groq", "deepgram"]).optional()
+  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."
+  )
 }).strict();
 var VideoTranscribeInputs = z33.object({
   // A video (audio auto-extracted locally) OR a bare audio track. The key stays
@@ -9334,10 +9470,10 @@ var VideoTranscribeOutputs = z33.object({
 var AUDIO_EXTRACT_TIMEOUT_MS = 6e4;
 var videoTranscribeNode = defineNode({
   id: "video_transcribe",
-  version: "2.3.0",
+  version: "2.4.0",
   category: "language",
   location: "local",
-  summary: 'Transcribe a video or audio track to a word-level JSON transcript. Default `transcriber:"groq"` uses Groq Whisper Large v3 Turbo ($0.04/hr, 10s min); `transcriber:"deepgram"` uses Deepgram Nova-3 ($0.0043/min) and additionally emits a `rich` JSON output with punctuated words + paragraph/sentence grouping (and speaker indices). Automatically extracts audio locally (mono 16 kHz MP3) before uploading \u2014 reduces payload ~100\xD7 and lifts the effective duration limit well beyond Groq\'s 100 MB file cap. The `transcript` output is always an array of {text, start, end} entries ready to feed Hyperframes caption compositions (Deepgram prefers the punctuated word form).',
+  summary: 'Transcribe a video or audio track to a word-level JSON transcript. Default `transcriber:"groq"` uses Groq Whisper Large v3 Turbo ($0.04/hr, 10s min); `transcriber:"deepgram"` uses Deepgram Nova-3 ($0.0043/min) and additionally emits a `rich` JSON output with punctuated words + paragraph/sentence grouping (and speaker indices). Automatically extracts audio locally (mono 16 kHz MP3) before uploading \u2014 reduces payload ~100\xD7 and lifts the effective duration limit well beyond Groq\'s 100 MB file cap. The `transcript` output is always an array of {text, start, end} entries ready to feed Hyperframes caption compositions (Deepgram prefers the punctuated word form). Known names are spelled the way the brand spells them: the company\'s own name is biased into the request and enforced on the output automatically, and `keyterms` adds any other name the script depends on.',
   when_to_use: 'Use to generate burned-in captions for a stitched video. Pair with `hyperframe_render` and a captions composition (e.g. `tiktok-captions`) by passing the transcript JSON through `params.variables.transcript`. Pick `params.language` to filter out non-target speech (e.g. "es" for Spanish). Pick `transcriber:"deepgram"` when you want punctuation/paragraphs (read them from the `rich` output) or speaker grouping. Requires ffmpeg on PATH for audio extraction (falls back to full video upload if unavailable).',
   inputs: VideoTranscribeInputs,
   params: VideoTranscribeParams,
@@ -9349,7 +9485,7 @@ var videoTranscribeNode = defineNode({
     const effectiveInputs = audioInput ?? inputs;
     return await callBackendExec({
       nodeType: "video_transcribe",
-      nodeVersion: "2.3.0",
+      nodeVersion: "2.4.0",
       params,
       inputs: effectiveInputs,
       outputKinds: { transcript: "json", rich: "json" },
@@ -9666,4 +9802,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-WHUKLAGW.js.map
+//# sourceMappingURL=chunk-BD4GLBWV.js.map