@koda-sl/baker-cli 0.460.0 → 0.462.0

package/dist/chunk-V44SLD5J.js

@@ -0,0 +1,309 @@
+import {
+  ApiError,
+  apiGet
+} from "./chunk-D4N5ZXEO.js";
+import {
+  getEnv
+} from "./chunk-NBPJBJJD.js";
+
+// src/error-handler.ts
+var REQUEST_CONNECTION_PLATFORM = {
+  google_ads: "google-ads",
+  ga4: "google-analytics",
+  gsc: "google-search-console",
+  linkedin_ads: "linkedin",
+  meta_ads: "meta",
+  x_ads: "x-ads"
+};
+var PLATFORM_NAME = {
+  google_ads: "Google Ads",
+  ga4: "Google Analytics 4",
+  gsc: "Google Search Console",
+  x_ads: "X Ads",
+  meta_ads: "Meta Ads",
+  linkedin_ads: "LinkedIn Ads"
+};
+function connectionFixExplanation(platform) {
+  const name = PLATFORM_NAME[platform];
+  const slug = REQUEST_CONNECTION_PLATFORM[platform];
+  return `${name} is not connected for this company (or no account has been picked). Don't send the user to Settings or end the turn here \u2014 call the \`request_connection\` tool with { platform: "${slug}", reason } and they connect and pick their accounts from inside the chat. If the \`request_connection\` call fails, say so plainly and give the exact route: dashboard \u2192 Brain \u2192 Integrations \u2192 Platforms \u2192 ${name}. Then carry on with the rest of the task and say what stays unavailable until it is connected.`;
+}
+function handleConnectionError(platform, originalMessage) {
+  const platformName = PLATFORM_NAME[platform];
+  const alternative = {
+    google_ads: "keywords-for-site or research advertisers",
+    ga4: "lighthouse for page performance",
+    gsc: "keywords-for-site or research keyword-gap",
+    x_ads: "research advertisers",
+    meta_ads: "research advertisers or research keyword-ideas",
+    linkedin_ads: "research advertisers (LinkedIn Ad Library) or research keyword-ideas"
+  }[platform];
+  const code = {
+    google_ads: "NO_GOOGLE_ADS_CONNECTION",
+    ga4: "NO_GA4_CONNECTION",
+    gsc: "NO_GSC_CONNECTION",
+    x_ads: "NO_X_ADS_CONNECTION",
+    meta_ads: "NO_META_ADS_CONNECTION",
+    linkedin_ads: "NO_LINKEDIN_ADS_CONNECTION"
+  }[platform];
+  const envelope = {
+    ok: false,
+    error: {
+      code,
+      message: originalMessage || `No ${platformName} connection found for this company.`,
+      fix: {
+        action: "request_connection",
+        explanation: `${connectionFixExplanation(platform)} (Optional fallback for estimated external insights: 'baker research ${alternative}'.)`
+      },
+      retryable: false
+    }
+  };
+  writeJsonEnvelope(envelope);
+  process.exit(1);
+}
+function isNotConnectedError(code, message) {
+  if (code !== "NOT_FOUND" && code !== "UNAUTHORIZED" && code !== "FORBIDDEN") {
+    return false;
+  }
+  return /no .* connection found|not connected|no .* (selected|picked)|is not in .* connected/i.test(message);
+}
+function needsConnectionFix(code, message) {
+  if (code === "UNAUTHORIZED") {
+    return true;
+  }
+  return isNotConnectedError(code, message);
+}
+
+// src/commands/ads/cache.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CACHE_DIR = join(homedir(), ".baker", "cache", "ads");
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function hashKey(key) {
+  return createHash("sha256").update(key).digest("hex").slice(0, 16);
+}
+function cachePath(category, key) {
+  const dir = join(CACHE_DIR, category);
+  ensureDir(dir);
+  return join(dir, `${hashKey(key)}.json`);
+}
+function cacheGet(category, key) {
+  const path = cachePath(category, key);
+  if (!existsSync(path)) {
+    return null;
+  }
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const entry = JSON.parse(raw);
+    if (entry.expiresAt < Date.now()) {
+      rmSync(path, { force: true });
+      return null;
+    }
+    return entry;
+  } catch {
+    rmSync(path, { force: true });
+    return null;
+  }
+}
+function cacheSet(category, key, data, ttlMs, fields) {
+  const path = cachePath(category, key);
+  const entry = {
+    expiresAt: Date.now() + ttlMs,
+    data,
+    fields
+  };
+  writeFileSync(path, JSON.stringify(entry), "utf-8");
+}
+var HOUR = 60 * 60 * 1e3;
+var MINUTE = 60 * 1e3;
+function getQueryTtl(query) {
+  const upper = query.toUpperCase();
+  if (upper.includes("TODAY")) {
+    return 15 * MINUTE;
+  }
+  if (upper.includes("LAST_7_DAYS") || upper.includes("LAST_14_DAYS")) {
+    return 1 * HOUR;
+  }
+  return 6 * HOUR;
+}
+function buildQueryCacheKey(customerId, query) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  return `${customerId}:${today}:${query.trim().replace(/\s+/g, " ")}`;
+}
+function getManagerIdForCustomer(customerId) {
+  const cached = cacheGet("accounts", "list");
+  if (!cached) return void 0;
+  const account = cached.data.find((a) => a.id === customerId);
+  if (account?.access_type === "managed") return account.manager_id;
+  return void 0;
+}
+
+// src/commands/ads/output.ts
+function writeAdsJson(envelope) {
+  process.stdout.write(`${JSON.stringify(envelope, null, 2)}
+`);
+}
+function writeJsonEnvelope(envelope) {
+  process.stdout.write(`${JSON.stringify(envelope, null, 2)}
+`);
+}
+var TABLE_OUTPUT_FORMATS = ["json", "csv", "jsonl", "md"];
+function outputFormatRefusal(format, supported) {
+  if (supported.includes(format)) return null;
+  const list = supported.length > 1 ? `${supported.slice(0, -1).join(", ")} or ${supported.at(-1)}` : supported.join("");
+  return `--output ${format} is not supported \u2014 use ${list}`;
+}
+function toCsvRow(values) {
+  return values.map((v) => {
+    if (v.includes(",") || v.includes('"') || v.includes("\n")) {
+      return `"${v.replace(/"/g, '""')}"`;
+    }
+    return v;
+  }).join(",");
+}
+function flattenRow(row) {
+  const flat = {};
+  for (const [key, val] of Object.entries(row)) {
+    flat[key] = typeof val === "object" && val !== null ? JSON.stringify(val) : String(val ?? "");
+  }
+  return flat;
+}
+function writeWhole(lines) {
+  process.stdout.write(`${lines.join("\n")}
+`);
+}
+function writeAdsCsv(data, fields) {
+  if (data.length === 0) return;
+  const cols = fields ?? Object.keys(data[0] ?? {});
+  const lines = [toCsvRow(cols)];
+  for (const row of data) {
+    const flat = flattenRow(row);
+    lines.push(toCsvRow(cols.map((f) => flat[f] ?? "")));
+  }
+  writeWhole(lines);
+}
+function writeAdsJsonl(data) {
+  if (data.length === 0) return;
+  writeWhole(data.map((row) => JSON.stringify(row)));
+}
+function mdCell(value) {
+  return value.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+}
+function writeAdsMd(data, fields) {
+  if (data.length === 0) return;
+  const cols = fields ?? Object.keys(data[0] ?? {});
+  const lines = [`| ${cols.join(" | ")} |`, `| ${cols.map(() => "---").join(" | ")} |`];
+  for (const row of data) {
+    const flat = flattenRow(row);
+    lines.push(`| ${cols.map((f) => mdCell(flat[f] ?? "")).join(" | ")} |`);
+  }
+  writeWhole(lines);
+}
+function writeAdsOutput(data, format, fields, hints = []) {
+  switch (format) {
+    case "csv":
+      writeAdsCsv(data, fields);
+      break;
+    case "jsonl":
+      writeAdsJsonl(data);
+      break;
+    case "md":
+      writeAdsMd(data, fields);
+      break;
+    default:
+      writeJsonEnvelope(hints.length > 0 ? { ok: true, data, hints } : { ok: true, data });
+      return;
+  }
+  for (const hint of hints) process.stderr.write(`${hint}
+`);
+}
+async function fetchAccounts(useCache = true) {
+  if (useCache) {
+    const cached = cacheGet("accounts", "list");
+    if (cached) return cached.data;
+  }
+  const params = !useCache ? { "skip-cache": "true" } : void 0;
+  const data = await apiGet("/api/ads/google/accounts", params);
+  if (useCache) {
+    cacheSet("accounts", "list", data, 60 * 60 * 1e3);
+  }
+  return data;
+}
+async function resolveCustomerId(args) {
+  const fromArgs = args["customer-id"];
+  const customerId = fromArgs || getEnv().BAKER_GOOGLE_ADS_CUSTOMER_ID;
+  if (customerId) {
+    if (!/^\d{10}$/.test(customerId)) {
+      writeAdsJson({
+        ok: false,
+        error: {
+          code: "INVALID_CUSTOMER_ID",
+          message: "Customer ID must be exactly 10 digits without dashes. Pass --customer-id or set BAKER_GOOGLE_ADS_CUSTOMER_ID."
+        }
+      });
+      process.exit(1);
+    }
+    return customerId;
+  }
+  const useCache = !args["no-cache"];
+  try {
+    const accounts = await fetchAccounts(useCache);
+    const [single] = accounts;
+    if (accounts.length === 1 && single) {
+      process.stderr.write(`Using account "${single.name}" (${single.id})
+`);
+      return single.id;
+    }
+    if (accounts.length === 0) {
+      handleConnectionError("google_ads");
+    }
+    const list = accounts.map((a) => `  ${a.id}  ${a.name}`).join("\n");
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "MULTIPLE_ACCOUNTS",
+        message: `Multiple accounts found. Pass --customer-id or set BAKER_GOOGLE_ADS_CUSTOMER_ID:
+${list}`
+      }
+    });
+    process.exit(1);
+  } catch (err) {
+    if (err instanceof ApiError && isNotConnectedError(err.code, err.message)) {
+      handleConnectionError("google_ads", err.message);
+    }
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "INVALID_CUSTOMER_ID",
+        message: "Could not auto-detect account. Pass --customer-id or set BAKER_GOOGLE_ADS_CUSTOMER_ID."
+      }
+    });
+    process.exit(1);
+  }
+}
+
+export {
+  cacheGet,
+  cacheSet,
+  getQueryTtl,
+  buildQueryCacheKey,
+  getManagerIdForCustomer,
+  writeAdsJson,
+  writeJsonEnvelope,
+  TABLE_OUTPUT_FORMATS,
+  outputFormatRefusal,
+  toCsvRow,
+  writeAdsOutput,
+  resolveCustomerId,
+  connectionFixExplanation,
+  handleConnectionError,
+  isNotConnectedError,
+  needsConnectionFix
+};
+//# sourceMappingURL=chunk-V44SLD5J.js.map

package/dist/chunk-VIBXT23M.js

@@ -0,0 +1,304 @@
+import {
+  languageTag
+} from "./chunk-XY3KCVRB.js";
+import {
+  parseRefExpr
+} from "./chunk-3GJDEOZ2.js";
+import {
+  AWARENESS_VALUES
+} from "./chunk-5HYSKH77.js";
+import {
+  collectAssetRefLikes,
+  isPersistedAssetRef
+} from "./chunk-3GJKFY7A.js";
+
+// src/commands/canvas/creative-definition.ts
+import { parseDocument } from "yaml";
+var PLATFORM_VALUES = ["meta", "google", "linkedin", "tiktok", "youtube", "x", "other"];
+var FORMAT_VALUES = ["1:1", "4:5", "9:16", "16:9", "1.91:1"];
+var EVIDENCE_VALUES = ["observed", "interpreted", "hypothesized", "generated"];
+function titleFromSlug(slug) {
+  const title = slug.split("-").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return title || slug;
+}
+function resolvePlatform(platform) {
+  const value = platform?.trim();
+  return value && PLATFORM_VALUES.includes(value) ? value : "meta";
+}
+function resolveFormats(aspect) {
+  const value = aspect?.trim();
+  return value && FORMAT_VALUES.includes(value) ? [value] : ["4:5"];
+}
+function resolveFormatList(formats) {
+  const valid = [...new Set(formats.map((f) => f.trim()))].filter(
+    (f) => FORMAT_VALUES.includes(f)
+  );
+  return valid.length > 0 ? valid : ["4:5"];
+}
+function describeBlueprintIntent(blueprint) {
+  const intent = blueprint?.ad_intent;
+  if (typeof intent === "string" && intent.trim()) return intent.trim();
+  if (intent && typeof intent === "object") {
+    const summary = intent.summary ?? intent.feeling;
+    if (typeof summary === "string" && summary.trim()) return summary.trim();
+  }
+  return void 0;
+}
+function yamlScalar(value) {
+  return JSON.stringify(value);
+}
+function buildCreativeDefinition(input) {
+  const lines = ["---", `title: ${yamlScalar(input.title)}`, `kind: ${input.kind}`, `platform: ${input.platform}`];
+  lines.push(`formats: [${input.formats.map(yamlScalar).join(", ")}]`);
+  lines.push(`status: ${input.status ?? "draft"}`);
+  if (input.sourceReferenceUrl) lines.push(`sourceReferenceUrl: ${yamlScalar(input.sourceReferenceUrl)}`);
+  if (input.sourceAdvertiser) lines.push(`sourceAdvertiser: ${yamlScalar(input.sourceAdvertiser)}`);
+  if (input.sourceAdvertiserId) lines.push(`sourceAdvertiserId: ${yamlScalar(input.sourceAdvertiserId)}`);
+  if (input.sourceAdId) lines.push(`sourceAdId: ${yamlScalar(input.sourceAdId)}`);
+  if (input.sourcePlatform) lines.push(`sourcePlatform: ${input.sourcePlatform}`);
+  if (input.sourceKind) lines.push(`sourceKind: ${input.sourceKind}`);
+  if (input.sourcePath) lines.push(`sourcePath: ${yamlScalar(input.sourcePath)}`);
+  if (input.targetAdSet) lines.push(`targetAdSet: ${yamlScalar(input.targetAdSet)}`);
+  if (input.viewer) lines.push(`viewer: ${JSON.stringify(input.viewer)}`);
+  lines.push("---", "");
+  lines.push(input.description?.trim() || `${input.title} \u2014 canvas-built ${input.kind} ad for ${input.platform}.`);
+  lines.push("");
+  return lines.join("\n");
+}
+var SOURCE_FIELD_KEYS = ["sourceAdId", "sourcePlatform", "sourceAdvertiserId"];
+function parseDefinitionSourceFields(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match) return {};
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return {};
+  const fields = {};
+  for (const key of SOURCE_FIELD_KEYS) {
+    const value = doc.get(key);
+    if (typeof value === "string" && value.trim()) fields[key] = value.trim();
+  }
+  return fields;
+}
+function oneOf(values, value) {
+  return values.find((allowed) => allowed === value);
+}
+function parseDefinitionStrategyFields(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match) return {};
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return {};
+  const text = (key) => {
+    const value = doc.get(key);
+    return typeof value === "string" && value.trim() ? value.trim() : void 0;
+  };
+  const ideaSlug = text("idea");
+  const message = text("message");
+  const evidence = oneOf(EVIDENCE_VALUES, text("evidence"));
+  const angle = text("angle");
+  const persona = text("persona");
+  const awareness = oneOf(AWARENESS_VALUES, text("awareness"));
+  const hypothesis = text("hypothesis");
+  const seriesLead = text("series");
+  const language = languageTag(text("language") ?? "");
+  return {
+    ...seriesLead ? { seriesLead } : {},
+    ...language ? { language } : {},
+    ...ideaSlug ? { ideaSlug } : {},
+    ...message ? { message } : {},
+    ...evidence ? { evidence } : {},
+    ...angle ? { angle } : {},
+    ...persona ? { persona } : {},
+    ...awareness ? { awareness } : {},
+    ...hypothesis ? { hypothesis } : {}
+  };
+}
+function parseDefinitionSeriesPlace(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match || parseDocument(match[1] ?? "").errors.length > 0) return null;
+  const { seriesLead, language } = parseDefinitionStrategyFields(raw);
+  return { seriesLead: seriesLead ?? null, language: language ?? null };
+}
+function parseDefinitionViewerFields(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match) return {};
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return {};
+  const data = doc.toJS();
+  const adSet = data?.targetAdSet;
+  const targetAdSet = typeof adSet === "string" || typeof adSet === "number" ? String(adSet).trim() : "";
+  return {
+    ...targetAdSet ? { targetAdSet } : {},
+    ...data?.viewer !== void 0 ? { viewer: data.viewer } : {}
+  };
+}
+function setDefinitionViewer(raw, fields) {
+  const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+  if (!match) return raw;
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return raw;
+  if (fields.targetAdSet) doc.set("targetAdSet", fields.targetAdSet);
+  if (fields.viewer) doc.set("viewer", doc.createNode(fields.viewer, { flow: true }));
+  return `---
+${doc.toString()}---${raw.slice(match[0].length)}`;
+}
+
+// src/commands/canvas/run-record.ts
+import path from "path";
+var MAX_RUN_NODES = 200;
+var MAX_OUTPUTS_PER_NODE = 10;
+var MAX_FINAL_OUTPUTS = 10;
+var MAX_CREATIVE_SLUG_LENGTH = 100;
+function creativeSlugFromCanvasPath(filePath) {
+  const normalized = filePath.split(path.sep).join("/");
+  const match = normalized.match(/(?:^|\/)src\/creatives\/([a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\//);
+  const slug = match?.[1] ?? null;
+  return slug && slug.length <= MAX_CREATIVE_SLUG_LENGTH ? slug : null;
+}
+function finalOutputLabelsFromCanvas(parsed) {
+  const canvas = parsed;
+  const outputNodeId = canvas?.output?.node;
+  if (typeof outputNodeId !== "string" || !Array.isArray(canvas?.nodes)) return null;
+  const node = canvas.nodes.find((n) => n?.id === outputNodeId);
+  if (node?.type !== "collect") return null;
+  const explicit = node.params?.labels;
+  if (Array.isArray(explicit) && explicit.every((l) => typeof l === "string")) {
+    return { nodeId: outputNodeId, labels: explicit };
+  }
+  const images = node.inputs?.images;
+  if (!Array.isArray(images)) return null;
+  const labels = images.map((entry) => {
+    if (typeof entry !== "string") return void 0;
+    return parseRefExpr(entry)?.nodeId;
+  });
+  return { nodeId: outputNodeId, labels };
+}
+var OUTPUT_KINDS = /* @__PURE__ */ new Set(["image", "video", "audio", "json", "text", "font"]);
+function toRecordOutput(slot, value, label) {
+  const refs = collectAssetRefLikes(value);
+  const ref = refs.length === 1 ? refs[0] : null;
+  if (!ref || !isPersistedAssetRef(ref)) return null;
+  const kind = typeof ref.kind === "string" && OUTPUT_KINDS.has(ref.kind) ? ref.kind : null;
+  if (!kind) return null;
+  return {
+    slot,
+    label,
+    kind,
+    sha256: ref.sha256,
+    url: ref.url,
+    mime: ref.mime,
+    width: typeof ref.width === "number" ? ref.width : void 0,
+    height: typeof ref.height === "number" ? ref.height : void 0,
+    durationMs: typeof ref.duration_ms === "number" ? ref.duration_ms : void 0
+  };
+}
+function nodeOutputsToRecord(nodeOutputs, labels) {
+  const out = [];
+  for (const [slot, value] of Object.entries(nodeOutputs)) {
+    if (Array.isArray(value)) {
+      value.forEach((item, i) => {
+        const rec = toRecordOutput(`${slot}#${i}`, item, labels?.[i]);
+        if (rec) out.push(rec);
+      });
+    } else {
+      const rec = toRecordOutput(slot, value);
+      if (rec) out.push(rec);
+    }
+  }
+  return out.slice(0, MAX_OUTPUTS_PER_NODE);
+}
+function finalOutputsToRecord(output, labels) {
+  if (Array.isArray(output)) {
+    return output.map((item, i) => toRecordOutput(`final#${i}`, item, labels?.[i])).filter((rec2) => rec2 !== null).slice(0, MAX_FINAL_OUTPUTS);
+  }
+  const rec = toRecordOutput("final", output);
+  return rec ? [rec] : [];
+}
+function finalFiles(output, labels) {
+  const items = Array.isArray(output) ? output : [output];
+  const files = {};
+  items.forEach((item, i) => {
+    const ref = collectAssetRefLikes(item)[0];
+    if (ref && typeof ref.path === "string") files[labels?.[i] ?? `final#${i}`] = ref.path;
+  });
+  return files;
+}
+function buildRunRecord(result, meta, plan, finalLabels) {
+  const nodes = result.node_runs.slice(0, MAX_RUN_NODES).map((run) => {
+    const planned = plan?.get(run.node_id);
+    return {
+      nodeId: run.node_id,
+      nodeType: run.node_type,
+      cached: run.cached,
+      credits: run.credits,
+      durationMs: run.duration_ms,
+      outputs: nodeOutputsToRecord(
+        result.outputs_by_node[run.node_id] ?? {},
+        run.node_id === finalLabels?.nodeId ? finalLabels.labels : void 0
+      ),
+      deps: planned?.deps,
+      status: plan ? "completed" : void 0,
+      paramsPreview: planned?.paramsPreview,
+      ...planned?.role !== void 0 ? { role: planned.role } : {}
+    };
+  });
+  const finalOutputs = finalOutputsToRecord(result.output, finalLabels?.labels);
+  return {
+    runId: result.run_id,
+    ...meta,
+    status: "completed",
+    stats: {
+      totalNodes: result.stats.total_nodes,
+      cachedNodes: result.stats.cached_nodes,
+      totalCredits: result.stats.total_credits,
+      durationMs: result.stats.duration_ms
+    },
+    nodes,
+    finalOutputs: finalOutputs.length > 0 ? finalOutputs : void 0,
+    // Sent whenever the review RAN, empty list included. Sending it only when there
+    // were findings makes a clean render and an unreviewed one look identical in the
+    // record — which is the exact ambiguity this field was added to remove: proving a
+    // review had happened once meant re-running a cached canvas and reading raw JSON.
+    // Only the fields the backend keeps: a static review's typed fields (`kind`) stay in the CLI.
+    ...meta.review ? { review: meta.review.slice(0, 40).map(({ severity, what, scene }) => ({ severity, what, ...scene ? { scene } : {} })) } : {}
+  };
+}
+function buildInitialRunRecord(runId, meta) {
+  return {
+    runId,
+    ...meta,
+    status: "running",
+    stats: { totalNodes: 0, cachedNodes: 0, totalCredits: 0, durationMs: 0 },
+    nodes: []
+  };
+}
+function buildFailedRunRecord(runId, errorMessage, meta) {
+  return {
+    runId,
+    ...meta,
+    status: "failed",
+    errorMessage: errorMessage.slice(0, 2e3),
+    stats: { totalNodes: 0, cachedNodes: 0, totalCredits: 0, durationMs: 0 },
+    nodes: []
+  };
+}
+
+export {
+  titleFromSlug,
+  resolvePlatform,
+  resolveFormats,
+  resolveFormatList,
+  describeBlueprintIntent,
+  buildCreativeDefinition,
+  parseDefinitionSourceFields,
+  parseDefinitionStrategyFields,
+  parseDefinitionSeriesPlace,
+  parseDefinitionViewerFields,
+  setDefinitionViewer,
+  creativeSlugFromCanvasPath,
+  finalOutputLabelsFromCanvas,
+  nodeOutputsToRecord,
+  finalFiles,
+  buildRunRecord,
+  buildInitialRunRecord,
+  buildFailedRunRecord
+};
+//# sourceMappingURL=chunk-VIBXT23M.js.map

package/dist/chunk-VPVAOLWQ.js

@@ -0,0 +1,23 @@
+import {
+  creativesRunResponseSchema
+} from "./chunk-ZJVHZHYP.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-D4N5ZXEO.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-VPVAOLWQ.js.map