@kinetixui/cli 0.22.1 → 0.23.0

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
-import pc9 from "picocolors";
+import pc10 from "picocolors";
 
 // src/commands/add.ts
 import { existsSync as existsSync4 } from "fs";
@@ -648,8 +648,8 @@ async function parity(names, options) {
     return item;
   }) : components;
   const nameWidth = Math.max(9, ...rows.map((r) => r.name.length));
-  const header = `${"COMPONENT".padEnd(nameWidth)}  ${PLATFORMS.map((p) => PLATFORM_ABBR[p]).join("  ")}  STATUS`;
-  console.log(pc7.dim(header));
+  const header4 = `${"COMPONENT".padEnd(nameWidth)}  ${PLATFORMS.map((p) => PLATFORM_ABBR[p]).join("  ")}  STATUS`;
+  console.log(pc7.dim(header4));
   for (const item of rows) {
     const on = new Set(item.platforms ?? PLATFORMS);
     const marks = PLATFORMS.map((p) => on.has(p) ? pc7.green("\u2713 ") : pc7.dim("\u2014 "));
@@ -666,20 +666,275 @@ async function parity(names, options) {
   }
 }
 
-// src/commands/theme.ts
-import { existsSync as existsSync9 } from "fs";
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import path9 from "path";
+// src/commands/preset.ts
+import { writeFile as writeFile3 } from "fs/promises";
 import pc8 from "picocolors";
 
-// src/lib/color-math.ts
+// ../create-preset/src/index.ts
+var PRESET_VERSION = 1;
+var SUPPORTED_VERSIONS = [1];
+var NEUTRALS = ["kinetix", "neutral", "cool", "warm", "stone"];
+var RADII = ["square", "small", "default", "rounded", "soft"];
+var SURFACES = ["flat", "bordered", "soft", "elevated"];
+var CHART_PALETTES = ["kinetix", "brand", "categorical", "cool", "warm"];
+var ACCEPTED_TOKENS = [
+  "background",
+  "foreground",
+  "card",
+  "card-foreground",
+  "popover",
+  "popover-foreground",
+  "primary",
+  "primary-foreground",
+  "secondary",
+  "secondary-foreground",
+  "muted",
+  "muted-foreground",
+  "accent",
+  "accent-foreground",
+  "destructive",
+  "destructive-foreground",
+  "border",
+  "input",
+  "ring",
+  "action",
+  "action-foreground",
+  "link",
+  "focus",
+  "brand",
+  "brand-foreground"
+];
+var DEFAULT_BRAND = "#1d4ed8";
+var DEFAULT_PRESET = {
+  brand: DEFAULT_BRAND,
+  neutral: "kinetix",
+  radius: "default",
+  surface: "soft",
+  chartPalette: "kinetix",
+  manualOverrides: {}
+};
+var LIMITS = {
+  /** Longest code accepted, prefix included. A maximal legitimate preset is ~700 characters. */
+  code: 4096,
+  /** Longest decoded JSON. Base64 expands by 4/3, so this is the real guard. */
+  json: 4096,
+  /** A hex colour, at most. */
+  colour: 7,
+  /** More override entries than there are tokens means the payload is not one of ours. */
+  overrides: 64
+};
+var HEX2 = /^#[0-9a-f]{6}$/;
+var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var fail = (error) => ({ ok: false, error });
+var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function normalizeColour(value) {
+  const trimmed = value.trim().toLowerCase();
+  const hashed = trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
+  return HEX2.test(hashed) ? hashed : null;
+}
+function readEnum(value, allowed, field) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    return { code: "bad-field", field, message: `${field} must be one of: ${allowed.join(", ")}` };
+  }
+  return value;
+}
+function validate(raw) {
+  if (!isPlainObject(raw)) return fail({ code: "bad-json", message: "A preset must be a JSON object." });
+  const version = raw.v;
+  if (typeof version !== "number" || !Number.isInteger(version)) {
+    return fail({ code: "bad-json", message: "A preset must carry an integer version." });
+  }
+  if (!SUPPORTED_VERSIONS.includes(version)) {
+    return fail({
+      code: "unsupported-version",
+      version,
+      message: `This preset is version ${version}; this build reads version ${SUPPORTED_VERSIONS.join(", ")}. Update KinetixUI and try again.`
+    });
+  }
+  const config = { ...DEFAULT_PRESET, manualOverrides: {} };
+  if (raw.brand !== void 0) {
+    if (typeof raw.brand !== "string" || raw.brand.length > LIMITS.colour) {
+      return fail({ code: "bad-field", field: "brand", message: "brand must be a hex colour." });
+    }
+    const colour = normalizeColour(raw.brand);
+    if (!colour) return fail({ code: "bad-field", field: "brand", message: `"${raw.brand}" is not a six-digit hex colour.` });
+    config.brand = colour;
+  }
+  for (const [field, allowed] of [
+    ["neutral", NEUTRALS],
+    ["radius", RADII],
+    ["surface", SURFACES],
+    ["chartPalette", CHART_PALETTES]
+  ]) {
+    if (raw[field] === void 0) continue;
+    const value = readEnum(raw[field], allowed, field);
+    if (typeof value !== "string") return fail(value);
+    config[field] = value;
+  }
+  if (raw.manualOverrides !== void 0) {
+    if (!isPlainObject(raw.manualOverrides)) {
+      return fail({ code: "bad-field", field: "manualOverrides", message: "manualOverrides must be an object." });
+    }
+    const entries = Object.entries(raw.manualOverrides);
+    if (entries.length > LIMITS.overrides) {
+      return fail({ code: "bad-field", field: "manualOverrides", message: "Too many overrides." });
+    }
+    for (const [token, value] of entries) {
+      if (FORBIDDEN_KEYS.has(token)) {
+        return fail({ code: "bad-field", field: "manualOverrides", message: `"${token}" is not a theme colour.` });
+      }
+      if (!ACCEPTED_TOKENS.includes(token)) {
+        return fail({ code: "bad-field", field: "manualOverrides", message: `"${token}" is not a theme colour.` });
+      }
+      if (typeof value !== "string" || value.length > LIMITS.colour) {
+        return fail({ code: "bad-field", field: "manualOverrides", message: `${token} must be a hex colour.` });
+      }
+      const colour = normalizeColour(value);
+      if (!colour) {
+        return fail({ code: "bad-field", field: "manualOverrides", message: `${token}: "${value}" is not a six-digit hex colour.` });
+      }
+      config.manualOverrides[token] = colour;
+    }
+  }
+  return { ok: true, config };
+}
+function canonicalize(config) {
+  const envelope = { v: PRESET_VERSION };
+  const brand = normalizeColour(config.brand) ?? DEFAULT_BRAND;
+  if (brand !== DEFAULT_PRESET.brand) envelope.brand = brand;
+  if (config.neutral !== DEFAULT_PRESET.neutral) envelope.neutral = config.neutral;
+  if (config.radius !== DEFAULT_PRESET.radius) envelope.radius = config.radius;
+  if (config.surface !== DEFAULT_PRESET.surface) envelope.surface = config.surface;
+  if (config.chartPalette !== DEFAULT_PRESET.chartPalette) envelope.chartPalette = config.chartPalette;
+  const overrides = {};
+  for (const token of ACCEPTED_TOKENS) {
+    const value = config.manualOverrides[token];
+    if (!value) continue;
+    const colour = normalizeColour(value);
+    if (colour) overrides[token] = colour;
+  }
+  if (Object.keys(overrides).length > 0) envelope.manualOverrides = overrides;
+  return envelope;
+}
+function isDefaultPreset(config) {
+  const envelope = canonicalize(config);
+  return Object.keys(envelope).length === 1;
+}
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var REVERSE = new Map([...ALPHABET].map((c, i) => [c, i]));
+function toBase64Url(text) {
+  const bytes = [];
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code > 127) return null;
+    bytes.push(code);
+  }
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = bytes[i + 1];
+    const c = bytes[i + 2];
+    out += ALPHABET[a >> 2];
+    out += ALPHABET[(a & 3) << 4 | (b ?? 0) >> 4];
+    if (b === void 0) break;
+    out += ALPHABET[(b & 15) << 2 | (c ?? 0) >> 6];
+    if (c === void 0) break;
+    out += ALPHABET[c & 63];
+  }
+  return out;
+}
+function fromBase64Url(code) {
+  let out = "";
+  let buffer = 0;
+  let bits = 0;
+  for (const char of code) {
+    const value = REVERSE.get(char);
+    if (value === void 0) return null;
+    buffer = buffer << 6 | value;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      const byte = buffer >> bits & 255;
+      if (byte > 127) return null;
+      out += String.fromCharCode(byte);
+    }
+  }
+  return out;
+}
+var PRESET_PREFIX = "KX";
+function encodePreset(config) {
+  const payload = toBase64Url(JSON.stringify(canonicalize(config)));
+  if (payload === null) throw new Error("Preset contains a value that cannot be encoded.");
+  return `${PRESET_PREFIX}${PRESET_VERSION}_${payload}`;
+}
+function decodePreset(input) {
+  const code = extractCode(input);
+  if (!code) return fail({ code: "empty", message: "No preset code found." });
+  if (code.length > LIMITS.code) return fail({ code: "too-long", message: "That preset code is too long to be one of ours." });
+  const match = /^KX(\d+)_(.*)$/s.exec(code);
+  if (!match) {
+    return fail({ code: "bad-prefix", message: "A preset code starts with KX1_." });
+  }
+  const version = Number(match[1]);
+  if (!SUPPORTED_VERSIONS.includes(version)) {
+    return fail({
+      code: "unsupported-version",
+      version,
+      message: `This preset is version ${version}; this build reads version ${SUPPORTED_VERSIONS.join(", ")}. Update KinetixUI and try again.`
+    });
+  }
+  const json = fromBase64Url(match[2] ?? "");
+  if (json === null) return fail({ code: "bad-encoding", message: "That preset code is not valid base64url." });
+  if (json.length > LIMITS.json) return fail({ code: "too-long", message: "That preset is larger than any real one." });
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return fail({ code: "bad-json", message: "That preset code does not contain a readable preset." });
+  }
+  if (isPlainObject(parsed) && parsed.v === void 0) parsed.v = version;
+  const result = validate(parsed);
+  return result.ok ? { ok: true, config: migrate(result.config, version) } : result;
+}
+function migrate(config, from) {
+  switch (from) {
+    case 1:
+      return config;
+    default:
+      return config;
+  }
+}
+function extractCode(input) {
+  const text = input.trim();
+  if (!text) return null;
+  if (text.length > LIMITS.code * 2) return null;
+  if (/^https?:\/\//i.test(text)) {
+    try {
+      const url = new URL(text);
+      const values = url.searchParams.getAll(PRESET_PARAM);
+      const first = values[0];
+      return first === void 0 ? null : first.trim();
+    } catch {
+      return null;
+    }
+  }
+  return text;
+}
+var PRESET_PARAM = "preset";
+function presetUrl(config, origin) {
+  return `${origin.replace(/\/$/, "")}/create?${PRESET_PARAM}=${encodePreset(config)}`;
+}
+
+// ../create-theme/src/color-math.ts
 function hexToRgb(hex) {
   const h = hex.replace("#", "");
   const n = parseInt(h.length === 3 ? h.replace(/(.)/g, "$1$1") : h, 16);
   return [n >> 16 & 255, n >> 8 & 255, n & 255];
 }
 function rgbToHsl(r, g, b) {
-  r /= 255, g /= 255, b /= 255;
+  r /= 255;
+  g /= 255;
+  b /= 255;
   const max = Math.max(r, g, b), min = Math.min(r, g, b);
   let h = 0, s = 0;
   const l = (max + min) / 2;
@@ -705,18 +960,46 @@ function hexToHslChannels(hex) {
   const [h, s, l] = rgbToHsl(...hexToRgb(hex));
   return `${h} ${s}% ${l}%`;
 }
-function relLuminance([r, g, b]) {
-  const [cr, cg, cb] = [r, g, b].map((v) => {
-    const s = v / 255;
-    return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
-  });
-  return 0.2126 * cr + 0.7152 * cg + 0.0722 * cb;
+function relLuminanceNormalized([r, g, b]) {
+  const linear = (s) => s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+  return 0.2126 * linear(r) + 0.7152 * linear(g) + 0.0722 * linear(b);
 }
-function contrastRatio(hexA, hexB) {
-  const la = relLuminance(hexToRgb(hexA)) + 0.05;
-  const lb = relLuminance(hexToRgb(hexB)) + 0.05;
+var normalize = ([r, g, b]) => [r / 255, g / 255, b / 255];
+function contrastOfNormalized(a, b) {
+  const la = relLuminanceNormalized(a) + 0.05;
+  const lb = relLuminanceNormalized(b) + 0.05;
   return la > lb ? la / lb : lb / la;
 }
+function contrastRatio(hexA, hexB) {
+  return contrastOfNormalized(normalize(hexToRgb(hexA)), normalize(hexToRgb(hexB)));
+}
+function hslChannelsToHex(channels) {
+  const [h = 0, s = 0, l = 0] = channels.trim().split(/\s+/).map((v) => parseFloat(v));
+  const S = s / 100;
+  const L = l / 100;
+  const c = (1 - Math.abs(2 * L - 1)) * S;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = L - c / 2;
+  const sector = Math.floor((h % 360 + 360) % 360 / 60);
+  const rgb = [
+    [c, x, 0],
+    [x, c, 0],
+    [0, c, x],
+    [0, x, c],
+    [x, 0, c],
+    [c, 0, x]
+  ][sector];
+  return `#${rgb.map((v) => Math.round((v + m) * 255).toString(16).padStart(2, "0")).join("")}`;
+}
+function swiftUiChannels(hex) {
+  return hexToRgb(hex).map((v) => Number((v / 255).toFixed(3)));
+}
+function guaranteedContrast(hexA, hexB) {
+  const exact = contrastRatio(hexA, hexB);
+  const asCss = contrastRatio(hslChannelsToHex(hexToHslChannels(hexA)), hslChannelsToHex(hexToHslChannels(hexB)));
+  const asSwift = contrastOfNormalized(swiftUiChannels(hexA), swiftUiChannels(hexB));
+  return Math.min(exact, asCss, asSwift);
+}
 function bestTextHex(bgHex) {
   return contrastRatio(bgHex, "#ffffff") >= contrastRatio(bgHex, "#000000") ? "#ffffff" : "#000000";
 }
@@ -728,8 +1011,1672 @@ function normalizeHex(v) {
   return `#${t.toLowerCase()}`;
 }
 
+// ../create-theme/src/oklch.ts
+var clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+var wrapHue = (h) => h >= 0 && h < 360 ? h : (h % 360 + 360) % 360;
+var MAX_CHROMA = 0.37;
+var toLinear = (v) => v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+var toGamma = (v) => v <= 31308e-7 ? v * 12.92 : 1.055 * v ** (1 / 2.4) - 0.055;
+function srgbToOklab([r, g, b]) {
+  const lr = toLinear(r / 255);
+  const lg = toLinear(g / 255);
+  const lb = toLinear(b / 255);
+  const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  return {
+    L: 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    a: 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    b: 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s
+  };
+}
+function oklabToSrgbRaw({ L, a, b }) {
+  const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+  const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+  const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
+  return [
+    toGamma(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s) * 255,
+    toGamma(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s) * 255,
+    toGamma(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s) * 255
+  ];
+}
+function oklabToOklch({ L, a, b }) {
+  const c = Math.sqrt(a * a + b * b);
+  if (c < 1e-6) return { l: L, c: 0, h: 0 };
+  return { l: L, c, h: (Math.atan2(b, a) * 180 / Math.PI + 360) % 360 };
+}
+function oklchToOklab({ l, c, h }) {
+  const rad = h * Math.PI / 180;
+  return { L: l, a: c * Math.cos(rad), b: c * Math.sin(rad) };
+}
+var EPS = 0.5 / 255;
+var fitsSrgb = (rgb) => rgb.every((v) => v >= -EPS * 255 && v <= 255 + EPS * 255);
+function gamutMapOklch(colour) {
+  const h = wrapHue(colour.h);
+  const l = clamp(colour.l, 0, 1);
+  const c = Math.max(0, colour.c);
+  if (fitsSrgb(oklabToSrgbRaw(oklchToOklab({ l, c, h })))) return { l, c, h };
+  let lo = 0;
+  let hi = c;
+  for (let i = 0; i < 24; i++) {
+    const mid = (lo + hi) / 2;
+    if (fitsSrgb(oklabToSrgbRaw(oklchToOklab({ l, c: mid, h })))) lo = mid;
+    else hi = mid;
+  }
+  return { l, c: lo, h };
+}
+function rgbToHex([r, g, b]) {
+  const ch = (v) => Math.round(clamp(v, 0, 255)).toString(16).padStart(2, "0");
+  return `#${ch(r)}${ch(g)}${ch(b)}`;
+}
+function hexToOklch(hex) {
+  if (!isHex(hex)) return null;
+  return oklabToOklch(srgbToOklab(hexToRgb(normalizeHex(hex))));
+}
+function oklchToHex(colour) {
+  return rgbToHex(oklabToSrgbRaw(oklchToOklab(gamutMapOklch(colour))));
+}
+function adjust(colour, { dl = 0, dc = 0, dh = 0 }) {
+  return gamutMapOklch({
+    l: clamp(colour.l + dl, 0, 1),
+    c: Math.max(0, colour.c + dc),
+    h: wrapHue(colour.h + dh)
+  });
+}
+
+// ../tokens/dist/web/tokens.js
+var tokens = {
+  "color": {
+    "azure": {
+      "0": "#f7faff",
+      "50": "#eff6ff",
+      "100": "#dbeafe",
+      "150": "#cde1fd",
+      "200": "#bfdbfe",
+      "300": "#93c5fd",
+      "400": "#60a5fa",
+      "500": "#3b82f6",
+      "600": "#2563eb",
+      "700": "#1d4ed8",
+      "800": "#1e40af",
+      "850": "#1b3897",
+      "900": "#1e3a8a",
+      "950": "#172554",
+      "1000": "#0f172a"
+    },
+    "blue": {
+      "0": "#f6fbff",
+      "50": "#f0f7ff",
+      "100": "#92b2c8",
+      "150": "#83a4b9",
+      "200": "#7495ab",
+      "300": "#57778d",
+      "400": "#395a70",
+      "500": "#1b3c53",
+      "600": "#163042",
+      "700": "#102432",
+      "800": "#0b1821",
+      "850": "#081219",
+      "900": "#050c11",
+      "950": "#030608",
+      "1000": "#000000"
+    },
+    "green": {
+      "0": "#ffffff",
+      "50": "#f1f3f1",
+      "100": "#e3e7e3",
+      "150": "#d5dbd5",
+      "200": "#c7cfc7",
+      "300": "#acb8ab",
+      "400": "#90a08f",
+      "500": "#748873",
+      "600": "#5d6d5c",
+      "700": "#465245",
+      "800": "#2e362e",
+      "850": "#232923",
+      "900": "#171b17",
+      "950": "#0c0e0c",
+      "1000": "#000000"
+    },
+    "taupe": {
+      "0": "#ffffff",
+      "50": "#fbf9f8",
+      "100": "#f6f3f0",
+      "150": "#f2ece9",
+      "200": "#ede6e2",
+      "300": "#e4dad3",
+      "400": "#dbcdc5",
+      "500": "#d2c1b6",
+      "600": "#b4a499",
+      "700": "#96867c",
+      "800": "#78695f",
+      "850": "#695a51",
+      "900": "#5a4b42",
+      "950": "#4b3d34",
+      "1000": "#3c2e25"
+    },
+    "cream": {
+      "0": "#ffffff",
+      "50": "#fefefd",
+      "100": "#fefdfc",
+      "150": "#fdfbfa",
+      "200": "#fdfaf9",
+      "300": "#fbf8f5",
+      "400": "#faf5f2",
+      "500": "#f9f3ef",
+      "600": "#e3d4ca",
+      "700": "#cdb5a4",
+      "800": "#b8957f",
+      "850": "#ad866c",
+      "900": "#a27659",
+      "950": "#976747",
+      "1000": "#8c5734"
+    },
+    "amber": {
+      "0": "#ffffff",
+      "50": "#fff8ee",
+      "100": "#fff2dd",
+      "150": "#ffebcb",
+      "200": "#ffe4ba",
+      "300": "#ffd798",
+      "400": "#ffc975",
+      "500": "#ffbc53",
+      "600": "#d49c42",
+      "700": "#aa7b32",
+      "800": "#7f5b21",
+      "850": "#6a4b19",
+      "900": "#553a11",
+      "950": "#3f2a08",
+      "1000": "#2a1a00"
+    },
+    "red": {
+      "0": "#fff9f9",
+      "50": "#f9e1e1",
+      "100": "#f4c9c9",
+      "150": "#eeb1b1",
+      "200": "#e89999",
+      "300": "#dd6a6a",
+      "400": "#d13a3a",
+      "500": "#c60a0a",
+      "600": "#9e0808",
+      "700": "#770606",
+      "800": "#4f0404",
+      "850": "#3b0303",
+      "900": "#280202",
+      "950": "#140101",
+      "1000": "#000000"
+    },
+    "neutral": {
+      "0": "#ffffff",
+      "50": "#fafafa",
+      "100": "#f6f6f6",
+      "200": "#ededed",
+      "300": "#e0e0e0",
+      "400": "#c2c2c2",
+      "500": "#9e9e9e",
+      "600": "#6d6d6d",
+      "700": "#4f4f4f",
+      "800": "#333333",
+      "900": "#1f1f1f",
+      "1000": "#000000"
+    },
+    "static": {
+      "white": "#ffffff",
+      "black": "#000000"
+    },
+    "background": "#ffffff",
+    "foreground": "#050c11",
+    "card": "#ffffff",
+    "card-foreground": "#050c11",
+    "popover": "#ffffff",
+    "popover-foreground": "#050c11",
+    "primary": "#1d4ed8",
+    "primary-foreground": "#f0f7ff",
+    "secondary": "#c7cfc7",
+    "secondary-foreground": "#465245",
+    "muted": "#f6f6f6",
+    "muted-foreground": "#6d6d6d",
+    "accent": "#f0f7ff",
+    "accent-foreground": "#1d4ed8",
+    "destructive": "#c60a0a",
+    "destructive-foreground": "#fef3f2",
+    "success": "#5d6d5c",
+    "success-foreground": "#f1f3f1",
+    "warning": "#7f5b21",
+    "warning-foreground": "#fff8eb",
+    "border": "#92b2c8",
+    "input": "#92b2c8",
+    "ring": "#1d4ed8",
+    "semantic": {
+      "error": "#ec5047",
+      "on-error": "#fef3f2",
+      "error-container": "#fef3f2",
+      "on-error-container": "#ec5047",
+      "warning-container": "#fff8eb",
+      "on-warning-container": "#f97907",
+      "success-container": "#f1f3f1",
+      "on-success-container": "#465245",
+      "warning": "#f97907",
+      "info-container": "#f0f7ff",
+      "on-info-container": "#395a70"
+    },
+    "chart-1": "#1b3c53",
+    "chart-2": "#748873",
+    "chart-3": "#ffbc53",
+    "chart-4": "#d13a3a",
+    "chart-5": "#b4a499",
+    "chart-6": "#57778d",
+    "chart-7": "#9e0808",
+    "chart-8": "#465245",
+    "sidebar": "#fafafa",
+    "sidebar-foreground": "#050c11",
+    "sidebar-primary": "#1d4ed8",
+    "sidebar-primary-foreground": "#f0f7ff",
+    "sidebar-accent": "#f0f7ff",
+    "sidebar-accent-foreground": "#1d4ed8",
+    "sidebar-border": "#e0e0e0",
+    "sidebar-ring": "#1d4ed8",
+    "tertiary": "#b0b0b0",
+    "tertiary-foreground": "#f0f7ff",
+    "info": "#57778d",
+    "info-foreground": "#f0f7ff",
+    "brand": "#1b3c53",
+    "brand-foreground": "#f0f7ff",
+    "action": "#1d4ed8",
+    "action-foreground": "#f0f7ff",
+    "action-hover": "#3460dc",
+    "action-pressed": "#3f69de",
+    "focus": "#1d4ed8",
+    "link": "#1d4ed8"
+  },
+  "spacing": {
+    "0": "0",
+    "1": "4px",
+    "2": "8px",
+    "3": "12px",
+    "4": "16px",
+    "5": "20px",
+    "6": "24px",
+    "7": "28px",
+    "8": "32px",
+    "10": "40px",
+    "12": "48px",
+    "16": "64px",
+    "20": "80px",
+    "24": "96px",
+    "32": "128px"
+  },
+  "radius": {
+    "none": "0",
+    "sm": "4px",
+    "md": "8px",
+    "lg": "12px",
+    "xl": "16px",
+    "xxl": "24px",
+    "full": "9999px",
+    "field": "4px",
+    "control": "8px",
+    "container": "12px",
+    "surface": "16px"
+  },
+  "borderWidth": {
+    "default": "1px",
+    "focus": "2px"
+  },
+  "interaction": {
+    "target": {
+      "minimum": "44px",
+      "default": "40px"
+    },
+    "focus": {
+      "width": "1px",
+      "offset": "2px"
+    },
+    "press": {
+      "opacity": 0.8
+    },
+    "drag": {
+      "threshold": 4
+    }
+  },
+  "duration": {
+    "instant": "100ms",
+    "fast": "200ms",
+    "base": "300ms",
+    "slow": "500ms",
+    "slower": "1000ms"
+  },
+  "easing": {
+    "linear": [
+      0,
+      0,
+      1,
+      1
+    ],
+    "standard": [
+      0.4,
+      0,
+      0.2,
+      1
+    ],
+    "enter": [
+      0,
+      0,
+      0.2,
+      1
+    ],
+    "exit": [
+      0.4,
+      0,
+      1,
+      1
+    ],
+    "emphasized": [
+      0.2,
+      0,
+      0,
+      1
+    ]
+  },
+  "opacity": {
+    "hidden": 0,
+    "disabled": 0.5,
+    "muted": 0.7,
+    "visible": 1
+  },
+  "font": {
+    "family": {
+      "sans": "Montserrat, ui-sans-serif, system-ui, sans-serif"
+    },
+    "weight": {
+      "regular": "400",
+      "medium": "500",
+      "semibold": "600"
+    }
+  },
+  "fontSize": {
+    "display-lg": "57px",
+    "display-md": "45px",
+    "display-sm": "36px",
+    "headline-lg": "32px",
+    "headline-md": "28px",
+    "headline-sm": "24px",
+    "title-lg": "22px",
+    "title-md": "16px",
+    "title-sm": "14px",
+    "title-dialog": "18px",
+    "label-lg": "14px",
+    "label-md": "12px",
+    "label-sm": "11px",
+    "body-lg": "16px",
+    "body-md": "14px",
+    "body-sm": "12px"
+  },
+  "lineHeight": {
+    "display-lg": "64px",
+    "display-md": "52px",
+    "display-sm": "44px",
+    "headline-lg": "40px",
+    "headline-md": "36px",
+    "headline-sm": "32px",
+    "title-lg": "28px",
+    "title-md": "24px",
+    "title-sm": "20px",
+    "title-dialog": "24px",
+    "label-lg": "20px",
+    "label-md": "16px",
+    "label-sm": "16px",
+    "body-lg": "24px",
+    "body-md": "20px",
+    "body-sm": "16px"
+  },
+  "letterSpacing": {
+    "tighter": "-0.25px",
+    "normal": "0",
+    "wide-1": "0.1px",
+    "wide-15": "0.15px",
+    "wide-25": "0.25px",
+    "wide-5": "0.5px"
+  },
+  "zIndex": {
+    "base": 0,
+    "raised": 1,
+    "docked": 10,
+    "focus": 20,
+    "sticky": 40,
+    "overlay": 50
+  },
+  "shadow": {
+    "sm": [
+      {
+        "color": "#0000000d",
+        "offsetX": "0",
+        "offsetY": "1",
+        "blur": "2",
+        "spread": "0"
+      }
+    ],
+    "md": [
+      {
+        "color": "#0000001f",
+        "offsetX": "0",
+        "offsetY": "1",
+        "blur": "1",
+        "spread": "0"
+      },
+      {
+        "color": "#676e7614",
+        "offsetX": "0",
+        "offsetY": "2",
+        "blur": "5",
+        "spread": "0"
+      }
+    ],
+    "lg": [
+      {
+        "color": "#00000012",
+        "offsetX": "0",
+        "offsetY": "4",
+        "blur": "6",
+        "spread": "-1"
+      },
+      {
+        "color": "#0000000f",
+        "offsetX": "0",
+        "offsetY": "2",
+        "blur": "4",
+        "spread": "-2"
+      }
+    ],
+    "xl": [
+      {
+        "color": "#0000001f",
+        "offsetX": "0",
+        "offsetY": "4",
+        "blur": "24",
+        "spread": "0"
+      }
+    ],
+    "focus": [
+      {
+        "color": "#1d4ed8",
+        "offsetX": "0",
+        "offsetY": "0",
+        "blur": "0",
+        "spread": "1px"
+      },
+      {
+        "color": "#1d4ed833",
+        "offsetX": "0",
+        "offsetY": "0",
+        "blur": "0",
+        "spread": "4"
+      }
+    ],
+    "focus-destructive": [
+      {
+        "color": "#ec5047",
+        "offsetX": "0",
+        "offsetY": "0",
+        "blur": "0",
+        "spread": "1px"
+      },
+      {
+        "color": "#ec504733",
+        "offsetX": "0",
+        "offsetY": "0",
+        "blur": "0",
+        "spread": "4"
+      }
+    ],
+    "focus-success": [
+      {
+        "color": "#5d6d5c",
+        "offsetX": "0",
+        "offsetY": "0",
+        "blur": "0",
+        "spread": "1px"
+      },
+      {
+        "color": "#5d6d5c33",
+        "offsetX": "0",
+        "offsetY": "0",
+        "blur": "0",
+        "spread": "4"
+      }
+    ],
+    "focus-warning": [
+      {
+        "color": "#7f5b21",
+        "offsetX": "0",
+        "offsetY": "0",
+        "blur": "0",
+        "spread": "1px"
+      },
+      {
+        "color": "#7f5b2133",
+        "offsetX": "0",
+        "offsetY": "0",
+        "blur": "0",
+        "spread": "4"
+      }
+    ]
+  },
+  "text": {
+    "display-lg": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "500",
+      "fontSize": "57px",
+      "lineHeight": "64px",
+      "letterSpacing": "-0.25px"
+    },
+    "display-md": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "500",
+      "fontSize": "45px",
+      "lineHeight": "52px",
+      "letterSpacing": "0"
+    },
+    "display-sm": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "400",
+      "fontSize": "36px",
+      "lineHeight": "44px",
+      "letterSpacing": "0"
+    },
+    "headline-lg": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "600",
+      "fontSize": "32px",
+      "lineHeight": "40px",
+      "letterSpacing": "0"
+    },
+    "headline-md": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "400",
+      "fontSize": "28px",
+      "lineHeight": "36px",
+      "letterSpacing": "0"
+    },
+    "headline-sm": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "400",
+      "fontSize": "24px",
+      "lineHeight": "32px",
+      "letterSpacing": "0"
+    },
+    "title-lg": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "400",
+      "fontSize": "22px",
+      "lineHeight": "28px",
+      "letterSpacing": "0"
+    },
+    "title-md": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "500",
+      "fontSize": "16px",
+      "lineHeight": "24px",
+      "letterSpacing": "0.15px"
+    },
+    "title-sm": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "500",
+      "fontSize": "14px",
+      "lineHeight": "20px",
+      "letterSpacing": "0.1px"
+    },
+    "title-dialog": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "600",
+      "fontSize": "18px",
+      "lineHeight": "24px",
+      "letterSpacing": "0"
+    },
+    "label-lg": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "500",
+      "fontSize": "14px",
+      "lineHeight": "20px",
+      "letterSpacing": "0.1px"
+    },
+    "label-md": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "500",
+      "fontSize": "12px",
+      "lineHeight": "16px",
+      "letterSpacing": "0.5px"
+    },
+    "label-sm": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "500",
+      "fontSize": "11px",
+      "lineHeight": "16px",
+      "letterSpacing": "0.5px"
+    },
+    "body-lg": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "400",
+      "fontSize": "16px",
+      "lineHeight": "24px",
+      "letterSpacing": "0.5px"
+    },
+    "body-md": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "400",
+      "fontSize": "14px",
+      "lineHeight": "20px",
+      "letterSpacing": "0.25px"
+    },
+    "body-sm": {
+      "fontFamily": "Montserrat, ui-sans-serif, system-ui, sans-serif",
+      "fontWeight": "400",
+      "fontSize": "12px",
+      "lineHeight": "16px",
+      "letterSpacing": "0"
+    }
+  }
+};
+var tokens_default = tokens;
+
+// ../create-theme/src/contract.ts
+var TOKEN_CONTRACT = [
+  { token: "background", light: "#ffffff", dark: "#050c11" },
+  { token: "foreground", light: "#050c11", dark: "#f0f7ff" },
+  { token: "card", light: "#ffffff", dark: "#0b1821", note: "synthesized" },
+  { token: "popover", light: "#ffffff", dark: "#0b1821", note: "synthesized" },
+  { token: "primary", light: "#1d4ed8", dark: "#60a5fa" },
+  { token: "primary-foreground", light: "#f0f7ff", dark: "#050c11" },
+  { token: "secondary", light: "#c7cfc7", dark: "#2e362e" },
+  { token: "secondary-foreground", light: "#465245", dark: "#e3e7e3" },
+  { token: "muted", light: "#f6f6f6", dark: "#102432" },
+  { token: "muted-foreground", light: "#6d6d6d", dark: "#92b2c8" },
+  { token: "accent", light: "#f0f7ff", dark: "#102432" },
+  { token: "accent-foreground", light: "#1d4ed8", dark: "#f0f7ff" },
+  { token: "destructive", light: "#c60a0a", dark: "#dd6a6a", note: "darkened for AA" },
+  { token: "success", light: "#5d6d5c", dark: "#90a08f" },
+  { token: "warning", light: "#7f5b21", dark: "#ffc975", note: "darkened for AA" },
+  { token: "border", light: "#92b2c8", dark: "#395a70" },
+  { token: "ring", light: "#1d4ed8", dark: "#60a5fa", note: "synthesized" },
+  // Role tokens layered over primary / ring (added after the shadcn-compatible set on purpose: the
+  // first row for a given hex names it in tokenNameForHex, so `primary` stays the label).
+  { token: "brand", light: "#1b3c53", dark: "#7495ab", note: "identity \u2014 the Figma navy" },
+  { token: "brand-foreground", light: "#f0f7ff", dark: "#050c11" },
+  { token: "action", light: "#1d4ed8", dark: "#60a5fa", note: "defaults to primary" },
+  { token: "action-foreground", light: "#f0f7ff", dark: "#050c11", note: "defaults to primary-foreground" },
+  { token: "action-hover", light: "#3460dc", dark: "#5796e3", note: "action @ 90% \u2014 native" },
+  { token: "action-pressed", light: "#3f69de", dark: "#528ed7", note: "action @ 85% \u2014 native" },
+  { token: "link", light: "#1d4ed8", dark: "#60a5fa", note: "defaults to primary" },
+  { token: "focus", light: "#1d4ed8", dark: "#60a5fa", note: "defaults to ring" }
+];
+var RADIUS_STEP_NAMES = ["sm", "md", "lg", "xl"];
+var ELEVATION_STEP_NAMES = ["sm", "md", "lg", "xl"];
+var px = (value) => Number(value.replace("px", ""));
+var SHIPPED_RADIUS = {
+  sm: px(tokens_default.radius.sm),
+  md: px(tokens_default.radius.md),
+  lg: px(tokens_default.radius.lg),
+  xl: px(tokens_default.radius.xl)
+};
+var SHADOWS = tokens_default.shadow;
+var SHIPPED_ELEVATION = {
+  sm: SHADOWS.sm,
+  md: SHADOWS.md,
+  lg: SHADOWS.lg,
+  xl: SHADOWS.xl
+};
+
+// ../create-theme/src/palette.ts
+var CONTRAST_PAIRS = [
+  ["background", "foreground"],
+  ["card", "card-foreground"],
+  ["popover", "popover-foreground"],
+  ["primary", "primary-foreground"],
+  ["secondary", "secondary-foreground"],
+  ["muted", "muted-foreground"],
+  ["accent", "accent-foreground"],
+  ["destructive", "destructive-foreground"],
+  ["action", "action-foreground"],
+  ["brand", "brand-foreground"]
+];
+
+// ../create-theme/src/engine.ts
+var ACTION_BAND = {
+  light: [0.42, 0.62],
+  dark: [0.66, 0.84]
+};
+var BACKDROP_L = { light: 1, dark: 0.15 };
+var clamp2 = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+function intoBand(colour, mode) {
+  const [lo, hi] = ACTION_BAND[mode];
+  return adjust(colour, { dl: clamp2(colour.l, lo, hi) - colour.l });
+}
+function foregroundFor(surfaceHex) {
+  return foregroundForAll([surfaceHex]);
+}
+function foregroundForAll(surfaces) {
+  const primary = surfaces[0];
+  if (primary === void 0) return "#000000";
+  const s = hexToOklch(primary);
+  if (!s) return "#000000";
+  const tint = Math.min(s.c, 0.03);
+  const worst = (candidate) => Math.min(...surfaces.map((surface) => guaranteedContrast(surface, candidate)));
+  const tinted = [oklchToHex({ l: 0.97, c: tint, h: s.h }), oklchToHex({ l: 0.09, c: tint, h: s.h })];
+  const best = worst(tinted[0]) >= worst(tinted[1]) ? tinted[0] : tinted[1];
+  if (worst(best) >= AA) return best;
+  return worst("#ffffff") >= worst("#000000") ? "#ffffff" : "#000000";
+}
+var AA = 4.5;
+function stateOf(action, mode, fraction) {
+  return adjust(action, { dl: (BACKDROP_L[mode] - action.l) * fraction });
+}
+var HOVER_FRACTION = 0.1;
+var PRESSED_FRACTION = 0.16;
+var STATE_SCALE_STEPS = 20;
+function interactionStates(action, mode) {
+  const actionHex = oklchToHex(action);
+  for (let step = STATE_SCALE_STEPS; step >= 0; step--) {
+    const scale = step / STATE_SCALE_STEPS;
+    const hover = oklchToHex(stateOf(action, mode, HOVER_FRACTION * scale));
+    const pressed = oklchToHex(stateOf(action, mode, PRESSED_FRACTION * scale));
+    const foreground2 = foregroundForAll([actionHex, hover, pressed]);
+    const readable = [actionHex, hover, pressed].every((surface) => guaranteedContrast(surface, foreground2) >= AA);
+    if (readable) return { hover, pressed, foreground: foreground2, scale };
+  }
+  const foreground = foregroundForAll([actionHex]);
+  return { hover: actionHex, pressed: actionHex, foreground, scale: 0 };
+}
+function readableOnSurface(surfaceHex, preferredHex) {
+  if (guaranteedContrast(surfaceHex, preferredHex) >= AA) return preferredHex;
+  const surface = hexToOklch(surfaceHex);
+  const preferred = hexToOklch(preferredHex);
+  if (!surface || !preferred) return foregroundFor(surfaceHex);
+  const step = surface.l > 0.5 ? -0.02 : 0.02;
+  for (let i = 1; i <= 50; i++) {
+    const candidate = oklchToHex(adjust(preferred, { dl: step * i }));
+    if (guaranteedContrast(surfaceHex, candidate) >= AA) return candidate;
+  }
+  return foregroundFor(surfaceHex);
+}
+function deriveBrandRoles(brandHex, mode) {
+  const brand = hexToOklch(brandHex);
+  if (!brand) return {};
+  const action = intoBand(brand, mode);
+  const actionHex = oklchToHex(action);
+  const brandOwn = oklchToHex(brand);
+  const states = interactionStates(action, mode);
+  const actionFg = states.foreground;
+  const accent = oklchToHex({
+    l: mode === "light" ? 0.96 : 0.24,
+    c: Math.min(brand.c, 0.04),
+    h: brand.h
+  });
+  return {
+    brand: brandOwn,
+    "brand-foreground": foregroundFor(brandOwn),
+    action: actionHex,
+    "action-foreground": actionFg,
+    "action-hover": states.hover,
+    "action-pressed": states.pressed,
+    link: actionHex,
+    focus: actionHex,
+    // `primary` and `ring` are the pre-role names the contract says `action` and `focus` default to.
+    // Create writes both so a component that still reads the older name follows the theme.
+    primary: actionHex,
+    "primary-foreground": actionFg,
+    ring: actionHex,
+    accent,
+    // The action colour if it is readable on its own tint, stepped toward readable if not.
+    "accent-foreground": readableOnSurface(accent, actionHex)
+  };
+}
+var NEUTRAL_TINT = {
+  neutral: { h: 0, c: 0 },
+  cool: { h: 250, c: 0.012 },
+  warm: { h: 70, c: 0.012 },
+  stone: { h: 40, c: 8e-3 }
+};
+var NEUTRAL_LADDER = {
+  light: {
+    background: 1,
+    card: 1,
+    popover: 1,
+    muted: 0.975,
+    border: 0.86,
+    input: 0.86,
+    "muted-foreground": 0.535,
+    foreground: 0.15
+  },
+  dark: {
+    background: 0.16,
+    card: 0.22,
+    popover: 0.22,
+    muted: 0.27,
+    border: 0.4,
+    input: 0.4,
+    "muted-foreground": 0.72,
+    foreground: 0.97
+  }
+};
+function deriveNeutrals(neutral, mode) {
+  if (neutral === "kinetix") return {};
+  const { h, c } = NEUTRAL_TINT[neutral];
+  const ladder = NEUTRAL_LADDER[mode];
+  const at = (l) => oklchToHex({ l, c, h });
+  const out = {};
+  for (const [token, l] of Object.entries(ladder)) out[token] = at(l);
+  out["card-foreground"] = out.foreground;
+  out["popover-foreground"] = out.foreground;
+  return out;
+}
+var RADIUS_STEPS = {
+  square: { sm: 0, md: 0, lg: 0, xl: 0 },
+  small: { sm: 4, md: 4, lg: 8, xl: 12 },
+  default: { sm: 4, md: 8, lg: 12, xl: 16 },
+  rounded: { sm: 8, md: 12, lg: 16, xl: 24 },
+  soft: { sm: 12, md: 20, lg: 28, xl: 36 }
+};
+function deriveRadius(radius) {
+  return { ...RADIUS_STEPS[radius] };
+}
+function deriveElevation(surface) {
+  switch (surface) {
+    case "soft":
+      return { ...SHIPPED_ELEVATION };
+    case "elevated":
+      return {
+        sm: SHIPPED_ELEVATION.md,
+        md: SHIPPED_ELEVATION.lg,
+        lg: SHIPPED_ELEVATION.xl,
+        xl: SHIPPED_ELEVATION.xl
+      };
+    case "flat":
+    case "bordered":
+      return { sm: [], md: [], lg: [], xl: [] };
+  }
+}
+function deriveSurfaceBorder(surface, mode, borderHex) {
+  if (surface !== "bordered") return null;
+  const border = hexToOklch(borderHex);
+  return border ? oklchToHex(adjust(border, { dl: mode === "light" ? -0.14 : 0.14 })) : null;
+}
+var CHART_HUES = {
+  categorical: [255, 60, 145, 330, 200],
+  cool: [200, 250, 290, 170, 225],
+  // A warm band is only ~100° wide, so the hues are ordered against the lightness ladder below rather
+  // than run in sequence: the two closest hues (45 and 55) sit on the two most separated lightnesses.
+  // Running them in order gave two oranges a reader could not tell apart.
+  warm: [20, 55, 45, 115, 90]
+};
+var CHART_L = {
+  light: [0.55, 0.68, 0.46, 0.62, 0.74],
+  dark: [0.7, 0.62, 0.78, 0.55, 0.85]
+};
+function deriveChart(palette, brandHex, mode) {
+  if (palette === "kinetix") return {};
+  const hues = palette === "brand" ? (() => {
+    const h = hexToOklch(brandHex)?.h ?? 255;
+    return [0, 50, -50, 100, -100].map((d) => ((h + d) % 360 + 360) % 360);
+  })() : CHART_HUES[palette];
+  const ls = CHART_L[mode];
+  const out = {};
+  hues.forEach((h, i) => {
+    out[`chart-${i + 1}`] = oklchToHex({ l: ls[i], c: Math.min(0.16, MAX_CHROMA), h });
+  });
+  return out;
+}
+
+// ../create-theme/src/resolve.ts
+var ALIASED_FROM = {
+  "card-foreground": "foreground",
+  "popover-foreground": "foreground",
+  input: "border"
+};
+var FOREGROUND_OF = Object.fromEntries(CONTRAST_PAIRS);
+function shippedColorsFor(mode) {
+  const out = {};
+  for (const row2 of TOKEN_CONTRACT) out[row2.token] = mode === "dark" ? row2.dark : row2.light;
+  for (const [token, source] of Object.entries(ALIASED_FROM)) {
+    const value = out[source];
+    if (value) out[token] = value;
+  }
+  for (const [base, fg] of Object.entries(FOREGROUND_OF)) {
+    const baseHex = out[base];
+    if (baseHex && !out[fg]) out[fg] = foregroundFor(baseHex);
+  }
+  return out;
+}
+var SHIPPED_COLORS = {
+  light: shippedColorsFor("light"),
+  dark: shippedColorsFor("dark")
+};
+var SHIPPED_THEME = {
+  light: { colors: SHIPPED_COLORS.light, radius: SHIPPED_RADIUS, elevation: SHIPPED_ELEVATION },
+  dark: { colors: SHIPPED_COLORS.dark, radius: SHIPPED_RADIUS, elevation: SHIPPED_ELEVATION }
+};
+function resolveMode(design, mode) {
+  const colors = { ...SHIPPED_COLORS[mode] };
+  Object.assign(colors, deriveNeutrals(design.neutral, mode));
+  if (design.brand.toLowerCase() !== DEFAULT_PRESET.brand) {
+    Object.assign(colors, deriveBrandRoles(design.brand, mode));
+  }
+  Object.assign(colors, deriveChart(design.chartPalette, design.brand, mode));
+  const border = deriveSurfaceBorder(design.surface, mode, colors.border ?? "#000000");
+  if (border) colors.border = border;
+  for (const [token, hex] of Object.entries(design.manualOverrides)) {
+    if (hex) colors[token] = hex;
+  }
+  for (const [base, fg] of Object.entries(FOREGROUND_OF)) {
+    if (design.manualOverrides[base] && !design.manualOverrides[fg]) {
+      colors[fg] = foregroundFor(colors[base]);
+    }
+  }
+  return {
+    colors,
+    radius: deriveRadius(design.radius),
+    elevation: deriveElevation(design.surface)
+  };
+}
+function canonicalDesign(design) {
+  const result = validate(canonicalize(design));
+  return result.ok ? result.config : design;
+}
+function resolveCreateTheme(input) {
+  const design = canonicalDesign(input);
+  return {
+    light: resolveMode(design, "light"),
+    dark: resolveMode(design, "dark"),
+    meta: {
+      design,
+      // In token order, not insertion order. `Object.keys` would hand back whatever order the overrides
+      // happened to be written in, so a decoded preset (canonicalized, sorted) and the design it was
+      // encoded from would resolve to two theme objects that are not equal — which breaks the one
+      // property the whole pipeline rests on. Token order, rather than alphabetical, because that is the
+      // order the raw editor and the CLI already list overrides in.
+      manualTokens: ACCEPTED_TOKENS.filter((token) => design.manualOverrides[token]),
+      isDefault: isDefaultPreset(design)
+    }
+  };
+}
+
+// ../create-theme/src/exporters/css.ts
+var px2 = (value) => Number(value) === 0 ? "0" : `${value}px`;
+function shadowCss(layers) {
+  if (layers.length === 0) return "none";
+  return layers.map((l) => `${px2(l.offsetX)} ${px2(l.offsetY)} ${px2(l.blur)} ${px2(l.spread)} ${l.color}`).join(", ");
+}
+var declaration = (token, value) => `  --${token}: ${value};`;
+var block = (selector, lines) => lines.length ? `${selector} {
+${lines.join("\n")}
+}` : "";
+function colorLines(resolved, base) {
+  return Object.keys(resolved.colors).filter((token) => {
+    const value = resolved.colors[token];
+    return value && value.toLowerCase() !== base.colors[token]?.toLowerCase();
+  }).sort().map((token) => declaration(token, hexToHslChannels(resolved.colors[token])));
+}
+function cssVarOverrides(resolved, base = SHIPPED_THEME.light) {
+  const out = {};
+  for (const step of RADIUS_STEP_NAMES) {
+    if (resolved.radius[step] !== base.radius[step]) out[`radius-${step}`] = `${resolved.radius[step]}px`;
+  }
+  for (const step of ELEVATION_STEP_NAMES) {
+    const value = shadowCss(resolved.elevation[step]);
+    if (value !== shadowCss(base.elevation[step])) out[`shadow-${step}`] = value;
+  }
+  return out;
+}
+var varLines = (resolved, base) => Object.entries(cssVarOverrides(resolved, base)).map(([token, value]) => declaration(token, value));
+function exportCss(theme2, options = {}) {
+  const rootSelector = options.rootSelector ?? ":root";
+  const darkSelector = options.darkSelector ?? ".dark";
+  const rootVars = varLines(theme2.light, SHIPPED_THEME.light);
+  const root = [...colorLines(theme2.light, SHIPPED_THEME.light), ...rootVars];
+  const dark = [
+    ...colorLines(theme2.dark, SHIPPED_THEME.dark),
+    ...varLines(theme2.dark, SHIPPED_THEME.dark).filter((line) => !rootVars.includes(line))
+  ];
+  return [block(rootSelector, root), block(darkSelector, dark)].filter(Boolean).join("\n\n");
+}
+
+// ../create-theme/src/exporters/flutter.ts
+var DEFAULT_FLUTTER_SYMBOL = "CreateTheme";
+var DART_RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "assert",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "default",
+  "do",
+  "else",
+  "enum",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "for",
+  "if",
+  "in",
+  "is",
+  "new",
+  "null",
+  "rethrow",
+  "return",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "var",
+  "void",
+  "while",
+  "with"
+]);
+function dartSymbolError(symbol) {
+  if (symbol.length === 0) return "A theme name cannot be empty.";
+  if (symbol.length > 64) return "A theme name must be 64 characters or fewer.";
+  if (/[\p{Cc}\p{Cf}]/u.test(symbol)) return "A theme name cannot contain control characters.";
+  if (/^[0-9]/.test(symbol)) return `"${symbol}" cannot start with a digit \u2014 Dart type names begin with a letter or underscore.`;
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(symbol)) {
+    return `"${symbol}" is not a Dart identifier \u2014 use letters, digits and underscores only.`;
+  }
+  if (DART_RESERVED_WORDS.has(symbol)) return `"${symbol}" is a Dart reserved word and cannot be a type name.`;
+  return null;
+}
+function dartColor(hex) {
+  const h = hex.replace("#", "").trim();
+  if (!/^[0-9a-fA-F]{6}$/.test(h)) return null;
+  return `Color(0xFF${h.toUpperCase()})`;
+}
+var FLUTTER_COLOR_FIELDS = [
+  ["primary", "primary"],
+  ["primaryForeground", "primary-foreground"],
+  ["action", "action"],
+  ["actionForeground", "action-foreground"],
+  ["actionHover", "action-hover"],
+  ["actionPressed", "action-pressed"],
+  ["link", "link"],
+  ["focus", "focus"],
+  ["brand", "brand"],
+  ["brandForeground", "brand-foreground"],
+  ["secondary", "secondary"],
+  ["secondaryForeground", "secondary-foreground"],
+  ["destructive", "destructive"],
+  ["destructiveForeground", "destructive-foreground"],
+  ["foreground", "foreground"],
+  ["background", "background"],
+  ["border", "border"],
+  ["input", "input"],
+  ["ring", "ring"],
+  ["muted", "muted"],
+  ["mutedForeground", "muted-foreground"],
+  ["accent", "accent"],
+  ["accentForeground", "accent-foreground"],
+  ["tertiary", "tertiary"],
+  ["tertiaryForeground", "tertiary-foreground"],
+  ["warning", "warning"],
+  ["warningForeground", "warning-foreground"],
+  ["card", "card"],
+  ["cardForeground", "card-foreground"],
+  ["success", "success"],
+  ["successForeground", "success-foreground"],
+  ["info", "info"],
+  ["infoForeground", "info-foreground"],
+  ["popover", "popover"],
+  ["popoverForeground", "popover-foreground"]
+];
+var FLUTTER_CHART_STOPS = [1, 2, 3, 4, 5];
+var shippedRef = (appearance, field) => `KinetixColors.${appearance}.${field}`;
+function fieldValue(mode, appearance, field, token) {
+  const resolved = mode.colors[token];
+  if (!resolved) return shippedRef(appearance, field);
+  const shipped = SHIPPED_COLORS[appearance][token];
+  if (shipped && shipped.toLowerCase() === resolved.toLowerCase()) return shippedRef(appearance, field);
+  return dartColor(resolved) ?? shippedRef(appearance, field);
+}
+function colorSet(mode, appearance) {
+  const fields = FLUTTER_COLOR_FIELDS.map(
+    ([field, token]) => `    ${field}: ${fieldValue(mode, appearance, field, token)},`
+  );
+  const chart = FLUTTER_CHART_STOPS.map(
+    (stop) => `      ${fieldValue(mode, appearance, `chart${stop}`, `chart-${stop}`)},`
+  );
+  return [...fields, "    chart: <Color>[", ...chart, "    ],"].join("\n");
+}
+function header(symbol, theme2) {
+  const design = theme2.meta.design;
+  return [
+    "//",
+    `// ${symbol} \u2014 a KinetixUI Create theme.`,
+    "//",
+    "// Generated by `kinetixui preset flutter`. Edit the design in Create and re-export rather than",
+    "// editing this file: it is a rendering of a preset, not a source of one.",
+    "//",
+    `// Theme colour ${design.brand} \xB7 ${design.neutral} neutral \xB7 ${design.chartPalette} charts`,
+    "//",
+    "// Every semantic colour KinetixColors declares is carried here, light and dark \u2014 Flutter's contract",
+    "// is the complete one, so no role is left behind.",
+    "//",
+    "// COLOURS ONLY. Radius and elevation are not themeable at runtime: widgets read `KinetixRadius`",
+    "// constants directly and `KinetixTheme` carries neither them nor `KinetixShadows`, so this design's",
+    `// radius (${design.radius}) and surface treatment (${design.surface}) have nowhere to be installed.`,
+    "// They apply on the web. That is the only thing this file does not carry.",
+    "//",
+    "// A field written as `KinetixColors.light.\u2026` is one this design did not change, and it keeps",
+    "// following the library. Six of them \u2014 tertiary, tertiaryForeground, info, infoForeground,",
+    "// successForeground and warningForeground \u2014 are always references, because Create does not model",
+    "// those tokens.",
+    "//",
+    "// These are `static final` rather than `static const`: Dart's constant expressions do not include",
+    "// instance field access, so a `static const` could not reference the shipped palette. The theme is",
+    "// still usable everywhere a const one would be \u2014 `KinetixTheme.custom` takes it fine \u2014 you just",
+    "// cannot write `const KinetixTheme.custom(\u2026)` around it.",
+    "//",
+    "// Apply it to Kinetix widgets:",
+    "//",
+    `//   KinetixTheme.custom(light: ${symbol}.light, dark: ${symbol}.dark, child: App())`,
+    "//",
+    "// \u2026and to Material or Cupertino widgets, whose own theme APIs represent the subset they can:",
+    "//",
+    `//   MaterialApp(theme: KinetixMaterialTheme.fromColors(Brightness.light, ${symbol}.light))`,
+    "//"
+  ].join("\n");
+}
+function exportFlutter(theme2, options = {}) {
+  const symbol = options.symbol ?? DEFAULT_FLUTTER_SYMBOL;
+  const reason = dartSymbolError(symbol);
+  if (reason) throw new Error(reason);
+  return [
+    header(symbol, theme2),
+    "",
+    "import 'package:flutter/widgets.dart';",
+    "import 'package:kinetix_ui/kinetix_ui.dart';",
+    "",
+    // `abstract final class` is Dart 3 and the package floor is >=3.6, so it is available. It is the
+    // idiomatic way to say "namespace, never instantiated, never extended" — the same intent SwiftUI's
+    // `enum` and Compose's `object` express.
+    `abstract final class ${symbol} {`,
+    "  static final KinetixColors light = KinetixColors(",
+    colorSet(theme2.light, "light"),
+    "  );",
+    "",
+    "  static final KinetixColors dark = KinetixColors(",
+    colorSet(theme2.dark, "dark"),
+    "  );",
+    "}",
+    ""
+  ].join("\n");
+}
+
+// ../create-theme/src/exporters/compose.ts
+var DEFAULT_COMPOSE_SYMBOL = "CreateTheme";
+var KOTLIN_KEYWORDS = /* @__PURE__ */ new Set([
+  "as",
+  "break",
+  "class",
+  "continue",
+  "do",
+  "else",
+  "false",
+  "for",
+  "fun",
+  "if",
+  "in",
+  "interface",
+  "is",
+  "null",
+  "object",
+  "package",
+  "return",
+  "super",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typealias",
+  "typeof",
+  "val",
+  "var",
+  "when",
+  "while"
+]);
+function kotlinSymbolError(symbol) {
+  if (symbol.length === 0) return "A theme name cannot be empty.";
+  if (symbol.length > 64) return "A theme name must be 64 characters or fewer.";
+  if (/[\p{Cc}\p{Cf}]/u.test(symbol)) return "A theme name cannot contain control characters.";
+  if (/^[0-9]/.test(symbol)) return `"${symbol}" cannot start with a digit \u2014 Kotlin type names begin with a letter or underscore.`;
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(symbol)) {
+    return `"${symbol}" is not a Kotlin identifier \u2014 use letters, digits and underscores only.`;
+  }
+  if (KOTLIN_KEYWORDS.has(symbol)) return `"${symbol}" is a Kotlin keyword and cannot be a type name.`;
+  return null;
+}
+function kotlinFieldName(token) {
+  return token.replace(/[-_]([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function composeColor(hex) {
+  const h = hex.replace("#", "").trim();
+  if (!/^[0-9a-fA-F]{6}$/.test(h)) return null;
+  return `Color(0xff${h.toLowerCase()})`;
+}
+var COMPOSE_COLOR_FIELDS = [
+  ["primary", "primary"],
+  ["primaryForeground", "primary-foreground"],
+  ["action", "action"],
+  ["actionForeground", "action-foreground"],
+  ["actionHover", "action-hover"],
+  ["actionPressed", "action-pressed"],
+  ["link", "link"],
+  ["focus", "focus"],
+  ["brand", "brand"],
+  ["brandForeground", "brand-foreground"],
+  ["secondary", "secondary"],
+  ["secondaryForeground", "secondary-foreground"],
+  ["destructive", "destructive"],
+  ["destructiveForeground", "destructive-foreground"],
+  ["foreground", "foreground"],
+  ["background", "background"],
+  ["border", "border"],
+  ["muted", "muted"],
+  ["mutedForeground", "muted-foreground"],
+  ["accent", "accent"],
+  ["accentForeground", "accent-foreground"],
+  ["tertiary", "tertiary"],
+  ["warning", "warning"],
+  ["warningForeground", "warning-foreground"],
+  ["card", "card"],
+  ["cardForeground", "card-foreground"],
+  ["success", "success"],
+  ["successForeground", "success-foreground"],
+  ["info", "info"],
+  ["infoForeground", "info-foreground"],
+  ["popover", "popover"],
+  ["popoverForeground", "popover-foreground"]
+];
+var COMPOSE_CHART_STOPS = [1, 2, 3, 4, 5];
+var COMPOSE_UNMAPPED_PRESET_ROLES = ["input", "ring"];
+var COMPOSE_NATIVE_THEME_GAPS = ["tertiary-foreground"];
+var SHIPPED_OBJECT = { light: "KinetixTokensLight", dark: "KinetixTokensDark" };
+var shippedRef2 = (appearance, token) => `${SHIPPED_OBJECT[appearance]}.color${kotlinFieldName(token).replace(/^./, (c) => c.toUpperCase())}`;
+function fieldValue2(mode, appearance, token) {
+  const resolved = mode.colors[token];
+  if (!resolved) return shippedRef2(appearance, token);
+  const shipped = SHIPPED_COLORS[appearance][token];
+  if (shipped && shipped.toLowerCase() === resolved.toLowerCase()) return shippedRef2(appearance, token);
+  return composeColor(resolved) ?? shippedRef2(appearance, token);
+}
+function colorSet2(mode, appearance) {
+  const fields = COMPOSE_COLOR_FIELDS.map(
+    ([field, token]) => `        ${field} = ${fieldValue2(mode, appearance, token)},`
+  );
+  const chart = COMPOSE_CHART_STOPS.map(
+    (stop) => `            ${fieldValue2(mode, appearance, `chart-${stop}`)},`
+  );
+  return [...fields, "        chart = listOf(", ...chart, "        ),"].join("\n");
+}
+function header2(symbol, theme2) {
+  const design = theme2.meta.design;
+  return [
+    "//",
+    `// ${symbol} \u2014 a KinetixUI Create theme.`,
+    "//",
+    "// Generated by `kinetixui preset compose`. Edit the design in Create and re-export rather than",
+    "// editing this file: it is a rendering of a preset, not a source of one.",
+    "//",
+    `// Theme colour ${design.brand} \xB7 ${design.neutral} neutral \xB7 ${design.chartPalette} charts`,
+    "//",
+    "// COLOURS ONLY. KinetixUI for Compose is themeable through `KinetixColors`, and this file carries",
+    "// every colour it has a field for. What this design can express and Compose cannot receive:",
+    "//",
+    `//   - radius (${design.radius}) and surface treatment (${design.surface}). Compose reads these from`,
+    "//     generated constants, not from a runtime theme, so nothing written here could override them.",
+    "//     Both apply on the web.",
+    `//   - \`${COMPOSE_UNMAPPED_PRESET_ROLES.join("` and `")}\`. Create resolves both, and a preset can override either by`,
+    "//     hand, but `KinetixColors` has no field for them.",
+    "//",
+    "// That is the complete list for this design. Nothing else was dropped.",
+    "//",
+    `// Separately, and not a Create limitation: \`${COMPOSE_NATIVE_THEME_GAPS.join("`, `")}\` is in the Kinetix`,
+    "// token contract and in the SwiftUI theme, but Compose's `KinetixColors` does not expose it. Create",
+    "// does not model that token at all, so no preset can set it and nothing here is affected by it.",
+    "//",
+    "// A field written as `KinetixTokensLight.\u2026` is one this design did not change, and it keeps",
+    "// following the library.",
+    "//"
+  ].join("\n");
+}
+function exportCompose(theme2, options = {}) {
+  const symbol = options.symbol ?? DEFAULT_COMPOSE_SYMBOL;
+  const reason = kotlinSymbolError(symbol);
+  if (reason) throw new Error(reason);
+  const light = colorSet2(theme2.light, "light");
+  const dark = colorSet2(theme2.dark, "dark");
+  const usesColor = `${light}${dark}`.includes("Color(0x");
+  return [
+    header2(symbol, theme2),
+    "",
+    "package com.kinetixui.create",
+    "",
+    // Alphabetical, and aliased exactly as the package's own Theme.kt does it:
+    // `com.kinetixui.tokens.KinetixTheme` is the generated token object while `com.kinetixui.ui.KinetixTheme`
+    // is the composable, so the bare name is ambiguous in any file that wants both.
+    ...usesColor ? ["import androidx.compose.ui.graphics.Color"] : [],
+    "import com.kinetixui.tokens.KinetixTheme as KinetixTokensLight",
+    "import com.kinetixui.tokens.KinetixThemeDark as KinetixTokensDark",
+    "import com.kinetixui.ui.KinetixColors",
+    "",
+    `object ${symbol} {`,
+    "    /** Apply with `KinetixTheme(light = light, dark = dark) { \u2026 }`. */",
+    "    val light = KinetixColors(",
+    light,
+    "    )",
+    "",
+    "    val dark = KinetixColors(",
+    dark,
+    "    )",
+    "}",
+    ""
+  ].join("\n");
+}
+
+// ../create-theme/src/exporters/swiftui.ts
+var DEFAULT_SWIFT_SYMBOL = "CreateTheme";
+var SWIFT_KEYWORDS = /* @__PURE__ */ new Set([
+  "associatedtype",
+  "borrowing",
+  "class",
+  "consuming",
+  "deinit",
+  "enum",
+  "extension",
+  "fileprivate",
+  "func",
+  "import",
+  "init",
+  "inout",
+  "internal",
+  "let",
+  "macro",
+  "nonisolated",
+  "open",
+  "operator",
+  "private",
+  "precedencegroup",
+  "protocol",
+  "public",
+  "rethrows",
+  "static",
+  "struct",
+  "subscript",
+  "typealias",
+  "var",
+  "break",
+  "case",
+  "catch",
+  "continue",
+  "default",
+  "defer",
+  "do",
+  "else",
+  "fallthrough",
+  "for",
+  "guard",
+  "if",
+  "in",
+  "repeat",
+  "return",
+  "throw",
+  "switch",
+  "where",
+  "while",
+  "Any",
+  "as",
+  "await",
+  "false",
+  "is",
+  "nil",
+  "rethrows",
+  "self",
+  "Self",
+  "super",
+  "throw",
+  "throws",
+  "true",
+  "try"
+]);
+function swiftSymbolError(symbol) {
+  if (symbol.length === 0) return "A theme name cannot be empty.";
+  if (symbol.length > 64) return "A theme name must be 64 characters or fewer.";
+  if (/[\p{Cc}\p{Cf}]/u.test(symbol)) return "A theme name cannot contain control characters.";
+  if (/^[0-9]/.test(symbol)) return `"${symbol}" cannot start with a digit \u2014 Swift type names begin with a letter or underscore.`;
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(symbol)) {
+    return `"${symbol}" is not a Swift identifier \u2014 use letters, digits and underscores only.`;
+  }
+  if (SWIFT_KEYWORDS.has(symbol)) return `"${symbol}" is a Swift keyword and cannot be a type name.`;
+  return null;
+}
+function swiftFieldName(token) {
+  return token.replace(/[-_]([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function swiftColor(hex) {
+  const h = hex.replace("#", "").trim();
+  if (!/^[0-9a-fA-F]{6}$/.test(h)) return null;
+  const [r, g, b] = swiftUiChannels(`#${h}`);
+  return `Color(red: ${r}, green: ${g}, blue: ${b})`;
+}
+var SWIFT_COLOR_FIELDS = [
+  "primary",
+  "primary-foreground",
+  "action",
+  "action-foreground",
+  "action-hover",
+  "action-pressed",
+  "link",
+  "focus",
+  "brand",
+  "brand-foreground",
+  "secondary",
+  "secondary-foreground",
+  "destructive",
+  "destructive-foreground",
+  "foreground",
+  "background",
+  "border",
+  "input",
+  "ring",
+  "muted",
+  "muted-foreground",
+  "accent",
+  "accent-foreground",
+  "tertiary",
+  "tertiary-foreground",
+  "warning",
+  "warning-foreground",
+  "card",
+  "card-foreground",
+  "success",
+  "success-foreground",
+  "info",
+  "info-foreground",
+  "popover",
+  "popover-foreground"
+];
+var SWIFT_CHART_STOPS = [1, 2, 3, 4, 5];
+var SHIPPED_ENUM = { light: "KinetixColorsSwiftUI", dark: "KinetixColorsSwiftUIDark" };
+function fieldValue3(mode, appearance, token) {
+  const reference = `${SHIPPED_ENUM[appearance]}.${swiftFieldName(token)}`;
+  const resolved = mode.colors[token];
+  if (!resolved) return reference;
+  const shipped = SHIPPED_COLORS[appearance][token];
+  if (shipped && shipped.toLowerCase() === resolved.toLowerCase()) return reference;
+  return swiftColor(resolved) ?? reference;
+}
+function colorSet3(mode, appearance) {
+  const fields = SWIFT_COLOR_FIELDS.map(
+    (token) => `        ${swiftFieldName(token)}: ${fieldValue3(mode, appearance, token)},`
+  );
+  const chart = SWIFT_CHART_STOPS.map(
+    (stop) => `            ${fieldValue3(mode, appearance, `chart-${stop}`)},`
+  );
+  return [...fields, "        chart: [", ...chart, "        ]"].join("\n");
+}
+function header3(symbol, theme2) {
+  const design = theme2.meta.design;
+  return [
+    "//",
+    `// ${symbol} \u2014 a KinetixUI Create theme.`,
+    "//",
+    "// Generated by `kinetixui preset swiftui`. Edit the design in Create and re-export rather than",
+    "// editing this file: it is a rendering of a preset, not a source of one.",
+    "//",
+    `// Theme colour ${design.brand} \xB7 ${design.neutral} neutral \xB7 ${design.chartPalette} charts`,
+    "//",
+    "// COLOURS ONLY. KinetixUI for SwiftUI is themeable through `KinetixColors`; corner radius and",
+    "// elevation are literals inside each view, with no token to override. This design's radius",
+    `// (${design.radius}) and surface treatment (${design.surface}) therefore are NOT carried here \u2014 they`,
+    "// apply on the web. Nothing is silently dropped; there is nowhere for them to go yet.",
+    "//",
+    "// A field written as `KinetixColorsSwiftUI.\u2026` is one this design did not change, and it keeps",
+    "// following the library.",
+    "//"
+  ].join("\n");
+}
+function exportSwiftUi(theme2, options = {}) {
+  const symbol = options.symbol ?? DEFAULT_SWIFT_SYMBOL;
+  const reason = swiftSymbolError(symbol);
+  if (reason) throw new Error(reason);
+  return [
+    header3(symbol, theme2),
+    "",
+    "import SwiftUI",
+    "import KinetixUI",
+    "",
+    `public enum ${symbol} {`,
+    "    /// Apply with `KinetixTheme(light: .light, dark: .dark) { \u2026 }`, or set",
+    "    /// `\\.kinetixColors` directly to pin one appearance.",
+    `    public static let light = KinetixColors(`,
+    colorSet3(theme2.light, "light"),
+    "    )",
+    "",
+    `    public static let dark = KinetixColors(`,
+    colorSet3(theme2.dark, "dark"),
+    "    )",
+    "}",
+    ""
+  ].join("\n");
+}
+
+// src/commands/preset.ts
+function read(input) {
+  const result = decodePreset(input);
+  if (!result.ok) {
+    throw new Error(result.error.message);
+  }
+  return result.config;
+}
+var row = (label, value) => `  ${pc8.dim(label.padEnd(16))} ${value}`;
+function presetDecode(input, opts) {
+  const config = read(input);
+  if (opts.json) {
+    console.log(JSON.stringify(config, null, 2));
+    return;
+  }
+  console.log();
+  console.log(pc8.bold("Kinetix Create preset"));
+  console.log();
+  console.log(row("Theme colour", config.brand));
+  console.log(row("Neutral", config.neutral));
+  console.log(row("Radius", config.radius));
+  console.log(row("Surface", config.surface));
+  console.log(row("Chart palette", config.chartPalette));
+  const overrides = ACCEPTED_TOKENS.filter((token) => config.manualOverrides[token]);
+  console.log();
+  if (overrides.length === 0) {
+    console.log(pc8.dim("  No manual overrides \u2014 every colour is generated from the theme colour."));
+  } else {
+    console.log(pc8.bold(`  Manual overrides (${overrides.length})`));
+    for (const token of overrides) console.log(row(`  ${token}`, config.manualOverrides[token]));
+  }
+  if (isDefaultPreset(config)) {
+    console.log();
+    console.log(pc8.dim("  This preset is the shipped Kinetix default \u2014 it changes nothing."));
+  }
+  console.log();
+  console.log(
+    pc8.dim(
+      // Wrapped so that no command name is split across lines — a reader scanning for `theme build`
+      // should find it, and so should a test.
+      "  A preset describes a design, not a stylesheet.\n\n    kinetixui preset css <code>       the same web CSS the workspace's Copy CSS produces\n    kinetixui preset swiftui <code>   a SwiftUI colour theme\n    kinetixui preset compose <code>   a Jetpack Compose colour theme\n    kinetixui preset flutter <code>   a Flutter colour theme\n\n  For a file of literal colours, `kinetixui theme build` is unchanged."
+    )
+  );
+  console.log();
+}
+async function presetCss(input, opts) {
+  const css = exportCss(resolveCreateTheme(read(input)));
+  if (opts.output) {
+    await writeFile3(opts.output, css ? `${css}
+` : "", "utf8");
+    console.log(pc8.green("\u2714"), css ? `Wrote ${opts.output}` : `Wrote ${opts.output} (empty \u2014 the preset is the Kinetix default)`);
+    return;
+  }
+  if (!css) {
+    console.error(pc8.dim("This preset is the shipped Kinetix default \u2014 there is nothing to override."));
+    return;
+  }
+  console.log(css);
+}
+async function presetSwiftUi(input, opts) {
+  const symbol = opts.name ?? DEFAULT_SWIFT_SYMBOL;
+  const reason = swiftSymbolError(symbol);
+  if (reason) throw new Error(reason);
+  const swift = exportSwiftUi(resolveCreateTheme(read(input)), { symbol });
+  if (opts.output) {
+    await writeFile3(opts.output, swift, "utf8");
+    console.log(pc8.green("\u2714"), `Wrote ${opts.output} \u2014 apply it with KinetixTheme(light: ${symbol}.light, dark: ${symbol}.dark)`);
+    return;
+  }
+  process.stdout.write(swift);
+}
+async function presetCompose(input, opts) {
+  const symbol = opts.name ?? DEFAULT_COMPOSE_SYMBOL;
+  const reason = kotlinSymbolError(symbol);
+  if (reason) throw new Error(reason);
+  const kotlin = exportCompose(resolveCreateTheme(read(input)), { symbol });
+  if (opts.output) {
+    await writeFile3(opts.output, kotlin, "utf8");
+    console.log(pc8.green("\u2714"), `Wrote ${opts.output} \u2014 apply it with KinetixTheme(light = ${symbol}.light, dark = ${symbol}.dark)`);
+    return;
+  }
+  process.stdout.write(kotlin);
+}
+async function presetFlutter(input, opts) {
+  const symbol = opts.name ?? DEFAULT_FLUTTER_SYMBOL;
+  const reason = dartSymbolError(symbol);
+  if (reason) throw new Error(reason);
+  const dart = exportFlutter(resolveCreateTheme(read(input)), { symbol });
+  if (opts.output) {
+    await writeFile3(opts.output, dart, "utf8");
+    console.log(pc8.green("\u2714"), `Wrote ${opts.output} \u2014 apply it with KinetixTheme.custom(light: ${symbol}.light, dark: ${symbol}.dark, child: \u2026)`);
+    return;
+  }
+  process.stdout.write(dart);
+}
+function presetUrlCommand(input, opts) {
+  console.log(presetUrl(read(input), opts.site));
+}
+
+// src/commands/theme.ts
+import { existsSync as existsSync9 } from "fs";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
+import path9 from "path";
+import pc9 from "picocolors";
+
 // src/lib/theme.ts
-var ACCEPTED_TOKENS = [
+var ACCEPTED_TOKENS2 = [
   "background",
   "foreground",
   "card",
@@ -784,7 +2731,7 @@ var EXAMPLE_VALUES = {
   brand: "#0f172a",
   "brand-foreground": "#ffffff"
 };
-var FOREGROUND_OF = {
+var FOREGROUND_OF2 = {
   background: "foreground",
   card: "card-foreground",
   popover: "popover-foreground",
@@ -796,7 +2743,7 @@ var FOREGROUND_OF = {
   action: "action-foreground",
   brand: "brand-foreground"
 };
-var CONTRAST_PAIRS = [
+var CONTRAST_PAIRS2 = [
   ["background", "foreground"],
   ["card", "card-foreground"],
   ["popover", "popover-foreground"],
@@ -808,7 +2755,7 @@ var CONTRAST_PAIRS = [
   ["action", "action-foreground"],
   ["brand", "brand-foreground"]
 ];
-var isAccepted = (t) => ACCEPTED_TOKENS.includes(t);
+var isAccepted = (t) => ACCEPTED_TOKENS2.includes(t);
 function parseThemeFile(text) {
   const values = {};
   const errors = [];
@@ -834,22 +2781,22 @@ function parseThemeFile(text) {
   });
   return { values, errors, unknownTokens };
 }
-function deriveForegrounds(values) {
+function deriveForegrounds2(values) {
   const out = { ...values };
-  for (const [base, fg] of Object.entries(FOREGROUND_OF)) {
+  for (const [base, fg] of Object.entries(FOREGROUND_OF2)) {
     if (out[base] && !out[fg]) out[fg] = bestTextHex(out[base]);
   }
   return out;
 }
-function toCssBlock(values) {
-  const lines = ACCEPTED_TOKENS.filter((t) => values[t]).map((t) => `  --${t}: ${hexToHslChannels(values[t])};`);
+function toCssBlock2(values) {
+  const lines = ACCEPTED_TOKENS2.filter((t) => values[t]).map((t) => `  --${t}: ${hexToHslChannels(values[t])};`);
   return `:root {
 ${lines.join("\n")}
 }
 `;
 }
-function checkContrast(values) {
-  return CONTRAST_PAIRS.filter(([bg, fg]) => values[bg] && values[fg]).map(([bg, fg]) => {
+function checkContrast2(values) {
+  return CONTRAST_PAIRS2.filter(([bg, fg]) => values[bg] && values[fg]).map(([bg, fg]) => {
     const ratio = contrastRatio(values[bg], values[fg]);
     return { pair: [bg, fg], ratio, pass: ratio >= 4.5 };
   });
@@ -868,7 +2815,7 @@ function scaffoldThemeFile(name) {
     "# don't have to set both unless you want a specific foreground.",
     "#"
   ];
-  for (const token of ACCEPTED_TOKENS) {
+  for (const token of ACCEPTED_TOKENS2) {
     lines.push(`# ${token},${EXAMPLE_VALUES[token]}`);
   }
   return lines.join("\n") + "\n";
@@ -890,10 +2837,10 @@ async function themeCreate(name, options) {
     throw new Error(`${path9.relative(cwd, file)} already exists. Pass --force to overwrite it.`);
   }
   await mkdir2(path9.dirname(file), { recursive: true });
-  await writeFile3(file, scaffoldThemeFile(name), "utf8");
-  console.log(pc8.green("\u2714"), `Wrote ${path9.relative(cwd, file)}`);
+  await writeFile4(file, scaffoldThemeFile(name), "utf8");
+  console.log(pc9.green("\u2714"), `Wrote ${path9.relative(cwd, file)}`);
   console.log(`Uncomment and edit the tokens you want to override, then run:`);
-  console.log(pc8.dim(`  kinetixui theme build ${name}`));
+  console.log(pc9.dim(`  kinetixui theme build ${name}`));
 }
 async function themeBuild(name, options) {
   assertThemeName(name);
@@ -904,32 +2851,32 @@ async function themeBuild(name, options) {
   }
   const text = await readFile3(src, "utf8");
   const { values: parsed, errors, unknownTokens } = parseThemeFile(text);
-  for (const err of errors) console.log(pc8.yellow("!"), err);
-  for (const unknown of unknownTokens) console.log(pc8.yellow("!"), `"${unknown}" isn't a known token \u2014 skipped.`);
-  const values = deriveForegrounds(parsed);
+  for (const err of errors) console.log(pc9.yellow("!"), err);
+  for (const unknown of unknownTokens) console.log(pc9.yellow("!"), `"${unknown}" isn't a known token \u2014 skipped.`);
+  const values = deriveForegrounds2(parsed);
   const setCount = Object.keys(values).length;
   if (setCount === 0) {
     throw new Error(`No tokens set in ${path9.relative(cwd, src)} \u2014 nothing to build. Uncomment at least one line.`);
   }
   const dest = cssPath(cwd, name);
-  await writeFile3(dest, toCssBlock(values), "utf8");
-  console.log(pc8.green("\u2714"), `Wrote ${path9.relative(cwd, dest)} (${setCount} token${setCount === 1 ? "" : "s"})`);
-  console.log(`Paste it after ${pc8.dim('@import "@kinetixui/tokens/css";')} in your global CSS.`);
+  await writeFile4(dest, toCssBlock2(values), "utf8");
+  console.log(pc9.green("\u2714"), `Wrote ${path9.relative(cwd, dest)} (${setCount} token${setCount === 1 ? "" : "s"})`);
+  console.log(`Paste it after ${pc9.dim('@import "@kinetixui/tokens/css";')} in your global CSS.`);
   console.log();
-  console.log(pc8.dim("WCAG AA contrast (4.5:1)"));
-  const results = checkContrast(values);
+  console.log(pc9.dim("WCAG AA contrast (4.5:1)"));
+  const results = checkContrast2(values);
   let failed = 0;
   for (const { pair, ratio, pass } of results) {
-    const mark = pass ? pc8.green("\u2714") : pc8.red("\u2716");
+    const mark = pass ? pc9.green("\u2714") : pc9.red("\u2716");
     if (!pass) failed++;
-    console.log(`${mark} ${pair[0]} / ${pair[1]}`, pc8.dim(`${ratio.toFixed(2)}:1`));
+    console.log(`${mark} ${pair[0]} / ${pair[1]}`, pc9.dim(`${ratio.toFixed(2)}:1`));
   }
   if (results.length === 0) {
-    console.log(pc8.dim("(no checkable pairs \u2014 set at least one base + foreground, or just a base to auto-derive one)"));
+    console.log(pc9.dim("(no checkable pairs \u2014 set at least one base + foreground, or just a base to auto-derive one)"));
   }
   console.log();
   console.log("Native (SwiftUI/Compose/Flutter) theme output isn't built yet \u2014 this compiles to CSS only.");
-  console.log(pc8.dim("See https://kinetixui.com/docs/cli#theme for the current scope."));
+  console.log(pc9.dim("See https://kinetixui.com/docs/cli#theme for the current scope."));
   if (failed > 0 && options.failOnContrast) {
     process.exitCode = 1;
   }
@@ -938,7 +2885,7 @@ async function themeBuild(name, options) {
 // package.json
 var package_default = {
   name: "@kinetixui/cli",
-  version: "0.22.1",
+  version: "0.23.0",
   description: "Add KinetixUI components and tokens to your project.",
   type: "module",
   license: "MIT",
@@ -961,6 +2908,8 @@ var package_default = {
     prompts: "^2.4.2"
   },
   devDependencies: {
+    "@kinetixui/create-preset": "workspace:*",
+    "@kinetixui/create-theme": "workspace:*",
     "@types/node": "^22.20.3",
     "@types/prompts": "^2.4.9",
     tsup: "^8.5.1",
@@ -982,7 +2931,7 @@ program.command("init").description("Set up kinetixui.json and pull in the token
   try {
     await init({ registry: opts.registry, yes: opts.yes });
   } catch (err) {
-    console.error(pc9.red("\u2716"), err.message);
+    console.error(pc10.red("\u2716"), err.message);
     process.exitCode = 1;
   }
 });
@@ -990,7 +2939,7 @@ program.command("add").description("Add one or more components to your project."
   try {
     await add(components, { registry: opts.registry, overwrite: opts.overwrite, all: opts.all });
   } catch (err) {
-    console.error(pc9.red("\u2716"), err.message);
+    console.error(pc10.red("\u2716"), err.message);
     process.exitCode = 1;
   }
 });
@@ -998,7 +2947,7 @@ program.command("list").description("List every component available in the regis
   try {
     await list({ registry: opts.registry });
   } catch (err) {
-    console.error(pc9.red("\u2716"), err.message);
+    console.error(pc10.red("\u2716"), err.message);
     process.exitCode = 1;
   }
 });
@@ -1006,7 +2955,7 @@ program.command("inspect").description("Show everything the registry knows about
   try {
     await inspect(name, { registry: opts.registry });
   } catch (err) {
-    console.error(pc9.red("\u2716"), err.message);
+    console.error(pc10.red("\u2716"), err.message);
     process.exitCode = 1;
   }
 });
@@ -1014,7 +2963,7 @@ program.command("parity").description("Show which platforms carry each component
   try {
     await parity(components, { registry: opts.registry });
   } catch (err) {
-    console.error(pc9.red("\u2716"), err.message);
+    console.error(pc10.red("\u2716"), err.message);
     process.exitCode = 1;
   }
 });
@@ -1022,7 +2971,7 @@ program.command("lint").description("Scan for hardcoded colors and spacing that
   try {
     await lint(target, { fail: opts.fail });
   } catch (err) {
-    console.error(pc9.red("\u2716"), err.message);
+    console.error(pc10.red("\u2716"), err.message);
     process.exitCode = 1;
   }
 });
@@ -1030,7 +2979,7 @@ program.command("doctor").description("Check kinetixui.json, its aliases, and th
   try {
     await doctor();
   } catch (err) {
-    console.error(pc9.red("\u2716"), err.message);
+    console.error(pc10.red("\u2716"), err.message);
     process.exitCode = 1;
   }
 });
@@ -1039,7 +2988,7 @@ theme.command("create").description("Scaffold kinetixui-themes/<name>.csv with e
   try {
     await themeCreate(name, { force: opts.force });
   } catch (err) {
-    console.error(pc9.red("\u2716"), err.message);
+    console.error(pc10.red("\u2716"), err.message);
     process.exitCode = 1;
   }
 });
@@ -1047,7 +2996,56 @@ theme.command("build").description("Compile kinetixui-themes/<name>.csv to CSS a
   try {
     await themeBuild(name, { failOnContrast: opts.failOnContrast });
   } catch (err) {
-    console.error(pc9.red("\u2716"), err.message);
+    console.error(pc10.red("\u2716"), err.message);
+    process.exitCode = 1;
+  }
+});
+var preset = program.command("preset").description("Read a Kinetix Create preset code (KX1_\u2026) produced by kinetixui.com/create.");
+preset.command("decode").description("Show what a preset contains. Accepts a KX1_ code or a full /create?preset=\u2026 URL.").argument("<preset>", "a KX1_ code, or a share URL").option("--json", "print the configuration as JSON", false).action((input, opts) => {
+  try {
+    presetDecode(input, { json: opts.json });
+  } catch (err) {
+    console.error(pc10.red("\u2716"), err.message);
+    process.exitCode = 1;
+  }
+});
+preset.command("css").description("Resolve a preset into its web CSS override block \u2014 the same output as Copy CSS in the workspace. Web CSS only; no native (SwiftUI/Compose/Flutter) output.").argument("<preset>", "a KX1_ code, or a share URL").option("-o, --output <file>", "write to a file instead of stdout").action(async (input, opts) => {
+  try {
+    await presetCss(input, { output: opts.output });
+  } catch (err) {
+    console.error(pc10.red("\u2716"), err.message);
+    process.exitCode = 1;
+  }
+});
+preset.command("swiftui").description("Resolve a preset into a SwiftUI theme file (KinetixColors, light and dark). Colours only \u2014 SwiftUI has no radius or elevation token to carry. No Compose or Flutter output.").argument("<preset>", "a KX1_ code, or a share URL").option("-o, --output <file>", "write to a file instead of stdout").option("-n, --name <symbol>", "the Swift enum to generate", DEFAULT_SWIFT_SYMBOL).action(async (input, opts) => {
+  try {
+    await presetSwiftUi(input, { output: opts.output, name: opts.name });
+  } catch (err) {
+    console.error(pc10.red("\u2716"), err.message);
+    process.exitCode = 1;
+  }
+});
+preset.command("compose").description("Resolve a preset into a Jetpack Compose theme file (KinetixColors, light and dark). Colours only \u2014 Compose has no runtime radius or elevation token to carry. No Flutter or Android XML output.").argument("<preset>", "a KX1_ code, or a share URL").option("-o, --output <file>", "write to a file instead of stdout").option("-n, --name <symbol>", "the Kotlin object to generate", DEFAULT_COMPOSE_SYMBOL).action(async (input, opts) => {
+  try {
+    await presetCompose(input, { output: opts.output, name: opts.name });
+  } catch (err) {
+    console.error(pc10.red("\u2716"), err.message);
+    process.exitCode = 1;
+  }
+});
+preset.command("flutter").description("Resolve a preset into a Flutter theme file (KinetixColors, light and dark). Colours only \u2014 Flutter's radius and elevation are not runtime-themeable. No Android XML output.").argument("<preset>", "a KX1_ code, or a share URL").option("-o, --output <file>", "write to a file instead of stdout").option("-n, --name <symbol>", "the Dart class to generate", DEFAULT_FLUTTER_SYMBOL).action(async (input, opts) => {
+  try {
+    await presetFlutter(input, { output: opts.output, name: opts.name });
+  } catch (err) {
+    console.error(pc10.red("\u2716"), err.message);
+    process.exitCode = 1;
+  }
+});
+preset.command("url").description("Print the canonical share URL for a preset. Prints it \u2014 piping it to your opener is up to you.").argument("<preset>", "a KX1_ code, or a share URL").option("-s, --site <origin>", "site origin", "https://kinetixui.com").action((input, opts) => {
+  try {
+    presetUrlCommand(input, { site: opts.site });
+  } catch (err) {
+    console.error(pc10.red("\u2716"), err.message);
     process.exitCode = 1;
   }
 });