@koda-sl/baker-cli 0.123.0-dev.31b784126 → 0.123.0-dev.4a85b9f30

package/dist/{chunk-Q3K5TXC6.js → chunk-43KBQLP5.js}

@@ -3214,7 +3214,7 @@ var Engine = class {
       log: this.log,
       signal: opts.signal
     };
-    const preparedForExec = needsLocalMaterialization(def) ? { ...prepared, resolvedInputs: await this.materializeLocalInputs(prepared.resolvedInputs) } : prepared;
+    const preparedForExec = def.location === "local" ? { ...prepared, resolvedInputs: await this.materializeLocalInputs(prepared.resolvedInputs) } : prepared;
     const { parsedInputs, parsedParams } = parseNodeArgs(def, preparedForExec, node.id, node.type);
     const result = await invokeExecute(def, parsedInputs, parsedParams, ctx, node.id, node.type);
     const elapsed = Date.now() - t0;
@@ -3336,9 +3336,6 @@ async function invokeExecute(def, parsedInputs, parsedParams, ctx, nodeId, nodeT
     throw new NodeExecutionError(nodeId, nodeType, { kind: "local", cause: e });
   }
 }
-function needsLocalMaterialization(def) {
-  return def.location === "local" && !def.passthroughRefs;
-}
 function pickFinalOutput(canvas, outputs) {
   if (canvas.output) {
     const node = outputs[canvas.output.node];
@@ -3354,7 +3351,7 @@ function computeNeedsLocalBytes(canvas, graph, registry) {
   const needs = /* @__PURE__ */ new Set();
   for (const [consumerId, deps] of graph) {
     const def = registry.get(typeById.get(consumerId) ?? "");
-    if (def?.location !== "local" || def.passthroughRefs) continue;
+    if (def?.location !== "local") continue;
     for (const dep of deps) needs.add(dep);
   }
   return needs;
@@ -4685,56 +4682,19 @@ var audioTimelineNode = defineNode({
   }
 });
 
-// src/engine/nodes/local/collect.ts
-import { z as z7 } from "zod";
-var collectNode = defineNode({
-  id: "collect",
-  version: "1.0.0",
-  category: "data",
-  location: "local",
-  passthroughRefs: true,
-  summary: "Gather images from multiple upstream nodes into one ordered array \u2014 the standard terminal for multi-variant canvases whose final output is several images.",
-  when_to_use: "Point the canvas `output` at this node when several independent branches (e.g. one image_generate per scene/variant) must ALL be finals. Wire `inputs.images` as an array of refs like `$ref:gen_billboard_03.images#0` \u2014 each final inherits its producer node id as its label (or set `params.labels` to override), so variants stay identifiable in the dashboard and selection.",
-  inputs: z7.object({ images: z7.array(ImageRef).min(1) }).strict(),
-  params: z7.object({ labels: z7.array(z7.string().min(1)).min(1).optional() }).strict(),
-  outputs: z7.object({ images: z7.array(ImageRef).min(1) }).strict(),
-  outputKinds: { images: "image" },
-  cost: () => ({ credits: 0, seconds_estimate: 0 }),
-  // Arity is only knowable at validate time when `images` is a literal array;
-  // a single `$ref:` string to an upstream array output defers to runtime.
-  validateExtra: ({ rawParams, rawInputs }) => {
-    const labels = rawParams?.labels;
-    if (!Array.isArray(labels)) return [];
-    if (new Set(labels).size !== labels.length) {
-      return [{ path: "params.labels", message: "labels must be unique \u2014 each names one output variant" }];
-    }
-    const images = rawInputs?.images;
-    if (Array.isArray(images) && labels.length !== images.length) {
-      return [
-        {
-          path: "params.labels",
-          message: `labels has ${labels.length} entries but ${images.length} images are wired \u2014 provide one label per image`
-        }
-      ];
-    }
-    return [];
-  },
-  execute: ({ inputs }) => Promise.resolve({ images: inputs.images })
-});
-
 // src/engine/nodes/local/ffmpeg.ts
-import { z as z8 } from "zod";
+import { z as z7 } from "zod";
 var FFMPEG_BIN2 = "ffmpeg";
-var OutputDecl = z8.object({
-  kind: z8.enum(["image", "video", "audio"]),
-  ext: z8.string().min(1).max(8)
+var OutputDecl = z7.object({
+  kind: z7.enum(["image", "video", "audio"]),
+  ext: z7.string().min(1).max(8)
 }).strict();
-var FfmpegParams = z8.object({
-  args: z8.array(z8.string()).min(1),
-  outputs: z8.record(z8.string(), OutputDecl).default({})
+var FfmpegParams = z7.object({
+  args: z7.array(z7.string()).min(1),
+  outputs: z7.record(z7.string(), OutputDecl).default({})
 }).strict();
-var FfmpegInputs = z8.record(z8.string(), z8.unknown());
-var FfmpegOutputs = z8.record(z8.string(), z8.custom());
+var FfmpegInputs = z7.record(z7.string(), z7.unknown());
+var FfmpegOutputs = z7.record(z7.string(), z7.custom());
 var ffmpegNode = defineNode({
   id: "ffmpeg",
   version: "2.0.0",
@@ -4765,7 +4725,7 @@ import { mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile3 } from "fs/prom
 import { createRequire } from "module";
 import { tmpdir as tmpdir3 } from "os";
 import path6 from "path";
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 
 // src/engine/nodes/local/lib/assets.ts
 import { copyFile as copyFile3, readFile as readFile4 } from "fs/promises";
@@ -4801,15 +4761,15 @@ var DEFAULT_SPECIMEN = [
   "abcdefghijklmnopqrstuvwxyz",
   `0123456789 !?&@#$%().,:;'"-`
 ].join("\n");
-var FontSpecimenParams = z9.object({
-  text: z9.string().min(1).max(2e3).optional().default(DEFAULT_SPECIMEN),
-  font_size: z9.number().int().min(8).max(512).optional().default(72),
-  padding: z9.number().int().min(0).max(512).optional().default(64),
-  line_height: z9.number().min(0.8).max(3).optional().default(1.35),
-  max_width: z9.number().int().min(256).max(4096).optional()
+var FontSpecimenParams = z8.object({
+  text: z8.string().min(1).max(2e3).optional().default(DEFAULT_SPECIMEN),
+  font_size: z8.number().int().min(8).max(512).optional().default(72),
+  padding: z8.number().int().min(0).max(512).optional().default(64),
+  line_height: z8.number().min(0.8).max(3).optional().default(1.35),
+  max_width: z8.number().int().min(256).max(4096).optional()
 }).strict();
-var FontSpecimenInputs = z9.object({ font: FontRef }).loose();
-var FontSpecimenOutputs = z9.object({ image: ImageRef }).strict();
+var FontSpecimenInputs = z8.object({ font: FontRef }).loose();
+var FontSpecimenOutputs = z8.object({ image: ImageRef }).strict();
 var DEVICE_SCALE_FACTOR = 2;
 var PAGE_TIMEOUT_MS = 3e4;
 function escapeHtml(text) {
@@ -4950,7 +4910,7 @@ import { createRequire as createRequire2 } from "module";
 import { cpus, tmpdir as tmpdir4 } from "os";
 import path11 from "path";
 import { promisify as promisify4 } from "util";
-import { z as z11 } from "zod";
+import { z as z10 } from "zod";
 
 // src/engine/engine/composition-hash.ts
 import { readdir as readdir2, readFile as readFile5, stat as stat4 } from "fs/promises";
@@ -4988,62 +4948,62 @@ async function collectFiles(root, current) {
 // src/engine/engine/composition-meta.ts
 import { readFile as readFile6 } from "fs/promises";
 import path8 from "path";
-import { z as z10 } from "zod";
-var InputKind = z10.enum(["video", "image", "audio", "json"]);
-var InputSpec = z10.object({
+import { z as z9 } from "zod";
+var InputKind = z9.enum(["video", "image", "audio", "json"]);
+var InputSpec = z9.object({
   kind: InputKind,
-  required: z10.boolean().optional().default(false),
+  required: z9.boolean().optional().default(false),
   // Filename the composition's HTML references (e.g. `input.mp4`, `logo.png`).
   // Defaults to `<key><ext>` derived from the kind.
-  staged_as: z10.string().min(1).optional(),
-  description: z10.string().optional()
+  staged_as: z9.string().min(1).optional(),
+  description: z9.string().optional()
 }).strict();
 var ParamSpecBase = {
-  required: z10.boolean().optional().default(false),
-  description: z10.string().optional()
+  required: z9.boolean().optional().default(false),
+  description: z9.string().optional()
 };
-var StringParam = z10.object({
+var StringParam = z9.object({
   ...ParamSpecBase,
-  kind: z10.literal("string"),
-  default: z10.string().optional(),
-  enum: z10.array(z10.string()).optional()
+  kind: z9.literal("string"),
+  default: z9.string().optional(),
+  enum: z9.array(z9.string()).optional()
 }).strict();
-var IntegerParam = z10.object({
+var IntegerParam = z9.object({
   ...ParamSpecBase,
-  kind: z10.literal("integer"),
-  default: z10.number().int().optional(),
-  min: z10.number().int().optional(),
-  max: z10.number().int().optional()
+  kind: z9.literal("integer"),
+  default: z9.number().int().optional(),
+  min: z9.number().int().optional(),
+  max: z9.number().int().optional()
 }).strict();
-var NumberParam = z10.object({
+var NumberParam = z9.object({
   ...ParamSpecBase,
-  kind: z10.literal("number"),
-  default: z10.number().optional(),
-  min: z10.number().optional(),
-  max: z10.number().optional()
+  kind: z9.literal("number"),
+  default: z9.number().optional(),
+  min: z9.number().optional(),
+  max: z9.number().optional()
 }).strict();
-var BooleanParam = z10.object({
+var BooleanParam = z9.object({
   ...ParamSpecBase,
-  kind: z10.literal("boolean"),
-  default: z10.boolean().optional()
+  kind: z9.literal("boolean"),
+  default: z9.boolean().optional()
 }).strict();
-var ColorParam = z10.object({
+var ColorParam = z9.object({
   ...ParamSpecBase,
-  kind: z10.literal("color"),
-  default: z10.string().optional()
+  kind: z9.literal("color"),
+  default: z9.string().optional()
 }).strict();
-var ImageParam = z10.object({
+var ImageParam = z9.object({
   ...ParamSpecBase,
-  kind: z10.literal("image"),
-  default: z10.string().optional()
+  kind: z9.literal("image"),
+  default: z9.string().optional()
 }).strict();
-var JsonParam = z10.object({
+var JsonParam = z9.object({
   ...ParamSpecBase,
-  kind: z10.literal("json"),
-  schema: z10.unknown().optional(),
-  default: z10.unknown().optional()
+  kind: z9.literal("json"),
+  schema: z9.unknown().optional(),
+  default: z9.unknown().optional()
 }).strict();
-var ParamSpec = z10.discriminatedUnion("kind", [
+var ParamSpec = z9.discriminatedUnion("kind", [
   StringParam,
   IntegerParam,
   NumberParam,
@@ -5052,16 +5012,16 @@ var ParamSpec = z10.discriminatedUnion("kind", [
   ImageParam,
   JsonParam
 ]);
-var CompositionMetaSchema = z10.object({
-  id: z10.string().min(1),
-  title: z10.string().min(1),
-  description: z10.string().optional(),
-  width: z10.number().int().positive(),
-  height: z10.number().int().positive(),
-  fps: z10.number().int().positive().default(30),
-  default_duration: z10.number().positive().default(10),
-  inputs: z10.record(z10.string(), InputSpec).default({}),
-  params: z10.record(z10.string(), ParamSpec).default({})
+var CompositionMetaSchema = z9.object({
+  id: z9.string().min(1),
+  title: z9.string().min(1),
+  description: z9.string().optional(),
+  width: z9.number().int().positive(),
+  height: z9.number().int().positive(),
+  fps: z9.number().int().positive().default(30),
+  default_duration: z9.number().positive().default(10),
+  inputs: z9.record(z9.string(), InputSpec).default({}),
+  params: z9.record(z9.string(), ParamSpec).default({})
 }).strict();
 async function loadCompositionMeta(compositionDir) {
   const metaPath = path8.join(compositionDir, "meta.json");
@@ -5089,39 +5049,39 @@ function buildParamsSchema(meta) {
   for (const [name, spec] of Object.entries(meta.params)) {
     shape[name] = buildParamFieldSchema(name, spec);
   }
-  return z10.object(shape).strict();
+  return z9.object(shape).strict();
 }
 function buildParamFieldSchema(name, spec) {
   switch (spec.kind) {
     case "string": {
-      const s = spec.enum && spec.enum.length > 0 ? z10.enum(spec.enum) : z10.string();
+      const s = spec.enum && spec.enum.length > 0 ? z9.enum(spec.enum) : z9.string();
       return finalize(s, spec.default, spec.required);
     }
     case "integer": {
-      let s = z10.number().int();
+      let s = z9.number().int();
       if (spec.min !== void 0) s = s.min(spec.min);
       if (spec.max !== void 0) s = s.max(spec.max);
       return finalize(s, spec.default, spec.required);
     }
     case "number": {
-      let s = z10.number();
+      let s = z9.number();
       if (spec.min !== void 0) s = s.min(spec.min);
       if (spec.max !== void 0) s = s.max(spec.max);
       return finalize(s, spec.default, spec.required);
     }
     case "boolean":
-      return finalize(z10.boolean(), spec.default, spec.required);
+      return finalize(z9.boolean(), spec.default, spec.required);
     case "color": {
-      const s = z10.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
+      const s = z9.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
         message: `param "${name}": must be a 3/6/8-digit hex color (e.g. "#ff0066")`
       });
       return finalize(s, spec.default, spec.required);
     }
     case "image":
-      return finalize(z10.union([z10.string().min(1), z10.record(z10.string(), z10.unknown())]), spec.default, spec.required);
+      return finalize(z9.union([z9.string().min(1), z9.record(z9.string(), z9.unknown())]), spec.default, spec.required);
     case "json":
       return finalize(
-        z10.unknown().refine((v) => v !== void 0, { message: `param "${name}" is required` }),
+        z9.unknown().refine((v) => v !== void 0, { message: `param "${name}" is required` }),
         spec.default,
         spec.required
       );
@@ -5421,17 +5381,17 @@ function literalize(value) {
 // src/engine/nodes/local/hyperframe.ts
 var execFileAsync2 = promisify4(execFile4);
 var require_2 = createRequire2(import.meta.url);
-var HyperframeParams = z11.object({
-  composition: z11.string().min(1),
+var HyperframeParams = z10.object({
+  composition: z10.string().min(1),
   // Output container. mp4 (default) for delivery; webm/mov render WITH
   // transparency (alpha) when the composition background is transparent —
   // use for motion-graphic overlays dropped into Premiere/AE/Nuke.
-  format: z11.enum(["mp4", "webm", "mov"]).optional().default("mp4"),
-  timeout_ms: z11.number().int().positive().optional().default(10 * 60 * 1e3)
-}).catchall(z11.unknown());
-var HyperframeInputs = z11.record(z11.string(), z11.custom()).optional().default({});
-var HyperframeOutputs = z11.object({
-  video: z11.custom()
+  format: z10.enum(["mp4", "webm", "mov"]).optional().default("mp4"),
+  timeout_ms: z10.number().int().positive().optional().default(10 * 60 * 1e3)
+}).catchall(z10.unknown());
+var HyperframeInputs = z10.record(z10.string(), z10.custom()).optional().default({});
+var HyperframeOutputs = z10.object({
+  video: z10.custom()
 }).strict();
 var NODE_OWNED_PARAM_KEYS = /* @__PURE__ */ new Set(["composition", "format", "timeout_ms"]);
 var MIME_BY_FORMAT = {
@@ -5720,23 +5680,23 @@ import { createRequire as createRequire3 } from "module";
 import { tmpdir as tmpdir5 } from "os";
 import path12 from "path";
 import { promisify as promisify5 } from "util";
-import { z as z12 } from "zod";
+import { z as z11 } from "zod";
 var _execFileAsync = promisify5(execFile5);
 var require_3 = createRequire3(import.meta.url);
-var WaitForSpec = z12.discriminatedUnion("kind", [
-  z12.object({ kind: z12.literal("auto") }),
-  z12.object({ kind: z12.literal("selector"), value: z12.string().min(1) }),
-  z12.object({ kind: z12.literal("function"), value: z12.string().min(1) }),
-  z12.object({ kind: z12.literal("timeout"), ms: z12.number().int().min(0).max(6e4) })
+var WaitForSpec = z11.discriminatedUnion("kind", [
+  z11.object({ kind: z11.literal("auto") }),
+  z11.object({ kind: z11.literal("selector"), value: z11.string().min(1) }),
+  z11.object({ kind: z11.literal("function"), value: z11.string().min(1) }),
+  z11.object({ kind: z11.literal("timeout"), ms: z11.number().int().min(0).max(6e4) })
 ]);
-var HyperframeSnapshotParams = z12.object({
-  composition: z12.string().min(1),
+var HyperframeSnapshotParams = z11.object({
+  composition: z11.string().min(1),
   wait_for: WaitForSpec.optional().default({ kind: "auto" }),
-  timeout_ms: z12.number().int().positive().optional().default(6e4)
-}).catchall(z12.unknown());
-var HyperframeSnapshotInputs = z12.record(z12.string(), z12.custom()).optional().default({});
-var HyperframeSnapshotOutputs = z12.object({
-  image: z12.custom()
+  timeout_ms: z11.number().int().positive().optional().default(6e4)
+}).catchall(z11.unknown());
+var HyperframeSnapshotInputs = z11.record(z11.string(), z11.custom()).optional().default({});
+var HyperframeSnapshotOutputs = z11.object({
+  image: z11.custom()
 }).strict();
 var NODE_OWNED_PARAM_KEYS2 = /* @__PURE__ */ new Set(["composition", "wait_for", "timeout_ms"]);
 var DEVICE_SCALE_FACTOR2 = 2;
@@ -5928,18 +5888,18 @@ async function waitForReady(page, waitFor, timeoutMs) {
 // src/engine/nodes/local/imagemagick.ts
 import { execFile as execFile6 } from "child_process";
 import { promisify as promisify6 } from "util";
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 var execFileAsync3 = promisify6(execFile6);
-var OutputDecl2 = z13.object({
-  kind: z13.enum(["image", "video", "audio"]),
-  ext: z13.string().min(1).max(8)
+var OutputDecl2 = z12.object({
+  kind: z12.enum(["image", "video", "audio"]),
+  ext: z12.string().min(1).max(8)
 }).strict();
-var ImageMagickParams = z13.object({
-  args: z13.array(z13.string()).min(1),
-  outputs: z13.record(z13.string(), OutputDecl2).default({})
+var ImageMagickParams = z12.object({
+  args: z12.array(z12.string()).min(1),
+  outputs: z12.record(z12.string(), OutputDecl2).default({})
 }).strict();
-var ImageMagickInputs = z13.record(z13.string(), z13.unknown());
-var ImageMagickOutputs = z13.record(z13.string(), z13.custom());
+var ImageMagickInputs = z12.record(z12.string(), z12.unknown());
+var ImageMagickOutputs = z12.record(z12.string(), z12.custom());
 var resolvedBin;
 async function resolveBin() {
   if (resolvedBin) return resolvedBin;
@@ -5981,29 +5941,29 @@ var imagemagickNode = defineNode({
 });
 
 // src/engine/nodes/local/text.ts
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 var textNode = defineNode({
   id: "text",
   version: "1.0.0",
   category: "data",
   location: "local",
   summary: "A literal text value. Use for prompts, descriptions, copy.",
-  inputs: z14.object({}).strict(),
-  params: z14.object({ value: z14.string() }).strict(),
-  outputs: z14.object({ text: z14.string() }).strict(),
+  inputs: z13.object({}).strict(),
+  params: z13.object({ value: z13.string() }).strict(),
+  outputs: z13.object({ text: z13.string() }).strict(),
   cost: () => ({ credits: 0, seconds_estimate: 0 }),
   execute: ({ params }) => Promise.resolve({ text: params.value })
 });
 
 // src/engine/nodes/remote/audioVoiceConvert.ts
-import { z as z15 } from "zod";
-var AudioVoiceConvertParams = z15.object({
-  model: z15.literal("elevenlabs/eleven_multilingual_sts_v2"),
+import { z as z14 } from "zod";
+var AudioVoiceConvertParams = z14.object({
+  model: z14.literal("elevenlabs/eleven_multilingual_sts_v2"),
   /** Target voice id. Splice an upstream `voice_select` via `"{{voice_ref}}"`. */
-  voice: z15.string().min(1),
-  output_format: z15.string().optional(),
+  voice: z14.string().min(1),
+  output_format: z14.string().optional(),
   /** Strip the source clip's background noise before re-voicing. */
-  remove_background_noise: z15.boolean().optional()
+  remove_background_noise: z14.boolean().optional()
 }).strict();
 var audioVoiceConvertNode = delegated({
   id: "audio_voice_convert",
@@ -6011,44 +5971,44 @@ var audioVoiceConvertNode = delegated({
   category: "audio",
   summary: "Voice Changer / speech-to-speech via ElevenLabs (eleven_multilingual_sts_v2). Re-voices an existing audio clip in a TARGET voice while preserving timing/prosody.",
   when_to_use: 'Use to normalize a generator-chosen voice (e.g. a Seedance talking-head clip\'s native audio) into ONE consistent brand voice across every scene \u2014 the cadence is preserved so any lip-sync stays valid. Wire `inputs.voice_ref: $ref:<voice_select>.voice_id` and set `params.voice: "{{voice_ref}}"`.',
-  inputs: z15.object({
+  inputs: z14.object({
     audio: AudioRef,
     voice_ref: TextRef.optional()
   }).strict(),
   params: AudioVoiceConvertParams,
-  outputs: z15.object({ audio: AudioRef }).strict(),
+  outputs: z14.object({ audio: AudioRef }).strict(),
   outputKinds: { audio: "audio" },
   cost: () => ({ credits: 1, seconds_estimate: 20 })
 });
 
 // src/engine/nodes/remote/dialogue.ts
-import { z as z16 } from "zod";
-var DialogueInput = z16.object({
-  text: z16.string().min(1),
-  voice_id: z16.string().min(1)
+import { z as z15 } from "zod";
+var DialogueInput = z15.object({
+  text: z15.string().min(1),
+  voice_id: z15.string().min(1)
 });
 var DIALOGUE_MODELS = ["elevenlabs/eleven_v3"];
-var DialogueParams = z16.object({
-  model: z16.enum(DIALOGUE_MODELS),
+var DialogueParams = z15.object({
+  model: z15.enum(DIALOGUE_MODELS),
   /**
    * Ordered list of lines, each tagged with the voice that should speak it.
    * Up to 10 unique voice_ids; total text across all lines should stay under
    * ~2000 characters for best quality (ElevenLabs guidance).
    */
-  inputs: z16.array(DialogueInput).min(1).max(50),
-  language_code: z16.string().optional(),
+  inputs: z15.array(DialogueInput).min(1).max(50),
+  language_code: z15.string().optional(),
   /** ElevenLabs voice/model settings passthrough (e.g. `{ stability: 0.5 }`). */
-  settings: z16.record(z16.string(), z16.unknown()).optional(),
-  seed: z16.number().int().min(0).max(4294967295).optional(),
-  apply_text_normalization: z16.enum(["auto", "on", "off"]).optional(),
+  settings: z15.record(z15.string(), z15.unknown()).optional(),
+  seed: z15.number().int().min(0).max(4294967295).optional(),
+  apply_text_normalization: z15.enum(["auto", "on", "off"]).optional(),
   /**
    * When true, hits `/v1/text-to-dialogue/with-timestamps` and emits a
    * separate `timestamps` output — character-level alignment plus
    * per-voice segment markers usable for captions, lipsync, or
    * beat-matched cuts in ad creatives.
    */
-  with_timestamps: z16.boolean().optional(),
-  output_format: z16.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
+  with_timestamps: z15.boolean().optional(),
+  output_format: z15.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
 }).strict().refine((p) => p.inputs.reduce((sum, line) => sum + line.text.length, 0) <= ELEVENLABS_MAX_TEXT_CHARS, {
   message: `total dialogue text exceeds ${ELEVENLABS_MAX_TEXT_CHARS} characters`,
   path: ["inputs"]
@@ -6059,9 +6019,9 @@ var dialogueNode = delegated({
   category: "audio",
   summary: "Multi-voice dialogue / VO with ElevenLabs Eleven v3. Each line is tagged with a `voice_id`, so you can render two-character scripts (e.g. ad VO + customer testimonial reaction) in a single call. Setting `with_timestamps: true` adds character-level alignment for caption rendering and lipsync-friendly cuts.",
   when_to_use: "Use for any ad creative or website video VO that needs more than narration \u2014 interviews, two-actor scripts, character ads, testimonial reads. For single-voice flat reads the existing `tts` node is cheaper and simpler; reach for `dialogue` when you need multiple speakers in one stitched track or word-level timing for downstream lipsync / captions.",
-  inputs: z16.object({}).loose(),
+  inputs: z15.object({}).loose(),
   params: DialogueParams,
-  outputs: z16.object({ audio: AudioRef, timestamps: JsonRef.optional() }).strict(),
+  outputs: z15.object({ audio: AudioRef, timestamps: JsonRef.optional() }).strict(),
   outputKinds: { audio: "audio", timestamps: "json" },
   cost: ({ params }) => {
     const chars = params.inputs.reduce((sum, line) => sum + line.text.length, 0);
@@ -6070,7 +6030,7 @@ var dialogueNode = delegated({
 });
 
 // src/engine/nodes/remote/image.ts
-import { z as z17 } from "zod";
+import { z as z16 } from "zod";
 var IMAGE_GENERATE_MODELS2 = [
   "openai/gpt-5.4-image-2",
   "google/gemini-3.5-flash",
@@ -6078,16 +6038,16 @@ var IMAGE_GENERATE_MODELS2 = [
   "google/gemini-3-pro-image-preview",
   "recraft/recraft-v4.1-pro-vector"
 ];
-var ImageGenerateParams = z17.object({
-  model: z17.enum(IMAGE_GENERATE_MODELS2),
-  prompt: z17.string().min(1),
-  aspect_ratio: z17.enum(["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "4:5", "5:4", "21:9", "1:4", "4:1", "1:8", "8:1"]).optional(),
-  image_size: z17.enum(["0.5K", "1K", "2K", "4K"]).optional(),
+var ImageGenerateParams = z16.object({
+  model: z16.enum(IMAGE_GENERATE_MODELS2),
+  prompt: z16.string().min(1),
+  aspect_ratio: z16.enum(["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "4:5", "5:4", "21:9", "1:4", "4:1", "1:8", "8:1"]).optional(),
+  image_size: z16.enum(["0.5K", "1K", "2K", "4K"]).optional(),
   // Recraft v4 vector controls — forwarded into `image_config`. Registry
   // rejects them on non-Recraft models.
-  strength: z17.number().min(0).max(1).optional(),
-  rgb_colors: z17.array(z17.array(z17.number().int().min(0).max(255))).optional(),
-  background_rgb_color: z17.array(z17.number().int().min(0).max(255)).optional()
+  strength: z16.number().min(0).max(1).optional(),
+  rgb_colors: z16.array(z16.array(z16.number().int().min(0).max(255))).optional(),
+  background_rgb_color: z16.array(z16.number().int().min(0).max(255)).optional()
 }).strict();
 var imageGenerateNode = delegated({
   id: "image_generate",
@@ -6097,22 +6057,22 @@ var imageGenerateNode = delegated({
   when_to_use: "Use for hero shots, product photography, illustrations, and vector logos. `recraft/recraft-v4.1-pro-vector` for crisp vector / logo work; `openai/gpt-5.4-image-2` for photorealistic; Gemini variants for fast iteration and editing via the `reference` input. `reference` accepts ONE image or an ARRAY of images \u2014 wire several to combine references in a single generation (e.g. a subject sheet + a font specimen + the original ad). Every reference is forwarded to the model in array order.",
   // `reference` is one image or an ordered array of images. The backend forwards
   // each as a separate `image_url` to the provider (OpenRouter accepts many).
-  inputs: z17.object({ reference: z17.union([ImageRef, z17.array(ImageRef).min(1)]).optional() }).loose(),
+  inputs: z16.object({ reference: z16.union([ImageRef, z16.array(ImageRef).min(1)]).optional() }).loose(),
   params: ImageGenerateParams,
-  outputs: z17.object({ images: z17.array(ImageRef).min(1) }).strict(),
+  outputs: z16.object({ images: z16.array(ImageRef).min(1) }).strict(),
   outputKinds: { images: "image" },
   cost: () => ({ credits: 5, seconds_estimate: 10 })
 });
 
 // src/engine/nodes/remote/imageAspectAdapt.ts
-import { z as z18 } from "zod";
+import { z as z17 } from "zod";
 var ASPECT_ADAPT_MODELS = ["google/gemini-3-pro-image-preview", "google/gemini-3.1-flash-image-preview"];
 var ASPECT_ADAPT_FORMATS = ["1:1", "2:3", "3:2", "3:4", "4:3", "4:5", "5:4", "9:16", "16:9", "21:9"];
-var ImageAspectAdaptParams = z18.object({
-  model: z18.enum(ASPECT_ADAPT_MODELS),
-  formats: z18.array(z18.enum(ASPECT_ADAPT_FORMATS)).min(1).max(6).refine((formats) => new Set(formats).size === formats.length, { message: "formats must be unique" }),
-  guidance: z18.string().min(1).optional(),
-  image_size: z18.enum(["0.5K", "1K", "2K", "4K"]).optional()
+var ImageAspectAdaptParams = z17.object({
+  model: z17.enum(ASPECT_ADAPT_MODELS),
+  formats: z17.array(z17.enum(ASPECT_ADAPT_FORMATS)).min(1).max(6).refine((formats) => new Set(formats).size === formats.length, { message: "formats must be unique" }),
+  guidance: z17.string().min(1).optional(),
+  image_size: z17.enum(["0.5K", "1K", "2K", "4K"]).optional()
 }).strict();
 var imageAspectAdaptNode = delegated({
   id: "image_aspect_adapt",
@@ -6120,9 +6080,9 @@ var imageAspectAdaptNode = delegated({
   category: "image",
   summary: "Adapt ONE creative into multiple aspect ratios (Meta: 9:16 stories, 1:1 feed, 4:5, 16:9\u2026) in a single step. AI recomposes the layout per format \u2014 identical subject, text, logos, colors, and style; the scene is extended/restructured, never stretched or cropped. Formats that already match the source ratio pass through unchanged at zero cost. Outputs are ordered exactly as `formats`.",
   when_to_use: "Use after a hero creative exists (image_generate, ingest, image_search) to fan it out to every placement format \u2014 wire the creative into `source` and list the target ratios in `formats`. Cost is estimated per format; formats matching the source ratio are free pass-throughs. Pick `google/gemini-3.1-flash-image-preview` (Nano Banana flash) while iterating, `google/gemini-3-pro-image-preview` (Nano Banana Pro) for final-quality adaptation.",
-  inputs: z18.object({ source: ImageRef }).loose(),
+  inputs: z17.object({ source: ImageRef }).loose(),
   params: ImageAspectAdaptParams,
-  outputs: z18.object({ images: z18.array(ImageRef).min(1) }).strict(),
+  outputs: z17.object({ images: z17.array(ImageRef).min(1) }).strict(),
   outputKinds: { images: "image" },
   cost: ({ params }) => {
     const p = params;
@@ -6135,12 +6095,12 @@ var imageAspectAdaptNode = delegated({
 });
 
 // src/engine/nodes/remote/imageBackgroundRemove.ts
-import { z as z19 } from "zod";
-var ImageBackgroundRemoveParams = z19.object({
-  model: z19.literal("fal/birefnet-v2").optional().default("fal/birefnet-v2"),
-  model_variant: z19.enum(["General Use (Light)", "General Use (Heavy)", "Matting", "Portrait", "DIS", "HRSOD", "COD"]).optional().default("General Use (Light)"),
-  operating_resolution: z19.enum(["1024x1024", "2048x2048", "2304x2304"]).optional(),
-  mask_only: z19.boolean().optional().default(false)
+import { z as z18 } from "zod";
+var ImageBackgroundRemoveParams = z18.object({
+  model: z18.literal("fal/birefnet-v2").optional().default("fal/birefnet-v2"),
+  model_variant: z18.enum(["General Use (Light)", "General Use (Heavy)", "Matting", "Portrait", "DIS", "HRSOD", "COD"]).optional().default("General Use (Light)"),
+  operating_resolution: z18.enum(["1024x1024", "2048x2048", "2304x2304"]).optional(),
+  mask_only: z18.boolean().optional().default(false)
 }).strict();
 var imageBackgroundRemoveNode = delegated({
   id: "image_background_remove",
@@ -6148,11 +6108,11 @@ var imageBackgroundRemoveNode = delegated({
   category: "image",
   summary: "Remove the background from an image and return a transparent PNG (or the segmentation mask). Powered by fal.ai `fal-ai/birefnet/v2`.",
   when_to_use: "Use to extract subjects from photos for use as overlays in hyperframe compositions, product shots, or compositing pipelines. Set `mask_only:true` to return the binary mask instead of the alpha-cut image.",
-  inputs: z19.object({
+  inputs: z18.object({
     image: ImageRef
   }).strict(),
   params: ImageBackgroundRemoveParams,
-  outputs: z19.object({
+  outputs: z18.object({
     image: ImageRef,
     mask: ImageRef.optional()
   }).strict(),
@@ -6161,7 +6121,7 @@ var imageBackgroundRemoveNode = delegated({
 });
 
 // src/engine/nodes/remote/imageDescribe.ts
-import { z as z20 } from "zod";
+import { z as z19 } from "zod";
 var IMAGE_DESCRIBE_MODELS = ["~google/gemini-pro-latest", "~google/gemini-flash-latest"];
 var imageDescribeNode = delegated({
   id: "image_describe",
@@ -6169,33 +6129,33 @@ var imageDescribeNode = delegated({
   category: "vision",
   summary: "Reverse-engineer an image into an exhaustive, replication-grade JSON description: who the advertiser is and what they sell (source_context), composition, non-person subjects with expression/treatment, deeply detailed people, brand-identified logos (named by brand, not appearance), camera optics, lighting, color palette WITH per-color brand-ownership (brand vs borrowed-functional) and purpose, materials, visible text, ad signals (proof badges/CTA/price), the persuasion engine (ad_intent), style, post-processing.",
   when_to_use: 'Use to turn a reference image into a structured blueprint you can inject into downstream prompts via `{{slot}}` \u2014 e.g. restyle a competitor ad onto your own product, lock a look across a series, or feed exact palette/lighting into image_generate. Purpose-built for market adaptation: logos are identified by brand ("Trustpilot", never "green star"), people and animals carry expression/emotion/intent detail, and each color is tagged brand vs borrowed-functional so a recolor can keep the reds/yellows that do a job. The extraction prompt is baked in; use `focus` to emphasise aspects and `context` to pass known provenance (advertiser, category, market) so source_context and color ownership are grounded. Pick `~google/gemini-pro-latest` for the densest extraction (recommended for ad / market-adaptation passes), `~google/gemini-flash-latest` for cheap/fast passes. The output is rich \u2014 raise `max_tokens` (e.g. 8000+) for dense ads so the JSON isn\'t truncated.',
-  inputs: z20.object({ image: ImageRef }).loose(),
-  params: z20.object({
-    model: z20.enum(IMAGE_DESCRIBE_MODELS),
-    focus: z20.string().optional(),
-    context: z20.string().optional(),
-    temperature: z20.number().min(0).max(2).optional(),
-    max_tokens: z20.number().int().positive().optional()
+  inputs: z19.object({ image: ImageRef }).loose(),
+  params: z19.object({
+    model: z19.enum(IMAGE_DESCRIBE_MODELS),
+    focus: z19.string().optional(),
+    context: z19.string().optional(),
+    temperature: z19.number().min(0).max(2).optional(),
+    max_tokens: z19.number().int().positive().optional()
   }).strict(),
-  outputs: z20.object({ description: JsonRef }).strict(),
+  outputs: z19.object({ description: JsonRef }).strict(),
   outputKinds: { description: "json" },
   cost: () => ({ credits: 2, seconds_estimate: 10 })
 });
 
 // src/engine/nodes/remote/imageReferenceSheet.ts
-import { z as z21 } from "zod";
+import { z as z20 } from "zod";
 var REFERENCE_SHEET_MODELS = ["google/gemini-3-pro-image-preview", "google/gemini-3.1-flash-image-preview"];
-var ImageReferenceSheetParams = z21.object({
-  model: z21.enum(REFERENCE_SHEET_MODELS),
-  subject_description: z21.string().min(1),
+var ImageReferenceSheetParams = z20.object({
+  model: z20.enum(REFERENCE_SHEET_MODELS),
+  subject_description: z20.string().min(1),
   // `location` = a set/room shown from several camera ANGLES (not a rotated subject),
   // so a multi-scene shoot keeps one consistent set.
-  subject_type: z21.enum(["character", "person", "product", "location"]),
-  views: z21.array(z21.string().min(1)).min(2).max(8).optional(),
-  style: z21.string().optional(),
-  prompt_override: z21.string().min(1).optional(),
-  aspect_ratio: z21.enum(["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "4:5", "5:4", "21:9", "1:4", "4:1", "1:8", "8:1"]).optional(),
-  image_size: z21.enum(["0.5K", "1K", "2K", "4K"]).optional()
+  subject_type: z20.enum(["character", "person", "product", "location"]),
+  views: z20.array(z20.string().min(1)).min(2).max(8).optional(),
+  style: z20.string().optional(),
+  prompt_override: z20.string().min(1).optional(),
+  aspect_ratio: z20.enum(["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "4:5", "5:4", "21:9", "1:4", "4:1", "1:8", "8:1"]).optional(),
+  image_size: z20.enum(["0.5K", "1K", "2K", "4K"]).optional()
 }).strict();
 var imageReferenceSheetNode = delegated({
   id: "image_reference_sheet",
@@ -6203,9 +6163,9 @@ var imageReferenceSheetNode = delegated({
   category: "image",
   summary: "Fuse 1\u20136 images of a single subject (person, character, product, or location/set) into ONE multi-view reference sheet \u2014 a labeled grid in consistent style and lighting: a turnaround (FRONT / SIDE / BACK\u2026) for a person/character/product, or several camera angles of the same room (WIDE / REVERSE / DETAIL\u2026) for a location. Curated models: Gemini 3 Pro Image (best fusion + labels), Gemini 3.1 Flash Image (cheap iteration).",
   when_to_use: "Use before image_generate / video_generate when a subject must stay consistent across many creatives \u2014 wire the `sheet` output into their `reference` input instead of re-describing the subject per prompt. `subject_description` should be the exact wording you reuse downstream. Pick `google/gemini-3-pro-image-preview` for final 6-view sheets at 2K+, `google/gemini-3.1-flash-image-preview` while iterating.",
-  inputs: z21.object({ references: z21.array(ImageRef).min(1).max(6) }).loose(),
+  inputs: z20.object({ references: z20.array(ImageRef).min(1).max(6) }).loose(),
   params: ImageReferenceSheetParams,
-  outputs: z21.object({ sheet: ImageRef }).strict(),
+  outputs: z20.object({ sheet: ImageRef }).strict(),
   outputKinds: { sheet: "image" },
   cost: ({ params }) => ({
     credits: params?.model === "google/gemini-3-pro-image-preview" ? 20 : 5,
@@ -6214,10 +6174,10 @@ var imageReferenceSheetNode = delegated({
 });
 
 // src/engine/nodes/remote/imageSearch.ts
-import { z as z22 } from "zod";
-var ImageSearchParams = z22.object({
-  prompt: z22.string().min(1),
-  count: z22.number().int().min(1).max(20).default(5)
+import { z as z21 } from "zod";
+var ImageSearchParams = z21.object({
+  prompt: z21.string().min(1),
+  count: z21.number().int().min(1).max(20).default(5)
 }).strict();
 var imageSearchNode = delegated({
   id: "image_search",
@@ -6225,15 +6185,15 @@ var imageSearchNode = delegated({
   category: "image",
   summary: "Agentic image search across Google Images, stock photography (Freepik), and Pinterest. An LLM agent picks the search tools and queries, selects the best matches, and the results are downloaded into canvas assets.",
   when_to_use: "Use to gather real-world reference or inspiration images for a prompt (e.g. several photos of an australian shepherd) so a later step or the user can pick the best one. Not for creating new imagery \u2014 use image_generate for that.",
-  inputs: z22.object({}).loose(),
+  inputs: z21.object({}).loose(),
   params: ImageSearchParams,
-  outputs: z22.object({ images: z22.array(ImageRef).min(1) }).strict(),
+  outputs: z21.object({ images: z21.array(ImageRef).min(1) }).strict(),
   outputKinds: { images: "image" },
   cost: ({ params }) => ({ credits: Math.ceil(2 + params.count / 2), seconds_estimate: 30 })
 });
 
 // src/engine/nodes/remote/imageSelect.ts
-import { z as z23 } from "zod";
+import { z as z22 } from "zod";
 var IMAGE_SELECT_MODELS = ["~google/gemini-flash-latest", "~google/gemini-pro-latest"];
 var imageSelectNode = delegated({
   id: "image_select",
@@ -6241,15 +6201,15 @@ var imageSelectNode = delegated({
   category: "vision",
   summary: "Pick the best `count` images out of 2+ candidates with a vision LLM, judged against a prompt. Outputs a passthrough subset of the input refs (no new pixels) plus the model's comparative reasoning.",
   when_to_use: "Use after fanning out several image_generate variants (or any pool of 2+ images) to keep only the strongest before expensive downstream steps \u2014 video generation, reference sheets, final delivery. `count` fixes the output size, so `images#0`\u2026`images#count-1` are always safe to wire. Pick `~google/gemini-flash-latest` for cheap/fast picks and `~google/gemini-pro-latest` for harder aesthetic judgement.",
-  inputs: z23.object({ images: z23.array(ImageRef).min(2) }).loose(),
-  params: z23.object({
-    model: z23.enum(IMAGE_SELECT_MODELS),
-    prompt: z23.string().min(1),
-    count: z23.number().int().min(1).default(1),
-    temperature: z23.number().min(0).max(2).optional(),
-    max_tokens: z23.number().int().positive().optional()
+  inputs: z22.object({ images: z22.array(ImageRef).min(2) }).loose(),
+  params: z22.object({
+    model: z22.enum(IMAGE_SELECT_MODELS),
+    prompt: z22.string().min(1),
+    count: z22.number().int().min(1).default(1),
+    temperature: z22.number().min(0).max(2).optional(),
+    max_tokens: z22.number().int().positive().optional()
   }).strict(),
-  outputs: z23.object({ images: z23.array(ImageRef).min(1), reasoning: TextRef }).strict(),
+  outputs: z22.object({ images: z22.array(ImageRef).min(1), reasoning: TextRef }).strict(),
   outputKinds: { images: "image", reasoning: "text" },
   cost: () => ({ credits: 1, seconds_estimate: 5 }),
   // Arity is only knowable at validate time when `images` is a literal array
@@ -6274,34 +6234,34 @@ var imageSelectNode = delegated({
 });
 
 // src/engine/nodes/remote/music.ts
-import { z as z24 } from "zod";
+import { z as z23 } from "zod";
 var MUSIC_MODELS = ["elevenlabs/music-v1", "elevenlabs/video-background-music-v1"];
-var MusicParams = z24.object({
-  model: z24.enum(MUSIC_MODELS),
+var MusicParams = z23.object({
+  model: z23.enum(MUSIC_MODELS),
   /** Free-form prompt. Used by `elevenlabs/music-v1` (compose-detailed). */
-  prompt: z24.string().optional(),
+  prompt: z23.string().optional(),
   /**
    * Structured composition plan (intro / hook / verse / outro sections with
    * per-section styles + durations). Mutually exclusive with `prompt`.
    */
-  composition_plan: z24.record(z24.string(), z24.unknown()).optional(),
+  composition_plan: z23.record(z23.string(), z23.unknown()).optional(),
   /** Target length when using `prompt`. 3000–454545ms (capped by the $10 per-node cost limit). */
-  music_length_ms: z24.number().int().min(3e3).max(ELEVENLABS_MAX_MUSIC_LENGTH_MS).optional(),
-  seed: z24.number().int().optional(),
+  music_length_ms: z23.number().int().min(3e3).max(ELEVENLABS_MAX_MUSIC_LENGTH_MS).optional(),
+  seed: z23.number().int().optional(),
   /** Prompt mode only — forces an instrumental (no vocals) track. */
-  force_instrumental: z24.boolean().optional(),
+  force_instrumental: z23.boolean().optional(),
   /** composition_plan only — honor exact section durations. */
-  respect_sections_durations: z24.boolean().optional(),
+  respect_sections_durations: z23.boolean().optional(),
   /** Emit word-level timestamps alongside the audio. */
-  with_timestamps: z24.boolean().optional(),
+  with_timestamps: z23.boolean().optional(),
   /**
    * video-to-music only — short description of the desired score
    * ("upbeat synth, fast cuts, 80s") used to bias the model.
    */
-  description: z24.string().max(1e3).optional(),
+  description: z23.string().max(1e3).optional(),
   /** video-to-music only — up to 10 style tags. */
-  tags: z24.array(z24.string()).max(10).optional(),
-  output_format: z24.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
+  tags: z23.array(z23.string()).max(10).optional(),
+  output_format: z23.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
 }).strict();
 var musicNode = delegated({
   id: "music",
@@ -6309,9 +6269,9 @@ var musicNode = delegated({
   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.",
-  inputs: z24.object({ video: VideoRef.optional() }).loose(),
+  inputs: z23.object({ video: VideoRef.optional() }).loose(),
   params: MusicParams,
-  outputs: z24.object({ audio: AudioRef, timestamps: JsonRef.optional() }).strict(),
+  outputs: z23.object({ audio: AudioRef, timestamps: JsonRef.optional() }).strict(),
   outputKinds: { audio: "audio", timestamps: "json" },
   cost: ({ params }) => {
     const seconds = params.music_length_ms ? Math.ceil(params.music_length_ms / 1e3) : 30;
@@ -6342,25 +6302,25 @@ var musicNode = delegated({
 });
 
 // src/engine/nodes/remote/soundEffect.ts
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 var SOUND_EFFECT_MODELS = ["elevenlabs/eleven_text_to_sound_v2"];
-var SoundEffectParams = z25.object({
-  model: z25.enum(SOUND_EFFECT_MODELS),
+var SoundEffectParams = z24.object({
+  model: z24.enum(SOUND_EFFECT_MODELS),
   /** Prompt describing the SFX ("metal door slam", "soft UI tap", "ocean waves"). */
-  text: z25.string().min(1),
+  text: z24.string().min(1),
   /**
    * Target length in seconds. 0.5–30. Leave unset to let the model pick the
    * natural length for the described effect.
    */
-  duration_seconds: z25.number().min(0.5).max(30).optional(),
+  duration_seconds: z24.number().min(0.5).max(30).optional(),
   /**
    * 0–1. Higher = stick closer to the prompt at the cost of variety; lower
    * = let the model interpret more freely. Defaults to 0.3 on the provider.
    */
-  prompt_influence: z25.number().min(0).max(1).optional(),
+  prompt_influence: z24.number().min(0).max(1).optional(),
   /** Only valid on `eleven_text_to_sound_v2` — produce a seamless loop. */
-  loop: z25.boolean().optional(),
-  output_format: z25.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
+  loop: z24.boolean().optional(),
+  output_format: z24.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
 }).strict();
 var soundEffectNode = delegated({
   id: "sound_effect",
@@ -6368,9 +6328,9 @@ var soundEffectNode = delegated({
   category: "audio",
   summary: "Generate short sound effects from a text prompt via ElevenLabs Text-to-Sound. Use for whooshes, impacts, UI clicks, ambient beds, or signature stingers in ad creatives and product videos.",
   when_to_use: "Reach for this when you need a punch-in SFX layered against `video_generate` or `hyperframe_render` output \u2014 e.g. a logo whoosh on a hero shot, a click on a CTA cut, a swelling ambient bed under VO. Set `loop: true` for atmospheric beds that need to tile under longer footage; leave `duration_seconds` unset and the model picks a natural length.",
-  inputs: z25.object({}).loose(),
+  inputs: z24.object({}).loose(),
   params: SoundEffectParams,
-  outputs: z25.object({ audio: AudioRef }).strict(),
+  outputs: z24.object({ audio: AudioRef }).strict(),
   outputKinds: { audio: "audio" },
   cost: ({ params }) => {
     const seconds = params.duration_seconds ?? 5;
@@ -6379,7 +6339,7 @@ var soundEffectNode = delegated({
 });
 
 // src/engine/nodes/remote/textGenerate.ts
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 var TEXT_GENERATE_MODELS = ["~google/gemini-flash-latest", "~google/gemini-pro-latest"];
 var textGenerateNode = delegated({
   id: "text_generate",
@@ -6387,58 +6347,58 @@ var textGenerateNode = delegated({
   category: "language",
   summary: "Single-turn LLM text generation via OpenRouter. Returns a text response.",
   when_to_use: 'Use for any short text generation step in a canvas \u2014 ad copy, hooks, headlines, JSON outputs for downstream nodes. Pick `~google/gemini-flash-latest` for cheap/fast work and `~google/gemini-pro-latest` for harder reasoning. When the output must be JSON for a downstream `{{slot}}` (e.g. the ad-blueprint transform), set `response_format: "json_object"` so the model returns clean JSON with no markdown fences or prose. Set `web_search: true` to let the model search the live web first (OpenRouter `:online`) \u2014 useful when the transform must adapt copy to the target brand\'s real facts (current pricing, the trust signals it actually has) rather than guess.',
-  inputs: z26.object({}).loose(),
-  params: z26.object({
-    model: z26.enum(TEXT_GENERATE_MODELS),
-    prompt: z26.string().min(1),
-    system: z26.string().optional(),
-    response_format: z26.enum(["text", "json_object"]).optional(),
-    web_search: z26.boolean().optional(),
-    temperature: z26.number().min(0).max(2).optional(),
-    max_tokens: z26.number().int().positive().optional()
+  inputs: z25.object({}).loose(),
+  params: z25.object({
+    model: z25.enum(TEXT_GENERATE_MODELS),
+    prompt: z25.string().min(1),
+    system: z25.string().optional(),
+    response_format: z25.enum(["text", "json_object"]).optional(),
+    web_search: z25.boolean().optional(),
+    temperature: z25.number().min(0).max(2).optional(),
+    max_tokens: z25.number().int().positive().optional()
   }).strict(),
-  outputs: z26.object({ text: TextRef }).strict(),
+  outputs: z25.object({ text: TextRef }).strict(),
   outputKinds: { text: "text" },
   cost: () => ({ credits: 1, seconds_estimate: 3 })
 });
 
 // src/engine/nodes/remote/tts.ts
-import { z as z27 } from "zod";
+import { z as z26 } from "zod";
 var TTS_MODELS = ["elevenlabs/eleven_v3"];
-var TtsVoiceSettings = z27.object({
-  stability: z27.number().min(0).max(1).optional(),
-  similarity_boost: z27.number().min(0).max(1).optional(),
-  style: z27.number().min(0).max(1).optional(),
-  use_speaker_boost: z27.boolean().optional(),
-  speed: z27.number().min(0.25).max(4).optional()
+var TtsVoiceSettings = z26.object({
+  stability: z26.number().min(0).max(1).optional(),
+  similarity_boost: z26.number().min(0).max(1).optional(),
+  style: z26.number().min(0).max(1).optional(),
+  use_speaker_boost: z26.boolean().optional(),
+  speed: z26.number().min(0.25).max(4).optional()
 }).strict();
-var TtsPronunciationLocator = z27.object({
-  pronunciation_dictionary_id: z27.string().min(1),
-  version_id: z27.string().nullable().optional()
+var TtsPronunciationLocator = z26.object({
+  pronunciation_dictionary_id: z26.string().min(1),
+  version_id: z26.string().nullable().optional()
 }).strict();
-var TtsParams = z27.object({
-  model: z27.enum(TTS_MODELS),
-  text: z27.string().min(1).max(ELEVENLABS_MAX_TEXT_CHARS),
-  voice: z27.string().min(1),
+var TtsParams = z26.object({
+  model: z26.enum(TTS_MODELS),
+  text: z26.string().min(1).max(ELEVENLABS_MAX_TEXT_CHARS),
+  voice: z26.string().min(1),
   /** Provider output_format (mp3 family only — assets are stored as audio/mpeg). */
-  output_format: z27.enum(ELEVENLABS_OUTPUT_FORMATS).optional(),
-  seed: z27.number().int().min(0).max(4294967295).optional(),
+  output_format: z26.enum(ELEVENLABS_OUTPUT_FORMATS).optional(),
+  seed: z26.number().int().min(0).max(4294967295).optional(),
   // Top-level shortcuts; structured form is `voice_settings`.
-  stability: z27.number().min(0).max(1).optional(),
-  similarity_boost: z27.number().min(0).max(1).optional(),
+  stability: z26.number().min(0).max(1).optional(),
+  similarity_boost: z26.number().min(0).max(1).optional(),
   voice_settings: TtsVoiceSettings.optional(),
   /** ISO 639-1 language code. eleven_v3 supports language hints. */
-  language_code: z27.string().optional(),
-  pronunciation_dictionary_locators: z27.array(TtsPronunciationLocator).max(3).optional(),
-  apply_text_normalization: z27.enum(["auto", "on", "off"]).optional(),
+  language_code: z26.string().optional(),
+  pronunciation_dictionary_locators: z26.array(TtsPronunciationLocator).max(3).optional(),
+  apply_text_normalization: z26.enum(["auto", "on", "off"]).optional(),
   /** Currently Japanese-only. Adds latency. */
-  apply_language_text_normalization: z27.boolean().optional(),
+  apply_language_text_normalization: z26.boolean().optional(),
   /**
    * When true, hits `/v1/text-to-speech/{voice_id}/with-timestamps` and
    * adds a `timestamps` output (character-level alignment) for caption
    * rendering, lipsync, and beat-matched cuts.
    */
-  with_timestamps: z27.boolean().optional()
+  with_timestamps: z26.boolean().optional()
 }).strict();
 var ttsNode = delegated({
   id: "tts",
@@ -6446,9 +6406,9 @@ var ttsNode = delegated({
   category: "audio",
   summary: "Single-voice text-to-speech via ElevenLabs Eleven v3. Optional character-level timestamps for caption rendering and beat-matched cuts.",
   when_to_use: "Use for single-speaker VO \u2014 ad reads, hero-section narration, product walkthroughs. Reach for `dialogue` when you need multiple voices in one stitched track. Set `with_timestamps: true` when downstream needs character-level alignment (captions, lipsync).",
-  inputs: z27.object({}).loose(),
+  inputs: z26.object({}).loose(),
   params: TtsParams,
-  outputs: z27.object({ audio: AudioRef, timestamps: JsonRef.optional() }).strict(),
+  outputs: z26.object({ audio: AudioRef, timestamps: JsonRef.optional() }).strict(),
   outputKinds: { audio: "audio", timestamps: "json" },
   cost: ({ params }) => ({
     credits: Math.max(1, Math.ceil(params.text.length * 15e-4)),
@@ -6457,23 +6417,23 @@ var ttsNode = delegated({
 });
 
 // src/engine/nodes/remote/video.ts
-import { z as z28 } from "zod";
+import { z as z27 } from "zod";
 var VIDEO_GENERATE_MODELS = ["bytedance/seedance-2.0", "google/veo-3.1-fast"];
-var VideoGenerateParams = z28.object({
-  model: z28.enum(VIDEO_GENERATE_MODELS),
-  prompt: z28.string().min(1),
-  duration: z28.number().int().positive().optional(),
-  resolution: z28.string().optional(),
+var VideoGenerateParams = z27.object({
+  model: z27.enum(VIDEO_GENERATE_MODELS),
+  prompt: z27.string().min(1),
+  duration: z27.number().int().positive().optional(),
+  resolution: z27.string().optional(),
   // Union of ratios accepted by at least one curated model (registry gates
   // per-model). 3:2/2:3 are deliberately absent: no registered model takes them.
-  aspect_ratio: z28.enum(["16:9", "9:16", "1:1", "4:3", "3:4", "21:9", "9:21"]).optional(),
-  generate_audio: z28.boolean().optional(),
-  seed: z28.number().int().nonnegative().optional(),
+  aspect_ratio: z27.enum(["16:9", "9:16", "1:1", "4:3", "3:4", "21:9", "9:21"]).optional(),
+  generate_audio: z27.boolean().optional(),
+  seed: z27.number().int().nonnegative().optional(),
   // Veo-only passthroughs (routed via `provider.options.google-vertex.parameters`).
-  negative_prompt: z28.string().optional(),
-  person_generation: z28.string().optional(),
-  enhance_prompt: z28.boolean().optional(),
-  conditioning_scale: z28.number().optional()
+  negative_prompt: z27.string().optional(),
+  person_generation: z27.string().optional(),
+  enhance_prompt: z27.boolean().optional(),
+  conditioning_scale: z27.number().optional()
 }).strict();
 var videoGenerateNode = delegated({
   id: "video_generate",
@@ -6481,23 +6441,23 @@ var videoGenerateNode = delegated({
   category: "video",
   summary: "Generate video for ad creatives. Two curated models: `bytedance/seedance-2.0` (production quality, photorealistic humans via fal.ai) and `google/veo-3.1-fast` (cheap/fast for iteration and tests). Async with polling.",
   when_to_use: "Use `bytedance/seedance-2.0` for final ad output (photoreal subjects, image-to-video with first/last frames). Use `google/veo-3.1-fast` while iterating to keep cost low. Each model has different supported durations, resolutions, and aspect ratios \u2014 see the README per-model section.",
-  inputs: z28.object({
+  inputs: z27.object({
     first_frame: ImageRef.optional(),
     last_frame: ImageRef.optional(),
     reference: ImageRef.optional()
   }).loose(),
   params: VideoGenerateParams,
-  outputs: z28.object({ video: VideoRef }).strict(),
+  outputs: z27.object({ video: VideoRef }).strict(),
   outputKinds: { video: "video" },
   cost: () => ({ credits: 50, seconds_estimate: 120 })
 });
 
 // src/engine/nodes/remote/videoBackgroundRemove.ts
-import { z as z29 } from "zod";
-var VideoBackgroundRemoveParams = z29.object({
-  model: z29.literal("fal/veed-video-background-removal").optional().default("fal/veed-video-background-removal"),
-  edge_refinement: z29.boolean().optional().default(true),
-  output_codec: z29.enum(["vp9", "h264"]).optional().default("vp9")
+import { z as z28 } from "zod";
+var VideoBackgroundRemoveParams = z28.object({
+  model: z28.literal("fal/veed-video-background-removal").optional().default("fal/veed-video-background-removal"),
+  edge_refinement: z28.boolean().optional().default(true),
+  output_codec: z28.enum(["vp9", "h264"]).optional().default("vp9")
 }).strict();
 var videoBackgroundRemoveNode = delegated({
   id: "video_background_remove",
@@ -6505,18 +6465,18 @@ var videoBackgroundRemoveNode = delegated({
   category: "video",
   summary: "Remove the background from a video and return a transparent VP9-with-alpha WebM (or H264 RGB+alpha pair). Drops directly into a hyperframe composition as `<video src='...'>` for chroma-keyed picture-in-picture overlays. Powered by fal.ai `veed/video-background-removal/fast`.",
   when_to_use: "Use when you need a talking-head or subject to float over a custom background in a hyperframe composition. Pair with hyperframe_render(composition: screencast-with-talker) for screencast-with-narrator videos. Output is `video/webm` with alpha \u2014 feed straight into `<video src>` in a composition.",
-  inputs: z29.object({
+  inputs: z28.object({
     video: VideoRef
   }).strict(),
   params: VideoBackgroundRemoveParams,
-  outputs: z29.object({ video: VideoRef }).strict(),
+  outputs: z28.object({ video: VideoRef }).strict(),
   outputKinds: { video: "video" },
   // $0.012 per 30 frames (edge refinement on) — assume ~30fps; refine via fal dashboard.
   cost: () => ({ credits: 50, seconds_estimate: 60 })
 });
 
 // src/engine/nodes/remote/videoDeconstruct.ts
-import { z as z30 } from "zod";
+import { z as z29 } from "zod";
 var VIDEO_DECONSTRUCT_MODELS = ["~google/gemini-flash-latest", "~google/gemini-pro-latest"];
 var videoDeconstructNode = delegated({
   id: "video_deconstruct",
@@ -6524,34 +6484,34 @@ var videoDeconstructNode = delegated({
   category: "video",
   summary: 'Deconstruct a video into a replication-grade blueprint: scene boundaries, the real start/end frame of every scene (extracted from the video as images), and an exhaustive JSON analysis \u2014 per-scene action detail, camera motion, generation-ready frame/motion prompts, overlay text with full typographic style, floating elements, deeply detailed cast (perceived demographics, ethnicity/skin-tone, styling, market-recasting notes), brand-identified logos (named by brand and what they signal, not by appearance, with on-screen timestamps), dialogue with voice descriptions, music spec, SFX list, plus a word-level transcript. `mode:"index"` is the cheap structure-first pass: scene boundaries + global blueprint only (one LLM call, no frames).',
   when_to_use: 'Use to reverse-engineer a reference video (e.g. a competitor ad) so a new canvas can reproduce or remix it scene by scene. Agent loop: (1) optionally run `mode:"index"` to see the structure cheaply (scene count, boundaries, transcript) before planning; (2) run the full deconstruct; (3) read `analysis` and author the reproduction canvas. The blueprint maps 1:1 onto generation nodes: `analysis.scenes[i]` aligns positionally with `start_frames#i`/`end_frames#i`; per scene, `start_frame_prompt`/`end_frame_prompt` feed image_generate (overlay text is excluded from them by contract \u2014 recomposite it from `overlays`), `motion_prompt` + the two frames feed video_generate (first_frame/last_frame), `dialogue[].voice_description` casts tts/dialogue voices, `global.music.music_prompt` feeds music, `sfx[].sound_effect_prompt` feeds sound_effect, and `overlays`/`floating_elements` drive an ffmpeg/hyperframe overlay pass. Long videos (over ~8 min single-shot): run `mode:"index"` first, then several full nodes IN PARALLEL each with a `start_s`/`end_s` window (\u2264480s, snap edges to index scene boundaries), and merge by concatenating `analysis.scenes`; over-length errors include suggested windows. Inject fields into downstream prompts via `{{slot}}`. Pick `~google/gemini-pro-latest` for the densest extraction, `~google/gemini-flash-latest` for cheap/fast passes.',
-  inputs: z30.object({ video: VideoRef }).loose(),
-  params: z30.object({
-    model: z30.enum(VIDEO_DECONSTRUCT_MODELS),
-    mode: z30.enum(["full", "index"]).optional(),
-    language: z30.string().min(2).max(8).optional(),
-    max_scenes: z30.number().int().min(1).max(60).optional(),
-    focus: z30.string().optional(),
-    start_s: z30.number().min(0).optional(),
-    end_s: z30.number().positive().optional(),
+  inputs: z29.object({ video: VideoRef }).loose(),
+  params: z29.object({
+    model: z29.enum(VIDEO_DECONSTRUCT_MODELS),
+    mode: z29.enum(["full", "index"]).optional(),
+    language: z29.string().min(2).max(8).optional(),
+    max_scenes: z29.number().int().min(1).max(60).optional(),
+    focus: z29.string().optional(),
+    start_s: z29.number().min(0).optional(),
+    end_s: z29.number().positive().optional(),
     // Real visual shot-cut timestamps (absolute seconds), detected locally with
     // ffmpeg before the deconstruct. The backend SNAPS its LLM scene boundaries
     // onto these and SPLITS any scene that spans one, so a scene's frames never
     // straddle a hard cut. `scaffold-video` populates this; omit for LLM-only cuts.
-    shot_cuts: z30.array(z30.number().min(0)).max(200).optional(),
+    shot_cuts: z29.array(z29.number().min(0)).max(200).optional(),
     // The video model's per-clip ceiling (seconds). A shot longer than this is
     // split into seamless continuation sub-scenes (shared splice frame), so long
     // shots reproduce in full instead of being truncated. `scaffold-video` sets
     // the Seedance ceiling (15); omit to disable length splitting.
-    max_clip_s: z30.number().positive().max(60).optional(),
+    max_clip_s: z29.number().positive().max(60).optional(),
     // Transcript provider for the blueprint's dialogue/transcript. Default
     // Groq Whisper; "deepgram" routes to Nova-3 so words carry punctuation.
-    transcriber: z30.enum(["groq", "deepgram"]).optional()
+    transcriber: z29.enum(["groq", "deepgram"]).optional()
   }).strict(),
-  outputs: z30.object({
+  outputs: z29.object({
     analysis: JsonRef,
     // Absent in mode:"index" (structure only, no Mux frame extraction).
-    start_frames: z30.array(ImageRef).min(1).optional(),
-    end_frames: z30.array(ImageRef).min(1).optional(),
+    start_frames: z29.array(ImageRef).min(1).optional(),
+    end_frames: z29.array(ImageRef).min(1).optional(),
     transcript: JsonRef
   }).strict(),
   outputKinds: { analysis: "json", start_frames: "image", end_frames: "image", transcript: "json" },
@@ -6559,22 +6519,22 @@ var videoDeconstructNode = delegated({
 });
 
 // src/engine/nodes/remote/videoLipsync.ts
-import { z as z31 } from "zod";
-var FalLipsyncParams = z31.object({
-  model: z31.literal("fal/veed-lipsync")
+import { z as z30 } from "zod";
+var FalLipsyncParams = z30.object({
+  model: z30.literal("fal/veed-lipsync")
 }).strict();
-var VideoLipsyncParams = z31.discriminatedUnion("model", [FalLipsyncParams]);
+var VideoLipsyncParams = z30.discriminatedUnion("model", [FalLipsyncParams]);
 var videoLipsyncNode = delegated({
   id: "video_lipsync",
   version: "1.0.0",
   category: "video",
   summary: "Lip-sync a video to an audio track. Currently backed by VEED via fal.ai (`fal/veed-lipsync`). $0.40/min of output.",
-  inputs: z31.object({
+  inputs: z30.object({
     video: VideoRef,
     audio: AudioRef
   }).strict(),
   params: VideoLipsyncParams,
-  outputs: z31.object({ video: VideoRef }).strict(),
+  outputs: z30.object({ video: VideoRef }).strict(),
   outputKinds: { video: "video" },
   cost: () => ({ credits: 20, seconds_estimate: 120 })
 });
@@ -6583,7 +6543,7 @@ var videoLipsyncNode = delegated({
 import { mkdtemp as mkdtemp6, readFile as readFile10, rm as rm6 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
 import path13 from "path";
-import { z as z32 } from "zod";
+import { z as z31 } from "zod";
 
 // src/engine/nodes/local/lib/ffmpeg.ts
 import { execFile as execFile7 } from "child_process";
@@ -6662,21 +6622,21 @@ ${detail.slice(-4e3)}`);
 }
 
 // src/engine/nodes/remote/videoTranscribe.ts
-var VideoTranscribeParams = z32.object({
-  language: z32.string().min(2).max(8).optional(),
+var VideoTranscribeParams = z31.object({
+  language: z31.string().min(2).max(8).optional(),
   // 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: z32.enum(["groq", "deepgram"]).optional()
+  transcriber: z31.enum(["groq", "deepgram"]).optional()
 }).strict();
-var VideoTranscribeInputs = z32.object({
+var VideoTranscribeInputs = z31.object({
   video: VideoRef
 }).strict();
-var VideoTranscribeOutputs = z32.object({
-  transcript: z32.custom(),
+var VideoTranscribeOutputs = z31.object({
+  transcript: z31.custom(),
   // Only emitted by the Deepgram path: full punctuated words + paragraph /
   // sentence grouping with speaker indices. Absent for the default Groq path.
-  rich: z32.custom().optional()
+  rich: z31.custom().optional()
 }).strict();
 var AUDIO_EXTRACT_TIMEOUT_MS = 6e4;
 var videoTranscribeNode = defineNode({
@@ -6761,29 +6721,29 @@ async function tryExtractAudio(inputs, ctx) {
 }
 
 // src/engine/nodes/remote/voiceSelect.ts
-import { z as z33 } from "zod";
+import { z as z32 } from "zod";
 var voiceSelectNode = delegated({
   id: "voice_select",
   version: "1.0.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.',
-  inputs: z33.object({}).loose(),
-  params: z33.object({
-    description: z33.string().min(1),
-    gender: z33.string().optional(),
-    age: z33.string().optional(),
-    accent: z33.string().optional(),
-    language: z33.string().optional(),
-    limit: z33.number().int().min(1).max(20).optional()
+  inputs: z32.object({}).loose(),
+  params: z32.object({
+    description: z32.string().min(1),
+    gender: z32.string().optional(),
+    age: z32.string().optional(),
+    accent: z32.string().optional(),
+    language: z32.string().optional(),
+    limit: z32.number().int().min(1).max(20).optional()
   }).strict(),
-  outputs: z33.object({ voice_id: TextRef, candidates: JsonRef }).strict(),
+  outputs: z32.object({ voice_id: TextRef, candidates: JsonRef }).strict(),
   outputKinds: { voice_id: "text", candidates: "json" },
   cost: () => ({ credits: 0, seconds_estimate: 5 })
 });
 
 // src/engine/schema/catalog.ts
-import { z as z34 } from "zod";
+import { z as z33 } from "zod";
 function generateCatalog(registry, opts = {}) {
   const entries = registry.all().map((def) => {
     const cost = def.cost ? safeCost(def) : void 0;
@@ -6794,9 +6754,9 @@ function generateCatalog(registry, opts = {}) {
       summary: def.summary,
       when_to_use: def.when_to_use,
       location: def.location,
-      inputs: z34.toJSONSchema(def.inputs, { unrepresentable: "any" }),
-      params: z34.toJSONSchema(def.params, { unrepresentable: "any" }),
-      outputs: z34.toJSONSchema(def.outputs, { unrepresentable: "any" }),
+      inputs: z33.toJSONSchema(def.inputs, { unrepresentable: "any" }),
+      params: z33.toJSONSchema(def.params, { unrepresentable: "any" }),
+      outputs: z33.toJSONSchema(def.outputs, { unrepresentable: "any" }),
       cost_estimate_credits: cost?.credits,
       runtime_estimate_seconds: cost?.seconds_estimate
     };
@@ -6873,8 +6833,7 @@ var LOCAL_NODES = [
   imagemagickNode,
   videoTranscribeNode,
   fontSpecimenNode,
-  audioTimelineNode,
-  collectNode
+  audioTimelineNode
 ];
 var REMOTE_NODES = [
   textGenerateNode,
@@ -6955,4 +6914,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-Q3K5TXC6.js.map
+//# sourceMappingURL=chunk-43KBQLP5.js.map