@koda-sl/baker-cli 0.477.0 → 0.479.0

package/dist/chunk-HH5PFZ7U.js

@@ -1,84 +0,0 @@
-import {
-  findWorkspaceRoot
-} from "./chunk-ANWV2VTO.js";
-
-// src/commands/canvas/unbilled-spend.ts
-import { randomUUID } from "crypto";
-import { mkdir, readdir, readFile, rename, unlink, writeFile } from "fs/promises";
-import path from "path";
-import { z } from "zod";
-var DIR = "unbilled-spend";
-var Held = z.array(
-  z.object({ model: z.string(), inputTokens: z.number(), outputTokens: z.number(), costUsd: z.number() })
-);
-async function holdUnbilledSpend(cacheDir, usage) {
-  if (usage.length === 0) return;
-  const dir = path.join(cacheDir, DIR);
-  await mkdir(dir, { recursive: true });
-  await writeFile(path.join(dir, `${Date.now()}-${randomUUID()}.json`), JSON.stringify(usage), "utf8");
-}
-async function holdWorkspaceSpend(usage) {
-  const root = findWorkspaceRoot(process.cwd()) ?? process.cwd();
-  await holdUnbilledSpend(path.join(root, "canvas", ".cache"), usage).catch(() => {
-  });
-}
-async function takeUnbilledSpend(cacheDir) {
-  const dir = path.join(cacheDir, DIR);
-  const files = await readdir(dir).catch(() => []);
-  const byModel = /* @__PURE__ */ new Map();
-  for (const file of files.filter((f) => f.endsWith(".json"))) {
-    const claimed = path.join(dir, `${file}.${randomUUID()}.taken`);
-    try {
-      await rename(path.join(dir, file), claimed);
-    } catch {
-      continue;
-    }
-    const parsed = Held.safeParse(await readFile(claimed, "utf8").then(JSON.parse, () => null).catch(() => null));
-    await unlink(claimed).catch(() => {
-    });
-    for (const call of parsed.success ? parsed.data : []) {
-      const sum = byModel.get(call.model);
-      byModel.set(
-        call.model,
-        sum ? {
-          model: call.model,
-          inputTokens: sum.inputTokens + call.inputTokens,
-          outputTokens: sum.outputTokens + call.outputTokens,
-          costUsd: sum.costUsd + call.costUsd
-        } : { ...call }
-      );
-    }
-  }
-  return [...byModel.values()];
-}
-async function sendBillingSpend(cacheDir, usage, send) {
-  try {
-    await send();
-    return null;
-  } catch (e) {
-    await holdUnbilledSpend(cacheDir, usage).catch(() => {
-    });
-    return e instanceof Error ? e.message : String(e);
-  }
-}
-function holdWhenSettled(cacheDir, spendOf) {
-  const pending = [];
-  return {
-    settled: (run, outputs) => {
-      pending.push(holdUnbilledSpend(cacheDir, spendOf(run, outputs)).catch(() => {
-      }));
-    },
-    drained: async () => {
-      await Promise.all(pending);
-    }
-  };
-}
-
-export {
-  holdUnbilledSpend,
-  holdWorkspaceSpend,
-  takeUnbilledSpend,
-  sendBillingSpend,
-  holdWhenSettled
-};
-//# sourceMappingURL=chunk-HH5PFZ7U.js.map

package/dist/chunk-HKR7VCFK.js

@@ -1,42 +0,0 @@
-import {
-  ApiError
-} from "./chunk-7ANWFQEA.js";
-import {
-  writeJson
-} from "./chunk-ANYMWCST.js";
-
-// src/commands/studio/errors.ts
-var CREDIT_HINTS = ["credit", "top up", "billing", "quota"];
-function studioStartFix(message) {
-  const lower = message.toLowerCase();
-  if (CREDIT_HINTS.some((hint) => lower.includes(hint))) {
-    return {
-      action: "Stop generating and finish the task with assets that already exist",
-      explanation: "No generation will run until the plan is topped up, so retrying costs time and changes nothing. Source or reuse an image instead, complete the rest of the work, and tell the user the new artwork could not be produced."
-    };
-  }
-  return {
-    action: "Drop or correct the setting the message names, then run the command once more",
-    explanation: "The message says which model was chosen and what it accepts. If the setting is not essential to the brief, leave it out rather than switching model. Do not abort the wider job over one refused setting."
-  };
-}
-function failStudioCommand(error, opts = {}) {
-  if (error instanceof ApiError) {
-    writeJson({
-      ok: false,
-      error: {
-        code: error.code,
-        message: error.message,
-        ...opts.withFix ? { fix: studioStartFix(error.message) } : {}
-      }
-    });
-    process.exit(1);
-  }
-  writeJson({ ok: false, error: { code: "INTERNAL_ERROR", message: "Unexpected error" } });
-  process.exit(1);
-}
-
-export {
-  failStudioCommand
-};
-//# sourceMappingURL=chunk-HKR7VCFK.js.map

package/dist/chunk-JQ4PQ2H6.js

@@ -1,197 +0,0 @@
-import {
-  mediaTagsCreateRequestSchema,
-  mediaTagsDeleteRequestSchema,
-  mediaTagsUpdateRequestSchema
-} from "./chunk-GAJQPQWS.js";
-import {
-  ApiError,
-  apiGet,
-  apiPost
-} from "./chunk-7ANWFQEA.js";
-import {
-  registerSchema,
-  writeJson
-} from "./chunk-ANYMWCST.js";
-
-// src/lib/tags-command.ts
-import { defineCommand } from "citty";
-var OUTPUT_ARG = {
-  output: { type: "string", description: "Output format: md|json", required: false, default: "md" }
-};
-var SHARED_POOL_HINT = "Custom tags are one pool shared by images, videos and testimonials \u2014 this change shows up in all three. Already applied: publishing or discarding this chat does not undo it.";
-function fail(err) {
-  const code = err instanceof ApiError ? err.code : "INTERNAL_ERROR";
-  const message = err instanceof ApiError ? err.message : "Unexpected error";
-  writeJson({ ok: false, error: { code, message } });
-  process.exit(1);
-}
-function failInvalid(issue) {
-  writeJson({ ok: false, error: { code: "VALIDATION_ERROR", message: issue?.message ?? "Invalid request" } });
-  process.exit(1);
-}
-function makeTagsCommand(command, label, endpoint) {
-  registerSchema({
-    command: `${command}.tags.list`,
-    description: `List the available ${label} tag taxonomy (built-in defaults + this company's custom tags).`,
-    args: OUTPUT_ARG
-  });
-  const listCommand = defineCommand({
-    meta: {
-      name: "list",
-      description: `List the available ${label} tag names (defaults + company custom tags). Use before filtering with --tags. Example: baker ${command} tags`
-    },
-    args: OUTPUT_ARG,
-    run: async ({ args }) => {
-      try {
-        const { markdown } = await apiGet(endpoint);
-        if (args.output === "json") {
-          writeJson({ ok: true, data: { markdown } });
-          return;
-        }
-        process.stdout.write(`${markdown.trimEnd()}
-`);
-      } catch (err) {
-        const code = err instanceof ApiError ? err.code : "INTERNAL_ERROR";
-        const message = err instanceof ApiError ? err.message : "Unexpected error";
-        if (args.output === "json") {
-          writeJson({ ok: false, error: { code, message } });
-        } else {
-          process.stderr.write(`Error: ${message}
-`);
-        }
-        process.exit(1);
-      }
-    }
-  });
-  const createArgs = {
-    name: { type: "positional", description: "Tag name (stored lowercased, spaces \u2192 hyphens)", required: true },
-    description: {
-      type: "string",
-      description: "What the tag means, so it gets applied consistently",
-      required: false
-    }
-  };
-  registerSchema({
-    command: `${command}.tags.create`,
-    description: "Create a custom media tag in the company's shared pool (images, videos and testimonials). Applies immediately. Use when no built-in or custom tag fits.",
-    args: {
-      name: { type: "string", description: "Tag name (stored lowercased, spaces \u2192 hyphens)", required: true },
-      description: createArgs.description
-    }
-  });
-  const createCommand = defineCommand({
-    meta: {
-      name: "create",
-      description: `Create a custom tag (shared by images, videos and testimonials). Applies immediately.
-
-Example: baker ${command} tags create "summer sale" --description "Assets for the summer sale campaign"`
-    },
-    args: createArgs,
-    run: async ({ args }) => {
-      const parsed = mediaTagsCreateRequestSchema.safeParse({
-        name: String(args.name ?? ""),
-        ...args.description ? { description: String(args.description) } : {}
-      });
-      if (!parsed.success) failInvalid(parsed.error.issues[0]);
-      try {
-        const data = await apiPost("/api/media-tags/create", parsed.data);
-        writeJson({
-          ok: true,
-          data,
-          hints: [
-            SHARED_POOL_HINT,
-            `Use it as \`--tags ${data.name}\`.`,
-            ...data.description ? [] : ["MISSING --description: add one with `tags update` so the tag is applied consistently."]
-          ]
-        });
-      } catch (err) {
-        fail(err);
-      }
-    }
-  });
-  registerSchema({
-    command: `${command}.tags.update`,
-    description: "Change what a custom tag means (its description). Built-in tags cannot be changed. Applies immediately.",
-    args: {
-      slug: { type: "string", description: "Custom tag name, as `tags` lists it", required: true },
-      description: { type: "string", description: "New description", required: true }
-    }
-  });
-  const updateCommand = defineCommand({
-    meta: {
-      name: "update",
-      description: `Change a custom tag's description. Built-in tags cannot be changed. Applies immediately.
-
-Example: baker ${command} tags update summer-sale --description "Assets for the 2026 summer sale"`
-    },
-    args: {
-      slug: { type: "positional", description: "Custom tag name, as `tags` lists it", required: true },
-      description: { type: "string", description: "New description", required: true }
-    },
-    run: async ({ args }) => {
-      const parsed = mediaTagsUpdateRequestSchema.safeParse({
-        slug: String(args.slug ?? ""),
-        description: String(args.description ?? "")
-      });
-      if (!parsed.success) failInvalid(parsed.error.issues[0]);
-      try {
-        const data = await apiPost("/api/media-tags/update", parsed.data);
-        writeJson({ ok: true, data, hints: [SHARED_POOL_HINT] });
-      } catch (err) {
-        fail(err);
-      }
-    }
-  });
-  registerSchema({
-    command: `${command}.tags.delete`,
-    description: "Delete a custom tag from the company's shared pool. Built-in tags cannot be deleted. Applies immediately. Confirm with the user first.",
-    args: { slug: { type: "string", description: "Custom tag name, as `tags` lists it", required: true } }
-  });
-  const deleteCommand = defineCommand({
-    meta: {
-      name: "delete",
-      description: `Delete a custom tag (shared by images, videos and testimonials). Built-in tags cannot be deleted. Applies immediately \u2014 confirm with the user first.
-
-Example: baker ${command} tags delete summer-sale`
-    },
-    args: { slug: { type: "positional", description: "Custom tag name, as `tags` lists it", required: true } },
-    run: async ({ args }) => {
-      const parsed = mediaTagsDeleteRequestSchema.safeParse({ slug: String(args.slug ?? "") });
-      if (!parsed.success) failInvalid(parsed.error.issues[0]);
-      try {
-        const data = await apiPost("/api/media-tags/delete", parsed.data);
-        writeJson({ ok: true, data, hints: [SHARED_POOL_HINT] });
-      } catch (err) {
-        fail(err);
-      }
-    }
-  });
-  return defineCommand({
-    meta: {
-      name: "tags",
-      description: `The ${label} tag taxonomy: built-in defaults plus the company's custom tags (one pool shared by images, videos and testimonials). Subcommands: list (default), create, update, delete.
-
-Examples:
-  baker ${command} tags                                   # list available tags
-  baker ${command} tags create "summer sale" --description "\u2026"
-  baker ${command} tags update summer-sale --description "\u2026"
-  baker ${command} tags delete summer-sale`
-    },
-    // Declared on the parent too: `default: "list"` dispatches the bare `tags --output json`
-    // form, and citty reads an undeclared flag's value as a subcommand name.
-    args: OUTPUT_ARG,
-    subCommands: {
-      list: listCommand,
-      create: createCommand,
-      update: updateCommand,
-      delete: deleteCommand
-    },
-    // `default`, never `run`: citty falls through to the parent's `run` after a subcommand.
-    default: "list"
-  });
-}
-
-export {
-  makeTagsCommand
-};
-//# sourceMappingURL=chunk-JQ4PQ2H6.js.map

package/dist/chunk-JRLGQA2T.js

@@ -1,333 +0,0 @@
-import {
-  captureProxyCredentials,
-  isChallengeBody,
-  isPrivateAddress,
-  isProxyFailure,
-  nextPlannedRoute,
-  plannedRoutes,
-  refuseNonPublicUrl,
-  shouldEscalate
-} from "./chunk-H5CGVMQW.js";
-
-// ../proxy/src/fetch.ts
-import { lookup as dnsLookup } from "dns";
-import { Agent, ProxyAgent, Response, fetch as undiciFetch } from "undici";
-
-// ../proxy/src/fetchDecision.ts
-function classifyFetchOutcome(signal) {
-  if (isProxyFailure(signal)) return "proxy_unavailable";
-  if (shouldEscalate(signal)) return "blocked";
-  if (signal.status != null && signal.status >= 200 && signal.status < 400 && !signal.challenge) return "ok";
-  return "failed";
-}
-function shouldTryNextRoute(outcome) {
-  return outcome === "blocked" || outcome === "proxy_unavailable";
-}
-var TIMEOUT_CODES = /* @__PURE__ */ new Set([
-  "UND_ERR_CONNECT_TIMEOUT",
-  "UND_ERR_HEADERS_TIMEOUT",
-  "UND_ERR_BODY_TIMEOUT",
-  "ETIMEDOUT"
-]);
-var RESET_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "UND_ERR_SOCKET", "EPIPE"]);
-var PROXY_RESPONSE = /Proxy response \((\d+)\)/;
-function errorCode(error) {
-  if (typeof error !== "object" || error === null) return null;
-  const code = error.code;
-  if (typeof code === "string") return code;
-  const name = error.name;
-  return typeof name === "string" ? name : null;
-}
-function errorMessage(error) {
-  if (typeof error === "object" && error !== null) {
-    const message = error.message;
-    if (typeof message === "string") return message;
-  }
-  return String(error);
-}
-function errorBlockSignal(error, proxied) {
-  const proxyResponse = PROXY_RESPONSE.exec(errorMessage(error));
-  if (proxyResponse) {
-    const status = Number(proxyResponse[1]);
-    return status === 407 ? { status: 407 } : { netError: "ERR_TUNNEL_CONNECTION_FAILED" };
-  }
-  const code = errorCode(error);
-  if (code !== null && TIMEOUT_CODES.has(code)) return { timedOut: true };
-  if (code === "AbortError" || code === "TimeoutError") return { timedOut: true };
-  if (proxied) {
-    return { netError: "ERR_PROXY_CONNECTION_FAILED" };
-  }
-  if (code !== null && RESET_CODES.has(code)) return { netError: "ERR_CONNECTION_RESET" };
-  return { netError: code ?? "ERR_FAILED" };
-}
-function shouldSniffChallenge(contentType, contentLength, maxSniffBytes) {
-  if (contentLength !== null && contentLength > maxSniffBytes) return false;
-  if (contentType === null || contentType.trim() === "") return true;
-  const type = contentType.toLowerCase();
-  if (type.startsWith("image/") || type.startsWith("video/") || type.startsWith("audio/")) return false;
-  return type.includes("text/") || type.includes("html") || type.includes("json") || type.includes("xml");
-}
-
-// ../proxy/src/fetch.ts
-var DEFAULT_TIMEOUT_MS = 6e4;
-var MAX_SNIFF_BYTES = 64 * 1024;
-function tierOf(route) {
-  return route.kind === "proxy" ? route.tier : "direct";
-}
-function agentFor(route) {
-  if (route.kind !== "proxy") return directAgent();
-  const token = Buffer.from(`${route.username}:${route.password}`).toString("base64");
-  return new ProxyAgent({ uri: route.server, token: `Basic ${token}` });
-}
-function directAgent() {
-  return new Agent({
-    connect: {
-      lookup: (hostname, options, callback) => {
-        dnsLookup(hostname, options, (error, address, family) => {
-          if (error) {
-            callback(error, address, family);
-            return;
-          }
-          const found = Array.isArray(address) ? address.map((entry) => entry.address) : [address];
-          const blocked = found.find((entry) => isPrivateAddress(entry));
-          if (blocked !== void 0) {
-            callback(new Error(`${PRIVATE_ADDRESS_CODE}: ${hostname} resolves to ${blocked}`), "", 4);
-            return;
-          }
-          callback(null, address, family);
-        });
-      }
-    }
-  });
-}
-var PRIVATE_ADDRESS_CODE = "EPRIVATEADDR";
-var MAX_REDIRECTS = 20;
-var REDIRECT_STATUS = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
-function originOf(url) {
-  try {
-    return new URL(url).origin;
-  } catch {
-    return null;
-  }
-}
-function refuseRedirect(entry, to) {
-  if (refuseNonPublicUrl(to) === null) return false;
-  const destination = originOf(to);
-  return destination === null || destination !== originOf(entry);
-}
-async function followRedirects(url, init) {
-  let current = url;
-  let request = { ...init, redirect: "manual" };
-  for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
-    const response = await undiciFetch(current, request);
-    const location = response.headers.get("location");
-    if (!REDIRECT_STATUS.has(response.status) || location === null) return response;
-    await response.body?.cancel();
-    const next = new URL(location, current).toString();
-    if (refuseRedirect(url, next)) {
-      throw new Error(`${PRIVATE_ADDRESS_CODE}: redirected to ${next}`);
-    }
-    const method = (request.method ?? "GET").toUpperCase();
-    const downgrade = response.status === 303 || (response.status === 301 || response.status === 302) && method === "POST";
-    request = downgrade ? { ...request, method: "GET", body: void 0 } : request;
-    current = next;
-  }
-  throw new Error(`too many redirects following ${url}`);
-}
-var NULL_BODY_STATUS = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
-function rebuild(response, body) {
-  if (response.status < 200 || response.status > 599 || NULL_BODY_STATUS.has(response.status)) {
-    return new Response(null, { status: response.status, headers: response.headers });
-  }
-  return new Response(body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers: response.headers
-  });
-}
-function declaredLength(response) {
-  const raw = response.headers.get("content-length");
-  if (raw === null) return null;
-  const value = Number(raw);
-  return Number.isFinite(value) ? value : null;
-}
-async function readOnce(response, sniff, maxBytes) {
-  const declared = declaredLength(response);
-  if (maxBytes !== void 0 && declared !== null && declared > maxBytes) {
-    await response.body?.cancel();
-    return { response: rebuild(response, new ArrayBuffer(0)), challenge: false };
-  }
-  const body = await response.arrayBuffer();
-  const wantsSniff = sniff && shouldSniffChallenge(response.headers.get("content-type"), body.byteLength, MAX_SNIFF_BYTES);
-  const challenge = wantsSniff ? isChallengeBody(new TextDecoder().decode(body)) : false;
-  return { response: rebuild(response, body), challenge };
-}
-async function attemptRoute(url, init, route, options) {
-  const tier = tierOf(route);
-  const agent = agentFor(route);
-  const startedAt = Date.now();
-  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-  const signal = init.signal ? AbortSignal.any([init.signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs);
-  try {
-    const raw = await followRedirects(url, { ...init, dispatcher: agent ?? void 0, signal });
-    const read = await readOnce(raw, options.sniffChallenge ?? true, options.maxBytes);
-    const outcome = classifyFetchOutcome({ status: raw.status, challenge: read.challenge });
-    return {
-      attempt: { tier, status: raw.status, ms: Date.now() - startedAt, outcome },
-      response: outcome === "proxy_unavailable" ? null : read.response
-    };
-  } catch (error) {
-    const blockSignal = errorBlockSignal(error, route.kind === "proxy");
-    return {
-      attempt: {
-        tier,
-        status: blockSignal.status ?? void 0,
-        ms: Date.now() - startedAt,
-        outcome: classifyFetchOutcome(blockSignal)
-      },
-      response: null,
-      error
-    };
-  } finally {
-    await agent?.close();
-  }
-}
-async function fetchWithEscalation(url, init, options) {
-  const attempts = [];
-  let originResponse = null;
-  let originTier = "direct";
-  let lastError;
-  const routes = plannedRoutes(url, options.credentials, options.routeOptions);
-  const tried = [];
-  for (let route = routes[0] ?? null; route !== null; route = nextPlannedRoute(routes, tried)) {
-    const rung = await attemptRoute(url, init, route, options);
-    attempts.push(rung.attempt);
-    tried.push({ tier: rung.attempt.tier, proxyFailure: rung.attempt.outcome === "proxy_unavailable" });
-    if (rung.response !== null) {
-      originResponse = rung.response;
-      originTier = rung.attempt.tier;
-    }
-    if (rung.error !== void 0) lastError = rung.error;
-    if (!shouldTryNextRoute(rung.attempt.outcome)) break;
-  }
-  return {
-    response: originResponse,
-    attempts,
-    finalTier: originResponse !== null ? originTier : lastAttempt(attempts)?.tier ?? "direct",
-    ...originResponse === null && lastError !== void 0 ? { error: lastError } : {}
-  };
-}
-function lastAttempt(attempts) {
-  return attempts[attempts.length - 1];
-}
-function describeLadder(result) {
-  const rungs = result.attempts.map((a) => `${a.tier}:${a.outcome}${a.status ? `(${a.status})` : ""}@${a.ms}ms`);
-  return `${rungs.join(" \u2192 ")} | final=${result.finalTier}`;
-}
-function rescued(result) {
-  return result.attempts.some((attempt) => attempt.outcome === "ok");
-}
-function endedBlocked(result) {
-  if (rescued(result)) return false;
-  return result.attempts.some((attempt) => attempt.outcome === "blocked");
-}
-function endedProxyUnavailable(result) {
-  if (rescued(result) || endedBlocked(result)) return false;
-  return result.attempts.some((attempt) => attempt.outcome === "proxy_unavailable");
-}
-function endedPrivateAddress(result) {
-  if (rescued(result)) return false;
-  for (let error = result.error, depth = 0; error instanceof Error && depth < 5; depth++) {
-    if (error.message.includes(PRIVATE_ADDRESS_CODE)) return true;
-    error = error.cause;
-  }
-  return false;
-}
-
-// src/lib/externalFetch.ts
-var BROWSER_HEADERS = {
-  "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36",
-  Accept: "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
-  "Accept-Language": "en-US,en;q=0.9"
-};
-var NOT_PUBLIC_MESSAGE = "That address is not reachable from the public web, so there is nothing to read.";
-var MAX_REMOTE_IMAGE_BYTES = 25e6;
-var ExternalFetchError = class extends Error {
-  /** True when the fault was ours — a route we could not open, not a dead host. */
-  ourFault;
-  constructor(message, ourFault) {
-    super(message);
-    this.name = "ExternalFetchError";
-    this.ourFault = ourFault;
-  }
-};
-async function fetchExternal(url, options = {}) {
-  if (refuseNonPublicUrl(url) !== null) {
-    throw new ExternalFetchError(NOT_PUBLIC_MESSAGE, false);
-  }
-  const result = await fetchWithEscalation(
-    url,
-    { headers: { ...BROWSER_HEADERS, ...options.headers } },
-    {
-      credentials: captureProxyCredentials(),
-      ...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs },
-      ...options.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes },
-      ...options.sniffChallenge === void 0 ? {} : { sniffChallenge: options.sniffChallenge }
-    }
-  );
-  if (result.attempts.length > 1) {
-    process.stderr.write(`fetch ladder ${url} \u2014 ${describeLadder(result)}
-`);
-  }
-  if (result.response === null) {
-    if (endedPrivateAddress(result)) {
-      throw new ExternalFetchError(NOT_PUBLIC_MESSAGE, false);
-    }
-    const ourFault = endedProxyUnavailable(result);
-    throw new ExternalFetchError(
-      ourFault ? "Could not open a route to that address." : "That address did not answer.",
-      ourFault
-    );
-  }
-  return { response: result.response, blocked: endedBlocked(result) };
-}
-function refuseOversize(bytes, maxBytes) {
-  if (bytes === null || bytes <= maxBytes) return null;
-  return `That file is ${humanBytes(bytes)} \u2014 the limit is ${humanBytes(maxBytes)}.`;
-}
-function humanBytes(n) {
-  if (n >= 1024 ** 3) return `${(n / 1024 ** 3).toFixed(1)} GB`;
-  if (n >= 1024 ** 2) return `${(n / 1024 ** 2).toFixed(1)} MB`;
-  return `${Math.max(1, Math.round(n / 1024))} KB`;
-}
-function declaredBytes(response) {
-  const raw = response.headers.get("content-length");
-  if (raw === null) return null;
-  const value = Number(raw);
-  return Number.isFinite(value) ? value : null;
-}
-async function fetchExternalBytes(url, options) {
-  const { response, blocked } = await fetchExternal(url, options);
-  if (!response.ok) {
-    throw new ExternalFetchError(`${response.status} ${response.statusText}`, false);
-  }
-  if (blocked) {
-    throw new ExternalFetchError("That host served a security check instead of the file.", false);
-  }
-  const declared = refuseOversize(declaredBytes(response), options.maxBytes);
-  if (declared !== null) {
-    throw new ExternalFetchError(declared, false);
-  }
-  const buffer = Buffer.from(await response.arrayBuffer());
-  const actual = refuseOversize(buffer.byteLength, options.maxBytes);
-  if (actual !== null) {
-    throw new ExternalFetchError(actual, false);
-  }
-  return { buffer, contentType: response.headers.get("content-type") };
-}
-
-export {
-  MAX_REMOTE_IMAGE_BYTES,
-  fetchExternalBytes
-};
-//# sourceMappingURL=chunk-JRLGQA2T.js.map

package/dist/chunk-JU6X4XFU.js

@@ -1,23 +0,0 @@
-import {
-  creativesRunResponseSchema
-} from "./chunk-GAJQPQWS.js";
-import {
-  ApiError,
-  apiPost
-} from "./chunk-7ANWFQEA.js";
-
-// src/commands/canvas/run-history.ts
-async function fetchRunRecord(runId, post = apiPost) {
-  try {
-    const response = await post("/api/creatives/run", { runId });
-    return creativesRunResponseSchema.parse(response).data;
-  } catch (e) {
-    if (e instanceof ApiError && e.code === "NOT_FOUND") return null;
-    throw e;
-  }
-}
-
-export {
-  fetchRunRecord
-};
-//# sourceMappingURL=chunk-JU6X4XFU.js.map