@bridge-ds/stylelint-plugin 0.0.0-stage → 0.2.1

package/dist/index.js

@@ -0,0 +1,1349 @@
+// src/index.ts
+import stylelint from "stylelint";
+
+// ../core/src/values.ts
+var ALIAS_RE = /^\{([^{}]+)\}$/;
+var isAlias = (v) => typeof v === "string" && ALIAS_RE.test(v);
+var aliasTarget = (v) => ALIAS_RE.exec(v)?.[1] ?? v;
+function hexToRgba(hex) {
+  const m = /^#?([0-9a-f]{3,8})$/i.exec(hex.trim());
+  if (!m) return void 0;
+  let h = m[1];
+  if (h.length === 3 || h.length === 4) h = [...h].map((c) => c + c).join("");
+  if (h.length !== 6 && h.length !== 8) return void 0;
+  const n = (idx) => parseInt(h.slice(idx, idx + 2), 16) / 255;
+  return { r: n(0), g: n(2), b: n(4), a: h.length === 8 ? n(6) : 1 };
+}
+
+// ../core/src/audit/color.ts
+var NAMED_COLORS = {
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  azure: "#f0ffff",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  black: "#000000",
+  blanchedalmond: "#ffebcd",
+  blue: "#0000ff",
+  blueviolet: "#8a2be2",
+  brown: "#a52a2a",
+  burlywood: "#deb887",
+  cadetblue: "#5f9ea0",
+  chartreuse: "#7fff00",
+  chocolate: "#d2691e",
+  coral: "#ff7f50",
+  cornflowerblue: "#6495ed",
+  cornsilk: "#fff8dc",
+  crimson: "#dc143c",
+  cyan: "#00ffff",
+  darkblue: "#00008b",
+  darkcyan: "#008b8b",
+  darkgoldenrod: "#b8860b",
+  darkgray: "#a9a9a9",
+  darkgreen: "#006400",
+  darkgrey: "#a9a9a9",
+  darkkhaki: "#bdb76b",
+  darkmagenta: "#8b008b",
+  darkolivegreen: "#556b2f",
+  darkorange: "#ff8c00",
+  darkorchid: "#9932cc",
+  darkred: "#8b0000",
+  darksalmon: "#e9967a",
+  darkseagreen: "#8fbc8f",
+  darkslateblue: "#483d8b",
+  darkslategray: "#2f4f4f",
+  darkslategrey: "#2f4f4f",
+  darkturquoise: "#00ced1",
+  darkviolet: "#9400d3",
+  deeppink: "#ff1493",
+  deepskyblue: "#00bfff",
+  dimgray: "#696969",
+  dimgrey: "#696969",
+  dodgerblue: "#1e90ff",
+  firebrick: "#b22222",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  fuchsia: "#ff00ff",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  gray: "#808080",
+  green: "#008000",
+  greenyellow: "#adff2f",
+  grey: "#808080",
+  honeydew: "#f0fff0",
+  hotpink: "#ff69b4",
+  indianred: "#cd5c5c",
+  indigo: "#4b0082",
+  ivory: "#fffff0",
+  khaki: "#f0e68c",
+  lavender: "#e6e6fa",
+  lavenderblush: "#fff0f5",
+  lawngreen: "#7cfc00",
+  lemonchiffon: "#fffacd",
+  lightblue: "#add8e6",
+  lightcoral: "#f08080",
+  lightcyan: "#e0ffff",
+  lightgoldenrodyellow: "#fafad2",
+  lightgray: "#d3d3d3",
+  lightgreen: "#90ee90",
+  lightgrey: "#d3d3d3",
+  lightpink: "#ffb6c1",
+  lightsalmon: "#ffa07a",
+  lightseagreen: "#20b2aa",
+  lightskyblue: "#87cefa",
+  lightslategray: "#778899",
+  lightslategrey: "#778899",
+  lightsteelblue: "#b0c4de",
+  lightyellow: "#ffffe0",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  linen: "#faf0e6",
+  magenta: "#ff00ff",
+  maroon: "#800000",
+  mediumaquamarine: "#66cdaa",
+  mediumblue: "#0000cd",
+  mediumorchid: "#ba55d3",
+  mediumpurple: "#9370db",
+  mediumseagreen: "#3cb371",
+  mediumslateblue: "#7b68ee",
+  mediumspringgreen: "#00fa9a",
+  mediumturquoise: "#48d1cc",
+  mediumvioletred: "#c71585",
+  midnightblue: "#191970",
+  mintcream: "#f5fffa",
+  mistyrose: "#ffe4e1",
+  moccasin: "#ffe4b5",
+  navajowhite: "#ffdead",
+  navy: "#000080",
+  oldlace: "#fdf5e6",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  orange: "#ffa500",
+  orangered: "#ff4500",
+  orchid: "#da70d6",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  paleturquoise: "#afeeee",
+  palevioletred: "#db7093",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peru: "#cd853f",
+  pink: "#ffc0cb",
+  plum: "#dda0dd",
+  powderblue: "#b0e0e6",
+  purple: "#800080",
+  rebeccapurple: "#663399",
+  red: "#ff0000",
+  rosybrown: "#bc8f8f",
+  royalblue: "#4169e1",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seashell: "#fff5ee",
+  sienna: "#a0522d",
+  silver: "#c0c0c0",
+  skyblue: "#87ceeb",
+  slateblue: "#6a5acd",
+  slategray: "#708090",
+  slategrey: "#708090",
+  snow: "#fffafa",
+  springgreen: "#00ff7f",
+  steelblue: "#4682b4",
+  tan: "#d2b48c",
+  teal: "#008080",
+  thistle: "#d8bfd8",
+  tomato: "#ff6347",
+  turquoise: "#40e0d0",
+  violet: "#ee82ee",
+  wheat: "#f5deb3",
+  white: "#ffffff",
+  whitesmoke: "#f5f5f5",
+  yellow: "#ffff00",
+  yellowgreen: "#9acd32"
+};
+var num = (s, scale) => s.endsWith("%") ? parseFloat(s) / 100 * scale : parseFloat(s);
+function hslToRgb(h, s, l) {
+  const hh = (h % 360 + 360) % 360 / 360;
+  if (s === 0) return [l, l, l];
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  const f = (t) => {
+    let x = t;
+    if (x < 0) x += 1;
+    if (x > 1) x -= 1;
+    if (x < 1 / 6) return p + (q - p) * 6 * x;
+    if (x < 1 / 2) return q;
+    if (x < 2 / 3) return p + (q - p) * (2 / 3 - x) * 6;
+    return p;
+  };
+  return [f(hh + 1 / 3), f(hh), f(hh - 1 / 3)];
+}
+function parseCssColor(input) {
+  const s = input.trim().toLowerCase();
+  if (s.startsWith("#")) return hexToRgba(s);
+  if (NAMED_COLORS[s]) return hexToRgba(NAMED_COLORS[s]);
+  const fn = /^(rgba?|hsla?)\(\s*([^)]*)\)$/.exec(s);
+  const bare = /^(-?[\d.]+)(deg)?\s+([\d.]+)%\s+([\d.]+)%(\s*\/\s*([\d.]+%?))?$/.exec(s);
+  if (bare) {
+    const [r2, g2, b2] = hslToRgb(parseFloat(bare[1]), parseFloat(bare[3]) / 100, parseFloat(bare[4]) / 100);
+    return { r: r2, g: g2, b: b2, a: bare[6] ? num(bare[6], 1) : 1 };
+  }
+  if (!fn) return void 0;
+  const parts = fn[2].split(/[\s,/]+/).filter(Boolean);
+  if (parts.length < 3 || parts.some((p) => !/^-?[\d.]+(%|deg)?$/.test(p))) return void 0;
+  const alpha = parts[3] !== void 0 ? num(parts[3], 1) : 1;
+  if (fn[1].startsWith("rgb")) {
+    const [r2, g2, b2] = parts.slice(0, 3).map((p) => num(p, 255) / 255);
+    return { r: r2, g: g2, b: b2, a: alpha };
+  }
+  const [r, g, b] = hslToRgb(parseFloat(parts[0]), num(parts[1], 1), num(parts[2], 1));
+  return { r, g, b, a: alpha };
+}
+var lin = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+function toOklab(c) {
+  const r = lin(c.r);
+  const g = lin(c.g);
+  const b = lin(c.b);
+  const l = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+  const m = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+  const s = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+  return {
+    L: 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    a: 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    b: 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  };
+}
+function deltaE(x, y) {
+  const p = toOklab(x);
+  const q = toOklab(y);
+  return Math.hypot(p.L - q.L, p.a - q.a, p.b - q.b) * 100 + Math.abs(x.a - y.a) * 50;
+}
+var COLOR_LITERAL_RE = /#(?:[0-9a-fA-F]{8}|[0-9a-fA-F]{6}|[0-9a-fA-F]{3,4})\b|\b(?:rgba?|hsla?)\([^()]*\)/g;
+
+// ../core/src/audit/scan-value.ts
+var COLOR_PROP = /^(color|background(-color|-image)?|border(-(top|right|bottom|left|block|inline)(-(start|end))?)?(-color)?|outline(-color)?|fill|stroke|text-decoration(-color)?|caret-color|accent-color|column-rule(-color)?|stop-color|flood-color|lighting-color|-webkit-text-fill-color|scrollbar-color|box-shadow|text-shadow)$/;
+var SPACING_PROP = /^(padding|margin|gap|row-gap|column-gap|grid-gap|grid-row-gap|grid-column-gap|inset|top|right|bottom|left|scroll-margin|scroll-padding)(-(top|right|bottom|left|block|inline|x|y)(-(start|end))?)?$/;
+var SIZE_PROP = /^(min-|max-)?(width|height|block-size|inline-size)$|^flex-basis$/;
+var RADIUS_PROP = /radius$/;
+var BORDER_WIDTH_PROP = /^(border|outline)(-(top|right|bottom|left|block|inline)(-(start|end))?)?(-width)?$|^outline-offset$|^column-rule(-width)?$/;
+var MOTION_PROP = /^(transition|animation)(-duration|-delay)?$/;
+var EASING_PROP = /^(transition|animation)(-timing-function)?$/;
+var SKIP_PROP = /^(content|grid-template(-areas)?|grid-area|src|mask(-image)?|transform|translate|will-change|cursor|quotes|font-feature-settings|font-variation-settings|counter-(reset|increment)|clip-path|d|unicode-range)$/;
+var looseKey = (p) => p.startsWith("$") || p.startsWith("--") || !/^-?[a-z]+(-[a-z]+)*$/.test(p) || !KNOWN_PROPS.has(p);
+var KNOWN_PROPS = new Set(
+  "color background background-color background-image border border-top border-right border-bottom border-left border-color border-width border-style border-radius border-top-left-radius border-top-right-radius border-bottom-left-radius border-bottom-right-radius border-top-color border-bottom-color border-left-color border-right-color border-top-width border-bottom-width border-left-width border-right-width border-block border-inline border-block-start border-block-end border-inline-start border-inline-end outline outline-color outline-width outline-offset fill stroke text-decoration text-decoration-color caret-color accent-color box-shadow text-shadow padding padding-top padding-right padding-bottom padding-left padding-block padding-inline padding-x padding-y padding-inline-start padding-inline-end padding-block-start padding-block-end margin margin-top margin-right margin-bottom margin-left margin-block margin-inline margin-x margin-y margin-inline-start margin-inline-end margin-block-start margin-block-end gap row-gap column-gap grid-gap inset top right bottom left width height min-width min-height max-width max-height flex-basis font font-family font-size font-weight line-height letter-spacing transition transition-duration transition-delay transition-timing-function animation animation-duration animation-delay animation-timing-function z-index opacity display position flex flex-direction flex-wrap flex-grow flex-shrink align-items justify-content overflow text-align white-space cursor content transform".split(" ")
+);
+function mask(value) {
+  let out = value;
+  for (const fn of ["var(", "url(", "env("]) {
+    let i = out.indexOf(fn);
+    while (i >= 0) {
+      let depth = 0;
+      let j = i + fn.length - 1;
+      for (; j < out.length; j++) {
+        if (out[j] === "(") depth++;
+        else if (out[j] === ")" && --depth === 0) break;
+      }
+      out = out.slice(0, i) + " ".repeat(j + 1 - i) + out.slice(j + 1);
+      i = out.indexOf(fn, i);
+    }
+  }
+  return out.replace(/(["'])(?:(?!\1).)*\1/g, (s) => " ".repeat(s.length));
+}
+var LENGTH_RE = /(?<![\w.#-])(-?\d*\.?\d+)(px|rem|em)\b/g;
+function lengthCategory(prop) {
+  if (RADIUS_PROP.test(prop)) return "radius";
+  if (SPACING_PROP.test(prop)) return "spacing";
+  if (SIZE_PROP.test(prop)) return "size";
+  if (BORDER_WIDTH_PROP.test(prop)) return "border-width";
+  if (prop === "font-size") return "font-size";
+  if (prop === "line-height") return "line-height";
+  if (looseKey(prop)) {
+    const k = prop.toLowerCase();
+    if (/radius|rounded/.test(k)) return "radius";
+    if (/space|spacing|gap|padding|margin|gutter|inset/.test(k)) return "spacing";
+    if (/font-?size|fontsize/.test(k)) return "font-size";
+    if (/width|height|size/.test(k)) return "size";
+  }
+  return void 0;
+}
+function scanCssValue(property, value) {
+  const prop = property.trim().toLowerCase();
+  const vars = [...value.matchAll(/var\(\s*(--[\w-]+)/g)].map((m) => m[1]);
+  const hits = [];
+  const out = { hits, vars, themeRef: false };
+  if (SKIP_PROP.test(prop)) return out;
+  const v = value.trim();
+  if (!v || /^(inherit|initial|unset|revert|none|auto|0|normal|currentcolor|transparent)$/i.test(v)) return out;
+  if (/^\$[\w-]+$/.test(v) || /^theme\(/.test(v)) {
+    out.themeRef = true;
+    return out;
+  }
+  const masked = mask(value);
+  if (prop === "font-family") {
+    if (masked.trim() && !/^(inherit|initial|unset)$/i.test(v)) hits.push({ category: "font-family", text: v, index: value.indexOf(v) });
+    return out;
+  }
+  if (prop === "box-shadow" || prop === "text-shadow") {
+    const numbers = masked.replace(/(?<![\w.])0(?![\w.%])/g, " ");
+    if (/\d/.test(numbers) || masked.search(COLOR_LITERAL_RE) >= 0) hits.push({ category: "shadow", text: v, index: value.indexOf(v) });
+    return out;
+  }
+  for (const m of masked.matchAll(COLOR_LITERAL_RE)) if (parseCssColor(m[0])) hits.push({ category: "color", text: m[0], index: m.index });
+  if (COLOR_PROP.test(prop) || prop.startsWith("--") || prop.startsWith("$")) {
+    for (const m of masked.matchAll(/(?<![\w#.-])([a-z]+)(?![\w(-])/gi)) {
+      const n = m[1].toLowerCase();
+      if (NAMED_COLORS[n] && !/^(transparent|currentcolor)$/.test(n)) hits.push({ category: "color", text: m[1], index: m.index });
+    }
+    if (prop.startsWith("--") && /^-?[\d.]+(deg)?\s+[\d.]+%\s+[\d.]+%/.test(v) && parseCssColor(v)) hits.push({ category: "color", text: v, index: value.indexOf(v) });
+  }
+  if (prop === "z-index") {
+    const n = /^-?\d+$/.test(v) ? Number(v) : NaN;
+    if (Number.isFinite(n) && Math.abs(n) > 1) hits.push({ category: "z-index", text: v, index: value.indexOf(v) });
+    return out;
+  }
+  if (prop === "font-weight") {
+    if (/^(\d{3}|bold|bolder|lighter)$/i.test(v)) hits.push({ category: "font-weight", text: v, index: value.indexOf(v) });
+    return out;
+  }
+  if (prop === "line-height" && /^\d*\.?\d+$/.test(v) && Number(v) !== 0) {
+    hits.push({ category: "line-height", text: v, index: value.indexOf(v) });
+    return out;
+  }
+  if (MOTION_PROP.test(prop)) {
+    for (const m of masked.matchAll(/(?<![\w.-])(\d*\.?\d+)(ms|s)\b/g)) if (Number(m[1]) !== 0) hits.push({ category: "duration", text: m[0], index: m.index });
+  }
+  if (EASING_PROP.test(prop)) {
+    for (const m of masked.matchAll(/cubic-bezier\([^)]*\)|(?<![\w-])(ease-in-out|ease-in|ease-out|ease|linear)(?![\w-])/g)) hits.push({ category: "easing", text: m[0], index: m.index });
+  }
+  const cat = lengthCategory(prop);
+  if (cat) {
+    for (const m of masked.matchAll(LENGTH_RE)) if (Number(m[1]) !== 0) hits.push({ category: cat, text: m[0].replace(/^-/, ""), index: m.index + (m[0].startsWith("-") ? 1 : 0) });
+  }
+  hits.sort((a, b) => a.index - b.index);
+  return out;
+}
+
+// ../core/src/layered.ts
+var aliasOf = (v) => isAlias(v) ? aliasTarget(v) : null;
+function globToRegExp(glob) {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*" && glob[i + 1] === "*") {
+      if (glob[i + 2] === "/") {
+        re += "(?:.*/)?";
+        i += 2;
+      } else {
+        re += ".*";
+        i += 1;
+      }
+    } else if (c === "*") re += "[^/]*";
+    else if (c === "?") re += "[^/]";
+    else re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  }
+  return new RegExp(`^${re}$`);
+}
+var comboKey = (c) => Object.entries(c).map(([k, v]) => `${k}=${v}`).join(",") || "default";
+function flattenLayerFile(json, file, issues) {
+  const out = [];
+  const walk2 = (node, path, inheritedType) => {
+    if (!node || typeof node !== "object" || Array.isArray(node)) return;
+    const n = node;
+    const type = typeof n.$type === "string" ? n.$type : inheritedType;
+    if ("$value" in n) {
+      out.push({
+        path: path.join("."),
+        ...type ? { type } : {},
+        value: n.$value,
+        ...typeof n.$description === "string" ? { description: n.$description } : {},
+        ...n.$extensions && typeof n.$extensions === "object" ? { extensions: n.$extensions } : {},
+        ...n.$deprecated !== void 0 ? { deprecated: n.$deprecated } : {},
+        file
+      });
+      return;
+    }
+    for (const [k, v] of Object.entries(n)) {
+      if (k.startsWith("$")) continue;
+      const p = [...path, k].join(".");
+      if (/[{}.]/.test(k)) issues.push({ level: "error", code: "invalid-name", message: `Name "${k}" contains {, } or . which DTCG forbids.`, path: p, file });
+      if (v && typeof v === "object" && !Array.isArray(v)) walk2(v, [...path, k], type);
+      else issues.push({ level: "error", code: "not-a-token", message: `"${p}" is neither a token (no $value) nor a group.`, path: p, file });
+    }
+  };
+  walk2(json, []);
+  return out;
+}
+var toHex2 = (n) => Math.round(Math.max(0, Math.min(1, n)) * 255).toString(16).padStart(2, "0");
+function compactJson(v) {
+  if (Array.isArray(v)) return `[${v.map(compactJson).join(", ")}]`;
+  if (v && typeof v === "object") {
+    const e = Object.entries(v);
+    return e.length ? `{ ${e.map(([k, x]) => `${JSON.stringify(k)}: ${compactJson(x)}`).join(", ")} }` : "{}";
+  }
+  return JSON.stringify(v);
+}
+function colorToCss(c) {
+  if (typeof c === "string") return c;
+  if (!c || typeof c !== "object") return String(c);
+  const o = c;
+  const [r, g, b] = (o.components ?? []).map((x) => typeof x === "number" ? x : 0);
+  const alpha = o.alpha ?? 1;
+  if (alpha < 1) return `rgb(${[r, g, b].map((x) => Math.round((x ?? 0) * 255)).join(" ")} / ${alpha})`;
+  return o.hex ?? `#${[r, g, b].map((x) => toHex2(x ?? 0)).join("")}`;
+}
+var dimToCss = (d) => d && typeof d === "object" && "value" in d ? `${d.value}${d.unit}` : String(d);
+function valueToCss(type, v, ext) {
+  if (v === void 0 || v === null) return "";
+  switch (type) {
+    case "color":
+      return colorToCss(v);
+    case "dimension":
+    case "duration":
+      return dimToCss(v);
+    case "cubicBezier":
+      return Array.isArray(v) ? `cubic-bezier(${v.join(", ")})` : String(v);
+    case "fontFamily":
+      return Array.isArray(v) ? v.map((n) => /\s/.test(String(n)) ? `"${n}"` : String(n)).join(", ") : String(v);
+    case "shadow": {
+      if (typeof v === "string") return v;
+      const layers = Array.isArray(v) ? v : [v];
+      return layers.map((l) => [l.inset ? "inset" : "", dimToCss(l.offsetX), dimToCss(l.offsetY), dimToCss(l.blur), dimToCss(l.spread ?? { value: 0, unit: "px" }), colorToCss(l.color)].filter(Boolean).join(" ")).join(", ");
+    }
+    default: {
+      const unit = ext?.["dev.bridge.unit"];
+      if (typeof v === "number" && typeof unit === "string") return `${v}${unit}`;
+      return typeof v === "object" ? compactJson(v) : String(v);
+    }
+  }
+}
+var LayeredTokenSet = class {
+  /** `files`: token file path relative to tokens.root -> file text. */
+  constructor(config, files) {
+    this.config = config;
+    this.files = files;
+    this.fileNames = [...files.keys()].sort();
+    for (const f of this.fileNames) {
+      let json;
+      try {
+        json = JSON.parse(files.get(f));
+      } catch (e) {
+        this.issues.push({ level: "error", code: "invalid-json", message: `Invalid JSON: ${e.message}`, file: f });
+        continue;
+      }
+      this.defs.push(...flattenLayerFile(json, f, this.issues));
+    }
+  }
+  config;
+  files;
+  defs = [];
+  issues = [];
+  fileNames;
+  views = /* @__PURE__ */ new Map();
+  get modeNames() {
+    return Object.keys(this.config.axes);
+  }
+  get defaultCombo() {
+    return Object.fromEntries(Object.entries(this.config.axes).map(([k, m]) => [k, m.default]));
+  }
+  /** Every combination of the given modes (all modes when omitted); other modes stay at default. */
+  combos(only) {
+    let out = [this.defaultCombo];
+    for (const [name, m] of Object.entries(this.config.axes)) {
+      if (only && !only.includes(name)) continue;
+      out = out.flatMap((c) => m.values.map((v) => ({ ...c, [name]: v })));
+    }
+    return out;
+  }
+  normalizeCombo(partial = {}) {
+    const c = { ...this.defaultCombo };
+    for (const [k, v] of Object.entries(partial)) {
+      if (v === void 0) continue;
+      const m = this.config.axes[k];
+      if (!m) throw new Error(`Unknown mode "${k}". Modes: ${this.modeNames.join(", ") || "none"}.`);
+      if (!m.values.includes(v)) throw new Error(`Unknown ${k} "${v}". Values: ${m.values.join(", ")}.`);
+      c[k] = v;
+    }
+    return c;
+  }
+  tierOfFile(file) {
+    for (const [tier, dirs] of Object.entries(this.config.tokens.tiers)) {
+      if (dirs.some((d) => file === d || file.startsWith(`${d.replace(/\/$/, "")}/`) || globToRegExp(d).test(file))) return tier;
+    }
+    return void 0;
+  }
+  /** Tier of a token: the lowest layer that defines it in the default mode (an override does not change its tier). */
+  tierOf(path) {
+    const d = this.view(this.defaultCombo).get(path)?.[0] ?? this.defs.find((x) => x.path === path);
+    return d ? this.tierOfFile(d.file) : void 0;
+  }
+  /** Files of each layer for a combo, in resolution order. */
+  layerFiles(combo) {
+    const files = [];
+    const missing = [];
+    for (const l of this.config.tokens.layers) {
+      const pattern = l.files.replace(/\{([^}]+)\}/g, (_, k) => combo[k] ?? `{${k}}`);
+      const re = globToRegExp(pattern);
+      const hit = this.fileNames.filter((f) => re.test(f));
+      if (!hit.length && !l.optional) missing.push(pattern);
+      for (const f of hit) if (!files.includes(f)) files.push(f);
+    }
+    return { files, missing };
+  }
+  /** path -> definitions in layer order (last one wins) for a combo. */
+  view(combo) {
+    const key = comboKey(combo);
+    let v = this.views.get(key);
+    if (!v) {
+      const { files, missing } = this.layerFiles(combo);
+      const map = /* @__PURE__ */ new Map();
+      const byFile = /* @__PURE__ */ new Map();
+      for (const d of this.defs) (byFile.get(d.file) ?? byFile.set(d.file, []).get(d.file)).push(d);
+      for (const f of files) for (const d of byFile.get(f) ?? []) (map.get(d.path) ?? map.set(d.path, []).get(d.path)).push(d);
+      v = { map, missing };
+      this.views.set(key, v);
+    }
+    return v.map;
+  }
+  missingLayers(combo) {
+    this.view(combo);
+    return this.views.get(comboKey(combo)).missing;
+  }
+  /** Every token path defined in any combo. */
+  allPaths() {
+    return [...new Set(this.defs.map((d) => d.path))].sort();
+  }
+  defsOf(path) {
+    return this.defs.filter((d) => d.path === path);
+  }
+  /** First combo whose layers include `file`, preferring the default. */
+  comboForFile(file) {
+    const all = [this.defaultCombo, ...this.combos()];
+    return all.find((c) => this.layerFiles(c).files.includes(file)) ?? this.defaultCombo;
+  }
+  resolve(path, combo) {
+    const view = this.view(combo);
+    const chain = [path];
+    const top = view.get(path);
+    if (!top) return { path, value: void 0, css: "", chain, definedIn: [], error: `"${path}" is not defined for ${comboKey(combo)}` };
+    const def = top[top.length - 1];
+    let type = def.type;
+    let error;
+    const deref = (target, stack) => {
+      if (stack.includes(target)) {
+        error = `circular alias: ${[...stack, target].join(" -> ")}`;
+        return void 0;
+      }
+      const t = view.get(target);
+      if (!t) {
+        error = `broken alias {${target}}`;
+        return void 0;
+      }
+      const td = t[t.length - 1];
+      type ??= td.type;
+      return walk2(td.value, [...stack, target]);
+    };
+    const walk2 = (v, stack) => {
+      const a = aliasOf(v);
+      if (a) return deref(a, stack);
+      if (Array.isArray(v)) return v.map((x) => walk2(x, stack));
+      if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, walk2(x, stack)]));
+      return v;
+    };
+    let cur = def.value;
+    const seen = /* @__PURE__ */ new Set([path]);
+    for (let a = aliasOf(cur); a; a = aliasOf(cur)) {
+      chain.push(a);
+      if (seen.has(a)) break;
+      seen.add(a);
+      const t = view.get(a);
+      if (!t) break;
+      cur = t[t.length - 1].value;
+    }
+    const value = walk2(def.value, [path]);
+    return { path, ...type ? { type } : {}, value, css: error ? "" : valueToCss(type, value, def.extensions), chain, definedIn: top.map((d) => d.file), ...error ? { error } : {} };
+  }
+  /** Tokens whose own value aliases `path` directly, across all files. */
+  referencedBy(path) {
+    const needle = `{${path}}`;
+    return this.defs.filter((d) => JSON.stringify(d.value).includes(needle)).map((d) => ({ path: d.path, file: d.file }));
+  }
+  cssVarName(path) {
+    return `${this.config.cssVar.prefix}${path.split(".").join(this.config.cssVar.separator)}`;
+  }
+  /** Repo-relative path of a token file. */
+  repoPath(file) {
+    const root = this.config.tokens.root;
+    return root === "." || !root ? file : `${root.replace(/\/$/, "")}/${file}`;
+  }
+};
+function selectTokenFiles(config, repoFiles) {
+  const root = config.tokens.root.replace(/\/$/, "");
+  const rel = (f) => root === "." || !root ? f : f.startsWith(`${root}/`) ? f.slice(root.length + 1) : null;
+  const inc = config.tokens.include.map(globToRegExp);
+  const exc = config.tokens.exclude.map(globToRegExp);
+  return repoFiles.filter((f) => f !== config.contrast?.path).map(rel).filter((f) => f !== null && inc.some((r) => r.test(f)) && !exc.some((r) => r.test(f)));
+}
+
+// ../core/src/audit/ds-index.ts
+var TIER_RANK_COLOR = { semantic: 0, base: 1, component: 2, brand: 3, density: 3, primitive: 4 };
+var TIER_RANK_SCALE = { semantic: 0, base: 0, brand: 1, density: 2, primitive: 3, component: 5 };
+var COLOR_HINTS = [
+  [/^(color|fill|stroke|-webkit-text-fill-color|caret-color|text-decoration(-color)?)$/, /(^|\.)(text|fg|icon|foreground|link)(\.|-|$)/],
+  [/background|bgcolor/, /(^|\.)(bg|surface|background|fill|solid|scrim|overlay)(\.|-|$)/],
+  [/border|outline|divider|column-rule/, /(^|\.)(border|outline|ring|divider|line|separator)(\.|-|$)/]
+];
+var PATH_FOR = {
+  spacing: /(^|\.)space(\.|$)/,
+  size: /(^|\.)size(\.|$)/,
+  radius: /(^|\.)radius(\.|$)|-radius$|\.radius$/,
+  "border-width": /border-width|border\.width|(^|\.)stroke(\.|$)/,
+  "font-size": /font\.size|font-size|text\.size/,
+  "line-height": /line-height|leading/,
+  duration: /duration/,
+  "z-index": /^(z|layer|z-index|zindex)\./,
+  "font-weight": /weight/
+};
+var toPx = (css) => {
+  const m = /^(-?\d*\.?\d+)(px|rem|em)?$/.exec(css.trim());
+  if (!m) return void 0;
+  return m[2] === "rem" || m[2] === "em" ? Number(m[1]) * 16 : Number(m[1]);
+};
+var toMs = (css) => {
+  const m = /^(\d*\.?\d+)(ms|s)$/.exec(css.trim());
+  return m ? m[2] === "s" ? Number(m[1]) * 1e3 : Number(m[1]) : void 0;
+};
+var EASE_KEYWORDS = { ease: [0.25, 0.1, 0.25, 1], "ease-in": [0.42, 0, 1, 1], "ease-out": [0, 0, 0.58, 1], "ease-in-out": [0.42, 0, 0.58, 1], linear: [0, 0, 1, 1] };
+var bezier = (css) => {
+  const k = EASE_KEYWORDS[css.trim()];
+  if (k) return k;
+  const m = /cubic-bezier\(([^)]*)\)/.exec(css);
+  const n = m?.[1].split(",").map(Number);
+  return n && n.length === 4 && n.every(Number.isFinite) ? n : void 0;
+};
+var WEIGHT_WORDS = { normal: 400, bold: 700, bolder: 700, lighter: 300 };
+var firstFamily = (css) => css.split(",")[0].trim().replace(/^["']|["']$/g, "").toLowerCase();
+var shadowNums = (css) => [...css.replace(/rgba?\([^)]*\)|#[0-9a-f]+|hsla?\([^)]*\)/gi, "").matchAll(/-?\d*\.?\d+/g)].map((m) => Number(m[0]));
+function level(conf) {
+  return conf >= 0.999 ? "exact" : conf >= 0.75 ? "high" : conf >= 0.5 ? "medium" : "low";
+}
+var round = (n, d = 2) => Math.round(n * 10 ** d) / 10 ** d;
+var DEFAULT_NATIVE_ELEMENTS = ["button", "input", "select", "textarea", "dialog", "table", "a", "img"];
+var DesignSystemIndex = class {
+  cssVars = /* @__PURE__ */ new Set();
+  packages;
+  components;
+  foreignLibraries;
+  nativeElements;
+  tokenCount;
+  modes;
+  colors = [];
+  byType = /* @__PURE__ */ new Map();
+  defaultCombo;
+  constructor(set, opts) {
+    this.packages = opts.packages;
+    this.components = new Set(opts.components);
+    this.foreignLibraries = opts.foreignLibraries ?? [];
+    this.nativeElements = opts.nativeElements ?? DEFAULT_NATIVE_ELEMENTS;
+    this.defaultCombo = set.defaultCombo;
+    this.modes = set.combos().map(comboKey);
+    const paths = set.allPaths();
+    this.tokenCount = paths.length;
+    const defKey = comboKey(this.defaultCombo);
+    const seenColor = /* @__PURE__ */ new Set();
+    for (const combo of set.combos()) {
+      const key = this.modeLabel(combo);
+      const isDefault = comboKey(combo) === defKey;
+      const view = set.view(combo);
+      for (const p of view.keys()) {
+        const r = set.resolve(p, combo);
+        if (r.error || !r.css) continue;
+        const base = { path: p, cssVar: set.cssVarName(p), type: r.type ?? "", tier: set.tierOf(p) ?? "primitive", css: r.css };
+        if (r.type === "color") {
+          const rgba = parseCssColor(r.css);
+          const id = `${p}|${r.css}`;
+          if (!rgba || seenColor.has(id)) continue;
+          seenColor.add(id);
+          this.colors.push({ ...base, rgba, ...key ? { combo: key } : {} });
+        } else if (isDefault) {
+          const list2 = this.byType.get(base.type) ?? [];
+          list2.push(base);
+          this.byType.set(base.type, list2);
+        }
+      }
+    }
+    for (const p of paths) this.cssVars.add(set.cssVarName(p));
+  }
+  modeLabel(combo) {
+    const diff = Object.entries(combo).filter(([k, v]) => this.defaultCombo[k] !== v);
+    return diff.length ? diff.map(([k, v]) => `${k}=${v}`).join(",") : void 0;
+  }
+  isDsVar(name) {
+    return this.cssVars.has(name);
+  }
+  isDsModule(mod) {
+    return this.packages.some((p) => mod === p || mod.startsWith(`${p}/`));
+  }
+  entries(types, pathRe) {
+    const all = types.flatMap((t) => this.byType.get(t) ?? []);
+    if (!pathRe) return all;
+    const narrowed = all.filter((e) => pathRe.test(e.path));
+    return narrowed.length ? narrowed : all;
+  }
+  make(e, distance, confidence) {
+    return { token: e.path, cssVar: e.cssVar, value: e.css, ...e.combo ? { mode: e.combo } : {}, distance: round(distance), confidence: round(confidence), level: level(confidence) };
+  }
+  /** Nearest color by deltaE OK across every mode; semantic tokens and tokens that fit the property win near-ties. */
+  suggestColor(value, property) {
+    const target = parseCssColor(value);
+    if (!target || !this.colors.length) return void 0;
+    const hint = COLOR_HINTS.find(([re]) => property && re.test(property))?.[1];
+    const scored = this.colors.map((e) => ({ e, d: deltaE(target, e.rgba) }));
+    const min = Math.min(...scored.map((s) => s.d));
+    const tolerance = min <= 0.5 ? 0.5 : min + 2;
+    const pick = scored.filter((s) => s.d <= Math.max(tolerance, min)).sort((a, b) => Number(hint ? !hint.test(a.e.path) : 0) - Number(hint ? !hint.test(b.e.path) : 0) || (TIER_RANK_COLOR[a.e.tier] ?? 5) - (TIER_RANK_COLOR[b.e.tier] ?? 5) || Number(Boolean(a.e.combo)) - Number(Boolean(b.e.combo)) || a.d - b.d)[0];
+    if (!pick || pick.d > 15) return void 0;
+    const conf = pick.d <= 0.5 ? 1 : pick.d <= 2 ? 0.85 : pick.d <= 5 ? 0.6 : 0.3;
+    return this.make(pick.e, pick.d, conf);
+  }
+  nearestNumber(cands, target, read, rank = TIER_RANK_SCALE) {
+    const scored = cands.map((e) => ({ e, n: read(e) })).filter((s) => s.n !== void 0).map((s) => ({ e: s.e, d: Math.abs(s.n - target) }));
+    if (!scored.length) return void 0;
+    const min = Math.min(...scored.map((s) => s.d));
+    return scored.filter((s) => s.d === min).sort((a, b) => (rank[a.e.tier] ?? 5) - (rank[b.e.tier] ?? 5) || a.e.path.length - b.e.path.length)[0];
+  }
+  ratioConfidence(d, target) {
+    if (d === 0) return 1;
+    const rel = d / Math.max(Math.abs(target), 1);
+    return d <= 1 || rel <= 0.05 ? 0.8 : rel <= 0.15 ? 0.55 : rel <= 0.4 ? 0.3 : 0;
+  }
+  /** Suggest a token for a hardcoded value of a category. Undefined when nothing is close. */
+  suggest(category, value, property) {
+    switch (category) {
+      case "color":
+        return this.suggestColor(value, property);
+      case "spacing":
+      case "size":
+      case "radius":
+      case "border-width":
+      case "font-size": {
+        const px = toPx(value);
+        if (px === void 0) return void 0;
+        const best = this.nearestNumber(this.entries(["dimension"], PATH_FOR[category]), Math.abs(px), (e) => toPx(e.css));
+        if (!best) return void 0;
+        let conf = this.ratioConfidence(best.d, px);
+        if (conf && /em$/.test(value) && !/rem$/.test(value)) conf = Math.min(conf, 0.55);
+        return conf ? this.make(best.e, best.d, conf) : void 0;
+      }
+      case "line-height": {
+        const n = Number(value);
+        if (!Number.isFinite(n)) return void 0;
+        const best = this.nearestNumber(this.entries(["number", "dimension"], PATH_FOR["line-height"]).filter((e) => PATH_FOR["line-height"].test(e.path)), n, (e) => Number(e.css));
+        if (!best) return void 0;
+        const conf = best.d < 1e-3 ? 1 : best.d <= 0.05 ? 0.8 : best.d <= 0.15 ? 0.5 : 0.25;
+        return this.make(best.e, best.d, conf);
+      }
+      case "duration": {
+        const ms = toMs(value);
+        if (ms === void 0) return void 0;
+        const cands = this.entries(["duration"]).filter((e) => toMs(e.css) !== 0 || ms === 0);
+        const best = this.nearestNumber(cands, ms, (e) => toMs(e.css));
+        const conf = best ? this.ratioConfidence(best.d, ms) || 0.25 : 0;
+        return best ? this.make(best.e, best.d, conf) : void 0;
+      }
+      case "easing": {
+        const target = bezier(value);
+        if (!target) return void 0;
+        const scored = this.entries(["cubicBezier"]).map((e) => ({ e, b: bezier(e.css) })).filter((s) => s.b).map((s) => ({ e: s.e, d: s.b.reduce((acc, x, i) => acc + Math.abs(x - target[i]), 0) })).sort((a, b) => a.d - b.d || (TIER_RANK_SCALE[a.e.tier] ?? 5) - (TIER_RANK_SCALE[b.e.tier] ?? 5));
+        const best = scored.find((s) => s.d === scored[0].d && /motion/.test(s.e.path)) ?? scored[0];
+        if (!best) return void 0;
+        return this.make(best.e, best.d, best.d < 0.011 ? 1 : best.d <= 0.3 ? 0.55 : 0.3);
+      }
+      case "z-index": {
+        const n = Number(value);
+        const cands = [...this.entries(["number"]), ...this.entries([""])].filter((e) => PATH_FOR["z-index"].test(e.path));
+        const best = this.nearestNumber(cands, n, (e) => Number(e.css));
+        if (!best) return void 0;
+        return this.make(best.e, best.d, best.d === 0 ? 1 : best.d <= 10 ? 0.5 : 0.25);
+      }
+      case "font-weight": {
+        const n = WEIGHT_WORDS[value.toLowerCase()] ?? Number(value);
+        if (!Number.isFinite(n)) return void 0;
+        const cands = [...this.entries(["fontWeight"]), ...this.entries(["number"])].filter((e) => PATH_FOR["font-weight"].test(e.path));
+        const best = this.nearestNumber(cands, n, (e) => Number(e.css));
+        if (!best) return void 0;
+        const conf = best.d === 0 ? String(n) === value ? 1 : 0.9 : best.d <= 100 ? 0.6 : 0.3;
+        return this.make(best.e, best.d / 100, conf);
+      }
+      case "font-family": {
+        const fam = firstFamily(value);
+        const cands = this.entries(["fontFamily"]);
+        const exact = cands.filter((e) => firstFamily(e.css) === fam).sort((a, b) => (TIER_RANK_SCALE[a.tier] ?? 5) - (TIER_RANK_SCALE[b.tier] ?? 5))[0];
+        if (exact) return this.make(exact, 0, value.replace(/\s/g, "") === exact.css.replace(/\s/g, "") ? 1 : 0.9);
+        const mono = /mono|courier|consol|menlo/.test(value.toLowerCase());
+        const generic = cands.filter((e) => mono ? /mono/.test(e.path) : /sans/.test(e.path)).sort((a, b) => (TIER_RANK_SCALE[a.tier] ?? 5) - (TIER_RANK_SCALE[b.tier] ?? 5))[0];
+        return generic ? this.make(generic, 1, 0.3) : void 0;
+      }
+      case "shadow": {
+        const norm = (s) => s.replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").trim().toLowerCase();
+        const cands = this.entries(["shadow"]);
+        const exact = cands.find((e) => norm(e.css) === norm(value));
+        if (exact) return this.make(exact, 0, 1);
+        const t = shadowNums(value);
+        const scored = cands.map((e) => {
+          const n = shadowNums(e.css);
+          const len = Math.max(n.length, t.length);
+          let d = 0;
+          for (let i = 0; i < len; i++) d += Math.abs((n[i] ?? 0) - (t[i] ?? 0));
+          return { e, d };
+        }).sort((a, b) => a.d - b.d || Number(!/elevation/.test(a.e.path)) - Number(!/elevation/.test(b.e.path)));
+        const best = scored[0];
+        if (!best) return void 0;
+        return this.make(best.e, best.d, best.d <= 2 ? 0.75 : best.d <= 8 ? 0.5 : 0.25);
+      }
+    }
+  }
+  /** Same value as the token (safe to replace): exact level and, for lengths, the same unit. */
+  static isExact(s) {
+    return Boolean(s && s.level === "exact");
+  }
+};
+
+// ../core/src/audit/report.ts
+function isSafeFix(h, s) {
+  if (!s || s.level !== "exact") return false;
+  switch (h.category) {
+    case "color": {
+      const a = parseCssColor(h.text);
+      const b = parseCssColor(s.value);
+      return Boolean(a && b && s.distance <= 0.5 && Math.abs(a.a - b.a) < 0.01);
+    }
+    case "spacing":
+    case "size":
+    case "radius":
+    case "border-width":
+    case "font-size":
+    case "duration":
+    case "z-index":
+    case "font-weight":
+    case "line-height":
+      return h.text.trim() === s.value.trim();
+    case "shadow":
+      return s.distance === 0;
+    default:
+      return false;
+  }
+}
+
+// ../core/src/previews.ts
+var PREVIEW_APP_LABELS = { docs: "Docs", storybook: "Storybook", admin: "Admin demo" };
+
+// ../core/src/teams.ts
+var LOGIN = /^[A-Za-z0-9](?:[A-Za-z0-9]|-(?=[A-Za-z0-9])){0,38}$/;
+var SLUG = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+function parseOwnerEntry(raw) {
+  if (typeof raw !== "string") return null;
+  const s = raw.trim().replace(/^@/, "");
+  const slash = s.indexOf("/");
+  if (slash < 0) return LOGIN.test(s) ? { kind: "person", login: s } : null;
+  const org = s.slice(0, slash);
+  const slug = s.slice(slash + 1);
+  return LOGIN.test(org) && SLUG.test(slug) ? { kind: "team", org, slug } : null;
+}
+function ownerEntryProblems(raw) {
+  if (raw === void 0) return [];
+  const isObj2 = (x) => Boolean(x) && typeof x === "object" && !Array.isArray(x);
+  if (!isObj2(raw)) return ['"governance.owners" must be { "design": [people or teams], "tech": [people or teams] }'];
+  const out = [];
+  for (const [k, v] of Object.entries(raw)) {
+    if (k !== "design" && k !== "tech") {
+      out.push(`"governance.owners.${k}" is not an owner group (design, tech)`);
+      continue;
+    }
+    if (!Array.isArray(v)) {
+      out.push(`"governance.owners.${k}" must be a list of people or teams`);
+      continue;
+    }
+    v.forEach((x, i) => {
+      if (typeof x !== "string" || !parseOwnerEntry(x))
+        out.push(`"governance.owners.${k}[${i}]" (${JSON.stringify(x)}) is not a GitHub login or team. Write a person as "peterbono" or "@peterbono", a team as "@org/team-slug".`);
+    });
+  }
+  return out;
+}
+
+// ../core/src/rights.ts
+var OWNER_GROUPS = ["design", "tech"];
+var RIGHTS = ["approveDesign", "approveTech", "ship"];
+var DEFAULT_RIGHTS = { approveDesign: ["design"], approveTech: ["tech"], ship: ["tech"] };
+function normalizeRights(input) {
+  const pick = (r) => {
+    const v = input?.[r];
+    if (!Array.isArray(v)) return [...DEFAULT_RIGHTS[r]];
+    return OWNER_GROUPS.filter((g) => v.includes(g));
+  };
+  return { approveDesign: pick("approveDesign"), approveTech: pick("approveTech"), ship: pick("ship") };
+}
+function rightsProblems(raw) {
+  if (raw === void 0) return [];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return ['"governance.rights" must be { "approveDesign": [groups], "approveTech": [groups], "ship": [groups] }'];
+  const out = [];
+  for (const [k, v] of Object.entries(raw)) {
+    if (!RIGHTS.includes(k)) out.push(`"governance.rights.${k}" is not a right (${RIGHTS.join(", ")})`);
+    else if (!Array.isArray(v) || v.length === 0 || !v.every((g) => OWNER_GROUPS.includes(g)))
+      out.push(`"governance.rights.${k}" must list one or more of "design", "tech"`);
+  }
+  return out;
+}
+function visualImpactProblems(raw) {
+  if (raw === void 0) return [];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return ['"visualImpact" must be { "mode": "auto" | "on-demand" }'];
+  const out = [];
+  for (const [k, v] of Object.entries(raw)) {
+    if (k !== "mode") out.push(`"visualImpact.${k}" is not a setting (mode)`);
+    else if (v !== "auto" && v !== "on-demand") out.push('"visualImpact.mode" must be "auto" or "on-demand"');
+  }
+  return out;
+}
+
+// ../core/src/config.ts
+var CONFIG_FILE = "bridge.config.json";
+var DEFAULT_OVERRIDE = { allowed: [], requireReason: true, minReasonLength: 20 };
+var DEFAULT_TOKEN_PATHS = {
+  root: "tokens",
+  primitives: "primitives",
+  brands: "brands",
+  semantic: "semantic",
+  base: "base",
+  density: "density",
+  components: "components",
+  contrastChecks: "contrast.checks.json"
+};
+var DEFAULT_GOVERNANCE = {
+  protectedBranches: ["main", "master"],
+  branchPrefix: "bridge/",
+  labels: ["source: mcp"],
+  guardrails: ["AGENTS.md", "CLAUDE.md", "docs/GOVERNANCE.md", ".stylelintrc.json", ".github/", CONFIG_FILE],
+  owners: { design: [], tech: [] }
+};
+var FLAT_TOKEN_KEYS = ["primitives", "brands", "semantic", "base", "density", "components", "contrastChecks"];
+var CANONICAL_TOKEN_KEYS = ["root", "include", "exclude", "tiers", "layers"];
+var FLAT_MODE_KEYS = ["brands", "themes", "densities", "defaults"];
+var AXIS_OF = { brands: "brand", themes: "theme", densities: "density" };
+var ConfigError = class extends Error {
+  constructor(problems) {
+    super(`${CONFIG_FILE} is invalid: ${problems.join("; ")}`);
+    this.problems = problems;
+    this.name = "ConfigError";
+  }
+  problems;
+};
+var trimSlashes = (p) => p.trim().replace(/^\.?\/+|\/+$/g, "");
+var list = (v) => v === void 0 ? [] : Array.isArray(v) ? v : [v];
+var isFlatModes = (m) => Object.keys(m).some((k) => FLAT_MODE_KEYS.includes(k)) || Object.keys(m).length === 0;
+function parseRepoInput(repo, branch) {
+  if (!repo) return void 0;
+  if (typeof repo === "string") {
+    const [owner, name] = repo.split("/");
+    return { owner, name, defaultBranch: branch ?? "main" };
+  }
+  return { owner: repo.owner, name: repo.name, defaultBranch: repo.defaultBranch ?? branch ?? "main" };
+}
+function conventionalLayers(p) {
+  return [
+    { files: `${p.primitives}/*.tokens.json`, optional: false },
+    { files: `${p.semantic}/${p.base}.tokens.json`, optional: true },
+    { files: `${p.brands}/{brand}.tokens.json`, optional: false },
+    { files: `${p.semantic}/{theme}.tokens.json`, optional: false },
+    { files: `${p.brands}/{brand}.{theme}.tokens.json`, optional: true },
+    { files: `${p.density}/{density}.tokens.json`, optional: false },
+    { files: `${p.components}/*.tokens.json`, optional: false }
+  ];
+}
+function defineConfig(input) {
+  const t = input.tokens ?? {};
+  const root = trimSlashes(t.root ?? DEFAULT_TOKEN_PATHS.root) || ".";
+  const tiersIn = t.tiers ? Object.fromEntries(Object.entries(t.tiers).map(([k, v]) => [k, list(v).map(trimSlashes)])) : void 0;
+  const firstDir = (tier) => tiersIn?.[tier]?.find((d) => !d.endsWith(".json"));
+  const baseFile = tiersIn?.base?.find((d) => d.endsWith(".json"));
+  const contrastPath = input.contrast?.path ? trimSlashes(input.contrast.path) : void 0;
+  const underRoot = (p) => root === "." ? p : p.startsWith(`${root}/`) ? p.slice(root.length + 1) : void 0;
+  const paths = {
+    root,
+    primitives: trimSlashes(t.primitives ?? firstDir("primitive") ?? DEFAULT_TOKEN_PATHS.primitives),
+    brands: trimSlashes(t.brands ?? firstDir("brand") ?? DEFAULT_TOKEN_PATHS.brands),
+    semantic: trimSlashes(t.semantic ?? firstDir("semantic") ?? DEFAULT_TOKEN_PATHS.semantic),
+    base: trimSlashes(t.base ?? (baseFile ? baseFile.split("/").pop().replace(/(\.tokens)?\.json$/, "") : DEFAULT_TOKEN_PATHS.base)),
+    density: trimSlashes(t.density ?? firstDir("density") ?? DEFAULT_TOKEN_PATHS.density),
+    components: trimSlashes(t.components ?? firstDir("component") ?? DEFAULT_TOKEN_PATHS.components),
+    contrastChecks: trimSlashes(t.contrastChecks ?? (contrastPath ? underRoot(contrastPath) ?? contrastPath : DEFAULT_TOKEN_PATHS.contrastChecks))
+  };
+  const tiers = tiersIn ?? {
+    primitive: [paths.primitives],
+    brand: [paths.brands],
+    base: [`${paths.semantic}/${paths.base}.tokens.json`],
+    semantic: [paths.semantic],
+    density: [paths.density],
+    component: [paths.components]
+  };
+  const layers = t.layers?.length ? t.layers.map((l) => typeof l === "string" ? { files: l, optional: false } : { files: l.files, optional: l.optional ?? false }) : conventionalLayers(paths);
+  const axes = {};
+  const m = input.modes ?? {};
+  if (isFlatModes(m)) {
+    for (const key of ["brands", "themes", "densities"]) {
+      const values = m[key] ?? [];
+      if (!values.length) continue;
+      const axis = AXIS_OF[key];
+      const def = m.defaults?.[axis] ?? values[0];
+      axes[axis] = { values, default: def, parity: axis === "theme" };
+    }
+  } else {
+    for (const [name, a] of Object.entries(m)) axes[name] = { values: a.values, default: a.default ?? a.values[0], parity: a.parity ?? false };
+  }
+  const ordered = (axis) => {
+    const a = axes[axis];
+    return a ? [a.default, ...a.values.filter((v) => v !== a.default)] : [];
+  };
+  const modes = {
+    brands: ordered("brand"),
+    themes: ordered("theme"),
+    densities: ordered("density"),
+    defaults: { brand: axes.brand?.default, theme: axes.theme?.default, density: axes.density?.default }
+  };
+  const pkg = input.changesets?.package ?? input.changeset?.package;
+  const g = input.governance ?? {};
+  const contrastFile = contrastPath ?? [root === "." ? "" : root, paths.contrastChecks].filter(Boolean).join("/");
+  return {
+    repo: parseRepoInput(input.repo, input.branch),
+    tokens: { ...paths, include: input.tokens?.include ?? ["**/*.tokens.json"], exclude: input.tokens?.exclude ?? [], tiers, layers },
+    axes,
+    modes,
+    contrast: { path: contrastFile, modes: input.contrast?.modes },
+    components: input.components ? {
+      dir: trimSlashes(input.components.dir),
+      docsSuffix: input.components.docsSuffix ?? ".docs.json",
+      styleSuffix: input.components.styleSuffix ?? ".module.css",
+      reference: input.components.reference,
+      index: input.components.index,
+      specs: input.components.specs
+    } : void 0,
+    docs: { ...input.docs },
+    changesets: pkg ? { dir: trimSlashes(input.changesets?.dir ?? ".changeset"), package: pkg } : void 0,
+    changeset: pkg ? { package: pkg } : void 0,
+    cssVar: { prefix: input.cssVar?.prefix ?? "--", separator: input.cssVar?.separator ?? "-" },
+    governance: {
+      protectedBranches: g.protectedBranches ?? DEFAULT_GOVERNANCE.protectedBranches,
+      branchPrefix: g.branchPrefix ?? DEFAULT_GOVERNANCE.branchPrefix,
+      labels: g.labels ?? DEFAULT_GOVERNANCE.labels,
+      guardrails: g.guardrails ?? [...DEFAULT_GOVERNANCE.guardrails, contrastFile],
+      owners: { design: g.owners?.design ?? [], tech: g.owners?.tech ?? [] },
+      ...g.override ? {
+        override: {
+          allowed: g.override.allowed ?? DEFAULT_OVERRIDE.allowed,
+          requireReason: g.override.requireReason ?? DEFAULT_OVERRIDE.requireReason,
+          minReasonLength: g.override.minReasonLength ?? DEFAULT_OVERRIDE.minReasonLength
+        }
+      } : {},
+      ...g.rights ? { rights: normalizeRights(g.rights) } : {}
+    },
+    ...input.audit ? { audit: { ...input.audit } } : {},
+    ...input.visualImpact ? { visualImpact: { mode: input.visualImpact.mode === "on-demand" ? "on-demand" : "auto" } } : {},
+    ...input.integrations ? { integrations: { ...input.integrations } } : {},
+    ...input.previews ? {
+      previews: {
+        packages: input.previews.packages ?? [],
+        apps: { ...input.previews.apps },
+        ...input.previews.production ? { production: { ...input.previews.production } } : {}
+      }
+    } : {}
+  };
+}
+var isStr = (x) => typeof x === "string" && x.trim().length > 0;
+var isStrList = (x) => Array.isArray(x) && x.every(isStr);
+var isObj = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+function loadConfig(source) {
+  let data = source;
+  if (typeof source === "string") {
+    try {
+      data = JSON.parse(source);
+    } catch (err) {
+      throw new ConfigError([`not valid JSON (${err.message})`]);
+    }
+  }
+  if (!isObj(data)) throw new ConfigError(["top level must be an object"]);
+  const problems = [];
+  const d = data;
+  const repo = d.repo;
+  if (typeof repo === "string") {
+    if (!/^[\w.-]+\/[\w.-]+$/.test(repo)) problems.push('"repo" must be "owner/name" or { "owner", "name" }');
+  } else if (repo !== void 0) {
+    if (!isObj(repo)) problems.push('"repo" must be "owner/name" or { "owner", "name" }');
+    else {
+      if (!isStr(repo.owner)) problems.push('"repo.owner" must be a non-empty string');
+      if (!isStr(repo.name)) problems.push('"repo.name" must be a non-empty string');
+      if (repo.defaultBranch !== void 0 && !isStr(repo.defaultBranch)) problems.push('"repo.defaultBranch" must be a non-empty string');
+    }
+  }
+  if (d.branch !== void 0 && !isStr(d.branch)) problems.push('"branch" must be a non-empty string');
+  const tokens = d.tokens;
+  if (tokens !== void 0) {
+    if (!isObj(tokens)) problems.push('"tokens" must be an object');
+    else
+      for (const [k, v] of Object.entries(tokens)) {
+        if (FLAT_TOKEN_KEYS.includes(k) || k === "root") {
+          if (!isStr(v)) problems.push(`"tokens.${k}" must be a non-empty string`);
+        } else if (k === "include" || k === "exclude") {
+          if (!isStrList(v)) problems.push(`"tokens.${k}" must be a list of globs`);
+        } else if (k === "tiers") {
+          if (!isObj(v) || !Object.values(v).every((x) => isStr(x) || isStrList(x))) problems.push('"tokens.tiers" must map tier names to directories');
+        } else if (k === "layers") {
+          if (!Array.isArray(v) || !v.length || !v.every((l) => isStr(l) || isObj(l) && isStr(l.files) && (l.optional === void 0 || typeof l.optional === "boolean")))
+            problems.push('"tokens.layers" must be a non-empty list of { "files", "optional"? }');
+        } else if (!CANONICAL_TOKEN_KEYS.includes(k)) problems.push(`"tokens.${k}" is not a known key`);
+      }
+  }
+  const modes = d.modes;
+  let axisNames = [];
+  if (modes !== void 0) {
+    if (!isObj(modes)) problems.push('"modes" must be an object');
+    else if (isFlatModes(modes)) {
+      for (const k of ["brands", "themes", "densities"]) {
+        if (modes[k] !== void 0 && !isStrList(modes[k])) problems.push(`"modes.${k}" must be a list of names`);
+      }
+      const defs = modes.defaults;
+      const lists = { brand: "brands", theme: "themes", density: "densities" };
+      for (const [k, l] of Object.entries(lists)) {
+        const v = defs?.[k];
+        if (v === void 0) continue;
+        if (!isStr(v)) problems.push(`"modes.defaults.${k}" must be a string`);
+        else if (isStrList(modes[l]) && !modes[l].includes(v)) problems.push(`"modes.defaults.${k}" ("${v}") is not in "modes.${l}"`);
+      }
+      axisNames = Object.entries(lists).filter(([, l]) => isStrList(modes[l]) && modes[l].length).map(([k]) => k);
+    } else {
+      for (const [name, a] of Object.entries(modes)) {
+        if (!isObj(a) || !isStrList(a.values) || !a.values.length) {
+          problems.push(`"modes.${name}.values" must be a non-empty list of names`);
+          continue;
+        }
+        if (a.default !== void 0 && (!isStr(a.default) || !a.values.includes(a.default))) problems.push(`"modes.${name}.default" ("${String(a.default)}") is not in "modes.${name}.values"`);
+        if (a.parity !== void 0 && typeof a.parity !== "boolean") problems.push(`"modes.${name}.parity" must be true or false`);
+        axisNames.push(name);
+      }
+    }
+  }
+  if (isObj(tokens) && Array.isArray(tokens.layers)) {
+    for (const l of tokens.layers) {
+      const files = typeof l === "string" ? l : isObj(l) ? String(l.files) : "";
+      for (const ph of files.match(/\{([^}]+)\}/g) ?? []) {
+        if (!axisNames.includes(ph.slice(1, -1))) problems.push(`layer "${files}" uses ${ph} but "modes.${ph.slice(1, -1)}" is not defined`);
+      }
+    }
+  }
+  const contrast = d.contrast;
+  if (contrast !== void 0 && (!isObj(contrast) || !isStr(contrast.path) || contrast.modes !== void 0 && !isStrList(contrast.modes)))
+    problems.push('"contrast" must be { "path", "modes"? }');
+  const comps = d.components;
+  if (comps !== void 0 && (!isObj(comps) || !isStr(comps.dir))) problems.push('"components.dir" must be a non-empty string');
+  const cs = d.changeset;
+  if (cs !== void 0 && (!isObj(cs) || !isStr(cs.package))) problems.push('"changeset.package" must be a non-empty string');
+  const css = d.changesets;
+  if (css !== void 0 && (!isObj(css) || !isStr(css.package))) problems.push('"changesets.package" must be a non-empty string');
+  const gov = d.governance;
+  if (gov !== void 0) {
+    if (!isObj(gov)) problems.push('"governance" must be an object');
+    else {
+      for (const k of ["protectedBranches", "labels", "guardrails"]) if (gov[k] !== void 0 && !(Array.isArray(gov[k]) && gov[k].every((x) => typeof x === "string"))) problems.push(`"governance.${k}" must be a list of strings`);
+      if (gov.branchPrefix !== void 0 && !isStr(gov.branchPrefix)) problems.push('"governance.branchPrefix" must be a non-empty string');
+      problems.push(...ownerEntryProblems(gov.owners));
+      const ov = gov.override;
+      if (ov !== void 0) {
+        if (!isObj(ov)) problems.push('"governance.override" must be an object');
+        else {
+          if (ov.allowed !== void 0 && !isStrList(ov.allowed)) problems.push('"governance.override.allowed" must be a list of GitHub logins');
+          if (ov.requireReason !== void 0 && typeof ov.requireReason !== "boolean") problems.push('"governance.override.requireReason" must be true or false');
+          if (ov.minReasonLength !== void 0 && !(Number.isInteger(ov.minReasonLength) && ov.minReasonLength >= 0)) problems.push('"governance.override.minReasonLength" must be a whole number, 0 or more');
+        }
+      }
+      problems.push(...rightsProblems(gov.rights));
+    }
+  }
+  problems.push(...visualImpactProblems(d.visualImpact));
+  const audit = d.audit;
+  if (audit !== void 0) {
+    if (!isObj(audit)) problems.push('"audit" must be an object');
+    else for (const k of ["packages", "foreignLibraries", "nativeElements", "exclude"]) if (audit[k] !== void 0 && !isStrList(audit[k])) problems.push(`"audit.${k}" must be a list of strings`);
+  }
+  const pv = d.previews;
+  if (pv !== void 0) {
+    if (!isObj(pv)) problems.push('"previews" must be an object');
+    else {
+      if (pv.packages !== void 0 && !isStrList(pv.packages)) problems.push('"previews.packages" must be a list of package names');
+      for (const field of ["apps", "production"]) {
+        const apps = pv[field];
+        if (apps === void 0) continue;
+        if (!isObj(apps)) {
+          problems.push(`"previews.${field}" must be an object`);
+          continue;
+        }
+        for (const [k, v] of Object.entries(apps)) {
+          if (!(k in PREVIEW_APP_LABELS)) problems.push(`"previews.${field}.${k}" is not a known app (${Object.keys(PREVIEW_APP_LABELS).join(", ")})`);
+          else if (!isStr(v) || !/^https?:\/\//.test(v)) problems.push(`"previews.${field}.${k}" must be an http(s) URL${field === "apps" ? " template" : ""}`);
+          else if (field === "production" && /\{\w+\}/.test(v)) problems.push(`"previews.production.${k}" is a fixed URL: placeholders such as {branch} belong in "previews.apps"`);
+        }
+      }
+    }
+  }
+  if (problems.length) throw new ConfigError(problems);
+  return defineConfig(d);
+}
+
+// ../core/src/node/audit.ts
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+var toPosix = (p) => p.split(sep).join("/");
+function walk(dir, root, out, skipDirs) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    const abs = join(dir, name);
+    let st;
+    try {
+      st = statSync(abs);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) {
+      if (!skipDirs.includes(name)) walk(abs, root, out, skipDirs);
+    } else out.push(toPosix(relative(root, abs)));
+  }
+}
+function findDesignSystemRoot(from) {
+  let dir = resolve(from);
+  for (; ; ) {
+    if (existsSync(join(dir, "bridge.config.json"))) return dir;
+    const up = dirname(dir);
+    if (up === dir) return void 0;
+    dir = up;
+  }
+}
+var cache = /* @__PURE__ */ new Map();
+function loadDesignSystem(root, opts = {}) {
+  const abs = resolve(root);
+  const hit = cache.get(abs);
+  if (hit && !opts.fresh) return hit;
+  const cfgPath = join(abs, "bridge.config.json");
+  if (!existsSync(cfgPath)) throw new Error(`No bridge.config.json in ${abs}: pass the design system repo (--ds <dir>) or run bridge init there.`);
+  const config = loadConfig(readFileSync(cfgPath, "utf8"));
+  const tokensRoot = config.tokens.root.replace(/\/$/, "");
+  const listed = [];
+  walk(join(abs, tokensRoot === "." ? "" : tokensRoot), abs, listed, ["node_modules", ".git", "dist"]);
+  const files = /* @__PURE__ */ new Map();
+  for (const f of selectTokenFiles(config, listed)) files.set(f, readFileSync(join(abs, tokensRoot === "." ? "" : tokensRoot, f), "utf8"));
+  const set = new LayeredTokenSet(config, files);
+  const components = [];
+  let packages = config.audit?.packages;
+  if (config.components) {
+    const dir = join(abs, config.components.dir);
+    if (existsSync(dir)) {
+      for (const name of readdirSync(dir)) if (/^[A-Z][A-Za-z0-9]*$/.test(name) && statSync(join(dir, name)).isDirectory()) components.push(name);
+    }
+    if (!packages) {
+      packages = ["@bridge-ds/react"];
+      for (let d = dir; d.startsWith(abs) && d !== abs; d = dirname(d)) {
+        const pj = join(d, "package.json");
+        if (existsSync(pj)) {
+          const name = JSON.parse(readFileSync(pj, "utf8")).name;
+          if (name && !packages.includes(name)) packages.unshift(name);
+          break;
+        }
+      }
+    }
+  }
+  const index = new DesignSystemIndex(set, {
+    packages: packages ?? ["@bridge-ds/react"],
+    components: components.sort(),
+    ...config.audit?.foreignLibraries ? { foreignLibraries: config.audit.foreignLibraries } : {},
+    ...config.audit?.nativeElements ? { nativeElements: config.audit.nativeElements } : {}
+  });
+  const loaded = { root: abs, config, set, index };
+  cache.set(abs, loaded);
+  return loaded;
+}
+
+// src/index.ts
+var {
+  createPlugin,
+  utils: { report, ruleMessages, validateOptions }
+} = stylelint;
+var ruleName = "bridge/use-tokens";
+var messages = ruleMessages(ruleName, {
+  rejected: (value, category, token, tokenValue, level2) => level2 === "exact" ? `Use var(${token}) instead of ${value}: it is the same ${category} (${tokenValue}).` : `Use a token instead of the raw ${category} ${value}: closest is var(${token}) (${tokenValue}, ${level2} match).`
+});
+var meta = { url: "https://github.com/peterbono/ai-design-system-demo/tree/main/packages/stylelint-plugin#bridgeuse-tokens", fixable: true };
+var RANK = { exact: 3, high: 2, medium: 1, low: 0 };
+var isString = (x) => typeof x === "string";
+var rule = (primary, secondary) => (root, result) => {
+  const valid = validateOptions(
+    result,
+    ruleName,
+    { actual: primary, possible: [true, false] },
+    { actual: secondary, possible: { designSystem: [isString], minConfidence: ["exact", "high", "medium", "low"], categories: [isString], ignoreProperties: [isString] }, optional: true }
+  );
+  if (!valid || !primary) return;
+  const dsRoot = secondary?.designSystem ?? process.env.BRIDGE_DS ?? findDesignSystemRoot(root.source?.input.file ?? process.cwd()) ?? findDesignSystemRoot(process.cwd());
+  let ds;
+  try {
+    if (!dsRoot) throw new Error("no bridge.config.json found");
+    ds = loadDesignSystem(dsRoot).index;
+  } catch (e) {
+    result.warn(`${ruleName}: ${e.message}. Set the "designSystem" option to your design system repo.`, { stylelintType: "invalidOption" });
+    return;
+  }
+  const min = RANK[secondary?.minConfidence ?? "medium"];
+  const ignore = (secondary?.ignoreProperties ?? []).map((p) => p.startsWith("/") && p.lastIndexOf("/") > 0 ? new RegExp(p.slice(1, p.lastIndexOf("/")), p.slice(p.lastIndexOf("/") + 1)) : new RegExp(`^${p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`));
+  root.walkDecls((decl) => {
+    if (ignore.some((r) => r.test(decl.prop))) return;
+    const scan = scanCssValue(decl.prop, decl.value);
+    const found = scan.hits.filter((hit) => !secondary?.categories || secondary.categories.includes(hit.category)).map((hit) => ({ hit, s: ds.suggest(hit.category, hit.text, decl.prop.toLowerCase()) })).filter((x) => Boolean(x.s) && RANK[x.s.level] >= min);
+    const safe = found.filter((x) => isSafeFix(x.hit, x.s));
+    let fixed = false;
+    const fix = () => {
+      if (fixed) return;
+      fixed = true;
+      let v = decl.value;
+      for (const { hit, s } of [...safe].sort((a, b) => b.hit.index - a.hit.index)) v = v.slice(0, hit.index) + `var(${s.cssVar})` + v.slice(hit.index + hit.text.length);
+      decl.value = v;
+    };
+    const offset = decl.prop.length + (decl.raws.between?.length ?? 1);
+    for (const x of found) {
+      report({
+        result,
+        ruleName,
+        message: messages.rejected(x.hit.text, x.hit.category, x.s.cssVar, x.s.value, x.s.level),
+        node: decl,
+        index: offset + x.hit.index,
+        endIndex: offset + x.hit.index + x.hit.text.length,
+        ...safe.includes(x) ? { fix } : {}
+      });
+    }
+  });
+};
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+var plugin = createPlugin(ruleName, rule);
+var index_default = plugin;
+export {
+  index_default as default,
+  messages,
+  ruleName
+};