@flashdsm/genome 0.1.0

package/dist/index.js

@@ -0,0 +1,3775 @@
+#!/usr/bin/env node
+import {
+  GENOME_CONFIG_FILENAME,
+  GenomeConfigSchema,
+  LEGACY_CONFIG_FILENAME,
+  TokenCategorySchema,
+  TokenSchema,
+  TokenTypeSchema,
+  configCandidates,
+  getDesignTokens,
+  getImpact,
+  getModule,
+  getRelations,
+  listModules,
+  loadTokensFromFile,
+  makeChangePlan,
+  normalizeTokenDocument,
+  parseCategoryInput,
+  parseFlashAtomicDocument,
+  resolveTokenFilePath,
+  tokenChangeToPlanEntry
+} from "./chunk-6OCQZNS7.js";
+
+// src/index.ts
+import { resolve as resolve11 } from "path";
+import { fileURLToPath } from "url";
+import {
+  McpServer
+} from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+import { readFileSync, realpathSync } from "fs";
+import { readFile as readFile12 } from "fs/promises";
+
+// src/api.ts
+var ApiError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+  status;
+  body;
+};
+function createApiClient(opts) {
+  const baseUrl = opts.baseUrl.replace(/\/$/, "");
+  async function request(path, init) {
+    const headers = new Headers({ "Content-Type": "application/json" });
+    if (opts.accessToken) {
+      headers.set("Authorization", `Bearer ${opts.accessToken}`);
+    }
+    const res = await fetch(`${baseUrl}${path}`, { ...init, headers });
+    const text = await res.text();
+    let body;
+    if (text) {
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = text;
+      }
+    }
+    if (!res.ok) {
+      const msg = typeof body === "object" && body && "detail" in body && typeof body.detail === "string" ? body.detail : `HTTP ${res.status}`;
+      throw new ApiError(msg, res.status, body);
+    }
+    return body;
+  }
+  return {
+    health: () => request("/health"),
+    listDesignSystems: () => request("/api/v1/design-systems/"),
+    createFromCodeScan: (body) => request("/api/v1/design-systems/from-code-scan", {
+      method: "POST",
+      body: JSON.stringify(body)
+    }),
+    getDesignSystem: (id) => request(`/api/v1/design-systems/${id}`)
+  };
+}
+
+// src/load-components.ts
+import { readFile } from "fs/promises";
+import { dirname, isAbsolute, resolve } from "path";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseComponent(value) {
+  if (!isRecord(value) || typeof value.name !== "string") return null;
+  return value;
+}
+function normalizeComponentDocument(raw) {
+  if (Array.isArray(raw)) {
+    return {
+      components: raw.map(parseComponent).filter((c) => c !== null)
+    };
+  }
+  if (!isRecord(raw)) {
+    return { components: [] };
+  }
+  const name = typeof raw.name === "string" ? raw.name : void 0;
+  const list = Array.isArray(raw.components) ? raw.components : [];
+  return {
+    name,
+    components: list.map(parseComponent).filter((c) => c !== null)
+  };
+}
+async function readJsonObject(path) {
+  try {
+    const text = await readFile(path, "utf8");
+    const parsed = JSON.parse(text);
+    return isRecord(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveComponentsFilePath(options) {
+  const cwd = options.cwd ?? process.cwd();
+  if (options.componentsPath) {
+    return isAbsolute(options.componentsPath) ? options.componentsPath : resolve(cwd, options.componentsPath);
+  }
+  for (const configPath of configCandidates(options.configPath, cwd)) {
+    const raw = await readJsonObject(configPath);
+    if (!raw) continue;
+    const base = dirname(configPath);
+    if (raw.version === 2) {
+      const parsed = GenomeConfigSchema.safeParse(raw);
+      if (!parsed.success) continue;
+      const dir = parsed.data.outputs.genomeDir.replace(/\/+$/, "");
+      const named = `${dir}/components.json`;
+      return isAbsolute(named) ? named : resolve(base, named);
+    }
+    if (typeof raw.componentsFile !== "string") continue;
+    return isAbsolute(raw.componentsFile) ? raw.componentsFile : resolve(base, raw.componentsFile);
+  }
+  if (options.tokenFile) {
+    return resolve(dirname(options.tokenFile), "components.json");
+  }
+  return resolve(cwd, "components.json");
+}
+async function loadComponentsFromFile(componentsFile) {
+  const text = await readFile(componentsFile, "utf8");
+  const raw = JSON.parse(text);
+  const { components, name } = normalizeComponentDocument(raw);
+  return { source: componentsFile, components, name };
+}
+function filterComponentsByCategory(components, category) {
+  if (!category) return components;
+  const needle = category.toLowerCase();
+  return components.filter((c) => (c.category ?? "").toLowerCase() === needle);
+}
+function findComponentByName(components, name) {
+  const needle = name.toLowerCase();
+  return components.find((c) => c.name.toLowerCase() === needle);
+}
+
+// ../codegen/dist/shared/colorMath.js
+function normalizeHex(value) {
+  const m = /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(value.trim());
+  if (!m)
+    return null;
+  let hex = m[1].toLowerCase();
+  if (hex.length === 3)
+    hex = hex.split("").map((c) => c + c).join("");
+  return `#${hex.slice(0, 6)}`;
+}
+function srgbToLinear(c) {
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function hexToLinearRgb(hex) {
+  const normalized = normalizeHex(hex);
+  if (!normalized)
+    return null;
+  return [
+    srgbToLinear(parseInt(normalized.slice(1, 3), 16) / 255),
+    srgbToLinear(parseInt(normalized.slice(3, 5), 16) / 255),
+    srgbToLinear(parseInt(normalized.slice(5, 7), 16) / 255)
+  ];
+}
+function relativeLuminance(hex) {
+  const rgb = hexToLinearRgb(hex);
+  if (!rgb)
+    return null;
+  return 0.2126 * rgb[0] + 0.7152 * rgb[1] + 0.0722 * rgb[2];
+}
+function contrastRatio(a, b) {
+  const la = relativeLuminance(a);
+  const lb = relativeLuminance(b);
+  if (la === null || lb === null)
+    return null;
+  const [hi, lo] = la >= lb ? [la, lb] : [lb, la];
+  return (hi + 0.05) / (lo + 0.05);
+}
+function hexToOklab(hex) {
+  const rgb = hexToLinearRgb(hex);
+  if (!rgb)
+    return null;
+  const [r, g, b] = rgb;
+  const l_ = Math.cbrt(0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b);
+  const m_ = Math.cbrt(0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b);
+  const s_ = Math.cbrt(0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b);
+  return {
+    L: 0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,
+    a: 1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,
+    b: 0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_
+  };
+}
+function hexToOklch(hex) {
+  const lab = hexToOklab(hex);
+  if (!lab)
+    return null;
+  return {
+    l: lab.L,
+    c: Math.sqrt(lab.a * lab.a + lab.b * lab.b),
+    h: (Math.atan2(lab.b, lab.a) * 180 / Math.PI + 360) % 360
+  };
+}
+function hexToRgba(value) {
+  const raw = value.trim();
+  const m = /^#([0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(raw);
+  if (!m)
+    return null;
+  let hex = m[1];
+  if (hex.length <= 4) {
+    hex = hex.split("").map((c) => c + c).join("");
+  }
+  const n = (i) => parseInt(hex.slice(i, i + 2), 16);
+  return {
+    r: n(0),
+    g: n(2),
+    b: n(4),
+    a: hex.length === 8 ? Math.round(n(6) / 255 * 1e3) / 1e3 : 1
+  };
+}
+function round(n, places) {
+  const f = 10 ** places;
+  return Math.round(n * f) / f;
+}
+function formatColor(value, format) {
+  if (format === "hex")
+    return value;
+  const rgba = hexToRgba(value);
+  if (!rgba)
+    return value;
+  const { r, g, b, a } = rgba;
+  const alpha = a < 1 ? `, ${a}` : "";
+  if (format === "rgba") {
+    return a < 1 ? `rgba(${r}, ${g}, ${b}${alpha})` : `rgb(${r}, ${g}, ${b})`;
+  }
+  if (format === "hsl") {
+    const rn = r / 255;
+    const gn = g / 255;
+    const bn = b / 255;
+    const max = Math.max(rn, gn, bn);
+    const min = Math.min(rn, gn, bn);
+    const l = (max + min) / 2;
+    let h = 0;
+    let s = 0;
+    if (max !== min) {
+      const d = max - min;
+      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+      if (max === rn)
+        h = (gn - bn) / d + (gn < bn ? 6 : 0);
+      else if (max === gn)
+        h = (bn - rn) / d + 2;
+      else
+        h = (rn - gn) / d + 4;
+      h *= 60;
+    }
+    const body2 = `${round(h, 1)}, ${round(s * 100, 1)}%, ${round(l * 100, 1)}%`;
+    return a < 1 ? `hsla(${body2}${alpha})` : `hsl(${body2})`;
+  }
+  const solid = `#${[r, g, b].map((c) => c.toString(16).padStart(2, "0")).join("")}`;
+  const lch = hexToOklch(solid);
+  if (!lch)
+    return value;
+  const body = `${round(lch.l * 100, 2)}% ${round(lch.c, 4)} ${round(lch.c < 5e-4 ? 0 : lch.h, 2)}`;
+  return a < 1 ? `oklch(${body} / ${a})` : `oklch(${body})`;
+}
+
+// ../codegen/dist/shared/appearances.js
+var CONTRAST_ENHANCED = 7;
+var PAIRED_ROLES = [
+  "primary",
+  "secondary",
+  "accent",
+  "muted",
+  "control",
+  "destructive",
+  "success",
+  "warning",
+  "info"
+];
+function semanticPairs(names) {
+  const pairs = [];
+  if (names.has("background") && names.has("foreground")) {
+    pairs.push(["background", "foreground"]);
+  }
+  for (const role of PAIRED_ROLES) {
+    if (names.has(role) && names.has(`${role}-foreground`)) {
+      pairs.push([role, `${role}-foreground`]);
+    }
+  }
+  return pairs;
+}
+function splitRamp(name) {
+  const m = /^(.+?)-(\d{1,4})$/.exec(name);
+  if (!m)
+    return null;
+  const step = Number(m[2]);
+  return Number.isFinite(step) ? { family: m[1], step } : null;
+}
+function resolveToken(byName, name) {
+  let current = byName.get(name);
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; current && depth < 10; depth++) {
+    if (!(current.layer === "alias" && current.referencedTokenId))
+      return current;
+    if (seen.has(current.name))
+      return void 0;
+    seen.add(current.name);
+    current = byName.get(current.referencedTokenId);
+  }
+  return void 0;
+}
+function resolve2(byName, name) {
+  return resolveToken(byName, name)?.value ?? "";
+}
+function highContrastOverrides(palette) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const t of palette)
+    if (t?.name)
+      byName.set(t.name, t);
+  const ramps = /* @__PURE__ */ new Map();
+  for (const t of byName.values()) {
+    if (t.layer === "alias" || t.referencedTokenId)
+      continue;
+    const split = splitRamp(t.name);
+    if (!split || !normalizeHex(t.value ?? ""))
+      continue;
+    const list = ramps.get(split.family);
+    if (list)
+      list.push(t);
+    else
+      ramps.set(split.family, [t]);
+  }
+  const overrides = [];
+  for (const [surfaceName, foregroundName] of semanticPairs(new Set(byName.keys()))) {
+    const surface = resolve2(byName, surfaceName);
+    const foreground = resolve2(byName, foregroundName);
+    const current = contrastRatio(surface, foreground);
+    if (current === null || current >= CONTRAST_ENHANCED)
+      continue;
+    const via = resolveToken(byName, foregroundName);
+    const family = via ? splitRamp(via.name)?.family : void 0;
+    const steps = family ? ramps.get(family) ?? [] : [];
+    let best = null;
+    for (const step of steps) {
+      const ratio = contrastRatio(surface, step.value);
+      if (ratio === null || ratio < CONTRAST_ENHANCED)
+        continue;
+      if (!best || ratio < best.ratio)
+        best = { value: step.value, ratio };
+    }
+    if (!best)
+      continue;
+    overrides.push({
+      name: foregroundName,
+      value: best.value,
+      because: `${foregroundName} on ${surfaceName}: ${current.toFixed(2)}:1 becomes ${best.ratio.toFixed(2)}:1`
+    });
+  }
+  return overrides;
+}
+function resolvedValue(palette, name) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const t of palette)
+    if (t?.name)
+      byName.set(t.name, t);
+  const value = resolve2(byName, name);
+  return normalizeHex(value) ? value : null;
+}
+var DENSITY_SCALES = {
+  compact: 0.85,
+  comfortable: 1.15
+};
+var LENGTH = /^(-?\d*\.?\d+)(px|rem|em)$/;
+function densityOverrides(spacing, scale) {
+  const out = [];
+  for (const t of spacing) {
+    if (!t?.name || t.layer === "alias" || t.referencedTokenId)
+      continue;
+    const m = LENGTH.exec((t.value ?? "").trim());
+    if (!m)
+      continue;
+    const scaled = Number(m[1]) * scale;
+    if (!Number.isFinite(scaled) || scaled === 0)
+      continue;
+    const rounded = Number(scaled.toPrecision(6));
+    if (rounded === Number(m[1]) || rounded === 0)
+      continue;
+    out.push({
+      name: t.name,
+      value: `${rounded}${m[2]}`,
+      because: `${t.value} at ${scale}x`
+    });
+  }
+  return out;
+}
+
+// ../codegen/dist/tokens.js
+function tokensToCssVarName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function resolveAliasLiteral(byName, t) {
+  let current = t;
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; current && depth < 10; depth++) {
+    if (!(current.layer === "alias" && current.referencedTokenId)) {
+      return current.value;
+    }
+    if (seen.has(current.name))
+      return void 0;
+    seen.add(current.name);
+    current = byName.get(current.referencedTokenId);
+  }
+  return void 0;
+}
+function resolveTokenValue(t) {
+  if (t.layer === "alias" && t.referencedTokenId) {
+    return `var(--${tokensToCssVarName(t.referencedTokenId)})`;
+  }
+  return t.value;
+}
+function emitColorVars(colors, lines, elementSemantics = [], colorFormat = "hex") {
+  const primitives = colors.filter((t) => t.layer !== "alias");
+  const aliases = colors.filter((t) => t.layer === "alias");
+  if (primitives.length) {
+    lines.push("  /* Color Primitives */");
+    for (const t of primitives) {
+      lines.push(`  --${tokensToCssVarName(t.name)}: ${formatColor(t.value, colorFormat)};`);
+    }
+    lines.push("");
+  }
+  if (aliases.length || elementSemantics.length) {
+    lines.push("  /* Semantics */");
+    for (const t of aliases) {
+      lines.push(`  --${tokensToCssVarName(t.name)}: ${resolveTokenValue(t)};`);
+    }
+    for (const s of elementSemantics) {
+      lines.push(`  --${tokensToCssVarName(s.name)}: var(--${tokensToCssVarName(s.tokenName)});`);
+    }
+    lines.push("");
+  }
+}
+function unchangedPrimitiveNames(colors, lightColors) {
+  const dark = /* @__PURE__ */ new Map();
+  for (const t of colors) {
+    if (t.layer !== "alias" && !t.referencedTokenId)
+      dark.set(t.name, t.value ?? "");
+  }
+  const same2 = /* @__PURE__ */ new Set();
+  for (const t of lightColors) {
+    if (t.layer !== "alias" && !t.referencedTokenId && dark.get(t.name) === (t.value ?? "")) {
+      same2.add(t.name);
+    }
+  }
+  return same2;
+}
+function sharedAliasNames(colors, lightColors) {
+  const darkRefs = /* @__PURE__ */ new Map();
+  for (const t of colors) {
+    if (t.layer === "alias" && t.referencedTokenId) {
+      darkRefs.set(t.name, t.referencedTokenId);
+    }
+  }
+  const shared = /* @__PURE__ */ new Set();
+  for (const t of lightColors) {
+    if (t.layer === "alias" && t.referencedTokenId && darkRefs.get(t.name) === t.referencedTokenId) {
+      shared.add(t.name);
+    }
+  }
+  return shared;
+}
+function singleThemePalette(tokens) {
+  return tokens.colors.length ? tokens.colors : tokens.lightColors;
+}
+function motionTokens(tokens) {
+  return tokens.motion ?? [];
+}
+var NAMED_EASINGS = {
+  linear: [0, 0, 1, 1],
+  ease: [0.25, 0.1, 0.25, 1],
+  "ease-in": [0.42, 0, 1, 1],
+  "ease-out": [0, 0, 0.58, 1],
+  "ease-in-out": [0.42, 0, 0.58, 1]
+};
+function parseDuration(css) {
+  const m = /^\s*(-?[\d.]+)\s*(ms|s)\s*$/i.exec(css);
+  if (!m)
+    return null;
+  const value = Number(m[1]);
+  if (!Number.isFinite(value))
+    return null;
+  return { value, unit: m[2].toLowerCase() };
+}
+function parseCubicBezier(css) {
+  const trimmed = css.trim();
+  const named = NAMED_EASINGS[trimmed.toLowerCase()];
+  if (named)
+    return [...named];
+  const m = /^cubic-bezier\(([^)]+)\)$/i.exec(trimmed);
+  if (!m)
+    return null;
+  const parts = m[1].split(",").map((p) => Number(p.trim()));
+  if (parts.length !== 4 || parts.some((n) => !Number.isFinite(n)))
+    return null;
+  return parts;
+}
+function motionTokenKind(t) {
+  if (t.type === "duration" || t.type === "cubicBezier" || t.type === "transition")
+    return t.type;
+  const value = t.value.trim();
+  if (parseDuration(value))
+    return "duration";
+  if (parseCubicBezier(value) || /^linear\(/i.test(value))
+    return "cubicBezier";
+  const n = t.name.toLowerCase();
+  if (n.startsWith("duration-"))
+    return "duration";
+  if (n.startsWith("ease-") || n.startsWith("spring-"))
+    return "cubicBezier";
+  if (/\s/.test(value))
+    return "transition";
+  return null;
+}
+function splitTopLevel(css) {
+  const out = [];
+  let depth = 0;
+  let cur = "";
+  for (const ch of css.trim()) {
+    if (ch === "(")
+      depth++;
+    else if (ch === ")")
+      depth--;
+    if (depth === 0 && /\s/.test(ch)) {
+      if (cur)
+        out.push(cur);
+      cur = "";
+      continue;
+    }
+    cur += ch;
+  }
+  if (cur)
+    out.push(cur);
+  return out;
+}
+function decomposeTransition(css) {
+  const parts = splitTopLevel(css);
+  if (parts.length < 2 || parts.length > 3)
+    return null;
+  const isTime = (p) => parseDuration(p) !== null || /duration|delay/i.test(p);
+  const isEase = (p) => parseCubicBezier(p) !== null || /linear\(|ease|spring|cubic-bezier/i.test(p);
+  const duration = parts.find(isTime);
+  const timingFunction = parts.find((p) => p !== duration && isEase(p));
+  if (!duration || !timingFunction)
+    return null;
+  const delay = parts.find((p) => p !== duration && p !== timingFunction && isTime(p)) ?? "0ms";
+  return { duration, timingFunction, delay };
+}
+function motionAlias(css) {
+  const m = /^var\(\s*--([a-z0-9-]+)\s*(?:,[^)]*)?\)$/i.exec(css.trim());
+  return m ? `{motion.${m[1]}}` : null;
+}
+var FLASH_MODES_EXTENSION = "com.flashdsm.modes";
+function motionDtcgEntry(t, legacyDurationStrings = false) {
+  const base = t.description ? { $description: t.description } : {};
+  const encodeTime = (css) => {
+    const alias = motionAlias(css);
+    if (alias)
+      return alias;
+    const parsed = parseDuration(css);
+    if (!parsed)
+      return css;
+    return legacyDurationStrings ? `${parsed.value}${parsed.unit}` : parsed;
+  };
+  switch (motionTokenKind(t)) {
+    case "duration": {
+      const parsed = parseDuration(t.value);
+      if (parsed) {
+        return {
+          $type: "duration",
+          $value: legacyDurationStrings ? `${parsed.value}${parsed.unit}` : parsed,
+          ...base
+        };
+      }
+      break;
+    }
+    case "cubicBezier": {
+      const isLinearFn = /^linear\(/i.test(t.value.trim());
+      const curve = parseCubicBezier(isLinearFn ? t.fallbackValue ?? "" : t.value);
+      if (curve) {
+        return {
+          $type: "cubicBezier",
+          $value: curve,
+          ...base,
+          ...isLinearFn ? { $extensions: { "com.flashdsm.motion": { easing: t.value } } } : {}
+        };
+      }
+      break;
+    }
+    case "transition": {
+      const parts = decomposeTransition(t.value);
+      if (parts) {
+        return {
+          $type: "transition",
+          $value: {
+            duration: encodeTime(parts.duration),
+            delay: encodeTime(parts.delay),
+            timingFunction: motionAlias(parts.timingFunction) ?? parseCubicBezier(parts.timingFunction) ?? parts.timingFunction
+          },
+          ...base
+        };
+      }
+      break;
+    }
+  }
+  return { $type: t.type || "motion", $value: t.value, ...base };
+}
+function emitReducedMotion(motion, lines) {
+  const durations = motion.filter((t) => motionTokenKind(t) === "duration");
+  const distances = motion.filter((t) => tokensToCssVarName(t.name).startsWith("motion-distance"));
+  const scale = motion.find((t) => tokensToCssVarName(t.name) === "motion-scale");
+  if (!durations.length && !distances.length && !scale)
+    return;
+  const off = [];
+  const on = [];
+  if (scale) {
+    off.push(`  --${tokensToCssVarName(scale.name)}: 0.001;`);
+    on.push(`  --${tokensToCssVarName(scale.name)}: 1;`);
+  }
+  for (const t of durations) {
+    off.push(`  --${tokensToCssVarName(t.name)}: 0.001ms;`);
+    on.push(`  --${tokensToCssVarName(t.name)}: ${t.value};`);
+  }
+  for (const t of distances) {
+    off.push(`  --${tokensToCssVarName(t.name)}: 0px;`);
+    on.push(`  --${tokensToCssVarName(t.name)}: ${t.value};`);
+  }
+  lines.push("");
+  lines.push("/* Reduced motion - reduce, don't remove. */");
+  lines.push("@media (prefers-reduced-motion: reduce) {");
+  lines.push('  :root:not([data-motion="full"]) {');
+  for (const l of off)
+    lines.push(`  ${l}`);
+  lines.push("  }");
+  lines.push("}");
+  lines.push("");
+  lines.push("/* In-app override - wins over the OS setting, both directions. */");
+  lines.push('[data-motion="reduced"] {');
+  for (const l of off)
+    lines.push(l);
+  lines.push("}");
+  lines.push("");
+  lines.push('[data-motion="full"] {');
+  for (const l of on)
+    lines.push(l);
+  lines.push("}");
+}
+function emitOverrides(overrides, selectors, indent, lines, withReasons = false) {
+  selectors.forEach((selector, i) => {
+    const last = i === selectors.length - 1;
+    lines.push(`${indent}${selector}${last ? " {" : ","}`);
+  });
+  for (const o of overrides) {
+    const reason = withReasons ? ` /* ${o.because} */` : "";
+    lines.push(`${indent}  --${tokensToCssVarName(o.name)}: ${o.value};${reason}`);
+  }
+  lines.push(`${indent}}`);
+}
+function emitHighContrast(tokens, lines, colorFormat = "hex") {
+  const hasLight = tokens.lightColors.length > 0;
+  const hasDark = tokens.colors.length > 0;
+  const bothThemes = hasLight && hasDark;
+  const defaultPalette = hasDark ? tokens.colors : tokens.lightColors;
+  const otherPalette = bothThemes ? tokens.lightColors : [];
+  const defaults = highContrastOverrides(defaultPalette);
+  const others = bothThemes ? highContrastOverrides(otherPalette) : [];
+  if (!defaults.length && !others.length)
+    return;
+  const blockFor = (own, otherNames, palette) => {
+    const byName = new Map(own.map((o) => [o.name, o]));
+    for (const name of otherNames) {
+      if (byName.has(name))
+        continue;
+      const held = resolvedValue(palette, name);
+      if (!held)
+        continue;
+      byName.set(name, {
+        name,
+        value: held,
+        because: `unchanged here; the other theme moves it`
+      });
+    }
+    return [...byName.values()];
+  };
+  const spelled = (block) => block.map((o) => ({ ...o, value: formatColor(o.value, colorFormat) }));
+  const defaultBlock = spelled(blockFor(defaults, others.map((o) => o.name), defaultPalette));
+  const otherBlock = bothThemes ? spelled(blockFor(others, defaults.map((o) => o.name), otherPalette)) : [];
+  lines.push("");
+  lines.push("/* High contrast: only the foregrounds move, each to a step of its own ramp that reaches 7:1 */");
+  if (defaultBlock.length) {
+    lines.push("@media (prefers-contrast: more) {");
+    emitOverrides(defaultBlock, [":root"], "  ", lines, true);
+    lines.push("}");
+    emitOverrides(defaultBlock, [':root[data-contrast="more"]'], "", lines);
+  }
+  if (otherBlock.length) {
+    lines.push("");
+    lines.push("@media (prefers-contrast: more) {");
+    emitOverrides(otherBlock, ['[data-theme="light"]', ".light"], "  ", lines, true);
+    lines.push("}");
+    lines.push("@media (prefers-contrast: more) and (prefers-color-scheme: light) {");
+    emitOverrides(otherBlock, [':root:not([data-theme="dark"])'], "  ", lines);
+    lines.push("}");
+    emitOverrides(otherBlock, [
+      '[data-theme="light"][data-contrast="more"]',
+      '.light[data-contrast="more"]',
+      '[data-contrast="more"] [data-theme="light"]',
+      '[data-contrast="more"] .light'
+    ], "", lines);
+  }
+}
+function emitDensity(tokens, lines) {
+  for (const [name, scale] of Object.entries(DENSITY_SCALES)) {
+    const overrides = densityOverrides(tokens.spacing, scale);
+    if (!overrides.length)
+      continue;
+    lines.push("");
+    lines.push(`/* Density: ${name}, spacing at ${scale}x */`);
+    emitOverrides(overrides, [`[data-density="${name}"]`], "", lines);
+  }
+}
+function generateCSS(tokens, attribution = false, appearances = {}) {
+  const hasLightColors = tokens.lightColors.length > 0;
+  const hasDarkColors = tokens.colors.length > 0;
+  const hasBothThemes = hasLightColors && hasDarkColors;
+  const colorFormat = appearances.colorFormat ?? "hex";
+  const lines = [];
+  if (attribution) {
+    lines.push("/*");
+    lines.push(" * Design tokens generated by Flash DSM - https://flashdsm.com");
+    lines.push(" * Upgrade to a paid plan to remove this attribution.");
+    lines.push(" */");
+    lines.push("");
+  }
+  const knownColorVars = new Set([...tokens.colors, ...tokens.lightColors].map((t) => tokensToCssVarName(t.name)));
+  const allDeclaredVars = new Set([
+    ...knownColorVars,
+    ...tokens.spacing,
+    ...tokens.typography,
+    ...tokens.radius,
+    ...tokens.shadows,
+    ...tokens.border,
+    ...tokens.effects,
+    ...tokens.icons,
+    ...motionTokens(tokens)
+  ].map((t) => typeof t === "string" ? t : tokensToCssVarName(t.name)));
+  const takenSemanticVars = /* @__PURE__ */ new Set();
+  const semantics = (tokens.usageSemantics ?? []).filter((s) => {
+    const name = tokensToCssVarName(s.name);
+    if (!knownColorVars.has(tokensToCssVarName(s.tokenName)))
+      return false;
+    if (allDeclaredVars.has(name) || takenSemanticVars.has(name))
+      return false;
+    takenSemanticVars.add(name);
+    return true;
+  });
+  if (hasBothThemes) {
+    lines.push("/* Dark mode (default) */");
+    lines.push(":root {");
+    emitColorVars(tokens.colors, lines, semantics, colorFormat);
+  } else {
+    lines.push(":root {");
+    if (hasDarkColors)
+      emitColorVars(tokens.colors, lines, semantics, colorFormat);
+    else if (hasLightColors)
+      emitColorVars(tokens.lightColors, lines, semantics, colorFormat);
+  }
+  const nonColor = [
+    ["/* Spacing */", tokens.spacing],
+    ["/* Typography */", tokens.typography],
+    ["/* Border Radius */", tokens.radius],
+    ["/* Shadows */", tokens.shadows],
+    ["/* Border */", tokens.border],
+    ["/* Effects */", tokens.effects],
+    ["/* Icons */", tokens.icons],
+    ["/* Motion */", motionTokens(tokens)]
+  ];
+  for (const [c, group] of nonColor) {
+    if (!group.length)
+      continue;
+    lines.push(`  ${c}`);
+    for (const t of group) {
+      lines.push(`  --${tokensToCssVarName(t.name)}: ${resolveTokenValue(t)};`);
+    }
+    lines.push("");
+  }
+  lines.push("}");
+  if (hasBothThemes) {
+    const shared = sharedAliasNames(tokens.colors, tokens.lightColors);
+    const unchanged = unchangedPrimitiveNames(tokens.colors, tokens.lightColors);
+    const lightOnly = tokens.lightColors.filter((t) => t.layer === "alias" || t.referencedTokenId ? !shared.has(t.name) : !unchanged.has(t.name));
+    lines.push("");
+    lines.push("/* Light mode - explicit opt-in */");
+    if (shared.size) {
+      lines.push("/* Semantic aliases are declared once in :root; themes swap the values under them. */");
+    }
+    lines.push('[data-theme="light"],');
+    lines.push(".light {");
+    emitColorVars(lightOnly, lines, [], colorFormat);
+    lines.push("}");
+    lines.push("");
+    lines.push("/* Light mode - respects OS preference unless explicitly overridden */");
+    lines.push("@media (prefers-color-scheme: light) {");
+    lines.push('  :root:not([data-theme="dark"]) {');
+    const lp = lightOnly.filter((t) => t.layer !== "alias");
+    const la = lightOnly.filter((t) => t.layer === "alias");
+    for (const t of lp) {
+      lines.push(`    --${tokensToCssVarName(t.name)}: ${formatColor(t.value, colorFormat)};`);
+    }
+    for (const t of la) {
+      lines.push(`    --${tokensToCssVarName(t.name)}: ${resolveTokenValue(t)};`);
+    }
+    lines.push("  }");
+    lines.push("}");
+  }
+  if (appearances.highContrast)
+    emitHighContrast(tokens, lines, colorFormat);
+  if (appearances.density)
+    emitDensity(tokens, lines);
+  emitReducedMotion(motionTokens(tokens), lines);
+  return lines.join("\n");
+}
+function generateJSON(tokens, options = {}) {
+  const result = {};
+  const palette = singleThemePalette(tokens);
+  if (palette.length) {
+    result["color"] = {};
+    const defaultTheme = palette === tokens.colors ? "dark" : "light";
+    const otherTheme = defaultTheme === "dark" ? "light" : "dark";
+    const other = defaultTheme === "dark" ? tokens.lightColors : tokens.colors;
+    const keyOf = (t) => tokensToCssVarName(t.name);
+    const otherByKey = new Map(other.map((t) => [keyOf(t), t]));
+    const valueIn = (list) => {
+      const byName = new Map(list.map((t) => [t.name, t]));
+      return (t) => {
+        if (!(t.layer === "alias" && t.referencedTokenId))
+          return t.value;
+        const reference = `{color.${tokensToCssVarName(t.referencedTokenId)}}`;
+        if (!options.resolved)
+          return reference;
+        return resolveAliasLiteral(byName, t) ?? reference;
+      };
+    };
+    const defaultValue = valueIn(palette);
+    const otherValue = valueIn(other);
+    const entryFor = (t, $value) => ({
+      $value,
+      $type: "color",
+      ...t.description ? { $description: t.description } : {}
+    });
+    const modes = (dark, light) => ({
+      [FLASH_MODES_EXTENSION]: {
+        ...dark !== null ? { dark } : {},
+        ...light !== null ? { light } : {}
+      }
+    });
+    const oneThemeOnly = (theme, value) => theme === "dark" ? modes(value, null) : modes(null, value);
+    for (const t of palette) {
+      const $value = defaultValue(t);
+      const entry = entryFor(t, $value);
+      const twin = otherByKey.get(keyOf(t));
+      if (twin) {
+        const twinValue = otherValue(twin);
+        if (twinValue !== $value) {
+          entry.$extensions = defaultTheme === "dark" ? modes($value, twinValue) : modes(twinValue, $value);
+        }
+      } else if (other.length) {
+        entry.$extensions = oneThemeOnly(defaultTheme, $value);
+      }
+      result["color"][keyOf(t)] = entry;
+    }
+    const defaultKeys = new Set(palette.map(keyOf));
+    for (const t of other) {
+      if (defaultKeys.has(keyOf(t)))
+        continue;
+      const value = otherValue(t);
+      const entry = entryFor(t, value);
+      entry.$extensions = oneThemeOnly(otherTheme, value);
+      result["color"][keyOf(t)] = entry;
+    }
+  }
+  const sections = [
+    ["spacing", tokens.spacing],
+    ["typography", tokens.typography],
+    ["borderRadius", tokens.radius],
+    ["shadow", tokens.shadows]
+  ];
+  for (const [group, items] of sections) {
+    if (!items.length)
+      continue;
+    result[group] = {};
+    const keyFor = (name) => tokensToCssVarName(name).replace(new RegExp(`^${group}-?`), "") || name;
+    for (const t of items) {
+      const $value = t.layer === "alias" && t.referencedTokenId ? `{${group}.${keyFor(t.referencedTokenId)}}` : t.value;
+      result[group][keyFor(t.name)] = {
+        $value,
+        $type: t.type || group,
+        ...t.description ? { $description: t.description } : {}
+      };
+    }
+  }
+  const motion = motionTokens(tokens);
+  if (motion.length) {
+    result["motion"] = {};
+    for (const t of motion) {
+      result["motion"][tokensToCssVarName(t.name)] = motionDtcgEntry(t, options.legacyDurationStrings);
+    }
+  }
+  return JSON.stringify(result, null, 2);
+}
+var SD_LENGTH_RE = /^-?\d*\.?\d+(px|rem|em|pt)$/i;
+function styleDictionaryType(group, t, resolved = t.value) {
+  const value = (resolved ?? "").trim();
+  const isLength = SD_LENGTH_RE.test(value);
+  if (group === "color")
+    return "color";
+  if (group === "motion") {
+    return motionTokenKind(t) === "duration" ? "duration" : "cubicBezier";
+  }
+  if (group === "shadow")
+    return t.type || group;
+  if (group === "font") {
+    const name = tokensToCssVarName(t.name);
+    if (/famil|typeface|stack/.test(name))
+      return "fontFamily";
+    if (/weight/.test(name))
+      return "fontWeight";
+    if (/line-height|leading/.test(name))
+      return isLength ? "size" : "number";
+  }
+  return isLength ? "size" : t.type || group;
+}
+function generateStyleDictionary(tokens) {
+  const result = {};
+  const write = (group, items, keyFor) => {
+    if (!items.length)
+      return;
+    const byName = new Map(items.map((t) => [t.name, t]));
+    const resolveValue = (t) => resolveAliasLiteral(byName, t);
+    const bucket = {};
+    for (const t of items) {
+      const value = t.layer === "alias" && t.referencedTokenId ? `{${group}.${keyFor(t.referencedTokenId)}.value}` : t.value;
+      bucket[keyFor(t.name)] = {
+        value,
+        type: styleDictionaryType(group, t, resolveValue(t)),
+        ...t.description ? { comment: t.description } : {}
+      };
+    }
+    result[group] = bucket;
+  };
+  const stripped = (...prefixes) => (name) => {
+    let key = tokensToCssVarName(name);
+    for (const prefix of prefixes) {
+      key = key.replace(new RegExp(`^${prefix}-?`), "");
+    }
+    return key || tokensToCssVarName(name);
+  };
+  write("color", singleThemePalette(tokens), stripped());
+  write("size", tokens.spacing, stripped("spacing"));
+  write("radius", tokens.radius, stripped("radius"));
+  write("font", tokens.typography, stripped("typography", "font"));
+  write("shadow", tokens.shadows, stripped("shadow"));
+  write("border", tokens.border, stripped("border"));
+  write("motion", motionTokens(tokens), stripped());
+  return JSON.stringify(result, null, 2);
+}
+function generateStyleDictionaryConfig() {
+  const platform = (name, destination, format, options) => ({
+    transformGroup: name,
+    buildPath: `build/${name}/`,
+    files: [{ destination, format, ...options ? { options } : {} }]
+  });
+  return JSON.stringify({
+    source: ["tokens/style-dictionary.tokens.json"],
+    platforms: {
+      css: platform("css", "variables.css", "css/variables"),
+      scss: platform("scss", "_variables.scss", "scss/variables"),
+      "ios-swift": {
+        ...platform("ios-swift", "Tokens.swift", "ios-swift/class.swift", {
+          className: "Tokens"
+        })
+      },
+      android: platform("android", "tokens.xml", "android/resources"),
+      compose: platform("compose", "Tokens.kt", "compose/object", {
+        className: "Tokens",
+        packageName: "tokens"
+      })
+    }
+  }, null, 2);
+}
+function shortHash(input) {
+  let h = 5381;
+  for (let i = 0; i < input.length; i++) {
+    h = (h << 5) + h + input.charCodeAt(i) | 0;
+  }
+  return (h >>> 0).toString(16);
+}
+function tokenHashes(tokens) {
+  const out = {};
+  const all = [
+    ["colors", tokens.colors],
+    ["lightColors", tokens.lightColors],
+    ["spacing", tokens.spacing],
+    ["typography", tokens.typography],
+    ["radius", tokens.radius],
+    ["shadows", tokens.shadows],
+    ["border", tokens.border],
+    ["effects", tokens.effects],
+    ["icons", tokens.icons],
+    ["motion", motionTokens(tokens)]
+  ];
+  for (const [group, items] of all) {
+    for (const t of items) {
+      out[`${group}.${tokensToCssVarName(t.name)}`] = shortHash(`${t.value}|${t.layer || ""}|${t.referencedTokenId || ""}`);
+    }
+  }
+  return out;
+}
+
+// ../codegen/dist/from-atomic-document.js
+function atomicTokenToDesign(t, value = t.value) {
+  return {
+    name: t.name,
+    value,
+    type: t.type,
+    category: t.category,
+    ...t.description ? { description: t.description } : {},
+    ...t.layer ? { layer: t.layer } : {},
+    ...t.referencedTokenId ? { referencedTokenId: t.referencedTokenId } : {},
+    ...t.colorGroup ? { colorGroup: t.colorGroup } : {},
+    ...t.fallbackValue ? { fallbackValue: t.fallbackValue } : {},
+    ...t.metadata ? { metadata: t.metadata } : {}
+  };
+}
+function atomicThemeValues(t) {
+  const meta = t.metadata ?? {};
+  const dark = meta.dark || meta.darkValue;
+  const light = meta.light || meta.lightValue;
+  if (!dark && !light)
+    return [t.value, t.value];
+  return [dark ? String(dark) : null, light ? String(light) : null];
+}
+function fromAtomicDocument(doc) {
+  const f = doc.foundations;
+  const colors = [];
+  const lightColors = [];
+  const palette = [
+    ...f.colors ?? [],
+    ...(doc.semantics ?? []).map((t) => ({ ...t, layer: t.layer ?? "alias" }))
+  ];
+  for (const t of palette) {
+    const [dark, light] = atomicThemeValues(t);
+    if (dark !== null)
+      colors.push(atomicTokenToDesign(t, dark));
+    if (light !== null)
+      lightColors.push(atomicTokenToDesign(t, light));
+  }
+  return {
+    colors,
+    lightColors,
+    spacing: (f.spacing ?? []).map((t) => atomicTokenToDesign(t)),
+    typography: (f.typography ?? []).map((t) => atomicTokenToDesign(t)),
+    radius: (f.radius ?? []).map((t) => atomicTokenToDesign(t)),
+    shadows: (f.shadows ?? []).map((t) => atomicTokenToDesign(t)),
+    border: (f.border ?? []).map((t) => atomicTokenToDesign(t)),
+    motion: (f.motion ?? []).map((t) => atomicTokenToDesign(t)),
+    effects: (f.effects ?? []).map((t) => atomicTokenToDesign(t)),
+    icons: (f.icons ?? []).map((t) => atomicTokenToDesign(t))
+  };
+}
+function defaultStateBindings(component) {
+  const defaultBindings = component.bindings.filter((b) => (b.stateId ?? "default") === "default" && !b.variantId);
+  if (defaultBindings.length)
+    return defaultBindings;
+  const primaryVariant = component.variants[0]?.id;
+  if (!primaryVariant)
+    return component.bindings;
+  return component.bindings.filter((b) => (b.stateId ?? "default") === "default" && b.variantId === primaryVariant);
+}
+function slotToTailwind(slot, tokenId) {
+  const cssVar = `var(--${tokensToCssVarName(tokenId)})`;
+  switch (slot) {
+    case "background":
+      return `bg-[${cssVar}]`;
+    case "foreground":
+    case "color":
+      return `text-[${cssVar}]`;
+    case "accent":
+      return `accent-[${cssVar}]`;
+    case "border":
+      return `border border-[${cssVar}]`;
+    case "padding":
+      return `p-[${cssVar}]`;
+    case "margin":
+      return `m-[${cssVar}]`;
+    case "gap":
+      return `gap-[${cssVar}]`;
+    case "borderRadius":
+      return `rounded-[${cssVar}]`;
+    case "fontSize":
+      return `text-[${cssVar}]`;
+    case "fontWeight":
+      return `font-[${cssVar}]`;
+    case "lineHeight":
+      return `leading-[${cssVar}]`;
+    case "letterSpacing":
+      return `tracking-[${cssVar}]`;
+    case "boxShadow":
+      return `shadow-[${cssVar}]`;
+    case "minHeight":
+      return `min-h-[${cssVar}]`;
+    case "transition":
+      return `transition-[${cssVar}]`;
+    default:
+      return null;
+  }
+}
+function rootTagForComponent(id) {
+  switch (id) {
+    case "button":
+    case "icon-button":
+      return "button";
+    case "input":
+    case "search-input":
+    case "password-input":
+      return "input";
+    case "textarea":
+      return "textarea";
+    case "select":
+      return "select";
+    case "checkbox":
+    case "radio":
+    case "switch":
+      return "input";
+    case "a":
+    case "link":
+      return "a";
+    default:
+      return "div";
+  }
+}
+function atomicComponentsToExportSpecs(doc) {
+  return doc.components.map((component) => {
+    const classes = defaultStateBindings(component).map((b) => slotToTailwind(String(b.slot), b.tokenId)).filter((c) => Boolean(c));
+    const tag = rootTagForComponent(component.id);
+    const classAttr = classes.length > 0 ? ` className="${classes.join(" ")}"` : "";
+    const selfClosing = tag === "input";
+    const code = selfClosing ? `<${tag}${classAttr} />` : `<${tag}${classAttr}>${component.name}</${tag}>`;
+    return {
+      name: component.id,
+      category: component.category,
+      description: component.description,
+      code
+    };
+  });
+}
+
+// ../codegen/dist/shared/componentAliases.js
+var COMPONENT_ALIASES = {
+  TextField: ["input"],
+  TextInput: ["input"],
+  InputField: ["input"],
+  FormField: ["input"],
+  Field: ["input"],
+  Entry: ["input"],
+  TextBox: ["textarea", "input"],
+  MultilineInput: ["textarea"],
+  PasswordField: ["password-input", "input"],
+  PasswordInput: ["password-input", "input"],
+  NumberField: ["number-input", "input"],
+  NumberInput: ["number-input", "input"],
+  SpinButton: ["number-input", "input"],
+  SearchBar: ["search-input", "input"],
+  SearchField: ["search-input", "input"],
+  SearchBox: ["search-input", "input"],
+  OTP: ["otp-input", "input"],
+  PinInput: ["otp-input", "input"],
+  VerificationCode: ["otp-input", "input"],
+  Combobox: ["select", "dropdown-list"],
+  Autocomplete: ["select", "dropdown-list"],
+  Listbox: ["select", "dropdown-list"],
+  Picker: ["select", "dropdown-list"],
+  Menu: ["dropdown-list", "select"],
+  MenuList: ["dropdown-list", "select"],
+  ContextMenu: ["dropdown-list"],
+  TokenInput: ["multi-select", "select"],
+  TagsInput: ["multi-select", "select"],
+  CheckboxGroup: ["checkbox"],
+  Tickbox: ["checkbox"],
+  RadioGroup: ["radio"],
+  RadioButton: ["radio"],
+  OptionButton: ["radio"],
+  ToggleSwitch: ["switch", "toggle"],
+  ToggleButton: ["toggle", "switch"],
+  SegmentedControl: ["toggle", "tabs"],
+  RangeSlider: ["slider"],
+  Range: ["slider"],
+  Dialog: ["modal"],
+  AlertDialog: ["modal"],
+  Sheet: ["modal", "drawer"],
+  Popup: ["modal", "popover"],
+  Lightbox: ["modal"],
+  SideSheet: ["drawer", "sidebar"],
+  SidePanel: ["drawer", "sidebar"],
+  Offcanvas: ["drawer", "sidebar"],
+  Flyout: ["popover", "dropdown-list"],
+  HoverCard: ["popover", "tooltip"],
+  Hint: ["tooltip"],
+  Infotip: ["tooltip"],
+  Popper: ["tooltip", "popover"],
+  Snackbar: ["toast", "alert"],
+  Notification: ["toast", "alert"],
+  Notice: ["alert", "toast"],
+  Banner: ["alert"],
+  Callout: ["alert"],
+  InlineMessage: ["alert"],
+  InfoBox: ["alert"],
+  Tag: ["chip", "badge"],
+  Pill: ["chip", "badge"],
+  StatusBadge: ["badge", "chip"],
+  Counter: ["badge", "chip"],
+  DataGrid: ["data-table"],
+  Table: ["data-table"],
+  DataTable: ["data-table"],
+  Calendar: ["date-picker"],
+  DateField: ["date-picker"],
+  DateRangePicker: ["date-picker"],
+  ListView: ["list"],
+  ItemList: ["list"],
+  Repeater: ["list"],
+  CircularProgress: ["progress-indicator", "progress", "spinner"],
+  ProgressCircle: ["progress-indicator", "progress"],
+  ProgressBar: ["progress"],
+  LinearProgress: ["progress"],
+  Meter: ["progress"],
+  Gauge: ["progress"],
+  Loader: ["spinner"],
+  Loading: ["spinner"],
+  LoadingIndicator: ["spinner", "progress-indicator"],
+  ActivityIndicator: ["spinner"],
+  Throbber: ["spinner"],
+  Placeholder: ["skeleton"],
+  Shimmer: ["skeleton"],
+  LoadingSkeleton: ["skeleton"],
+  AppBar: ["navbar"],
+  TopBar: ["navbar"],
+  Toolbar: ["navbar"],
+  NavigationBar: ["navbar"],
+  Nav: ["navbar"],
+  SideNav: ["sidebar", "navbar"],
+  NavigationRail: ["sidebar", "navbar"],
+  TabBar: ["tabs"],
+  TabList: ["tabs"],
+  TabPanel: ["tabs"],
+  Breadcrumbs: ["breadcrumb"],
+  Crumbs: ["breadcrumb"],
+  Paginator: ["pagination"],
+  Pager: ["pagination"],
+  Stepper: ["pagination"],
+  Anchor: ["link"],
+  Hyperlink: ["link"],
+  NavLink: ["link"],
+  Panel: ["card"],
+  Tile: ["card"],
+  Collapse: ["accordion"],
+  Collapsible: ["accordion"],
+  Disclosure: ["accordion"],
+  Expander: ["accordion"],
+  Details: ["accordion"],
+  Separator: ["divider"],
+  Rule: ["divider"],
+  PageTitle: ["page-header"],
+  Masthead: ["page-header"],
+  TitleBar: ["page-header"],
+  Hero: ["page-header"],
+  BlankSlate: ["empty-state"],
+  NoData: ["empty-state"],
+  ZeroState: ["empty-state"],
+  ProfilePicture: ["avatar"],
+  UserPic: ["avatar"],
+  Initials: ["avatar"],
+  Img: ["image"],
+  Picture: ["image"],
+  Thumbnail: ["image"],
+  Glyph: ["icon"],
+  Symbol: ["icon"],
+  FAB: ["icon-button", "button"],
+  FloatingActionButton: ["icon-button", "button"],
+  ActionButton: ["icon-button", "button"],
+  DropdownButton: ["split-button", "button"],
+  ButtonGroup: ["split-button", "button"],
+  Btn: ["button"],
+  CTA: ["button"],
+  Submit: ["button"],
+  Video: ["video-frame"],
+  Player: ["video-frame"],
+  MediaFrame: ["video-frame"]
+};
+function aliasKey(name) {
+  return (name ?? "").toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+var ALIAS_INDEX = Object.fromEntries(Object.entries(COMPONENT_ALIASES).map(([alias, candidates]) => [
+  aliasKey(alias),
+  candidates
+]));
+function resolveComponentName(wanted, available) {
+  const lookup = /* @__PURE__ */ new Map();
+  for (const name of available) {
+    if (typeof name !== "string" || !name.trim())
+      continue;
+    const key2 = aliasKey(name);
+    if (!lookup.has(key2))
+      lookup.set(key2, name);
+  }
+  const key = aliasKey(wanted);
+  if (!key)
+    return null;
+  const direct = lookup.get(key);
+  if (direct !== void 0)
+    return direct;
+  for (const candidate of ALIAS_INDEX[key] ?? []) {
+    const found = lookup.get(aliasKey(candidate));
+    if (found !== void 0)
+      return found;
+  }
+  return null;
+}
+function aliasesFor(canonical, available) {
+  const key = aliasKey(canonical);
+  const ranked = [];
+  for (const [alias, candidates] of Object.entries(COMPONENT_ALIASES)) {
+    const keys = candidates.map(aliasKey);
+    const rank = keys.indexOf(key);
+    if (rank < 0)
+      continue;
+    if (aliasKey(alias) === key)
+      continue;
+    if (aliasKey(resolveComponentName(alias, available) ?? "") === key) {
+      ranked.push([rank, alias]);
+    }
+  }
+  return ranked.sort((a, b) => a[0] - b[0] || a[1].localeCompare(b[1])).map(([, alias]) => alias);
+}
+
+// ../codegen/dist/shared/tactileKit.js
+var TACTILE_CSS_PATH = "tokens/tactile.css";
+var TACTILE_COMPONENT_NAMES = /* @__PURE__ */ new Set([
+  "button",
+  "icon-button",
+  "switch",
+  "checkbox",
+  "slider",
+  "toggle"
+]);
+var HEADER = `Generated by Flash DSM Maker - tactile kit. Styles live in ${TACTILE_CSS_PATH}.`;
+
+// ../codegen/dist/shared/agentsMd.js
+var MAX_ALIASES_PER_COMPONENT = 8;
+var NAMED_PRIMITIVES = ["Box", "Stack", "Flex", "Grid", "Container"];
+function semanticRoles(tokens) {
+  const all = [
+    ...tokens.colors ?? [],
+    ...tokens.lightColors ?? []
+  ];
+  const byId = /* @__PURE__ */ new Map();
+  for (const token of all) {
+    if (token.name && !byId.has(token.name))
+      byId.set(token.name, token);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const token of all) {
+    const ref = token.referencedTokenId;
+    if (!ref || !token.name || seen.has(token.name))
+      continue;
+    seen.add(token.name);
+    const target = byId.get(ref);
+    out.push([
+      tokensToCssVarName(token.name),
+      tokensToCssVarName(target?.name ?? ref),
+      target?.value ?? token.value ?? ""
+    ]);
+  }
+  return out;
+}
+function componentLines(components) {
+  const names = components.map((c) => c.name).filter(Boolean);
+  const byName = new Map(components.map((c) => [c.name, c]));
+  const lines = [];
+  for (const name of [...names].sort()) {
+    const spec = byName.get(name);
+    let line = `- \`${name}\``;
+    if (spec?.description?.trim())
+      line += ` - ${spec.description.trim()}`;
+    lines.push(line);
+    const aliases = aliasesFor(name, names);
+    if (aliases.length) {
+      const shown = aliases.slice(0, MAX_ALIASES_PER_COMPONENT).join(", ");
+      lines.push(`  - Also known as: ${shown}`);
+    }
+  }
+  return lines;
+}
+function interactionsBlock(components) {
+  const kit = components.map((c) => c.name).filter((name) => TACTILE_COMPONENT_NAMES.has(name)).sort();
+  const which = kit.length ? `the ${kit.map((n) => `\`${n}\``).join(", ")} components` : "the kit's controls";
+  return `
+## Interactions
+
+This system uses the tactile kit. \`${TACTILE_CSS_PATH}\` gives ${which}
+their look and motion: pill surfaces, ink for selected states, a 90ms press
+and a small spring on release.
+
+- Use these components as they are. Do not restyle their \`tk-*\` classes,
+  add transitions to them, or rebuild them with utility classes.
+- Keep the native input inside the switch, checkbox, segmented control and
+  slider. Their state lives there (\`:checked\`, \`:has()\`), so swapping it
+  for a \`div\` breaks the behaviour and the accessibility together.
+- To change the motion, change the tokens (\`--ease-spring\`,
+  \`--ease-bounce\`, \`--duration-press\`), not the stylesheet.
+`;
+}
+function generateAgentsMd(options) {
+  const { projectName, tokens, components, library, interactionKit } = options;
+  const lines = componentLines(components);
+  const componentsBlock = lines.length ? `Build with these - they live in \`components/\`. Do not create a second
+version of one that already exists, and do not import a component from
+another UI library to fill a gap.
+
+${lines.join("\n")}` : `This export ships no components. Style plain elements with the tokens
+in \`tokens/tokens.css\`.`;
+  const roles = semanticRoles(tokens);
+  const rolesBlock = roles.length ? `Style with the role, never the primitive underneath it.
+\`var(--primary)\` survives a rebrand; \`var(--primary-500)\` and a raw hex
+do not.
+
+${roles.map(([role, ref, value]) => `- \`--${role}\` \u2192 \`var(--${ref})\`${value ? ` (${value})` : ""}`).join("\n")}` : `This export has no semantic colour layer - use the named tokens in
+\`tokens/tokens.css\`.`;
+  const libraryNote = library ? `
+This project is themed for **${library}**. Its theme file under
+\`theme/\` is generated from the same tokens - change tokens, not the theme.
+` : "";
+  return `# ${projectName}
+
+Instructions for AI coding agents working in this project. Its UI is built
+on a design system exported from Flash DSM.
+
+Token reference: \`tokens/tokens.css\` (CSS custom properties) and
+\`tokens/tokens.json\` (DTCG).
+${libraryNote}
+## Rules
+
+1. Use a component from the catalogue below before writing a new one. If
+   nothing fits, compose from existing components rather than inventing a
+   new primitive.
+2. Style only with the tokens this system defines. No hex codes, no
+   arbitrary Tailwind values (\`bg-[#1e293b]\`), no inline pixel sizes.
+3. Prefer the semantic colour roles over the primitives they point at.
+4. Keep the foreground/background pairs as defined - they are tuned for
+   WCAG AA contrast. Do not mix a foreground from one pair with a
+   background from another.
+5. If a value you need has no token, say so in your response instead of
+   hardcoding it. A flagged gap is fixable; a hardcoded hex is invisible.
+
+## Components
+
+${componentsBlock}
+${interactionKit === "tactile" ? interactionsBlock(components) : ""}
+## Layout
+
+${NAMED_PRIMITIVES.map((p) => `\`${p}\``).join(", ")}
+are not components in this system - they are layout primitives from other
+libraries. Use plain elements (\`div\`, \`section\`, \`ul\`) with this
+system's spacing tokens instead of reaching for a component that does not
+exist here.
+
+## Colour roles
+
+${rolesBlock}
+
+## Do not
+
+- Do not install or import another UI library (MUI, Chakra, Ant, Radix,
+  Bootstrap) to satisfy a requirement. If this system cannot express it,
+  say so.
+- Do not invent a component name. Every name you import must appear in the
+  catalogue above.
+- Do not hardcode a colour, spacing, radius, shadow or font size that has
+  a token.
+- Do not restyle a component inline to make it look like a different
+  variant. Use the variant the system defines.
+`;
+}
+
+// ../codegen/dist/shared/motionPrune.js
+var CORE_MOTION = /* @__PURE__ */ new Set([
+  "duration-fast",
+  "duration-normal",
+  "duration-slow",
+  "ease-in",
+  "ease-out",
+  "ease-in-out",
+  "motion-enter",
+  "motion-exit",
+  "motion-transition",
+  "motion-scale",
+  "motion-distance-sm",
+  "motion-distance-md",
+  "motion-distance-lg"
+]);
+var VAR_REF_RE = /var\(\s*--([a-z0-9-]+)/gi;
+function collectVarRefs(text, into) {
+  for (const match of text.matchAll(VAR_REF_RE)) {
+    into.add(match[1].toLowerCase());
+  }
+}
+function pruneUnusedMotionTokens(tokens, components = []) {
+  const motion = tokens.motion ?? [];
+  if (!motion.length)
+    return tokens;
+  const motionNames = /* @__PURE__ */ new Map();
+  for (const t of motion) {
+    if (t?.name)
+      motionNames.set(t.name.toLowerCase(), t);
+  }
+  const referenced = /* @__PURE__ */ new Set();
+  const otherCategories = [
+    tokens.colors,
+    tokens.lightColors,
+    tokens.spacing,
+    tokens.typography,
+    tokens.radius,
+    tokens.shadows,
+    tokens.border,
+    tokens.effects,
+    tokens.icons
+  ];
+  for (const list of otherCategories) {
+    for (const t of list ?? [])
+      collectVarRefs(t?.value ?? "", referenced);
+  }
+  for (const c of components)
+    collectVarRefs(c?.code ?? "", referenced);
+  const keep = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const name of motionNames.keys()) {
+    if (CORE_MOTION.has(name) || referenced.has(name)) {
+      keep.add(name);
+      queue.push(name);
+    }
+  }
+  while (queue.length) {
+    const token = motionNames.get(queue.pop());
+    if (!token)
+      continue;
+    const refs = /* @__PURE__ */ new Set();
+    collectVarRefs(token.value ?? "", refs);
+    if (token.referencedTokenId)
+      refs.add(token.referencedTokenId.toLowerCase());
+    for (const ref of refs) {
+      if (motionNames.has(ref) && !keep.has(ref)) {
+        keep.add(ref);
+        queue.push(ref);
+      }
+    }
+  }
+  if (keep.size === motionNames.size)
+    return tokens;
+  return {
+    ...tokens,
+    motion: motion.filter((t) => keep.has((t?.name ?? "").toLowerCase()))
+  };
+}
+
+// ../codegen/dist/repo-token-diff.js
+var GROUP_SECTIONS = {
+  spacing: "spacing",
+  typography: "typography",
+  borderRadius: "radius",
+  shadow: "shadows"
+};
+var BUNDLE_SECTION = {
+  colors: "design-tokens-dark-colors",
+  lightColors: "design-tokens-light-colors",
+  spacing: "design-tokens-spacing",
+  typography: "design-tokens-typography",
+  radius: "design-tokens-radius",
+  shadows: "design-tokens-shadow"
+};
+function groupKey(group, name) {
+  return tokensToCssVarName(name).replace(new RegExp(`^${group}-?`), "") || name;
+}
+var HEX = /^#[0-9a-f]{3,8}$/i;
+function same(a, b) {
+  const x = a.trim();
+  const y = b.trim();
+  return HEX.test(x) && HEX.test(y) ? x.toLowerCase() === y.toLowerCase() : x === y;
+}
+var isReference = (value) => /^\{[^}]+\}$/.test(value.trim());
+function modesOf(entry) {
+  const modes = entry.$extensions?.[FLASH_MODES_EXTENSION];
+  return modes && typeof modes === "object" ? modes : null;
+}
+function themeValue(entry, theme, defaultTheme, web) {
+  const value = typeof entry.$value === "string" ? entry.$value : void 0;
+  if (theme === defaultTheme && web && value !== void 0 && typeof web.$value === "string" && !same(value, web.$value)) {
+    return value;
+  }
+  const modes = modesOf(entry);
+  if (modes) {
+    const own = modes[theme];
+    return typeof own === "string" ? own : void 0;
+  }
+  return value;
+}
+function parseTree(text) {
+  try {
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function diffRepoTokens(doc, repoDtcg) {
+  const tokens = fromAtomicDocument(doc);
+  const web = JSON.parse(generateJSON(tokens));
+  const repo = parseTree(repoDtcg);
+  const edits = [];
+  const findings = [];
+  if (!repo) {
+    findings.push({
+      path: "(file)",
+      code: "unreadable",
+      reason: "The tokens file is not a JSON object any more. Fix it, or pull again to restore it."
+    });
+    return { edits, findings };
+  }
+  const compare = (path, section, name, before, after, theme) => {
+    if (before === void 0 || after === void 0)
+      return;
+    if (same(before, after))
+      return;
+    if (isReference(before) || isReference(after)) {
+      findings.push({
+        path,
+        code: "alias",
+        before,
+        after,
+        reason: "This token is an alias, or became one. Re-point aliases in Flash; a push only carries literal values."
+      });
+      return;
+    }
+    edits.push({
+      path,
+      section,
+      name,
+      ...theme ? { theme } : {},
+      before,
+      after
+    });
+  };
+  const presence = (group, webGroup) => {
+    const repoGroup = repo[group] ?? {};
+    for (const key of Object.keys(repoGroup)) {
+      if (key.startsWith("$") || key in webGroup)
+        continue;
+      findings.push({
+        path: `${group}.${key}`,
+        code: "added-in-repo",
+        reason: "Not in the design system. Add it in Flash, then pull; a push does not create tokens."
+      });
+    }
+    for (const key of Object.keys(webGroup)) {
+      if (key in repoGroup)
+        continue;
+      findings.push({
+        path: `${group}.${key}`,
+        code: "removed-in-repo",
+        reason: "Deleted from the file but still in the design system. A push does not remove tokens; delete it in Flash if that is the intent."
+      });
+    }
+  };
+  const webColors = web.color ?? {};
+  presence("color", webColors);
+  const palette = singleThemePalette(tokens);
+  const defaultTheme = palette === tokens.colors ? "dark" : "light";
+  const names = {
+    dark: new Map(tokens.colors.map((t) => [tokensToCssVarName(t.name), t])),
+    light: new Map(tokens.lightColors.map((t) => [tokensToCssVarName(t.name), t]))
+  };
+  for (const [key, webEntry] of Object.entries(webColors)) {
+    const repoEntry = repo.color?.[key];
+    if (!repoEntry)
+      continue;
+    for (const theme of ["dark", "light"]) {
+      const token = names[theme].get(key);
+      if (!token)
+        continue;
+      compare(`color.${key}`, BUNDLE_SECTION[theme === "dark" ? "colors" : "lightColors"], token.name, themeValue(webEntry, theme, defaultTheme), themeValue(repoEntry, theme, defaultTheme, webEntry), theme);
+    }
+  }
+  for (const [group, field] of Object.entries(GROUP_SECTIONS)) {
+    const webGroup = web[group];
+    if (!webGroup)
+      continue;
+    presence(group, webGroup);
+    const byKey = new Map(tokens[field].map((t) => [groupKey(group, t.name), t]));
+    for (const [key, webEntry] of Object.entries(webGroup)) {
+      const repoEntry = repo[group]?.[key];
+      const token = byKey.get(key);
+      if (!repoEntry || !token)
+        continue;
+      if (typeof webEntry.$value !== "string")
+        continue;
+      if (typeof repoEntry.$value !== "string")
+        continue;
+      compare(`${group}.${key}`, BUNDLE_SECTION[field], token.name, webEntry.$value, repoEntry.$value);
+    }
+  }
+  return { edits, findings };
+}
+
+// ../codegen/dist/repo-bundle.js
+var DEFAULT_REPO_BUNDLE_PATHS = {
+  tokensDtcg: "design-tokens.json",
+  tokensCss: "tokens.css",
+  styleDictionary: null,
+  styleDictionaryConfig: null,
+  agentsMd: "AGENTS.md"
+};
+function hashRepoFiles(files) {
+  const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+  const framed = sorted.map((f) => `${f.path.length}:${f.path}${f.content.length}:${f.content}`);
+  return shortHash(`${framed.length}:${framed.join("")}`);
+}
+function documentToRepoBundle(doc, options = {}) {
+  const paths = {
+    ...DEFAULT_REPO_BUNDLE_PATHS,
+    ...options.paths
+  };
+  const components = atomicComponentsToExportSpecs(doc);
+  const tokens = pruneUnusedMotionTokens(fromAtomicDocument(doc), components);
+  const projectName = options.projectName ?? doc.name;
+  const files = [];
+  if (paths.tokensDtcg) {
+    files.push({ path: paths.tokensDtcg, content: generateJSON(tokens) });
+  }
+  if (paths.tokensCss) {
+    files.push({
+      path: paths.tokensCss,
+      content: generateCSS(tokens, options.attribution === true)
+    });
+  }
+  if (paths.styleDictionary) {
+    files.push({
+      path: paths.styleDictionary,
+      content: generateStyleDictionary(tokens)
+    });
+  }
+  if (paths.styleDictionaryConfig) {
+    files.push({
+      path: paths.styleDictionaryConfig,
+      content: generateStyleDictionaryConfig()
+    });
+  }
+  if (paths.agentsMd) {
+    files.push({
+      path: paths.agentsMd,
+      content: generateAgentsMd({
+        projectName,
+        tokens,
+        components,
+        ...options.library ? { library: options.library } : {}
+      })
+    });
+  }
+  return {
+    files,
+    hashes: tokenHashes(tokens),
+    contentHash: hashRepoFiles(files)
+  };
+}
+
+// src/document.ts
+var TYPES = new Set(TokenTypeSchema.options);
+var CATEGORIES = new Set(TokenCategorySchema.options);
+var CATEGORY_ALIASES = {
+  color: "colors",
+  shadows: "shadow",
+  effect: "effects",
+  icon: "icons",
+  borders: "border",
+  font: "typography",
+  fonts: "typography"
+};
+var TYPE_FOR_CATEGORY = {
+  colors: "color",
+  spacing: "size",
+  typography: "font",
+  radius: "radius",
+  shadow: "shadow",
+  motion: "motion",
+  border: "border",
+  effects: "effect",
+  icons: "icon"
+};
+function normaliseToken(token, fallbackCategory) {
+  if (!token || typeof token !== "object" || Array.isArray(token)) return token;
+  const t = { ...token };
+  if (typeof t.category === "string" && !CATEGORIES.has(t.category)) {
+    t.category = CATEGORY_ALIASES[t.category] ?? fallbackCategory ?? t.category;
+  }
+  if (typeof t.type === "string" && !TYPES.has(t.type)) {
+    const category = typeof t.category === "string" && CATEGORIES.has(t.category) ? t.category : CATEGORY_ALIASES[t.type] ?? t.type;
+    t.type = TYPE_FOR_CATEGORY[category] ?? t.type;
+  }
+  return t;
+}
+var FOUNDATION_CATEGORY = {
+  colors: "colors",
+  typography: "typography",
+  spacing: "spacing",
+  radius: "radius",
+  shadows: "shadow",
+  motion: "motion",
+  border: "border",
+  effects: "effects",
+  icons: "icons"
+};
+function normaliseServerDocument(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return input;
+  const doc = { ...input };
+  const foundations = doc.foundations;
+  if (foundations && typeof foundations === "object" && !Array.isArray(foundations)) {
+    const next = {};
+    for (const [key, list] of Object.entries(foundations)) {
+      next[key] = Array.isArray(list) ? list.map((t) => normaliseToken(t, FOUNDATION_CATEGORY[key])) : list;
+    }
+    doc.foundations = next;
+  }
+  if (Array.isArray(doc.semantics)) {
+    doc.semantics = doc.semantics.map((t) => normaliseToken(t));
+  }
+  return doc;
+}
+function parseServerDocument(input) {
+  return parseFlashAtomicDocument(normaliseServerDocument(input));
+}
+
+// src/tools/pull-from-web.ts
+import { join as join2, resolve as resolve4 } from "path";
+
+// src/lock.ts
+import { readFile as readFile2 } from "fs/promises";
+import { z } from "zod";
+var GENOME_LOCK_BASENAME = "genome.lock";
+var GenomeLockSchema = z.object({
+  version: z.literal(1),
+  genomeId: z.number().int().positive(),
+  /** The web revision these files were projected from. */
+  revision: z.union([z.string(), z.number()]),
+  /** `documentToRepoBundle`'s hash over the files it wrote. */
+  contentHash: z.string().min(1),
+  /** ISO timestamp of the pull, for a human reading the file. */
+  pulledAt: z.string().min(1),
+  /** The paths the pull wrote, so a later drift check knows what to hash. */
+  files: z.array(z.string().min(1)).default([]),
+  /**
+   * Each written file's own hash, so a drift check can say *which* files
+   * moved rather than only that something did. Empty in locks written before
+   * it existed; those still answer the yes-or-no question through
+   * `contentHash`.
+   */
+  fileHashes: z.record(z.string(), z.string()).default({})
+});
+function renderLock(lock) {
+  return `${JSON.stringify(lock, null, 2)}
+`;
+}
+async function readLock(path) {
+  const raw = await readFile2(path, "utf8").catch(() => null);
+  if (!raw) return null;
+  try {
+    const parsed = GenomeLockSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/write-plan.ts
+import { mkdir, readFile as readFile3, realpath, writeFile } from "fs/promises";
+import { dirname as dirname2, isAbsolute as isAbsolute2, join, relative, resolve as resolve3 } from "path";
+var MAX_HUNKS = 20;
+function hunks(before, after) {
+  const a = before.split("\n");
+  const b = after.split("\n");
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start++;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA--;
+    endB--;
+  }
+  const removed = a.slice(start, endA);
+  const added = b.slice(start, endB);
+  const out = [];
+  for (const line of removed.slice(0, MAX_HUNKS)) out.push(`- ${line}`);
+  if (removed.length > MAX_HUNKS) {
+    out.push(`\u2026 ${removed.length - MAX_HUNKS} more removed`);
+  }
+  for (const line of added.slice(0, MAX_HUNKS)) out.push(`+ ${line}`);
+  if (added.length > MAX_HUNKS) {
+    out.push(`\u2026 ${added.length - MAX_HUNKS} more added`);
+  }
+  return out.join("\n");
+}
+function safeJoin(root, path) {
+  if (isAbsolute2(path)) return null;
+  const full = resolve3(join(root, path));
+  const rel = relative(resolve3(root), full);
+  if (rel.startsWith("..") || isAbsolute2(rel)) return null;
+  return full;
+}
+async function containedAfterLinks(root, full) {
+  let dir = dirname2(full);
+  let realDir = null;
+  for (let depth = 0; depth < 64; depth++) {
+    realDir = await realpath(dir).catch(() => null);
+    if (realDir) break;
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (!realDir) return true;
+  const realRoot = await realpath(root).catch(() => null) ?? resolve3(root);
+  const rel = relative(realRoot, join(realDir, relative(dir, full)));
+  return !rel.startsWith("..") && !isAbsolute2(rel);
+}
+async function writeFiles(files, opts) {
+  const root = resolve3(opts.workspaceRoot);
+  const confirm = opts.confirm === true;
+  const entries = [];
+  const written = [];
+  for (const file of files) {
+    const full = safeJoin(root, file.path);
+    if (full === null) {
+      entries.push({
+        action: "flag",
+        targetKind: "file",
+        path: file.path,
+        code: "outside-workspace",
+        reason: "This path leaves the workspace root, so Genome will not write it. Fix the outputs entry in genome.config.json."
+      });
+      continue;
+    }
+    if (!await containedAfterLinks(root, full)) {
+      entries.push({
+        action: "flag",
+        targetKind: "file",
+        path: file.path,
+        code: "outside-workspace",
+        reason: "A directory on this path is a link out of the workspace, so Genome will not write through it."
+      });
+      continue;
+    }
+    const before = await readFile3(full, "utf8").catch(() => null);
+    if (before !== null && file.createOnly) {
+      entries.push({
+        action: "skip",
+        targetKind: "file",
+        path: file.path,
+        reason: "Written once, then yours to edit. Genome leaves it alone."
+      });
+      continue;
+    }
+    if (before === file.content) {
+      entries.push({ action: "skip", targetKind: "file", path: file.path });
+      continue;
+    }
+    entries.push({
+      action: before === null ? "create" : "update",
+      targetKind: "file",
+      path: file.path,
+      ...before === null ? {} : { reason: hunks(before, file.content) }
+    });
+    if (!confirm) continue;
+    try {
+      await mkdir(dirname2(full), { recursive: true });
+      await writeFile(full, file.content, "utf8");
+      written.push(file.path);
+    } catch (err) {
+      entries[entries.length - 1] = {
+        action: "flag",
+        targetKind: "file",
+        path: file.path,
+        code: "write-failed",
+        reason: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+  return { ...makeChangePlan(entries, !confirm), written };
+}
+
+// src/tools/pull-from-web.ts
+function inDir(dir, name) {
+  return `${dir.replace(/\/+$/, "")}/${name}`;
+}
+function parseIconFiles(text) {
+  if (!text?.trim()) return {};
+  const parsed = JSON.parse(text);
+  const files = parsed?.files;
+  if (!files || typeof files !== "object" || Array.isArray(files)) return {};
+  const out = {};
+  for (const [path, content] of Object.entries(files)) {
+    if (typeof content === "string") out[path] = content;
+  }
+  return out;
+}
+function iconFilePath(iconsDir, serverPath) {
+  const relative2 = serverPath.replace(/^icons\//, "");
+  if (!relative2 || relative2.startsWith("/") || relative2.includes("\\") || relative2.split("/").some((segment) => segment === ".." || segment === "")) {
+    return null;
+  }
+  return inDir(iconsDir, relative2);
+}
+async function pullFromWeb(opts) {
+  const envelope = await opts.client.getGenome();
+  if (!envelope?.document) {
+    throw new Error(
+      "This design system has no v2 document to project. Open it in Flash and save once, then pull again."
+    );
+  }
+  if (envelope.id !== opts.config.genomeId) {
+    throw new Error(
+      `This token belongs to design system #${envelope.id}, but genome.config.json names #${opts.config.genomeId}. Run link again, or use the token for #${opts.config.genomeId}.`
+    );
+  }
+  const doc = parseServerDocument(envelope.document);
+  const { outputs } = opts.config;
+  const bundle = documentToRepoBundle(doc, {
+    projectName: envelope.name,
+    paths: {
+      tokensDtcg: outputs.tokensDtcg,
+      tokensCss: outputs.tokensCss,
+      // The Style Dictionary source and AGENTS.md are not part of the token
+      // projection: the first is opt-in, and the second comes from the
+      // server so the repo and the hosted kit say the same thing.
+      styleDictionary: null,
+      styleDictionaryConfig: null,
+      agentsMd: null
+    }
+  });
+  const files = bundle.files.map((f) => ({
+    path: f.path,
+    content: f.content
+  }));
+  const dir = outputs.genomeDir;
+  files.push({
+    path: inDir(dir, "components.json"),
+    content: `${JSON.stringify(
+      doc.components.map((c) => ({
+        id: c.id,
+        name: c.name,
+        category: c.category,
+        ...c.description ? { description: c.description } : {},
+        variants: c.variants.map((v) => v.name),
+        states: c.states
+      })),
+      null,
+      2
+    )}
+`
+  });
+  const kit = await opts.client.readResource("flash://design-system/kit.md").catch(() => null);
+  if (kit) files.push({ path: inDir(dir, "kit.md"), content: kit });
+  const componentDocs = await opts.client.readResource("flash://design-system/components.md").catch(() => null);
+  if (componentDocs && componentDocs.trim()) {
+    files.push({ path: inDir(dir, "components.md"), content: componentDocs });
+  }
+  const iconFiles = await opts.client.readResource("flash://design-system/icon-files.json").then(parseIconFiles).catch(() => ({}));
+  const iconsDir = opts.config.outputs.icons ?? inDir(dir, "icons");
+  for (const [serverPath, content] of Object.entries(iconFiles)) {
+    const local = iconFilePath(iconsDir, serverPath);
+    if (local) files.push({ path: local, content });
+  }
+  const lockPath = inDir(dir, GENOME_LOCK_BASENAME);
+  const previous = await readLock(join2(resolve4(opts.workspaceRoot), lockPath));
+  const contentHash = hashRepoFiles(
+    files.map((f) => ({ path: f.path, content: f.content }))
+  );
+  const result = await writeFiles(files, {
+    workspaceRoot: opts.workspaceRoot,
+    confirm: opts.confirm
+  });
+  const accepted = new Set(
+    result.entries.filter((e) => e.action !== "flag").map((e) => e.path)
+  );
+  const sameFiles = previous !== null && previous.files.length === accepted.size && previous.files.every((f) => accepted.has(f));
+  const unchanged = sameFiles && previous.contentHash === contentHash && String(previous.revision) === String(envelope.revision);
+  const fileHashes = {};
+  for (const f of files) {
+    if (accepted.has(f.path)) {
+      fileHashes[f.path] = hashRepoFiles([
+        { path: f.path, content: f.content }
+      ]);
+    }
+  }
+  const lock = {
+    version: 1,
+    genomeId: envelope.id,
+    revision: envelope.revision,
+    contentHash,
+    pulledAt: unchanged ? previous.pulledAt : (/* @__PURE__ */ new Date()).toISOString(),
+    files: [...accepted],
+    fileHashes
+  };
+  const lockResult = await writeFiles(
+    [{ path: lockPath, content: renderLock(lock) }],
+    {
+      workspaceRoot: opts.workspaceRoot,
+      confirm: opts.confirm
+    }
+  );
+  let recorded = false;
+  const codebase = opts.config.codebase;
+  if (opts.confirm === true && codebase) {
+    const tokenFilesLanded = bundle.files.some((f) => accepted.has(f.path));
+    const componentsLanded = accepted.has(inDir(dir, "components.json"));
+    const items = [
+      ...componentsLanded ? [
+        ...doc.components.map((c) => ({
+          type: "component",
+          id: c.id,
+          name: c.name
+        })),
+        ...doc.modules.map((m) => ({
+          type: "module",
+          id: m.id,
+          name: m.name
+        }))
+      ] : [],
+      // The token projection is pulled whole; one event stands for it.
+      ...tokenFilesLanded ? [{ type: "token", name: "all" }] : []
+    ];
+    if (items.length) {
+      try {
+        await opts.client.callTool("record_pull", {
+          codebase_id: codebase.id,
+          codebase_name: codebase.name,
+          revision: envelope.revision,
+          items
+        });
+        recorded = true;
+      } catch {
+        recorded = false;
+      }
+    }
+  }
+  const entries = [...result.entries, ...lockResult.entries];
+  return {
+    ...makeChangePlan(entries, opts.confirm !== true),
+    written: [...result.written, ...lockResult.written],
+    genomeId: envelope.id,
+    name: envelope.name,
+    revision: envelope.revision,
+    contentHash,
+    recorded
+  };
+}
+
+// src/tools/detect-drift.ts
+import { readFile as readFile5 } from "fs/promises";
+import { join as join4, resolve as resolve6 } from "path";
+
+// src/tools/repo-state.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join3, resolve as resolve5 } from "path";
+function lockPathFor(config) {
+  return `${config.outputs.genomeDir.replace(/\/+$/, "")}/${GENOME_LOCK_BASENAME}`;
+}
+async function readRepoState(opts) {
+  const envelope = await opts.client.getGenome();
+  if (!envelope?.document) {
+    throw new Error(
+      "This design system has no v2 document to compare against. Open it in Flash and save once, then try again."
+    );
+  }
+  if (envelope.id !== opts.config.genomeId) {
+    throw new Error(
+      `This token belongs to design system #${envelope.id}, but genome.config.json names #${opts.config.genomeId}. Run link again, or use the token for #${opts.config.genomeId}.`
+    );
+  }
+  const root = resolve5(opts.workspaceRoot);
+  const lock = await readLock(join3(root, lockPathFor(opts.config)));
+  const tokensPath = opts.config.outputs.tokensDtcg;
+  const tokensText = await readFile4(join3(root, tokensPath), "utf8").catch(
+    () => null
+  );
+  return {
+    envelope,
+    doc: parseServerDocument(envelope.document),
+    lock,
+    tokensPath,
+    tokensText
+  };
+}
+
+// src/tools/detect-drift.ts
+async function detectDrift(opts) {
+  const state = await readRepoState(opts);
+  const { envelope, lock } = state;
+  if (!lock) {
+    return {
+      ...makeChangePlan([], true),
+      genomeId: envelope.id,
+      local: { drifted: false, files: [], missing: [] },
+      remote: {
+        drifted: false,
+        pulledRevision: null,
+        revision: envelope.revision
+      },
+      pushable: 0,
+      summary: "This repo has never pulled, so there is nothing to drift from. Run pull_from_web first."
+    };
+  }
+  const root = resolve6(opts.workspaceRoot);
+  const current = [];
+  const moved = [];
+  const missing = [];
+  for (const path of lock.files) {
+    const content = await readFile5(join4(root, path), "utf8").catch(() => null);
+    if (content === null) {
+      missing.push(path);
+      continue;
+    }
+    current.push({ path, content });
+    const recorded = lock.fileHashes[path];
+    if (recorded && recorded !== hashRepoFiles([{ path, content }])) {
+      moved.push(path);
+    }
+  }
+  const localDrifted = missing.length > 0 || hashRepoFiles(current) !== lock.contentHash;
+  const remoteDrifted = String(lock.revision) !== String(envelope.revision);
+  const entries = [];
+  let pushable = 0;
+  if (state.tokensText !== null) {
+    const diff = diffRepoTokens(state.doc, state.tokensText);
+    pushable = diff.edits.length;
+    for (const edit of diff.edits) {
+      entries.push({
+        action: "flag",
+        targetKind: "token",
+        path: edit.theme ? `${edit.path} (${edit.theme})` : edit.path,
+        before: edit.before,
+        after: edit.after,
+        code: "repo-edit",
+        reason: "Changed in the repo. push_to_web proposes it for review in Flash."
+      });
+    }
+    for (const finding of diff.findings) {
+      entries.push({
+        action: "flag",
+        targetKind: "token",
+        path: finding.path,
+        before: finding.before ?? null,
+        after: finding.after ?? null,
+        code: finding.code,
+        reason: finding.reason
+      });
+    }
+  }
+  let summary;
+  if (!localDrifted && !remoteDrifted) {
+    summary = "In step: the repo holds exactly what it pulled, and Flash has not moved.";
+  } else if (remoteDrifted && localDrifted) {
+    summary = `Both moved: Flash is at revision ${envelope.revision}, the repo pulled ${lock.revision}, and the repo has edits of its own. A push is refused while Flash is ahead, because it cannot tell your edits from Flash's. Keep a copy of the flagged values, pull, re-apply them, then push.`;
+  } else if (remoteDrifted) {
+    summary = `Flash moved from revision ${lock.revision} to ${envelope.revision}. Run pull_from_web to bring the repo up to date.`;
+  } else if (pushable > 0) {
+    summary = `The repo changed ${pushable} token value${pushable === 1 ? "" : "s"}. Run push_to_web to propose ${pushable === 1 ? "it" : "them"} for review in Flash.`;
+  } else {
+    summary = "The repo's files changed, but no token value a push can carry. See the flagged entries.";
+  }
+  return {
+    ...makeChangePlan(entries, true),
+    genomeId: envelope.id,
+    local: { drifted: localDrifted, files: moved, missing },
+    remote: {
+      drifted: remoteDrifted,
+      pulledRevision: lock.revision,
+      revision: envelope.revision
+    },
+    pushable,
+    summary
+  };
+}
+
+// src/tools/push-to-web.ts
+function findingEntry(finding) {
+  return {
+    action: "flag",
+    targetKind: "token",
+    path: finding.path,
+    before: finding.before ?? null,
+    after: finding.after ?? null,
+    code: finding.code,
+    reason: finding.reason
+  };
+}
+async function pushToWeb(opts) {
+  const state = await readRepoState(opts);
+  const { envelope, lock } = state;
+  if (!lock) {
+    throw new Error(
+      "This repo has never pulled, so there is no baseline to push from. Run pull_from_web first."
+    );
+  }
+  if (String(lock.revision) !== String(envelope.revision)) {
+    throw new Error(
+      `Flash has moved on since this repo pulled (revision ${lock.revision}, now ${envelope.revision}). A push now could undo those changes. Keep a copy of your edits, pull, re-apply them, then push.`
+    );
+  }
+  if (state.tokensText === null) {
+    throw new Error(
+      `${state.tokensPath} is missing, so there is nothing to push. Pull again to restore it.`
+    );
+  }
+  const { edits, findings } = diffRepoTokens(state.doc, state.tokensText);
+  const flagged = findings.map(findingEntry);
+  const base = {
+    genomeId: envelope.id,
+    revision: envelope.revision,
+    findings
+  };
+  if (!edits.length) {
+    return {
+      ...makeChangePlan(flagged, true),
+      ...base,
+      status: "no_changes",
+      changeSetId: null,
+      message: findings.length ? "No token value changed. The flagged entries are things a push does not carry." : "No token value changed since the last pull."
+    };
+  }
+  const planned = edits.map((edit) => ({
+    action: "update",
+    targetKind: "token",
+    path: edit.theme ? `${edit.path} (${edit.theme})` : edit.path,
+    before: edit.before,
+    after: edit.after
+  }));
+  if (opts.confirm !== true) {
+    return {
+      ...makeChangePlan([...planned, ...flagged], true),
+      ...base,
+      status: "dry_run",
+      changeSetId: null,
+      message: `${edits.length} token value${edits.length === 1 ? "" : "s"} to propose for review. Run again with confirm to open the change set in Flash.`
+    };
+  }
+  const codebase = opts.config.codebase?.name ?? opts.config.name;
+  const response = await opts.client.callTool(
+    "propose_change_set",
+    {
+      base_revision: envelope.revision,
+      source_label: `Genome \xB7 ${codebase}`,
+      changes: edits.map((edit) => ({
+        section: edit.section,
+        name: edit.name,
+        value: edit.after
+      }))
+    }
+  );
+  const skipped = (response.skipped ?? []).map((s) => ({
+    action: "flag",
+    targetKind: "token",
+    path: `${s.section}/${s.name}`,
+    code: "skipped-by-server",
+    reason: s.reason
+  }));
+  const proposed = (response.diff ?? []).map(tokenChangeToPlanEntry);
+  return {
+    ...makeChangePlan([...proposed, ...skipped, ...flagged], false),
+    ...base,
+    status: response.no_changes ? "no_changes" : "proposed",
+    changeSetId: response.change_set_id ?? null,
+    message: response.message ?? (response.no_changes ? "Flash already has these values, or the same proposal is waiting for review." : "Proposed for review. Open Sync in Flash to apply or discard it.")
+  };
+}
+
+// src/tools/graph.ts
+async function graphDocument(client) {
+  const envelope = await client.getGenome();
+  if (!envelope?.document) {
+    throw new Error(
+      "These tools read the v2 document, and this system is not on schema v2 yet. Use get_tokens instead."
+    );
+  }
+  return normaliseServerDocument(envelope.document);
+}
+async function runGraphTool(client, tool, args) {
+  const doc = await graphDocument(client);
+  switch (tool) {
+    case "list_modules":
+      return { modules: listModules(doc) };
+    case "get_module": {
+      const wanted = args.module?.trim();
+      if (!wanted) throw new Error("Missing required argument: module");
+      const found = getModule(doc, wanted);
+      if (!found.found) {
+        const shown = found.available.slice(0, 30).join(", ") || "none";
+        throw new Error(`Module '${wanted}' not found. Available: ${shown}`);
+      }
+      return found.module;
+    }
+    case "get_relations": {
+      const ref = args.token?.trim() || void 0;
+      const relations = getRelations(doc, ref);
+      if (ref !== void 0 && "found" in relations && !relations.found) {
+        throw new Error(`Token '${ref}' not found in this system.`);
+      }
+      return relations;
+    }
+    case "get_impact": {
+      const wanted = args.token?.trim();
+      if (!wanted) throw new Error("Missing required argument: token");
+      const impact = getImpact(doc, wanted);
+      if (!impact.found) {
+        throw new Error(`Token '${wanted}' not found in this system.`);
+      }
+      return impact;
+    }
+  }
+}
+
+// src/tools/sync-context.ts
+var CREATE_ONLY = true;
+async function syncContext(opts) {
+  const { outputs } = opts.config;
+  const files = [];
+  const agents = await opts.client.readResource("flash://design-system/AGENTS.md").catch(() => null);
+  if (agents) {
+    files.push({
+      path: outputs.agentsMd,
+      content: agents,
+      createOnly: CREATE_ONLY
+    });
+  }
+  const rules = await opts.client.callTool("get_agent_rules").catch(() => null);
+  if (typeof rules === "string" && rules.trim()) {
+    files.push({
+      path: outputs.cursorRules,
+      content: ensureTrailingNewline(rules)
+    });
+  }
+  const skill = await opts.client.readResource("flash://design-system/SKILL.md").catch(() => null);
+  if (skill) {
+    files.push({
+      path: `${outputs.genomeDir.replace(/\/+$/, "")}/SKILL.md`,
+      content: skill
+    });
+  }
+  if (!files.length) {
+    throw new Error(
+      "The server returned no agent context to write. Check the token is still valid and the design system has been saved at least once."
+    );
+  }
+  return writeFiles(files, {
+    workspaceRoot: opts.workspaceRoot,
+    confirm: opts.confirm
+  });
+}
+function ensureTrailingNewline(text) {
+  return text.endsWith("\n") ? text : `${text}
+`;
+}
+
+// src/workspace.ts
+import { readFile as readFile6 } from "fs/promises";
+import { resolve as resolve7 } from "path";
+
+// src/rpc.ts
+var TOOL_ERROR = -32e3;
+var RpcError = class extends Error {
+  constructor(message, code, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "RpcError";
+  }
+  code;
+  data;
+};
+function unwrapToolResult(result) {
+  if (typeof result !== "object" || result === null) return result;
+  const envelope = result;
+  const text = envelope.content?.find((c) => c.type === "text")?.text;
+  if (text === void 0) return result;
+  if (envelope.isError) throw new RpcError(text, TOOL_ERROR);
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function createRpcClient(opts) {
+  const baseUrl = opts.baseUrl.replace(/\/$/, "");
+  const doFetch = opts.fetchImpl ?? fetch;
+  let nextId = 1;
+  async function rpc(method, params = {}) {
+    const res = await doFetch(`${baseUrl}/api/v1/mcp`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream",
+        Authorization: `Bearer ${opts.token}`
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: nextId++,
+        method,
+        params
+      })
+    });
+    const text = await res.text();
+    if (!res.ok) {
+      const hint = res.status === 401 ? "The MCP token was rejected. Mint a new one in Flash under Connect, and set FLASH_GENOME_TOKEN." : `HTTP ${res.status}`;
+      throw new RpcError(hint, res.status, text.slice(0, 500));
+    }
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      throw new RpcError(
+        "The server did not answer with JSON-RPC",
+        -32700,
+        text.slice(0, 500)
+      );
+    }
+    if (body.error) {
+      throw new RpcError(body.error.message, body.error.code, body.error.data);
+    }
+    return body.result;
+  }
+  async function callTool(name, args = {}) {
+    const result = await rpc("tools/call", { name, arguments: args });
+    return unwrapToolResult(result);
+  }
+  async function readResource(uri) {
+    const result = await rpc("resources/read", { uri });
+    const text = result?.contents?.[0]?.text;
+    if (typeof text !== "string") {
+      throw new RpcError(`Resource ${uri} came back with no text`, TOOL_ERROR);
+    }
+    return text;
+  }
+  async function getGenome() {
+    try {
+      return await callTool("get_design_system");
+    } catch (err) {
+      if (!(err instanceof RpcError) || err.code !== TOOL_ERROR) throw err;
+      try {
+        return await callTool("get_tokens");
+      } catch {
+        throw err;
+      }
+    }
+  }
+  return { callTool, readResource, getGenome };
+}
+
+// src/workspace.ts
+function genomeToken(explicit) {
+  const token = explicit || process.env.FLASH_GENOME_TOKEN || "";
+  if (!token) {
+    throw new Error(
+      "No MCP token. Mint one in Flash under Connect and set FLASH_GENOME_TOKEN, or start Genome with --token."
+    );
+  }
+  return token;
+}
+async function readGenomeConfig(workspaceRoot, configPath) {
+  let legacy = false;
+  for (const path of configCandidates(configPath, workspaceRoot)) {
+    const raw = await readFile6(path, "utf8").catch(() => null);
+    if (!raw) continue;
+    if (path.endsWith(LEGACY_CONFIG_FILENAME)) legacy = true;
+    let parsed;
+    try {
+      parsed = GenomeConfigSchema.safeParse(JSON.parse(raw));
+    } catch {
+      throw new Error(
+        `${path} is not valid JSON. Fix or delete it, then run flash-genome link.`
+      );
+    }
+    if (parsed.success) return parsed.data;
+    if (JSON.parse(raw).version === 2) {
+      throw new Error(
+        `${path} does not match the genome.config.json schema. Run flash-genome link to rewrite it.`
+      );
+    }
+  }
+  throw new Error(
+    legacy ? `${GENOME_CONFIG_FILENAME} is missing; this repo still has the older ${LEGACY_CONFIG_FILENAME}. Run flash-genome link to write one.` : `No ${GENOME_CONFIG_FILENAME} here. Run flash-genome link in this repository first.`
+  );
+}
+async function workspaceContext(opts) {
+  const workspaceRoot = resolve7(process.cwd(), opts.workspace ?? ".");
+  const config = await readGenomeConfig(workspaceRoot, opts.configPath);
+  const client = createRpcClient({
+    // Already resolved by the caller in the documented order: the flag, then
+    // the environment, then this repo's config, then the hosted default.
+    // Preferring the config here would make the flag and the variable
+    // unusable, since the config always has a url.
+    baseUrl: opts.apiUrl,
+    token: genomeToken(opts.token)
+  });
+  return { config, client, workspaceRoot };
+}
+
+// src/tools/link.ts
+import { randomBytes } from "crypto";
+import { readFile as readFile7, writeFile as writeFile2 } from "fs/promises";
+import { basename, join as join5, resolve as resolve8 } from "path";
+var DEFAULT_INPUTS = {
+  tokens: ["design-tokens.json", "tokens.css"],
+  components: []
+};
+function codebaseIdentity(previous, workspaceRoot) {
+  if (previous) return previous;
+  return {
+    id: `cb_${randomBytes(12).toString("hex")}`,
+    name: basename(workspaceRoot) || "codebase"
+  };
+}
+async function linkGenome(opts) {
+  const envelope = await opts.client.getGenome();
+  if (!envelope || typeof envelope.id !== "number") {
+    throw new Error(
+      "The server did not say which design system this token belongs to."
+    );
+  }
+  const root = resolve8(opts.workspaceRoot);
+  const path = join5(root, GENOME_CONFIG_FILENAME);
+  const before = await readFile7(path, "utf8").catch(() => null);
+  let previous = null;
+  let unreadable = false;
+  if (before) {
+    try {
+      const parsed = GenomeConfigSchema.safeParse(JSON.parse(before));
+      previous = parsed.success ? parsed.data : null;
+      unreadable = !parsed.success;
+    } catch {
+      unreadable = true;
+    }
+  }
+  if (unreadable) {
+    throw new Error(
+      `${GENOME_CONFIG_FILENAME} exists but is not a valid config. Fix or delete it, then run link again - overwriting it would lose the paths it names.`
+    );
+  }
+  const config = GenomeConfigSchema.parse({
+    version: 2,
+    genomeId: envelope.id,
+    name: envelope.name,
+    apiUrl: opts.apiUrl,
+    revision: envelope.revision,
+    codebase: codebaseIdentity(previous?.codebase, root),
+    // Keep whatever the repo had configured: a re-link is usually a token
+    // rotation, and rewriting someone's paths is not what they asked for.
+    ...previous ? { inputs: previous.inputs, outputs: previous.outputs } : { inputs: DEFAULT_INPUTS },
+    ...opts.framework ? { framework: opts.framework } : {},
+    ...previous?.framework && !opts.framework ? { framework: previous.framework } : {}
+  });
+  const body = `${JSON.stringify(config, null, 2)}
+`;
+  const unchanged = before === body;
+  if (!unchanged) await writeFile2(path, body, "utf8");
+  return {
+    path,
+    config,
+    written: !unchanged,
+    rebound: Boolean(previous && previous.genomeId !== config.genomeId),
+    ...previous ? { previousGenomeId: previous.genomeId } : {}
+  };
+}
+function describeLink(result) {
+  const lines = [
+    result.written ? `Wrote ${GENOME_CONFIG_FILENAME}` : `${GENOME_CONFIG_FILENAME} already matched`,
+    `  design system: ${result.config.name} (#${result.config.genomeId})`,
+    `  revision:      ${result.config.revision ?? "unknown"}`,
+    `  api:           ${result.config.apiUrl}`,
+    ...result.config.codebase ? [
+      `  codebase:      ${result.config.codebase.name} (${result.config.codebase.id})`
+    ] : []
+  ];
+  if (result.rebound) {
+    lines.push(
+      `  note:          this repo was linked to #${result.previousGenomeId}; it now points at #${result.config.genomeId}`
+    );
+  }
+  lines.push(
+    "",
+    "The token stays out of this file. Keep it in FLASH_GENOME_TOKEN."
+  );
+  return lines.join("\n");
+}
+
+// src/tools/apply-token-patch.ts
+import { readFile as readFile8, writeFile as writeFile3 } from "fs/promises";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function applyTokenPatch(tokenFile, patch, options = {}) {
+  const confirm = options.confirm === true;
+  const text = await readFile8(tokenFile, "utf8");
+  const raw = JSON.parse(text);
+  const { tokens, name } = normalizeTokenDocument(raw);
+  const beforeCount = tokens.length;
+  const byName = new Map(tokens.map((t) => [t.name, t]));
+  const changes = [];
+  for (const step of patch) {
+    if (step.op === "remove") {
+      if (byName.delete(step.token.name)) {
+        changes.push({ op: "remove", name: step.token.name });
+      }
+      continue;
+    }
+    const existing = byName.get(step.token.name);
+    const candidate = {
+      name: step.token.name,
+      value: step.token.value ?? existing?.value ?? "",
+      type: step.token.type ?? existing?.type ?? "color",
+      category: step.token.category ?? existing?.category ?? "colors",
+      description: step.token.description ?? existing?.description
+    };
+    const parsed = TokenSchema.safeParse(candidate);
+    if (!parsed.success) {
+      throw new Error(
+        `Invalid token patch for "${step.token.name}": ${parsed.error.message}`
+      );
+    }
+    byName.set(parsed.data.name, parsed.data);
+    changes.push({
+      op: existing ? "update" : "insert",
+      name: parsed.data.name
+    });
+  }
+  const next = [...byName.values()];
+  const result = {
+    source: tokenFile,
+    dryRun: !confirm,
+    applied: false,
+    beforeCount,
+    afterCount: next.length,
+    changes
+  };
+  if (!confirm) {
+    result.tokens = next;
+    return result;
+  }
+  let out;
+  if (Array.isArray(raw)) {
+    out = next;
+  } else if (isRecord2(raw) && Array.isArray(raw.tokens)) {
+    out = { ...raw, name: name ?? raw.name, tokens: next };
+  } else {
+    out = { name: name ?? "Design System", version: "0.1.0", tokens: next };
+  }
+  await writeFile3(tokenFile, `${JSON.stringify(out, null, 2)}
+`, "utf8");
+  result.applied = true;
+  result.tokens = next;
+  return result;
+}
+
+// src/tools/brand-dna.ts
+import { readFile as readFile9 } from "fs/promises";
+import { dirname as dirname3, resolve as resolve9 } from "path";
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function getBrandDna(options) {
+  if (options.brandDnaFile) {
+    const text2 = await readFile9(options.brandDnaFile, "utf8");
+    const raw2 = JSON.parse(text2);
+    if (!isRecord3(raw2)) {
+      throw new Error("brand-dna file must be a JSON object");
+    }
+    return { source: options.brandDnaFile, brandDna: raw2 };
+  }
+  const sibling = resolve9(dirname3(options.tokenFile), "brand-dna.json");
+  try {
+    const text2 = await readFile9(sibling, "utf8");
+    const raw2 = JSON.parse(text2);
+    if (isRecord3(raw2)) {
+      return { source: sibling, brandDna: raw2 };
+    }
+  } catch {
+  }
+  const text = await readFile9(options.tokenFile, "utf8");
+  const raw = JSON.parse(text);
+  if (!isRecord3(raw)) {
+    throw new Error(
+      "Brand DNA not found (no brand-dna.json and tokens is not an object)"
+    );
+  }
+  for (const key of ["dsm-brand-dna", "brandDna", "brand_dna"]) {
+    const value = raw[key];
+    if (isRecord3(value)) {
+      return { source: `${options.tokenFile}#${key}`, brandDna: value };
+    }
+  }
+  throw new Error(
+    "Brand DNA not found. Add fixtures/brand-dna.json or tokens['dsm-brand-dna']."
+  );
+}
+
+// src/tools/components.ts
+async function listComponents(componentsFile, category) {
+  const loaded = await loadComponentsFromFile(componentsFile);
+  const components = filterComponentsByCategory(loaded.components, category);
+  return {
+    source: loaded.source,
+    name: loaded.name,
+    category,
+    count: components.length,
+    components
+  };
+}
+async function getComponent(componentsFile, name) {
+  const loaded = await loadComponentsFromFile(componentsFile);
+  const component = findComponentByName(loaded.components, name);
+  if (!component) {
+    const available = loaded.components.map((c) => c.name).join(", ");
+    throw new Error(
+      `Component "${name}" not found. Available: ${available || "(none)"}`
+    );
+  }
+  return { source: loaded.source, component };
+}
+
+// src/tools/generate-component-prompt.ts
+async function generateComponentPrompt(componentsFile, tokenFile, name) {
+  const { source: componentSource, component } = await getComponent(
+    componentsFile,
+    name
+  );
+  const tokens = await getDesignTokens(tokenFile);
+  const related = (component.tokensUsed ?? []).map((tokenName) => tokens.tokens.find((t) => t.name === tokenName)).filter((t) => Boolean(t));
+  const tokenBlock = related.length > 0 ? related.map((t) => `- ${t.name}: ${t.value} (${t.category})`).join("\n") : tokens.tokens.slice(0, 12).map((t) => `- ${t.name}: ${t.value} (${t.category})`).join("\n");
+  const variants = component.variants?.length ? component.variants.join(", ") : "default";
+  const prompt = [
+    `Implement the Flash DSM "${component.name}" component.`,
+    component.description ? `Purpose: ${component.description}` : null,
+    `Category: ${component.category ?? "uncategorized"}`,
+    `Variants: ${variants}`,
+    "",
+    "Use these design tokens (do not hardcode raw values when a token exists):",
+    tokenBlock,
+    "",
+    "Constraints:",
+    "- Prefer design tokens over hard-coded colors/spacing",
+    "- Keep accessibility (labels, focus, contrast) intact",
+    "- Match existing project component patterns"
+  ].filter((line) => line !== null).join("\n");
+  return {
+    name: component.name,
+    prompt,
+    componentSource,
+    tokenSource: tokens.source
+  };
+}
+
+// src/tools/list-violations.ts
+import { readFile as readFile10 } from "fs/promises";
+var HEX_RE = /#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})\b/g;
+var ARBITRARY_TW_RE = /\b(?:bg|text|border|from|to|via|ring)-\[#[0-9a-fA-F]{3,8}\]/g;
+var ARBITRARY_PX_RE = /\b(?:p|px|py|pt|pb|pl|pr|m|mx|my|mt|mb|ml|mr|gap|space-[xy])-\[(\d+)px\]/g;
+function normalizeHex2(hex) {
+  let h = hex.slice(1).toLowerCase();
+  if (h.length === 3 || h.length === 4) {
+    h = h.split("").map((c) => c + c).join("").slice(0, 6);
+  }
+  return `#${h.slice(0, 6)}`;
+}
+function colorTokenSet(tokens) {
+  const map = /* @__PURE__ */ new Map();
+  for (const t of tokens) {
+    if (t.type === "color" || t.category === "colors") {
+      if (t.value.startsWith("#")) {
+        map.set(normalizeHex2(t.value), t.name);
+      }
+    }
+  }
+  return map;
+}
+function spacingTokenSet(tokens) {
+  const map = /* @__PURE__ */ new Map();
+  for (const t of tokens) {
+    if (t.category === "spacing" || t.type === "size") {
+      map.set(t.value.toLowerCase(), t.name);
+    }
+  }
+  return map;
+}
+function lineCol(source, index) {
+  const upto = source.slice(0, index);
+  const lines = upto.split("\n");
+  return {
+    line: lines.length,
+    column: (lines[lines.length - 1]?.length ?? 0) + 1
+  };
+}
+async function listViolations(tokenFile, filePath) {
+  const loaded = await loadTokensFromFile(tokenFile);
+  const source = await readFile10(filePath, "utf8");
+  const colors = colorTokenSet(loaded.tokens);
+  const spacing = spacingTokenSet(loaded.tokens);
+  const violations = [];
+  for (const match of source.matchAll(HEX_RE)) {
+    const hex = match[0];
+    const idx = match.index ?? 0;
+    const { line, column } = lineCol(source, idx);
+    const tokenName = colors.get(normalizeHex2(hex));
+    if (tokenName) {
+      violations.push({
+        rule: "prefer-token",
+        message: `Hardcoded color ${hex} matches token ${tokenName} - prefer the token`,
+        match: hex,
+        line,
+        column,
+        suggestion: tokenName
+      });
+    } else {
+      violations.push({
+        rule: "unknown-color",
+        message: `Hardcoded color ${hex} is not in the design token palette`,
+        match: hex,
+        line,
+        column
+      });
+    }
+  }
+  for (const match of source.matchAll(ARBITRARY_TW_RE)) {
+    const cls = match[0];
+    const idx = match.index ?? 0;
+    const { line, column } = lineCol(source, idx);
+    violations.push({
+      rule: "arbitrary-tailwind-color",
+      message: `Arbitrary Tailwind color ${cls} bypasses design tokens`,
+      match: cls,
+      line,
+      column
+    });
+  }
+  for (const match of source.matchAll(ARBITRARY_PX_RE)) {
+    const cls = match[0];
+    const px = `${match[1]}px`;
+    const idx = match.index ?? 0;
+    const { line, column } = lineCol(source, idx);
+    const tokenName = spacing.get(px.toLowerCase());
+    violations.push({
+      rule: "arbitrary-tailwind-spacing",
+      message: tokenName ? `Arbitrary spacing ${cls} matches token ${tokenName}` : `Arbitrary spacing ${cls} is not in spacing tokens`,
+      match: cls,
+      line,
+      column,
+      suggestion: tokenName
+    });
+  }
+  return {
+    file: filePath,
+    tokenSource: loaded.source,
+    count: violations.length,
+    violations
+  };
+}
+
+// src/tools/scan-workspace.ts
+import { readFile as readFile11, readdir } from "fs/promises";
+import { basename as basename2, join as join6, resolve as resolve10 } from "path";
+var MODES_EXTENSION = "com.flashdsm.modes";
+function walkDtcg(node, path, visit) {
+  for (const [k, v] of Object.entries(node)) {
+    if (k.startsWith("$") || typeof v !== "object" || !v) continue;
+    const child = v;
+    if ("$value" in child || "value" in child) {
+      visit([...path, k].join("-"), child);
+    } else {
+      walkDtcg(child, [...path, k], visit);
+    }
+  }
+}
+var TOKEN_FILES = ["design-tokens.json", "tokens.json"];
+var CSS_RE = /tokens?\.css$/i;
+var TW_RE = /^tailwind\.config\.(js|cjs|mjs|ts)$/i;
+var SKIP = /node_modules|dist|build|\.git/i;
+var CSS_VAR = /--([a-z0-9-_]+)\s*:\s*([^;{}]+);/gi;
+function classify(name, value) {
+  const v = value.trim();
+  if (/^#[0-9a-fA-F]{3,8}$/.test(v))
+    return { category: "colors", type: "color" };
+  if (/^-?\d*\.?\d+(px|rem|em|%)$/.test(v)) {
+    return /radius/i.test(name) ? { category: "radius", type: "radius" } : { category: "spacing", type: "size" };
+  }
+  return null;
+}
+async function walk(root, dir, out) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  for (const e of entries) {
+    const full = join6(dir, e.name);
+    if (e.isDirectory()) {
+      if (!SKIP.test(e.name)) await walk(root, full, out);
+    } else out.push(full.slice(root.length + 1));
+  }
+}
+async function scanWorkspace(workspaceRoot) {
+  const root = resolve10(workspaceRoot);
+  const paths = [];
+  await walk(root, root, paths);
+  const tokens = {};
+  const sources = /* @__PURE__ */ new Set();
+  let scanned = 0;
+  for (const rel of paths) {
+    const base = basename2(rel);
+    if (!TOKEN_FILES.includes(base) && !CSS_RE.test(base) && !TW_RE.test(base))
+      continue;
+    const text = await readFile11(join6(root, rel), "utf8").catch(() => null);
+    if (!text) continue;
+    scanned += 1;
+    if (base.endsWith(".json")) {
+      try {
+        const raw = JSON.parse(text);
+        walkDtcg(raw, [], (name, leaf) => {
+          const val = leaf.$value ?? leaf.value;
+          if (typeof val !== "string") return;
+          const c = classify(name, val);
+          if (!c) return;
+          const ext = leaf.$extensions;
+          const modes = ext?.[MODES_EXTENSION];
+          const token = {
+            name,
+            value: val,
+            type: c.type,
+            category: c.category
+          };
+          if (modes && typeof modes === "object") {
+            const clean = {};
+            for (const [theme, v] of Object.entries(modes)) {
+              if (typeof v === "string") clean[theme] = v;
+            }
+            if (Object.keys(clean).length) token.modes = clean;
+          }
+          tokens[c.category] ??= [];
+          tokens[c.category].push(token);
+          sources.add(rel);
+        });
+      } catch {
+      }
+    } else if (/\.css$/i.test(rel)) {
+      for (const m of text.matchAll(CSS_VAR)) {
+        const c = classify(m[1], m[2]);
+        if (!c) continue;
+        tokens[c.category] ??= [];
+        tokens[c.category].push({
+          name: m[1].toLowerCase(),
+          value: m[2].trim(),
+          type: c.type,
+          category: c.category
+        });
+        sources.add(rel);
+      }
+    }
+  }
+  return {
+    workspaceRoot: root,
+    tokens,
+    components: [],
+    sources: [...sources],
+    stats: {
+      filesScanned: scanned,
+      colors: tokens.colors?.length ?? 0,
+      spacing: tokens.spacing?.length ?? 0,
+      typography: tokens.typography?.length ?? 0,
+      radius: tokens.radius?.length ?? 0,
+      shadows: tokens.shadows?.length ?? 0,
+      components: 0
+    }
+  };
+}
+
+// src/tools/suggest-token-usage.ts
+var HEX_RE2 = /#(?:[0-9a-fA-F]{3,4}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})\b/g;
+var PX_RE = /\b(\d+(?:\.\d+)?)px\b/g;
+function normalizeHex3(hex) {
+  let h = hex.slice(1).toLowerCase();
+  if (h.length === 3 || h.length === 4) {
+    h = h.split("").map((c) => c + c).join("").slice(0, 6);
+  }
+  return `#${h.slice(0, 6)}`;
+}
+function hexDistance(a, b) {
+  const parse = (h) => {
+    const n = normalizeHex3(h).slice(1);
+    return [
+      parseInt(n.slice(0, 2), 16),
+      parseInt(n.slice(2, 4), 16),
+      parseInt(n.slice(4, 6), 16)
+    ];
+  };
+  try {
+    const [ar, ag, ab] = parse(a);
+    const [br, bg, bb] = parse(b);
+    return Math.hypot(ar - br, ag - bg, ab - bb);
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+function nearestColor(tokens, hex) {
+  const colors = tokens.filter(
+    (t) => t.category === "colors" || t.type === "color"
+  );
+  let best = null;
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (const t of colors) {
+    if (!t.value.startsWith("#")) continue;
+    const d = hexDistance(hex, t.value);
+    if (d < bestDist) {
+      bestDist = d;
+      best = t;
+    }
+  }
+  return best;
+}
+function nearestSpacing(tokens, px) {
+  const spacing = tokens.filter(
+    (t) => t.category === "spacing" || t.type === "size"
+  );
+  const target = parseFloat(px);
+  let best = null;
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (const t of spacing) {
+    const m = t.value.match(/^(\d+(?:\.\d+)?)px$/i);
+    if (!m) continue;
+    const d = Math.abs(parseFloat(m[1]) - target);
+    if (d < bestDist) {
+      bestDist = d;
+      best = t;
+    }
+  }
+  return best;
+}
+async function suggestTokenUsage(tokenFile, context) {
+  const loaded = await loadTokensFromFile(tokenFile);
+  const suggestions = [];
+  const hexes = context.match(HEX_RE2) ?? [];
+  for (const hex of [...new Set(hexes)]) {
+    const nearest = nearestColor(loaded.tokens, hex);
+    const exact = nearest && normalizeHex3(nearest.value) === normalizeHex3(hex);
+    suggestions.push({
+      found: hex,
+      kind: "color",
+      suggestion: nearest ? {
+        name: nearest.name,
+        value: nearest.value,
+        distance: exact ? 0 : hexDistance(hex, nearest.value)
+      } : null,
+      note: nearest ? exact ? `Exact match - use token ${nearest.name}` : `Nearest color token is ${nearest.name} (${nearest.value})` : "No color tokens available"
+    });
+  }
+  const pxs = [...context.matchAll(PX_RE)].map((m) => `${m[1]}px`);
+  for (const px of [...new Set(pxs)]) {
+    const nearest = nearestSpacing(loaded.tokens, px);
+    const exact = nearest?.value.toLowerCase() === px.toLowerCase();
+    suggestions.push({
+      found: px,
+      kind: "spacing",
+      suggestion: nearest ? { name: nearest.name, value: nearest.value } : null,
+      note: nearest ? exact ? `Exact match - use token ${nearest.name}` : `Nearest spacing token is ${nearest.name} (${nearest.value})` : "No spacing tokens available"
+    });
+  }
+  return {
+    source: loaded.source,
+    contextPreview: context.slice(0, 200),
+    suggestions
+  };
+}
+
+// src/index.ts
+var PACKAGE_ROOT = resolve11(fileURLToPath(new URL("..", import.meta.url)));
+function packageVersion() {
+  try {
+    const raw = readFileSync(resolve11(PACKAGE_ROOT, "package.json"), "utf8");
+    const version = JSON.parse(raw).version;
+    return typeof version === "string" ? version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var TOOL_NAMES = [
+  "get_tokens",
+  "list_components",
+  "get_component",
+  "get_brand_dna",
+  "suggest_token",
+  "apply_token_patch",
+  "generate_component_prompt",
+  "check_violations",
+  "scan_workspace",
+  "pull_from_web",
+  "detect_drift",
+  "push_to_web",
+  "list_modules",
+  "get_module",
+  "get_relations",
+  "get_impact",
+  "sync_context",
+  "api_health",
+  "list_design_systems"
+];
+function parseCliArgs(argv) {
+  let tokensPath;
+  let componentsPath;
+  let configPath;
+  let apiUrl;
+  let accessToken;
+  let token;
+  const VALUE_FLAGS = /* @__PURE__ */ new Set([
+    "--tokens",
+    "-t",
+    "--components",
+    "--config",
+    "-c",
+    "--api-url",
+    "--access-token",
+    "--token"
+  ]);
+  let command;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (VALUE_FLAGS.has(arg)) {
+      i++;
+      continue;
+    }
+    if (arg.startsWith("-")) continue;
+    command = arg;
+    break;
+  }
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === command) continue;
+    if (arg === "--tokens" || arg === "-t") {
+      tokensPath = argv[++i];
+      continue;
+    }
+    if (arg === "--components") {
+      componentsPath = argv[++i];
+      continue;
+    }
+    if (arg === "--config" || arg === "-c") {
+      configPath = argv[++i];
+      continue;
+    }
+    if (arg === "--api-url") {
+      apiUrl = argv[++i];
+      continue;
+    }
+    if (arg === "--access-token") {
+      accessToken = argv[++i];
+      continue;
+    }
+    if (arg === "--token") {
+      token = argv[++i];
+      continue;
+    }
+    if (arg === "--help" || arg === "-h") {
+      console.error(`Usage: flash-genome [command] [options]
+
+Flash Genome: the local MCP for a Flash design system (stdio).
+
+Commands:
+  (none)             Start the MCP server on stdio
+  link               Bind this repo to the design system the token belongs to
+
+Credentials:
+  FLASH_GENOME_TOKEN Flash MCP token, flash_mcp_\u2026, minted in Flash under
+                     Connect. Used by the link command.
+  --token            The same token as an argument. Visible in shell history
+                     and in process listings, so prefer the variable.
+
+Options:
+  --tokens, -t       Path to design-tokens.json
+  --components       Path to components.json
+  --config, -c       Path to genome.config.json (or the older flash-ds.config.json)
+  --api-url          Flash base URL. Without it: FLASH_GENOME_API_URL, then
+                     FLASH_DS_API_URL, then this repo's genome.config.json,
+                     then https://flashdsm.com
+  --access-token     Deprecated web JWT, for api_health and list_design_systems
+  --help, -h         Show this help
+`);
+      process.exit(0);
+    }
+  }
+  return {
+    command,
+    tokensPath,
+    componentsPath,
+    configPath,
+    apiUrl,
+    accessToken,
+    token
+  };
+}
+function textResult(data, isError = false) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof data === "string" ? data : JSON.stringify(data, null, 2)
+      }
+    ],
+    ...isError ? { isError: true } : {}
+  };
+}
+function errorResult(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return textResult(`Error: ${message}`, true);
+}
+async function createServer(opts) {
+  const cli = { configPath: opts.configPath };
+  const server = new McpServer({
+    name: "flash-genome",
+    version: packageVersion()
+  });
+  const api = createApiClient({
+    baseUrl: opts.apiUrl,
+    accessToken: opts.accessToken
+  });
+  const categoryEnum = z2.enum(
+    TokenCategorySchema.options
+  );
+  const alias = (names, description, schema, handler) => {
+    for (const name of names) server.tool(name, description, schema, handler);
+  };
+  alias(
+    ["get_tokens", "get_design_tokens"],
+    "Read design tokens from the local Flash token file. Optionally filter by category. Read-only.",
+    {
+      category: categoryEnum.optional().describe("Optional token category (e.g. colors, spacing)")
+    },
+    async (args) => {
+      try {
+        const category = parseCategoryInput(args.category);
+        const result = await getDesignTokens(opts.tokenFile, { category });
+        return textResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "list_components",
+    "List components from the local components.json (optionally filter by category).",
+    {
+      category: z2.string().optional().describe("Optional component category (e.g. actions, forms)")
+    },
+    async (args) => {
+      try {
+        const result = await listComponents(opts.componentsFile, args.category);
+        return textResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "get_component",
+    "Get a single component spec by name from the local components file.",
+    {
+      name: z2.string().describe("Component name (e.g. Button)")
+    },
+    async (args) => {
+      try {
+        const result = await getComponent(opts.componentsFile, args.name);
+        return textResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "get_brand_dna",
+    "Read brand DNA from brand-dna.json (sibling of tokens) or tokens['dsm-brand-dna'].",
+    {},
+    async () => {
+      try {
+        const result = await getBrandDna({ tokenFile: opts.tokenFile });
+        return textResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  alias(
+    ["suggest_token", "suggest_token_usage"],
+    "Suggest design tokens for hardcoded colors/spacing found in a context snippet (deterministic, no LLM).",
+    {
+      context: z2.string().describe("Code or design context containing colors/px values")
+    },
+    async (args) => {
+      try {
+        const result = await suggestTokenUsage(opts.tokenFile, args.context);
+        return textResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "apply_token_patch",
+    "Upsert/remove tokens in the local design-tokens.json. Dry-run by default; set confirm=true to write.",
+    {
+      patch: z2.array(
+        z2.object({
+          op: z2.enum(["upsert", "remove"]),
+          token: z2.object({
+            name: z2.string(),
+            value: z2.string().optional(),
+            type: z2.string().optional(),
+            category: z2.string().optional(),
+            description: z2.string().optional()
+          })
+        })
+      ).describe("List of upsert/remove operations"),
+      confirm: z2.boolean().optional().describe("Must be true to write the file (default: dry-run)")
+    },
+    async (args) => {
+      try {
+        const result = await applyTokenPatch(opts.tokenFile, args.patch, {
+          confirm: args.confirm
+        });
+        return textResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "generate_component_prompt",
+    "Generate an AI handoff prompt for implementing a named component with Flash tokens.",
+    {
+      name: z2.string().describe("Component name")
+    },
+    async (args) => {
+      try {
+        const result = await generateComponentPrompt(
+          opts.componentsFile,
+          opts.tokenFile,
+          args.name
+        );
+        return textResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  alias(
+    ["check_violations", "list_violations"],
+    "Lint a source file for hardcoded colors / arbitrary Tailwind values vs design tokens.",
+    {
+      file: z2.string().describe("Absolute or cwd-relative path to a source file")
+    },
+    async (args) => {
+      try {
+        const filePath = resolve11(process.cwd(), args.file);
+        const result = await listViolations(opts.tokenFile, filePath);
+        return textResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "scan_workspace",
+    "Scan the workspace for DTCG JSON, CSS variables, and Tailwind colors; POST to FastAPI to create a v2 design system. Requires --access-token.",
+    {
+      workspace: z2.string().optional().describe("Workspace root (default: cwd)"),
+      name: z2.string().optional().describe("Name for the new design system")
+    },
+    async (args) => {
+      try {
+        if (!opts.accessToken) {
+          throw new Error(
+            "scan_workspace requires --access-token or FLASH_DS_ACCESS_TOKEN"
+          );
+        }
+        const root = resolve11(process.cwd(), args.workspace ?? ".");
+        const scan = await scanWorkspace(root);
+        const created = await api.createFromCodeScan({
+          name: args.name,
+          scan
+        });
+        return textResult({ scan: scan.stats, ...created });
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  const workspaceArgs = {
+    workspace: z2.string().optional().describe("Repo root (default: cwd)"),
+    confirm: z2.boolean().optional().describe("Must be true to write files. Without it, nothing is written")
+  };
+  const pullTool = async (args) => {
+    try {
+      const ctx = await workspaceContext({
+        workspace: args.workspace,
+        configPath: cli.configPath,
+        apiUrl: opts.apiUrl,
+        token: opts.token
+      });
+      return textResult(await pullFromWeb({ ...ctx, confirm: args.confirm }));
+    } catch (err) {
+      return errorResult(err);
+    }
+  };
+  alias(
+    ["pull_from_web", "sync_to_repo"],
+    "Write this design system into the repository: the token files and mirrors named by genome.config.json. Returns the plan; writes only with confirm. Run sync_context as well for the files an agent reads before writing UI.",
+    workspaceArgs,
+    pullTool
+  );
+  server.tool(
+    "detect_drift",
+    "Has the repo moved since the last pull, has Flash, and which token values changed. Read-only; every finding is flagged.",
+    { workspace: workspaceArgs.workspace },
+    async (args) => {
+      try {
+        const ctx = await workspaceContext({
+          workspace: args.workspace,
+          configPath: cli.configPath,
+          apiUrl: opts.apiUrl,
+          token: opts.token
+        });
+        return textResult(await detectDrift(ctx));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "push_to_web",
+    "Propose the token values this repo changed to Flash, as a change set a person reviews on the Sync page. Nothing is applied. Returns the plan; proposes only with confirm. Refused while Flash is ahead of the last pull.",
+    workspaceArgs,
+    async (args) => {
+      try {
+        const ctx = await workspaceContext({
+          workspace: args.workspace,
+          configPath: cli.configPath,
+          apiUrl: opts.apiUrl,
+          token: opts.token
+        });
+        return textResult(await pushToWeb({ ...ctx, confirm: args.confirm }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  const graphClient = () => createRpcClient({ baseUrl: opts.apiUrl, token: genomeToken(opts.token) });
+  const graphTool = (name) => async (args) => {
+    try {
+      return textResult(await runGraphTool(graphClient(), name, args));
+    } catch (err) {
+      return errorResult(err);
+    }
+  };
+  server.tool(
+    "list_modules",
+    "Every module, with its part count, the components it is built from, and how many token bindings it carries.",
+    {},
+    graphTool("list_modules")
+  );
+  server.tool(
+    "get_module",
+    "One module by id or name: its parts in order, each resolved to its component, and its bindings.",
+    { module: z2.string().describe("Module id or name") },
+    graphTool("get_module")
+  );
+  server.tool(
+    "get_relations",
+    "With a token: what it aliases, what aliases it, and what binds to it directly. Without one: every alias edge, binding and module part.",
+    { token: z2.string().optional().describe("Token id or name") },
+    graphTool("get_relations")
+  );
+  server.tool(
+    "get_impact",
+    "What breaks if a token changes: every token that resolves through it, and the components and modules that end up using it. Call before changing a token.",
+    { token: z2.string().describe("Token id or name") },
+    graphTool("get_impact")
+  );
+  server.tool(
+    "sync_context",
+    "Refresh the files an agent reads before writing UI: AGENTS.md (once), the Cursor rule, and the Agent Skill. Returns the plan; writes only with confirm.",
+    workspaceArgs,
+    async (args) => {
+      try {
+        const ctx = await workspaceContext({
+          workspace: args.workspace,
+          configPath: cli.configPath,
+          apiUrl: opts.apiUrl,
+          token: opts.token
+        });
+        return textResult(await syncContext({ ...ctx, confirm: args.confirm }));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "api_health",
+    "Check Flash DSM FastAPI /health endpoint.",
+    {},
+    async () => {
+      try {
+        const result = await api.health();
+        return textResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.tool(
+    "list_design_systems",
+    "List design systems from FastAPI (requires --access-token / FLASH_DS_ACCESS_TOKEN).",
+    {},
+    async () => {
+      try {
+        const result = await api.listDesignSystems();
+        return textResult(result);
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  return server;
+}
+async function resolveApiUrl(cli, cwd) {
+  if (cli.apiUrl) return cli.apiUrl;
+  const fromEnv = process.env.FLASH_GENOME_API_URL || process.env.FLASH_DS_API_URL;
+  if (fromEnv) return fromEnv;
+  for (const path of configCandidates(cli.configPath, cwd)) {
+    const raw = await readFile12(path, "utf8").catch(() => null);
+    if (!raw) continue;
+    try {
+      const parsed = GenomeConfigSchema.safeParse(JSON.parse(raw));
+      if (parsed.success) return parsed.data.apiUrl;
+    } catch {
+      continue;
+    }
+  }
+  return "https://flashdsm.com";
+}
+async function runLink(cli) {
+  const token = cli.token || process.env.FLASH_GENOME_TOKEN || "";
+  if (!token) {
+    console.error(
+      "flash-genome link needs an MCP token. Mint one in Flash under Connect, then run it again with --token flash_mcp_\u2026 or FLASH_GENOME_TOKEN set."
+    );
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const apiUrl = await resolveApiUrl(cli, cwd);
+  const client = createRpcClient({ baseUrl: apiUrl, token });
+  try {
+    const result = await linkGenome({ client, workspaceRoot: cwd, apiUrl });
+    console.log(describeLink(result));
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+async function main() {
+  const cli = parseCliArgs(process.argv.slice(2));
+  if (cli.command === "link") return runLink(cli);
+  if (cli.command) {
+    console.error(
+      `Unknown command "${cli.command}". Run flash-genome --help for the list.`
+    );
+    process.exit(1);
+  }
+  const apiUrl = await resolveApiUrl(cli, process.cwd());
+  const accessToken = cli.accessToken || process.env.FLASH_DS_ACCESS_TOKEN || null;
+  let tokenFile;
+  try {
+    tokenFile = await resolveTokenFilePath({
+      tokensPath: cli.tokensPath,
+      configPath: cli.configPath,
+      cwd: process.cwd()
+    });
+  } catch (err) {
+    tokenFile = resolve11(PACKAGE_ROOT, "fixtures", "design-tokens.json");
+    console.error(
+      `[flash-genome] resolve failed (${err instanceof Error ? err.message : err}); using ${tokenFile}`
+    );
+  }
+  let componentsFile;
+  try {
+    componentsFile = await resolveComponentsFilePath({
+      componentsPath: cli.componentsPath,
+      configPath: cli.configPath,
+      tokenFile,
+      cwd: process.cwd()
+    });
+  } catch {
+    componentsFile = resolve11(PACKAGE_ROOT, "fixtures", "components.json");
+  }
+  console.error(`[flash-genome] tokens: ${tokenFile}`);
+  console.error(`[flash-genome] components: ${componentsFile}`);
+  console.error(`[flash-genome] api: ${apiUrl}`);
+  console.error(`[flash-genome] tools: ${TOOL_NAMES.join(", ")}`);
+  const server = await createServer({
+    tokenFile,
+    componentsFile,
+    apiUrl,
+    accessToken,
+    token: cli.token || process.env.FLASH_GENOME_TOKEN || null,
+    configPath: cli.configPath
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+function isEntryPoint(argv1, moduleUrl) {
+  if (argv1 === void 0) return false;
+  const real = (p) => {
+    try {
+      return realpathSync(p);
+    } catch {
+      return resolve11(p);
+    }
+  };
+  return real(fileURLToPath(moduleUrl)) === real(argv1);
+}
+var invokedDirectly = isEntryPoint(process.argv[1], import.meta.url);
+if (invokedDirectly) {
+  main().catch((err) => {
+    console.error("[flash-genome] fatal:", err);
+    process.exit(1);
+  });
+}
+export {
+  TOOL_NAMES,
+  createServer,
+  isEntryPoint
+};