@koda-sl/baker-cli 0.204.0 → 0.209.0

package/dist/{chunk-5MPIOGRO.js → chunk-E2WYWHJJ.js}

@@ -1,7 +1,7 @@
 import {
   debugLogHttp,
   readBodyForLog
-} from "./chunk-UZYVSPCA.js";
+} from "./chunk-3E33AGNR.js";
 import {
   __commonJS,
   __toESM,
@@ -13,7 +13,7 @@ import {
   plannedRoutes,
   refuseNonPublicUrl,
   shouldEscalate
-} from "./chunk-6NZG2TCM.js";
+} from "./chunk-IRNM3T6B.js";
 
 // ../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js
 var require_safe_stable_stringify = __commonJS({
@@ -612,7 +612,7 @@ ${originalIndentation}`;
 });
 
 // src/engine/index.ts
-import path16 from "path";
+import path18 from "path";
 
 // src/engine/client/http.ts
 var CONTENT_POLICY_CODE = "content_policy_blocked";
@@ -661,17 +661,17 @@ var HttpClient = class {
     this.fetchFn = opts.fetchFn ?? fetch;
     this.sleepFn = opts.sleepFn ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   }
-  async postJson(path17, body, signal) {
-    return await this.requestJson("POST", path17, body, signal);
+  async postJson(path19, body, signal) {
+    return await this.requestJson("POST", path19, body, signal);
   }
-  async putJson(path17, body, signal) {
-    return await this.requestJson("PUT", path17, body, signal);
+  async putJson(path19, body, signal) {
+    return await this.requestJson("PUT", path19, body, signal);
   }
-  async getJson(path17, signal) {
-    return await this.requestJson("GET", path17, void 0, signal);
+  async getJson(path19, signal) {
+    return await this.requestJson("GET", path19, void 0, signal);
   }
-  async requestJson(method, path17, body, signal) {
-    const url = `${this.baseUrl}${path17.startsWith("/") ? path17 : `/${path17}`}`;
+  async requestJson(method, path19, body, signal) {
+    const url = `${this.baseUrl}${path19.startsWith("/") ? path19 : `/${path19}`}`;
     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;
@@ -834,12 +834,12 @@ var BackendClient = class {
   }
   async pollJob(jobId, signal) {
     const deadline = Date.now() + JOB_POLL_MAX_MS;
-    const path17 = `/api/canvas/jobs/${encodeURIComponent(jobId)}`;
+    const path19 = `/api/canvas/jobs/${encodeURIComponent(jobId)}`;
     for (let attempt = 0; ; attempt++) {
       if (signal?.aborted) {
         throw new BackendHttpError({ kind: "network", cause: signal.reason ?? new Error("aborted") });
       }
-      const job = await this.http.getJson(path17, signal);
+      const job = await this.http.getJson(path19, signal);
       if (job.status === "completed") return job.result;
       if (job.status === "failed") throw failedJobError(job.error);
       if (Date.now() > deadline) {
@@ -918,8 +918,8 @@ var BackendClient = class {
     await this.http.postJson("/api/creatives/definition", payload, signal);
   }
   getArtifact(kind, name, version, signal) {
-    const path17 = version ? `/api/canvas/artifacts/${encodeURIComponent(kind)}/${encodeURIComponent(name)}/${encodeURIComponent(version)}` : `/api/canvas/artifacts/${encodeURIComponent(kind)}/${encodeURIComponent(name)}`;
-    return this.http.getJson(path17, signal);
+    const path19 = version ? `/api/canvas/artifacts/${encodeURIComponent(kind)}/${encodeURIComponent(name)}/${encodeURIComponent(version)}` : `/api/canvas/artifacts/${encodeURIComponent(kind)}/${encodeURIComponent(name)}`;
+    return this.http.getJson(path19, signal);
   }
 };
 
@@ -4289,9 +4289,9 @@ function checkOutputRef(ctx) {
 function pushZodIssues(issues, err, pathPrefix, code, nodeId, nodeType) {
   for (const issue of err.issues) {
     const tail2 = pathToString(issue.path);
-    const path17 = pathPrefix ? tail2 ? `${pathPrefix}.${tail2}` : pathPrefix : tail2;
+    const path19 = pathPrefix ? tail2 ? `${pathPrefix}.${tail2}` : pathPrefix : tail2;
     issues.push({
-      path: path17,
+      path: path19,
       code,
       message: issue.message,
       received: issue.code === "invalid_type" ? issue.received : void 0,
@@ -4300,8 +4300,8 @@ function pushZodIssues(issues, err, pathPrefix, code, nodeId, nodeType) {
     });
   }
 }
-function pathToString(path17) {
-  return path17.map((p) => typeof p === "number" ? `[${p}]` : `.${String(p)}`).join("").replace(/^\./, "");
+function pathToString(path19) {
+  return path19.map((p) => typeof p === "number" ? `[${p}]` : `.${String(p)}`).join("").replace(/^\./, "");
 }
 function buildDepGraph(canvas) {
   const graph = /* @__PURE__ */ new Map();
@@ -4910,10 +4910,10 @@ var NodeRegistry = class {
 };
 
 // src/engine/nodes/ingest.ts
-import { execFile as execFileCb, spawn } from "child_process";
-import { mkdtemp, readdir, readFile as readFile3, rm, stat as stat2 } from "fs/promises";
+import { execFile as execFileCb } from "child_process";
+import { mkdtemp, readFile as readFile4, rm, stat as stat2 } from "fs/promises";
 import { tmpdir } from "os";
-import path4 from "path";
+import path6 from "path";
 import { promisify } from "util";
 import { z as z5 } from "zod";
 
@@ -5231,6 +5231,248 @@ async function fetchExternalBytes(url, options) {
   return { buffer, contentType: response.headers.get("content-type") };
 }
 
+// src/lib/ytDlp.ts
+import { spawn } from "child_process";
+import { readdir, readFile as readFile3 } from "fs/promises";
+import path5 from "path";
+
+// src/lib/vimeoCookie.ts
+import { writeFile as writeFile3 } from "fs/promises";
+import path4 from "path";
+var COOKIE_NAME = "vimeo";
+async function writeVimeoCookieFile(cookie, workDir) {
+  const value = cookie?.trim();
+  if (!value) return void 0;
+  const expires = Math.floor(Date.now() / 1e3) + 365 * 24 * 60 * 60;
+  const jar = [
+    "# Netscape HTTP Cookie File",
+    [".vimeo.com", "TRUE", "/", "TRUE", String(expires), COOKIE_NAME, value].join("	"),
+    ""
+  ].join("\n");
+  const filePath = path4.join(workDir, "vimeo-cookies.txt");
+  await writeFile3(filePath, jar, { mode: 384 });
+  return filePath;
+}
+var VIMEO_AUTH_SIGNATURES = ["oauth token", "only works when logged-in", "unable to fetch new oauth tokens"];
+function isVimeoAuthFailure(detail) {
+  const haystack = detail.toLowerCase();
+  if (!haystack.includes("[vimeo]")) return false;
+  return VIMEO_AUTH_SIGNATURES.some((signature) => haystack.includes(signature));
+}
+
+// src/lib/ytDlpSignal.ts
+var HTTP_ERROR = /HTTP Error (\d{3})/i;
+var CHALLENGE_PHRASES = [
+  "sign in to confirm you're not a bot",
+  "sign in to confirm you\u2019re not a bot",
+  "confirm you are not a bot",
+  "unusual traffic",
+  "captcha"
+];
+var NOT_A_BLOCK_PHRASES = ["private video", "video unavailable", "members-only", "this video is available to"];
+var PROXY_TUNNEL_FAILURE = /tunnel connection failed: 407|proxy authentication required|http error 407/i;
+function ytDlpBlockSignal(stderr) {
+  const text = stderr.toLowerCase();
+  if (PROXY_TUNNEL_FAILURE.test(stderr)) return { status: 407 };
+  if (NOT_A_BLOCK_PHRASES.some((phrase) => text.includes(phrase))) return {};
+  const status = HTTP_ERROR.exec(stderr);
+  if (status) return { status: Number(status[1]) };
+  if (CHALLENGE_PHRASES.some((phrase) => text.includes(phrase))) return { challenge: true };
+  return {};
+}
+
+// src/lib/ytDlp.ts
+var YT_DLP_BIN = "yt-dlp";
+var YT_DLP_TIMEOUT_MS = 10 * 60 * 1e3;
+var YT_DLP_PROBE_TIMEOUT_MS = 60 * 1e3;
+var YtDlpError = class extends Error {
+  constructor(message2, stderrTail) {
+    super(message2);
+    this.stderrTail = stderrTail;
+    this.name = "YtDlpError";
+  }
+  stderrTail;
+};
+function tail(text, maxLines) {
+  return text.split("\n").slice(-maxLines).join("\n");
+}
+async function runYtDlp(args) {
+  const outTemplate = path5.join(args.workDir, "out.%(ext)s");
+  const infoPath = path5.join(args.workDir, "out.info.json");
+  const argv = [
+    args.url,
+    "--no-playlist",
+    "--no-progress",
+    "--no-warnings",
+    "--quiet",
+    "--write-info-json",
+    "-o",
+    outTemplate
+  ];
+  if (args.audioOnly) {
+    argv.push("-x", "--audio-format", "m4a");
+  } else {
+    const format = args.maxHeight ? `bv*[height<=${args.maxHeight}]+ba/b[height<=${args.maxHeight}]/bv*+ba/b` : "bv*+ba/b";
+    argv.push("--format", format, "--merge-output-format", "mp4");
+  }
+  const cookieFile = await writeVimeoCookieFile(args.vimeoCookie, args.workDir);
+  if (cookieFile) argv.push("--cookies", cookieFile);
+  args.onLog?.(`yt-dlp: downloading ${args.audioOnly ? "audio" : "video"}`);
+  const { code, stderr, tier } = await runViaLadder({
+    url: args.url,
+    argv,
+    timeoutMs: args.timeoutMs ?? YT_DLP_TIMEOUT_MS,
+    onLog: args.onLog,
+    country: args.country
+  });
+  if (code !== 0) {
+    throw new YtDlpError(`yt-dlp exited ${code}`, tail(stderr, 40));
+  }
+  const files = await readdir(args.workDir);
+  const wanted = args.audioOnly ? ".m4a" : ".mp4";
+  const downloaded = files.find((f) => f.startsWith("out.") && f.endsWith(wanted));
+  if (!downloaded) {
+    throw new YtDlpError(`yt-dlp finished but produced no ${wanted} file (saw: ${files.join(", ")})`, "");
+  }
+  let info = {};
+  try {
+    info = JSON.parse(await readFile3(infoPath, "utf-8"));
+  } catch {
+  }
+  return { filePath: path5.join(args.workDir, downloaded), info, tier };
+}
+async function probeYtDlp(args) {
+  const argv = [
+    args.url,
+    "--no-playlist",
+    "--no-warnings",
+    "--dump-single-json",
+    "--skip-download",
+    // Without this the probe fails wherever the *download* would fail, which
+    // defeats the point of probing: yt-dlp still runs format selection for
+    // `--dump-single-json`, so a binary too old to read a site's format list
+    // exits "Requested format is not available" and we learn nothing — measured
+    // against a stale build, which returned full metadata the moment this flag
+    // was added. Duration and id come from the page, not from a format.
+    "--ignore-no-formats-error"
+  ];
+  if (args.cookieDir) {
+    const cookieFile = await writeVimeoCookieFile(args.vimeoCookie, args.cookieDir);
+    if (cookieFile) argv.push("--cookies", cookieFile);
+  }
+  let stdout = "";
+  const { code, stderr, tier } = await walkYtDlpLadder({
+    url: args.url,
+    credentials: captureProxyCredentials(),
+    attempt: async (route) => {
+      const result = await spawnAndWait(YT_DLP_BIN, argv, args.timeoutMs ?? YT_DLP_PROBE_TIMEOUT_MS, {
+        extraEnv: proxyEnvFor(route),
+        captureStdout: true
+      });
+      stdout = result.stdout ?? "";
+      return result;
+    },
+    onLog: args.onLog,
+    country: args.country
+  });
+  if (code !== 0) {
+    throw new YtDlpError(`yt-dlp exited ${code}`, tail(stderr, 40));
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    throw new YtDlpError("yt-dlp returned metadata that could not be read", tail(stdout, 5));
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    throw new YtDlpError("yt-dlp returned no metadata for that link", tail(stderr, 40));
+  }
+  return { info: parsed, tier };
+}
+function isAudioOnly(info) {
+  return info.vcodec === "none";
+}
+function durationSeconds(info) {
+  const raw = info.duration;
+  return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? raw : void 0;
+}
+function canonicalUrl(info) {
+  const raw = info.webpage_url;
+  return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+async function walkYtDlpLadder(args) {
+  const routes = plannedRoutes(args.url, args.credentials, args.country ? { country: args.country } : void 0);
+  let last = { code: -1, stderr: "", tier: "direct" };
+  for (const route of routes) {
+    const tier = route.kind === "proxy" ? route.tier : "direct";
+    if (route.kind === "proxy") args.onLog?.(`yt-dlp: retrying via ${tier}`);
+    last = { ...await args.attempt(route), tier };
+    if (last.code === 0) return last;
+    if (!shouldEscalate(ytDlpBlockSignal(last.stderr))) return last;
+  }
+  return last;
+}
+function runViaLadder(args) {
+  return walkYtDlpLadder({
+    url: args.url,
+    credentials: captureProxyCredentials(),
+    attempt: (route) => spawnAndWait(YT_DLP_BIN, args.argv, args.timeoutMs, { extraEnv: proxyEnvFor(route) }),
+    onLog: args.onLog,
+    country: args.country
+  });
+}
+function proxyEnvFor(route) {
+  if (route.kind !== "proxy") return void 0;
+  const uri = new URL(route.server);
+  uri.username = encodeURIComponent(route.username);
+  uri.password = encodeURIComponent(route.password);
+  return {
+    HTTP_PROXY: uri.toString(),
+    HTTPS_PROXY: uri.toString(),
+    http_proxy: uri.toString(),
+    https_proxy: uri.toString()
+  };
+}
+function spawnAndWait(bin, argv, timeoutMs, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, argv, {
+      stdio: ["ignore", "pipe", "pipe"],
+      // `childEnvWith` because `spawn`'s `env` REPLACES the environment rather
+      // than extending it — passing only the additions would strip PATH.
+      ...options.extraEnv ? { env: childEnvWith(options.extraEnv) } : {}
+    });
+    const stderrChunks = [];
+    const stdoutChunks = [];
+    let stderrLen = 0;
+    const MAX_STDERR = 256 * 1024;
+    child.stdout.on("data", (chunk) => {
+      if (options.captureStdout) stdoutChunks.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      if (stderrLen < MAX_STDERR) {
+        stderrChunks.push(chunk);
+        stderrLen += chunk.length;
+      }
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      reject(new Error(`${bin} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(new Error(`failed to spawn "${bin}" \u2014 ${err.message}`));
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        code: code ?? -1,
+        stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+        ...options.captureStdout ? { stdout: Buffer.concat(stdoutChunks).toString("utf-8") } : {}
+      });
+    });
+  });
+}
+
 // src/engine/schema/refs.ts
 import { z as z4 } from "zod";
 
@@ -5426,25 +5668,6 @@ function mapClientError(ctx, e) {
   return new NodeExecutionError(ctx.nodeId, ctx.nodeType, { kind: "local", cause: e });
 }
 
-// src/engine/nodes/ytDlpSignal.ts
-var HTTP_ERROR = /HTTP Error (\d{3})/i;
-var CHALLENGE_PHRASES = [
-  "sign in to confirm you're not a bot",
-  "sign in to confirm you\u2019re not a bot",
-  "confirm you are not a bot",
-  "unusual traffic",
-  "captcha"
-];
-var NOT_A_BLOCK_PHRASES = ["private video", "video unavailable", "members-only", "this video is available to"];
-function ytDlpBlockSignal(stderr) {
-  const text = stderr.toLowerCase();
-  if (NOT_A_BLOCK_PHRASES.some((phrase) => text.includes(phrase))) return {};
-  const status = HTTP_ERROR.exec(stderr);
-  if (status) return { status: Number(status[1]) };
-  if (CHALLENGE_PHRASES.some((phrase) => text.includes(phrase))) return { challenge: true };
-  return {};
-}
-
 // src/engine/nodes/ingest.ts
 var execFile = promisify(execFileCb);
 var ExpectEnum = z5.enum(["image", "video", "audio", "text", "json", "font"]);
@@ -5617,8 +5840,8 @@ function resolveLocalPath(input) {
       `ingest: ~ path expansion is not supported (got "${input}"). Use an absolute path or a cwd-relative path.`
     );
   }
-  if (path4.isAbsolute(input)) return input;
-  return path4.resolve(process.cwd(), input);
+  if (path6.isAbsolute(input)) return input;
+  return path6.resolve(process.cwd(), input);
 }
 var EXT_TO_MIME = {
   png: "image/png",
@@ -5666,7 +5889,7 @@ function sniffSvg(buf) {
   return head.startsWith("<?xml") ? head.includes("<svg") : head.startsWith("<svg");
 }
 function inferMimeFromPath(absPath, sniffBytes) {
-  const ext = path4.extname(absPath).slice(1).toLowerCase();
+  const ext = path6.extname(absPath).slice(1).toLowerCase();
   const fromExt = EXT_TO_MIME[ext];
   if (fromExt) return fromExt;
   const fromBytes = sniffImageMime(sniffBytes);
@@ -5805,7 +6028,7 @@ async function execLocalFile(params, ctx) {
   }
   let bytes;
   try {
-    bytes = await readFile3(absPath);
+    bytes = await readFile4(absPath);
   } catch (e) {
     if (e.code === "EACCES") {
       throw localExecError(ctx, `permission_denied: ${absPath}`);
@@ -5856,7 +6079,7 @@ function localFileMetadata(args) {
     strategy: "local_file",
     ingested_at: (/* @__PURE__ */ new Date()).toISOString(),
     file_size: args.fileSize,
-    original_filename: path4.basename(args.absPath),
+    original_filename: path6.basename(args.absPath),
     ...args.rasterizedFrom ? { rasterized_from: args.rasterizedFrom } : {},
     ...args.durationMs !== void 0 ? { duration_ms: args.durationMs } : {}
   };
@@ -5865,8 +6088,6 @@ function withProbedDuration(ref, durationMs) {
   if (durationMs === void 0 || ref.kind !== "video") return ref;
   return { ...ref, duration_ms: durationMs };
 }
-var YT_DLP_BIN = "yt-dlp";
-var YT_DLP_TIMEOUT_MS = 10 * 60 * 1e3;
 var YT_DLP_MIME = {
   image: "image/png",
   video: "video/mp4",
@@ -5880,9 +6101,9 @@ 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(path4.join(tmpdir(), "ingest-yt-"));
+  const workDir = await mkdtemp(path6.join(tmpdir(), "ingest-yt-"));
   try {
-    const { filePath, info } = await runYtDlp({
+    const { filePath, info } = await runYtDlpForNode({
       url: params.url,
       audioOnly: params.expect === "audio",
       workDir,
@@ -5895,7 +6116,7 @@ async function execYtDlp(params, ctx) {
         `file_too_large: yt-dlp output for ${params.url} is ${downloadedStats.size} bytes (limit ${MAX_ASSET_BYTES})`
       );
     }
-    const bytes = await readFile3(filePath);
+    const bytes = await readFile4(filePath);
     const kind = params.expect;
     const mime = YT_DLP_MIME[kind];
     const metadata = buildYtDlpMetadata(params.url, info);
@@ -5906,69 +6127,24 @@ async function execYtDlp(params, ctx) {
     });
   }
 }
-async function runYtDlpViaLadder(url, argv, ctx) {
-  const routes = plannedRoutes(url, captureProxyCredentials());
-  let last = { code: -1, stderr: "" };
-  for (const route of routes) {
-    if (route.kind === "proxy") ctx.log(`ingest: retrying yt-dlp via ${route.tier}`);
-    last = await spawnAndWait(YT_DLP_BIN, argv, YT_DLP_TIMEOUT_MS, proxyEnvFor(route));
-    if (last.code === 0) return last;
-    if (!shouldEscalate(ytDlpBlockSignal(last.stderr))) return last;
-  }
-  return last;
-}
-function proxyEnvFor(route) {
-  if (route.kind !== "proxy") return void 0;
-  const uri = new URL(route.server);
-  uri.username = encodeURIComponent(route.username);
-  uri.password = encodeURIComponent(route.password);
-  return {
-    HTTP_PROXY: uri.toString(),
-    HTTPS_PROXY: uri.toString(),
-    http_proxy: uri.toString(),
-    https_proxy: uri.toString()
-  };
-}
-async function runYtDlp(args) {
-  const outTemplate = path4.join(args.workDir, "out.%(ext)s");
-  const infoPath = path4.join(args.workDir, "out.info.json");
-  const argv = [
-    args.url,
-    "--no-playlist",
-    "--no-progress",
-    "--no-warnings",
-    "--quiet",
-    "--write-info-json",
-    "-o",
-    outTemplate
-  ];
-  if (args.audioOnly) {
-    argv.push("-x", "--audio-format", "m4a");
-  } else {
-    argv.push("--format", "bv*+ba/b", "--merge-output-format", "mp4");
-  }
-  args.ctx.log(`ingest: spawning yt-dlp (${args.audioOnly ? "audio" : "video"})`);
-  const { code, stderr } = await runYtDlpViaLadder(args.url, argv, args.ctx);
-  if (code !== 0) {
-    throw new NodeExecutionError(args.ctx.nodeId, args.ctx.nodeType, {
-      kind: "local",
-      cause: new Error(`yt-dlp exited ${code}
-${tail(stderr, 40)}`)
-    });
-  }
-  const files = await readdir(args.workDir);
-  const wanted = args.audioOnly ? ".m4a" : ".mp4";
-  const downloaded = files.find((f) => f.startsWith("out.") && f.endsWith(wanted));
-  if (!downloaded) {
-    throw new Error(`ingest: yt-dlp finished but no ${wanted} file in ${args.workDir} (saw: ${files.join(", ")})`);
-  }
-  let info = {};
+async function runYtDlpForNode(args) {
   try {
-    const raw = await readFile3(infoPath, "utf-8");
-    info = JSON.parse(raw);
-  } catch {
+    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(error.stderrTail ? `${error.message}
+${error.stderrTail}` : error.message)
+      });
+    }
+    throw error;
   }
-  return { filePath: path4.join(args.workDir, downloaded), info };
 }
 function buildYtDlpMetadata(sourceUrl, info) {
   const out = {
@@ -5995,41 +6171,6 @@ async function uploadAndIngest(args) {
   });
   return { ...localRef, url: publicUrl };
 }
-function spawnAndWait(bin, argv, timeoutMs, env) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(bin, argv, {
-      stdio: ["ignore", "pipe", "pipe"],
-      ...env ? { env: childEnvWith(env) } : {}
-    });
-    const stderrChunks = [];
-    let stderrLen = 0;
-    const MAX_STDERR = 256 * 1024;
-    child.stdout.on("data", () => {
-    });
-    child.stderr.on("data", (chunk) => {
-      if (stderrLen < MAX_STDERR) {
-        stderrChunks.push(chunk);
-        stderrLen += chunk.length;
-      }
-    });
-    const timer = setTimeout(() => {
-      child.kill("SIGKILL");
-      reject(new Error(`ingest: ${bin} timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      reject(new Error(`ingest: failed to spawn "${bin}" \u2014 ${err.message}`));
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      resolve({ code: code ?? -1, stderr: Buffer.concat(stderrChunks).toString("utf8") });
-    });
-  });
-}
-function tail(text, maxLines) {
-  const lines = text.split("\n");
-  return lines.slice(-maxLines).join("\n");
-}
 async function ytDlpVersion() {
   try {
     const { stdout } = await execFile(YT_DLP_BIN, ["--version"], { encoding: "utf-8", maxBuffer: 64 * 1024 });
@@ -6060,9 +6201,9 @@ import { z as z6 } from "zod";
 
 // src/engine/nodes/local/lib/cli-runner.ts
 import { execFile as execFileCb2, spawn as spawn2 } from "child_process";
-import { copyFile as copyFile2, mkdtemp as mkdtemp2, readFile as readFile4, rm as rm2, stat as stat3 } from "fs/promises";
+import { copyFile as copyFile2, mkdtemp as mkdtemp2, readFile as readFile5, rm as rm2, stat as stat3 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import path5 from "path";
+import path7 from "path";
 import { promisify as promisify2 } from "util";
 var execFile2 = promisify2(execFileCb2);
 var DEFAULT_TIMEOUT_MS2 = 10 * 60 * 1e3;
@@ -6089,7 +6230,7 @@ function mimeForExt(ext) {
 }
 function extForAssetRef(ref) {
   if (ref.path) {
-    const e = path5.extname(ref.path);
+    const e = path7.extname(ref.path);
     if (e) return e;
   }
   const reverse = {
@@ -6111,14 +6252,14 @@ function planArrayInputSlot(tmpDir, slot, values, lookup, stagedInputs) {
     const ref = values[i];
     if (!ref) continue;
     if (!ref.path) throw new Error(`cli-runner: inputs.${slot}[${i}] has no local path`);
-    const dest = path5.join(tmpDir, `in_${slot}_${i}${extForAssetRef(ref)}`);
+    const dest = path7.join(tmpDir, `in_${slot}_${i}${extForAssetRef(ref)}`);
     stagedInputs.push({ srcPath: ref.path, destPath: dest });
     lookup.set(`in.${slot}.${i}`, dest);
   }
 }
 function planSingleInputSlot(tmpDir, slot, ref, lookup, stagedInputs) {
   if (!ref.path) throw new Error(`cli-runner: inputs.${slot} has no local path`);
-  const dest = path5.join(tmpDir, `in_${slot}${extForAssetRef(ref)}`);
+  const dest = path7.join(tmpDir, `in_${slot}${extForAssetRef(ref)}`);
   stagedInputs.push({ srcPath: ref.path, destPath: dest });
   lookup.set(`in.${slot}`, dest);
 }
@@ -6126,7 +6267,7 @@ function planOutputs(tmpDir, outputs, lookup) {
   const outputPaths = [];
   for (const [name, spec] of Object.entries(outputs)) {
     const ext = spec.ext.startsWith(".") ? spec.ext : `.${spec.ext}`;
-    const absPath = path5.join(tmpDir, `out_${name}${ext}`);
+    const absPath = path7.join(tmpDir, `out_${name}${ext}`);
     outputPaths.push({ name, absPath, spec });
     lookup.set(`out.${name}`, absPath);
   }
@@ -6167,8 +6308,8 @@ function rejectRawPaths(substituted, original, stagingDir) {
     throw new Error(`cli-runner: home-relative path "${original}" not allowed in args.`);
   }
   if (substituted.startsWith("/")) {
-    const resolved = path5.resolve(substituted);
-    if (!resolved.startsWith(`${stagingDir}${path5.sep}`) && resolved !== stagingDir) {
+    const resolved = path7.resolve(substituted);
+    if (!resolved.startsWith(`${stagingDir}${path7.sep}`) && resolved !== stagingDir) {
       throw new Error(
         `cli-runner: raw filesystem path "${original}" not allowed \u2014 declare an input slot and use {{in.<slot>}} instead.`
       );
@@ -6218,7 +6359,7 @@ function tailLines(text, maxLines) {
 }
 async function runCli(opts) {
   const { bin, args, inputs, outputs, ctx, timeoutMs = DEFAULT_TIMEOUT_MS2 } = opts;
-  const tmpDir = await mkdtemp2(path5.join(tmpdir2(), `cli-${bin.replace(/[^a-z0-9]/gi, "")}-`));
+  const tmpDir = await mkdtemp2(path7.join(tmpdir2(), `cli-${bin.replace(/[^a-z0-9]/gi, "")}-`));
   try {
     const { lookup, stagedInputs, outputPaths } = planPlaceholders(tmpDir, inputs, outputs);
     await stageInputs(stagedInputs);
@@ -6240,7 +6381,7 @@ ${tailLines(stderr, 40)}`);
       if (!s?.isFile() || s.size === 0) {
         throw new Error(`cli-runner: declared output "${name}" missing or empty at ${absPath}`);
       }
-      const bytes = await readFile4(absPath);
+      const bytes = await readFile5(absPath);
       const ref = await ctx.assets.ingestBytes({
         bytes: Buffer.from(bytes),
         kind: spec.kind,
@@ -6495,20 +6636,20 @@ var ffmpegNode = defineNode({
 });
 
 // src/engine/nodes/local/fontSpecimen.ts
-import { mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { mkdtemp as mkdtemp3, rm as rm3, writeFile as writeFile4 } from "fs/promises";
 import { createRequire } from "module";
 import { tmpdir as tmpdir3 } from "os";
-import path7 from "path";
+import path9 from "path";
 import { z as z9 } from "zod";
 
 // src/engine/nodes/local/lib/assets.ts
-import { copyFile as copyFile3, readFile as readFile5 } from "fs/promises";
-import path6 from "path";
+import { copyFile as copyFile3, readFile as readFile6 } from "fs/promises";
+import path8 from "path";
 async function stageAsset(ref, destDir, filename) {
   if (!ref.path) {
     throw new Error(`stageAsset: ref (${ref.kind}/${ref.mime}) has no local path`);
   }
-  const dest = path6.join(destDir, filename);
+  const dest = path8.join(destDir, filename);
   await copyFile3(ref.path, dest);
   return dest;
 }
@@ -6517,7 +6658,7 @@ async function refToUrl(ref) {
   if (!ref.path) {
     throw new Error("refToUrl: AssetRef has neither url nor path");
   }
-  const bytes = await readFile5(ref.path);
+  const bytes = await readFile6(ref.path);
   return `data:${ref.mime};base64,${bytes.toString("base64")}`;
 }
 var ASSET_KINDS = /* @__PURE__ */ new Set(["image", "video", "audio", "json", "text", "font"]);
@@ -6591,12 +6732,12 @@ var fontSpecimenNode = defineNode({
   outputKinds: { image: "image" },
   cost: () => ({ credits: 0, seconds_estimate: 5 }),
   async execute({ inputs, params, ctx }) {
-    const tmp = await mkdtemp3(path7.join(tmpdir3(), "font-specimen-"));
+    const tmp = await mkdtemp3(path9.join(tmpdir3(), "font-specimen-"));
     try {
       const fontFilename = `font.${extForMime(inputs.font.mime)}`;
       await stageAsset(inputs.font, tmp, fontFilename);
-      const entryPath = path7.join(tmp, "index.html");
-      await writeFile3(entryPath, buildSpecimenHtml(params, fontFilename), "utf-8");
+      const entryPath = path9.join(tmp, "index.html");
+      await writeFile4(entryPath, buildSpecimenHtml(params, fontFilename), "utf-8");
       ctx.log(`rendering specimen (${params.font_size}px, ${params.text.split("\n").length} lines)`);
       const pwSpecifier = ["play", "wright"].join("");
       const playwright = require_(pwSpecifier);
@@ -6679,16 +6820,16 @@ var fontSpecimenNode = defineNode({
 
 // src/engine/nodes/local/hyperframe.ts
 import { execFile as execFile4 } from "child_process";
-import { copyFile as copyFile4, mkdtemp as mkdtemp4, readFile as readFile9, rm as rm4, stat as stat5, writeFile as writeFile5 } from "fs/promises";
+import { copyFile as copyFile4, mkdtemp as mkdtemp4, readFile as readFile10, rm as rm4, stat as stat5, writeFile as writeFile6 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
 import { cpus, tmpdir as tmpdir4 } from "os";
-import path12 from "path";
+import path14 from "path";
 import { promisify as promisify4 } from "util";
 import { z as z11 } from "zod";
 
 // src/engine/engine/composition-hash.ts
-import { readdir as readdir2, readFile as readFile6, stat as stat4 } from "fs/promises";
-import path8 from "path";
+import { readdir as readdir2, readFile as readFile7, stat as stat4 } from "fs/promises";
+import path10 from "path";
 var SKIP_DIRS = /* @__PURE__ */ new Set([".cache", ".git", "node_modules", "dist", "build", ".next", ".turbo"]);
 function isSkippedName(name) {
   if (name.startsWith(".")) return true;
@@ -6705,23 +6846,23 @@ async function collectFiles(root, current) {
   const names = await readdir2(current);
   for (const name of names) {
     if (isSkippedName(name)) continue;
-    const abs = path8.join(current, name);
+    const abs = path10.join(current, name);
     const s = await stat4(abs);
     if (s.isDirectory()) {
       out.push(...await collectFiles(root, abs));
       continue;
     }
     if (!s.isFile()) continue;
-    const bytes = await readFile6(abs);
-    const relPath = path8.relative(root, abs).split(path8.sep).join("/");
+    const bytes = await readFile7(abs);
+    const relPath = path10.relative(root, abs).split(path10.sep).join("/");
     out.push({ relPath, contentSha: sha256Hex(bytes) });
   }
   return out;
 }
 
 // src/engine/engine/composition-meta.ts
-import { readFile as readFile7 } from "fs/promises";
-import path9 from "path";
+import { readFile as readFile8 } from "fs/promises";
+import path11 from "path";
 import { z as z10 } from "zod";
 var InputKind = z10.enum(["video", "image", "audio", "json"]);
 var InputSpec = z10.object({
@@ -6798,10 +6939,10 @@ var CompositionMetaSchema = z10.object({
   params: z10.record(z10.string(), ParamSpec).default({})
 }).strict();
 async function loadCompositionMeta(compositionDir) {
-  const metaPath = path9.join(compositionDir, "meta.json");
+  const metaPath = path11.join(compositionDir, "meta.json");
   let raw;
   try {
-    raw = await readFile7(metaPath, "utf-8");
+    raw = await readFile8(metaPath, "utf-8");
   } catch (e) {
     throw new Error(`composition meta: cannot read ${metaPath} (${e.message})`);
   }
@@ -6879,8 +7020,8 @@ function defaultFilenameForInput(key, kind) {
 
 // src/engine/nodes/local/lib/hyperframe-check.ts
 import { execFile as execFile3 } from "child_process";
-import { readFile as readFile8 } from "fs/promises";
-import path10 from "path";
+import { readFile as readFile9 } from "fs/promises";
+import path12 from "path";
 import { promisify as promisify3 } from "util";
 var execFileAsync = promisify3(execFile3);
 var NEVER_BLOCK = [
@@ -7032,7 +7173,7 @@ ${detail}`);
   }
   let indexHtml = "";
   try {
-    indexHtml = await readFile8(path10.join(dir, "index.html"), "utf-8");
+    indexHtml = await readFile9(path12.join(dir, "index.html"), "utf-8");
   } catch {
     indexHtml = "";
   }
@@ -7096,11 +7237,11 @@ ${stderr.slice(0, 1500)}`;
 }
 
 // src/engine/nodes/local/lib/hyperframe-meta.ts
-import { writeFile as writeFile4 } from "fs/promises";
-import path11 from "path";
+import { writeFile as writeFile5 } from "fs/promises";
+import path13 from "path";
 async function ensureHyperframesMetaJson(tmp, nodeId, meta, duration) {
-  const metaPath = path11.join(tmp, "meta.json");
-  await writeFile4(
+  const metaPath = path13.join(tmp, "meta.json");
+  await writeFile5(
     metaPath,
     JSON.stringify(
       {
@@ -7199,7 +7340,7 @@ var hyperframeRenderNode = defineNode({
     const compositionDir = await resolveCompositionDir(params.composition);
     const meta = await loadCompositionMeta(compositionDir);
     const compositionParams = validateAndParseDynamicParams(meta, params);
-    const tmp = await mkdtemp4(path12.join(tmpdir4(), "hf-render-"));
+    const tmp = await mkdtemp4(path14.join(tmpdir4(), "hf-render-"));
     try {
       await copyComposition(compositionDir, tmp);
       await vendorGsap(tmp, ctx);
@@ -7209,9 +7350,9 @@ var hyperframeRenderNode = defineNode({
       await substituteCompositionFiles(tmp, substitutionValues);
       await ensureHyperframesMetaJson(tmp, ctx.nodeId, meta, duration);
       await runHyperframesCheck({ dir: tmp, nodeId: "hyperframe_render", ctx, timeoutMs: params.timeout_ms });
-      const outputPath = path12.join(tmp, `output.${params.format}`);
+      const outputPath = path14.join(tmp, `output.${params.format}`);
       await runRender({ tmp, outputPath, params, meta, ctx });
-      const bytes = await readFile9(outputPath);
+      const bytes = await readFile10(outputPath);
       ctx.log(`rendered ${bytes.length} bytes`);
       const ref = await ctx.assets.ingestBytes({
         bytes: Buffer.from(bytes),
@@ -7233,10 +7374,10 @@ var hyperframeRenderNode = defineNode({
   }
 });
 async function resolveCompositionDir(composition) {
-  const compositionPath = path12.isAbsolute(composition) ? composition : path12.resolve(process.cwd(), composition);
+  const compositionPath = path14.isAbsolute(composition) ? composition : path14.resolve(process.cwd(), composition);
   const s = await stat5(compositionPath);
   if (s.isDirectory()) return compositionPath;
-  return path12.dirname(compositionPath);
+  return path14.dirname(compositionPath);
 }
 async function validateComposition(rawParams) {
   const issues = await validateCompositionParams(rawParams);
@@ -7318,7 +7459,7 @@ async function copyComposition(srcDir, destDir) {
   await cp(srcDir, destDir, {
     recursive: true,
     filter: (src) => {
-      const name = path12.basename(src);
+      const name = path14.basename(src);
       if (name === ".cache" || name === "node_modules" || name === ".git") return false;
       return true;
     }
@@ -7327,7 +7468,7 @@ async function copyComposition(srcDir, destDir) {
 async function vendorGsap(tmp, ctx) {
   try {
     const gsapMin = require_2.resolve("gsap/dist/gsap.min.js");
-    await copyFile4(gsapMin, path12.join(tmp, "gsap.min.js"));
+    await copyFile4(gsapMin, path14.join(tmp, "gsap.min.js"));
   } catch (e) {
     ctx.log(`warning: could not vendor gsap.min.js (${e.message}); compositions must self-supply`);
   }
@@ -7342,7 +7483,7 @@ async function stageInputs2(tmp, inputs, meta, ctx) {
     await stageAsset(ref, tmp, filename);
     ctx.log(`staged ${spec.kind} \u2192 ${filename}`);
     if (spec.kind === "video" && primaryDuration === null) {
-      primaryDuration = await probeDurationSeconds(path12.join(tmp, filename));
+      primaryDuration = await probeDurationSeconds(path14.join(tmp, filename));
     }
   }
   return primaryDuration;
@@ -7388,15 +7529,15 @@ function coerceImageParam(value) {
   throw new Error("hyperframe_render: image param must be a URL string or AssetRef");
 }
 async function substituteCompositionFiles(tmp, values) {
-  const entryPath = path12.join(tmp, "index.html");
-  const original = await readFile9(entryPath, "utf-8");
+  const entryPath = path14.join(tmp, "index.html");
+  const original = await readFile10(entryPath, "utf-8");
   const { output, missing } = substituteVariables(original, values);
   if (missing.length > 0) {
     throw new Error(
       `hyperframe_render: composition references undefined variables: ${missing.map((m) => `{{${m}}}`).join(", ")}. Add to params or to meta.json's params with a default.`
     );
   }
-  await writeFile5(entryPath, output, "utf-8");
+  await writeFile6(entryPath, output, "utf-8");
 }
 var MAX_WORKERS = 4;
 function workerCount() {
@@ -7405,7 +7546,7 @@ function workerCount() {
 async function runRender(opts) {
   const { tmp, outputPath, params, meta, ctx } = opts;
   const args = buildRenderArgs(tmp, outputPath, meta, params.format);
-  ctx.log(`rendering ${meta.width}x${meta.height}@${meta.fps}fps ${params.format} from ${path12.basename(tmp)}`);
+  ctx.log(`rendering ${meta.width}x${meta.height}@${meta.fps}fps ${params.format} from ${path14.basename(tmp)}`);
   try {
     await execFileAsync2("npx", args, { timeout: params.timeout_ms, maxBuffer: 64 * 1024 * 1024 });
   } catch (e) {
@@ -7449,10 +7590,10 @@ async function probeDurationSeconds(filePath) {
 
 // src/engine/nodes/local/hyperframe-snapshot.ts
 import { execFile as execFile5 } from "child_process";
-import { copyFile as copyFile5, mkdtemp as mkdtemp5, readFile as readFile10, rm as rm5, writeFile as writeFile6 } from "fs/promises";
+import { copyFile as copyFile5, mkdtemp as mkdtemp5, readFile as readFile11, rm as rm5, writeFile as writeFile7 } from "fs/promises";
 import { createRequire as createRequire3 } from "module";
 import { tmpdir as tmpdir5 } from "os";
-import path13 from "path";
+import path15 from "path";
 import { promisify as promisify5 } from "util";
 import { z as z12 } from "zod";
 var _execFileAsync = promisify5(execFile5);
@@ -7499,7 +7640,7 @@ var hyperframeSnapshotNode = defineNode({
     const compositionDir = await resolveCompositionDir(params.composition);
     const meta = await loadCompositionMeta(compositionDir);
     const compositionParams = validateAndParseDynamicParams2(meta, params);
-    const tmp = await mkdtemp5(path13.join(tmpdir5(), "hf-snap-"));
+    const tmp = await mkdtemp5(path15.join(tmpdir5(), "hf-snap-"));
     try {
       await copyComposition2(compositionDir, tmp);
       await vendorGsap2(tmp, ctx);
@@ -7514,7 +7655,7 @@ var hyperframeSnapshotNode = defineNode({
         timeoutMs: params.timeout_ms,
         samples: 1
       });
-      const entryPath = path13.join(tmp, "index.html");
+      const entryPath = path15.join(tmp, "index.html");
       const entryUrl = `file://${entryPath}`;
       ctx.log(`snapshotting ${meta.width}x${meta.height}@${DEVICE_SCALE_FACTOR2}x wait=${params.wait_for.kind}`);
       const pwSpecifier = ["play", "wright"].join("");
@@ -7575,7 +7716,7 @@ async function copyComposition2(srcDir, destDir) {
   await cp(srcDir, destDir, {
     recursive: true,
     filter: (src) => {
-      const name = path13.basename(src);
+      const name = path15.basename(src);
       if (name === ".cache" || name === "node_modules" || name === ".git") return false;
       return true;
     }
@@ -7584,7 +7725,7 @@ async function copyComposition2(srcDir, destDir) {
 async function vendorGsap2(tmp, ctx) {
   try {
     const gsapMin = require_3.resolve("gsap/dist/gsap.min.js");
-    await copyFile5(gsapMin, path13.join(tmp, "gsap.min.js"));
+    await copyFile5(gsapMin, path15.join(tmp, "gsap.min.js"));
   } catch (e) {
     ctx.log(`warning: could not vendor gsap.min.js (${e.message}); compositions must self-supply`);
   }
@@ -7618,15 +7759,15 @@ function coerceImageParam2(value) {
   throw new Error("hyperframe_snapshot: image param must be a URL string or AssetRef");
 }
 async function substituteCompositionFiles2(tmp, values) {
-  const entryPath = path13.join(tmp, "index.html");
-  const original = await readFile10(entryPath, "utf-8");
+  const entryPath = path15.join(tmp, "index.html");
+  const original = await readFile11(entryPath, "utf-8");
   const { output, missing } = substituteVariables(original, values);
   if (missing.length > 0) {
     throw new Error(
       `hyperframe_snapshot: composition references undefined variables: ${missing.map((m) => `{{${m}}}`).join(", ")}.`
     );
   }
-  await writeFile6(entryPath, output, "utf-8");
+  await writeFile7(entryPath, output, "utf-8");
 }
 async function waitForReady(page, waitFor, timeoutMs) {
   switch (waitFor.kind) {
@@ -8368,9 +8509,9 @@ var videoLipsyncNode = delegated({
 });
 
 // src/engine/nodes/remote/videoTranscribe.ts
-import { mkdtemp as mkdtemp6, readFile as readFile11, rm as rm6 } from "fs/promises";
+import { mkdtemp as mkdtemp6, readFile as readFile12, rm as rm6 } from "fs/promises";
 import { tmpdir as tmpdir6 } from "os";
-import path14 from "path";
+import path16 from "path";
 import { z as z33 } from "zod";
 
 // src/engine/nodes/local/lib/ffmpeg.ts
@@ -8505,14 +8646,14 @@ async function tryExtractAudio(inputs, ctx) {
       ctx.log("video_transcribe: no audio track detected, sending full video");
       return null;
     }
-    tmpDir = await mkdtemp6(path14.join(tmpdir6(), "vtx-"));
-    const audioPath = path14.join(tmpDir, "audio.mp3");
+    tmpDir = await mkdtemp6(path16.join(tmpdir6(), "vtx-"));
+    const audioPath = path16.join(tmpDir, "audio.mp3");
     ctx.log("video_transcribe: extracting audio (mono 16kHz mp3)");
     await runFfmpeg(
       ["-i", video.path, "-vn", "-ac", "1", "-ar", "16000", "-b:a", "64k", "-f", "mp3", "-y", audioPath],
       { timeout_ms: AUDIO_EXTRACT_TIMEOUT_MS }
     );
-    const bytes = await readFile11(audioPath);
+    const bytes = await readFile12(audioPath);
     if (bytes.byteLength === 0) {
       ctx.log("video_transcribe: extracted audio is empty, sending full video");
       return null;
@@ -8619,19 +8760,19 @@ function safeCost(def) {
 
 // src/engine/storage/cache-store.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdir as mkdir3, readFile as readFile12, rename as rename2, writeFile as writeFile7 } from "fs/promises";
-import path15 from "path";
+import { mkdir as mkdir3, readFile as readFile13, rename as rename2, writeFile as writeFile8 } from "fs/promises";
+import path17 from "path";
 var LocalCacheStore = class {
   rootDir;
   constructor(rootDir) {
     this.rootDir = rootDir;
   }
   filePath(cacheKey) {
-    return path15.join(this.rootDir, `${cacheKey}.json`);
+    return path17.join(this.rootDir, `${cacheKey}.json`);
   }
   async get(cacheKey) {
     try {
-      const buf = await readFile12(this.filePath(cacheKey), "utf8");
+      const buf = await readFile13(this.filePath(cacheKey), "utf8");
       return JSON.parse(buf);
     } catch (e) {
       if (e.code === "ENOENT") return null;
@@ -8640,9 +8781,9 @@ var LocalCacheStore = class {
   }
   async put(entry) {
     const dest = this.filePath(entry.cacheKey);
-    await mkdir3(path15.dirname(dest), { recursive: true });
+    await mkdir3(path17.dirname(dest), { recursive: true });
     const tmp = `${dest}.tmp-${process.pid}-${randomUUID2()}`;
-    await writeFile7(tmp, JSON.stringify(entry, null, 0));
+    await writeFile8(tmp, JSON.stringify(entry, null, 0));
     await rename2(tmp, dest);
   }
 };
@@ -8696,12 +8837,12 @@ function defaultRegistry() {
 }
 function createEngineFromEnv(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const cacheDir = opts.cacheDir ?? path16.join(cwd, "canvas", ".cache");
-  const outputsDir = opts.outputsDir ?? path16.join(cwd, "canvas");
+  const cacheDir = opts.cacheDir ?? path18.join(cwd, "canvas", ".cache");
+  const outputsDir = opts.outputsDir ?? path18.join(cwd, "canvas");
   const creds = requireCredentialsFromEnv();
   const client = new BackendClient({ baseUrl: creds.url, apiKey: creds.apiKey });
-  const assets = new LocalAssetStore(path16.join(cacheDir, "assets"));
-  const localCache = new LocalCacheStore(path16.join(cacheDir, "index"));
+  const assets = new LocalAssetStore(path18.join(cacheDir, "assets"));
+  const localCache = new LocalCacheStore(path18.join(cacheDir, "index"));
   const remoteCacheEnabled = opts.remoteCache ?? remoteCacheEnabledFromEnv();
   const cache = remoteCacheEnabled ? new LayeredCacheStore({
     local: localCache,
@@ -8764,6 +8905,14 @@ export {
   elementMentionKeywords,
   MAX_REMOTE_IMAGE_BYTES,
   fetchExternalBytes,
+  isVimeoAuthFailure,
+  ytDlpBlockSignal,
+  YtDlpError,
+  runYtDlp,
+  probeYtDlp,
+  isAudioOnly,
+  durationSeconds,
+  canonicalUrl,
   toModelSafeImage,
   BackendClient2,
   Engine2 as Engine,
@@ -8775,4 +8924,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-5MPIOGRO.js.map
+//# sourceMappingURL=chunk-E2WYWHJJ.js.map