@koda-sl/baker-cli 0.74.0 → 0.80.0

package/dist/{chunk-JIDZ37KG.js → chunk-NBNUNCY7.js}

@@ -621,7 +621,7 @@ ${originalIndentation}`;
 });
 
 // src/engine/index.ts
-import path13 from "path";
+import path15 from "path";
 
 // src/engine/client/http.ts
 var BackendHttpError = class extends Error {
@@ -667,14 +667,14 @@ var HttpClient = class {
     this.fetchFn = opts.fetchFn ?? fetch;
     this.sleepFn = opts.sleepFn ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   }
-  async postJson(path14, body, signal) {
-    return await this.requestJson("POST", path14, body, signal);
+  async postJson(path16, body, signal) {
+    return await this.requestJson("POST", path16, body, signal);
   }
-  async getJson(path14, signal) {
-    return await this.requestJson("GET", path14, void 0, signal);
+  async getJson(path16, signal) {
+    return await this.requestJson("GET", path16, void 0, signal);
   }
-  async requestJson(method, path14, body, signal) {
-    const url = `${this.baseUrl}${path14.startsWith("/") ? path14 : `/${path14}`}`;
+  async requestJson(method, path16, body, signal) {
+    const url = `${this.baseUrl}${path16.startsWith("/") ? path16 : `/${path16}`}`;
     for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
       const outcome = await this.attempt(method, url, body, attempt, signal);
       if (outcome.kind === "value") return outcome.value;
@@ -786,8 +786,8 @@ var BackendClient = class {
     );
   }
   getArtifact(kind, name, version, signal) {
-    const path14 = version ? `/api/canvas/artifacts/${encodeURIComponent(kind)}/${encodeURIComponent(name)}/${encodeURIComponent(version)}` : `/api/canvas/artifacts/${encodeURIComponent(kind)}/${encodeURIComponent(name)}`;
-    return this.http.getJson(path14, signal);
+    const path16 = version ? `/api/canvas/artifacts/${encodeURIComponent(kind)}/${encodeURIComponent(name)}/${encodeURIComponent(version)}` : `/api/canvas/artifacts/${encodeURIComponent(kind)}/${encodeURIComponent(name)}`;
+    return this.http.getJson(path16, signal);
   }
 };
 
@@ -1242,6 +1242,21 @@ var MODEL_REGISTRY = {
       }
     }
   },
+  audio_voice_convert: {
+    "elevenlabs/eleven_multilingual_sts_v2": {
+      // Speech-to-speech / Voice Changer: re-voice an existing audio clip in the
+      // TARGET voice, preserving timing/prosody. Used to normalize a talking-head
+      // clip's native (generator-chosen) voice into ONE consistent brand voice.
+      label: "ElevenLabs Voice Changer (multilingual STS v2)",
+      inputs: [{ kind: "audio", mimes: FAL_AUDIO_MIMES }],
+      required: ["voice"],
+      params: {
+        voice: { kind: "string" },
+        output_format: { kind: "string", enum: ELEVENLABS_OUTPUT_FORMATS },
+        remove_background_noise: { kind: "boolean" }
+      }
+    }
+  },
   music: {
     "elevenlabs/music-v1": {
       label: "ElevenLabs Music v1 (Compose)",
@@ -1512,11 +1527,30 @@ var VideoMeta = z.object({
       speaker: z.string().optional()
     })
   ).default([]),
-  // Scenes with a single on-camera speaker — each MUST be lip-synced. Either a
-  // bare scene index (validator falls back to the scaffold naming convention) or
-  // `{ scene, lipsync_node }`, which names the exact node to look for so a
-  // hand-authored canvas with differently-named clip nodes isn't a false miss.
-  talking_scenes: z.array(z.union([z.number(), z.object({ scene: z.number(), lipsync_node: z.string() })])).default([])
+  // Scenes with a single on-camera speaker, voiced NATIVELY by the video model
+  // (Seedance generate_audio) then re-voiced to one brand voice. Each entry names
+  // the `audio_voice_convert` node the validator confirms is present — the
+  // native-audio replacement for the retired post-hoc lipsync check. A bare scene
+  // index (legacy) or `{ scene, lipsync_node }` (legacy veed canvases) still parse.
+  talking_scenes: z.array(
+    z.union([
+      z.number(),
+      z.object({
+        scene: z.number(),
+        voice_convert_node: z.string(),
+        // Advisory: the scene's visual length vs the estimated spoken length, so
+        // a reviewer can see a native line that may run past its cut. Not gated.
+        scene_s: z.number().optional(),
+        est_speech_s: z.number().optional()
+      }),
+      z.object({ scene: z.number(), lipsync_node: z.string() })
+    ])
+  ).default([]),
+  // Advisory, NOT gated by the validator: the reviewable "which graphic fires
+  // on which spoken beat" map emitted by scaffold-video (per-scene window,
+  // spoken line, storyboard frames, scheduled graphics). Free-form rows so the
+  // schema stays decoupled from the scaffold's exact shape.
+  motion_board: z.array(z.unknown()).optional()
 }).strict().optional();
 var CanvasMetadata = z.object({
   name: z.string().optional(),
@@ -2193,7 +2227,8 @@ function resolveRefKind(ctx, refStr) {
   if (!targetDef) return null;
   const targetParams = targetDef.params.safeParse(target.params ?? {});
   const resolvedKinds = resolveOutputKinds(targetDef.outputKinds, targetParams.success ? targetParams.data : {});
-  const kind = resolvedKinds[expr.output];
+  const declaredKind = target.params?.outputs?.[expr.output]?.kind;
+  const kind = resolvedKinds[expr.output] ?? declaredKind;
   return kind && MODEL_INPUT_KINDS.has(kind) ? kind : null;
 }
 function checkOneRef(ctx, n, i, refStr, jsonPath, field) {
@@ -2286,6 +2321,24 @@ function estimateCredits(ctx) {
   }
   return total;
 }
+function talkingSceneSatisfied(ctx, entry, scene) {
+  const nodes = ctx.canvas.nodes;
+  if (typeof entry === "object" && "voice_convert_node" in entry) {
+    const clipNativeAudio = nodes.some(
+      (n) => n.id === `s${scene}_clip` && n.type === "video_generate" && n.params?.generate_audio === true
+    );
+    const converted = nodes.some((n) => n.id === entry.voice_convert_node && n.type === "audio_voice_convert");
+    return clipNativeAudio && converted;
+  }
+  if (typeof entry === "object") {
+    return nodes.some((n) => n.id === entry.lipsync_node && n.type === "video_lipsync");
+  }
+  return nodes.some((n) => {
+    if (n.type !== "video_lipsync") return false;
+    const video = n.inputs?.video;
+    return video === `$ref:s${scene}_trim.video` || video === `$ref:s${scene}_clip.video`;
+  });
+}
 function checkVideoInvariants(ctx) {
   const meta = ctx.canvas.metadata?.video;
   if (!meta) return;
@@ -2312,16 +2365,11 @@ function checkVideoInvariants(ctx) {
   }
   for (const entry of meta.talking_scenes) {
     const scene = typeof entry === "number" ? entry : entry.scene;
-    const synced = typeof entry === "number" ? ctx.canvas.nodes.some((n) => {
-      if (n.type !== "video_lipsync") return false;
-      const video = n.inputs?.video;
-      return video === `$ref:s${scene}_trim.video` || video === `$ref:s${scene}_clip.video`;
-    }) : ctx.canvas.nodes.some((n) => n.id === entry.lipsync_node && n.type === "video_lipsync");
-    if (!synced) {
+    if (!talkingSceneSatisfied(ctx, entry, scene)) {
       ctx.issues.push({
         path: "metadata.video.talking_scenes",
         code: STAGE_CODES.LIPSYNC_MISSING,
-        message: `scene ${scene} has a single on-camera speaker but no video_lipsync on s${scene}_clip \u2014 its mouth will drift out of sync with the voiceover`
+        message: `scene ${scene} is a single-on-camera-speaker talking head but its clip lacks native audio (generate_audio) or the audio_voice_convert node is missing \u2014 the voice won't be brand-consistent / lips may drift`
       });
     }
   }
@@ -2355,9 +2403,9 @@ function checkOutputRef(ctx) {
 function pushZodIssues(issues, err, pathPrefix, code, nodeId, nodeType) {
   for (const issue of err.issues) {
     const tail2 = pathToString(issue.path);
-    const path14 = pathPrefix ? tail2 ? `${pathPrefix}.${tail2}` : pathPrefix : tail2;
+    const path16 = pathPrefix ? tail2 ? `${pathPrefix}.${tail2}` : pathPrefix : tail2;
     issues.push({
-      path: path14,
+      path: path16,
       code,
       message: issue.message,
       received: issue.code === "invalid_type" ? issue.received : void 0,
@@ -2366,8 +2414,8 @@ function pushZodIssues(issues, err, pathPrefix, code, nodeId, nodeType) {
     });
   }
 }
-function pathToString(path14) {
-  return path14.map((p) => typeof p === "number" ? `[${p}]` : `.${String(p)}`).join("").replace(/^\./, "");
+function pathToString(path16) {
+  return path16.map((p) => typeof p === "number" ? `[${p}]` : `.${String(p)}`).join("").replace(/^\./, "");
 }
 function buildDepGraph(canvas) {
   const graph = /* @__PURE__ */ new Map();
@@ -3995,12 +4043,12 @@ var fontSpecimenNode = defineNode({
 });
 
 // src/engine/nodes/local/hyperframe.ts
-import { execFile as execFile3 } from "child_process";
-import { copyFile as copyFile4, mkdtemp as mkdtemp4, readFile as readFile7, rm as rm4, stat as stat5, writeFile as writeFile4 } from "fs/promises";
+import { execFile as execFile4 } from "child_process";
+import { copyFile as copyFile4, mkdtemp as mkdtemp4, readFile as readFile8, rm as rm4, stat as stat5, writeFile as writeFile5 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
 import { cpus, tmpdir as tmpdir4 } from "os";
-import path9 from "path";
-import { promisify as promisify3 } from "util";
+import path11 from "path";
+import { promisify as promisify4 } from "util";
 import { z as z10 } from "zod";
 
 // src/engine/engine/composition-hash.ts
@@ -4194,6 +4242,148 @@ function defaultFilenameForInput(key, kind) {
   return `${key}.png`;
 }
 
+// src/engine/nodes/local/lib/hyperframe-check.ts
+import { execFile as execFile3 } from "child_process";
+import { readFile as readFile7 } from "fs/promises";
+import path9 from "path";
+import { promisify as promisify3 } from "util";
+var execFileAsync = promisify3(execFile3);
+var NEVER_BLOCK = [/contrast/i, /\bwcag\b/i, /missing_local_asset/i, /font[_-]?family/i, /font[_-]?face/i];
+var UNAVAILABLE = /unknown command|command not found|not found|Did you mean|Unknown argument|ENOENT/i;
+function isAdvisory(code, message) {
+  const hay = `${code} ${message}`;
+  return NEVER_BLOCK.some((re) => re.test(hay));
+}
+function parseCheckJson(raw) {
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+  }
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    try {
+      return JSON.parse(trimmed.slice(start, end + 1));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function classifyLint(json) {
+  const out = [];
+  const findings = json?.findings;
+  if (!Array.isArray(findings)) return out;
+  for (const f of findings) {
+    const rec = f;
+    const code = String(rec?.code ?? "");
+    const message = String(rec?.message ?? "");
+    const severity = String(rec?.severity ?? "info");
+    const blocking = severity === "error" && !isAdvisory(code, message);
+    out.push({ source: "lint", code, message, severity: blocking ? "blocking" : "warning" });
+  }
+  return out;
+}
+function classifyInspect(json) {
+  const out = [];
+  const obj = json;
+  const issues = obj?.issues;
+  if (!Array.isArray(issues)) return out;
+  for (const iss of issues) {
+    const rec = iss;
+    const code = String(rec?.code ?? rec?.type ?? "overflow");
+    const message = String(rec?.message ?? rec?.detail ?? JSON.stringify(iss));
+    const severity = rec?.severity ? String(rec.severity) : obj?.ok === false ? "error" : "warning";
+    out.push({ source: "inspect", code, message, severity: severity === "error" ? "blocking" : "warning" });
+  }
+  return out;
+}
+function classifyCheckOutput(lintRaw, inspectRaw) {
+  const findings = [...classifyLint(parseCheckJson(lintRaw)), ...classifyInspect(parseCheckJson(inspectRaw))];
+  return {
+    blocking: findings.filter((f) => f.severity === "blocking"),
+    warnings: findings.filter((f) => f.severity === "warning")
+  };
+}
+function buildLintArgs(dir) {
+  return ["hyperframes", "lint", dir, "--json"];
+}
+function buildInspectArgs(dir, samples) {
+  return ["hyperframes", "inspect", dir, "--json", "--samples", String(samples)];
+}
+function buildSnapshotArgs(dir, frames) {
+  return ["hyperframes", "snapshot", dir, "--frames", String(frames), "--describe", "false"];
+}
+function usesNestedCompositions(indexHtml) {
+  const withoutComments = indexHtml.replace(/<!--[\s\S]*?-->/g, "");
+  return /data-composition-src\s*=/.test(withoutComments);
+}
+async function runOne(args, timeoutMs) {
+  try {
+    const { stdout } = await execFileAsync("npx", args, { timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 });
+    return stdout;
+  } catch (e) {
+    const err = e;
+    if (err.stdout?.includes("{")) return err.stdout;
+    const blob = `${err.stderr ?? ""} ${err.message ?? ""}`;
+    if (UNAVAILABLE.test(blob)) return null;
+    return null;
+  }
+}
+async function runSnapshotSmoke(args, timeoutMs) {
+  try {
+    await execFileAsync("npx", args, { timeout: timeoutMs, maxBuffer: 64 * 1024 * 1024 });
+    return { ok: true, unavailable: false, message: "" };
+  } catch (e) {
+    const err = e;
+    const blob = `${err.stderr ?? ""} ${err.message ?? ""}`;
+    if (UNAVAILABLE.test(blob)) return { ok: false, unavailable: true, message: blob };
+    return { ok: false, unavailable: false, message: (err.stderr || err.message || "snapshot failed").slice(0, 800) };
+  }
+}
+async function runHyperframesCheck(opts) {
+  const { dir, nodeId, ctx, timeoutMs, samples = 5 } = opts;
+  const [lintRaw, inspectRaw] = await Promise.all([
+    runOne(buildLintArgs(dir), timeoutMs),
+    runOne(buildInspectArgs(dir, samples), timeoutMs)
+  ]);
+  if (lintRaw === null && inspectRaw === null) {
+    ctx.log(`${nodeId}: hyperframes lint/inspect unavailable \u2014 skipping pre-render check`);
+    return;
+  }
+  const { blocking, warnings } = classifyCheckOutput(lintRaw ?? "", inspectRaw ?? "");
+  for (const w of warnings) {
+    ctx.log(`${nodeId}: hyperframe check warning [${w.source}/${w.code}] ${w.message}`);
+  }
+  if (blocking.length > 0) {
+    const detail = blocking.map((b) => `\u2022 [${b.source}/${b.code}] ${b.message}`).join("\n");
+    throw new Error(`${nodeId}: pre-render check failed (${blocking.length} blocking)
+${detail}`);
+  }
+  let indexHtml = "";
+  try {
+    indexHtml = await readFile7(path9.join(dir, "index.html"), "utf-8");
+  } catch {
+    indexHtml = "";
+  }
+  if (indexHtml && usesNestedCompositions(indexHtml)) {
+    const snap = await runSnapshotSmoke(buildSnapshotArgs(dir, Math.min(samples, 3)), Math.max(timeoutMs, 12e4));
+    if (snap.unavailable) {
+      ctx.log(`${nodeId}: hyperframes snapshot unavailable \u2014 skipping nested-composition smoke test`);
+    } else if (!snap.ok) {
+      throw new Error(
+        `${nodeId}: nested-composition smoke test failed \u2014 an embedded block did not render. Check the host\u2194block id match, that the block's <style>/<script> live inside its <template>, and that it styles #root (not a class).
+${snap.message}`
+      );
+    } else {
+      ctx.log(`${nodeId}: nested-composition smoke test passed`);
+    }
+  }
+  ctx.log(`${nodeId}: pre-render check passed (${warnings.length} warning${warnings.length === 1 ? "" : "s"})`);
+}
+
 // src/engine/nodes/local/lib/hyperframe-errors.ts
 var KNOWN_ERROR_PATTERNS = [
   {
@@ -4237,6 +4427,29 @@ ${stderr.slice(0, 1500)}`;
   return null;
 }
 
+// src/engine/nodes/local/lib/hyperframe-meta.ts
+import { writeFile as writeFile4 } from "fs/promises";
+import path10 from "path";
+async function ensureHyperframesMetaJson(tmp, nodeId, meta, duration) {
+  const metaPath = path10.join(tmp, "meta.json");
+  await writeFile4(
+    metaPath,
+    JSON.stringify(
+      {
+        id: nodeId,
+        name: meta.id,
+        duration,
+        width: meta.width,
+        height: meta.height,
+        fps: meta.fps
+      },
+      null,
+      2
+    ),
+    "utf-8"
+  );
+}
+
 // src/engine/nodes/local/lib/templating.ts
 var PATTERN = /\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}/g;
 function substituteVariables(source, values) {
@@ -4272,25 +4485,34 @@ function literalize(value) {
 }
 
 // src/engine/nodes/local/hyperframe.ts
-var execFileAsync = promisify3(execFile3);
+var execFileAsync2 = promisify4(execFile4);
 var require_2 = createRequire2(import.meta.url);
 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: 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", "timeout_ms"]);
+var NODE_OWNED_PARAM_KEYS = /* @__PURE__ */ new Set(["composition", "format", "timeout_ms"]);
+var MIME_BY_FORMAT = {
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime"
+};
 var ENGINE_INJECTED_TOKENS = /* @__PURE__ */ new Set(["duration"]);
 var hyperframeRenderNode = defineNode({
   id: "hyperframe_render",
-  version: "6.0.0",
+  version: "6.1.0",
   category: "video",
   location: "local",
   summary: "Render an mp4 by composing an HTML/CSS/GSAP composition over upstream assets. Point `params.composition` at a directory containing `index.html` + `meta.json`. All variables are passed as primitives in `params` and substituted into the composition before render.",
-  when_to_use: "Use to add captions, lower-thirds, branded overlays, title cards, or any HTML-driven graphic over a video. Point `params.composition` at a directory containing `index.html` + `meta.json`. Inputs are keyed by the composition's `meta.json.inputs` map \u2014 wire `inputs.<key> = $ref:<node>.<output>`. Output resolution/fps come from the composition's `meta.json`; quality, format, and worker count are fixed by the engine for ad-creative delivery.",
+  when_to_use: "Use to add captions, lower-thirds, branded overlays, title cards, or any HTML-driven graphic over a video. Point `params.composition` at a directory containing `index.html` + `meta.json`. Inputs are keyed by the composition's `meta.json.inputs` map \u2014 wire `inputs.<key> = $ref:<node>.<output>`. Output resolution/fps come from the composition's `meta.json`; quality and worker count are fixed by the engine. Set `params.format` to `webm` or `mov` for a transparent (alpha) overlay to composite in another editor; defaults to `mp4`. Runs a pre-render `hyperframes lint`/`inspect` gate (overflow/structural errors block; contrast warns).",
   inputs: HyperframeInputs,
   params: HyperframeParams,
   outputs: HyperframeOutputs,
@@ -4309,7 +4531,7 @@ var hyperframeRenderNode = defineNode({
     const compositionDir = await resolveCompositionDir(params.composition);
     const meta = await loadCompositionMeta(compositionDir);
     const compositionParams = validateAndParseDynamicParams(meta, params);
-    const tmp = await mkdtemp4(path9.join(tmpdir4(), "hf-render-"));
+    const tmp = await mkdtemp4(path11.join(tmpdir4(), "hf-render-"));
     try {
       await copyComposition(compositionDir, tmp);
       await vendorGsap(tmp, ctx);
@@ -4317,15 +4539,16 @@ var hyperframeRenderNode = defineNode({
       const duration = stagedDuration ?? meta.default_duration;
       const substitutionValues = await buildSubstitutionValues(compositionParams, meta, duration);
       await substituteCompositionFiles(tmp, substitutionValues);
-      await ensureMetaJson(tmp, ctx.nodeId, meta, duration);
-      const outputPath = path9.join(tmp, "output.mp4");
+      await ensureHyperframesMetaJson(tmp, ctx.nodeId, meta, duration);
+      await runHyperframesCheck({ dir: tmp, nodeId: "hyperframe_render", ctx, timeoutMs: params.timeout_ms });
+      const outputPath = path11.join(tmp, `output.${params.format}`);
       await runRender({ tmp, outputPath, params, meta, ctx });
-      const bytes = await readFile7(outputPath);
+      const bytes = await readFile8(outputPath);
       ctx.log(`rendered ${bytes.length} bytes`);
       const ref = await ctx.assets.ingestBytes({
         bytes: Buffer.from(bytes),
         kind: "video",
-        mime: "video/mp4",
+        mime: MIME_BY_FORMAT[params.format],
         metadata: {
           width: meta.width,
           height: meta.height,
@@ -4342,10 +4565,10 @@ var hyperframeRenderNode = defineNode({
   }
 });
 async function resolveCompositionDir(composition) {
-  const compositionPath = path9.isAbsolute(composition) ? composition : path9.resolve(process.cwd(), composition);
+  const compositionPath = path11.isAbsolute(composition) ? composition : path11.resolve(process.cwd(), composition);
   const s = await stat5(compositionPath);
   if (s.isDirectory()) return compositionPath;
-  return path9.dirname(compositionPath);
+  return path11.dirname(compositionPath);
 }
 async function validateCompositionParams(rawParams) {
   const issues = [];
@@ -4412,7 +4635,7 @@ async function copyComposition(srcDir, destDir) {
   await cp(srcDir, destDir, {
     recursive: true,
     filter: (src) => {
-      const name = path9.basename(src);
+      const name = path11.basename(src);
       if (name === ".cache" || name === "node_modules" || name === ".git") return false;
       return true;
     }
@@ -4421,7 +4644,7 @@ async function copyComposition(srcDir, destDir) {
 async function vendorGsap(tmp, ctx) {
   try {
     const gsapMin = require_2.resolve("gsap/dist/gsap.min.js");
-    await copyFile4(gsapMin, path9.join(tmp, "gsap.min.js"));
+    await copyFile4(gsapMin, path11.join(tmp, "gsap.min.js"));
   } catch (e) {
     ctx.log(`warning: could not vendor gsap.min.js (${e.message}); compositions must self-supply`);
   }
@@ -4436,7 +4659,7 @@ async function stageInputs2(tmp, inputs, meta, ctx) {
     await stageAsset(ref, tmp, filename);
     ctx.log(`staged ${spec.kind} \u2192 ${filename}`);
     if (spec.kind === "video" && primaryDuration === null) {
-      primaryDuration = await probeDurationSeconds(path9.join(tmp, filename));
+      primaryDuration = await probeDurationSeconds(path11.join(tmp, filename));
     }
   }
   return primaryDuration;
@@ -4482,34 +4705,15 @@ function coerceImageParam(value) {
   throw new Error("hyperframe_render: image param must be a URL string or AssetRef");
 }
 async function substituteCompositionFiles(tmp, values) {
-  const entryPath = path9.join(tmp, "index.html");
-  const original = await readFile7(entryPath, "utf-8");
+  const entryPath = path11.join(tmp, "index.html");
+  const original = await readFile8(entryPath, "utf-8");
   const { output, missing } = substituteVariables(original, values);
   if (missing.length > 0) {
     throw new Error(
       `hyperframe_render: composition references undefined variables: ${missing.map((m) => `{{${m}}}`).join(", ")}. Add to params or to meta.json's params with a default.`
     );
   }
-  await writeFile4(entryPath, output, "utf-8");
-}
-async function ensureMetaJson(tmp, nodeId, meta, duration) {
-  const metaPath = path9.join(tmp, "meta.json");
-  await writeFile4(
-    metaPath,
-    JSON.stringify(
-      {
-        id: nodeId,
-        name: meta.id,
-        duration,
-        width: meta.width,
-        height: meta.height,
-        fps: meta.fps
-      },
-      null,
-      2
-    ),
-    "utf-8"
-  );
+  await writeFile5(entryPath, output, "utf-8");
 }
 var MAX_WORKERS = 4;
 function workerCount() {
@@ -4517,10 +4721,10 @@ function workerCount() {
 }
 async function runRender(opts) {
   const { tmp, outputPath, params, meta, ctx } = opts;
-  const args = buildRenderArgs(tmp, outputPath, meta);
-  ctx.log(`rendering ${meta.width}x${meta.height}@${meta.fps}fps from ${path9.basename(tmp)}`);
+  const args = buildRenderArgs(tmp, outputPath, meta, params.format);
+  ctx.log(`rendering ${meta.width}x${meta.height}@${meta.fps}fps ${params.format} from ${path11.basename(tmp)}`);
   try {
-    await execFileAsync("npx", args, { timeout: params.timeout_ms, maxBuffer: 64 * 1024 * 1024 });
+    await execFileAsync2("npx", args, { timeout: params.timeout_ms, maxBuffer: 64 * 1024 * 1024 });
   } catch (e) {
     const stderr = e.stderr ?? "";
     const stdout = e.stdout ?? "";
@@ -4530,7 +4734,7 @@ async function runRender(opts) {
 ${friendly ?? detail.slice(0, 4e3)}`);
   }
 }
-function buildRenderArgs(tmp, outputPath, meta) {
+function buildRenderArgs(tmp, outputPath, meta, format) {
   return [
     "hyperframes",
     "render",
@@ -4542,13 +4746,13 @@ function buildRenderArgs(tmp, outputPath, meta) {
     "--quality",
     "high",
     "--format",
-    "mp4",
+    format,
     "--workers",
     String(workerCount())
   ];
 }
 async function probeDurationSeconds(filePath) {
-  const { stdout } = await execFileAsync(
+  const { stdout } = await execFileAsync2(
     "ffprobe",
     ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", filePath],
     { encoding: "utf-8" }
@@ -4561,14 +4765,14 @@ async function probeDurationSeconds(filePath) {
 }
 
 // src/engine/nodes/local/hyperframe-snapshot.ts
-import { execFile as execFile4 } from "child_process";
-import { copyFile as copyFile5, mkdtemp as mkdtemp5, readFile as readFile8, rm as rm5, writeFile as writeFile5 } from "fs/promises";
+import { execFile as execFile5 } from "child_process";
+import { copyFile as copyFile5, mkdtemp as mkdtemp5, readFile as readFile9, rm as rm5, writeFile as writeFile6 } from "fs/promises";
 import { createRequire as createRequire3 } from "module";
 import { tmpdir as tmpdir5 } from "os";
-import path10 from "path";
-import { promisify as promisify4 } from "util";
+import path12 from "path";
+import { promisify as promisify5 } from "util";
 import { z as z11 } from "zod";
-var _execFileAsync = promisify4(execFile4);
+var _execFileAsync = promisify5(execFile5);
 var require_3 = createRequire3(import.meta.url);
 var WaitForSpec = z11.discriminatedUnion("kind", [
   z11.object({ kind: z11.literal("auto") }),
@@ -4589,7 +4793,7 @@ var NODE_OWNED_PARAM_KEYS2 = /* @__PURE__ */ new Set(["composition", "wait_for",
 var DEVICE_SCALE_FACTOR2 = 2;
 var hyperframeSnapshotNode = defineNode({
   id: "hyperframe_snapshot",
-  version: "4.0.0",
+  version: "4.1.0",
   category: "image",
   location: "local",
   summary: "Render an HTML/CSS composition to a static PNG via headless Chromium at 2x device-scale (retina). Same composition model as `hyperframe_render` \u2014 point `params.composition` at a directory containing `index.html` + `meta.json`.",
@@ -4612,14 +4816,22 @@ var hyperframeSnapshotNode = defineNode({
     const compositionDir = await resolveCompositionDir(params.composition);
     const meta = await loadCompositionMeta(compositionDir);
     const compositionParams = validateAndParseDynamicParams2(meta, params);
-    const tmp = await mkdtemp5(path10.join(tmpdir5(), "hf-snap-"));
+    const tmp = await mkdtemp5(path12.join(tmpdir5(), "hf-snap-"));
     try {
       await copyComposition2(compositionDir, tmp);
       await vendorGsap2(tmp, ctx);
       await stageInputs3(tmp, inputs, meta, ctx);
       const substitutionValues = await buildSubstitutionValues2(compositionParams, meta);
       await substituteCompositionFiles2(tmp, substitutionValues);
-      const entryPath = path10.join(tmp, "index.html");
+      await ensureHyperframesMetaJson(tmp, ctx.nodeId, meta, meta.default_duration);
+      await runHyperframesCheck({
+        dir: tmp,
+        nodeId: "hyperframe_snapshot",
+        ctx,
+        timeoutMs: params.timeout_ms,
+        samples: 1
+      });
+      const entryPath = path12.join(tmp, "index.html");
       const entryUrl = `file://${entryPath}`;
       ctx.log(`snapshotting ${meta.width}x${meta.height}@${DEVICE_SCALE_FACTOR2}x wait=${params.wait_for.kind}`);
       const pwSpecifier = ["play", "wright"].join("");
@@ -4680,7 +4892,7 @@ async function copyComposition2(srcDir, destDir) {
   await cp(srcDir, destDir, {
     recursive: true,
     filter: (src) => {
-      const name = path10.basename(src);
+      const name = path12.basename(src);
       if (name === ".cache" || name === "node_modules" || name === ".git") return false;
       return true;
     }
@@ -4689,7 +4901,7 @@ async function copyComposition2(srcDir, destDir) {
 async function vendorGsap2(tmp, ctx) {
   try {
     const gsapMin = require_3.resolve("gsap/dist/gsap.min.js");
-    await copyFile5(gsapMin, path10.join(tmp, "gsap.min.js"));
+    await copyFile5(gsapMin, path12.join(tmp, "gsap.min.js"));
   } catch (e) {
     ctx.log(`warning: could not vendor gsap.min.js (${e.message}); compositions must self-supply`);
   }
@@ -4723,15 +4935,15 @@ function coerceImageParam2(value) {
   throw new Error("hyperframe_snapshot: image param must be a URL string or AssetRef");
 }
 async function substituteCompositionFiles2(tmp, values) {
-  const entryPath = path10.join(tmp, "index.html");
-  const original = await readFile8(entryPath, "utf-8");
+  const entryPath = path12.join(tmp, "index.html");
+  const original = await readFile9(entryPath, "utf-8");
   const { output, missing } = substituteVariables(original, values);
   if (missing.length > 0) {
     throw new Error(
       `hyperframe_snapshot: composition references undefined variables: ${missing.map((m) => `{{${m}}}`).join(", ")}.`
     );
   }
-  await writeFile5(entryPath, output, "utf-8");
+  await writeFile6(entryPath, output, "utf-8");
 }
 async function waitForReady(page, waitFor, timeoutMs) {
   switch (waitFor.kind) {
@@ -4765,10 +4977,10 @@ async function waitForReady(page, waitFor, timeoutMs) {
 }
 
 // src/engine/nodes/local/imagemagick.ts
-import { execFile as execFile5 } from "child_process";
-import { promisify as promisify5 } from "util";
+import { execFile as execFile6 } from "child_process";
+import { promisify as promisify6 } from "util";
 import { z as z12 } from "zod";
-var execFileAsync2 = promisify5(execFile5);
+var execFileAsync3 = promisify6(execFile6);
 var OutputDecl2 = z12.object({
   kind: z12.enum(["image", "video", "audio"]),
   ext: z12.string().min(1).max(8)
@@ -4784,7 +4996,7 @@ async function resolveBin() {
   if (resolvedBin) return resolvedBin;
   for (const candidate of ["magick", "convert"]) {
     try {
-      await execFileAsync2(candidate, ["-version"], { encoding: "utf-8" });
+      await execFileAsync3(candidate, ["-version"], { encoding: "utf-8" });
       resolvedBin = candidate;
       return candidate;
     } catch {
@@ -4834,34 +5046,60 @@ var textNode = defineNode({
   execute: ({ params }) => Promise.resolve({ text: params.value })
 });
 
-// src/engine/nodes/remote/dialogue.ts
+// src/engine/nodes/remote/audioVoiceConvert.ts
 import { z as z14 } from "zod";
-var DialogueInput = z14.object({
-  text: z14.string().min(1),
-  voice_id: z14.string().min(1)
+var AudioVoiceConvertParams = z14.object({
+  model: z14.literal("elevenlabs/eleven_multilingual_sts_v2"),
+  /** Target voice id. Splice an upstream `voice_select` via `"{{voice_ref}}"`. */
+  voice: z14.string().min(1),
+  output_format: z14.string().optional(),
+  /** Strip the source clip's background noise before re-voicing. */
+  remove_background_noise: z14.boolean().optional()
+}).strict();
+var audioVoiceConvertNode = delegated({
+  id: "audio_voice_convert",
+  version: "1.0.0",
+  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: z14.object({
+    audio: AudioRef,
+    voice_ref: TextRef.optional()
+  }).strict(),
+  params: AudioVoiceConvertParams,
+  outputs: z14.object({ audio: AudioRef }).strict(),
+  outputKinds: { audio: "audio" },
+  cost: () => ({ credits: 1, seconds_estimate: 20 })
+});
+
+// src/engine/nodes/remote/dialogue.ts
+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 = z14.object({
-  model: z14.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: z14.array(DialogueInput).min(1).max(50),
-  language_code: z14.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: z14.record(z14.string(), z14.unknown()).optional(),
-  seed: z14.number().int().min(0).max(4294967295).optional(),
-  apply_text_normalization: z14.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: z14.boolean().optional(),
-  output_format: z14.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"]
@@ -4872,9 +5110,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: z14.object({}).loose(),
+  inputs: z15.object({}).loose(),
   params: DialogueParams,
-  outputs: z14.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);
@@ -4883,7 +5121,7 @@ var dialogueNode = delegated({
 });
 
 // src/engine/nodes/remote/image.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 var IMAGE_GENERATE_MODELS2 = [
   "openai/gpt-5.4-image-2",
   "google/gemini-3.5-flash",
@@ -4891,16 +5129,16 @@ var IMAGE_GENERATE_MODELS2 = [
   "google/gemini-3-pro-image-preview",
   "recraft/recraft-v4.1-pro-vector"
 ];
-var ImageGenerateParams = z15.object({
-  model: z15.enum(IMAGE_GENERATE_MODELS2),
-  prompt: z15.string().min(1),
-  aspect_ratio: z15.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: z15.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: z15.number().min(0).max(1).optional(),
-  rgb_colors: z15.array(z15.array(z15.number().int().min(0).max(255))).optional(),
-  background_rgb_color: z15.array(z15.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",
@@ -4910,22 +5148,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: z15.object({ reference: z15.union([ImageRef, z15.array(ImageRef).min(1)]).optional() }).loose(),
+  inputs: z16.object({ reference: z16.union([ImageRef, z16.array(ImageRef).min(1)]).optional() }).loose(),
   params: ImageGenerateParams,
-  outputs: z15.object({ images: z15.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 z16 } 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 = z16.object({
-  model: z16.enum(ASPECT_ADAPT_MODELS),
-  formats: z16.array(z16.enum(ASPECT_ADAPT_FORMATS)).min(1).max(6).refine((formats) => new Set(formats).size === formats.length, { message: "formats must be unique" }),
-  guidance: z16.string().min(1).optional(),
-  image_size: z16.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",
@@ -4933,9 +5171,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: z16.object({ source: ImageRef }).loose(),
+  inputs: z17.object({ source: ImageRef }).loose(),
   params: ImageAspectAdaptParams,
-  outputs: z16.object({ images: z16.array(ImageRef).min(1) }).strict(),
+  outputs: z17.object({ images: z17.array(ImageRef).min(1) }).strict(),
   outputKinds: { images: "image" },
   cost: ({ params }) => {
     const p = params;
@@ -4948,12 +5186,12 @@ var imageAspectAdaptNode = delegated({
 });
 
 // src/engine/nodes/remote/imageBackgroundRemove.ts
-import { z as z17 } from "zod";
-var ImageBackgroundRemoveParams = z17.object({
-  model: z17.literal("fal/birefnet-v2").optional().default("fal/birefnet-v2"),
-  model_variant: z17.enum(["General Use (Light)", "General Use (Heavy)", "Matting", "Portrait", "DIS", "HRSOD", "COD"]).optional().default("General Use (Light)"),
-  operating_resolution: z17.enum(["1024x1024", "2048x2048", "2304x2304"]).optional(),
-  mask_only: z17.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",
@@ -4961,11 +5199,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: z17.object({
+  inputs: z18.object({
     image: ImageRef
   }).strict(),
   params: ImageBackgroundRemoveParams,
-  outputs: z17.object({
+  outputs: z18.object({
     image: ImageRef,
     mask: ImageRef.optional()
   }).strict(),
@@ -4974,7 +5212,7 @@ var imageBackgroundRemoveNode = delegated({
 });
 
 // src/engine/nodes/remote/imageDescribe.ts
-import { z as z18 } 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",
@@ -4982,31 +5220,31 @@ 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: z18.object({ image: ImageRef }).loose(),
-  params: z18.object({
-    model: z18.enum(IMAGE_DESCRIBE_MODELS),
-    focus: z18.string().optional(),
-    context: z18.string().optional(),
-    temperature: z18.number().min(0).max(2).optional(),
-    max_tokens: z18.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: z18.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 z19 } 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 = z19.object({
-  model: z19.enum(REFERENCE_SHEET_MODELS),
-  subject_description: z19.string().min(1),
-  subject_type: z19.enum(["character", "person", "product"]),
-  views: z19.array(z19.string().min(1)).min(2).max(6).optional(),
-  style: z19.string().optional(),
-  prompt_override: z19.string().min(1).optional(),
-  aspect_ratio: z19.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: z19.enum(["0.5K", "1K", "2K", "4K"]).optional()
+var ImageReferenceSheetParams = z20.object({
+  model: z20.enum(REFERENCE_SHEET_MODELS),
+  subject_description: z20.string().min(1),
+  subject_type: z20.enum(["character", "person", "product"]),
+  views: z20.array(z20.string().min(1)).min(2).max(6).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",
@@ -5014,9 +5252,9 @@ var imageReferenceSheetNode = delegated({
   category: "image",
   summary: "Fuse 1\u20136 images of a single subject (person, character, or product) into ONE multi-view reference sheet \u2014 a labeled turnaround grid (FRONT / SIDE / BACK\u2026) in consistent style and lighting. 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: z19.object({ references: z19.array(ImageRef).min(1).max(6) }).loose(),
+  inputs: z20.object({ references: z20.array(ImageRef).min(1).max(6) }).loose(),
   params: ImageReferenceSheetParams,
-  outputs: z19.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,
@@ -5025,10 +5263,10 @@ var imageReferenceSheetNode = delegated({
 });
 
 // src/engine/nodes/remote/imageSearch.ts
-import { z as z20 } from "zod";
-var ImageSearchParams = z20.object({
-  prompt: z20.string().min(1),
-  count: z20.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",
@@ -5036,15 +5274,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: z20.object({}).loose(),
+  inputs: z21.object({}).loose(),
   params: ImageSearchParams,
-  outputs: z20.object({ images: z20.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 z21 } 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",
@@ -5052,15 +5290,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: z21.object({ images: z21.array(ImageRef).min(2) }).loose(),
-  params: z21.object({
-    model: z21.enum(IMAGE_SELECT_MODELS),
-    prompt: z21.string().min(1),
-    count: z21.number().int().min(1).default(1),
-    temperature: z21.number().min(0).max(2).optional(),
-    max_tokens: z21.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: z21.object({ images: z21.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
@@ -5085,34 +5323,34 @@ var imageSelectNode = delegated({
 });
 
 // src/engine/nodes/remote/music.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var MUSIC_MODELS = ["elevenlabs/music-v1", "elevenlabs/video-background-music-v1"];
-var MusicParams = z22.object({
-  model: z22.enum(MUSIC_MODELS),
+var MusicParams = z23.object({
+  model: z23.enum(MUSIC_MODELS),
   /** Free-form prompt. Used by `elevenlabs/music-v1` (compose-detailed). */
-  prompt: z22.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: z22.record(z22.string(), z22.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: z22.number().int().min(3e3).max(ELEVENLABS_MAX_MUSIC_LENGTH_MS).optional(),
-  seed: z22.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: z22.boolean().optional(),
+  force_instrumental: z23.boolean().optional(),
   /** composition_plan only — honor exact section durations. */
-  respect_sections_durations: z22.boolean().optional(),
+  respect_sections_durations: z23.boolean().optional(),
   /** Emit word-level timestamps alongside the audio. */
-  with_timestamps: z22.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: z22.string().max(1e3).optional(),
+  description: z23.string().max(1e3).optional(),
   /** video-to-music only — up to 10 style tags. */
-  tags: z22.array(z22.string()).max(10).optional(),
-  output_format: z22.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",
@@ -5120,9 +5358,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: z22.object({ video: VideoRef.optional() }).loose(),
+  inputs: z23.object({ video: VideoRef.optional() }).loose(),
   params: MusicParams,
-  outputs: z22.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;
@@ -5153,25 +5391,25 @@ var musicNode = delegated({
 });
 
 // src/engine/nodes/remote/soundEffect.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var SOUND_EFFECT_MODELS = ["elevenlabs/eleven_text_to_sound_v2"];
-var SoundEffectParams = z23.object({
-  model: z23.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: z23.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: z23.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: z23.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: z23.boolean().optional(),
-  output_format: z23.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
+  loop: z24.boolean().optional(),
+  output_format: z24.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
 }).strict();
 var soundEffectNode = delegated({
   id: "sound_effect",
@@ -5179,9 +5417,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: z23.object({}).loose(),
+  inputs: z24.object({}).loose(),
   params: SoundEffectParams,
-  outputs: z23.object({ audio: AudioRef }).strict(),
+  outputs: z24.object({ audio: AudioRef }).strict(),
   outputKinds: { audio: "audio" },
   cost: ({ params }) => {
     const seconds = params.duration_seconds ?? 5;
@@ -5190,7 +5428,7 @@ var soundEffectNode = delegated({
 });
 
 // src/engine/nodes/remote/textGenerate.ts
-import { z as z24 } 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",
@@ -5198,58 +5436,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: z24.object({}).loose(),
-  params: z24.object({
-    model: z24.enum(TEXT_GENERATE_MODELS),
-    prompt: z24.string().min(1),
-    system: z24.string().optional(),
-    response_format: z24.enum(["text", "json_object"]).optional(),
-    web_search: z24.boolean().optional(),
-    temperature: z24.number().min(0).max(2).optional(),
-    max_tokens: z24.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: z24.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 z25 } from "zod";
+import { z as z26 } from "zod";
 var TTS_MODELS = ["elevenlabs/eleven_v3"];
-var TtsVoiceSettings = z25.object({
-  stability: z25.number().min(0).max(1).optional(),
-  similarity_boost: z25.number().min(0).max(1).optional(),
-  style: z25.number().min(0).max(1).optional(),
-  use_speaker_boost: z25.boolean().optional(),
-  speed: z25.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 = z25.object({
-  pronunciation_dictionary_id: z25.string().min(1),
-  version_id: z25.string().nullable().optional()
+var TtsPronunciationLocator = z26.object({
+  pronunciation_dictionary_id: z26.string().min(1),
+  version_id: z26.string().nullable().optional()
 }).strict();
-var TtsParams = z25.object({
-  model: z25.enum(TTS_MODELS),
-  text: z25.string().min(1).max(ELEVENLABS_MAX_TEXT_CHARS),
-  voice: z25.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: z25.enum(ELEVENLABS_OUTPUT_FORMATS).optional(),
-  seed: z25.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: z25.number().min(0).max(1).optional(),
-  similarity_boost: z25.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: z25.string().optional(),
-  pronunciation_dictionary_locators: z25.array(TtsPronunciationLocator).max(3).optional(),
-  apply_text_normalization: z25.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: z25.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: z25.boolean().optional()
+  with_timestamps: z26.boolean().optional()
 }).strict();
 var ttsNode = delegated({
   id: "tts",
@@ -5257,9 +5495,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: z25.object({}).loose(),
+  inputs: z26.object({}).loose(),
   params: TtsParams,
-  outputs: z25.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)),
@@ -5268,23 +5506,23 @@ var ttsNode = delegated({
 });
 
 // src/engine/nodes/remote/video.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var VIDEO_GENERATE_MODELS = ["bytedance/seedance-2.0", "google/veo-3.1-fast"];
-var VideoGenerateParams = z26.object({
-  model: z26.enum(VIDEO_GENERATE_MODELS),
-  prompt: z26.string().min(1),
-  duration: z26.number().int().positive().optional(),
-  resolution: z26.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: z26.enum(["16:9", "9:16", "1:1", "4:3", "3:4", "21:9", "9:21"]).optional(),
-  generate_audio: z26.boolean().optional(),
-  seed: z26.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: z26.string().optional(),
-  person_generation: z26.string().optional(),
-  enhance_prompt: z26.boolean().optional(),
-  conditioning_scale: z26.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",
@@ -5292,23 +5530,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: z26.object({
+  inputs: z27.object({
     first_frame: ImageRef.optional(),
     last_frame: ImageRef.optional(),
     reference: ImageRef.optional()
   }).loose(),
   params: VideoGenerateParams,
-  outputs: z26.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 z27 } from "zod";
-var VideoBackgroundRemoveParams = z27.object({
-  model: z27.literal("fal/veed-video-background-removal").optional().default("fal/veed-video-background-removal"),
-  edge_refinement: z27.boolean().optional().default(true),
-  output_codec: z27.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",
@@ -5316,18 +5554,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: z27.object({
+  inputs: z28.object({
     video: VideoRef
   }).strict(),
   params: VideoBackgroundRemoveParams,
-  outputs: z27.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 z28 } 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",
@@ -5335,24 +5573,24 @@ 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: z28.object({ video: VideoRef }).loose(),
-  params: z28.object({
-    model: z28.enum(VIDEO_DECONSTRUCT_MODELS),
-    mode: z28.enum(["full", "index"]).optional(),
-    language: z28.string().min(2).max(8).optional(),
-    max_scenes: z28.number().int().min(1).max(60).optional(),
-    focus: z28.string().optional(),
-    start_s: z28.number().min(0).optional(),
-    end_s: z28.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(),
     // Transcript provider for the blueprint's dialogue/transcript. Default
     // Groq Whisper; "deepgram" routes to Nova-3 so words carry punctuation.
-    transcriber: z28.enum(["groq", "deepgram"]).optional()
+    transcriber: z29.enum(["groq", "deepgram"]).optional()
   }).strict(),
-  outputs: z28.object({
+  outputs: z29.object({
     analysis: JsonRef,
     // Absent in mode:"index" (structure only, no Mux frame extraction).
-    start_frames: z28.array(ImageRef).min(1).optional(),
-    end_frames: z28.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" },
@@ -5360,38 +5598,38 @@ var videoDeconstructNode = delegated({
 });
 
 // src/engine/nodes/remote/videoLipsync.ts
-import { z as z29 } from "zod";
-var FalLipsyncParams = z29.object({
-  model: z29.literal("fal/veed-lipsync")
+import { z as z30 } from "zod";
+var FalLipsyncParams = z30.object({
+  model: z30.literal("fal/veed-lipsync")
 }).strict();
-var VideoLipsyncParams = z29.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: z29.object({
+  inputs: z30.object({
     video: VideoRef,
     audio: AudioRef
   }).strict(),
   params: VideoLipsyncParams,
-  outputs: z29.object({ video: VideoRef }).strict(),
+  outputs: z30.object({ video: VideoRef }).strict(),
   outputKinds: { video: "video" },
   cost: () => ({ credits: 20, seconds_estimate: 120 })
 });
 
 // src/engine/nodes/remote/videoTranscribe.ts
-import { mkdtemp as mkdtemp6, readFile as readFile9, rm as rm6 } from "fs/promises";
+import { mkdtemp as mkdtemp6, readFile as readFile10, rm as rm6 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import path11 from "path";
-import { z as z30 } from "zod";
+import path13 from "path";
+import { z as z31 } from "zod";
 
 // src/engine/nodes/local/lib/ffmpeg.ts
-import { execFile as execFile6 } from "child_process";
-import { promisify as promisify6 } from "util";
-var execFileAsync3 = promisify6(execFile6);
+import { execFile as execFile7 } from "child_process";
+import { promisify as promisify7 } from "util";
+var execFileAsync4 = promisify7(execFile7);
 async function probeVideo(filePath) {
-  const { stdout } = await execFileAsync3(
+  const { stdout } = await execFileAsync4(
     "ffprobe",
     ["-v", "error", "-show_streams", "-show_format", "-of", "json", filePath],
     { encoding: "utf-8", maxBuffer: 8 * 1024 * 1024 }
@@ -5449,7 +5687,7 @@ function parseFrameRate(rate) {
 }
 async function runFfmpeg(args, opts) {
   try {
-    await execFileAsync3("ffmpeg", args, {
+    await execFileAsync4("ffmpeg", args, {
       timeout: opts.timeout_ms,
       maxBuffer: 64 * 1024 * 1024
     });
@@ -5463,21 +5701,21 @@ ${detail.slice(-4e3)}`);
 }
 
 // src/engine/nodes/remote/videoTranscribe.ts
-var VideoTranscribeParams = z30.object({
-  language: z30.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: z30.enum(["groq", "deepgram"]).optional()
+  transcriber: z31.enum(["groq", "deepgram"]).optional()
 }).strict();
-var VideoTranscribeInputs = z30.object({
+var VideoTranscribeInputs = z31.object({
   video: VideoRef
 }).strict();
-var VideoTranscribeOutputs = z30.object({
-  transcript: z30.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: z30.custom().optional()
+  rich: z31.custom().optional()
 }).strict();
 var AUDIO_EXTRACT_TIMEOUT_MS = 6e4;
 var videoTranscribeNode = defineNode({
@@ -5515,14 +5753,14 @@ async function tryExtractAudio(inputs, ctx) {
       ctx.log("video_transcribe: no audio track detected, sending full video");
       return null;
     }
-    tmpDir = await mkdtemp6(path11.join(tmpdir6(), "vtx-"));
-    const audioPath = path11.join(tmpDir, "audio.mp3");
+    tmpDir = await mkdtemp6(path13.join(tmpdir6(), "vtx-"));
+    const audioPath = path13.join(tmpDir, "audio.mp3");
     ctx.log("video_transcribe: extracting audio (mono 16kHz mp3)");
     await runFfmpeg(
       ["-i", video.path, "-vn", "-ac", "1", "-ar", "16000", "-b:a", "64k", "-f", "mp3", "-y", audioPath],
       { timeout_ms: AUDIO_EXTRACT_TIMEOUT_MS }
     );
-    const bytes = await readFile9(audioPath);
+    const bytes = await readFile10(audioPath);
     if (bytes.byteLength === 0) {
       ctx.log("video_transcribe: extracted audio is empty, sending full video");
       return null;
@@ -5562,29 +5800,29 @@ async function tryExtractAudio(inputs, ctx) {
 }
 
 // src/engine/nodes/remote/voiceSelect.ts
-import { z as z31 } 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: z31.object({}).loose(),
-  params: z31.object({
-    description: z31.string().min(1),
-    gender: z31.string().optional(),
-    age: z31.string().optional(),
-    accent: z31.string().optional(),
-    language: z31.string().optional(),
-    limit: z31.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: z31.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 z32 } 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;
@@ -5595,9 +5833,9 @@ function generateCatalog(registry, opts = {}) {
       summary: def.summary,
       when_to_use: def.when_to_use,
       location: def.location,
-      inputs: z32.toJSONSchema(def.inputs, { unrepresentable: "any" }),
-      params: z32.toJSONSchema(def.params, { unrepresentable: "any" }),
-      outputs: z32.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
     };
@@ -5629,19 +5867,19 @@ function safeCost(def) {
 
 // src/engine/storage/cache-store.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir3, readFile as readFile10, rename as rename2, writeFile as writeFile6 } from "fs/promises";
-import path12 from "path";
+import { mkdir as mkdir3, readFile as readFile11, rename as rename2, writeFile as writeFile7 } from "fs/promises";
+import path14 from "path";
 var LocalCacheStore = class {
   rootDir;
   constructor(rootDir) {
     this.rootDir = rootDir;
   }
   filePath(cacheKey) {
-    return path12.join(this.rootDir, `${cacheKey}.json`);
+    return path14.join(this.rootDir, `${cacheKey}.json`);
   }
   async get(cacheKey) {
     try {
-      const buf = await readFile10(this.filePath(cacheKey), "utf8");
+      const buf = await readFile11(this.filePath(cacheKey), "utf8");
       return JSON.parse(buf);
     } catch (e) {
       if (e.code === "ENOENT") return null;
@@ -5650,9 +5888,9 @@ var LocalCacheStore = class {
   }
   async put(entry) {
     const dest = this.filePath(entry.cacheKey);
-    await mkdir3(path12.dirname(dest), { recursive: true });
+    await mkdir3(path14.dirname(dest), { recursive: true });
     const tmp = `${dest}.tmp-${process.pid}-${randomUUID2()}`;
-    await writeFile6(tmp, JSON.stringify(entry, null, 0));
+    await writeFile7(tmp, JSON.stringify(entry, null, 0));
     await rename2(tmp, dest);
   }
 };
@@ -5686,6 +5924,7 @@ var REMOTE_NODES = [
   imageSelectNode,
   videoGenerateNode,
   ttsNode,
+  audioVoiceConvertNode,
   musicNode,
   dialogueNode,
   soundEffectNode,
@@ -5703,14 +5942,14 @@ function defaultRegistry() {
 }
 function createEngineFromEnv(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const cacheDir = opts.cacheDir ?? path13.join(cwd, "canvas", ".cache");
-  const outputsDir = opts.outputsDir ?? path13.join(cwd, "canvas");
+  const cacheDir = opts.cacheDir ?? path15.join(cwd, "canvas", ".cache");
+  const outputsDir = opts.outputsDir ?? path15.join(cwd, "canvas");
   const creds = requireCredentialsFromEnv();
   return new Engine({
     registry: defaultRegistry(),
     client: new BackendClient({ baseUrl: creds.url, apiKey: creds.apiKey }),
-    assets: new LocalAssetStore(path13.join(cacheDir, "assets")),
-    cache: new LocalCacheStore(path13.join(cacheDir, "index")),
+    assets: new LocalAssetStore(path15.join(cacheDir, "assets")),
+    cache: new LocalCacheStore(path15.join(cacheDir, "index")),
     outputsDir,
     log: opts.log
   });
@@ -5731,4 +5970,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-JIDZ37KG.js.map
+//# sourceMappingURL=chunk-NBNUNCY7.js.map