@koda-sl/baker-cli 0.525.0 → 0.526.0

package/dist/chunk-XJHUSJY6.js

@@ -0,0 +1,156 @@
+import {
+  Phrases,
+  RULE_APPLIES,
+  RULE_KINDS,
+  RULE_STRENGTHS
+} from "./chunk-JCVPZ7CV.js";
+import {
+  holdWorkspaceSpend
+} from "./chunk-V2XEX2YR.js";
+import {
+  askAboutText
+} from "./chunk-SDQLZYQG.js";
+import {
+  CREATIVE_FEEDBACK_REASON_LABELS
+} from "./chunk-HVJJEQDQ.js";
+
+// src/commands/creatives/rule-candidate.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+var optionalPhrases = Phrases.optional().catch(void 0);
+var Draft = z.object({
+  because: z.string().trim().min(3).max(400),
+  text: z.string().trim().min(1).max(300),
+  strength: z.enum(RULE_STRENGTHS).catch("must"),
+  applies: z.enum(RULE_APPLIES).catch("any"),
+  language: z.string().trim().regex(/^[a-z]{2,3}$/).optional().catch(void 0),
+  kinds: z.array(z.enum(RULE_KINDS)).optional().catch(void 0),
+  platforms: optionalPhrases,
+  forbid: optionalPhrases,
+  require: optionalPhrases,
+  allow: optionalPhrases,
+  people: z.literal("real").optional().catch(void 0)
+});
+function parseDrafts(answer) {
+  const rules = answer?.rules;
+  if (!Array.isArray(rules)) return [];
+  return rules.slice(0, MAX_DRAFTS).flatMap((raw) => {
+    const draft = Draft.safeParse(raw);
+    if (!draft.success) return [];
+    const { because: _because, ...rule } = draft.data;
+    return [
+      Object.fromEntries(
+        Object.entries(rule).filter(([, v]) => v !== void 0 && !(Array.isArray(v) && v.length === 0))
+      )
+    ];
+  });
+}
+var MAX_DRAFTS = 3;
+function draftRulesPrompt(note, ad) {
+  const where = [ad.kind ? `a ${ad.kind} ad` : "an ad", ad.platform ? `for ${ad.platform}` : ""].filter(Boolean).join(" ");
+  return [
+    `A person rejected ${where} and said, in their own words:`,
+    `"""${note}"""`,
+    "",
+    "List only the standing rules this note states for EVERY future ad of the company (at most 3). Most notes state none: they ask for changes to this ad (fix a word, move the logo, speed up a scene, redo the pieces), and a change to this ad is never a rule, however it is phrased. A rule is standing only when the note itself says it holds beyond this ad (always, never, in every video, in these creatives, these mistakes keep happening, it is the format of the programme, the rule of the other pieces), or it corrects how the company or what it sells must always be named.",
+    "For each rule, quote in `because` the note's own words that make it hold beyond this ad; a rule you cannot quote that for is not a rule. Return JSON only:",
+    '{"rules": [{"because": string, "text": string, "strength": "never" | "must" | "prefer", "applies": "copy" | "picture" | "cast" | "logo" | "voice" | "sound" | "subtitles" | "any", "language": string, "kinds": ["static" | "video"], "platforms": string[], "forbid": string[], "require": string[], "allow": string[], "people": "real" | null}]}',
+    "- text: the rule in one short sentence, in the note's own language and close to its words.",
+    '- strength: "never" for a ban, "must" for something every ad has to do, "prefer" for a taste.',
+    '- applies: what of the ad it is about ("copy" for its words, "picture", "cast" for who appears, "logo", "voice", "sound", "subtitles"), else "any".',
+    `- language: the note's language as a two-letter code ("es").`,
+    '- kinds and platforms: only when the note limits the rule to them ("en estos creativos de linkedin" gives platforms ["linkedin"]); else [].',
+    `- forbid: the exact words the rule bans in the ad's words, only when a word or phrase decides it ("100 % online", not "online" gives forbid ["online"], allow ["100 % online"]); else []. require: words every ad must say; usually []. allow: the right phrase that contains a banned word.`,
+    '- people: "real" only when the rule is that no AI-made or invented people appear; else null.',
+    'Return {"rules": []} when the note states no standing rule.'
+  ].join("\n");
+}
+var RULE_DRAFT_MODEL = "google/gemini-3.5-flash";
+var DRAFT_REQUEST = {
+  provider: { order: ["google-vertex"], allow_fallbacks: false },
+  seed: 0,
+  reasoning: { effort: "low" },
+  response_format: { type: "json_object" }
+};
+var DRAFT_TIMEOUT_MS = 3e4;
+function modelRuleDrafter(cacheDir) {
+  return async (note, ad) => {
+    const prompt = draftRulesPrompt(note, ad);
+    const key = createHash("sha256").update(JSON.stringify([RULE_DRAFT_MODEL, prompt])).digest("hex").slice(0, 16);
+    const file = path.join(cacheDir, "rule-drafts", `${key}.json`);
+    const cached = await readFile(file, "utf8").then(
+      (raw) => parseDrafts(JSON.parse(raw)),
+      () => null
+    );
+    if (cached) return cached;
+    const spent = [];
+    const answer = await askAboutText(RULE_DRAFT_MODEL, prompt, (u) => spent.push(u), {
+      timeoutMs: DRAFT_TIMEOUT_MS,
+      request: DRAFT_REQUEST
+    }).catch(() => null);
+    await holdWorkspaceSpend(spent);
+    if (answer === null) return [];
+    await mkdir(path.dirname(file), { recursive: true }).catch(() => void 0);
+    await writeFile(file, JSON.stringify(answer), "utf8").catch(() => void 0);
+    return parseDrafts(answer);
+  };
+}
+async function ruleCandidates(note, ad, draft) {
+  const text = note?.trim();
+  if (!text) return [];
+  return await draft(text, ad).catch(() => []);
+}
+var candidatesDir = (cacheDir) => path.join(cacheDir, "rule-candidates");
+async function saveCandidates(cacheDir, candidates) {
+  await mkdir(candidatesDir(cacheDir), { recursive: true });
+  return await Promise.all(
+    candidates.map(async (c) => {
+      const id = `rc-${createHash("sha256").update(JSON.stringify(c)).digest("hex").slice(0, 8)}`;
+      await writeFile(path.join(candidatesDir(cacheDir), `${id}.json`), JSON.stringify(c), "utf8");
+      return id;
+    })
+  );
+}
+async function loadCandidate(cacheDir, id) {
+  if (!/^rc-[0-9a-f]{8}$/.test(id)) return null;
+  return await readFile(path.join(candidatesDir(cacheDir), `${id}.json`), "utf8").then(
+    (raw) => JSON.parse(raw),
+    () => null
+  );
+}
+var REPEATED_ON = 2;
+var REPEATED_NOTES = 3;
+function repeatedReasons(notes, reasons, slug) {
+  return reasons.flatMap((reason) => {
+    const others = notes.filter((n) => n.creative !== slug && n.reasons.includes(reason));
+    const creatives = new Set(others.map((n) => n.creative)).size;
+    return creatives >= REPEATED_ON ? [
+      {
+        label: CREATIVE_FEEDBACK_REASON_LABELS[reason],
+        creatives,
+        notes: [...new Set(others.map((n) => n.note))].slice(0, REPEATED_NOTES)
+      }
+    ] : [];
+  });
+}
+function ruleCandidateHints(drafted, repeated) {
+  const asks = drafted.map(
+    (d) => `Their words state a rule for every ad: "${d.text}". Ask them once, in their language: make this a rule for every ad from now on? Only on yes: \`baker creatives rules add --candidate ${d.id}\` (reword it with --text if they correct it). On no, never ask again in this chat.`
+  );
+  const patterns = repeated.map(
+    (r) => `"${r.label}" was also the reason on ${r.creatives} other ads (their words: ${r.notes.map((n) => `"${n}"`).join("; ")}). ${drafted.length > 0 ? "Say so when you ask." : 'Ask them once whether there is a rule for every ad behind it; on yes, `baker creatives rules add --text "<the rule, in their words>" \u2026`.'}`
+  );
+  return [...asks, ...patterns];
+}
+
+export {
+  modelRuleDrafter,
+  ruleCandidates,
+  saveCandidates,
+  loadCandidate,
+  repeatedReasons,
+  ruleCandidateHints
+};
+//# sourceMappingURL=chunk-XJHUSJY6.js.map

package/dist/chunk-XPDUBDPL.js

@@ -0,0 +1,25 @@
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-B4UVJCJ4.js";
+
+// src/commands/avatars/transport.ts
+function unwrap(response) {
+  if (response.ok === false || response.data === void 0) {
+    throw new ApiError("INTERNAL_ERROR", response.error?.message ?? "The avatars service returned an unusable answer");
+  }
+  return response.data;
+}
+async function readAvatars(path, params) {
+  return unwrap(await apiGet(path, params));
+}
+async function writeAvatars(path, body, opts) {
+  return unwrap(await apiPost(path, body, opts));
+}
+
+export {
+  readAvatars,
+  writeAvatars
+};
+//# sourceMappingURL=chunk-XPDUBDPL.js.map

package/dist/chunk-XRSRHAEU.js

@@ -0,0 +1,163 @@
+import {
+  failApi
+} from "./chunk-J4ASA24X.js";
+import {
+  CREATIVE_PERFORMANCE_DEFAULT_DAYS,
+  CREATIVE_PERFORMANCE_MAX_DAYS
+} from "./chunk-HVJJEQDQ.js";
+import {
+  apiPost
+} from "./chunk-B4UVJCJ4.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-FSGJSREN.js";
+
+// src/commands/creatives/performance.ts
+import { readFileSync } from "fs";
+import path from "path";
+import { defineCommand } from "citty";
+import { parse as parseYaml } from "yaml";
+var DESCRIPTION = `How each Baker creative is doing in the live Meta ads that show it: spend, impressions, CTR, CPC, results, cost per result, frequency and a fatigue verdict, next to the angle, hook, mechanism and dominant slot its definition set out to test. Video creatives add hookRate (percent of impressions that watched 3 seconds) and holdRate (percent of those that reached a ThruPlay). Use it before briefing new creatives, to learn which angle and mechanism to make next and which creatives to replace.
+
+Start here:
+  baker creatives performance                      # every creative in an ad, last 30 days
+  baker creatives performance --slug spring-offer  # one creative
+  baker creatives performance --days 14 --full     # ids, last-7-day figures, a video's watch funnel, one row per ad
+
+Fatigue follows the Meta playbook (07-creative-audit.md): fresh, fading, fatigued, dead, or too_early (under 14 days or 1,000 impressions) and no_delivery. A low hook rate means the first 3 seconds need new hooks; a working hook with a low hold rate means the body loses people. A creative counts once a Session's publish created an ad with it.`;
+var ARGS = {
+  slug: { type: "string", description: "Only this creative (src/creatives/<slug>/)", required: false },
+  days: {
+    type: "string",
+    description: `Reporting window in days, ending today (1-${CREATIVE_PERFORMANCE_MAX_DAYS}, default ${CREATIVE_PERFORMANCE_DEFAULT_DAYS})`,
+    required: false
+  },
+  full: {
+    type: "boolean",
+    description: "Add ids, last-7-day CTR and cost per result, and one row per ad",
+    required: false,
+    default: false
+  }
+};
+registerSchema({ command: "creatives.performance", description: DESCRIPTION, args: ARGS });
+var INSIGHT_KEYS = [
+  "idea",
+  "message",
+  "evidence",
+  "angle",
+  "hook",
+  "mechanism",
+  "dominantSlot",
+  "persona",
+  "awareness",
+  "hypothesis"
+];
+var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---/;
+function insightValue(value) {
+  if (typeof value === "string") return value.trim() || null;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return null;
+}
+function definitionInsights(markdown) {
+  const block = FRONTMATTER.exec(markdown)?.[1];
+  if (!block) return null;
+  let parsed;
+  try {
+    parsed = parseYaml(block);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object") return null;
+  const insights = {};
+  for (const [key, raw] of Object.entries(parsed)) {
+    if (!(INSIGHT_KEYS.includes(key) || key.startsWith("source") || key.startsWith("reference"))) continue;
+    const value = insightValue(raw);
+    if (value !== null) insights[key] = value;
+  }
+  return Object.keys(insights).length > 0 ? insights : null;
+}
+function readLocalDefinition(slug) {
+  try {
+    return readFileSync(path.join(process.cwd(), "src", "creatives", slug, "_definition.md"), "utf8");
+  } catch {
+    return null;
+  }
+}
+var COMPARED_FIELDS = [
+  { key: "angle", label: "angle", advice: "Brief the next creative on the cheapest angle with a new hook." },
+  { key: "mechanism", label: "mechanism", advice: "Brief the next creative on the cheapest mechanism." },
+  { key: "dominantSlot", label: "dominant slot", advice: "Lead the next creative with the cheapest dominant slot." }
+];
+function cheapestHint(creatives, { key, label, advice }) {
+  const byValue = /* @__PURE__ */ new Map();
+  for (const creative of creatives) {
+    const value = creative.definition?.[key];
+    if (!value || creative.costPerResult === null) continue;
+    const best = byValue.get(value);
+    if (!best || (best.costPerResult ?? Number.POSITIVE_INFINITY) > creative.costPerResult)
+      byValue.set(value, creative);
+  }
+  if (byValue.size < 2) return null;
+  const ranked = [...byValue.entries()].sort(([, a], [, b]) => (a.costPerResult ?? 0) - (b.costPerResult ?? 0)).map(
+    ([value, creative]) => `"${value}" ${creative.costPerResult}${creative.currency ? ` ${creative.currency}` : ""} (${creative.slug ?? creative.title})`
+  );
+  return `Cost per result by ${label}: ${ranked.join(", ")}. ${advice}`;
+}
+function withDefinitions(response, readDefinition) {
+  const creatives = response.data.creatives.map((creative) => {
+    const markdown = creative.slug ? readDefinition(creative.slug) : null;
+    const definition = markdown ? definitionInsights(markdown) : null;
+    return definition ? { ...creative, definition } : creative;
+  });
+  const hints = [...response.hints ?? []];
+  for (const field of COMPARED_FIELDS) {
+    const hint = cheapestHint(creatives, field);
+    if (hint) hints.push(hint);
+  }
+  const unnamed = creatives.filter((creative) => !creative.definition?.angle).map((c) => c.slug ?? c.title);
+  if (unnamed.length > 0) {
+    hints.push(
+      `No angle recorded for: ${unnamed.join(", ")}. Add angle and hook to src/creatives/<slug>/_definition.md so results show which angle works.`
+    );
+  }
+  return { ...response, data: { ...response.data, creatives }, ...hints.length > 0 ? { hints } : {} };
+}
+function syncedCreativesHint(slug) {
+  return `Live Meta read. Across every platform, from the synced copy (no rate limit, full history): baker ads performance creatives ranks them against their ad-group peers (madeInBaker names this creative), and baker ads performance live-in --creative ${slug ?? "<slug>"} lists the live campaigns showing it.`;
+}
+function parseDays(raw) {
+  if (raw === void 0) return void 0;
+  const days = Number(raw);
+  if (!Number.isInteger(days) || days < 1 || days > CREATIVE_PERFORMANCE_MAX_DAYS) {
+    throw new Error(`--days must be a whole number from 1 to ${CREATIVE_PERFORMANCE_MAX_DAYS}`);
+  }
+  return days;
+}
+var performanceCommand = defineCommand({
+  meta: { name: "performance", description: DESCRIPTION },
+  args: ARGS,
+  run: async ({ args }) => {
+    try {
+      const body = {};
+      const slug = args.slug;
+      if (slug) body.slug = slug;
+      const days = parseDays(args.days);
+      if (days !== void 0) body.days = days;
+      if (args.full) body.full = true;
+      const response = await apiPost("/api/creatives/performance", body);
+      const out = withDefinitions(response, readLocalDefinition);
+      writeJson({ ...out, hints: [...out.hints ?? [], syncedCreativesHint(slug)] });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+
+export {
+  definitionInsights,
+  withDefinitions,
+  parseDays,
+  performanceCommand
+};
+//# sourceMappingURL=chunk-XRSRHAEU.js.map

package/dist/chunk-XVHR2NCG.js

@@ -0,0 +1,249 @@
+import {
+  readWorkspaceBrandDoc
+} from "./chunk-ZFJ2FQUH.js";
+import {
+  brandTokensSchema
+} from "./chunk-HVJJEQDQ.js";
+
+// src/engine/landing/lib/brand-tokens.ts
+import { readFile } from "fs/promises";
+import path from "path";
+
+// src/engine/landing/lib/color.ts
+var NEUTRAL_COLOR_KEYWORDS = /* @__PURE__ */ new Set([
+  "transparent",
+  "currentcolor",
+  "black",
+  "white",
+  "gray",
+  "grey",
+  "silver",
+  "dimgray",
+  "dimgrey",
+  "darkgray",
+  "darkgrey",
+  "lightgray",
+  "lightgrey",
+  "gainsboro",
+  "whitesmoke"
+]);
+function hexChannels(color) {
+  const long = color.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})(?:[0-9a-f]{2})?$/i);
+  if (long)
+    return [
+      Number.parseInt(long[1] ?? "0", 16),
+      Number.parseInt(long[2] ?? "0", 16),
+      Number.parseInt(long[3] ?? "0", 16)
+    ];
+  const short = color.match(/^#([0-9a-f])([0-9a-f])([0-9a-f])(?:[0-9a-f])?$/i);
+  if (short) {
+    const dup = (s) => Number.parseInt(`${s ?? "0"}${s ?? "0"}`, 16);
+    return [dup(short[1]), dup(short[2]), dup(short[3])];
+  }
+  return null;
+}
+function parseColor(raw) {
+  const c = String(raw || "").trim().toLowerCase();
+  if (!c || c === "transparent") return null;
+  const rgb = c.match(/rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)(?:[\s,/]+([\d.]+%?))?\s*\)/i);
+  if (rgb) {
+    const alpha = rgb[4];
+    const a = alpha === void 0 ? 1 : alpha.endsWith("%") ? Number.parseFloat(alpha) / 100 : Number.parseFloat(alpha);
+    return { r: Number(rgb[1]), g: Number(rgb[2]), b: Number(rgb[3]), a };
+  }
+  const oklch = parseOklch(c);
+  if (oklch) return oklch;
+  const hex = hexChannels(c);
+  if (hex) return { r: hex[0], g: hex[1], b: hex[2], a: 1 };
+  return null;
+}
+function parseOklch(c) {
+  const m = c.match(/oklch\(\s*([\d.]+%?)\s+([\d.]+%?)\s+([\d.]+)(?:deg)?(?:\s*\/\s*([\d.]+%?))?\s*\)/i);
+  if (!m) return null;
+  const pct = (s, scale) => s.endsWith("%") ? Number.parseFloat(s) / 100 * scale : Number.parseFloat(s);
+  const alpha = m[4];
+  const a = alpha === void 0 ? 1 : pct(alpha, 1);
+  return { ...oklchToRgb(pct(m[1] ?? "0", 1), pct(m[2] ?? "0", 0.4), Number.parseFloat(m[3] ?? "0")), a };
+}
+function oklchToRgb(L, C, H) {
+  const hRad = H * Math.PI / 180;
+  const a = C * Math.cos(hRad);
+  const b = C * Math.sin(hRad);
+  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  const lin = [
+    4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,
+    -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,
+    -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s
+  ].map((v) => {
+    const g = v <= 31308e-7 ? 12.92 * v : 1.055 * Math.sign(v) * Math.abs(v) ** (1 / 2.4) - 0.055;
+    return Math.round(Math.max(0, Math.min(1, g)) * 255);
+  });
+  return { r: lin[0] ?? 0, g: lin[1] ?? 0, b: lin[2] ?? 0 };
+}
+function isNeutralAuthoredColor(rawColor) {
+  const c = String(rawColor || "").trim().toLowerCase();
+  if (!c) return false;
+  if (NEUTRAL_COLOR_KEYWORDS.has(c)) return true;
+  if (/^rgba?\(/i.test(c)) {
+    const channels2 = c.match(/^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)/i);
+    if (channels2) {
+      const values = [1, 2, 3].map((i) => Number(channels2[i]));
+      return Math.max(...values) - Math.min(...values) < 30;
+    }
+    return false;
+  }
+  const oklch = c.match(/oklch\(\s*[\d.]+%?\s+([\d.-]+)/i);
+  if (oklch) return Number.parseFloat(oklch[1] ?? "0") < 0.02;
+  const lch = c.match(/lch\(\s*[\d.]+%?\s+([\d.-]+)/i);
+  if (lch) return Number.parseFloat(lch[1] ?? "0") < 3;
+  const hsl = c.match(/hsla?\(\s*[\d.-]+\s*,?\s*([\d.]+)%/i);
+  if (hsl) return Number.parseFloat(hsl[1] ?? "0") < 10;
+  const channels = hexChannels(c);
+  if (channels) return Math.max(...channels) - Math.min(...channels) < 30;
+  return false;
+}
+function hasChroma(c, threshold = 30) {
+  if (!c) return false;
+  return Math.max(c.r, c.g, c.b) - Math.min(c.r, c.g, c.b) >= threshold;
+}
+function getHue(c) {
+  if (!c) return 0;
+  const r = c.r / 255;
+  const g = c.g / 255;
+  const b = c.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  if (max === min) return 0;
+  const d = max - min;
+  let h;
+  if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+  else if (max === g) h = ((b - r) / d + 2) / 6;
+  else h = ((r - g) / d + 4) / 6;
+  return Math.round(h * 360);
+}
+function isAiPurpleHue(hue) {
+  return hue >= 225 && hue <= 310;
+}
+function isCreamColor(c) {
+  if (Math.min(c.r, c.g, c.b) < 209) return false;
+  if (!(c.r >= c.g && c.g >= c.b)) return false;
+  const warmth = c.r - c.b;
+  return warmth >= 6 && warmth <= 48;
+}
+
+// src/engine/landing/lib/brand-tokens.ts
+var EMPTY = { fonts: /* @__PURE__ */ new Set(), colors: [], gradientStops: [], hasTokens: false };
+function isNotAFamily(value) {
+  return /^[1-9]00$/.test(value) || /^\d+(?:\.\d+)?(?:px|rem|em|%|pt|vw|vh|ch|ex)$/i.test(value) || /^(?:normal|bold|bolder|lighter|italic|oblique|none|auto|inherit|initial|unset)$/i.test(value);
+}
+function parseBrandTokens(globalCss, brandDoc) {
+  const fonts = /* @__PURE__ */ new Set();
+  const colors = [];
+  parseGlobalCss(globalCss, fonts, colors);
+  for (const font of brandDoc?.fonts ?? []) if (font.use) fonts.add(font.family.toLowerCase());
+  for (const color of brandDoc?.colors ?? []) {
+    const parsed = color.use ? parseColor(color.hex) : null;
+    if (parsed) colors.push(parsed);
+  }
+  return { fonts, colors, gradientStops: [], hasTokens: fonts.size > 0 || colors.length > 0 };
+}
+var COLOR_LITERAL = /#[0-9a-f]{3,8}\b|rgba?\([^)]*\)|oklch\([^)]*\)/gi;
+function chromaticStops(text) {
+  return (text.match(COLOR_LITERAL) ?? []).map(parseColor).filter((c) => c !== null && hasChroma(c));
+}
+function brandDocGradientStops(brandMd) {
+  const gradients = brandMd.match(/(?:repeating-)?(?:linear|radial|conic)-gradient\((?:[^()]|\([^()]*\))*\)/gi) ?? [];
+  return gradients.flatMap(chromaticStops);
+}
+function parseGlobalCss(rawCss, fonts, colors) {
+  const globalCss = rawCss.replace(/\/\*[\s\S]*?\*\//g, (block) => block.replace(/[^\n]/g, " "));
+  for (const m of globalCss.matchAll(/(?<![\w-])--font-([\w-]*)\s*:\s*([^;]+);/gi)) {
+    const slug = m[1] ?? "";
+    if (slug.includes("--") || /^weight(?:$|[-\s])/i.test(slug)) continue;
+    const first = (m[2] ?? "").split(",")[0]?.trim().replace(/^['"]|['"]$/g, "").toLowerCase();
+    if (!first || isNotAFamily(first)) continue;
+    fonts.add(first);
+  }
+  for (const m of globalCss.matchAll(
+    /--color-[\w-]*\s*:\s*(#[0-9a-f]{3,8}\b|rgba?\([^)]+\)|oklch\([^)]+\)|hsla?\([^)]+\))/gi
+  )) {
+    const c = parseColor(m[1] ?? "");
+    if (c) colors.push(c);
+  }
+}
+function brandTokensFromCanonical(tokens) {
+  const fonts = new Set(tokens.fonts.map((f) => f.family.toLowerCase()));
+  const colors = [];
+  for (const color of tokens.colors) {
+    const parsed = parseColor(color.value);
+    if (parsed) colors.push(parsed);
+  }
+  return { fonts, colors, gradientStops: [], hasTokens: fonts.size > 0 || colors.length > 0 };
+}
+async function loadBrandTokens(projectRoot, opts = {}) {
+  const gradientStops = brandDocGradientStops(await safeRead(path.join(projectRoot, "src", "brand", "BRAND.md")));
+  const brand = await loadCommittedTokens(projectRoot, opts);
+  return gradientStops.length > 0 ? { ...brand, gradientStops, hasTokens: true } : brand;
+}
+async function loadCommittedTokens(projectRoot, opts) {
+  const tokensRaw = await safeRead(path.join(projectRoot, "src", "brand", "tokens.json"));
+  if (tokensRaw) {
+    try {
+      const canonical = brandTokensSchema.safeParse(JSON.parse(tokensRaw));
+      if (canonical.success) return brandTokensFromCanonical(canonical.data);
+    } catch {
+    }
+  }
+  const globalCss = await safeRead(path.join(projectRoot, "src", "styles", "global.css"));
+  const brandDoc = await readWorkspaceBrandDoc(projectRoot, {
+    ...opts.readBrandDoc ? { read: opts.readBrandDoc } : {},
+    ...opts.onSpend ? { onSpend: opts.onSpend } : {}
+  });
+  if (!globalCss && !brandDoc) return EMPTY;
+  return parseBrandTokens(globalCss, brandDoc);
+}
+async function safeRead(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch {
+    return "";
+  }
+}
+function brandCommitsFont(brand, snippet) {
+  if (brand.fonts.size === 0) return false;
+  const lower = snippet.toLowerCase();
+  for (const f of brand.fonts) if (f.length >= 3 && lower.includes(f)) return true;
+  return false;
+}
+function brandCommitsAiHue(brand) {
+  return brand.colors.some((c) => hasChroma(c, 40) && isAiPurpleHue(getHue(c)));
+}
+var SAME_COLOR_TOLERANCE = 6;
+function sameColor(a, b) {
+  return Math.abs(a.r - b.r) <= SAME_COLOR_TOLERANCE && Math.abs(a.g - b.g) <= SAME_COLOR_TOLERANCE && Math.abs(a.b - b.b) <= SAME_COLOR_TOLERANCE;
+}
+function brandCommitsGradient(brand, snippet) {
+  const stops = chromaticStops(snippet);
+  if (stops.length === 0) return false;
+  const committed = [...brand.colors, ...brand.gradientStops];
+  return stops.every((stop) => committed.some((c) => sameColor(c, stop)));
+}
+function brandCommitsCream(brand) {
+  return brand.colors.some((c) => isCreamColor(c));
+}
+
+export {
+  parseColor,
+  isNeutralAuthoredColor,
+  hasChroma,
+  isCreamColor,
+  parseBrandTokens,
+  loadBrandTokens,
+  brandCommitsFont,
+  brandCommitsAiHue,
+  brandCommitsGradient,
+  brandCommitsCream
+};
+//# sourceMappingURL=chunk-XVHR2NCG.js.map