@atomixstudio/mcp 1.0.29 → 1.0.31

package/dist/index.js

@@ -2,7 +2,7 @@
 import {
   isAllowedMethod,
   normalizeBridgeMethod
-} from "./chunk-BXWOCXYT.js";
+} from "./chunk-CE6J5MJX.js";
 
 // src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -1288,10 +1288,710 @@ function getTokenStats(data) {
   };
 }
 
+// ../figma-tools/dist/index.js
+var LEGACY_GROUP_PREFIX = {
+  background: "bg",
+  text: "text",
+  icon: "icon",
+  border: "border",
+  brand: "brand",
+  action: "action",
+  feedback: "feedback"
+};
+var RESERVED_COLOR_KEYS = /* @__PURE__ */ new Set(["customScales", "neutral"]);
+function getColorGroupOrder(storedColors) {
+  if (Array.isArray(storedColors._groupOrder) && storedColors._groupOrder.length > 0) {
+    return storedColors._groupOrder;
+  }
+  return Object.keys(storedColors).filter(
+    (k) => !k.startsWith("_") && !RESERVED_COLOR_KEYS.has(k) && typeof storedColors[k] === "object"
+  );
+}
+function getGroupPrefix(storedColors, groupName) {
+  const custom = storedColors._groupPrefix;
+  if (custom && typeof custom[groupName] === "string") return custom[groupName];
+  return LEGACY_GROUP_PREFIX[groupName] ?? groupName;
+}
+function refScaleToFigmaDisplayName(scaleFromRef) {
+  const s = scaleFromRef.trim();
+  if (!s) return s;
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function referenceToFigmaPrimitiveName(ref, primitiveNames) {
+  if (!ref || typeof ref !== "string") return null;
+  const r = ref.trim();
+  const scaleStep = /^([a-zA-Z]+)\.(\d+|[a-z]+)$/.exec(r);
+  if (scaleStep) {
+    const [, scale, step] = scaleStep;
+    const scaleDisplay = refScaleToFigmaDisplayName(scale);
+    const name = `${scaleDisplay} / ${step}`;
+    return primitiveNames.has(name) ? name : null;
+  }
+  const radixMatch = /^radix\.([a-zA-Z]+)\.(\d+)$/.exec(r);
+  if (radixMatch) {
+    const [, family, step] = radixMatch;
+    const scaleName = refScaleToFigmaDisplayName(family);
+    const name = `${scaleName} / ${step}`;
+    return primitiveNames.has(name) ? name : null;
+  }
+  const oneOffMatch = /^(?:new|oneOff)\.(.+)$/.exec(r);
+  if (oneOffMatch) {
+    const name = `One-off / ${oneOffMatch[1]}`;
+    return primitiveNames.has(name) ? name : null;
+  }
+  const whiteAlpha = /^whiteAlpha\.(.+)$/.exec(r);
+  if (whiteAlpha) {
+    const name = `WhiteAlpha / ${whiteAlpha[1]}`;
+    return primitiveNames.has(name) ? name : null;
+  }
+  const blackAlpha = /^blackAlpha\.(.+)$/.exec(r);
+  if (blackAlpha) {
+    const name = `BlackAlpha / ${blackAlpha[1]}`;
+    return primitiveNames.has(name) ? name : null;
+  }
+  return null;
+}
+function referenceToScaleName(ref) {
+  if (!ref || typeof ref !== "string") return null;
+  const r = ref.trim();
+  const scaleStep = /^([a-zA-Z]+)\.(\d+|[a-z]+)$/.exec(r);
+  if (scaleStep) return refScaleToFigmaDisplayName(scaleStep[1]);
+  const radixMatch = /^radix\.([a-zA-Z]+)\.(\d+)$/.exec(r);
+  if (radixMatch) return refScaleToFigmaDisplayName(radixMatch[1]);
+  return null;
+}
+function getReferencedScaleNames(storedColors) {
+  const names = /* @__PURE__ */ new Set();
+  const groupOrder = getColorGroupOrder(storedColors);
+  for (const groupName of groupOrder) {
+    const group = storedColors[groupName];
+    if (!group || typeof group !== "object") continue;
+    const keys = Object.keys(group).filter((k) => !k.startsWith("_") && k !== "governance");
+    for (const key of keys) {
+      const value = group[key];
+      if (value === void 0 || typeof value !== "object" || value === null) continue;
+      const theme = value;
+      const lightScale = theme.light?.reference ? referenceToScaleName(theme.light.reference) : null;
+      const darkScale = theme.dark?.reference ? referenceToScaleName(theme.dark.reference) : null;
+      if (lightScale) names.add(lightScale);
+      if (darkScale) names.add(darkScale);
+    }
+  }
+  return names;
+}
+function getFullScaleFromStored(storedColors, scaleName) {
+  const key = scaleName.toLowerCase();
+  if (key === "neutral" || key === "gray") {
+    const neutral = storedColors.neutral;
+    if (!neutral?.steps || typeof neutral.steps !== "object") return null;
+    const out = {};
+    for (const [step, stepValue] of Object.entries(neutral.steps)) {
+      const hex = stepValue?.hex;
+      if (typeof hex === "string" && /^#?[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$/i.test(hex)) {
+        out[step] = hex.startsWith("#") ? hex : `#${hex}`;
+      }
+    }
+    return Object.keys(out).length > 0 ? out : null;
+  }
+  const customScales = storedColors.customScales;
+  if (Array.isArray(customScales)) {
+    const keyNorm = key.replace(/\s+/g, "");
+    const scale = customScales.find(
+      (s) => s.name?.toLowerCase() === key || s.name?.toLowerCase().replace(/\s+/g, "") === keyNorm
+    );
+    if (scale?.steps && typeof scale.steps === "object") {
+      const out = {};
+      for (const [step, stepValue] of Object.entries(scale.steps)) {
+        const hex = stepValue?.hex;
+        if (typeof hex === "string" && /^#?[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$/i.test(hex)) {
+          out[step] = hex.startsWith("#") ? hex : `#${hex}`;
+        }
+      }
+      if (Object.keys(out).length > 0) return out;
+    }
+  }
+  return null;
+}
+function buildSemanticRefMap(storedColors, primitiveNames) {
+  const out = {};
+  const groupOrder = getColorGroupOrder(storedColors);
+  for (const groupName of groupOrder) {
+    const group = storedColors[groupName];
+    if (!group || typeof group !== "object") continue;
+    const prefix = getGroupPrefix(storedColors, groupName);
+    const rowOrder = Array.isArray(group._rowOrder) ? group._rowOrder : void 0;
+    const keys = Array.isArray(rowOrder) ? rowOrder : Object.keys(group).filter((k) => !k.startsWith("_") && k !== "governance");
+    const toKebab = prefix === "action" || prefix === "brand" || prefix === "feedback";
+    for (const key of keys) {
+      const value = group[key];
+      if (value === void 0 || typeof value !== "object" || value === null) continue;
+      const theme = value;
+      let cssKey = key === "app" ? "page" : key;
+      if (toKebab) {
+        cssKey = String(key).replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+      }
+      const fullKey = `${prefix}-${cssKey}`;
+      const lightRef = theme.light?.reference ? referenceToFigmaPrimitiveName(theme.light.reference, primitiveNames) : null;
+      const darkRef = theme.dark?.reference ? referenceToFigmaPrimitiveName(theme.dark.reference, primitiveNames) : null;
+      if (lightRef || darkRef) {
+        out[fullKey] = {};
+        if (lightRef) out[fullKey].Light = lightRef;
+        if (darkRef) out[fullKey].Dark = darkRef;
+      }
+    }
+  }
+  return out;
+}
+function figmaColorNameWithGroup(key) {
+  if (key.includes("/")) {
+    const [group2, ...rest] = key.split("/");
+    const name2 = rest.join("/").trim();
+    if (!name2) return key;
+    const groupDisplay2 = group2.charAt(0).toUpperCase() + group2.slice(1).toLowerCase();
+    return `${groupDisplay2} / ${name2}`;
+  }
+  const firstDash = key.indexOf("-");
+  if (firstDash <= 0) return key;
+  const group = key.slice(0, firstDash);
+  const name = key.slice(firstDash + 1);
+  const groupDisplay = group.charAt(0).toUpperCase() + group.slice(1).toLowerCase();
+  return `${groupDisplay} / ${name}`;
+}
+var FIGMA_SHADOW_ORDER = {
+  none: 0,
+  xs: 1,
+  sm: 2,
+  md: 3,
+  lg: 4,
+  xl: 5,
+  "2xl": 6,
+  focus: 7
+};
+function tokenValueToNumber(s) {
+  if (typeof s !== "string" || !s.trim()) return 0;
+  const t = s.trim();
+  if (t.endsWith("rem")) {
+    const n2 = parseFloat(t.replace(/rem$/, ""));
+    return Number.isFinite(n2) ? Math.round(n2 * 16) : 0;
+  }
+  if (t.endsWith("px")) {
+    const n2 = parseFloat(t.replace(/px$/, ""));
+    return Number.isFinite(n2) ? Math.round(n2) : 0;
+  }
+  const n = parseFloat(t);
+  return Number.isFinite(n) ? n : 0;
+}
+function parseBoxShadowToFigmaEffect(shadowStr) {
+  const s = shadowStr.trim();
+  if (!s || s.toLowerCase() === "none") return null;
+  const parsePx = (x) => typeof x === "string" ? parseFloat(x.replace(/px$/i, "")) : NaN;
+  const colorMatch = s.match(/(rgba?\s*\([^)]+\)|#[0-9A-Fa-f]{3,8})\s*$/i);
+  const colorStr = colorMatch ? colorMatch[1].trim() : void 0;
+  const rest = (colorMatch ? s.slice(0, colorMatch.index) : s).trim();
+  const parts = rest ? rest.split(/\s+/) : [];
+  if (parts.length < 3) return null;
+  const offsetX = parsePx(parts[0]);
+  const offsetY = parsePx(parts[1]);
+  const blur = parsePx(parts[2]);
+  let spread = 0;
+  if (parts.length >= 4) spread = parsePx(parts[3]);
+  let r = 0, g = 0, b = 0, a = 0.1;
+  if (colorStr) {
+    const rgbaMatch = colorStr.match(/rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+)\s*)?\)/i);
+    if (rgbaMatch) {
+      r = Number(rgbaMatch[1]) / 255;
+      g = Number(rgbaMatch[2]) / 255;
+      b = Number(rgbaMatch[3]) / 255;
+      a = rgbaMatch[4] != null ? parseFloat(rgbaMatch[4]) : 1;
+    } else {
+      const hexMatch = colorStr.match(/^#?([0-9A-Fa-f]{6})([0-9A-Fa-f]{2})?$/);
+      if (hexMatch) {
+        r = parseInt(hexMatch[1].slice(0, 2), 16) / 255;
+        g = parseInt(hexMatch[1].slice(2, 4), 16) / 255;
+        b = parseInt(hexMatch[1].slice(4, 6), 16) / 255;
+        a = hexMatch[2] ? parseInt(hexMatch[2], 16) / 255 : 0.1;
+      }
+    }
+  }
+  if (!Number.isFinite(offsetX) || !Number.isFinite(offsetY) || !Number.isFinite(blur)) return null;
+  return {
+    type: "DROP_SHADOW",
+    offset: { x: offsetX, y: offsetY },
+    radius: Math.max(0, blur),
+    spread: Number.isFinite(spread) ? spread : 0,
+    color: { r, g, b, a },
+    visible: true,
+    blendMode: "NORMAL"
+  };
+}
+function parseBoxShadowToFigmaEffects(shadowStr) {
+  const s = (shadowStr || "").trim();
+  if (!s || s.toLowerCase() === "none") return [];
+  const out = [];
+  const segments = s.split(/\s*,\s*/);
+  for (const seg of segments) {
+    const effect = parseBoxShadowToFigmaEffect(seg.trim());
+    if (effect) out.push(effect);
+  }
+  return out;
+}
+function colorTo8DigitHex(color) {
+  if (!color || typeof color !== "string") return null;
+  const s = color.trim();
+  const rgbaMatch = s.match(/rgba?\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+)\s*)?\)/i);
+  if (rgbaMatch) {
+    const r = Math.max(0, Math.min(255, parseInt(rgbaMatch[1], 10)));
+    const g = Math.max(0, Math.min(255, parseInt(rgbaMatch[2], 10)));
+    const b = Math.max(0, Math.min(255, parseInt(rgbaMatch[3], 10)));
+    const a = rgbaMatch[4] != null ? Math.max(0, Math.min(1, parseFloat(rgbaMatch[4]))) : 1;
+    const aByte = Math.round(a * 255);
+    const hex = "#" + [r, g, b, aByte].map((n) => n.toString(16).padStart(2, "0")).join("").toUpperCase();
+    return hex;
+  }
+  const hexMatch = s.match(/^#?([0-9A-Fa-f]{6})([0-9A-Fa-f]{2})?$/i);
+  if (hexMatch) {
+    const rgb = hexMatch[1];
+    const aa = hexMatch[2] ?? "FF";
+    return `#${rgb}${aa}`.toUpperCase();
+  }
+  return null;
+}
+function typesetKeyToFontFamilyRole(key) {
+  const prefix = (key.split("-")[0] ?? key).toLowerCase();
+  if (prefix === "display" || prefix.startsWith("display")) return "display";
+  if (prefix === "heading" || prefix.startsWith("heading")) return "heading";
+  if (prefix === "mono" || prefix.startsWith("mono")) return "mono";
+  if (prefix.startsWith("body")) return "body";
+  return "body";
+}
+function buildFigmaPayloadsFromDS(data) {
+  const tokens = data.tokens;
+  const colors = tokens?.colors;
+  const typography = tokens?.typography;
+  const hexRe = /^#?[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?$/;
+  const modes = [];
+  if (colors?.modes) {
+    const light = colors.modes.light ?? {};
+    const dark = colors.modes.dark ?? {};
+    if (Object.keys(light).length > 0) modes.push("Light");
+    if (Object.keys(dark).length > 0 && !modes.includes("Dark")) modes.push("Dark");
+  }
+  if (modes.length === 0) modes.push("Light");
+  const primitiveModes = ["Value"];
+  const dsName = data.meta?.name;
+  const collectionPrefix = dsName ? `${dsName} ` : "";
+  const referencedScaleNames = data.storedColors ? getReferencedScaleNames(data.storedColors) : /* @__PURE__ */ new Set();
+  const primitiveVariables = [];
+  const primitiveNames = /* @__PURE__ */ new Set();
+  const oneOffHexToFigmaName = /* @__PURE__ */ new Map();
+  const alphaScales = colors?.alphaScales;
+  if (alphaScales?.whiteAlpha && typeof alphaScales.whiteAlpha === "object") {
+    for (const [step, value] of Object.entries(alphaScales.whiteAlpha)) {
+      if (typeof value !== "string") continue;
+      const hex = colorTo8DigitHex(value);
+      if (!hex || !hexRe.test(hex)) continue;
+      const figmaName = `WhiteAlpha / ${step}`;
+      if (primitiveNames.has(figmaName)) continue;
+      primitiveNames.add(figmaName);
+      const values = {};
+      for (const m of primitiveModes) values[m] = hex;
+      primitiveVariables.push({ name: figmaName, values });
+    }
+  }
+  if (alphaScales?.blackAlpha && typeof alphaScales.blackAlpha === "object") {
+    for (const [step, value] of Object.entries(alphaScales.blackAlpha)) {
+      if (typeof value !== "string") continue;
+      const hex = colorTo8DigitHex(value);
+      if (!hex || !hexRe.test(hex)) continue;
+      const figmaName = `BlackAlpha / ${step}`;
+      if (primitiveNames.has(figmaName)) continue;
+      primitiveNames.add(figmaName);
+      const values = {};
+      for (const m of primitiveModes) values[m] = hex;
+      primitiveVariables.push({ name: figmaName, values });
+    }
+  }
+  if (colors?.scales && typeof colors.scales === "object") {
+    for (const [scaleName, steps] of Object.entries(colors.scales)) {
+      if (!steps || typeof steps !== "object") continue;
+      let groupDisplay = scaleName.charAt(0).toUpperCase() + scaleName.slice(1);
+      if (scaleName.toLowerCase() === "neutral" && data.storedColors) {
+        const neutral = data.storedColors.neutral;
+        if (neutral?.baseHueFamily) {
+          groupDisplay = refScaleToFigmaDisplayName(neutral.baseHueFamily);
+        }
+      }
+      for (const [step, hexVal] of Object.entries(steps)) {
+        if (typeof hexVal !== "string") continue;
+        const hex = colorTo8DigitHex(hexVal) ?? (hexRe.test(hexVal) ? hexVal : null);
+        if (!hex || !hexRe.test(hex)) continue;
+        const figmaName = `${groupDisplay} / ${step}`;
+        if (primitiveNames.has(figmaName)) continue;
+        primitiveNames.add(figmaName);
+        const values = {};
+        for (const m of primitiveModes) values[m] = hex;
+        primitiveVariables.push({ name: figmaName, values });
+      }
+    }
+  }
+  const radixVariables = [];
+  const radixCollectionName = `${collectionPrefix}Colors Radix`;
+  for (const scaleName of referencedScaleNames) {
+    if (primitiveNames.has(`${scaleName} / 50`) || primitiveNames.has(`${scaleName} / 100`)) continue;
+    const fromStored = data.storedColors ? getFullScaleFromStored(data.storedColors, scaleName) : null;
+    const scaleData = fromStored ?? data.getRadixScale?.(scaleName) ?? null;
+    if (!scaleData) continue;
+    for (const [step, hexVal] of Object.entries(scaleData)) {
+      const figmaName = `${scaleName} / ${step}`;
+      if (primitiveNames.has(figmaName)) continue;
+      const hex = colorTo8DigitHex(hexVal) ?? (hexRe.test(hexVal) ? hexVal : null);
+      if (!hex || !hexRe.test(hex)) continue;
+      primitiveNames.add(figmaName);
+      const values = {};
+      for (const m of primitiveModes) values[m] = hex;
+      primitiveVariables.push({ name: figmaName, values });
+    }
+  }
+  if (colors?.oneOffs && Array.isArray(colors.oneOffs)) {
+    for (const oneOff of colors.oneOffs) {
+      if (!oneOff || typeof oneOff !== "object" || typeof oneOff.hex !== "string") continue;
+      const hex = colorTo8DigitHex(oneOff.hex) ?? (hexRe.test(oneOff.hex) ? oneOff.hex : null);
+      if (!hex || !hexRe.test(hex)) continue;
+      const name = typeof oneOff.name === "string" && oneOff.name ? oneOff.name : oneOff.id ?? "unnamed";
+      const figmaName = `One-off / ${name}`;
+      if (primitiveNames.has(figmaName)) continue;
+      primitiveNames.add(figmaName);
+      const values = {};
+      for (const m of primitiveModes) values[m] = hex;
+      primitiveVariables.push({ name: figmaName, values });
+      const normalizedHex = hex.replace(/^#/, "").toUpperCase();
+      const key8 = normalizedHex.length === 6 ? normalizedHex + "FF" : normalizedHex;
+      oneOffHexToFigmaName.set(key8, figmaName);
+    }
+  }
+  const semanticRefMap = data.storedColors && primitiveNames.size > 0 ? buildSemanticRefMap(data.storedColors, primitiveNames) : {};
+  const semanticVariables = [];
+  const semanticNames = /* @__PURE__ */ new Set();
+  const primitivesCollectionName = `${collectionPrefix}Colors Primitives`;
+  if (colors?.modes) {
+    const light = colors.modes.light ?? {};
+    const dark = colors.modes.dark ?? {};
+    const orderedKeys = [...Object.keys(light)];
+    for (const k of Object.keys(dark)) {
+      if (!orderedKeys.includes(k)) orderedKeys.push(k);
+    }
+    for (const key of orderedKeys) {
+      const lightVal = light[key];
+      const darkVal = dark[key];
+      const lightHex = typeof lightVal === "string" ? colorTo8DigitHex(lightVal) ?? (hexRe.test(lightVal) ? lightVal : null) : null;
+      if (lightHex && hexRe.test(lightHex)) {
+        const figmaName = figmaColorNameWithGroup(key);
+        if (semanticNames.has(figmaName)) continue;
+        semanticNames.add(figmaName);
+        const darkHex = typeof darkVal === "string" ? colorTo8DigitHex(darkVal) ?? (hexRe.test(darkVal) ? darkVal : null) : null;
+        const refs = semanticRefMap[key];
+        const values = {
+          ...modes.includes("Light") && { Light: lightHex },
+          ...modes.includes("Dark") && { Dark: darkHex && hexRe.test(darkHex) ? darkHex : lightHex }
+        };
+        const aliasByMode = {};
+        for (const m of modes) {
+          const aliasFromRef = m === "Light" ? refs?.Light : refs?.Dark;
+          if (aliasFromRef && primitiveNames.has(aliasFromRef)) {
+            aliasByMode[m] = aliasFromRef;
+            continue;
+          }
+          const hexForMode = m === "Light" ? lightHex : darkHex && hexRe.test(darkHex) ? darkHex : lightHex;
+          const norm = hexForMode.replace(/^#/, "").toUpperCase();
+          const key8 = norm.length === 6 ? norm + "FF" : norm;
+          const oneOffAlias = oneOffHexToFigmaName.get(key8);
+          if (oneOffAlias) {
+            aliasByMode[m] = oneOffAlias;
+          }
+        }
+        semanticVariables.push({
+          name: figmaName,
+          values,
+          ...Object.keys(aliasByMode).length > 0 ? { aliasByMode } : {}
+        });
+      }
+    }
+  }
+  if (colors?.static?.brand && typeof colors.static.brand === "object") {
+    for (const [key, hex] of Object.entries(colors.static.brand)) {
+      if (typeof hex !== "string" || !hexRe.test(hex)) continue;
+      const figmaName = figmaColorNameWithGroup(`brand/${key}`);
+      if (semanticNames.has(figmaName)) continue;
+      semanticNames.add(figmaName);
+      const values = {};
+      for (const m of modes) values[m] = hex;
+      semanticVariables.push({ name: figmaName, values });
+    }
+  }
+  const colorVariableCollections = [];
+  if (primitiveVariables.length > 0) {
+    colorVariableCollections.push({
+      collectionName: primitivesCollectionName,
+      modes: primitiveModes,
+      variables: primitiveVariables,
+      applyScopes: false
+    });
+  }
+  if (radixVariables.length > 0) {
+    colorVariableCollections.push({
+      collectionName: radixCollectionName,
+      modes,
+      variables: radixVariables,
+      applyScopes: false
+    });
+  }
+  if (semanticVariables.length > 0) {
+    const primitiveCollections = [];
+    if (primitiveVariables.length > 0) primitiveCollections.push(primitivesCollectionName);
+    if (radixVariables.length > 0) primitiveCollections.push(radixCollectionName);
+    colorVariableCollections.push({
+      collectionName: `${collectionPrefix}Colors Semantic`,
+      modes,
+      variables: semanticVariables,
+      applyScopes: true,
+      ...primitiveCollections.length > 1 ? { primitiveCollectionNames: primitiveCollections } : primitiveCollections.length === 1 ? { primitiveCollectionName: primitiveCollections[0] } : {}
+    });
+  }
+  const paintStyles = [];
+  const textStyles = [];
+  const sizeToPx = (val, basePx = 16) => {
+    if (typeof val === "number") return Math.round(val);
+    const s = String(val).trim();
+    const pxMatch = s.match(/^([\d.]+)\s*px$/i);
+    if (pxMatch) return Math.round(parseFloat(pxMatch[1]));
+    const remMatch = s.match(/^([\d.]+)\s*rem$/i);
+    if (remMatch) return Math.round(parseFloat(remMatch[1]) * basePx);
+    const n = parseFloat(s);
+    if (Number.isFinite(n)) return n <= 0 ? basePx : n < 50 ? Math.round(n * basePx) : Math.round(n);
+    return basePx;
+  };
+  const letterSpacingToPx = (val, fontSizePx) => {
+    if (val === void 0 || val === null) return void 0;
+    if (typeof val === "number") return Math.round(val);
+    const s = String(val).trim();
+    const pxMatch = s.match(/^([-\d.]+)\s*px$/i);
+    if (pxMatch) return Math.round(parseFloat(pxMatch[1]));
+    const emMatch = s.match(/^([-\d.]+)\s*em$/i);
+    if (emMatch) return Math.round(parseFloat(emMatch[1]) * fontSizePx);
+    const n = parseFloat(s);
+    return Number.isFinite(n) ? Math.round(n) : void 0;
+  };
+  const firstFont = (obj) => {
+    if (typeof obj === "string") {
+      const primary = obj.split(",")[0].trim().replace(/^['"]|['"]$/g, "");
+      return primary || "Inter";
+    }
+    if (obj && typeof obj === "object" && !Array.isArray(obj)) {
+      const v = obj.body ?? obj.heading ?? obj.display ?? Object.values(obj)[0];
+      return firstFont(v);
+    }
+    return "Inter";
+  };
+  const toFontFamilyString = (val) => {
+    if (typeof val === "string") {
+      const s = val.trim().replace(/^["']|["']$/g, "");
+      return s || "Inter";
+    }
+    return firstFont(val);
+  };
+  const fontFamilyMap = typography?.fontFamily ?? {};
+  const defaultFontFamily = typography ? firstFont(typography.fontFamily ?? "Inter") : "Inter";
+  const fontSizeMap = typography?.fontSize;
+  const fontWeightMap = typography?.fontWeight;
+  const lineHeightMap = typography?.lineHeight;
+  const letterSpacingMap = typography?.letterSpacing;
+  const textTransformMap = typography?.textTransform;
+  const textDecorationMap = typography?.textDecoration;
+  if (fontSizeMap && typeof fontSizeMap === "object" && Object.keys(fontSizeMap).length > 0) {
+    for (const [key, sizeVal] of Object.entries(fontSizeMap)) {
+      const fontSize = sizeToPx(sizeVal);
+      if (fontSize <= 0) continue;
+      const role = typesetKeyToFontFamilyRole(key);
+      const fontFamily = toFontFamilyString(
+        fontFamilyMap[role] ?? fontFamilyMap.body ?? fontFamilyMap.heading ?? fontFamilyMap.display ?? defaultFontFamily
+      );
+      const lh = lineHeightMap && typeof lineHeightMap === "object" ? lineHeightMap[key] : void 0;
+      const weight = fontWeightMap && typeof fontWeightMap === "object" ? fontWeightMap[key] : void 0;
+      const fontWeight = weight != null ? String(weight) : "400";
+      const letterSpacingPx = letterSpacingToPx(
+        letterSpacingMap && typeof letterSpacingMap === "object" ? letterSpacingMap[key] : void 0,
+        fontSize
+      );
+      const textTransform = textTransformMap && typeof textTransformMap === "object" ? textTransformMap[key] : void 0;
+      const textDecoration = textDecorationMap && typeof textDecorationMap === "object" ? textDecorationMap[key] : void 0;
+      const namePart = key.replace(/-/g, " / ");
+      const style = {
+        name: namePart.startsWith("Typography") ? namePart : `Typography / ${namePart}`,
+        fontFamily,
+        fontWeight,
+        fontSize,
+        lineHeightUnit: "PERCENT",
+        letterSpacingUnit: "PIXELS",
+        ...letterSpacingPx !== void 0 && letterSpacingPx !== 0 ? { letterSpacingValue: letterSpacingPx } : {}
+      };
+      if (lh != null && typeof lh === "number" && lh > 0) {
+        style.lineHeightValue = lh >= 10 ? Math.round(lh / fontSize * 100) : Math.round(lh * 100);
+      } else {
+        style.lineHeightValue = 150;
+      }
+      if (textTransform === "uppercase") style.textCase = "UPPER";
+      else if (textTransform === "lowercase") style.textCase = "LOWER";
+      else if (textTransform === "capitalize") style.textCase = "TITLE";
+      else style.textCase = "ORIGINAL";
+      if (textDecoration === "underline") style.textDecoration = "UNDERLINE";
+      else style.textDecoration = "NONE";
+      textStyles.push(style);
+    }
+  }
+  const textStylesMap = typography?.textStyles;
+  if (textStyles.length === 0 && textStylesMap && typeof textStylesMap === "object") {
+    for (const [styleName, style] of Object.entries(textStylesMap)) {
+      if (!style || typeof style !== "object") continue;
+      const fontSize = sizeToPx(style.fontSize ?? "1rem");
+      const lhStr = style.lineHeight;
+      const lineHeightUnitless = lhStr != null ? lhStr.endsWith("%") ? parseFloat(lhStr) / 100 : sizeToPx(lhStr) / fontSize : 1.5;
+      const payload = {
+        name: styleName.startsWith("Typography") ? styleName : `Typography / ${styleName.replace(/\//g, " / ")}`,
+        fontFamily: defaultFontFamily,
+        fontWeight: String(style.fontWeight ?? "400"),
+        fontSize,
+        lineHeightUnit: "PERCENT",
+        lineHeightValue: Math.round((Number.isFinite(lineHeightUnitless) ? lineHeightUnitless : 1.5) * 100),
+        letterSpacingUnit: "PIXELS",
+        textCase: "ORIGINAL",
+        textDecoration: "NONE"
+      };
+      textStyles.push(payload);
+    }
+  }
+  textStyles.sort((a, b) => {
+    if (a.fontSize !== b.fontSize) return a.fontSize - b.fontSize;
+    return (a.name || "").localeCompare(b.name || "");
+  });
+  const numberVariableCollections = [];
+  const spacing = tokens?.spacing;
+  if (spacing?.scale && typeof spacing.scale === "object") {
+    const vars = [];
+    for (const [key, val] of Object.entries(spacing.scale)) {
+      const n = tokenValueToNumber(val);
+      if (n >= 0) vars.push({ name: `Spacing / ${key}`, value: n });
+    }
+    vars.sort((a, b) => a.value - b.value);
+    if (vars.length > 0)
+      numberVariableCollections.push({
+        collectionName: `${collectionPrefix}Spacing`,
+        categoryKey: "Spacing",
+        variables: vars,
+        scopes: ["GAP"]
+      });
+  }
+  const radius = tokens?.radius;
+  if (radius?.scale && typeof radius.scale === "object") {
+    const vars = [];
+    for (const [key, val] of Object.entries(radius.scale)) {
+      const n = tokenValueToNumber(val);
+      if (n >= 0) vars.push({ name: `Radius / ${key}`, value: n });
+    }
+    vars.sort((a, b) => a.value - b.value);
+    if (vars.length > 0)
+      numberVariableCollections.push({
+        collectionName: `${collectionPrefix}Radius`,
+        categoryKey: "Radius",
+        variables: vars,
+        scopes: ["CORNER_RADIUS"]
+      });
+  }
+  const borders = tokens?.borders;
+  if (borders?.width && typeof borders.width === "object") {
+    const vars = [];
+    for (const [key, val] of Object.entries(borders.width)) {
+      const n = tokenValueToNumber(val);
+      if (n >= 0) vars.push({ name: `Borders / ${key}`, value: n });
+    }
+    vars.sort((a, b) => a.value - b.value);
+    if (vars.length > 0)
+      numberVariableCollections.push({
+        collectionName: `${collectionPrefix}Borders`,
+        categoryKey: "Borders",
+        variables: vars,
+        scopes: ["STROKE_FLOAT"]
+      });
+  }
+  const sizing = tokens?.sizing;
+  const sizingVariables = [];
+  if (sizing?.height && typeof sizing.height === "object") {
+    for (const [key, val] of Object.entries(sizing.height)) {
+      const n = tokenValueToNumber(val);
+      if (n >= 0) sizingVariables.push({ name: `Height / ${key}`, value: n });
+    }
+  }
+  if (sizing?.icon && typeof sizing.icon === "object") {
+    for (const [key, val] of Object.entries(sizing.icon)) {
+      const n = tokenValueToNumber(val);
+      if (n >= 0) sizingVariables.push({ name: `Icon / ${key}`, value: n });
+    }
+  }
+  sizingVariables.sort((a, b) => a.value - b.value);
+  if (sizingVariables.length > 0) {
+    numberVariableCollections.push({
+      collectionName: `${collectionPrefix}Sizing`,
+      categoryKey: "Sizing",
+      variables: sizingVariables,
+      scopes: ["WIDTH_HEIGHT"]
+    });
+  }
+  const layout = tokens?.layout;
+  if (layout?.breakpoint && typeof layout.breakpoint === "object") {
+    const vars = [];
+    for (const [key, val] of Object.entries(layout.breakpoint)) {
+      const n = tokenValueToNumber(val);
+      if (n >= 0) vars.push({ name: `Breakpoint / ${key}`, value: n });
+    }
+    vars.sort((a, b) => a.value - b.value);
+    if (vars.length > 0)
+      numberVariableCollections.push({
+        collectionName: `${collectionPrefix}Layout`,
+        categoryKey: "Layout",
+        variables: vars,
+        scopes: ["WIDTH_HEIGHT"]
+      });
+  }
+  const effectStyles = [];
+  const shadows = tokens?.shadows;
+  if (shadows?.elevation && typeof shadows.elevation === "object") {
+    for (const [key, val] of Object.entries(shadows.elevation)) {
+      if (typeof val !== "string") continue;
+      const effects = parseBoxShadowToFigmaEffects(val);
+      if (effects.length > 0) effectStyles.push({ name: `Shadow / ${key}`, effects });
+    }
+  }
+  if (shadows?.focus && typeof shadows.focus === "string") {
+    const effects = parseBoxShadowToFigmaEffects(shadows.focus);
+    if (effects.length > 0) effectStyles.push({ name: "Shadow / focus", effects });
+  }
+  effectStyles.sort((a, b) => {
+    const nameA = a.name.startsWith("Shadow / ") ? a.name.slice(9) : a.name;
+    const nameB = b.name.startsWith("Shadow / ") ? b.name.slice(9) : b.name;
+    const orderA = FIGMA_SHADOW_ORDER[nameA] ?? 100;
+    const orderB = FIGMA_SHADOW_ORDER[nameB] ?? 100;
+    if (orderA !== orderB) return orderA - orderB;
+    return nameA.localeCompare(nameB);
+  });
+  return {
+    colorVariableCollections,
+    paintStyles,
+    textStyles,
+    numberVariableCollections,
+    effectStyles
+  };
+}
+
 // src/index.ts
-import {
-  buildFigmaPayloadsFromDS
-} from "@atomix/figma_tools";
 import * as path2 from "path";
 import * as fs2 from "fs";
 import { execSync } from "child_process";
@@ -1493,7 +2193,7 @@ function parseArgs() {
 }
 var cliArgs = parseArgs();
 var { dsId, apiKey, accessToken } = cliArgs;
-var apiBase = cliArgs.apiBase || "https://atomixstudio.eu";
+var apiBase = cliArgs.apiBase || "https://atomix.studio";
 var cachedData = null;
 var cachedETag = null;
 var cachedMcpTier = null;
@@ -1557,6 +2257,10 @@ function formatValidationBlock(entries) {
 async function fetchDesignSystemForMCP(forceRefresh = false) {
   if (!dsId) throw new Error("Missing --ds-id. Usage: npx @atomixstudio/mcp --ds-id <id> --atomix-token <token>");
   if (!accessToken) throw new Error("Missing --atomix-token. Get your token from the Export modal or Settings.");
+  if (forceRefresh) {
+    cachedData = null;
+    cachedETag = null;
+  }
   const result = await fetchDesignSystem({
     dsId,
     accessToken,
@@ -1573,7 +2277,7 @@ async function fetchDesignSystemForMCP(forceRefresh = false) {
   return result.data;
 }
 var TOKEN_CATEGORIES = ["colors", "typography", "spacing", "sizing", "shadows", "radius", "borders", "motion", "zIndex"];
-function typesetKeyToFontFamilyRole(key) {
+function typesetKeyToFontFamilyRole2(key) {
   const prefix = (key.split("-")[0] ?? key).toLowerCase();
   if (prefix === "display" || prefix.startsWith("display")) return "display";
   if (prefix === "heading" || prefix.startsWith("heading")) return "heading";
@@ -1593,7 +2297,7 @@ function buildTypesetsList(typography, cssPrefix = "atmx") {
   const p = cssPrefix ? `${cssPrefix}-` : "";
   const typesets = [];
   for (const key of Object.keys(fontSize)) {
-    const role = typesetKeyToFontFamilyRole(key);
+    const role = typesetKeyToFontFamilyRole2(key);
     const familyName = fontFamily[role] ?? fontFamily.body;
     const fontFamilyVarName = familyName ? `--${p}typography-font-family-${role}` : void 0;
     const fontFamilyVar = familyName ? `var(${fontFamilyVarName})` : "";
@@ -1619,7 +2323,7 @@ function buildTypesetsList(typography, cssPrefix = "atmx") {
 var server = new Server(
   {
     name: "atomix-mcp-user",
-    version: "1.0.28"
+    version: "1.0.30"
   },
   {
     capabilities: {
@@ -1918,8 +2622,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const totalChanges = lightChanges + darkChanges + deprecatedCount;
         if (totalChanges === 0 && !dryRun) {
           const lastUpdated = designSystemData.meta.exportedAt ? new Date(designSystemData.meta.exportedAt).toLocaleString() : "N/A";
+          lastSyncAffectedTokens = { modified: [], removed: [], added: [], format, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
           return {
-            responseText: `\u2713 Already up to date!
+            responseText: `\u2713 Already up to date (checked DB v${designSystemData.meta.version}, exported ${lastUpdated}).
 
 File: ${output}
 Tokens: ${tokenCount}
@@ -1930,8 +2635,9 @@ Last updated: ${lastUpdated}`,
           };
         }
         if (totalChanges === 0 && dryRun) {
+          lastSyncAffectedTokens = { modified: [], removed: [], added: [], format, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
           return {
-            responseText: `[DRY RUN] Already up to date. No changes would be written.
+            responseText: `[DRY RUN] Already up to date (checked DB v${designSystemData.meta.version}). No changes would be written.
 
 File: ${output}
 Tokens: ${tokenCount}
@@ -2572,9 +3278,7 @@ ${tokenResponseText}${validationBlock}` : `${summary}${validationBlock}`);
             out.agentInstruction = agentStartBridge;
             out.userInstruction = `If the bridge still does not connect: ${userSteps}`;
             out.figmaPayload = {
-              collectionName: payloads.colorVariables.collectionName,
-              modes: payloads.colorVariables.modes,
-              variables: payloads.colorVariables.variables,
+              colorVariableCollections: payloads.colorVariableCollections,
               paintStyles: payloads.paintStyles,
               textStyles: payloads.textStyles,
               numberVariableCollections: payloads.numberVariableCollections,
@@ -2584,13 +3288,21 @@ ${tokenResponseText}${validationBlock}` : `${summary}${validationBlock}`);
               content: [{ type: "text", text: JSON.stringify(out, null, 2) }]
             };
           }
-          if (payloads.colorVariables.variables.length > 0) {
-            out.colorVariables = await sendBridgeRequest("create_color_variables", {
-              collectionName: payloads.colorVariables.collectionName,
-              modes: payloads.colorVariables.modes,
-              variables: payloads.colorVariables.variables,
-              removeVariablesNotInPayload: true
-            });
+          const colorResults = [];
+          for (const coll of payloads.colorVariableCollections) {
+            if (coll.variables.length > 0) {
+              const result = await sendBridgeRequest("create_color_variables", {
+                collectionName: coll.collectionName,
+                modes: coll.modes,
+                variables: coll.variables,
+                removeVariablesNotInPayload: true,
+                applyScopes: coll.applyScopes
+              });
+              colorResults.push({ collectionName: coll.collectionName, result });
+            }
+          }
+          if (colorResults.length > 0) {
+            out.colorVariables = colorResults.length === 1 ? colorResults[0].result : colorResults;
           }
           if (payloads.paintStyles.length > 0) {
             out.paintStyles = await sendBridgeRequest("create_paint_styles", {
@@ -2632,9 +3344,7 @@ ${tokenResponseText}${validationBlock}` : `${summary}${validationBlock}`);
             });
           }
           out.figmaPayload = {
-            collectionName: payloads.colorVariables.collectionName,
-            modes: payloads.colorVariables.modes,
-            variables: payloads.colorVariables.variables,
+            colorVariableCollections: payloads.colorVariableCollections,
             paintStyles: payloads.paintStyles,
             textStyles: payloads.textStyles,
             numberVariableCollections: payloads.numberVariableCollections,
@@ -2643,9 +3353,7 @@ ${tokenResponseText}${validationBlock}` : `${summary}${validationBlock}`);
         } catch (e) {
           out.error = e instanceof Error ? e.message : String(e);
           out.figmaPayload = {
-            collectionName: payloads.colorVariables.collectionName,
-            modes: payloads.colorVariables.modes,
-            variables: payloads.colorVariables.variables,
+            colorVariableCollections: payloads.colorVariableCollections,
             paintStyles: payloads.paintStyles,
             textStyles: payloads.textStyles,
             numberVariableCollections: payloads.numberVariableCollections,
@@ -2671,11 +3379,21 @@ ${tokenResponseText}${validationBlock}` : `${summary}${validationBlock}`);
         }
         const summaryParts = [];
         const colorResult = out.colorVariables;
-        if (colorResult && (colorResult.variableNames?.length || (colorResult.removed ?? 0) > 0)) {
-          const parts = [];
-          if (colorResult.variableNames?.length) parts.push(`${colorResult.variableNames.length} synced`);
-          if ((colorResult.removed ?? 0) > 0) parts.push(`${colorResult.removed} removed`);
-          summaryParts.push(`Colors: ${parts.join(", ")}.`);
+        if (colorResult) {
+          const results = Array.isArray(colorResult) ? colorResult : [{ result: colorResult }];
+          let totalSynced = 0;
+          let totalRemoved = 0;
+          for (const r of results) {
+            const res = r.result;
+            if (res?.variableNames?.length) totalSynced += res.variableNames.length;
+            if ((res?.removed ?? 0) > 0) totalRemoved += res.removed ?? 0;
+          }
+          if (totalSynced > 0 || totalRemoved > 0) {
+            const parts = [];
+            if (totalSynced > 0) parts.push(`${totalSynced} synced`);
+            if (totalRemoved > 0) parts.push(`${totalRemoved} removed`);
+            summaryParts.push(`Colors: ${parts.join(", ")}.`);
+          }
         }
         const paintResult = out.paintStyles;
         if (paintResult) {
@@ -2903,7 +3621,7 @@ var SHOWCASE_HTML_TEMPLATE = `<!DOCTYPE html>
         <li>Run <code>/--rules</code> to load governance rules; run <code>/--sync</code> and <code>/--refactor</code> after you change tokens in Atomix Studio</li>
       </ul>
     </div>
-    <p class="tips">Keep the source of truth at <a href="https://atomixstudio.eu" target="_blank" rel="noopener">atomixstudio.eu</a> \u2014 avoid editing token values in this repo.</p>
+    <p class="tips">Keep the source of truth at <a href="https://atomix.studio" target="_blank" rel="noopener">atomix.studio</a> \u2014 avoid editing token values in this repo.</p>
   </div>
 </body>
 </html>
@@ -3027,7 +3745,7 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
     };
   }
   const canonicalName = name === "--hello" ? "hello" : name === "--get-started" ? "atomix-setup" : name === "--rules" ? "design-system-rules" : name === "--sync" ? "sync" : name === "--refactor" ? "refactor" : name === "--sync-to-figma" || name === "syncToFigma" ? "sync-to-figma" : name;
-  const shouldForceRefresh = canonicalName === "sync";
+  const shouldForceRefresh = canonicalName === "sync" || canonicalName === "refactor";
   let data = null;
   let stats = null;
   try {
@@ -3044,7 +3762,7 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
             content: {
               type: "text",
               text: `The MCP server isn't configured. To use design system prompts, you need to configure the server with:
-- \`--ds-id\`: Your design system ID (get it from https://atomixstudio.eu/ds/[your-ds-id])
+- \`--ds-id\`: Your design system ID (get it from https://atomix.studio/ds/[your-ds-id])
 - \`--atomix-token\`: Your access token (get it from the Export modal or Settings \u2192 Regenerate Atomix access token)
 
 Both are required. Configure the MCP server in your AI tool's MCP settings, then restart your AI tool.`
@@ -3358,42 +4076,59 @@ Format the response as a markdown table with columns: Token Name | Value | CSS V
       };
     }
     case "refactor": {
-      if (!lastSyncAffectedTokens) {
+      const refactorOutput = args?.output || "./tokens.css";
+      const refactorFormat = args?.format || "css";
+      const refactorOutputPath = path2.resolve(process.cwd(), refactorOutput);
+      const refactorFileExists = fs2.existsSync(refactorOutputPath);
+      if (!data) {
         return {
           description: "Refactor codebase for deprecated tokens",
-          messages: [
-            {
-              role: "user",
-              content: {
-                type: "text",
-                text: `No recent sync data available. Please run \`/sync\` first to update your token file, then run \`/refactor\` to scan your codebase for deprecated token usage.`
-              }
-            }
-          ]
+          messages: [{
+            role: "user",
+            content: { type: "text", text: `Failed to fetch design system from DB. Check your --ds-id and --atomix-token configuration.` }
+          }]
         };
       }
-      if (lastSyncAffectedTokens.removed.length === 0) {
+      if (!refactorFileExists) {
         return {
           description: "Refactor codebase for deprecated tokens",
-          messages: [
-            {
-              role: "user",
-              content: {
-                type: "text",
-                text: `\u2713 No deprecated tokens found in last sync.
-
-Your codebase is up to date! The last sync on ${new Date(lastSyncAffectedTokens.timestamp).toLocaleString()} did not remove any tokens.`
-              }
-            }
-          ]
+          messages: [{
+            role: "user",
+            content: { type: "text", text: `No token file found at \`${refactorOutput}\`. Please run \`/--sync\` first to create your token file, then run \`/--refactor\` to scan your codebase for deprecated token usage.` }
+          }]
+        };
+      }
+      const deprecatedTokens = /* @__PURE__ */ new Map();
+      if (["css", "scss", "less"].includes(refactorFormat)) {
+        const oldContent = fs2.readFileSync(refactorOutputPath, "utf-8");
+        const oldVarPattern = /(?:^|\n)\s*(?:\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\/\s*)?(--[a-zA-Z0-9-]+):\s*([^;]+);/gm;
+        let match;
+        while ((match = oldVarPattern.exec(oldContent)) !== null) {
+          const varName = match[1];
+          const varValue = match[2].trim();
+          if (!(varName in data.cssVariables)) deprecatedTokens.set(varName, varValue);
+        }
+      }
+      const dsVersion = data.meta.version ?? "?";
+      const dsExportedAt = data.meta.exportedAt ? new Date(data.meta.exportedAt).toLocaleString() : "N/A";
+      if (deprecatedTokens.size === 0) {
+        return {
+          description: "Refactor codebase for deprecated tokens",
+          messages: [{
+            role: "user",
+            content: { type: "text", text: `\u2713 No deprecated tokens found.
+
+Your token file \`${refactorOutput}\` is aligned with the design system (v${dsVersion}, exported ${dsExportedAt}). No tokens need migration.` }
+          }]
         };
       }
-      const format = lastSyncAffectedTokens.format;
+      const format = refactorFormat;
       const isNativeFormat = ["swift", "kotlin", "dart"].includes(format);
+      const removed = Array.from(deprecatedTokens.entries()).map(([token, lastValue]) => ({ token, lastValue }));
       let searchPatterns = "";
       let fileExtensions = "";
       if (isNativeFormat) {
-        const nativeTokens = lastSyncAffectedTokens.removed.map((r) => {
+        const nativeTokens = removed.map((r) => {
           const withoutPrefix = r.token.replace(/^--atmx-/, "");
           const camelCase = withoutPrefix.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
           const pascalCase = camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
@@ -3411,15 +4146,20 @@ Your codebase is up to date! The last sync on ${new Date(lastSyncAffectedTokens.
         }
       } else {
         fileExtensions = ".tsx, .ts, .jsx, .js, .css, .scss, .less, .vue, .svelte files";
-        searchPatterns = lastSyncAffectedTokens.removed.map(
+        searchPatterns = removed.map(
           (r) => `  \u2022 \`var(${r.token})\` or \`"${r.token}"\` (was: ${r.lastValue})`
         ).join("\n");
       }
       const instructions = `Scan the codebase for deprecated design tokens and help update them.
 
-## Deprecated Tokens (${lastSyncAffectedTokens.removed.length})
+## Design System (fresh from DB)
+- **Version:** ${dsVersion}
+- **Last exported:** ${dsExportedAt}
+- **Token file:** ${refactorOutput}
+
+## Deprecated Tokens (${removed.length})
 
-The following tokens have been removed from the design system:
+The following tokens exist in your local token file but have been removed from the design system:
 
 ${searchPatterns}
 
@@ -3588,7 +4328,7 @@ ${tokenSummary}
 
 ---
 
-*Atomix Studio \u2014 https://atomixstudio.eu | DS: https://atomixstudio.eu/ds/${dsId}*
+*Atomix Studio \u2014 https://atomix.studio | DS: https://atomix.studio/ds/${dsId}*
 `;
 }
 async function startServer() {