@koda-sl/baker-cli 0.124.0 → 0.128.0-dev.70bf43ce4

package/dist/{chunk-IWPAXJC3.js → chunk-43KBQLP5.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 = def.location === "local" ? { ...prepared, resolvedInputs: await this.materializeLocalInputs(prepared.resolvedInputs) } : prepared;
+    const { parsedInputs, parsedParams } = parseNodeArgs(def, preparedForExec, node.id, node.type);
     const result = await invokeExecute(def, parsedInputs, parsedParams, ctx, node.id, node.type);
     const elapsed = Date.now() - t0;
     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,
@@ -3071,6 +3346,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") 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 +3486,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 +3603,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 +3630,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 +3684,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 +3801,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 +3844,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 +3857,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 +3924,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 +3983,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 +4074,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 +4124,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 +4155,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 } : {}
   };
 }
@@ -4394,7 +4747,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");
@@ -4766,8 +5119,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 +5148,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 +5163,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;
 }
@@ -5257,7 +5610,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) {
@@ -5487,7 +5840,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) {
@@ -6513,17 +6866,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 +6896,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 +6914,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-IWPAXJC3.js.map
+//# sourceMappingURL=chunk-43KBQLP5.js.map