@koda-sl/baker-cli 0.464.0 → 0.466.0

package/dist/chunk-42NVYJLD.js

@@ -0,0 +1,1711 @@
+import {
+  YT_DLP_BIN,
+  YtDlpError,
+  runYtDlp
+} from "./chunk-BH3B2E7H.js";
+import {
+  fetchExternalBytes
+} from "./chunk-R7DHZDYT.js";
+import {
+  debugLogHttp,
+  readBodyForLog
+} from "./chunk-7JB56IVP.js";
+import {
+  canvasAssetOriginsSetting
+} from "./chunk-XMS5K54U.js";
+
+// src/engine/engine/errors.ts
+function isBlocking(issue) {
+  return issue.severity !== "warning";
+}
+var CanvasError = class extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "CanvasError";
+  }
+};
+var ValidationError = class extends CanvasError {
+  issues;
+  constructor(issues) {
+    const head = issues[0];
+    const summary = head ? `${head.code}: ${head.message}` : "canvas validation failed";
+    super(`${issues.length} validation issue(s): ${summary}`);
+    this.name = "ValidationError";
+    this.issues = issues;
+  }
+};
+var NodeExecutionError = class extends CanvasError {
+  nodeId;
+  nodeType;
+  cause;
+  constructor(nodeId, nodeType, cause) {
+    super(`node ${nodeId} (${nodeType}) failed: ${describeCause(cause)}`);
+    this.name = "NodeExecutionError";
+    this.nodeId = nodeId;
+    this.nodeType = nodeType;
+    this.cause = cause;
+  }
+};
+var RunAbortedError = class extends CanvasError {
+  reason;
+  constructor(reason, message2) {
+    super(message2);
+    this.name = "RunAbortedError";
+    this.reason = reason;
+  }
+};
+var LayerExecutionError = class extends CanvasError {
+  failures;
+  constructor(failures) {
+    const ids = failures.map((f) => f.nodeId).join(", ");
+    super(`${failures.length} nodes failed in one layer: ${ids}`);
+    this.name = "LayerExecutionError";
+    this.failures = failures;
+  }
+};
+function describeFailureReason(reason) {
+  return reason instanceof Error ? reason.message : String(reason);
+}
+function isInputRejection(reason) {
+  if (!(reason instanceof NodeExecutionError) || reason.cause.kind !== "remote") return false;
+  const { status, provider } = reason.cause;
+  return (status === 400 || status === 422) && provider === void 0;
+}
+function runFailureCode(e) {
+  const reasons = e instanceof LayerExecutionError ? e.failures.map((f) => f.reason) : [e];
+  return reasons.length > 0 && reasons.every(isInputRejection) ? "input_invalid" : "runtime";
+}
+function failureDetail(reason) {
+  if (reason instanceof NodeExecutionError) {
+    const c = reason.cause;
+    switch (c.kind) {
+      case "remote":
+        return {
+          message: c.message,
+          code: c.code,
+          provider: c.provider,
+          retryable: c.retryable ?? (c.status >= 500 || c.status === 429)
+        };
+      case "timeout":
+        return {
+          message: `timed out${c.provider ? ` (${c.provider})` : ""}`,
+          code: "timeout",
+          provider: c.provider,
+          retryable: true
+        };
+      case "content_policy":
+        return { message: c.message, code: "content_policy", provider: c.provider, retryable: false };
+      case "network":
+        return {
+          message: c.cause instanceof Error ? c.cause.message : "network error",
+          code: "network",
+          retryable: true
+        };
+      case "local":
+        return { message: c.cause instanceof Error ? c.cause.message : String(c.cause), code: "local" };
+      default: {
+        const _exhaustive = c;
+        return { message: String(_exhaustive) };
+      }
+    }
+  }
+  return { message: describeFailureReason(reason) };
+}
+function retryVerdict(retryable) {
+  if (retryable === true) return "transient \u2014 retry the run";
+  if (retryable === false) return "not retryable \u2014 retrying will not help, fix the input";
+  return "retryability unknown";
+}
+function describeCause(c) {
+  switch (c.kind) {
+    case "local":
+      return c.cause instanceof Error ? c.cause.message : String(c.cause);
+    case "remote":
+      return `[${c.code}] ${c.message}${c.provider ? ` (${c.provider})` : ""} \u2014 ${retryVerdict(c.retryable)}`;
+    case "timeout":
+      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);
+    }
+  }
+}
+
+// src/engine/storage/sha256.ts
+import { createHash } from "crypto";
+function sha256Hex(input) {
+  const h = createHash("sha256");
+  h.update(input);
+  return h.digest("hex");
+}
+
+// src/engine/storage/asset-store.ts
+import { randomUUID } from "crypto";
+import { createWriteStream } from "fs";
+import { mkdir, readFile, rename, stat, unlink, writeFile } from "fs/promises";
+import path from "path";
+import { Readable, Transform } from "stream";
+import { pipeline } from "stream/promises";
+var MAX_ASSET_BYTES = 2 * 1024 * 1024 * 1024;
+var MIME_TO_EXT = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp",
+  "image/gif": "gif",
+  "image/avif": "avif",
+  "video/mp4": "mp4",
+  "video/webm": "webm",
+  "video/quicktime": "mov",
+  "audio/mpeg": "mp3",
+  "audio/wav": "wav",
+  "audio/x-wav": "wav",
+  "audio/ogg": "ogg",
+  "audio/mp4": "m4a",
+  "application/json": "json",
+  "text/plain": "txt",
+  "text/markdown": "md",
+  "text/html": "html",
+  "font/ttf": "ttf",
+  "font/otf": "otf",
+  "font/woff": "woff",
+  "font/woff2": "woff2"
+};
+function extForMime(mime) {
+  return MIME_TO_EXT[mime] ?? "bin";
+}
+var LocalAssetStore = class {
+  rootDir;
+  fetchFn;
+  maxRemoteAssetBytes;
+  constructor(rootDir, fetchFn = fetch, opts) {
+    this.rootDir = rootDir;
+    this.fetchFn = fetchFn;
+    this.maxRemoteAssetBytes = opts?.maxRemoteAssetBytes ?? MAX_ASSET_BYTES;
+  }
+  pathFor(sha, mime) {
+    const ext = extForMime(mime);
+    const shard = sha.slice(0, 2);
+    return path.join(this.rootDir, shard, `${sha}.${ext}`);
+  }
+  async exists(sha, mime) {
+    try {
+      await stat(this.pathFor(sha, mime));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  readBytes(sha, mime) {
+    return readFile(this.pathFor(sha, mime));
+  }
+  async ingestBytes(args) {
+    const sha = sha256Hex(args.bytes);
+    const dest = this.pathFor(sha, args.mime);
+    await mkdir(path.dirname(dest), { recursive: true });
+    if (!await this.exists(sha, args.mime)) {
+      const tmp = `${dest}.tmp-${process.pid}-${randomUUID()}`;
+      await writeFile(tmp, args.bytes);
+      await rename(tmp, dest);
+    }
+    return buildRef({ kind: args.kind, sha, mime: args.mime, path: dest, metadata: args.metadata });
+  }
+  async ingestRemote(args) {
+    const dest = this.pathFor(args.sha256, args.mime);
+    let bytes;
+    if (await this.exists(args.sha256, args.mime)) {
+      bytes = await readFile(dest);
+    } else {
+      await mkdir(path.dirname(dest), { recursive: true });
+      const res = await this.fetchFn(args.url);
+      if (!res.ok || !res.body) {
+        throw new Error(`asset-store: fetch ${args.url} \u2192 ${res.status}`);
+      }
+      const declared = Number(res.headers.get("content-length"));
+      if (Number.isFinite(declared) && declared > this.maxRemoteAssetBytes) {
+        throw new Error(
+          `asset-store: ${args.url} is ${declared} bytes, exceeds the ${this.maxRemoteAssetBytes} byte limit`
+        );
+      }
+      const tmp = `${dest}.tmp-${process.pid}-${randomUUID()}`;
+      try {
+        await pipeline(
+          Readable.fromWeb(res.body),
+          byteLimit(args.url, this.maxRemoteAssetBytes),
+          createWriteStream(tmp)
+        );
+        const written = await readFile(tmp);
+        const computed = sha256Hex(written);
+        if (computed !== args.sha256 && !cdnReencodedImage(res, args.kind)) {
+          throw new Error(`asset-store: sha mismatch for ${args.url} (got ${computed}, expected ${args.sha256})`);
+        }
+        await rename(tmp, dest);
+        bytes = written;
+      } catch (e) {
+        await unlink(tmp).catch(() => void 0);
+        throw e;
+      }
+    }
+    return buildRef({
+      kind: args.kind,
+      sha: args.sha256,
+      mime: args.mime,
+      url: args.url,
+      path: dest,
+      metadata: args.metadata,
+      bytes
+    });
+  }
+};
+function cdnReencodedImage(res, kind) {
+  return kind === "image" && res.headers.get("cf-polished") !== null;
+}
+function byteLimit(url, maxBytes) {
+  let total = 0;
+  return new Transform({
+    transform(chunk, _enc, cb) {
+      total += chunk.length;
+      if (total > maxBytes) {
+        cb(new Error(`asset-store: ${url} exceeds the ${maxBytes} byte limit (aborted at ${total} bytes)`));
+        return;
+      }
+      cb(null, chunk);
+    }
+  });
+}
+function buildRef(args) {
+  const base = {
+    sha256: args.sha,
+    mime: args.mime,
+    url: args.url,
+    path: args.path,
+    metadata: args.metadata
+  };
+  switch (args.kind) {
+    case "image": {
+      const { width, height } = args.metadata ?? {};
+      return { kind: "image", ...base, width, height };
+    }
+    case "video": {
+      const { width, height, duration_ms } = args.metadata ?? {};
+      return { kind: "video", ...base, width, height, duration_ms };
+    }
+    case "audio": {
+      const { duration_ms } = args.metadata ?? {};
+      return { kind: "audio", ...base, duration_ms };
+    }
+    case "json":
+      return { kind: "json", ...base };
+    case "text":
+      return { kind: "text", ...base };
+    case "font":
+      return { kind: "font", ...base };
+    default: {
+      const _exhaustive = args.kind;
+      throw new Error(`asset-store: unknown kind ${String(_exhaustive)}`);
+    }
+  }
+}
+
+// src/engine/lib/json-walk.ts
+function isContainerObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function forEachString(value, visit, path3 = "") {
+  if (typeof value === "string") {
+    visit(value, path3);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) forEachString(value[i], visit, path3 ? `${path3}[${i}]` : `[${i}]`);
+    return;
+  }
+  if (isContainerObject(value)) {
+    for (const [k, v] of Object.entries(value)) forEachString(v, visit, path3 ? `${path3}.${k}` : k);
+  }
+}
+function forEachObject(value, visit) {
+  if (Array.isArray(value)) {
+    for (const v of value) forEachObject(v, visit);
+    return;
+  }
+  if (!isContainerObject(value)) return;
+  visit(value);
+  for (const v of Object.values(value)) forEachObject(v, visit);
+}
+function mapStrings(value, fn) {
+  if (typeof value === "string") return fn(value);
+  if (Array.isArray(value)) return value.map((v) => mapStrings(v, fn));
+  if (isContainerObject(value)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = mapStrings(v, fn);
+    return out;
+  }
+  return value;
+}
+function mapObjects(value, replace) {
+  if (Array.isArray(value)) return value.map((v) => mapObjects(v, replace));
+  if (!isContainerObject(value)) return value;
+  const replaced = replace(value);
+  if (replaced !== void 0) return replaced;
+  const out = {};
+  for (const [k, v] of Object.entries(value)) out[k] = mapObjects(v, replace);
+  return out;
+}
+async function mapObjectsAsync(value, replace) {
+  if (Array.isArray(value)) return Promise.all(value.map((v) => mapObjectsAsync(v, replace)));
+  if (!isContainerObject(value)) return value;
+  const replaced = replace(value);
+  if (replaced !== void 0) return replaced;
+  const out = {};
+  for (const [k, v] of Object.entries(value)) out[k] = await mapObjectsAsync(v, replace);
+  return out;
+}
+
+// src/engine/schema/refs.ts
+import { z as z2 } from "zod";
+
+// src/engine/schema/primitives.ts
+import { z } from "zod";
+var Sha256Hex = z.string().regex(/^[0-9a-f]{64}$/, "expected 64-char lower-case hex sha-256");
+var MimeType = z.string().regex(/^[a-zA-Z0-9!#$&^_.+-]+\/[a-zA-Z0-9!#$&^_.+-]+$/, "expected RFC 6838 mime");
+
+// src/engine/schema/refs.ts
+var BaseAssetRef = z2.object({
+  url: z2.string().url().optional(),
+  path: z2.string().optional(),
+  sha256: Sha256Hex,
+  mime: MimeType,
+  metadata: z2.record(z2.string(), z2.unknown()).optional()
+});
+var ImageRef = BaseAssetRef.extend({
+  kind: z2.literal("image"),
+  width: z2.number().int().positive().optional(),
+  height: z2.number().int().positive().optional()
+});
+var VideoRef = BaseAssetRef.extend({
+  kind: z2.literal("video"),
+  width: z2.number().int().positive().optional(),
+  height: z2.number().int().positive().optional(),
+  duration_ms: z2.number().nonnegative().optional()
+});
+var AudioRef = BaseAssetRef.extend({
+  kind: z2.literal("audio"),
+  duration_ms: z2.number().nonnegative().optional()
+});
+var JsonRef = BaseAssetRef.extend({
+  kind: z2.literal("json")
+});
+var TextRef = BaseAssetRef.extend({
+  kind: z2.literal("text")
+});
+var FontRef = BaseAssetRef.extend({
+  kind: z2.literal("font")
+});
+var AssetRef = z2.discriminatedUnion("kind", [ImageRef, VideoRef, AudioRef, JsonRef, TextRef, FontRef]);
+function isObject(v) {
+  return Boolean(v) && typeof v === "object";
+}
+var ASSET_KINDS = /* @__PURE__ */ new Set(["image", "video", "audio", "json", "text", "font"]);
+function contentShaOf(v) {
+  if (isObject(v) && "sha256" in v && typeof v.sha256 === "string") return v.sha256;
+  return null;
+}
+function isAssetRef(v) {
+  return isObject(v) && typeof v.kind === "string" && "sha256" in v;
+}
+function isAssetRefArray(v) {
+  return Array.isArray(v) && v.length > 0 && v.every(isAssetRef);
+}
+function isUrlOnlyRef(v) {
+  return isObject(v) && typeof v.kind === "string" && typeof v.url === "string" && typeof v.sha256 === "string" && typeof v.mime === "string" && typeof v.path !== "string";
+}
+function isStageableRef(v) {
+  return isObject(v) && 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");
+}
+function isAssetRefLike(v) {
+  return isObject(v) && !Array.isArray(v) && typeof v.sha256 === "string" && typeof v.mime === "string";
+}
+
+// src/engine/storage/remote-cache-store.ts
+var CANVAS_ASSETS_URL_SEGMENT = "/canvas-assets/";
+function canvasAssetOrigins(setting = canvasAssetOriginsSetting()) {
+  return (setting ?? "https://media.withbaker.com,https://media.dev-baker.com").split(",").map((origin) => origin.trim().replace(/\/+$/, "")).filter(Boolean);
+}
+function isCanvasAssetOrigin(url) {
+  try {
+    const { origin } = new URL(url);
+    return canvasAssetOrigins().some((allowed) => {
+      try {
+        return new URL(allowed).origin === origin;
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return false;
+  }
+}
+function parseCanvasAssetUrl(url) {
+  let pathname;
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return null;
+    pathname = parsed.pathname;
+  } catch {
+    return null;
+  }
+  const match = /\/canvas-assets\/([0-9a-f]{2})\/([0-9a-f]{64})\.([a-z0-9]+)$/.exec(pathname);
+  if (!match) return null;
+  const [, shard, sha256, ext] = match;
+  if (shard === void 0 || sha256 === void 0 || ext === void 0 || !sha256.startsWith(shard)) return null;
+  return { sha256, ext };
+}
+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 collectAssetRefLikes(value) {
+  const out = [];
+  forEachObject(value, (o) => {
+    if (isAssetRefLike(o)) out.push(o);
+  });
+  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/client/http.ts
+var CONTENT_POLICY_CODE = "content_policy_blocked";
+var REQUEST_IN_PROGRESS_CODE = "request_in_progress";
+var BackendHttpError = class extends Error {
+  detail;
+  constructor(detail) {
+    super(describe(detail));
+    this.name = "BackendHttpError";
+    this.detail = detail;
+  }
+};
+function describe(d) {
+  switch (d.kind) {
+    case "unauthorized":
+      return `unauthorized: ${d.message}`;
+    case "validation":
+      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":
+      return `server error ${d.status}: ${d.message}`;
+    case "network":
+      return d.cause instanceof Error ? `network: ${d.cause.message}` : "network error";
+    default: {
+      const _ex = d;
+      return String(_ex);
+    }
+  }
+}
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  maxRetries;
+  fetchFn;
+  sleepFn;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.timeoutMs = opts.timeoutMs ?? 10 * 60 * 1e3;
+    this.maxRetries = opts.maxRetries ?? 3;
+    this.fetchFn = opts.fetchFn ?? fetch;
+    this.sleepFn = opts.sleepFn ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  }
+  async postJson(path3, body, signal) {
+    return await this.requestJson("POST", path3, body, signal);
+  }
+  async putJson(path3, body, signal) {
+    return await this.requestJson("PUT", path3, body, signal);
+  }
+  async getJson(path3, signal) {
+    return await this.requestJson("GET", path3, void 0, signal);
+  }
+  async requestJson(method, path3, body, signal) {
+    const url = `${this.baseUrl}${path3.startsWith("/") ? path3 : `/${path3}`}`;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      const outcome = await this.attempt(method, url, body, attempt, signal);
+      if (outcome.kind === "value") return outcome.value;
+      if (outcome.kind === "retry") {
+        await this.sleepFn(backoffMs(attempt));
+        continue;
+      }
+      throw outcome.error;
+    }
+    throw new BackendHttpError({ kind: "server", status: 0, message: "retries exhausted" });
+  }
+  async attempt(method, url, body, attempt, signal) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(signal?.reason);
+    if (signal) {
+      if (signal.aborted) controller.abort(signal.reason);
+      else signal.addEventListener("abort", onAbort, { once: true });
+    }
+    const timer = setTimeout(() => controller.abort(new Error("timeout")), this.timeoutMs);
+    const startedAt = Date.now();
+    try {
+      const res = await this.fetchFn(url, {
+        method,
+        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
+      });
+      debugLogHttp({
+        source: "canvas",
+        method,
+        url,
+        requestBody: method === "GET" ? void 0 : body,
+        status: res.status,
+        ok: res.ok,
+        responseBody: await readBodyForLog(res),
+        durationMs: Date.now() - startedAt
+      });
+      if (res.ok) return { kind: "value", value: await res.json() };
+      const err = await parseErrorBody(res);
+      if (attempt < this.maxRetries && shouldRetry(err)) return { kind: "retry" };
+      return { kind: "throw", error: new BackendHttpError(err) };
+    } catch (e) {
+      debugLogHttp({
+        source: "canvas",
+        method,
+        url,
+        requestBody: method === "GET" ? void 0 : body,
+        durationMs: Date.now() - startedAt,
+        error: e
+      });
+      return this.handleAttemptException(e, attempt, signal, method);
+    } finally {
+      clearTimeout(timer);
+      if (signal) signal.removeEventListener("abort", onAbort);
+    }
+  }
+  handleAttemptException(e, attempt, signal, method) {
+    if (e instanceof BackendHttpError) return { kind: "throw", error: e };
+    const aborted = e.name === "AbortError";
+    if (aborted && signal?.aborted) {
+      return { kind: "throw", error: new BackendHttpError({ kind: "network", cause: signal.reason ?? e }) };
+    }
+    if (aborted) {
+      if (method === "GET" && attempt < this.maxRetries) return { kind: "retry" };
+      return { kind: "throw", error: new BackendHttpError({ kind: "timeout", message: "request timed out" }) };
+    }
+    if (attempt < this.maxRetries) return { kind: "retry" };
+    return { kind: "throw", error: new BackendHttpError({ kind: "network", cause: e }) };
+  }
+};
+async function parseErrorBody(res) {
+  let body = {};
+  try {
+    body = await res.json();
+  } catch {
+  }
+  const errObj = body.error ?? {};
+  const bodyless = body.error === void 0 && res.status >= 500;
+  const message2 = bodyless ? `HTTP ${res.status} with no response body \u2014 the request was dropped before the server answered` : errObj.message ?? `HTTP ${res.status}`;
+  if (bodyless && res.status === 502) {
+    return { kind: "server", status: res.status, message: message2 };
+  }
+  return classifyBackendError(res.status, errObj, message2);
+}
+function providerVerdict(status, errObj, message2) {
+  if (errObj.provider === void 0 && errObj.code !== "provider_error") return null;
+  return {
+    kind: "provider",
+    status,
+    provider: errObj.provider,
+    code: errObj.code ?? "provider_error",
+    message: message2,
+    // A 4xx is terminal unless the backend says otherwise — the opposite
+    // default from the 502 branch, where the status itself means "try again".
+    retryable: errObj.retryable ?? false
+  };
+}
+function classifyBackendError(status, errObj, message2) {
+  return codeVerdict(status, errObj, message2) ?? clientVerdict(status, errObj, message2) ?? serverVerdict(status, errObj, message2) ?? {
+    // Remaining 4xx (404, 405, 409, …): the request itself is wrong, so a retry
+    // can't help — and re-dispatching a POST risks a double provider charge.
+    kind: "validation",
+    status,
+    message: message2,
+    code: errObj.code,
+    details: errObj.details
+  };
+}
+function codeVerdict(status, errObj, message2) {
+  if (errObj.code === CONTENT_POLICY_CODE) {
+    return { kind: "content_policy", status, provider: errObj.provider, message: message2 };
+  }
+  if (errObj.code === REQUEST_IN_PROGRESS_CODE) return { kind: "server", status, message: message2 };
+  return null;
+}
+function clientVerdict(status, errObj, message2) {
+  if (status === 401 || status === 403) return { kind: "unauthorized", status, message: message2 };
+  if (status !== 400 && status !== 422) return null;
+  return providerVerdict(status, errObj, message2) ?? {
+    kind: "validation",
+    status,
+    message: message2,
+    code: errObj.code,
+    details: errObj.details
+  };
+}
+function serverVerdict(status, errObj, message2) {
+  if (status >= 500 && errObj.retryable === false) {
+    return {
+      kind: "provider",
+      status,
+      provider: errObj.provider,
+      code: errObj.code ?? "server_error",
+      message: message2,
+      retryable: false
+    };
+  }
+  if (status === 504 || status === 502 && errObj.code === "provider_timeout") {
+    return { kind: "timeout", provider: errObj.provider, message: message2 };
+  }
+  if (status === 502) {
+    return {
+      kind: "provider",
+      status,
+      provider: errObj.provider,
+      code: errObj.code ?? "provider_error",
+      message: message2,
+      retryable: errObj.retryable ?? true
+    };
+  }
+  if (status >= 500 || status === 429) return { kind: "server", status, message: message2 };
+  return null;
+}
+function backoffMs(attempt) {
+  return 1e3 * 2 ** attempt;
+}
+function shouldRetry(err) {
+  if (err.kind === "server") return true;
+  if (err.kind === "provider" && err.retryable) return true;
+  return false;
+}
+
+// src/engine/nodes/ingest.ts
+import { execFile as execFileCb } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { createReadStream } from "fs";
+import { mkdtemp, readFile as readFile2, rm, stat as stat2 } from "fs/promises";
+import { tmpdir } from "os";
+import path2 from "path";
+import { promisify } from "util";
+import { z as z3 } from "zod";
+
+// src/engine/engine/define.ts
+function resolveOutputKinds(spec, params) {
+  if (!spec) return {};
+  return typeof spec === "function" ? spec(params) : spec;
+}
+function defineNode(def) {
+  return def;
+}
+
+// src/engine/lib/url.ts
+function looksLikeHttpUrl(value) {
+  return typeof value === "string" && /^https?:\/\//i.test(value.trim());
+}
+
+// src/engine/nodes/remote/upload.ts
+var PUT_MAX_ATTEMPTS = 4;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function presignAndPut(args) {
+  let lastFailure = null;
+  for (let attempt = 0; attempt < PUT_MAX_ATTEMPTS; attempt++) {
+    if (args.ctx.signal?.aborted) break;
+    if (attempt > 0) await sleep(500 * 2 ** (attempt - 1) * (1 + Math.random() * 0.25));
+    const result = await attemptPresignedPut(args);
+    if (result.ok) return result.url;
+    lastFailure = result.failure;
+    if (!result.retryable) break;
+  }
+  throw lastFailure ?? new Error("upload: aborted before the PUT could start");
+}
+async function attemptPresignedPut(args) {
+  try {
+    const { putUrl, publicUrl, conditional } = await args.ctx.client.presignAssetUpload(
+      args.sha256,
+      args.mime,
+      args.ctx.signal,
+      void 0,
+      true
+    );
+    const putRes = await fetch(putUrl, {
+      method: "PUT",
+      body: new Uint8Array(args.bytes),
+      // A conditional URL was signed WITH this header, so it must be sent exactly.
+      headers: conditional ? { "Content-Type": args.mime, "If-None-Match": "*" } : { "Content-Type": args.mime },
+      signal: args.ctx.signal
+    });
+    if (putRes.ok) return { ok: true, url: publicUrl };
+    if (conditional && putRes.status === 412) return { ok: true, url: publicUrl };
+    return {
+      ok: false,
+      failure: new Error(`upload: presigned PUT failed ${putRes.status} ${putRes.statusText}`),
+      // Only transient statuses warrant a replay — a 400/403 fails identically every attempt.
+      retryable: putRes.status >= 500 || putRes.status === 429 || putRes.status === 408
+    };
+  } catch (e) {
+    return {
+      ok: false,
+      failure: e instanceof Error ? e : new Error(String(e)),
+      retryable: args.ctx.signal?.aborted !== true
+    };
+  }
+}
+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/nodes/remote/delegate.ts
+function delegated(spec) {
+  return {
+    ...spec,
+    location: "remote",
+    execute: async ({ inputs, params, ctx }) => {
+      return await callBackendExec({
+        nodeType: spec.id,
+        nodeVersion: spec.version,
+        params,
+        inputs,
+        outputKinds: resolveOutputKinds(spec.outputKinds, params),
+        ctx
+      });
+    }
+  };
+}
+async function callBackendExec(args) {
+  try {
+    const serialized = await serializeInputs(args.inputs, args.ctx);
+    const idempotencyKey = args.ctx.cacheKey ? `${args.ctx.canvasRunId}:${args.ctx.cacheKey}` : void 0;
+    const res = await args.ctx.client.exec(
+      {
+        nodeType: args.nodeType,
+        nodeVersion: args.nodeVersion,
+        params: args.params,
+        inputs: serialized,
+        idempotency_key: idempotencyKey,
+        canvas_run_id: args.ctx.canvasRunId,
+        node_id: args.ctx.nodeId
+      },
+      args.ctx.signal
+    );
+    if (typeof res.credits_charged === "number") args.ctx.reportCharge?.(res.credits_charged);
+    return await ingestOutputs(res.outputs, args.ctx, args.outputKinds);
+  } catch (e) {
+    throw mapClientError(args.ctx, e);
+  }
+}
+async function serializeInputs(inputs, ctx) {
+  if (!inputs || typeof inputs !== "object") return {};
+  const out = {};
+  for (const [k, v] of Object.entries(inputs)) {
+    out[k] = await stripLocalRefs(v, ctx);
+  }
+  return out;
+}
+async function stripLocalRefs(value, ctx) {
+  if (Array.isArray(value)) return Promise.all(value.map((v) => stripLocalRefs(v, ctx)));
+  if (value && typeof value === "object") {
+    if ("kind" in value && "sha256" in value && "mime" in value) {
+      const ref = await ensureUploaded(value, ctx);
+      return {
+        kind: ref.kind,
+        url: ref.url,
+        sha256: ref.sha256,
+        mime: ref.mime,
+        metadata: ref.metadata
+      };
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = await stripLocalRefs(v, ctx);
+    return out;
+  }
+  return value;
+}
+async function ingestOutputs(outputs, ctx, kinds) {
+  const result = {};
+  for (const [name, value] of Object.entries(outputs)) {
+    const declaredKind = kinds[name];
+    result[name] = await ingestValue(value, ctx, declaredKind);
+  }
+  return result;
+}
+async function ingestValue(value, ctx, declaredKind) {
+  if (Array.isArray(value)) {
+    const out = [];
+    for (const v of value) out.push(await ingestValue(v, ctx, declaredKind));
+    return out;
+  }
+  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,
+      sha256: value.sha256,
+      mime: value.mime,
+      metadata: value.metadata
+    });
+  }
+  return value;
+}
+function isRawAsset(v) {
+  return Boolean(
+    v && typeof v === "object" && "url" in v && "sha256" in v && "mime" in v && typeof v.url === "string" && typeof v.sha256 === "string"
+  );
+}
+function mapClientError(ctx, e) {
+  if (e instanceof BackendHttpError) {
+    const d = e.detail;
+    if (d.kind === "provider") {
+      return new NodeExecutionError(ctx.nodeId, ctx.nodeType, {
+        kind: "remote",
+        status: d.status,
+        code: d.code,
+        message: d.message,
+        provider: d.provider,
+        // The backend's real classification — providerErr pins the status to 502,
+        // so this flag (not the status) is the source of truth for retryability.
+        retryable: d.retryable
+      });
+    }
+    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 });
+    }
+    if (d.kind === "validation") {
+      return new NodeExecutionError(ctx.nodeId, ctx.nodeType, {
+        kind: "remote",
+        status: d.status,
+        // The backend's own code (`model_invalid_params`, `cost_limit_exceeded`,
+        // `invalid_inputs`, …) says WHICH refusal; `invalid_params` only when it gave none.
+        code: d.code ?? "invalid_params",
+        message: d.message,
+        // The request itself was refused; it fails the same way until the input changes.
+        retryable: false
+      });
+    }
+    if (d.kind === "unauthorized") {
+      return new NodeExecutionError(ctx.nodeId, ctx.nodeType, {
+        kind: "remote",
+        status: d.status,
+        code: "unauthorized",
+        message: d.message
+      });
+    }
+    if (d.kind === "network") {
+      return new NodeExecutionError(ctx.nodeId, ctx.nodeType, { kind: "network", cause: d.cause });
+    }
+    return new NodeExecutionError(ctx.nodeId, ctx.nodeType, {
+      kind: "remote",
+      status: d.status,
+      code: "server_error",
+      message: d.message
+    });
+  }
+  return new NodeExecutionError(ctx.nodeId, ctx.nodeType, { kind: "local", cause: e });
+}
+
+// src/engine/nodes/ingest.ts
+var execFile = promisify(execFileCb);
+var ExpectEnum = z3.enum(["image", "video", "audio", "text", "json", "font"]);
+function coercePathUrlToUrl(input) {
+  if (!input || typeof input !== "object") return input;
+  const obj = input;
+  if (obj.source === "path" && looksLikeHttpUrl(obj.path)) {
+    const { path: _path, ...rest } = obj;
+    return { ...rest, source: "url", url: obj.path.trim() };
+  }
+  return input;
+}
+var IngestParams = z3.preprocess(
+  coercePathUrlToUrl,
+  z3.discriminatedUnion("source", [
+    z3.object({
+      source: z3.literal("url"),
+      url: z3.string().url(),
+      expect: ExpectEnum
+    }).strict(),
+    z3.object({
+      source: z3.literal("path"),
+      path: z3.string().min(1),
+      expect: ExpectEnum
+    }).strict()
+  ])
+);
+var IngestInputs = z3.object({}).strict();
+var IngestOutputs = z3.object({ asset: AssetRef }).strict();
+var RAW_TEXT_EXTENSIONS = [".txt", ".md"];
+function resolveStrategy(params) {
+  if (params.source === "path") return "local_file";
+  if (takesCanvasAssetVerbatim(params.url, params.expect)) return "canvas_asset";
+  switch (params.expect) {
+    case "video":
+    case "audio":
+      return "yt_dlp";
+    case "image":
+    case "json":
+    case "font":
+      return "direct_fetch";
+    case "text": {
+      const p = safePathname(params.url);
+      const isRawText = RAW_TEXT_EXTENSIONS.some((ext) => p.endsWith(ext));
+      return isRawText ? "direct_fetch" : "firecrawl";
+    }
+    default: {
+      params.expect;
+      throw new Error(`ingest: unhandled expect=${String(params.expect)}`);
+    }
+  }
+}
+function safePathname(rawUrl) {
+  try {
+    return new URL(rawUrl).pathname.toLowerCase();
+  } catch {
+    return "";
+  }
+}
+var ingestNode = defineNode({
+  id: "ingest",
+  version: "1.3.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: a canvas-assets URL (`\u2026/canvas-assets/<xx>/<sha>.<ext>`, the durable copy of an earlier output) is taken back byte-for-byte with its sha unchanged; yt-dlp for other video/audio (YouTube/TikTok/Vimeo/etc. and direct file URLs), Firecrawl for HTML/PDF pages \u2192 markdown, direct HTTP fetch for binary URLs (images, fonts) and raw .txt/.md. For source=path: read a committed file from the workspace and upload to R2.",
+  when_to_use: 'Use as the on-ramp for any external asset a canvas needs. `expect` makes the output port statically typed so downstream wiring is checked before any byte is fetched. Pick `source: "url"` for portable canvas; pick `source: "path"` only for a file committed to the workspace (`src/brand/\u2026`, `src/creatives/<slug>/assets/\u2026`) \u2014 the canvas is rendered again in other Sessions, which have only what is committed. To reuse an earlier output (a voice take, a clip, a frame), ingest its canvas-assets URL from the run outputs: it comes back with the same sha, so nothing downstream re-renders. Never point `path` into `canvas/` (`canvas/.cache/`, `canvas/r_*`): that folder is not committed, and validate rewrites a cache path to its canvas-assets URL. Compose with other nodes for richer pipelines (e.g. `ingest expect=video` \u2192 `video_transcribe`).',
+  inputs: IngestInputs,
+  params: IngestParams,
+  outputs: IngestOutputs,
+  cost: () => ({ credits: 0, seconds_estimate: 5 }),
+  // Output kind is declared in params, so validators/UI can type the port
+  // statically without running the node.
+  outputKinds: (params) => ({ asset: params.expect }),
+  async execute({ params, ctx }) {
+    const strategy = resolveStrategy(params);
+    const source = params.source === "url" ? params.url : params.path;
+    ctx.log(`ingest: ${strategy} (${params.expect}) ${source}`);
+    const asset = await runStrategy(strategy, params, ctx);
+    return { asset };
+  }
+});
+function runStrategy(strategy, params, ctx) {
+  if (params.source === "path") {
+    if (strategy !== "local_file") {
+      throw new Error(`ingest: invariant \u2014 source=path but strategy=${strategy}`);
+    }
+    return execLocalFile(params, ctx);
+  }
+  switch (strategy) {
+    case "canvas_asset":
+      return execCanvasAsset(params, ctx);
+    case "direct_fetch":
+      return execDirectFetch(params, ctx);
+    case "firecrawl":
+      return execFirecrawl(params, ctx);
+    case "yt_dlp":
+      return execYtDlp(params, ctx);
+    case "local_file":
+      throw new Error(`ingest: invariant \u2014 source=url but strategy=local_file`);
+    default: {
+      strategy;
+      throw new Error(`ingest: unhandled strategy=${String(strategy)}`);
+    }
+  }
+}
+function canvasAssetMime(url, expect) {
+  const address = parseCanvasAssetUrl(url);
+  const mime = address ? EXT_TO_MIME[address.ext] : void 0;
+  return mime !== void 0 && inferKindFromMime(mime) === expect ? mime : null;
+}
+function takesCanvasAssetVerbatim(url, expect) {
+  return isCanvasAssetOrigin(url) && canvasAssetMime(url, expect) !== null;
+}
+async function execCanvasAsset(params, ctx) {
+  const address = parseCanvasAssetUrl(params.url);
+  const mime = canvasAssetMime(params.url, params.expect);
+  if (!address || mime === null) throw new Error(`ingest: invariant \u2014 canvas_asset strategy for ${params.url}`);
+  try {
+    return await ctx.assets.ingestRemote({
+      kind: params.expect,
+      url: params.url,
+      sha256: address.sha256,
+      mime,
+      metadata: { strategy: "canvas_asset", source_url: params.url, ingested_at: (/* @__PURE__ */ new Date()).toISOString() }
+    });
+  } catch (e) {
+    throw localExecError(ctx, e.message);
+  }
+}
+async function execDirectFetch(params, ctx) {
+  if (params.expect === "image") {
+    return ingestImageUrl(params.url, ctx);
+  }
+  const result = await callBackendExec({
+    nodeType: "ingest",
+    nodeVersion: ingestNode.version,
+    params: { strategy: "direct_fetch", url: params.url, expect: params.expect },
+    inputs: {},
+    outputKinds: { asset: params.expect },
+    ctx
+  });
+  return assertAssetOutput(result, params.expect);
+}
+async function ingestImageUrl(url, ctx) {
+  let bytes;
+  try {
+    ({ buffer: bytes } = await fetchExternalBytes(url, { maxBytes: MAX_ASSET_BYTES }));
+  } catch (e) {
+    throw localExecError(ctx, `fetch ${url} \u2192 ${e.message}`);
+  }
+  let normalized;
+  try {
+    normalized = await toModelSafeImage(bytes);
+  } catch (e) {
+    throw localExecError(ctx, `${url}: ${e.message}`);
+  }
+  const note = normalizationNote(normalized);
+  if (note) ctx.log(`ingest: ${url} ${note}`);
+  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 execFirecrawl(params, ctx) {
+  const result = await callBackendExec({
+    nodeType: "ingest",
+    nodeVersion: ingestNode.version,
+    params: { strategy: "firecrawl", url: params.url },
+    inputs: {},
+    outputKinds: { asset: "text" },
+    ctx
+  });
+  return assertAssetOutput(result, "text");
+}
+function assertAssetOutput(result, expected) {
+  const asset = result.asset;
+  if (!asset || typeof asset !== "object" || !("kind" in asset)) {
+    throw new Error(`ingest: backend returned no asset (got ${JSON.stringify(result)})`);
+  }
+  if (asset.kind !== expected) {
+    throw new Error(`ingest: backend returned kind=${asset.kind} but expected ${expected}`);
+  }
+  return asset;
+}
+function resolveLocalPath(input) {
+  if (input.startsWith("~")) {
+    throw new Error(
+      `ingest: ~ path expansion is not supported (got "${input}"). Use an absolute path or a cwd-relative path.`
+    );
+  }
+  if (path2.isAbsolute(input)) return input;
+  return path2.resolve(process.cwd(), input);
+}
+var EXT_TO_MIME = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  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",
+  m4v: "video/mp4",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  m4a: "audio/mp4",
+  ogg: "audio/ogg",
+  flac: "audio/flac",
+  json: "application/json",
+  txt: "text/plain",
+  md: "text/markdown",
+  markdown: "text/markdown",
+  html: "text/html",
+  htm: "text/html",
+  csv: "text/csv",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  svg: "image/svg+xml"
+};
+var SVG_MIME = "image/svg+xml";
+var SVG_TARGET_LONGEST_PX = 2048;
+var SVG_BASE_DENSITY = 72;
+var SVG_MAX_DENSITY = 2400;
+function sniffSvg(buf) {
+  const head = buf.subarray(0, Math.min(buf.length, 512)).toString("utf8").trimStart();
+  return head.startsWith("<?xml") ? head.includes("<svg") : head.startsWith("<svg");
+}
+function inferMimeFromPath(absPath, sniffBytes) {
+  const ext = path2.extname(absPath).slice(1).toLowerCase();
+  const fromExt = EXT_TO_MIME[ext];
+  if (fromExt) return fromExt;
+  const fromBytes = sniffImageMime(sniffBytes);
+  if (fromBytes) return fromBytes;
+  if (sniffSvg(sniffBytes)) return SVG_MIME;
+  return "application/octet-stream";
+}
+async function rasterizeSvgToPng(bytes) {
+  const { default: sharp } = await import("sharp");
+  const base = await sharp(bytes).metadata();
+  const longest = Math.max(base.width ?? 0, base.height ?? 0);
+  let density = SVG_BASE_DENSITY;
+  if (longest > 0) {
+    const scaled = Math.round(SVG_BASE_DENSITY * SVG_TARGET_LONGEST_PX / longest);
+    density = Math.min(SVG_MAX_DENSITY, Math.max(SVG_BASE_DENSITY, scaled));
+  }
+  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"]);
+var MAX_MODEL_REFERENCE_BYTES = 30 * 1024 * 1024;
+async function fitWithinReferenceLimit(bytes, mime, maxBytes) {
+  if (bytes.byteLength <= maxBytes) return { bytes, mime };
+  const { default: sharp } = await import("sharp");
+  const read = () => sharp(bytes, { animated: true });
+  const meta = await read().metadata();
+  const animated = (meta.pages ?? 1) > 1;
+  const keepAlpha = meta.hasAlpha === true;
+  const width = meta.width ?? 0;
+  const encode = async (scale2) => {
+    let pipeline2 = read();
+    if (scale2 < 1 && width > 0) pipeline2 = pipeline2.resize({ width: Math.max(256, Math.round(width * scale2)) });
+    if (animated && mime === "image/gif") return { bytes: await pipeline2.gif().toBuffer(), mime: "image/gif" };
+    if (animated || keepAlpha) return { bytes: await pipeline2.webp({ quality: 90 }).toBuffer(), mime: "image/webp" };
+    return { bytes: await pipeline2.jpeg({ quality: 90, mozjpeg: true }).toBuffer(), mime: "image/jpeg" };
+  };
+  let out = await encode(1);
+  let scale = 1;
+  for (let pass = 0; pass < 4 && out.bytes.byteLength > maxBytes; pass++) {
+    scale *= Math.min(0.9, Math.sqrt(maxBytes / out.bytes.byteLength));
+    out = await encode(scale);
+  }
+  return out;
+}
+async function toModelSafeImage(bytes, opts) {
+  const maxBytes = opts?.maxBytes ?? MAX_MODEL_REFERENCE_BYTES;
+  const fitToModel = async (candidate, mime, rasterizedFrom) => {
+    const fitted = await fitWithinReferenceLimit(candidate, mime, maxBytes);
+    return {
+      bytes: fitted.bytes,
+      mime: fitted.mime,
+      ...rasterizedFrom ? { rasterizedFrom } : {},
+      ...fitted.bytes === candidate ? {} : { shrunkFromBytes: candidate.byteLength }
+    };
+  };
+  const safe = sniffImageMime(bytes);
+  if (safe && MODEL_SAFE_IMAGE_MIMES.has(safe)) {
+    return await fitToModel(bytes, safe);
+  }
+  if (sniffSvg(bytes)) {
+    return await fitToModel(await rasterizeSvgToPng(bytes), "image/png", "svg");
+  }
+  const { default: sharp } = await import("sharp");
+  let png;
+  let format;
+  try {
+    const img = sharp(bytes);
+    format = (await img.metadata()).format ?? "unknown";
+    png = await img.png({ force: true }).toBuffer();
+  } catch (e) {
+    throw new Error(`bytes are not a decodable image (${e.message})`);
+  }
+  return await fitToModel(png, "image/png", format);
+}
+function normalizationNote(image) {
+  const parts = [];
+  if (image.rasterizedFrom) parts.push(`normalized ${image.rasterizedFrom} -> ${image.mime}`);
+  if (image.shrunkFromBytes !== void 0) {
+    parts.push(
+      `fitted ${image.shrunkFromBytes}B -> ${image.bytes.length}B as ${image.mime} (providers refuse a reference over ${MAX_MODEL_REFERENCE_BYTES}B)`
+    );
+  }
+  return parts.length > 0 ? parts.join("; ") : null;
+}
+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 && hasAscii(buf, 1, "PNG")) return "image/png";
+  if (buf[0] === 255 && buf[1] === 216 && buf[2] === 255) return "image/jpeg";
+  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;
+  while (offset + 8 <= end) {
+    let size = buf.readUInt32BE(offset);
+    const boxType = buf.toString("ascii", offset + 4, offset + 8);
+    let headerLen = 8;
+    if (size === 1) {
+      if (offset + 16 > end) return null;
+      size = Number(buf.readBigUInt64BE(offset + 8));
+      headerLen = 16;
+    } else if (size === 0) {
+      size = end - offset;
+    }
+    if (size < headerLen || offset + size > end) return null;
+    if (boxType === type) return { start: offset + headerLen, end: offset + size };
+    offset += size;
+  }
+  return null;
+}
+var MVHD_DURATION_UNKNOWN = 4294967295;
+function mp4DurationMs(bytes) {
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);
+  const moov = findBoxPayload(buf, 0, buf.length, "moov");
+  if (!moov) return void 0;
+  const mvhd = findBoxPayload(buf, moov.start, moov.end, "mvhd");
+  if (!mvhd) return void 0;
+  const version = buf[mvhd.start];
+  const tsOffset = mvhd.start + 4 + (version === 1 ? 16 : 8);
+  if (version === 1) {
+    if (tsOffset + 12 > mvhd.end) return void 0;
+    const timescale2 = buf.readUInt32BE(tsOffset);
+    const duration2 = buf.readBigUInt64BE(tsOffset + 4);
+    if (timescale2 === 0 || duration2 === 0n) return void 0;
+    return Math.round(Number(duration2) / timescale2 * 1e3);
+  }
+  if (version !== 0) return void 0;
+  if (tsOffset + 8 > mvhd.end) return void 0;
+  const timescale = buf.readUInt32BE(tsOffset);
+  const duration = buf.readUInt32BE(tsOffset + 4);
+  if (timescale === 0 || duration === 0 || duration === MVHD_DURATION_UNKNOWN) return void 0;
+  return Math.round(duration / timescale * 1e3);
+}
+function inferKindFromMime(mime) {
+  if (mime.startsWith("image/")) return "image";
+  if (mime.startsWith("video/")) return "video";
+  if (mime.startsWith("audio/")) return "audio";
+  if (mime === "application/json") return "json";
+  if (mime.startsWith("text/")) return "text";
+  if (mime.startsWith("font/")) return "font";
+  return null;
+}
+function localExecError(ctx, message2) {
+  return new NodeExecutionError(ctx.nodeId, ctx.nodeType, {
+    kind: "local",
+    cause: new Error(`ingest: ${message2}`)
+  });
+}
+async function execLocalFile(params, ctx) {
+  const absPath = resolveLocalPath(params.path);
+  let stats;
+  try {
+    stats = await stat2(absPath);
+  } catch (e) {
+    const code = e.code;
+    if (code === "ENOENT") {
+      throw localExecError(ctx, `file_not_found: ${absPath}`);
+    }
+    if (code === "EACCES") {
+      throw localExecError(ctx, `permission_denied: ${absPath}`);
+    }
+    throw localExecError(ctx, `stat failed for ${absPath}: ${e.message}`);
+  }
+  if (!stats.isFile()) {
+    throw localExecError(ctx, `not_a_file: ${absPath} (isDirectory=${stats.isDirectory()})`);
+  }
+  if (stats.size > MAX_ASSET_BYTES) {
+    throw localExecError(ctx, `file_too_large: ${absPath} is ${stats.size} bytes (limit ${MAX_ASSET_BYTES})`);
+  }
+  let bytes;
+  try {
+    bytes = await readFile2(absPath);
+  } catch (e) {
+    if (e.code === "EACCES") {
+      throw localExecError(ctx, `permission_denied: ${absPath}`);
+    }
+    throw localExecError(ctx, `read failed for ${absPath}: ${e.message}`);
+  }
+  const mime = inferMimeFromPath(absPath, bytes);
+  const kind = inferKindFromMime(mime);
+  if (kind === null) {
+    throw localExecError(
+      ctx,
+      `kind_mismatch: ${absPath} has mime=${mime} which doesn't map to any ingest kind (image/video/audio/text/json/font). If this is a PDF and you want text extraction, host it via URL and use source="url".`
+    );
+  }
+  if (kind !== params.expect) {
+    throw localExecError(ctx, `kind_mismatch: expect=${params.expect} but ${absPath} has mime=${mime} (kind=${kind})`);
+  }
+  ctx.log(`ingest: local file ${stats.size}B mime=${mime}`);
+  let outBytes = bytes;
+  let outMime = mime;
+  let rasterizedFrom;
+  if (kind === "image") {
+    const normalized = await toModelSafeImage(bytes);
+    outBytes = normalized.bytes;
+    outMime = normalized.mime;
+    rasterizedFrom = normalized.rasterizedFrom;
+    const note = normalizationNote(normalized);
+    if (note) ctx.log(`ingest: ${note}`);
+  }
+  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, rasterizedFrom }),
+    ctx
+  });
+  return withProbedDuration(ref, durationMs);
+}
+function probeVideoDurationMs(expect, bytes, ctx) {
+  if (expect !== "video") return void 0;
+  const durationMs = mp4DurationMs(bytes);
+  if (durationMs !== void 0) ctx.log(`ingest: probed video duration ${durationMs}ms`);
+  return durationMs;
+}
+function localFileMetadata(args) {
+  return {
+    source_path: args.absPath,
+    strategy: "local_file",
+    ingested_at: (/* @__PURE__ */ new Date()).toISOString(),
+    file_size: args.fileSize,
+    original_filename: path2.basename(args.absPath),
+    ...args.rasterizedFrom ? { rasterized_from: args.rasterizedFrom } : {},
+    ...args.durationMs !== void 0 ? { duration_ms: args.durationMs } : {}
+  };
+}
+function withProbedDuration(ref, durationMs) {
+  if (durationMs === void 0 || ref.kind !== "video") return ref;
+  return { ...ref, duration_ms: durationMs };
+}
+var YT_DLP_MIME = {
+  image: "image/png",
+  video: "video/mp4",
+  audio: "audio/mp4",
+  text: "text/plain",
+  json: "application/json",
+  font: "font/ttf"
+  // unreachable — resolveStrategy never routes font to yt_dlp
+};
+async function execYtDlp(params, ctx) {
+  if (params.expect !== "video" && params.expect !== "audio") {
+    throw new Error(`ingest: yt_dlp only handles video/audio, got expect=${params.expect}`);
+  }
+  const workDir = await mkdtemp(path2.join(tmpdir(), "ingest-yt-"));
+  try {
+    const { filePath, info, reducedQuality } = await runYtDlpForNode({
+      url: params.url,
+      audioOnly: params.expect === "audio",
+      workDir,
+      ctx
+    });
+    const downloadedStats = await stat2(filePath);
+    if (downloadedStats.size > MAX_ASSET_BYTES) {
+      throw localExecError(
+        ctx,
+        `file_too_large: yt-dlp output for ${params.url} is ${downloadedStats.size} bytes (limit ${MAX_ASSET_BYTES})`
+      );
+    }
+    const bytes = await readFile2(filePath);
+    const kind = params.expect;
+    const mime = YT_DLP_MIME[kind];
+    const metadata = buildYtDlpMetadata(params.url, info);
+    if (reducedQuality) {
+      metadata.reduced_quality = true;
+      ctx.log(`ingest: ${params.url} was only available at reduced resolution`);
+    }
+    return await uploadAndIngest({ bytes, kind, mime, metadata, ctx });
+  } finally {
+    await rm(workDir, { recursive: true, force: true }).catch((e) => {
+      ctx.log(`ingest: tmp cleanup failed (${e.message})`);
+    });
+  }
+}
+async function runYtDlpForNode(args) {
+  try {
+    return await runYtDlp({
+      url: args.url,
+      audioOnly: args.audioOnly,
+      workDir: args.workDir,
+      onLog: (message2) => args.ctx.log(`ingest: ${message2}`)
+    });
+  } catch (error) {
+    if (error instanceof YtDlpError) {
+      throw new NodeExecutionError(args.ctx.nodeId, args.ctx.nodeType, {
+        kind: "local",
+        cause: new Error(describeYtDlpFailure(error.message, error.stderrTail))
+      });
+    }
+    throw error;
+  }
+}
+function describeYtDlpFailure(message2, stderrTail) {
+  const base = stderrTail ? `${message2}
+${stderrTail}` : message2;
+  if (!/CERTIFICATE_VERIFY_FAILED|SSL certificate problem/i.test(stderrTail)) return base;
+  return `${base}
+This machine could not verify the download's TLS certificate; the file itself is fine. Report it and leave this ingest as it is. Never copy the file out of canvas/ (the render cache or a run folder) to work around it: canvas/ is not committed, so the creative would fail every later publish. To reuse one of our own outputs, ingest its canvas-assets URL, which does not go through this downloader.`;
+}
+function buildYtDlpMetadata(sourceUrl, info) {
+  const out = {
+    source_url: sourceUrl,
+    strategy: "yt_dlp",
+    ingested_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (typeof info.title === "string") out.original_title = info.title;
+  if (typeof info.uploader === "string") out.original_uploader = info.uploader;
+  if (typeof info.duration === "number") out.original_duration_s = info.duration;
+  if (typeof info.webpage_url === "string") out.webpage_url = info.webpage_url;
+  if (typeof info.width === "number") out.width = info.width;
+  if (typeof info.height === "number") out.height = info.height;
+  return out;
+}
+async function uploadAndIngest(args) {
+  const sha = sha256Hex(args.bytes);
+  const publicUrl = await presignAndPut({ bytes: args.bytes, sha256: sha, mime: args.mime, ctx: args.ctx });
+  const localRef = await args.ctx.assets.ingestBytes({
+    bytes: args.bytes,
+    kind: args.kind,
+    mime: args.mime,
+    metadata: args.metadata
+  });
+  return { ...localRef, url: publicUrl };
+}
+async function ytDlpVersion() {
+  try {
+    const { stdout } = await execFile(YT_DLP_BIN, ["--version"], { encoding: "utf-8", maxBuffer: 64 * 1024 });
+    return stdout.trim();
+  } catch {
+    return "yt-dlp:unknown";
+  }
+}
+async function fileSha256(abs) {
+  const hash = createHash2("sha256");
+  for await (const chunk of createReadStream(abs)) hash.update(chunk);
+  return hash.digest("hex");
+}
+ingestNode.cacheKeyExtras = async ({ params }) => {
+  const p = params;
+  const extras = {};
+  if (p.source === "path" && typeof p.path === "string") {
+    try {
+      extras.local_file_sha256 = await fileSha256(resolveLocalPath(p.path));
+    } catch {
+    }
+  }
+  if (p.source === "url" && (p.expect === "video" || p.expect === "audio") && !(typeof p.url === "string" && takesCanvasAssetVerbatim(p.url, p.expect))) {
+    extras.yt_dlp_version = await ytDlpVersion();
+  }
+  return extras;
+};
+
+export {
+  looksLikeHttpUrl,
+  resolveOutputKinds,
+  defineNode,
+  isBlocking,
+  ValidationError,
+  NodeExecutionError,
+  RunAbortedError,
+  LayerExecutionError,
+  describeFailureReason,
+  runFailureCode,
+  failureDetail,
+  ImageRef,
+  VideoRef,
+  AudioRef,
+  JsonRef,
+  TextRef,
+  FontRef,
+  ASSET_KINDS,
+  contentShaOf,
+  isAssetRef,
+  isAssetRefArray,
+  isUrlOnlyRef,
+  isStageableRef,
+  sha256Hex,
+  MAX_ASSET_BYTES,
+  extForMime,
+  LocalAssetStore,
+  forEachString,
+  forEachObject,
+  mapStrings,
+  mapObjects,
+  mapObjectsAsync,
+  isPersistedAssetRef,
+  collectAssetRefLikes,
+  RemoteCacheStore,
+  LayeredCacheStore,
+  BackendHttpError,
+  HttpClient,
+  classifyBackendError,
+  persistOutputAssetUrls,
+  delegated,
+  callBackendExec,
+  coercePathUrlToUrl,
+  ingestNode,
+  canvasAssetMime,
+  inferMimeFromPath,
+  toModelSafeImage,
+  uploadAndIngest
+};
+//# sourceMappingURL=chunk-42NVYJLD.js.map