@loworbitstudio/visor-theme-engine 0.1.0

package/dist/index.js

@@ -0,0 +1,2414 @@
+import {
+  TAILWIND_GRAY,
+  VISOR_FONTS_CDN,
+  buildVisorFontUrl,
+  clampToSrgb,
+  compositeOverBackground,
+  generateDarkCss,
+  generateFullBundleCss,
+  generateLightCss,
+  generatePreloadLinks,
+  generatePrimitivesCss,
+  generateSemanticCss,
+  generateShadeScale,
+  generateStylesheetLinks,
+  getContrastRatio,
+  googleFontsCatalog,
+  hexToOklch,
+  hexToRgb,
+  isValidColor,
+  isValidHex,
+  lookupGoogleFont,
+  normalizeHex,
+  oklchToHex,
+  parseColor,
+  parseHex,
+  parseHsla,
+  parseOklch,
+  parseRgba,
+  resolveFont,
+  resolveThemeFonts,
+  rgbToHex,
+  rgbToOklch,
+  serializeColor
+} from "./chunk-ZLXFCNYF.js";
+
+// src/pipeline.ts
+import { parse as parseYaml } from "yaml";
+
+// src/visor-theme.schema.json
+var visor_theme_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://visor.loworbit.studio/schemas/visor-theme.schema.json",
+  title: "Visor Theme",
+  description: "Schema for .visor.yaml theme files \u2014 portable visual identity definitions for the Visor design system.",
+  type: "object",
+  required: ["name", "version", "colors"],
+  additionalProperties: false,
+  properties: {
+    name: {
+      type: "string",
+      minLength: 1,
+      description: "Human-readable theme name."
+    },
+    version: {
+      const: 1,
+      description: "Schema version. Currently always 1."
+    },
+    group: {
+      type: "string",
+      description: "Theme group for the docs site theme switcher (e.g. 'Visor', 'Client', 'Low Orbit'). Used by `visor theme sync`. Defaults to folder-based grouping when omitted."
+    },
+    colors: {
+      type: "object",
+      description: "Color definitions for light mode. Only primary is required \u2014 all others have sensible defaults.",
+      required: ["primary"],
+      additionalProperties: false,
+      properties: {
+        primary: {
+          $ref: "#/$defs/cssColor",
+          description: "Brand color. Drives interactive-*, accent-*, text-link, border-focus tokens. Anchored at shade 600."
+        },
+        accent: {
+          $ref: "#/$defs/cssColor",
+          description: "Secondary brand color. Defaults to primary if omitted."
+        },
+        neutral: {
+          $ref: "#/$defs/cssColor",
+          description: "Base neutral color for generating the gray scale (50-950). Defaults to Tailwind Gray if omitted."
+        },
+        background: {
+          $ref: "#/$defs/cssColor",
+          description: "Page background for light mode. Default: #FFFFFF."
+        },
+        surface: {
+          $ref: "#/$defs/cssColor",
+          description: "Card/panel background for light mode. Default: #FFFFFF."
+        },
+        success: {
+          $ref: "#/$defs/cssColor",
+          description: "Success status color. Default: #22C55E (Tailwind green-500)."
+        },
+        warning: {
+          $ref: "#/$defs/cssColor",
+          description: "Warning status color. Default: #F59E0B (Tailwind amber-500)."
+        },
+        error: {
+          $ref: "#/$defs/cssColor",
+          description: "Error status color. Default: #EF4444 (Tailwind red-500)."
+        },
+        info: {
+          $ref: "#/$defs/cssColor",
+          description: "Info status color. Default: #0EA5E9 (Tailwind sky-500)."
+        }
+      }
+    },
+    "colors-dark": {
+      type: "object",
+      description: "Dark mode color overrides. Any key from colors can be overridden. Omitted keys inherit from the derived dark mode values (not from light mode).",
+      additionalProperties: false,
+      properties: {
+        primary: { $ref: "#/$defs/cssColor" },
+        accent: { $ref: "#/$defs/cssColor" },
+        neutral: { $ref: "#/$defs/cssColor" },
+        background: { $ref: "#/$defs/cssColor" },
+        surface: { $ref: "#/$defs/cssColor" },
+        success: { $ref: "#/$defs/cssColor" },
+        warning: { $ref: "#/$defs/cssColor" },
+        error: { $ref: "#/$defs/cssColor" },
+        info: { $ref: "#/$defs/cssColor" }
+      }
+    },
+    typography: {
+      type: "object",
+      description: "Typography configuration. Defaults to system font stacks if omitted.",
+      additionalProperties: false,
+      properties: {
+        heading: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            family: {
+              type: "string",
+              description: "Google Fonts family name or CSS font stack."
+            },
+            weight: {
+              type: "integer",
+              minimum: 100,
+              maximum: 900,
+              description: "Font weight for headings. Default: 600."
+            },
+            source: {
+              type: "string",
+              enum: ["google-fonts", "visor-fonts", "local"],
+              description: "Font source. Defaults to Google Fonts lookup, then local."
+            },
+            org: {
+              type: "string",
+              description: "Organization namespace for visor-fonts CDN (required when source is visor-fonts)."
+            }
+          }
+        },
+        display: {
+          type: "object",
+          description: "Display/decorative font for hero text and splash screens. Falls back to heading font if omitted.",
+          additionalProperties: false,
+          properties: {
+            family: {
+              type: "string",
+              description: "Google Fonts family name or CSS font stack."
+            },
+            weight: {
+              type: "integer",
+              minimum: 100,
+              maximum: 900,
+              description: "Font weight for display text. Default: 400."
+            },
+            source: {
+              type: "string",
+              enum: ["google-fonts", "visor-fonts", "local"],
+              description: "Font source. Defaults to Google Fonts lookup, then local."
+            },
+            org: {
+              type: "string",
+              description: "Organization namespace for visor-fonts CDN (required when source is visor-fonts)."
+            }
+          }
+        },
+        body: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            family: {
+              type: "string",
+              description: "Google Fonts family name or CSS font stack."
+            },
+            weight: {
+              type: "integer",
+              minimum: 100,
+              maximum: 900,
+              description: "Font weight for body text. Default: 400."
+            },
+            source: {
+              type: "string",
+              enum: ["google-fonts", "visor-fonts", "local"],
+              description: "Font source. Defaults to Google Fonts lookup, then local."
+            },
+            org: {
+              type: "string",
+              description: "Organization namespace for visor-fonts CDN (required when source is visor-fonts)."
+            }
+          }
+        },
+        mono: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            family: {
+              type: "string",
+              description: "Google Fonts family name or CSS font stack for monospace."
+            }
+          }
+        },
+        scale: {
+          type: "number",
+          description: "Type scale multiplier applied to the font-size ramp. Default: 1."
+        },
+        "letter-spacing": {
+          type: "object",
+          description: "Letter spacing scale.",
+          additionalProperties: false,
+          properties: {
+            tight: { type: "string" },
+            normal: { type: "string" },
+            wide: { type: "string" }
+          }
+        }
+      }
+    },
+    spacing: {
+      type: "object",
+      description: "Spacing configuration.",
+      additionalProperties: false,
+      properties: {
+        base: {
+          type: "number",
+          minimum: 1,
+          description: "Base spacing unit in pixels. Default: 4. Generates the full spacing scale."
+        }
+      }
+    },
+    radius: {
+      type: "object",
+      description: "Border radius scale in pixels.",
+      additionalProperties: false,
+      properties: {
+        sm: { type: "number", minimum: 0 },
+        md: { type: "number", minimum: 0 },
+        lg: { type: "number", minimum: 0 },
+        xl: { type: "number", minimum: 0 },
+        pill: { type: "number", minimum: 0, description: "Default: 9999." }
+      }
+    },
+    shadows: {
+      type: "object",
+      description: "Named shadow definitions as CSS box-shadow values.",
+      additionalProperties: false,
+      properties: {
+        xs: { type: "string" },
+        sm: { type: "string" },
+        md: { type: "string" },
+        lg: { type: "string" },
+        xl: { type: "string" }
+      }
+    },
+    motion: {
+      type: "object",
+      description: "Motion/animation configuration.",
+      additionalProperties: false,
+      properties: {
+        "duration-fast": {
+          type: "string",
+          pattern: "^\\d+ms$",
+          description: "Fast duration for micro-interactions. Default: 100ms."
+        },
+        "duration-normal": {
+          type: "string",
+          pattern: "^\\d+ms$",
+          description: "Normal duration for standard transitions. Default: 200ms."
+        },
+        "duration-slow": {
+          type: "string",
+          pattern: "^\\d+ms$",
+          description: "Slow duration for larger animations. Default: 500ms."
+        },
+        easing: {
+          type: "string",
+          description: "Default easing curve as a CSS timing function."
+        }
+      }
+    },
+    overrides: {
+      type: "object",
+      description: "Per-token escape hatch. Values replace derived tokens. Use CSS custom property names without the -- prefix as keys.",
+      additionalProperties: false,
+      properties: {
+        light: {
+          type: "object",
+          description: "Token overrides applied in light mode.",
+          additionalProperties: { type: "string" }
+        },
+        dark: {
+          type: "object",
+          description: "Token overrides applied in dark mode.",
+          additionalProperties: { type: "string" }
+        }
+      }
+    }
+  },
+  $defs: {
+    cssColor: {
+      type: "string",
+      description: "CSS color value. Accepts hex (#RGB, #RRGGBB, #RRGGBBAA), rgb()/rgba(), hsl()/hsla(), or oklch() formats.",
+      anyOf: [
+        { pattern: "^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$" },
+        { pattern: "^rgba?\\(" },
+        { pattern: "^hsla?\\(" },
+        { pattern: "^oklch\\(" }
+      ]
+    }
+  }
+};
+
+// src/schema.ts
+var KNOWN_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "version",
+  "group",
+  "colors",
+  "colors-dark",
+  "typography",
+  "spacing",
+  "radius",
+  "shadows",
+  "motion",
+  "overrides"
+]);
+var KNOWN_COLOR_KEYS = /* @__PURE__ */ new Set([
+  "primary",
+  "accent",
+  "neutral",
+  "background",
+  "surface",
+  "success",
+  "warning",
+  "error",
+  "info"
+]);
+var KNOWN_TYPOGRAPHY_KEYS = /* @__PURE__ */ new Set([
+  "heading",
+  "display",
+  "body",
+  "mono",
+  "letter-spacing",
+  "scale"
+]);
+var KNOWN_TYPOGRAPHY_FONT_KEYS = /* @__PURE__ */ new Set(["family", "weight", "source", "org"]);
+var KNOWN_TYPOGRAPHY_MONO_KEYS = /* @__PURE__ */ new Set(["family"]);
+var KNOWN_LETTER_SPACING_KEYS = /* @__PURE__ */ new Set(["tight", "normal", "wide"]);
+var KNOWN_SPACING_KEYS = /* @__PURE__ */ new Set(["base"]);
+var KNOWN_RADIUS_KEYS = /* @__PURE__ */ new Set(["sm", "md", "lg", "xl", "pill"]);
+var KNOWN_SHADOW_KEYS = /* @__PURE__ */ new Set(["xs", "sm", "md", "lg", "xl"]);
+var KNOWN_MOTION_KEYS = /* @__PURE__ */ new Set(["duration-fast", "duration-normal", "duration-slow", "easing"]);
+var KNOWN_OVERRIDES_KEYS = /* @__PURE__ */ new Set(["light", "dark"]);
+function checkUnknownKeys(obj, errors) {
+  for (const key of Object.keys(obj)) {
+    if (!KNOWN_TOP_LEVEL_KEYS.has(key)) {
+      errors.push(`Unknown top-level key '${key}'. Valid keys: ${[...KNOWN_TOP_LEVEL_KEYS].join(", ")}`);
+    }
+  }
+  if (typeof obj.colors === "object" && obj.colors !== null) {
+    for (const key of Object.keys(obj.colors)) {
+      if (!KNOWN_COLOR_KEYS.has(key)) {
+        errors.push(`Unknown key 'colors.${key}'. Valid keys: ${[...KNOWN_COLOR_KEYS].join(", ")}`);
+      }
+    }
+  }
+  if (typeof obj["colors-dark"] === "object" && obj["colors-dark"] !== null) {
+    for (const key of Object.keys(obj["colors-dark"])) {
+      if (!KNOWN_COLOR_KEYS.has(key)) {
+        errors.push(`Unknown key 'colors-dark.${key}'. Valid keys: ${[...KNOWN_COLOR_KEYS].join(", ")}`);
+      }
+    }
+  }
+  if (typeof obj.typography === "object" && obj.typography !== null) {
+    const typo = obj.typography;
+    for (const key of Object.keys(typo)) {
+      if (!KNOWN_TYPOGRAPHY_KEYS.has(key)) {
+        errors.push(`Unknown key 'typography.${key}'. Valid keys: ${[...KNOWN_TYPOGRAPHY_KEYS].join(", ")}`);
+      }
+    }
+    if (typeof typo.heading === "object" && typo.heading !== null) {
+      for (const key of Object.keys(typo.heading)) {
+        if (!KNOWN_TYPOGRAPHY_FONT_KEYS.has(key)) {
+          errors.push(`Unknown key 'typography.heading.${key}'. Valid keys: ${[...KNOWN_TYPOGRAPHY_FONT_KEYS].join(", ")}`);
+        }
+      }
+    }
+    if (typeof typo.display === "object" && typo.display !== null) {
+      for (const key of Object.keys(typo.display)) {
+        if (!KNOWN_TYPOGRAPHY_FONT_KEYS.has(key)) {
+          errors.push(`Unknown key 'typography.display.${key}'. Valid keys: ${[...KNOWN_TYPOGRAPHY_FONT_KEYS].join(", ")}`);
+        }
+      }
+    }
+    if (typeof typo.body === "object" && typo.body !== null) {
+      for (const key of Object.keys(typo.body)) {
+        if (!KNOWN_TYPOGRAPHY_FONT_KEYS.has(key)) {
+          errors.push(`Unknown key 'typography.body.${key}'. Valid keys: ${[...KNOWN_TYPOGRAPHY_FONT_KEYS].join(", ")}`);
+        }
+      }
+    }
+    if (typeof typo.mono === "object" && typo.mono !== null) {
+      for (const key of Object.keys(typo.mono)) {
+        if (!KNOWN_TYPOGRAPHY_MONO_KEYS.has(key)) {
+          errors.push(`Unknown key 'typography.mono.${key}'. Valid keys: ${[...KNOWN_TYPOGRAPHY_MONO_KEYS].join(", ")}`);
+        }
+      }
+    }
+    if (typeof typo["letter-spacing"] === "object" && typo["letter-spacing"] !== null) {
+      for (const key of Object.keys(typo["letter-spacing"])) {
+        if (!KNOWN_LETTER_SPACING_KEYS.has(key)) {
+          errors.push(`Unknown key 'typography.letter-spacing.${key}'. Valid keys: ${[...KNOWN_LETTER_SPACING_KEYS].join(", ")}`);
+        }
+      }
+    }
+  }
+  if (typeof obj.spacing === "object" && obj.spacing !== null) {
+    for (const key of Object.keys(obj.spacing)) {
+      if (!KNOWN_SPACING_KEYS.has(key)) {
+        errors.push(`Unknown key 'spacing.${key}'. Valid keys: ${[...KNOWN_SPACING_KEYS].join(", ")}`);
+      }
+    }
+  }
+  if (typeof obj.radius === "object" && obj.radius !== null) {
+    for (const key of Object.keys(obj.radius)) {
+      if (!KNOWN_RADIUS_KEYS.has(key)) {
+        errors.push(`Unknown key 'radius.${key}'. Valid keys: ${[...KNOWN_RADIUS_KEYS].join(", ")}`);
+      }
+    }
+  }
+  if (typeof obj.shadows === "object" && obj.shadows !== null) {
+    for (const key of Object.keys(obj.shadows)) {
+      if (!KNOWN_SHADOW_KEYS.has(key)) {
+        errors.push(`Unknown key 'shadows.${key}'. Valid keys: ${[...KNOWN_SHADOW_KEYS].join(", ")}`);
+      }
+    }
+  }
+  if (typeof obj.motion === "object" && obj.motion !== null) {
+    for (const key of Object.keys(obj.motion)) {
+      if (!KNOWN_MOTION_KEYS.has(key)) {
+        errors.push(`Unknown key 'motion.${key}'. Valid keys: ${[...KNOWN_MOTION_KEYS].join(", ")}`);
+      }
+    }
+  }
+  if (typeof obj.overrides === "object" && obj.overrides !== null) {
+    for (const key of Object.keys(obj.overrides)) {
+      if (!KNOWN_OVERRIDES_KEYS.has(key)) {
+        errors.push(`Unknown key 'overrides.${key}'. Valid keys: ${[...KNOWN_OVERRIDES_KEYS].join(", ")}`);
+      }
+    }
+  }
+}
+function validateConfig(config) {
+  const errors = [];
+  if (typeof config !== "object" || config === null) {
+    return { valid: false, errors: ["Config must be an object"] };
+  }
+  const obj = config;
+  checkUnknownKeys(obj, errors);
+  if (typeof obj.name !== "string" || obj.name.length === 0) {
+    errors.push("'name' is required and must be a non-empty string");
+  }
+  if (obj.version !== 1) {
+    errors.push("'version' must be 1");
+  }
+  if (typeof obj.colors !== "object" || obj.colors === null) {
+    errors.push("'colors' is required and must be an object");
+    return { valid: false, errors };
+  }
+  const colors = obj.colors;
+  if (typeof colors.primary !== "string" || !isValidColor(colors.primary)) {
+    errors.push("'colors.primary' is required and must be a valid CSS color (hex, rgba, hsla, or oklch)");
+  }
+  const optionalColorFields = [
+    "accent",
+    "neutral",
+    "background",
+    "surface",
+    "success",
+    "warning",
+    "error",
+    "info"
+  ];
+  for (const field of optionalColorFields) {
+    if (colors[field] !== void 0) {
+      if (typeof colors[field] !== "string" || !isValidColor(colors[field])) {
+        errors.push(`'colors.${field}' must be a valid CSS color (hex, rgba, hsla, or oklch)`);
+      }
+    }
+  }
+  if (obj["colors-dark"] !== void 0) {
+    if (typeof obj["colors-dark"] !== "object" || obj["colors-dark"] === null) {
+      errors.push("'colors-dark' must be an object");
+    } else {
+      const darkColors = obj["colors-dark"];
+      const allColorFields = ["primary", ...optionalColorFields];
+      for (const field of allColorFields) {
+        if (darkColors[field] !== void 0) {
+          if (typeof darkColors[field] !== "string" || !isValidColor(darkColors[field])) {
+            errors.push(`'colors-dark.${field}' must be a valid CSS color (hex, rgba, hsla, or oklch)`);
+          }
+        }
+      }
+    }
+  }
+  if (obj.motion && typeof obj.motion === "object") {
+    const motion = obj.motion;
+    for (const key of ["duration-fast", "duration-normal", "duration-slow"]) {
+      if (motion[key] !== void 0) {
+        if (typeof motion[key] !== "string" || !/^\d+ms$/.test(motion[key])) {
+          errors.push(`'motion.${key}' must match pattern "Nms" (e.g., "200ms")`);
+        }
+      }
+    }
+  }
+  if (typeof obj.typography === "object" && obj.typography !== null) {
+    const typo = obj.typography;
+    for (const slot of ["heading", "display", "body"]) {
+      const font = typo[slot];
+      if (font && font.source === "visor-fonts" && !font.org) {
+        errors.push(`'typography.${slot}.org' is required when source is 'visor-fonts'`);
+      }
+    }
+  }
+  if (obj.overrides !== void 0) {
+    if (typeof obj.overrides !== "object" || obj.overrides === null) {
+      errors.push("'overrides' must be an object");
+    } else {
+      const overrides = obj.overrides;
+      for (const mode of ["light", "dark"]) {
+        if (overrides[mode] !== void 0) {
+          if (typeof overrides[mode] !== "object" || overrides[mode] === null) {
+            errors.push(`'overrides.${mode}' must be an object`);
+          }
+        }
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+function isVisorThemeConfig(config) {
+  return validateConfig(config).valid;
+}
+
+// src/resolve.ts
+var DEFAULT_FONT_SANS = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif';
+var DEFAULT_FONT_MONO = '"SF Mono", "Fira Code", "Fira Mono", "Roboto Mono", monospace';
+var DEFAULTS = {
+  colors: {
+    background: "#FFFFFF",
+    surface: "#FFFFFF",
+    success: "#22C55E",
+    warning: "#F59E0B",
+    error: "#EF4444",
+    info: "#0EA5E9"
+  },
+  typography: {
+    scale: 1,
+    heading: { family: DEFAULT_FONT_SANS, weight: 600 },
+    body: { family: DEFAULT_FONT_SANS, weight: 400 },
+    mono: { family: DEFAULT_FONT_MONO }
+  },
+  spacing: { base: 4 },
+  radius: { sm: 2, md: 4, lg: 8, xl: 12, pill: 9999 },
+  shadows: {
+    xs: "0 1px 1px 0 rgba(0, 0, 0, 0.04)",
+    sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)",
+    md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
+    lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1)",
+    xl: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1)"
+  },
+  motion: {
+    "duration-fast": "100ms",
+    "duration-normal": "200ms",
+    "duration-slow": "500ms",
+    easing: "cubic-bezier(0.4, 0, 0.2, 1)"
+  }
+};
+function resolveConfig(config) {
+  const colors = config.colors;
+  const originalColors = {};
+  const colorFormats = {};
+  for (const [key, value] of Object.entries(colors)) {
+    if (value !== void 0) {
+      const parsed = parseColor(value);
+      if (parsed) {
+        originalColors[key] = value;
+        if (parsed.format !== "hex") {
+          colorFormats[key] = parsed.format;
+        }
+      }
+    }
+  }
+  if (config["colors-dark"]) {
+    for (const [key, value] of Object.entries(config["colors-dark"])) {
+      if (value !== void 0) {
+        const parsed = parseColor(value);
+        if (parsed) {
+          originalColors[`dark.${key}`] = value;
+          if (parsed.format !== "hex") {
+            colorFormats[`dark.${key}`] = parsed.format;
+          }
+        }
+      }
+    }
+  }
+  return {
+    name: config.name,
+    version: 1,
+    colors: {
+      primary: colors.primary,
+      accent: colors.accent ?? colors.primary,
+      neutral: colors.neutral ?? null,
+      // null = use Tailwind Gray verbatim
+      background: colors.background ?? DEFAULTS.colors.background,
+      surface: colors.surface ?? DEFAULTS.colors.surface,
+      success: colors.success ?? DEFAULTS.colors.success,
+      warning: colors.warning ?? DEFAULTS.colors.warning,
+      error: colors.error ?? DEFAULTS.colors.error,
+      info: colors.info ?? DEFAULTS.colors.info
+    },
+    "colors-dark": config["colors-dark"],
+    typography: {
+      scale: config.typography?.scale ?? DEFAULTS.typography.scale,
+      heading: {
+        family: config.typography?.heading?.family ?? DEFAULTS.typography.heading.family,
+        weight: config.typography?.heading?.weight ?? DEFAULTS.typography.heading.weight,
+        ...config.typography?.heading?.source && { source: config.typography.heading.source },
+        ...config.typography?.heading?.org && { org: config.typography.heading.org }
+      },
+      display: {
+        family: config.typography?.display?.family ?? config.typography?.heading?.family ?? DEFAULTS.typography.heading.family,
+        weight: config.typography?.display?.weight ?? 400,
+        ...config.typography?.display?.source && { source: config.typography.display.source },
+        ...config.typography?.display?.org && { org: config.typography.display.org }
+      },
+      body: {
+        family: config.typography?.body?.family ?? DEFAULTS.typography.body.family,
+        weight: config.typography?.body?.weight ?? DEFAULTS.typography.body.weight,
+        ...config.typography?.body?.source && { source: config.typography.body.source },
+        ...config.typography?.body?.org && { org: config.typography.body.org }
+      },
+      mono: {
+        family: config.typography?.mono?.family ?? DEFAULTS.typography.mono.family
+      }
+    },
+    spacing: {
+      base: config.spacing?.base ?? DEFAULTS.spacing.base
+    },
+    radius: {
+      sm: config.radius?.sm ?? DEFAULTS.radius.sm,
+      md: config.radius?.md ?? DEFAULTS.radius.md,
+      lg: config.radius?.lg ?? DEFAULTS.radius.lg,
+      xl: config.radius?.xl ?? DEFAULTS.radius.xl,
+      pill: config.radius?.pill ?? DEFAULTS.radius.pill
+    },
+    shadows: {
+      xs: config.shadows?.xs ?? DEFAULTS.shadows.xs,
+      sm: config.shadows?.sm ?? DEFAULTS.shadows.sm,
+      md: config.shadows?.md ?? DEFAULTS.shadows.md,
+      lg: config.shadows?.lg ?? DEFAULTS.shadows.lg,
+      xl: config.shadows?.xl ?? DEFAULTS.shadows.xl
+    },
+    motion: {
+      "duration-fast": config.motion?.["duration-fast"] ?? DEFAULTS.motion["duration-fast"],
+      "duration-normal": config.motion?.["duration-normal"] ?? DEFAULTS.motion["duration-normal"],
+      "duration-slow": config.motion?.["duration-slow"] ?? DEFAULTS.motion["duration-slow"],
+      easing: config.motion?.easing ?? DEFAULTS.motion.easing
+    },
+    overrides: config.overrides,
+    originalColors,
+    colorFormats
+  };
+}
+
+// src/semantic-map.ts
+function isShadeRef(ref) {
+  return "role" in ref;
+}
+var CONFIG_BACKGROUND = "__CONFIG_BACKGROUND__";
+var CONFIG_SURFACE = "__CONFIG_SURFACE__";
+var CONFIG_DARK_BACKGROUND = "__CONFIG_DARK_BACKGROUND__";
+var CONFIG_DARK_SURFACE = "__CONFIG_DARK_SURFACE__";
+var SEMANTIC_TEXT_MAP = {
+  primary: {
+    light: { role: "neutral", shade: 900 },
+    dark: { role: "neutral", shade: 50 }
+  },
+  secondary: {
+    light: { role: "neutral", shade: 600 },
+    dark: { role: "neutral", shade: 400 }
+  },
+  tertiary: {
+    light: { role: "neutral", shade: 400 },
+    dark: { role: "neutral", shade: 500 }
+  },
+  disabled: {
+    light: { role: "neutral", shade: 300 },
+    dark: { role: "neutral", shade: 600 }
+  },
+  inverse: {
+    light: { constant: "#ffffff" },
+    dark: { role: "neutral", shade: 900 }
+  },
+  "inverse-secondary": {
+    light: { role: "neutral", shade: 200 },
+    dark: { role: "neutral", shade: 700 }
+  },
+  link: {
+    light: { role: "primary", shade: 600 },
+    dark: { role: "primary", shade: 400 }
+  },
+  "link-hover": {
+    light: { role: "primary", shade: 700 },
+    dark: { role: "primary", shade: 300 }
+  },
+  success: {
+    light: { role: "success", shade: 700 },
+    dark: { role: "success", shade: 500 }
+  },
+  warning: {
+    light: { role: "warning", shade: 700 },
+    dark: { role: "warning", shade: 500 }
+  },
+  error: {
+    light: { role: "error", shade: 700 },
+    dark: { role: "error", shade: 500 }
+  },
+  info: {
+    light: { role: "info", shade: 700 },
+    dark: { role: "info", shade: 500 }
+  }
+};
+var SEMANTIC_SURFACE_MAP = {
+  page: {
+    light: { constant: CONFIG_BACKGROUND },
+    dark: { constant: CONFIG_DARK_BACKGROUND }
+  },
+  card: {
+    light: { constant: CONFIG_SURFACE },
+    dark: { constant: CONFIG_DARK_SURFACE }
+  },
+  subtle: {
+    light: { role: "neutral", shade: 50 },
+    dark: { role: "neutral", shade: 800 }
+  },
+  muted: {
+    light: { role: "neutral", shade: 100 },
+    dark: { role: "neutral", shade: 700 }
+  },
+  overlay: {
+    light: { role: "neutral", shade: 900 },
+    dark: { role: "neutral", shade: 950 }
+  },
+  "interactive-default": {
+    light: { constant: "#ffffff" },
+    dark: { role: "neutral", shade: 800 }
+  },
+  "interactive-hover": {
+    light: { role: "neutral", shade: 50 },
+    dark: { role: "neutral", shade: 700 }
+  },
+  "interactive-active": {
+    light: { role: "neutral", shade: 100 },
+    dark: { role: "neutral", shade: 600 }
+  },
+  "interactive-disabled": {
+    light: { role: "neutral", shade: 50 },
+    dark: { role: "neutral", shade: 800 }
+  },
+  "accent-subtle": {
+    light: { role: "primary", shade: 50 },
+    dark: { role: "primary", shade: 900 }
+  },
+  "accent-default": {
+    light: { role: "primary", shade: 500 },
+    dark: { role: "primary", shade: 500 }
+  },
+  "accent-strong": {
+    light: { role: "primary", shade: 600 },
+    dark: { role: "primary", shade: 400 }
+  },
+  "success-subtle": {
+    light: { role: "success", shade: 50 },
+    dark: { role: "success", shade: 900 }
+  },
+  "success-default": {
+    light: { role: "success", shade: 500 },
+    dark: { role: "success", shade: 500 }
+  },
+  "warning-subtle": {
+    light: { role: "warning", shade: 50 },
+    dark: { role: "warning", shade: 900 }
+  },
+  "warning-default": {
+    light: { role: "warning", shade: 500 },
+    dark: { role: "warning", shade: 500 }
+  },
+  "error-subtle": {
+    light: { role: "error", shade: 50 },
+    dark: { role: "error", shade: 900 }
+  },
+  "error-default": {
+    light: { role: "error", shade: 500 },
+    dark: { role: "error", shade: 500 }
+  },
+  "info-subtle": {
+    light: { role: "info", shade: 50 },
+    dark: { role: "info", shade: 900 }
+  },
+  "info-default": {
+    light: { role: "info", shade: 500 },
+    dark: { role: "info", shade: 500 }
+  }
+};
+var SEMANTIC_BORDER_MAP = {
+  default: {
+    light: { role: "neutral", shade: 200 },
+    dark: { role: "neutral", shade: 700 }
+  },
+  muted: {
+    light: { role: "neutral", shade: 100 },
+    dark: { role: "neutral", shade: 800 }
+  },
+  strong: {
+    light: { role: "neutral", shade: 300 },
+    dark: { role: "neutral", shade: 600 }
+  },
+  focus: {
+    light: { role: "primary", shade: 500 },
+    dark: { role: "primary", shade: 400 }
+  },
+  disabled: {
+    light: { role: "neutral", shade: 100 },
+    dark: { role: "neutral", shade: 800 }
+  },
+  success: {
+    light: { role: "success", shade: 500 },
+    dark: { role: "success", shade: 500 }
+  },
+  warning: {
+    light: { role: "warning", shade: 500 },
+    dark: { role: "warning", shade: 500 }
+  },
+  error: {
+    light: { role: "error", shade: 500 },
+    dark: { role: "error", shade: 500 }
+  },
+  info: {
+    light: { role: "info", shade: 500 },
+    dark: { role: "info", shade: 500 }
+  }
+};
+var SEMANTIC_INTERACTIVE_MAP = {
+  // Primary action
+  "primary-bg": {
+    light: { role: "primary", shade: 600 },
+    dark: { role: "primary", shade: 500 }
+  },
+  "primary-bg-hover": {
+    light: { role: "primary", shade: 700 },
+    dark: { role: "primary", shade: 400 }
+  },
+  "primary-bg-active": {
+    light: { role: "primary", shade: 800 },
+    dark: { role: "primary", shade: 300 }
+  },
+  "primary-text": {
+    light: { constant: "#ffffff" },
+    dark: { constant: "#ffffff" }
+  },
+  // Secondary action
+  "secondary-bg": {
+    light: { constant: "#ffffff" },
+    dark: { role: "neutral", shade: 800 }
+  },
+  "secondary-bg-hover": {
+    light: { role: "neutral", shade: 50 },
+    dark: { role: "neutral", shade: 700 }
+  },
+  "secondary-bg-active": {
+    light: { role: "neutral", shade: 100 },
+    dark: { role: "neutral", shade: 600 }
+  },
+  "secondary-text": {
+    light: { role: "neutral", shade: 900 },
+    dark: { role: "neutral", shade: 50 }
+  },
+  "secondary-border": {
+    light: { role: "neutral", shade: 300 },
+    dark: { role: "neutral", shade: 600 }
+  },
+  // Destructive action
+  "destructive-bg": {
+    light: { role: "error", shade: 600 },
+    dark: { role: "error", shade: 500 }
+  },
+  "destructive-bg-hover": {
+    light: { role: "error", shade: 700 },
+    dark: { role: "error", shade: 600 }
+  },
+  "destructive-text": {
+    light: { constant: "#ffffff" },
+    dark: { constant: "#ffffff" }
+  },
+  // Ghost action
+  "ghost-bg": {
+    light: { constant: "#ffffff" },
+    dark: { role: "neutral", shade: 800 }
+  },
+  "ghost-bg-hover": {
+    light: { role: "neutral", shade: 100 },
+    dark: { role: "neutral", shade: 700 }
+  }
+};
+var SEMANTIC_MAP = {
+  text: SEMANTIC_TEXT_MAP,
+  surface: SEMANTIC_SURFACE_MAP,
+  border: SEMANTIC_BORDER_MAP,
+  interactive: SEMANTIC_INTERACTIVE_MAP
+};
+
+// src/assign.ts
+function lookupShade(primitives, role, shade) {
+  const scale = primitives[role];
+  const value = scale[shade];
+  if (!value) {
+    throw new Error(
+      `Missing shade ${shade} for role '${role}'. Status colors only have shades 50, 100, 500, 600, 700, 900.`
+    );
+  }
+  return value;
+}
+function resolveRef(ref, primitives, config) {
+  if (isShadeRef(ref)) {
+    return lookupShade(primitives, ref.role, ref.shade);
+  }
+  switch (ref.constant) {
+    case CONFIG_BACKGROUND:
+      return config.colors.background;
+    case CONFIG_SURFACE:
+      return config.colors.surface;
+    case CONFIG_DARK_BACKGROUND:
+      return config["colors-dark"]?.background ?? lookupShade(primitives, "neutral", 950);
+    case CONFIG_DARK_SURFACE:
+      return config["colors-dark"]?.surface ?? lookupShade(primitives, "neutral", 900);
+    default:
+      return ref.constant;
+  }
+}
+function resolveMapping(mapping, primitives, config) {
+  return {
+    light: resolveRef(mapping.light, primitives, config),
+    dark: resolveRef(mapping.dark, primitives, config)
+  };
+}
+function assignSemanticTokens(primitives, config) {
+  const text = {};
+  const surface = {};
+  const border = {};
+  const interactive = {};
+  for (const [name, mapping] of Object.entries(SEMANTIC_MAP.text)) {
+    text[name] = resolveMapping(mapping, primitives, config);
+  }
+  for (const [name, mapping] of Object.entries(SEMANTIC_MAP.surface)) {
+    surface[name] = resolveMapping(mapping, primitives, config);
+  }
+  for (const [name, mapping] of Object.entries(SEMANTIC_MAP.border)) {
+    border[name] = resolveMapping(mapping, primitives, config);
+  }
+  for (const [name, mapping] of Object.entries(SEMANTIC_MAP.interactive)) {
+    interactive[name] = resolveMapping(mapping, primitives, config);
+  }
+  return { text, surface, border, interactive };
+}
+
+// src/overrides.ts
+var TOKEN_CATEGORIES = [
+  { prefix: "text-", key: "text" },
+  { prefix: "surface-", key: "surface" },
+  { prefix: "border-", key: "border" },
+  { prefix: "interactive-", key: "interactive" }
+];
+function findToken(key, tokens) {
+  for (const { prefix, key: groupKey } of TOKEN_CATEGORIES) {
+    if (key.startsWith(prefix)) {
+      const name = key.slice(prefix.length);
+      if (name in tokens[groupKey]) {
+        return { group: tokens[groupKey], name };
+      }
+    }
+  }
+  return null;
+}
+function applyOverrides(tokens, overrides) {
+  if (!overrides) return tokens;
+  const result = {
+    text: { ...tokens.text },
+    surface: { ...tokens.surface },
+    border: { ...tokens.border },
+    interactive: { ...tokens.interactive }
+  };
+  for (const group of ["text", "surface", "border", "interactive"]) {
+    for (const [name, value] of Object.entries(result[group])) {
+      result[group][name] = { ...value };
+    }
+  }
+  if (overrides.light) {
+    for (const [key, value] of Object.entries(overrides.light)) {
+      const match = findToken(key, result);
+      if (match) {
+        match.group[match.name] = {
+          ...match.group[match.name],
+          light: value
+        };
+      }
+    }
+  }
+  if (overrides.dark) {
+    for (const [key, value] of Object.entries(overrides.dark)) {
+      const match = findToken(key, result);
+      if (match) {
+        match.group[match.name] = {
+          ...match.group[match.name],
+          dark: value
+        };
+      }
+    }
+  }
+  return result;
+}
+
+// src/pipeline.ts
+function generatePrimitives(config) {
+  return {
+    primary: generateShadeScale(config.colors.primary, "primary"),
+    accent: generateShadeScale(config.colors.accent, "accent"),
+    neutral: config.colors.neutral === null ? TAILWIND_GRAY : generateShadeScale(config.colors.neutral, "neutral"),
+    success: generateShadeScale(config.colors.success, "success"),
+    warning: generateShadeScale(config.colors.warning, "warning"),
+    error: generateShadeScale(config.colors.error, "error"),
+    info: generateShadeScale(config.colors.info, "info")
+  };
+}
+function parseConfig(yamlString) {
+  const parsed = parseYaml(yamlString);
+  const result = validateConfig(parsed);
+  if (!result.valid) {
+    throw new Error(
+      `Invalid .visor.yaml:
+${result.errors.map((e) => `  - ${e}`).join("\n")}`
+    );
+  }
+  return parsed;
+}
+function generateTheme(yamlString) {
+  const config = parseConfig(yamlString);
+  return generateThemeFromConfig(config);
+}
+function generateThemeFromConfig(config) {
+  return generateThemeDataFromConfig(config).output;
+}
+function generateThemeData(yamlString) {
+  const config = parseConfig(yamlString);
+  return generateThemeDataFromConfig(config);
+}
+function generateThemeDataFromConfig(config) {
+  const validation = validateConfig(config);
+  if (!validation.valid) {
+    throw new Error(
+      `Invalid theme config:
+${validation.errors.map((e) => `  - ${e}`).join("\n")}`
+    );
+  }
+  const resolved = resolveConfig(config);
+  const primitives = generatePrimitives(resolved);
+  let tokens = assignSemanticTokens(primitives, resolved);
+  tokens = applyOverrides(tokens, resolved.overrides);
+  const output = {
+    primitivesCss: generatePrimitivesCss(primitives, resolved),
+    semanticCss: generateSemanticCss(tokens),
+    lightCss: generateLightCss(tokens),
+    darkCss: generateDarkCss(tokens),
+    fullBundleCss: generateFullBundleCss(primitives, tokens, resolved)
+  };
+  return { config: resolved, primitives, tokens, output };
+}
+
+// src/export.ts
+import { stringify as stringifyYaml } from "yaml";
+var DEFAULT_COLORS = {
+  background: "#ffffff",
+  surface: "#ffffff",
+  success: "#22c55e",
+  warning: "#f59e0b",
+  error: "#ef4444",
+  info: "#0ea5e9"
+};
+var DEFAULT_RADIUS = { sm: 2, md: 4, lg: 8, xl: 12, pill: 9999 };
+var DEFAULT_SHADOWS = {
+  xs: "0 1px 1px 0 rgba(0, 0, 0, 0.04)",
+  sm: "0 1px 2px 0 rgba(0, 0, 0, 0.05)",
+  md: "0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -2px rgba(0, 0, 0, 0.1)",
+  lg: "0 10px 15px -3px rgba(0, 0, 0, 0.1), 0 4px 6px -4px rgba(0, 0, 0, 0.1)",
+  xl: "0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 8px 10px -6px rgba(0, 0, 0, 0.1)"
+};
+var DEFAULT_MOTION = {
+  "duration-fast": "100ms",
+  "duration-normal": "200ms",
+  "duration-slow": "500ms",
+  easing: "cubic-bezier(0.4, 0, 0.2, 1)"
+};
+var DEFAULT_FONT_SANS2 = '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif';
+var DEFAULT_FONT_MONO2 = '"SF Mono", "Fira Code", "Fira Mono", "Roboto Mono", monospace';
+function isDefaultColor(key, value) {
+  return key in DEFAULT_COLORS && value.toLowerCase() === DEFAULT_COLORS[key];
+}
+function extractAnchorColor(primitives, role) {
+  const anchorShade = role === "primary" || role === "accent" ? 600 : 500;
+  const scale = primitives[role];
+  return scale[anchorShade];
+}
+function exportTheme(primitives, config) {
+  const output = {
+    name: config.name,
+    version: 1
+  };
+  const getOriginal = (key) => config.originalColors?.[key];
+  const colors = {
+    primary: getOriginal("primary") ?? extractAnchorColor(primitives, "primary")
+  };
+  const accentOriginal = getOriginal("accent");
+  const accentHex = extractAnchorColor(primitives, "accent");
+  if (accentHex.toLowerCase() !== extractAnchorColor(primitives, "primary").toLowerCase()) {
+    colors.accent = accentOriginal ?? accentHex;
+  }
+  if (config.colors.neutral !== null) {
+    colors.neutral = getOriginal("neutral") ?? extractAnchorColor(primitives, "neutral");
+  }
+  if (config.colors.background.toLowerCase() !== DEFAULT_COLORS.background) {
+    colors.background = getOriginal("background") ?? config.colors.background;
+  }
+  if (config.colors.surface.toLowerCase() !== DEFAULT_COLORS.surface) {
+    colors.surface = getOriginal("surface") ?? config.colors.surface;
+  }
+  for (const role of ["success", "warning", "error", "info"]) {
+    const hex = extractAnchorColor(primitives, role);
+    if (!isDefaultColor(role, hex)) {
+      colors[role] = getOriginal(role) ?? hex;
+    }
+  }
+  output.colors = colors;
+  if (config["colors-dark"]) {
+    const darkColors = {};
+    for (const [key, value] of Object.entries(config["colors-dark"])) {
+      if (value) darkColors[key] = getOriginal(`dark.${key}`) ?? value;
+    }
+    if (Object.keys(darkColors).length > 0) {
+      output["colors-dark"] = darkColors;
+    }
+  }
+  const typo = {};
+  if (config.typography.heading.family !== DEFAULT_FONT_SANS2) {
+    typo.heading = { family: config.typography.heading.family };
+  }
+  if (config.typography.heading.weight !== 600) {
+    typo.heading = { ...typo.heading || {}, weight: config.typography.heading.weight };
+  }
+  if (config.typography.body.family !== DEFAULT_FONT_SANS2) {
+    typo.body = { family: config.typography.body.family };
+  }
+  if (config.typography.body.weight !== 400) {
+    typo.body = { ...typo.body || {}, weight: config.typography.body.weight };
+  }
+  if (config.typography.mono.family !== DEFAULT_FONT_MONO2) {
+    typo.mono = { family: config.typography.mono.family };
+  }
+  if (Object.keys(typo).length > 0) {
+    output.typography = typo;
+  }
+  if (config.spacing.base !== 4) {
+    output.spacing = { base: config.spacing.base };
+  }
+  const radius = {};
+  for (const [key, defaultVal] of Object.entries(DEFAULT_RADIUS)) {
+    const val = config.radius[key];
+    if (val !== defaultVal) {
+      radius[key] = val;
+    }
+  }
+  if (Object.keys(radius).length > 0) {
+    output.radius = radius;
+  }
+  const shadows = {};
+  for (const [key, defaultVal] of Object.entries(DEFAULT_SHADOWS)) {
+    const val = config.shadows[key];
+    if (val !== defaultVal) {
+      shadows[key] = val;
+    }
+  }
+  if (Object.keys(shadows).length > 0) {
+    output.shadows = shadows;
+  }
+  const motion = {};
+  for (const [key, defaultVal] of Object.entries(DEFAULT_MOTION)) {
+    const val = config.motion[key];
+    if (val !== defaultVal) {
+      motion[key] = val;
+    }
+  }
+  if (Object.keys(motion).length > 0) {
+    output.motion = motion;
+  }
+  if (config.overrides) {
+    const overrides = {};
+    if (config.overrides.light && Object.keys(config.overrides.light).length > 0) {
+      overrides.light = config.overrides.light;
+    }
+    if (config.overrides.dark && Object.keys(config.overrides.dark).length > 0) {
+      overrides.dark = config.overrides.dark;
+    }
+    if (Object.keys(overrides).length > 0) {
+      output.overrides = overrides;
+    }
+  }
+  return stringifyYaml(output, { lineWidth: 0 });
+}
+
+// src/validate.ts
+var CONTRAST_TEXT_AA = 4.5;
+var CONTRAST_INTERACTIVE_AA = 3;
+var DELTA_E_SIMILAR_THRESHOLD = 10;
+var CSS_LENGTH_RE = /^-?\d+(\.\d+)?(em|rem|px|%|ex|ch|vw|vh|cm|mm|in|pt|pc)?$/;
+var NAMED_EASINGS = /* @__PURE__ */ new Set([
+  "linear",
+  "ease",
+  "ease-in",
+  "ease-out",
+  "ease-in-out"
+]);
+var CUBIC_BEZIER_RE = /^cubic-bezier\(\s*-?\d+(\.\d+)?\s*,\s*-?\d+(\.\d+)?\s*,\s*-?\d+(\.\d+)?\s*,\s*-?\d+(\.\d+)?\s*\)$/;
+var STEPS_RE = /^steps\(\s*\d+\s*(,\s*(start|end|jump-start|jump-end|jump-none|jump-both)\s*)?\)$/;
+var KNOWN_SEMANTIC_TOKENS = /* @__PURE__ */ new Set([
+  ...Object.keys(SEMANTIC_TEXT_MAP).map((k) => `text-${k}`),
+  ...Object.keys(SEMANTIC_SURFACE_MAP).map((k) => `surface-${k}`),
+  ...Object.keys(SEMANTIC_BORDER_MAP).map((k) => `border-${k}`),
+  ...Object.keys(SEMANTIC_INTERACTIVE_MAP).map((k) => `interactive-${k}`)
+]);
+function issue(severity, code, message, path) {
+  const result = { severity, code, message };
+  if (path !== void 0) {
+    result.path = path;
+  }
+  return result;
+}
+function deltaEOklch(color1, color2) {
+  const parsed1 = parseColor(color1);
+  const parsed2 = parseColor(color2);
+  if (!parsed1 || !parsed2) return Infinity;
+  const [l1, c1, h1] = rgbToOklch(...parsed1.rgb);
+  const [l2, c2, h2] = rgbToOklch(...parsed2.rgb);
+  const h1Rad = h1 * Math.PI / 180;
+  const h2Rad = h2 * Math.PI / 180;
+  const a1 = c1 * Math.cos(h1Rad);
+  const b1 = c1 * Math.sin(h1Rad);
+  const a2 = c2 * Math.cos(h2Rad);
+  const b2 = c2 * Math.sin(h2Rad);
+  const dL = (l1 - l2) * 100;
+  const da = (a1 - a2) * 100;
+  const db = (b1 - b2) * 100;
+  return Math.sqrt(dL * dL + da * da + db * db);
+}
+function checkStructuralIntegrity(config, issues) {
+  const result = validateConfig(config);
+  if (!result.valid) {
+    for (const msg of result.errors) {
+      issues.push(issue("error", "STRUCTURAL", msg));
+    }
+    return false;
+  }
+  return true;
+}
+function checkCompleteness(config, issues) {
+  const colorEntries = Object.entries(config.colors);
+  for (const [key, value] of colorEntries) {
+    if (value !== void 0 && !isValidColor(value)) {
+      issues.push(
+        issue(
+          "error",
+          "INVALID_COLOR",
+          `'colors.${key}' is not a valid CSS color: ${value}`,
+          `colors.${key}`
+        )
+      );
+    }
+  }
+  const darkColors = config["colors-dark"];
+  if (darkColors) {
+    const darkEntries = Object.entries(darkColors);
+    for (const [key, value] of darkEntries) {
+      if (value !== void 0 && !isValidColor(value)) {
+        issues.push(
+          issue(
+            "error",
+            "INVALID_COLOR",
+            `'colors-dark.${key}' is not a valid CSS color: ${value}`,
+            `colors-dark.${key}`
+          )
+        );
+      }
+    }
+  }
+  if (config.radius) {
+    const radiusEntries = Object.entries(config.radius);
+    for (const [key, value] of radiusEntries) {
+      if (value !== void 0 && (typeof value !== "number" || value < 0)) {
+        issues.push(
+          issue(
+            "error",
+            "INVALID_RADIUS",
+            `'radius.${key}' must be a non-negative number, got: ${value}`,
+            `radius.${key}`
+          )
+        );
+      }
+    }
+  }
+  if (config.shadows) {
+    const shadowEntries = Object.entries(config.shadows);
+    for (const [key, value] of shadowEntries) {
+      if (value !== void 0) {
+        if (typeof value !== "string" || value.trim().length === 0) {
+          issues.push(
+            issue(
+              "error",
+              "INVALID_SHADOW",
+              `'shadows.${key}' must be a non-empty CSS box-shadow string`,
+              `shadows.${key}`
+            )
+          );
+        }
+      }
+    }
+  }
+  if (config.typography) {
+    const { heading, display: displayFont, body } = config.typography;
+    if (heading?.weight !== void 0) {
+      if (typeof heading.weight !== "number" || heading.weight < 100 || heading.weight > 900) {
+        issues.push(
+          issue(
+            "error",
+            "INVALID_WEIGHT",
+            `'typography.heading.weight' must be between 100 and 900, got: ${heading.weight}`,
+            "typography.heading.weight"
+          )
+        );
+      }
+    }
+    if (displayFont?.weight !== void 0) {
+      if (typeof displayFont.weight !== "number" || displayFont.weight < 100 || displayFont.weight > 900) {
+        issues.push(
+          issue(
+            "error",
+            "INVALID_WEIGHT",
+            `'typography.display.weight' must be between 100 and 900, got: ${displayFont.weight}`,
+            "typography.display.weight"
+          )
+        );
+      }
+    }
+    if (body?.weight !== void 0) {
+      if (typeof body.weight !== "number" || body.weight < 100 || body.weight > 900) {
+        issues.push(
+          issue(
+            "error",
+            "INVALID_WEIGHT",
+            `'typography.body.weight' must be between 100 and 900, got: ${body.weight}`,
+            "typography.body.weight"
+          )
+        );
+      }
+    }
+    if (heading?.family !== void 0) {
+      if (typeof heading.family !== "string" || heading.family.trim().length === 0) {
+        issues.push(
+          issue(
+            "error",
+            "INVALID_FONT_FAMILY",
+            "'typography.heading.family' must be a non-empty string",
+            "typography.heading.family"
+          )
+        );
+      }
+    }
+    if (displayFont?.family !== void 0) {
+      if (typeof displayFont.family !== "string" || displayFont.family.trim().length === 0) {
+        issues.push(
+          issue(
+            "error",
+            "INVALID_FONT_FAMILY",
+            "'typography.display.family' must be a non-empty string",
+            "typography.display.family"
+          )
+        );
+      }
+    }
+    if (body?.family !== void 0) {
+      if (typeof body.family !== "string" || body.family.trim().length === 0) {
+        issues.push(
+          issue(
+            "error",
+            "INVALID_FONT_FAMILY",
+            "'typography.body.family' must be a non-empty string",
+            "typography.body.family"
+          )
+        );
+      }
+    }
+    if (config.typography.mono?.family !== void 0) {
+      if (typeof config.typography.mono.family !== "string" || config.typography.mono.family.trim().length === 0) {
+        issues.push(
+          issue(
+            "error",
+            "INVALID_FONT_FAMILY",
+            "'typography.mono.family' must be a non-empty string",
+            "typography.mono.family"
+          )
+        );
+      }
+    }
+  }
+  if (config.spacing?.base !== void 0) {
+    if (typeof config.spacing.base !== "number" || config.spacing.base < 1) {
+      issues.push(
+        issue(
+          "error",
+          "INVALID_SPACING",
+          `'spacing.base' must be >= 1, got: ${config.spacing.base}`,
+          "spacing.base"
+        )
+      );
+    }
+  }
+}
+function checkTypeScaleCoherence(config, issues) {
+  const headingWeight = config.typography?.heading?.weight;
+  const bodyWeight = config.typography?.body?.weight;
+  if (headingWeight !== void 0 && bodyWeight !== void 0) {
+    if (headingWeight < bodyWeight) {
+      issues.push(
+        issue(
+          "error",
+          "TYPE_SCALE_INCOHERENT",
+          `Heading weight (${headingWeight}) must be >= body weight (${bodyWeight})`,
+          "typography"
+        )
+      );
+    }
+  }
+}
+function checkLetterSpacing(config, issues) {
+  const ls = config.typography?.["letter-spacing"];
+  if (!ls) return;
+  for (const key of ["tight", "normal", "wide"]) {
+    const value = ls[key];
+    if (value !== void 0) {
+      if (typeof value !== "string" || !CSS_LENGTH_RE.test(value.trim())) {
+        issues.push(
+          issue(
+            "error",
+            "INVALID_LETTER_SPACING",
+            `'typography.letter-spacing.${key}' must be a valid CSS length (e.g., "-0.05em", "0", "0.1rem"), got: ${value}`,
+            `typography.letter-spacing.${key}`
+          )
+        );
+      }
+    }
+  }
+}
+function isValidEasing(value) {
+  const trimmed = value.trim();
+  if (NAMED_EASINGS.has(trimmed)) return true;
+  if (CUBIC_BEZIER_RE.test(trimmed)) return true;
+  if (STEPS_RE.test(trimmed)) return true;
+  return false;
+}
+function checkMotionEasing(config, issues) {
+  const easing = config.motion?.easing;
+  if (easing === void 0) return;
+  if (typeof easing !== "string" || !isValidEasing(easing)) {
+    issues.push(
+      issue(
+        "error",
+        "INVALID_EASING",
+        `'motion.easing' must be a valid CSS timing function (e.g., "ease", "cubic-bezier(0.4, 0, 0.2, 1)", "steps(4, end)"), got: ${easing}`,
+        "motion.easing"
+      )
+    );
+  }
+}
+function parseDurationMs(value) {
+  const match = /^(\d+)ms$/.exec(value);
+  return match ? parseInt(match[1], 10) : null;
+}
+function checkMotionDurationRuntime(config, issues) {
+  const motion = config.motion;
+  if (!motion) return;
+  const durationKeys = ["duration-fast", "duration-normal", "duration-slow"];
+  const parsed = {};
+  for (const key of durationKeys) {
+    const value = motion[key];
+    if (value === void 0) continue;
+    const ms = parseDurationMs(value);
+    if (ms === null) continue;
+    if (ms <= 0) {
+      issues.push(
+        issue(
+          "error",
+          "INVALID_DURATION",
+          `'motion.${key}' must be > 0ms, got: ${value}`,
+          `motion.${key}`
+        )
+      );
+    } else if (ms > 1e4) {
+      issues.push(
+        issue(
+          "error",
+          "INVALID_DURATION",
+          `'motion.${key}' must be <= 10000ms, got: ${value}`,
+          `motion.${key}`
+        )
+      );
+    }
+    parsed[key] = ms;
+  }
+  if (parsed["duration-fast"] !== void 0 && parsed["duration-normal"] !== void 0) {
+    if (parsed["duration-fast"] >= parsed["duration-normal"]) {
+      issues.push(
+        issue(
+          "warning",
+          "DURATION_ORDER",
+          `'motion.duration-fast' (${parsed["duration-fast"]}ms) should be less than 'motion.duration-normal' (${parsed["duration-normal"]}ms)`,
+          "motion"
+        )
+      );
+    }
+  }
+  if (parsed["duration-normal"] !== void 0 && parsed["duration-slow"] !== void 0) {
+    if (parsed["duration-normal"] >= parsed["duration-slow"]) {
+      issues.push(
+        issue(
+          "warning",
+          "DURATION_ORDER",
+          `'motion.duration-normal' (${parsed["duration-normal"]}ms) should be less than 'motion.duration-slow' (${parsed["duration-slow"]}ms)`,
+          "motion"
+        )
+      );
+    }
+  }
+}
+function checkOverrides(config, issues) {
+  if (!config.overrides) return;
+  for (const mode of ["light", "dark"]) {
+    const modeOverrides = config.overrides[mode];
+    if (!modeOverrides) continue;
+    for (const [key, value] of Object.entries(modeOverrides)) {
+      if (typeof value !== "string" || value.trim().length === 0) {
+        issues.push(
+          issue(
+            "error",
+            "INVALID_OVERRIDE",
+            `'overrides.${mode}.${key}' must be a non-empty string`,
+            `overrides.${mode}.${key}`
+          )
+        );
+        continue;
+      }
+      if (!KNOWN_SEMANTIC_TOKENS.has(key)) {
+        issues.push(
+          issue(
+            "warning",
+            "UNKNOWN_OVERRIDE_KEY",
+            `'overrides.${mode}.${key}' does not match any known semantic token. Valid tokens include: text-primary, surface-page, border-default, interactive-primary-bg, etc.`,
+            `overrides.${mode}.${key}`
+          )
+        );
+      }
+    }
+  }
+}
+function checkResolvedCompleteness(resolved, issues) {
+  const requiredColors = [
+    "primary",
+    "accent",
+    "background",
+    "surface",
+    "success",
+    "warning",
+    "error",
+    "info"
+  ];
+  for (const key of requiredColors) {
+    const value = resolved.colors[key];
+    if (value === void 0 || value === null) {
+      if (key === "neutral") continue;
+      issues.push(
+        issue("error", "INCOMPLETE_RESOLVED", `Resolved config missing 'colors.${key}'`, `colors.${key}`)
+      );
+    }
+  }
+  if (!resolved.typography.heading.family) {
+    issues.push(issue("error", "INCOMPLETE_RESOLVED", "Resolved config missing 'typography.heading.family'", "typography.heading.family"));
+  }
+  if (!resolved.typography.body.family) {
+    issues.push(issue("error", "INCOMPLETE_RESOLVED", "Resolved config missing 'typography.body.family'", "typography.body.family"));
+  }
+  if (!resolved.typography.mono.family) {
+    issues.push(issue("error", "INCOMPLETE_RESOLVED", "Resolved config missing 'typography.mono.family'", "typography.mono.family"));
+  }
+  if (resolved.spacing.base === void 0 || resolved.spacing.base === null) {
+    issues.push(issue("error", "INCOMPLETE_RESOLVED", "Resolved config missing 'spacing.base'", "spacing.base"));
+  }
+  const requiredRadius = ["sm", "md", "lg", "xl", "pill"];
+  for (const key of requiredRadius) {
+    if (resolved.radius[key] === void 0 || resolved.radius[key] === null) {
+      issues.push(issue("error", "INCOMPLETE_RESOLVED", `Resolved config missing 'radius.${key}'`, `radius.${key}`));
+    }
+  }
+  const requiredShadows = ["xs", "sm", "md", "lg", "xl"];
+  for (const key of requiredShadows) {
+    if (!resolved.shadows[key]) {
+      issues.push(issue("error", "INCOMPLETE_RESOLVED", `Resolved config missing 'shadows.${key}'`, `shadows.${key}`));
+    }
+  }
+  const requiredMotion = [
+    "duration-fast",
+    "duration-normal",
+    "duration-slow",
+    "easing"
+  ];
+  for (const key of requiredMotion) {
+    if (!resolved.motion[key]) {
+      issues.push(issue("error", "INCOMPLETE_RESOLVED", `Resolved config missing 'motion.${key}'`, `motion.${key}`));
+    }
+  }
+}
+function colorToRgb(color) {
+  const parsed = parseColor(color);
+  return parsed ? parsed.rgb : [0, 0, 0];
+}
+function checkContrastWarnings(config, issues) {
+  const resolved = resolveConfig(config);
+  const lightBg = resolved.colors.background;
+  const lightSurface = resolved.colors.surface;
+  const primary = resolved.colors.primary;
+  const lightBgRgb = colorToRgb(lightBg);
+  const lightSurfaceRgb = colorToRgb(lightSurface);
+  const textDark = "#111827";
+  const textOnBg = getContrastRatio(textDark, lightBg, lightBgRgb);
+  if (textOnBg < CONTRAST_TEXT_AA) {
+    issues.push(
+      issue(
+        "warning",
+        "WCAG_CONTRAST",
+        `Light mode: text-primary on background has contrast ratio ${textOnBg.toFixed(2)}:1 (needs >= ${CONTRAST_TEXT_AA}:1)`,
+        "colors.background"
+      )
+    );
+  }
+  const textOnSurface = getContrastRatio(textDark, lightSurface, lightSurfaceRgb);
+  if (textOnSurface < CONTRAST_TEXT_AA) {
+    issues.push(
+      issue(
+        "warning",
+        "WCAG_CONTRAST",
+        `Light mode: text-primary on surface has contrast ratio ${textOnSurface.toFixed(2)}:1 (needs >= ${CONTRAST_TEXT_AA}:1)`,
+        "colors.surface"
+      )
+    );
+  }
+  const primaryOnBg = getContrastRatio(primary, lightBg, lightBgRgb);
+  if (primaryOnBg < CONTRAST_INTERACTIVE_AA) {
+    issues.push(
+      issue(
+        "warning",
+        "WCAG_CONTRAST",
+        `Light mode: primary color on background has contrast ratio ${primaryOnBg.toFixed(2)}:1 (needs >= ${CONTRAST_INTERACTIVE_AA}:1)`,
+        "colors.primary"
+      )
+    );
+  }
+  const primaryOnSurface = getContrastRatio(primary, lightSurface, lightSurfaceRgb);
+  if (primaryOnSurface < CONTRAST_INTERACTIVE_AA) {
+    issues.push(
+      issue(
+        "warning",
+        "WCAG_CONTRAST",
+        `Light mode: primary color on surface has contrast ratio ${primaryOnSurface.toFixed(2)}:1 (needs >= ${CONTRAST_INTERACTIVE_AA}:1)`,
+        "colors.primary"
+      )
+    );
+  }
+  const darkBg = resolved["colors-dark"]?.background ?? "#0a0a0a";
+  const darkSurface = resolved["colors-dark"]?.surface ?? "#171717";
+  const darkPrimary = resolved["colors-dark"]?.primary ?? primary;
+  const darkBgRgb = colorToRgb(darkBg);
+  const darkSurfaceRgb = colorToRgb(darkSurface);
+  const textLight = "#f9fafb";
+  const textOnDarkBg = getContrastRatio(textLight, darkBg, darkBgRgb);
+  if (textOnDarkBg < CONTRAST_TEXT_AA) {
+    issues.push(
+      issue(
+        "warning",
+        "WCAG_CONTRAST",
+        `Dark mode: text-primary on background has contrast ratio ${textOnDarkBg.toFixed(2)}:1 (needs >= ${CONTRAST_TEXT_AA}:1)`,
+        "colors-dark.background"
+      )
+    );
+  }
+  const textOnDarkSurface = getContrastRatio(textLight, darkSurface, darkSurfaceRgb);
+  if (textOnDarkSurface < CONTRAST_TEXT_AA) {
+    issues.push(
+      issue(
+        "warning",
+        "WCAG_CONTRAST",
+        `Dark mode: text-primary on surface has contrast ratio ${textOnDarkSurface.toFixed(2)}:1 (needs >= ${CONTRAST_TEXT_AA}:1)`,
+        "colors-dark.surface"
+      )
+    );
+  }
+  const darkPrimaryOnBg = getContrastRatio(darkPrimary, darkBg, darkBgRgb);
+  if (darkPrimaryOnBg < CONTRAST_INTERACTIVE_AA) {
+    issues.push(
+      issue(
+        "warning",
+        "WCAG_CONTRAST",
+        `Dark mode: primary color on background has contrast ratio ${darkPrimaryOnBg.toFixed(2)}:1 (needs >= ${CONTRAST_INTERACTIVE_AA}:1)`,
+        "colors-dark.primary"
+      )
+    );
+  }
+  const darkPrimaryOnSurface = getContrastRatio(darkPrimary, darkSurface, darkSurfaceRgb);
+  if (darkPrimaryOnSurface < CONTRAST_INTERACTIVE_AA) {
+    issues.push(
+      issue(
+        "warning",
+        "WCAG_CONTRAST",
+        `Dark mode: primary color on surface has contrast ratio ${darkPrimaryOnSurface.toFixed(2)}:1 (needs >= ${CONTRAST_INTERACTIVE_AA}:1)`,
+        "colors-dark.primary"
+      )
+    );
+  }
+}
+function checkColorSimilarity(config, issues) {
+  const resolved = resolveConfig(config);
+  const { primary, accent } = resolved.colors;
+  if (config.colors.accent === void 0) {
+    return;
+  }
+  const dE = deltaEOklch(primary, accent);
+  if (dE < DELTA_E_SIMILAR_THRESHOLD) {
+    issues.push(
+      issue(
+        "warning",
+        "COLOR_SIMILARITY",
+        `Primary and accent colors are very similar (deltaE: ${dE.toFixed(1)}). Consider using more distinct colors for better visual hierarchy.`,
+        "colors.accent"
+      )
+    );
+  }
+}
+function checkMissingGlowShadow(config, issues) {
+  if (config.shadows) {
+    const defined = Object.entries(config.shadows).filter(
+      ([, v]) => v !== void 0
+    );
+    if (defined.length > 0 && defined.length < 5) {
+      const allKeys = ["xs", "sm", "md", "lg", "xl"];
+      const missing = allKeys.filter(
+        (k) => config.shadows?.[k] === void 0
+      );
+      issues.push(
+        issue(
+          "warning",
+          "INCOMPLETE_SHADOWS",
+          `Shadow scale is partially defined \u2014 missing: ${missing.join(", ")}. Consider defining the full scale for consistency.`,
+          "shadows"
+        )
+      );
+    }
+  }
+}
+function checkRadiusScale(config, issues) {
+  if (!config.radius) return;
+  const resolved = resolveConfig(config);
+  const { sm, md, lg, xl } = resolved.radius;
+  if (sm > md) {
+    issues.push(
+      issue(
+        "warning",
+        "RADIUS_SCALE",
+        `Radius scale is not monotonically increasing: sm (${sm}) > md (${md})`,
+        "radius"
+      )
+    );
+  }
+  if (md > lg) {
+    issues.push(
+      issue(
+        "warning",
+        "RADIUS_SCALE",
+        `Radius scale is not monotonically increasing: md (${md}) > lg (${lg})`,
+        "radius"
+      )
+    );
+  }
+  if (lg > xl) {
+    issues.push(
+      issue(
+        "warning",
+        "RADIUS_SCALE",
+        `Radius scale is not monotonically increasing: lg (${lg}) > xl (${xl})`,
+        "radius"
+      )
+    );
+  }
+}
+function validate(config) {
+  const errors = [];
+  const warnings = [];
+  const structurallyValid = checkStructuralIntegrity(config, errors);
+  if (!structurallyValid) {
+    return { valid: false, errors, warnings };
+  }
+  const typedConfig = config;
+  checkCompleteness(typedConfig, errors);
+  checkTypeScaleCoherence(typedConfig, errors);
+  checkLetterSpacing(typedConfig, errors);
+  checkMotionEasing(typedConfig, errors);
+  const durationIssues = [];
+  checkMotionDurationRuntime(typedConfig, durationIssues);
+  for (const iss of durationIssues) {
+    (iss.severity === "error" ? errors : warnings).push(iss);
+  }
+  const overrideIssues = [];
+  checkOverrides(typedConfig, overrideIssues);
+  for (const iss of overrideIssues) {
+    (iss.severity === "error" ? errors : warnings).push(iss);
+  }
+  if (errors.length === 0) {
+    const resolved = resolveConfig(typedConfig);
+    checkResolvedCompleteness(resolved, errors);
+  }
+  if (errors.length === 0) {
+    checkContrastWarnings(typedConfig, warnings);
+    checkColorSimilarity(typedConfig, warnings);
+    checkMissingGlowShadow(typedConfig, warnings);
+    checkRadiusScale(typedConfig, warnings);
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+// src/extract.ts
+var ROOT_SELECTOR_RE = /(?::root|html)/;
+var DARK_SELECTOR_RE = /(?:\.dark|\[data-theme=["']dark["']\]|@custom-variant\s+dark)/;
+function parseCSSDeclarations(css) {
+  const declarations = [];
+  const cleaned = css.replace(/\/\*[\s\S]*?\*\//g, "");
+  const blocks = extractCSSBlocks(cleaned);
+  for (const block of blocks) {
+    const isDark = DARK_SELECTOR_RE.test(block.selector);
+    const isRoot = ROOT_SELECTOR_RE.test(block.selector) && !isDark;
+    const context = isDark ? "dark" : "light";
+    if (!isRoot && !isDark && !block.selector.includes(":root")) {
+      if (!block.body.includes("--")) continue;
+    }
+    if (block.body.includes("{")) continue;
+    const propRe = /(--[\w-]+)\s*:\s*([^;]+);/g;
+    let m;
+    while ((m = propRe.exec(block.body)) !== null) {
+      declarations.push({
+        property: m[1],
+        value: m[2].trim(),
+        context
+      });
+    }
+  }
+  return declarations;
+}
+function extractCSSBlocks(css) {
+  const blocks = [];
+  let i = 0;
+  while (i < css.length) {
+    const braceIdx = css.indexOf("{", i);
+    if (braceIdx === -1) break;
+    const selector = css.slice(i, braceIdx).trim();
+    let depth = 1;
+    let j = braceIdx + 1;
+    while (j < css.length && depth > 0) {
+      if (css[j] === "{") depth++;
+      if (css[j] === "}") depth--;
+      j++;
+    }
+    const body = css.slice(braceIdx + 1, j - 1);
+    if (selector) {
+      blocks.push({ selector, body });
+      if (body.includes("{")) {
+        const innerBlocks = extractCSSBlocks(body);
+        for (const inner of innerBlocks) {
+          const isDarkOuter = DARK_SELECTOR_RE.test(selector);
+          if (isDarkOuter && !DARK_SELECTOR_RE.test(inner.selector)) {
+            blocks.push({
+              selector: `.dark ${inner.selector}`,
+              body: inner.body
+            });
+          } else {
+            blocks.push(inner);
+          }
+        }
+      }
+    }
+    i = j;
+  }
+  return blocks;
+}
+var SEMANTIC_PREFIX_MAP = {
+  "--text-": "text",
+  "--surface-": "surface",
+  "--border-": "border",
+  "--interactive-": "interactive"
+};
+function findSemanticMapping(tokenName) {
+  for (const [prefix, category] of Object.entries(SEMANTIC_PREFIX_MAP)) {
+    if (tokenName.startsWith(prefix)) {
+      const key = tokenName.slice(prefix.length);
+      const map = SEMANTIC_MAP[category];
+      if (key in map) {
+        return { category, key, mapping: map[key] };
+      }
+    }
+  }
+  return null;
+}
+function isColorValue(value) {
+  if (value.startsWith("var(")) return false;
+  if (/^\d+(\.\d+)?(px|rem|em|%|ms|s)?$/.test(value)) return false;
+  if (value.includes(",") && (value.includes("sans") || value.includes("mono") || value.includes("serif"))) return false;
+  if (value.startsWith("cubic-bezier")) return false;
+  if (/^\d+px\s/.test(value)) return false;
+  return parseColor(value) !== null;
+}
+var ANCHOR_SHADES = {
+  primary: 600,
+  accent: 600,
+  neutral: 500,
+  success: 500,
+  warning: 500,
+  error: 500,
+  info: 500
+};
+var COLOR_NAME_PATTERNS = [
+  { pattern: /primary/i, role: "primary", confidence: "medium" },
+  { pattern: /accent/i, role: "accent", confidence: "medium" },
+  { pattern: /neutral|gray|grey/i, role: "neutral", confidence: "medium" },
+  { pattern: /success|green/i, role: "success", confidence: "medium" },
+  { pattern: /warning|amber|yellow|orange/i, role: "warning", confidence: "medium" },
+  { pattern: /error|danger|red|destructive/i, role: "error", confidence: "medium" },
+  { pattern: /info|blue/i, role: "info", confidence: "medium" }
+];
+function inferColorRoles(declarations) {
+  const candidates = [];
+  const unmapped = [];
+  for (const decl of declarations) {
+    const parsed = parseColor(decl.value);
+    if (!parsed) continue;
+    const semanticMatch = findSemanticMapping(decl.property);
+    if (semanticMatch) {
+      const modeRef = decl.context === "light" ? semanticMatch.mapping.light : semanticMatch.mapping.dark;
+      if (modeRef && isShadeRef(modeRef)) {
+        const ref = modeRef;
+        candidates.push({
+          role: ref.role,
+          value: decl.value,
+          parsed,
+          confidence: "high",
+          reason: `Exact match: ${decl.property} maps to ${ref.role}/${ref.shade}`,
+          shade: ref.shade
+        });
+        continue;
+      }
+    }
+    let matched = false;
+    for (const { pattern, role, confidence } of COLOR_NAME_PATTERNS) {
+      if (pattern.test(decl.property)) {
+        const shadeMatch = decl.property.match(/(\d{2,3})$/);
+        const shade = shadeMatch ? parseInt(shadeMatch[1]) : void 0;
+        candidates.push({
+          role,
+          value: decl.value,
+          parsed,
+          confidence,
+          reason: `Naming convention: ${decl.property} matches ${role} pattern`,
+          shade
+        });
+        matched = true;
+        break;
+      }
+    }
+    if (!matched) {
+      unmapped.push(decl);
+    }
+  }
+  return { candidates, unmapped };
+}
+function selectBestColors(candidates) {
+  const byRole = /* @__PURE__ */ new Map();
+  for (const c of candidates) {
+    const existing = byRole.get(c.role) ?? [];
+    existing.push(c);
+    byRole.set(c.role, existing);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [role, roleCandidates] of byRole) {
+    const anchorShade = ANCHOR_SHADES[role];
+    const sorted = [...roleCandidates].sort((a, b) => {
+      const confOrder = { high: 0, medium: 1, low: 2 };
+      const confDiff = confOrder[a.confidence] - confOrder[b.confidence];
+      if (confDiff !== 0) return confDiff;
+      const aIsAnchor = a.shade === anchorShade ? 0 : 1;
+      const bIsAnchor = b.shade === anchorShade ? 0 : 1;
+      return aIsAnchor - bIsAnchor;
+    });
+    const best = sorted[0];
+    result.set(role, {
+      value: best.value,
+      parsed: best.parsed,
+      confidence: best.confidence,
+      reason: best.reason
+    });
+  }
+  return result;
+}
+function parseFontFaceDeclarations(css) {
+  const results = [];
+  const cleaned = css.replace(/\/\*[\s\S]*?\*\//g, "");
+  const fontFaceRe = /@font-face\s*\{([^}]+)\}/g;
+  let match;
+  while ((match = fontFaceRe.exec(cleaned)) !== null) {
+    const block = match[1];
+    const decl = {};
+    const familyMatch = block.match(/font-family\s*:\s*([^;]+);/);
+    if (familyMatch) {
+      decl.family = familyMatch[1].trim().replace(/^["']|["']$/g, "");
+    }
+    const srcMatch = block.match(/src\s*:\s*([^;]+);/);
+    if (srcMatch) {
+      decl.src = srcMatch[1].trim();
+    }
+    const weightMatch = block.match(/font-weight\s*:\s*([^;]+);/);
+    if (weightMatch) {
+      decl.weight = weightMatch[1].trim();
+    }
+    const styleMatch = block.match(/font-style\s*:\s*([^;]+);/);
+    if (styleMatch) {
+      decl.style = styleMatch[1].trim();
+    }
+    if (decl.family) {
+      results.push(decl);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return results.filter((d) => {
+    const key = d.family.toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function extractTypography(declarations, fontFaces) {
+  const result = {};
+  for (const decl of declarations) {
+    const prop = decl.property;
+    const val = decl.value;
+    if (prop.includes("font-heading") || prop === "--font-family-heading") {
+      result.heading = { ...result.heading, family: cleanFontValue(val) };
+    } else if (prop.includes("font-display") || prop === "--font-family-display") {
+      result.display = { ...result.display, family: cleanFontValue(val) };
+    } else if (prop.includes("font-body") || prop.includes("font-sans") || prop === "--font-family-body") {
+      result.body = { ...result.body, family: cleanFontValue(val) };
+    } else if (prop.includes("font-mono") || prop.includes("font-code") || prop === "--font-family-mono") {
+      result.mono = { family: cleanFontValue(val) };
+    }
+    if (prop.includes("weight-heading") || prop === "--font-weight-heading") {
+      const weight = parseInt(val);
+      if (!isNaN(weight)) result.heading = { ...result.heading, weight };
+    } else if (prop.includes("weight-display") || prop === "--font-weight-display") {
+      const weight = parseInt(val);
+      if (!isNaN(weight)) result.display = { ...result.display, weight };
+    } else if (prop.includes("weight-body") || prop === "--font-weight-body") {
+      const weight = parseInt(val);
+      if (!isNaN(weight)) result.body = { ...result.body, weight };
+    }
+  }
+  if (fontFaces && fontFaces.length > 0) {
+    const MONO_INDICATORS = /mono|code|console|courier/i;
+    for (const ff of fontFaces) {
+      if (MONO_INDICATORS.test(ff.family)) {
+        if (!result.mono?.family) {
+          result.mono = { family: ff.family };
+        }
+      } else {
+        if (!result.heading?.family) {
+          result.heading = { ...result.heading, family: ff.family };
+        }
+        if (!result.body?.family) {
+          result.body = { ...result.body, family: ff.family };
+        }
+      }
+    }
+  }
+  return result;
+}
+var FALLBACK_FAMILIES = /* @__PURE__ */ new Set([
+  "sans-serif",
+  "serif",
+  "monospace",
+  "cursive",
+  "fantasy",
+  "system-ui",
+  "ui-sans-serif",
+  "ui-serif",
+  "ui-monospace",
+  "ui-rounded"
+]);
+function cleanFontValue(val) {
+  if (val.startsWith("var(")) return val;
+  const parts = val.split(",").map((p) => p.trim());
+  for (const part of parts) {
+    const cleaned = part.replace(/["']/g, "").trim();
+    if (FALLBACK_FAMILIES.has(cleaned.toLowerCase())) continue;
+    if (!cleaned) continue;
+    return cleaned;
+  }
+  return val.replace(/["']/g, "").trim();
+}
+function extractSpacing(declarations) {
+  for (const decl of declarations) {
+    if (decl.property === "--spacing-base" || decl.property === "--spacing-unit") {
+      const val = parseInt(decl.value);
+      if (!isNaN(val)) return { base: val };
+    }
+    if (decl.property === "--spacing-1") {
+      const val = parseInt(decl.value);
+      if (!isNaN(val)) return { base: val };
+    }
+  }
+  return void 0;
+}
+function extractRadius(declarations) {
+  const result = {};
+  const radiusMap = {
+    "--radius-sm": "sm",
+    "--radius-md": "md",
+    "--radius-lg": "lg",
+    "--radius-xl": "xl",
+    "--radius-pill": "pill",
+    "--border-radius-sm": "sm",
+    "--border-radius-md": "md",
+    "--border-radius-lg": "lg",
+    "--border-radius-xl": "xl",
+    "--border-radius-pill": "pill"
+  };
+  for (const decl of declarations) {
+    const key = radiusMap[decl.property];
+    if (key) {
+      const val = parseFloat(decl.value);
+      if (!isNaN(val)) result[key] = val;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function extractShadows(declarations) {
+  const result = {};
+  const shadowMap = {
+    "--shadow-xs": "xs",
+    "--shadow-sm": "sm",
+    "--shadow-md": "md",
+    "--shadow-lg": "lg",
+    "--shadow-xl": "xl"
+  };
+  for (const decl of declarations) {
+    const key = shadowMap[decl.property];
+    if (key) {
+      result[key] = decl.value;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function extractMotion(declarations) {
+  const result = {};
+  const motionMap = {
+    "--motion-duration-fast": "duration-fast",
+    "--motion-duration-normal": "duration-normal",
+    "--motion-duration-slow": "duration-slow",
+    "--motion-easing": "easing",
+    "--duration-fast": "duration-fast",
+    "--duration-normal": "duration-normal",
+    "--duration-slow": "duration-slow",
+    "--easing-default": "easing",
+    "--transition-duration-fast": "duration-fast",
+    "--transition-duration-normal": "duration-normal",
+    "--transition-duration-slow": "duration-slow"
+  };
+  for (const decl of declarations) {
+    const key = motionMap[decl.property];
+    if (key) {
+      result[key] = decl.value;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function extractBackgroundSurface(declarations) {
+  const result = {
+    light: {},
+    dark: {}
+  };
+  for (const decl of declarations) {
+    const parsed = parseColor(decl.value);
+    if (!parsed) continue;
+    if (decl.property === "--surface-page" || decl.property === "--background" || decl.property === "--bg" || decl.property === "--color-background") {
+      if (decl.context === "dark") {
+        result.dark.background = decl.value;
+      } else {
+        result.light.background = decl.value;
+      }
+    }
+    if (decl.property === "--surface-card" || decl.property === "--surface" || decl.property === "--color-surface") {
+      if (decl.context === "dark") {
+        result.dark.surface = decl.value;
+      } else {
+        result.light.surface = decl.value;
+      }
+    }
+  }
+  return result;
+}
+function extractFromCSS(files, name = "extracted-theme") {
+  const warnings = [];
+  const allDeclarations = [];
+  const allFontFaces = [];
+  for (const file of files) {
+    try {
+      const decls = parseCSSDeclarations(file.content);
+      allDeclarations.push(...decls);
+      const fontFaces = parseFontFaceDeclarations(file.content);
+      allFontFaces.push(...fontFaces);
+    } catch (err) {
+      warnings.push(`Failed to parse ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (allDeclarations.length === 0) {
+    warnings.push("No CSS custom properties found in any scanned files.");
+    return {
+      config: { name, version: 1, colors: { primary: "#6366f1" } },
+      tokens: [],
+      unmapped: [],
+      warnings
+    };
+  }
+  const colorDeclarations = allDeclarations.filter((d) => isColorValue(d.value));
+  const { candidates, unmapped: unmappedDecls } = inferColorRoles(colorDeclarations);
+  const bestColors = selectBestColors(candidates);
+  const typography = extractTypography(allDeclarations, allFontFaces);
+  const spacing = extractSpacing(allDeclarations);
+  const radius = extractRadius(allDeclarations);
+  const shadows = extractShadows(allDeclarations);
+  const motion = extractMotion(allDeclarations);
+  const bgSurface = extractBackgroundSurface(allDeclarations);
+  const tokens = [];
+  for (const candidate of candidates) {
+    tokens.push({
+      name: `colors.${candidate.role}`,
+      value: candidate.value,
+      context: "light",
+      confidence: candidate.confidence,
+      reason: candidate.reason
+    });
+  }
+  const config = {
+    name,
+    version: 1,
+    colors: {
+      primary: bestColors.get("primary")?.value ?? "#6366f1"
+    }
+  };
+  const optionalRoles = ["accent", "neutral", "success", "warning", "error", "info"];
+  for (const role of optionalRoles) {
+    const color = bestColors.get(role);
+    if (color) {
+      config.colors[role] = color.value;
+    }
+  }
+  if (bgSurface.light.background) config.colors.background = bgSurface.light.background;
+  if (bgSurface.light.surface) config.colors.surface = bgSurface.light.surface;
+  const darkColors = {};
+  if (bgSurface.dark.background) darkColors.background = bgSurface.dark.background;
+  if (bgSurface.dark.surface) darkColors.surface = bgSurface.dark.surface;
+  for (const decl of colorDeclarations) {
+    if (decl.context !== "dark") continue;
+    for (const { pattern, role } of COLOR_NAME_PATTERNS) {
+      if (pattern.test(decl.property)) {
+        darkColors[role] = decl.value;
+        break;
+      }
+    }
+  }
+  if (Object.keys(darkColors).length > 0) {
+    config["colors-dark"] = darkColors;
+  }
+  if (typography.heading || typography.display || typography.body || typography.mono) {
+    config.typography = {};
+    if (typography.heading) config.typography.heading = typography.heading;
+    if (typography.display) config.typography.display = typography.display;
+    if (typography.body) config.typography.body = typography.body;
+    if (typography.mono) config.typography.mono = typography.mono;
+  }
+  if (spacing) config.spacing = spacing;
+  if (radius) config.radius = radius;
+  if (shadows) config.shadows = shadows;
+  if (motion) config.motion = motion;
+  if (!bestColors.has("primary")) {
+    warnings.push(
+      "Could not identify a primary color. Using default (#6366f1). Review the output and set colors.primary manually."
+    );
+  }
+  const lowConfidenceTokens = tokens.filter((t) => t.confidence === "low");
+  if (lowConfidenceTokens.length > 0) {
+    warnings.push(
+      `${lowConfidenceTokens.length} token(s) extracted with low confidence \u2014 review these values.`
+    );
+  }
+  const unmapped = unmappedDecls.map((d) => ({
+    name: d.property,
+    value: d.value,
+    context: d.context
+  }));
+  return { config, tokens, unmapped, warnings };
+}
+export {
+  SEMANTIC_MAP,
+  TAILWIND_GRAY,
+  VISOR_FONTS_CDN,
+  applyOverrides,
+  assignSemanticTokens,
+  buildVisorFontUrl,
+  clampToSrgb,
+  cleanFontValue,
+  compositeOverBackground,
+  exportTheme,
+  extractFromCSS,
+  generateDarkCss,
+  generateFullBundleCss,
+  generateLightCss,
+  generatePreloadLinks,
+  generatePrimitives,
+  generatePrimitivesCss,
+  generateSemanticCss,
+  generateShadeScale,
+  generateStylesheetLinks,
+  generateTheme,
+  generateThemeData,
+  generateThemeDataFromConfig,
+  generateThemeFromConfig,
+  getContrastRatio,
+  googleFontsCatalog,
+  hexToOklch,
+  hexToRgb,
+  isValidColor,
+  isValidHex,
+  isVisorThemeConfig,
+  lookupGoogleFont,
+  normalizeHex,
+  oklchToHex,
+  parseCSSDeclarations,
+  parseColor,
+  parseConfig,
+  parseFontFaceDeclarations,
+  parseHex,
+  parseHsla,
+  parseOklch,
+  parseRgba,
+  resolveConfig,
+  resolveFont,
+  resolveThemeFonts,
+  rgbToHex,
+  serializeColor,
+  validate,
+  validateConfig,
+  visor_theme_schema_default as visorThemeSchema
+};