@loworbitstudio/visor-theme-engine 0.1.0

package/dist/chunk-ZLXFCNYF.js

@@ -0,0 +1,1399 @@
+// src/fonts/google-fonts-catalog.ts
+var googleFontsCatalog = [
+  { family: "Roboto", weights: [100, 300, 400, 500, 700, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Open Sans", weights: [300, 400, 500, 600, 700, 800], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Noto Sans", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Lato", weights: [100, 300, 400, 700, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Montserrat", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Poppins", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Roboto Condensed", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Source Sans 3", weights: [200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Inter", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Oswald", weights: [200, 300, 400, 500, 600, 700], styles: ["normal"], category: "sans-serif" },
+  { family: "Roboto Mono", weights: [100, 200, 300, 400, 500, 600, 700], styles: ["italic", "normal"], category: "monospace" },
+  { family: "Raleway", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Nunito", weights: [200, 300, 400, 500, 600, 700, 800, 900, 1e3], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Nunito Sans", weights: [200, 300, 400, 500, 600, 700, 800, 900, 1e3], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Ubuntu", weights: [300, 400, 500, 700], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Rubik", weights: [300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Playfair Display", weights: [400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "serif" },
+  { family: "Noto Sans JP", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "sans-serif" },
+  { family: "PT Sans", weights: [400, 700], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Merriweather", weights: [300, 400, 700, 900], styles: ["italic", "normal"], category: "serif" },
+  { family: "Roboto Slab", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "serif" },
+  { family: "Noto Sans KR", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "sans-serif" },
+  { family: "Kanit", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Work Sans", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Lora", weights: [400, 500, 600, 700], styles: ["italic", "normal"], category: "serif" },
+  { family: "Fira Sans", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Noto Serif", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "serif" },
+  { family: "Quicksand", weights: [300, 400, 500, 600, 700], styles: ["normal"], category: "sans-serif" },
+  { family: "Barlow", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Mulish", weights: [200, 300, 400, 500, 600, 700, 800, 900, 1e3], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "IBM Plex Sans", weights: [100, 200, 300, 400, 500, 600, 700], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Manrope", weights: [200, 300, 400, 500, 600, 700, 800], styles: ["normal"], category: "sans-serif" },
+  { family: "PT Serif", weights: [400, 700], styles: ["italic", "normal"], category: "serif" },
+  { family: "Karla", weights: [200, 300, 400, 500, 600, 700, 800], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Heebo", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "sans-serif" },
+  { family: "Noto Sans TC", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "sans-serif" },
+  { family: "Libre Franklin", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Josefin Sans", weights: [100, 200, 300, 400, 500, 600, 700], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Hind", weights: [300, 400, 500, 600, 700], styles: ["normal"], category: "sans-serif" },
+  { family: "Inconsolata", weights: [200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "monospace" },
+  { family: "DM Sans", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900, 1e3], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Libre Baskerville", weights: [400, 700], styles: ["italic", "normal"], category: "serif" },
+  { family: "Source Code Pro", weights: [200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "monospace" },
+  { family: "Mukta", weights: [200, 300, 400, 500, 600, 700, 800], styles: ["normal"], category: "sans-serif" },
+  { family: "Oxygen", weights: [300, 400, 700], styles: ["normal"], category: "sans-serif" },
+  { family: "Cabin", weights: [400, 500, 600, 700], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Source Serif 4", weights: [200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "serif" },
+  { family: "Bitter", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "serif" },
+  { family: "Abel", weights: [400], styles: ["normal"], category: "sans-serif" },
+  { family: "Exo 2", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Titillium Web", weights: [200, 300, 400, 600, 700, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "EB Garamond", weights: [400, 500, 600, 700, 800], styles: ["italic", "normal"], category: "serif" },
+  { family: "Anton", weights: [400], styles: ["normal"], category: "sans-serif" },
+  { family: "Archivo", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Cairo", weights: [200, 300, 400, 500, 600, 700, 800, 900, 1e3], styles: ["normal"], category: "sans-serif" },
+  { family: "Overpass", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Varela Round", weights: [400], styles: ["normal"], category: "sans-serif" },
+  { family: "Cormorant Garamond", weights: [300, 400, 500, 600, 700], styles: ["italic", "normal"], category: "serif" },
+  { family: "Crimson Text", weights: [400, 600, 700], styles: ["italic", "normal"], category: "serif" },
+  { family: "Outfit", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "sans-serif" },
+  { family: "Dosis", weights: [200, 300, 400, 500, 600, 700, 800], styles: ["normal"], category: "sans-serif" },
+  { family: "Comfortaa", weights: [300, 400, 500, 600, 700], styles: ["normal"], category: "display" },
+  { family: "Assistant", weights: [200, 300, 400, 500, 600, 700, 800], styles: ["normal"], category: "sans-serif" },
+  { family: "IBM Plex Mono", weights: [100, 200, 300, 400, 500, 600, 700], styles: ["italic", "normal"], category: "monospace" },
+  { family: "Signika", weights: [300, 400, 500, 600, 700], styles: ["normal"], category: "sans-serif" },
+  { family: "Space Grotesk", weights: [300, 400, 500, 600, 700], styles: ["normal"], category: "sans-serif" },
+  { family: "Space Mono", weights: [400, 700], styles: ["italic", "normal"], category: "monospace" },
+  { family: "Catamaran", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "sans-serif" },
+  { family: "Arimo", weights: [400, 500, 600, 700], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Figtree", weights: [300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Teko", weights: [300, 400, 500, 600, 700], styles: ["normal"], category: "sans-serif" },
+  { family: "Nanum Gothic", weights: [400, 700, 800], styles: ["normal"], category: "sans-serif" },
+  { family: "Lexend", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "sans-serif" },
+  { family: "Prompt", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Fira Code", weights: [300, 400, 500, 600, 700], styles: ["normal"], category: "monospace" },
+  { family: "Plus Jakarta Sans", weights: [200, 300, 400, 500, 600, 700, 800], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Barlow Condensed", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Crimson Pro", weights: [200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "serif" },
+  { family: "Fjalla One", weights: [400], styles: ["normal"], category: "sans-serif" },
+  { family: "Maven Pro", weights: [400, 500, 600, 700, 800, 900], styles: ["normal"], category: "sans-serif" },
+  { family: "Sora", weights: [100, 200, 300, 400, 500, 600, 700, 800], styles: ["normal"], category: "sans-serif" },
+  { family: "Asap", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Red Hat Display", weights: [300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Yanone Kaffeesatz", weights: [200, 300, 400, 500, 600, 700], styles: ["normal"], category: "sans-serif" },
+  { family: "Bebas Neue", weights: [400], styles: ["normal"], category: "sans-serif" },
+  { family: "Philosopher", weights: [400, 700], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Edu Australia VIC WA NT Hand", weights: [400, 500, 600, 700], styles: ["normal"], category: "handwriting" },
+  { family: "Jost", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Albert Sans", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Spectral", weights: [200, 300, 400, 500, 600, 700, 800], styles: ["italic", "normal"], category: "serif" },
+  { family: "Urbanist", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Vollkorn", weights: [400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "serif" },
+  { family: "Gelasio", weights: [400, 500, 600, 700], styles: ["italic", "normal"], category: "serif" },
+  { family: "JetBrains Mono", weights: [100, 200, 300, 400, 500, 600, 700, 800], styles: ["italic", "normal"], category: "monospace" },
+  { family: "Arvo", weights: [400, 700], styles: ["italic", "normal"], category: "serif" },
+  { family: "Rajdhani", weights: [300, 400, 500, 600, 700], styles: ["normal"], category: "sans-serif" },
+  { family: "Archivo Narrow", weights: [400, 500, 600, 700], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Public Sans", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Noto Sans SC", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "sans-serif" },
+  { family: "Prata", weights: [400], styles: ["normal"], category: "serif" },
+  { family: "Questrial", weights: [400], styles: ["normal"], category: "sans-serif" },
+  { family: "Saira", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Red Hat Text", weights: [300, 400, 500, 600, 700], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Atkinson Hyperlegible", weights: [400, 700], styles: ["italic", "normal"], category: "sans-serif" },
+  { family: "Bricolage Grotesque", weights: [200, 300, 400, 500, 600, 700, 800], styles: ["normal"], category: "sans-serif" },
+  { family: "Geist", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "sans-serif" },
+  { family: "Geist Mono", weights: [100, 200, 300, 400, 500, 600, 700, 800, 900], styles: ["normal"], category: "monospace" }
+];
+var catalogMap = /* @__PURE__ */ new Map();
+for (const entry of googleFontsCatalog) {
+  catalogMap.set(entry.family.toLowerCase(), entry);
+}
+function lookupGoogleFont(family) {
+  return catalogMap.get(family.toLowerCase());
+}
+
+// src/fonts/resolve.ts
+var DEFAULT_WEIGHTS = [400, 700];
+var DEFAULT_DISPLAY = "swap";
+function buildGoogleFontsCssUrl(family, weights, italic, display) {
+  const encodedFamily = family.replace(/ /g, "+");
+  const tuples = [];
+  const sortedWeights = [...weights].sort((a, b) => a - b);
+  if (italic) {
+    for (const w of sortedWeights) {
+      tuples.push(`0,${w}`);
+    }
+    for (const w of sortedWeights) {
+      tuples.push(`1,${w}`);
+    }
+    return `https://fonts.googleapis.com/css2?family=${encodedFamily}:ital,wght@${tuples.join(";")}&display=${display}`;
+  }
+  const wghtValues = sortedWeights.join(";");
+  return `https://fonts.googleapis.com/css2?family=${encodedFamily}:wght@${wghtValues}&display=${display}`;
+}
+var VISOR_FONTS_CDN = "https://fonts.visor.design";
+function buildFamilySlug(family) {
+  return family.toLowerCase().replace(/ /g, "-");
+}
+function buildFamilyPrefix(family) {
+  return family.replace(/ /g, "");
+}
+var WEIGHT_NAMES = {
+  100: "Thin",
+  200: "ExtraLight",
+  300: "Light",
+  400: "Regular",
+  500: "Medium",
+  600: "SemiBold",
+  700: "Bold",
+  800: "ExtraBold",
+  900: "Black"
+};
+function buildVisorFontUrl(org, family, weight) {
+  const slug = buildFamilySlug(family);
+  const prefix = buildFamilyPrefix(family);
+  const weightName = WEIGHT_NAMES[weight] ?? `W${weight}`;
+  return `${VISOR_FONTS_CDN}/${org}/${slug}/${prefix}-${weightName}.woff2`;
+}
+function resolveFont(family, options = {}) {
+  const display = options.display ?? DEFAULT_DISPLAY;
+  const requestedWeights = options.weights ?? DEFAULT_WEIGHTS;
+  const italic = options.italic ?? false;
+  const explicitSource = options.source;
+  if (explicitSource === "visor-fonts") {
+    return {
+      family,
+      source: "visor-fonts",
+      cssUrl: null,
+      weights: requestedWeights,
+      italic,
+      display,
+      category: options.category ?? "sans-serif",
+      guidance: null,
+      org: options.org ?? null
+    };
+  }
+  if (explicitSource === "local") {
+    return {
+      family,
+      source: "local",
+      cssUrl: null,
+      weights: requestedWeights,
+      italic,
+      display,
+      category: options.category ?? "sans-serif",
+      guidance: `"${family}" is a local font. To use this font:
+  1. Add the font files (.woff2) to your project's public/fonts/ directory
+  2. Create @font-face declarations in your theme CSS
+  3. Reference the font family in your theme's --font-display or --font-body token`,
+      org: null
+    };
+  }
+  const catalogEntry = lookupGoogleFont(family);
+  if (catalogEntry) {
+    const availableWeights = requestedWeights.filter(
+      (w) => catalogEntry.weights.includes(w)
+    );
+    const weights = availableWeights.length > 0 ? availableWeights : catalogEntry.weights;
+    const hasItalic = catalogEntry.styles.includes("italic");
+    const resolvedItalic = italic && hasItalic;
+    const cssUrl = buildGoogleFontsCssUrl(
+      catalogEntry.family,
+      weights,
+      resolvedItalic,
+      display
+    );
+    return {
+      family: catalogEntry.family,
+      // Use canonical casing from catalog
+      source: "google-fonts",
+      cssUrl,
+      weights,
+      italic: resolvedItalic,
+      display,
+      category: catalogEntry.category,
+      guidance: null,
+      org: null
+    };
+  }
+  return {
+    family,
+    source: "local",
+    cssUrl: null,
+    weights: requestedWeights,
+    italic,
+    display,
+    category: options.category ?? "sans-serif",
+    guidance: `"${family}" is not available on Google Fonts. To use this font:
+  1. Add the font files (.woff2) to your project's public/fonts/ directory
+  2. Create @font-face declarations in your theme CSS
+  3. Reference the font family in your theme's --font-display or --font-body token`,
+    org: null
+  };
+}
+
+// src/fonts/preload.ts
+var GOOGLE_FONTS_ORIGIN = "https://fonts.googleapis.com";
+var GOOGLE_FONTS_STATIC_ORIGIN = "https://fonts.gstatic.com";
+function generatePreloadLinks(resolutions, customFontPaths) {
+  const links = [];
+  const hasGoogleFonts = resolutions.some((r) => r.source === "google-fonts");
+  if (hasGoogleFonts) {
+    links.push(
+      `<link rel="preconnect" href="${GOOGLE_FONTS_ORIGIN}">`
+    );
+    links.push(
+      `<link rel="preconnect" href="${GOOGLE_FONTS_STATIC_ORIGIN}" crossorigin>`
+    );
+    for (const resolution of resolutions) {
+      if (resolution.source === "google-fonts" && resolution.cssUrl) {
+        links.push(
+          `<link rel="preload" as="style" href="${resolution.cssUrl}">`
+        );
+      }
+    }
+  }
+  const hasVisorFonts = resolutions.some((r) => r.source === "visor-fonts");
+  if (hasVisorFonts) {
+    links.push(
+      `<link rel="preconnect" href="${VISOR_FONTS_CDN}" crossorigin>`
+    );
+    for (const resolution of resolutions) {
+      if (resolution.source === "visor-fonts" && resolution.org) {
+        for (const weight of resolution.weights) {
+          const url = buildVisorFontUrl(resolution.org, resolution.family, weight);
+          links.push(
+            `<link rel="preload" as="font" type="font/woff2" href="${url}" crossorigin>`
+          );
+        }
+      }
+    }
+  }
+  if (customFontPaths) {
+    for (const resolution of resolutions) {
+      if (resolution.source === "local") {
+        const paths = customFontPaths.get(resolution.family);
+        if (paths) {
+          for (const path of paths) {
+            links.push(
+              `<link rel="preload" as="font" type="font/woff2" href="${path}" crossorigin>`
+            );
+          }
+        }
+      }
+    }
+  }
+  return links;
+}
+function generateStylesheetLinks(resolutions) {
+  const links = [];
+  for (const resolution of resolutions) {
+    if (resolution.source === "google-fonts" && resolution.cssUrl) {
+      links.push(
+        `<link rel="stylesheet" href="${resolution.cssUrl}">`
+      );
+    }
+  }
+  return links;
+}
+
+// src/fonts/pipeline.ts
+function generateFontCSS(heading, displayFont, body, mono, typography) {
+  const lines = [];
+  const allSlots = [heading, displayFont, body, mono];
+  const googleFonts = allSlots.filter(
+    (r) => r !== null && r.source === "google-fonts"
+  );
+  if (googleFonts.length > 0) {
+    lines.push("/* Google Fonts \u2014 load these stylesheets in your HTML <head> */");
+    for (const font of googleFonts) {
+      lines.push(`/* ${font.cssUrl} */`);
+    }
+    lines.push("");
+  }
+  const visorFonts = allSlots.filter(
+    (r) => r !== null && r.source === "visor-fonts"
+  );
+  const seenVisorFonts = /* @__PURE__ */ new Set();
+  if (visorFonts.length > 0) {
+    lines.push("/* Visor Fonts \u2014 CDN-hosted @font-face declarations */");
+    for (const font of visorFonts) {
+      if (seenVisorFonts.has(font.family)) continue;
+      seenVisorFonts.add(font.family);
+      for (const weight of font.weights) {
+        const url = buildVisorFontUrl(font.org ?? "", font.family, weight);
+        lines.push(`@font-face {`);
+        lines.push(`  font-family: "${font.family}";`);
+        lines.push(`  src: url("${url}") format("woff2");`);
+        lines.push(`  font-weight: ${weight};`);
+        lines.push(`  font-style: ${font.italic ? "italic" : "normal"};`);
+        lines.push(`  font-display: ${font.display};`);
+        lines.push(`}`);
+        lines.push("");
+      }
+    }
+  }
+  const localFonts = allSlots.filter(
+    (r) => r !== null && r.source === "local"
+  );
+  if (localFonts.length > 0) {
+    lines.push(
+      "/* Local fonts \u2014 add your @font-face declarations below */"
+    );
+    for (const font of localFonts) {
+      lines.push(`/* @font-face {`);
+      lines.push(`     font-family: "${font.family}";`);
+      lines.push(`     src: url("/fonts/${font.family.replace(/ /g, "-").toLowerCase()}.woff2") format("woff2");`);
+      lines.push(`     font-weight: ${font.weights.length === 1 ? font.weights[0] : `${font.weights[0]} ${font.weights[font.weights.length - 1]}`};`);
+      lines.push(`     font-style: ${font.italic ? "italic" : "normal"};`);
+      lines.push(`     font-display: ${font.display};`);
+      lines.push(`   } */`);
+      lines.push("");
+    }
+  }
+  const allFonts = allSlots.filter(
+    (r) => r !== null
+  );
+  const seenFamilies = /* @__PURE__ */ new Set();
+  for (const font of allFonts) {
+    if (!seenFamilies.has(font.family)) {
+      seenFamilies.add(font.family);
+      lines.push(generateFallbackFontFace(font));
+      lines.push("");
+    }
+  }
+  const overrides = [];
+  if (heading) {
+    const fallbackName = `${heading.family} Fallback`;
+    const fallback = getFallbackStack(heading);
+    overrides.push(
+      `  --font-heading: "${heading.family}", "${fallbackName}", ${fallback};`
+    );
+  }
+  if (displayFont) {
+    const fallbackName = `${displayFont.family} Fallback`;
+    const fallback = getFallbackStack(displayFont);
+    overrides.push(
+      `  --font-display: "${displayFont.family}", "${fallbackName}", ${fallback};`
+    );
+  }
+  if (body) {
+    const fallbackName = `${body.family} Fallback`;
+    const fallback = getFallbackStack(body);
+    overrides.push(`  --font-body: "${body.family}", "${fallbackName}", ${fallback};`);
+    overrides.push(`  --font-sans: "${body.family}", "${fallbackName}", ${fallback};`);
+  }
+  if (mono) {
+    const fallbackName = `${mono.family} Fallback`;
+    const fallback = getFallbackStack(mono);
+    overrides.push(`  --font-mono: "${mono.family}", "${fallbackName}", ${fallback};`);
+  }
+  if (typography.heading?.weight) {
+    overrides.push(
+      `  --weight-heading: ${typography.heading.weight};`
+    );
+  }
+  if (typography.display?.weight) {
+    overrides.push(
+      `  --weight-display: ${typography.display.weight};`
+    );
+  }
+  if (typography.body?.weight) {
+    overrides.push(
+      `  --weight-body: ${typography.body.weight};`
+    );
+  }
+  if (overrides.length > 0) {
+    lines.push(":root {");
+    lines.push(...overrides);
+    lines.push("}");
+  }
+  return lines.join("\n");
+}
+function getFallbackStack(resolution) {
+  switch (resolution.category) {
+    case "serif":
+      return 'Georgia, "Times New Roman", Times, serif';
+    case "monospace":
+      return '"SF Mono", "Fira Code", "Fira Mono", "Roboto Mono", monospace';
+    case "display":
+    case "handwriting":
+    case "sans-serif":
+    default:
+      return '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif';
+  }
+}
+function generateFallbackFontFace(resolution) {
+  const fallbackName = `${resolution.family} Fallback`;
+  const systemFont = getSystemFallbackFont(resolution.category);
+  const sizeAdjust = getSizeAdjust(resolution.category);
+  return [
+    `@font-face {`,
+    `  font-family: "${fallbackName}";`,
+    `  src: local("${systemFont}");`,
+    `  size-adjust: ${sizeAdjust};`,
+    `  ascent-override: 100%;`,
+    `  descent-override: 20%;`,
+    `  line-gap-override: 0%;`,
+    `}`
+  ].join("\n");
+}
+function getSystemFallbackFont(category) {
+  switch (category) {
+    case "serif":
+      return "Georgia";
+    case "monospace":
+      return "Courier New";
+    default:
+      return "Arial";
+  }
+}
+function getSizeAdjust(category) {
+  switch (category) {
+    case "serif":
+      return "105%";
+    case "monospace":
+      return "100%";
+    default:
+      return "107%";
+  }
+}
+function resolveThemeFonts(typography, options) {
+  const display = options?.display ?? "swap";
+  const warnings = [];
+  let headingResolution = null;
+  if (typography.heading?.family) {
+    const weights = [];
+    if (typography.heading.weight) weights.push(typography.heading.weight);
+    headingResolution = resolveFont(typography.heading.family, {
+      weights: weights.length > 0 ? weights : void 0,
+      display,
+      source: typography.heading.source,
+      org: typography.heading.org
+    });
+    if (headingResolution.guidance) {
+      warnings.push(headingResolution.guidance);
+    }
+  }
+  let bodyResolution = null;
+  if (typography.body?.family) {
+    const bodyWeights = [];
+    if (typography.body.weight) bodyWeights.push(typography.body.weight);
+    if (!bodyWeights.includes(400)) bodyWeights.push(400);
+    if (!bodyWeights.includes(700)) bodyWeights.push(700);
+    if (headingResolution && typography.body.family.toLowerCase() === headingResolution.family.toLowerCase()) {
+      const mergedWeights = Array.from(
+        /* @__PURE__ */ new Set([...headingResolution.weights, ...bodyWeights])
+      ).sort((a, b) => a - b);
+      headingResolution = resolveFont(typography.heading.family, {
+        weights: mergedWeights,
+        display,
+        source: typography.heading.source,
+        org: typography.heading.org
+      });
+      bodyResolution = headingResolution;
+    } else {
+      bodyResolution = resolveFont(typography.body.family, {
+        weights: bodyWeights.length > 0 ? bodyWeights : void 0,
+        display,
+        source: typography.body.source,
+        org: typography.body.org
+      });
+      if (bodyResolution.guidance) {
+        warnings.push(bodyResolution.guidance);
+      }
+    }
+  }
+  let displayResolution = null;
+  if (typography.display?.family) {
+    const displayWeights = [];
+    if (typography.display.weight) displayWeights.push(typography.display.weight);
+    if (headingResolution && typography.display.family.toLowerCase() === headingResolution.family.toLowerCase()) {
+      const mergedWeights = Array.from(
+        /* @__PURE__ */ new Set([...headingResolution.weights, ...displayWeights])
+      ).sort((a, b) => a - b);
+      headingResolution = resolveFont(typography.heading.family, {
+        weights: mergedWeights,
+        display,
+        source: typography.heading.source,
+        org: typography.heading.org
+      });
+      displayResolution = headingResolution;
+    } else if (bodyResolution && typography.display.family.toLowerCase() === bodyResolution.family.toLowerCase()) {
+      const mergedWeights = Array.from(
+        /* @__PURE__ */ new Set([...bodyResolution.weights, ...displayWeights])
+      ).sort((a, b) => a - b);
+      bodyResolution = resolveFont(typography.body.family, {
+        weights: mergedWeights,
+        display,
+        source: typography.body.source,
+        org: typography.body.org
+      });
+      displayResolution = bodyResolution;
+    } else {
+      displayResolution = resolveFont(typography.display.family, {
+        weights: displayWeights.length > 0 ? displayWeights : void 0,
+        display,
+        source: typography.display.source,
+        org: typography.display.org
+      });
+      if (displayResolution.guidance) {
+        warnings.push(displayResolution.guidance);
+      }
+    }
+  }
+  let monoResolution = null;
+  if (typography.mono?.family) {
+    const monoWeights = [];
+    if (typography.mono.weight) monoWeights.push(typography.mono.weight);
+    monoResolution = resolveFont(typography.mono.family, {
+      weights: monoWeights.length > 0 ? monoWeights : void 0,
+      display,
+      source: typography.mono.source,
+      org: typography.mono.org,
+      category: "monospace"
+    });
+    if (monoResolution.guidance) {
+      warnings.push(monoResolution.guidance);
+    }
+  }
+  const allResolutions = [];
+  if (headingResolution) allResolutions.push(headingResolution);
+  if (displayResolution && displayResolution !== headingResolution) {
+    allResolutions.push(displayResolution);
+  }
+  if (bodyResolution && bodyResolution !== headingResolution && bodyResolution !== displayResolution) {
+    allResolutions.push(bodyResolution);
+  }
+  if (monoResolution) allResolutions.push(monoResolution);
+  const preloadLinks = generatePreloadLinks(allResolutions);
+  const stylesheetLinks = generateStylesheetLinks(allResolutions);
+  const allLinks = [...preloadLinks, ...stylesheetLinks];
+  const css = generateFontCSS(headingResolution, displayResolution, bodyResolution, monoResolution, typography);
+  return {
+    heading: headingResolution,
+    display: displayResolution,
+    body: bodyResolution,
+    mono: monoResolution,
+    preloadLinks: allLinks,
+    css,
+    warnings
+  };
+}
+
+// src/color.ts
+function normalizeHex(hex) {
+  let color = hex.replace(/^#/, "");
+  if (color.length === 3) {
+    color = color[0] + color[0] + color[1] + color[1] + color[2] + color[2];
+  }
+  if (color.length === 8) {
+    color = color.slice(0, 6);
+  }
+  if (!/^[0-9a-fA-F]{6}$/.test(color)) {
+    return null;
+  }
+  return `#${color.toLowerCase()}`;
+}
+function isValidHex(hex) {
+  return normalizeHex(hex) !== null;
+}
+function hexToRgb(hex) {
+  const normalized = normalizeHex(hex);
+  if (!normalized) {
+    throw new Error(`Invalid hex color: ${hex}`);
+  }
+  return [
+    parseInt(normalized.slice(1, 3), 16),
+    parseInt(normalized.slice(3, 5), 16),
+    parseInt(normalized.slice(5, 7), 16)
+  ];
+}
+function rgbToHex(rgb) {
+  const [r, g, b] = rgb.map((c) => Math.round(Math.max(0, Math.min(255, c))));
+  return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
+}
+function toLinear(c) {
+  c /= 255;
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function fromLinear(c) {
+  return c <= 31308e-7 ? c * 12.92 : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+}
+function rgbToOklch(r, g, b) {
+  const lr = toLinear(r);
+  const lg = toLinear(g);
+  const lb = toLinear(b);
+  const x = 0.4124564 * lr + 0.3575761 * lg + 0.1804375 * lb;
+  const y = 0.2126729 * lr + 0.7151522 * lg + 0.072175 * lb;
+  const z = 0.0193339 * lr + 0.119192 * lg + 0.9503041 * lb;
+  const l_ = 0.8189330101 * x + 0.3618667424 * y - 0.1288597137 * z;
+  const m_ = 0.0329845436 * x + 0.9293118715 * y + 0.0361456387 * z;
+  const s_ = 0.0482003018 * x + 0.2643662691 * y + 0.633851707 * z;
+  const lCbrt = Math.cbrt(l_);
+  const mCbrt = Math.cbrt(m_);
+  const sCbrt = Math.cbrt(s_);
+  const L = 0.2104542553 * lCbrt + 0.793617785 * mCbrt - 0.0040720468 * sCbrt;
+  const a = 1.9779984951 * lCbrt - 2.428592205 * mCbrt + 0.4505937099 * sCbrt;
+  const okb = 0.0259040371 * lCbrt + 0.7827717662 * mCbrt - 0.808675766 * sCbrt;
+  const C = Math.sqrt(a * a + okb * okb);
+  let H = Math.atan2(okb, a) * (180 / Math.PI);
+  if (H < 0) H += 360;
+  return [L, C, H];
+}
+function hexToOklch(hex) {
+  return rgbToOklch(...hexToRgb(hex));
+}
+function oklchToLinearRgb(L, C, H) {
+  const hRad = H * (Math.PI / 180);
+  const a = C * Math.cos(hRad);
+  const okb = C * Math.sin(hRad);
+  const l_ = L + 0.3963377774 * a + 0.2158037573 * okb;
+  const m_ = L - 0.1055613458 * a - 0.0638541728 * okb;
+  const s_ = L - 0.0894841775 * a - 1.291485548 * okb;
+  const l = l_ * l_ * l_;
+  const m = m_ * m_ * m_;
+  const s = s_ * s_ * s_;
+  const lr = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+  const lg = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+  const lb = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
+  return [lr, lg, lb];
+}
+function isInGamut(lr, lg, lb) {
+  const eps = 1e-4;
+  return lr >= -eps && lr <= 1 + eps && lg >= -eps && lg <= 1 + eps && lb >= -eps && lb <= 1 + eps;
+}
+function clampToSrgb(L, C, H) {
+  const [lr, lg, lb] = oklchToLinearRgb(L, C, H);
+  if (isInGamut(lr, lg, lb)) {
+    return [
+      Math.round(fromLinear(Math.max(0, Math.min(1, lr))) * 255),
+      Math.round(fromLinear(Math.max(0, Math.min(1, lg))) * 255),
+      Math.round(fromLinear(Math.max(0, Math.min(1, lb))) * 255)
+    ];
+  }
+  let lo = 0;
+  let hi = C;
+  const tolerance = 1e-3;
+  while (hi - lo > tolerance) {
+    const mid = (lo + hi) / 2;
+    const [r2, g2, b2] = oklchToLinearRgb(L, mid, H);
+    if (isInGamut(r2, g2, b2)) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  const [r, g, b] = oklchToLinearRgb(L, lo, H);
+  return [
+    Math.round(fromLinear(Math.max(0, Math.min(1, r))) * 255),
+    Math.round(fromLinear(Math.max(0, Math.min(1, g))) * 255),
+    Math.round(fromLinear(Math.max(0, Math.min(1, b))) * 255)
+  ];
+}
+function oklchToHex(L, C, H) {
+  return rgbToHex(clampToSrgb(L, C, H));
+}
+function getLuminance(r, g, b) {
+  const [rs, gs, bs] = [r, g, b].map((c) => {
+    c = c / 255;
+    return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * rs + 0.7152 * gs + 0.0722 * bs;
+}
+function getContrastRatio(color1, color2, compositeBackground) {
+  const resolved1 = resolveContrastColor(color1, compositeBackground);
+  const resolved2 = resolveContrastColor(color2, compositeBackground);
+  const l1 = getLuminance(...resolved1);
+  const l2 = getLuminance(...resolved2);
+  const lighter = Math.max(l1, l2);
+  const darker = Math.min(l1, l2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function resolveContrastColor(color, compositeBackground) {
+  if (typeof color === "string") {
+    const parsed = parseColor(color);
+    if (!parsed) {
+      throw new Error(`Invalid color: ${color}`);
+    }
+    if (parsed.alpha !== void 0 && parsed.alpha < 1 && compositeBackground) {
+      return compositeOverBackground(parsed, compositeBackground);
+    }
+    return parsed.rgb;
+  }
+  if (color.alpha !== void 0 && color.alpha < 1 && compositeBackground) {
+    return compositeOverBackground(color, compositeBackground);
+  }
+  return color.rgb;
+}
+function parseHex(str) {
+  const trimmed = str.trim();
+  const stripped = trimmed.replace(/^#/, "");
+  let alpha;
+  if (stripped.length === 8) {
+    alpha = parseInt(stripped.slice(6, 8), 16) / 255;
+  }
+  const normalized = normalizeHex(trimmed);
+  if (!normalized) return null;
+  return {
+    rgb: hexToRgb(normalized),
+    alpha,
+    format: "hex",
+    original: trimmed
+  };
+}
+var RGBA_RE = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(?:,\s*([01]?\.?\d*))?\s*\)$/;
+function parseRgba(str) {
+  const trimmed = str.trim();
+  const m = RGBA_RE.exec(trimmed);
+  if (!m) return null;
+  const r = parseInt(m[1], 10);
+  const g = parseInt(m[2], 10);
+  const b = parseInt(m[3], 10);
+  if (r > 255 || g > 255 || b > 255) return null;
+  let alpha;
+  if (m[4] !== void 0) {
+    alpha = parseFloat(m[4]);
+    if (isNaN(alpha) || alpha < 0 || alpha > 1) return null;
+  }
+  return {
+    rgb: [r, g, b],
+    alpha,
+    format: "rgba",
+    original: trimmed
+  };
+}
+var HSLA_RE = /^hsla?\(\s*(\d{1,3}(?:\.\d+)?)\s*,\s*(\d{1,3}(?:\.\d+)?)%\s*,\s*(\d{1,3}(?:\.\d+)?)%\s*(?:,\s*([01]?\.?\d*))?\s*\)$/;
+function hslToRgb(h, s, l) {
+  const sNorm = s / 100;
+  const lNorm = l / 100;
+  const c = (1 - Math.abs(2 * lNorm - 1)) * sNorm;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = lNorm - c / 2;
+  let r1, g1, b1;
+  if (h < 60) {
+    [r1, g1, b1] = [c, x, 0];
+  } else if (h < 120) {
+    [r1, g1, b1] = [x, c, 0];
+  } else if (h < 180) {
+    [r1, g1, b1] = [0, c, x];
+  } else if (h < 240) {
+    [r1, g1, b1] = [0, x, c];
+  } else if (h < 300) {
+    [r1, g1, b1] = [x, 0, c];
+  } else {
+    [r1, g1, b1] = [c, 0, x];
+  }
+  return [
+    Math.round((r1 + m) * 255),
+    Math.round((g1 + m) * 255),
+    Math.round((b1 + m) * 255)
+  ];
+}
+function parseHsla(str) {
+  const trimmed = str.trim();
+  const m = HSLA_RE.exec(trimmed);
+  if (!m) return null;
+  const h = parseFloat(m[1]);
+  const s = parseFloat(m[2]);
+  const l = parseFloat(m[3]);
+  if (h > 360 || s > 100 || l > 100) return null;
+  let alpha;
+  if (m[4] !== void 0) {
+    alpha = parseFloat(m[4]);
+    if (isNaN(alpha) || alpha < 0 || alpha > 1) return null;
+  }
+  return {
+    rgb: hslToRgb(h, s, l),
+    alpha,
+    format: "hsla",
+    original: trimmed
+  };
+}
+var OKLCH_RE = /^oklch\(\s*([01]?\.?\d+)\s+([0-9]*\.?\d+)\s+([0-9]*\.?\d+)\s*(?:\/\s*([01]?\.?\d*))?\s*\)$/;
+function parseOklch(str) {
+  const trimmed = str.trim();
+  const m = OKLCH_RE.exec(trimmed);
+  if (!m) return null;
+  const L = parseFloat(m[1]);
+  const C = parseFloat(m[2]);
+  const H = parseFloat(m[3]);
+  if (isNaN(L) || isNaN(C) || isNaN(H)) return null;
+  if (L < 0 || L > 1) return null;
+  let alpha;
+  if (m[4] !== void 0) {
+    alpha = parseFloat(m[4]);
+    if (isNaN(alpha) || alpha < 0 || alpha > 1) return null;
+  }
+  return {
+    rgb: clampToSrgb(L, C, H),
+    alpha,
+    format: "oklch",
+    original: trimmed
+  };
+}
+function parseColor(str) {
+  if (!str || typeof str !== "string") return null;
+  const trimmed = str.trim();
+  if (trimmed.startsWith("#")) {
+    return parseHex(trimmed);
+  }
+  if (trimmed.startsWith("rgb")) {
+    return parseRgba(trimmed);
+  }
+  if (trimmed.startsWith("hsl")) {
+    return parseHsla(trimmed);
+  }
+  if (trimmed.startsWith("oklch")) {
+    return parseOklch(trimmed);
+  }
+  return null;
+}
+function isValidColor(str) {
+  return parseColor(str) !== null;
+}
+function compositeOverBackground(color, background) {
+  const a = color.alpha ?? 1;
+  return [
+    Math.round(a * color.rgb[0] + (1 - a) * background[0]),
+    Math.round(a * color.rgb[1] + (1 - a) * background[1]),
+    Math.round(a * color.rgb[2] + (1 - a) * background[2])
+  ];
+}
+function rgbToRgbaString(rgb, alpha) {
+  if (alpha !== void 0) {
+    return `rgba(${rgb[0]}, ${rgb[1]}, ${rgb[2]}, ${alpha})`;
+  }
+  return `rgb(${rgb[0]}, ${rgb[1]}, ${rgb[2]})`;
+}
+function rgbToHslaString(rgb, alpha) {
+  const r = rgb[0] / 255;
+  const g = rgb[1] / 255;
+  const b = rgb[2] / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  const d = max - min;
+  let h = 0;
+  let s = 0;
+  if (d !== 0) {
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    if (max === r) {
+      h = ((g - b) / d + (g < b ? 6 : 0)) * 60;
+    } else if (max === g) {
+      h = ((b - r) / d + 2) * 60;
+    } else {
+      h = ((r - g) / d + 4) * 60;
+    }
+  }
+  const hRound = Math.round(h);
+  const sRound = Math.round(s * 100);
+  const lRound = Math.round(l * 100);
+  if (alpha !== void 0) {
+    return `hsla(${hRound}, ${sRound}%, ${lRound}%, ${alpha})`;
+  }
+  return `hsl(${hRound}, ${sRound}%, ${lRound}%)`;
+}
+function rgbToOklchString(rgb, alpha) {
+  const [L, C, H] = rgbToOklch(...rgb);
+  const lStr = L.toFixed(4);
+  const cStr = C.toFixed(4);
+  const hStr = H.toFixed(2);
+  if (alpha !== void 0) {
+    return `oklch(${lStr} ${cStr} ${hStr} / ${alpha})`;
+  }
+  return `oklch(${lStr} ${cStr} ${hStr})`;
+}
+function serializeColor(parsed) {
+  if (parsed.format !== "hex" && parsed.original) {
+    return parsed.original;
+  }
+  switch (parsed.format) {
+    case "hex": {
+      if (parsed.alpha !== void 0) {
+        const alphaHex = Math.round(parsed.alpha * 255).toString(16).padStart(2, "0");
+        return `${rgbToHex(parsed.rgb)}${alphaHex}`;
+      }
+      return rgbToHex(parsed.rgb);
+    }
+    case "rgba":
+      return rgbToRgbaString(parsed.rgb, parsed.alpha);
+    case "hsla":
+      return rgbToHslaString(parsed.rgb, parsed.alpha);
+    case "oklch":
+      return rgbToOklchString(parsed.rgb, parsed.alpha);
+  }
+}
+
+// src/shades.ts
+var FULL_SHADE_STEPS = [
+  50,
+  100,
+  200,
+  300,
+  400,
+  500,
+  600,
+  700,
+  800,
+  900,
+  950
+];
+var SELECTIVE_SHADE_STEPS = [
+  50,
+  100,
+  500,
+  600,
+  700,
+  900
+];
+var LIGHTNESS_TARGETS = {
+  50: 0.97,
+  100: 0.93,
+  200: 0.87,
+  300: 0.78,
+  400: 0.65,
+  500: 0.55,
+  600: -1,
+  // placeholder — replaced by input L at anchor
+  700: 0.38,
+  800: 0.3,
+  900: 0.22,
+  950: 0.14
+};
+var CHROMA_MULTIPLIERS = {
+  50: 0.15,
+  100: 0.25,
+  200: 0.45,
+  300: 0.7,
+  400: 0.9,
+  500: 1,
+  600: 1,
+  700: 1,
+  800: 0.85,
+  900: 0.7,
+  950: 0.5
+};
+var ANCHOR_SHADE = {
+  primary: 600,
+  accent: 600,
+  neutral: 500,
+  success: 500,
+  warning: 500,
+  error: 500,
+  info: 500
+};
+var FULL_SCALE_ROLES = ["primary", "accent", "neutral"];
+var TAILWIND_GRAY = {
+  50: "#f9fafb",
+  100: "#f3f4f6",
+  200: "#e5e7eb",
+  300: "#d1d5db",
+  400: "#9ca3af",
+  500: "#6b7280",
+  600: "#4b5563",
+  700: "#374151",
+  800: "#1f2937",
+  900: "#111827",
+  950: "#030712"
+};
+function computeLightness(step, inputL, anchorShade) {
+  if (step === anchorShade) {
+    return inputL;
+  }
+  const anchorTarget = anchorShade === 600 ? inputL : LIGHTNESS_TARGETS[anchorShade];
+  const stepTarget = LIGHTNESS_TARGETS[step];
+  if (Math.abs(anchorTarget - inputL) < 0.01) {
+    return stepTarget;
+  }
+  if (step < anchorShade) {
+    const anchorDefaultL = anchorShade === 600 ? 0.45 : LIGHTNESS_TARGETS[anchorShade];
+    const rawRange = 0.97 - anchorDefaultL;
+    const newRange = 0.97 - inputL;
+    if (rawRange <= 0) return stepTarget;
+    const t = (stepTarget - anchorDefaultL) / rawRange;
+    return inputL + t * newRange;
+  } else {
+    const anchorDefaultL = anchorShade === 600 ? 0.45 : LIGHTNESS_TARGETS[anchorShade];
+    const rawRange = anchorDefaultL - 0.14;
+    const newRange = inputL - 0.14;
+    if (rawRange <= 0) return stepTarget;
+    const t = (anchorDefaultL - stepTarget) / rawRange;
+    return inputL - t * newRange;
+  }
+}
+function generateShadeScale(color, role) {
+  const parsed = parseColor(color);
+  const [inputL, inputC, inputH] = parsed ? rgbToOklch(...parsed.rgb) : hexToOklch(color);
+  const anchorShade = ANCHOR_SHADE[role];
+  const steps = FULL_SCALE_ROLES.includes(role) ? FULL_SHADE_STEPS : SELECTIVE_SHADE_STEPS;
+  const maxNeutralChroma = 0.02;
+  const scale = {};
+  for (const step of steps) {
+    const targetL = computeLightness(step, inputL, anchorShade);
+    let targetC = inputC * CHROMA_MULTIPLIERS[step];
+    if (role === "neutral") {
+      targetC = Math.min(targetC, maxNeutralChroma);
+    }
+    scale[step] = oklchToHex(targetL, targetC, inputH);
+  }
+  return scale;
+}
+
+// src/generate-css.ts
+function header(label) {
+  return [
+    "/* ============================================",
+    `   ${label}`,
+    "   Generated by @loworbitstudio/visor-theme-engine",
+    "   DO NOT EDIT \u2014 regenerate from .visor.yaml",
+    "   ============================================ */",
+    ""
+  ].join("\n");
+}
+function sectionComment(label) {
+  return `
+/* --- ${label} --- */`;
+}
+function block(selector, declarations) {
+  if (declarations.length === 0) return "";
+  return [selector + " {", ...declarations.map((d) => `  ${d}`), "}", ""].join(
+    "\n"
+  );
+}
+var FULL_SCALE_ROLES2 = ["primary", "accent", "neutral"];
+var SELECTIVE_SCALE_ROLES = [
+  "success",
+  "warning",
+  "error",
+  "info"
+];
+function generateColorPrimitives(primitives) {
+  const decls = [];
+  decls.push("--color-white: #ffffff;");
+  decls.push("--color-black: #000000;");
+  const allRoles = [...FULL_SCALE_ROLES2, ...SELECTIVE_SCALE_ROLES];
+  for (const role of allRoles) {
+    const scale = primitives[role];
+    const steps = FULL_SCALE_ROLES2.includes(role) ? FULL_SHADE_STEPS : SELECTIVE_SHADE_STEPS;
+    for (const step of steps) {
+      const value = scale[step];
+      decls.push(`--color-${role}-${step}: ${value};`);
+    }
+  }
+  return decls.join("\n  ");
+}
+function generateSpacingPrimitives(config) {
+  const base = config.spacing.base;
+  const multipliers = [0, 1, 2, 3, 4, 5, 6, 8, 10, 12, 16, 20, 24];
+  return multipliers.map((m) => {
+    const px = base * m;
+    const rem = px === 0 ? "0" : `${px / 16}rem`;
+    return `--spacing-${m}: ${rem}; /* ${px}px */`;
+  });
+}
+function generateRadiusPrimitives(config) {
+  const decls = [];
+  decls.push("--radius-none: 0;");
+  decls.push(
+    `--radius-sm: ${config.radius.sm / 16}rem; /* ${config.radius.sm}px */`
+  );
+  decls.push(
+    `--radius-md: ${config.radius.md / 16}rem; /* ${config.radius.md}px */`
+  );
+  decls.push(
+    `--radius-lg: ${config.radius.lg / 16}rem; /* ${config.radius.lg}px */`
+  );
+  decls.push(
+    `--radius-xl: ${config.radius.xl / 16}rem; /* ${config.radius.xl}px */`
+  );
+  decls.push(
+    `--radius-2xl: ${config.radius.xl * 1.333 / 16}rem; /* ${Math.round(config.radius.xl * 1.333)}px */`
+  );
+  decls.push(
+    `--radius-3xl: ${config.radius.xl * 2 / 16}rem; /* ${config.radius.xl * 2}px */`
+  );
+  decls.push(`--radius-full: ${config.radius.pill}px;`);
+  return decls;
+}
+function generateShadowPrimitives(config) {
+  return [
+    `--shadow-xs: ${config.shadows.xs};`,
+    `--shadow-sm: ${config.shadows.sm};`,
+    `--shadow-md: ${config.shadows.md};`,
+    `--shadow-lg: ${config.shadows.lg};`,
+    `--shadow-xl: ${config.shadows.xl};`
+  ];
+}
+function generateTypographyPrimitives(config) {
+  const decls = [];
+  const scale = config.typography.scale;
+  decls.push(`font-size: ${scale === 1 ? "1rem" : `${scale}rem`};`);
+  decls.push(`--font-heading: ${config.typography.heading.family};`);
+  decls.push(`--font-display: ${config.typography.display.family};`);
+  decls.push(`--font-sans: ${config.typography.body.family};`);
+  decls.push(`--font-body: ${config.typography.body.family};`);
+  decls.push(`--font-mono: ${config.typography.mono.family};`);
+  const fontSizes = {
+    xs: 12,
+    sm: 14,
+    base: 16,
+    lg: 18,
+    xl: 20,
+    "2xl": 24,
+    "3xl": 30,
+    "4xl": 36
+  };
+  for (const [name, px] of Object.entries(fontSizes)) {
+    decls.push(`--font-size-${name}: ${px / 16}rem; /* ${px}px */`);
+  }
+  decls.push(`--font-weight-normal: ${config.typography.body.weight};`);
+  decls.push("--font-weight-medium: 500;");
+  decls.push(`--font-weight-semibold: ${config.typography.heading.weight};`);
+  decls.push("--font-weight-bold: 700;");
+  decls.push(`--weight-display: ${config.typography.display.weight};`);
+  const lineHeights = {
+    none: 1,
+    tight: 1.25,
+    snug: 1.375,
+    normal: 1.5,
+    relaxed: 1.625,
+    loose: 2
+  };
+  for (const [name, value] of Object.entries(lineHeights)) {
+    decls.push(`--line-height-${name}: ${value};`);
+  }
+  return decls;
+}
+function generateMotionPrimitives(config) {
+  const decls = [];
+  decls.push(`--motion-duration-100: ${config.motion["duration-fast"]};`);
+  decls.push("--motion-duration-150: 150ms;");
+  decls.push(`--motion-duration-200: ${config.motion["duration-normal"]};`);
+  decls.push("--motion-duration-300: 300ms;");
+  decls.push(`--motion-duration-500: ${config.motion["duration-slow"]};`);
+  decls.push("--motion-duration-800: 800ms;");
+  decls.push("--motion-easing-linear: linear;");
+  decls.push("--motion-easing-ease-in: cubic-bezier(0.4, 0, 1, 1);");
+  decls.push("--motion-easing-ease-out: cubic-bezier(0, 0, 0.2, 1);");
+  decls.push(`--motion-easing-ease-in-out: ${config.motion.easing};`);
+  decls.push(
+    "--motion-easing-spring: cubic-bezier(0.34, 1.56, 0.64, 1);"
+  );
+  return decls;
+}
+function generateMiscPrimitives() {
+  return [
+    // Border widths
+    "--border-width-1: 1px;",
+    "--border-width-2: 2px;",
+    "--border-width-3: 3px;",
+    "--border-width-4: 4px;",
+    // Z-index
+    "--z-base: 0;",
+    "--z-raised: 1;",
+    "--z-dropdown: 1000;",
+    "--z-sticky: 1100;",
+    "--z-modal: 1300;",
+    "--z-popover: 1400;",
+    "--z-toast: 1500;",
+    // Overlay
+    "--overlay-bg: rgba(0, 0, 0, 0.5);",
+    // Focus ring
+    "--focus-ring-width: 2px;",
+    "--focus-ring-offset: 2px;"
+  ];
+}
+function generatePrimitivesCss(primitives, config) {
+  const lines = [];
+  lines.push(sectionComment("Primitive: Colors"));
+  lines.push(
+    block(":root", [generateColorPrimitives(primitives)])
+  );
+  lines.push(sectionComment("Primitive: Spacing"));
+  lines.push(block(":root", generateSpacingPrimitives(config)));
+  lines.push(sectionComment("Primitive: Border Radius"));
+  lines.push(block(":root", generateRadiusPrimitives(config)));
+  lines.push(sectionComment("Primitive: Typography"));
+  lines.push(block(":root", generateTypographyPrimitives(config)));
+  lines.push(sectionComment("Primitive: Shadows"));
+  lines.push(block(":root", generateShadowPrimitives(config)));
+  lines.push(sectionComment("Primitive: Motion"));
+  lines.push(block(":root", generateMotionPrimitives(config)));
+  lines.push(sectionComment("Primitive: Miscellaneous"));
+  lines.push(block(":root", generateMiscPrimitives()));
+  return header("Visor Theme \u2014 Primitives") + lines.join("\n");
+}
+function generateSemanticCss(tokens) {
+  const lines = [];
+  lines.push(sectionComment("Semantic: Text"));
+  const textDecls = Object.entries(tokens.text).map(
+    ([name, { light }]) => `--text-${name}: ${light};`
+  );
+  lines.push(block(":root", textDecls));
+  lines.push(sectionComment("Semantic: Surface"));
+  const surfaceDecls = Object.entries(tokens.surface).map(
+    ([name, { light }]) => `--surface-${name}: ${light};`
+  );
+  lines.push(block(":root", surfaceDecls));
+  lines.push(sectionComment("Semantic: Border"));
+  const borderDecls = Object.entries(tokens.border).map(
+    ([name, { light }]) => `--border-${name}: ${light};`
+  );
+  lines.push(block(":root", borderDecls));
+  lines.push(sectionComment("Semantic: Interactive"));
+  const interactiveDecls = Object.entries(tokens.interactive).map(
+    ([name, { light }]) => `--interactive-${name}: ${light};`
+  );
+  lines.push(block(":root", interactiveDecls));
+  return header("Visor Theme \u2014 Semantic") + lines.join("\n");
+}
+function buildAdaptiveDecls(tokens, theme) {
+  const textDecls = Object.entries(tokens.text).map(
+    ([name, values]) => `--text-${name}: ${values[theme]};`
+  );
+  const surfaceDecls = Object.entries(tokens.surface).map(
+    ([name, values]) => `--surface-${name}: ${values[theme]};`
+  );
+  const borderDecls = Object.entries(tokens.border).map(
+    ([name, values]) => `--border-${name}: ${values[theme]};`
+  );
+  const interactiveDecls = Object.entries(tokens.interactive).map(
+    ([name, values]) => `--interactive-${name}: ${values[theme]};`
+  );
+  return { textDecls, surfaceDecls, borderDecls, interactiveDecls };
+}
+function generateLightCss(tokens) {
+  const lines = [];
+  const { textDecls, surfaceDecls, borderDecls, interactiveDecls } = buildAdaptiveDecls(tokens, "light");
+  lines.push(sectionComment("Adaptive: Text (light)"));
+  lines.push(block(":root", textDecls));
+  lines.push(sectionComment("Adaptive: Surface (light)"));
+  lines.push(block(":root", surfaceDecls));
+  lines.push(sectionComment("Adaptive: Border (light)"));
+  lines.push(block(":root", borderDecls));
+  lines.push(sectionComment("Adaptive: Interactive (light)"));
+  lines.push(block(":root", interactiveDecls));
+  return header("Visor Theme \u2014 Light") + lines.join("\n");
+}
+function generateDarkCss(tokens) {
+  const lines = [];
+  const { textDecls, surfaceDecls, borderDecls, interactiveDecls } = buildAdaptiveDecls(tokens, "dark");
+  const darkSelectors = [".dark", ".theme-dark", '[data-theme="dark"]'];
+  const darkSelector = darkSelectors.join(",\n");
+  const prefersSelector = ':root:not(.light):not(.theme-light):not([data-theme="light"])';
+  lines.push(sectionComment("Adaptive: Text (dark) \u2014 manual toggle"));
+  lines.push(block(darkSelector, textDecls));
+  lines.push(sectionComment("Adaptive: Surface (dark) \u2014 manual toggle"));
+  lines.push(block(darkSelector, surfaceDecls));
+  lines.push(sectionComment("Adaptive: Border (dark) \u2014 manual toggle"));
+  lines.push(block(darkSelector, borderDecls));
+  lines.push(sectionComment("Adaptive: Interactive (dark) \u2014 manual toggle"));
+  lines.push(block(darkSelector, interactiveDecls));
+  lines.push(
+    sectionComment("Adaptive: Text (dark) \u2014 prefers-color-scheme")
+  );
+  lines.push(
+    `@media (prefers-color-scheme: dark) {
+${block(prefersSelector, textDecls)}}`
+  );
+  lines.push("");
+  lines.push(
+    sectionComment("Adaptive: Surface (dark) \u2014 prefers-color-scheme")
+  );
+  lines.push(
+    `@media (prefers-color-scheme: dark) {
+${block(prefersSelector, surfaceDecls)}}`
+  );
+  lines.push("");
+  lines.push(
+    sectionComment("Adaptive: Border (dark) \u2014 prefers-color-scheme")
+  );
+  lines.push(
+    `@media (prefers-color-scheme: dark) {
+${block(prefersSelector, borderDecls)}}`
+  );
+  lines.push("");
+  lines.push(
+    sectionComment("Adaptive: Interactive (dark) \u2014 prefers-color-scheme")
+  );
+  lines.push(
+    `@media (prefers-color-scheme: dark) {
+${block(prefersSelector, interactiveDecls)}}`
+  );
+  lines.push("");
+  return header("Visor Theme \u2014 Dark") + lines.join("\n");
+}
+function generateFullBundleCss(primitives, tokens, config) {
+  const lines = [
+    header("Visor Theme \u2014 Full Bundle"),
+    "/* Import order: primitives \u2192 adaptive (light) \u2192 adaptive (dark) */",
+    ""
+  ];
+  lines.push(
+    "/* ============================================",
+    "   Tier 1: Primitives",
+    "   ============================================ */"
+  );
+  const primitivesBody = generatePrimitivesCss(primitives, config).split("\n").slice(6).join("\n");
+  lines.push(primitivesBody);
+  lines.push(
+    "/* ============================================",
+    "   Tier 3: Adaptive \u2014 Light Theme (:root)",
+    "   ============================================ */"
+  );
+  const lightBody = generateLightCss(tokens).split("\n").slice(6).join("\n");
+  lines.push(lightBody);
+  lines.push(
+    "/* ============================================",
+    '   Tier 3: Adaptive \u2014 Dark Theme (.dark, .theme-dark, [data-theme="dark"])',
+    "   and @media (prefers-color-scheme: dark)",
+    "   ============================================ */"
+  );
+  const darkBody = generateDarkCss(tokens).split("\n").slice(6).join("\n");
+  lines.push(darkBody);
+  return lines.join("\n");
+}
+
+export {
+  googleFontsCatalog,
+  lookupGoogleFont,
+  VISOR_FONTS_CDN,
+  buildVisorFontUrl,
+  resolveFont,
+  generatePreloadLinks,
+  generateStylesheetLinks,
+  resolveThemeFonts,
+  normalizeHex,
+  isValidHex,
+  hexToRgb,
+  rgbToHex,
+  rgbToOklch,
+  hexToOklch,
+  clampToSrgb,
+  oklchToHex,
+  getContrastRatio,
+  parseHex,
+  parseRgba,
+  parseHsla,
+  parseOklch,
+  parseColor,
+  isValidColor,
+  compositeOverBackground,
+  serializeColor,
+  FULL_SHADE_STEPS,
+  SELECTIVE_SHADE_STEPS,
+  TAILWIND_GRAY,
+  generateShadeScale,
+  header,
+  sectionComment,
+  generatePrimitivesCss,
+  generateSemanticCss,
+  generateLightCss,
+  generateDarkCss,
+  generateFullBundleCss
+};