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

package/dist/{chunk-IWPAXJC3.js → chunk-Q3K5TXC6.js}

@@ -3,9 +3,9 @@ import {
   __toESM
 } from "./chunk-5WRI5ZAA.js";
 
-// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js
+// ../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/810146e81bae4e3a061fe487864f2fde80c4b03b886877dc0f1fffbc6480b67e/node_modules/safe-stable-stringify/index.js
 var require_safe_stable_stringify = __commonJS({
-  "../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js"(exports, module) {
+  "../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/810146e81bae4e3a061fe487864f2fde80c4b03b886877dc0f1fffbc6480b67e/node_modules/safe-stable-stringify/index.js"(exports, module) {
     "use strict";
     var { hasOwnProperty } = Object.prototype;
     var stringify = configure2();
@@ -138,9 +138,9 @@ var require_safe_stable_stringify = __commonJS({
         }
         if (value) {
           return (value2) => {
-            let message = `Object can not safely be stringified. Received type ${typeof value2}`;
-            if (typeof value2 !== "function") message += ` (${value2.toString()})`;
-            throw new Error(message);
+            let message2 = `Object can not safely be stringified. Received type ${typeof value2}`;
+            if (typeof value2 !== "function") message2 += ` (${value2.toString()})`;
+            throw new Error(message2);
           };
         }
       }
@@ -652,6 +652,9 @@ var HttpClient = class {
   async postJson(path16, body, signal) {
     return await this.requestJson("POST", path16, body, signal);
   }
+  async putJson(path16, body, signal) {
+    return await this.requestJson("PUT", path16, body, signal);
+  }
   async getJson(path16, signal) {
     return await this.requestJson("GET", path16, void 0, signal);
   }
@@ -679,8 +682,8 @@ var HttpClient = class {
     try {
       const res = await this.fetchFn(url, {
         method,
-        headers: method === "POST" ? { "Content-Type": "application/json", Authorization: `Bearer ${this.apiKey}` } : { Authorization: `Bearer ${this.apiKey}` },
-        body: method === "POST" ? JSON.stringify(body) : void 0,
+        headers: method === "GET" ? { Authorization: `Bearer ${this.apiKey}` } : { "Content-Type": "application/json", Authorization: `Bearer ${this.apiKey}` },
+        body: method === "GET" ? void 0 : JSON.stringify(body),
         signal: controller.signal
       });
       if (res.ok) return { kind: "value", value: await res.json() };
@@ -717,33 +720,33 @@ async function parseErrorBody(res) {
   const errObj = body.error ?? {};
   return classifyHttpError(res.status, errObj, errObj.message ?? `HTTP ${res.status}`);
 }
-function classifyHttpError(status, errObj, message) {
+function classifyHttpError(status, errObj, message2) {
   if (errObj.code === CONTENT_POLICY_CODE) {
-    return { kind: "content_policy", status, provider: errObj.provider, message };
+    return { kind: "content_policy", status, provider: errObj.provider, message: message2 };
   }
   if (status === 401 || status === 403) {
-    return { kind: "unauthorized", status, message };
+    return { kind: "unauthorized", status, message: message2 };
   }
   if (status === 400 || status === 422) {
-    return { kind: "validation", status, message, details: errObj.details };
+    return { kind: "validation", status, message: message2, details: errObj.details };
   }
   if (status === 502 || status === 504) {
     if (errObj.code === "provider_timeout" || status === 504) {
-      return { kind: "timeout", provider: errObj.provider, message };
+      return { kind: "timeout", provider: errObj.provider, message: message2 };
     }
     return {
       kind: "provider",
       status,
       provider: errObj.provider,
       code: errObj.code ?? "provider_error",
-      message,
+      message: message2,
       retryable: errObj.retryable ?? true
     };
   }
   if (status >= 500 || status === 429) {
-    return { kind: "server", status, message };
+    return { kind: "server", status, message: message2 };
   }
-  return { kind: "validation", status, message, details: errObj.details };
+  return { kind: "validation", status, message: message2, details: errObj.details };
 }
 function backoffMs(attempt) {
   return 1e3 * 2 ** attempt;
@@ -777,7 +780,9 @@ function failedJobError(error) {
     retryable: error.retryable ?? false
   });
 }
-var JOB_POLL_INTERVAL_MS = 3e3;
+function pollInterval(attempt) {
+  return attempt < 15 ? 1e3 : 3e3;
+}
 var JOB_POLL_MAX_MS = 20 * 60 * 1e3;
 var BackendClient = class {
   http;
@@ -794,7 +799,7 @@ var BackendClient = class {
   async pollJob(jobId, signal) {
     const deadline = Date.now() + JOB_POLL_MAX_MS;
     const path16 = `/api/canvas/jobs/${encodeURIComponent(jobId)}`;
-    while (true) {
+    for (let attempt = 0; ; attempt++) {
       if (signal?.aborted) {
         throw new BackendHttpError({ kind: "network", cause: signal.reason ?? new Error("aborted") });
       }
@@ -804,7 +809,7 @@ var BackendClient = class {
       if (Date.now() > deadline) {
         throw new BackendHttpError({ kind: "timeout", message: `job ${jobId} did not finish in time` });
       }
-      await sleep(JOB_POLL_INTERVAL_MS);
+      await sleep(pollInterval(attempt));
     }
   }
   presignAssetUpload(sha256, mime, signal) {
@@ -814,6 +819,35 @@ var BackendClient = class {
       signal
     );
   }
+  /** Remote cache lookup. A miss (404) — or an old backend without the route — returns null. */
+  async getCacheEntry(cacheKey, signal) {
+    try {
+      const res = await this.http.getJson(`/api/canvas/cache/${encodeURIComponent(cacheKey)}`, signal);
+      return res.entry;
+    } catch (e) {
+      if (e instanceof BackendHttpError && "status" in e.detail && e.detail.status === 404) return null;
+      throw e;
+    }
+  }
+  async putCacheEntry(entry, signal) {
+    await this.http.putJson(
+      `/api/canvas/cache/${encodeURIComponent(entry.cacheKey)}`,
+      entry,
+      signal
+    );
+  }
+  /** Durable run-history record — POST /api/canvas/runs (idempotent server-side on runId). */
+  async recordRun(payload, signal) {
+    await this.http.postJson("/api/canvas/runs", payload, signal);
+  }
+  /**
+   * Chat-scoped blueprint sync — POST /api/creatives/definition. Lets the
+   * dashboard draw a scaffolded creative's workflow graph BEFORE the first run.
+   * Additive on the backend (never archives siblings, never sets definitionPath).
+   */
+  async syncCreativeDefinition(payload, signal) {
+    await this.http.postJson("/api/creatives/definition", payload, signal);
+  }
   getArtifact(kind, name, version, 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);
@@ -837,14 +871,17 @@ function requireCredentialsFromEnv(env = process.env) {
   }
   return c;
 }
+function remoteCacheEnabledFromEnv(env = process.env) {
+  return env.BAKER_CANVAS_REMOTE_CACHE !== "off";
+}
 
 // src/engine/engine/errors.ts
 function isBlocking(issue) {
   return issue.severity !== "warning";
 }
 var CanvasError = class extends Error {
-  constructor(message) {
-    super(message);
+  constructor(message2) {
+    super(message2);
     this.name = "CanvasError";
   }
 };
@@ -901,7 +938,7 @@ function describeCause(c) {
   }
 }
 
-// ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/esm/wrapper.js
+// ../../.pnpm-store/v10/links/@/safe-stable-stringify/2.5.0/810146e81bae4e3a061fe487864f2fde80c4b03b886877dc0f1fffbc6480b67e/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;
@@ -959,10 +996,10 @@ var ELEVENLABS_OUTPUT_FORMATS = [
 var ELEVENLABS_MAX_TEXT_CHARS = 45454;
 var ELEVENLABS_MAX_MUSIC_LENGTH_MS = 454545;
 var OPENROUTER_IMAGE_MIMES = ["image/png", "image/jpeg", "image/webp", "image/gif"];
-var FAL_IMAGE_MIMES = ["image/png", "image/jpeg", "image/webp"];
-var FAL_VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
+var REPLICATE_IMAGE_MIMES = ["image/png", "image/jpeg", "image/webp"];
+var REPLICATE_VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
 var DECONSTRUCT_VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
-var FAL_AUDIO_MIMES = ["audio/wav", "audio/mpeg", "audio/mp3"];
+var REPLICATE_AUDIO_MIMES = ["audio/wav", "audio/mpeg", "audio/mp3"];
 var IMAGE_GENERATE_MODELS = [
   "openai/gpt-5.4-image-2",
   "google/gemini-3.5-flash",
@@ -1180,20 +1217,23 @@ var MODEL_REGISTRY = {
   },
   video_generate: {
     "bytedance/seedance-2.0": {
-      // Routed via fal.ai (not OpenRouter) because OpenRouter's Seedance
-      // passthrough rejects photorealistic human reference frames via
-      // ByteDance's "real person" safety filter.
+      // Routed via Replicate's official `bytedance/seedance-2.0` model. NOTE:
+      // ByteDance's upstream "real person" likeness filter still blocks photoreal
+      // human reference frames on ANY reseller — the escape is a synthetic/AI
+      // presenter face or routing real faces to Veo, not the provider choice.
       label: "ByteDance Seedance 2.0",
       inputs: [],
-      optional_inputs: [{ kind: "image", mimes: FAL_IMAGE_MIMES }],
+      optional_inputs: [{ kind: "image", mimes: REPLICATE_IMAGE_MIMES }],
       required: ["prompt"],
       params: {
-        prompt: { kind: "string" },
+        // Replicate's Seedance wrapper hard-caps the prompt at 4000 chars; gate
+        // it here so an over-length prompt fails validate (free) not the billed call.
+        prompt: { kind: "string", maxLength: 4e3 },
         aspect_ratio: {
           kind: "string",
           enum: ["1:1", "3:4", "9:16", "4:3", "16:9", "21:9", "9:21"]
         },
-        resolution: { kind: "string", enum: ["480p", "720p", "1080p"] },
+        resolution: { kind: "string", enum: ["480p", "720p", "1080p", "4k"] },
         duration: { kind: "number", enum: SEEDANCE_DURATIONS },
         seed: { kind: "number" },
         generate_audio: { kind: "boolean" }
@@ -1214,7 +1254,10 @@ var MODEL_REGISTRY = {
         duration: { kind: "number", enum: [4, 6, 8] },
         seed: { kind: "number" },
         generate_audio: { kind: "boolean" },
-        person_generation: { kind: "string", enum: ["allow_all"] },
+        // Image-to-video and EU/UK/CH/MENA regions cap this at `allow_adult`;
+        // `allow_all` is text-to-video only. Allow both so an image-conditioned
+        // Veo clip (the real-face fallback) validates.
+        person_generation: { kind: "string", enum: ["allow_all", "allow_adult"] },
         enhance_prompt: { kind: "boolean" },
         conditioning_scale: { kind: "number" }
       }
@@ -1265,8 +1308,8 @@ var MODEL_REGISTRY = {
     "fal/veed-lipsync": {
       label: "VEED Lipsync (fal.ai)",
       inputs: [
-        { kind: "video", mimes: FAL_VIDEO_MIMES },
-        { kind: "audio", mimes: FAL_AUDIO_MIMES }
+        { kind: "video", mimes: REPLICATE_VIDEO_MIMES },
+        { kind: "audio", mimes: REPLICATE_AUDIO_MIMES }
       ],
       required: [],
       params: {}
@@ -1302,7 +1345,7 @@ var MODEL_REGISTRY = {
       // 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 }],
+      inputs: [{ kind: "audio", mimes: REPLICATE_AUDIO_MIMES }],
       required: ["voice"],
       params: {
         voice: { kind: "string" },
@@ -1329,7 +1372,7 @@ var MODEL_REGISTRY = {
     },
     "elevenlabs/video-background-music-v1": {
       label: "ElevenLabs Video Background Music v1",
-      inputs: [{ kind: "video", mimes: FAL_VIDEO_MIMES }],
+      inputs: [{ kind: "video", mimes: REPLICATE_VIDEO_MIMES }],
       required: [],
       params: {
         description: { kind: "string" },
@@ -1500,7 +1543,7 @@ function validateValue(key, value, schema, model) {
 }
 
 // src/engine/lib/concurrency.ts
-var DEFAULT_CONCURRENCY = 5;
+var DEFAULT_CONCURRENCY = 8;
 function resolveConcurrency(...candidates) {
   for (const candidate of candidates) {
     if (candidate === void 0 || candidate === "") continue;
@@ -1562,6 +1605,160 @@ function encodeRandom() {
   return out;
 }
 
+// src/engine/storage/remote-cache-store.ts
+var CANVAS_ASSETS_URL_SEGMENT = "/canvas-assets/";
+function isPersistedAssetRef(ref) {
+  const { url, sha256 } = ref;
+  if (typeof url !== "string" || typeof sha256 !== "string") return false;
+  return url.includes(`${CANVAS_ASSETS_URL_SEGMENT}${sha256.slice(0, 2)}/${sha256}`) || url.includes(`${CANVAS_ASSETS_URL_SEGMENT}${sha256}`);
+}
+function isAssetRefLike(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.sha256 === "string" && typeof value.mime === "string";
+}
+function collectAssetRefLikes(value, out = []) {
+  if (Array.isArray(value)) {
+    for (const item of value) collectAssetRefLikes(item, out);
+    return out;
+  }
+  if (typeof value !== "object" || value === null) return out;
+  if (isAssetRefLike(value)) {
+    out.push(value);
+  }
+  for (const item of Object.values(value)) collectAssetRefLikes(item, out);
+  return out;
+}
+function entryFullyPersisted(entry) {
+  return collectAssetRefLikes(entry.outputs).every((ref) => isPersistedAssetRef(ref));
+}
+function stripLocalFields(entry) {
+  const clone = JSON.parse(JSON.stringify(entry));
+  for (const ref of collectAssetRefLikes(clone.outputs)) {
+    delete ref.path;
+    delete ref.bytes;
+  }
+  return clone;
+}
+var RemoteCacheStore = class {
+  client;
+  log;
+  constructor(client, log) {
+    this.client = client;
+    this.log = log ?? (() => void 0);
+  }
+  async get(cacheKey) {
+    return await this.client.getCacheEntry(cacheKey);
+  }
+  async put(entry) {
+    if (!entryFullyPersisted(entry)) {
+      this.log(`[cache   ] ${entry.cacheKey.slice(0, 12)}\u2026 has local-only assets, kept local`);
+      return;
+    }
+    const stripped = stripLocalFields(entry);
+    if (stripped.refs.length > MAX_REMOTE_REFS) {
+      stripped.refs = stripped.refs.slice(0, MAX_REMOTE_REFS);
+    }
+    await this.client.putCacheEntry(stripped);
+  }
+};
+var MAX_REMOTE_REFS = 512;
+var LayeredCacheStore = class {
+  rootDir;
+  local;
+  remote;
+  assets;
+  log;
+  constructor(opts) {
+    this.local = opts.local;
+    this.remote = opts.remote;
+    this.assets = opts.assets;
+    this.rootDir = opts.local.rootDir;
+    this.log = opts.log ?? (() => void 0);
+  }
+  async get(cacheKey) {
+    const localHit = await this.local.get(cacheKey);
+    if (localHit) return localHit;
+    let remoteEntry;
+    try {
+      remoteEntry = await this.remote.get(cacheKey);
+    } catch (e) {
+      this.log(`[cache   ] remote lookup failed (${message(e)}) \u2014 treating as miss`);
+      return null;
+    }
+    if (!remoteEntry) return null;
+    let rehydrated;
+    try {
+      rehydrated = await this.rehydrate(remoteEntry);
+    } catch (e) {
+      this.log(`[cache   ] ${cacheKey.slice(0, 12)}\u2026 rehydration failed (${message(e)}) \u2014 treating as miss`);
+      return null;
+    }
+    await this.local.put(rehydrated);
+    return rehydrated;
+  }
+  async put(entry) {
+    await this.local.put(entry);
+    try {
+      await this.remote.put(entry);
+    } catch (e) {
+      this.log(`[cache   ] remote write failed (${message(e)}) \u2014 entry kept local`);
+    }
+  }
+  /**
+   * Download every referenced asset into the local content-addressed store
+   * (sha-verified) and stamp fresh local paths. Any ref that cannot be
+   * rehydrated fails the WHOLE entry — a partially-hydrated cache hit would
+   * crash materialization later with a far less actionable error.
+   */
+  async rehydrate(entry) {
+    const clone = JSON.parse(JSON.stringify(entry));
+    for (const ref of collectAssetRefLikes(clone.outputs)) {
+      if (!isPersistedAssetRef(ref)) {
+        throw new Error(`ref ${ref.sha256.slice(0, 12)}\u2026 has no persisted url`);
+      }
+      const ingested = await this.assets.ingestRemote({
+        kind: typeof ref.kind === "string" ? ref.kind : "json",
+        url: ref.url,
+        sha256: ref.sha256,
+        mime: ref.mime,
+        metadata: ref.metadata ?? void 0
+      });
+      ref.path = ingested.path;
+    }
+    return clone;
+  }
+};
+function message(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+
+// src/engine/nodes/remote/upload.ts
+async function presignAndPut(args) {
+  const { putUrl, publicUrl } = await args.ctx.client.presignAssetUpload(args.sha256, args.mime, args.ctx.signal);
+  const putRes = await fetch(putUrl, {
+    method: "PUT",
+    body: new Uint8Array(args.bytes),
+    headers: { "Content-Type": args.mime },
+    signal: args.ctx.signal
+  });
+  if (!putRes.ok) {
+    throw new Error(`upload: presigned PUT failed ${putRes.status} ${putRes.statusText}`);
+  }
+  return publicUrl;
+}
+async function ensureUploaded(ref, ctx) {
+  if (ref.url) return ref;
+  const bytes = await ctx.assets.readBytes(ref.sha256, ref.mime);
+  const url = await presignAndPut({ bytes, sha256: ref.sha256, mime: ref.mime, ctx });
+  return { ...ref, url };
+}
+async function persistOutputAssetUrls(outputs, ctx) {
+  for (const ref of collectAssetRefLikes(outputs)) {
+    if (isPersistedAssetRef(ref)) continue;
+    const bytes = await ctx.assets.readBytes(ref.sha256, ref.mime);
+    ref.url = await presignAndPut({ bytes, sha256: ref.sha256, mime: ref.mime, ctx });
+  }
+}
+
 // src/engine/schema/canvas.ts
 import { z } from "zod";
 var REF_PREFIX = "$ref:";
@@ -1591,7 +1788,14 @@ var NodeDecl = z.object({
   version: z.string().min(1).optional(),
   inputs: z.record(z.string(), z.unknown()).optional(),
   params: z.record(z.string(), z.unknown()).optional(),
-  when: z.unknown().optional()
+  when: z.unknown().optional(),
+  // Regenerate knob. The engine is content-addressed: identical params + inputs
+  // return the cached render, so re-running an unchanged node NEVER re-bills or
+  // produces a new result. Bump this token (any string/number — a `2`, a `"v3"`,
+  // a note) and re-run to force THIS node to render fresh; because its new output
+  // changes downstream input hashes, everything depending on it regenerates too.
+  // This is the declarative "change a value, re-run, get a new render" affordance.
+  regenerate: z.union([z.string(), z.number()]).optional()
 }).strict();
 var OutputRef = z.object({
   node: z.string(),
@@ -2841,6 +3045,7 @@ var Engine = class {
   cache;
   outputsDir;
   log;
+  persistAssets;
   constructor(opts) {
     this.registry = opts.registry;
     this.client = opts.client;
@@ -2848,6 +3053,7 @@ var Engine = class {
     this.cache = opts.cache;
     this.outputsDir = opts.outputsDir;
     this.log = opts.log ?? (() => void 0);
+    this.persistAssets = opts.persistAssets ?? false;
   }
   validate(canvas) {
     return validateCanvas(canvas, this.registry);
@@ -2871,7 +3077,16 @@ var Engine = class {
     const outputs = {};
     const counters = { cachedNodes: 0, totalCredits: 0 };
     const nodeRuns = [];
-    await this.runLayers(canvas, outputs, runId, writer, opts, counters, nodeRuns);
+    const graph = this.pruneToOutput(canvas, buildGraph(canvas));
+    const needsBytes = computeNeedsLocalBytes(canvas, graph, this.registry);
+    this.emitProgress(opts, {
+      kind: "plan",
+      nodes: [...graph.entries()].map(([id, deps]) => {
+        const node = canvas.nodes.find((n) => n.id === id);
+        return { node_id: id, node_type: node?.type ?? "unknown", deps: [...deps], params: node?.params };
+      })
+    });
+    await this.runLayers(canvas, graph, outputs, runId, writer, opts, counters, nodeRuns, needsBytes);
     const output = pickFinalOutput(canvas, outputs);
     const stats = {
       total_nodes: canvas.nodes.length,
@@ -2894,39 +3109,51 @@ var Engine = class {
       `[done    ] ${stats.cached_nodes}/${stats.total_nodes} cached, ${stats.total_credits} credits, ${stats.duration_ms}ms`
     );
     this.log(`outputs in: ${writer.runDir}`);
-    return { run_id: runId, output, outputs_by_node: outputs, stats, outputs_dir: writer.runDir };
+    return { run_id: runId, output, outputs_by_node: outputs, stats, outputs_dir: writer.runDir, node_runs: nodeRuns };
   }
-  async runLayers(canvas, outputs, runId, writer, opts, counters, nodeRuns) {
-    const layers = topologicalLayers(this.pruneToOutput(canvas, buildGraph(canvas)));
+  async runLayers(canvas, graph, outputs, runId, writer, opts, counters, nodeRuns, needsBytes) {
+    const layers = topologicalLayers(graph);
     const limit = resolveConcurrency(opts.concurrency);
     for (const layer of layers) {
-      const settled = await mapWithConcurrency(
-        layer,
-        limit,
-        (nodeId) => this.executeOne(canvas, nodeId, outputs, runId, writer, opts).then((r) => {
+      const settled = await mapWithConcurrency(layer, limit, (nodeId) => {
+        this.emitProgress(opts, { kind: "node_start", node_id: nodeId });
+        return this.executeOne(canvas, nodeId, outputs, runId, writer, opts, needsBytes.has(nodeId)).then((r) => {
           if (r.cached) counters.cachedNodes++;
           counters.totalCredits += r.credits;
           const node = canvas.nodes.find((n) => n.id === nodeId);
           if (node) {
-            nodeRuns.push({
+            const run = {
               node_id: nodeId,
               node_type: node.type,
               cached: r.cached,
               duration_ms: r.durationMs,
               credits: r.credits
-            });
+            };
+            nodeRuns.push(run);
+            this.emitProgress(opts, { kind: "node_settled", run, outputs: outputs[nodeId] ?? {} });
           }
-        })
-      );
+        });
+      });
       const failures = [];
       settled.forEach((result, i) => {
         const nodeId = layer[i];
-        if (result.status === "rejected" && nodeId) failures.push({ nodeId, reason: result.reason });
+        if (result.status === "rejected" && nodeId) {
+          failures.push({ nodeId, reason: result.reason });
+          this.emitProgress(opts, { kind: "node_failed", node_id: nodeId });
+        }
       });
       if (failures.length === 1 && failures[0]) throw failures[0].reason;
       if (failures.length > 1) throw new LayerExecutionError(failures);
     }
   }
+  /** Progress consumers are observers only — an exception there must never fail the run. */
+  emitProgress(opts, event) {
+    if (!opts.onProgress) return;
+    try {
+      opts.onProgress(event);
+    } catch {
+    }
+  }
   /**
    * Dead-node elimination: when the canvas declares an `output`, execute only the
    * nodes that output transitively depends on. Orphaned nodes (left by an edit or
@@ -2957,12 +3184,13 @@ var Engine = class {
     }
     await writer.writeManifest("_final", output);
   }
-  async executeOne(canvas, nodeId, outputs, runId, writer, opts) {
+  async executeOne(canvas, nodeId, outputs, runId, writer, opts, downloadOutputs) {
     const node = canvas.nodes.find((n) => n.id === nodeId);
     if (!node) throw new Error(`executor: missing node ${nodeId}`);
     const def = this.registry.get(node.type);
     if (!def) throw new Error(`executor: missing registry entry for type ${node.type}`);
-    const prepared = await prepareForExecution(node, outputs, def, canvas.cache_salt, this.assets);
+    const regenerateToken = resolveRegenerateToken(node, opts.regenerate, runId);
+    const prepared = await prepareForExecution(node, outputs, def, canvas.cache_salt, regenerateToken, this.assets);
     const policy = opts.cache_policy ?? "read_write";
     if (policy !== "bypass") {
       const cacheT0 = Date.now();
@@ -2980,17 +3208,27 @@ var Engine = class {
       nodeId: node.id,
       nodeType: node.type,
       cacheKey: prepared.cacheKey,
+      downloadOutputs,
       client: this.client,
       assets: this.assets,
       log: this.log,
       signal: opts.signal
     };
-    const { parsedInputs, parsedParams } = parseNodeArgs(def, prepared, node.id, node.type);
+    const preparedForExec = needsLocalMaterialization(def) ? { ...prepared, resolvedInputs: await this.materializeLocalInputs(prepared.resolvedInputs) } : prepared;
+    const { parsedInputs, parsedParams } = parseNodeArgs(def, preparedForExec, node.id, node.type);
     const result = await invokeExecute(def, parsedInputs, parsedParams, ctx, node.id, node.type);
     const elapsed = Date.now() - t0;
     const credits = def.cost ? def.cost({ params: parsedParams }).credits : 0;
     const outputsObj = result;
     outputs[node.id] = outputsObj;
+    if (this.persistAssets) {
+      try {
+        await persistOutputAssetUrls(outputsObj, ctx);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        this.log(`[warn    ] ${node.id}: asset persistence failed (${msg}) \u2014 outputs stay local-only`);
+      }
+    }
     if (policy === "read_write") {
       await this.cache.put({
         cacheKey: prepared.cacheKey,
@@ -3019,8 +3257,42 @@ var Engine = class {
       }
     }
   }
+  /**
+   * Download any URL-only asset ref reachable in a local node's inputs so the
+   * bytes are on disk before the local runner stages them. Returns a copy —
+   * refs are replaced, never mutated in place, so the producer's cached output
+   * (shared object) keeps its URL-only shape.
+   */
+  async materializeLocalInputs(inputs) {
+    const fix = async (value) => {
+      if (Array.isArray(value)) return Promise.all(value.map(fix));
+      if (value && typeof value === "object") {
+        const v = value;
+        if (typeof v.kind === "string" && typeof v.url === "string" && typeof v.sha256 === "string" && typeof v.mime === "string" && typeof v.path !== "string") {
+          this.log(`[warn    ] materializing URL-only input on demand (${v.kind}/${v.mime}) \u2014 missed graph edge`);
+          return this.assets.ingestRemote({
+            kind: v.kind,
+            url: v.url,
+            sha256: v.sha256,
+            mime: v.mime,
+            metadata: v.metadata
+          });
+        }
+        const out = {};
+        for (const [k, val] of Object.entries(v)) out[k] = await fix(val);
+        return out;
+      }
+      return value;
+    };
+    return await fix(inputs);
+  }
 };
-async function prepareForExecution(node, outputs, def, cacheSalt, assets) {
+function resolveRegenerateToken(node, forced, runId) {
+  if (forced?.has(node.id)) return `run:${runId}`;
+  if (node.regenerate !== void 0) return `node:${String(node.regenerate)}`;
+  return void 0;
+}
+async function prepareForExecution(node, outputs, def, cacheSalt, regenerateToken, assets) {
   const resolvedInputs = resolveRefs(node.inputs ?? {}, { outputs }) ?? {};
   const resolvedParams = resolveRefs(node.params ?? {}, { outputs }) ?? {};
   const slotValues = await hydrateTextSlots(resolvedInputs, assets, node.id, node.type);
@@ -3033,6 +3305,9 @@ async function prepareForExecution(node, outputs, def, cacheSalt, assets) {
       throw new NodeExecutionError(node.id, node.type, { kind: "local", cause: e });
     }
   }
+  if (regenerateToken !== void 0) {
+    extras = { ...extras ?? {}, __regenerate__: regenerateToken };
+  }
   const cacheKey = computeCacheKey({
     node_id: node.type,
     node_version: def.version,
@@ -3061,6 +3336,9 @@ async function invokeExecute(def, parsedInputs, parsedParams, ctx, nodeId, nodeT
     throw new NodeExecutionError(nodeId, nodeType, { kind: "local", cause: e });
   }
 }
+function needsLocalMaterialization(def) {
+  return def.location === "local" && !def.passthroughRefs;
+}
 function pickFinalOutput(canvas, outputs) {
   if (canvas.output) {
     const node = outputs[canvas.output.node];
@@ -3071,6 +3349,16 @@ function pickFinalOutput(canvas, outputs) {
   const lastOut = outputs[last.id];
   return lastOut ? Object.values(lastOut)[0] : void 0;
 }
+function computeNeedsLocalBytes(canvas, graph, registry) {
+  const typeById = new Map(canvas.nodes.map((n) => [n.id, n.type]));
+  const needs = /* @__PURE__ */ new Set();
+  for (const [consumerId, deps] of graph) {
+    const def = registry.get(typeById.get(consumerId) ?? "");
+    if (def?.location !== "local" || def.passthroughRefs) continue;
+    for (const dep of deps) needs.add(dep);
+  }
+  return needs;
+}
 function buildGraph(canvas) {
   const graph = /* @__PURE__ */ new Map();
   for (const n of canvas.nodes) graph.set(n.id, /* @__PURE__ */ new Set());
@@ -3201,7 +3489,16 @@ async function hydrateSlotValue(value, assets, nodeId, nodeType) {
   try {
     bytes = await assets.readBytes(value.sha256, value.mime);
   } catch (e) {
-    throw new NodeExecutionError(nodeId, nodeType, { kind: "local", cause: e });
+    if (value.url) {
+      try {
+        await assets.ingestRemote({ kind: value.kind, url: value.url, sha256: value.sha256, mime: value.mime });
+        bytes = await assets.readBytes(value.sha256, value.mime);
+      } catch (e2) {
+        throw new NodeExecutionError(nodeId, nodeType, { kind: "local", cause: e2 });
+      }
+    } else {
+      throw new NodeExecutionError(nodeId, nodeType, { kind: "local", cause: e });
+    }
   }
   if (bytes.length > MAX_INLINE_TEXT_BYTES) {
     throw new NodeExecutionError(nodeId, nodeType, {
@@ -3309,27 +3606,6 @@ var FontRef = BaseAssetRef.extend({
 });
 var AssetRef = z4.discriminatedUnion("kind", [ImageRef, VideoRef, AudioRef, JsonRef, TextRef, FontRef]);
 
-// src/engine/nodes/remote/upload.ts
-async function presignAndPut(args) {
-  const { putUrl, publicUrl } = await args.ctx.client.presignAssetUpload(args.sha256, args.mime, args.ctx.signal);
-  const putRes = await fetch(putUrl, {
-    method: "PUT",
-    body: new Uint8Array(args.bytes),
-    headers: { "Content-Type": args.mime },
-    signal: args.ctx.signal
-  });
-  if (!putRes.ok) {
-    throw new Error(`upload: presigned PUT failed ${putRes.status} ${putRes.statusText}`);
-  }
-  return publicUrl;
-}
-async function ensureUploaded(ref, ctx) {
-  if (ref.url) return ref;
-  const bytes = await ctx.assets.readBytes(ref.sha256, ref.mime);
-  const url = await presignAndPut({ bytes, sha256: ref.sha256, mime: ref.mime, ctx });
-  return { ...ref, url };
-}
-
 // src/engine/nodes/remote/delegate.ts
 function delegated(spec) {
   return {
@@ -3357,7 +3633,9 @@ async function callBackendExec(args) {
         nodeVersion: args.nodeVersion,
         params: args.params,
         inputs: serialized,
-        idempotency_key: idempotencyKey
+        idempotency_key: idempotencyKey,
+        canvas_run_id: args.ctx.canvasRunId,
+        node_id: args.ctx.nodeId
       },
       args.ctx.signal
     );
@@ -3409,6 +3687,9 @@ async function ingestValue(value, ctx, declaredKind) {
   }
   if (isRawAsset(value)) {
     const kind = value.kind ?? declaredKind ?? "json";
+    if (ctx.downloadOutputs === false) {
+      return buildRef({ kind, sha: value.sha256, mime: value.mime, url: value.url, metadata: value.metadata });
+    }
     return ctx.assets.ingestRemote({
       kind,
       url: value.url,
@@ -3523,7 +3804,7 @@ function safePathname(rawUrl) {
 }
 var ingestNode = defineNode({
   id: "ingest",
-  version: "1.1.0",
+  version: "1.2.0",
   category: "io",
   location: "local",
   summary: "Ingest an external URL or a local file into the asset store. Declare the kind you expect (image/video/audio/text/json/font); the node picks the strategy. For source=url: yt-dlp for video/audio (YouTube/TikTok/Vimeo/etc. and direct file URLs), Handinger for HTML/PDF pages \u2192 markdown, direct HTTP fetch for binary URLs (images, fonts) and raw .txt/.md. For source=path: read from the local filesystem and upload to R2.",
@@ -3566,6 +3847,9 @@ function runStrategy(strategy, params, ctx) {
   }
 }
 async function execDirectFetch(params, ctx) {
+  if (params.expect === "image") {
+    return ingestImageUrl(params.url, ctx);
+  }
   const result = await callBackendExec({
     nodeType: "ingest",
     nodeVersion: ingestNode.version,
@@ -3576,6 +3860,37 @@ async function execDirectFetch(params, ctx) {
   });
   return assertAssetOutput(result, params.expect);
 }
+async function ingestImageUrl(url, ctx) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw localExecError(ctx, `fetch ${url} \u2192 ${res.status}`);
+  }
+  const ab = await res.arrayBuffer();
+  if (ab.byteLength > MAX_ASSET_BYTES) {
+    throw localExecError(ctx, `file_too_large: ${url} is ${ab.byteLength} bytes (limit ${MAX_ASSET_BYTES})`);
+  }
+  let normalized;
+  try {
+    normalized = await toModelSafeImage(Buffer.from(ab));
+  } catch (e) {
+    throw localExecError(ctx, `${url}: ${e.message}`);
+  }
+  if (normalized.rasterizedFrom) {
+    ctx.log(`ingest: normalized ${normalized.rasterizedFrom} URL -> PNG (${normalized.bytes.length}B)`);
+  }
+  return uploadAndIngest({
+    bytes: normalized.bytes,
+    kind: "image",
+    mime: normalized.mime,
+    metadata: {
+      source_url: url,
+      strategy: "direct_fetch",
+      ingested_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ...normalized.rasterizedFrom ? { rasterized_from: normalized.rasterizedFrom } : {}
+    },
+    ctx
+  });
+}
 async function execHandinger(params, ctx) {
   const result = await callBackendExec({
     nodeType: "ingest",
@@ -3612,7 +3927,15 @@ var EXT_TO_MIME = {
   jpeg: "image/jpeg",
   webp: "image/webp",
   gif: "image/gif",
+  // Non-model-safe rasters `toModelSafeImage` transcodes to PNG at ingest — they
+  // must resolve to an image mime here or the kind-check rejects the local file
+  // before normalization ever runs.
   avif: "image/avif",
+  heic: "image/heic",
+  heif: "image/heif",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  bmp: "image/bmp",
   mp4: "video/mp4",
   webm: "video/webm",
   mov: "video/quicktime",
@@ -3663,15 +3986,45 @@ async function rasterizeSvgToPng(bytes) {
   }
   return await sharp(bytes, { density }).png({ force: true, palette: false }).toBuffer();
 }
+var MODEL_SAFE_IMAGE_MIMES = /* @__PURE__ */ new Set(["image/jpeg", "image/png", "image/gif", "image/webp"]);
+async function toModelSafeImage(bytes) {
+  const safe = sniffImageMime(bytes);
+  if (safe && MODEL_SAFE_IMAGE_MIMES.has(safe)) {
+    return { bytes, mime: safe };
+  }
+  if (sniffSvg(bytes)) {
+    return { bytes: await rasterizeSvgToPng(bytes), mime: "image/png", rasterizedFrom: "svg" };
+  }
+  const { default: sharp } = await import("sharp");
+  try {
+    const img = sharp(bytes);
+    const format = (await img.metadata()).format;
+    const png = await img.png({ force: true }).toBuffer();
+    return { bytes: png, mime: "image/png", rasterizedFrom: format ?? "unknown" };
+  } catch (e) {
+    throw new Error(`bytes are not a decodable image (${e.message})`);
+  }
+}
+function hasAscii(buf, offset, sig) {
+  return buf.length >= offset + sig.length && buf.toString("ascii", offset, offset + sig.length) === sig;
+}
+var HEIC_BRANDS = /* @__PURE__ */ new Set(["heic", "heix", "heim", "heis", "hevc", "hevx", "mif1", "msf1", "heif"]);
+function sniffIsoBmff(buf) {
+  if (!hasAscii(buf, 4, "ftyp")) return null;
+  const brand = buf.subarray(8, 12).toString("ascii");
+  if (brand === "avif" || brand === "avis") return "image/avif";
+  if (HEIC_BRANDS.has(brand)) return "image/heic";
+  return null;
+}
 function sniffImageMime(buf) {
   if (buf.length < 4) return null;
-  if (buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) return "image/png";
+  if (buf[0] === 137 && hasAscii(buf, 1, "PNG")) return "image/png";
   if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "image/jpeg";
-  if (buf[0] === 71 && buf[1] === 73 && buf[2] === 70) return "image/gif";
-  if (buf.length >= 12 && buf[0] === 82 && buf[1] === 73 && buf[2] === 70 && buf[3] === 70 && buf[8] === 87 && buf[9] === 69 && buf[10] === 66 && buf[11] === 80) {
-    return "image/webp";
-  }
-  return null;
+  if (hasAscii(buf, 0, "GIF")) return "image/gif";
+  if (hasAscii(buf, 0, "RIFF") && hasAscii(buf, 8, "WEBP")) return "image/webp";
+  if (hasAscii(buf, 0, "II*\0") || hasAscii(buf, 0, "MM\0*")) return "image/tiff";
+  if (hasAscii(buf, 0, "BM")) return "image/bmp";
+  return sniffIsoBmff(buf);
 }
 function findBoxPayload(buf, start, end, type) {
   let offset = start;
@@ -3724,10 +4077,10 @@ function inferKindFromMime(mime) {
   if (mime.startsWith("font/")) return "font";
   return null;
 }
-function localExecError(ctx, message) {
+function localExecError(ctx, message2) {
   return new NodeExecutionError(ctx.nodeId, ctx.nodeType, {
     kind: "local",
-    cause: new Error(`ingest: ${message}`)
+    cause: new Error(`ingest: ${message2}`)
   });
 }
 async function execLocalFile(params, ctx) {
@@ -3774,17 +4127,20 @@ async function execLocalFile(params, ctx) {
   ctx.log(`ingest: local file ${stats.size}B mime=${mime}`);
   let outBytes = bytes;
   let outMime = mime;
-  if (mime === SVG_MIME) {
-    outBytes = await rasterizeSvgToPng(bytes);
-    outMime = "image/png";
-    ctx.log(`ingest: rasterized SVG -> PNG (${outBytes.length}B)`);
+  let rasterizedFrom;
+  if (kind === "image") {
+    const normalized = await toModelSafeImage(bytes);
+    outBytes = normalized.bytes;
+    outMime = normalized.mime;
+    rasterizedFrom = normalized.rasterizedFrom;
+    if (rasterizedFrom) ctx.log(`ingest: normalized ${rasterizedFrom} -> PNG (${outBytes.length}B)`);
   }
   const durationMs = probeVideoDurationMs(params.expect, outBytes, ctx);
   const ref = await uploadAndIngest({
     bytes: outBytes,
     kind: params.expect,
     mime: outMime,
-    metadata: localFileMetadata({ absPath, fileSize: stats.size, mime, durationMs }),
+    metadata: localFileMetadata({ absPath, fileSize: stats.size, mime, durationMs, rasterizedFrom }),
     ctx
   });
   return withProbedDuration(ref, durationMs);
@@ -3802,7 +4158,7 @@ function localFileMetadata(args) {
     ingested_at: (/* @__PURE__ */ new Date()).toISOString(),
     file_size: args.fileSize,
     original_filename: path3.basename(args.absPath),
-    ...args.mime === SVG_MIME ? { rasterized_from: "svg" } : {},
+    ...args.rasterizedFrom ? { rasterized_from: args.rasterizedFrom } : {},
     ...args.durationMs !== void 0 ? { duration_ms: args.durationMs } : {}
   };
 }
@@ -4329,19 +4685,56 @@ var audioTimelineNode = defineNode({
   }
 });
 
-// src/engine/nodes/local/ffmpeg.ts
+// src/engine/nodes/local/collect.ts
 import { z as z7 } from "zod";
+var collectNode = defineNode({
+  id: "collect",
+  version: "1.0.0",
+  category: "data",
+  location: "local",
+  passthroughRefs: true,
+  summary: "Gather images from multiple upstream nodes into one ordered array \u2014 the standard terminal for multi-variant canvases whose final output is several images.",
+  when_to_use: "Point the canvas `output` at this node when several independent branches (e.g. one image_generate per scene/variant) must ALL be finals. Wire `inputs.images` as an array of refs like `$ref:gen_billboard_03.images#0` \u2014 each final inherits its producer node id as its label (or set `params.labels` to override), so variants stay identifiable in the dashboard and selection.",
+  inputs: z7.object({ images: z7.array(ImageRef).min(1) }).strict(),
+  params: z7.object({ labels: z7.array(z7.string().min(1)).min(1).optional() }).strict(),
+  outputs: z7.object({ images: z7.array(ImageRef).min(1) }).strict(),
+  outputKinds: { images: "image" },
+  cost: () => ({ credits: 0, seconds_estimate: 0 }),
+  // Arity is only knowable at validate time when `images` is a literal array;
+  // a single `$ref:` string to an upstream array output defers to runtime.
+  validateExtra: ({ rawParams, rawInputs }) => {
+    const labels = rawParams?.labels;
+    if (!Array.isArray(labels)) return [];
+    if (new Set(labels).size !== labels.length) {
+      return [{ path: "params.labels", message: "labels must be unique \u2014 each names one output variant" }];
+    }
+    const images = rawInputs?.images;
+    if (Array.isArray(images) && labels.length !== images.length) {
+      return [
+        {
+          path: "params.labels",
+          message: `labels has ${labels.length} entries but ${images.length} images are wired \u2014 provide one label per image`
+        }
+      ];
+    }
+    return [];
+  },
+  execute: ({ inputs }) => Promise.resolve({ images: inputs.images })
+});
+
+// src/engine/nodes/local/ffmpeg.ts
+import { z as z8 } from "zod";
 var FFMPEG_BIN2 = "ffmpeg";
-var OutputDecl = z7.object({
-  kind: z7.enum(["image", "video", "audio"]),
-  ext: z7.string().min(1).max(8)
+var OutputDecl = z8.object({
+  kind: z8.enum(["image", "video", "audio"]),
+  ext: z8.string().min(1).max(8)
 }).strict();
-var FfmpegParams = z7.object({
-  args: z7.array(z7.string()).min(1),
-  outputs: z7.record(z7.string(), OutputDecl).default({})
+var FfmpegParams = z8.object({
+  args: z8.array(z8.string()).min(1),
+  outputs: z8.record(z8.string(), OutputDecl).default({})
 }).strict();
-var FfmpegInputs = z7.record(z7.string(), z7.unknown());
-var FfmpegOutputs = z7.record(z7.string(), z7.custom());
+var FfmpegInputs = z8.record(z8.string(), z8.unknown());
+var FfmpegOutputs = z8.record(z8.string(), z8.custom());
 var ffmpegNode = defineNode({
   id: "ffmpeg",
   version: "2.0.0",
@@ -4372,7 +4765,7 @@ import { mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile3 } from "fs/prom
 import { createRequire } from "module";
 import { tmpdir as tmpdir3 } from "os";
 import path6 from "path";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/engine/nodes/local/lib/assets.ts
 import { copyFile as copyFile3, readFile as readFile4 } from "fs/promises";
@@ -4394,7 +4787,7 @@ async function refToUrl(ref) {
   return `data:${ref.mime};base64,${bytes.toString("base64")}`;
 }
 var ASSET_KINDS = /* @__PURE__ */ new Set(["image", "video", "audio", "json", "text", "font"]);
-function isAssetRefLike(value) {
+function isAssetRefLike2(value) {
   if (!value || typeof value !== "object") return false;
   const v = value;
   return typeof v.kind === "string" && ASSET_KINDS.has(v.kind) && typeof v.mime === "string" && typeof v.sha256 === "string" && (typeof v.url === "string" || typeof v.path === "string");
@@ -4408,15 +4801,15 @@ var DEFAULT_SPECIMEN = [
   "abcdefghijklmnopqrstuvwxyz",
   `0123456789 !?&@#$%().,:;'"-`
 ].join("\n");
-var FontSpecimenParams = z8.object({
-  text: z8.string().min(1).max(2e3).optional().default(DEFAULT_SPECIMEN),
-  font_size: z8.number().int().min(8).max(512).optional().default(72),
-  padding: z8.number().int().min(0).max(512).optional().default(64),
-  line_height: z8.number().min(0.8).max(3).optional().default(1.35),
-  max_width: z8.number().int().min(256).max(4096).optional()
+var FontSpecimenParams = z9.object({
+  text: z9.string().min(1).max(2e3).optional().default(DEFAULT_SPECIMEN),
+  font_size: z9.number().int().min(8).max(512).optional().default(72),
+  padding: z9.number().int().min(0).max(512).optional().default(64),
+  line_height: z9.number().min(0.8).max(3).optional().default(1.35),
+  max_width: z9.number().int().min(256).max(4096).optional()
 }).strict();
-var FontSpecimenInputs = z8.object({ font: FontRef }).loose();
-var FontSpecimenOutputs = z8.object({ image: ImageRef }).strict();
+var FontSpecimenInputs = z9.object({ font: FontRef }).loose();
+var FontSpecimenOutputs = z9.object({ image: ImageRef }).strict();
 var DEVICE_SCALE_FACTOR = 2;
 var PAGE_TIMEOUT_MS = 3e4;
 function escapeHtml(text) {
@@ -4557,7 +4950,7 @@ import { createRequire as createRequire2 } from "module";
 import { cpus, tmpdir as tmpdir4 } from "os";
 import path11 from "path";
 import { promisify as promisify4 } from "util";
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/engine/engine/composition-hash.ts
 import { readdir as readdir2, readFile as readFile5, stat as stat4 } from "fs/promises";
@@ -4595,62 +4988,62 @@ async function collectFiles(root, current) {
 // src/engine/engine/composition-meta.ts
 import { readFile as readFile6 } from "fs/promises";
 import path8 from "path";
-import { z as z9 } from "zod";
-var InputKind = z9.enum(["video", "image", "audio", "json"]);
-var InputSpec = z9.object({
+import { z as z10 } from "zod";
+var InputKind = z10.enum(["video", "image", "audio", "json"]);
+var InputSpec = z10.object({
   kind: InputKind,
-  required: z9.boolean().optional().default(false),
+  required: z10.boolean().optional().default(false),
   // Filename the composition's HTML references (e.g. `input.mp4`, `logo.png`).
   // Defaults to `<key><ext>` derived from the kind.
-  staged_as: z9.string().min(1).optional(),
-  description: z9.string().optional()
+  staged_as: z10.string().min(1).optional(),
+  description: z10.string().optional()
 }).strict();
 var ParamSpecBase = {
-  required: z9.boolean().optional().default(false),
-  description: z9.string().optional()
+  required: z10.boolean().optional().default(false),
+  description: z10.string().optional()
 };
-var StringParam = z9.object({
+var StringParam = z10.object({
   ...ParamSpecBase,
-  kind: z9.literal("string"),
-  default: z9.string().optional(),
-  enum: z9.array(z9.string()).optional()
+  kind: z10.literal("string"),
+  default: z10.string().optional(),
+  enum: z10.array(z10.string()).optional()
 }).strict();
-var IntegerParam = z9.object({
+var IntegerParam = z10.object({
   ...ParamSpecBase,
-  kind: z9.literal("integer"),
-  default: z9.number().int().optional(),
-  min: z9.number().int().optional(),
-  max: z9.number().int().optional()
+  kind: z10.literal("integer"),
+  default: z10.number().int().optional(),
+  min: z10.number().int().optional(),
+  max: z10.number().int().optional()
 }).strict();
-var NumberParam = z9.object({
+var NumberParam = z10.object({
   ...ParamSpecBase,
-  kind: z9.literal("number"),
-  default: z9.number().optional(),
-  min: z9.number().optional(),
-  max: z9.number().optional()
+  kind: z10.literal("number"),
+  default: z10.number().optional(),
+  min: z10.number().optional(),
+  max: z10.number().optional()
 }).strict();
-var BooleanParam = z9.object({
+var BooleanParam = z10.object({
   ...ParamSpecBase,
-  kind: z9.literal("boolean"),
-  default: z9.boolean().optional()
+  kind: z10.literal("boolean"),
+  default: z10.boolean().optional()
 }).strict();
-var ColorParam = z9.object({
+var ColorParam = z10.object({
   ...ParamSpecBase,
-  kind: z9.literal("color"),
-  default: z9.string().optional()
+  kind: z10.literal("color"),
+  default: z10.string().optional()
 }).strict();
-var ImageParam = z9.object({
+var ImageParam = z10.object({
   ...ParamSpecBase,
-  kind: z9.literal("image"),
-  default: z9.string().optional()
+  kind: z10.literal("image"),
+  default: z10.string().optional()
 }).strict();
-var JsonParam = z9.object({
+var JsonParam = z10.object({
   ...ParamSpecBase,
-  kind: z9.literal("json"),
-  schema: z9.unknown().optional(),
-  default: z9.unknown().optional()
+  kind: z10.literal("json"),
+  schema: z10.unknown().optional(),
+  default: z10.unknown().optional()
 }).strict();
-var ParamSpec = z9.discriminatedUnion("kind", [
+var ParamSpec = z10.discriminatedUnion("kind", [
   StringParam,
   IntegerParam,
   NumberParam,
@@ -4659,16 +5052,16 @@ var ParamSpec = z9.discriminatedUnion("kind", [
   ImageParam,
   JsonParam
 ]);
-var CompositionMetaSchema = z9.object({
-  id: z9.string().min(1),
-  title: z9.string().min(1),
-  description: z9.string().optional(),
-  width: z9.number().int().positive(),
-  height: z9.number().int().positive(),
-  fps: z9.number().int().positive().default(30),
-  default_duration: z9.number().positive().default(10),
-  inputs: z9.record(z9.string(), InputSpec).default({}),
-  params: z9.record(z9.string(), ParamSpec).default({})
+var CompositionMetaSchema = z10.object({
+  id: z10.string().min(1),
+  title: z10.string().min(1),
+  description: z10.string().optional(),
+  width: z10.number().int().positive(),
+  height: z10.number().int().positive(),
+  fps: z10.number().int().positive().default(30),
+  default_duration: z10.number().positive().default(10),
+  inputs: z10.record(z10.string(), InputSpec).default({}),
+  params: z10.record(z10.string(), ParamSpec).default({})
 }).strict();
 async function loadCompositionMeta(compositionDir) {
   const metaPath = path8.join(compositionDir, "meta.json");
@@ -4696,39 +5089,39 @@ function buildParamsSchema(meta) {
   for (const [name, spec] of Object.entries(meta.params)) {
     shape[name] = buildParamFieldSchema(name, spec);
   }
-  return z9.object(shape).strict();
+  return z10.object(shape).strict();
 }
 function buildParamFieldSchema(name, spec) {
   switch (spec.kind) {
     case "string": {
-      const s = spec.enum && spec.enum.length > 0 ? z9.enum(spec.enum) : z9.string();
+      const s = spec.enum && spec.enum.length > 0 ? z10.enum(spec.enum) : z10.string();
       return finalize(s, spec.default, spec.required);
     }
     case "integer": {
-      let s = z9.number().int();
+      let s = z10.number().int();
       if (spec.min !== void 0) s = s.min(spec.min);
       if (spec.max !== void 0) s = s.max(spec.max);
       return finalize(s, spec.default, spec.required);
     }
     case "number": {
-      let s = z9.number();
+      let s = z10.number();
       if (spec.min !== void 0) s = s.min(spec.min);
       if (spec.max !== void 0) s = s.max(spec.max);
       return finalize(s, spec.default, spec.required);
     }
     case "boolean":
-      return finalize(z9.boolean(), spec.default, spec.required);
+      return finalize(z10.boolean(), spec.default, spec.required);
     case "color": {
-      const s = z9.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
+      const s = z10.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/, {
         message: `param "${name}": must be a 3/6/8-digit hex color (e.g. "#ff0066")`
       });
       return finalize(s, spec.default, spec.required);
     }
     case "image":
-      return finalize(z9.union([z9.string().min(1), z9.record(z9.string(), z9.unknown())]), spec.default, spec.required);
+      return finalize(z10.union([z10.string().min(1), z10.record(z10.string(), z10.unknown())]), spec.default, spec.required);
     case "json":
       return finalize(
-        z9.unknown().refine((v) => v !== void 0, { message: `param "${name}" is required` }),
+        z10.unknown().refine((v) => v !== void 0, { message: `param "${name}" is required` }),
         spec.default,
         spec.required
       );
@@ -4766,8 +5159,8 @@ var NEVER_BLOCK = [
   /text[_-]?occluded/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}`;
+function isAdvisory(code, message2) {
+  const hay = `${code} ${message2}`;
   return NEVER_BLOCK.some((re) => re.test(hay));
 }
 function parseCheckJson(raw) {
@@ -4795,10 +5188,10 @@ function classifyLint(json) {
   for (const f of findings) {
     const rec = f;
     const code = String(rec?.code ?? "");
-    const message = String(rec?.message ?? "");
+    const message2 = 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" });
+    const blocking = severity === "error" && !isAdvisory(code, message2);
+    out.push({ source: "lint", code, message: message2, severity: blocking ? "blocking" : "warning" });
   }
   return out;
 }
@@ -4810,9 +5203,9 @@ function classifyInspect(json) {
   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 message2 = 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" });
+    out.push({ source: "inspect", code, message: message2, severity: severity === "error" ? "blocking" : "warning" });
   }
   return out;
 }
@@ -5028,17 +5421,17 @@ function literalize(value) {
 // src/engine/nodes/local/hyperframe.ts
 var execFileAsync2 = promisify4(execFile4);
 var require_2 = createRequire2(import.meta.url);
-var HyperframeParams = z10.object({
-  composition: z10.string().min(1),
+var HyperframeParams = z11.object({
+  composition: z11.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()
+  format: z11.enum(["mp4", "webm", "mov"]).optional().default("mp4"),
+  timeout_ms: z11.number().int().positive().optional().default(10 * 60 * 1e3)
+}).catchall(z11.unknown());
+var HyperframeInputs = z11.record(z11.string(), z11.custom()).optional().default({});
+var HyperframeOutputs = z11.object({
+  video: z11.custom()
 }).strict();
 var NODE_OWNED_PARAM_KEYS = /* @__PURE__ */ new Set(["composition", "format", "timeout_ms"]);
 var MIME_BY_FORMAT = {
@@ -5257,7 +5650,7 @@ async function buildSubstitutionValues(compositionParams, meta, duration) {
 }
 function coerceImageParam(value) {
   if (typeof value === "string") return Promise.resolve(value);
-  if (isAssetRefLike(value)) return refToUrl(value);
+  if (isAssetRefLike2(value)) return refToUrl(value);
   throw new Error("hyperframe_render: image param must be a URL string or AssetRef");
 }
 async function substituteCompositionFiles(tmp, values) {
@@ -5327,23 +5720,23 @@ import { createRequire as createRequire3 } from "module";
 import { tmpdir as tmpdir5 } from "os";
 import path12 from "path";
 import { promisify as promisify5 } from "util";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var _execFileAsync = promisify5(execFile5);
 var require_3 = createRequire3(import.meta.url);
-var WaitForSpec = z11.discriminatedUnion("kind", [
-  z11.object({ kind: z11.literal("auto") }),
-  z11.object({ kind: z11.literal("selector"), value: z11.string().min(1) }),
-  z11.object({ kind: z11.literal("function"), value: z11.string().min(1) }),
-  z11.object({ kind: z11.literal("timeout"), ms: z11.number().int().min(0).max(6e4) })
+var WaitForSpec = z12.discriminatedUnion("kind", [
+  z12.object({ kind: z12.literal("auto") }),
+  z12.object({ kind: z12.literal("selector"), value: z12.string().min(1) }),
+  z12.object({ kind: z12.literal("function"), value: z12.string().min(1) }),
+  z12.object({ kind: z12.literal("timeout"), ms: z12.number().int().min(0).max(6e4) })
 ]);
-var HyperframeSnapshotParams = z11.object({
-  composition: z11.string().min(1),
+var HyperframeSnapshotParams = z12.object({
+  composition: z12.string().min(1),
   wait_for: WaitForSpec.optional().default({ kind: "auto" }),
-  timeout_ms: z11.number().int().positive().optional().default(6e4)
-}).catchall(z11.unknown());
-var HyperframeSnapshotInputs = z11.record(z11.string(), z11.custom()).optional().default({});
-var HyperframeSnapshotOutputs = z11.object({
-  image: z11.custom()
+  timeout_ms: z12.number().int().positive().optional().default(6e4)
+}).catchall(z12.unknown());
+var HyperframeSnapshotInputs = z12.record(z12.string(), z12.custom()).optional().default({});
+var HyperframeSnapshotOutputs = z12.object({
+  image: z12.custom()
 }).strict();
 var NODE_OWNED_PARAM_KEYS2 = /* @__PURE__ */ new Set(["composition", "wait_for", "timeout_ms"]);
 var DEVICE_SCALE_FACTOR2 = 2;
@@ -5487,7 +5880,7 @@ async function buildSubstitutionValues2(compositionParams, meta) {
 }
 function coerceImageParam2(value) {
   if (typeof value === "string") return Promise.resolve(value);
-  if (isAssetRefLike(value)) return refToUrl(value);
+  if (isAssetRefLike2(value)) return refToUrl(value);
   throw new Error("hyperframe_snapshot: image param must be a URL string or AssetRef");
 }
 async function substituteCompositionFiles2(tmp, values) {
@@ -5535,18 +5928,18 @@ async function waitForReady(page, waitFor, timeoutMs) {
 // src/engine/nodes/local/imagemagick.ts
 import { execFile as execFile6 } from "child_process";
 import { promisify as promisify6 } from "util";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 var execFileAsync3 = promisify6(execFile6);
-var OutputDecl2 = z12.object({
-  kind: z12.enum(["image", "video", "audio"]),
-  ext: z12.string().min(1).max(8)
+var OutputDecl2 = z13.object({
+  kind: z13.enum(["image", "video", "audio"]),
+  ext: z13.string().min(1).max(8)
 }).strict();
-var ImageMagickParams = z12.object({
-  args: z12.array(z12.string()).min(1),
-  outputs: z12.record(z12.string(), OutputDecl2).default({})
+var ImageMagickParams = z13.object({
+  args: z13.array(z13.string()).min(1),
+  outputs: z13.record(z13.string(), OutputDecl2).default({})
 }).strict();
-var ImageMagickInputs = z12.record(z12.string(), z12.unknown());
-var ImageMagickOutputs = z12.record(z12.string(), z12.custom());
+var ImageMagickInputs = z13.record(z13.string(), z13.unknown());
+var ImageMagickOutputs = z13.record(z13.string(), z13.custom());
 var resolvedBin;
 async function resolveBin() {
   if (resolvedBin) return resolvedBin;
@@ -5588,29 +5981,29 @@ var imagemagickNode = defineNode({
 });
 
 // src/engine/nodes/local/text.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var textNode = defineNode({
   id: "text",
   version: "1.0.0",
   category: "data",
   location: "local",
   summary: "A literal text value. Use for prompts, descriptions, copy.",
-  inputs: z13.object({}).strict(),
-  params: z13.object({ value: z13.string() }).strict(),
-  outputs: z13.object({ text: z13.string() }).strict(),
+  inputs: z14.object({}).strict(),
+  params: z14.object({ value: z14.string() }).strict(),
+  outputs: z14.object({ text: z14.string() }).strict(),
   cost: () => ({ credits: 0, seconds_estimate: 0 }),
   execute: ({ params }) => Promise.resolve({ text: params.value })
 });
 
 // src/engine/nodes/remote/audioVoiceConvert.ts
-import { z as z14 } from "zod";
-var AudioVoiceConvertParams = z14.object({
-  model: z14.literal("elevenlabs/eleven_multilingual_sts_v2"),
+import { z as z15 } from "zod";
+var AudioVoiceConvertParams = z15.object({
+  model: z15.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(),
+  voice: z15.string().min(1),
+  output_format: z15.string().optional(),
   /** Strip the source clip's background noise before re-voicing. */
-  remove_background_noise: z14.boolean().optional()
+  remove_background_noise: z15.boolean().optional()
 }).strict();
 var audioVoiceConvertNode = delegated({
   id: "audio_voice_convert",
@@ -5618,44 +6011,44 @@ var audioVoiceConvertNode = delegated({
   category: "audio",
   summary: "Voice Changer / speech-to-speech via ElevenLabs (eleven_multilingual_sts_v2). Re-voices an existing audio clip in a TARGET voice while preserving timing/prosody.",
   when_to_use: 'Use to normalize a generator-chosen voice (e.g. a Seedance talking-head clip\'s native audio) into ONE consistent brand voice across every scene \u2014 the cadence is preserved so any lip-sync stays valid. Wire `inputs.voice_ref: $ref:<voice_select>.voice_id` and set `params.voice: "{{voice_ref}}"`.',
-  inputs: z14.object({
+  inputs: z15.object({
     audio: AudioRef,
     voice_ref: TextRef.optional()
   }).strict(),
   params: AudioVoiceConvertParams,
-  outputs: z14.object({ audio: AudioRef }).strict(),
+  outputs: z15.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)
+import { z as z16 } from "zod";
+var DialogueInput = z16.object({
+  text: z16.string().min(1),
+  voice_id: z16.string().min(1)
 });
 var DIALOGUE_MODELS = ["elevenlabs/eleven_v3"];
-var DialogueParams = z15.object({
-  model: z15.enum(DIALOGUE_MODELS),
+var DialogueParams = z16.object({
+  model: z16.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: z15.array(DialogueInput).min(1).max(50),
-  language_code: z15.string().optional(),
+  inputs: z16.array(DialogueInput).min(1).max(50),
+  language_code: z16.string().optional(),
   /** ElevenLabs voice/model settings passthrough (e.g. `{ stability: 0.5 }`). */
-  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(),
+  settings: z16.record(z16.string(), z16.unknown()).optional(),
+  seed: z16.number().int().min(0).max(4294967295).optional(),
+  apply_text_normalization: z16.enum(["auto", "on", "off"]).optional(),
   /**
    * 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: z15.boolean().optional(),
-  output_format: z15.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
+  with_timestamps: z16.boolean().optional(),
+  output_format: z16.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"]
@@ -5666,9 +6059,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: z15.object({}).loose(),
+  inputs: z16.object({}).loose(),
   params: DialogueParams,
-  outputs: z15.object({ audio: AudioRef, timestamps: JsonRef.optional() }).strict(),
+  outputs: z16.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);
@@ -5677,7 +6070,7 @@ var dialogueNode = delegated({
 });
 
 // src/engine/nodes/remote/image.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var IMAGE_GENERATE_MODELS2 = [
   "openai/gpt-5.4-image-2",
   "google/gemini-3.5-flash",
@@ -5685,16 +6078,16 @@ var IMAGE_GENERATE_MODELS2 = [
   "google/gemini-3-pro-image-preview",
   "recraft/recraft-v4.1-pro-vector"
 ];
-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(),
+var ImageGenerateParams = z17.object({
+  model: z17.enum(IMAGE_GENERATE_MODELS2),
+  prompt: z17.string().min(1),
+  aspect_ratio: z17.enum(["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "4:5", "5:4", "21:9", "1:4", "4:1", "1:8", "8:1"]).optional(),
+  image_size: z17.enum(["0.5K", "1K", "2K", "4K"]).optional(),
   // Recraft v4 vector controls — forwarded into `image_config`. Registry
   // rejects them on non-Recraft models.
-  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()
+  strength: z17.number().min(0).max(1).optional(),
+  rgb_colors: z17.array(z17.array(z17.number().int().min(0).max(255))).optional(),
+  background_rgb_color: z17.array(z17.number().int().min(0).max(255)).optional()
 }).strict();
 var imageGenerateNode = delegated({
   id: "image_generate",
@@ -5704,22 +6097,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: z16.object({ reference: z16.union([ImageRef, z16.array(ImageRef).min(1)]).optional() }).loose(),
+  inputs: z17.object({ reference: z17.union([ImageRef, z17.array(ImageRef).min(1)]).optional() }).loose(),
   params: ImageGenerateParams,
-  outputs: z16.object({ images: z16.array(ImageRef).min(1) }).strict(),
+  outputs: z17.object({ images: z17.array(ImageRef).min(1) }).strict(),
   outputKinds: { images: "image" },
   cost: () => ({ credits: 5, seconds_estimate: 10 })
 });
 
 // src/engine/nodes/remote/imageAspectAdapt.ts
-import { z as z17 } from "zod";
+import { z as z18 } 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 = 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()
+var ImageAspectAdaptParams = z18.object({
+  model: z18.enum(ASPECT_ADAPT_MODELS),
+  formats: z18.array(z18.enum(ASPECT_ADAPT_FORMATS)).min(1).max(6).refine((formats) => new Set(formats).size === formats.length, { message: "formats must be unique" }),
+  guidance: z18.string().min(1).optional(),
+  image_size: z18.enum(["0.5K", "1K", "2K", "4K"]).optional()
 }).strict();
 var imageAspectAdaptNode = delegated({
   id: "image_aspect_adapt",
@@ -5727,9 +6120,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: z17.object({ source: ImageRef }).loose(),
+  inputs: z18.object({ source: ImageRef }).loose(),
   params: ImageAspectAdaptParams,
-  outputs: z17.object({ images: z17.array(ImageRef).min(1) }).strict(),
+  outputs: z18.object({ images: z18.array(ImageRef).min(1) }).strict(),
   outputKinds: { images: "image" },
   cost: ({ params }) => {
     const p = params;
@@ -5742,12 +6135,12 @@ var imageAspectAdaptNode = delegated({
 });
 
 // src/engine/nodes/remote/imageBackgroundRemove.ts
-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)
+import { z as z19 } from "zod";
+var ImageBackgroundRemoveParams = z19.object({
+  model: z19.literal("fal/birefnet-v2").optional().default("fal/birefnet-v2"),
+  model_variant: z19.enum(["General Use (Light)", "General Use (Heavy)", "Matting", "Portrait", "DIS", "HRSOD", "COD"]).optional().default("General Use (Light)"),
+  operating_resolution: z19.enum(["1024x1024", "2048x2048", "2304x2304"]).optional(),
+  mask_only: z19.boolean().optional().default(false)
 }).strict();
 var imageBackgroundRemoveNode = delegated({
   id: "image_background_remove",
@@ -5755,11 +6148,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: z18.object({
+  inputs: z19.object({
     image: ImageRef
   }).strict(),
   params: ImageBackgroundRemoveParams,
-  outputs: z18.object({
+  outputs: z19.object({
     image: ImageRef,
     mask: ImageRef.optional()
   }).strict(),
@@ -5768,7 +6161,7 @@ var imageBackgroundRemoveNode = delegated({
 });
 
 // src/engine/nodes/remote/imageDescribe.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var IMAGE_DESCRIBE_MODELS = ["~google/gemini-pro-latest", "~google/gemini-flash-latest"];
 var imageDescribeNode = delegated({
   id: "image_describe",
@@ -5776,33 +6169,33 @@ var imageDescribeNode = delegated({
   category: "vision",
   summary: "Reverse-engineer an image into an exhaustive, replication-grade JSON description: who the advertiser is and what they sell (source_context), composition, non-person subjects with expression/treatment, deeply detailed people, brand-identified logos (named by brand, not appearance), camera optics, lighting, color palette WITH per-color brand-ownership (brand vs borrowed-functional) and purpose, materials, visible text, ad signals (proof badges/CTA/price), the persuasion engine (ad_intent), style, post-processing.",
   when_to_use: 'Use to turn a reference image into a structured blueprint you can inject into downstream prompts via `{{slot}}` \u2014 e.g. restyle a competitor ad onto your own product, lock a look across a series, or feed exact palette/lighting into image_generate. Purpose-built for market adaptation: logos are identified by brand ("Trustpilot", never "green star"), people and animals carry expression/emotion/intent detail, and each color is tagged brand vs borrowed-functional so a recolor can keep the reds/yellows that do a job. The extraction prompt is baked in; use `focus` to emphasise aspects and `context` to pass known provenance (advertiser, category, market) so source_context and color ownership are grounded. Pick `~google/gemini-pro-latest` for the densest extraction (recommended for ad / market-adaptation passes), `~google/gemini-flash-latest` for cheap/fast passes. The output is rich \u2014 raise `max_tokens` (e.g. 8000+) for dense ads so the JSON isn\'t truncated.',
-  inputs: 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()
+  inputs: z20.object({ image: ImageRef }).loose(),
+  params: z20.object({
+    model: z20.enum(IMAGE_DESCRIBE_MODELS),
+    focus: z20.string().optional(),
+    context: z20.string().optional(),
+    temperature: z20.number().min(0).max(2).optional(),
+    max_tokens: z20.number().int().positive().optional()
   }).strict(),
-  outputs: z19.object({ description: JsonRef }).strict(),
+  outputs: z20.object({ description: JsonRef }).strict(),
   outputKinds: { description: "json" },
   cost: () => ({ credits: 2, seconds_estimate: 10 })
 });
 
 // src/engine/nodes/remote/imageReferenceSheet.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 var REFERENCE_SHEET_MODELS = ["google/gemini-3-pro-image-preview", "google/gemini-3.1-flash-image-preview"];
-var ImageReferenceSheetParams = z20.object({
-  model: z20.enum(REFERENCE_SHEET_MODELS),
-  subject_description: z20.string().min(1),
+var ImageReferenceSheetParams = z21.object({
+  model: z21.enum(REFERENCE_SHEET_MODELS),
+  subject_description: z21.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: z20.enum(["character", "person", "product", "location"]),
-  views: z20.array(z20.string().min(1)).min(2).max(8).optional(),
-  style: z20.string().optional(),
-  prompt_override: z20.string().min(1).optional(),
-  aspect_ratio: z20.enum(["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "4:5", "5:4", "21:9", "1:4", "4:1", "1:8", "8:1"]).optional(),
-  image_size: z20.enum(["0.5K", "1K", "2K", "4K"]).optional()
+  subject_type: z21.enum(["character", "person", "product", "location"]),
+  views: z21.array(z21.string().min(1)).min(2).max(8).optional(),
+  style: z21.string().optional(),
+  prompt_override: z21.string().min(1).optional(),
+  aspect_ratio: z21.enum(["1:1", "16:9", "9:16", "4:3", "3:4", "3:2", "2:3", "4:5", "5:4", "21:9", "1:4", "4:1", "1:8", "8:1"]).optional(),
+  image_size: z21.enum(["0.5K", "1K", "2K", "4K"]).optional()
 }).strict();
 var imageReferenceSheetNode = delegated({
   id: "image_reference_sheet",
@@ -5810,9 +6203,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: z20.object({ references: z20.array(ImageRef).min(1).max(6) }).loose(),
+  inputs: z21.object({ references: z21.array(ImageRef).min(1).max(6) }).loose(),
   params: ImageReferenceSheetParams,
-  outputs: z20.object({ sheet: ImageRef }).strict(),
+  outputs: z21.object({ sheet: ImageRef }).strict(),
   outputKinds: { sheet: "image" },
   cost: ({ params }) => ({
     credits: params?.model === "google/gemini-3-pro-image-preview" ? 20 : 5,
@@ -5821,10 +6214,10 @@ var imageReferenceSheetNode = delegated({
 });
 
 // src/engine/nodes/remote/imageSearch.ts
-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)
+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)
 }).strict();
 var imageSearchNode = delegated({
   id: "image_search",
@@ -5832,15 +6225,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: z21.object({}).loose(),
+  inputs: z22.object({}).loose(),
   params: ImageSearchParams,
-  outputs: z21.object({ images: z21.array(ImageRef).min(1) }).strict(),
+  outputs: z22.object({ images: z22.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 z22 } from "zod";
+import { z as z23 } from "zod";
 var IMAGE_SELECT_MODELS = ["~google/gemini-flash-latest", "~google/gemini-pro-latest"];
 var imageSelectNode = delegated({
   id: "image_select",
@@ -5848,15 +6241,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: 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()
+  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()
   }).strict(),
-  outputs: z22.object({ images: z22.array(ImageRef).min(1), reasoning: TextRef }).strict(),
+  outputs: z23.object({ images: z23.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
@@ -5881,34 +6274,34 @@ var imageSelectNode = delegated({
 });
 
 // src/engine/nodes/remote/music.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 var MUSIC_MODELS = ["elevenlabs/music-v1", "elevenlabs/video-background-music-v1"];
-var MusicParams = z23.object({
-  model: z23.enum(MUSIC_MODELS),
+var MusicParams = z24.object({
+  model: z24.enum(MUSIC_MODELS),
   /** Free-form prompt. Used by `elevenlabs/music-v1` (compose-detailed). */
-  prompt: z23.string().optional(),
+  prompt: z24.string().optional(),
   /**
    * Structured composition plan (intro / hook / verse / outro sections with
    * per-section styles + durations). Mutually exclusive with `prompt`.
    */
-  composition_plan: z23.record(z23.string(), z23.unknown()).optional(),
+  composition_plan: z24.record(z24.string(), z24.unknown()).optional(),
   /** Target length when using `prompt`. 3000–454545ms (capped by the $10 per-node cost limit). */
-  music_length_ms: z23.number().int().min(3e3).max(ELEVENLABS_MAX_MUSIC_LENGTH_MS).optional(),
-  seed: z23.number().int().optional(),
+  music_length_ms: z24.number().int().min(3e3).max(ELEVENLABS_MAX_MUSIC_LENGTH_MS).optional(),
+  seed: z24.number().int().optional(),
   /** Prompt mode only — forces an instrumental (no vocals) track. */
-  force_instrumental: z23.boolean().optional(),
+  force_instrumental: z24.boolean().optional(),
   /** composition_plan only — honor exact section durations. */
-  respect_sections_durations: z23.boolean().optional(),
+  respect_sections_durations: z24.boolean().optional(),
   /** Emit word-level timestamps alongside the audio. */
-  with_timestamps: z23.boolean().optional(),
+  with_timestamps: z24.boolean().optional(),
   /**
    * video-to-music only — short description of the desired score
    * ("upbeat synth, fast cuts, 80s") used to bias the model.
    */
-  description: z23.string().max(1e3).optional(),
+  description: z24.string().max(1e3).optional(),
   /** video-to-music only — up to 10 style tags. */
-  tags: z23.array(z23.string()).max(10).optional(),
-  output_format: z23.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
+  tags: z24.array(z24.string()).max(10).optional(),
+  output_format: z24.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
 }).strict();
 var musicNode = delegated({
   id: "music",
@@ -5916,9 +6309,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: z23.object({ video: VideoRef.optional() }).loose(),
+  inputs: z24.object({ video: VideoRef.optional() }).loose(),
   params: MusicParams,
-  outputs: z23.object({ audio: AudioRef, timestamps: JsonRef.optional() }).strict(),
+  outputs: z24.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;
@@ -5949,25 +6342,25 @@ var musicNode = delegated({
 });
 
 // src/engine/nodes/remote/soundEffect.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var SOUND_EFFECT_MODELS = ["elevenlabs/eleven_text_to_sound_v2"];
-var SoundEffectParams = z24.object({
-  model: z24.enum(SOUND_EFFECT_MODELS),
+var SoundEffectParams = z25.object({
+  model: z25.enum(SOUND_EFFECT_MODELS),
   /** Prompt describing the SFX ("metal door slam", "soft UI tap", "ocean waves"). */
-  text: z24.string().min(1),
+  text: z25.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: z24.number().min(0.5).max(30).optional(),
+  duration_seconds: z25.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: z24.number().min(0).max(1).optional(),
+  prompt_influence: z25.number().min(0).max(1).optional(),
   /** Only valid on `eleven_text_to_sound_v2` — produce a seamless loop. */
-  loop: z24.boolean().optional(),
-  output_format: z24.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
+  loop: z25.boolean().optional(),
+  output_format: z25.enum(ELEVENLABS_OUTPUT_FORMATS).optional()
 }).strict();
 var soundEffectNode = delegated({
   id: "sound_effect",
@@ -5975,9 +6368,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: z24.object({}).loose(),
+  inputs: z25.object({}).loose(),
   params: SoundEffectParams,
-  outputs: z24.object({ audio: AudioRef }).strict(),
+  outputs: z25.object({ audio: AudioRef }).strict(),
   outputKinds: { audio: "audio" },
   cost: ({ params }) => {
     const seconds = params.duration_seconds ?? 5;
@@ -5986,7 +6379,7 @@ var soundEffectNode = delegated({
 });
 
 // src/engine/nodes/remote/textGenerate.ts
-import { z as z25 } from "zod";
+import { z as z26 } from "zod";
 var TEXT_GENERATE_MODELS = ["~google/gemini-flash-latest", "~google/gemini-pro-latest"];
 var textGenerateNode = delegated({
   id: "text_generate",
@@ -5994,58 +6387,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: 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()
+  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()
   }).strict(),
-  outputs: z25.object({ text: TextRef }).strict(),
+  outputs: z26.object({ text: TextRef }).strict(),
   outputKinds: { text: "text" },
   cost: () => ({ credits: 1, seconds_estimate: 3 })
 });
 
 // src/engine/nodes/remote/tts.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var TTS_MODELS = ["elevenlabs/eleven_v3"];
-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()
+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()
 }).strict();
-var TtsPronunciationLocator = z26.object({
-  pronunciation_dictionary_id: z26.string().min(1),
-  version_id: z26.string().nullable().optional()
+var TtsPronunciationLocator = z27.object({
+  pronunciation_dictionary_id: z27.string().min(1),
+  version_id: z27.string().nullable().optional()
 }).strict();
-var TtsParams = z26.object({
-  model: z26.enum(TTS_MODELS),
-  text: z26.string().min(1).max(ELEVENLABS_MAX_TEXT_CHARS),
-  voice: z26.string().min(1),
+var TtsParams = z27.object({
+  model: z27.enum(TTS_MODELS),
+  text: z27.string().min(1).max(ELEVENLABS_MAX_TEXT_CHARS),
+  voice: z27.string().min(1),
   /** Provider output_format (mp3 family only — assets are stored as audio/mpeg). */
-  output_format: z26.enum(ELEVENLABS_OUTPUT_FORMATS).optional(),
-  seed: z26.number().int().min(0).max(4294967295).optional(),
+  output_format: z27.enum(ELEVENLABS_OUTPUT_FORMATS).optional(),
+  seed: z27.number().int().min(0).max(4294967295).optional(),
   // Top-level shortcuts; structured form is `voice_settings`.
-  stability: z26.number().min(0).max(1).optional(),
-  similarity_boost: z26.number().min(0).max(1).optional(),
+  stability: z27.number().min(0).max(1).optional(),
+  similarity_boost: z27.number().min(0).max(1).optional(),
   voice_settings: TtsVoiceSettings.optional(),
   /** ISO 639-1 language code. eleven_v3 supports language hints. */
-  language_code: z26.string().optional(),
-  pronunciation_dictionary_locators: z26.array(TtsPronunciationLocator).max(3).optional(),
-  apply_text_normalization: z26.enum(["auto", "on", "off"]).optional(),
+  language_code: z27.string().optional(),
+  pronunciation_dictionary_locators: z27.array(TtsPronunciationLocator).max(3).optional(),
+  apply_text_normalization: z27.enum(["auto", "on", "off"]).optional(),
   /** Currently Japanese-only. Adds latency. */
-  apply_language_text_normalization: z26.boolean().optional(),
+  apply_language_text_normalization: z27.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: z26.boolean().optional()
+  with_timestamps: z27.boolean().optional()
 }).strict();
 var ttsNode = delegated({
   id: "tts",
@@ -6053,9 +6446,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: z26.object({}).loose(),
+  inputs: z27.object({}).loose(),
   params: TtsParams,
-  outputs: z26.object({ audio: AudioRef, timestamps: JsonRef.optional() }).strict(),
+  outputs: z27.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)),
@@ -6064,23 +6457,23 @@ var ttsNode = delegated({
 });
 
 // src/engine/nodes/remote/video.ts
-import { z as z27 } from "zod";
+import { z as z28 } from "zod";
 var VIDEO_GENERATE_MODELS = ["bytedance/seedance-2.0", "google/veo-3.1-fast"];
-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(),
+var VideoGenerateParams = z28.object({
+  model: z28.enum(VIDEO_GENERATE_MODELS),
+  prompt: z28.string().min(1),
+  duration: z28.number().int().positive().optional(),
+  resolution: z28.string().optional(),
   // 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: 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(),
+  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(),
   // Veo-only passthroughs (routed via `provider.options.google-vertex.parameters`).
-  negative_prompt: z27.string().optional(),
-  person_generation: z27.string().optional(),
-  enhance_prompt: z27.boolean().optional(),
-  conditioning_scale: z27.number().optional()
+  negative_prompt: z28.string().optional(),
+  person_generation: z28.string().optional(),
+  enhance_prompt: z28.boolean().optional(),
+  conditioning_scale: z28.number().optional()
 }).strict();
 var videoGenerateNode = delegated({
   id: "video_generate",
@@ -6088,23 +6481,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: z27.object({
+  inputs: z28.object({
     first_frame: ImageRef.optional(),
     last_frame: ImageRef.optional(),
     reference: ImageRef.optional()
   }).loose(),
   params: VideoGenerateParams,
-  outputs: z27.object({ video: VideoRef }).strict(),
+  outputs: z28.object({ video: VideoRef }).strict(),
   outputKinds: { video: "video" },
   cost: () => ({ credits: 50, seconds_estimate: 120 })
 });
 
 // src/engine/nodes/remote/videoBackgroundRemove.ts
-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")
+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")
 }).strict();
 var videoBackgroundRemoveNode = delegated({
   id: "video_background_remove",
@@ -6112,18 +6505,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: z28.object({
+  inputs: z29.object({
     video: VideoRef
   }).strict(),
   params: VideoBackgroundRemoveParams,
-  outputs: z28.object({ video: VideoRef }).strict(),
+  outputs: z29.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 z29 } from "zod";
+import { z as z30 } from "zod";
 var VIDEO_DECONSTRUCT_MODELS = ["~google/gemini-flash-latest", "~google/gemini-pro-latest"];
 var videoDeconstructNode = delegated({
   id: "video_deconstruct",
@@ -6131,34 +6524,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: 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(),
+  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(),
     // 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: z29.array(z29.number().min(0)).max(200).optional(),
+    shot_cuts: z30.array(z30.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: z29.number().positive().max(60).optional(),
+    max_clip_s: z30.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: z29.enum(["groq", "deepgram"]).optional()
+    transcriber: z30.enum(["groq", "deepgram"]).optional()
   }).strict(),
-  outputs: z29.object({
+  outputs: z30.object({
     analysis: JsonRef,
     // Absent in mode:"index" (structure only, no Mux frame extraction).
-    start_frames: z29.array(ImageRef).min(1).optional(),
-    end_frames: z29.array(ImageRef).min(1).optional(),
+    start_frames: z30.array(ImageRef).min(1).optional(),
+    end_frames: z30.array(ImageRef).min(1).optional(),
     transcript: JsonRef
   }).strict(),
   outputKinds: { analysis: "json", start_frames: "image", end_frames: "image", transcript: "json" },
@@ -6166,22 +6559,22 @@ var videoDeconstructNode = delegated({
 });
 
 // src/engine/nodes/remote/videoLipsync.ts
-import { z as z30 } from "zod";
-var FalLipsyncParams = z30.object({
-  model: z30.literal("fal/veed-lipsync")
+import { z as z31 } from "zod";
+var FalLipsyncParams = z31.object({
+  model: z31.literal("fal/veed-lipsync")
 }).strict();
-var VideoLipsyncParams = z30.discriminatedUnion("model", [FalLipsyncParams]);
+var VideoLipsyncParams = z31.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: z30.object({
+  inputs: z31.object({
     video: VideoRef,
     audio: AudioRef
   }).strict(),
   params: VideoLipsyncParams,
-  outputs: z30.object({ video: VideoRef }).strict(),
+  outputs: z31.object({ video: VideoRef }).strict(),
   outputKinds: { video: "video" },
   cost: () => ({ credits: 20, seconds_estimate: 120 })
 });
@@ -6190,7 +6583,7 @@ var videoLipsyncNode = delegated({
 import { mkdtemp as mkdtemp6, readFile as readFile10, rm as rm6 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
 import path13 from "path";
-import { z as z31 } from "zod";
+import { z as z32 } from "zod";
 
 // src/engine/nodes/local/lib/ffmpeg.ts
 import { execFile as execFile7 } from "child_process";
@@ -6269,21 +6662,21 @@ ${detail.slice(-4e3)}`);
 }
 
 // src/engine/nodes/remote/videoTranscribe.ts
-var VideoTranscribeParams = z31.object({
-  language: z31.string().min(2).max(8).optional(),
+var VideoTranscribeParams = z32.object({
+  language: z32.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: z31.enum(["groq", "deepgram"]).optional()
+  transcriber: z32.enum(["groq", "deepgram"]).optional()
 }).strict();
-var VideoTranscribeInputs = z31.object({
+var VideoTranscribeInputs = z32.object({
   video: VideoRef
 }).strict();
-var VideoTranscribeOutputs = z31.object({
-  transcript: z31.custom(),
+var VideoTranscribeOutputs = z32.object({
+  transcript: z32.custom(),
   // Only emitted by the Deepgram path: full punctuated words + paragraph /
   // sentence grouping with speaker indices. Absent for the default Groq path.
-  rich: z31.custom().optional()
+  rich: z32.custom().optional()
 }).strict();
 var AUDIO_EXTRACT_TIMEOUT_MS = 6e4;
 var videoTranscribeNode = defineNode({
@@ -6368,29 +6761,29 @@ async function tryExtractAudio(inputs, ctx) {
 }
 
 // src/engine/nodes/remote/voiceSelect.ts
-import { z as z32 } from "zod";
+import { z as z33 } 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: 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()
+  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()
   }).strict(),
-  outputs: z32.object({ voice_id: TextRef, candidates: JsonRef }).strict(),
+  outputs: z33.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 z33 } from "zod";
+import { z as z34 } from "zod";
 function generateCatalog(registry, opts = {}) {
   const entries = registry.all().map((def) => {
     const cost = def.cost ? safeCost(def) : void 0;
@@ -6401,9 +6794,9 @@ function generateCatalog(registry, opts = {}) {
       summary: def.summary,
       when_to_use: def.when_to_use,
       location: def.location,
-      inputs: z33.toJSONSchema(def.inputs, { unrepresentable: "any" }),
-      params: z33.toJSONSchema(def.params, { unrepresentable: "any" }),
-      outputs: z33.toJSONSchema(def.outputs, { unrepresentable: "any" }),
+      inputs: z34.toJSONSchema(def.inputs, { unrepresentable: "any" }),
+      params: z34.toJSONSchema(def.params, { unrepresentable: "any" }),
+      outputs: z34.toJSONSchema(def.outputs, { unrepresentable: "any" }),
       cost_estimate_credits: cost?.credits,
       runtime_estimate_seconds: cost?.seconds_estimate
     };
@@ -6480,7 +6873,8 @@ var LOCAL_NODES = [
   imagemagickNode,
   videoTranscribeNode,
   fontSpecimenNode,
-  audioTimelineNode
+  audioTimelineNode,
+  collectNode
 ];
 var REMOTE_NODES = [
   textGenerateNode,
@@ -6513,17 +6907,29 @@ function createEngineFromEnv(opts = {}) {
   const cacheDir = opts.cacheDir ?? path15.join(cwd, "canvas", ".cache");
   const outputsDir = opts.outputsDir ?? path15.join(cwd, "canvas");
   const creds = requireCredentialsFromEnv();
+  const client = new BackendClient({ baseUrl: creds.url, apiKey: creds.apiKey });
+  const assets = new LocalAssetStore(path15.join(cacheDir, "assets"));
+  const localCache = new LocalCacheStore(path15.join(cacheDir, "index"));
+  const remoteCacheEnabled = opts.remoteCache ?? remoteCacheEnabledFromEnv();
+  const cache = remoteCacheEnabled ? new LayeredCacheStore({
+    local: localCache,
+    remote: new RemoteCacheStore(client, opts.log),
+    assets,
+    log: opts.log
+  }) : localCache;
   return new Engine({
     registry: defaultRegistry(),
-    client: new BackendClient({ baseUrl: creds.url, apiKey: creds.apiKey }),
-    assets: new LocalAssetStore(path15.join(cacheDir, "assets")),
-    cache: new LocalCacheStore(path15.join(cacheDir, "index")),
+    client,
+    assets,
+    cache,
     outputsDir,
-    log: opts.log
+    log: opts.log,
+    persistAssets: remoteCacheEnabled
   });
 }
 
 export {
+  requireCredentialsFromEnv,
   LayerExecutionError,
   describeFailureReason,
   SEEDANCE_DURATIONS,
@@ -6531,7 +6937,14 @@ export {
   IMAGE_GENERATE_MODELS,
   MODEL_REGISTRY,
   resolveConcurrency,
+  ulid,
+  isPersistedAssetRef,
+  collectAssetRefLikes,
+  REF_PREFIX,
+  parseRefExpr,
+  sha256Hex,
   elementMentionKeywords,
+  toModelSafeImage,
   BackendClient2 as BackendClient,
   Engine2 as Engine,
   LocalAssetStore2 as LocalAssetStore,
@@ -6542,4 +6955,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-IWPAXJC3.js.map
+//# sourceMappingURL=chunk-Q3K5TXC6.js.map