@koda-sl/baker-cli 0.114.0-dev.249eaa8ed → 0.115.0-dev.3bcc79f9c

package/dist/{chunk-5AWO4BHJ.js → chunk-OCMOQOIJ.js}

@@ -159,9 +159,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);
           };
         }
       }
@@ -624,6 +624,7 @@ ${originalIndentation}`;
 import path15 from "path";
 
 // src/engine/client/http.ts
+var CONTENT_POLICY_CODE = "content_policy_blocked";
 var BackendHttpError = class extends Error {
   detail;
   constructor(detail) {
@@ -640,6 +641,8 @@ function describe(d) {
       return `invalid request: ${d.message}`;
     case "provider":
       return `provider error${d.provider ? ` (${d.provider})` : ""}: ${d.message}`;
+    case "content_policy":
+      return `content policy blocked${d.provider ? ` (${d.provider})` : ""}: ${d.message}`;
     case "timeout":
       return `provider timeout${d.provider ? ` (${d.provider})` : ""}: ${d.message}`;
     case "server":
@@ -670,6 +673,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);
   }
@@ -697,8 +703,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() };
@@ -735,30 +741,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: 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;
@@ -774,6 +783,24 @@ function isAsyncJob(res) {
   return typeof res.job_id === "string";
 }
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function failedJobError(error) {
+  if (error.code === CONTENT_POLICY_CODE) {
+    return new BackendHttpError({
+      kind: "content_policy",
+      status: error.status ?? 422,
+      provider: error.provider,
+      message: error.message ?? "content policy blocked"
+    });
+  }
+  return new BackendHttpError({
+    kind: "provider",
+    status: error.status ?? 502,
+    provider: error.provider,
+    code: error.code ?? "provider_error",
+    message: error.message ?? "deconstruct failed",
+    retryable: error.retryable ?? false
+  });
+}
 var JOB_POLL_INTERVAL_MS = 3e3;
 var JOB_POLL_MAX_MS = 20 * 60 * 1e3;
 var BackendClient = class {
@@ -797,16 +824,7 @@ var BackendClient = class {
       }
       const job = await this.http.getJson(path16, signal);
       if (job.status === "completed") return job.result;
-      if (job.status === "failed") {
-        throw new BackendHttpError({
-          kind: "provider",
-          status: job.error.status ?? 502,
-          provider: job.error.provider,
-          code: job.error.code ?? "provider_error",
-          message: job.error.message ?? "deconstruct failed",
-          retryable: job.error.retryable ?? false
-        });
-      }
+      if (job.status === "failed") throw failedJobError(job.error);
       if (Date.now() > deadline) {
         throw new BackendHttpError({ kind: "timeout", message: `job ${jobId} did not finish in time` });
       }
@@ -820,6 +838,27 @@ 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);
+  }
   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);
@@ -843,11 +882,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";
   }
 };
@@ -895,6 +940,8 @@ function describeCause(c) {
       return `timeout${c.provider ? ` (${c.provider})` : ""}`;
     case "network":
       return c.cause instanceof Error ? `network: ${c.cause.message}` : "network error";
+    case "content_policy":
+      return `CONTENT_POLICY_BLOCKED${c.provider ? ` (${c.provider})` : ""}: ${c.message}`;
     default: {
       const _exhaustive = c;
       return String(_exhaustive);
@@ -1563,6 +1610,158 @@ function encodeRandom() {
   return out;
 }
 
+// src/engine/storage/remote-cache-store.ts
+var CANVAS_ASSETS_URL_SEGMENT = "/canvas-assets/";
+function isPersistedAssetRef(ref) {
+  return typeof ref.url === "string" && ref.url.includes(`${CANVAS_ASSETS_URL_SEGMENT}${ref.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:";
@@ -1638,7 +1837,23 @@ var VideoMeta = z.object({
   // on which spoken beat" map emitted by scaffold-video (per-scene window,
   // spoken line, storyboard frames, scheduled graphics). Free-form rows so the
   // schema stays decoupled from the scaffold's exact shape.
-  motion_board: z.array(z.unknown()).optional()
+  motion_board: z.array(z.unknown()).optional(),
+  // The recurring identity elements the scaffold wired (one shared reference slot
+  // per cast member / pet / product / logo). The reference-completeness check reads
+  // this to warn when a frame's description mentions an element whose ref isn't
+  // wired on that frame node (the wrong-identity-animal failure).
+  elements: z.array(
+    z.object({
+      ref: z.string(),
+      label: z.string(),
+      type: z.string(),
+      description: z.string().optional()
+    })
+  ).optional(),
+  // Per video_generate node: the scene's natural visual span. The validator warns
+  // when a clip's span exceeds the assigned model's max clip duration (e.g. a 9.2s
+  // scene on Veo, which caps at 8s) — the clip would truncate.
+  clip_spans: z.array(z.object({ node: z.string(), span_s: z.number() })).optional()
 }).strict().optional();
 var CanvasMetadata = z.object({
   name: z.string().optional(),
@@ -2136,8 +2351,11 @@ var STAGE_CODES = {
   AUDIO_DURATION: "VIDEO_AUDIO_DURATION",
   LIPSYNC_MISSING: "VIDEO_LIPSYNC_MISSING",
   SPEECH_OVERRUN: "VIDEO_SPEECH_OVERRUN",
-  ASPECT_MISMATCH: "VIDEO_ASPECT_MISMATCH"
+  ASPECT_MISMATCH: "VIDEO_ASPECT_MISMATCH",
+  REFERENCE_MISSING: "VIDEO_REFERENCE_MISSING",
+  SPAN_EXCEEDS_MODEL: "VIDEO_SPAN_EXCEEDS_MODEL"
 };
+var SPAN_MODEL_SLACK_S = 0.25;
 var VIDEO_TIME_SLACK_S = 0.75;
 var SPEECH_WORDS_PER_SECOND = 2.5;
 var SPEECH_OVERRUN_RATIO = 1.6;
@@ -2168,8 +2386,10 @@ function validateCanvas(input, registry) {
   const estimatedCredits = estimateCredits(ctx);
   checkOutputRef(ctx);
   checkVideoInvariants(ctx);
-  if (issues.length > 0) return { ok: false, issues };
-  return { ok: true, canvas, estimatedCredits };
+  const hasBlocking = issues.some(isBlocking);
+  if (hasBlocking) return { ok: false, issues };
+  const warnings = issues.filter((i) => !isBlocking(i));
+  return { ok: true, canvas, estimatedCredits, warnings: warnings.length > 0 ? warnings : void 0 };
 }
 async function validateCanvasDeep(input, registry) {
   const shallow = validateCanvas(input, registry);
@@ -2204,7 +2424,9 @@ async function validateCanvasDeep(input, registry) {
       });
     }
   }
-  if (issues.length > 0) return { ok: false, issues };
+  const hasBlocking = issues.some(isBlocking);
+  if (hasBlocking) return { ok: false, issues };
+  const warnings = [...shallow.warnings ?? [], ...issues.filter((i) => !isBlocking(i))];
   const perNodeCredits = canvas.nodes.map((n) => {
     const def = registry.get(n.type);
     let credits = 0;
@@ -2217,7 +2439,13 @@ async function validateCanvasDeep(input, registry) {
     }
     return { node_id: n.id, node_type: n.type, credits };
   });
-  return { ok: true, canvas, estimatedCredits: shallow.estimatedCredits, perNodeCredits };
+  return {
+    ok: true,
+    canvas,
+    estimatedCredits: shallow.estimatedCredits,
+    perNodeCredits,
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
 }
 function buildIdToIndex(canvas) {
   const m = /* @__PURE__ */ new Map();
@@ -2504,6 +2732,95 @@ function checkVideoInvariants(ctx) {
   }
   checkSpeechOverrun(ctx, meta.talking_scenes);
   checkAspectConsistency(ctx);
+  checkReferenceCompleteness(ctx, meta);
+  checkClipSpanFitsModel(ctx, meta);
+}
+var ELEMENT_TYPE_KEYWORDS = {
+  animal: ["dog", "puppy", "pup", "cat", "kitten", "kitty", "pet", "canine", "feline"],
+  logo: ["logo", "wordmark"],
+  badge: ["badge", "seal"],
+  product: []
+};
+var CHECKED_ELEMENT_TYPES = new Set(Object.keys(ELEMENT_TYPE_KEYWORDS));
+var KEYWORD_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "with",
+  "for",
+  "brand",
+  "logo",
+  "image",
+  "shot",
+  "main",
+  "hero",
+  "element",
+  "product",
+  "reference"
+]);
+function keywordTokens(text) {
+  if (!text) return [];
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 3 && !KEYWORD_STOPWORDS.has(t));
+}
+function keywordsForElement(el) {
+  const type = el.type.toLowerCase();
+  const typeWords = ELEMENT_TYPE_KEYWORDS[type] ?? [];
+  return [.../* @__PURE__ */ new Set([...typeWords, ...keywordTokens(el.label), ...keywordTokens(el.description)])];
+}
+function containsWord(text, word) {
+  const esc = word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`\\b${esc}\\b`, "i").test(text);
+}
+function checkFrameReferences(ctx, node, index, keyworded) {
+  const prompt = node.params?.prompt;
+  if (typeof prompt !== "string" || prompt.length === 0) return;
+  const inputsBlob = JSON.stringify(node.inputs ?? {});
+  for (const { el, keywords } of keyworded) {
+    if (inputsBlob.includes(el.ref)) continue;
+    const hit = keywords.find((kw) => containsWord(prompt, kw));
+    if (!hit) continue;
+    ctx.issues.push({
+      path: `nodes[${index}].inputs.reference`,
+      code: STAGE_CODES.REFERENCE_MISSING,
+      severity: "warning",
+      message: `frame "${node.id}" describes a "${hit}" but the "${el.label}" reference (${el.ref}) isn't wired on this node \u2014 the generator will invent a wrong-identity ${el.type} from prose. Add ${el.ref} to inputs.reference`,
+      node_id: node.id,
+      node_type: node.type
+    });
+  }
+}
+function checkReferenceCompleteness(ctx, meta) {
+  const elements = (meta.elements ?? []).filter((el) => CHECKED_ELEMENT_TYPES.has(el.type.toLowerCase()));
+  const keyworded = elements.map((el) => ({ el, keywords: keywordsForElement(el) })).filter((e) => e.keywords.length > 0);
+  if (keyworded.length === 0) return;
+  for (let i = 0; i < ctx.canvas.nodes.length; i++) {
+    const n = ctx.canvas.nodes[i];
+    if (n?.type === "image_generate") checkFrameReferences(ctx, n, i, keyworded);
+  }
+}
+function videoModelMaxDuration(model) {
+  const spec = MODEL_REGISTRY.video_generate[model];
+  const durations = spec?.params?.duration?.enum;
+  if (!durations) return void 0;
+  const nums = durations.filter((d) => typeof d === "number");
+  return nums.length > 0 ? Math.max(...nums) : void 0;
+}
+function checkClipSpanFitsModel(ctx, meta) {
+  for (const { node, span_s } of meta.clip_spans ?? []) {
+    const target = ctx.canvas.nodes.find((n) => n.id === node && n.type === "video_generate");
+    if (!target) continue;
+    const model = target.params?.model;
+    if (typeof model !== "string") continue;
+    const max = videoModelMaxDuration(model);
+    if (max === void 0 || span_s <= max + SPAN_MODEL_SLACK_S) continue;
+    ctx.issues.push({
+      path: `nodes[${ctx.idToIndex.get(node) ?? -1}].params.duration`,
+      code: STAGE_CODES.SPAN_EXCEEDS_MODEL,
+      severity: "warning",
+      message: `scene for clip "${node}" needs ~${span_s}s but ${model} caps clips at ${max}s \u2014 the clip will truncate. Split the scene, or keep it on a model whose max duration covers the span`,
+      node_id: node,
+      node_type: "video_generate"
+    });
+  }
 }
 function speechOverrunOf(node) {
   const params = node.params;
@@ -2661,6 +2978,7 @@ var Engine = class {
   cache;
   outputsDir;
   log;
+  persistAssets;
   constructor(opts) {
     this.registry = opts.registry;
     this.client = opts.client;
@@ -2668,6 +2986,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);
@@ -2684,6 +3003,9 @@ var Engine = class {
     const writer = new OutputWriter({ outputsDir: this.outputsDir, runId });
     await writer.ensure();
     this.log(`[validate] ok (${canvas.nodes.length} nodes, est. ${validation.estimatedCredits} credits)`);
+    for (const w of validation.warnings ?? []) {
+      this.log(`[warn    ] ${w.code}${w.node_id ? ` (${w.node_id})` : ""}: ${w.message}`);
+    }
     const t0 = Date.now();
     const outputs = {};
     const counters = { cachedNodes: 0, totalCredits: 0 };
@@ -2711,7 +3033,7 @@ 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)));
@@ -2808,6 +3130,14 @@ var Engine = class {
     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,
@@ -3126,27 +3456,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 {
@@ -3253,6 +3562,13 @@ function mapClientError(ctx, e) {
         provider: d.provider
       });
     }
+    if (d.kind === "content_policy") {
+      return new NodeExecutionError(ctx.nodeId, ctx.nodeType, {
+        kind: "content_policy",
+        provider: d.provider,
+        message: d.message
+      });
+    }
     if (d.kind === "timeout") {
       return new NodeExecutionError(ctx.nodeId, ctx.nodeType, { kind: "timeout", provider: d.provider });
     }
@@ -3534,10 +3850,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) {
@@ -4204,7 +4520,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");
@@ -4576,8 +4892,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) {
@@ -4605,10 +4921,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;
 }
@@ -4620,9 +4936,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;
 }
@@ -5067,7 +5383,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) {
@@ -5297,7 +5613,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) {
@@ -6323,17 +6639,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,
@@ -6341,6 +6669,10 @@ export {
   IMAGE_GENERATE_MODELS,
   MODEL_REGISTRY,
   resolveConcurrency,
+  ulid,
+  isPersistedAssetRef,
+  collectAssetRefLikes,
+  sha256Hex,
   BackendClient2 as BackendClient,
   Engine2 as Engine,
   LocalAssetStore2 as LocalAssetStore,
@@ -6351,4 +6683,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-5AWO4BHJ.js.map
+//# sourceMappingURL=chunk-OCMOQOIJ.js.map