@koda-sl/baker-cli 0.198.0-dev.6d2f498f5 → 0.199.0

package/dist/{chunk-CVJCXDWD.js → chunk-5MPIOGRO.js}

@@ -1,22 +1,23 @@
 import {
   debugLogHttp,
   readBodyForLog
-} from "./chunk-RN2XKQIJ.js";
+} from "./chunk-UZYVSPCA.js";
 import {
   __commonJS,
   __toESM,
   captureProxyCredentials,
   childEnvWith,
   isChallengeBody,
+  isPrivateAddress,
   isProxyFailure,
   plannedRoutes,
   refuseNonPublicUrl,
   shouldEscalate
-} from "./chunk-MVCCSWDE.js";
+} from "./chunk-6NZG2TCM.js";
 
-// ../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/810146e81bae4e3a061fe487864f2fde80c4b03b886877dc0f1fffbc6480b67e/node_modules/safe-stable-stringify/index.js
+// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js
 var require_safe_stable_stringify = __commonJS({
-  "../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/810146e81bae4e3a061fe487864f2fde80c4b03b886877dc0f1fffbc6480b67e/node_modules/safe-stable-stringify/index.js"(exports, module) {
+  "../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js"(exports, module) {
     "use strict";
     var { hasOwnProperty } = Object.prototype;
     var stringify = configure2();
@@ -1090,7 +1091,7 @@ function resolveAdaptFormats(params) {
   return params.formats ?? [];
 }
 
-// ../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/810146e81bae4e3a061fe487864f2fde80c4b03b886877dc0f1fffbc6480b67e/node_modules/safe-stable-stringify/esm/wrapper.js
+// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/esm/wrapper.js
 var import__ = __toESM(require_safe_stable_stringify(), 1);
 var configure = import__.default.configure;
 var wrapper_default = import__.default;
@@ -4917,7 +4918,8 @@ import { promisify } from "util";
 import { z as z5 } from "zod";
 
 // ../proxy/src/fetch.ts
-import { ProxyAgent, Response, fetch as undiciFetch } from "undici";
+import { lookup as dnsLookup } from "dns";
+import { Agent, ProxyAgent, Response, fetch as undiciFetch } from "undici";
 
 // ../proxy/src/fetchDecision.ts
 function classifyFetchOutcome(signal) {
@@ -4981,10 +4983,65 @@ function tierOf(route) {
   return route.kind === "proxy" ? route.tier : "direct";
 }
 function agentFor(route) {
-  if (route.kind !== "proxy") return null;
+  if (route.kind !== "proxy") return directAgent();
   const token = Buffer.from(`${route.username}:${route.password}`).toString("base64");
   return new ProxyAgent({ uri: route.server, token: `Basic ${token}` });
 }
+function directAgent() {
+  return new Agent({
+    connect: {
+      lookup: (hostname, options, callback) => {
+        dnsLookup(hostname, options, (error, address, family) => {
+          if (error) {
+            callback(error, address, family);
+            return;
+          }
+          const found = Array.isArray(address) ? address.map((entry) => entry.address) : [address];
+          const blocked = found.find((entry) => isPrivateAddress(entry));
+          if (blocked !== void 0) {
+            callback(new Error(`${PRIVATE_ADDRESS_CODE}: ${hostname} resolves to ${blocked}`), "", 4);
+            return;
+          }
+          callback(null, address, family);
+        });
+      }
+    }
+  });
+}
+var PRIVATE_ADDRESS_CODE = "EPRIVATEADDR";
+var MAX_REDIRECTS = 20;
+var REDIRECT_STATUS = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+function refuseRedirect(entry, to) {
+  if (refuseNonPublicUrl(to) === null) return false;
+  const destination = originOf(to);
+  return destination === null || destination !== originOf(entry);
+}
+async function followRedirects(url, init) {
+  let current = url;
+  let request = { ...init, redirect: "manual" };
+  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+    const response = await undiciFetch(current, request);
+    const location = response.headers.get("location");
+    if (!REDIRECT_STATUS.has(response.status) || location === null) return response;
+    await response.body?.cancel();
+    const next = new URL(location, current).toString();
+    if (refuseRedirect(url, next)) {
+      throw new Error(`${PRIVATE_ADDRESS_CODE}: redirected to ${next}`);
+    }
+    const method = (request.method ?? "GET").toUpperCase();
+    const downgrade = response.status === 303 || (response.status === 301 || response.status === 302) && method === "POST";
+    request = downgrade ? { ...request, method: "GET", body: void 0 } : request;
+    current = next;
+  }
+  throw new Error(`too many redirects following ${url}`);
+}
 var NULL_BODY_STATUS = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
 function rebuild(response, body) {
   if (response.status < 200 || response.status > 599 || NULL_BODY_STATUS.has(response.status)) {
@@ -5020,7 +5077,7 @@ async function attemptRoute(url, init, route, options) {
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const signal = init.signal ? AbortSignal.any([init.signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs);
   try {
-    const raw = await undiciFetch(url, { ...init, dispatcher: agent ?? void 0, signal });
+    const raw = await followRedirects(url, { ...init, dispatcher: agent ?? void 0, signal });
     const read = await readOnce(raw, options.sniffChallenge ?? true, options.maxBytes);
     const outcome = classifyFetchOutcome({ status: raw.status, challenge: read.challenge });
     return {
@@ -5083,6 +5140,14 @@ function endedProxyUnavailable(result) {
   if (rescued(result) || endedBlocked(result)) return false;
   return result.attempts.some((attempt) => attempt.outcome === "proxy_unavailable");
 }
+function endedPrivateAddress(result) {
+  if (rescued(result)) return false;
+  for (let error = result.error, depth = 0; error instanceof Error && depth < 5; depth++) {
+    if (error.message.includes(PRIVATE_ADDRESS_CODE)) return true;
+    error = error.cause;
+  }
+  return false;
+}
 
 // src/lib/externalFetch.ts
 var BROWSER_HEADERS = {
@@ -5090,6 +5155,8 @@ var BROWSER_HEADERS = {
   Accept: "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
   "Accept-Language": "en-US,en;q=0.9"
 };
+var NOT_PUBLIC_MESSAGE = "That address is not reachable from the public web, so there is nothing to read.";
+var MAX_REMOTE_IMAGE_BYTES = 25e6;
 var ExternalFetchError = class extends Error {
   /** True when the fault was ours — a route we could not open, not a dead host. */
   ourFault;
@@ -5101,7 +5168,7 @@ var ExternalFetchError = class extends Error {
 };
 async function fetchExternal(url, options = {}) {
   if (refuseNonPublicUrl(url) !== null) {
-    throw new ExternalFetchError("That address is not reachable from the public web, so there is nothing to read.", false);
+    throw new ExternalFetchError(NOT_PUBLIC_MESSAGE, false);
   }
   const result = await fetchWithEscalation(
     url,
@@ -5118,6 +5185,9 @@ async function fetchExternal(url, options = {}) {
 `);
   }
   if (result.response === null) {
+    if (endedPrivateAddress(result)) {
+      throw new ExternalFetchError(NOT_PUBLIC_MESSAGE, false);
+    }
     const ourFault = endedProxyUnavailable(result);
     throw new ExternalFetchError(
       ourFault ? "Could not open a route to that address." : "That address did not answer.",
@@ -5126,7 +5196,22 @@ async function fetchExternal(url, options = {}) {
   }
   return { response: result.response, blocked: endedBlocked(result) };
 }
-async function fetchExternalBytes(url, options = {}) {
+function refuseOversize(bytes, maxBytes) {
+  if (bytes === null || bytes <= maxBytes) return null;
+  return `That file is ${humanBytes(bytes)} \u2014 the limit is ${humanBytes(maxBytes)}.`;
+}
+function humanBytes(n) {
+  if (n >= 1024 ** 3) return `${(n / 1024 ** 3).toFixed(1)} GB`;
+  if (n >= 1024 ** 2) return `${(n / 1024 ** 2).toFixed(1)} MB`;
+  return `${Math.max(1, Math.round(n / 1024))} KB`;
+}
+function declaredBytes(response) {
+  const raw = response.headers.get("content-length");
+  if (raw === null) return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : null;
+}
+async function fetchExternalBytes(url, options) {
   const { response, blocked } = await fetchExternal(url, options);
   if (!response.ok) {
     throw new ExternalFetchError(`${response.status} ${response.statusText}`, false);
@@ -5134,10 +5219,16 @@ async function fetchExternalBytes(url, options = {}) {
   if (blocked) {
     throw new ExternalFetchError("That host served a security check instead of the file.", false);
   }
-  return {
-    buffer: Buffer.from(await response.arrayBuffer()),
-    contentType: response.headers.get("content-type")
-  };
+  const declared = refuseOversize(declaredBytes(response), options.maxBytes);
+  if (declared !== null) {
+    throw new ExternalFetchError(declared, false);
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  const actual = refuseOversize(buffer.byteLength, options.maxBytes);
+  if (actual !== null) {
+    throw new ExternalFetchError(actual, false);
+  }
+  return { buffer, contentType: response.headers.get("content-type") };
 }
 
 // src/engine/schema/refs.ts
@@ -5477,9 +5568,6 @@ async function ingestImageUrl(url, ctx) {
   } catch (e) {
     throw localExecError(ctx, `fetch ${url} \u2192 ${e.message}`);
   }
-  if (bytes.byteLength > MAX_ASSET_BYTES) {
-    throw localExecError(ctx, `file_too_large: ${url} is ${bytes.byteLength} bytes (limit ${MAX_ASSET_BYTES})`);
-  }
   let normalized;
   try {
     normalized = await toModelSafeImage(bytes);
@@ -7829,20 +7917,50 @@ var imageDescribeNode = delegated({
   cost: () => ({ credits: 2, seconds_estimate: 10 })
 });
 
-// src/engine/nodes/remote/imageReferenceSheet.ts
+// src/engine/nodes/remote/imageLayerize.ts
 import { z as z21 } from "zod";
+var ImageLayerizeParams = z21.object({
+  /**
+   * What to separate. Read as extraction instructions, not as a generation
+   * prompt — "keep the bottle and its shadow as one layer", not "make it blue".
+   */
+  instructions: z21.string().max(600).optional()
+}).strict();
+var imageLayerizeNode = delegated({
+  id: "image_layerize",
+  version: "1.0.0",
+  category: "image",
+  summary: "Split an image into editable layers: a transparent PNG per element, plus any copy baked into the picture recovered as real text with its typography. Powered by Seedream 5.0 Pro Layerize, with Ideogram lifting the text off first.",
+  when_to_use: "Use when you need ONE element of a picture on its own (a product with no background, a logo lockup), or when a shot is right but its copy is wrong and regenerating would change the picture too. The manifest gives you each layer's box and, for text, its exact wording, font, size and colour \u2014 enough to re-set a headline in the original's type. For a plain subject cutout with no text involved, `image_background_remove` is cheaper and one call.",
+  inputs: z21.object({
+    image: ImageRef
+  }).strict(),
+  params: ImageLayerizeParams,
+  outputs: z21.object({
+    layers: z21.array(ImageRef),
+    base: ImageRef,
+    manifest: JsonRef
+  }).strict(),
+  outputKinds: { layers: "image", base: "image", manifest: "json" },
+  // Billed per returned layer (2-17) plus an optional text pass; the backend
+  // charges the real count on completion. This is the pre-run estimate.
+  cost: () => ({ credits: 30, seconds_estimate: 100 })
+});
+
+// src/engine/nodes/remote/imageReferenceSheet.ts
+import { z as z22 } 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 = z22.object({
+  model: z22.enum(REFERENCE_SHEET_MODELS),
+  subject_description: z22.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(OPENROUTER_IMAGE_SIZES).optional()
+  subject_type: z22.enum(["character", "person", "product", "location"]),
+  views: z22.array(z22.string().min(1)).min(2).max(8).optional(),
+  style: z22.string().optional(),
+  prompt_override: z22.string().min(1).optional(),
+  aspect_ratio: z22.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: z22.enum(OPENROUTER_IMAGE_SIZES).optional()
 }).strict();
 var imageReferenceSheetNode = delegated({
   id: "image_reference_sheet",
@@ -7850,9 +7968,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: z22.object({ references: z22.array(ImageRef).min(1).max(6) }).loose(),
   params: ImageReferenceSheetParams,
-  outputs: z21.object({ sheet: ImageRef }).strict(),
+  outputs: z22.object({ sheet: ImageRef }).strict(),
   outputKinds: { sheet: "image" },
   cost: ({ params }) => ({
     credits: params?.model === "google/gemini-3-pro-image-preview" ? 20 : 5,
@@ -7861,10 +7979,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 z23 } from "zod";
+var ImageSearchParams = z23.object({
+  prompt: z23.string().min(1),
+  count: z23.number().int().min(1).max(20).default(5)
 }).strict();
 var imageSearchNode = delegated({
   id: "image_search",
@@ -7872,15 +7990,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: z23.object({}).loose(),
   params: ImageSearchParams,
-  outputs: z22.object({ images: z22.array(ImageRef).min(1) }).strict(),
+  outputs: z23.object({ images: z23.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 z24 } from "zod";
 var IMAGE_SELECT_MODELS = ["~google/gemini-flash-latest", "~google/gemini-pro-latest"];
 var imageSelectNode = delegated({
   id: "image_select",
@@ -7888,15 +8006,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: z24.object({ images: z24.array(ImageRef).min(2) }).loose(),
+  params: z24.object({
+    model: z24.enum(IMAGE_SELECT_MODELS),
+    prompt: z24.string().min(1),
+    count: z24.number().int().min(1).default(1),
+    temperature: z24.number().min(0).max(2).optional(),
+    max_tokens: z24.number().int().positive().optional()
   }).strict(),
-  outputs: z23.object({ images: z23.array(ImageRef).min(1), reasoning: TextRef }).strict(),
+  outputs: z24.object({ images: z24.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
@@ -7921,34 +8039,34 @@ var imageSelectNode = delegated({
 });
 
 // src/engine/nodes/remote/music.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var MUSIC_MODELS = ["elevenlabs/music-v1", "elevenlabs/video-background-music-v1"];
-var MusicParams = z24.object({
-  model: z24.enum(MUSIC_MODELS),
+var MusicParams = z25.object({
+  model: z25.enum(MUSIC_MODELS),
   /** Free-form prompt. Used by `elevenlabs/music-v1` (compose-detailed). */
-  prompt: z24.string().optional(),
+  prompt: z25.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: z25.record(z25.string(), z25.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: z25.number().int().min(3e3).max(ELEVENLABS_MAX_MUSIC_LENGTH_MS).optional(),
+  seed: z25.number().int().optional(),
   /** Prompt mode only — forces an instrumental (no vocals) track. */
-  force_instrumental: z24.boolean().optional(),
+  force_instrumental: z25.boolean().optional(),
   /** composition_plan only — honor exact section durations. */
-  respect_sections_durations: z24.boolean().optional(),
+  respect_sections_durations: z25.boolean().optional(),
   /** Emit word-level timestamps alongside the audio. */
-  with_timestamps: z24.boolean().optional(),
+  with_timestamps: z25.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: z25.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: z25.array(z25.string()).max(10).optional(),
+  output_format: z25.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
 }).strict();
 var musicNode = delegated({
   id: "music",
@@ -7956,9 +8074,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: z25.object({ video: VideoRef.optional() }).loose(),
   params: MusicParams,
-  outputs: z24.object({ audio: AudioRef, timestamps: JsonRef.optional() }).strict(),
+  outputs: z25.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;
@@ -7989,25 +8107,25 @@ var musicNode = delegated({
 });
 
 // src/engine/nodes/remote/soundEffect.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var SOUND_EFFECT_MODELS = ["elevenlabs/eleven_text_to_sound_v2"];
-var SoundEffectParams = z25.object({
-  model: z25.enum(SOUND_EFFECT_MODELS),
+var SoundEffectParams = z26.object({
+  model: z26.enum(SOUND_EFFECT_MODELS),
   /** Prompt describing the SFX ("metal door slam", "soft UI tap", "ocean waves"). */
-  text: z25.string().min(1),
+  text: z26.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: z26.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: z26.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: z26.boolean().optional(),
+  output_format: z26.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
 }).strict();
 var soundEffectNode = delegated({
   id: "sound_effect",
@@ -8015,9 +8133,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: z26.object({}).loose(),
   params: SoundEffectParams,
-  outputs: z25.object({ audio: AudioRef }).strict(),
+  outputs: z26.object({ audio: AudioRef }).strict(),
   outputKinds: { audio: "audio" },
   cost: ({ params }) => {
     const seconds = params.duration_seconds ?? 5;
@@ -8026,7 +8144,7 @@ var soundEffectNode = delegated({
 });
 
 // src/engine/nodes/remote/textGenerate.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var TEXT_GENERATE_MODELS = ["~google/gemini-flash-latest", "~google/gemini-pro-latest"];
 var textGenerateNode = delegated({
   id: "text_generate",
@@ -8034,58 +8152,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: z27.object({}).loose(),
+  params: z27.object({
+    model: z27.enum(TEXT_GENERATE_MODELS),
+    prompt: z27.string().min(1),
+    system: z27.string().optional(),
+    response_format: z27.enum(["text", "json_object"]).optional(),
+    web_search: z27.boolean().optional(),
+    temperature: z27.number().min(0).max(2).optional(),
+    max_tokens: z27.number().int().positive().optional()
   }).strict(),
-  outputs: z26.object({ text: TextRef }).strict(),
+  outputs: z27.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 z28 } 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 = z28.object({
+  stability: z28.number().min(0).max(1).optional(),
+  similarity_boost: z28.number().min(0).max(1).optional(),
+  style: z28.number().min(0).max(1).optional(),
+  use_speaker_boost: z28.boolean().optional(),
+  speed: z28.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 = z28.object({
+  pronunciation_dictionary_id: z28.string().min(1),
+  version_id: z28.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 = z28.object({
+  model: z28.enum(TTS_MODELS),
+  text: z28.string().min(1).max(ELEVENLABS_MAX_TEXT_CHARS),
+  voice: z28.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: z28.enum(ELEVENLABS_OUTPUT_FORMATS).optional(),
+  seed: z28.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: z28.number().min(0).max(1).optional(),
+  similarity_boost: z28.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: z28.string().optional(),
+  pronunciation_dictionary_locators: z28.array(TtsPronunciationLocator).max(3).optional(),
+  apply_text_normalization: z28.enum(["auto", "on", "off"]).optional(),
   /** Currently Japanese-only. Adds latency. */
-  apply_language_text_normalization: z27.boolean().optional(),
+  apply_language_text_normalization: z28.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: z28.boolean().optional()
 }).strict();
 var ttsNode = delegated({
   id: "tts",
@@ -8093,9 +8211,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: z28.object({}).loose(),
   params: TtsParams,
-  outputs: z27.object({ audio: AudioRef, timestamps: JsonRef.optional() }).strict(),
+  outputs: z28.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)),
@@ -8104,25 +8222,25 @@ var ttsNode = delegated({
 });
 
 // src/engine/nodes/remote/video.ts
-import { z as z28 } from "zod";
-var videoModelEnum = z28.enum(VIDEO_GENERATE_MODELS);
-var VideoGenerateParams = z28.object({
+import { z as z29 } from "zod";
+var videoModelEnum = z29.enum(VIDEO_GENERATE_MODELS);
+var VideoGenerateParams = z29.object({
   model: videoModelEnum,
-  prompt: z28.string().min(1),
-  duration: z28.number().int().positive().optional(),
-  resolution: z28.string().optional(),
+  prompt: z29.string().min(1),
+  duration: z29.number().int().positive().optional(),
+  resolution: z29.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: z29.enum(["16:9", "9:16", "1:1", "4:3", "3:4", "21:9", "9:21"]).optional(),
+  generate_audio: z29.boolean().optional(),
+  seed: z29.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: z29.string().optional(),
+  person_generation: z29.string().optional(),
+  enhance_prompt: z29.boolean().optional(),
+  conditioning_scale: z29.number().optional(),
   // Kling-only passthrough (prompt-adherence dial, sent top-level).
-  cfg_scale: z28.number().optional()
+  cfg_scale: z29.number().optional()
 }).strict();
 var videoGenerateNode = delegated({
   id: "video_generate",
@@ -8130,7 +8248,7 @@ var videoGenerateNode = delegated({
   category: "video",
   summary: "Generate video for ad creatives. Curated roster: `google/gemini-omni-flash` (DEFAULT \u2014 native audio + reference images in one call, 720p, 3-10s), `bytedance/seedance-2.0` (identity/product workhorse, NO photoreal human faces), `google/veo-3.1` (photoreal cine ceiling + the human-face model), `google/veo-3.1-fast` (cheap Veo iteration), `kwaivgi/kling-3.0` (motion-transfer/dynamic). Async with polling.",
   when_to_use: "`google/gemini-omni-flash` is the DEFAULT: it renders picture and synchronized audio in one call, and is the only model here that takes reference images alongside a prompt. SET `duration` (3-10s) to the length the beat actually needs \u2014 it bills ~$0.101 PER SECOND, so leaving it out renders the 10s default and charges ~$1.01 for a beat that may need 3s (~$0.30). Its resolution is fixed at 720p and it accepts only `16:9` or `9:16`; it takes NO `resolution`, `seed`, `negative_prompt` or `generate_audio` param \u2014 sending one fails validation. Keep the default for ordinary beats; move off it when a beat needs 1080p, a length outside 3-10s, or a 1:1 frame. Use `bytedance/seedance-2.0` for identity/product output WITHOUT a photoreal human face on camera. Any clip whose frame shows a photoreal human face \u2014 a UGC creator, presenter, or testimonial speaker, REAL OR AI-GENERATED \u2014 must use `google/veo-3.1`: ByteDance's filter rejects photoreal human faces on Seedance (content_policy_blocked/E005), and a synthetic AI face does NOT clear it. Use `google/veo-3.1-fast` while iterating to keep cost low; `kwaivgi/kling-3.0` for motion-transfer/hyper-dynamic beats. `baker canvas scaffold-video` auto-routes a photoreal cast to Veo; a Seedance clip blocked at runtime also auto-recovers on Veo. Each model gates its own durations/resolutions/aspect ratios in the registry \u2014 see the README per-model section.",
-  inputs: z28.object({
+  inputs: z29.object({
     first_frame: ImageRef.optional(),
     last_frame: ImageRef.optional(),
     reference: ImageRef.optional(),
@@ -8140,10 +8258,10 @@ var videoGenerateNode = delegated({
      * exclusive with `first_frame` — OpenRouter treats a request carrying both
      * as image-to-video and ignores these, so wire one or the other.
      */
-    references: z28.array(ImageRef).optional()
+    references: z29.array(ImageRef).optional()
   }).loose(),
   params: VideoGenerateParams,
-  outputs: z28.object({ video: VideoRef }).strict(),
+  outputs: z29.object({ video: VideoRef }).strict(),
   outputKinds: { video: "video" },
   // Priced from the shared contract, so `validate`'s quote and the charge the
   // backend applies come from ONE table. A flat number here under-quoted a
@@ -8163,11 +8281,11 @@ var videoGenerateNode = delegated({
 });
 
 // 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 z30 } from "zod";
+var VideoBackgroundRemoveParams = z30.object({
+  model: z30.literal("fal/veed-video-background-removal").optional().default("fal/veed-video-background-removal"),
+  edge_refinement: z30.boolean().optional().default(true),
+  output_codec: z30.enum(["vp9", "h264"]).optional().default("vp9")
 }).strict();
 var videoBackgroundRemoveNode = delegated({
   id: "video_background_remove",
@@ -8175,18 +8293,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: z30.object({
     video: VideoRef
   }).strict(),
   params: VideoBackgroundRemoveParams,
-  outputs: z29.object({ video: VideoRef }).strict(),
+  outputs: z30.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 z31 } from "zod";
 var VIDEO_DECONSTRUCT_MODELS = ["~google/gemini-flash-latest", "~google/gemini-pro-latest"];
 var videoDeconstructNode = delegated({
   id: "video_deconstruct",
@@ -8194,34 +8312,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: z31.object({ video: VideoRef }).loose(),
+  params: z31.object({
+    model: z31.enum(VIDEO_DECONSTRUCT_MODELS),
+    mode: z31.enum(["full", "index"]).optional(),
+    language: z31.string().min(2).max(8).optional(),
+    max_scenes: z31.number().int().min(1).max(60).optional(),
+    focus: z31.string().optional(),
+    start_s: z31.number().min(0).optional(),
+    end_s: z31.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: z31.array(z31.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: z31.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: z31.enum(["groq", "deepgram"]).optional()
   }).strict(),
-  outputs: z30.object({
+  outputs: z31.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: z31.array(ImageRef).min(1).optional(),
+    end_frames: z31.array(ImageRef).min(1).optional(),
     transcript: JsonRef
   }).strict(),
   outputKinds: { analysis: "json", start_frames: "image", end_frames: "image", transcript: "json" },
@@ -8229,22 +8347,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 z32 } from "zod";
+var FalLipsyncParams = z32.object({
+  model: z32.literal("fal/veed-lipsync")
 }).strict();
-var VideoLipsyncParams = z31.discriminatedUnion("model", [FalLipsyncParams]);
+var VideoLipsyncParams = z32.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: z32.object({
     video: VideoRef,
     audio: AudioRef
   }).strict(),
   params: VideoLipsyncParams,
-  outputs: z31.object({ video: VideoRef }).strict(),
+  outputs: z32.object({ video: VideoRef }).strict(),
   outputKinds: { video: "video" },
   cost: () => ({ credits: 20, seconds_estimate: 120 })
 });
@@ -8253,7 +8371,7 @@ var videoLipsyncNode = delegated({
 import { mkdtemp as mkdtemp6, readFile as readFile11, rm as rm6 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
 import path14 from "path";
-import { z as z32 } from "zod";
+import { z as z33 } from "zod";
 
 // src/engine/nodes/local/lib/ffmpeg.ts
 import { execFile as execFile7 } from "child_process";
@@ -8332,24 +8450,24 @@ ${detail.slice(-4e3)}`);
 }
 
 // src/engine/nodes/remote/videoTranscribe.ts
-var VideoTranscribeParams = z32.object({
-  language: z32.string().min(2).max(8).optional(),
+var VideoTranscribeParams = z33.object({
+  language: z33.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: z33.enum(["groq", "deepgram"]).optional()
 }).strict();
-var VideoTranscribeInputs = z32.object({
+var VideoTranscribeInputs = z33.object({
   // A video (audio auto-extracted locally) OR a bare audio track. The key stays
   // `video` for back-compat; the backend already accepts audio-kind refs on it —
   // the local extraction path has been shipping one for every video input.
-  video: z32.union([VideoRef, AudioRef])
+  video: z33.union([VideoRef, AudioRef])
 }).strict();
-var VideoTranscribeOutputs = z32.object({
-  transcript: z32.custom(),
+var VideoTranscribeOutputs = z33.object({
+  transcript: z33.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: z33.custom().optional()
 }).strict();
 var AUDIO_EXTRACT_TIMEOUT_MS = 6e4;
 var videoTranscribeNode = defineNode({
@@ -8434,29 +8552,29 @@ async function tryExtractAudio(inputs, ctx) {
 }
 
 // src/engine/nodes/remote/voiceSelect.ts
-import { z as z33 } from "zod";
+import { z as z34 } 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: z34.object({}).loose(),
+  params: z34.object({
+    description: z34.string().min(1),
+    gender: z34.string().optional(),
+    age: z34.string().optional(),
+    accent: z34.string().optional(),
+    language: z34.string().optional(),
+    limit: z34.number().int().min(1).max(20).optional()
   }).strict(),
-  outputs: z33.object({ voice_id: TextRef, candidates: JsonRef }).strict(),
+  outputs: z34.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 z35 } from "zod";
 function generateCatalog(registry, opts = {}) {
   const entries = registry.all().map((def) => {
     const cost = def.cost ? safeCost(def) : void 0;
@@ -8467,9 +8585,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: z35.toJSONSchema(def.inputs, { unrepresentable: "any" }),
+      params: z35.toJSONSchema(def.params, { unrepresentable: "any" }),
+      outputs: z35.toJSONSchema(def.outputs, { unrepresentable: "any" }),
       cost_estimate_credits: cost?.credits,
       runtime_estimate_seconds: cost?.seconds_estimate
     };
@@ -8567,7 +8685,8 @@ var REMOTE_NODES = [
   videoBackgroundRemoveNode,
   videoDeconstructNode,
   voiceSelectNode,
-  imageBackgroundRemoveNode
+  imageBackgroundRemoveNode,
+  imageLayerizeNode
 ];
 function defaultRegistry() {
   const r = new NodeRegistry();
@@ -8634,6 +8753,7 @@ export {
   REF_PREFIX,
   parseRefExpr,
   sha256Hex,
+  MAX_ASSET_BYTES,
   looksLikeHttpUrl,
   SEEDANCE_PROFILE,
   clipProfileFor,
@@ -8642,6 +8762,7 @@ export {
   spineInputFlags,
   spineInputOps,
   elementMentionKeywords,
+  MAX_REMOTE_IMAGE_BYTES,
   fetchExternalBytes,
   toModelSafeImage,
   BackendClient2,
@@ -8654,4 +8775,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-CVJCXDWD.js.map
+//# sourceMappingURL=chunk-5MPIOGRO.js.map