@koda-sl/baker-cli 0.545.0-dev.2a6beac48 → 0.545.0

package/dist/chunk-ZEUAJAKN.js

@@ -0,0 +1,225 @@
+import {
+  BRAND_DIR,
+  inkLuma,
+  logoArtwork
+} from "./chunk-XYNQMRNX.js";
+import {
+  fetchExternalBytes
+} from "./chunk-DGUN7FUH.js";
+import {
+  apiGet,
+  apiPost
+} from "./chunk-B2OHCWYB.js";
+
+// src/commands/canvas/clientLogo.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import * as cheerio from "cheerio";
+import path from "path";
+function decideClientLogo(domain, lookup) {
+  if (!domain) return { use: false, reason: "no_domain" };
+  const verdict = lookup?.brandMatch?.verdict;
+  if (verdict === "mismatch") {
+    return { use: false, reason: "mismatch", ...lookup?.brandMatch?.name ? { wrongBrand: lookup.brandMatch.name } : {} };
+  }
+  if (verdict !== "confirmed") return { use: false, reason: "unverified" };
+  const url = lookup?.hits?.map((hit) => hit.imageUrl ?? hit.sourceUrl).find((candidate) => Boolean(candidate));
+  return url ? { use: true, url } : { use: false, reason: "no_hits" };
+}
+function clientLogoMissNote(decision, domain) {
+  switch (decision.reason) {
+    case "no_domain":
+      return "Baker has no website on record for this company, so their mark could not be looked up.";
+    case "mismatch":
+      return `The mark found for \`${domain}\` belongs to ${decision.wrongBrand ?? "a different company"}, not to this client, so it was not used.`;
+    default:
+      return `No brand mark could be confirmed for \`${domain}\`, so nothing was placed.`;
+  }
+}
+function hostOf(site) {
+  try {
+    return new URL(/^https?:\/\//i.test(site) ? site : `https://${site}`).hostname.replace(/^www\./i, "").toLowerCase();
+  } catch {
+    return null;
+  }
+}
+var NOT_THE_LOGO = /favicon|apple-touch|sprite|(?:^|[/_.-])icons?(?:[/_.-]|$)|client|customer|partner|testimonial|trust|badge|award/i;
+function sayings(hit, url) {
+  const meta = hit.providerMeta ?? {};
+  const given = ["alt", "class", "id", "title"].map((key) => typeof meta[key] === "string" ? meta[key] : "");
+  return [new URL(url).pathname, hit.name ?? "", hit.description ?? "", ...given].join(" ");
+}
+function logoFromExtract(hits, domain) {
+  const own = hostOf(domain);
+  if (!own) return null;
+  const candidates = hits.flatMap((hit) => {
+    const url = hit.url ?? hit.imageUrl ?? hit.sourceUrl;
+    const host = url ? hostOf(url) : null;
+    if (!url || !host || host !== own && !host.endsWith(`.${own}`)) return [];
+    const said = sayings(hit, url);
+    if (!/logo/i.test(said) || NOT_THE_LOGO.test(said)) return [];
+    return [{ url, score: (/\.svg(?:\?|$)/i.test(url) ? 2 : 0) + (/logo/i.test(new URL(url).pathname) ? 1 : 0) }];
+  });
+  candidates.sort((a, b) => b.score - a.score || a.url.length - b.url.length);
+  return candidates[0]?.url ?? null;
+}
+var MAX_INLINE_SVG = 3e5;
+var BRAND_PLACES = "header, nav, [role=banner]";
+var IMAGE_ADDRESS = ["src", "data-src", "data-lazy-src", "data-original"];
+function logoFromPage(html, pageUrl, domain) {
+  const own = hostOf(domain);
+  if (!own) return null;
+  const $ = cheerio.load(html);
+  for (const el of $(`${BRAND_PLACES}`).find("img, svg").toArray()) {
+    const node = $(el);
+    const said = [node, node.closest("a")].flatMap((n) => ["class", "id", "alt", "aria-label", "title"].map((k) => n.attr(k) ?? "")).join(" ");
+    if (!/logo/i.test(said) || NOT_THE_LOGO.test(said)) continue;
+    if (el.tagName === "svg") {
+      const svg = standaloneSvg($, node);
+      if (svg) return { kind: "svg", svg };
+      continue;
+    }
+    const url = IMAGE_ADDRESS.map((k) => node.attr(k)?.trim() ?? "").filter((a) => a !== "" && !a.startsWith("data:")).map((a) => absolute(a, pageUrl)).find((a) => a !== null);
+    const host = url ? hostOf(url) : null;
+    if (url && host && (host === own || host.endsWith(`.${own}`))) return { kind: "url", url };
+  }
+  return null;
+}
+function absolute(address, base) {
+  try {
+    const url = new URL(address, base);
+    return /^https?:$/.test(url.protocol) ? url.href : null;
+  } catch {
+    return null;
+  }
+}
+function standaloneSvg($, node) {
+  const draws = node.find("path, circle, rect, polygon, polyline, ellipse, line, text").length > 0;
+  if (!draws || node.find("use").length > 0) return null;
+  const copy = node.clone();
+  if (!copy.attr("xmlns")) copy.attr("xmlns", "http://www.w3.org/2000/svg");
+  const svg = $.html(copy);
+  return svg.length <= MAX_INLINE_SVG ? svg : null;
+}
+function logoTone(inkLuma2) {
+  return inkLuma2 !== null && inkLuma2 > 170 ? "dark" : "light";
+}
+function withLogoRegistered(tokensJson, logo) {
+  if (tokensJson === null) return null;
+  let tokens;
+  try {
+    tokens = JSON.parse(tokensJson);
+  } catch {
+    return null;
+  }
+  if (!tokens || typeof tokens !== "object" || Array.isArray(tokens)) return null;
+  const doc = tokens;
+  const logos = Array.isArray(doc.logos) ? doc.logos : [];
+  if (logos.some((l) => l?.path === logo.path)) return null;
+  const next = { ...doc, logos: [...logos, { variant: "logo", background: logo.background, path: logo.path }] };
+  return `${JSON.stringify(next, null, 2)}
+`;
+}
+function logoMissingHint(company, domain) {
+  return `No logo on file for ${company}: add it on the Brand page${domain ? ` (we could not find it on ${domain})` : ""}.`;
+}
+function extensionOf(url) {
+  return /\.(svg|png|jpg|jpeg|webp)(?:\?|$)/i.exec(url)?.[1]?.toLowerCase() ?? "svg";
+}
+var MAX_LOGO_BYTES = 3e6;
+async function downloaded(url) {
+  try {
+    const { buffer } = await fetchExternalBytes(url, { maxBytes: MAX_LOGO_BYTES });
+    return buffer.byteLength > 0 ? { bytes: buffer, extension: extensionOf(url) } : null;
+  } catch {
+    return null;
+  }
+}
+async function logoOnSite(domain) {
+  const host = hostOf(domain);
+  if (!host) return null;
+  const page = `https://${host}/`;
+  try {
+    const { buffer } = await fetchExternalBytes(page, { maxBytes: MAX_LOGO_BYTES });
+    const found = logoFromPage(buffer.toString("utf8"), page, domain);
+    if (found?.kind === "svg") return { bytes: Buffer.from(found.svg, "utf8"), extension: "svg" };
+    const file = found ? await downloaded(found.url) : null;
+    if (file) return file;
+  } catch {
+  }
+  try {
+    const listed = await apiPost("/api/images/extract", { url: page, limit: 50 });
+    const url = logoFromExtract(listed.hits ?? [], domain);
+    return url ? await downloaded(url) : null;
+  } catch {
+    return null;
+  }
+}
+async function logoSource(domain) {
+  let lookup = null;
+  if (domain) {
+    try {
+      lookup = await apiPost("/api/images/logo", { domain, variant: "logo", autoIngest: 1 });
+    } catch {
+      lookup = null;
+    }
+  }
+  const decision = decideClientLogo(domain, lookup);
+  if (decision.use) {
+    const file = await downloaded(decision.url);
+    if (file) return file;
+  }
+  if (domain && !(decision.use === false && decision.reason === "mismatch")) {
+    const file = await logoOnSite(domain);
+    if (file) return file;
+  }
+  return { note: clientLogoMissNote(decision.use ? { use: false, reason: "no_hits" } : decision, domain) };
+}
+async function inkOf(bytes) {
+  try {
+    return inkLuma((await logoArtwork(bytes)).data);
+  } catch {
+    return null;
+  }
+}
+async function fetchClientLogo(root = ".") {
+  let domain;
+  let company;
+  try {
+    const found = await apiGet("/api/company");
+    domain = found.data.domain?.trim() || void 0;
+    company = found.data.name;
+  } catch {
+    domain = void 0;
+  }
+  const named = { ...domain ? { domain } : {}, ...company ? { company } : {} };
+  const source = await logoSource(domain);
+  if ("note" in source) return { ok: false, reason: source.note, ...named };
+  try {
+    const tone = logoTone(await inkOf(source.bytes));
+    const dir = path.join(root, BRAND_DIR, "logos");
+    await mkdir(dir, { recursive: true });
+    const file = path.join(dir, `logo-${tone}.${source.extension}`);
+    await writeFile(file, source.bytes);
+    await registerLogo(root, path.join(BRAND_DIR, "logos", path.basename(file)), tone);
+    return { ok: true, path: file, ...named };
+  } catch {
+    return { ok: false, reason: clientLogoMissNote({ use: false, reason: "no_hits" }, domain), ...named };
+  }
+}
+async function registerLogo(root, relative, background) {
+  const tokensPath = path.join(root, BRAND_DIR, "tokens.json");
+  const next = withLogoRegistered(await readFile(tokensPath, "utf8").catch(() => null), { path: relative, background });
+  if (next !== null) await writeFile(tokensPath, next, "utf8").catch(() => void 0);
+}
+async function withClientLogo(root, kit, reread, fetch = fetchClientLogo) {
+  if (kit.logo) return { kit };
+  const fetched = await fetch(root).catch(() => null);
+  if (fetched?.ok) return { kit: await reread() };
+  return { kit, hint: logoMissingHint(fetched?.company ?? "your company", fetched?.domain) };
+}
+
+export {
+  fetchClientLogo,
+  withClientLogo
+};
+//# sourceMappingURL=chunk-ZEUAJAKN.js.map

package/dist/chunk-ZUUVWWB5.js

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

package/dist/chunk-ZVAZFHH7.js

@@ -0,0 +1,249 @@
+import {
+  readWorkspaceBrandDoc
+} from "./chunk-NBWZVBDG.js";
+import {
+  brandTokensSchema
+} from "./chunk-R65V26HH.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-ZVAZFHH7.js.map