@koda-sl/baker-cli 0.477.0-dev.55c09e3e8 → 0.481.0-dev.2d33e194f

package/dist/chunk-VPBCR6DT.js

@@ -1,1743 +0,0 @@
-import {
-  YT_DLP_BIN,
-  YtDlpError,
-  runYtDlp
-} from "./chunk-6DE3EHEF.js";
-import {
-  fetchExternalBytes
-} from "./chunk-XLZMKMKD.js";
-import {
-  debugLogHttp,
-  readBodyForLog
-} from "./chunk-F4H6VVPE.js";
-import {
-  API_KEY_FORMAT_MESSAGE,
-  canvasAssetOriginsSetting,
-  isBakerApiKey
-} from "./chunk-G3UCXCC2.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/env.ts
-function credentialsFromEnv(env = process.env) {
-  const url = env.BAKER_API_URL;
-  const apiKey = env.BAKER_API_KEY;
-  if (!url || !apiKey) return null;
-  return { url, apiKey };
-}
-function requireCredentialsFromEnv(env = process.env) {
-  const c = credentialsFromEnv(env);
-  if (!c) {
-    throw new Error("missing BAKER_API_URL and/or BAKER_API_KEY environment variables");
-  }
-  if (!isBakerApiKey(c.apiKey)) {
-    throw new Error(`BAKER_API_KEY invalid: ${API_KEY_FORMAT_MESSAGE}`);
-  }
-  return c;
-}
-function remoteCacheEnabledFromEnv(env = process.env) {
-  return env.BAKER_CANVAS_REMOTE_CACHE !== "off";
-}
-function keyScopeFromEnv(env = process.env) {
-  return env.BAKER_KEY_SCOPE === "report" ? "report" : void 0;
-}
-
-// 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;
-  timeoutMs;
-  maxRetries;
-  fetchFn;
-  sleepFn;
-  authHeaders;
-  constructor(opts) {
-    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
-    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)));
-    const keyScope = opts.keyScope ?? keyScopeFromEnv();
-    this.authHeaders = {
-      Authorization: `Bearer ${opts.apiKey}`,
-      ...keyScope && { "x-baker-key-scope": keyScope }
-    };
-  }
-  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" ? this.authHeaders : { "Content-Type": "application/json", ...this.authHeaders },
-        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,
-  requireCredentialsFromEnv,
-  remoteCacheEnabledFromEnv,
-  BackendHttpError,
-  HttpClient,
-  classifyBackendError,
-  persistOutputAssetUrls,
-  delegated,
-  callBackendExec,
-  coercePathUrlToUrl,
-  ingestNode,
-  canvasAssetMime,
-  inferMimeFromPath,
-  toModelSafeImage,
-  uploadAndIngest
-};
-//# sourceMappingURL=chunk-VPBCR6DT.js.map