brandrail 0.0.0-stage → 0.1.0

package/dist/brandrail.mjs

@@ -0,0 +1,2139 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join3, relative as relative2, resolve as resolve3 } from "node:path";
+
+// ../engine/src/color.ts
+var clamp = (n, lo = 0, hi = 255) => Math.min(hi, Math.max(lo, n));
+function parseHex(hex) {
+  let h = hex.replace(/^#/, "").toLowerCase();
+  if (!/^[0-9a-f]+$/.test(h)) return null;
+  if (h.length === 3 || h.length === 4) h = h.split("").map((c) => c + c).join("");
+  if (h.length !== 6 && h.length !== 8) return null;
+  const n = (i) => parseInt(h.slice(i, i + 2), 16);
+  return { r: n(0), g: n(2), b: n(4), a: h.length === 8 ? n(6) / 255 : 1 };
+}
+function hslToRgb(h, s, l) {
+  h = (h % 360 + 360) % 360;
+  s /= 100;
+  l /= 100;
+  const k = (n) => (n + h / 30) % 12;
+  const a = s * Math.min(l, 1 - l);
+  const f = (n) => l - a * Math.max(-1, Math.min(k(n) - 3, Math.min(9 - k(n), 1)));
+  return [f(0) * 255, f(8) * 255, f(4) * 255];
+}
+function parseColor(input) {
+  const s = input.trim().toLowerCase();
+  if (s.startsWith("#")) return parseHex(s);
+  const m = s.match(/^(rgba?|hsla?)\(\s*([^)]*)\)$/);
+  if (!m) return null;
+  const parts = m[2].split(/[\s,/]+/).filter(Boolean);
+  if (parts.length < 3) return null;
+  const num = (p, max) => p.endsWith("%") ? parseFloat(p) / 100 * max : parseFloat(p);
+  const alpha = parts[3] !== void 0 ? num(parts[3], 1) : 1;
+  if (m[1].startsWith("rgb")) {
+    const [r2, g2, b2] = parts.slice(0, 3).map((p) => num(p, 255));
+    if ([r2, g2, b2].some((v) => Number.isNaN(v))) return null;
+    return { r: clamp(r2), g: clamp(g2), b: clamp(b2), a: alpha };
+  }
+  const [h, sat, l] = [parseFloat(parts[0]), parseFloat(parts[1]), parseFloat(parts[2])];
+  if ([h, sat, l].some((v) => Number.isNaN(v))) return null;
+  const [r, g, b] = hslToRgb(h, sat, l);
+  return { r: clamp(r), g: clamp(g), b: clamp(b), a: alpha };
+}
+function toHex({ r, g, b }) {
+  return `#${[r, g, b].map((v) => Math.round(v).toString(16).padStart(2, "0")).join("")}`;
+}
+function rgbToLab({ r, g, b }) {
+  const lin = (c) => {
+    const v = c / 255;
+    return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+  };
+  const [R, G, B] = [lin(r), lin(g), lin(b)];
+  const x = (R * 0.4124 + G * 0.3576 + B * 0.1805) / 0.95047;
+  const y = R * 0.2126 + G * 0.7152 + B * 0.0722;
+  const z = (R * 0.0193 + G * 0.1192 + B * 0.9505) / 1.08883;
+  const f = (t) => t > 8856e-6 ? Math.cbrt(t) : 7.787 * t + 16 / 116;
+  return { l: 116 * f(y) - 16, a: 500 * (f(x) - f(y)), b: 200 * (f(y) - f(z)) };
+}
+function deltaE(a, b) {
+  return Math.sqrt((a.l - b.l) ** 2 + (a.a - b.a) ** 2 + (a.b - b.b) ** 2);
+}
+function contrastRatio(a, b) {
+  const lum = ({ r, g, b: bl }) => {
+    const c = [r, g, bl].map((v) => {
+      const s = v / 255;
+      return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+    });
+    return 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];
+  };
+  const [l1, l2] = [lum(a), lum(b)].sort((x, y) => y - x);
+  return (l1 + 0.05) / (l2 + 0.05);
+}
+
+// ../engine/src/config.ts
+var DEFAULT_IGNORE = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/out/**",
+  "**/.next/**",
+  "**/.nuxt/**",
+  "**/.turbo/**",
+  "**/coverage/**",
+  "**/*.min.*",
+  "**/*.map",
+  "**/*.d.ts",
+  "**/tailwind.config.*",
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/*.stories.*",
+  "**/__tests__/**",
+  "**/__mocks__/**"
+];
+var DEFAULT_FORBIDDEN_IMPORTS = [
+  "@mui/material",
+  "@mui/joy",
+  "@material-ui/core",
+  "antd",
+  "@chakra-ui/react",
+  "react-bootstrap",
+  "bootstrap",
+  "@mantine/core",
+  "semantic-ui-react",
+  "primereact"
+];
+var NAME_TO_TAGS = {
+  button: ["button"],
+  input: ["input"],
+  textinput: ["input"],
+  inputtext: ["input"],
+  textfield: ["input"],
+  select: ["select"],
+  dropdown: ["select"],
+  textarea: ["textarea"],
+  inputtextarea: ["textarea"],
+  link: ["a"],
+  table: ["table"],
+  checkbox: ["input[type=checkbox]"],
+  radio: ["input[type=radio]"]
+};
+var GENERIC_FONTS = /* @__PURE__ */ new Set([
+  "inherit",
+  "initial",
+  "unset",
+  "system-ui",
+  "-apple-system",
+  "blinkmacsystemfont",
+  "sans-serif",
+  "serif",
+  "monospace",
+  "ui-sans-serif",
+  "ui-serif",
+  "ui-monospace",
+  "cursive",
+  "fantasy"
+]);
+function leaves(doc, prefix = "", out = []) {
+  if (!doc || typeof doc !== "object") return out;
+  const obj = doc;
+  if ("$value" in obj) {
+    const ext = obj.$extensions?.["dev.brandrail"];
+    out.push({ path: prefix, type: obj.$type, value: obj.$value, dark: ext?.modes?.dark });
+    return out;
+  }
+  for (const [k, v] of Object.entries(obj)) {
+    if (k.startsWith("$")) continue;
+    leaves(v, prefix ? `${prefix}.${k}` : k, out);
+  }
+  return out;
+}
+var px = (v) => {
+  if (typeof v === "number") return v;
+  if (typeof v !== "string") return null;
+  const m = v.trim().match(/^(-?\d*\.?\d+)(px|rem)?$/);
+  if (!m) return null;
+  const n = parseFloat(m[1]);
+  return m[2] === "rem" ? n * 16 : n;
+};
+function normalizeFontFamily(value) {
+  const first = value.split(",")[0] ?? "";
+  return first.trim().replace(/^['"]|['"]$/g, "").toLowerCase();
+}
+function isGenericFont(family) {
+  return GENERIC_FONTS.has(family) || family.startsWith("var(");
+}
+var uniqSorted = (xs) => [...new Set(xs.map((x) => Math.round(x * 100) / 100))].sort((a, b) => a - b);
+function resolveConfig(config) {
+  const all = leaves(config.tokens);
+  const colors = [];
+  for (const l of all) {
+    if (typeof l.value !== "string") continue;
+    if (l.type && l.type !== "color") continue;
+    if (!l.type && !l.path.startsWith("color")) continue;
+    const rgb = parseColor(l.value);
+    if (!rgb) continue;
+    const cssVar = `--${l.path.replace(/\./g, "-")}`;
+    colors.push({ path: l.path, cssVar, hex: toHex(rgb), lab: rgbToLab(rgb), alpha: rgb.a });
+    const dark = typeof l.dark === "string" ? parseColor(l.dark) : null;
+    if (dark) colors.push({ path: l.path, cssVar, hex: toHex(dark), lab: rgbToLab(dark), alpha: dark.a, mode: "dark" });
+  }
+  const spaceLeaves = all.filter((l) => /^(space|spacing)\./.test(l.path));
+  const spacing = [0, 1, 2];
+  const unit = px(spaceLeaves.find((l) => /\.unit$/.test(l.path))?.value);
+  for (const l of spaceLeaves) {
+    const v = px(l.value);
+    if (v !== null && !/\.unit$/.test(l.path)) spacing.push(v);
+  }
+  if (unit) for (const m of [0.5, 1, 1.5, 2, 2.5, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24]) spacing.push(unit * m);
+  if (spacing.length === 3) for (const v of [4, 8, 12, 16, 20, 24, 32, 40, 48, 64]) spacing.push(v);
+  const radiusVals = all.filter((l) => /^(radius|radii|border-?radius)\./i.test(l.path)).map((l) => px(l.value)).filter((v) => v !== null);
+  const radii = [0, 9999, ...radiusVals];
+  if (radiusVals.length === 1) radii.push(Math.round(radiusVals[0] / 2), radiusVals[0] * 2);
+  if (radiusVals.length === 0) radii.push(2, 4, 6, 8, 12, 16);
+  const fontLeaves = all.filter((l) => (l.type === "fontFamily" || /^font\.family\./.test(l.path)) && typeof l.value === "string");
+  const fonts = fontLeaves.map((l) => normalizeFontFamily(l.value));
+  const fontVars = fontLeaves.map((l) => `--${l.path.replace(/\./g, "-")}`);
+  const components = config.components ?? [];
+  const replaces = /* @__PURE__ */ new Map();
+  for (const c of components) {
+    const tags = c.replaces ?? NAME_TO_TAGS[c.name.toLowerCase()] ?? [];
+    for (const t of tags) {
+      const key = t.toLowerCase().replace(/\s+/g, "").replace(/["']/g, "");
+      if (!replaces.has(key)) replaces.set(key, c);
+    }
+  }
+  return {
+    tokenVersion: config.tokenVersion,
+    colors,
+    spacing: uniqSorted(spacing),
+    radii: uniqSorted(radii),
+    fonts: [...new Set(fonts)],
+    fontVars: fontVars.length ? fontVars : ["--font-family-sans"],
+    fontSizes: uniqSorted(all.filter((l) => /^font\.size\./.test(l.path)).map((l) => px(l.value)).filter((v) => v !== null)),
+    components,
+    replaces,
+    rules: config.rules ?? {},
+    ignore: [...DEFAULT_IGNORE, ...config.ignore ?? []],
+    forbiddenImports: config.forbiddenImports ?? DEFAULT_FORBIDDEN_IMPORTS,
+    colorTolerance: config.colorTolerance ?? 2.5
+  };
+}
+
+// ../engine/src/rules.ts
+var MARKUP = ["jsx", "vue", "svelte", "html"];
+var ALL = ["jsx", "vue", "svelte", "html", "css"];
+function* matches(re, text) {
+  const g = new RegExp(re.source, re.flags.includes("g") ? re.flags : re.flags + "g");
+  let m;
+  while (m = g.exec(text)) {
+    yield m;
+    if (m[0].length === 0) g.lastIndex++;
+  }
+}
+var lineBefore = (code, offset, max = 80) => {
+  const start = Math.max(code.lastIndexOf("\n", offset - 1) + 1, offset - max);
+  return code.slice(start, offset);
+};
+var lineOf = (code, offset) => {
+  const start = code.lastIndexOf("\n", offset - 1) + 1;
+  const end = code.indexOf("\n", offset);
+  return code.slice(start, end === -1 ? void 0 : end);
+};
+var fmt = (n) => `${Math.round(n * 100) / 100}px`;
+function neighbours(scale, v) {
+  const lower = [...scale].reverse().find((x) => x <= v);
+  const upper = scale.find((x) => x >= v);
+  const opts = [...new Set([lower, upper].filter((x) => x !== void 0))];
+  return opts.map(fmt).join(" or ");
+}
+function pxValues(value) {
+  const out = [];
+  for (const m of matches(/(-?\d*\.?\d+)(px|rem)\b/g, value)) {
+    const n = Math.abs(parseFloat(m[1])) * (m[2] === "rem" ? 16 : 1);
+    out.push({ n, index: m.index });
+  }
+  return out;
+}
+var noHardcodedColor = {
+  id: "no-hardcoded-color",
+  title: "Hard-coded colour",
+  description: "Colours must come from Brand Kit tokens, not hex / rgb / hsl literals.",
+  defaultSeverity: "error",
+  kinds: ALL,
+  check({ code, kind, config }) {
+    if (config.colors.length === 0) return [];
+    const out = [];
+    const re = /#(?:[0-9a-fA-F]{8}|[0-9a-fA-F]{6}|[0-9a-fA-F]{3,4})(?![0-9a-zA-Z_-])|(?<![\w-])(?:rgba?|hsla?)\(\s*[^()]*\)/g;
+    for (const m of matches(re, code)) {
+      const raw = m[0];
+      const before = lineBefore(code, m.index);
+      const line = lineOf(code, m.index);
+      if (raw.startsWith("#")) {
+        const prev = code[m.index - 1] ?? "";
+        if (/[A-Za-z0-9_&/]/.test(prev)) continue;
+        if (/(?:href|to|id|xlink:href|for|aria-[a-z]+)\s*=\s*["'{`]?\s*$/i.test(before)) continue;
+        if (/url\(\s*["']?$/.test(before)) continue;
+      }
+      if (/--[\w-]+\s*:\s*[^;{}]*$/.test(before)) continue;
+      if (kind !== "css" && /^\s*(import|export)\s/.test(line) && !/style|color/i.test(line)) continue;
+      const rgb = parseColor(raw);
+      if (!rgb) continue;
+      const lab = rgbToLab(rgb);
+      let best = config.colors[0];
+      let bestD = Infinity;
+      for (const c of config.colors) {
+        const d = deltaE(lab, c.lab) + Math.abs(rgb.a - (c.alpha ?? 1)) * 100;
+        if (d < bestD) {
+          bestD = d;
+          best = c;
+        }
+      }
+      if (bestD <= config.colorTolerance) {
+        out.push({
+          offset: m.index,
+          severity: "warning",
+          message: `Hard-coded ${raw} matches the token ${best.path}`,
+          suggestion: `Use var(${best.cssVar}) so it follows Brand Kit updates`
+        });
+      } else {
+        out.push({
+          offset: m.index,
+          message: `${raw} is not in the Brand Kit`,
+          suggestion: `Closest token is ${best.path} (${best.hex}, \u0394E ${bestD.toFixed(1)}): use var(${best.cssVar})`
+        });
+      }
+    }
+    return out;
+  }
+};
+var PALETTE = "slate|gray|zinc|neutral|stone|red|orange|amber|yellow|lime|green|emerald|teal|cyan|sky|blue|indigo|violet|purple|fuchsia|pink|rose";
+var UTIL = "bg|text|border(?:-[trblxyse])?|ring(?:-offset)?|fill|stroke|from|via|to|outline|divide|placeholder|accent|caret|decoration|shadow";
+var noRawPaletteClass = {
+  id: "no-raw-palette-class",
+  title: "Raw Tailwind palette class",
+  description: "Use semantic token classes (bg-primary, text-muted) instead of Tailwind's default palette.",
+  defaultSeverity: "warning",
+  kinds: MARKUP,
+  check({ code }) {
+    const out = [];
+    const re = new RegExp(`(?<![\\w-])((?:[a-z0-9-]+:)*)(${UTIL})-(${PALETTE})-(50|[1-9]00|950)(?:/\\d{1,3})?(?![\\w-])`, "g");
+    for (const m of matches(re, code)) {
+      out.push({
+        offset: m.index + m[1].length,
+        message: `Tailwind palette class ${m[0].slice(m[1].length)} bypasses the Brand Kit`,
+        suggestion: `Use a semantic class mapped to a token, e.g. ${m[2]}-primary or ${m[2]}-muted`
+      });
+    }
+    return out;
+  }
+};
+var spacingScale = {
+  id: "spacing-scale",
+  title: "Off-scale spacing",
+  description: "Padding, margin and gap must use the spacing scale.",
+  defaultSeverity: "warning",
+  kinds: ALL,
+  check({ code, kind, config }) {
+    const out = [];
+    const scale = config.spacing;
+    const ok = (n) => scale.some((s) => Math.abs(s - n) < 0.01);
+    for (const m of matches(/(?<![\w-])(padding|margin|gap|row-gap|column-gap)(?:-(?:top|right|bottom|left|inline|block)(?:-(?:start|end))?)?\s*:\s*([^;{}\n]+)/g, code)) {
+      const valueStart = m.index + m[0].length - m[2].length;
+      for (const v of pxValues(m[2])) {
+        if (!ok(v.n)) out.push({ offset: valueStart + v.index, message: `${m[1]} ${fmt(v.n)} is off the spacing scale`, suggestion: `Use ${neighbours(scale, v.n)}` });
+      }
+    }
+    if (kind !== "css") {
+      for (const m of matches(/(?<![\w-])(padding|margin|gap|rowGap|columnGap)(?:Top|Right|Bottom|Left|Inline|Block|X|Y)?\s*:\s*(['"`]?)(-?\d*\.?\d+)\2(?=\s*[,}\n])/g, code)) {
+        const n = Math.abs(parseFloat(m[3]));
+        if (!ok(n)) out.push({ offset: m.index, message: `${m[1]} ${fmt(n)} is off the spacing scale`, suggestion: `Use ${neighbours(scale, n)}` });
+      }
+      for (const m of matches(/(?<![\w-])-?(p[xytrbl]?|m[xytrbl]?|gap(?:-[xy])?|space-[xy])-\[(-?\d*\.?\d+)(px|rem)\]/g, code)) {
+        const n = Math.abs(parseFloat(m[2])) * (m[3] === "rem" ? 16 : 1);
+        if (!ok(n)) out.push({ offset: m.index, message: `${m[0]} is off the spacing scale`, suggestion: `Use ${neighbours(scale, n)}` });
+      }
+    }
+    return out;
+  }
+};
+var radiusScale = {
+  id: "radius-scale",
+  title: "Off-scale corner radius",
+  description: "Border radius must use the radius tokens.",
+  defaultSeverity: "info",
+  kinds: ALL,
+  check({ code, kind, config }) {
+    const out = [];
+    const ok = (n) => n >= 999 || config.radii.some((r) => Math.abs(r - n) < 0.01);
+    for (const m of matches(/(?<![\w-])border(?:-(?:top|bottom|start|end)-(?:left|right|start|end))?-radius\s*:\s*([^;{}\n]+)/g, code)) {
+      const valueStart = m.index + m[0].length - m[1].length;
+      for (const v of pxValues(m[1])) {
+        if (!ok(v.n)) out.push({ offset: valueStart + v.index, message: `border-radius ${fmt(v.n)} is not a radius token`, suggestion: `Use ${neighbours(config.radii.filter((r) => r < 999), v.n)}` });
+      }
+    }
+    if (kind !== "css") {
+      for (const m of matches(/(?<![\w-])borderRadius\s*:\s*(['"`]?)(\d*\.?\d+)\1(?=\s*[,}\n])/g, code)) {
+        const n = parseFloat(m[2]);
+        if (!ok(n)) out.push({ offset: m.index, message: `borderRadius ${fmt(n)} is not a radius token`, suggestion: `Use ${neighbours(config.radii.filter((r) => r < 999), n)}` });
+      }
+      for (const m of matches(/(?<![\w-])rounded(?:-[a-z]{1,2})?-\[(\d*\.?\d+)px\]/g, code)) {
+        const n = parseFloat(m[1]);
+        if (!ok(n)) out.push({ offset: m.index, message: `${m[0]} is not a radius token`, suggestion: `Use ${neighbours(config.radii.filter((r) => r < 999), n)}` });
+      }
+    }
+    return out;
+  }
+};
+var fontFamily = {
+  id: "font-family",
+  title: "Unapproved font",
+  description: "Only the Brand Kit's font families may be used.",
+  defaultSeverity: "warning",
+  kinds: ALL,
+  check({ code, kind, config }) {
+    if (config.fonts.length === 0) return [];
+    const out = [];
+    const allowed = config.fonts;
+    const test = (value, offset) => {
+      const fam = normalizeFontFamily(value);
+      if (!fam || isGenericFont(fam) || allowed.includes(fam)) return;
+      out.push({
+        offset,
+        message: `Font "${fam}" is not in the Brand Kit`,
+        suggestion: `Use var(--font-family-sans) (${allowed[0]})`
+      });
+    };
+    for (const m of matches(/(?<![\w-])font-family\s*:\s*([^;{}\n]+)/g, code)) test(m[1], m.index);
+    if (kind !== "css") {
+      for (const m of matches(/(?<![\w-])fontFamily\s*:\s*(['"`])([^'"`]+)\1/g, code)) test(m[2], m.index);
+      for (const m of matches(/(?<![\w-])font-\[([^\]]+)\]/g, code)) test(m[1].replace(/_/g, " "), m.index);
+    }
+    return out;
+  }
+};
+var TEXT_INPUT_TYPES = /* @__PURE__ */ new Set(["", "text", "email", "password", "number", "search", "tel", "url"]);
+var preferOfficialComponent = {
+  id: "prefer-official-component",
+  title: "Re-invented component",
+  description: "Use the design system component instead of a raw HTML element.",
+  defaultSeverity: "error",
+  kinds: MARKUP,
+  check({ code, config }) {
+    if (config.replaces.size === 0) return [];
+    const out = [];
+    const baseTags = [...new Set([...config.replaces.keys()].map((k) => k.replace(/\[.*$/, "").replace(/[^a-z0-9-]/g, "")))].filter(Boolean);
+    for (const m of matches(new RegExp(`<(${baseTags.join("|")})(?=[\\s>/])([^>]*)>`, "g"), code)) {
+      const tag = m[1];
+      const attrs = m[2];
+      let comp = config.replaces.get(tag);
+      if (tag === "input" || tag === "button") {
+        const type = (attrs.match(/\btype\s*=\s*\{?\s*["'`]([\w-]+)["'`]/)?.[1] ?? "").toLowerCase();
+        const specific = config.replaces.get(`${tag}[type=${type}]`);
+        if (specific) comp = specific;
+        else if (tag === "input" && !TEXT_INPUT_TYPES.has(type)) comp = type === "submit" || type === "button" ? config.replaces.get("button") : void 0;
+      }
+      if (!comp) continue;
+      if (new RegExp(`(?:function|const|class)\\s+${comp.name}\\b`).test(code)) continue;
+      out.push({
+        offset: m.index,
+        message: `Raw <${tag}${tag === "input" && /type=/.test(attrs) ? ` type="${attrs.match(/type\s*=\s*\{?\s*["'`]([\w-]+)/)?.[1]}"` : ""}> re-implements ${comp.name}`,
+        suggestion: `import { ${comp.name} } from "${comp.importPath}"`
+      });
+    }
+    return out;
+  }
+};
+var forbiddenImport = {
+  id: "forbidden-import",
+  title: "Other UI library",
+  description: "Only the design system's component library may be imported.",
+  defaultSeverity: "error",
+  kinds: ALL,
+  check({ code, config }) {
+    const out = [];
+    const lib = config.components[0]?.importPath;
+    const re = /(?:\bimport\s[^'";]*?from\s*|\bimport\s*\(\s*|\bimport\s+|\brequire\(\s*|@import\s+(?:url\(\s*)?)(['"])([^'"]+)\1/g;
+    for (const m of matches(re, code)) {
+      const spec = m[2];
+      const bad = config.forbiddenImports.find((p) => spec === p || spec.startsWith(`${p}/`));
+      if (!bad) continue;
+      out.push({
+        offset: m.index + m[0].indexOf(spec),
+        message: `Imports ${bad}, which isn't part of the design system`,
+        suggestion: lib ? `Use components from "${lib}"` : "Use the design system's components"
+      });
+    }
+    return out;
+  }
+};
+var imgAlt = {
+  id: "img-alt",
+  title: "Image without alt text",
+  description: "Every <img> needs an alt attribute (empty for decorative images).",
+  defaultSeverity: "warning",
+  kinds: MARKUP,
+  check({ code }) {
+    const out = [];
+    for (const m of matches(/<img(?=[\s/>])([^>]*)>/g, code)) {
+      if (/(?<![\w-])alt\s*=/.test(m[1]) || /\{\s*\.\.\./.test(m[1])) continue;
+      out.push({ offset: m.index, message: "<img> has no alt text", suggestion: 'Add alt="\u2026" describing the image, or alt="" if decorative' });
+    }
+    return out;
+  }
+};
+var RULES = [
+  noHardcodedColor,
+  noRawPaletteClass,
+  preferOfficialComponent,
+  forbiddenImport,
+  spacingScale,
+  fontFamily,
+  radiusScale,
+  imgAlt
+];
+var RULE_IDS = RULES.map((r) => r.id);
+
+// ../engine/src/source.ts
+function fileKind(path) {
+  const ext = path.toLowerCase().split(".").pop() ?? "";
+  if (["tsx", "jsx", "ts", "js", "mjs", "cjs", "mdx"].includes(ext)) return "jsx";
+  if (ext === "vue") return "vue";
+  if (ext === "svelte") return "svelte";
+  if (["html", "htm", "astro"].includes(ext)) return "html";
+  if (["css", "scss", "sass", "less", "pcss"].includes(ext)) return "css";
+  return "other";
+}
+var SCANNABLE = /* @__PURE__ */ new Set(["jsx", "vue", "svelte", "html", "css"]);
+var blank = (s) => s.replace(/[^\n]/g, " ");
+function stripComments(code, kind) {
+  let out = code;
+  if (kind === "html" || kind === "vue" || kind === "svelte") {
+    out = out.replace(/<!--[\s\S]*?-->/g, blank);
+  }
+  if (kind === "css") {
+    return out.replace(/\/\*[\s\S]*?\*\//g, blank).replace(/(^|[^:])\/\/[^\n]*/g, (m, p1) => p1 + blank(m.slice(p1.length)));
+  }
+  const chars = out.split("");
+  let i = 0;
+  let quote = null;
+  while (i < chars.length) {
+    const c = chars[i];
+    const n = chars[i + 1];
+    if (quote) {
+      if (c === "\\") i += 2;
+      else {
+        if (c === quote) quote = null;
+        i++;
+      }
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      quote = c;
+      i++;
+      continue;
+    }
+    if (c === "/" && n === "*") {
+      const end = out.indexOf("*/", i + 2);
+      const stop = end === -1 ? chars.length : end + 2;
+      for (let j = i; j < stop; j++) if (chars[j] !== "\n") chars[j] = " ";
+      i = stop;
+      continue;
+    }
+    if (c === "/" && n === "/" && chars[i - 1] !== ":" && kind === "jsx") {
+      while (i < chars.length && chars[i] !== "\n") chars[i++] = " ";
+      continue;
+    }
+    i++;
+  }
+  return chars.join("");
+}
+var LineIndex = class {
+  starts = [0];
+  text;
+  constructor(text) {
+    this.text = text;
+    for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) this.starts.push(i + 1);
+  }
+  position(offset) {
+    let lo = 0;
+    let hi = this.starts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (this.starts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return { line: lo + 1, column: offset - this.starts[lo] + 1 };
+  }
+  lineText(line) {
+    const start = this.starts[line - 1] ?? 0;
+    const end = this.starts[line] ?? this.text.length + 1;
+    return this.text.slice(start, end - 1);
+  }
+  get lineCount() {
+    return this.starts.length;
+  }
+};
+function globToRegExp(glob) {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        const slash = glob[i + 2] === "/";
+        re += slash ? "(?:.*/)?" : ".*";
+        i += slash ? 2 : 1;
+      } else re += "[^/]*";
+    } else if (c === "?") re += "[^/]";
+    else if (c === "{") {
+      const end = glob.indexOf("}", i);
+      re += `(?:${glob.slice(i + 1, end).split(",").map((s) => s.replace(/[.+^$()|[\]\\]/g, "\\$&")).join("|")})`;
+      i = end;
+    } else re += c.replace(/[.+^$()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${re}$`);
+}
+function makeIgnore(globs) {
+  const res = globs.map(globToRegExp);
+  return (path) => {
+    const p = path.replace(/\\/g, "/").replace(/^\.\//, "");
+    return res.some((r) => r.test(p) || r.test(`/${p}`));
+  };
+}
+
+// ../engine/src/check.ts
+var ENGINE_VERSION = "0.1.0";
+var WEIGHT = { error: 4, warning: 1.5, info: 0.25 };
+function computeScore(counts, lines) {
+  const penalty = counts.error * WEIGHT.error + counts.warning * WEIGHT.warning + counts.info * WEIGHT.info;
+  if (penalty === 0) return 100;
+  const perK = penalty / Math.max(1, lines / 1e3);
+  return Math.max(0, Math.min(99, Math.round(100 / (1 + perK / 25))));
+}
+function check(files, configInput, opts = {}) {
+  const t0 = Date.now();
+  const config = "replaces" in configInput ? configInput : resolveConfig(configInput);
+  const ignored = makeIgnore(config.ignore);
+  const violations = [];
+  let filesScanned = 0;
+  let linesScanned = 0;
+  for (const file of files) {
+    const path = file.path.replace(/\\/g, "/").replace(/^\.\//, "");
+    const kind = fileKind(path);
+    if (!SCANNABLE.has(kind) || ignored(path)) continue;
+    const only = opts.onlyLines?.get(path);
+    if (opts.onlyLines && (!only || only.size === 0)) continue;
+    filesScanned++;
+    const idx = new LineIndex(file.content);
+    linesScanned += only ? only.size : file.content.split("\n").filter((l) => l.trim()).length;
+    const code = stripComments(file.content, kind);
+    const seen = /* @__PURE__ */ new Set();
+    for (const rule of RULES) {
+      const setting = config.rules[rule.id];
+      if (setting === "off" || !rule.kinds.includes(kind)) continue;
+      for (const f of rule.check({ path, kind, code, config })) {
+        const { line, column } = idx.position(f.offset);
+        if (only && !only.has(line)) continue;
+        const key = `${rule.id}:${line}:${column}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        violations.push({
+          ruleId: rule.id,
+          severity: setting ?? f.severity ?? rule.defaultSeverity,
+          file: path,
+          line,
+          column,
+          message: f.message,
+          suggestion: f.suggestion,
+          snippet: opts.snippets === false ? void 0 : idx.lineText(line).trim().slice(0, 160)
+        });
+      }
+    }
+  }
+  violations.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column);
+  const counts = { error: 0, warning: 0, info: 0 };
+  const perRule = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    counts[v.severity]++;
+    perRule.set(v.ruleId, (perRule.get(v.ruleId) ?? 0) + 1);
+  }
+  return {
+    engineVersion: ENGINE_VERSION,
+    tokenVersion: config.tokenVersion,
+    score: computeScore(counts, linesScanned),
+    counts,
+    filesScanned,
+    linesScanned,
+    violations,
+    byRule: [...perRule].map(([ruleId, count]) => ({ ruleId, count })).sort((a, b) => b.count - a.count),
+    durationMs: Date.now() - t0
+  };
+}
+
+// ../engine/src/report.ts
+var RENDERED_ONLY = { "text-contrast": "Low text contrast", "font-size-scale": "Off-scale font size" };
+var title = (id) => RULES.find((r) => r.id === id)?.title ?? RENDERED_ONLY[id] ?? id;
+var ansi = (on) => {
+  const w = (code) => (s) => on ? `\x1B[${code}m${s}\x1B[0m` : s;
+  return { red: w("31"), yellow: w("33"), cyan: w("36"), green: w("32"), dim: w("2"), bold: w("1") };
+};
+var rendered = (r) => r.violations.length > 0 && r.violations.every((v) => v.line === 0);
+function formatPretty(report, { color = true, max = 200 } = {}) {
+  const c = ansi(color);
+  const sev = { error: c.red, warning: c.yellow, info: c.cyan };
+  const lines = [];
+  let lastFile = "";
+  for (const v of report.violations.slice(0, max)) {
+    if (v.file !== lastFile) {
+      lines.push("", c.bold(v.file));
+      lastFile = v.file;
+    }
+    const rendered2 = v.line === 0;
+    lines.push(`  ${c.dim(rendered2 ? "".padEnd(8) : `${v.line}:${v.column}`.padEnd(8))} ${sev[v.severity](v.severity.padEnd(7))} ${v.message}  ${c.dim(v.ruleId)}`);
+    if (v.suggestion) lines.push(`  ${" ".repeat(16)} ${c.green("\u2192")} ${v.suggestion}`);
+    if (rendered2 && v.snippet) lines.push(`  ${" ".repeat(16)} ${c.dim(`on ${v.snippet}`)}`);
+  }
+  if (report.violations.length > max) lines.push("", c.dim(`\u2026 and ${report.violations.length - max} more`));
+  const s = report.score;
+  const scoreStr = s >= 80 ? c.green(String(s)) : s >= 65 ? c.yellow(String(s)) : c.red(String(s));
+  lines.push(
+    "",
+    `${c.bold("Brand score")} ${scoreStr}/100  ${c.dim("\xB7")} ${c.red(`${report.counts.error} errors`)} ${c.dim("\xB7")} ${c.yellow(`${report.counts.warning} warnings`)} ${c.dim("\xB7")} ${c.cyan(`${report.counts.info} info`)}`,
+    c.dim(`${report.filesScanned} ${rendered(report) ? "pages" : "files"}, ${report.linesScanned} ${rendered(report) ? "elements" : "lines"} in ${report.durationMs}ms${report.tokenVersion ? ` \xB7 Brand Kit v${report.tokenVersion}` : ""}`)
+  );
+  return lines.join("\n");
+}
+var esc = (s) => s.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+var escProp = (s) => esc(s).replace(/:/g, "%3A").replace(/,/g, "%2C");
+function formatGithubAnnotations(report, max = 50) {
+  const level = { error: "error", warning: "warning", info: "notice" };
+  return report.violations.slice(0, max).map(
+    (v) => `::${level[v.severity]} file=${escProp(v.file)},line=${v.line},col=${v.column},title=${escProp(`Brandrail: ${title(v.ruleId)}`)}::${esc(
+      v.suggestion ? `${v.message}. ${v.suggestion}` : v.message
+    )}`
+  ).join("\n");
+}
+var COMMENT_MARKER = "<!-- brandrail-report -->";
+function formatMarkdown(report, opts = {}) {
+  const { threshold, maxRows = 30 } = opts;
+  const pass = threshold === void 0 || report.score >= threshold;
+  const badge = report.violations.length === 0 ? "\u{1F7E2}" : pass ? "\u{1F7E1}" : "\u{1F534}";
+  const out = [COMMENT_MARKER];
+  out.push(`## ${badge} Brand score: **${report.score}**/100${threshold !== void 0 ? ` (threshold ${threshold})` : ""}`);
+  out.push("");
+  out.push(
+    `**${report.counts.error}** errors \xB7 **${report.counts.warning}** warnings \xB7 **${report.counts.info}** info \u2014 ${report.filesScanned} files scanned${report.tokenVersion ? ` against Brand Kit v${report.tokenVersion}` : ""}`
+  );
+  if (report.violations.length === 0) {
+    out.push("", "Everything uses approved tokens and components. \u2728");
+  } else {
+    if (report.byRule.length) {
+      out.push("", "| Rule | Count |", "| --- | ---: |");
+      for (const r of report.byRule) out.push(`| ${title(r.ruleId)} \`${r.ruleId}\` | ${r.count} |`);
+    }
+    out.push("", "<details><summary>Violations</summary>", "", "| | Location | Issue | Fix |", "| --- | --- | --- | --- |");
+    const icon = { error: "\u{1F534}", warning: "\u{1F7E1}", info: "\u{1F535}" };
+    for (const v of report.violations.slice(0, maxRows)) {
+      const loc = v.line === 0 ? `${v.file} ${v.snippet ?? ""}`.trim() : `${v.file}:${v.line}`;
+      const url = opts.fileUrl?.(v);
+      const cell = (s) => s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+      out.push(`| ${icon[v.severity]} | ${url ? `[\`${loc}\`](${url})` : `\`${loc}\``} | ${cell(v.message)} | ${cell(v.suggestion ?? "")} |`);
+    }
+    if (report.violations.length > maxRows) out.push("", `\u2026and ${report.violations.length - maxRows} more.`);
+    out.push("", "</details>");
+  }
+  out.push("", `<sub>Brandrail engine ${report.engineVersion}${opts.dashboardUrl ? ` \xB7 [Open in Brandrail](${opts.dashboardUrl})` : ""}</sub>`);
+  return out.join("\n");
+}
+
+// ../engine/src/defaults.ts
+var starterConfig = {
+  $schema: "https://brandrail.dev/schema/config.json",
+  tokenVersion: "0.0.0-local",
+  tokens: {
+    color: {
+      action: { primary: { $type: "color", $value: "#1f883d", $description: "One primary action per view" } },
+      accent: { default: { $type: "color", $value: "#0969da", $description: "Links, focus, selection" } },
+      fg: {
+        default: { $type: "color", $value: "#1f2328", $description: "Body text" },
+        muted: { $type: "color", $value: "#59636e", $description: "Secondary text" }
+      },
+      canvas: {
+        default: { $type: "color", $value: "#ffffff", $description: "Page background" },
+        subtle: { $type: "color", $value: "#f6f8fa", $description: "Headers, wells" }
+      },
+      border: { default: { $type: "color", $value: "#d1d9e0", $description: "Borders and dividers" } },
+      danger: { default: { $type: "color", $value: "#cf222e", $description: "Destructive actions, errors" } }
+    },
+    font: {
+      family: { sans: { $type: "fontFamily", $value: "-apple-system, BlinkMacSystemFont, 'Segoe UI', 'Noto Sans', Helvetica, Arial, sans-serif" } },
+      size: { base: { $type: "dimension", $value: "14px" } }
+    },
+    radius: { md: { $type: "dimension", $value: "6px" } },
+    space: { unit: { $type: "dimension", $value: "8px" } }
+  },
+  components: [
+    { name: "Button", importPath: "@acme/ui" },
+    { name: "TextInput", importPath: "@acme/ui" },
+    { name: "Select", importPath: "@acme/ui" },
+    { name: "Textarea", importPath: "@acme/ui" }
+  ],
+  rules: {},
+  ignore: []
+};
+
+// ../engine/src/instructions.ts
+var RULES_START = "<!-- brandrail:start -->";
+var RULES_END = "<!-- brandrail:end -->";
+function generateInstructions(config, opts = {}) {
+  const r = resolveConfig(config);
+  const lines = [];
+  lines.push(`# Design system rules${opts.org ? ` \u2014 ${opts.org}` : ""}`);
+  lines.push("");
+  lines.push(
+    `All UI in this repo must follow the Brand Kit${r.tokenVersion ? ` (v${r.tokenVersion})` : ""}. These rules are checked on every pull request by Brandrail.`
+  );
+  lines.push("");
+  if (r.components.length) {
+    lines.push("## Components");
+    lines.push("Always use these components. Never re-create them with raw HTML elements:");
+    for (const c of r.components) {
+      const tags = [...r.replaces].filter(([, v]) => v === c).map(([t]) => `<${t}>`);
+      lines.push(`- \`${c.name}\` from \`${c.importPath}\`${tags.length ? ` (instead of ${tags.join(", ")})` : ""}`);
+    }
+    lines.push("");
+  }
+  if (r.colors.length) {
+    lines.push("## Colours");
+    lines.push("Use CSS variables only. Never write hex, rgb() or hsl() values, and never use Tailwind palette classes like `bg-blue-500`.");
+    for (const c of r.colors) {
+      if (c.mode) continue;
+      const dark = r.colors.find((d) => d.mode === "dark" && d.path === c.path);
+      lines.push(`- \`var(${c.cssVar})\` \u2014 ${c.path} (${c.hex}${dark ? `, dark ${dark.hex}` : ""})`);
+    }
+    lines.push("");
+  }
+  lines.push("## Spacing, radius and type");
+  lines.push(`- Spacing (padding, margin, gap) must be one of: ${r.spacing.filter((s) => s > 2).map((s) => `${s}px`).join(", ")}.`);
+  lines.push(`- Corner radius must be one of: ${r.radii.filter((x) => x > 0 && x < 999).map((x) => `${x}px`).join(", ")} (or fully rounded).`);
+  if (r.fonts.length) lines.push(`- Fonts: use ${r.fontVars.map((v) => `\`var(${v})\``).join(" or ")}; never set another font-family.`);
+  lines.push("");
+  lines.push("## Before you finish");
+  lines.push("- If the Brandrail MCP server is connected, call `validate_snippet` on the UI you wrote and fix every violation.");
+  lines.push("- Otherwise run `npx brandrail check` and fix errors before committing.");
+  lines.push("");
+  lines.push("<details><summary>Checked rules</summary>");
+  lines.push("");
+  for (const rule of RULES) {
+    if (r.rules[rule.id] === "off") continue;
+    lines.push(`- **${rule.title}** (\`${rule.id}\`): ${rule.description}`);
+  }
+  lines.push("");
+  lines.push("</details>");
+  return lines.join("\n");
+}
+function upsertSection(existing, section) {
+  const block = `${RULES_START}
+${section}
+${RULES_END}`;
+  const start = existing.indexOf(RULES_START);
+  const end = existing.indexOf(RULES_END);
+  if (start !== -1 && end > start) return existing.slice(0, start) + block + existing.slice(end + RULES_END.length);
+  return existing.trim() ? `${existing.trimEnd()}
+
+${block}
+` : `${block}
+`;
+}
+
+// ../engine/src/mcp-config.ts
+var json = (o) => `${JSON.stringify(o, null, 2)}
+`;
+function mcpClientConfigs(url) {
+  return [
+    {
+      id: "claude-code",
+      name: "Claude Code",
+      file: ".mcp.json",
+      projectFile: true,
+      content: json({ mcpServers: { brandrail: { type: "http", url, headers: { Authorization: "Bearer ${BRANDRAIL_KEY}" } } } }),
+      command: `claude mcp add --transport http brandrail ${url} --header "Authorization: Bearer $BRANDRAIL_KEY"`
+    },
+    {
+      id: "codex",
+      name: "Codex",
+      file: "~/.codex/config.toml",
+      projectFile: false,
+      content: `[mcp_servers.brandrail]
+url = "${url}"
+bearer_token_env_var = "BRANDRAIL_KEY"
+`,
+      command: `codex mcp add brandrail --url ${url} --bearer-token-env-var BRANDRAIL_KEY`
+    },
+    {
+      id: "cursor",
+      name: "Cursor",
+      file: ".cursor/mcp.json",
+      projectFile: true,
+      content: json({ mcpServers: { brandrail: { url, headers: { Authorization: "Bearer ${env:BRANDRAIL_KEY}" } } } })
+    },
+    {
+      id: "vscode",
+      name: "GitHub Copilot (VS Code)",
+      file: ".vscode/mcp.json",
+      projectFile: true,
+      content: json({
+        inputs: [{ type: "promptString", id: "brandrail-key", description: "Brandrail API key", password: true }],
+        servers: { brandrail: { type: "http", url, headers: { Authorization: "Bearer ${input:brandrail-key}" } } }
+      })
+    },
+    {
+      id: "windsurf",
+      name: "Windsurf",
+      file: "~/.codeium/windsurf/mcp_config.json",
+      projectFile: false,
+      content: json({ mcpServers: { brandrail: { serverUrl: url, headers: { Authorization: "Bearer ${env:BRANDRAIL_KEY}" } } } })
+    }
+  ];
+}
+var RULE_FILES = [
+  { file: "AGENTS.md", readBy: "Codex, Jules, Amp, Cursor and other agents" },
+  { file: "CLAUDE.md", readBy: "Claude Code" },
+  { file: ".cursor/rules/brandrail.mdc", readBy: "Cursor" },
+  { file: ".github/copilot-instructions.md", readBy: "GitHub Copilot" },
+  { file: ".windsurf/rules/brandrail.md", readBy: "Windsurf" },
+  { file: "GEMINI.md", readBy: "Gemini CLI" }
+];
+
+// ../engine/src/tokens.ts
+var EXT = "dev.brandrail";
+function slug(s) {
+  return s.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Za-z])(\d)/g, "$1-$2").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+var segs = (name) => name.split(/[/$.]+/).map(slug).filter(Boolean);
+var stripPrefix = (s, ...prefixes) => {
+  for (const p of prefixes) if (s === p) return "";
+  for (const p of prefixes) if (s.startsWith(`${p}-`)) return s.slice(p.length + 1);
+  return s;
+};
+var WEIGHTS = {
+  thin: "100",
+  hairline: "100",
+  "extra-light": "200",
+  "ultra-light": "200",
+  light: "300",
+  regular: "400",
+  regulare: "400",
+  normal: "400",
+  book: "400",
+  medium: "500",
+  "semi-bold": "600",
+  semibold: "600",
+  "demi-bold": "600",
+  bold: "700",
+  "extra-bold": "800",
+  "ultra-bold": "800",
+  black: "900",
+  heavy: "900"
+};
+function fontWeight(v) {
+  if (typeof v === "number") return String(v);
+  return WEIGHTS[slug(v)] ?? (/^\d{3}$/.test(v.trim()) ? v.trim() : v);
+}
+function colorValue(v) {
+  if (v && typeof v === "object" && "r" in v) {
+    const c = v;
+    const hex2 = toHex({ r: c.r * 255, g: c.g * 255, b: c.b * 255, a: 1 });
+    const a = c.a ?? 1;
+    return a < 1 ? `${hex2}${Math.round(a * 255).toString(16).padStart(2, "0")}` : hex2;
+  }
+  if (typeof v !== "string") return null;
+  const s = v.trim();
+  if (/^#[0-9a-f]{3,8}$/i.test(s)) {
+    const h = s.slice(1).toLowerCase();
+    return h.length === 3 || h.length === 4 ? `#${[...h].map((c) => c + c).join("")}` : `#${h}`;
+  }
+  const rgb = parseColor(s);
+  if (!rgb) return null;
+  const hex = toHex(rgb);
+  return rgb.a < 1 ? `${hex}${Math.round(rgb.a * 255).toString(16).padStart(2, "0")}` : hex;
+}
+var dim = (v) => typeof v === "number" ? `${Math.round(v * 100) / 100}px` : String(v).trim();
+function classify(name, kind, value, opts = {}) {
+  const parts = segs(name);
+  const hay = slug(`${opts.context ?? ""} ${name}`);
+  const scopes = opts.scopes ?? [];
+  const last = parts[parts.length - 1] ?? "";
+  const rest = parts.slice(0, -1);
+  if (kind === "boolean") return null;
+  if (kind === "color") {
+    const v2 = colorValue(value);
+    if (!v2) return null;
+    let p = parts[0] === "color" || parts[0] === "colors" ? parts.slice(1) : parts;
+    if (p.length === 1) p = [stripPrefix(p[0], "colors", "color") || p[0]];
+    const tail = p[p.length - 1];
+    const m = tail.match(/^(.*[a-z])-(\d+)$/);
+    if (m && p.length <= 2) p = [...p.slice(0, -1), m[1], m[2]];
+    return { path: ["color", ...p].join("."), type: "color", value: v2 };
+  }
+  if (kind === "string") {
+    const s = String(value);
+    if (scopes.includes("FONT_FAMILY") || /font-family|typeface|font-name/.test(hay) || last === "font") {
+      const n = stripPrefix(last, "font-family", "font", "family") || "sans";
+      return { path: `font.family.${/mono|code/.test(s.toLowerCase()) && n === "sans" ? "mono" : n}`, type: "fontFamily", value: s };
+    }
+    if (scopes.includes("FONT_STYLE") || scopes.includes("FONT_WEIGHT") || /font-weight|weight/.test(hay)) {
+      return { path: `font.weight.${stripPrefix(last, "font-weight", "weight") || last}`, type: "fontWeight", value: fontWeight(s) };
+    }
+    const c = colorValue(s);
+    if (c && /^#|^rgb|^hsl/i.test(s.trim())) return classify(name, "color", s, opts);
+    return null;
+  }
+  const v = dim(value);
+  const has = (...scope) => scope.some((x) => scopes.includes(x));
+  const nm = (...prefixes) => stripPrefix(last, ...prefixes) || last;
+  if (has("CORNER_RADIUS") || /radius|(^|-)rad(-|$)|corner|rounded/.test(hay)) return { path: `radius.${nm("radius", "rad", "corner", "rounded")}`, type: "dimension", value: v };
+  if (has("FONT_SIZE") || /font-size|text-size/.test(hay)) return { path: `font.size.${nm("font-size", "text-size", "size")}`, type: "dimension", value: v };
+  if (has("LINE_HEIGHT") || /line-height|leading/.test(hay)) return { path: `font.line-height.${nm("line-height", "leading")}`, type: "dimension", value: v };
+  if (has("LETTER_SPACING") || /letter-spacing|tracking/.test(hay)) return { path: `font.letter-spacing.${nm("letter-spacing", "tracking")}`, type: "dimension", value: v };
+  if (has("FONT_WEIGHT") || /font-weight/.test(hay)) return { path: `font.weight.${nm("font-weight", "weight")}`, type: "fontWeight", value: String(value) };
+  if (/icon/.test(last)) return { path: `size.icon.${nm("icon")}`, type: "dimension", value: v };
+  if (has("GAP") || /spac|gap|padding|margin|inset|(^|-)space(-|$)/.test(hay)) return { path: `space.${nm("spacing", "space", "gap")}`, type: "dimension", value: v };
+  if (has("STROKE_FLOAT") || /stroke|border-width/.test(hay)) return { path: `border.width.${nm("border-width", "stroke")}`, type: "dimension", value: v };
+  if (has("WIDTH_HEIGHT") || /size|width|height/.test(hay)) return { path: ["size", ...rest.filter((x) => x !== "size"), last].join("."), type: "dimension", value: v };
+  return { path: ["number", ...parts].join("."), type: "number", value: String(value) };
+}
+function rawLeaves(node, prefix, out, studio, inherited) {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return;
+  const o = node;
+  const groupType = o.$type ?? inherited;
+  const isLeaf = "$value" in o || studio && "value" in o && (typeof o.value !== "object" || o.value === null || "type" in o);
+  if (isLeaf) {
+    const ext = o.$extensions?.[EXT];
+    out.push({
+      path: prefix,
+      type: o.$type ?? o.type ?? groupType,
+      value: "$value" in o ? o.$value : o.value,
+      description: o.$description ?? o.description,
+      dark: ext?.modes?.dark
+    });
+    return;
+  }
+  for (const [k, v] of Object.entries(o)) if (!k.startsWith("$")) rawLeaves(v, prefix ? `${prefix}.${k}` : k, out, studio, groupType);
+}
+var REF = /^\{([^}]+)\}$/;
+function resolveRefs(raws) {
+  const byPath = new Map(raws.map((r) => [r.path, r]));
+  const deref = (v, mode, depth = 0) => {
+    if (typeof v !== "string" || depth > 10) return v;
+    const m = v.trim().match(REF);
+    if (!m) return v.replace(/\{([^}]+)\}/g, (all, p) => String(byPath.get(p)?.value ?? all));
+    const target = byPath.get(m[1]);
+    if (!target) return v;
+    return deref(mode === "dark" && target.dark !== void 0 ? target.dark : target.value, mode, depth + 1);
+  };
+  return raws.map((r) => ({ ...r, value: deref(r.value, "light"), dark: r.dark !== void 0 ? deref(r.dark, "dark") : void 0 }));
+}
+var TYPE_KIND = {
+  color: "color",
+  dimension: "number",
+  spacing: "number",
+  sizing: "number",
+  borderradius: "number",
+  fontsizes: "number",
+  fontsize: "number",
+  lineheights: "number",
+  lineheight: "number",
+  letterspacing: "number",
+  number: "number",
+  fontfamilies: "string",
+  fontfamily: "string",
+  fontweights: "string",
+  fontweight: "string"
+};
+function flattenTokens(doc) {
+  const raws = resolveRefs(collectRaw(doc).raws);
+  const out = [];
+  for (const r of raws) {
+    const t = (r.type ?? "").toLowerCase().replace(/[^a-z]/g, "");
+    if (t === "color" || !t && r.path.startsWith("color")) {
+      const v = colorValue(r.value);
+      if (!v) continue;
+      const d = r.dark !== void 0 ? colorValue(r.dark) : null;
+      out.push({ path: r.path, type: "color", value: v, ...d ? { dark: d } : {}, ...r.description ? { description: r.description } : {} });
+    } else if (typeof r.value === "string" || typeof r.value === "number") {
+      const type = t === "fontfamily" || t === "fontfamilies" ? "fontFamily" : t === "fontweight" || t === "fontweights" ? "fontWeight" : TYPE_KIND[t] === "number" ? "dimension" : t === "number" ? "number" : /^font\.family\./.test(r.path) ? "fontFamily" : typeof r.value === "number" ? "number" : /px$|rem$/.test(String(r.value)) ? "dimension" : "string";
+      out.push({ path: r.path, type, value: type === "dimension" ? dim(r.value) : String(r.value), ...r.description ? { description: r.description } : {} });
+    }
+  }
+  return out;
+}
+function collectRaw(doc) {
+  const o = doc ?? {};
+  const studio = !hasDollarValue(o) && hasStudioValue(o);
+  const order = o.$metadata?.tokenSetOrder;
+  if (!studio) {
+    const raws = [];
+    rawLeaves(o, "", raws, false);
+    return { raws, studio };
+  }
+  const setNames = (order ?? Object.keys(o).filter((k) => !k.startsWith("$"))).filter((k) => o[k] && typeof o[k] === "object");
+  const looksLikeSets = setNames.length > 0 && setNames.every((k) => !hasLeafAtTop(o[k]));
+  if (!looksLikeSets) {
+    const raws = [];
+    rawLeaves(o, "", raws, true);
+    return { raws, studio };
+  }
+  const merged = /* @__PURE__ */ new Map();
+  const darkSets = setNames.filter((n) => /dark/i.test(n));
+  for (const set of setNames.filter((n) => !/dark/i.test(n))) {
+    const raws = [];
+    rawLeaves(o[set], "", raws, true);
+    for (const r of raws) merged.set(r.path, r);
+  }
+  for (const set of darkSets) {
+    const raws = [];
+    rawLeaves(o[set], "", raws, true);
+    for (const r of raws) {
+      const base = merged.get(r.path);
+      if (base) base.dark = r.value;
+      else merged.set(r.path, r);
+    }
+  }
+  return { raws: [...merged.values()], studio };
+}
+function hasDollarValue(node, depth = 0) {
+  if (!node || typeof node !== "object" || depth > 12) return false;
+  if ("$value" in node) return true;
+  return Object.values(node).some((v) => hasDollarValue(v, depth + 1));
+}
+function hasStudioValue(node, depth = 0) {
+  if (!node || typeof node !== "object" || depth > 12) return false;
+  const o = node;
+  if ("value" in o && "type" in o) return true;
+  return Object.values(o).some((v) => hasStudioValue(v, depth + 1));
+}
+function hasLeafAtTop(node) {
+  return !!node && typeof node === "object" && ("value" in node || "$value" in node);
+}
+function buildDtcg(tokens) {
+  const tree = {};
+  for (const t of tokens) {
+    const parts = t.path.split(".");
+    let node = tree;
+    parts.forEach((p, i) => {
+      if (i === parts.length - 1) {
+        node[p] = {
+          $type: t.type,
+          $value: t.value,
+          ...t.description ? { $description: t.description } : {},
+          ...t.dark && t.dark !== t.value ? { $extensions: { [EXT]: { modes: { dark: t.dark } } } } : {}
+        };
+      } else {
+        const next = node[p];
+        if (next && typeof next === "object" && "$value" in next) node[p] = { default: next };
+        node = node[p] ??= {};
+      }
+    });
+  }
+  return tree;
+}
+var isAlias = (v) => !!v && typeof v === "object" && v.type === "VARIABLE_ALIAS";
+var DARK = /dark|night/i;
+var LIGHT = /light|default|day|base/i;
+function finish(format, all, notes, opts) {
+  const PALETTE2 = /^(color\.[a-z-]+)\.\d{1,3}$/;
+  const usedFamilies = new Set(all.filter((t) => t.referenced).map((t) => t.path.match(PALETTE2)?.[1]).filter(Boolean));
+  if (usedFamilies.size) {
+    const steps = /* @__PURE__ */ new Map();
+    for (const t of all) {
+      const f = t.path.match(PALETTE2)?.[1];
+      if (f) steps.set(f, (steps.get(f) ?? 0) + 1);
+    }
+    for (const t of all) {
+      const f = t.path.match(PALETTE2)?.[1];
+      if (f && (usedFamilies.has(f) || (steps.get(f) ?? 0) >= 3)) t.referenced = true;
+    }
+  }
+  const hasSemantic = all.some((t) => !t.referenced) && all.some((t) => t.referenced);
+  const keep = opts.includePrimitives || !hasSemantic ? all : all.filter((t) => !t.referenced);
+  const primitives = hasSemantic ? all.filter((t) => t.referenced).length : 0;
+  const seen = /* @__PURE__ */ new Set();
+  const tokens = [];
+  for (const { referenced: _r, ...t } of keep) {
+    if (seen.has(t.path)) continue;
+    seen.add(t.path);
+    tokens.push(t);
+  }
+  tokens.sort((a, b) => a.path.localeCompare(b.path, "en", { numeric: true }));
+  return { format, tokens: buildDtcg(tokens), count: tokens.length, primitives, notes };
+}
+function fromFigmaVariables(meta, opts = {}) {
+  const vars = meta.variables ?? {};
+  const cols = meta.variableCollections ?? {};
+  const notes = [];
+  const referenced = /* @__PURE__ */ new Set();
+  const modeFor = (col, want, likeName) => {
+    if (likeName) {
+      const same = col.modes.find((m) => m.name.toLowerCase() === likeName.toLowerCase());
+      if (same) return same.modeId;
+    }
+    if (want === "dark") return col.modes.find((m) => DARK.test(m.name))?.modeId;
+    return col.defaultModeId ?? col.modes[0]?.modeId;
+  };
+  const resolve4 = (v, want, modeName, depth = 0) => {
+    const col = cols[v.variableCollectionId];
+    if (!col) return void 0;
+    const modeId = modeFor(col, want, modeName) ?? col.defaultModeId;
+    const raw = v.valuesByMode[modeId] ?? Object.values(v.valuesByMode)[0];
+    if (!isAlias(raw)) return raw;
+    referenced.add(raw.id);
+    const target = vars[raw.id];
+    if (!target || depth > 10) return void 0;
+    const name = col.modes.find((m) => m.modeId === modeId)?.name;
+    return resolve4(target, want, name, depth + 1);
+  };
+  for (const v of Object.values(vars)) for (const val of Object.values(v.valuesByMode)) if (isAlias(val)) referenced.add(val.id);
+  for (const col of Object.values(cols)) {
+    if (col.remote) continue;
+    const dark = col.modes.find((m) => DARK.test(m.name));
+    const others = col.modes.filter((m) => m.modeId !== col.defaultModeId && m !== dark);
+    if (others.length) {
+      const def = col.modes.find((m) => m.modeId === col.defaultModeId)?.name;
+      notes.push(`\u201C${col.name}\u201D has modes ${col.modes.map((m) => m.name).join(", ")}; used \u201C${def}\u201D${dark ? ` (and \u201C${dark.name}\u201D as dark)` : ""}.`);
+    }
+  }
+  const out = [];
+  let hidden = 0;
+  for (const v of Object.values(vars)) {
+    const col = cols[v.variableCollectionId];
+    if (!col || v.remote || col.remote) continue;
+    if (v.hiddenFromPublishing) {
+      hidden++;
+      continue;
+    }
+    const kind = v.resolvedType === "COLOR" ? "color" : v.resolvedType === "FLOAT" ? "number" : v.resolvedType === "STRING" ? "string" : "boolean";
+    const value = resolve4(v, "default");
+    if (value === void 0) continue;
+    const c = classify(v.name, kind, value, { scopes: v.scopes?.filter((s) => s !== "ALL_SCOPES"), context: col.name });
+    if (!c) continue;
+    let darkValue;
+    if (c.type === "color") {
+      const hasDarkSomewhere = Object.values(cols).some((x) => x.modes.some((m) => DARK.test(m.name)));
+      if (hasDarkSomewhere) {
+        const d = colorValue(resolve4(v, "dark"));
+        if (d && d !== c.value) darkValue = d;
+      }
+    }
+    out.push({ ...c, ...darkValue ? { dark: darkValue } : {}, ...v.description ? { description: v.description } : {}, referenced: referenced.has(v.id) });
+  }
+  if (hidden) notes.push(`${hidden} variable${hidden === 1 ? "" : "s"} hidden from publishing were skipped.`);
+  return finish("figma-variables", out, notes, opts);
+}
+function fromFigmaStyles(styles, opts = {}) {
+  const out = [];
+  const families = /* @__PURE__ */ new Map();
+  let skipped = 0;
+  for (const s of styles) {
+    if (s.styleType === "FILL") {
+      const fill = s.node?.fills?.find((f) => f.type === "SOLID" && f.visible !== false && f.color);
+      if (!fill?.color) {
+        skipped++;
+        continue;
+      }
+      const c = classify(s.name, "color", { ...fill.color, a: (fill.color.a ?? 1) * (fill.opacity ?? 1) });
+      if (c) out.push({ ...c, ...s.description ? { description: s.description } : {} });
+    } else if (s.styleType === "TEXT" && s.node?.style) {
+      const st = s.node.style;
+      const name = segs(s.name).join("-");
+      if (st.fontSize) out.push({ path: `font.size.${name}`, type: "dimension", value: dim(st.fontSize) });
+      if (st.lineHeightPx) out.push({ path: `font.line-height.${name}`, type: "dimension", value: dim(Math.round(st.lineHeightPx)) });
+      if (st.fontWeight) out.push({ path: `font.weight.${name}`, type: "fontWeight", value: String(st.fontWeight) });
+      if (st.fontFamily) families.set(st.fontFamily, (families.get(st.fontFamily) ?? 0) + 1);
+    }
+  }
+  const fams = [...families.entries()].sort((a, b) => b[1] - a[1]);
+  fams.forEach(([f], i) => out.push({ path: `font.family.${i === 0 ? "sans" : /mono|code/i.test(f) ? "mono" : slug(f)}`, type: "fontFamily", value: f }));
+  const notes = skipped ? [`${skipped} fill style${skipped === 1 ? "" : "s"} (gradients or images) were skipped.`] : [];
+  return finish("figma-styles", out, notes, opts);
+}
+function plainLeaves(node, prefix, out) {
+  if (node === null || node === void 0) return;
+  if (typeof node !== "object" || typeof node === "object" && "r" in node && "g" in node) {
+    out.push({ key: prefix, value: node });
+    return;
+  }
+  for (const [k, v] of Object.entries(node)) plainLeaves(v, [...prefix, k], out);
+}
+function fromModeObject(obj, opts = {}) {
+  const notes = [];
+  const modes = Object.entries(obj).filter(([, v]) => v && typeof v === "object");
+  const leafSets = modes.map(([name, v]) => {
+    const l = [];
+    plainLeaves(v, [], l);
+    return { name, leaves: l, keys: new Set(l.map((x) => x.key.join("/"))) };
+  });
+  const groups = [];
+  for (const m of leafSets) {
+    const g = groups.find((grp) => {
+      const a = grp[0].keys;
+      let same = 0;
+      for (const k of m.keys) if (a.has(k)) same++;
+      return same / Math.max(a.size, m.keys.size) >= 0.8;
+    });
+    if (g) g.push(m);
+    else groups.push([m]);
+  }
+  const byLeaf = /* @__PURE__ */ new Map();
+  groups.forEach((grp, gi) => {
+    for (const m of grp) for (const l of m.leaves) {
+      const k = l.key[l.key.length - 1];
+      const e = byLeaf.get(k) ?? { group: gi, values: /* @__PURE__ */ new Map() };
+      e.values.set(m.name, l.value);
+      byLeaf.set(k, e);
+    }
+  });
+  const pick = (grp, want) => want === "dark" ? grp.find((m) => DARK.test(m.name)) : grp.find((m) => LIGHT.test(m.name) && !DARK.test(m.name)) ?? grp.find((m) => !DARK.test(m.name)) ?? grp[0];
+  const referenced = /* @__PURE__ */ new Set();
+  for (const m of leafSets) for (const l of m.leaves) if (typeof l.value === "string" && byLeaf.has(l.value)) referenced.add(l.value);
+  const deref = (v, want, depth = 0) => {
+    if (typeof v !== "string" || depth > 10) return v;
+    const ref = byLeaf.get(v) ?? byLeaf.get(v.replace(REF, "$1"));
+    if (!ref) return v;
+    referenced.add(v);
+    const grp = groups[ref.group];
+    const mode = pick(grp, want) ?? pick(grp, "default");
+    return deref(ref.values.get(mode.name) ?? [...ref.values.values()][0], want, depth + 1);
+  };
+  const out = [];
+  const pending = [];
+  for (const grp of groups) {
+    const def = pick(grp, "default");
+    const dark = pick(grp, "dark");
+    if (grp.length > 1) notes.push(`${grp.map((m) => m.name).join(" / ")} look like modes of one collection; used \u201C${def.name}\u201D${dark && dark !== def ? ` (and \u201C${dark.name}\u201D as dark)` : ""}.`);
+    for (const l of def.leaves) {
+      const key = l.key[l.key.length - 1];
+      const container = l.key.length > 1 ? l.key[l.key.length - 2].toLowerCase() : "";
+      const value = deref(l.value, "default");
+      const kind = container === "color" || colorValue(value) && /^#|^rgb|^hsl/i.test(String(value)) ? "color" : container === "string" || typeof value === "string" && !/^-?[\d.]+(px|rem|%)?$/.test(value) ? "string" : "number";
+      const c = classify(key, kind, kind === "number" && typeof value === "string" && /px$/.test(value) ? parseFloat(value) : value, { context: def.name });
+      if (!c) continue;
+      let d;
+      if (c.type === "color") {
+        const darkLeaf = dark && dark !== def ? dark.leaves.find((x) => x.key.join("/") === l.key.join("/")) : void 0;
+        const dv = colorValue(deref(darkLeaf ? darkLeaf.value : l.value, "dark"));
+        if (dv && dv !== c.value) d = dv;
+      }
+      pending.push({ key, t: { ...c, ...d ? { dark: d } : {} } });
+    }
+  }
+  for (const p of pending) out.push({ ...p.t, referenced: referenced.has(p.key) });
+  return finish("mode-object", out, notes, opts);
+}
+function importTokens(input, opts = {}) {
+  if (!input || typeof input !== "object") throw new Error("Expected a JSON object.");
+  const o = input;
+  const meta = o.meta ?? o;
+  if (meta.variables && meta.variableCollections) return fromFigmaVariables(meta, opts);
+  if (Array.isArray(o.styles) && o.styles.every((s) => s && "styleType" in s)) return fromFigmaStyles(o.styles, opts);
+  if (hasDollarValue(o) || hasStudioValue(o)) {
+    const studio = !hasDollarValue(o);
+    const flat = flattenTokens(o);
+    if (!flat.length) throw new Error("No tokens found in that file.");
+    const out = flat.map((t) => {
+      if (t.type === "color" && !t.path.startsWith("color.")) return { ...t, path: `color.${t.path}` };
+      return t;
+    });
+    const notes = studio ? [] : [];
+    const res = finish(studio ? "tokens-studio" : "dtcg", out, notes, opts);
+    return res;
+  }
+  const leaves2 = [];
+  plainLeaves(o, [], leaves2);
+  if (leaves2.length) return fromModeObject(o, opts);
+  throw new Error("Couldn't find any tokens. Supported: DTCG, Tokens Studio, Figma variables JSON.");
+}
+function diffTokens(before, after) {
+  const a = new Map(flattenTokens(before).map((t) => [t.path, t]));
+  const b = new Map(flattenTokens(after).map((t) => [t.path, t]));
+  const diff = { added: [], removed: [], changed: [], unchanged: 0 };
+  for (const [p, t] of b) {
+    const old = a.get(p);
+    if (!old) diff.added.push(t);
+    else if (old.value.toLowerCase() !== t.value.toLowerCase() || (old.dark ?? "").toLowerCase() !== (t.dark ?? "").toLowerCase()) diff.changed.push({ path: p, before: old, after: t });
+    else diff.unchanged++;
+  }
+  for (const [p, t] of a) if (!b.has(p)) diff.removed.push(t);
+  return diff;
+}
+function mergeTokens(base, incoming) {
+  const m = new Map(flattenTokens(base).map((t) => [t.path, t]));
+  for (const t of flattenTokens(incoming)) m.set(t.path, { ...m.get(t.path), ...t, description: t.description ?? m.get(t.path)?.description });
+  return buildDtcg([...m.values()]);
+}
+
+// ../engine/src/rendered.ts
+function collectRenderedNodes(maxNodes = 3e3) {
+  const SKIP = /* @__PURE__ */ new Set(["SCRIPT", "STYLE", "NOSCRIPT", "TEMPLATE", "IFRAME", "HEAD", "META", "LINK", "BR", "WBR", "SOURCE", "TRACK"]);
+  const px2 = (v) => {
+    const n = parseFloat(v);
+    return Number.isFinite(n) ? Math.round(n * 100) / 100 : 0;
+  };
+  const alphaOf = (c) => {
+    const m = c.match(/rgba?\(([^)]+)\)/);
+    if (!m) return 1;
+    const parts = m[1].split(/[\s,/]+/).filter(Boolean);
+    return parts[3] !== void 0 ? parseFloat(parts[3]) : 1;
+  };
+  const cssEsc = (s) => window.CSS && CSS.escape ? CSS.escape(s) : s.replace(/[^\w-]/g, "\\$&");
+  const part = (el) => {
+    if (el.id && el.id.length < 40) return `${el.tagName.toLowerCase()}#${cssEsc(el.id)}`;
+    const cls = Array.from(el.classList).filter((c) => c.length < 30).slice(0, 2).map((c) => `.${cssEsc(c)}`).join("");
+    return el.tagName.toLowerCase() + cls;
+  };
+  const selectorOf = (el) => {
+    const parts = [];
+    let cur = el;
+    while (cur && cur !== document.body && parts.length < 3) {
+      parts.unshift(part(cur));
+      if (cur.id) break;
+      cur = cur.parentElement;
+    }
+    return parts.join(" > ");
+  };
+  const bgCache = /* @__PURE__ */ new Map();
+  const effectiveBg = (el) => {
+    if (!el) return "rgb(255, 255, 255)";
+    if (bgCache.has(el)) return bgCache.get(el);
+    const cs = getComputedStyle(el);
+    let out;
+    if (cs.backgroundImage && cs.backgroundImage !== "none") out = null;
+    else if (alphaOf(cs.backgroundColor) >= 0.95) out = cs.backgroundColor;
+    else out = effectiveBg(el.parentElement);
+    bgCache.set(el, out);
+    return out;
+  };
+  const nodes = [];
+  const all = document.body ? document.body.querySelectorAll("*") : [];
+  for (const el of Array.from(all)) {
+    if (nodes.length >= maxNodes) break;
+    if (SKIP.has(el.tagName) || el.closest("svg") !== null && el.tagName.toLowerCase() !== "svg") continue;
+    const cs = getComputedStyle(el);
+    if (cs.display === "none" || cs.visibility === "hidden" || parseFloat(cs.opacity) === 0) continue;
+    const r = el.getBoundingClientRect();
+    if (r.width < 1 || r.height < 1) continue;
+    const text = Array.from(el.childNodes).filter((n) => n.nodeType === 3).map((n) => n.textContent ?? "").join(" ").replace(/\s+/g, " ").trim();
+    const borderW = Math.max(px2(cs.borderTopWidth), px2(cs.borderRightWidth), px2(cs.borderBottomWidth), px2(cs.borderLeftWidth));
+    const borderSide = px2(cs.borderTopWidth) > 0 ? cs.borderTopColor : px2(cs.borderBottomWidth) > 0 ? cs.borderBottomColor : px2(cs.borderLeftWidth) > 0 ? cs.borderLeftColor : cs.borderRightColor;
+    nodes.push({
+      selector: selectorOf(el),
+      tag: el.tagName.toLowerCase(),
+      text: text ? text.slice(0, 60) : void 0,
+      color: cs.color,
+      backgroundColor: cs.backgroundColor,
+      borderColor: borderW > 0 && cs.borderTopStyle !== "none" ? borderSide : void 0,
+      effectiveBackground: effectiveBg(el),
+      fontFamily: cs.fontFamily,
+      fontSize: px2(cs.fontSize),
+      fontWeight: parseInt(cs.fontWeight, 10) || 400,
+      radius: Math.max(px2(cs.borderTopLeftRadius), px2(cs.borderTopRightRadius), px2(cs.borderBottomLeftRadius), px2(cs.borderBottomRightRadius)),
+      minSide: Math.round(Math.min(r.width, r.height)),
+      padding: [px2(cs.paddingTop), px2(cs.paddingRight), px2(cs.paddingBottom), px2(cs.paddingLeft)],
+      gap: cs.display.includes("flex") || cs.display.includes("grid") ? [px2(cs.rowGap), px2(cs.columnGap)] : []
+    });
+  }
+  const links = Array.from(document.querySelectorAll("a[href]")).map((a) => a.href).filter((h) => {
+    try {
+      const u = new URL(h);
+      return u.origin === location.origin && !/\.(pdf|zip|png|jpe?g|svg|gif|webp|mp4)$/i.test(u.pathname);
+    } catch {
+      return false;
+    }
+  });
+  return { title: document.title, nodes, links: Array.from(new Set(links.map((h) => h.split("#")[0]))).slice(0, 50) };
+}
+var near = (scale, v, tol = 0.5) => scale.some((s) => Math.abs(s - v) <= tol);
+var neighbours2 = (scale, v) => {
+  const lo = [...scale].reverse().find((x) => x <= v);
+  const hi = scale.find((x) => x >= v);
+  return [...new Set([lo, hi].filter((x) => x !== void 0))].map((x) => `${x}px`).join(" or ");
+};
+function closestToken(config, rgb) {
+  const lab = rgbToLab(rgb);
+  let best = config.colors[0];
+  let bestD = Infinity;
+  for (const c of config.colors) {
+    const d = deltaE(lab, c.lab) + Math.abs(rgb.a - (c.alpha ?? 1)) * 100;
+    if (d < bestD) {
+      bestD = d;
+      best = c;
+    }
+  }
+  return { token: best, distance: bestD };
+}
+function colorLabel(rgb) {
+  const hex = toHex(rgb);
+  return rgb.a < 1 ? `${hex} at ${Math.round(rgb.a * 100)}%` : hex;
+}
+function checkRendered(pages, configInput, opts = {}) {
+  const t0 = Date.now();
+  const config = "replaces" in configInput ? configInput : resolveConfig(configInput);
+  const examples = opts.examples ?? 3;
+  const fontSizes = config.fontSizes;
+  const violations = [];
+  let nodesChecked = 0;
+  const spacing = config.spacing;
+  const radii = config.radii.filter((r) => r < 999);
+  for (const page of pages) {
+    const groups = /* @__PURE__ */ new Map();
+    const add = (key, g, selector) => {
+      const sev = config.rules[g.ruleId];
+      if (sev === "off") return;
+      const cur = groups.get(key) ?? { ...g, severity: sev ?? g.severity, selectors: [], count: 0 };
+      cur.count++;
+      if (cur.selectors.length < examples && !cur.selectors.includes(selector)) cur.selectors.push(selector);
+      groups.set(key, cur);
+    };
+    const colorCheck = (raw, where, selector) => {
+      if (!raw || !config.colors.length) return;
+      const rgb = parseColor(raw);
+      if (!rgb || rgb.a < 0.05) return;
+      const { token, distance } = closestToken(config, rgb);
+      if (distance <= config.colorTolerance) return;
+      const label = colorLabel(rgb);
+      add(
+        `color:${label}`,
+        {
+          ruleId: "no-hardcoded-color",
+          severity: "error",
+          message: (n) => `${label} isn't in the Brand Kit (${where} on ${n} element${n === 1 ? "" : "s"})`,
+          suggestion: token ? `Closest token is ${token.path} (${token.hex}, \u0394E ${distance.toFixed(1)}): use var(${token.cssVar})` : void 0
+        },
+        selector
+      );
+    };
+    for (const n of page.nodes) {
+      nodesChecked++;
+      if (n.text) colorCheck(n.color, "text", n.selector);
+      colorCheck(n.backgroundColor, "background", n.selector);
+      colorCheck(n.borderColor, "border", n.selector);
+      if (n.text) {
+        const fg = parseColor(n.color);
+        const bg = n.effectiveBackground ? parseColor(n.effectiveBackground) : null;
+        if (fg && bg && fg.a > 0.05) {
+          const blended = fg.a < 1 ? { r: fg.r * fg.a + bg.r * (1 - fg.a), g: fg.g * fg.a + bg.g * (1 - fg.a), b: fg.b * fg.a + bg.b * (1 - fg.a), a: 1 } : fg;
+          const ratio = contrastRatio(blended, bg);
+          const large = n.fontSize >= 24 || n.fontSize >= 18.66 && n.fontWeight >= 700;
+          const min = large ? 3 : 4.5;
+          if (ratio < min) {
+            const pair = `${colorLabel(fg)} on ${toHex(bg)}`;
+            add(
+              `contrast:${pair}:${large}`,
+              {
+                ruleId: "text-contrast",
+                severity: "error",
+                message: (c) => `${pair} is ${ratio.toFixed(2)}:1, below ${min}:1${large ? " for large text" : ""} (${c} element${c === 1 ? "" : "s"})`,
+                suggestion: "Use the Brand Kit's text colours on its background colours, e.g. fg.default on canvas.default",
+                sample: n.text
+              },
+              n.selector
+            );
+          }
+        }
+        if (config.fonts.length) {
+          const fam = normalizeFontFamily(n.fontFamily);
+          if (fam && !isGenericFont(fam) && !config.fonts.includes(fam) && !/^(pre|code|kbd|samp)$/.test(n.tag)) {
+            add(
+              `font:${fam}`,
+              {
+                ruleId: "font-family",
+                severity: "warning",
+                message: (c) => `Font \u201C${n.fontFamily.split(",")[0].replace(/["']/g, "").trim()}\u201D isn't a Brand Kit font (${c} element${c === 1 ? "" : "s"})`,
+                suggestion: `Use ${config.fontVars.map((v) => `var(${v})`).join(" or ")}`
+              },
+              n.selector
+            );
+          }
+        }
+        if (fontSizes.length >= 3 && !near(fontSizes, n.fontSize)) {
+          add(
+            `size:${n.fontSize}`,
+            {
+              ruleId: "font-size-scale",
+              severity: "warning",
+              message: (c) => `Font size ${n.fontSize}px is off the type scale (${c} element${c === 1 ? "" : "s"})`,
+              suggestion: `Use ${neighbours2(fontSizes, n.fontSize)}`
+            },
+            n.selector
+          );
+        }
+      }
+      for (const v of [.../* @__PURE__ */ new Set([...n.padding, ...n.gap])]) {
+        if (v <= 2 || near(spacing, v)) continue;
+        add(
+          `space:${v}`,
+          { ruleId: "spacing-scale", severity: "warning", message: (c) => `Spacing ${v}px is off the scale (${c} element${c === 1 ? "" : "s"})`, suggestion: `Use ${neighbours2(spacing, v)}` },
+          n.selector
+        );
+      }
+      if (n.radius > 0 && n.radius < 999 && n.radius < n.minSide / 2 - 0.5 && radii.length && !near(radii, n.radius)) {
+        add(
+          `radius:${n.radius}`,
+          { ruleId: "radius-scale", severity: "warning", message: (c) => `Corner radius ${n.radius}px is off the scale (${c} element${c === 1 ? "" : "s"})`, suggestion: `Use ${neighbours2(radii, n.radius)}` },
+          n.selector
+        );
+      }
+    }
+    const path = pagePath(page.url);
+    for (const g of groups.values()) {
+      violations.push({
+        ruleId: g.ruleId,
+        severity: g.severity,
+        file: path,
+        line: 0,
+        column: 0,
+        message: g.message(g.count),
+        suggestion: g.suggestion,
+        snippet: g.selectors.join(", ") + (g.sample ? `  \u201C${g.sample}\u201D` : "")
+      });
+    }
+  }
+  const order = { error: 0, warning: 1, info: 2 };
+  violations.sort((a, b) => a.file.localeCompare(b.file) || order[a.severity] - order[b.severity] || countOf(b) - countOf(a));
+  const counts = { error: 0, warning: 0, info: 0 };
+  const perRule = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    counts[v.severity]++;
+    perRule.set(v.ruleId, (perRule.get(v.ruleId) ?? 0) + 1);
+  }
+  return {
+    engineVersion: ENGINE_VERSION,
+    tokenVersion: config.tokenVersion,
+    // Findings are grouped per distinct value, so each one weighs more than a single code line.
+    score: computeScore(counts, Math.max(2e3, nodesChecked * 3)),
+    counts,
+    filesScanned: pages.length,
+    linesScanned: nodesChecked,
+    violations,
+    byRule: [...perRule].map(([ruleId, count]) => ({ ruleId, count })).sort((a, b) => b.count - a.count),
+    durationMs: Date.now() - t0
+  };
+}
+var countOf = (v) => Number(v.message.match(/\((?:\w+ on )?(\d+) element/)?.[1] ?? 0);
+function pagePath(url) {
+  try {
+    const u = new URL(url);
+    return `${u.host}${u.pathname}${u.search}`;
+  } catch {
+    return url;
+  }
+}
+
+// src/api.ts
+var DEFAULT_API = "https://web-phi-nine-77.vercel.app";
+function apiBase() {
+  return (process.env.BRANDRAIL_API_URL ?? DEFAULT_API).replace(/\/$/, "");
+}
+async function call(path, init) {
+  const res = await fetch(`${apiBase()}${path}`, {
+    ...init,
+    headers: { "content-type": "application/json", authorization: `Bearer ${init.key}`, ...init.headers ?? {} }
+  });
+  const text = await res.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {
+  }
+  if (!res.ok) {
+    const msg = body?.error ?? `${res.status} ${res.statusText}`;
+    throw new Error(`Brandrail API ${path}: ${msg}`);
+  }
+  return body;
+}
+function fetchBrandKit(key) {
+  return call("/api/v1/brand-kit", { method: "GET", key });
+}
+function uploadReport(key, payload) {
+  const report = payload.uploadSnippets ? payload.report : { ...payload.report, violations: payload.report.violations.map(({ snippet: _snippet, ...v }) => v) };
+  return call("/api/v1/scans", { method: "POST", key, body: JSON.stringify({ ...payload, report }) });
+}
+
+// src/files.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+var CONFIG_FILE = "brandrail.config.json";
+var MAX_FILE_BYTES = 512 * 1024;
+function collectFiles(root, paths, ignoreGlobs) {
+  const ignored = makeIgnore(ignoreGlobs);
+  const out = [];
+  const rel = (p) => relative(root, p).split(sep).join("/");
+  const visit = (abs) => {
+    const r = rel(abs);
+    let st;
+    try {
+      st = statSync(abs);
+    } catch {
+      return;
+    }
+    if (st.isDirectory()) {
+      const name = abs.split(sep).pop() ?? "";
+      if (r && (ignored(`${r}/`) || ignored(`${r}/x`) || name.startsWith(".") && name !== "." && name !== ".github")) return;
+      for (const entry of readdirSync(abs)) visit(join(abs, entry));
+      return;
+    }
+    if (!st.isFile() || st.size > MAX_FILE_BYTES) return;
+    if (fileKind(r) === "other" || ignored(r)) return;
+    out.push({ path: r, content: readFileSync(abs, "utf8") });
+  };
+  for (const p of paths.length ? paths : ["."]) visit(resolve(root, p));
+  return out;
+}
+function findConfig(start) {
+  let dir = resolve(start);
+  for (; ; ) {
+    const candidate = join(dir, CONFIG_FILE);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function readConfig(path) {
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  if (!parsed || typeof parsed !== "object" || !parsed.tokens) {
+    throw new Error(`${path} has no "tokens". Run \`brandrail init\` to create one.`);
+  }
+  return parsed;
+}
+
+// src/git.ts
+import { execFileSync } from "node:child_process";
+var git = (args, cwd) => {
+  try {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+};
+function repoInfo(cwd) {
+  const remote = git(["remote", "get-url", "origin"], cwd);
+  const m = remote?.match(/[:/]([^/:]+\/[^/]+?)(?:\.git)?$/);
+  const folder = cwd.split(/[\\/]/).pop() ?? "repo";
+  return {
+    slug: m?.[1] ?? remote ?? folder,
+    branch: git(["rev-parse", "--abbrev-ref", "HEAD"], cwd) ?? void 0,
+    sha: git(["rev-parse", "HEAD"], cwd) ?? void 0
+  };
+}
+function parseChangedLines(diff) {
+  const out = /* @__PURE__ */ new Map();
+  let file = null;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++ ")) {
+      const p = line.slice(4).trim();
+      file = p === "/dev/null" ? null : p.replace(/^b\//, "");
+      if (file && !out.has(file)) out.set(file, /* @__PURE__ */ new Set());
+      continue;
+    }
+    const h = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+    if (h && file) {
+      const start = Number(h[1]);
+      const count = h[2] === void 0 ? 1 : Number(h[2]);
+      const set = out.get(file);
+      for (let i = 0; i < count; i++) set.add(start + i);
+    }
+  }
+  return out;
+}
+function changedLines(cwd, base) {
+  const mergeBase = git(["merge-base", base, "HEAD"], cwd) ?? base;
+  const diff = git(["diff", "-U0", "--no-color", "--diff-filter=AMR", mergeBase], cwd);
+  return diff === null ? null : parseChangedLines(diff);
+}
+
+// src/scan.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import { join as join2, resolve as resolve2 } from "node:path";
+function loadPlaywright(cwd) {
+  for (const base of [join2(cwd, "package.json"), import.meta.url]) {
+    for (const name of ["playwright", "playwright-core"]) {
+      try {
+        return createRequire(base)(name);
+      } catch {
+      }
+    }
+  }
+  throw new Error("`brandrail scan` needs Playwright: npm i -D playwright && npx playwright install chromium");
+}
+async function scanPages(cwd, url, config, opts, log2) {
+  const pw = loadPlaywright(cwd);
+  const start = /^https?:\/\//i.test(url) ? url : `http://${url}`;
+  const state = opts.storageState ? resolve2(cwd, opts.storageState) : void 0;
+  if (state && !existsSync2(state)) throw new Error(`--storage-state file not found: ${state}`);
+  const browser = await pw.chromium.launch({ headless: true });
+  try {
+    const context = await browser.newContext({ viewport: { width: opts.width, height: 900 }, storageState: state });
+    const queue = [start];
+    const seen = /* @__PURE__ */ new Set();
+    const pages = [];
+    while (queue.length && pages.length < opts.pages) {
+      const next = queue.shift();
+      const key = next.replace(/\/$/, "");
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const page = await context.newPage();
+      try {
+        const res = await page.goto(next, { waitUntil: "domcontentloaded", timeout: 3e4 });
+        if (res && res.status() >= 400) {
+          log2(`  skipped ${next} (${res.status()})`);
+          if (pages.length === 0) throw new Error(`${next} answered ${res.status()}`);
+          continue;
+        }
+        await page.waitForLoadState("networkidle", { timeout: 8e3 }).catch(() => {
+        });
+        if (opts.waitMs) await page.waitForTimeout(opts.waitMs);
+        const data = await page.evaluate(collectRenderedNodes, 4e3);
+        pages.push({ url: page.url(), title: data.title, nodes: data.nodes });
+        log2(`  \u2714 ${page.url()}  (${data.nodes.length} elements)`);
+        if (pages.length === 1) queue.push(...data.links.filter((l) => l.startsWith(new URL(page.url()).origin)).sort((a, b) => a.length - b.length));
+      } finally {
+        await page.close().catch(() => {
+        });
+      }
+    }
+    return { report: checkRendered(pages, config), pages };
+  } finally {
+    await browser.close();
+  }
+}
+
+// src/index.ts
+var HELP = `brandrail ${ENGINE_VERSION} \u2014 check that UI follows your design system
+
+Usage
+  brandrail check [paths...]   Scan files and print violations
+  brandrail init               Create brandrail.config.json and AI rule files
+  brandrail scan <url>         Check a running page (localhost, staging, behind a login) in a real browser
+  brandrail import <file>      Load tokens (DTCG, Tokens Studio, Figma variables JSON) into the config
+  brandrail rules              List the rules
+
+Options for check
+  --config <file>        Config file (default: nearest brandrail.config.json)
+  --format <fmt>         pretty | json | markdown | github   (default: pretty)
+  --fail-below <score>   Exit 1 when the brand score is lower (default: off)
+  --changed [base]       Only report lines changed vs base branch (default: origin/main)
+  --upload               Send the result to Brandrail (needs BRANDRAIL_KEY)
+  --no-color             Plain output
+
+Options for init
+  --from-api             Pull the published Brand Kit (needs BRANDRAIL_KEY)
+  --no-rules             Don't write AGENTS.md (Codex), CLAUDE.md, Cursor, Copilot, Windsurf, Gemini rule files
+  --mcp                  Also add the Brandrail MCP server to .mcp.json, .cursor/mcp.json, .vscode/mcp.json
+                         and print the Codex / Windsurf config
+  --force                Overwrite an existing brandrail.config.json
+
+Options for scan
+  --pages <n>            Also scan pages it links to, up to n in total (default 1, max 20)
+  --storage-state <file> Playwright storage state with your login cookies
+  --wait <ms>            Extra wait after load, for client-rendered apps
+  --width <px>           Viewport width (default 1280)
+  --format, --fail-below, --upload   As for check
+  Needs Playwright: npm i -D playwright && npx playwright install chromium
+
+Options for import
+  --replace              Replace the config's tokens instead of merging
+  --primitives           Keep raw palette ramps (gray.100\u2026900) that semantic tokens point at
+
+Environment
+  BRANDRAIL_KEY          API key from Dashboard \u2192 Connect
+  BRANDRAIL_API_URL      Brandrail URL (default ${apiBase()})
+`;
+function parseArgs(argv) {
+  const [cmd = "help", ...rest] = argv;
+  const positional = [];
+  const flags = {};
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a.startsWith("--no-")) flags[a.slice(5)] = false;
+    else if (a.startsWith("--")) {
+      const [k, v] = a.slice(2).split("=", 2);
+      const next = rest[i + 1];
+      if (v !== void 0) flags[k] = v;
+      else if (next !== void 0 && !next.startsWith("-") && ["config", "format", "fail-below", "changed", "pages", "storage-state", "wait", "width"].includes(k)) {
+        flags[k] = next;
+        i++;
+      } else flags[k] = true;
+    } else positional.push(a);
+  }
+  return { cmd, positional, flags };
+}
+var log = (s = "") => process.stderr.write(`${s}
+`);
+async function loadConfig(cwd, flags) {
+  const explicit = typeof flags.config === "string" ? resolve3(cwd, flags.config) : null;
+  const path = explicit ?? findConfig(cwd);
+  if (path) return { config: readConfig(path), source: relative2(cwd, path) || CONFIG_FILE };
+  const key = process.env.BRANDRAIL_KEY;
+  if (key) {
+    const { config } = await fetchBrandKit(key);
+    return { config, source: `${apiBase()} (published Brand Kit)` };
+  }
+  throw new Error(`No ${CONFIG_FILE} found. Run \`npx brandrail init\` first, or set BRANDRAIL_KEY to use your published Brand Kit.`);
+}
+async function cmdCheck(cwd, positional, flags) {
+  const { config, source } = await loadConfig(cwd, flags);
+  const resolved = resolveConfig(config);
+  const root = dirname2(typeof flags.config === "string" ? resolve3(cwd, flags.config) : findConfig(cwd) ?? join3(cwd, CONFIG_FILE));
+  const files = collectFiles(root, positional.map((p) => relative2(root, resolve3(cwd, p))), resolved.ignore);
+  let onlyLines;
+  if (flags.changed) {
+    const base = typeof flags.changed === "string" ? flags.changed : "origin/main";
+    onlyLines = changedLines(root, base) ?? void 0;
+    if (!onlyLines) log(`warning: couldn't read git diff against ${base}; checking everything`);
+  }
+  const report = check(files, resolved, { onlyLines });
+  const format = typeof flags.format === "string" ? flags.format : "pretty";
+  const threshold = flags["fail-below"] !== void 0 ? Number(flags["fail-below"]) : void 0;
+  if (format === "json") process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+  else if (format === "markdown") process.stdout.write(`${formatMarkdown(report, { threshold })}
+`);
+  else if (format === "github") process.stdout.write(`${formatGithubAnnotations(report)}
+`);
+  else {
+    const color = flags.color !== false && process.stdout.isTTY !== false && !process.env.NO_COLOR;
+    const kit = `Brand Kit: ${source}${config.tokenVersion ? ` v${config.tokenVersion}` : ""}`;
+    log(color ? `\x1B[2m${kit}\x1B[0m` : kit);
+    process.stdout.write(`${formatPretty(report, { color })}
+`);
+  }
+  if (flags.upload) {
+    const key = process.env.BRANDRAIL_KEY;
+    if (!key) log("warning: --upload needs BRANDRAIL_KEY; skipped");
+    else {
+      const repo = repoInfo(root);
+      const res = await uploadReport(key, {
+        source: process.env.CI ? "ci" : "cli",
+        target: { kind: "repo", name: repo.slug.split("/").pop() ?? repo.slug, location: repo.slug },
+        ref: repo.branch ?? repo.sha?.slice(0, 7),
+        title: flags.changed ? `Changed lines on ${repo.branch ?? "HEAD"}` : `Local check on ${repo.branch ?? "HEAD"}`,
+        threshold,
+        report
+      });
+      log(`Uploaded \u2192 ${res.url ?? res.scanId}`);
+    }
+  }
+  if (threshold !== void 0 && report.score < threshold) {
+    log(`
+Brand score ${report.score} is below ${threshold}.`);
+    return 1;
+  }
+  return 0;
+}
+function writeRuleFiles(root, config, org) {
+  const md = generateInstructions(config, { org });
+  const written = [];
+  const write = (rel, content) => {
+    const abs = join3(root, rel);
+    mkdirSync(dirname2(abs), { recursive: true });
+    const before = existsSync3(abs) ? readFileSync2(abs, "utf8") : "";
+    writeFileSync(abs, content(before));
+    written.push(rel);
+  };
+  for (const { file, readBy } of RULE_FILES) {
+    if (file.endsWith(".mdc")) {
+      write(file, () => `---
+description: Design system rules from Brandrail
+globs: ["**/*.{tsx,jsx,vue,svelte,html,css,scss}"]
+alwaysApply: true
+---
+
+${md}
+`);
+    } else if (file.startsWith(".windsurf/")) {
+      write(file, () => `---
+trigger: always_on
+---
+
+${md}
+`);
+    } else {
+      write(file, (before) => upsertSection(before, md));
+    }
+    written[written.length - 1] = `${file}  (${readBy})`;
+  }
+  return written;
+}
+function writeMcpConfigs(root) {
+  const url = `${apiBase()}/api/mcp`;
+  for (const c of mcpClientConfigs(url)) {
+    if (!c.projectFile) continue;
+    const abs = join3(root, c.file);
+    mkdirSync(dirname2(abs), { recursive: true });
+    const ours = JSON.parse(c.content);
+    let merged = ours;
+    if (existsSync3(abs)) {
+      try {
+        const existing = JSON.parse(readFileSync2(abs, "utf8"));
+        merged = { ...existing };
+        for (const [k, v] of Object.entries(ours)) {
+          if (Array.isArray(v)) {
+            const prev = Array.isArray(existing[k]) ? existing[k] : [];
+            merged[k] = [...prev.filter((x) => !v.some((y) => y.id === x.id)), ...v];
+          } else merged[k] = { ...existing[k] ?? {}, ...v };
+        }
+      } catch {
+        log(`warning: ${c.file} isn't valid JSON; left unchanged`);
+        continue;
+      }
+    }
+    writeFileSync(abs, `${JSON.stringify(merged, null, 2)}
+`);
+    log(`\u2714 added brandrail to ${c.file}  (${c.name})`);
+  }
+  for (const c of mcpClientConfigs(url).filter((x) => !x.projectFile)) {
+    log(`
+${c.name}: ${c.command ? `run
+  ${c.command}
+or add` : "add"} to ${c.file}:
+${c.content.replace(/^/gm, "  ")}`);
+  }
+  log("\nSet BRANDRAIL_KEY in your shell (an API key from Dashboard \u2192 Connect) before starting the AI tool.");
+}
+async function cmdInit(cwd, flags) {
+  const target = join3(cwd, CONFIG_FILE);
+  let config = starterConfig;
+  let org;
+  if (flags["from-api"]) {
+    const key = process.env.BRANDRAIL_KEY;
+    if (!key) throw new Error("--from-api needs BRANDRAIL_KEY (Dashboard \u2192 Connect \u2192 API keys).");
+    const res = await fetchBrandKit(key);
+    config = { $schema: starterConfig.$schema, ...res.config };
+    org = res.org;
+  }
+  if (existsSync3(target) && !flags.force && !flags["from-api"]) {
+    log(`${CONFIG_FILE} already exists (use --force to overwrite). Updating rule files from it.`);
+    config = readConfig(target);
+  } else {
+    writeFileSync(target, `${JSON.stringify(config, null, 2)}
+`);
+    log(`\u2714 wrote ${CONFIG_FILE}${org ? ` from ${org}'s Brand Kit` : " (starter tokens \u2014 edit them or use --from-api)"}`);
+  }
+  if (flags.rules !== false) for (const f of writeRuleFiles(cwd, config, org)) log(`\u2714 updated ${f}`);
+  if (flags.mcp) writeMcpConfigs(cwd);
+  log("\nNext: npx brandrail check");
+  return 0;
+}
+async function cmdScan(cwd, positional, flags) {
+  const url = positional[0];
+  if (!url) throw new Error("Usage: brandrail scan <url> [--pages 3] [--storage-state auth.json] [--upload]");
+  const { config, source } = await loadConfig(cwd, flags);
+  const num = (k, d, max) => typeof flags[k] === "string" ? Math.min(Math.max(Number(flags[k]) || d, 0), max) : d;
+  log(`Scanning ${url} \u2026`);
+  const { report, pages } = await scanPages(
+    cwd,
+    url,
+    config,
+    {
+      pages: Math.max(1, num("pages", 1, 20)),
+      storageState: typeof flags["storage-state"] === "string" ? flags["storage-state"] : void 0,
+      waitMs: num("wait", 0, 3e4),
+      width: num("width", 1280, 3840) || 1280
+    },
+    log
+  );
+  const format = typeof flags.format === "string" ? flags.format : "pretty";
+  const threshold = flags["fail-below"] !== void 0 ? Number(flags["fail-below"]) : void 0;
+  if (format === "json") process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+  else if (format === "markdown") process.stdout.write(`${formatMarkdown(report, { threshold })}
+`);
+  else {
+    const color = flags.color !== false && process.stdout.isTTY !== false && !process.env.NO_COLOR;
+    log(color ? `\x1B[2mBrand Kit: ${source}\x1B[0m` : `Brand Kit: ${source}`);
+    process.stdout.write(`${formatPretty(report, { color }).replace(/:0:0\b/g, "")}
+`);
+  }
+  if (flags.upload) {
+    const key = process.env.BRANDRAIL_KEY;
+    if (!key) log("warning: --upload needs BRANDRAIL_KEY; skipped");
+    else {
+      const first = new URL(pages[0].url);
+      const res = await uploadReport(key, {
+        source: process.env.CI ? "ci" : "cli",
+        target: { kind: "url", name: first.host, location: `${first.origin}${first.pathname === "/" ? "" : first.pathname}` },
+        ref: first.toString(),
+        title: pages.length > 1 ? `${first.host} \xB7 ${pages.length} pages` : `${first.host}${first.pathname === "/" ? "" : first.pathname}`,
+        threshold,
+        report
+      });
+      log(`Uploaded \u2192 ${res.url ?? res.scanId}`);
+    }
+  }
+  if (threshold !== void 0 && report.score < threshold) {
+    log(`
+Brand score ${report.score} is below ${threshold}.`);
+    return 1;
+  }
+  return 0;
+}
+function cmdImport(cwd, positional, flags) {
+  const file = positional[0];
+  if (!file) throw new Error("Usage: brandrail import <tokens.json> [--replace] [--primitives]");
+  const raw = JSON.parse(readFileSync2(resolve3(cwd, file), "utf8"));
+  const res = importTokens(raw, { includePrimitives: !!flags.primitives });
+  const path = (typeof flags.config === "string" ? resolve3(cwd, flags.config) : findConfig(cwd)) ?? join3(cwd, CONFIG_FILE);
+  const config = existsSync3(path) ? readConfig(path) : { ...starterConfig, tokens: {} };
+  const next = flags.replace ? res.tokens : mergeTokens(config.tokens, res.tokens);
+  const d = diffTokens(config.tokens, next);
+  writeFileSync(path, `${JSON.stringify({ ...config, tokens: next }, null, 2)}
+`);
+  log(`\u2714 ${res.count} tokens from ${file} (${res.format})${res.primitives ? `, ${res.primitives} palette primitives left out (--primitives to keep)` : ""}`);
+  for (const n of res.notes) log(`  \xB7 ${n}`);
+  log(`\u2714 ${relative2(cwd, path) || CONFIG_FILE}: ${d.changed.length} changed, ${d.added.length} added, ${d.removed.length} removed`);
+  log("\nNext: npx brandrail init (to refresh AI rule files), then npx brandrail check");
+  return 0;
+}
+function cmdRules() {
+  for (const r of RULES) process.stdout.write(`${r.id.padEnd(28)} ${r.defaultSeverity.padEnd(8)} ${r.description}
+`);
+  return 0;
+}
+async function main(argv = process.argv.slice(2)) {
+  const { cmd, positional, flags } = parseArgs(argv);
+  const cwd = process.cwd();
+  if (flags.version || cmd === "--version" || cmd === "-v") {
+    process.stdout.write(`${ENGINE_VERSION}
+`);
+    return 0;
+  }
+  switch (cmd) {
+    case "check":
+      return cmdCheck(cwd, positional, flags);
+    case "init":
+      return cmdInit(cwd, flags);
+    case "scan":
+      return cmdScan(cwd, positional, flags);
+    case "import":
+      return cmdImport(cwd, positional, flags);
+    case "rules":
+      return cmdRules();
+    default:
+      process.stdout.write(HELP);
+      return cmd === "help" || cmd === "--help" || cmd === "-h" ? 0 : 1;
+  }
+}
+main().then(
+  (code) => process.exit(code),
+  (err) => {
+    log(`brandrail: ${err.message}`);
+    process.exit(2);
+  }
+);
+export {
+  main
+};