@koda-sl/baker-cli 0.449.0 → 0.450.0-dev.b454c3dd2

package/dist/chunk-6F7DVPOS.js

@@ -0,0 +1,310 @@
+import {
+  mappingRowProblem,
+  mentionOf
+} from "./chunk-NYIGXDUG.js";
+import {
+  CONDITION_LOGICS,
+  HUBSPOT_DEAL_CONTACTS,
+  HUBSPOT_OBJECTS,
+  HUBSPOT_PROPERTY_KINDS,
+  REJECTION_MESSAGES,
+  TRIGGER_CONDITIONS_MAX,
+  onlyCondition,
+  triggerProblem,
+  validateEventName
+} from "./chunk-7EPXVICM.js";
+
+// ../api/src/event-sources/hubspot.ts
+var HUBSPOT_CONTACT_ID_VARIABLE = "id";
+var HUBSPOT_CONTACT_PREFIX = "contact.";
+function contactPath(property) {
+  return `${HUBSPOT_CONTACT_PREFIX}${property}`;
+}
+var HUBSPOT_DEFAULT_PROPERTIES = {
+  email: "email",
+  phone: "phone",
+  external_id: HUBSPOT_CONTACT_ID_VARIABLE,
+  first_name: "firstname",
+  last_name: "lastname",
+  city: "city",
+  postal_code: "zip",
+  country: "country",
+  gclid: "hs_google_click_id",
+  fbclid: "hs_facebook_click_id"
+};
+var throughContact = Object.fromEntries(
+  Object.entries(HUBSPOT_DEFAULT_PROPERTIES).map(([field, property]) => [field, contactPath(property)])
+);
+var HUBSPOT_DEAL_DEFAULT_PROPERTIES = {
+  ...throughContact,
+  value: "amount",
+  currency: "deal_currency_code"
+};
+var HUBSPOT_LEAD_DEFAULT_PROPERTIES = throughContact;
+var DEFAULTS = {
+  contact: HUBSPOT_DEFAULT_PROPERTIES,
+  deal: HUBSPOT_DEAL_DEFAULT_PROPERTIES,
+  lead: HUBSPOT_LEAD_DEFAULT_PROPERTIES
+};
+function hubspotDefaultMapping(sourceName, object = "contact") {
+  const mapping = { event_name: sourceName };
+  for (const [field, property] of Object.entries(DEFAULTS[object])) {
+    mapping[field] = mentionOf(property);
+  }
+  return mapping;
+}
+
+// ../api/src/event-sources/wire.ts
+import { z } from "zod";
+var SOURCE_KINDS = ["webhook", "hubspot"];
+var SOURCE_STATUSES = ["learning", "counting", "paused"];
+var SOURCE_NAME_MAX = 80;
+var sourceNameSchema = z.string().trim().min(1).max(SOURCE_NAME_MAX).refine((name) => validateEventName(name) === null, REJECTION_MESSAGES.invalid_name);
+var sourceIdSchema = z.string().min(1);
+var sourceMappingSchema = z.record(z.string(), z.string().min(1)).superRefine((mapping, ctx) => {
+  for (const row of Object.keys(mapping)) {
+    const problem = mappingRowProblem(row);
+    if (problem !== null) ctx.addIssue({ code: "custom", message: problem, path: [row] });
+  }
+});
+var currencyCodeSchema = z.string().trim().toUpperCase().regex(/^[A-Z]{3}$/, "A currency is a three-letter code, like EUR or USD.");
+var hubspotObjectSchema = z.enum(HUBSPOT_OBJECTS);
+var hubspotDealContactsSchema = z.enum(HUBSPOT_DEAL_CONTACTS);
+var hubspotConditionInputSchema = z.strictObject({
+  property: z.string().trim().min(1),
+  /** One of the property's kind's operators (`baker hubspot contacts properties` lists them); `is` when unsaid. */
+  operator: z.string().trim().min(1).default("is"),
+  /** As HubSpot spells them: an option's internal value, a number, a `YYYY-MM-DD`, `true`/`false`. None for an empty check, two for a between, several for a list. */
+  values: z.array(z.string().trim().min(1)).max(50).default([])
+});
+var conditionLogicSchema = z.enum(CONDITION_LOGICS);
+var conditionGroupInputSchema = z.strictObject({
+  logic: conditionLogicSchema,
+  conditions: z.array(hubspotConditionInputSchema).min(1).max(TRIGGER_CONDITIONS_MAX)
+});
+var combinedInputSchema = z.strictObject({
+  /** How the rows combine: `And` (every one) or `Or` (any one) — a Form's filter's "Match AND / OR". */
+  logic: conditionLogicSchema.default("And"),
+  /** Conditions, and groups of conditions with their own logic, one level deep. */
+  conditions: z.array(z.union([hubspotConditionInputSchema, conditionGroupInputSchema])).min(1).max(TRIGGER_CONDITIONS_MAX)
+}).superRefine((trigger, context) => {
+  const problem = triggerProblem(trigger);
+  if (problem !== null) context.addIssue({ code: "custom", message: problem });
+});
+var hubspotTriggerInputSchema = z.union([combinedInputSchema, hubspotConditionInputSchema]).transform((input) => "conditions" in input ? input : onlyCondition(input));
+var hubspotConditionSchema = hubspotConditionInputSchema.extend({
+  propertyLabel: z.string(),
+  kind: z.enum(HUBSPOT_PROPERTY_KINDS),
+  /** A select that holds several values at once (`a;b`); decides what HubSpot may filter on. */
+  multiple: z.boolean().optional(),
+  valueLabels: z.array(z.string())
+});
+var hubspotTriggerFields = {
+  logic: conditionLogicSchema,
+  conditions: z.array(
+    z.union([
+      hubspotConditionSchema,
+      z.strictObject({ logic: conditionLogicSchema, conditions: z.array(hubspotConditionSchema) })
+    ])
+  )
+};
+var hubspotWatchSchema = z.strictObject({
+  ...hubspotTriggerFields,
+  object: hubspotObjectSchema,
+  contacts: hubspotDealContactsSchema.optional()
+});
+var sampleRecordSchema = z.strictObject({ id: z.string(), properties: z.record(z.string(), z.string()) });
+var hubspotPreviewRequestSchema = z.strictObject({
+  object: hubspotObjectSchema.default("contact"),
+  trigger: hubspotTriggerInputSchema,
+  /** Property names to read off the sample; `id` is always there. On a deal or a lead, `contact.<name>` reads its first contact. */
+  properties: z.array(z.string().trim().min(1)).max(60).optional(),
+  /** The record to draw the preview from — an id, or text to search (an email or a name for a contact, a deal's or a lead's name). The one most recently at the trigger when unsaid. */
+  contact: z.string().trim().min(1).max(200).optional()
+});
+var hubspotPreviewSchema = z.strictObject({
+  /** Records satisfying the trigger today — the ones that will NOT be counted. */
+  total: z.number(),
+  /** False when the trigger has more combinations than HubSpot's search takes, so `total` is only near. */
+  exact: z.boolean().optional(),
+  /**
+   * The sample record the trigger is on, with the properties asked for and
+   * the contacts behind it, first first; none when nothing fits.
+   *
+   * One field rather than one per object: a contact source's record *is* the
+   * person and its `contacts` is empty, while a deal's and a lead's carry the
+   * people the event is about. Three parallel nullable fields, exactly one of
+   * them ever set, would say the same thing and let a caller read the wrong one.
+   */
+  record: sampleRecordSchema.extend({ contacts: z.array(sampleRecordSchema) }).nullable()
+});
+var sourcesRequestSchema = z.strictObject({
+  /** The company's own server door: made once, `counting` from the start, the same address for ever after. */
+  server: z.strictObject({}).optional(),
+  create: z.strictObject({ name: sourceNameSchema }).optional(),
+  /** A HubSpot event: read every five minutes, counting from now. The labels are looked up server-side. */
+  createHubspot: z.strictObject({
+    name: sourceNameSchema.optional(),
+    /** A contact, a deal or a lead. A deal's and a lead's event is about its contact, read through `contact.<property>` rows. */
+    object: hubspotObjectSchema.default("contact"),
+    trigger: hubspotTriggerInputSchema,
+    /** On a deal: the deal's first contact (the default), or every contact on it, each its own event. */
+    contacts: hubspotDealContactsSchema.optional(),
+    /** Rows to read off the record, over the defaults; the same table `map` writes. */
+    mapping: sourceMappingSchema.optional(),
+    /** A number property on the record to read as the amount; needs `currency` beside it. Sugar over the mapping's `value` and `currency` rows. */
+    amountProperty: z.string().trim().min(1).optional(),
+    currency: currencyCodeSchema.optional()
+  }).optional(),
+  /** Change what a HubSpot event watches. It counts from now on under the new trigger; the rows stay. The object cannot change: the rows read it. */
+  setTrigger: z.strictObject({
+    sourceId: sourceIdSchema,
+    trigger: hubspotTriggerInputSchema,
+    contacts: hubspotDealContactsSchema.optional()
+  }).optional(),
+  /** Ask HubSpot what a trigger would count today, and read one real record, without making anything. */
+  preview: hubspotPreviewRequestSchema.optional(),
+  /** Change where a HubSpot-read source takes its amount from; no `amountProperty` clears it. Sugar over `map`. */
+  setAmount: z.strictObject({
+    sourceId: sourceIdSchema,
+    amountProperty: z.string().trim().min(1).optional(),
+    currency: currencyCodeSchema.optional()
+  }).optional(),
+  /**
+   * Count a HubSpot event's history: every moment its trigger came to hold
+   * since `since`, read out of HubSpot's own property history.
+   *
+   * Not the thing a source deliberately refuses to do. A source never
+   * backfills the **present state** — somebody who already satisfies a
+   * condition is not an event today — and this reports only moments HubSpot
+   * has a timestamp for, so nothing is invented. Dry unless `write`.
+   */
+  backfill: z.strictObject({
+    sourceId: sourceIdSchema,
+    /** ISO instant, or Unix milliseconds. Bounded by the 400 days the store keeps. */
+    since: z.union([z.string().trim().min(1), z.number()]),
+    /**
+     * Where a capped run carries on from: only records last changed at or
+     * before this instant are read.
+     *
+     * The **read** is what it bounds, never the history. Records are chosen
+     * most-recently-changed first, so a run that reaches its cap has covered
+     * the newest of them and the rest are the ones nearest `since` — which
+     * no shorter window can reach, because shortening one only drops
+     * candidates from the old end and hands back the same newest records
+     * again. `reachedBack` is the value to pass here, and the moments each
+     * record is then judged on are still the whole of `since` to now.
+     */
+    before: z.union([z.string().trim().min(1), z.number()]).optional(),
+    /** Without it, nothing is counted and the answer says what would be. */
+    write: z.boolean().optional()
+  }).optional(),
+  map: z.strictObject({ sourceId: sourceIdSchema, mapping: sourceMappingSchema }).optional(),
+  pause: z.strictObject({ sourceId: sourceIdSchema }).optional(),
+  resume: z.strictObject({ sourceId: sourceIdSchema }).optional(),
+  remove: z.strictObject({ sourceId: sourceIdSchema }).optional()
+});
+var sourceRefusalSchema = z.strictObject({
+  at: z.number(),
+  count: z.number(),
+  code: z.string(),
+  reason: z.string()
+});
+var detectedFieldSchema = z.strictObject({
+  path: z.string(),
+  confidence: z.enum(["key", "value"])
+});
+var HUBSPOT_LISTENING_STATES = ["listening", "not_configured", "failed"];
+var sourceViewSchema = z.strictObject({
+  id: z.string(),
+  kind: z.enum(SOURCE_KINDS),
+  name: z.string(),
+  status: z.enum(SOURCE_STATUSES),
+  /** The address a tool posts to. A HubSpot source has none: Baker calls HubSpot. */
+  url: z.string().optional(),
+  /** What a HubSpot source watches, and on which object. */
+  hubspot: hubspotWatchSchema.optional(),
+  /** A HubSpot source counts changes from here on; one HubSpot reports from before it is dropped. Moves when the trigger changes. */
+  countingSince: z.number().optional(),
+  /**
+   * Whether HubSpot is keeping this source's changes for Baker, as last
+   * checked: `listening` when the app's journal subscription on the account
+   * names the property; `not_configured` when the app has not been told yet
+   * (or cannot be, with no credentials); `failed` when HubSpot refused the
+   * subscription. `detail` says what to do.
+   */
+  listening: z.strictObject({ state: z.enum(HUBSPOT_LISTENING_STATES), detail: z.string().optional() }).optional(),
+  /** Why the last delivery could not be counted, in product words; absent when the last one was. */
+  lastError: z.string().optional(),
+  lastArrivalAt: z.number().optional(),
+  /**
+   * What its last delivery **refused, event by event** — which `lastError` is
+   * not and `lastArrivalAt` cannot be. A source refusing everything it
+   * receives has no arrival and no read failure, so without this it reads as
+   * one nobody has sent anything to. `refusalWords` turns it into the
+   * sentence a person is shown. Cleared by the next delivery that counts.
+   */
+  lastRefusal: sourceRefusalSchema.optional(),
+  /** The first send, masked, while learning. Kept once confirmed. */
+  sample: z.strictObject({ receivedAt: z.number(), body: z.string() }).optional(),
+  /** Field → template; empty means the guess (an address) or the defaults (a HubSpot read). */
+  mapping: z.record(z.string(), z.string()),
+  /** The guess over the sample, for the sheet to prefill and the CLI to suggest. */
+  detected: z.record(z.string(), detectedFieldSchema).optional(),
+  /** Every path the sample's first item holds, with its masked value — what the picker offers. */
+  paths: z.array(z.strictObject({ path: z.string(), value: z.string() })).optional(),
+  /** `baker` when the sample already parses as the `POST /v1/events` contract and needs no mapping. */
+  format: z.enum(["baker", "foreign"]).optional()
+});
+var stagedSourceOpSchema = z.strictObject({
+  kind: z.enum(["create", "setTrigger", "map", "status", "remove"]),
+  ref: z.string(),
+  name: z.string(),
+  summary: z.string(),
+  /** On a create: what the source will watch and read. */
+  hubspot: hubspotWatchSchema.optional(),
+  mapping: z.record(z.string(), z.string()).optional(),
+  status: z.enum(["paused", "counting"]).optional()
+});
+var backfillResultSchema = z.strictObject({
+  sourceId: z.string(),
+  name: z.string(),
+  since: z.number(),
+  /** Records whose history was read. */
+  examined: z.number(),
+  /** Moments the trigger came to hold, across them. */
+  entries: z.number(),
+  /** Of those, already counted — the journal got there first, or a previous run did. */
+  alreadyCounted: z.number(),
+  /** What a `write` run would hand over, or did. */
+  pending: z.number(),
+  /** Whether the read stopped at its cap; {@link BackfillResult.reachedBack} is where to carry on from. */
+  capped: z.boolean(),
+  /**
+   * How far back the read got: the instant the oldest record it examined was
+   * last changed. Only on a capped run, and it is the next run's `before`.
+   */
+  reachedBack: z.number().optional(),
+  counted: z.number().optional(),
+  refused: z.number().optional(),
+  refusedReason: z.string().optional()
+});
+var sourcesResponseSchema = z.strictObject({
+  ok: z.literal(true),
+  data: z.strictObject({
+    sources: z.array(sourceViewSchema),
+    /** Only when the request carried `preview`. */
+    preview: hubspotPreviewSchema.optional(),
+    /** Only when the request carried `backfill`. */
+    backfill: backfillResultSchema.optional(),
+    /** What this chat has staged, when one is attached: applied at Publish, dropped with a discard. */
+    staged: z.array(stagedSourceOpSchema).optional()
+  }),
+  hints: z.array(z.string()).optional()
+});
+
+export {
+  hubspotDefaultMapping,
+  hubspotTriggerInputSchema
+};
+//# sourceMappingURL=chunk-6F7DVPOS.js.map

package/dist/chunk-6NY2GPR4.js

@@ -0,0 +1,304 @@
+import {
+  languageTag
+} from "./chunk-ASI4P6X2.js";
+import {
+  parseRefExpr
+} from "./chunk-FPOGPFAG.js";
+import {
+  AWARENESS_VALUES
+} from "./chunk-5HYSKH77.js";
+import {
+  collectAssetRefLikes,
+  isPersistedAssetRef
+} from "./chunk-HRYOZUSK.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-6NY2GPR4.js.map