@atomixstudio/mcp 1.0.34 → 1.0.35

package/dist/chunk-426RNS3G.js

@@ -0,0 +1,1782 @@
+#!/usr/bin/env node
+
+// ../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) ?? data.resolvedRadixScales?.[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
+  };
+}
+var FIGMA_DESIGN_CATALOG = {
+  // ---- Methods ----------------------------------------------------------
+  methods: [
+    // Query
+    {
+      method: "get_document_info",
+      category: "query",
+      description: "Returns basic document information (name, pages).",
+      params: []
+    },
+    {
+      method: "get_selection",
+      category: "query",
+      description: "Returns the current selection in the Figma file.",
+      params: []
+    },
+    {
+      method: "get_node_info",
+      category: "query",
+      description: "Returns detailed info about a specific node.",
+      params: [
+        { name: "nodeId", type: "string", required: true, description: "Figma node ID" }
+      ]
+    },
+    {
+      method: "get_figma_variables_and_styles",
+      category: "query",
+      description: "Returns all local variable collections, text styles, effect styles, and paint styles in the file.",
+      params: []
+    },
+    {
+      method: "get_figma_library_variables",
+      category: "query",
+      description: "Returns library (team/external) variable collections available to the file.",
+      params: []
+    },
+    {
+      method: "get_design_screenshot",
+      category: "query",
+      description: "Returns a base64 PNG screenshot of a frame.",
+      params: [
+        { name: "frameId", type: "string", required: true, description: "Frame node ID" },
+        { name: "scale", type: "number", required: false, description: "Export scale 1-4 (default 1)" }
+      ]
+    },
+    {
+      method: "list_local_components",
+      category: "query",
+      description: "Lists all local components in the current file page. Returns componentId, name, and description. Use the returned componentId with design_create_component_instance.",
+      params: []
+    },
+    {
+      method: "get_component_catalog",
+      category: "query",
+      description: "Returns the curated design assets catalog: library components, library styles, library variables, local components, local styles, and local variables. Only enabled (non-excluded) items are returned. Use component keys with design_create_component_instance's componentKey param. Optionally filter by name with the query param.",
+      params: [
+        { name: "query", type: "string", required: false, description: "Filter components by name (case-insensitive substring match)" }
+      ]
+    },
+    {
+      method: "get_component_text_layers",
+      category: "query",
+      description: "Scans a component (library or local) and returns all visible text layers inside it. Returns an array of { name, characters } for each text node. Use this to discover the exact text node names before calling design_create_component_instance with textOverrides. Provide componentKey (library) or componentId (local) or nodeId (existing instance on canvas).",
+      params: [
+        { name: "componentKey", type: "string", required: false, description: "Library component key to scan" },
+        { name: "componentId", type: "string", required: false, description: "Local component ID to scan" },
+        { name: "nodeId", type: "string", required: false, description: "Existing instance or component node ID on canvas" }
+      ]
+    },
+    {
+      method: "get_variable_collection_modes",
+      category: "query",
+      description: "Returns available modes for a variable collection.",
+      params: [
+        { name: "collectionId", type: "string", required: true, description: "Variable collection ID" }
+      ]
+    },
+    {
+      method: "get_frame_variable_mode",
+      category: "query",
+      description: "Returns the current variable mode set on a frame for a collection.",
+      params: [
+        { name: "frameId", type: "string", required: true, description: "Frame node ID" },
+        { name: "collectionId", type: "string", required: true, description: "Variable collection ID" }
+      ]
+    },
+    // Sync (token push)
+    {
+      method: "create_color_variables",
+      category: "sync",
+      description: "Create or update a color variable collection (primitives or semantics with light/dark modes).",
+      params: [
+        { name: "collectionName", type: "string", required: true, description: "Collection name" },
+        { name: "modes", type: "array", required: true, description: "Mode names (e.g. ['Light','Dark'])" },
+        { name: "variables", type: "array", required: true, description: "Array of color variables" },
+        { name: "applyScopes", type: "boolean", required: false, description: "Apply scopes to variables (true for semantics)" },
+        { name: "primitiveCollectionName", type: "string", required: false, description: "Primitives collection for alias resolution" },
+        { name: "primitiveCollectionNames", type: "array", required: false, description: "Multiple primitives collections for alias resolution" }
+      ]
+    },
+    {
+      method: "create_paint_styles",
+      category: "sync",
+      description: "Create or update paint styles.",
+      params: [
+        { name: "styles", type: "array", required: true, description: "Array of { name, color } paint styles" }
+      ]
+    },
+    {
+      method: "create_text_styles",
+      category: "sync",
+      description: "Create or update text styles from typography tokens.",
+      params: [
+        { name: "styles", type: "array", required: true, description: "Array of text style payloads" }
+      ]
+    },
+    {
+      method: "create_number_variables",
+      category: "sync",
+      description: "Create or update a number variable collection (spacing, radius, borders, sizing, breakpoints).",
+      params: [
+        { name: "collectionName", type: "string", required: true, description: "Collection name" },
+        { name: "categoryKey", type: "string", required: true, description: "Token category key" },
+        { name: "variables", type: "array", required: true, description: "Array of { name, value } number variables" },
+        { name: "scopes", type: "array", required: true, description: "Figma variable scopes" }
+      ]
+    },
+    {
+      method: "create_effect_styles",
+      category: "sync",
+      description: "Create or update effect styles (shadows).",
+      params: [
+        { name: "styles", type: "array", required: true, description: "Array of { name, effects } effect styles" }
+      ]
+    },
+    {
+      method: "apply_fill_to_selection",
+      category: "sync",
+      description: "Apply a fill color to the current Figma selection.",
+      params: [
+        { name: "variableId", type: "string", required: false, description: "Variable ID to apply" },
+        { name: "paintStyleId", type: "string", required: false, description: "Paint style ID to apply" }
+      ]
+    },
+    {
+      method: "apply_matching_styles_to_selection",
+      category: "styling",
+      description: "Apply matching or closest variables and styles to the current Figma selection by color distance.",
+      params: [
+        { name: "strategy", type: "string", required: false, description: "Match strategy", enum: ["closest", "variable"] },
+        { name: "applyFills", type: "boolean", required: false, description: "Apply matching to fill colors (default true)" },
+        { name: "applyStrokes", type: "boolean", required: false, description: "Apply matching to stroke colors (default true)" },
+        { name: "applyTextStyles", type: "boolean", required: false, description: "Apply closest text style (default true)" },
+        { name: "applyEffects", type: "boolean", required: false, description: "Apply closest effect style (default true)" },
+        { name: "applyCornerRadius", type: "boolean", required: false, description: "Bind closest corner radius variable (default true)" }
+      ]
+    },
+    // Create (design)
+    {
+      method: "design_create_frame",
+      category: "create",
+      description: "Creates a frame. When parentId is omitted, creates a top-level ROOT frame on the canvas with vertical auto-layout (FIXED size, clipped, auto-positioned next to existing content, selected and scrolled into view). When parentId is provided, creates a child frame inside that parent. USE FRAMES for all containers, sections, columns, cards, buttons, inputs \u2014 anything that holds children or needs auto-layout.",
+      params: [
+        { name: "parentId", type: "string", required: false, description: "Parent node name or ID. Omit to create a top-level root frame." },
+        { name: "name", type: "string", required: false, description: "Node name (used for ID resolution in later steps)" },
+        { name: "width", type: "number", required: false, description: "Optional fixed width" },
+        { name: "height", type: "number", required: false, description: "Optional fixed height" },
+        { name: "fillVariableName", type: "string", required: false, description: "Background fill variable name" },
+        { name: "cornerRadiusVariableName", type: "string", required: false, description: "Corner radius variable name" },
+        { name: "cornerRadius", type: "number", required: false, description: "Corner radius literal (prefer variable when available)" }
+      ]
+    },
+    {
+      method: "design_create_text",
+      category: "create",
+      description: "Creates a text node with visible content.",
+      params: [
+        { name: "parentId", type: "string", required: false, description: "Parent node name or ID" },
+        { name: "characters", type: "string", required: true, description: 'The visible text label (e.g. "Button", "Submit"). NEVER just "Text".' },
+        { name: "textStyleName", type: "string", required: false, description: "Text style name from the file" },
+        { name: "fillVariableName", type: "string", required: false, description: "Text color variable name" },
+        { name: "name", type: "string", required: false, description: "Node name" }
+      ]
+    },
+    {
+      method: "design_create_rectangle",
+      category: "create",
+      description: "Creates a rectangle. Use ONLY for decorative shapes, dividers, or image placeholders \u2014 NOT for layout containers.",
+      params: [
+        { name: "parentId", type: "string", required: false, description: "Parent node name or ID" },
+        { name: "width", type: "number", required: true, description: "Width in pixels" },
+        { name: "height", type: "number", required: true, description: "Height in pixels" },
+        { name: "fillVariableName", type: "string", required: false, description: "Fill variable name" },
+        { name: "cornerRadiusVariableName", type: "string", required: false, description: "Corner radius variable name" },
+        { name: "cornerRadius", type: "number", required: false, description: "Corner radius literal" },
+        { name: "name", type: "string", required: false, description: "Node name" }
+      ]
+    },
+    {
+      method: "design_create_ellipse",
+      category: "create",
+      description: "Creates an ellipse shape.",
+      params: [
+        { name: "parentId", type: "string", required: false, description: "Parent node name or ID" },
+        { name: "width", type: "number", required: true, description: "Width in pixels" },
+        { name: "height", type: "number", required: true, description: "Height in pixels" },
+        { name: "fillVariableName", type: "string", required: false, description: "Fill variable name" },
+        { name: "name", type: "string", required: false, description: "Node name" }
+      ]
+    },
+    {
+      method: "design_create_line",
+      category: "create",
+      description: "Creates a line.",
+      params: [
+        { name: "parentId", type: "string", required: false, description: "Parent node name or ID" },
+        { name: "length", type: "number", required: false, description: "Line length in pixels" },
+        { name: "strokeVariableName", type: "string", required: false, description: "Stroke color variable name" },
+        { name: "strokeWeight", type: "number", required: false, description: "Stroke weight in pixels" },
+        { name: "name", type: "string", required: false, description: "Node name" }
+      ]
+    },
+    {
+      method: "design_create_vector",
+      category: "create",
+      description: "Creates a vector node with optional SVG path data. Use for custom icons or shapes when no library component exists.",
+      params: [
+        { name: "parentId", type: "string", required: false, description: "Parent node name or ID" },
+        { name: "name", type: "string", required: false, description: "Node name" },
+        { name: "vectorPaths", type: "array", required: false, description: 'Array of SVG path objects: [{"windingRule":"NONZERO"|"EVENODD","data":"M0 0 L10 10..."}]' },
+        { name: "width", type: "number", required: false, description: "Vector width in pixels" },
+        { name: "height", type: "number", required: false, description: "Vector height in pixels" },
+        { name: "fillVariableName", type: "string", required: false, description: "Fill color variable name" }
+      ]
+    },
+    {
+      method: "design_create_image",
+      category: "create",
+      description: "Creates an image node from base64 data.",
+      params: [
+        { name: "parentId", type: "string", required: false, description: "Parent node name or ID" },
+        { name: "imageBytesBase64", type: "string", required: true, description: "Base64-encoded PNG or JPEG" },
+        { name: "width", type: "number", required: false, description: "Width in pixels" },
+        { name: "height", type: "number", required: false, description: "Height in pixels" },
+        { name: "scaleMode", type: "string", required: false, description: "Image scale mode", enum: ["FILL", "FIT", "CROP", "TILE"] },
+        { name: "name", type: "string", required: false, description: "Node name" }
+      ]
+    },
+    {
+      method: "design_create_frame_from_preset",
+      category: "create",
+      description: "Creates a frame from a device preset.",
+      params: [
+        {
+          name: "preset",
+          type: "string",
+          required: true,
+          description: "Device preset name",
+          enum: [
+            "iphone_14",
+            "iphone_14_plus",
+            "iphone_se",
+            "android_360",
+            "android_412",
+            "tablet_768",
+            "desktop_1440",
+            "desktop_1920"
+          ]
+        },
+        { name: "parentId", type: "string", required: false, description: "Parent node name or ID" }
+      ]
+    },
+    // Components
+    {
+      method: "design_create_component_instance",
+      category: "component",
+      description: 'Creates an instance of a library or local component. For library components with variants, pass the componentKey (works for both component keys and component set keys). Select a variant with variantKey (exact key) or variantProperties (property map like {"Size":"sm","State":"default"}). Use textOverrides to set text inside the instance (e.g. button label, input placeholder) \u2014 keys are text node names, values are the text. After creation, hardcoded fills/strokes are automatically rebound to the closest matching DS color variable so imported components use semantic colors. Set rebindColors to false to skip.',
+      params: [
+        { name: "parentId", type: "string", required: false, description: "Parent node name or ID" },
+        { name: "componentKey", type: "string", required: false, description: "Library component key or component set key" },
+        { name: "variantKey", type: "string", required: false, description: "Specific variant key (from children list) to import a particular variant instead of the default" },
+        { name: "variantProperties", type: "object", required: false, description: 'Variant properties map to select a variant by property values (e.g. {"Size":"sm","State":"default"}). Alternative to variantKey.' },
+        { name: "componentId", type: "string", required: false, description: "Local component ID" },
+        { name: "name", type: "string", required: false, description: "Node name" },
+        { name: "textOverrides", type: "object", required: false, description: 'Text overrides for text nodes inside the instance. Keys are text node names, values are the replacement text (e.g. {"Label":"Submit","Placeholder":"Enter email"}). The first text node can also be targeted with key "_primary".' },
+        { name: "fillVariableId", type: "string", required: false, description: "Color variable ID to apply as the root fill (overrides automatic rebind for the instance root)" },
+        { name: "rebindColors", type: "boolean", required: false, description: "Auto-rebind hardcoded fills/strokes to closest DS color variable (default: true)" }
+      ]
+    },
+    {
+      method: "design_create_component",
+      category: "component",
+      description: "Creates an empty master component.",
+      params: [
+        { name: "parentId", type: "string", required: false, description: "Parent node name or ID" },
+        { name: "name", type: "string", required: false, description: "Component name" },
+        { name: "width", type: "number", required: false, description: "Width in pixels" },
+        { name: "height", type: "number", required: false, description: "Height in pixels" }
+      ]
+    },
+    {
+      method: "design_convert_to_component",
+      category: "component",
+      description: "Converts an existing frame to a component.",
+      params: [
+        { name: "nodeId", type: "string", required: true, description: "Frame node ID to convert" },
+        { name: "name", type: "string", required: false, description: "Component name" }
+      ]
+    },
+    {
+      method: "design_combine_as_variants",
+      category: "component",
+      description: "Combines 2+ components into a variant set.",
+      params: [
+        { name: "parentId", type: "string", required: true, description: "Parent node name or ID" },
+        { name: "nodeIds", type: "array", required: true, description: "Array of 2+ component node IDs" },
+        { name: "index", type: "number", required: false, description: "Insert index" }
+      ]
+    },
+    // Layout
+    {
+      method: "design_set_auto_layout",
+      category: "layout",
+      description: "Sets auto-layout on a frame. Use layoutWrap WRAP for horizontal layouts that wrap children to multiple rows.",
+      params: [
+        { name: "nodeId", type: "string", required: false, description: "Target node name or ID (defaults to last created frame)" },
+        { name: "direction", type: "string", required: true, description: "Layout direction", enum: ["VERTICAL", "HORIZONTAL"] },
+        { name: "layoutWrap", type: "string", required: false, description: "Only for HORIZONTAL: NO_WRAP (default) or WRAP to allow children to wrap to next row", enum: ["NO_WRAP", "WRAP"] },
+        { name: "counterAxisSpacingVariableName", type: "string", required: false, description: "When layoutWrap WRAP: spacing between wrapped rows (variable name)" },
+        { name: "counterAxisAlignContent", type: "string", required: false, description: "When layoutWrap WRAP: alignment of wrapped rows", enum: ["AUTO", "SPACE_BETWEEN"] },
+        { name: "paddingVariableName", type: "string", required: false, description: "Padding variable name (all sides). Overridden by per-side params if provided." },
+        { name: "paddingTopVariableName", type: "string", required: false, description: "Top padding variable name (overrides paddingVariableName for top)" },
+        { name: "paddingRightVariableName", type: "string", required: false, description: "Right padding variable name (overrides paddingVariableName for right)" },
+        { name: "paddingBottomVariableName", type: "string", required: false, description: "Bottom padding variable name (overrides paddingVariableName for bottom)" },
+        { name: "paddingLeftVariableName", type: "string", required: false, description: "Left padding variable name (overrides paddingVariableName for left)" },
+        { name: "itemSpacingVariableName", type: "string", required: false, description: "Item spacing variable name" },
+        { name: "primaryAxisAlignItems", type: "string", required: false, description: "Primary axis alignment", enum: ["MIN", "CENTER", "MAX", "SPACE_BETWEEN"] },
+        { name: "counterAxisAlignItems", type: "string", required: false, description: "Counter axis alignment", enum: ["MIN", "CENTER", "MAX", "BASELINE"] },
+        { name: "layoutSizingHorizontal", type: "string", required: false, description: "Horizontal sizing", enum: ["HUG", "FILL"] },
+        { name: "layoutSizingVertical", type: "string", required: false, description: "Vertical sizing", enum: ["HUG", "FILL"] }
+      ]
+    },
+    {
+      method: "design_set_layout_sizing",
+      category: "layout",
+      description: "Sets sizing behavior and optional per-child alignment override on a node within auto-layout.",
+      params: [
+        { name: "nodeId", type: "string", required: false, description: "Target node name or ID" },
+        { name: "layoutSizingHorizontal", type: "string", required: false, description: "Horizontal sizing", enum: ["FIXED", "HUG", "FILL"] },
+        { name: "layoutSizingVertical", type: "string", required: false, description: "Vertical sizing", enum: ["FIXED", "HUG", "FILL"] },
+        { name: "layoutAlign", type: "string", required: false, description: "Whether this child stretches on the counter axis. Use STRETCH to fill; INHERIT (default) to not stretch. Counter-axis alignment is set on the parent via counterAxisAlignItems.", enum: ["STRETCH", "INHERIT"] }
+      ]
+    },
+    {
+      method: "design_set_layout_constraints",
+      category: "layout",
+      description: "Sets min/max width/height constraints on a node. Use variable names for token-bound values, or raw numbers as fallback.",
+      params: [
+        { name: "nodeId", type: "string", required: true, description: "Target node name or ID" },
+        { name: "minWidthVariableName", type: "string", required: false, description: "Min width variable name" },
+        { name: "maxWidthVariableName", type: "string", required: false, description: "Max width variable name" },
+        { name: "minHeightVariableName", type: "string", required: false, description: "Min height variable name" },
+        { name: "maxHeightVariableName", type: "string", required: false, description: "Max height variable name" },
+        { name: "minWidth", type: "number", required: false, description: "Min width in pixels (fallback if no variable)" },
+        { name: "maxWidth", type: "number", required: false, description: "Max width in pixels (fallback if no variable)" },
+        { name: "minHeight", type: "number", required: false, description: "Min height in pixels (fallback if no variable)" },
+        { name: "maxHeight", type: "number", required: false, description: "Max height in pixels (fallback if no variable)" }
+      ]
+    },
+    {
+      method: "design_set_resize_constraints",
+      category: "layout",
+      description: "Sets resize constraints (how the node responds to parent resize). Use for absolutely positioned/floating elements so they float correctly on resize. Horizontal: MIN=Left, CENTER=Center, MAX=Right, STRETCH=Left+Right (pin both, width stretches), SCALE=scale with parent. Vertical: MIN=Top, CENTER=Center, MAX=Bottom, STRETCH=Top+Bottom, SCALE=scale.",
+      params: [
+        { name: "nodeId", type: "string", required: true, description: "Target node name or ID" },
+        { name: "constraintsHorizontal", type: "string", required: false, description: "Horizontal: MIN (left), CENTER, MAX (right), STRETCH (left+right), SCALE", enum: ["MIN", "MAX", "CENTER", "STRETCH", "SCALE"] },
+        { name: "constraintsVertical", type: "string", required: false, description: "Vertical: MIN (top), CENTER, MAX (bottom), STRETCH (top+bottom), SCALE", enum: ["MIN", "MAX", "CENTER", "STRETCH", "SCALE"] }
+      ]
+    },
+    {
+      method: "design_set_node_position",
+      category: "layout",
+      description: "Sets x/y position of a node. For floating elements inside an auto-layout frame (badges, FABs, overlays), set absolute: true so the node ignores auto-layout and is positioned by x/y; then use design_set_resize_constraints so it floats correctly on parent resize.",
+      params: [
+        { name: "nodeId", type: "string", required: true, description: "Target node name or ID" },
+        { name: "x", type: "number", required: true, description: "X position" },
+        { name: "y", type: "number", required: true, description: "Y position" },
+        { name: "absolute", type: "boolean", required: false, description: "If true, set layoutPositioning to ABSOLUTE so the node is taken out of auto-layout flow (use for floating UI elements)" }
+      ]
+    },
+    {
+      method: "design_resize_node",
+      category: "layout",
+      description: "Resizes a node and optionally updates corner radius.",
+      params: [
+        { name: "nodeId", type: "string", required: false, description: "Target node name or ID" },
+        { name: "width", type: "number", required: false, description: "New width" },
+        { name: "height", type: "number", required: false, description: "New height" },
+        { name: "cornerRadiusVariableName", type: "string", required: false, description: "Corner radius variable name" },
+        { name: "cornerRadius", type: "number", required: false, description: "Corner radius literal" }
+      ]
+    },
+    {
+      method: "design_append_child",
+      category: "layout",
+      description: "Reparents a node into a new parent.",
+      params: [
+        { name: "parentId", type: "string", required: true, description: "New parent node name or ID" },
+        { name: "childId", type: "string", required: true, description: "Child node name or ID to reparent" }
+      ]
+    },
+    {
+      method: "design_group_nodes",
+      category: "layout",
+      description: "Groups multiple nodes together.",
+      params: [
+        { name: "parentId", type: "string", required: true, description: "Parent node name or ID" },
+        { name: "nodeIds", type: "array", required: true, description: "Array of node names or IDs to group" }
+      ]
+    },
+    // Styling
+    {
+      method: "design_set_effects",
+      category: "styling",
+      description: "Applies an effect style to a node.",
+      params: [
+        { name: "nodeId", type: "string", required: true, description: "Target node name or ID" },
+        { name: "effectStyleName", type: "string", required: true, description: "Effect style name from the file" }
+      ]
+    },
+    {
+      method: "design_set_strokes",
+      category: "styling",
+      description: "Sets stroke color, weight, and alignment on a node. Supports uniform weight or per-side weights (top/right/bottom/left).",
+      params: [
+        { name: "nodeId", type: "string", required: true, description: "Target node name or ID" },
+        { name: "strokeVariableName", type: "string", required: true, description: "Stroke color variable name" },
+        { name: "strokeWeight", type: "number", required: false, description: "Uniform stroke weight in pixels (overridden by per-side values)" },
+        { name: "strokeWeightVariableName", type: "string", required: false, description: "Stroke weight variable name" },
+        { name: "strokeAlign", type: "string", required: false, description: "Stroke alignment", enum: ["INSIDE", "OUTSIDE", "CENTER"] },
+        { name: "strokeTopWeight", type: "number", required: false, description: "Top stroke weight (enables individual strokes)" },
+        { name: "strokeRightWeight", type: "number", required: false, description: "Right stroke weight" },
+        { name: "strokeBottomWeight", type: "number", required: false, description: "Bottom stroke weight" },
+        { name: "strokeLeftWeight", type: "number", required: false, description: "Left stroke weight" }
+      ]
+    },
+    {
+      method: "design_set_text_properties",
+      category: "styling",
+      description: "Sets text alignment, truncation, max lines, and auto-sizing mode on a text node.",
+      params: [
+        { name: "nodeId", type: "string", required: true, description: "Target text node name or ID" },
+        { name: "textAlignHorizontal", type: "string", required: false, description: "Horizontal alignment", enum: ["LEFT", "CENTER", "RIGHT", "JUSTIFIED"] },
+        { name: "textAlignVertical", type: "string", required: false, description: "Vertical alignment", enum: ["TOP", "CENTER", "BOTTOM"] },
+        { name: "textAutoResize", type: "string", required: false, description: "Text auto-sizing mode: WIDTH_AND_HEIGHT (auto width), HEIGHT (fixed width, auto height), NONE (fixed size), TRUNCATE (fixed + clip)", enum: ["NONE", "WIDTH_AND_HEIGHT", "HEIGHT", "TRUNCATE"] },
+        { name: "textTruncation", type: "string", required: false, description: "Truncation mode", enum: ["DISABLED", "ENDING"] },
+        { name: "maxLines", type: "number", required: false, description: "Max lines before truncation" }
+      ]
+    },
+    // Mode
+    {
+      method: "design_set_frame_variable_mode",
+      category: "mode",
+      description: "Sets light/dark mode override on a frame. The root frame defaults to Light automatically \u2014 child frames inherit from root (AUTO). Only use this to switch the root frame's mode or to override a specific non-root parent frame.",
+      params: [
+        { name: "frameId", type: "string", required: true, description: "Frame node ID" },
+        { name: "collectionId", type: "string", required: true, description: "Variable collection ID" },
+        { name: "modeId", type: "string", required: true, description: "Mode ID" }
+      ]
+    },
+    // Finalize
+    {
+      method: "finalize_design_frame",
+      category: "finalize",
+      description: "Renames the root frame and optionally sets its background fill. Should be the last step.",
+      params: [
+        { name: "frameId", type: "string", required: false, description: "Frame ID (auto-targets root frame if omitted)" },
+        { name: "name", type: "string", required: true, description: "Final descriptive name for the frame" },
+        { name: "fillVariableName", type: "string", required: false, description: "Background fill variable name" }
+      ]
+    }
+  ],
+  // ---- Output rules (AI instructions, not mandatory for all callers) ------
+  outputRules: [
+    "If the user is asking a question and NOT requesting UI on canvas, answer with a helpful reply and output steps: [].",
+    "For multi-element designs, the first step should be design_create_frame with NO parentId and width/height from standard sizes. This creates the root frame.",
+    "The root frame IS the design canvas. Add sections/columns/children directly to it \u2014 do NOT create a wrapper frame inside.",
+    "Last step is ALWAYS finalize_design_frame with a descriptive name and optional fillVariableName for the root background.",
+    'Every design_create_text MUST include actual characters content, NEVER just "Text".',
+    "Every design_create_frame for a visible component MUST include fillVariableName for its background.",
+    "Every frame with children MUST have design_set_auto_layout applied.",
+    "parentId must be a frame or group, NEVER a component instance. When using design_create_component_instance, create a wrapper frame first, add the instance to it, then use the wrapper frame as parentId for text or other children.",
+    "When using design_create_component_instance for UI components (buttons, inputs, cards, alerts), ALWAYS pass textOverrides to set the visible text INSIDE the component. Do NOT create separate design_create_text steps for text that belongs inside a component \u2014 use textOverrides instead.",
+    'Use design_set_layout_sizing with layoutSizingHorizontal:"FILL" on section/column frames (direct children of root) so they stretch to fill root width. Plugin auto-applies FILL width for 2nd-level children.',
+    "Use EXACT variable/style names from the file context \u2014 do not invent names.",
+    "All params MUST be included in each step \u2014 method names alone are useless without their params."
+  ],
+  // ---- ID resolution rules -----------------------------------------------
+  idResolutionRules: [
+    "After the first design_create_frame (root frame, no parentId), any create step missing parentId defaults to the root frame.",
+    'Use the "name" param from a previous create step as parentId/nodeId to reference that node. Example: if you create a frame with name:"Card", then parentId:"Card" in a later step targets that frame.',
+    'For design_set_auto_layout/design_resize_node/design_set_layout_sizing: use nodeId:"FrameName" to target a named frame. If nodeId is omitted, it targets the last created frame (or the root).',
+    "finalize_design_frame auto-targets the root frame if frameId is omitted."
+  ],
+  // ---- Composition guidelines --------------------------------------------
+  compositionGuidelines: [
+    // --- Sizing hierarchy (enforced by plugin, but model should follow) ---
+    "SIZING HIERARCHY (critical):",
+    "  Level 1 \u2014 Root frame: width is ALWAYS FIXED (never FILL/HUG). Height is HUG for pages/screens (>=500px) so content grows, FIXED for small components (<500px like navbars, cards).",
+    "  Level 2 \u2014 Sections/columns (direct children of root): ALWAYS layoutSizingHorizontal FILL so they stretch to root width. The plugin auto-applies FILL width, but you should still call design_set_layout_sizing for clarity.",
+    "  Level 3 \u2014 Content frames (cards, rows, inputs, buttons): FILL width to stretch within their section, or HUG for inline elements (badges, icons). Use design_set_layout_sizing explicitly.",
+    "  Text nodes: FILL width + textAutoResize HEIGHT for body/paragraph text (auto-applied by plugin). HUG for short labels.",
+    // --- General composition ---
+    "The root frame already has VERTICAL auto-layout. Add sections directly as children.",
+    "Use design_create_frame for all containers (sections, columns, cards, inputs, buttons). Rectangles do NOT support children.",
+    "For a 2-column layout: create left + right column frames directly in the root frame, set layout_sizing FILL on columns, change root auto-layout to HORIZONTAL.",
+    "For a page with sections: create section frames directly in the root frame, set layout_sizing FILL on each section.",
+    "For a card: root frame (small size) with card frame (fill + radius) as direct child, children inside card, auto-layout card VERTICAL, finalize.",
+    'When a card or row uses an icon/component: create a wrapper frame (e.g. name:"Card"), add design_create_component_instance as child of that frame, then add text/other children with parentId:"Card" \u2014 never use the instance name as parentId.',
+    "For grouped elements (button = frame + text, input = frame + text): create inner frames with their own auto-layout.",
+    "Apply auto-layout to INNER frames first, then OUTER frames (bottom-up order).",
+    "For text that should wrap (body, paragraph, card/feed content): ensure the text's parent frame has auto-layout, then use design_set_layout_sizing on the text node with layoutSizingHorizontal FILL and design_set_text_properties with textAutoResize HEIGHT so text wraps to the frame width.",
+    "For horizontal layouts that should wrap children to multiple rows (e.g. tag lists, card grids): use design_set_auto_layout with direction HORIZONTAL and layoutWrap WRAP; optionally set counterAxisSpacingVariableName and counterAxisAlignContent (AUTO or SPACE_BETWEEN).",
+    "Floating elements (badge, FAB, overlay, close button): create the node as child of the relevant frame, then design_set_node_position with absolute: true and x, y; then design_set_resize_constraints (e.g. STRETCH+MAX for a bottom bar that stretches width and sticks to bottom)."
+  ],
+  // ---- Placeholder sizes -------------------------------------------------
+  placeholderSizes: {
+    desktop: { width: 1440, height: 900, description: '"desktop" / "page" / "landing" / "dashboard" / "screen"' },
+    mobile: { width: 390, height: 844, description: '"mobile" / "phone" / "app"' },
+    tablet: { width: 768, height: 1024, description: '"tablet" / "iPad"' },
+    card: { width: 400, height: 500, description: '"card" / "dialog" / "modal"' },
+    sidebar: { width: 320, height: 600, description: '"sidebar"' },
+    navbar: { width: 1440, height: 64, description: '"navbar" / "header"' },
+    component: { width: 400, height: 200, description: '"button" / "input" / "badge" / small component' }
+  },
+  // ---- Examples ----------------------------------------------------------
+  examples: [
+    {
+      prompt: "Create a primary button",
+      reply: "Primary button with `Action / primary` fill.",
+      steps: [
+        { method: "design_create_frame", params: { width: 400, height: 200 } },
+        { method: "design_create_frame", params: { name: "Button", fillVariableName: "Action / primary", cornerRadiusVariableName: "Radius / md" } },
+        { method: "design_create_text", params: { parentId: "Button", characters: "Button", textStyleName: "bodySm", fillVariableName: "Action / primary-foreground" } },
+        { method: "design_set_auto_layout", params: { nodeId: "Button", direction: "HORIZONTAL", paddingVariableName: "Spacing / md", itemSpacingVariableName: "Spacing / sm", primaryAxisAlignItems: "CENTER", counterAxisAlignItems: "CENTER", layoutSizingHorizontal: "HUG", layoutSizingVertical: "HUG" } },
+        { method: "finalize_design_frame", params: { name: "Primary Button" } }
+      ]
+    },
+    {
+      prompt: "Design a login screen",
+      reply: "Desktop login screen with image column and form column.",
+      steps: [
+        { method: "design_create_frame", params: { width: 1440, height: 900 } },
+        { method: "design_create_frame", params: { name: "ImageColumn", fillVariableName: "Surface / muted" } },
+        { method: "design_set_layout_sizing", params: { nodeId: "ImageColumn", layoutSizingHorizontal: "FILL", layoutSizingVertical: "FILL" } },
+        { method: "design_create_frame", params: { name: "FormColumn", fillVariableName: "Surface / primary" } },
+        { method: "design_set_layout_sizing", params: { nodeId: "FormColumn", layoutSizingHorizontal: "FILL", layoutSizingVertical: "FILL" } },
+        { method: "design_create_text", params: { parentId: "FormColumn", characters: "Welcome back", textStyleName: "heading", fillVariableName: "Text / primary", name: "Title" } },
+        { method: "design_create_frame", params: { parentId: "FormColumn", name: "EmailInput", fillVariableName: "Surface / secondary", cornerRadiusVariableName: "Radius / md" } },
+        { method: "design_create_text", params: { parentId: "EmailInput", characters: "Email address", textStyleName: "bodySm", fillVariableName: "Text / secondary" } },
+        { method: "design_set_auto_layout", params: { nodeId: "EmailInput", direction: "HORIZONTAL", paddingVariableName: "Spacing / sm", counterAxisAlignItems: "CENTER", layoutSizingHorizontal: "FILL", layoutSizingVertical: "HUG" } },
+        { method: "design_create_frame", params: { parentId: "FormColumn", name: "PasswordInput", fillVariableName: "Surface / secondary", cornerRadiusVariableName: "Radius / md" } },
+        { method: "design_create_text", params: { parentId: "PasswordInput", characters: "Password", textStyleName: "bodySm", fillVariableName: "Text / secondary" } },
+        { method: "design_set_auto_layout", params: { nodeId: "PasswordInput", direction: "HORIZONTAL", paddingVariableName: "Spacing / sm", counterAxisAlignItems: "CENTER", layoutSizingHorizontal: "FILL", layoutSizingVertical: "HUG" } },
+        { method: "design_create_frame", params: { parentId: "FormColumn", name: "LoginBtn", fillVariableName: "Action / primary", cornerRadiusVariableName: "Radius / md" } },
+        { method: "design_create_text", params: { parentId: "LoginBtn", characters: "Sign in", textStyleName: "bodySm", fillVariableName: "Action / primary-foreground" } },
+        { method: "design_set_auto_layout", params: { nodeId: "LoginBtn", direction: "HORIZONTAL", paddingVariableName: "Spacing / md", primaryAxisAlignItems: "CENTER", counterAxisAlignItems: "CENTER", layoutSizingHorizontal: "FILL", layoutSizingVertical: "HUG" } },
+        { method: "design_set_auto_layout", params: { nodeId: "FormColumn", direction: "VERTICAL", paddingVariableName: "Spacing / xl", itemSpacingVariableName: "Spacing / md", primaryAxisAlignItems: "CENTER", counterAxisAlignItems: "MIN", layoutSizingHorizontal: "FILL", layoutSizingVertical: "FILL" } },
+        { method: "design_set_auto_layout", params: { direction: "HORIZONTAL", itemSpacingVariableName: "Spacing / none", primaryAxisAlignItems: "MIN", counterAxisAlignItems: "MIN" } },
+        { method: "finalize_design_frame", params: { name: "Desktop Login Screen", fillVariableName: "Surface / primary" } }
+      ],
+      note: "The last design_set_auto_layout without nodeId targets the root frame (overrides its default VERTICAL layout to HORIZONTAL for the 2-column split)."
+    }
+  ]
+};
+function getCatalogMethodNames() {
+  return FIGMA_DESIGN_CATALOG.methods.map((m) => m.method);
+}
+function getDesignMethodNames() {
+  return FIGMA_DESIGN_CATALOG.methods.filter((m) => m.category !== "query" && m.category !== "sync").map((m) => m.method);
+}
+function getQueryMethodNames() {
+  return FIGMA_DESIGN_CATALOG.methods.filter((m) => m.category === "query").map((m) => m.method);
+}
+function formatCatalogForMCP(catalog, fileContext) {
+  const designMethods = catalog.methods.filter(
+    (m) => m.category !== "sync"
+  );
+  return {
+    methods: designMethods.map((m) => ({
+      method: m.method,
+      category: m.category,
+      description: m.description,
+      params: m.params
+    })),
+    outputRules: catalog.outputRules,
+    idResolutionRules: catalog.idResolutionRules,
+    compositionGuidelines: catalog.compositionGuidelines,
+    placeholderSizes: catalog.placeholderSizes,
+    examples: catalog.examples,
+    ...fileContext ? { fileContext } : {}
+  };
+}
+function normalizeTokenName(name) {
+  return name.toLowerCase().trim().replace(/\s*\/\s*/g, "/").replace(/\s+/g, "/").replace(/\/+/g, "/").replace(/^\//, "").replace(/\/$/, "");
+}
+function buildResolvers(fileContext) {
+  const textStyleIdByName = /* @__PURE__ */ new Map();
+  const textStyleIdByNormalized = /* @__PURE__ */ new Map();
+  for (const s of fileContext.textStyles ?? []) {
+    textStyleIdByName.set(s.name, s.id);
+    textStyleIdByNormalized.set(normalizeTokenName(s.name), s.id);
+  }
+  const effectStyleIdByName = /* @__PURE__ */ new Map();
+  const effectStyleIdByNormalized = /* @__PURE__ */ new Map();
+  for (const s of fileContext.effectStyles ?? []) {
+    effectStyleIdByName.set(s.name, s.id);
+    effectStyleIdByNormalized.set(normalizeTokenName(s.name), s.id);
+  }
+  const variableIdByName = /* @__PURE__ */ new Map();
+  const variableIdByNormalized = /* @__PURE__ */ new Map();
+  for (const coll of fileContext.variableCollections ?? []) {
+    for (const v of coll.variables) {
+      variableIdByName.set(v.name, v.id);
+      variableIdByNormalized.set(normalizeTokenName(v.name), v.id);
+    }
+  }
+  for (const coll of fileContext.variableCollectionsLibrary ?? []) {
+    for (const v of coll.variables) {
+      const identifier = v.key ? `libkey:${v.key}` : v.id ?? "";
+      if (!identifier) continue;
+      if (!variableIdByName.has(v.name)) {
+        variableIdByName.set(v.name, identifier);
+        variableIdByNormalized.set(normalizeTokenName(v.name), identifier);
+      }
+    }
+  }
+  const firstTextStyleId = (fileContext.textStyles ?? [])[0]?.id;
+  const firstEffectStyleId = (fileContext.effectStyles ?? [])[0]?.id;
+  return {
+    textStyleIdByName,
+    textStyleIdByNormalized,
+    effectStyleIdByName,
+    effectStyleIdByNormalized,
+    variableIdByName,
+    variableIdByNormalized,
+    firstTextStyleId,
+    firstEffectStyleId
+  };
+}
+function resolveByNameOrNormalized(name, exact, normalized) {
+  return exact.get(name) ?? normalized.get(normalizeTokenName(name));
+}
+function resolveVariableName(name, variableIdByName, variableIdByNormalized) {
+  return variableIdByName.get(name) ?? variableIdByNormalized.get(normalizeTokenName(name)) ?? (name.includes(" / ") ? variableIdByName.get(name.split(" / ").slice(-1)[0]?.trim() ?? "") : void 0) ?? (name.includes("/") ? variableIdByNormalized.get(normalizeTokenName(name.split("/").pop() ?? "")) : void 0);
+}
+function resolveStepParams(params, resolvers) {
+  const out = { ...params };
+  const {
+    textStyleIdByName,
+    textStyleIdByNormalized,
+    effectStyleIdByName,
+    effectStyleIdByNormalized,
+    variableIdByName,
+    variableIdByNormalized,
+    firstTextStyleId,
+    firstEffectStyleId
+  } = resolvers;
+  if (typeof out.textStyleName === "string") {
+    const id = resolveByNameOrNormalized(out.textStyleName, textStyleIdByName, textStyleIdByNormalized) ?? firstTextStyleId;
+    if (id) {
+      out.textStyleId = id;
+      delete out.textStyleName;
+    }
+  }
+  if (typeof out.fillVariableName === "string") {
+    const id = resolveVariableName(out.fillVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.fillVariableId = id;
+      delete out.fillVariableName;
+    }
+  }
+  if (typeof out.effectStyleName === "string") {
+    const id = resolveByNameOrNormalized(out.effectStyleName, effectStyleIdByName, effectStyleIdByNormalized) ?? firstEffectStyleId;
+    if (id) {
+      out.effectStyleId = id;
+      delete out.effectStyleName;
+    }
+  }
+  if (typeof out.strokeVariableName === "string") {
+    const id = resolveVariableName(out.strokeVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.strokeVariableId = id;
+      delete out.strokeVariableName;
+    }
+  }
+  if (typeof out.cornerRadiusVariableName === "string") {
+    const id = resolveVariableName(out.cornerRadiusVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.cornerRadiusVariableId = id;
+      delete out.cornerRadiusVariableName;
+    }
+  }
+  if (typeof out.strokeWeightVariableName === "string") {
+    const id = resolveVariableName(out.strokeWeightVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.strokeWeightVariableId = id;
+      delete out.strokeWeightVariableName;
+    }
+  }
+  if (typeof out.paddingVariableName === "string") {
+    const id = resolveVariableName(out.paddingVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.paddingVariableId = id;
+      delete out.paddingVariableName;
+    }
+  }
+  if (typeof out.paddingTopVariableName === "string") {
+    const id = resolveVariableName(out.paddingTopVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.paddingTopVariableId = id;
+      delete out.paddingTopVariableName;
+    }
+  }
+  if (typeof out.paddingRightVariableName === "string") {
+    const id = resolveVariableName(out.paddingRightVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.paddingRightVariableId = id;
+      delete out.paddingRightVariableName;
+    }
+  }
+  if (typeof out.paddingBottomVariableName === "string") {
+    const id = resolveVariableName(out.paddingBottomVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.paddingBottomVariableId = id;
+      delete out.paddingBottomVariableName;
+    }
+  }
+  if (typeof out.paddingLeftVariableName === "string") {
+    const id = resolveVariableName(out.paddingLeftVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.paddingLeftVariableId = id;
+      delete out.paddingLeftVariableName;
+    }
+  }
+  if (typeof out.itemSpacingVariableName === "string") {
+    const id = resolveVariableName(out.itemSpacingVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.itemSpacingVariableId = id;
+      delete out.itemSpacingVariableName;
+    }
+  }
+  if (typeof out.counterAxisSpacingVariableName === "string") {
+    const id = resolveVariableName(out.counterAxisSpacingVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.counterAxisSpacingVariableId = id;
+      delete out.counterAxisSpacingVariableName;
+    }
+  }
+  if (typeof out.minWidthVariableName === "string") {
+    const id = resolveVariableName(out.minWidthVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.minWidthVariableId = id;
+      delete out.minWidthVariableName;
+    }
+  }
+  if (typeof out.maxWidthVariableName === "string") {
+    const id = resolveVariableName(out.maxWidthVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.maxWidthVariableId = id;
+      delete out.maxWidthVariableName;
+    }
+  }
+  if (typeof out.minHeightVariableName === "string") {
+    const id = resolveVariableName(out.minHeightVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.minHeightVariableId = id;
+      delete out.minHeightVariableName;
+    }
+  }
+  if (typeof out.maxHeightVariableName === "string") {
+    const id = resolveVariableName(out.maxHeightVariableName, variableIdByName, variableIdByNormalized);
+    if (id) {
+      out.maxHeightVariableId = id;
+      delete out.maxHeightVariableName;
+    }
+  }
+  return out;
+}
+var SCHEMA_VERSION = 1;
+var FIGMA_PERSONA_ASK = `- When asked who you are or about your role, use the persona defined in the system prompt (Lola, creative assistant for their design system; Ask vs Create help). Steer off-topic conversation back to what they'd like to do in Figma with their design system.
+- If the user asks you to create, design, or generate UI components or screens on the Figma canvas (e.g. "create a button", "design a login form", "make a card", "add a navbar"), do not attempt to do it. Tell them that to create on the canvas they need to switch to Create mode, then repeat their request there.`;
+var FIGMA_PERSONA_CREATE = `- When asked who you are or about your role, use the persona defined in the system prompt (Lola, creative assistant for their design system; Ask vs Create help). Steer off-topic conversation back to what they'd like to do in Figma with their design system.
+- You are the design system expert for Create mode. Expertise: token-based UI (variables, text/effect styles), auto-layout and structure, naming and semantics, consistency with design system tokens, step-by-step Figma bridge commands. Same personality: direct, precise, no fluff; every step and name must earn its place.`;
+var KNOWLEDGE_ASK_PREREQUISITES = `- You support the design system owner and their team with questions about their brand, design direction, content, and UX. You are brand-agnostic: advise only from their design system's rules (tone of voice, design direction, component and copy guidance). Never impose a different brand.
+- Use only the "Design system rules" and any tone or direction stated there. If the user has not defined tone or direction, say so and suggest they add it in their design system.`;
+var KNOWLEDGE_ASK_BEST_PRACTICES = `- Lead with benefit and clarity; avoid corporate fluff and feature-first answers.
+- For copy or naming: give a concrete before/after when improving something.
+- For visual or brand questions: tie recommendations to their tokens and rules (e.g. "Given your primary and surface tokens...").
+- Brainstorm as a partner: offer 2\u20133 clear options when relevant, then narrow with them.
+- UX and product design: When the question touches flows, layout, or controls, apply UX heuristics (e.g. visibility of system status, match to real world, user control, consistency, error prevention, recognition over recall, flexibility, minimalism, error recovery, help) and interaction design (clear affordances, feedback, mapping, constraints). Recommend in plain language and, when useful, name the principle (e.g. "This improves visibility of system status" or "Recognition over recall: show the option instead of making them remember it").`;
+var KNOWLEDGE_ASK_DOS_DONTS = `Do:
+- Ground every recommendation in their design system rules; speak to them as experts; use short, active phrasing; suggest specific wording when discussing copy.
+- Use UX and interaction design principles to justify design recommendations (e.g. feedback, consistency, clarity of next steps).
+
+DO NOT:
+- DO NOT invent tone or direction they have not defined; talk at them; over-explain; use hedging ("we think", "might help") or passive, weak copy.
+- DO NOT give purely subjective design opinions without tying them to a principle (heuristic, interaction design, or the user's design system rules).`;
+var KNOWLEDGE_CREATE_PREREQUISITES = `- Must use either linked variables/style library (primary) or local variables/styles (secondary) for binding. Use only token names that appear in the "Available in this Figma file" asset list; do not invent names.
+- IMPORTANT: If neither linked nor local variables/styles are available, halt the design process and ask the user to run syncToFigma (MCP tool) or /--sync-to-figma (slash prompt) first to set up variables and styles. Do not proceed without them.
+- Always refer to the user's DS foundation AI guide for design direction and token usage.`;
+var KNOWLEDGE_CREATE_BEST_PRACTICES = `- When the Design assets catalog lists components (Button, Input, Card, Alert, etc.): you MUST use design_create_component_instance for those elements. Do NOT build buttons, inputs, or cards from design_create_frame + design_create_text. Search the catalog by name and use the componentKey (or componentId for local). Pass textOverrides to set text inside the component (e.g. button labels, input placeholders) and variantProperties to select the correct variant. Only use frame+text when the catalog has no matching component.
+- For all colors (fills, strokes, text color), use ONLY variable names (fillVariableName, strokeVariableName). NEVER use paint style names for colors \u2014 variables support mode switching (light/dark).
+- Last step is finalize_design_frame to name and optionally set the background fill on the root frame.
+- parentId can be omitted on the first child \u2014 it defaults to the root frame. For deeper children, use the "name" from the parent design_create_frame step as parentId.
+- nodeId in design_set_auto_layout / design_set_layout_sizing / design_set_strokes / design_set_effects is the "name" of the target node (resolved to Figma id at runtime).
+- After design_create_frame, call design_set_auto_layout, then add children (text/rectangle/ellipse or design_create_component_instance), then design_set_layout_sizing on each child.
+- Apply cornerRadius via cornerRadiusVariableName; use design_set_strokes for borders; design_set_effects for shadows.`;
+var KNOWLEDGE_CREATE_DOS_DONTS = `Do:
+- ALWAYS use SEMANTIC COLOR VARIABLE NAMES (fillVariableName, strokeVariableName) for all colors.
+- Apply SEMANTIC COLOR VARIABLE NAMES for frames, shapes, and text, change the original color if not compliant.
+- Give every created frame a clear "name" so later steps can reference it by nodeId.
+- Output a full sequence of steps for the requested component (e.g. button = frame + auto-layout + text + layout sizing + finalize).
+- For design_create_text, ALWAYS set "characters" to the real visible label (e.g. "Button", "Submit", "Sign in"). Never use a placeholder like "Text" or leave it empty.
+- For frames that are buttons, cards, or have a visible background, ALWAYS set fillVariableName to a color variable from the assets list.
+- For button label text on a colored background, set fillVariableName on design_create_text to a contrasting color variable (e.g. onPrimary).
+- ALWAYS use design_create_component_instance for icons, logos, illustrations, AND UI components (buttons, inputs, cards, alerts, etc.) when matching components exist in the catalog. Search the catalog by name and use the componentKey (or componentId for local).
+- For component instances with text (buttons, inputs, cards, alerts, etc.), ALWAYS pass textOverrides to set the visible text INSIDE the component. Use exact text node names from the catalog's textLayers list (e.g. {"Label": "Submit", "Description": "Click here"}). If the catalog shows textLayers for a component, use those exact names as keys. If textLayers are not listed, use get_component_text_layers to discover them, or use {"_primary": "Submit"} to target the first text node. NEVER create separate design_create_text nodes for text that belongs inside a component instance.
+- For component sets with variants, prefer variantProperties (e.g. {"Size": "sm", "State": "default", "Type": "outline"}) to select the right variant by property values. Use variantKey only when you have the exact key from the catalog children list.
+- When a card or row contains an icon/component: create a wrapper frame first (design_create_frame with name e.g. "Card"), add design_create_component_instance as child of that frame, then add text/other children with parentId the wrapper frame name \u2014 never use the instance as parentId (Figma cannot append to component instances).
+- For icons and logo instances, ALWAYS pass fillVariableName with a semantic color (e.g. "Icon / primary", "Text / primary"). You choose the token; the plugin applies it to the glyph only. If you omit fillVariableName, the plugin resolves existing hex fills to the closest variable (prefers semantic) \u2014 so either way icons get semantic color.
+
+DO NOT:
+- DO NOT invent variable or style names not in the assets list.
+- DO NOT use primitive color variables, raw hex, or paint style or raw PX values.
+- DO NOT set fill or background on the icon frame; fillVariableName on design_create_component_instance applies to the glyph only.
+- DO NOT use primitive variable names for colors (e.g. "GrayDark / 300", "Gray / 50", "Red / 800") \u2014 use ONLY variables from collections whose name does not include "Primitives" and does not start with "Radix " (e.g. "Text / primary", "Action / primary", "Surface / primary" from semantic collections).
+- DO NOT output only one or two steps for a component request; include all steps needed to build the UI.
+- DO NOT use arbitrary frame sizes like 100x100 or 200x200; use standard device sizes (see catalog) or hug content.
+- DO NOT use design_create_vector for icons when a matching icon component exists in the catalog \u2014 always prefer design_create_component_instance.
+- DO NOT create separate design_create_text nodes for text that should be inside a component instance (e.g. button labels, input placeholders, alert messages). Use textOverrides on design_create_component_instance instead.
+- DO NOT build UI components (buttons, inputs, cards, alerts) from scratch with design_create_frame + design_create_text when matching components exist in the catalog. Always use design_create_component_instance with textOverrides and variantProperties.
+- DO NOT guess text node names for textOverrides. Check the catalog's textLayers data first. If unavailable, call get_component_text_layers before creating the instance to discover the exact text node names.`;
+var KNOWLEDGE_QUALITY_PROTOCOL = `## Quality Verification
+
+1. After finalize_design_frame, ALWAYS call get_design_screenshot to visually inspect the result.
+2. If a source reference was provided (screenshot, image, code snippet, URL), compare the output against it.
+3. Identify structural mismatches: missing elements, wrong hierarchy, incorrect spacing, misaligned sections.
+4. Iterate: add or modify steps to fix issues, then screenshot again.
+5. Maximum 3 iteration rounds before asking the user for guidance on remaining discrepancies.
+6. Do not declare the design complete until the screenshot confirms it matches the intent.`;
+var KNOWLEDGE_LAYOUT_DISCIPLINE = `## Auto-Layout & Sizing
+
+- Auto-layout everything. Every frame with children MUST have design_set_auto_layout applied.
+- Floating elements (badges, close buttons, FABs, overlays, tooltips): (1) design_set_node_position with absolute: true and x, y; (2) design_set_resize_constraints so they float on parent resize (e.g. STRETCH horizontal + MAX vertical for a bottom bar that sticks to bottom and stretches width).
+- Use design_set_node_position with absolute: true ONLY for floating elements; it takes the node out of auto-layout so x/y apply.
+- Root frame width: fixed width, all child frames stretch to fill the root frame width.
+- Root frame height: Dont fix height, all child frames HUG to fill the root frame height.
+- Content Width: FILL for content that stretches to parent, HUG for content-sized elements (buttons, tags, chips).
+- Content Height: Content determines height, but set it to FILL for columns and sidebars that stretch vertically.
+- Wrapping text: For any body or paragraph text that should wrap within its container (e.g. feed content, card copy, descriptions), (1) set the frame that directly contains the text to layoutSizingHorizontal "FILL" via design_set_layout_sizing so it uses full width, and (2) call design_set_text_properties on that text node with textAutoResize "HEIGHT" so the text wraps to the frame width instead of hugging. Without both, text will hug and leave empty space.
+- Never leave sizing as default FIXED unless the element has a deliberate fixed dimension.
+- For icons use icon sizing variables and spacing. Keep icon frames square.
+- Set elements to hug or fill \u2014 never leave them unconstrained.`;
+var KNOWLEDGE_MOBILE_DESIGN = `## Designing for Mobile
+
+### Best Practices
+1. Avoid fixed width or height. Add padding and set height and width to hug contents or fill width. See spacing and sizing rules! 
+2. Text width should always set to "FILL" to ensure text wraps within frame's width.
+3. Add system status bar UI and home indicator UI if no components for this is available in the catalog. Use spacing variables to set the padding.
+4. Use device preset frames for correct dimensions. iPhone 14: 390\xD7844, Android: 412\xD7915 (or 360\xD7800 for compact). Use design_create_frame_from_preset when available.
+5. All interactive elements must follow sizing and spacing rules. Use sizing / height variables to enforce this consistently.
+6. Design for the thumb zone: place primary actions in the bottom 60% of the screen. Bottom navigation with 4\u20135 items is the standard pattern.
+7. Mobile is single-column. Stack sections vertically. Avoid horizontal scrolling for primary content.
+
+### Figma-Specific Tips
+1. Use design_create_frame_from_preset (iphone_14, android_412) instead of manual dimensions.
+2. Set text nodes to textAutoResize: "HEIGHT" for fixed-width, auto-height text (mobile text wraps within screen width).
+3. Content frames: layoutSizingHorizontal "FILL", layoutSizingVertical "HUG" \u2014 fills width, hugs content height.
+4. Bottom navigation: horizontal auto-layout frame, FILL width, items spaced with SPACE_BETWEEN, each item is a vertical frame (icon + label).
+5. Cards in scrollable lists: create a container frame with VERTICAL auto-layout, each card FILL width and HUG height.
+6. Set the ROOT frame's height to "HUG" content to ensure it stretches to the content height.`;
+var KNOWLEDGE_WEB_DESIGN = `## Designing for Web
+
+### Best Practices
+1. Use 1440\xD7900 desktop frame if size not specified. Design content within a max-width container (see breakpoint tokens) centered in the viewport using counterAxisAlignItems: "CENTER".
+2. Detect how many sections are needed and create them as children of the root frame. 
+3. Root frame by default is a vertical auto-layout frame with FILL horizontal layout sizing. Create a constrained content frame inside with max-width via design_set_layout_constraints.
+4. Navigation: horizontal auto-layout, logo on the left, nav links centered or right-aligned, use SPACE_BETWEEN for even distribution.
+5. All interactive elements must follow sizing and spacing rules. Use sizing / height variables to enforce this consistently.
+6. Responsive thinking: use min/max width constraints on content containers. Cards and grid items benefit from min-width to prevent collapsing.
+
+### Figma-Specific Tips
+1. The root frame IS the viewport. Add full-width sections directly as children (VERTICAL auto-layout by default).
+2. For multi-column layouts: switch the appropriate parent frame to auto-layout.
+3. Use layoutSizingHorizontal "FILL" on column frames so they stretch proportionally.
+4. Apply counterAxisAlignItems "STRETCH" on horizontal parents for equal-height columns.
+5. Hero sections: VERTICAL auto-layout, CENTER both axes, generous padding tokens (xl or 2xl). Use itemSpacing for vertical rhythm.`;
+var KNOWLEDGE_TOKEN_APPLICATION = `## Applying Tokens to Designs
+
+### Best Practices
+1. ALWAYS use SEMANTIC COLOR VARIABLES (fillVariableName, strokeVariableName) \u2014 never use PRIMITIVE colors, hex, rgb, or paint style names. Variables enable light/dark mode switching.
+2. If components are using NON-SEMANTIC color fills for any shapes or text, replace them with SEMANTIC color fills.
+3. For icons and logos: pass fillVariableName on design_create_component_instance. The plugin applies the color to the glyph (vector/shape) only, not the icon frame, and rebinds any existing fill to a semantic variable when possible.
+4. Use semantic token names over primitive names when both exist: prefer "Surface / primary" over "Neutral / 10", prefer "Action / primary" over "Green / 600".
+5. Bind spacing via paddingVariableName (uniform or per-side) and itemSpacingVariableName on auto-layout frames. Never hardcode pixel spacing.
+6. Bind corner radius via cornerRadiusVariableName on frames and rectangles. Reserve raw cornerRadius only when no variable exists.
+7. Apply text styles via textStyleName for consistent typography. Text styles bundle font family, size, weight, and line height.
+
+### Figma-Specific Tips
+1. The asset list ("Available in this Figma file") is the source of truth. Match exact names including slashes and casing.
+2. Use apply_matching_styles_to_selection for batch token application to existing, unbound designs. It matches by color distance.
+3. The root frame is automatically set to Light mode. Child frames inherit from root (AUTO). Do NOT call design_set_frame_variable_mode on child frames unless the user explicitly asks for a mode override on a specific section. Only use it on the root frame to switch the entire design's mode, or on a non-root parent frame as an explicit override.
+4. Per-side padding variables (paddingTopVariableName, etc.) override uniform paddingVariableName \u2014 use for asymmetric layouts like cards with more bottom padding.
+5. For Icons apply SEMANTIC color to the vector shapes. DO NOT set bg color to the ICON frame background.`;
+var KNOWLEDGE_IMAGE_TO_FIGMA = `## Image-to-Figma Recreation
+
+ACTIVATION: Apply this knowledge ONLY when the user has selected a reference image and asks to recreate, reproduce, replicate, or redesign it. A reference image is a selected IMAGE node, RECTANGLE, or FRAME containing a single child. If the selection contains multiple elements, REJECT: reply that you can only recreate from a single reference image and ask the user to flatten or select just one image.
+
+### Step 1: Determine Device Type from Image Dimensions
+
+The selection context includes the image dimensions (width, height). Use these to determine the root frame size:
+- Portrait orientation (height > width \xD7 1.2) \u2192 MOBILE. Use 390\xD7844 root frame. Follow mobile design rules.
+- Width \u2265 1200 \u2192 DESKTOP. Use 1440\xD7900 root frame. Follow web design rules.
+- Width 600\u20131199 AND landscape/square \u2192 TABLET. Use 768\xD71024 root frame. Follow web design rules with single-column bias.
+- If dimensions are unavailable, infer from image content (phone chrome = mobile, browser chrome = desktop).
+Use the matching standard size from the catalog. Do NOT use the image's raw pixel dimensions as the frame size.
+
+### Step 2: Systematic Top-Down Decomposition
+
+Scan the reference image from top to bottom. Identify each distinct horizontal band:
+1. Status bar / system UI (mobile only)
+2. Navigation / header
+3. Content sections (hero, features, lists, grids, forms)
+4. Footer / bottom navigation (mobile: tab bar)
+
+Each band becomes a FRAME with auto-layout. Name each frame descriptively (e.g., "Header", "Hero Section", "Destination Cards Grid", "App Download Section").
+
+### Step 3: Element Identification Within Sections
+
+For each section, identify every visible element:
+- **Text**: Read the EXACT text from the image. Use the precise wording \u2014 do not paraphrase or summarize. Match the apparent hierarchy (heading vs body vs caption) to available text styles.
+- **Buttons / CTAs**: Frame + text with action color variables. Match the visual style (filled = primary, outlined = secondary).
+- **Input fields**: Frame + placeholder text with surface/muted fills.
+- **Cards**: Frame with fill + corner radius, containing image placeholder + text + metadata.
+- **Content images** (photos, illustrations, avatars): Create a RECTANGLE placeholder with a muted/secondary fill. Set dimensions proportional to what appears in the reference. Name descriptively (e.g., "New York Photo", "Hero Illustration", "User Avatar").
+- **Icons**: Use design_create_component_instance if a matching icon exists in the catalog. Otherwise use a small rectangle placeholder.
+- **Dividers / separators**: design_create_line or a thin frame with border fill.
+- **Badges / chips / tags**: Small frames with HUG sizing, rounded corners, and appropriate fill.
+
+### Step 4: Proportional Sizing and Spacing
+
+Estimate proportions from the reference image relative to the root frame, not pixel-exact:
+- If a hero section takes roughly 40% of the viewport height, size accordingly.
+- If cards are arranged in a 2\xD74 or 3\xD72 grid, use horizontal auto-layout with FILL children.
+- Match the visual density: tight spacing vs generous whitespace. Use spacing variables (sm for tight, md for normal, lg for generous, xl for spacious).
+- For text sizing: large headings \u2192 largest available text style, body \u2192 mid-range style, captions \u2192 smallest style.
+
+### Step 5: Color Mapping Strategy
+
+Map visual colors from the image to the CLOSEST SEMANTIC variable \u2014 do not try to match exact hex values:
+- Dark backgrounds \u2192 use the darkest available surface/background variable
+- Light backgrounds \u2192 Surface / primary or Surface / muted
+- Brand-colored elements (buttons, highlights) \u2192 Action / primary or brand variables
+- Text on dark \u2192 light text variable; text on light \u2192 dark text variable
+- Subtle borders \u2192 Border / primary or Border / secondary
+- Muted/disabled elements \u2192 Text / muted or Surface / muted
+
+### Content Images and Photos
+
+Photos, illustrations, screenshots, and complex graphics CANNOT be recreated. For each:
+- Look for image library or image components. 
+- If none, create a rectangle placeholder with muted or any semantic surface / background color fill. Do not use primitive colors or hex values.
+- Size proportionally to the reference.
+- Name descriptively: "Hero Banner Image", "Product Photo", "Map Preview".
+- DO NOT attempt to describe or recreate photo content as vector shapes`;
+var KNOWLEDGE_COMPONENTS_VARIANTS = `## Creating Components & Variants
+
+### Best Practices
+1. Build the base component fully first: frame + auto-layout + children + token bindings + sizing. Finalize structure before converting.
+2. If components are using NON-SEMANTIC color fills for any shapes or text, replace them with SEMANTIC color fills.
+3. Avoid fixed width or height. Add padding and set height and width to hug content. See spacing and sizing rules! 
+4. Name with slash convention for organization: "Button/Primary", "Input/Default", "Card/Outlined". Figma groups these in the assets panel.
+5. Every variant must be a unique combination of properties (e.g., Size=sm + State=default vs Size=sm + State=hover). Do not duplicate property combinations.
+6. Use variable binding on all variants so they inherit mode switching (light/dark) automatically. Do NOT set explicit variable mode on variant frames \u2014 they inherit from the root frame.
+7. NEVER use primitive colors or hardcoded colors for UI components.
+
+### Figma-Specific Tips
+1. Use design_create_component for the master, build its internals (auto-layout, children, tokens), then create variant frames and use design_combine_as_variants.
+2. Alternative: build all variant frames first, use design_convert_to_component on each, then design_combine_as_variants to merge into a variant set.
+3. Set auto-layout and layout sizing BEFORE converting to component. Changing structure after conversion can break variant overrides.
+4. Use list_local_components before creating to avoid duplicating existing components in the file.
+5. Variant property naming must be consistent across all variants in the set (e.g., always "Size", never mixing "Size" and "size").`;
+var FIGMA_SKILL_EXTRAS_ASK = {
+  schema_version: SCHEMA_VERSION,
+  prerequisites: `${FIGMA_PERSONA_ASK}
+${KNOWLEDGE_ASK_PREREQUISITES}`,
+  best_practices: KNOWLEDGE_ASK_BEST_PRACTICES,
+  dos_donts: KNOWLEDGE_ASK_DOS_DONTS
+};
+var FIGMA_SKILL_EXTRAS_CREATE = {
+  schema_version: SCHEMA_VERSION,
+  prerequisites: `${FIGMA_PERSONA_CREATE}
+${KNOWLEDGE_CREATE_PREREQUISITES}`,
+  best_practices: [
+    KNOWLEDGE_CREATE_BEST_PRACTICES,
+    KNOWLEDGE_LAYOUT_DISCIPLINE,
+    KNOWLEDGE_QUALITY_PROTOCOL,
+    KNOWLEDGE_MOBILE_DESIGN,
+    KNOWLEDGE_WEB_DESIGN,
+    KNOWLEDGE_TOKEN_APPLICATION,
+    KNOWLEDGE_COMPONENTS_VARIANTS,
+    KNOWLEDGE_IMAGE_TO_FIGMA
+  ].join("\n\n"),
+  dos_donts: KNOWLEDGE_CREATE_DOS_DONTS
+};
+var FIGMA_DESIGN_SKILL_MD = `# Figma Design Skill
+
+Create high-quality, token-bound designs in Figma from any reference: screenshots, images, code snippets, or URLs. Every element uses the user's design system variables and styles.
+
+## Prerequisites
+
+${KNOWLEDGE_CREATE_PREREQUISITES}
+
+## Core Workflow
+
+${KNOWLEDGE_CREATE_BEST_PRACTICES}
+
+${KNOWLEDGE_LAYOUT_DISCIPLINE}
+
+${KNOWLEDGE_QUALITY_PROTOCOL}
+
+${KNOWLEDGE_MOBILE_DESIGN}
+
+${KNOWLEDGE_WEB_DESIGN}
+
+${KNOWLEDGE_TOKEN_APPLICATION}
+
+${KNOWLEDGE_COMPONENTS_VARIANTS}
+
+${KNOWLEDGE_IMAGE_TO_FIGMA}
+
+## Do's and Don'ts
+
+${KNOWLEDGE_CREATE_DOS_DONTS}
+`;
+
+// src/figma-bridge-protocol.ts
+var BRIDGE_METHODS = getCatalogMethodNames();
+function isBridgeRequest(msg) {
+  if (!msg || typeof msg !== "object") return false;
+  const m = msg;
+  return typeof m.id === "string" && m.id.length > 0 && typeof m.method === "string" && m.method.length > 0;
+}
+function normalizeBridgeMethod(method) {
+  if (typeof method !== "string" || !method) return method;
+  return method.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+function isAllowedMethod(method) {
+  const normalized = normalizeBridgeMethod(method);
+  return BRIDGE_METHODS.includes(normalized);
+}
+
+export {
+  buildFigmaPayloadsFromDS,
+  FIGMA_DESIGN_CATALOG,
+  getDesignMethodNames,
+  getQueryMethodNames,
+  formatCatalogForMCP,
+  buildResolvers,
+  resolveStepParams,
+  FIGMA_DESIGN_SKILL_MD,
+  BRIDGE_METHODS,
+  isBridgeRequest,
+  normalizeBridgeMethod,
+  isAllowedMethod
+};
+//# sourceMappingURL=chunk-426RNS3G.js.map