@bridge-ds/core 0.8.0 → 0.9.0

package/dist/component-spec-BzfBkYRD.js

@@ -0,0 +1,1122 @@
+import { bX as tokenBump, aI as changeKind, M as LayeredTokenSet, aA as aliasOf, bI as rgbaToDtcg, bc as hexToRgba, n as parseTokenFile, l as emptyTokenFile, s as serializeTokenFile, z as moveToken, r as removeToken, bf as inheritedTypeAt, u as upsertToken, D as readTokenAt, aN as comboKey, bH as renderedColor, aV as contrastRatio, w as rgbaToHex, U as classifyRisk, V as RISK_LABELS, ba as globToRegExp, a1 as slugify, Q as validateLayered } from "./pr-composer-D2SZm7cg.js";
+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 list = 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, `${list}${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 commitMessage = `${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,
+    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 list = file.coverage ?? file.components.map((c) => ({ name: c.name, status: "generated" }));
+  const generated = list.filter((c) => c.status === "generated").length;
+  const drafted = list.filter((c) => c.status === "drafted").length;
+  const layout = list.filter((c) => c.status === "layout").length;
+  return { generated, drafted, inFigma: generated + drafted, visual: list.length - layout, layout, total: list.length, missing: list.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 {
+  toChangeSummary as $,
+  composeChangeset as A,
+  BULK_LIMIT as B,
+  COLOR_FIELDS as C,
+  DEFAULT_PROTECTED_BRANCHES as D,
+  contrastDeltaTable as E,
+  countChanges as F,
+  coverageSummary as G,
+  figmaCell as H,
+  fileModes as I,
+  filterHistory as J,
+  firstParagraph as K,
+  hashSpec as L,
+  iconComponentName as M,
+  modeLabel as N,
+  parseChangesetText as O,
+  ProtectedBranchError as P,
+  parseComponentSpecs as Q,
+  REDUCED_MOTION_NOTE as R,
+  SPEC_FIELDS as S,
+  TRIGGER_LABELS as T,
+  UNRELEASED as U,
+  planRestore as V,
+  planRevert as W,
+  planToJson as X,
+  prNumberFromSubject as Y,
+  specHash as Z,
+  titleOf as _,
+  assertSafeBranch as a,
+  tokenCssVar as a0,
+  tokenHistory as a1,
+  validateComponentSpec as a2,
+  variantName as a3,
+  versionTimeline as a4,
+  parseChangelog as b,
+  collectHistory as c,
+  buildReport as d,
+  applyTokenEdits as e,
+  buildHistoryEntry as f,
+  coerceValue as g,
+  checkLayeredPair as h,
+  formatChangeset as i,
+  diffLayered as j,
+  contrastDelta as k,
+  runLayeredContrast as l,
+  mergeReleases as m,
+  layeredImpact as n,
+  classifyLayered as o,
+  packageDirCandidates as p,
+  composeProposalBody as q,
+  releasesFromTags as r,
+  COMPONENT_SPECS_VERSION as s,
+  DEFAULT_COMPONENT_SPECS_FILE as t,
+  assignVersions as u,
+  variantKeyOf as v,
+  changeTable as w,
+  changesetBump as x,
+  componentMotion as y,
+  componentsUsingMotionToken as z
+};
+//# sourceMappingURL=component-spec-BzfBkYRD.js.map