standby-design-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,3458 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../core/src/math.ts
+function round(n, decimals = 4) {
+  const f = Math.pow(10, decimals);
+  return Math.round(n * f) / f;
+}
+var init_math = __esm({
+  "../core/src/math.ts"() {
+  }
+});
+
+// ../core/src/clamp.ts
+function generateClamp(minSize, maxSize, minVw = 375, maxVw = 1920) {
+  const lo = Math.min(minSize, maxSize);
+  const hi = Math.max(minSize, maxSize);
+  if (lo === hi) {
+    return `${round(lo)}rem`;
+  }
+  const minVwRem = minVw / 16;
+  const maxVwRem = maxVw / 16;
+  const slope = (hi - lo) / (maxVwRem - minVwRem);
+  const intercept = lo - slope * minVwRem;
+  const slopeVw = round(slope * 100);
+  const interceptRem = round(intercept);
+  const sign = interceptRem >= 0 ? "+" : "-";
+  const absIntercept = Math.abs(interceptRem);
+  const preferred = `${slopeVw}vw ${sign} ${absIntercept}rem`;
+  return `clamp(${round(lo)}rem, ${preferred}, ${round(hi)}rem)`;
+}
+var init_clamp = __esm({
+  "../core/src/clamp.ts"() {
+    init_math();
+  }
+});
+
+// ../core/src/typography.ts
+function applyTypography(levels, lineHeightOverrides, letterSpacingOverrides) {
+  return levels.map((l) => ({
+    ...l,
+    lineHeight: lineHeightOverrides[l.level] ?? DEFAULT_LINE_HEIGHTS[l.level],
+    letterSpacing: letterSpacingOverrides[l.level] ?? DEFAULT_LETTER_SPACINGS[l.level]
+  }));
+}
+var DEFAULT_LINE_HEIGHTS, DEFAULT_LETTER_SPACINGS;
+var init_typography = __esm({
+  "../core/src/typography.ts"() {
+    DEFAULT_LINE_HEIGHTS = {
+      "display": 1.05,
+      "h1": 1.1,
+      "h2": 1.15,
+      "h3": 1.2,
+      "h4": 1.25,
+      "h5": 1.3,
+      "h6": 1.4,
+      "body-l": 1.5,
+      "body-m": 1.5,
+      "body-s": 1.5,
+      "caption": 1.4
+    };
+    DEFAULT_LETTER_SPACINGS = {
+      "display": -0.04,
+      "h1": -0.03,
+      "h2": -0.02,
+      "h3": -0.01,
+      "h4": 0,
+      "h5": 0,
+      "h6": 0,
+      "body-l": 0,
+      "body-m": 0,
+      "body-s": 0.01,
+      "caption": 0.01
+    };
+  }
+});
+
+// ../core/src/scale.ts
+var scale_exports = {};
+__export(scale_exports, {
+  DEFAULT_TRADITIONAL: () => DEFAULT_TRADITIONAL,
+  DEFAULT_TRADITIONAL_MOBILE: () => DEFAULT_TRADITIONAL_MOBILE,
+  LEVEL_LABELS: () => LEVEL_LABELS,
+  RATIO_PRESETS: () => RATIO_PRESETS,
+  TRADITIONAL_SIZES: () => TRADITIONAL_SIZES,
+  TYPE_LEVELS: () => TYPE_LEVELS,
+  customScale: () => customScale,
+  goldenScale: () => goldenScale,
+  stepDown: () => stepDown,
+  traditionalScale: () => traditionalScale
+});
+function goldenScale(baseSize) {
+  return TYPE_LEVELS.map((level) => {
+    const ref = GOLDEN_TABLE[level];
+    const min = round(ref.min * baseSize);
+    const max = round(ref.max * baseSize);
+    const isFluid = min !== max;
+    return {
+      level,
+      label: LEVEL_LABELS[level],
+      minRem: min,
+      maxRem: max,
+      clampValue: isFluid ? generateClamp(min, max) : `${min}rem`,
+      isFluid,
+      isHeading: level === "display" || level.startsWith("h"),
+      lineHeight: DEFAULT_LINE_HEIGHTS[level],
+      letterSpacing: DEFAULT_LETTER_SPACINGS[level]
+    };
+  });
+}
+function stepDown(px) {
+  const pxList = TRADITIONAL_SIZES.map((s) => s.px);
+  const idx = pxList.indexOf(px);
+  if (idx <= 0) return pxList[0];
+  return pxList[idx - 1];
+}
+function traditionalScale(assignments, mobileAssignments) {
+  return TYPE_LEVELS.map((level) => {
+    const maxPx = assignments[level];
+    const minPx = mobileAssignments[level];
+    const maxRem = round(maxPx / 16);
+    const minRem = round(minPx / 16);
+    const isFluid = minRem !== maxRem;
+    return {
+      level,
+      label: LEVEL_LABELS[level],
+      minRem,
+      maxRem,
+      clampValue: isFluid ? generateClamp(minRem, maxRem) : `${maxRem}rem`,
+      isFluid,
+      isHeading: level === "display" || level.startsWith("h"),
+      lineHeight: DEFAULT_LINE_HEIGHTS[level],
+      letterSpacing: DEFAULT_LETTER_SPACINGS[level]
+    };
+  });
+}
+function customScale(baseSize, ratio, mobileRatio = ratio, mobileBaseSize = baseSize) {
+  return TYPE_LEVELS.map((level) => {
+    const step = LEVEL_STEPS[level];
+    const max = round(baseSize * Math.pow(ratio, step));
+    const min = round(mobileBaseSize * Math.pow(mobileRatio, step));
+    const isFluid = min !== max;
+    return {
+      level,
+      label: LEVEL_LABELS[level],
+      minRem: min,
+      maxRem: max,
+      clampValue: isFluid ? generateClamp(min, max) : `${min}rem`,
+      isFluid,
+      isHeading: level === "display" || level.startsWith("h"),
+      lineHeight: DEFAULT_LINE_HEIGHTS[level],
+      letterSpacing: DEFAULT_LETTER_SPACINGS[level]
+    };
+  });
+}
+var TYPE_LEVELS, LEVEL_LABELS, GOLDEN_TABLE, TRADITIONAL_SIZES, DEFAULT_TRADITIONAL, DEFAULT_TRADITIONAL_MOBILE, RATIO_PRESETS, LEVEL_STEPS;
+var init_scale = __esm({
+  "../core/src/scale.ts"() {
+    init_clamp();
+    init_math();
+    init_typography();
+    TYPE_LEVELS = [
+      "display",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "body-l",
+      "body-m",
+      "body-s",
+      "caption"
+    ];
+    LEVEL_LABELS = {
+      "display": "Display",
+      "h1": "H1",
+      "h2": "H2",
+      "h3": "H3",
+      "h4": "H4",
+      "h5": "H5",
+      "h6": "H6",
+      "body-l": "Body L",
+      "body-m": "Body M",
+      "body-s": "Body S",
+      "caption": "Caption"
+    };
+    GOLDEN_TABLE = {
+      "display": { min: 3, max: 4.7 },
+      "h1": { min: 2.4, max: 3.7 },
+      "h2": { min: 2.2, max: 2.9 },
+      "h3": { min: 1.8, max: 2.2 },
+      "h4": { min: 1.5, max: 1.7 },
+      "h5": { min: 1.2, max: 1.3 },
+      "h6": { min: 1, max: 1 },
+      "body-l": { min: 1.5, max: 1.7 },
+      "body-m": { min: 1.1, max: 1.3 },
+      "body-s": { min: 1, max: 1 },
+      "caption": { min: 0.79, max: 0.79 }
+    };
+    TRADITIONAL_SIZES = [
+      { px: 6, name: "Nonpareille" },
+      { px: 7, name: "Mignon" },
+      { px: 8, name: "Petit" },
+      { px: 9, name: "Borgis" },
+      { px: 10, name: "Korpus" },
+      { px: 10.5, name: "Konkordanz" },
+      { px: 11, name: "Rheinl\xE4nder" },
+      { px: 12, name: "Cicero" },
+      { px: 14, name: "Mittel" },
+      { px: 16, name: "Tertia" },
+      { px: 18, name: "Paragon" },
+      { px: 20, name: "Text" },
+      { px: 22, name: "Doppelcicero" },
+      { px: 24, name: "Kleine Kanon" },
+      { px: 26, name: "Gro\xDFe Kanon" },
+      { px: 28, name: "Missal" },
+      { px: 36, name: "Kleine Sabon" },
+      { px: 48, name: "Gro\xDFe Sabon" },
+      { px: 72, name: "Imperial" }
+    ];
+    DEFAULT_TRADITIONAL = {
+      "display": 72,
+      "h1": 48,
+      "h2": 36,
+      "h3": 24,
+      "h4": 20,
+      "h5": 18,
+      "h6": 16,
+      "body-l": 20,
+      "body-m": 18,
+      "body-s": 16,
+      "caption": 14
+    };
+    DEFAULT_TRADITIONAL_MOBILE = Object.fromEntries(
+      TYPE_LEVELS.map((level) => [level, stepDown(DEFAULT_TRADITIONAL[level])])
+    );
+    RATIO_PRESETS = [
+      { name: "Minor Second", value: 1.067 },
+      { name: "Major Second", value: 1.125 },
+      { name: "Minor Third", value: 1.2 },
+      { name: "Major Third", value: 1.25 },
+      { name: "Golden Ratio (area)", value: 1.272 },
+      { name: "Perfect Fourth", value: 1.333 },
+      { name: "Augmented Fourth", value: 1.414 },
+      { name: "Perfect Fifth", value: 1.5 },
+      { name: "Golden Ratio", value: 1.618 }
+    ];
+    LEVEL_STEPS = {
+      "display": 6,
+      "h1": 5,
+      "h2": 4,
+      "h3": 3,
+      "h4": 2,
+      "h5": 1,
+      "h6": 0,
+      "body-l": 2,
+      "body-m": 1,
+      "body-s": 0,
+      "caption": -1
+    };
+  }
+});
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools-generate.ts
+import { z } from "zod";
+
+// ../core/src/url-state/color.ts
+function encodeState(s) {
+  const brand = s.brandHex.replace("#", "");
+  const bg = s.bgColorHex.replace("#", "");
+  const err = s.errorColorHex.replace("#", "");
+  const chroma = Math.round(s.chromaScale * 100);
+  let hash = `${brand},${bg},${s.bgAutoMatch ? 1 : 0},${err},${s.errorAutoMatch ? 1 : 0},${chroma},${s.currentMode},${s.brandPin ? 1 : 0},${s.errorPin ? 1 : 0},${s.fgContrastMode},${encodeURIComponent(s.themeName)},${s.brandInvert ? 1 : 0},${s.errorInvert ? 1 : 0}`;
+  s.extraAccents.forEach((a) => {
+    hash += `!${encodeURIComponent(a.name)}:${a.hex.replace("#", "")}:${a.pin ? 1 : 0}:${a.autoMatch ? 1 : 0}:${Math.round(a.autoHue)}:${a.invert ? 1 : 0}`;
+  });
+  return hash;
+}
+function decodeState(hash) {
+  if (!hash) return null;
+  const segments = hash.split("!");
+  const p = segments[0].split(",");
+  if (p.length < 7) return null;
+  const [brand, bg, bgAuto, err, errAuto, chroma, mode] = p;
+  if (!/^[0-9a-fA-F]{6}$/.test(brand)) return null;
+  const result = {
+    brandHex: "#" + brand.toUpperCase(),
+    bgColorHex: /^[0-9a-fA-F]{6}$/.test(bg) ? "#" + bg.toUpperCase() : "#" + brand.toUpperCase(),
+    bgAutoMatch: bgAuto === "1",
+    errorColorHex: /^[0-9a-fA-F]{6}$/.test(err) ? "#" + err.toUpperCase() : "#CC3333",
+    errorAutoMatch: errAuto === "1",
+    chromaScale: 0.25,
+    currentMode: mode === "balanced" || mode === "exact" ? mode : "balanced",
+    brandPin: p[7] === "1",
+    brandInvert: false,
+    errorPin: p[8] === "1",
+    errorInvert: false,
+    fgContrastMode: "best",
+    themeName: "Standby.Design",
+    extraAccents: []
+  };
+  const chromaVal = parseInt(chroma);
+  if (!isNaN(chromaVal) && chromaVal >= 0 && chromaVal <= 100) {
+    result.chromaScale = chromaVal / 100;
+  }
+  if (p.length > 9) {
+    const fgMode = p[9];
+    if (fgMode === "best" || fgMode === "preferLight" || fgMode === "preferDark") {
+      result.fgContrastMode = fgMode;
+    }
+  }
+  result.themeName = p.length > 10 && p[10] ? decodeURIComponent(p[10]) : "Standby.Design";
+  result.brandInvert = p.length > 11 && p[11] === "1";
+  result.errorInvert = p.length > 12 && p[12] === "1";
+  for (let i = 1; i < segments.length; i++) {
+    const firstColon = segments[i].indexOf(":");
+    if (firstColon === -1) continue;
+    const rawName = segments[i].substring(0, firstColon);
+    const rest = segments[i].substring(firstColon + 1);
+    const restParts = rest.split(":");
+    const rawHex = restParts[0];
+    const pin = restParts[1] === "1";
+    const autoMatch = restParts[2] === "1";
+    const autoHue = restParts[3] ? parseInt(restParts[3]) || 0 : 0;
+    const accentInvert = restParts[4] === "1";
+    const name = decodeURIComponent(rawName) || "Extra " + i;
+    if (autoMatch || /^[0-9a-fA-F]{6}$/.test(rawHex)) {
+      result.extraAccents.push({ name, hex: "#" + rawHex.toUpperCase(), pin, invert: accentInvert, autoMatch, autoHue });
+    }
+  }
+  return result;
+}
+
+// ../core/src/url-state/type.ts
+init_scale();
+function encodeOverrides(overrides) {
+  const entries = Object.entries(overrides).filter(([, v]) => v !== void 0);
+  if (entries.length === 0) return "";
+  return entries.map(([k, v]) => `${k}:${v}`).join(";");
+}
+function encodeState2(state) {
+  const parts = [
+    state.scaleMode,
+    state.baseSize,
+    state.customRatio,
+    state.mobileRatio,
+    state.headingFont,
+    state.bodyFont,
+    state.monoFont
+  ];
+  if (state.scaleMode === "traditional" && state.traditionalAssignments) {
+    for (const level of TYPE_LEVELS) {
+      parts.push(state.traditionalAssignments[level]);
+    }
+  }
+  const ext = [];
+  if (state.headingWeight !== 500) ext.push(`hw=${state.headingWeight}`);
+  if (state.mobileBaseSize !== state.baseSize) ext.push(`mbs=${state.mobileBaseSize}`);
+  if (state.mobileRatioMode !== "auto") ext.push(`mrm=${state.mobileRatioMode}`);
+  if (state.autoShrink !== 25) ext.push(`as=${state.autoShrink}`);
+  const lh = encodeOverrides(state.lineHeightOverrides);
+  if (lh) ext.push(`lh=${lh}`);
+  const ls = encodeOverrides(state.letterSpacingOverrides);
+  if (ls) ext.push(`ls=${ls}`);
+  if (state.scaleMode === "traditional" && state.traditionalMobileAssignments) {
+    const tmParts = TYPE_LEVELS.map((l) => state.traditionalMobileAssignments[l]);
+    ext.push(`tm=${tmParts.join(",")}`);
+  }
+  const positional = parts.join(",");
+  return ext.length > 0 ? `${positional}|${ext.join("&")}` : positional;
+}
+function decodeOverrides(str) {
+  const result = {};
+  if (!str) return result;
+  for (const pair of str.split(";")) {
+    const [key, val] = pair.split(":");
+    if (key && val && TYPE_LEVELS.includes(key)) {
+      const n = parseFloat(val);
+      if (!isNaN(n)) result[key] = n;
+    }
+  }
+  return result;
+}
+function decodeState2(hash) {
+  const raw = hash.replace(/^#/, "");
+  if (!raw) return null;
+  const [positional, extStr] = raw.split("|");
+  const parts = positional.split(",");
+  if (parts.length < 7) return null;
+  const mode = parts[0];
+  if (!["traditional", "custom"].includes(mode)) return null;
+  const baseSize = parseFloat(parts[1]);
+  const customRatio = parseFloat(parts[2]);
+  const mobileRatio = parseFloat(parts[3]);
+  if (isNaN(baseSize) || isNaN(customRatio) || isNaN(mobileRatio)) return null;
+  const state = {
+    scaleMode: mode,
+    baseSize,
+    customRatio,
+    mobileRatio,
+    headingFont: parts[4],
+    bodyFont: parts[5],
+    monoFont: parts[6],
+    headingWeight: 500,
+    mobileBaseSize: baseSize,
+    mobileRatioMode: "auto",
+    autoShrink: 25,
+    lineHeightOverrides: {},
+    letterSpacingOverrides: {}
+  };
+  if (mode === "traditional" && parts.length >= 16) {
+    const assignments = {};
+    const levelCount = Math.min(TYPE_LEVELS.length, parts.length - 7);
+    for (let i = 0; i < levelCount; i++) {
+      const val = parseFloat(parts[7 + i]);
+      if (isNaN(val)) return null;
+      assignments[TYPE_LEVELS[i]] = val;
+    }
+    for (const level of TYPE_LEVELS) {
+      if (!(level in assignments)) {
+        assignments[level] = DEFAULT_TRADITIONAL[level];
+      }
+    }
+    state.traditionalAssignments = assignments;
+  }
+  if (extStr) {
+    const params = new URLSearchParams(extStr);
+    const hw = params.get("hw");
+    if (hw) {
+      const n = parseInt(hw);
+      if (!isNaN(n)) state.headingWeight = n;
+    }
+    const mbs = params.get("mbs");
+    if (mbs) {
+      const n = parseFloat(mbs);
+      if (!isNaN(n)) state.mobileBaseSize = n;
+    }
+    const mrm = params.get("mrm");
+    if (mrm === "custom") state.mobileRatioMode = "custom";
+    const as = params.get("as");
+    if (as) {
+      const n = parseFloat(as);
+      if (!isNaN(n)) state.autoShrink = n;
+    }
+    params.get("sbm");
+    const lh = params.get("lh");
+    if (lh) state.lineHeightOverrides = decodeOverrides(lh);
+    const ls = params.get("ls");
+    if (ls) state.letterSpacingOverrides = decodeOverrides(ls);
+    const tm = params.get("tm");
+    if (tm && mode === "traditional") {
+      const tmParts = tm.split(",");
+      const tmAssign = {};
+      for (let i = 0; i < Math.min(TYPE_LEVELS.length, tmParts.length); i++) {
+        const val = parseFloat(tmParts[i]);
+        if (!isNaN(val)) tmAssign[TYPE_LEVELS[i]] = val;
+      }
+      state.traditionalMobileAssignments = tmAssign;
+    }
+  }
+  return state;
+}
+
+// ../core/src/url-state/shape.ts
+function encodeState3(s) {
+  return [
+    s.shapeStyle,
+    s.shadowEnabled ? 1 : 0,
+    s.shadowType,
+    Math.round(s.shadowStrength * 100),
+    Math.round(s.shadowBlurScale * 100),
+    Math.round(s.shadowScale * 1e3),
+    s.shadowColorMode === "auto" ? "a" : "c",
+    s.shadowColorMode === "custom" ? s.shadowCustomColor.replace("#", "") : "",
+    s.borderEnabled ? 1 : 0,
+    Math.round(s.borderWidth * 10),
+    s.borderColorMode === "auto" ? "a" : "c",
+    s.borderColorMode === "custom" ? s.borderCustomColor.replace("#", "") : "",
+    s.borderRadius,
+    Math.round(s.glassDepth * 10),
+    Math.round(s.glassBlur * 10),
+    Math.round(s.glassDispersion * 10),
+    s.ringWidth,
+    s.ringOffset,
+    s.ringColorMode === "auto" ? "a" : "c",
+    s.ringColorMode === "custom" ? s.ringCustomColor.replace("#", "") : "",
+    s.separationMode,
+    s.shadowOffsetX,
+    s.shadowOffsetY,
+    s.brutalistVariant === "solid" ? "s" : "o"
+  ].join(",");
+}
+var SHAPE_STYLES = /* @__PURE__ */ new Set(["paper", "glass", "neomorph", "neobrutalism"]);
+var SHADOW_TYPES = /* @__PURE__ */ new Set(["normal", "flat"]);
+var SEPARATION_MODES = /* @__PURE__ */ new Set(["shadow", "border", "contrast", "gap", "mixed"]);
+function decodeState3(raw) {
+  const parts = raw.split(",");
+  if (parts.length < 20) return null;
+  const isLegacy = parts[0] === "0" || parts[0] === "1";
+  if (isLegacy) {
+    parts.unshift("paper");
+  }
+  if (parts.length < 21) return null;
+  const result = {};
+  if (SHAPE_STYLES.has(parts[0])) result.shapeStyle = parts[0];
+  if (parts[1] === "0" || parts[1] === "1") result.shadowEnabled = parts[1] === "1";
+  if (parts[2] === "neumorphic") {
+    result.shapeStyle = "neomorph";
+    result.shadowType = "normal";
+  } else if (SHADOW_TYPES.has(parts[2])) {
+    result.shadowType = parts[2];
+  }
+  const strength = parseInt(parts[3]);
+  if (!isNaN(strength)) result.shadowStrength = strength / 100;
+  const blur = parseInt(parts[4]);
+  if (!isNaN(blur)) result.shadowBlurScale = blur / 100;
+  const scale = parseInt(parts[5]);
+  if (!isNaN(scale)) result.shadowScale = scale / 1e3;
+  result.shadowColorMode = parts[6] === "c" ? "custom" : "auto";
+  if (parts[7] && /^[0-9a-fA-F]{6}$/.test(parts[7])) result.shadowCustomColor = "#" + parts[7];
+  if (parts[8] === "0" || parts[8] === "1") result.borderEnabled = parts[8] === "1";
+  const bw = parseInt(parts[9]);
+  if (!isNaN(bw)) result.borderWidth = bw / 10;
+  result.borderColorMode = parts[10] === "c" ? "custom" : "auto";
+  if (parts[11] && /^[0-9a-fA-F]{6}$/.test(parts[11])) result.borderCustomColor = "#" + parts[11];
+  const radius = parseInt(parts[12]);
+  if (!isNaN(radius)) result.borderRadius = radius;
+  const gDepth = parseInt(parts[13]);
+  if (!isNaN(gDepth)) result.glassDepth = gDepth / 10;
+  const gBlur = parseInt(parts[14]);
+  if (!isNaN(gBlur)) result.glassBlur = gBlur / 10;
+  const gDisp = parseInt(parts[15]);
+  if (!isNaN(gDisp)) result.glassDispersion = gDisp / 10;
+  const rw = parseInt(parts[16]);
+  if (!isNaN(rw)) result.ringWidth = rw;
+  const ro = parseInt(parts[17]);
+  if (!isNaN(ro)) result.ringOffset = ro;
+  result.ringColorMode = parts[18] === "c" ? "custom" : "auto";
+  if (parts[19] && /^[0-9a-fA-F]{6}$/.test(parts[19])) result.ringCustomColor = "#" + parts[19];
+  if (SEPARATION_MODES.has(parts[20])) result.separationMode = parts[20];
+  const oX = parseInt(parts[21]);
+  if (!isNaN(oX)) result.shadowOffsetX = oX;
+  const oY = parseInt(parts[22]);
+  if (!isNaN(oY)) result.shadowOffsetY = oY;
+  if (parts[23] === "s" || parts[23] === "o") {
+    result.brutalistVariant = parts[23] === "s" ? "solid" : "outlined";
+  }
+  return result;
+}
+
+// ../core/src/url-state/symbol.ts
+var STYLE_MAP = { a: "auto", o: "outlined", f: "filled", d: "duotone" };
+var STYLE_REV = { auto: "a", outlined: "o", filled: "f", duotone: "d" };
+var WEIGHT_MAP = { a: "auto", t: "thin", r: "regular", b: "bold" };
+var WEIGHT_REV = { auto: "a", thin: "t", regular: "r", bold: "b" };
+var CORNERS_MAP = { a: "auto", s: "sharp", n: "rounded" };
+var CORNERS_REV = { auto: "a", sharp: "s", rounded: "n" };
+function encodeState4(state) {
+  return [
+    STYLE_REV[state.preferredStyle],
+    WEIGHT_REV[state.preferredWeight],
+    CORNERS_REV[state.preferredCorners],
+    Math.round(state.iconBaseSize * 100),
+    Math.round(state.iconScale * 1e3),
+    state.snapTo4px ? "1" : "0",
+    state.selectedSet || ""
+  ].join(",");
+}
+function decodeState4(raw) {
+  const parts = raw.split(",");
+  if (parts.length < 6) return null;
+  const style = STYLE_MAP[parts[0]];
+  const weight = WEIGHT_MAP[parts[1]];
+  const corners = CORNERS_MAP[parts[2]];
+  const baseSize = parseInt(parts[3], 10) / 100;
+  const scale = parseInt(parts[4], 10) / 1e3;
+  const snap = parts[5] !== "0";
+  const setId = parts[6] || null;
+  if (!style || !weight || !corners || isNaN(baseSize) || isNaN(scale)) {
+    return null;
+  }
+  return {
+    preferredStyle: style,
+    preferredWeight: weight,
+    preferredCorners: corners,
+    iconBaseSize: Math.max(0.5, Math.min(3, baseSize)),
+    iconScale: Math.max(1, Math.min(2, scale)),
+    snapTo4px: snap,
+    selectedSet: setId
+  };
+}
+
+// ../core/src/layout.ts
+var DEFAULT_BREAKPOINTS = [
+  { name: "sm", minPx: 640 },
+  { name: "md", minPx: 768 },
+  { name: "lg", minPx: 1024 },
+  { name: "xl", minPx: 1280 },
+  { name: "2xl", minPx: 1536 }
+];
+var DEFAULT_CONTAINERS = [
+  { name: "prose", maxPx: 680 },
+  { name: "narrow", maxPx: 960 },
+  { name: "default", maxPx: 1200 },
+  { name: "wide", maxPx: 1440 },
+  { name: "full", maxPx: 1920 }
+];
+var DEFAULT_FLUID_MIN_VW = 375;
+var DEFAULT_FLUID_MAX_VW = 1920;
+var DEFAULT_PROSE_MAX_CH = 65;
+function sortBreakpoints(bps) {
+  return [...bps].sort((a, b) => a.minPx - b.minPx);
+}
+function sortContainers(cts) {
+  return [...cts].sort((a, b) => a.maxPx - b.maxPx);
+}
+
+// ../core/src/aspect.ts
+var DEFAULT_ASPECT_RATIOS = [
+  { name: "square", w: 1, h: 1 },
+  { name: "landscape", w: 4, h: 3 },
+  { name: "photo", w: 3, h: 2 },
+  { name: "video", w: 16, h: 9 },
+  { name: "ultrawide", w: 21, h: 9 },
+  { name: "golden", w: 1.618, h: 1 },
+  { name: "silver", w: 1.414, h: 1 },
+  { name: "cinema", w: 2.39, h: 1 }
+];
+function formatAspect(a) {
+  const w = Number.isInteger(a.w) ? a.w.toString() : a.w.toFixed(3).replace(/\.?0+$/, "");
+  const h = Number.isInteger(a.h) ? a.h.toString() : a.h.toFixed(3).replace(/\.?0+$/, "");
+  return `${w} / ${h}`;
+}
+function aspectValue(a) {
+  return a.h === 0 ? 0 : a.w / a.h;
+}
+function reciprocal(a) {
+  return { name: `${a.name}-portrait`, w: a.h, h: a.w };
+}
+function expandAndSortAspects(ratios, includeReciprocals) {
+  const all = [];
+  for (const a of ratios) {
+    all.push(a);
+    if (includeReciprocals && a.w !== a.h) all.push(reciprocal(a));
+  }
+  return all.sort((a, b) => aspectValue(b) - aspectValue(a));
+}
+
+// ../core/src/url-state/space.ts
+var DEFAULT_SPACE_URL_STATE = {
+  spacingMode: "harmonic",
+  spacingBaseRem: 1,
+  spacingRatio: 1.272,
+  spacingMultiplier: 1,
+  spacingSnap: true,
+  breakpoints: DEFAULT_BREAKPOINTS,
+  fluidMinVw: DEFAULT_FLUID_MIN_VW,
+  fluidMaxVw: DEFAULT_FLUID_MAX_VW,
+  containers: DEFAULT_CONTAINERS,
+  proseMaxCh: DEFAULT_PROSE_MAX_CH,
+  aspectRatios: DEFAULT_ASPECT_RATIOS,
+  aspectIncludeReciprocals: true
+};
+function breakpointsEqualDefault(bps) {
+  if (bps.length !== DEFAULT_BREAKPOINTS.length) return false;
+  return bps.every((b, i) => b.name === DEFAULT_BREAKPOINTS[i].name && b.minPx === DEFAULT_BREAKPOINTS[i].minPx);
+}
+function containersEqualDefault(cts) {
+  if (cts.length !== DEFAULT_CONTAINERS.length) return false;
+  return cts.every((c, i) => c.name === DEFAULT_CONTAINERS[i].name && c.maxPx === DEFAULT_CONTAINERS[i].maxPx);
+}
+function aspectsEqualDefault(ars) {
+  if (ars.length !== DEFAULT_ASPECT_RATIOS.length) return false;
+  return ars.every((a, i) => a.name === DEFAULT_ASPECT_RATIOS[i].name && a.w === DEFAULT_ASPECT_RATIOS[i].w && a.h === DEFAULT_ASPECT_RATIOS[i].h);
+}
+function encodeAspect(a) {
+  const wInt = Number.isInteger(a.w);
+  const hInt = Number.isInteger(a.h);
+  if (wInt && hInt) return `${a.name}:${a.w}:${a.h}`;
+  return `${a.name}:${Math.round(a.w * 1e3)}:${Math.round(a.h * 1e3)}`;
+}
+function decodeAspectField(s, h) {
+  const n = parseFloat(s);
+  if (isNaN(n)) return 0;
+  return n >= 100 ? n / 1e3 : n;
+}
+function encodeState5(s) {
+  const head = [
+    s.spacingMode,
+    Math.round(s.spacingBaseRem * 1e3),
+    Math.round(s.spacingRatio * 1e3),
+    Math.round(s.spacingMultiplier * 100),
+    s.spacingSnap ? 1 : 0
+  ].join(",");
+  const ext = [];
+  if (!breakpointsEqualDefault(s.breakpoints)) {
+    const bpStr = s.breakpoints.map((b) => `${b.name}:${b.minPx}`).join(";");
+    ext.push(`bp=${bpStr}`);
+  }
+  if (s.fluidMinVw !== DEFAULT_FLUID_MIN_VW || s.fluidMaxVw !== DEFAULT_FLUID_MAX_VW) {
+    ext.push(`fvw=${s.fluidMinVw},${s.fluidMaxVw}`);
+  }
+  if (!containersEqualDefault(s.containers)) {
+    const ctStr = s.containers.map((c) => `${c.name}:${c.maxPx}`).join(";");
+    ext.push(`ct=${ctStr}`);
+  }
+  if (s.proseMaxCh !== DEFAULT_PROSE_MAX_CH) {
+    ext.push(`pch=${s.proseMaxCh}`);
+  }
+  if (!aspectsEqualDefault(s.aspectRatios)) {
+    const arStr = s.aspectRatios.map(encodeAspect).join(";");
+    ext.push(`ar=${arStr}`);
+  }
+  if (!s.aspectIncludeReciprocals) {
+    ext.push(`arr=0`);
+  }
+  return ext.length > 0 ? `${head}|${ext.join("&")}` : head;
+}
+var VALID_MODES = /* @__PURE__ */ new Set(["harmonic", "geometric"]);
+function decodeState5(raw) {
+  if (!raw) return null;
+  const [head, extStr] = raw.split("|");
+  const parts = head.split(",");
+  if (parts.length < 5) return null;
+  const result = {};
+  if (VALID_MODES.has(parts[0])) {
+    result.spacingMode = parts[0];
+  }
+  const baseRem = parseInt(parts[1]);
+  if (!isNaN(baseRem)) result.spacingBaseRem = baseRem / 1e3;
+  const ratio = parseInt(parts[2]);
+  if (!isNaN(ratio)) result.spacingRatio = ratio / 1e3;
+  const mult = parseInt(parts[3]);
+  if (!isNaN(mult)) result.spacingMultiplier = mult / 100;
+  if (parts[4] === "0" || parts[4] === "1") result.spacingSnap = parts[4] === "1";
+  if (!extStr) return result;
+  const params = new URLSearchParams(extStr);
+  const bp = params.get("bp");
+  if (bp) {
+    const bps = [];
+    for (const entry of bp.split(";")) {
+      const [name, px] = entry.split(":");
+      const n = parseInt(px);
+      if (name && !isNaN(n)) bps.push({ name, minPx: n });
+    }
+    if (bps.length > 0) result.breakpoints = bps;
+  }
+  const fvw = params.get("fvw");
+  if (fvw) {
+    const [minS, maxS] = fvw.split(",");
+    const min = parseInt(minS);
+    const max = parseInt(maxS);
+    if (!isNaN(min)) result.fluidMinVw = min;
+    if (!isNaN(max)) result.fluidMaxVw = max;
+  }
+  const ct = params.get("ct");
+  if (ct) {
+    const cts = [];
+    for (const entry of ct.split(";")) {
+      const [name, px] = entry.split(":");
+      const n = parseInt(px);
+      if (name && !isNaN(n)) cts.push({ name, maxPx: n });
+    }
+    if (cts.length > 0) result.containers = cts;
+  }
+  const pch = params.get("pch");
+  if (pch) {
+    const n = parseInt(pch);
+    if (!isNaN(n)) result.proseMaxCh = n;
+  }
+  const ar = params.get("ar");
+  if (ar) {
+    const ars = [];
+    for (const entry of ar.split(";")) {
+      const [name, wS, hS] = entry.split(":");
+      if (!name || wS === void 0 || hS === void 0) continue;
+      const w = decodeAspectField(wS, hS);
+      const h = decodeAspectField(hS, wS);
+      if (w > 0 && h > 0) ars.push({ name, w, h });
+    }
+    if (ars.length > 0) result.aspectRatios = ars;
+  }
+  const arr = params.get("arr");
+  if (arr === "0") result.aspectIncludeReciprocals = false;
+  else if (arr === "1") result.aspectIncludeReciprocals = true;
+  return result;
+}
+
+// ../core/src/color-math.ts
+function srgbToLinear(c) {
+  c /= 255;
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function linearToSrgb(c) {
+  c = Math.max(0, Math.min(1, c));
+  return c <= 31308e-7 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+}
+function linearSrgbToOklab(r, g, b) {
+  let l_ = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+  let m_ = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+  let s_ = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+  l_ = Math.cbrt(l_);
+  m_ = Math.cbrt(m_);
+  s_ = Math.cbrt(s_);
+  return [
+    0.2104542553 * l_ + 0.793617785 * m_ - 0.0040720468 * s_,
+    1.9779984951 * l_ - 2.428592205 * m_ + 0.4505937099 * s_,
+    0.0259040371 * l_ + 0.7827717662 * m_ - 0.808675766 * s_
+  ];
+}
+function oklabToLinearSrgb(L, a, b) {
+  let l_ = L + 0.3963377774 * a + 0.2158037573 * b;
+  let m_ = L - 0.1055613458 * a - 0.0638541728 * b;
+  let s_ = L - 0.0894841775 * a - 1.291485548 * b;
+  l_ = l_ * l_ * l_;
+  m_ = m_ * m_ * m_;
+  s_ = s_ * s_ * s_;
+  return [
+    4.0767416621 * l_ - 3.3077115913 * m_ + 0.2309699292 * s_,
+    -1.2684380046 * l_ + 2.6097574011 * m_ - 0.3413193965 * s_,
+    -0.0041960863 * l_ - 0.7034186147 * m_ + 1.707614701 * s_
+  ];
+}
+function oklabToOklch(L, a, b) {
+  return [L, Math.sqrt(a * a + b * b), (Math.atan2(b, a) * 180 / Math.PI % 360 + 360) % 360];
+}
+function oklchToOklab(L, C, H) {
+  const rad = H * Math.PI / 180;
+  return [L, C * Math.cos(rad), C * Math.sin(rad)];
+}
+function hexToRgb(hex) {
+  hex = hex.replace("#", "");
+  return [parseInt(hex.slice(0, 2), 16), parseInt(hex.slice(2, 4), 16), parseInt(hex.slice(4, 6), 16)];
+}
+function rgbToHex(r, g, b) {
+  const clamp = (v) => Math.max(0, Math.min(255, Math.round(v * 255)));
+  return "#" + [r, g, b].map((c) => clamp(c).toString(16).padStart(2, "0")).join("").toUpperCase();
+}
+function hexToOklch(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  const [lr, lg, lb] = [srgbToLinear(r), srgbToLinear(g), srgbToLinear(b)];
+  const [L, a, ob] = linearSrgbToOklab(lr, lg, lb);
+  return oklabToOklch(L, a, ob);
+}
+function oklchToHex(L, C, H) {
+  const [oL, oa, ob] = oklchToOklab(L, C, H);
+  const [r, g, b] = oklabToLinearSrgb(oL, oa, ob);
+  return rgbToHex(linearToSrgb(r), linearToSrgb(g), linearToSrgb(b));
+}
+function isInGamut(L, C, H) {
+  const [oL, oa, ob] = oklchToOklab(L, C, H);
+  const [r, g, b] = oklabToLinearSrgb(oL, oa, ob);
+  return r >= -1e-3 && r <= 1.001 && g >= -1e-3 && g <= 1.001 && b >= -1e-3 && b <= 1.001;
+}
+function maxChromaInGamut(L, H) {
+  let lo = 0, hi = 0.4;
+  for (let i = 0; i < 20; i++) {
+    const mid = (lo + hi) / 2;
+    if (isInGamut(L, mid, H)) lo = mid;
+    else hi = mid;
+  }
+  return lo;
+}
+function invertHex(hex) {
+  const [L, C, H] = hexToOklch(hex);
+  const invL = 1 - L;
+  const maxC = maxChromaInGamut(invL, H);
+  return oklchToHex(invL, Math.min(C, maxC * 0.95), H);
+}
+function relativeLuminance(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  return 0.2126 * srgbToLinear(r) + 0.7152 * srgbToLinear(g) + 0.0722 * srgbToLinear(b);
+}
+function contrastRatio(hex1, hex2) {
+  const l1 = relativeLuminance(hex1);
+  const l2 = relativeLuminance(hex2);
+  const lighter = Math.max(l1, l2), darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+
+// ../core/src/palette.ts
+var STEPS = [25, 50, 75, 100, 200, 300, 400, 500, 600, 700, 800, 825, 850, 875, 900, 925, 950, 975];
+var L_WHITE = 0.98;
+var L_BLACK = 0.1;
+var ERROR_HUE = 25;
+var SUCCESS_HUE = 145;
+var WARNING_HUE = 85;
+var INFO_HUE = 255;
+function surfaceChromaCorrection(L) {
+  if (L >= 0.45) return 1;
+  return Math.pow(L / 0.45, 1.2);
+}
+function computeAutoAccentHex(primaryHex, hue) {
+  const [pL, pC, pH] = hexToOklch(primaryHex);
+  const primaryMaxC = maxChromaInGamut(pL, pH);
+  const saturation = primaryMaxC > 1e-3 ? pC / primaryMaxC : 0.5;
+  const accentMaxC = maxChromaInGamut(pL, hue);
+  return oklchToHex(pL, accentMaxC * saturation * 0.95, hue);
+}
+function computeAutoErrorHex(primaryHex) {
+  return computeAutoAccentHex(primaryHex, ERROR_HUE);
+}
+function generatePalette(hex, chromaScale = 1, mode = "balanced") {
+  const [bL, bC, bH] = hexToOklch(hex);
+  const inputMaxC = maxChromaInGamut(bL, bH);
+  const saturation = inputMaxC > 1e-3 ? bC / inputMaxC : 0;
+  const blend = Math.min(1, saturation / 0.3);
+  const safeH = bC > 5e-3 ? bH : 0;
+  const L_MID = mode === "exact" ? bL : 0.5;
+  function stepToL(step) {
+    if (step <= 500) return L_WHITE + step / 500 * (L_MID - L_WHITE);
+    return L_MID + (step - 500) / 500 * (L_BLACK - L_MID);
+  }
+  if (mode === "exact") {
+    return STEPS.map((step) => {
+      const L = stepToL(step);
+      const H = safeH;
+      let C;
+      if (step === 500) {
+        C = bC * chromaScale;
+      } else {
+        const stepNorm = step <= 500 ? step / 500 : (1e3 - step) / 500;
+        const envelope = 1 - Math.pow(1 - stepNorm, 2);
+        const correction = chromaScale < 1 ? surfaceChromaCorrection(L) : 1;
+        const desired = bC * chromaScale * envelope * correction;
+        const gamutMax = bC > 5e-3 ? maxChromaInGamut(L, safeH) : 0;
+        C = Math.min(desired, gamutMax * 0.95);
+      }
+      const hx = oklchToHex(L, C, H);
+      const css = `oklch(${L.toFixed(4)} ${C.toFixed(4)} ${H.toFixed(2)})`;
+      return { step, L, C, H, hex: hx, css };
+    });
+  }
+  const maxC500 = maxChromaInGamut(L_MID, safeH);
+  const targetC500 = maxC500 * 0.88 * blend;
+  return STEPS.map((step) => {
+    const L = stepToL(step);
+    const envelope = 1 - Math.pow(2 * L - 1, 2);
+    const correction = chromaScale < 1 ? surfaceChromaCorrection(L) : 1;
+    const desired = targetC500 * chromaScale * Math.max(0, envelope) * correction;
+    const gamutMax = bC > 5e-3 ? maxChromaInGamut(L, safeH) : 0;
+    const C = Math.min(desired, gamutMax * 0.95);
+    const H = safeH;
+    const hx = oklchToHex(L, C, H);
+    const css = `oklch(${L.toFixed(4)} ${C.toFixed(4)} ${H.toFixed(2)})`;
+    return { step, L, C, H, hex: hx, css };
+  });
+}
+
+// src/tools-generate.ts
+init_scale();
+
+// ../core/src/icon-sets.ts
+var ICON_FAMILIES = [
+  {
+    id: "material",
+    name: "Material Symbols",
+    iconifyPrefix: "material-symbols",
+    cornerStyle: "sharp",
+    mood: 25,
+    description: "Geometric, authoritative, and systematic.",
+    url: "https://fonts.google.com/icons",
+    npmPackage: "@iconify-json/material-symbols",
+    license: "Apache 2.0",
+    defaultVariant: "material-outlined",
+    variants: [
+      { id: "material-outlined", style: "outlined", strokeWeight: "regular", label: "Outlined" },
+      { id: "material-filled", style: "filled", strokeWeight: "regular", label: "Filled" }
+    ]
+  },
+  {
+    id: "lucide",
+    name: "Lucide",
+    iconifyPrefix: "lucide",
+    cornerStyle: "rounded",
+    mood: 60,
+    description: "Friendly, consistent, and approachable.",
+    url: "https://lucide.dev",
+    npmPackage: "lucide-react",
+    license: "ISC",
+    defaultVariant: "lucide",
+    variants: [
+      { id: "lucide", style: "outlined", strokeWeight: "regular", label: "Outlined" }
+    ]
+  },
+  {
+    id: "phosphor",
+    name: "Phosphor",
+    iconifyPrefix: "ph",
+    cornerStyle: "rounded",
+    mood: 55,
+    description: "Warm, versatile, and expressive.",
+    url: "https://phosphoricons.com",
+    npmPackage: "@phosphor-icons/react",
+    license: "MIT",
+    defaultVariant: "phosphor-regular",
+    variants: [
+      { id: "phosphor-regular", style: "outlined", strokeWeight: "regular", label: "Regular" },
+      { id: "phosphor-bold", style: "outlined", strokeWeight: "bold", label: "Bold" },
+      { id: "phosphor-thin", style: "outlined", strokeWeight: "thin", label: "Thin" },
+      { id: "phosphor-fill", style: "filled", strokeWeight: "regular", label: "Fill" }
+    ]
+  },
+  {
+    id: "solar",
+    name: "Solar",
+    iconifyPrefix: "solar",
+    cornerStyle: "rounded",
+    mood: 75,
+    description: "Expressive, modern, with a distinctive broken-line variant.",
+    url: "https://solar-icons.com",
+    npmPackage: "@iconify-json/solar",
+    license: "CC BY 4.0",
+    defaultVariant: "solar-linear",
+    variants: [
+      { id: "solar-linear", style: "outlined", strokeWeight: "thin", label: "Linear" },
+      { id: "solar-bold", style: "outlined", strokeWeight: "bold", label: "Bold" },
+      { id: "solar-broken", style: "outlined", strokeWeight: "thin", label: "Broken" }
+    ]
+  },
+  {
+    id: "tabler",
+    name: "Tabler Icons",
+    iconifyPrefix: "tabler",
+    cornerStyle: "rounded",
+    mood: 50,
+    description: "Clean, systematic, with outline and filled variants on a 24px grid.",
+    url: "https://tabler.io/icons",
+    npmPackage: "@tabler/icons-react",
+    license: "MIT",
+    defaultVariant: "tabler-outline",
+    variants: [
+      { id: "tabler-outline", style: "outlined", strokeWeight: "regular", label: "Outline" },
+      { id: "tabler-filled", style: "filled", strokeWeight: "regular", label: "Filled" }
+    ]
+  },
+  {
+    id: "radix",
+    name: "Radix Icons",
+    iconifyPrefix: "radix-icons",
+    cornerStyle: "sharp",
+    mood: 40,
+    description: "Precise, minimal, designed on a 15px grid.",
+    url: "https://www.radix-ui.com/icons",
+    npmPackage: "@radix-ui/react-icons",
+    license: "MIT",
+    defaultVariant: "radix",
+    variants: [
+      { id: "radix", style: "outlined", strokeWeight: "thin", label: "Regular" }
+    ]
+  }
+];
+var ICON_SETS = ICON_FAMILIES.flatMap(
+  (f) => f.variants.map((v) => ({
+    id: v.id,
+    name: f.variants.length > 1 ? `${f.name} ${v.label}` : f.name,
+    familyId: f.id,
+    iconifyPrefix: f.iconifyPrefix,
+    style: v.style,
+    strokeWeight: v.strokeWeight,
+    cornerStyle: f.cornerStyle,
+    mood: f.mood,
+    description: f.description,
+    url: f.url,
+    npmPackage: f.npmPackage,
+    license: f.license
+  }))
+);
+function getSetById(id) {
+  return ICON_SETS.find((s) => s.id === id);
+}
+
+// ../core/src/unified-hash.ts
+function isUnifiedHash(raw) {
+  const str = raw.replace(/^#/, "");
+  return /(?:^|&)[ctsyp]=/.test(str);
+}
+function parseUnifiedHash(raw) {
+  const str = raw.replace(/^#/, "");
+  const result = { c: null, t: null, s: null, y: null, p: null };
+  if (!isUnifiedHash(str)) return result;
+  for (const part of str.split("&")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const key = part.slice(0, eq);
+    const value = part.slice(eq + 1);
+    if (key === "c" || key === "t" || key === "s" || key === "y" || key === "p") {
+      result[key] = value || null;
+    }
+  }
+  return result;
+}
+function buildUnifiedHash(segments) {
+  const parts = [];
+  if (segments.c) parts.push("c=" + segments.c);
+  if (segments.t) parts.push("t=" + segments.t);
+  if (segments.s) parts.push("s=" + segments.s);
+  if (segments.y) parts.push("y=" + segments.y);
+  if (segments.p) parts.push("p=" + segments.p);
+  return parts.join("&");
+}
+
+// src/lib.ts
+init_scale();
+init_typography();
+
+// ../core/src/spacing.ts
+var SPACING_STEPS = [
+  { name: "3xs", multiple: 0.25 },
+  { name: "2xs", multiple: 0.5 },
+  { name: "xs", multiple: 0.75 },
+  { name: "sm", multiple: 1 },
+  { name: "md", multiple: 1.5 },
+  { name: "lg", multiple: 2 },
+  { name: "xl", multiple: 3 },
+  { name: "2xl", multiple: 4 },
+  { name: "3xl", multiple: 6 }
+];
+var SM_INDEX = 3;
+function snapRem(raw) {
+  if (raw < 1) return Math.round(raw * 4) / 4;
+  if (raw < 4) return Math.round(raw * 2) / 2;
+  return Math.round(raw);
+}
+function computeFromConfig(cfg) {
+  const { baseRem, ratio, mode, multiplier, snap } = cfg;
+  const unit = baseRem * multiplier;
+  return SPACING_STEPS.map((step, i) => {
+    const raw = mode === "harmonic" ? unit * step.multiple : unit * Math.pow(ratio, i - SM_INDEX);
+    const rem = snap ? snapRem(raw) : Math.round(raw * 1e3) / 1e3;
+    return {
+      name: step.name,
+      multiple: step.multiple,
+      rem,
+      px: Math.round(rem * 16)
+    };
+  });
+}
+function computeFromLevels(levels, multiplier) {
+  const bodyM = levels.find((l) => l.level === "body-m");
+  if (!bodyM) return [];
+  const baseRem = bodyM.maxRem * bodyM.lineHeight;
+  return computeFromConfig({
+    baseRem,
+    ratio: 1.272,
+    mode: "harmonic",
+    multiplier,
+    snap: true
+  });
+}
+function computeSpacingTokens(arg, multiplier = 1) {
+  if (Array.isArray(arg)) return computeFromLevels(arg, multiplier);
+  return computeFromConfig(arg);
+}
+
+// src/lib.ts
+var BASE_URL = "https://standby.design";
+function parseInput(input) {
+  if (!input) return { c: null, t: null, s: null, y: null, p: null };
+  let hash = input.trim();
+  if (/^https?:\/\//i.test(hash)) {
+    const idx = hash.indexOf("#");
+    hash = idx === -1 ? "" : hash.slice(idx + 1);
+  }
+  hash = hash.replace(/^#/, "");
+  return parseUnifiedHash(hash);
+}
+function buildHash(segs) {
+  return buildUnifiedHash({
+    c: segs.c ?? void 0,
+    t: segs.t ?? void 0,
+    s: segs.s ?? void 0,
+    y: segs.y ?? void 0,
+    p: segs.p ?? void 0
+  });
+}
+function systemUrl(segs) {
+  const hash = buildHash(segs);
+  const colorState = segs.c ? decodeState(segs.c) : null;
+  const params = new URLSearchParams();
+  const name = colorState?.themeName?.trim();
+  if (name && name !== "Standby.Design") params.set("t", name);
+  const hex = colorState?.brandHex?.replace("#", "");
+  if (hex && /^[0-9a-fA-F]{6}$/.test(hex)) params.set("c", hex);
+  const query = params.toString() ? `?${params.toString()}` : "";
+  return `${BASE_URL}/system/${query}#${hash}`;
+}
+function toolUrl(tool, segs) {
+  return `${BASE_URL}/${tool}#${buildHash(segs)}`;
+}
+function normalizeHex(input) {
+  const hex = input.trim().replace(/^#/, "");
+  if (!/^[0-9a-fA-F]{6}$/.test(hex)) return null;
+  return "#" + hex.toUpperCase();
+}
+var DEFAULT_COLOR_STATE = {
+  brandHex: "#335A7F",
+  bgColorHex: "#335A7F",
+  bgAutoMatch: true,
+  errorColorHex: "#CC3333",
+  errorAutoMatch: true,
+  chromaScale: 0.25,
+  currentMode: "balanced",
+  brandPin: false,
+  brandInvert: false,
+  errorPin: false,
+  errorInvert: false,
+  fgContrastMode: "best",
+  themeName: "",
+  extraAccents: [
+    { name: "Success", hex: "#33994D", pin: false, invert: false, autoMatch: true, autoHue: SUCCESS_HUE },
+    { name: "Warning", hex: "#998033", pin: false, invert: false, autoMatch: true, autoHue: WARNING_HUE },
+    { name: "Info", hex: "#3355CC", pin: false, invert: false, autoMatch: true, autoHue: INFO_HUE }
+  ]
+};
+var DEFAULT_TYPE_HASH = "custom,1,1.272,1.19,satoshi,satoshi,system-mono";
+function defaultTypeState() {
+  return decodeState2(DEFAULT_TYPE_HASH);
+}
+var DEFAULT_SHAPE_STATE = {
+  shapeStyle: "paper",
+  shadowEnabled: true,
+  shadowType: "normal",
+  shadowStrength: 1,
+  shadowBlurScale: 1,
+  shadowScale: 1.272,
+  shadowColorMode: "auto",
+  shadowCustomColor: "#000000",
+  borderEnabled: true,
+  borderWidth: 1,
+  borderColorMode: "auto",
+  borderCustomColor: "#000000",
+  borderRadius: 8,
+  glassDepth: 0.2,
+  glassBlur: 1,
+  glassDispersion: 0.4,
+  ringWidth: 2,
+  ringOffset: 2,
+  ringColorMode: "auto",
+  ringCustomColor: "#000000",
+  separationMode: "shadow",
+  shadowOffsetX: 2,
+  shadowOffsetY: 4,
+  brutalistVariant: "outlined"
+};
+var DEFAULT_SYMBOL_STATE = {
+  preferredStyle: "auto",
+  preferredWeight: "auto",
+  preferredCorners: "auto",
+  iconBaseSize: 1.25,
+  iconScale: 1.272,
+  snapTo4px: true,
+  selectedSet: null
+};
+function colorStateFrom(segs) {
+  return (segs.c ? decodeState(segs.c) : null) ?? DEFAULT_COLOR_STATE;
+}
+function typeStateFrom(segs) {
+  return (segs.t ? decodeState2(segs.t) : null) ?? defaultTypeState();
+}
+function shapeStateFrom(segs) {
+  const decoded = segs.s ? decodeState3(segs.s) : null;
+  return { ...DEFAULT_SHAPE_STATE, ...decoded ?? {} };
+}
+function symbolStateFrom(segs) {
+  return segs.y ? decodeState4(segs.y) : null;
+}
+function spaceStateFrom(segs) {
+  const decoded = segs.p ? decodeState5(segs.p) : null;
+  return { ...DEFAULT_SPACE_URL_STATE, ...decoded ?? {} };
+}
+function accentCssName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "accent";
+}
+function buildPalette(colorState) {
+  const { brandHex, bgColorHex, bgAutoMatch, errorColorHex, errorAutoMatch, chromaScale, currentMode, extraAccents, brandPin, errorPin } = colorState;
+  const effectiveBgHex = bgAutoMatch ? brandHex : bgColorHex;
+  const effectiveErrorHex = errorAutoMatch ? computeAutoErrorHex(brandHex) : errorColorHex;
+  const brand = generatePalette(brandHex, 1, currentMode);
+  const surface = generatePalette(effectiveBgHex, chromaScale, currentMode);
+  const error = generatePalette(effectiveErrorHex, 1, currentMode);
+  const errorSurface = generatePalette(effectiveErrorHex, chromaScale, currentMode);
+  const neutral = generatePalette(effectiveBgHex, 0, currentMode);
+  const accentPalettes = (extraAccents || []).filter((a) => a.autoMatch || /^#[0-9a-fA-F]{6}$/.test(a.hex)).map((a) => {
+    const effectiveHex = a.autoMatch ? computeAutoAccentHex(brandHex, a.autoHue) : a.hex;
+    return {
+      name: a.name,
+      hex: effectiveHex,
+      cssName: accentCssName(a.name),
+      palette: generatePalette(effectiveHex, 1, currentMode),
+      slatedPalette: generatePalette(effectiveHex, chromaScale, currentMode),
+      pin: a.pin,
+      invert: a.invert
+    };
+  });
+  const brandSwatchOverride = brandPin ? { hex: brandHex, L: hexToOklch(brandHex)[0] } : null;
+  const errorSwatchOverride = errorPin ? { hex: effectiveErrorHex, L: hexToOklch(effectiveErrorHex)[0] } : null;
+  const neutralExtended = [
+    { step: 0, L: 1, C: 0, H: 0, hex: "#FFFFFF", css: "oklch(1 0 0)" },
+    ...neutral,
+    { step: 1e3, L: 0, C: 0, H: 0, hex: "#000000", css: "oklch(0 0 0)" }
+  ];
+  return { brand, surface, error, errorSurface, neutral, neutralExtended, accentPalettes, brandSwatchOverride, errorSwatchOverride, effectiveBgHex, effectiveErrorHex };
+}
+function buildScale(typeState) {
+  let s;
+  if (typeState.scaleMode === "traditional") {
+    const desktop = typeState.traditionalAssignments ?? DEFAULT_TRADITIONAL;
+    const mobile = typeState.traditionalMobileAssignments ?? DEFAULT_TRADITIONAL_MOBILE;
+    s = traditionalScale(desktop, mobile);
+  } else {
+    s = customScale(typeState.baseSize, typeState.customRatio, typeState.mobileRatio, typeState.mobileBaseSize ?? typeState.baseSize);
+  }
+  return applyTypography(s, typeState.lineHeightOverrides ?? {}, typeState.letterSpacingOverrides ?? {});
+}
+function buildSpacing(spaceState) {
+  return computeSpacingTokens({
+    baseRem: spaceState.spacingBaseRem,
+    ratio: spaceState.spacingRatio,
+    mode: spaceState.spacingMode,
+    multiplier: spaceState.spacingMultiplier,
+    snap: spaceState.spacingSnap
+  });
+}
+function stepHex(entries, step) {
+  return entries.find((e) => e.step === step)?.hex ?? "";
+}
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errorResult(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// ../core/src/icon-tokens.ts
+function computeIconTokens(baseSize, scale, strokePx, snapTo4px = true) {
+  const md = baseSize;
+  const sm = md / scale;
+  const xs = sm / scale;
+  const lg = md * scale;
+  const xl = lg * scale;
+  const xxl = xl * scale;
+  const toToken = (raw, name, useCase) => {
+    const px = snapTo4px ? Math.round(raw * 16 / 4) * 4 : Math.round(raw * 16);
+    const rem = snapTo4px ? px / 16 : Math.round(raw * 1e4) / 1e4;
+    return { name, rem, px, useCase };
+  };
+  return {
+    sizes: [
+      toToken(xs, "xs", "Inline, caption-level"),
+      toToken(sm, "sm", "Body text companion"),
+      toToken(md, "md", "Standard UI elements"),
+      toToken(lg, "lg", "Navigation, actions"),
+      toToken(xl, "xl", "Feature, hero sections"),
+      toToken(xxl, "2xl", "Display, illustration")
+    ],
+    strokeWidth: strokePx
+  };
+}
+function weightToStroke(weight) {
+  switch (weight) {
+    case "thin":
+      return 1;
+    case "regular":
+      return 1.5;
+    case "bold":
+      return 2;
+  }
+}
+
+// ../core/src/recommend.ts
+var WEIGHT_ORDER = ["thin", "regular", "bold"];
+function styleScore(pref, actual) {
+  if (pref === "auto") return { score: 0.7, reason: null };
+  if (pref === actual) return { score: 1, reason: `${actual} style matches` };
+  return { score: 0.2, reason: null };
+}
+function moodScore(prefMood, setMood) {
+  const score = Math.exp(-Math.pow(setMood - prefMood, 2) / 2e3);
+  const diff = Math.abs(setMood - prefMood);
+  if (diff <= 15) return { score, reason: "mood closely matches" };
+  return { score, reason: null };
+}
+function weightScore(pref, actual) {
+  if (pref === "auto") return { score: 0.7, reason: null };
+  if (pref === actual) return { score: 1, reason: `${actual} weight matches` };
+  const prefIdx = WEIGHT_ORDER.indexOf(pref);
+  const actIdx = WEIGHT_ORDER.indexOf(actual);
+  if (Math.abs(prefIdx - actIdx) === 1) return { score: 0.5, reason: null };
+  return { score: 0.1, reason: null };
+}
+function cornerScore(pref, actual) {
+  if (pref === "auto") return { score: 0.7, reason: null };
+  if (pref === actual) return { score: 1, reason: `${actual} corners match` };
+  if (actual === "mixed") return { score: 0.6, reason: null };
+  return { score: 0.2, reason: null };
+}
+function recommendSets(prefs) {
+  return ICON_SETS.map((set) => {
+    const style = styleScore(prefs.style, set.style);
+    const mood = moodScore(prefs.mood, set.mood);
+    const weight = weightScore(prefs.weight, set.strokeWeight);
+    const corners = cornerScore(prefs.corners, set.cornerStyle);
+    const score = style.score * 0.25 + mood.score * 0.3 + weight.score * 0.2 + corners.score * 0.25;
+    const reasons = [style.reason, mood.reason, weight.reason, corners.reason].filter(Boolean);
+    return { set, score, reasons };
+  }).sort((a, b) => b.score - a.score);
+}
+
+// ../core/src/fontshare.ts
+var MONO_FONTS = [
+  { slug: "system-mono", name: "System Default", category: "mono", fallback: "monospace", isSystem: true },
+  { slug: "consolas", name: "Consolas", category: "mono", fallback: "monospace", isSystem: true },
+  { slug: "sf-mono", name: "SF Mono", category: "mono", fallback: "monospace", isSystem: true }
+];
+var SYSTEM_MONO_STACKS = {
+  "system-mono": "ui-monospace, 'Cascadia Code', Consolas, 'SF Mono', Menlo, 'DejaVu Sans Mono', monospace",
+  "consolas": "Consolas, 'Cascadia Code', 'DejaVu Sans Mono', monospace",
+  "sf-mono": "'SF Mono', Menlo, 'DejaVu Sans Mono', monospace"
+};
+var SEED_CATALOG = [
+  { slug: "satoshi", name: "Satoshi", category: "sans", fallback: "sans-serif" },
+  { slug: "general-sans", name: "General Sans", category: "sans", fallback: "sans-serif" },
+  { slug: "zodiak", name: "Zodiak", category: "serif", fallback: "serif" },
+  { slug: "clash-display", name: "Clash Display", category: "display", fallback: "sans-serif" },
+  ...MONO_FONTS
+];
+var catalog = [...SEED_CATALOG];
+var catalogMap = new Map(catalog.map((f) => [f.slug, f]));
+function getCatalog() {
+  return catalog;
+}
+function fontFamily(slug) {
+  const monoStack = SYSTEM_MONO_STACKS[slug];
+  if (monoStack) return monoStack;
+  const entry = catalogMap.get(slug);
+  if (!entry) return "sans-serif";
+  return `'${entry.name}', ${entry.fallback}`;
+}
+function buildFontshareUrl(slugs) {
+  const unique = [...new Set(slugs.filter((s) => !SYSTEM_MONO_STACKS[s] && s))];
+  if (unique.length === 0) return "";
+  const params = unique.map((s) => `f[]=${s}@1,2`).join("&");
+  return `https://api.fontshare.com/v2/css?${params}&display=swap`;
+}
+function buildFontshareEmbed(slugs) {
+  const url = buildFontshareUrl(slugs);
+  if (!url) return "";
+  return `<link href="${url}" rel="stylesheet">`;
+}
+function fontsByCategory() {
+  const groups = {};
+  for (const font of catalog) {
+    if (!groups[font.category]) groups[font.category] = [];
+    groups[font.category].push(font);
+  }
+  return groups;
+}
+
+// src/summaries.ts
+function colorSummary(state, palette) {
+  const lines = [];
+  const name = state.themeName && state.themeName !== "Standby.Design" ? ` \xB7 theme "${state.themeName}"` : "";
+  lines.push(`## Color \u2014 brand ${state.brandHex} \xB7 mode ${state.currentMode} \xB7 surface chroma ${Math.round(state.chromaScale * 100)}%${name}`);
+  lines.push("");
+  lines.push(`Brand scale: ${palette.brand.map((e) => `${e.step}:${e.hex}`).join(" ")}`);
+  lines.push(`Surface scale: ${palette.surface.map((e) => `${e.step}:${e.hex}`).join(" ")}`);
+  lines.push(`Error: ${palette.effectiveErrorHex}${state.errorAutoMatch ? " (auto-derived from brand hue)" : ""}`);
+  if (palette.accentPalettes.length > 0) {
+    lines.push(`Accents: ${palette.accentPalettes.map((a) => `${a.name} ${a.hex}${a.pin ? " (pinned)" : ""}`).join(" \xB7 ")}`);
+  }
+  lines.push("");
+  lines.push("Key semantic tokens (light/dark):");
+  lines.push(`- primary: ${state.brandPin ? state.brandHex + " (pinned)" : `${stepHex(palette.brand, 600)} / ${stepHex(palette.brand, 400)}`}`);
+  lines.push(`- background: ${stepHex(palette.surface, 50)} / ${stepHex(palette.surface, 875)}`);
+  lines.push(`- destructive: ${state.errorPin ? palette.effectiveErrorHex + " (pinned)" : `${stepHex(palette.error, 600)} / ${stepHex(palette.error, 400)}`}`);
+  return lines.join("\n");
+}
+function typeSummary(state, scale) {
+  const lines = [];
+  const modeLabel = state.scaleMode === "traditional" ? "traditional scale" : `custom ratio ${state.customRatio} (mobile ${state.mobileRatio})`;
+  lines.push(`## Typography \u2014 ${modeLabel} \xB7 base ${state.baseSize}rem`);
+  lines.push(`Fonts: heading ${fontFamily(state.headingFont)} (${state.headingFont}, weight ${state.headingWeight}) \xB7 body ${fontFamily(state.bodyFont)} (${state.bodyFont}) \xB7 mono ${fontFamily(state.monoFont)} (${state.monoFont})`);
+  lines.push("");
+  lines.push("Level | Mobile\u2192Desktop | Line-height | Letter-spacing");
+  for (const l of scale) {
+    const size = l.isFluid ? `${l.minRem}rem \u2192 ${l.maxRem}rem` : `${l.maxRem}rem`;
+    lines.push(`${l.label} | ${size} | ${l.lineHeight} | ${l.letterSpacing}em`);
+  }
+  return lines.join("\n");
+}
+function spaceSummary(state, spacing) {
+  const lines = [];
+  const mode = state.spacingMode === "geometric" ? `geometric \xD7${state.spacingRatio}` : "harmonic multiples";
+  lines.push(`## Spacing & Layout \u2014 ${mode} \xB7 base ${state.spacingBaseRem}rem \xB7 multiplier ${state.spacingMultiplier}\xD7 \xB7 snap ${state.spacingSnap ? "on" : "off"}`);
+  lines.push(`Spacing: ${spacing.map((t) => `${t.name}:${t.rem}rem`).join(" ")}`);
+  lines.push(`Breakpoints: ${state.breakpoints.map((b) => `${b.name}:${b.minPx}px`).join(" ")}`);
+  lines.push(`Containers: ${state.containers.map((c) => `${c.name}:${c.maxPx}px`).join(" ")} \xB7 prose ${state.proseMaxCh}ch`);
+  lines.push(`Aspect ratios: ${state.aspectRatios.map((a) => `${a.name} ${a.w}:${a.h}`).join(" \xB7 ")}${state.aspectIncludeReciprocals ? " (+ reciprocals)" : ""}`);
+  lines.push(`Fluid viewport anchors: ${state.fluidMinVw}px \u2192 ${state.fluidMaxVw}px`);
+  return lines.join("\n");
+}
+function shapeSummary(state) {
+  const lines = [];
+  lines.push(`## Shape \u2014 style ${state.shapeStyle} \xB7 radius base ${state.borderRadius}px`);
+  switch (state.shapeStyle) {
+    case "paper":
+      lines.push(`Shadows: ${state.shadowEnabled ? `${state.shadowType}, strength ${state.shadowStrength}, blur \xD7${state.shadowBlurScale}, level spread \xD7${state.shadowScale}` : "off"} (color ${state.shadowColorMode === "custom" ? state.shadowCustomColor : "auto"})`);
+      break;
+    case "glass":
+      lines.push(`Glass: depth ${state.glassDepth} \xB7 blur ${state.glassBlur} \xB7 dispersion ${state.glassDispersion}`);
+      break;
+    case "neomorph":
+      lines.push(`Neumorphic shadows: strength ${state.shadowStrength}, blur \xD7${state.shadowBlurScale}`);
+      break;
+    case "neobrutalism":
+      lines.push(`Brutalist: variant ${state.brutalistVariant} \xB7 shadow offset ${state.shadowOffsetX}px/${state.shadowOffsetY}px`);
+      break;
+  }
+  lines.push(`Border: ${state.borderEnabled ? `${state.borderWidth}px (color ${state.borderColorMode === "custom" ? state.borderCustomColor : "auto"})` : "off"}`);
+  lines.push(`Focus ring: ${state.ringWidth}px width, ${state.ringOffset}px offset (color ${state.ringColorMode === "custom" ? state.ringCustomColor : "auto"})`);
+  lines.push(`Separation mode: ${state.separationMode}`);
+  return lines.join("\n");
+}
+function resolveIconSet(state) {
+  if (state.selectedSet) {
+    const set = getSetById(state.selectedSet);
+    if (set) return { set, selected: true };
+  }
+  const recommended = recommendSets({
+    style: state.preferredStyle,
+    mood: 50,
+    weight: state.preferredWeight,
+    corners: state.preferredCorners
+  });
+  return { set: recommended[0]?.set || ICON_SETS[0], selected: false };
+}
+function symbolSummary(state) {
+  const { set, selected } = resolveIconSet(state);
+  const tokens = computeIconTokens(state.iconBaseSize, state.iconScale, weightToStroke(set.strokeWeight), state.snapTo4px);
+  const lines = [];
+  lines.push(`## Icons \u2014 ${selected ? "selected" : "recommended"}: ${set.name} (${set.id})`);
+  lines.push(`${set.description} \xB7 install: npm install ${set.npmPackage}`);
+  lines.push(`Style ${set.style} \xB7 weight ${set.strokeWeight} \xB7 corners ${set.cornerStyle}`);
+  lines.push(`Sizes (base ${state.iconBaseSize}rem, scale \xD7${state.iconScale}${state.snapTo4px ? ", 4px snap" : ""}): ${tokens.sizes.map((s) => `${s.name}:${s.px}px`).join(" ")} \xB7 stroke ${tokens.strokeWidth}px`);
+  return lines.join("\n");
+}
+
+// src/tools-generate.ts
+var URL_PARAM = z.string().optional().describe(
+  "Existing standby.design URL (or raw hash) to modify. Only this tool's section is changed; color/type/shape/icon/spacing settings from other tools are preserved. Omit to start fresh from defaults."
+);
+function header(segs, editTool) {
+  return [
+    `Design system: ${systemUrl(segs)}`,
+    `Fine-tune in UI: ${toolUrl(editTool, segs)}`
+  ].join("\n");
+}
+var READ_ONLY = { readOnlyHint: true, openWorldHint: false };
+var ACCENT_PRESET_HUES = {
+  success: SUCCESS_HUE,
+  warning: WARNING_HUE,
+  info: INFO_HUE
+};
+function registerGenerateTools(server2) {
+  server2.registerTool(
+    "generate_color_palette",
+    {
+      title: "Generate color palette",
+      description: "Generate a perceptually uniform OKLCH color palette from a brand color: 18-step scales for brand/surface/error/accents, semantic tokens (shadcn/ui compatible), light+dark modes. Returns a shareable standby.design/system URL and a compact summary. Use export_design_system for full CSS/Tailwind output.",
+      inputSchema: {
+        url: URL_PARAM,
+        brandHex: z.string().optional().describe('Brand color as 6-digit hex, e.g. "#335A7F". The palette midpoint is derived from this.'),
+        themeName: z.string().max(60).optional().describe("Name of the design system (appears in exports and page title)."),
+        mode: z.enum(["balanced", "exact"]).optional().describe(`"balanced": step 500 is always the perceptual midpoint (even light/dark distribution). "exact": step 500 keeps the input color's lightness.`),
+        chromaScale: z.number().min(0).max(1).optional().describe("Surface saturation 0\u20131 (0 = grey surfaces, 1 = vibrant). Default 0.25."),
+        bgColorHex: z.string().optional().describe('Surface tint color as hex, or "auto" to derive from the brand color (default).'),
+        errorColorHex: z.string().optional().describe('Error/destructive color as hex, or "auto" to derive from the brand hue (default).'),
+        brandPin: z.boolean().optional().describe("Pin the primary token to the exact input hex instead of the palette step."),
+        brandInvert: z.boolean().optional().describe("For pinned brand: mirror lightness in dark mode (e.g. black buttons in light mode, white in dark)."),
+        errorPin: z.boolean().optional(),
+        errorInvert: z.boolean().optional(),
+        fgContrastMode: z.enum(["best", "preferLight", "preferDark"]).optional().describe("Text color strategy on colored backgrounds."),
+        accents: z.array(z.object({
+          name: z.string().min(1).max(30),
+          hex: z.string().optional().describe("Hex color. Omit to auto-derive from the brand color (requires autoHue or a preset name: Success/Warning/Info)."),
+          autoHue: z.number().min(0).max(360).optional().describe("OKLCH hue for auto-derived accents."),
+          pin: z.boolean().optional(),
+          invert: z.boolean().optional()
+        })).max(3).optional().describe("Up to 3 additional named accent colors. Replaces the existing accent list when provided; pass [] to remove all accents. Default: Success/Warning/Info, auto-derived.")
+      },
+      annotations: READ_ONLY
+    },
+    async (args) => {
+      const segs = parseInput(args.url);
+      const state = { ...colorStateFrom(segs), extraAccents: [...colorStateFrom(segs).extraAccents] };
+      if (args.brandHex !== void 0) {
+        const hex = normalizeHex(args.brandHex);
+        if (!hex) return errorResult(`Invalid brandHex "${args.brandHex}" \u2014 expected a 6-digit hex color like #335A7F.`);
+        state.brandHex = hex;
+      }
+      if (args.themeName !== void 0) state.themeName = args.themeName;
+      if (args.mode !== void 0) state.currentMode = args.mode;
+      if (args.chromaScale !== void 0) state.chromaScale = args.chromaScale;
+      if (args.bgColorHex !== void 0) {
+        if (args.bgColorHex.toLowerCase() === "auto") {
+          state.bgAutoMatch = true;
+          state.bgColorHex = state.brandHex;
+        } else {
+          const hex = normalizeHex(args.bgColorHex);
+          if (!hex) return errorResult(`Invalid bgColorHex "${args.bgColorHex}" \u2014 expected a 6-digit hex color or "auto".`);
+          state.bgAutoMatch = false;
+          state.bgColorHex = hex;
+        }
+      }
+      if (args.errorColorHex !== void 0) {
+        if (args.errorColorHex.toLowerCase() === "auto") {
+          state.errorAutoMatch = true;
+        } else {
+          const hex = normalizeHex(args.errorColorHex);
+          if (!hex) return errorResult(`Invalid errorColorHex "${args.errorColorHex}" \u2014 expected a 6-digit hex color or "auto".`);
+          state.errorAutoMatch = false;
+          state.errorColorHex = hex;
+        }
+      }
+      if (args.brandPin !== void 0) state.brandPin = args.brandPin;
+      if (args.brandInvert !== void 0) state.brandInvert = args.brandInvert;
+      if (args.errorPin !== void 0) state.errorPin = args.errorPin;
+      if (args.errorInvert !== void 0) state.errorInvert = args.errorInvert;
+      if (args.fgContrastMode !== void 0) state.fgContrastMode = args.fgContrastMode;
+      if (args.accents !== void 0) {
+        const accents = [];
+        for (const a of args.accents) {
+          if (a.hex) {
+            const hex = normalizeHex(a.hex);
+            if (!hex) return errorResult(`Invalid hex "${a.hex}" for accent "${a.name}".`);
+            accents.push({ name: a.name, hex, pin: a.pin ?? false, invert: a.invert ?? false, autoMatch: false, autoHue: 0 });
+          } else {
+            const hue = a.autoHue ?? ACCENT_PRESET_HUES[a.name.toLowerCase()];
+            if (hue === void 0) {
+              return errorResult(`Accent "${a.name}": provide either a hex color or an autoHue (0\u2013360) for auto-derivation. Presets with known hues: Success, Warning, Info.`);
+            }
+            accents.push({ name: a.name, hex: "#000000", pin: a.pin ?? false, invert: a.invert ?? false, autoMatch: true, autoHue: hue });
+          }
+        }
+        state.extraAccents = accents;
+      }
+      const next = { ...segs, c: encodeState(state) };
+      const palette = buildPalette(state);
+      return textResult(`${header(next, "color")}
+
+${colorSummary(state, palette)}`);
+    }
+  );
+  const levelOverrides = z.record(z.string(), z.number()).optional();
+  server2.registerTool(
+    "generate_type_scale",
+    {
+      title: "Generate type scale",
+      description: "Generate a fluid typographic scale (CSS clamp() between 375px and 1920px viewports) with 11 levels (Display, H1\u2013H6, Body L/M/S, Caption), Fontshare fonts, line heights and letter spacing. Returns a shareable standby.design/system URL and a summary table. Use list_fonts to discover font slugs.",
+      inputSchema: {
+        url: URL_PARAM,
+        scaleMode: z.enum(["custom", "traditional"]).optional().describe('"custom": compound ratio scale (default). "traditional": classical Renaissance point sizes per level.'),
+        baseSize: z.number().min(0.5).max(2).optional().describe("Desktop base size in rem (default 1.0)."),
+        ratio: z.number().min(1.05).max(1.7).optional().describe("Scale ratio for custom mode. Presets: 1.2 minor third, 1.25 major third, 1.272 golden-ratio-area (default, \u221A\u03C6), 1.333 perfect fourth, 1.618 golden ratio. The empirical perceptual corridor is 1.20\u20131.50."),
+        mobileBaseSize: z.number().min(0.5).max(2).optional().describe("Mobile base size in rem (default = baseSize)."),
+        mobileRatio: z.number().min(1).max(1.7).optional().describe("Explicit mobile scale ratio. Omit to auto-derive from ratio and autoShrink."),
+        autoShrink: z.number().min(0).max(100).optional().describe("Percent reduction for the auto-derived mobile ratio (default 25). Only used when mobileRatio is not set."),
+        headingFont: z.string().optional().describe('Fontshare font slug for headings, e.g. "satoshi", "general-sans", "clash-display".'),
+        bodyFont: z.string().optional().describe("Fontshare font slug for body text."),
+        monoFont: z.string().optional().describe('Font slug for code. System stacks: "system-mono", "consolas", "sf-mono".'),
+        headingWeight: z.number().int().min(100).max(900).optional().describe("Font weight for headings (default 500)."),
+        lineHeightOverrides: levelOverrides.describe('Per-level line-height overrides, e.g. {"h1": 1.1, "body-m": 1.6}. Levels: display, h1\u2013h6, body-l, body-m, body-s, caption.'),
+        letterSpacingOverrides: levelOverrides.describe('Per-level letter-spacing overrides in em, e.g. {"display": -0.05}.'),
+        traditionalAssignments: z.record(z.string(), z.number()).optional().describe('For traditional mode: desktop px size per level, e.g. {"display": 48, "h1": 36, ...}.'),
+        traditionalMobileAssignments: z.record(z.string(), z.number()).optional().describe("For traditional mode: mobile px size per level.")
+      },
+      annotations: READ_ONLY
+    },
+    async (args) => {
+      const segs = parseInput(args.url);
+      const state = typeStateFrom(segs);
+      for (const key of ["lineHeightOverrides", "letterSpacingOverrides", "traditionalAssignments", "traditionalMobileAssignments"]) {
+        const rec = args[key];
+        if (!rec) continue;
+        const bad = Object.keys(rec).filter((k) => !TYPE_LEVELS.includes(k));
+        if (bad.length > 0) return errorResult(`Invalid type level(s) in ${key}: ${bad.join(", ")}. Valid levels: ${TYPE_LEVELS.join(", ")}.`);
+      }
+      if (args.scaleMode !== void 0) state.scaleMode = args.scaleMode;
+      if (args.baseSize !== void 0) {
+        if (state.mobileBaseSize === state.baseSize && args.mobileBaseSize === void 0) {
+          state.mobileBaseSize = args.baseSize;
+        }
+        state.baseSize = args.baseSize;
+      }
+      if (args.ratio !== void 0) state.customRatio = args.ratio;
+      if (args.mobileBaseSize !== void 0) state.mobileBaseSize = args.mobileBaseSize;
+      if (args.autoShrink !== void 0) state.autoShrink = args.autoShrink;
+      if (args.mobileRatio !== void 0) {
+        state.mobileRatioMode = "custom";
+        state.mobileRatio = args.mobileRatio;
+      } else if (state.mobileRatioMode === "auto") {
+        state.mobileRatio = Math.round((1 + (state.customRatio - 1) * (1 - state.autoShrink / 100)) * 1e3) / 1e3;
+      }
+      if (args.headingFont !== void 0) state.headingFont = args.headingFont;
+      if (args.bodyFont !== void 0) state.bodyFont = args.bodyFont;
+      if (args.monoFont !== void 0) state.monoFont = args.monoFont;
+      if (args.headingWeight !== void 0) state.headingWeight = args.headingWeight;
+      if (args.lineHeightOverrides !== void 0) state.lineHeightOverrides = args.lineHeightOverrides;
+      if (args.letterSpacingOverrides !== void 0) state.letterSpacingOverrides = args.letterSpacingOverrides;
+      if (state.scaleMode === "traditional") {
+        const fill = (rec, base) => {
+          const out = { ...base };
+          for (const [k, v] of Object.entries(rec ?? {})) out[k] = v;
+          return out;
+        };
+        const { DEFAULT_TRADITIONAL: DEFAULT_TRADITIONAL2, DEFAULT_TRADITIONAL_MOBILE: DEFAULT_TRADITIONAL_MOBILE2 } = await Promise.resolve().then(() => (init_scale(), scale_exports));
+        state.traditionalAssignments = fill(args.traditionalAssignments, state.traditionalAssignments ?? DEFAULT_TRADITIONAL2);
+        state.traditionalMobileAssignments = fill(args.traditionalMobileAssignments, state.traditionalMobileAssignments ?? DEFAULT_TRADITIONAL_MOBILE2);
+      }
+      const next = { ...segs, t: encodeState2(state) };
+      const scale = buildScale(state);
+      return textResult(`${header(next, "type")}
+
+${typeSummary(state, scale)}`);
+    }
+  );
+  server2.registerTool(
+    "generate_shape_tokens",
+    {
+      title: "Generate shape tokens",
+      description: 'Generate shape tokens \u2014 radii, shadows, borders, focus rings \u2014 in one of four visual styles: "paper" (classic surfaces with layered shadows), "glass" (liquid glass), "neomorph" (soft neumorphism), "neobrutalism" (hard offset shadows). Returns a shareable standby.design/system URL and a summary.',
+      inputSchema: {
+        url: URL_PARAM,
+        style: z.enum(["paper", "glass", "neomorph", "neobrutalism"]).optional().describe('Top-level visual style (default "paper").'),
+        borderRadius: z.number().int().min(0).max(64).optional().describe("Base radius in px; scales to a xs\u2013xl radius set (default 8)."),
+        shadowEnabled: z.boolean().optional(),
+        shadowType: z.enum(["normal", "flat"]).optional().describe("Shadow rendering for paper style."),
+        shadowStrength: z.number().min(0).max(3).optional().describe("Shadow alpha multiplier (default 1.0)."),
+        shadowBlurScale: z.number().min(0).max(3).optional().describe("Shadow blur multiplier (default 1.0)."),
+        shadowScale: z.number().min(1).max(2).optional().describe("Elevation level spread ratio (default 1.272)."),
+        shadowColorHex: z.string().optional().describe('Custom shadow color as hex, or "auto" (default).'),
+        shadowOffsetX: z.number().int().min(-16).max(16).optional().describe("Brutalist shadow X offset in px (default 2)."),
+        shadowOffsetY: z.number().int().min(-16).max(16).optional().describe("Brutalist shadow Y offset in px (default 4)."),
+        brutalistVariant: z.enum(["outlined", "solid"]).optional(),
+        borderEnabled: z.boolean().optional(),
+        borderWidth: z.number().min(0).max(10).optional().describe("Border width in px (default 1)."),
+        borderColorHex: z.string().optional().describe('Custom border color as hex, or "auto" (default).'),
+        glassDepth: z.number().min(-2).max(5).optional().describe("Glass displacement intensity (default 0.2)."),
+        glassBlur: z.number().min(0).max(20).optional().describe("Glass backdrop blur (default 1.0)."),
+        glassDispersion: z.number().min(0).max(2).optional().describe("Chromatic aberration intensity (default 0.4)."),
+        ringWidth: z.number().int().min(0).max(8).optional().describe("Focus ring width in px (default 2)."),
+        ringOffset: z.number().int().min(0).max(8).optional().describe("Focus ring offset in px (default 2)."),
+        ringColorHex: z.string().optional().describe('Custom focus ring color as hex, or "auto" (default).'),
+        separationMode: z.enum(["shadow", "border", "contrast", "gap", "mixed"]).optional().describe("How surfaces separate from the background.")
+      },
+      annotations: READ_ONLY
+    },
+    async (args) => {
+      const segs = parseInput(args.url);
+      const state = shapeStateFrom(segs);
+      if (args.style !== void 0) state.shapeStyle = args.style;
+      if (args.borderRadius !== void 0) state.borderRadius = args.borderRadius;
+      if (args.shadowEnabled !== void 0) state.shadowEnabled = args.shadowEnabled;
+      if (args.shadowType !== void 0) state.shadowType = args.shadowType;
+      if (args.shadowStrength !== void 0) state.shadowStrength = args.shadowStrength;
+      if (args.shadowBlurScale !== void 0) state.shadowBlurScale = args.shadowBlurScale;
+      if (args.shadowScale !== void 0) state.shadowScale = args.shadowScale;
+      if (args.shadowOffsetX !== void 0) state.shadowOffsetX = args.shadowOffsetX;
+      if (args.shadowOffsetY !== void 0) state.shadowOffsetY = args.shadowOffsetY;
+      if (args.brutalistVariant !== void 0) state.brutalistVariant = args.brutalistVariant;
+      if (args.borderEnabled !== void 0) state.borderEnabled = args.borderEnabled;
+      if (args.borderWidth !== void 0) state.borderWidth = args.borderWidth;
+      if (args.glassDepth !== void 0) state.glassDepth = args.glassDepth;
+      if (args.glassBlur !== void 0) state.glassBlur = args.glassBlur;
+      if (args.glassDispersion !== void 0) state.glassDispersion = args.glassDispersion;
+      if (args.ringWidth !== void 0) state.ringWidth = args.ringWidth;
+      if (args.ringOffset !== void 0) state.ringOffset = args.ringOffset;
+      if (args.separationMode !== void 0) state.separationMode = args.separationMode;
+      for (const [argKey, modeKey, colorKey] of [
+        ["shadowColorHex", "shadowColorMode", "shadowCustomColor"],
+        ["borderColorHex", "borderColorMode", "borderCustomColor"],
+        ["ringColorHex", "ringColorMode", "ringCustomColor"]
+      ]) {
+        const value = args[argKey];
+        if (value === void 0) continue;
+        if (value.toLowerCase() === "auto") {
+          state[modeKey] = "auto";
+        } else {
+          const hex = normalizeHex(value);
+          if (!hex) return errorResult(`Invalid ${argKey} "${value}" \u2014 expected a 6-digit hex color or "auto".`);
+          state[modeKey] = "custom";
+          state[colorKey] = hex;
+        }
+      }
+      const next = { ...segs, s: encodeState3(state) };
+      return textResult(`${header(next, "shape")}
+
+${shapeSummary(state)}`);
+    }
+  );
+  const SET_IDS = ICON_SETS.map((s) => s.id);
+  server2.registerTool(
+    "generate_icon_tokens",
+    {
+      title: "Generate icon tokens",
+      description: `Pick an icon set and generate icon sizing tokens (xs\u20132xl + stroke width). Either select a specific set or state style preferences and get a recommendation. Available sets: ${SET_IDS.join(", ")}. Returns a shareable standby.design/system URL and a summary.`,
+      inputSchema: {
+        url: URL_PARAM,
+        set: z.string().optional().describe(`Icon set variant id to select explicitly, e.g. "lucide-outlined". One of: ${SET_IDS.join(", ")}. Pass "auto" to clear the selection and use the recommendation instead.`),
+        style: z.enum(["outlined", "filled", "duotone", "auto"]).optional().describe("Preferred icon style for the recommendation."),
+        weight: z.enum(["thin", "regular", "bold", "auto"]).optional().describe("Preferred stroke weight."),
+        corners: z.enum(["sharp", "rounded", "auto"]).optional().describe("Preferred corner style (sharp = corporate/precise, rounded = friendly)."),
+        baseSize: z.number().min(0.5).max(3).optional().describe("Base icon size (md) in rem (default 1.25)."),
+        scale: z.number().min(1).max(2).optional().describe("Size scale ratio (default 1.272)."),
+        snapTo4px: z.boolean().optional().describe("Round sizes to the 4px grid (default true).")
+      },
+      annotations: READ_ONLY
+    },
+    async (args) => {
+      const segs = parseInput(args.url);
+      const state = symbolStateFrom(segs) ?? { ...DEFAULT_SYMBOL_STATE };
+      if (args.set !== void 0) {
+        if (args.set.toLowerCase() === "auto") {
+          state.selectedSet = null;
+        } else if (!SET_IDS.includes(args.set)) {
+          return errorResult(`Unknown icon set "${args.set}". Valid ids: ${SET_IDS.join(", ")} \u2014 or "auto" for the recommendation.`);
+        } else {
+          state.selectedSet = args.set;
+        }
+      }
+      if (args.style !== void 0) state.preferredStyle = args.style;
+      if (args.weight !== void 0) state.preferredWeight = args.weight;
+      if (args.corners !== void 0) state.preferredCorners = args.corners;
+      if (args.baseSize !== void 0) state.iconBaseSize = args.baseSize;
+      if (args.scale !== void 0) state.iconScale = args.scale;
+      if (args.snapTo4px !== void 0) state.snapTo4px = args.snapTo4px;
+      const next = { ...segs, y: encodeState4(state) };
+      return textResult(`${header(next, "symbol")}
+
+${symbolSummary(state)}`);
+    }
+  );
+  server2.registerTool(
+    "generate_space_tokens",
+    {
+      title: "Generate spacing & layout tokens",
+      description: "Generate spacing tokens (3xs\u20133xl), breakpoints, container widths, prose measure, and aspect ratios. Returns a shareable standby.design/system URL and a summary.",
+      inputSchema: {
+        url: URL_PARAM,
+        mode: z.enum(["harmonic", "geometric"]).optional().describe('"harmonic": multiples of the base (default). "geometric": compound ratio steps.'),
+        baseRem: z.number().min(0.25).max(4).optional().describe("Base spacing in rem (default 1.0)."),
+        ratio: z.number().min(1).max(2).optional().describe("Ratio for geometric mode (default 1.272)."),
+        multiplier: z.number().min(0.25).max(4).optional().describe("Uniform scale factor on all tokens (default 1.0)."),
+        snap: z.boolean().optional().describe("Snap token values to a sensible grid (default true)."),
+        breakpoints: z.array(z.object({
+          name: z.string().min(1),
+          minPx: z.number().int().min(0)
+        })).optional().describe('Replace the breakpoint list, e.g. [{"name":"sm","minPx":640},...]. Defaults: sm 640, md 768, lg 1024, xl 1280, 2xl 1536.'),
+        fluidMinVw: z.number().int().min(200).max(1e3).optional().describe("Lower fluid viewport anchor in px (default 375)."),
+        fluidMaxVw: z.number().int().min(1e3).max(3840).optional().describe("Upper fluid viewport anchor in px (default 1920)."),
+        containers: z.array(z.object({
+          name: z.string().min(1),
+          maxPx: z.number().int().min(0)
+        })).optional().describe("Replace the container list. Defaults: prose 680, narrow 880, default 1200, wide 1440."),
+        proseMaxCh: z.number().int().min(20).max(120).optional().describe("Prose measure in ch (default 65)."),
+        aspectRatios: z.array(z.object({
+          name: z.string().min(1),
+          w: z.number().positive(),
+          h: z.number().positive()
+        })).optional().describe('Replace the aspect ratio list, e.g. [{"name":"video","w":16,"h":9}].'),
+        includeReciprocals: z.boolean().optional().describe("Also export flipped (portrait) variants of each ratio (default true).")
+      },
+      annotations: READ_ONLY
+    },
+    async (args) => {
+      const segs = parseInput(args.url);
+      const state = spaceStateFrom(segs);
+      if (args.mode !== void 0) state.spacingMode = args.mode;
+      if (args.baseRem !== void 0) state.spacingBaseRem = args.baseRem;
+      if (args.ratio !== void 0) state.spacingRatio = args.ratio;
+      if (args.multiplier !== void 0) state.spacingMultiplier = args.multiplier;
+      if (args.snap !== void 0) state.spacingSnap = args.snap;
+      if (args.breakpoints !== void 0) state.breakpoints = args.breakpoints;
+      if (args.fluidMinVw !== void 0) state.fluidMinVw = args.fluidMinVw;
+      if (args.fluidMaxVw !== void 0) state.fluidMaxVw = args.fluidMaxVw;
+      if (args.containers !== void 0) state.containers = args.containers;
+      if (args.proseMaxCh !== void 0) state.proseMaxCh = args.proseMaxCh;
+      if (args.aspectRatios !== void 0) state.aspectRatios = args.aspectRatios;
+      if (args.includeReciprocals !== void 0) state.aspectIncludeReciprocals = args.includeReciprocals;
+      const next = { ...segs, p: encodeState5(state) };
+      const spacing = buildSpacing(state);
+      return textResult(`${header(next, "space")}
+
+${spaceSummary(state, spacing)}`);
+    }
+  );
+}
+
+// src/tools-system.ts
+import { z as z2 } from "zod";
+
+// ../../system-react/src/lib/color-code-export.ts
+function generateSeedComment(state, effectiveBgHex, effectiveErrorHex) {
+  const title = state.themeName && state.themeName !== "Standby.Design" ? `${state.themeName} \u2014 ` : "";
+  const accents = state.extraAccents.map(
+    (a) => `${a.name} ${a.autoMatch ? `auto (hue ${Math.round(a.autoHue)}\xB0)` : a.hex}${a.pin ? ", pinned" : ""}`
+  ).join(" \xB7 ");
+  const lines = [
+    `/*`,
+    ` * ${title}generated with standby.design`,
+    ` * Seed: brand ${state.brandHex}${state.brandPin ? " (pinned)" : ""}${state.brandInvert ? " (dark-inverted)" : ""} \xB7 mode ${state.currentMode} \xB7 text contrast ${state.fgContrastMode}`,
+    ` * Surface: ${state.bgAutoMatch ? "auto from brand" : state.bgColorHex} \u2192 ${effectiveBgHex} \xB7 chroma ${Math.round(state.chromaScale * 100)}%`,
+    ` * Error: ${state.errorAutoMatch ? "auto from brand hue" : state.errorColorHex} \u2192 ${effectiveErrorHex}${state.errorPin ? " (pinned)" : ""}${state.errorInvert ? " (dark-inverted)" : ""}`,
+    ...accents ? [` * Accents: ${accents}`] : [],
+    ` * Restore: https://standby.design/color#c=${encodeState(state)}`,
+    ` */`
+  ];
+  return lines.join("\n") + "\n\n";
+}
+function palMap(arr) {
+  return Object.fromEntries(arr.map((r) => [r.step, r]));
+}
+function fgStep(bgHex, pMap, ls, ds, fgMode) {
+  if (!bgHex) return ls;
+  const lightHex = pMap[ls]?.hex;
+  const darkHex = pMap[ds]?.hex;
+  const lightCR = lightHex ? contrastRatio(lightHex, bgHex) : 0;
+  const darkCR = darkHex ? contrastRatio(darkHex, bgHex) : 0;
+  if (fgMode === "preferDark") {
+    if (darkCR >= 4.5) return ds;
+    if (lightCR >= 4.5) return ls;
+    return ds;
+  }
+  if (fgMode === "preferLight") {
+    if (lightCR >= 4.5) return ls;
+    if (darkCR >= 4.5) return ds;
+    return ls;
+  }
+  return lightCR >= darkCR ? ls : ds;
+}
+function fgDirect(bgHex, pMap, ls, ds, pfx, fgMode) {
+  const step = fgStep(bgHex, pMap, ls, ds, fgMode);
+  return pMap[step]?.css || `var(--color-${pfx}-${step})`;
+}
+function hexToCss(hex) {
+  const [L, C, H] = hexToOklch(hex);
+  return `oklch(${L.toFixed(4)} ${C.toFixed(4)} ${H.toFixed(2)})`;
+}
+function fmtSec(palette, prefix, mode) {
+  const gs = [
+    { l: "Light Surfaces", f: (r) => r.step <= 100 },
+    { l: "Core", f: (r) => r.step >= 200 && r.step <= 800 },
+    { l: "Dark Surfaces (normal)", f: (r) => r.step >= 825 && r.step <= 875 },
+    { l: "Dark Surfaces (high contrast)", f: (r) => r.step >= 900 }
+  ];
+  let out = "";
+  gs.forEach((g, i) => {
+    if (i > 0) out += "\n";
+    out += `  /* ${g.l} */
+`;
+    palette.filter(g.f).forEach((r) => {
+      const v = mode === "css" ? r.css : r.hex;
+      out += `  --color-${prefix}-${r.step}: ${v};
+`;
+    });
+  });
+  return out;
+}
+function buildBlock(sel, rows) {
+  let o = `${sel} {
+`;
+  rows.forEach(([name, prefix, step]) => {
+    if (name === "#comment") o += `  /* ${step} */
+`;
+    else if (prefix === null) o += `  /* ${step} */
+`;
+    else if (prefix === "#direct") o += `  --${name}: ${step};
+`;
+    else o += `  --${name}: var(--color-${prefix}-${step});
+`;
+  });
+  return o + `}
+`;
+}
+function generatePrimitivesOklch(brand, surface, error, errorSurface, neutralExtended, accentPalettes, chromaScale, customBgHex, themeName) {
+  const pct = Math.round(chromaScale * 100);
+  const bgLabel = customBgHex ? `${pct}% chroma \u2014 base ${customBgHex}` : `${pct}% chroma`;
+  const header2 = themeName ? `/* ${themeName} \u2014 Primitive Tokens */` : `/* Primitive Tokens */`;
+  const cmt = (t) => `
+  /* ${t} */
+`;
+  let o = `${header2}
+:root {
+`;
+  o += cmt("Brand") + fmtSec(brand, "brand", "css");
+  o += cmt(`Surface \u2014 ${bgLabel}`) + fmtSec(surface, "surface", "css");
+  o += cmt("Error") + fmtSec(error, "error", "css");
+  o += cmt(`Error Surface \u2014 ${pct}% chroma`) + fmtSec(errorSurface, "error-surface", "css");
+  o += cmt("Neutral") + fmtSec(neutralExtended, "neutral", "css");
+  accentPalettes.forEach((entry) => {
+    o += cmt(entry.name) + fmtSec(entry.palette, entry.cssName, "css");
+    o += cmt(`${entry.name} Surface \u2014 ${pct}% chroma`) + fmtSec(entry.slatedPalette, entry.cssName + "-surface", "css");
+  });
+  o += `}`;
+  return o;
+}
+function generateSemantic(accentPalettes, brandPal, errPal, errSurfPal, surfacePal, brandPin, pinnedBrandHex, brandInvert, errorPin, pinnedErrorHex, errorInvert, fgMode, themeName) {
+  const brandMap = palMap(brandPal);
+  const errMap = palMap(errPal);
+  const errSurfMap = palMap(errSurfPal);
+  const surfMap = palMap(surfacePal);
+  const bPin = brandPin;
+  const bHex = pinnedBrandHex;
+  const ePin = errorPin;
+  const eHex = pinnedErrorHex;
+  const bCss = bPin && bHex ? hexToCss(bHex) : null;
+  const bFgCss = bPin && bHex ? fgDirect(bHex, brandMap, 50, 975, "brand", fgMode) : null;
+  const bInvHex = bPin && bHex && brandInvert ? invertHex(bHex) : null;
+  const bInvCss = bInvHex ? hexToCss(bInvHex) : null;
+  const bInvFgCss = bInvHex ? fgDirect(bInvHex, brandMap, 50, 975, "brand", fgMode) : null;
+  const primaryLight = bPin && bHex ? ["primary", "#direct", bCss] : ["primary", "brand", 600];
+  const primaryFgLight = bPin && bHex ? ["primary-foreground", "#direct", bFgCss] : ["primary-foreground", "brand", fgStep(brandMap[600]?.hex, brandMap, 50, 975, fgMode)];
+  const primaryDark = bPin && bHex ? bInvCss ? ["primary", "#direct", bInvCss] : ["primary", "#direct", bCss] : ["primary", "brand", 400];
+  const primaryFgDark = bPin && bHex ? bInvFgCss ? ["primary-foreground", "#direct", bInvFgCss] : ["primary-foreground", "#direct", bFgCss] : ["primary-foreground", "brand", fgStep(brandMap[400]?.hex, brandMap, 50, 975, fgMode)];
+  const sbPrimLight = bPin && bHex ? ["sidebar-primary", "#direct", bCss] : ["sidebar-primary", "brand", 600];
+  const sbPrimFgLight = bPin && bHex ? ["sidebar-primary-foreground", "#direct", bFgCss] : ["sidebar-primary-foreground", "brand", fgStep(brandMap[600]?.hex, brandMap, 50, 975, fgMode)];
+  const sbPrimDark = bPin && bHex ? bInvCss ? ["sidebar-primary", "#direct", bInvCss] : ["sidebar-primary", "#direct", bCss] : ["sidebar-primary", "brand", 400];
+  const sbPrimFgDark = bPin && bHex ? bInvFgCss ? ["sidebar-primary-foreground", "#direct", bInvFgCss] : ["sidebar-primary-foreground", "#direct", bFgCss] : ["sidebar-primary-foreground", "brand", fgStep(brandMap[400]?.hex, brandMap, 50, 975, fgMode)];
+  const brandContrastWarnLight = [];
+  const brandContrastWarnDark = [];
+  if (bPin && bHex) {
+    const lightBg = surfMap[50]?.hex;
+    const darkBg = surfMap[875]?.hex;
+    const darkCheckHex = bInvHex || bHex;
+    const lightFail = lightBg ? contrastRatio(bHex, lightBg) < 4.5 : false;
+    const darkFail = darkBg ? contrastRatio(darkCheckHex, darkBg) < 4.5 : false;
+    if (lightFail) {
+      brandContrastWarnLight.push([
+        "#comment",
+        null,
+        `\u26A0 Pinned primary has low contrast on light surfaces \u2014 do not use as text color. Use --foreground for text on light backgrounds.`
+      ]);
+    }
+    if (darkFail) {
+      brandContrastWarnDark.push([
+        "#comment",
+        null,
+        `\u26A0 Pinned primary has low contrast on dark surfaces \u2014 do not use as text color. Use --foreground for text on dark backgrounds.`
+      ]);
+    }
+  }
+  const eCss = ePin && eHex ? hexToCss(eHex) : null;
+  const eFgCss = ePin && eHex ? fgDirect(eHex, errSurfMap, 100, 900, "error-surface", fgMode) : null;
+  const eInvHex = ePin && eHex && errorInvert ? invertHex(eHex) : null;
+  const eInvCss = eInvHex ? hexToCss(eInvHex) : null;
+  const eInvFgCss = eInvHex ? fgDirect(eInvHex, errSurfMap, 100, 900, "error-surface", fgMode) : null;
+  const destLight = ePin && eHex ? ["destructive", "#direct", eCss] : ["destructive", "error", 600];
+  const destFgLight = ePin && eHex ? ["destructive-foreground", "#direct", eFgCss] : ["destructive-foreground", "error-surface", fgStep(errMap[600]?.hex, errSurfMap, 100, 900, fgMode)];
+  const destDark = ePin && eHex ? eInvCss ? ["destructive", "#direct", eInvCss] : ["destructive", "#direct", eCss] : ["destructive", "error", 400];
+  const destFgDark = ePin && eHex ? eInvFgCss ? ["destructive-foreground", "#direct", eInvFgCss] : ["destructive-foreground", "#direct", eFgCss] : ["destructive-foreground", "error-surface", fgStep(errMap[400]?.hex, errSurfMap, 100, 900, fgMode)];
+  const root = buildBlock(":root", [
+    [null, null, "Base"],
+    ["background", "surface", 50],
+    ["foreground", "surface", 975],
+    [null, null, "Card"],
+    ["card", "surface", 25],
+    ["card-foreground", "surface", 975],
+    [null, null, "Popover"],
+    ["popover", "surface", 25],
+    ["popover-foreground", "surface", 975],
+    [null, null, "Primary"],
+    primaryLight,
+    primaryFgLight,
+    ...brandContrastWarnLight,
+    ["primary-subtle", "brand", 100],
+    ["primary-subtle-foreground", "brand", 950],
+    [null, null, "Secondary \u2014 softened brand"],
+    ["secondary", "brand", 200],
+    ["secondary-foreground", "brand", fgStep(brandMap[200]?.hex, brandMap, 100, 900, fgMode)],
+    [null, null, "Muted"],
+    ["muted", "surface", 75],
+    ["muted-foreground", "surface", 700],
+    [null, null, "Accent"],
+    ["accent", "brand", 100],
+    ["accent-foreground", "brand", fgStep(brandMap[100]?.hex, brandMap, 50, 950, fgMode)],
+    [null, null, "Destructive"],
+    destLight,
+    destFgLight,
+    ["destructive-subtle", "error", 100],
+    ["destructive-subtle-foreground", "error", 950],
+    ["destructive-border", "error-surface", 300],
+    [null, null, "Border / Input / Ring"],
+    ["border", "surface", 300],
+    ["border-muted", "surface", 200],
+    ["input", "surface", 300],
+    ["ring", "surface", 400],
+    [null, null, "Sidebar"],
+    ["sidebar", "surface", 25],
+    ["sidebar-foreground", "surface", 975],
+    sbPrimLight,
+    sbPrimFgLight,
+    ["sidebar-accent", "brand", 100],
+    ["sidebar-accent-foreground", "brand", fgStep(brandMap[100]?.hex, brandMap, 50, 950, fgMode)],
+    ["sidebar-border", "surface", 300],
+    ["sidebar-ring", "surface", 400]
+  ]);
+  const dark = buildBlock(".dark", [
+    [null, null, "Base"],
+    ["background", "surface", 875],
+    ["foreground", "surface", 25],
+    [null, null, "Card"],
+    ["card", "surface", 825],
+    ["card-foreground", "surface", 25],
+    [null, null, "Popover"],
+    ["popover", "surface", 800],
+    ["popover-foreground", "surface", 25],
+    [null, null, "Primary"],
+    primaryDark,
+    primaryFgDark,
+    ...brandContrastWarnDark,
+    ["primary-subtle", "brand", 800],
+    ["primary-subtle-foreground", "brand", 50],
+    [null, null, "Secondary \u2014 softened brand"],
+    ["secondary", "brand", 800],
+    ["secondary-foreground", "brand", fgStep(brandMap[800]?.hex, brandMap, 100, 900, fgMode)],
+    [null, null, "Muted"],
+    ["muted", "surface", 850],
+    ["muted-foreground", "surface", 300],
+    [null, null, "Accent"],
+    ["accent", "brand", 800],
+    ["accent-foreground", "brand", fgStep(brandMap[800]?.hex, brandMap, 50, 950, fgMode)],
+    [null, null, "Destructive"],
+    destDark,
+    destFgDark,
+    ["destructive-subtle", "error", 800],
+    ["destructive-subtle-foreground", "error", 50],
+    ["destructive-border", "error-surface", 700],
+    [null, null, "Border / Input / Ring"],
+    ["border", "surface", 600],
+    ["border-muted", "surface", 700],
+    ["input", "surface", 700],
+    ["ring", "surface", 500],
+    [null, null, "Sidebar"],
+    ["sidebar", "surface", 875],
+    ["sidebar-foreground", "surface", 25],
+    sbPrimDark,
+    sbPrimFgDark,
+    ["sidebar-accent", "brand", 800],
+    ["sidebar-accent-foreground", "brand", fgStep(brandMap[800]?.hex, brandMap, 50, 950, fgMode)],
+    ["sidebar-border", "surface", 600],
+    ["sidebar-ring", "surface", 500]
+  ]);
+  let accentBlocks = "";
+  accentPalettes.forEach((entry) => {
+    const n = entry.cssName;
+    const aPin = !!entry.pin;
+    const aInv = !!entry.invert;
+    const aHex = entry.hex;
+    const aCss = aPin ? hexToCss(aHex) : null;
+    const aMap = palMap(entry.palette || []);
+    const aFgCss = aPin ? fgDirect(aHex, aMap, 50, 975, n, fgMode) : null;
+    const aInvHex = aPin && aInv ? invertHex(aHex) : null;
+    const aInvCss = aInvHex ? hexToCss(aInvHex) : null;
+    const aInvFgCss = aInvHex ? fgDirect(aInvHex, aMap, 50, 975, n, fgMode) : null;
+    const aLight = aPin ? [n, "#direct", aCss] : [n, n, 600];
+    const aFgL = aPin ? [`${n}-foreground`, "#direct", aFgCss] : [`${n}-foreground`, n, fgStep(aMap[600]?.hex, aMap, 50, 975, fgMode)];
+    const aDark = aPin ? aInvCss ? [n, "#direct", aInvCss] : [n, "#direct", aCss] : [n, n, 400];
+    const aFgD = aPin ? aInvFgCss ? [`${n}-foreground`, "#direct", aInvFgCss] : [`${n}-foreground`, "#direct", aFgCss] : [`${n}-foreground`, n, fgStep(aMap[400]?.hex, aMap, 50, 975, fgMode)];
+    const accentRoot = buildBlock(":root", [
+      [null, null, `${entry.name} \u2014 light`],
+      aLight,
+      aFgL,
+      [null, null, "Background / Card / Popover"],
+      [`${n}-background`, `${n}-surface`, 50],
+      [`${n}-background-foreground`, `${n}-surface`, 975],
+      [`${n}-card`, `${n}-surface`, 25],
+      [`${n}-card-foreground`, `${n}-surface`, 975],
+      [`${n}-popover`, `${n}-surface`, 25],
+      [`${n}-popover-foreground`, `${n}-surface`, 975],
+      [null, null, "Secondary"],
+      [`${n}-secondary`, n, 200],
+      [`${n}-secondary-foreground`, n, 900],
+      [null, null, "Muted / Subtle / Accent"],
+      [`${n}-muted`, `${n}-surface`, 75],
+      [`${n}-muted-foreground`, `${n}-surface`, 700],
+      [`${n}-accent`, n, 100],
+      [`${n}-accent-foreground`, n, 950],
+      [`${n}-subtle`, n, 100],
+      [`${n}-subtle-foreground`, n, 950],
+      [null, null, "Border / Input / Ring"],
+      [`${n}-border`, `${n}-surface`, 300],
+      [`${n}-border-muted`, `${n}-surface`, 200],
+      [`${n}-input`, `${n}-surface`, 300],
+      [`${n}-ring`, `${n}-surface`, 400]
+    ]);
+    const accentDark = buildBlock(".dark", [
+      [null, null, `${entry.name} \u2014 dark`],
+      aDark,
+      aFgD,
+      [null, null, "Background / Card / Popover"],
+      [`${n}-background`, `${n}-surface`, 875],
+      [`${n}-background-foreground`, `${n}-surface`, 25],
+      [`${n}-card`, `${n}-surface`, 825],
+      [`${n}-card-foreground`, `${n}-surface`, 25],
+      [`${n}-popover`, `${n}-surface`, 800],
+      [`${n}-popover-foreground`, `${n}-surface`, 25],
+      [null, null, "Secondary"],
+      [`${n}-secondary`, n, 800],
+      [`${n}-secondary-foreground`, n, 100],
+      [null, null, "Muted / Subtle / Accent"],
+      [`${n}-muted`, `${n}-surface`, 850],
+      [`${n}-muted-foreground`, `${n}-surface`, 300],
+      [`${n}-accent`, n, 800],
+      [`${n}-accent-foreground`, n, 50],
+      [`${n}-subtle`, n, 800],
+      [`${n}-subtle-foreground`, n, 50],
+      [null, null, "Border / Input / Ring"],
+      [`${n}-border`, `${n}-surface`, 700],
+      [`${n}-border-muted`, `${n}-surface`, 700],
+      [`${n}-input`, `${n}-surface`, 700],
+      [`${n}-ring`, `${n}-surface`, 500]
+    ]);
+    accentBlocks += `
+/* ${entry.name} Accent \u2014 semantic tokens */
+` + accentRoot + "\n" + accentDark;
+  });
+  const header2 = themeName ? `/* ${themeName} \u2014 Semantic Tokens (shadcn/ui compatible) */
+` : `/* Semantic Tokens \u2014 shadcn/ui compatible */
+`;
+  return header2 + root + "\n" + dark + accentBlocks;
+}
+function generateLlmBriefing(brandHex, effectiveBgHex, effectiveErrorHex, accentPalettes, chromaScale, mode, brandPin, errorPin, themeName, fgContrastMode) {
+  const pct = Math.round(chromaScale * 100);
+  const title = themeName || "Untitled Theme";
+  const fgLabel = fgContrastMode === "best" ? "Best Contrast (auto)" : fgContrastMode === "preferLight" ? "Prefer Light" : "Prefer Dark";
+  const colorRows = [
+    `| Brand | \`${brandHex}\` | \`--color-brand-*\` | Primary interactive color${brandPin ? " (pinned)" : ""} |`,
+    `| Surface | \`${effectiveBgHex}\` | \`--color-surface-*\` | Background/container tint at ${pct}% chroma |`,
+    `| Error | \`${effectiveErrorHex}\` | \`--color-error-*\` | Destructive/alert color${errorPin ? " (pinned)" : ""} |`,
+    `| Neutral | derived | \`--color-neutral-*\` | 0% chroma variant for high-contrast surfaces |`,
+    ...accentPalettes.map(
+      (a) => `| ${a.name} | \`${a.hex}\` | \`--color-${a.cssName}-*\` | Additional accent${a.pin ? " (pinned)" : ""} |`
+    )
+  ].join("\n");
+  const pinnedNote = brandPin || errorPin || accentPalettes.some((a) => a.pin) ? `
+> **Pinned** means the exact input hex is used for primary/destructive button colors instead of the generated palette step (brand-600/400 or error-600/400).
+` : "";
+  let pinnedContrastWarning = "";
+  if (brandPin) {
+    pinnedContrastWarning = `
+> \u26A0 **Contrast warning \u2014 pinned primary**: The pinned brand color (\`${brandHex}\`) may not have sufficient contrast (WCAG AA 4.5:1) against your surface backgrounds when used as a text color. **Do not use \`--primary\` for body text.** Use \`--foreground\` for general text. \`--primary-foreground\` is only for text on primary-colored backgrounds (e.g. buttons).
+`;
+  }
+  return `# ${title} \u2014 Theme Briefing
+
+All colors are generated in the **OKLCH** color space (perceptually uniform). Gamut mapping to sRGB is handled automatically \u2014 you never need to worry about out-of-gamut values.
+
+## Seed Colors
+
+| Role | Hex | CSS prefix | Notes |
+|------|-----|------------|-------|
+${colorRows}
+${pinnedNote}${pinnedContrastWarning}
+## Semantic Token Mapping
+
+| Token | Light | Dark | Usage |
+|-------|-------|------|-------|
+| \`--background\` | surface-50 | surface-875 | Page background |
+| \`--foreground\` | surface-975 | surface-25 | Primary text |
+| \`--card\` | surface-25 | surface-825 | Card backgrounds |
+| \`--popover\` | surface-25 | surface-800 | Popover/dropdown |
+| \`--primary\` | brand-600 | brand-400 | Primary buttons, links |
+| \`--primary-subtle\` | brand-100 | brand-800 | Tinted brand fills: callouts, selected items |
+| \`--secondary\` | brand-200 | brand-800 | Secondary buttons |
+| \`--muted\` | surface-75 | surface-850 | Muted backgrounds |
+| \`--accent\` | brand-100 | brand-800 | Interaction highlights (hover, selected) |
+| \`--destructive\` | error-600 | error-400 | Error/delete actions |
+| \`--destructive-subtle\` | error-100 | error-800 | Inline errors, alert backgrounds |
+| \`--destructive-border\` | error-surface-300 | error-surface-700 | Error borders |
+| \`--border\` | surface-300 | surface-600 | Default borders |
+| \`--border-muted\` | surface-200 | surface-700 | Subtle separators |
+| \`--input\` | surface-300 | surface-700 | Form-control borders (input, select, textarea) |
+| \`--ring\` | surface-400 | surface-500 | Focus rings |
+
+### Sidebar
+
+| Token | Light | Dark |
+|-------|-------|------|
+| \`--sidebar\` | surface-25 | surface-875 |
+| \`--sidebar-primary\` | brand-600 | brand-400 |
+| \`--sidebar-accent\` | brand-100 | brand-800 |
+| \`--sidebar-border\` | surface-300 | surface-600 |
+
+Every background token has a matching \`*-foreground\` counterpart. Always pair them.
+${accentPalettes.length > 0 ? `
+### Accent Scopes
+
+Each accent color provides a full semantic scope:
+${accentPalettes.map((a) => `- **${a.name}** (\`--${a.cssName}\`): \`-foreground\`, \`-background\`, \`-card\`, \`-popover\`, \`-secondary\`, \`-muted\`, \`-accent\`, \`-subtle\`, \`-border\`, \`-border-muted\`, \`-input\`, \`-ring\` \u2014 each with light/dark variants.`).join("\n")}
+` : ""}
+## How to Use
+
+1. **Use semantic tokens** (\`--primary\`, \`--background\`, etc.) in component code \u2014 never reference primitive step numbers directly.
+2. **Tailwind**: All tokens are available as Tailwind utilities (\`bg-primary\`, \`text-foreground\`, \`border-border\`, etc.).
+3. **Dark mode**: Add \`.dark\` to \`<html>\` or a container. All semantic tokens remap automatically.
+4. **Borders**: Default to \`--border-muted\` for subtle separation (dividers, table rows). Use \`--border\` for visible borders (cards, panels). Form controls (\`input\`, \`select\`, \`textarea\`) always use \`--input\` \u2014 never \`--border\`.
+5. **Shadows and radii**: see standby.design/shape for hue-matched shadow tokens and border-radius scales.
+6. **Border-radius**: Base \`--radius: 0.625rem\`. Derived sizes: \`--radius-sm\` (0.6\xD7) through \`--radius-4xl\` (2.6\xD7).
+
+## Primitive Scale Reference
+
+Each color uses an 18-step scale: **25, 50, 75, 100, 200\u2013800, 825, 850, 875, 900, 925, 950, 975**
+
+- **25\u2013100** \u2014 light surfaces (backgrounds, cards)
+- **200\u2013800** \u2014 core palette (buttons, text, accents)
+- **825\u2013875** \u2014 dark-mode surfaces
+- **900\u2013975** \u2014 high-contrast surfaces
+
+Two variants per color:
+- \`--color-{name}-{step}\` \u2014 full chroma (interactive elements)
+- \`--color-{name}-surface-{step}\` \u2014 ${pct}% chroma (backgrounds, containers)
+
+## Settings
+
+- **Palette mode**: ${mode === "balanced" ? "Balanced midpoint" : "Brand Centered"}
+- **Foreground contrast**: ${fgLabel}
+- **Surface chroma**: ${pct}%
+`;
+}
+
+// ../../system-react/src/lib/type-code-export.ts
+function generateCssExport(opts) {
+  const { levels, headingFont, bodyFont, monoFont, scaleLabel: scaleLabel2 } = opts;
+  const headingFF = fontFamily(headingFont);
+  const bodyFF = fontFamily(bodyFont);
+  const monoFF = fontFamily(monoFont);
+  const isGolden = scaleLabel2.includes("\u221A\u03C6");
+  let css = `/* Type Scale \u2014 ${scaleLabel2} */
+`;
+  if (isGolden) {
+    css += `/* Scales the perceived area of letterforms by the golden ratio. */
+`;
+  }
+  css += `:root {
+`;
+  css += `  /* Font Families */
+`;
+  css += `  --font-heading: ${headingFF};
+`;
+  css += `  --font-body: ${bodyFF};
+`;
+  css += `  --font-mono: ${monoFF};
+`;
+  css += `
+  /* Type Scale */
+`;
+  for (const l of levels) {
+    css += `  --text-${l.level}: ${l.clampValue};
+`;
+  }
+  css += `
+  /* Line Heights */
+`;
+  for (const l of levels) {
+    css += `  --leading-${l.level}: ${l.lineHeight};
+`;
+  }
+  css += `
+  /* Letter Spacing */
+`;
+  for (const l of levels) {
+    css += `  --tracking-${l.level}: ${l.letterSpacing}em;
+`;
+  }
+  if (opts.spacingTokens.length > 0) {
+    css += `
+  /* Spacing Scale */
+`;
+    for (const t of opts.spacingTokens) {
+      css += `  --space-${t.name}: ${t.rem}rem;
+`;
+    }
+  }
+  css += `}
+`;
+  return css;
+}
+function generateTailwindV4Export(opts) {
+  const { levels, headingFont, bodyFont, monoFont, scaleLabel: scaleLabel2 } = opts;
+  const headingFF = fontFamily(headingFont);
+  const bodyFF = fontFamily(bodyFont);
+  const monoFF = fontFamily(monoFont);
+  const isGolden = scaleLabel2.includes("\u221A\u03C6");
+  let css = `/* Type Scale \u2014 ${scaleLabel2} */
+`;
+  if (isGolden) {
+    css += `/* Scales the perceived area of letterforms by the golden ratio. */
+`;
+  }
+  css += `@theme {
+`;
+  css += `  --font-heading: ${headingFF};
+`;
+  css += `  --font-body: ${bodyFF};
+`;
+  css += `  --font-mono: ${monoFF};
+`;
+  css += `
+`;
+  for (const l of levels) {
+    css += `  --text-${l.level}: ${l.clampValue};
+`;
+  }
+  css += `
+`;
+  for (const l of levels) {
+    css += `  --leading-${l.level}: ${l.lineHeight};
+`;
+  }
+  css += `
+`;
+  for (const l of levels) {
+    css += `  --tracking-${l.level}: ${l.letterSpacing}em;
+`;
+  }
+  if (opts.spacingTokens.length > 0) {
+    css += `
+`;
+    for (const t of opts.spacingTokens) {
+      css += `  --space-${t.name}: ${t.rem}rem;
+`;
+    }
+  }
+  css += `}
+`;
+  return css;
+}
+function generateLlmBriefing2(opts) {
+  const { levels, spacingTokens, headingFont, bodyFont, monoFont, scaleLabel: scaleLabel2 } = opts;
+  const headingFF = fontFamily(headingFont);
+  const bodyFF = fontFamily(bodyFont);
+  const monoFF = fontFamily(monoFont);
+  let md = `# Type Scale \u2014 ${scaleLabel2}
+
+`;
+  md += `## Fonts
+
+`;
+  md += `- **Heading:** ${headingFF}
+`;
+  md += `- **Body:** ${bodyFF}
+`;
+  md += `- **Mono:** ${monoFF}
+`;
+  md += `
+## Type Scale
+
+`;
+  md += `| Level | Min | Max | clamp() |
+`;
+  md += `|-------|-----|-----|---------|
+`;
+  for (const l of levels) {
+    if (l.isFluid) {
+      md += `| ${l.label} | ${l.minRem}rem | ${l.maxRem}rem | \`${l.clampValue}\` |
+`;
+    } else {
+      md += `| ${l.label} | ${l.maxRem}rem | \u2014 | ${l.maxRem}rem |
+`;
+    }
+  }
+  md += `
+## Line Heights
+
+`;
+  md += `| Level | Value |
+`;
+  md += `|-------|-------|
+`;
+  for (const l of levels) {
+    md += `| ${l.label} | ${l.lineHeight} |
+`;
+  }
+  md += `
+## Letter Spacing
+
+`;
+  md += `| Level | Value |
+`;
+  md += `|-------|-------|
+`;
+  for (const l of levels) {
+    md += `| ${l.label} | ${l.letterSpacing}em |
+`;
+  }
+  if (spacingTokens.length > 0) {
+    md += `
+## Spacing Scale
+
+`;
+    md += `| Token | Value |
+`;
+    md += `|-------|-------|
+`;
+    for (const t of spacingTokens) {
+      md += `| --space-${t.name} | ${t.rem}rem (${t.px}px) |
+`;
+    }
+  }
+  md += `
+## Usage
+
+`;
+  md += `Use the CSS custom properties from the CSS or Tailwind export.
+`;
+  md += `Font sizes use \`clamp()\` for fluid scaling between 375px and 1920px viewport.
+`;
+  md += `Combine with color tokens from standby.design/color and shape tokens from standby.design/shape.
+`;
+  return md;
+}
+function generateFontEmbed(headingFont, bodyFont, monoFont) {
+  const slugs = [headingFont, bodyFont, monoFont].filter(Boolean);
+  const embed = buildFontshareEmbed(slugs);
+  if (!embed) return "<!-- No Fontshare fonts selected -->";
+  return `<!-- Fontshare Fonts -->
+${embed}`;
+}
+
+// ../core/src/shadows.ts
+function buildLevels(scale) {
+  return [
+    { name: "xs", factor: 1 / (scale * scale) },
+    { name: "sm", factor: 1 / scale },
+    { name: "md", factor: 1 },
+    { name: "lg", factor: scale },
+    { name: "xl", factor: scale * scale }
+  ];
+}
+function getShadowHue(bgHex, config) {
+  if (config.colorMode === "custom" && config.customColor) {
+    const [, , h2] = hexToOklch(config.customColor);
+    return { L: 0.05, C: 0.01, H: h2.toFixed(2) };
+  }
+  const [, , h] = hexToOklch(bgHex);
+  return { L: 0.05, C: 0.01, H: h.toFixed(2) };
+}
+function generateNormal(bgHex, isDark, config) {
+  const { H } = getShadowHue(bgHex, config);
+  const shadowL = isDark ? 0.02 : 0.05;
+  const shadowC = isDark ? 5e-3 : 0.01;
+  const alphaMultiplier = (isDark ? 1.4 : 0.7) * config.strength;
+  return buildLevels(config.scale).map(({ name, factor }) => {
+    const oY = factor;
+    const a1 = Math.min(0.7, 0.12 * factor * alphaMultiplier).toFixed(3);
+    const a2 = Math.min(0.5, 0.18 * factor * alphaMultiplier).toFixed(3);
+    const b1 = (factor * 0.6 * config.blurScale).toFixed(3);
+    const b2 = (factor * 2 * config.blurScale).toFixed(3);
+    const shadow = `0 ${(oY * 0.4).toFixed(3)}rem ${b1}rem oklch(${shadowL} ${shadowC} ${H} / ${a1}), 0 ${oY.toFixed(3)}rem ${b2}rem oklch(${shadowL} ${shadowC} ${H} / ${a2})`;
+    return { name, shadow };
+  });
+}
+function neumorphicColors(bgHex, isDark) {
+  const [bgL, bgC, bgH] = hexToOklch(bgHex);
+  const lightL = Math.min(1, bgL + (isDark ? 0.12 : 0.25));
+  const darkL = Math.max(0, bgL - (isDark ? 0.15 : 0.12));
+  return {
+    lightHex: oklchToHex(lightL, bgC * 0.3, bgH),
+    darkHex: oklchToHex(darkL, bgC * 0.3, bgH)
+  };
+}
+function generateNeumorphic(bgHex, isDark, config) {
+  const { lightHex, darkHex } = neumorphicColors(bgHex, isDark);
+  return buildLevels(config.scale).map(({ name, factor }) => {
+    const dist = (factor * 0.25).toFixed(2);
+    const blur = (factor * 0.5 * config.blurScale).toFixed(2);
+    const aLight = Math.min(1, 0.5 * factor * config.strength).toFixed(2);
+    const aDark = Math.min(1, 0.6 * factor * config.strength).toFixed(2);
+    const shadow = `-${dist}rem -${dist}rem ${blur}rem ${lightHex}${alphaHex(parseFloat(aLight))}, ${dist}rem ${dist}rem ${blur}rem ${darkHex}${alphaHex(parseFloat(aDark))}`;
+    return { name, shadow };
+  });
+}
+function generateFlat(bgHex, isDark, config) {
+  const [, , surfaceHue] = hexToOklch(bgHex);
+  const shadowL = isDark ? 0.08 : 0.15;
+  const shadowC = isDark ? 0.01 : 0.02;
+  const H = surfaceHue.toFixed(2);
+  const baseAlpha = (isDark ? 0.6 : 0.35) * config.strength;
+  return buildLevels(config.scale).map(({ name, factor }) => {
+    const offset = (factor * 0.25).toFixed(2);
+    const a = Math.min(1, baseAlpha * factor).toFixed(2);
+    const shadow = `0 ${offset}rem 0 oklch(${shadowL} ${shadowC} ${H} / ${a})`;
+    return { name, shadow };
+  });
+}
+function generateBrutalist(bgHex, isDark, config) {
+  const baseX = config.offsetX ?? 4;
+  const baseY = config.offsetY ?? 4;
+  const strokeWidth = config.borderWidth ?? 1;
+  let strokeL;
+  let strokeC;
+  let strokeH;
+  if (config.colorMode === "custom" && config.customColor) {
+    const [l, c, h] = hexToOklch(config.customColor);
+    strokeL = l;
+    strokeC = c;
+    strokeH = h.toFixed(2);
+  } else {
+    const [, , surfaceHue] = hexToOklch(bgHex);
+    strokeL = isDark ? 0.98 : 0.05;
+    strokeC = 5e-3;
+    strokeH = surfaceHue.toFixed(2);
+  }
+  const [bgL, bgC, bgHue] = hexToOklch(bgHex);
+  return buildLevels(config.scale).map(({ name, factor }) => {
+    const oX = (baseX * factor).toFixed(2);
+    const oY = (baseY * factor).toFixed(2);
+    const a = Math.min(1, config.strength).toFixed(3);
+    const shadow = `${oX}px ${oY}px 0 0 oklch(${bgL.toFixed(3)} ${bgC.toFixed(3)} ${bgHue.toFixed(2)}), ${oX}px ${oY}px 0 ${strokeWidth}px oklch(${strokeL} ${strokeC} ${strokeH} / ${a})`;
+    return { name, shadow };
+  });
+}
+function alphaHex(a) {
+  return Math.round(Math.min(1, Math.max(0, a)) * 255).toString(16).padStart(2, "0");
+}
+function generateShadows(bgHex, isDark, config) {
+  switch (config.type) {
+    case "neumorphic":
+      return generateNeumorphic(bgHex, isDark, config);
+    case "flat":
+      return generateFlat(bgHex, isDark, config);
+    case "brutalist":
+      return generateBrutalist(bgHex, isDark, config);
+    default:
+      return generateNormal(bgHex, isDark, config);
+  }
+}
+
+// ../../system-react/src/lib/shape-code-export.ts
+var SHAPE_DEFAULTS = {
+  shapeStyle: "paper",
+  shadowEnabled: true,
+  shadowType: "normal",
+  shadowStrength: 1,
+  shadowBlurScale: 1,
+  shadowScale: 1.272,
+  shadowColorMode: "auto",
+  shadowCustomColor: "#000000",
+  shadowOffsetX: 2,
+  shadowOffsetY: 4,
+  brutalistVariant: "outlined",
+  borderEnabled: true,
+  borderWidth: 1,
+  borderRadius: 8,
+  glassDepth: 0,
+  glassBlur: 0,
+  glassDispersion: 0,
+  ringWidth: 2,
+  ringOffset: 2,
+  separationMode: "shadow",
+  surfaceHex: "#335A7F"
+};
+function optsFromState(state, surfaceHex) {
+  return {
+    ...SHAPE_DEFAULTS,
+    ...state,
+    surfaceHex: surfaceHex ?? state?.shadowCustomColor ?? SHAPE_DEFAULTS.surfaceHex
+  };
+}
+function effectiveShadowType(opts) {
+  if (opts.shapeStyle === "neomorph") return "neumorphic";
+  if (opts.shapeStyle === "neobrutalism") return "brutalist";
+  return opts.shadowType;
+}
+function buildShadowConfig(opts) {
+  return {
+    type: effectiveShadowType(opts),
+    strength: opts.shadowStrength,
+    blurScale: opts.shadowBlurScale,
+    scale: opts.shadowScale,
+    colorMode: opts.shadowColorMode,
+    customColor: opts.shadowCustomColor,
+    offsetX: opts.shadowOffsetX,
+    offsetY: opts.shadowOffsetY,
+    borderWidth: opts.borderEnabled ? opts.borderWidth : 1
+  };
+}
+function deriveBgHex(surfaceHex, isDark) {
+  const [, , H] = hexToOklch(surfaceHex);
+  const C = 0.015;
+  return isDark ? oklchToHex(0.15, C, H) : oklchToHex(0.96, C * 0.3, H);
+}
+function radiusScale(base) {
+  return {
+    xs: base / 4,
+    sm: base / 2,
+    md: base,
+    lg: base * 1.5,
+    xl: base * 2
+  };
+}
+function pxToRem(px) {
+  return `${+(px / 16).toFixed(4)}rem`;
+}
+function shadowTypeLabel(t) {
+  return { normal: "Normal", neumorphic: "Neumorphic", flat: "Flat", brutalist: "Brutalist" }[t];
+}
+function scaleLabel(scale) {
+  return Math.abs(scale - 1.272) < 1e-3 ? "\u221A\u03C6" : scale.toFixed(3);
+}
+function generateShapeCss(opts) {
+  const config = buildShadowConfig(opts);
+  const radii = radiusScale(opts.borderRadius);
+  let css = `/* Shape Tokens \u2014 standby.design/shape */
+`;
+  css += `:root {
+`;
+  if (opts.shadowEnabled) {
+    const lightBg = deriveBgHex(opts.surfaceHex, false);
+    const lightShadows = generateShadows(lightBg, false, config);
+    css += `  /* Shadows \u2014 ${shadowTypeLabel(effectiveShadowType(opts))}, scale ${scaleLabel(opts.shadowScale)} */
+`;
+    for (const s of lightShadows) {
+      css += `  --shadow-${s.name}: ${s.shadow};
+`;
+    }
+  } else {
+    css += `  /* Shadows: disabled */
+`;
+  }
+  css += `
+  /* Border Radius */
+`;
+  for (const [name, px] of Object.entries(radii)) {
+    const varName = name === "md" ? "--radius" : `--radius-${name}`;
+    css += `  ${varName}: ${pxToRem(px)};
+`;
+  }
+  if (opts.borderEnabled && opts.borderWidth > 0) {
+    css += `
+  /* Border */
+`;
+    css += `  --border-width: ${opts.borderWidth}px;
+`;
+  }
+  css += `
+  /* Focus Ring */
+`;
+  css += `  --ring-width: ${opts.ringWidth}px;
+`;
+  css += `  --ring-offset: ${opts.ringOffset}px;
+`;
+  if (opts.shapeStyle === "glass") {
+    css += `
+  /* Liquid Glass (vaso) */
+`;
+    css += `  --glass-depth: ${opts.glassDepth};
+`;
+    css += `  --glass-blur: ${opts.glassBlur};
+`;
+    css += `  --glass-dispersion: ${opts.glassDispersion};
+`;
+  }
+  css += `}
+`;
+  if (opts.shadowEnabled) {
+    const darkBg = deriveBgHex(opts.surfaceHex, true);
+    const darkShadows = generateShadows(darkBg, true, config);
+    css += `
+.dark {
+`;
+    for (const s of darkShadows) {
+      css += `  --shadow-${s.name}: ${s.shadow};
+`;
+    }
+    css += `}
+`;
+  }
+  css += `
+/* Surface separation strategy: ${opts.separationMode} */
+`;
+  return css;
+}
+function generateShapeTailwind(opts) {
+  const config = buildShadowConfig(opts);
+  const radii = radiusScale(opts.borderRadius);
+  let css = `/* Shape Tokens \u2014 standby.design/shape */
+`;
+  css += `@theme {
+`;
+  for (const [name, px] of Object.entries(radii)) {
+    const varName = name === "md" ? "--radius" : `--radius-${name}`;
+    css += `  ${varName}: ${pxToRem(px)};
+`;
+  }
+  if (opts.borderEnabled && opts.borderWidth > 0) {
+    css += `
+  --border-width: ${opts.borderWidth}px;
+`;
+  }
+  css += `
+  --ring-width: ${opts.ringWidth}px;
+`;
+  css += `  --ring-offset: ${opts.ringOffset}px;
+`;
+  if (opts.shapeStyle === "glass") {
+    css += `
+  --glass-depth: ${opts.glassDepth};
+`;
+    css += `  --glass-blur: ${opts.glassBlur};
+`;
+    css += `  --glass-dispersion: ${opts.glassDispersion};
+`;
+  }
+  css += `}
+`;
+  if (opts.shadowEnabled) {
+    const lightBg = deriveBgHex(opts.surfaceHex, false);
+    const darkBg = deriveBgHex(opts.surfaceHex, true);
+    const lightShadows = generateShadows(lightBg, false, config);
+    const darkShadows = generateShadows(darkBg, true, config);
+    css += `
+/* Shadows \u2014 ${shadowTypeLabel(effectiveShadowType(opts))}, scale ${scaleLabel(opts.shadowScale)} */
+`;
+    css += `:root {
+`;
+    for (const s of lightShadows) {
+      css += `  --shadow-${s.name}: ${s.shadow};
+`;
+    }
+    css += `}
+`;
+    css += `.dark {
+`;
+    for (const s of darkShadows) {
+      css += `  --shadow-${s.name}: ${s.shadow};
+`;
+    }
+    css += `}
+`;
+  }
+  css += `
+/* Surface separation strategy: ${opts.separationMode} */
+`;
+  return css;
+}
+function generateLlmBriefing3(opts) {
+  const config = buildShadowConfig(opts);
+  const radii = radiusScale(opts.borderRadius);
+  let md = `# Shape Tokens \u2014 standby.design/shape
+
+`;
+  md += `## Shadows
+
+`;
+  if (opts.shadowEnabled) {
+    md += `- **Style:** ${shadowTypeLabel(effectiveShadowType(opts))}
+`;
+    md += `- **Scale:** ${scaleLabel(opts.shadowScale)} (5 levels: xs, sm, md, lg, xl)
+`;
+    md += `- **Strength:** ${opts.shadowStrength}
+`;
+    md += `- **Blur scale:** ${opts.shadowBlurScale}
+`;
+    md += `- **Color mode:** ${opts.shadowColorMode}${opts.shadowColorMode === "custom" ? ` (${opts.shadowCustomColor})` : ""}
+
+`;
+    const lightBg = deriveBgHex(opts.surfaceHex, false);
+    const darkBg = deriveBgHex(opts.surfaceHex, true);
+    const lightShadows = generateShadows(lightBg, false, config);
+    const darkShadows = generateShadows(darkBg, true, config);
+    md += `### Light mode
+
+`;
+    md += `| Level | box-shadow |
+|-------|------------|
+`;
+    for (const s of lightShadows) md += `| ${s.name} | \`${s.shadow}\` |
+`;
+    md += `
+### Dark mode
+
+`;
+    md += `| Level | box-shadow |
+|-------|------------|
+`;
+    for (const s of darkShadows) md += `| ${s.name} | \`${s.shadow}\` |
+`;
+  } else {
+    md += `Shadows are **disabled**.
+`;
+  }
+  md += `
+## Border Radius
+
+`;
+  md += `Base: ${opts.borderRadius}px
+
+`;
+  md += `| Token | Value |
+|-------|-------|
+`;
+  for (const [name, px] of Object.entries(radii)) {
+    const token = name === "md" ? "--radius" : `--radius-${name}`;
+    md += `| ${token} | ${pxToRem(px)} (${px}px) |
+`;
+  }
+  md += `
+## Border
+
+`;
+  if (opts.borderEnabled && opts.borderWidth > 0) {
+    md += `- **Width:** ${opts.borderWidth}px
+`;
+  } else {
+    md += `Borders are **disabled**.
+`;
+  }
+  md += `
+## Focus Ring
+
+`;
+  md += `- **Width:** ${opts.ringWidth}px
+`;
+  md += `- **Offset:** ${opts.ringOffset}px
+`;
+  md += `
+## Liquid Glass
+
+`;
+  if (opts.shapeStyle === "glass") {
+    md += `Uses the \`vaso\` library (liquid glass distortion effect).
+
+`;
+    md += `- **Depth:** ${opts.glassDepth} (displacement intensity)
+`;
+    md += `- **Blur:** ${opts.glassBlur} (backdrop blur amount)
+`;
+    md += `- **Dispersion:** ${opts.glassDispersion} (chromatic aberration)
+`;
+  } else {
+    md += `Liquid glass effect is **disabled**.
+`;
+  }
+  md += `
+## Surface Separation
+
+`;
+  md += `Strategy: **${opts.separationMode}**
+`;
+  const descriptions = {
+    shadow: "Surfaces are separated using box-shadow elevation.",
+    border: "Surfaces are separated using visible borders.",
+    contrast: "Surfaces are separated using background-color contrast.",
+    gap: "Surfaces are separated using whitespace (gap/padding).",
+    mixed: "Surfaces use a combination of shadow, border, and contrast."
+  };
+  md += `${descriptions[opts.separationMode]}
+`;
+  md += `
+## Usage
+
+`;
+  md += `Use the CSS custom properties from the CSS or Tailwind export.
+`;
+  md += `Shadows are mode-dependent \u2014 define both \`:root\` and \`.dark\` blocks.
+`;
+  md += `Combine with color tokens from standby.design/color and type tokens from standby.design/type.
+`;
+  return md;
+}
+
+// ../../system-react/src/lib/design-token-export.ts
+function generateDesignTokens(opts) {
+  const { levels, spacingTokens, headingFont, bodyFont, monoFont, headingWeight } = opts;
+  const headingFF = fontFamily(headingFont);
+  const bodyFF = fontFamily(bodyFont);
+  const monoFF = fontFamily(monoFont);
+  const tokens = {
+    font: {
+      heading: { $type: "fontFamily", $value: headingFF },
+      body: { $type: "fontFamily", $value: bodyFF },
+      mono: { $type: "fontFamily", $value: monoFF }
+    },
+    typography: {},
+    spacing: {}
+  };
+  const typo = tokens.typography;
+  for (const l of levels) {
+    typo[l.level] = {
+      $type: "typography",
+      $value: {
+        fontFamily: l.isHeading ? headingFF : bodyFF,
+        fontSize: l.clampValue,
+        fontWeight: l.isHeading ? headingWeight : 400,
+        lineHeight: l.lineHeight,
+        letterSpacing: `${l.letterSpacing}em`
+      }
+    };
+  }
+  const space = tokens.spacing;
+  for (const t of spacingTokens) {
+    space[t.name] = {
+      $type: "dimension",
+      $value: `${t.rem}rem`
+    };
+  }
+  return JSON.stringify(tokens, null, 2);
+}
+
+// ../core/src/space-code-export.ts
+var expandAspects = expandAndSortAspects;
+function generateSpaceCss(opts) {
+  const { spacingTokens, breakpoints, fluidMinVw, fluidMaxVw, containers, proseMaxCh, aspectRatios, includeReciprocals, ratioLabel } = opts;
+  const bps = sortBreakpoints(breakpoints);
+  const cts = sortContainers(containers);
+  const ars = expandAspects(aspectRatios, includeReciprocals);
+  let css = `/* Space \u2014 ${ratioLabel} */
+:root {
+`;
+  css += `  /* Spacing Scale */
+`;
+  for (const t of spacingTokens) {
+    css += `  --space-${t.name}: ${t.rem}rem;
+`;
+  }
+  css += `
+  /* Breakpoints */
+`;
+  for (const b of bps) {
+    css += `  --breakpoint-${b.name}: ${b.minPx}px;
+`;
+  }
+  css += `  --fluid-min-vw: ${fluidMinVw}px;
+`;
+  css += `  --fluid-max-vw: ${fluidMaxVw}px;
+`;
+  css += `
+  /* Containers */
+`;
+  for (const c of cts) {
+    css += `  --container-${c.name}: ${c.maxPx}px;
+`;
+  }
+  css += `  --prose-max: ${proseMaxCh}ch;
+`;
+  css += `
+  /* Aspect Ratios */
+`;
+  for (const a of ars) {
+    css += `  --aspect-${a.name}: ${formatAspect(a)};
+`;
+  }
+  css += `}
+`;
+  return css;
+}
+function generateSpaceTailwind(opts) {
+  const { spacingTokens, breakpoints, containers, aspectRatios, includeReciprocals, ratioLabel } = opts;
+  const bps = sortBreakpoints(breakpoints);
+  const cts = sortContainers(containers);
+  const ars = expandAspects(aspectRatios, includeReciprocals);
+  let css = `/* Space \u2014 ${ratioLabel} */
+`;
+  css += `/* Tailwind v4: --spacing-*, --breakpoint-*, --container-* are native theme keys. */
+`;
+  css += `@theme {
+`;
+  for (const t of spacingTokens) {
+    css += `  --spacing-${t.name}: ${t.rem}rem;
+`;
+  }
+  css += `
+`;
+  for (const b of bps) {
+    css += `  --breakpoint-${b.name}: ${b.minPx}px;
+`;
+  }
+  css += `
+`;
+  for (const c of cts) {
+    css += `  --container-${c.name}: ${c.maxPx}px;
+`;
+  }
+  css += `
+`;
+  for (const a of ars) {
+    css += `  --aspect-${a.name}: ${formatAspect(a)};
+`;
+  }
+  css += `}
+`;
+  return css;
+}
+function generateSpaceLlmBriefing(opts) {
+  const { spacingTokens, breakpoints, fluidMinVw, fluidMaxVw, containers, proseMaxCh, aspectRatios, includeReciprocals, ratioLabel } = opts;
+  const bps = sortBreakpoints(breakpoints);
+  const cts = sortContainers(containers);
+  const ars = expandAspects(aspectRatios, includeReciprocals);
+  let md = `# Spacing & Layout \u2014 ${ratioLabel}
+
+`;
+  md += `## Spacing Scale
+
+`;
+  md += `| Token | rem | px |
+`;
+  md += `|-------|-----|----|
+`;
+  for (const t of spacingTokens) {
+    md += `| --space-${t.name} | ${t.rem}rem | ${t.px}px |
+`;
+  }
+  md += `
+## Breakpoints
+
+`;
+  md += `| Name | Min Width |
+`;
+  md += `|------|-----------|
+`;
+  for (const b of bps) md += `| ${b.name} | ${b.minPx}px |
+`;
+  md += `
+Fluid viewport anchors: ${fluidMinVw}px (min) \u2192 ${fluidMaxVw}px (max).
+`;
+  md += `
+## Containers
+
+`;
+  md += `| Name | Max Width |
+`;
+  md += `|------|-----------|
+`;
+  for (const c of cts) md += `| ${c.name} | ${c.maxPx}px |
+`;
+  md += `
+Prose reading column: ${proseMaxCh}ch.
+`;
+  md += `
+## Aspect Ratios
+
+`;
+  md += `| Name | Ratio |
+`;
+  md += `|------|-------|
+`;
+  for (const a of ars) md += `| ${a.name} | ${formatAspect(a)} |
+`;
+  md += `
+## Usage
+
+`;
+  md += `Use the CSS custom properties from the CSS or Tailwind export.
+`;
+  md += `Spacing tokens follow a ${opts.ratioLabel} scale suitable for margins, padding, and gap values.
+`;
+  md += `Combine with color tokens from standby.design/color, type tokens from standby.design/type, and shape tokens from standby.design/shape.
+`;
+  if (includeReciprocals) {
+    md += `
+*Portrait variants (-portrait suffix) are included for non-square ratios.*
+`;
+  }
+  return md;
+}
+
+// src/tools-system.ts
+var ALL_SECTIONS = ["color", "type", "space", "shape", "symbol"];
+function getScaleLabel(typeState) {
+  if (typeState.scaleMode === "traditional") return "Traditional Scale";
+  const r = typeState.customRatio;
+  if (Math.abs(r - 1.272) < 1e-3) return "Custom Ratio (\u221A\u03C6 \u2248 1.272)";
+  return `Custom Ratio (${r})`;
+}
+function getSpaceRatioLabel(s) {
+  if (s.spacingMode === "geometric" && Math.abs(s.spacingRatio - 1.272) < 1e-3) {
+    return "\u221A\u03C6 Golden Ratio";
+  }
+  if (s.spacingMode === "geometric") {
+    return `Geometric \xD7${s.spacingRatio.toFixed(3)}`;
+  }
+  return "Harmonic multiples";
+}
+function symbolTokenLines(sym) {
+  const { set } = resolveIconSet(sym);
+  const tokens = computeIconTokens(sym.iconBaseSize, sym.iconScale, weightToStroke(set.strokeWeight), sym.snapTo4px);
+  return {
+    header: [
+      `/* Icon Tokens \u2014 standby.design/symbol */`,
+      `/* Recommended: ${set.name} (${set.id}) */`
+    ],
+    tokens: [
+      ...tokens.sizes.map((s) => `  --icon-${s.name}: ${s.rem}rem;`),
+      `  --icon-stroke: ${tokens.strokeWidth}px;`
+    ]
+  };
+}
+function generateSymbolCss(sym) {
+  const { header: header2, tokens } = symbolTokenLines(sym);
+  return [...header2, ":root {", ...tokens, "}"].join("\n");
+}
+function generateSymbolTailwind(sym) {
+  const { header: header2, tokens } = symbolTokenLines(sym);
+  return [...header2, "@theme {", ...tokens, "}"].join("\n");
+}
+function generateSymbolLlmBriefing(sym) {
+  const { set } = resolveIconSet(sym);
+  const tokens = computeIconTokens(sym.iconBaseSize, sym.iconScale, weightToStroke(set.strokeWeight), sym.snapTo4px);
+  return [
+    `# Icon System \u2014 standby.design/symbol`,
+    ``,
+    `**Recommended:** ${set.name} \u2014 ${set.description}`,
+    `- Install: \`npm install ${set.npmPackage}\``,
+    `- Style: ${set.style}, Weight: ${set.strokeWeight}, Corners: ${set.cornerStyle}`,
+    ``,
+    `| Token | Value |`,
+    `|-------|-------|`,
+    ...tokens.sizes.map((s) => `| --icon-${s.name} | ${s.rem}rem (${s.px}px) |`),
+    `| --icon-stroke | ${tokens.strokeWidth}px |`
+  ].join("\n");
+}
+function registerSystemTools(server2) {
+  server2.registerTool(
+    "get_design_system",
+    {
+      title: "Inspect design system",
+      description: "Decode a standby.design URL (or raw hash) and return an overview of the full design system: color palette, type scale, spacing & layout, shape tokens, and icons \u2014 plus per-tool edit links.",
+      inputSchema: {
+        url: z2.string().describe("A standby.design URL or raw unified hash (e.g. from a previous generate_* call or copied from the browser).")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    async (args) => {
+      const segs = parseInput(args.url);
+      if (!segs.c && !segs.t && !segs.s && !segs.y && !segs.p) {
+        return errorResult("No design-system configuration found in that URL/hash. Expected a unified hash like #c=...&t=...&s=...&y=...&p=...");
+      }
+      const colorState = colorStateFrom(segs);
+      const typeState = typeStateFrom(segs);
+      const shapeState = shapeStateFrom(segs);
+      const symbolState = symbolStateFrom(segs);
+      const spaceState = spaceStateFrom(segs);
+      const parts = [
+        `Design system: ${systemUrl(segs)}`,
+        "",
+        `Configured sections: ${["c", "t", "s", "y", "p"].filter((k) => segs[k]).map((k) => ({ c: "color", t: "type", s: "shape", y: "symbol", p: "space" })[k]).join(", ")} (missing sections shown with defaults)`,
+        "",
+        colorSummary(colorState, buildPalette(colorState)),
+        `Edit: ${toolUrl("color", segs)}`,
+        "",
+        typeSummary(typeState, buildScale(typeState)),
+        `Edit: ${toolUrl("type", segs)}`,
+        "",
+        spaceSummary(spaceState, buildSpacing(spaceState)),
+        `Edit: ${toolUrl("space", segs)}`,
+        "",
+        shapeSummary(shapeState),
+        `Edit: ${toolUrl("shape", segs)}`,
+        "",
+        symbolState ? symbolSummary(symbolState) : "## Icons \u2014 not configured (use generate_icon_tokens)",
+        symbolState ? `Edit: ${toolUrl("symbol", segs)}` : ""
+      ];
+      return textResult(parts.filter((p) => p !== "").join("\n").replace(/\n{3,}/g, "\n\n"));
+    }
+  );
+  server2.registerTool(
+    "export_design_system",
+    {
+      title: "Export design system code",
+      description: 'Generate the full token code for a design system URL in one format: "css" (CSS custom properties incl. semantic shadcn/ui-compatible tokens), "tailwind" (Tailwind v4 @theme), "design-tokens" (W3C DTCG JSON \u2014 typography & spacing), "llm-briefing" (Markdown brief for AI code generation), or "font-embed" (Fontshare <link> snippet). Optionally restrict to specific sections.',
+      inputSchema: {
+        url: z2.string().describe("A standby.design URL or raw unified hash."),
+        format: z2.enum(["css", "tailwind", "design-tokens", "llm-briefing", "font-embed"]).describe("Output format."),
+        sections: z2.array(z2.enum(["color", "type", "space", "shape", "symbol"])).optional().describe("Which sections to include. Default: all configured sections (symbol only when configured).")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    async (args) => {
+      const segs = parseInput(args.url);
+      const sections = args.sections ?? ALL_SECTIONS.filter((s) => s !== "symbol" || segs.y !== null);
+      const colorState = colorStateFrom(segs);
+      const typeState = typeStateFrom(segs);
+      const shapeState = shapeStateFrom(segs);
+      const symbolState = symbolStateFrom(segs) ?? (sections.includes("symbol") ? { ...DEFAULT_SYMBOL_STATE } : null);
+      const spaceState = spaceStateFrom(segs);
+      const palette = buildPalette(colorState);
+      const scale = buildScale(typeState);
+      const spacing = buildSpacing(spaceState);
+      const spaceOpts = {
+        spacingTokens: spacing,
+        breakpoints: spaceState.breakpoints,
+        fluidMinVw: spaceState.fluidMinVw,
+        fluidMaxVw: spaceState.fluidMaxVw,
+        containers: spaceState.containers,
+        proseMaxCh: spaceState.proseMaxCh,
+        aspectRatios: spaceState.aspectRatios,
+        includeReciprocals: spaceState.aspectIncludeReciprocals,
+        ratioLabel: getSpaceRatioLabel(spaceState)
+      };
+      const typeOpts = {
+        levels: scale,
+        spacingTokens: [],
+        headingFont: typeState.headingFont,
+        bodyFont: typeState.bodyFont,
+        monoFont: typeState.monoFont,
+        scaleLabel: getScaleLabel(typeState)
+      };
+      const colorCss = () => {
+        let css = generateSeedComment(colorState, palette.effectiveBgHex, palette.effectiveErrorHex);
+        css += generatePrimitivesOklch(
+          palette.brand,
+          palette.surface,
+          palette.error,
+          palette.errorSurface,
+          palette.neutralExtended,
+          palette.accentPalettes,
+          colorState.chromaScale,
+          colorState.bgAutoMatch ? null : colorState.bgColorHex,
+          colorState.themeName
+        );
+        css += "\n";
+        css += generateSemantic(
+          palette.accentPalettes,
+          palette.brand,
+          palette.error,
+          palette.errorSurface,
+          palette.surface,
+          colorState.brandPin,
+          colorState.brandPin ? colorState.brandHex : null,
+          colorState.brandInvert,
+          colorState.errorPin,
+          colorState.errorPin ? palette.effectiveErrorHex : null,
+          colorState.errorInvert,
+          colorState.fgContrastMode,
+          colorState.themeName
+        );
+        return css;
+      };
+      const has = (s) => sections.includes(s);
+      let output;
+      switch (args.format) {
+        case "css":
+          output = [
+            has("color") ? colorCss() : "",
+            has("type") ? generateCssExport(typeOpts) : "",
+            has("space") ? generateSpaceCss(spaceOpts) : "",
+            has("shape") ? generateShapeCss(optsFromState(shapeState, palette.effectiveBgHex)) : "",
+            has("symbol") && symbolState ? generateSymbolCss(symbolState) : ""
+          ].filter(Boolean).join("\n") || "/* No sections selected */";
+          break;
+        case "tailwind":
+          output = [
+            // Color primitives + semantic tokens are plain CSS variables and identical in both formats.
+            has("color") ? colorCss() : "",
+            has("type") ? generateTailwindV4Export(typeOpts) : "",
+            has("space") ? generateSpaceTailwind(spaceOpts) : "",
+            has("shape") ? generateShapeTailwind(optsFromState(shapeState, palette.effectiveBgHex)) : "",
+            has("symbol") && symbolState ? generateSymbolTailwind(symbolState) : ""
+          ].filter(Boolean).join("\n") || "/* No sections selected */";
+          break;
+        case "design-tokens":
+          output = generateDesignTokens({
+            levels: scale,
+            spacingTokens: spacing,
+            headingFont: typeState.headingFont,
+            bodyFont: typeState.bodyFont,
+            monoFont: typeState.monoFont,
+            headingWeight: typeState.headingWeight
+          });
+          output += '\n\n/* Note: the DTCG export covers typography & spacing (matching the web app). Use format "css" or "tailwind" for color and shape tokens. */';
+          break;
+        case "llm-briefing": {
+          const parts = [];
+          if (has("color")) {
+            parts.push(generateLlmBriefing(
+              colorState.brandHex,
+              palette.effectiveBgHex,
+              palette.effectiveErrorHex,
+              palette.accentPalettes,
+              colorState.chromaScale,
+              colorState.currentMode,
+              colorState.brandPin,
+              colorState.errorPin,
+              colorState.themeName,
+              colorState.fgContrastMode
+            ));
+          }
+          if (has("type")) parts.push(generateLlmBriefing2(typeOpts));
+          if (has("space")) parts.push(generateSpaceLlmBriefing(spaceOpts));
+          if (has("shape")) parts.push(generateLlmBriefing3(optsFromState(shapeState, palette.effectiveBgHex)));
+          if (has("symbol") && symbolState) parts.push(generateSymbolLlmBriefing(symbolState));
+          output = parts.join("\n---\n\n") || "<!-- No sections selected -->";
+          break;
+        }
+        case "font-embed":
+          output = generateFontEmbed(typeState.headingFont, typeState.bodyFont, typeState.monoFont) || "<!-- No fonts selected -->";
+          break;
+      }
+      return textResult(`Design system: ${systemUrl(segs)}
+
+${output}`);
+    }
+  );
+  server2.registerTool(
+    "list_fonts",
+    {
+      title: "List available fonts",
+      description: "List Fontshare font slugs usable in generate_type_scale (headingFont/bodyFont/monoFont), grouped by category. This is the bundled seed catalog \u2014 any valid Fontshare slug works even if not listed here.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    async () => {
+      void getCatalog();
+      const byCategory = fontsByCategory();
+      const lines = [];
+      for (const [category, fonts] of Object.entries(byCategory)) {
+        lines.push(`## ${category}`);
+        for (const f of fonts) lines.push(`- ${f.slug} \u2014 ${f.name}`);
+        lines.push("");
+      }
+      lines.push("Any other Fontshare slug (fontshare.com) is also accepted.");
+      return textResult(lines.join("\n"));
+    }
+  );
+}
+
+// src/index.ts
+var server = new McpServer(
+  { name: "standby-design", version: "0.1.0" },
+  {
+    instructions: [
+      "Tools for generating complete design systems with standby.design.",
+      "Typical flow: generate_color_palette \u2192 generate_type_scale \u2192 generate_shape_tokens / generate_icon_tokens / generate_space_tokens, passing the returned URL into each subsequent call so the sections accumulate. Every result includes a shareable standby.design/system URL the user can open to view and fine-tune the system visually.",
+      "Use export_design_system to get the full CSS / Tailwind v4 / W3C design tokens / LLM briefing for a URL, and get_design_system to inspect an existing URL.",
+      "All tools are pure and deterministic \u2014 no network access, no side effects."
+    ].join("\n")
+  }
+);
+registerGenerateTools(server);
+registerSystemTools(server);
+var transport = new StdioServerTransport();
+await server.connect(transport);
+console.error("standby-design MCP server running on stdio");