@bridge-ds/core 0.7.0 → 0.9.0

package/dist/{component-spec-1z2ih4E3.js → pr-composer-D2SZm7cg.js}

@@ -1,4 +1,476 @@
-import { a as collectRefs, i as isAlias, b as aliasTarget, h as hexToRgba, p as parseColor, v as valuesEqual, f as formatValue, L as LayeredTokenSet, d as aliasOf, r as rgbaToDtcg, c as comboKey, e as rgbaToHex, g as globToRegExp, j as validateLayered } from "./layered-BnbmToGs.js";
+const ALIAS_RE = /^\{([^{}]+)\}$/;
+const isAlias = (v) => typeof v === "string" && ALIAS_RE.test(v);
+const aliasTarget = (v) => ALIAS_RE.exec(v)?.[1] ?? v;
+const toAlias = (path) => `{${path}}`;
+function collectRefs(value, out = []) {
+  if (isAlias(value)) out.push(aliasTarget(value));
+  else if (Array.isArray(value)) value.forEach((v) => collectRefs(v, out));
+  else if (value && typeof value === "object") Object.values(value).forEach((v) => collectRefs(v, out));
+  return out;
+}
+const clamp01 = (n) => Math.min(1, Math.max(0, n));
+const round = (n, digits) => {
+  const f = 10 ** digits;
+  return Math.round(n * f) / f;
+};
+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 };
+}
+const to255 = (n) => Math.round(clamp01(n) * 255);
+const rgbaToHex = (c) => "#" + [c.r, c.g, c.b].map((x) => to255(x).toString(16).padStart(2, "0")).join("");
+function parseColor(value) {
+  if (typeof value === "string") return isAlias(value) ? void 0 : hexToRgba(value);
+  if (!value || typeof value !== "object") return void 0;
+  const v = value;
+  const alpha = typeof v.alpha === "number" ? v.alpha : 1;
+  if (v.colorSpace === "srgb" && Array.isArray(v.components) && v.components.length === 3) {
+    const [r, g, b] = v.components;
+    if ([r, g, b].every((x) => typeof x === "number")) return { r, g, b, a: alpha };
+  }
+  if (typeof v.hex === "string") {
+    const c = hexToRgba(v.hex);
+    if (c) return { ...c, a: alpha };
+  }
+  return void 0;
+}
+function rgbaToDtcg(c) {
+  const out = {
+    colorSpace: "srgb",
+    components: [round(clamp01(c.r), 3), round(clamp01(c.g), 3), round(clamp01(c.b), 3)]
+  };
+  if (c.a < 0.9995) out.alpha = round(clamp01(c.a), 3);
+  out.hex = rgbaToHex(c);
+  return out;
+}
+function colorsEqual(a, b) {
+  return rgbaToHex(a) === rgbaToHex(b) && Math.abs(a.a - b.a) < 2e-3;
+}
+function parseDimension(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const v = value;
+    if (typeof v.value === "number" && typeof v.unit === "string") return { value: v.value, unit: v.unit };
+  }
+  if (typeof value === "string") {
+    const m = /^(-?\d+(?:\.\d+)?)(px|rem)$/.exec(value.trim());
+    if (m) return { value: Number(m[1]), unit: m[2] };
+  }
+  if (typeof value === "number") return { value, unit: "px" };
+  return void 0;
+}
+const numbersEqual = (a, b) => Math.abs(a - b) < 1e-4;
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a === "number" && typeof b === "number") return numbersEqual(a, b);
+  if (typeof a !== typeof b || !a || !b || typeof a !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, idx) => deepEqual(v, b[idx]));
+  const ka = Object.keys(a).filter((k) => a[k] !== void 0);
+  const kb = Object.keys(b).filter((k) => b[k] !== void 0);
+  if (ka.length !== kb.length) return false;
+  return ka.every((k) => deepEqual(a[k], b[k]));
+}
+function valuesEqual(type, a, b) {
+  if (a === void 0 || b === void 0) return a === b;
+  if (isAlias(a) || isAlias(b)) return isAlias(a) && isAlias(b) && aliasTarget(a) === aliasTarget(b);
+  if (type === "color") {
+    const ca = parseColor(a);
+    const cb = parseColor(b);
+    if (ca && cb) return colorsEqual(ca, cb);
+  }
+  if (type === "dimension") {
+    const da = parseDimension(a);
+    const db = parseDimension(b);
+    if (da && db) return da.unit === db.unit && numbersEqual(da.value, db.value);
+  }
+  return deepEqual(a, b);
+}
+function formatValue(type, value) {
+  if (value === void 0) return "none";
+  if (isAlias(value)) return aliasTarget(value);
+  if (type === "color") {
+    const c = parseColor(value);
+    const hex = value && typeof value === "object" && typeof value.hex === "string" ? value.hex.toLowerCase() : void 0;
+    if (c) return c.a < 0.9995 ? `${hex ?? rgbaToHex(c)} @ ${Math.round(c.a * 100)}%` : hex ?? rgbaToHex(c);
+  }
+  if (type === "dimension") {
+    const d = parseDimension(value);
+    if (d) return `${d.value}${d.unit}`;
+  }
+  if (Array.isArray(value)) return value.join(", ");
+  if (typeof value === "object" && value) return JSON.stringify(value);
+  return String(value);
+}
+const DTCG_TYPES = /* @__PURE__ */ new Set(["color", "dimension", "fontFamily", "fontWeight", "duration", "cubicBezier", "number", "strokeStyle", "border", "transition", "shadow", "gradient", "typography", "fontStyle", "string", "boolean"]);
+const 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}$`);
+}
+const comboKey = (c) => Object.entries(c).map(([k, v]) => `${k}=${v}`).join(",") || "default";
+function flattenLayerFile(json, file, issues) {
+  const out = [];
+  const walk = (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)) walk(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 });
+    }
+  };
+  walk(json, []);
+  return out;
+}
+const 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("")}`;
+}
+const 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);
+    }
+  }
+}
+class LayeredTokenSet {
+  /** `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 walk(td.value, [...stack, target]);
+    };
+    const walk = (v, stack) => {
+      const a = aliasOf(v);
+      if (a) return deref(a, stack);
+      if (Array.isArray(v)) return v.map((x) => walk(x, stack));
+      if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, walk(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 = walk(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)));
+}
+function checkShape(type, v) {
+  if (aliasOf(v)) return null;
+  const isObj2 = (x) => Boolean(x) && typeof x === "object" && !Array.isArray(x);
+  switch (type) {
+    case "color":
+      if (typeof v === "string") return /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(v) ? "warn:color as a hex string: DTCG 2025.10 uses { colorSpace, components, hex }" : "color must be { colorSpace, components } (or a hex string)";
+      if (!isObj2(v) || typeof v.colorSpace !== "string" || !Array.isArray(v.components)) return "color must be { colorSpace, components, alpha?, hex? }";
+      if (v.components.length !== 3 || !v.components.every((c) => typeof c === "number" || c === "none" || aliasOf(c))) return "color components must be 3 numbers";
+      if (v.alpha !== void 0 && (typeof v.alpha !== "number" || v.alpha < 0 || v.alpha > 1)) return "color alpha must be between 0 and 1";
+      if (v.hex !== void 0 && !/^#[0-9a-f]{6}$/i.test(String(v.hex))) return "color hex must be #rrggbb";
+      return null;
+    case "dimension":
+      if (typeof v === "string" || typeof v === "number") return "warn:dimension as a plain value: DTCG 2025.10 uses { value, unit }";
+      return isObj2(v) && typeof v.value === "number" && ["px", "rem"].includes(String(v.unit)) ? null : 'dimension must be { value: number, unit: "px" | "rem" }';
+    case "duration":
+      if (typeof v === "string") return "warn:duration as a string: DTCG 2025.10 uses { value, unit }";
+      return isObj2(v) && typeof v.value === "number" && ["ms", "s"].includes(String(v.unit)) ? null : 'duration must be { value: number, unit: "ms" | "s" }';
+    case "cubicBezier":
+      return Array.isArray(v) && v.length === 4 && v.every((x) => typeof x === "number") && v[0] >= 0 && v[0] <= 1 && v[2] >= 0 && v[2] <= 1 ? null : "cubicBezier must be [x1, y1, x2, y2] with x in 0..1";
+    case "fontFamily":
+      return typeof v === "string" || Array.isArray(v) && v.every((x) => typeof x === "string") ? null : "fontFamily must be a string or an array of strings";
+    case "fontWeight":
+      return typeof v === "number" && v >= 1 && v <= 1e3 || typeof v === "string" ? null : "fontWeight must be 1..1000 or a keyword";
+    case "number":
+      return typeof v === "number" ? null : "number must be a number";
+    case "shadow": {
+      const layers = Array.isArray(v) ? v : [v];
+      return layers.every((l) => isObj2(l) && "color" in l && "offsetX" in l && "offsetY" in l && "blur" in l) ? null : "shadow must be { color, offsetX, offsetY, blur, spread? } or an array of them";
+    }
+    default:
+      return null;
+  }
+}
+function validateLayered(set) {
+  const issues = [...set.issues];
+  for (const d of set.defs) {
+    if (d.type && !DTCG_TYPES.has(d.type)) issues.push({ level: "error", code: "unknown-type", message: `Unknown $type "${d.type}".`, path: d.path, file: d.file });
+    if (d.type) {
+      const s = checkShape(d.type, d.value);
+      if (s) issues.push({ level: s.startsWith("warn:") ? "warning" : "error", code: "invalid-value", message: s.replace(/^warn:/, ""), path: d.path, file: d.file });
+    }
+  }
+  const merged = /* @__PURE__ */ new Map();
+  const add = (i, combo) => {
+    const k = `${i.code}|${i.path}|${i.message}`;
+    const prev = merged.get(k);
+    if (prev) prev.modes.push(comboKey(combo));
+    else merged.set(k, { ...i, modes: [comboKey(combo)] });
+  };
+  for (const combo of set.combos()) {
+    for (const miss of set.missingLayers(combo)) add({ level: "error", code: "missing-layer", message: `No file matches layer "${miss}".` }, combo);
+    for (const [path, defs] of set.view(combo)) {
+      const r = set.resolve(path, combo);
+      const def = defs[defs.length - 1];
+      if (r.error) add({ level: "error", code: r.error.startsWith("circular") ? "circular-alias" : "broken-alias", message: r.error, path, file: def.file }, combo);
+      else if (!r.type) add({ level: "error", code: "missing-type", message: "No $type on the token, its groups or its alias target.", path, file: def.file }, combo);
+      else if (def.type && aliasOf(def.value)) {
+        const target = set.view(combo).get(aliasOf(def.value));
+        const tt = target?.[target.length - 1]?.type;
+        if (tt && tt !== def.type) add({ level: "error", code: "type-mismatch", message: `$type ${def.type} aliases a ${tt} token (${String(def.value)}).`, path, file: def.file }, combo);
+      }
+    }
+  }
+  const total = set.combos().length;
+  for (const i of merged.values()) {
+    if (i.modes.length === total) delete i.modes;
+    issues.push(i);
+  }
+  issues.push(...layeredParityIssues(set));
+  return issues;
+}
+function layeredParityIssues(set) {
+  const out = [];
+  const pathsOf = (file) => new Set(set.defs.filter((d) => d.file === file).map((d) => d.path));
+  for (const [mode, m] of Object.entries(set.config.axes)) {
+    if (!m.parity) continue;
+    for (const layer of set.config.tokens.layers) {
+      if (!layer.files.includes(`{${mode}}`) || layer.optional) continue;
+      const others = (layer.files.match(/\{([^}]+)\}/g) ?? []).map((p) => p.slice(1, -1)).filter((k) => k !== mode);
+      let fixed = [{}];
+      for (const o of others) fixed = fixed.flatMap((c) => (set.config.axes[o]?.values ?? []).map((v) => ({ ...c, [o]: v })));
+      for (const c of fixed) {
+        const filesByValue = m.values.map((v) => {
+          const re = globToRegExp(layer.files.replace(/\{([^}]+)\}/g, (_, k) => k === mode ? v : c[k]));
+          return { v, files: set.fileNames.filter((f) => re.test(f)) };
+        });
+        const present = filesByValue.filter((x) => x.files.length);
+        if (!present.length) continue;
+        for (const x of filesByValue) {
+          if (!x.files.length) out.push({ level: "error", code: "mode-parity", message: `${mode} "${x.v}" has no file for layer "${layer.files}" while ${present.map((p) => p.v).join(", ")} do.` });
+        }
+        const sets = present.map((x) => ({ v: x.v, files: x.files, paths: new Set(x.files.flatMap((f) => [...pathsOf(f)])) }));
+        const union = new Set(sets.flatMap((s) => [...s.paths]));
+        for (const p of union) {
+          const lacking = sets.filter((s) => !s.paths.has(p));
+          if (lacking.length) {
+            const having = sets.find((s) => s.paths.has(p));
+            out.push({ level: "error", code: "mode-parity", message: `Defined for ${mode} ${sets.filter((s) => s.paths.has(p)).map((s) => s.v).join(", ")} but not ${lacking.map((s) => s.v).join(", ")} (${lacking.map((s) => s.files.join(", ")).join("; ")}).`, path: p, file: having.files[0] });
+          }
+        }
+      }
+    }
+  }
+  return out;
+}
 const EXT_ID = "com.dsbridge.id";
 const EXT_SCOPES = "com.figma.scopes";
 const PRIMITIVE_MODE = "value";
@@ -22,6 +494,53 @@ const TIER_NAMES = {
   component: "Component"
 };
 const modeDisplayName = (mode) => mode.charAt(0).toUpperCase() + mode.slice(1);
+function valueIn(t, ctx) {
+  const axis = TIER_AXIS[t.tier];
+  if (!axis) return { value: t.values[SINGLE_MODE], via: "token" };
+  if (t.tier === "semantic" && ctx.overrides && ctx.brand && ctx.theme) {
+    const o = ctx.overrides.get(`${ctx.brand}|${ctx.theme}|${t.path}`);
+    if (o !== void 0) return { value: o, via: "override" };
+  }
+  const mode = ctx[axis];
+  return { value: mode === void 0 ? void 0 : t.values[mode], via: "token" };
+}
+function resolve(index, path, ctx) {
+  const chain = [];
+  const via = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = path;
+  for (; ; ) {
+    if (seen.has(current)) return { chain: [...chain, current], via, error: "cycle", at: current };
+    seen.add(current);
+    chain.push(current);
+    const t = index.get(current);
+    if (!t) return { chain, via, error: "broken", at: current };
+    const v = valueIn(t, ctx);
+    if (v.value === void 0) return { chain, via, error: "missing-mode", at: current };
+    via.push(v.via);
+    if (!isAlias(v.value)) return { value: v.value, chain, via };
+    current = aliasTarget(v.value);
+  }
+}
+function findReferenceProblems(index, axes) {
+  const out = [];
+  const base = { brand: axes.brand?.[0], theme: axes.theme?.[0], density: axes.density?.[0] };
+  for (const t of index.values()) {
+    const axis = TIER_AXIS[t.tier];
+    const modes = axis ? (axes[axis] ?? Object.keys(t.values)).filter((m) => t.values[m] !== void 0) : [SINGLE_MODE];
+    for (const mode of modes) {
+      const v = t.values[mode];
+      for (const ref of collectRefs(v)) {
+        if (!index.has(ref)) out.push({ path: t.path, mode, kind: "broken", target: ref, chain: [t.path, ref] });
+      }
+      if (isAlias(v)) {
+        const r = resolve(index, t.path, axis ? { ...base, [axis]: mode } : base);
+        if (r.error === "cycle") out.push({ path: t.path, mode, kind: "cycle", target: r.at ?? "", chain: r.chain });
+      }
+    }
+  }
+  return out;
+}
 const PREVIEW_APP_LABELS = { docs: "Docs", storybook: "Storybook", admin: "Admin demo" };
 const PREVIEW_PLACEHOLDERS = ["branch", "rawBranch", "pr", "sha", "sha7"];
 function branchSlug(branch) {
@@ -564,6 +1083,10 @@ const DEFAULT_PRODUCTS = [
 ];
 const PRODUCT_LABEL_PREFIX = "product: ";
 const productLabel = (key) => `${PRODUCT_LABEL_PREFIX}${key}`;
+function productMarks(products, p) {
+  if (p.key === defaultProduct(products).key) return { labels: [], line: "" };
+  return { labels: [productLabel(p.key)], line: `**Product:** ${p.name}` };
+}
 function productsOf(config) {
   const list2 = config?.products;
   return Array.isArray(list2) && list2.length ? list2 : DEFAULT_PRODUCTS;
@@ -1670,53 +2193,6 @@ function indexByPath(tokens) {
   for (const t of tokens) m.set(t.path, t);
   return m;
 }
-function valueIn(t, ctx) {
-  const axis = TIER_AXIS[t.tier];
-  if (!axis) return { value: t.values[SINGLE_MODE], via: "token" };
-  if (t.tier === "semantic" && ctx.overrides && ctx.brand && ctx.theme) {
-    const o = ctx.overrides.get(`${ctx.brand}|${ctx.theme}|${t.path}`);
-    if (o !== void 0) return { value: o, via: "override" };
-  }
-  const mode = ctx[axis];
-  return { value: mode === void 0 ? void 0 : t.values[mode], via: "token" };
-}
-function resolve(index, path, ctx) {
-  const chain = [];
-  const via = [];
-  const seen = /* @__PURE__ */ new Set();
-  let current = path;
-  for (; ; ) {
-    if (seen.has(current)) return { chain: [...chain, current], via, error: "cycle", at: current };
-    seen.add(current);
-    chain.push(current);
-    const t = index.get(current);
-    if (!t) return { chain, via, error: "broken", at: current };
-    const v = valueIn(t, ctx);
-    if (v.value === void 0) return { chain, via, error: "missing-mode", at: current };
-    via.push(v.via);
-    if (!isAlias(v.value)) return { value: v.value, chain, via };
-    current = aliasTarget(v.value);
-  }
-}
-function findReferenceProblems(index, axes) {
-  const out = [];
-  const base = { brand: axes.brand?.[0], theme: axes.theme?.[0], density: axes.density?.[0] };
-  for (const t of index.values()) {
-    const axis = TIER_AXIS[t.tier];
-    const modes = axis ? (axes[axis] ?? Object.keys(t.values)).filter((m) => t.values[m] !== void 0) : [SINGLE_MODE];
-    for (const mode of modes) {
-      const v = t.values[mode];
-      for (const ref of collectRefs(v)) {
-        if (!index.has(ref)) out.push({ path: t.path, mode, kind: "broken", target: ref, chain: [t.path, ref] });
-      }
-      if (isAlias(v)) {
-        const r = resolve(index, t.path, axis ? { ...base, [axis]: mode } : base);
-        if (r.error === "cycle") out.push({ path: t.path, mode, kind: "cycle", target: r.at ?? "", chain: r.chain });
-      }
-    }
-  }
-  return out;
-}
 const has = (segments, ...names) => names.some((n) => segments.includes(n));
 function defaultScopes(path, type, tier) {
   const s = path.split(".");
@@ -1755,124 +2231,32 @@ const sameScopes = (a, b) => {
   return sa.length === sb.length && sa.every((x, i) => x === sb[i]);
 };
 const effectiveScopes = (t) => t.scopes ?? defaultScopes(t.path, t.type, t.tier);
-const CONTRAST_CHECKS_FILE = "contrast.checks.json";
-const AA_MIN = { text: 4.5, "large-text": 3, ui: 3 };
-const AAA_MIN = { text: 7, "large-text": 4.5, ui: 4.5 };
-const channel = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
-function luminance(c) {
-  const q = (x) => Math.round(Math.min(1, Math.max(0, x)) * 255) / 255;
-  return 0.2126 * channel(q(c.r)) + 0.7152 * channel(q(c.g)) + 0.0722 * channel(q(c.b));
-}
-function composite(fg, bg) {
-  const a = fg.a;
-  return { r: fg.r * a + bg.r * (1 - a), g: fg.g * a + bg.g * (1 - a), b: fg.b * a + bg.b * (1 - a), a: 1 };
-}
-function contrastRatio(fg, bg) {
-  const f = typeof fg === "string" ? hexToRgba(fg) : fg;
-  const b = typeof bg === "string" ? hexToRgba(bg) : bg;
-  if (!f || !b) throw new Error("Invalid color");
-  const opaqueBg = { ...b };
-  const l1 = luminance(composite(f, opaqueBg));
-  const l2 = luminance(opaqueBg);
-  const [hi, lo] = l1 > l2 ? [l1, l2] : [l2, l1];
-  return (hi + 0.05) / (lo + 0.05);
-}
-function contrastLevel(ratio, kind, min = AA_MIN[kind]) {
-  if (ratio < min) return "fail";
-  if (ratio >= AAA_MIN[kind]) return "AAA";
-  return "AA";
+const normDesc = (d) => (d ?? "").trim();
+function fieldChanges(a, b) {
+  const out = [];
+  if (a.path !== b.path) out.push({ field: "path", before: a.path, after: b.path });
+  if (a.type !== b.type) out.push({ field: "type", before: a.type, after: b.type });
+  const modes = [.../* @__PURE__ */ new Set([...Object.keys(a.values), ...Object.keys(b.values)])];
+  for (const mode of modes) {
+    if (!valuesEqual(b.type, a.values[mode], b.values[mode])) out.push({ field: "value", mode, before: a.values[mode], after: b.values[mode] });
+  }
+  if (normDesc(a.description) !== normDesc(b.description)) out.push({ field: "description", before: a.description, after: b.description });
+  const sa = effectiveScopes(a);
+  const sb = effectiveScopes(b);
+  if (!sameScopes(sa, sb)) out.push({ field: "scopes", before: sa, after: sb });
+  return out;
 }
-function contrastScope(set) {
-  return {
-    brands: set.layout.brands.map((b) => b.mode),
-    themes: set.layout.themes.map((t) => t.mode),
-    density: set.layout.densities[0]?.mode,
-    overrides: set.overrideIndex
-  };
+function sameToken(a, b) {
+  if (!a || !b) return a === b;
+  return fieldChanges(a, b).length === 0;
 }
-const cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-const contextLabel = (r) => r.brand ? `${cap(r.brand)} ${r.theme}` : cap(r.theme);
-function renderedColor(value) {
-  const c = parseColor(value);
-  const hex = value && typeof value === "object" ? value.hex : void 0;
-  const fromHex = typeof hex === "string" ? hexToRgba(hex) : void 0;
-  return c && fromHex ? { ...fromHex, a: c.a } : c;
-}
-function evaluatePairs(index, pairs, scope) {
-  const out = [];
-  const brands = scope.brands.length ? scope.brands : [void 0];
-  for (const brand of brands) {
-    for (const theme of scope.themes) {
-      const ctx = { brand, theme, density: scope.density, overrides: scope.overrides };
-      for (const pair of pairs) {
-        const steps = [];
-        const color = (path) => {
-          const r = resolve(index, path, ctx);
-          r.via.forEach((via, i) => steps.push({ path: r.chain[i], via }));
-          if (r.error) return `${path} cannot be resolved (${r.error === "broken" ? `missing ${r.at}` : r.error})`;
-          return renderedColor(r.value) ?? `${path} is not a color`;
-        };
-        const fg = color(pair.foreground);
-        const bg = color(pair.background);
-        if (typeof fg === "string" || typeof bg === "string") {
-          out.push({ pair, brand, theme, steps, error: typeof fg === "string" ? fg : bg });
-          continue;
-        }
-        const ratio = Math.round(contrastRatio(fg, bg) * 100) / 100;
-        out.push({ pair, brand, theme, ratio, level: contrastLevel(ratio, pair.kind, pair.min), steps });
-      }
-    }
-  }
-  return out;
-}
-const kindForMin = (min) => min >= AA_MIN.text ? "text" : "ui";
-const contrastPair = (foreground, background, min = AA_MIN.text) => ({ foreground, background, min, kind: kindForMin(min) });
-function parseContrastChecks(text) {
-  if (!text) return [];
-  const data = JSON.parse(text);
-  const list2 = Array.isArray(data) ? data : Array.isArray(data.pairs) ? data.pairs : [];
-  const out = [];
-  for (const p of list2) {
-    let fg, bg, min;
-    if (Array.isArray(p)) [fg, bg, min] = p;
-    else if (p && typeof p === "object") {
-      const o = p;
-      fg = o.fg ?? o.foreground;
-      bg = o.bg ?? o.background;
-      min = o.min ?? o.ratio ?? AA_MIN.text;
-    }
-    if (typeof fg !== "string" || typeof bg !== "string" || typeof min !== "number" || !(min > 0)) continue;
-    out.push(contrastPair(fg, bg, min));
-  }
-  return out;
-}
-const pairKey = (r) => `${r.brand ?? ""}/${r.theme}:${r.pair.foreground}|${r.pair.background}`;
-const normDesc = (d) => (d ?? "").trim();
-function fieldChanges(a, b) {
-  const out = [];
-  if (a.path !== b.path) out.push({ field: "path", before: a.path, after: b.path });
-  if (a.type !== b.type) out.push({ field: "type", before: a.type, after: b.type });
-  const modes = [.../* @__PURE__ */ new Set([...Object.keys(a.values), ...Object.keys(b.values)])];
-  for (const mode of modes) {
-    if (!valuesEqual(b.type, a.values[mode], b.values[mode])) out.push({ field: "value", mode, before: a.values[mode], after: b.values[mode] });
-  }
-  if (normDesc(a.description) !== normDesc(b.description)) out.push({ field: "description", before: a.description, after: b.description });
-  const sa = effectiveScopes(a);
-  const sb = effectiveScopes(b);
-  if (!sameScopes(sa, sb)) out.push({ field: "scopes", before: sa, after: sb });
-  return out;
-}
-function sameToken(a, b) {
-  if (!a || !b) return a === b;
-  return fieldChanges(a, b).length === 0;
-}
-function sideChange(from, to) {
-  if (!from && !to) return void 0;
-  if (!from) return { kind: "added", fields: [] };
-  if (!to) return { kind: "removed", fields: [] };
-  const fields = fieldChanges(from, to);
-  if (!fields.length) return void 0;
-  return { kind: fields.some((f) => f.field === "path") ? "renamed" : "changed", fields };
+function sideChange(from, to) {
+  if (!from && !to) return void 0;
+  if (!from) return { kind: "added", fields: [] };
+  if (!to) return { kind: "removed", fields: [] };
+  const fields = fieldChanges(from, to);
+  if (!fields.length) return void 0;
+  return { kind: fields.some((f) => f.field === "path") ? "renamed" : "changed", fields };
 }
 function threeWayDiff(base, figma, head) {
   const ids = /* @__PURE__ */ new Set([...base?.keys() ?? [], ...figma.keys(), ...head.keys()]);
@@ -1911,7 +2295,7 @@ const RISK_LABELS = {
   2: "Tier 2: medium risk, design review then design + tech approval",
   3: "Tier 3: token change, needs design + tech approval"
 };
-const BUMP_RANK$1 = { patch: 0, minor: 1, major: 2 };
+const BUMP_RANK = { patch: 0, minor: 1, major: 2 };
 const LOW = [/\.md$/, /^docs\//, /\.stories\.tsx?$/, /\.docs\.json$/, /\.test\.tsx?$/, /^\.changeset\//];
 const isSummary = (c) => "kind" in c;
 function summarizeTokenChange(c) {
@@ -1927,7 +2311,7 @@ function tokenBump(changes) {
   let bump;
   for (const c of changes.map(summarizeTokenChange)) {
     const b = c.kind === "removed" || c.kind === "renamed" ? "major" : c.kind === "changed" && c.descriptionOnly ? "patch" : "minor";
-    if (!bump || BUMP_RANK$1[b] > BUMP_RANK$1[bump]) bump = b;
+    if (!bump || BUMP_RANK[b] > BUMP_RANK[bump]) bump = b;
   }
   return bump;
 }
@@ -1957,6 +2341,98 @@ function classifyRisk(input) {
   const tier = reasons[0]?.tier ?? 1;
   return { tier, label: RISK_LABELS[tier], reasons: reasons.map((r) => r.text), bump };
 }
+const CONTRAST_CHECKS_FILE = "contrast.checks.json";
+const AA_MIN = { text: 4.5, "large-text": 3, ui: 3 };
+const AAA_MIN = { text: 7, "large-text": 4.5, ui: 4.5 };
+const channel = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+function luminance(c) {
+  const q = (x) => Math.round(Math.min(1, Math.max(0, x)) * 255) / 255;
+  return 0.2126 * channel(q(c.r)) + 0.7152 * channel(q(c.g)) + 0.0722 * channel(q(c.b));
+}
+function composite(fg, bg) {
+  const a = fg.a;
+  return { r: fg.r * a + bg.r * (1 - a), g: fg.g * a + bg.g * (1 - a), b: fg.b * a + bg.b * (1 - a), a: 1 };
+}
+function contrastRatio(fg, bg) {
+  const f = typeof fg === "string" ? hexToRgba(fg) : fg;
+  const b = typeof bg === "string" ? hexToRgba(bg) : bg;
+  if (!f || !b) throw new Error("Invalid color");
+  const opaqueBg = { ...b };
+  const l1 = luminance(composite(f, opaqueBg));
+  const l2 = luminance(opaqueBg);
+  const [hi, lo] = l1 > l2 ? [l1, l2] : [l2, l1];
+  return (hi + 0.05) / (lo + 0.05);
+}
+function contrastLevel(ratio, kind, min = AA_MIN[kind]) {
+  if (ratio < min) return "fail";
+  if (ratio >= AAA_MIN[kind]) return "AAA";
+  return "AA";
+}
+function contrastScope(set) {
+  return {
+    brands: set.layout.brands.map((b) => b.mode),
+    themes: set.layout.themes.map((t) => t.mode),
+    density: set.layout.densities[0]?.mode,
+    overrides: set.overrideIndex
+  };
+}
+const cap = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+const contextLabel = (r) => r.brand ? `${cap(r.brand)} ${r.theme}` : cap(r.theme);
+function renderedColor(value) {
+  const c = parseColor(value);
+  const hex = value && typeof value === "object" ? value.hex : void 0;
+  const fromHex = typeof hex === "string" ? hexToRgba(hex) : void 0;
+  return c && fromHex ? { ...fromHex, a: c.a } : c;
+}
+function evaluatePairs(index, pairs, scope) {
+  const out = [];
+  const brands = scope.brands.length ? scope.brands : [void 0];
+  for (const brand of brands) {
+    for (const theme of scope.themes) {
+      const ctx = { brand, theme, density: scope.density, overrides: scope.overrides };
+      for (const pair of pairs) {
+        const steps = [];
+        const color = (path) => {
+          const r = resolve(index, path, ctx);
+          r.via.forEach((via, i) => steps.push({ path: r.chain[i], via }));
+          if (r.error) return `${path} cannot be resolved (${r.error === "broken" ? `missing ${r.at}` : r.error})`;
+          return renderedColor(r.value) ?? `${path} is not a color`;
+        };
+        const fg = color(pair.foreground);
+        const bg = color(pair.background);
+        if (typeof fg === "string" || typeof bg === "string") {
+          out.push({ pair, brand, theme, steps, error: typeof fg === "string" ? fg : bg });
+          continue;
+        }
+        const ratio = Math.round(contrastRatio(fg, bg) * 100) / 100;
+        out.push({ pair, brand, theme, ratio, level: contrastLevel(ratio, pair.kind, pair.min), steps });
+      }
+    }
+  }
+  return out;
+}
+const kindForMin = (min) => min >= AA_MIN.text ? "text" : "ui";
+const contrastPair = (foreground, background, min = AA_MIN.text) => ({ foreground, background, min, kind: kindForMin(min) });
+function parseContrastChecks(text) {
+  if (!text) return [];
+  const data = JSON.parse(text);
+  const list2 = Array.isArray(data) ? data : Array.isArray(data.pairs) ? data.pairs : [];
+  const out = [];
+  for (const p of list2) {
+    let fg, bg, min;
+    if (Array.isArray(p)) [fg, bg, min] = p;
+    else if (p && typeof p === "object") {
+      const o = p;
+      fg = o.fg ?? o.foreground;
+      bg = o.bg ?? o.background;
+      min = o.min ?? o.ratio ?? AA_MIN.text;
+    }
+    if (typeof fg !== "string" || typeof bg !== "string" || typeof min !== "number" || !(min > 0)) continue;
+    out.push(contrastPair(fg, bg, min));
+  }
+  return out;
+}
+const pairKey = (r) => `${r.brand ?? ""}/${r.theme}:${r.pair.foreground}|${r.pair.background}`;
 const RISK_TIER = RISK_LABELS[3];
 function slugify(text, max = 40) {
   const s = text.toLowerCase().normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -1992,7 +2468,7 @@ const describe = (set, t, mode) => {
   const resolved = r.value === void 0 ? "unresolved" : formatValue(t.type, r.value);
   return `${formatValue(t.type, v)} (${resolved})`;
 };
-const cell$1 = (s) => s.replace(/\|/g, "\\|").replace(/\n/g, " ") || " ";
+const cell = (s) => s.replace(/\|/g, "\\|").replace(/\n/g, " ") || " ";
 const code = (s) => s ? `\`${s}\`` : "";
 function valueText(head, proposed, c, mode) {
   const t = c.target ?? c.current;
@@ -2069,7 +2545,7 @@ function composePrBody(input) {
     const extras = [];
     if (c.current && c.target && (c.current.description ?? "") !== (c.target.description ?? "")) extras.push("description");
     lines.push(
-      `| ${name} | ${TIER_NAMES[t.tier]} | ${kind}${extras.length ? ` (+${extras.join(", ")})` : ""} | ${cell$1(valuesCell(head, proposed, c))} | ${contrastCell(c, validation.contrastBefore, validation.contrastAfter)} |`
+      `| ${name} | ${TIER_NAMES[t.tier]} | ${kind}${extras.length ? ` (+${extras.join(", ")})` : ""} | ${cell(valuesCell(head, proposed, c))} | ${contrastCell(c, validation.contrastBefore, validation.contrastAfter)} |`
     );
   }
   lines.push("");
@@ -2124,1282 +2600,189 @@ ${body}
 
 ${footer}`;
 }
-function changesetBump(changes) {
-  return tokenBump(changes) ?? "patch";
-}
-function formatChangeset(packageName, bump, summary, details = "") {
-  return `---
-"${packageName}": ${bump}
----
-
-${summary.trim()}
-${details ? `
-${details.trim()}
-` : ""}`;
-}
-function composeChangeset(changes, opts) {
-  const bump = changesetBump(changes);
-  const name = opts.branch.replace(/^tokens\//, "ds-bridge-").replace(/[^a-z0-9-]/gi, "-");
-  const list2 = changes.slice(0, 20).map((c) => `- ${changeKind(c)} \`${(c.target ?? c.current).path}\``).join("\n");
-  const more = changes.length > 20 ? `
-- and ${changes.length - 20} more` : "";
-  const summary = opts.source ? `${opts.title} (${opts.source}).` : `${opts.title}.`;
-  return {
-    path: `.changeset/${name}.md`,
-    content: formatChangeset(opts.packageName, bump, summary, `${list2}${more}`)
-  };
-}
-function coerceValue(input, type, existing) {
-  if (typeof input !== "string") return input;
-  const s = input.trim();
-  if (aliasOf(s)) return s;
-  if (s.startsWith("{") || s.startsWith("[")) {
-    try {
-      return JSON.parse(s);
-    } catch {
-    }
-  }
-  const keepString = typeof existing === "string" && !aliasOf(existing);
-  switch (type) {
-    case "color": {
-      const m = /^#([0-9a-f]{6})([0-9a-f]{2})?$/i.exec(s) ?? /^#([0-9a-f]{3})$/i.exec(s);
-      if (!m) return s;
-      const hex6 = m[1].length === 3 ? [...m[1]].map((c) => c + c).join("") : m[1];
-      if (keepString) return `#${hex6.toLowerCase()}${m[2] ?? ""}`;
-      return rgbaToDtcg(hexToRgba(`#${hex6}${m[2] ?? ""}`));
-    }
-    case "dimension": {
-      const m = /^(-?\d*\.?\d+)\s*(px|rem)?$/.exec(s);
-      if (!m || keepString) return s;
-      return { value: Number(m[1]), unit: m[2] ?? "px" };
-    }
-    case "duration": {
-      const m = /^(\d*\.?\d+)\s*(ms|s)?$/.exec(s);
-      if (!m || keepString) return s;
-      return { value: Number(m[1]), unit: m[2] ?? "ms" };
-    }
-    case "number":
-    case "fontWeight":
-      return /^-?\d*\.?\d+$/.test(s) ? Number(s) : s;
-    default:
-      return s;
-  }
-}
-function applyTokenEdits(base, edits) {
-  let set = base;
-  const files = new Map(base.files);
-  const touched = /* @__PURE__ */ new Set();
-  const notes = [];
-  const edit = (f, fn) => {
-    const doc = files.has(f) ? parseTokenFile(f, files.get(f)) : emptyTokenFile(f);
-    if (!fn(doc)) return;
-    const text = serializeTokenFile(doc);
-    if (text !== files.get(f)) {
-      files.set(f, text);
-      touched.add(f);
-    }
-  };
-  const definingFiles = (path) => [...new Set(set.defs.filter((d) => d.path === path).map((d) => d.file))];
-  const pickFiles = (e, all) => {
-    const defs = definingFiles(e.path);
-    if (e.file) {
-      if (!files.has(e.file)) throw new Error(`File "${e.file}" is not a token file. Token files: ${set.fileNames.join(", ")}`);
-      if (!defs.includes(e.file)) throw new Error(`"${e.path}" is not defined in ${e.file}. It is defined in: ${defs.join(", ") || 'no file (use op "add")'}.`);
-      return [e.file];
-    }
-    if (e.mode) {
-      const combo = set.normalizeCombo(e.mode);
-      const v = set.view(combo).get(e.path);
-      if (!v) throw new Error(`"${e.path}" is not defined for ${JSON.stringify(combo)}.`);
-      return [v[v.length - 1].file];
-    }
-    if (!defs.length) throw new Error(`Token "${e.path}" does not exist. Use op "add" to create it.`);
-    if (defs.length > 1 && !all) throw new Error(`"${e.path}" is defined in ${defs.length} files (${defs.join(", ")}). Pass "file" or "mode" (for example { "theme": "dark" }), or one edit per file.`);
-    return defs;
-  };
-  for (const e of edits) {
-    if (!e.path || /[{}]/.test(e.path)) throw new Error(`Invalid token path "${e.path}". Use dots: color.text.muted.`);
-    switch (e.op) {
-      case "set": {
-        if (e.value === void 0 && e.description === void 0 && e.type === void 0) throw new Error(`set ${e.path}: give value, description or type.`);
-        for (const f of pickFiles(e, false)) {
-          edit(f, (doc) => {
-            const cur = readTokenAt(doc, e.path);
-            const type = e.type ?? cur.type;
-            return upsertToken(doc, e.path, {
-              type,
-              value: e.value === void 0 ? cur.value : coerceValue(e.value, type, cur.value),
-              description: e.description ?? cur.description
-            });
-          });
-        }
-        break;
-      }
-      case "add": {
-        let file = e.file;
-        if (!file && e.mode) {
-          const combo = set.normalizeCombo(e.mode);
-          const parent = e.path.split(".").slice(0, -1).join(".");
-          const sib = [...set.view(combo).entries()].filter(([p]) => p.startsWith(`${parent}.`)).map(([, d]) => d[d.length - 1].file);
-          file = sib[sib.length - 1];
-        }
-        if (!file) {
-          const keys = e.path.split(".");
-          for (let d = keys.length - 1; d > 0 && !file; d--) {
-            const prefix = `${keys.slice(0, d).join(".")}.`;
-            const fs = [...new Set(set.defs.filter((x) => x.path.startsWith(prefix)).map((x) => x.file))];
-            if (fs.length === 1) file = fs[0];
-            else if (fs.length > 1) throw new Error(`Where should "${e.path}" go? Its group exists in ${fs.join(", ")}. Pass "file" (one add per file for light and dark).`);
-          }
-        }
-        if (!file) throw new Error(`Cannot infer a file for new token "${e.path}". Pass "file".`);
-        if (!files.has(file)) throw new Error(`File "${file}" is not a token file. Token files: ${set.fileNames.join(", ")}`);
-        if (set.defs.some((d) => d.path === e.path && d.file === file)) throw new Error(`"${e.path}" already exists in ${file}. Use op "set".`);
-        if (e.value === void 0) throw new Error(`add ${e.path}: value is required.`);
-        edit(file, (doc) => {
-          const type = e.type ?? inheritedTypeAt(doc, e.path);
-          if (!type && !aliasOf(e.value)) throw new Error(`add ${e.path}: pass "type" (color, dimension, ...); no parent group sets one.`);
-          return upsertToken(doc, e.path, { type, value: coerceValue(e.value, type), description: e.description });
-        });
-        break;
-      }
-      case "remove": {
-        for (const f of pickFiles(e, true)) edit(f, (doc) => removeToken(doc, e.path));
-        const users = set.referencedBy(e.path).filter((u) => u.path !== e.path);
-        if (users.length) notes.push(`${users.length} token(s) alias ${e.path}: ${users.slice(0, 8).map((u) => u.path).join(", ")}. Validation will flag them as broken unless they are edited too.`);
-        break;
-      }
-      case "rename": {
-        const to = e.newPath;
-        if (!to || /[{}]/.test(to)) throw new Error(`rename ${e.path}: pass a valid newPath.`);
-        if (set.defs.some((d) => d.path === to)) throw new Error(`rename: "${to}" already exists.`);
-        for (const f of pickFiles(e, true)) edit(f, (doc) => moveToken(doc, e.path, to));
-        const from = `"{${e.path}}"`;
-        const next = `"{${to}}"`;
-        for (const [f, text] of files) {
-          if (!text.includes(from)) continue;
-          files.set(f, text.split(from).join(next));
-          touched.add(f);
-        }
-        break;
-      }
-      default:
-        throw new Error(`Unknown op "${e.op}". Use set, add, remove or rename.`);
-    }
-    set = new LayeredTokenSet(base.config, new Map(files));
-  }
-  return { files, touched: [...touched].filter((f) => files.get(f) !== base.files.get(f)).sort(), notes };
-}
-function checkLayeredPair(set, pair, combo) {
-  const base = { fg: pair.foreground, bg: pair.background, min: pair.min, modes: comboKey(combo) };
-  const f = set.resolve(pair.foreground, combo);
-  const b = set.resolve(pair.background, combo);
-  if (f.error || b.error) return { ...base, ratio: null, pass: false, note: f.error ?? b.error };
-  const fc = renderedColor(f.value);
-  const bc = renderedColor(b.value);
-  if (!fc || !bc) return { ...base, ratio: null, pass: false, note: "not a color Bridge can measure (needs srgb or hex)" };
-  if (bc.a < 1) return { ...base, ratio: null, pass: false, note: "background is translucent: contrast depends on what is behind it" };
-  const ratio = Math.round(contrastRatio(fc, bc) * 100) / 100;
-  return { ...base, ratio, pass: ratio >= pair.min, fgValue: rgbaToHex(fc), bgValue: rgbaToHex(bc), ...fc.a < 1 ? { note: "foreground alpha composited over background" } : {} };
-}
-function runLayeredContrast(set, pairs, modes) {
-  const combos = set.combos(modes ?? set.config.contrast?.modes);
-  return combos.flatMap((c) => pairs.map((p) => checkLayeredPair(set, p, c)));
-}
-function contrastDelta(before, after) {
-  const key = (r) => `${r.fg}|${r.bg}|${r.modes}`;
-  const prev = new Map(before.map((r) => [key(r), r]));
-  return after.map((a) => {
-    const b = prev.get(key(a));
-    return { fg: a.fg, bg: a.bg, min: a.min, modes: a.modes, before: b?.ratio ?? null, after: a.ratio, passBefore: b?.pass ?? true, passAfter: a.pass };
-  }).filter((d) => d.before !== d.after || !d.passAfter);
-}
-const same$1 = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-function diffLayered(before, after) {
-  const key = (d) => `${d.file}\0${d.path}`;
-  const b = new Map(before.defs.map((d) => [key(d), d]));
-  const a = new Map(after.defs.map((d) => [key(d), d]));
-  const css = (set, d) => set.resolve(d.path, set.comboForFile(d.file)).css;
-  const tierOf = (set, f) => {
-    const t = set.tierOfFile(f);
-    return t ? { tier: t } : {};
-  };
-  const changes = [];
-  const removed = [];
-  const added = [];
-  for (const [k, d] of b) {
-    const n = a.get(k);
-    if (!n) {
-      removed.push(d);
-      continue;
-    }
-    const fields = [];
-    if (!same$1(d.value, n.value)) fields.push("value");
-    if (d.type !== n.type) fields.push("type");
-    if (d.description !== n.description) fields.push("description");
-    if (!same$1(d.extensions, n.extensions)) fields.push("extensions");
-    if (!fields.length) continue;
-    changes.push({
-      kind: "changed",
-      path: d.path,
-      file: d.file,
-      ...tierOf(after, d.file),
-      ...n.type ? { type: n.type } : {},
-      fields,
-      before: d.value,
-      after: n.value,
-      beforeCss: css(before, d),
-      afterCss: css(after, n),
-      ...d.description !== n.description ? { descriptionBefore: d.description ?? "", descriptionAfter: n.description ?? "" } : {}
-    });
-  }
-  for (const [k, d] of a) if (!b.has(k)) added.push(d);
-  for (const r of [...removed]) {
-    const i = added.findIndex((x) => x.file === r.file && same$1(x.value, r.value) && x.type === r.type);
-    if (i < 0) continue;
-    const n = added.splice(i, 1)[0];
-    removed.splice(removed.indexOf(r), 1);
-    changes.push({ kind: "renamed", path: n.path, from: r.path, file: n.file, ...n.type ? { type: n.type } : {}, fields: [], before: r.value, after: n.value, afterCss: css(after, n), ...tierOf(after, n.file) });
-  }
-  for (const d of removed) changes.push({ kind: "removed", path: d.path, file: d.file, ...d.type ? { type: d.type } : {}, fields: [], before: d.value, beforeCss: css(before, d), ...d.description ? { descriptionBefore: d.description } : {}, ...tierOf(before, d.file) });
-  for (const d of added) changes.push({ kind: "added", path: d.path, file: d.file, ...d.type ? { type: d.type } : {}, fields: [], after: d.value, afterCss: css(after, d), ...d.description ? { descriptionAfter: d.description } : {}, ...tierOf(after, d.file) });
-  return changes.sort((x, y) => x.path.localeCompare(y.path) || x.file.localeCompare(y.file));
-}
-function layeredImpact(before, after, direct, limit = 60) {
-  const skip = new Set(direct.map((c) => c.path));
-  const byPath = /* @__PURE__ */ new Map();
-  for (const combo of after.combos()) {
-    const paths = /* @__PURE__ */ new Set([...before.view(combo).keys(), ...after.view(combo).keys()]);
-    for (const p of paths) {
-      if (skip.has(p)) continue;
-      const x = before.resolve(p, combo).css;
-      const y = after.resolve(p, combo).css;
-      if (x === y) continue;
-      const e = byPath.get(p);
-      if (e) e.modes.push(comboKey(combo));
-      else byPath.set(p, { path: p, modes: [comboKey(combo)], before: x, after: y });
-    }
-  }
-  const all = [...byPath.values()].sort((a, b) => a.path.localeCompare(b.path));
-  return { total: all.length, entries: all.slice(0, limit) };
-}
-const toChangeSummary = (c) => ({
-  kind: c.kind,
-  path: c.path,
-  ...c.kind === "changed" ? { descriptionOnly: c.fields.length > 0 && c.fields.every((f) => f === "description") } : {}
-});
-function classifyLayered(changes, otherFiles = [], config) {
-  const r = classifyRisk({ tokenChanges: changes.map(toChangeSummary), files: otherFiles.map((path) => ({ path })), config });
-  return { tier: r.tier, bump: r.bump ?? "patch", reasons: r.reasons.length ? r.reasons : ["No token or guardrail change"], label: r.label };
-}
-const short = (v) => {
-  if (v === void 0) return "";
-  const s = typeof v === "string" ? v : JSON.stringify(v);
-  return s.length > 60 ? `${s.slice(0, 57)}...` : s;
-};
-const cell = (s) => s.replace(/\|/g, "\\|").replace(/\n/g, " ");
-const swatch = (css) => css ? `\`${cell(css)}\`` : "";
-const aliasNote = (v) => typeof v === "string" && v.startsWith("{") ? ` (${cell(short(v))})` : "";
-function changeTable(changes) {
-  if (!changes.length) return "_No token changes._";
-  const rows = changes.map((c) => {
-    const what = c.kind === "renamed" ? `renamed from \`${c.from}\`` : c.kind === "changed" ? c.fields.join(", ") : c.kind;
-    const before = c.kind === "added" || c.kind === "renamed" ? "" : `${swatch(c.beforeCss)}${aliasNote(c.before)}`;
-    const after = c.kind === "removed" ? "" : `${swatch(c.afterCss)}${aliasNote(c.after)}`;
-    return `| \`${c.path}\` | ${what} | ${before} | ${after} | ${c.file} |`;
-  });
-  return ["| Token | Change | Before | After | File |", "| --- | --- | --- | --- | --- |", ...rows].join("\n");
-}
-function contrastDeltaTable(deltas, limit = 40) {
-  if (!deltas.length) return "_No contrast pair moved._";
-  const rows = deltas.slice(0, limit).map((d) => `| \`${d.fg}\` on \`${d.bg}\` | ${d.modes} | ${d.before ?? "n/a"} | ${d.after ?? "n/a"} | ${d.min} | ${d.passAfter ? "pass" : "**fail**"} |`);
-  const more = deltas.length > limit ? `
-
-_${deltas.length - limit} more pair(s) not shown._` : "";
-  return ["| Pair | Mode | Before | After | Min | Result |", "| --- | --- | --- | --- | --- | --- |", ...rows].join("\n") + more;
-}
-function composeProposalBody(args) {
-  const t = args.tier.tier;
-  const box = (n) => `- ${n === t ? "[x]" : "[ ]"} ${RISK_LABELS[n]}`;
-  const impactList = args.impact.entries.slice(0, 15).map((e) => `- \`${e.path}\`: ${swatch(e.before)} -> ${swatch(e.after)} (${e.modes.length} mode${e.modes.length > 1 ? "s" : ""})`);
-  return [
-    "## What changed and why",
-    "",
-    args.summary.trim(),
-    "",
-    `Proposed through ${args.tool ?? "Bridge MCP"}${args.author ? ` by ${args.author}` : ""}. Agent-authored: a human design owner and tech owner review and merge.`,
-    "",
-    "## Risk tier",
-    "",
-    box(1),
-    box(2),
-    box(3),
-    "",
-    ...args.tier.reasons.map((r) => `- ${r}`),
-    `- Semver bump: \`${args.tier.bump}\``,
-    "",
-    "## Token changes",
-    "",
-    changeTable(args.changes),
-    "",
-    "## Contrast before and after",
-    "",
-    contrastDeltaTable(args.contrast),
-    "",
-    "## Downstream impact",
-    "",
-    args.impact.total ? [`${args.impact.total} token(s) resolve to a new value because they alias an edited token.`, "", ...impactList, args.impact.total > 15 ? `- and ${args.impact.total - 15} more` : ""].filter(Boolean).join("\n") : "_No other token changes value._",
-    "",
-    "## Checks",
-    "",
-    `- Token validation: ${args.validationErrors ? `**${args.validationErrors} error(s)**` : "no errors"} (DTCG schema, aliases, light and dark parity)`,
-    `- Contrast gate: ${args.contrast.some((d) => !d.passAfter) ? "**failing pairs, see table**" : "all pairs pass"}`,
-    "",
-    "## Authored by",
-    "",
-    "- [ ] Human",
-    "- [x] AI agent (Claude), reviewed by a human before merge",
-    "",
-    "## Design review checklist",
-    "",
-    "- [ ] Checked in light and dark themes and in every brand",
-    "- [ ] Contrast table reviewed, no pair loosened",
-    "- [ ] Changeset bump matches the tier",
-    ""
-  ].join("\n");
-}
-const DEFAULT_PROTECTED_BRANCHES = ["main", "master"];
-class ProtectedBranchError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ProtectedBranchError";
-  }
-}
-function assertSafeBranch(branch, rules = {}) {
-  const name = branch.replace(/^refs\/heads\//, "").trim();
-  const blocked = /* @__PURE__ */ new Set([...rules.protectedBranches ?? DEFAULT_PROTECTED_BRANCHES, ...rules.base ? [rules.base] : []]);
-  if (!name || blocked.has(name)) {
-    throw new ProtectedBranchError(`Refusing to write to protected branch "${name}". Bridge only creates new branches and pull requests.`);
-  }
-  if (rules.branchPrefix && !name.startsWith(rules.branchPrefix)) {
-    throw new ProtectedBranchError(`Branch "${name}" must start with "${rules.branchPrefix}".`);
-  }
-}
-const BULK_LIMIT = 60;
-const UNRELEASED = "Unreleased";
-const SUBJECT_PR = [/^Merge pull request #(\d+)/, /\(#(\d+)\)\s*$/];
-function prNumberFromSubject(subject) {
-  for (const re of SUBJECT_PR) {
-    const m = re.exec(subject);
-    if (m) return Number(m[1]);
-  }
-  return void 0;
-}
-function parseChangesetText(path, text) {
-  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
-  if (!m) return null;
-  const bumps = [...m[1].matchAll(/["']?([^"'\s:]+)["']?\s*:\s*(major|minor|patch)/g)].map((x) => ({ pkg: x[1], bump: x[2] }));
-  const order = ["major", "minor", "patch"];
-  const bump = order.find((b) => bumps.some((x) => x.bump === b));
-  const summary = m[2].trim().split(/\r?\n\r?\n/)[0].replace(/\s+/g, " ").trim();
-  return { path, ...bump ? { bump } : {}, packages: bumps.map((b) => b.pkg), summary };
-}
-function firstParagraph(text) {
-  if (!text) return "";
-  const cleaned = text.replace(/<!--[\s\S]*?-->/g, "");
-  for (const para of cleaned.split(/\r?\n\s*\r?\n/)) {
-    const lines = para.split(/\r?\n/).filter((l) => l.trim() && !/^\s*#{1,6}\s/.test(l) && !/^\s*[-*]\s*\[[ xX]\]/.test(l) && !/^\s*(Co-Authored-By|Claude-Session|Signed-off-by):/i.test(l));
-    const s = lines.join(" ").replace(/\s+/g, " ").trim();
-    if (s && !/^\|/.test(s)) return s.length > 400 ? `${s.slice(0, 397)}...` : s;
-  }
-  return "";
-}
-function countChanges(changes) {
-  const c = { added: 0, changed: 0, removed: 0, renamed: 0, total: changes.length };
-  for (const x of changes) c[x.kind]++;
-  return c;
-}
-const shortSha = (sha) => sha.slice(0, 7);
-function titleOf(commit) {
-  if (commit.pr?.title) return commit.pr.title;
-  if (/^Merge pull request #\d+/.test(commit.subject)) {
-    const first = (commit.body ?? "").split(/\r?\n/).find((l) => l.trim());
-    if (first) return first.trim();
-  }
-  return commit.subject;
-}
-function buildHistoryEntry(input) {
-  const { config, commit } = input;
-  const beforeSet = new LayeredTokenSet(config, input.before);
-  const afterSet = new LayeredTokenSet(config, input.after);
-  const changes = diffLayered(beforeSet, afterSet);
-  if (!changes.length) return null;
-  const tier = classifyLayered(changes, [], config);
-  const changesets = (input.changesets ?? []).map((c) => parseChangesetText(c.path, c.text)).filter((c) => c !== null);
-  const pkg = config.changesets?.package;
-  const relevant = changesets.filter((c) => !pkg || !c.packages.length || c.packages.includes(pkg));
-  const title = titleOf(commit);
-  const why = relevant.map((c) => c.summary).find(Boolean) || firstParagraph(commit.pr?.body) || firstParagraph(commit.body) || title;
-  const prNumber = commit.pr?.number ?? prNumberFromSubject(commit.subject);
-  const pr = commit.pr ?? (prNumber ? { number: prNumber, title, ...config.repo ? { url: `https://github.com/${config.repo.owner}/${config.repo.name}/pull/${prNumber}` } : {} } : void 0);
-  const changesetBump2 = relevant.map((c) => c.bump).find((b) => b === "major");
-  const bump = changesetBump2 ?? tier.bump;
-  return {
-    id: pr ? `pr-${pr.number}` : shortSha(commit.sha),
-    sha: commit.sha,
-    ...commit.parents[0] ? { baseSha: commit.parents[0] } : {},
-    date: commit.date,
-    author: commit.pr?.author ?? commit.author,
-    title,
-    why,
-    ...pr ? { pr } : {},
-    changes,
-    counts: countChanges(changes),
-    tier: tier.tier,
-    bump,
-    breaking: bump === "major",
-    reasons: tier.reasons,
-    changesets: relevant,
-    ...changes.length > BULK_LIMIT ? { bulk: true } : {},
-    ...input.demo ? { demo: true } : {}
-  };
-}
-async function collectHistory(config, backend, opts) {
-  const root = config.tokens.root.replace(/\/$/, "");
-  const commits = await backend.listCommits({ ref: opts.ref, paths: [root === "." ? "" : root].filter(Boolean), limit: opts.limit ?? 40 });
-  const seen = /* @__PURE__ */ new Set();
-  const picked = [];
-  for (const c of commits) {
-    const n = c.pr?.number;
-    if (n !== void 0) {
-      if (seen.has(n)) continue;
-      seen.add(n);
-    }
-    picked.push(c);
-  }
-  const entries = [];
-  let done = 0;
-  for (const c of picked) {
-    const parent = c.parents[0];
-    const [before, after] = await Promise.all([parent ? backend.tokenFiles(parent) : Promise.resolve(/* @__PURE__ */ new Map()), backend.tokenFiles(c.sha)]);
-    let changesets = [];
-    if (backend.changesetPaths && backend.readFile && config.changesets) {
-      const [was, now] = await Promise.all([parent ? backend.changesetPaths(parent) : Promise.resolve([]), backend.changesetPaths(c.sha)]);
-      const added = now.filter((p) => !was.includes(p) && p.endsWith(".md") && !/README\.md$/i.test(p));
-      changesets = (await Promise.all(added.map(async (p) => ({ path: p, text: await backend.readFile(c.sha, p) ?? "" })))).filter((x) => x.text);
-    }
-    const e = buildHistoryEntry({ config, commit: c, before, after, changesets });
-    if (e) entries.push(e);
-    opts.onProgress?.(++done, picked.length);
-  }
-  return entries;
-}
-function parseChangelog(text) {
-  const out = [];
-  const parts = text.split(/^##\s+/m).slice(1);
-  for (const p of parts) {
-    const [head, ...rest] = p.split(/\r?\n/);
-    const version = /v?(\d+\.\d+\.\d+(?:-[\w.]+)?)/.exec(head ?? "")?.[1];
-    if (!version) continue;
-    const body = rest.join("\n");
-    const shas = [...new Set([...body.matchAll(/(?:^|[\s[`(])([0-9a-f]{7,40})(?=[\s`\]):]|$)/gm)].map((m) => m[1]))];
-    const prs = [...new Set([...body.matchAll(/(?:#|\/pull\/)(\d+)/g)].map((m) => Number(m[1])))];
-    const date = /(\d{4}-\d{2}-\d{2})/.exec(head ?? "")?.[1];
-    out.push({ version, ...date ? { date } : {}, shas, prs });
-  }
-  return out;
-}
-function releasesFromTags(tags, pkg) {
-  const out = [];
-  for (const t of tags) {
-    const m = /^(?:(@?[^@\s]+)@)?v?(\d+\.\d+\.\d+(?:-[\w.]+)?)$/.exec(t.name);
-    if (!m) continue;
-    if (pkg && m[1] && m[1] !== pkg) continue;
-    out.push({ version: m[2], ...t.sha ? { sha: t.sha } : {}, ...t.date ? { date: t.date } : {} });
-  }
-  return out;
-}
-function assignVersions(entries, releases) {
-  const dated = releases.filter((r) => r.date).sort((a, b) => Date.parse(a.date) - Date.parse(b.date));
-  return entries.map((e) => {
-    const cited = releases.find((r) => r.shas?.some((s) => e.sha.startsWith(s)) || e.pr && r.prs?.includes(e.pr.number));
-    const byTag = cited ? void 0 : dated.find((r) => r.sha === e.sha || Date.parse(r.date) >= Date.parse(e.date));
-    return { ...e, version: (cited ?? byTag)?.version ?? UNRELEASED };
-  });
-}
-const BUMP_RANK = { patch: 0, minor: 1, major: 2 };
-function versionTimeline(entries, releases = []) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const e of entries) {
-    const v = e.version ?? UNRELEASED;
-    let g = groups.get(v);
-    if (!g) {
-      const rel = releases.find((r) => r.version === v);
-      g = { version: v, pending: v === UNRELEASED, date: rel?.date ?? e.date, entries: [], prs: [], tokenChanges: 0, breaking: false, bump: "patch", authors: [] };
-      groups.set(v, g);
-    }
-    g.entries.push(e.id);
-    if (e.pr && !g.prs.includes(e.pr.number)) g.prs.push(e.pr.number);
-    g.tokenChanges += e.counts.total;
-    g.breaking ||= e.breaking;
-    if (BUMP_RANK[e.bump] > BUMP_RANK[g.bump]) g.bump = e.bump;
-    if (!g.authors.includes(e.author)) g.authors.push(e.author);
-    if (!releases.some((r) => r.version === v && r.date) && Date.parse(e.date) > Date.parse(g.date)) g.date = e.date;
-  }
-  return [...groups.values()].sort((a, b) => a.pending ? -1 : b.pending ? 1 : Date.parse(b.date) - Date.parse(a.date));
-}
-const matchesToken = (path, q) => path === q || path.startsWith(`${q.replace(/\.$/, "")}.`);
-function filterHistory(entries, f = {}) {
-  const q = f.query?.trim().toLowerCase();
-  return entries.filter(
-    (e) => (!f.token || e.changes.some((c) => matchesToken(c.path, f.token) || c.from && matchesToken(c.from, f.token))) && (!f.author || e.author.toLowerCase() === f.author.toLowerCase()) && (!f.tier || e.tier === f.tier) && (!f.version || (e.version ?? UNRELEASED) === f.version) && (f.breaking === void 0 || e.breaking === f.breaking) && (!f.since || Date.parse(e.date) >= Date.parse(f.since)) && (!f.until || Date.parse(e.date) <= Date.parse(f.until) + 86399999) && (!q || `${e.title} ${e.why} ${e.pr ? `#${e.pr.number}` : ""} ${e.sha}`.toLowerCase().includes(q))
-  );
-}
-function fileModes(config, file) {
-  for (const layer of config.tokens.layers) {
-    const keys = [];
-    const marked = layer.files.replace(/\{([^}]+)\}/g, (_, k) => {
-      keys.push(k);
-      return "
";
-    });
-    const source = globToRegExp(marked).source.replace(/\u0001/g, "([^/.]+)");
-    const m = new RegExp(source).exec(file);
-    if (m) return Object.fromEntries(keys.map((k, i) => [k, m[i + 1]]));
-  }
-  return {};
-}
-function modeLabel(modes) {
-  const v = Object.values(modes).filter(Boolean);
-  if (!v.length) return "All modes";
-  const s = v.join(" ");
-  return s.charAt(0).toUpperCase() + s.slice(1);
-}
-function tokenHistory(entries, path, config) {
-  const names = /* @__PURE__ */ new Set([path]);
-  const out = [];
-  const sorted = [...entries].sort((a, b) => Date.parse(b.date) - Date.parse(a.date));
-  for (const e of sorted) {
-    const hits = e.changes.filter((c) => names.has(c.path));
-    for (const c of hits) {
-      const modes = config ? fileModes(config, c.file) : {};
-      out.push({
-        entryId: e.id,
-        sha: e.sha,
-        date: e.date,
-        author: e.author,
-        title: e.title,
-        why: e.why,
-        ...e.pr ? { pr: e.pr } : {},
-        ...e.version ? { version: e.version } : {},
-        ...e.demo ? { demo: true } : {},
-        kind: c.kind,
-        path: c.path,
-        ...c.from ? { from: c.from } : {},
-        file: c.file,
-        modes,
-        modeLabel: modeLabel(modes),
-        fields: c.fields,
-        ...c.before !== void 0 ? { before: c.before } : {},
-        ...c.after !== void 0 ? { after: c.after } : {},
-        ...c.beforeCss !== void 0 ? { beforeCss: c.beforeCss } : {},
-        ...c.afterCss !== void 0 ? { afterCss: c.afterCss } : {},
-        ...c.descriptionBefore !== void 0 ? { descriptionBefore: c.descriptionBefore } : {},
-        ...c.descriptionAfter !== void 0 ? { descriptionAfter: c.descriptionAfter } : {}
-      });
-    }
-    for (const c of hits) if (c.kind === "renamed" && c.from) names.add(c.from);
-  }
-  return out;
-}
-const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-const keyOf = (path, file) => `${path}@${file}`;
-const show = (v) => typeof v === "string" ? v : JSON.stringify(v);
-function defIn(set, path, file) {
-  return set.defs.find((d) => d.path === path && d.file === file);
-}
-function sharesCombo(set, a, b) {
-  return a === b || set.combos().some((c) => {
-    const files = set.layerFiles(c).files;
-    return files.includes(a) && files.includes(b);
-  });
-}
-function laterTouching(later, path, file, from) {
-  return later.filter((e) => e.changes.some((c) => c.file === file && (c.path === path || c.from === path || from !== void 0 && (c.path === from || c.from === from)))).sort((a, b) => Date.parse(a.date) - Date.parse(b.date)).map((e) => ({ id: e.id, title: e.title, date: e.date, author: e.author, ...e.pr ? { pr: e.pr.number } : {} }));
-}
-function planRevert(input) {
-  const { current, entry } = input;
-  const later = (input.later ?? []).filter((e) => e.id !== entry.id && Date.parse(e.date) >= Date.parse(entry.date));
-  const res = input.resolutions ?? {};
-  const planned = [];
-  const conflicts = [];
-  const skipped = [];
-  const config = current.config;
-  const css = (path, file) => current.resolve(path, current.comboForFile(file)).css;
-  for (const c of entry.changes) {
-    const key = keyOf(c.path, c.file);
-    const label = modeLabel(fileModes(config, c.file));
-    const original = { ...c.before !== void 0 ? { before: c.before } : {}, ...c.after !== void 0 ? { after: c.after } : {}, ...c.beforeCss ? { beforeCss: c.beforeCss } : {}, ...c.afterCss ? { afterCss: c.afterCss } : {} };
-    const conflict = (reason, message, cur, editIfForced, summary) => {
-      const resolution = res[key] ?? "keep-current";
-      conflicts.push({ key, path: c.path, file: c.file, kind: c.kind, reason, message, original, ...cur ? { current: cur } : {}, later: laterTouching(later, c.path, c.file, c.from), resolution });
-      if (resolution === "use-before" && editIfForced) planned.push({ key, path: c.path, file: c.file, summary: summary ?? `${editIfForced.op} ${c.path}`, edit: editIfForced });
-    };
-    const now = defIn(current, c.path, c.file);
-    switch (c.kind) {
-      case "changed": {
-        if (!now) {
-          conflict("removed-later", `${c.path} was removed from ${c.file} after this change. Restoring it is a new token decision, not a revert.`, void 0, { op: "add", path: c.path, file: c.file, value: c.before, ...c.type ? { type: c.type } : {}, ...c.descriptionBefore ? { description: c.descriptionBefore } : {} }, `Add ${c.path} back with ${show(c.before)} (${label})`);
-          break;
-        }
-        const valueField = c.fields.includes("value");
-        const descField = c.fields.includes("description");
-        const cur = { value: now.value, css: css(c.path, c.file) };
-        const valueAt = (v) => same(now.value, v);
-        const descNow = now.description ?? "";
-        if (!valueField && !descField) {
-          skipped.push({ key, path: c.path, file: c.file, reason: "Only the type or extensions changed: edit those by hand." });
-          break;
-        }
-        if ((!valueField || valueAt(c.before)) && (!descField || descNow === (c.descriptionBefore ?? ""))) {
-          skipped.push({ key, path: c.path, file: c.file, reason: "Already back to the value from before this change." });
-          break;
-        }
-        const valueMoved = valueField && !valueAt(c.after) && !valueAt(c.before);
-        const descMoved = descField && descNow !== (c.descriptionAfter ?? "") && descNow !== (c.descriptionBefore ?? "");
-        const edit = {
-          op: "set",
-          path: c.path,
-          file: c.file,
-          ...valueField ? { value: c.before } : {},
-          ...descField ? { description: c.descriptionBefore ?? "" } : {}
-        };
-        const summary = valueField ? `Set ${c.path} back to ${show(c.before)} (${label})` : `Put the old description of ${c.path} back (${label})`;
-        if (valueMoved || descMoved) {
-          conflict("changed-later", `${c.path} changed again after this change: it is now ${cur.css || show(cur.value)}, not ${c.afterCss || show(c.after)}.`, cur, edit, summary);
-          break;
-        }
-        planned.push({ key, path: c.path, file: c.file, summary, edit });
-        break;
-      }
-      case "added": {
-        if (!now) {
-          skipped.push({ key, path: c.path, file: c.file, reason: "Already removed." });
-          break;
-        }
-        const users = current.referencedBy(c.path).filter((u) => u.path !== c.path && sharesCombo(current, u.file, c.file));
-        const edit = { op: "remove", path: c.path, file: c.file };
-        const summary = `Remove ${c.path} (${label})`;
-        if (!same(now.value, c.after)) {
-          conflict("changed-later", `${c.path} changed after it was added: it is now ${css(c.path, c.file) || show(now.value)}.`, { value: now.value, css: css(c.path, c.file) }, edit, summary);
-          break;
-        }
-        if (users.length) {
-          conflict("still-referenced", `${users.length} token(s) alias ${c.path} now (${users.slice(0, 4).map((u) => u.path).join(", ")}${users.length > 4 ? ", ..." : ""}). Removing it would break them.`, { value: now.value, css: css(c.path, c.file) }, edit, summary);
-          break;
-        }
-        planned.push({ key, path: c.path, file: c.file, summary, edit });
-        break;
-      }
-      case "removed": {
-        const edit = { op: "add", path: c.path, file: c.file, value: c.before, ...c.type ? { type: c.type } : {}, ...c.descriptionBefore ? { description: c.descriptionBefore } : {} };
-        const summary = `Add ${c.path} back with ${show(c.before)} (${label})`;
-        if (now) {
-          if (same(now.value, c.before)) skipped.push({ key, path: c.path, file: c.file, reason: "Already back." });
-          else conflict("recreated-later", `${c.path} was added again later with another value (${css(c.path, c.file) || show(now.value)}).`, { value: now.value, css: css(c.path, c.file) });
-          break;
-        }
-        planned.push({ key, path: c.path, file: c.file, summary, edit });
-        break;
-      }
-      case "renamed": {
-        const from = c.from;
-        const back = defIn(current, from, c.file);
-        if (back && !now) {
-          skipped.push({ key, path: c.path, file: c.file, reason: `Already named ${from}.` });
-          break;
-        }
-        if (!now) {
-          conflict("renamed-later", `${c.path} no longer exists in ${c.file}: it was renamed or removed again later.`);
-          break;
-        }
-        if (back) {
-          conflict("recreated-later", `${from} exists again in ${c.file}, so ${c.path} cannot take its old name back.`, { value: back.value, css: css(from, c.file) });
-          break;
-        }
-        if (planned.some((p) => p.edit.op === "rename" && p.path === c.path)) {
-          skipped.push({ key, path: c.path, file: c.file, reason: "Covered by the rename above." });
-          break;
-        }
-        planned.push({ key, path: c.path, file: c.file, summary: `Rename ${c.path} back to ${from} and repoint its aliases`, edit: { op: "rename", path: c.path, newPath: from } });
-        break;
-      }
-    }
-  }
-  const prLink = entry.pr ? entry.pr.url ? `[#${entry.pr.number}](${entry.pr.url})` : `#${entry.pr.number}` : `commit ${entry.sha.slice(0, 7)}`;
-  const title = `Revert: ${entry.title}`;
-  const lines = [
-    `Reverts ${prLink} ("${entry.title}"), merged ${entry.date.slice(0, 10)} by ${entry.author}.`,
-    "",
-    `Original reason: ${entry.why}`,
-    "",
-    "Bridge computed the inverse token edits against the current base branch, not a blind git revert: tokens that changed again since are listed as conflicts and kept unless a reviewer chose to restore them."
-  ];
-  if (conflicts.length) {
-    lines.push("", "### Conflicts", "", "| Token | File | Why | Decision |", "| --- | --- | --- | --- |");
-    for (const k of conflicts) lines.push(`| \`${k.path}\` | ${k.file} | ${k.message.replace(/\|/g, "\\|")}${k.later.length ? ` Later: ${k.later.map((l) => l.pr ? `#${l.pr}` : l.id).join(", ")}.` : ""} | ${k.resolution === "use-before" ? "restore the old value" : "keep current"} |`);
-  }
-  if (skipped.length) lines.push("", `${skipped.length} change(s) were already undone on the base branch and are left alone.`);
-  return finishPlan({ ...input, kind: "revert", title, prTitle: title, summary: lines.join("\n"), planned, conflicts, skipped, source: entry });
-}
-function planRestore(input) {
-  const { current, path } = input;
-  const files = [...new Set(current.defs.filter((d) => d.path === path).map((d) => d.file))];
-  if (!files.length) throw new Error(`Token "${path}" does not exist on the base branch. Restoring a removed token is a revert of the change that removed it.`);
-  const file = input.file ?? (files.length === 1 ? files[0] : void 0);
-  if (!file) throw new Error(`"${path}" is defined in ${files.join(", ")}. Pass the file (the mode) to restore.`);
-  if (!files.includes(file)) throw new Error(`"${path}" is not defined in ${file}. It is defined in: ${files.join(", ")}.`);
-  const label = modeLabel(fileModes(current.config, file));
-  const from = input.label ? ` from ${input.label}` : "";
-  const planned = [{ key: keyOf(path, file), path, file, summary: `Set ${path} to ${show(input.value)} (${label})`, edit: { op: "set", path, file, value: input.value } }];
-  const title = `Restore ${path} (${label})${from}`;
-  const item = input.item;
-  const summary = [
-    `Restores \`${path}\` in ${label} to ${show(input.value)}${from}.`,
-    ...item ? ["", `That value came from ${item.pr ? item.pr.url ? `[#${item.pr.number}](${item.pr.url})` : `#${item.pr.number}` : `commit ${item.sha.slice(0, 7)}`} ("${item.title}"), ${item.date.slice(0, 10)}, by ${item.author}.`] : []
-  ].join("\n");
-  return finishPlan({ ...input, kind: "restore", title, prTitle: title, summary, planned, conflicts: [], skipped: [] });
-}
-const issueKey = (i) => `${i.code}|${i.path ?? ""}|${i.file ?? ""}|${i.message}`;
-function finishPlan(p) {
-  const { current } = p;
-  const config = current.config;
-  const edits = p.planned.map((x) => x.edit);
-  const notes = [];
-  const empty = classifyLayered([], [], config);
-  const base = {
-    kind: p.kind,
-    title: p.title,
-    prTitle: p.prTitle,
-    summary: p.summary,
-    ...p.source ? { source: { id: p.source.id, sha: p.source.sha, title: p.source.title, ...p.source.pr ? { pr: p.source.pr } : {}, date: p.source.date, author: p.source.author } } : {},
-    planned: p.planned,
-    edits,
-    conflicts: p.conflicts,
-    skipped: p.skipped,
-    branch: `${config.governance.branchPrefix}${slugify(p.title, 48)}`
-  };
-  const nothing = (why) => ({ ...base, status: "nothing-to-do", why, changes: [], contrast: [], newFailures: [], newErrors: [], tier: empty, files: [], commitMessage: "", prBody: "", notes });
-  if (!edits.length) return nothing(p.conflicts.length ? 'Every change conflicts with a later one. Choose "restore the old value" on a conflict to include it.' : "Nothing left to undo: the base branch already has the old values.");
-  let result;
-  try {
-    result = applyTokenEdits(current, edits);
-  } catch (e) {
-    return { ...nothing(e.message), status: "blocked" };
-  }
-  notes.push(...result.notes);
-  const after = new LayeredTokenSet(config, result.files);
-  const changes = diffLayered(current, after);
-  if (!changes.length) return nothing("The edits leave every token as it is now.");
-  const prev = new Set(validateLayered(current).map(issueKey));
-  const newErrors = validateLayered(after).filter((i) => i.level === "error" && !prev.has(issueKey(i)));
-  const pairs = p.pairs ?? [];
-  const modes = config.contrast?.modes;
-  const contrast = pairs.length ? contrastDelta(runLayeredContrast(current, pairs, modes), runLayeredContrast(after, pairs, modes)) : [];
-  const newFailures = contrast.filter((d) => d.passBefore && !d.passAfter);
-  const tier = classifyLayered(changes, [], config);
-  const impact = layeredImpact(current, after, changes);
-  const prBody = composeProposalBody({ summary: p.summary, changes, contrast, impact, tier, validationErrors: newErrors.length, tool: p.tool ?? "Bridge", ...p.author ? { author: p.author } : {} });
-  const changeset = config.changesets ? { path: `${config.changesets.dir.replace(/\/$/, "")}/bridge-${slugify(p.title, 48)}.md`, content: formatChangeset(config.changesets.package, tier.bump, p.title.replace(/\.?$/, ".")) } : void 0;
-  const files = [...result.touched.map((f) => ({ path: current.repoPath(f), content: result.files.get(f) })), ...changeset ? [changeset] : []];
-  const commitMessage2 = `${p.kind === "revert" ? "revert(tokens)" : "fix(tokens)"}: ${p.title.replace(/^Revert: /, "")}
-
-${p.source?.pr ? `Reverts #${p.source.pr.number}. ` : ""}Tier ${tier.tier}. Planned with ${p.tool ?? "Bridge"}.`;
-  const blocked = newErrors.length || newFailures.length;
-  return {
-    ...base,
-    status: blocked ? "blocked" : "ready",
-    ...blocked ? { why: [newErrors.length ? `${newErrors.length} new validation error(s)` : "", newFailures.length ? `${newFailures.length} contrast pair(s) would fail` : ""].filter(Boolean).join(" and ") } : {},
-    changes,
-    contrast,
-    newFailures,
-    newErrors,
-    tier,
-    files,
-    ...changeset ? { changeset } : {},
-    commitMessage: commitMessage2,
-    prBody,
-    notes
-  };
-}
-function planToJson(plan) {
-  return {
-    bridge: "change-plan",
-    kind: plan.kind,
-    status: plan.status,
-    title: plan.prTitle,
-    branch: plan.branch,
-    tier: plan.tier.tier,
-    bump: plan.tier.bump,
-    edits: plan.edits,
-    conflicts: plan.conflicts.map((c) => ({ key: c.key, reason: c.reason, message: c.message, resolution: c.resolution })),
-    files: plan.files,
-    commitMessage: plan.commitMessage,
-    prBody: plan.prBody
-  };
-}
-function packageDirCandidates(config) {
-  const parts = config.tokens.root.replace(/\/$/, "").split("/").filter((p) => p && p !== ".");
-  const out = [];
-  for (let i = parts.length; i >= 0; i--) out.push(parts.slice(0, i).join("/"));
-  return out;
-}
-function mergeReleases(changelog, tags) {
-  const byVersion = /* @__PURE__ */ new Map();
-  for (const r of [...changelog, ...tags]) {
-    const prev = byVersion.get(r.version);
-    byVersion.set(r.version, prev ? { ...r, ...prev, ...prev.date ? {} : r.date ? { date: r.date } : {}, ...prev.sha ? {} : r.sha ? { sha: r.sha } : {} } : r);
-  }
-  return [...byVersion.values()];
-}
-function buildReport(args) {
-  const entries = assignVersions(args.entries, args.releases).sort((a, b) => Date.parse(b.date) - Date.parse(a.date));
-  return { ...args, entries, timeline: versionTimeline(entries, args.releases) };
-}
-const COMPONENT_SPECS_VERSION = 1;
-const DEFAULT_COMPONENT_SPECS_FILE = "packages/react/component-specs.json";
-const SPEC_FIELDS = [
-  "fill",
-  "stroke",
-  "strokeWeight",
-  "strokeTopWeight",
-  "strokeRightWeight",
-  "strokeBottomWeight",
-  "strokeLeftWeight",
-  "cornerRadius",
-  "paddingTop",
-  "paddingRight",
-  "paddingBottom",
-  "paddingLeft",
-  "itemSpacing",
-  "counterAxisSpacing",
-  "width",
-  "height",
-  "minWidth",
-  "minHeight",
-  "opacity",
-  "textFill",
-  "fontFamily",
-  "fontSize",
-  "fontWeight",
-  "lineHeight",
-  "letterSpacing",
-  "textDecoration"
-];
-const COLOR_FIELDS = /* @__PURE__ */ new Set(["fill", "stroke", "textFill"]);
-const TRIGGER_LABELS = {
-  ON_HOVER: "While hovering",
-  ON_PRESS: "While pressing",
-  ON_CLICK: "On click",
-  MOUSE_ENTER: "Mouse enter",
-  MOUSE_LEAVE: "Mouse leave"
-};
-function coverageSummary(file) {
-  const list2 = file.coverage ?? file.components.map((c) => ({ name: c.name, status: "generated" }));
-  const generated = list2.filter((c) => c.status === "generated").length;
-  const drafted = list2.filter((c) => c.status === "drafted").length;
-  const layout = list2.filter((c) => c.status === "layout").length;
-  return { generated, drafted, inFigma: generated + drafted, visual: list2.length - layout, layout, total: list2.length, missing: list2.filter((c) => c.status === "unsupported") };
-}
-const LAYOUT_DIRECTIONS = /* @__PURE__ */ new Set(["HORIZONTAL", "VERTICAL"]);
-const PRIMARY = /* @__PURE__ */ new Set(["MIN", "CENTER", "MAX", "SPACE_BETWEEN"]);
-const COUNTER = /* @__PURE__ */ new Set(["MIN", "CENTER", "MAX", "STRETCH"]);
-const PART_KINDS = /* @__PURE__ */ new Set(["frame", "text", "icon", "vector"]);
-function validateComponentSpec(spec, tokenTypes) {
-  const out = [];
-  const at = (where, why) => out.push(`${spec.name ?? "spec"}: ${where}: ${why}`);
-  if (typeof spec.name !== "string" || !spec.name) return ["the spec has no name"];
-  if (!Array.isArray(spec.axes) || !Array.isArray(spec.properties) || !Array.isArray(spec.parts) || !Array.isArray(spec.variants) || !Array.isArray(spec.unmapped)) return [`${spec.name}: axes, properties, parts, variants and unmapped must be lists`];
-  const axisNames = /* @__PURE__ */ new Set();
-  for (const a of spec.axes) {
-    if (!a.name || axisNames.has(a.name)) at("axes", `"${a.name}" is missing or repeated`);
-    axisNames.add(a.name);
-    if (!Array.isArray(a.values) || !a.values.length) at(`axis ${a.name}`, "has no values");
-    else if (!a.values.includes(a.default)) at(`axis ${a.name}`, `default "${a.default}" is not one of its values`);
-  }
-  const props = /* @__PURE__ */ new Map();
-  for (const p of spec.properties) {
-    if (props.has(p.name)) at("properties", `"${p.name}" is repeated`);
-    props.set(p.name, p);
-    if (p.type !== "TEXT" && p.type !== "BOOLEAN") at(`property ${p.name}`, `type ${String(p.type)} is not TEXT or BOOLEAN`);
-    else if (typeof p.default !== (p.type === "TEXT" ? "string" : "boolean")) at(`property ${p.name}`, `default must be a ${p.type === "TEXT" ? "text" : "true or false"}`);
-  }
-  const parts = /* @__PURE__ */ new Map();
-  for (const part of spec.parts) {
-    if (!part.id || parts.has(part.id)) at("parts", `id "${part.id}" is missing or repeated`);
-    if (!PART_KINDS.has(part.kind)) at(`part ${part.id}`, `kind ${String(part.kind)} is not frame, text, icon or vector`);
-    if (part.parent === void 0) {
-      if ([...parts.values()].some((x) => x.parent === void 0)) at(`part ${part.id}`, "a second root (every other part needs a parent)");
-    } else if (!parts.has(part.parent)) at(`part ${part.id}`, `parent "${part.parent}" is not a part listed before it`);
-    else if (parts.get(part.parent).kind !== "frame") at(`part ${part.id}`, `parent "${part.parent}" is not a frame`);
-    if (part.layout && (!LAYOUT_DIRECTIONS.has(part.layout.direction) || !PRIMARY.has(part.layout.primary) || !COUNTER.has(part.layout.counter))) at(`part ${part.id}`, "layout is not a valid auto layout");
-    if (part.text !== void 0 && props.get(part.text)?.type !== "TEXT") at(`part ${part.id}`, `text property "${part.text}" does not exist`);
-    if (part.visible !== void 0 && props.get(part.visible)?.type !== "BOOLEAN") at(`part ${part.id}`, `visibility property "${part.visible}" does not exist`);
-    if (part.kind === "text" && part.text === void 0 && part.characters === void 0 && !part.swap) at(`part ${part.id}`, "a text part needs a TEXT property or its characters");
-    parts.set(part.id, part);
-  }
-  if (!spec.parts.length || spec.parts[0].parent !== void 0) at("parts", "the first part must be the root");
-  const expected = spec.axes.reduce((n, a) => n * (a.values?.length || 1), 1);
-  if (spec.variants.length !== expected) at("variants", `${spec.variants.length} variants for ${expected} combinations of the axes`);
-  const seen = /* @__PURE__ */ new Set();
-  for (const v of spec.variants) {
-    const key = variantKeyOf(v.props ?? {});
-    const where = `variant ${key}`;
-    if (seen.has(key)) at(where, "is repeated");
-    seen.add(key);
-    for (const a of spec.axes) if (!a.values?.includes(v.props?.[a.name] ?? "")) at(where, `${a.name} is not one of its values`);
-    for (const k of Object.keys(v.props ?? {})) if (!axisNames.has(k)) at(where, `${k} is not an axis`);
-    for (const [id, fields] of Object.entries(v.values ?? {})) {
-      const part = parts.get(id);
-      if (!part) {
-        at(where, `values for "${id}", which is not a part`);
-        continue;
-      }
-      for (const [field, value] of Object.entries(fields ?? {})) {
-        if (!SPEC_FIELDS.includes(field)) at(`${where}, ${id}`, `${field} is not a field`);
-        else if (value === null) {
-          if (!COLOR_FIELDS.has(field)) at(`${where}, ${id}`, `${field} cannot be empty (only colors can be none)`);
-        } else if (typeof value === "number") {
-          if (COLOR_FIELDS.has(field)) at(`${where}, ${id}`, `${field} cannot be a number`);
-        } else if (typeof value !== "string") at(`${where}, ${id}`, `${field} must be a token path, a number or none`);
-        else if (field === "textDecoration") {
-          if (!/^(UNDERLINE|STRIKETHROUGH|NONE)$/.test(value)) at(`${where}, ${id}`, `${value} is not a text decoration`);
-        } else if (tokenTypes) {
-          for (const path of value.startsWith("calc(") ? (value.match(/[A-Za-z][\w.-]*/g) ?? []).filter((x) => x !== "calc" && !/^\d|^px$/.test(x)) : [value]) {
-            const type = tokenTypes.get(path);
-            if (!type) at(`${where}, ${id}`, `${path} is not a token`);
-            else if (!value.startsWith("calc(") && !FIELD_TOKEN_TYPES(field).includes(type)) at(`${where}, ${id}`, `${path} is a ${type} token, ${field} needs ${FIELD_TOKEN_TYPES(field).join(" or ")}`);
-          }
-        }
-      }
-    }
-    for (const id of v.hidden ?? []) if (!parts.has(id)) at(where, `hides "${id}", which is not a part`);
-    for (const id of Object.keys(v.layout ?? {})) if (!parts.has(id)) at(where, `lays out "${id}", which is not a part`);
-    for (const [id, vec] of Object.entries(v.vectors ?? {})) if (parts.get(id)?.kind !== "vector" || !/^<svg[\s>]/.test(vec.svg)) at(where, `vector "${id}" is not a vector part with an SVG`);
-    for (const id of Object.keys(v.slots ?? {})) if (!parts.has(id)) at(where, `shows a component in "${id}", which is not a part`);
-  }
-  for (const [i, x] of (spec.interactions ?? []).entries()) {
-    const where = `interaction ${i + 1}`;
-    const axis = spec.axes.find((a) => a.name === x.axis);
-    if (!(x.trigger in TRIGGER_LABELS)) at(where, `trigger ${String(x.trigger)} is not one Figma has`);
-    if (!axis) at(where, `${x.axis} is not an axis`);
-    else if (!axis.values.includes(x.from) || !axis.values.includes(x.to) || x.from === x.to) at(where, `${x.from} to ${x.to} are not two values of ${x.axis}`);
-    for (const k of x.variants ?? []) if (!seen.has(k)) at(where, `variant ${k} does not exist`);
-    const t = x.transition;
-    if (t && (!(t.duration > 0) || t.easing.type === "CUSTOM_CUBIC_BEZIER" && (t.easing.bezier?.length !== 4 || t.easing.bezier.some((n) => typeof n !== "number")))) at(where, "the transition needs a duration and a valid easing");
-  }
-  return out;
-}
-function FIELD_TOKEN_TYPES(field) {
-  if (COLOR_FIELDS.has(field)) return ["color"];
-  if (field === "fontFamily") return ["fontFamily"];
-  if (field === "fontWeight") return ["fontWeight", "number"];
-  if (field === "opacity") return ["number"];
-  return ["dimension", "number"];
-}
-const iconComponentName = (name) => `Icon/${name}`;
-function specHash(text) {
-  let h = 2166136261;
-  for (let i = 0; i < text.length; i++) {
-    h ^= text.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return (h >>> 0).toString(16).padStart(8, "0");
-}
-function hashSpec(spec) {
-  const { hash: _ignored, example: _example, ...rest } = spec;
-  return specHash(JSON.stringify(rest));
-}
-const variantName = (props) => Object.entries(props).map(([k, v]) => `${k}=${v}`).join(", ");
-const variantKeyOf = (props) => Object.keys(props).sort().map((k) => `${k}=${props[k]}`).join(", ") || "Default";
-const REDUCED_MOTION_NOTE = "In code, reduced motion turns this off.";
-function componentMotion(spec) {
-  const keys = new Set(spec.variants.map((v) => variantKeyOf(v.props)));
-  const reactions = [];
-  const triggers = [];
-  for (const x of spec.interactions ?? []) {
-    const only = x.variants ? new Set(x.variants) : void 0;
-    let count = 0;
-    for (const v of spec.variants) {
-      if (v.props[x.axis] !== x.from) continue;
-      const fromKey = variantKeyOf(v.props);
-      if (only && !only.has(fromKey)) continue;
-      const to = { ...v.props, [x.axis]: x.to };
-      const toKey = variantKeyOf(to);
-      if (!keys.has(toKey)) continue;
-      reactions.push({ trigger: x.trigger, label: TRIGGER_LABELS[x.trigger], from: { ...v.props }, to, fromKey, toKey, transition: x.transition });
-      count++;
-    }
-    triggers.push({ ...x, label: TRIGGER_LABELS[x.trigger], count });
-  }
-  const transitions = (spec.interactions ?? []).map((x) => x.transition).filter((t) => !!t);
-  const cannotPlay = [...spec.motion ?? []];
-  const openNote = cannotPlay.find((n) => n.enter || n.exit);
-  const opening = openNote ? { enter: openNote.enter ?? null, exit: openNote.exit ?? null } : void 0;
-  const openTransitions = opening ? [opening.enter, opening.exit].filter((t) => !!t) : [];
-  const tokens = [
-    ...new Set([...transitions, ...openTransitions].flatMap((t) => [t.durationToken, t.easingToken]).concat(cannotPlay.map((n) => n.durationToken)).filter((t) => !!t))
-  ].sort();
-  const properties = [...new Set(transitions.flatMap((t) => t.properties))].sort();
-  const approximations = [...new Set(transitions.map((t) => t.approximated).filter((t) => !!t))];
-  const animates = transitions.length > 0 || openTransitions.length > 0 || cannotPlay.some((n) => /animation/i.test(n.what));
-  return { name: spec.name, reactions, triggers, tokens, properties, approximations, cannotPlay, opening, reducedMotion: animates ? REDUCED_MOTION_NOTE : void 0 };
-}
-function componentsUsingMotionToken(specs, tokenPath, chainOf) {
-  const out = /* @__PURE__ */ new Set();
-  for (const c of specs.components) {
-    for (const t of componentMotion(c).tokens) {
-      if (t === tokenPath || (chainOf?.(t) ?? []).includes(tokenPath)) out.add(c.name);
-    }
-  }
-  return [...out].sort();
-}
-function parseComponentSpecs(text) {
-  let data;
-  try {
-    data = JSON.parse(text);
-  } catch {
-    throw new Error("component-specs.json is not valid JSON.");
-  }
-  const f = data;
-  if (!f || typeof f !== "object" || !Array.isArray(f.components)) throw new Error('component-specs.json has no "components" list.');
-  if (f.version !== COMPONENT_SPECS_VERSION) throw new Error(`component-specs.json is version ${String(f.version)}; this tool reads version ${COMPONENT_SPECS_VERSION}.`);
-  return f;
-}
-const tokenCssVar = (path, prefix = "--", separator = "-") => `${prefix}${path.split(".").join(separator)}`;
-function figmaCell(entry) {
-  if (!entry) return void 0;
-  if (entry.status === "generated") return { label: "Yes" };
-  if (entry.status === "drafted") return { label: "Drafted", title: "Drafted with Claude where the code cannot be read on its own: in Figma, check it against the code." };
-  if (entry.status === "layout") return { label: "Auto layout", title: "A layout helper: nothing to draw, use auto layout in Figma." };
-  return { label: "Not yet", ...entry.reason ? { title: `Not supported yet: ${entry.reason}` } : {} };
-}
 export {
-  applyTokenEdits as $,
-  evaluatePairs as A,
-  contrastScope as B,
-  CONFIG_FILE as C,
-  contextLabel as D,
-  pathId as E,
-  flattenTokens as F,
-  serializeTokenFile as G,
-  removeToken as H,
-  upsertToken as I,
-  threeWayDiff as J,
-  emptyTokenFile as K,
-  parseTokenFile as L,
-  EXT_ID as M,
-  EXT_SCOPES as N,
-  moveToken as O,
-  effectiveScopes as P,
-  sameScopes as Q,
-  defaultScopes as R,
+  fromPlain as $,
+  effectiveScopes as A,
+  sameScopes as B,
+  defaultScopes as C,
+  readTokenAt as D,
+  EXT_ID as E,
+  modeFile as F,
+  defaultFile as G,
+  CONFIG_FILE as H,
+  loadConfig as I,
+  ConfigError as J,
+  DEFAULT_TOKEN_PATHS as K,
+  selectTokenFiles as L,
+  LayeredTokenSet as M,
+  resolveBranchPreviews as N,
+  tokensPath as O,
+  toConfigJson as P,
+  validateLayered as Q,
+  parseContrastChecks as R,
   SINGLE_MODE as S,
   TIER_NAMES as T,
-  readTokenAt as U,
-  modeFile as V,
-  defaultFile as W,
-  DEFAULT_PROTECTED_BRANCHES as X,
-  ProtectedBranchError as Y,
-  ConfigError as Z,
-  DEFAULT_TOKEN_PATHS as _,
-  assertSafeBranch as a,
-  changedModes as a$,
-  buildHistoryEntry as a0,
-  resolveBranchPreviews as a1,
-  tokensPath as a2,
-  coerceValue as a3,
-  toConfigJson as a4,
-  parseContrastChecks as a5,
-  checkLayeredPair as a6,
-  classifyRisk as a7,
-  formatChangeset as a8,
-  RISK_LABELS as a9,
-  OWNER_GROUPS as aA,
-  PREVIEW_APP_LABELS as aB,
-  PREVIEW_COMMENT_MARKER as aC,
-  PREVIEW_PLACEHOLDERS as aD,
-  PRIMITIVE_MODE as aE,
-  PRODUCT_LABEL_PREFIX as aF,
-  REDUCED_MOTION_NOTE as aG,
-  RIGHTS as aH,
-  RIGHT_LABEL as aI,
-  RISK_TIER as aJ,
-  SPEC_FIELDS as aK,
-  TIER_ORDER as aL,
-  TRIGGER_LABELS as aM,
-  TeamDirectory as aN,
-  UNRELEASED as aO,
-  VISUAL_CHECK_LABEL as aP,
-  affectedContrast as aQ,
-  appForProject as aR,
-  appUrl as aS,
-  approverEntries as aT,
-  approverLists as aU,
-  assignVersions as aV,
-  baseBranchOf as aW,
-  branchName as aX,
-  branchSlug as aY,
-  changeKind as aZ,
-  changeTable as a_,
-  parseJson as aa,
-  serializeJson as ab,
-  plainEqual as ac,
-  toPlain as ad,
-  getEntry as ae,
-  fromPlain as af,
-  previewLinks as ag,
-  slugify as ah,
-  readPreviewComment as ai,
-  findPreviewComment as aj,
-  previewsSettled as ak,
-  canShip as al,
-  whoCanShipSentence as am,
-  unreadableShipTeams as an,
-  AAA_MIN as ao,
-  AA_MIN as ap,
-  BULK_LIMIT as aq,
-  CONTRAST_CELL_MAX as ar,
-  CONTRAST_CHECKS_FILE as as,
-  DEFAULT_COMPONENT_SPECS_FILE as at,
-  DEFAULT_GOVERNANCE as au,
-  DEFAULT_OVERRIDE as av,
-  DEFAULT_PRODUCTS as aw,
-  DEFAULT_RIGHTS as ax,
-  DEFAULT_VISUAL_IMPACT as ay,
-  JsonParseError as az,
-  parseChangelog as b,
-  planToJson as b$,
-  changesetBump as b0,
-  classifyLayered as b1,
-  clearRawDeep as b2,
-  commitMessage as b3,
-  componentMotion as b4,
-  componentsUsingMotionToken as b5,
-  composeChangeset as b6,
-  composePrBody as b7,
-  composeProposalBody as b8,
-  composite as b9,
-  formatOwnerEntry as bA,
-  getChild as bB,
-  groupsPhrase as bC,
-  holdersOf as bD,
-  indexByPath as bE,
-  inheritedTypeAt as bF,
-  installCommand as bG,
-  installCommandFromPreviewComment as bH,
-  isGuardrail as bI,
-  isTeamEntry as bJ,
-  isTokenFile as bK,
-  isVercelComment as bL,
-  kindForMin as bM,
-  layeredImpact as bN,
-  luminance as bO,
-  modeLabel as bP,
-  nodesEqual as bQ,
-  normalizeRights as bR,
-  overrideKey as bS,
-  ownerEntryProblems as bT,
-  pairKey as bU,
-  parseChangesetText as bV,
-  parseComponentSpecs as bW,
-  parseOwnerEntry as bX,
-  parseVercelComment as bY,
-  planRestore as bZ,
-  planRevert as b_,
-  contextFor as ba,
-  contrastDelta as bb,
-  contrastDeltaTable as bc,
-  contrastLevel as bd,
-  contrastPair as be,
-  contrastRatio as bf,
-  countChanges as bg,
-  coverageSummary as bh,
-  defaultProduct as bi,
-  defaultTitle as bj,
-  defineConfig as bk,
-  detectLayout as bl,
-  diffLayered as bm,
-  entriesFor as bn,
-  entryLabel as bo,
-  expandEntries as bp,
-  expandOwners as bq,
-  fieldChanges as br,
-  figmaCell as bs,
-  fileModes as bt,
-  filterHistory as bu,
-  findProduct as bv,
-  findToken as bw,
-  findVercelComment as bx,
-  firstParagraph as by,
-  formatNumber as bz,
-  collectHistory as c,
-  previewComment as c0,
-  previewLinksOf as c1,
-  previewUrl as c2,
-  productForPlace as c3,
-  productLabel as c4,
-  productOfBranch as c5,
-  productProblems as c6,
-  productsOf as c7,
-  projectOfLabel as c8,
-  protectedBranchesOf as c9,
-  renderedColor as ca,
-  rightsProblems as cb,
-  runLayeredContrast as cc,
-  sameProducts as cd,
-  sameToken as ce,
-  shipPolicy as cf,
-  snapshotUrl as cg,
-  summarizeTokenChange as ch,
-  tarballAssetName as ci,
-  tarballUrl as cj,
-  teamKey as ck,
-  teamKeyOf as cl,
-  teamUnreadableMessage as cm,
-  teamsIn as cn,
-  titleOf as co,
-  toChangeSummary as cp,
-  toMap as cq,
-  tokenBump as cr,
-  tokenHistory as cs,
-  tokenNode as ct,
-  unreadableTeams as cu,
-  valueIn as cv,
-  variantName as cw,
-  versionTimeline as cx,
-  visualImpactProblems as cy,
-  buildReport as d,
-  prNumberFromSubject as e,
-  variantKeyOf as f,
-  layoutOptions as g,
-  hashSpec as h,
-  iconComponentName as i,
-  buildTokenSet as j,
-  defaultContext as k,
-  loadConfig as l,
-  mergeReleases as m,
-  resolve as n,
-  COMPONENT_SPECS_VERSION as o,
-  packageDirCandidates as p,
-  COLOR_FIELDS as q,
-  releasesFromTags as r,
-  specHash as s,
-  tokenCssVar as t,
-  modeDisplayName as u,
-  validateComponentSpec as v,
-  modesOf as w,
-  isMultiMode as x,
-  TIER_AXIS as y,
-  findReferenceProblems as z
+  classifyRisk as U,
+  RISK_LABELS as V,
+  parseJson as W,
+  serializeJson as X,
+  plainEqual as Y,
+  toPlain as Z,
+  getEntry as _,
+  modesOf as a,
+  entryLabel as a$,
+  previewLinks as a0,
+  slugify as a1,
+  readPreviewComment as a2,
+  findPreviewComment as a3,
+  previewsSettled as a4,
+  canShip as a5,
+  whoCanShipSentence as a6,
+  unreadableShipTeams as a7,
+  layoutOptions as a8,
+  buildTokenSet as a9,
+  aliasOf as aA,
+  appForProject as aB,
+  appUrl as aC,
+  approverEntries as aD,
+  approverLists as aE,
+  baseBranchOf as aF,
+  branchName as aG,
+  branchSlug as aH,
+  changeKind as aI,
+  changedModes as aJ,
+  clearRawDeep as aK,
+  colorToCss as aL,
+  colorsEqual as aM,
+  comboKey as aN,
+  commitMessage as aO,
+  compactJson as aP,
+  composePrBody as aQ,
+  composite as aR,
+  contextFor as aS,
+  contrastLevel as aT,
+  contrastPair as aU,
+  contrastRatio as aV,
+  defaultContext as aW,
+  defaultTitle as aX,
+  defineConfig as aY,
+  detectLayout as aZ,
+  entriesFor as a_,
+  productOfBranch as aa,
+  defaultProduct as ab,
+  AAA_MIN as ac,
+  AA_MIN as ad,
+  CONTRAST_CELL_MAX as ae,
+  CONTRAST_CHECKS_FILE as af,
+  DEFAULT_GOVERNANCE as ag,
+  DEFAULT_OVERRIDE as ah,
+  DEFAULT_PRODUCTS as ai,
+  DEFAULT_RIGHTS as aj,
+  DEFAULT_VISUAL_IMPACT as ak,
+  DTCG_TYPES as al,
+  JsonParseError as am,
+  OWNER_GROUPS as an,
+  PREVIEW_APP_LABELS as ao,
+  PREVIEW_COMMENT_MARKER as ap,
+  PREVIEW_PLACEHOLDERS as aq,
+  PRIMITIVE_MODE as ar,
+  PRODUCT_LABEL_PREFIX as as,
+  RIGHTS as at,
+  RIGHT_LABEL as au,
+  RISK_TIER as av,
+  TIER_ORDER as aw,
+  TeamDirectory as ax,
+  VISUAL_CHECK_LABEL as ay,
+  affectedContrast as az,
+  TIER_AXIS as b,
+  valueToCss as b$,
+  expandEntries as b0,
+  expandOwners as b1,
+  fieldChanges as b2,
+  findProduct as b3,
+  findToken as b4,
+  findVercelComment as b5,
+  flattenLayerFile as b6,
+  formatNumber as b7,
+  formatOwnerEntry as b8,
+  getChild as b9,
+  productForPlace as bA,
+  productLabel as bB,
+  productMarks as bC,
+  productProblems as bD,
+  productsOf as bE,
+  projectOfLabel as bF,
+  protectedBranchesOf as bG,
+  renderedColor as bH,
+  rgbaToDtcg as bI,
+  rightsProblems as bJ,
+  sameProducts as bK,
+  sameToken as bL,
+  shipPolicy as bM,
+  snapshotUrl as bN,
+  summarizeTokenChange as bO,
+  tarballAssetName as bP,
+  tarballUrl as bQ,
+  teamKey as bR,
+  teamKeyOf as bS,
+  teamUnreadableMessage as bT,
+  teamsIn as bU,
+  toAlias as bV,
+  toMap as bW,
+  tokenBump as bX,
+  tokenNode as bY,
+  unreadableTeams as bZ,
+  valueIn as b_,
+  globToRegExp as ba,
+  groupsPhrase as bb,
+  hexToRgba as bc,
+  holdersOf as bd,
+  indexByPath as be,
+  inheritedTypeAt as bf,
+  installCommand as bg,
+  installCommandFromPreviewComment as bh,
+  isGuardrail as bi,
+  isTeamEntry as bj,
+  isTokenFile as bk,
+  isVercelComment as bl,
+  kindForMin as bm,
+  layeredParityIssues as bn,
+  luminance as bo,
+  nodesEqual as bp,
+  normalizeRights as bq,
+  overrideKey as br,
+  ownerEntryProblems as bs,
+  pairKey as bt,
+  parseDimension as bu,
+  parseOwnerEntry as bv,
+  parseVercelComment as bw,
+  previewComment as bx,
+  previewLinksOf as by,
+  previewUrl as bz,
+  collectRefs as c,
+  visualImpactProblems as c0,
+  contrastScope as d,
+  evaluatePairs as e,
+  findReferenceProblems as f,
+  contextLabel as g,
+  isAlias as h,
+  isMultiMode as i,
+  aliasTarget as j,
+  flattenTokens as k,
+  emptyTokenFile as l,
+  modeDisplayName as m,
+  parseTokenFile as n,
+  EXT_SCOPES as o,
+  pathId as p,
+  parseColor as q,
+  removeToken as r,
+  serializeTokenFile as s,
+  threeWayDiff as t,
+  upsertToken as u,
+  valuesEqual as v,
+  rgbaToHex as w,
+  formatValue as x,
+  resolve as y,
+  moveToken as z
 };
-//# sourceMappingURL=component-spec-1z2ih4E3.js.map
+//# sourceMappingURL=pr-composer-D2SZm7cg.js.map