@koda-sl/baker-cli 0.499.0 → 0.501.0-dev.6e96f50b9

package/dist/chunk-XRTM4DGG.js

@@ -0,0 +1,285 @@
+import {
+  IDEA_VIDEO_FORMATS,
+  figuresIn,
+  unsourcedClaims
+} from "./chunk-X4A7NEBZ.js";
+import {
+  AD_SPEC_SCHEMA,
+  unfitReasons
+} from "./chunk-N22J7UPW.js";
+import {
+  proofStrength
+} from "./chunk-Q7US4OOA.js";
+
+// src/commands/creatives/make-model.ts
+import { parse, parseDocument, Scalar, visit } from "yaml";
+var REFERENCE_CANDIDATES = 6;
+function isVideoIdea(idea) {
+  return IDEA_VIDEO_FORMATS.includes(idea.format ?? "");
+}
+var BY_TEMPERATURE = {
+  cold: { audienceTemperature: "0_cold", excludeBrandReliant: true },
+  warm: { audienceTemperature: "1_warm_engaged,2_hot_visited", excludeBrandReliant: true },
+  hot: { audienceTemperature: "3_customer" }
+};
+function referenceSearchFor(idea, temperature, where = {}) {
+  return {
+    query: where.category || idea.message,
+    scope: "followed-first",
+    platform: "meta",
+    format: "static",
+    formatPattern: idea.format,
+    awareness: idea.awareness,
+    ...BY_TEMPERATURE[temperature],
+    ...where.country ? { country: where.country } : {},
+    maxPerAdvertiser: 1,
+    limit: REFERENCE_CANDIDATES,
+    diverse: true
+  };
+}
+function referenceSearchesFor(idea, temperature, where = {}) {
+  const strict = referenceSearchFor(idea, temperature, where);
+  const { awareness: _awareness, ...anyStage } = strict;
+  const { audienceTemperature: _temperature, excludeBrandReliant: _reliant, ...viewerAny } = anyStage;
+  const anyViewer = { ...viewerAny, scope: "all" };
+  const { formatPattern: _pattern, ...anyContainer } = anyViewer;
+  const { country: _country, ...anywhere } = anyViewer;
+  const { country: _anyCountry, ...anyContainerAnywhere } = anyContainer;
+  const { query: _query, ...winners } = anyStage;
+  const { query: _anyQuery, country: _winnersCountry, ...winnersAnywhere } = anyViewer;
+  const inMarket = (steps) => where.country ? steps : [];
+  const shows = idea.shows?.trim();
+  const { formatPattern: _shownPattern, ...anyCategory } = { ...anyStage, scope: "all" };
+  const { country: _shownCountry, ...anyCategoryAnywhere } = anyCategory;
+  const { country: _viewerCountry, ...anyViewerAnywhere } = anyViewer;
+  const { formatPattern: _anyPattern, ...shownAnyViewer } = anyViewerAnywhere;
+  const kinds = (where.shows ?? []).flatMap((q) => q.trim() ? [{ ...anyCategoryAnywhere, query: q.trim() }] : []);
+  const shown = shows ? [
+    ...inMarket([{ ...anyCategory, query: shows }]),
+    ...kinds,
+    { ...anyCategoryAnywhere, query: shows },
+    { ...shownAnyViewer, query: shows },
+    ...idea.format ? [{ ...anyViewerAnywhere, query: shows }] : []
+  ] : [];
+  const anyAd = (query) => query?.trim() ? [...inMarket([{ ...anyContainer, query: query.trim() }]), { ...anyContainerAnywhere, query: query.trim() }] : [];
+  if (shows) {
+    return [
+      ...shown,
+      ...where.category ? [anyContainerAnywhere] : [],
+      ...where.audience?.trim() ? [{ ...anyContainerAnywhere, query: where.audience.trim() }] : [],
+      { ...winnersAnywhere, sort: "winner" }
+    ];
+  }
+  return [
+    ...where.country ? [strict, anyStage, anyContainer] : [strict, anyStage],
+    anywhere,
+    anyContainerAnywhere,
+    ...anyAd(where.audience),
+    ...(where.wider ?? []).flatMap((q) => q.trim() ? [{ ...anyContainerAnywhere, query: q.trim() }] : []),
+    ...anyAd(where.industry),
+    ...where.category ? [{ ...anyContainerAnywhere, query: idea.message }] : [],
+    ...inMarket([{ ...winners, sort: "winner" }]),
+    { ...winnersAnywhere, sort: "winner" }
+  ];
+}
+function referenceWhereOf(brief, fallback) {
+  if (!brief) return fallback;
+  const country = brief.country === null ? void 0 : brief.country ?? fallback.country;
+  const audience = brief.audience ?? fallback.audience;
+  return {
+    ...country ? { country } : {},
+    category: brief.category,
+    ...brief.industry ? { industry: brief.industry } : {},
+    ...audience ? { audience } : {},
+    ...brief.wider.length ? { wider: brief.wider } : {},
+    ...brief.shows?.length ? { shows: brief.shows } : {}
+  };
+}
+function rankedForOf(brief, where, bet) {
+  return {
+    category: brief?.category ?? where.category ?? bet.message,
+    ...brief?.industry ? { industry: brief.industry } : {},
+    ...brief?.buyer ? { buyer: brief.buyer } : {},
+    ...brief?.humour ? { humour: brief.humour } : {},
+    ...brief?.memes ? { memes: brief.memes } : {},
+    ...brief?.memesWhy ? { memesWhy: brief.memesWhy } : {},
+    ...brief?.avoid.length ? { avoid: brief.avoid } : {},
+    message: bet.message,
+    who: bet.who,
+    ...bet.shows ? { shows: bet.shows } : {}
+  };
+}
+var brandKey = (name) => name.normalize("NFD").replace(new RegExp("\\p{M}", "gu"), "").toLowerCase().replace(/[^\p{L}\p{N}]/gu, "");
+function isOwnBrand(advertiser, brands) {
+  const page = brandKey(advertiser ?? "");
+  return page !== "" && brands.some((b) => brandKey(b).length >= 3 && page.includes(brandKey(b)));
+}
+function pooledCandidates(searches, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const pooled = [];
+  for (const candidate of searches.flat()) {
+    const brand = candidate.advertiser_id ? `brand:${candidate.advertiser_id}` : null;
+    if (!candidate.ad_id || seen.has(candidate.ad_id) || brand && seen.has(brand)) continue;
+    seen.add(candidate.ad_id);
+    if (brand) seen.add(brand);
+    pooled.push(candidate);
+  }
+  const proven = (c) => proofStrength(c.winner_score) !== "little";
+  return [...pooled.filter(proven), ...pooled.filter((c) => !proven(c))].slice(0, limit);
+}
+function freshReferencesFirst(candidates, taken) {
+  return [
+    ...candidates.filter((c) => !isTakenReference(c, taken)),
+    ...candidates.filter((c) => isTakenReference(c, taken))
+  ];
+}
+function isTakenReference(c, taken) {
+  return c.ad_id != null && taken.adIds.has(c.ad_id) || c.advertiser_id != null && taken.advertiserIds.has(c.advertiser_id);
+}
+function fitsIdea(fit) {
+  return fit.verdict !== "reject" && missingElements(fit).length === 0 && fit.our_viewer?.stops !== "no";
+}
+function missingElements(fit) {
+  return fit.load_bearing.filter((l) => l.have === "missing" && !l.ours?.trim()).map((l) => l.element);
+}
+function whyUnfit(fit) {
+  const reasons = unfitReasons(fit);
+  if (reasons.length > 0) return reasons.join("; ");
+  if (fit.our_viewer?.stops === "no") {
+    return `our viewer would not stop for it${fit.our_viewer.why ? `: ${fit.our_viewer.why}` : ""}`;
+  }
+  return fit.transfer_note?.trim() || "the check found it does not carry this ad";
+}
+function definitionFieldsOf(idea, evidence) {
+  return {
+    idea: idea.id,
+    message: idea.message,
+    ...evidence !== "explore" ? { evidence } : {},
+    angle: idea.angle,
+    persona: idea.who,
+    awareness: idea.awareness,
+    hypothesis: idea.why
+  };
+}
+var FRONTMATTER = /^---\r?\n([\s\S]*?\r?\n)?---/;
+function readsAsText11(text) {
+  try {
+    return parse(text, { version: "1.1" }) === text;
+  } catch {
+    return false;
+  }
+}
+function setDefinitionFields(raw, fields) {
+  const match = raw.match(FRONTMATTER);
+  if (!match) return raw;
+  const doc = parseDocument(match[1] ?? "");
+  if (doc.errors.length > 0) return raw;
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0) continue;
+    const node = doc.createNode(value);
+    visit(node, {
+      Scalar(_, scalar) {
+        if (typeof scalar.value === "string" && !readsAsText11(scalar.value)) {
+          scalar.type = Scalar.QUOTE_DOUBLE;
+        }
+      }
+    });
+    doc.set(key, node);
+  }
+  return `---
+${doc.toString()}---${raw.slice(match[0].length)}`;
+}
+function setSpecMessage(specJson, message) {
+  const spec = JSON.parse(specJson);
+  return `${JSON.stringify({ ...spec, message }, null, 2)}
+`;
+}
+function setSpecViewer(specJson, idea, personas) {
+  const spec = JSON.parse(specJson);
+  const viewer = spec.viewer ?? {};
+  return `${JSON.stringify({ ...spec, viewer: { ...viewer, who: personaWho(idea, personas) } }, null, 2)}
+`;
+}
+function personaWho(idea, personas) {
+  const persona = personas.find((p) => p.slug === idea.who);
+  if (persona?.title) return `${persona.title}${persona.segment ? ` (${persona.segment})` : ""}`;
+  return persona?.segment ?? idea.who.replace(/[-_]/g, " ");
+}
+var AUDIENCE_QUERY_WORDS = 9;
+function audienceQuery(idea, personas) {
+  return personaWho(idea, personas).replace(/\(/g, " ").replace(/\)/g, "").split(/\s+/).filter(Boolean).slice(0, AUDIENCE_QUERY_WORDS).join(" ").replace(/[\s,;:.–—-]+$/, "");
+}
+function fitBetOf(idea, personas, insights, market) {
+  const quotes = insights.filter((i) => idea.evidence.includes(i.id)).map((i) => i.quote);
+  return {
+    who: personaWho(idea, personas),
+    message: idea.message,
+    awareness: idea.awareness,
+    angle: idea.angle,
+    ...idea.shows ? { shows: idea.shows } : {},
+    ...quotes.length > 0 ? { quotes } : {},
+    ...market ? { market } : {}
+  };
+}
+function withFitConcept(specJson, seeded) {
+  const spec = JSON.parse(specJson);
+  const held = spec.concept;
+  if (held?.reference_ad_id) return specJson;
+  return `${JSON.stringify({ ...spec, ...seeded }, null, 2)}
+`;
+}
+function unsourcedCopyLines(specJson, corpus) {
+  const spec = JSON.parse(specJson);
+  const figures = figuresIn(corpus);
+  const lines = Array.isArray(spec.copy) ? spec.copy : [];
+  return lines.flatMap((line) => {
+    const text = typeof line === "object" && line !== null ? line.text : void 0;
+    return typeof text === "string" && unsourcedClaims(text, figures).length > 0 ? [text] : [];
+  });
+}
+var PHOTO_FORMATS = /photo|lifestyle|before_after|ugc|product|selfie|street/;
+function ideaSpec(idea, who) {
+  const container = idea.format ? `, as a ${idea.format.replace(/_/g, " ")}` : "";
+  const shows = idea.shows ? ` (${idea.shows})` : "";
+  return {
+    schema: AD_SPEC_SCHEMA,
+    viewer: { who },
+    message: idea.message,
+    copy: [{ text: "[TODO: the headline, in the customer's words]", lettering: "designed", role: "headline" }],
+    scene: {
+      description: `[TODO: what the viewer sees first${shows}${container}, that shows: ${idea.message}]`,
+      look: PHOTO_FORMATS.test(idea.format ?? idea.shows ?? "") ? "photo" : "designed"
+    },
+    colors: [],
+    references: [],
+    logo: true,
+    third_party_brands: [],
+    scene_text: [],
+    mechanism: []
+  };
+}
+
+export {
+  isVideoIdea,
+  referenceSearchesFor,
+  referenceWhereOf,
+  rankedForOf,
+  isOwnBrand,
+  pooledCandidates,
+  freshReferencesFirst,
+  isTakenReference,
+  fitsIdea,
+  missingElements,
+  whyUnfit,
+  definitionFieldsOf,
+  setDefinitionFields,
+  setSpecMessage,
+  setSpecViewer,
+  personaWho,
+  audienceQuery,
+  fitBetOf,
+  withFitConcept,
+  unsourcedCopyLines,
+  ideaSpec
+};
+//# sourceMappingURL=chunk-XRTM4DGG.js.map

package/dist/chunk-Y35WFNKZ.js

@@ -0,0 +1,131 @@
+import {
+  holdUnbilledSpend
+} from "./chunk-E44NXCTL.js";
+import {
+  askAboutText
+} from "./chunk-PSYAT3ZM.js";
+
+// src/engine/brand/brand-doc.ts
+import { createHash } from "crypto";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var BRAND_DOC_MODEL = "google/gemini-3.5-flash-lite";
+var REQUEST = {
+  provider: { order: ["google-vertex"], allow_fallbacks: false },
+  seed: 0,
+  response_format: { type: "json_object" }
+};
+var PROMPT_VERSION = 3;
+var TIMEOUT_MS = 3e4;
+var BRAND_MD_CHARS = 32e3;
+var NOTE_CHARS = 600;
+var COMPANY_MD_CHARS = 4e3;
+var Font = z.object({
+  family: z.string().trim().min(1).max(60),
+  role: z.enum(["heading", "body", "any"]).catch("any"),
+  use: z.boolean()
+});
+var Color = z.object({
+  hex: z.string().trim().regex(/^#?[0-9a-fA-F]{6}$/).transform((h) => `#${h.replace(/^#/, "").toLowerCase()}`),
+  use: z.boolean()
+});
+var note = z.string().trim().min(1).max(NOTE_CHARS).nullable().optional().catch(null);
+var Reading = z.object({
+  name: z.string().trim().min(1).max(80).nullable().catch(null),
+  wordmark: z.array(z.string().trim().min(1).max(40)).catch([]),
+  logoNames: z.array(z.string().trim().min(1).max(40)).catch([]),
+  fonts: z.array(z.unknown()).catch([]),
+  colors: z.array(z.unknown()).catch([]),
+  voice: note,
+  imagery: note,
+  logoUsage: note
+});
+function brandDocPrompt(docs) {
+  return [
+    "You read a company's brand guidelines (BRAND.md), the start of its company profile (COMPANY.md) and the file names of its logos. They may be written in any language, or several. Extract only what they state; never invent a value.",
+    "",
+    "Return JSON only, in this shape:",
+    '{"name": string | null, "wordmark": string[], "logoNames": string[], "fonts": [{"family": string, "role": "heading" | "body" | "any", "use": boolean}], "colors": [{"hex": "#rrggbb", "use": boolean}], "voice": string | null, "imagery": string | null, "logoUsage": string | null}',
+    "",
+    `- name: the brand's name exactly as written ("# Zernio Brand Guidelines" names Zernio). null when neither document states one, as in an unfilled template ("# Brand Guidelines", "# Company", TODO).`,
+    `- wordmark: every word the documents say the logo prints, as they quote it ("Wordmark: \\"permut\\"" gives "permut"; 'symbol plus "Cubbo" wordmark' gives "Cubbo"), even when it is also the name. [] when they quote none.`,
+    '- logoNames: a product or brand name a logo file name carries ("logo-engage-blue.png" gives "Engage"). Colours, variants, sizes and formats (dark, white, icon, isotype, png) are not names. [] when none.',
+    `- fonts: every typeface the guidelines name, by its family name exactly, the banned ones included. role is heading, body, or any when they do not say. use is false when the guidelines ban it, forbid it or say to avoid it or never use it, in any wording or language; true when the brand uses it. Only a named typeface counts: a generic family (sans-serif, serif, monospace, system-ui) or the operating system's own fonts ("system stack", "system fonts") is not one, so leave it out.`,
+    "- colors: every hex colour the guidelines give. use is false when they ban it or say to avoid it, true when it is a brand colour.",
+    "- voice: how the brand speaks, as the guidelines put it, at most two sentences in their language. null when they do not say.",
+    "- imagery: what the brand's pictures look like and never look like (photography, illustration, people; a ```generation-style block says it too), at most two sentences in their language. null when they do not say.",
+    "- logoUsage: which logo file an ad uses and how it must appear (which file for which product, line or background, what never to do to it), at most two sentences in their language. null when they do not say.",
+    "",
+    "<brand_md>",
+    (docs.brandMd ?? "").slice(0, BRAND_MD_CHARS),
+    "</brand_md>",
+    "<company_md>",
+    (docs.companyMd ?? "").slice(0, COMPANY_MD_CHARS),
+    "</company_md>",
+    "<logo_files>",
+    (docs.logoFiles ?? []).join("\n"),
+    "</logo_files>"
+  ].join("\n");
+}
+function parseBrandDoc(answer) {
+  const parsed = Reading.safeParse(answer);
+  if (!parsed.success) return null;
+  const fonts = parsed.data.fonts.flatMap((f) => {
+    const font = Font.safeParse(f);
+    return font.success ? [font.data] : [];
+  });
+  const colors = parsed.data.colors.flatMap((c) => {
+    const color = Color.safeParse(c);
+    return color.success ? [color.data] : [];
+  });
+  const { voice, imagery, logoUsage } = parsed.data;
+  return {
+    ...parsed.data.name ? { name: parsed.data.name } : {},
+    wordmark: [.../* @__PURE__ */ new Set([...parsed.data.wordmark, ...parsed.data.logoNames])],
+    fonts,
+    colors,
+    ...voice ? { voice } : {},
+    ...imagery ? { imagery } : {},
+    ...logoUsage ? { logoUsage } : {}
+  };
+}
+function brandDocReader(cacheDir, onSpend) {
+  return async (docs) => {
+    const prompt = brandDocPrompt(docs);
+    const key = createHash("sha256").update(JSON.stringify([PROMPT_VERSION, BRAND_DOC_MODEL, prompt])).digest("hex");
+    const file = path.join(cacheDir, "brand-doc", `${key}.json`);
+    const cached = parseBrandDoc(await readFile(file, "utf8").then(JSON.parse, () => null));
+    if (cached) return cached;
+    const spent = [];
+    const answer = await askAboutText(BRAND_DOC_MODEL, prompt, (u) => onSpend ? onSpend(u) : spent.push(u), {
+      timeoutMs: TIMEOUT_MS,
+      request: REQUEST
+    }).catch(() => null);
+    await holdUnbilledSpend(cacheDir, spent).catch(() => void 0);
+    const reading = parseBrandDoc(answer);
+    if (reading) {
+      await mkdir(path.dirname(file), { recursive: true }).catch(() => void 0);
+      await writeFile(file, JSON.stringify(reading), "utf8").catch(() => void 0);
+    }
+    return reading;
+  };
+}
+var LOGO_FILE = /logo|lockup|wordmark|isotype|isologo/i;
+async function workspaceBrandDocs(root) {
+  const read = (rel) => readFile(path.join(root, rel), "utf8").catch(() => null);
+  const logoFiles = (await readdir(path.join(root, "src", "brand", "logos")).catch(() => [])).filter((f) => /\.(png|jpe?g|webp|svg)$/i.test(f) && LOGO_FILE.test(f)).sort();
+  return { brandMd: await read("src/brand/BRAND.md"), companyMd: await read("COMPANY.md"), logoFiles };
+}
+async function readWorkspaceBrandDoc(root, opts = {}) {
+  const docs = await workspaceBrandDocs(root);
+  if (!docs.brandMd?.trim() && !docs.companyMd?.trim()) return null;
+  const read = opts.read ?? brandDocReader(path.join(root, "canvas", ".cache"), opts.onSpend);
+  return await read(docs).catch(() => null);
+}
+
+export {
+  LOGO_FILE,
+  readWorkspaceBrandDoc
+};
+//# sourceMappingURL=chunk-Y35WFNKZ.js.map

package/dist/chunk-Y456MK74.js

@@ -0,0 +1,224 @@
+import {
+  nodeParamsPreview
+} from "./chunk-5HJ4F4NQ.js";
+import {
+  creativeSlugFromCanvasPath
+} from "./chunk-ERGEZPJH.js";
+import {
+  parseDefinitionDelivery,
+  parseDefinitionSeriesPlace,
+  parseDefinitionSourceFields,
+  parseDefinitionStrategyFields,
+  prepareCanvas
+} from "./chunk-JD2PWX7P.js";
+import {
+  BackendClient
+} from "./chunk-JYOVVJ2E.js";
+import {
+  nodeDependencies
+} from "./chunk-B5JQM24Z.js";
+import {
+  requireCredentialsFromEnv
+} from "./chunk-FOMFU2RX.js";
+
+// src/commands/canvas/sync-definition.ts
+import { readdir, readFile, stat } from "fs/promises";
+import path from "path";
+import { parseDocument } from "yaml";
+import { defineCommand } from "citty";
+
+// src/commands/canvas/definition-graph.ts
+var MAX_NODES = 300;
+var PREVIEWABLE_INGEST_EXPECTS = /* @__PURE__ */ new Set(["image"]);
+function nodeInputPreviewUrl(type, params) {
+  if (type !== "ingest" || !params || typeof params !== "object") return void 0;
+  const p = params;
+  if (p.source !== "url" || typeof p.url !== "string") return void 0;
+  if (!/^https?:\/\//i.test(p.url)) return void 0;
+  if (typeof p.expect === "string" && !PREVIEWABLE_INGEST_EXPECTS.has(p.expect)) return void 0;
+  return p.url;
+}
+function canvasToDefinitionGraph(canvas) {
+  const rawNodes = canvas?.nodes;
+  if (!Array.isArray(rawNodes)) return null;
+  const parsed = [];
+  for (const raw of rawNodes) {
+    const id = raw?.id;
+    const type = raw?.type;
+    if (typeof id !== "string" || typeof type !== "string") continue;
+    parsed.push({ id, type, inputs: raw.inputs, params: raw.params });
+    if (parsed.length >= MAX_NODES) break;
+  }
+  if (parsed.length === 0) return null;
+  const ids = new Set(parsed.map((n) => n.id));
+  const nodes = parsed.map(({ id, type, inputs, params }) => {
+    const deps = nodeDependencies({ id, inputs, params }, ids);
+    deps.delete(id);
+    const depList = [...deps];
+    const paramsPreview = nodeParamsPreview(params, depList);
+    const base = { id, type };
+    if (depList.length > 0) base.deps = depList;
+    if (paramsPreview) base.paramsPreview = paramsPreview;
+    const inputPreviewUrl = nodeInputPreviewUrl(type, params);
+    if (inputPreviewUrl) base.inputPreviewUrl = inputPreviewUrl;
+    return base;
+  });
+  const rawOutput = canvas?.output;
+  const outNode = rawOutput?.node;
+  const outSlot = rawOutput?.output;
+  const output = typeof outNode === "string" && typeof outSlot === "string" ? { node: outNode, output: outSlot } : void 0;
+  return { nodes, output };
+}
+
+// src/commands/canvas/sync-definition.ts
+function buildDefinitionSyncPayload(input, graph, chatId) {
+  const { canvas: _canvas, ...fields } = input;
+  return Object.fromEntries([
+    ...Object.entries(fields).filter(([, v]) => v !== void 0),
+    ["graph", graph],
+    ["chatId", chatId]
+  ]);
+}
+async function readDefinitionSourceFields(canvasPath) {
+  try {
+    return parseDefinitionSourceFields(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function readDefinitionPlatforms(canvasPath) {
+  const raw = await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8").catch(() => null);
+  const delivery = raw === null ? null : parseDefinitionDelivery(raw);
+  return delivery ? { platforms: delivery.platforms ?? null } : {};
+}
+async function readDefinitionBody(canvasPath) {
+  try {
+    return { definition: await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8") };
+  } catch {
+    return {};
+  }
+}
+async function readDefinitionTitle(canvasPath) {
+  try {
+    const raw = await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8");
+    const match = raw.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+    const doc = match ? parseDocument(match[1] ?? "") : null;
+    const title = doc && doc.errors.length === 0 ? doc.get("title") : void 0;
+    return typeof title === "string" && title.trim() ? title.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readDefinitionStrategyFields(canvasPath) {
+  try {
+    return parseDefinitionStrategyFields(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function readDefinitionSeriesPlace(canvasPath) {
+  try {
+    return parseDefinitionSeriesPlace(await readFile(path.join(path.dirname(canvasPath), "_definition.md"), "utf8")) ?? {};
+  } catch {
+    return {};
+  }
+}
+async function syncCreativeDefinitionBestEffort(input) {
+  const chatId = process.env.BAKER_CHAT_ID;
+  if (!chatId) return;
+  const graph = canvasToDefinitionGraph(input.canvas);
+  if (!graph || graph.nodes.length === 0) return;
+  try {
+    const creds = requireCredentialsFromEnv();
+    const client = new BackendClient({ baseUrl: creds.url, apiKey: creds.apiKey });
+    await client.syncCreativeDefinition(buildDefinitionSyncPayload(input, graph, chatId));
+    process.stdout.write(`[definition] synced workflow graph (${graph.nodes.length} nodes) \u2014 view it in the dashboard
+`);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    process.stderr.write(`[warn] workflow graph not synced (${msg})
+`);
+  }
+}
+async function resolveCanvasPath(inputPath) {
+  const resolved = path.resolve(inputPath);
+  let dir = resolved;
+  try {
+    if ((await stat(resolved)).isFile()) {
+      if (resolved.endsWith(".canvas.json")) return resolved;
+      dir = path.dirname(resolved);
+    }
+  } catch {
+    dir = resolved.endsWith(".canvas.json") ? path.dirname(resolved) : resolved;
+  }
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return null;
+  }
+  const canvases = entries.filter((name) => name.endsWith(".canvas.json"));
+  const slug = creativeSlugFromCanvasPath(`${dir}/x/`);
+  const chosen = (slug ? canvases.find((name) => name === `${slug}.canvas.json`) : void 0) ?? canvases[0];
+  return chosen ? path.join(dir, chosen) : null;
+}
+var syncDefinitionCommand = defineCommand({
+  meta: {
+    name: "sync-definition",
+    description: "Push a creative's current node-graph + input thumbnails to the dashboard without rendering. The graph has the creative's blueprint applied (prompt.json and scenes/*.json edits), exactly as `run` would render it, without changing any file. Runs automatically when you edit a creative's canvas.json or prompt.json."
+  },
+  args: {
+    file: {
+      type: "positional",
+      required: true,
+      description: "A path under src/creatives/<slug>/ (the .canvas.json, its prompt.json, or the folder)"
+    },
+    title: {
+      type: "boolean",
+      description: "Also record the title its _definition.md gives. Only for a creative just made from another (a series ad, a translation), never on an edit re-sync."
+    }
+  },
+  async run({ args }) {
+    const canvasPath = await resolveCanvasPath(String(args.file));
+    if (!canvasPath) {
+      return;
+    }
+    const slug = creativeSlugFromCanvasPath(canvasPath);
+    if (!slug) return;
+    let canvas;
+    let sourceSha;
+    try {
+      const prepared = await prepareCanvas(canvasPath, { write: false });
+      canvas = prepared.fileGraph;
+      sourceSha = prepared.sourceSha;
+    } catch {
+      return;
+    }
+    const title = args.title ? await readDefinitionTitle(canvasPath) : void 0;
+    await syncCreativeDefinitionBestEffort({
+      slug,
+      canvas,
+      sourceSha,
+      ...title ? { title } : {},
+      ...await readDefinitionSourceFields(canvasPath),
+      ...await readDefinitionStrategyFields(canvasPath),
+      ...await readDefinitionSeriesPlace(canvasPath),
+      ...await readDefinitionPlatforms(canvasPath),
+      ...await readDefinitionBody(canvasPath)
+    });
+  }
+});
+
+export {
+  buildDefinitionSyncPayload,
+  readDefinitionSourceFields,
+  readDefinitionPlatforms,
+  readDefinitionBody,
+  readDefinitionTitle,
+  readDefinitionStrategyFields,
+  readDefinitionSeriesPlace,
+  syncCreativeDefinitionBestEffort,
+  resolveCanvasPath,
+  syncDefinitionCommand
+};
+//# sourceMappingURL=chunk-Y456MK74.js.map

package/dist/chunk-YW2SISXV.js

@@ -0,0 +1,57 @@
+import {
+  formEventKey
+} from "./chunk-DI44SZVP.js";
+import {
+  flowNodeTriggers
+} from "./chunk-MWD6JTOY.js";
+
+// ../api/src/analytics/flowEventKeys.ts
+function flowNodes(node, acc = []) {
+  if (!node || typeof node !== "object") return acc;
+  const record = node;
+  acc.push(record);
+  if (Array.isArray(record.children)) for (const child of record.children) flowNodes(child, acc);
+  return acc;
+}
+function flowEventKeys(tree, slug) {
+  const primary = [];
+  const secondary = [];
+  const nodes = flowNodes(tree).filter((node) => typeof node.id === "string" && node.id !== "");
+  if (nodes.length === 0) return [];
+  for (const node of nodes) {
+    const id = node.id;
+    const triggers = flowNodeTriggers(node.nodeData);
+    for (const triggerId of triggers.available) {
+      const candidate = {
+        eventKey: formEventKey(slug, id, triggerId),
+        nodeId: id,
+        nodeName: typeof node.name === "string" ? node.name : id,
+        nodeType: triggers.type,
+        triggerId,
+        isCompletion: triggers.completion === triggerId
+      };
+      (candidate.isCompletion ? primary : secondary).push(candidate);
+    }
+  }
+  return [
+    ...primary,
+    ...secondary,
+    {
+      eventKey: `submit:${slug}`,
+      nodeId: null,
+      nodeName: "the Form ran out of steps",
+      nodeType: null,
+      triggerId: null,
+      // A Form reaching its last node is as primary as an outcome gets for a
+      // Form with no widget in it — but it never fires on one that ends in a
+      // booking widget or a redirect, so it does not lead the list.
+      isCompletion: false
+    }
+  ];
+}
+
+export {
+  flowNodes,
+  flowEventKeys
+};
+//# sourceMappingURL=chunk-YW2SISXV.js.map