rainbowindex 0.4.0 → 0.4.1

package/CHANGELOG.md

@@ -5,6 +5,98 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.1] - 2026-08-25
+
+### Added
+
+- **Automatic zero-CLS font fallbacks.** Any `@font` slot whose family is in
+  the built-in metrics table (~100 common Google + system families, generated
+  from `@capsizecss/metrics` at development time — no new runtime dependency)
+  now gets a metrics-adjusted local fallback `@font-face` automatically. The
+  fallback font is picked from the slot's stack, or by the web font's
+  category (Arial / Times New Roman / Courier New). Opt out with
+  `metrics: none;`, pick the matched local font with `metrics: "Segoe UI";`,
+  or keep full manual control with
+  `metrics: "Arial" <size-adjust> <ascent> <descent> <line-gap>;`.
+- **`face:` entries** — local font files are now declared as repeatable
+  `face: <src> [{ overrides }]` entries, one grammar for every face:
+  `display: "Satoshi" { face: /Satoshi.woff2; face: /Satoshi-Italic.woff2 { style: italic; } }`.
+- **Fallback stacks work with `from google`** —
+  `sans: "Inter", ui-sans-serif, sans-serif from google;` now parses as a
+  google slot with fallbacks (previously it silently became a manual stack).
+- **@font now warns instead of ignoring silently**: unknown option keys
+  (RI-1217), `preload` on non-local slots where it can have no effect
+  (RI-1219), and partial or invalid `metrics` values (RI-1220).
+
+### Changed
+
+- The `@font` parser was rebuilt on the shared entry scanner: one pass, no
+  regex preambles, no re-serialization. Public API (`parseFontBody`,
+  `parseNestedFontBlock`) is unchanged.
+- **Incremental rebuilds only re-do changed work** — the scanner keeps a
+  per-file cache keyed on mtime + size, so a CLI watch or Vite HMR rebuild
+  re-reads and re-extracts only the files that actually changed instead of
+  the whole project. The CSS entry analysis is memoized on the entry text
+  (stable theme identity across rebuilds), Google-font resolution keeps its
+  identity when metadata is unchanged, and per-class compilation results
+  (rule, warnings, token usage) are replayed across rebuilds from a
+  theme-keyed cache. A one-file edit in a large project now costs
+  O(changed files) instead of O(project).
+- **`ri()` conditional args hit the cache fast path** — falsy arguments
+  (`ri("flex", isActive && "bg-blue-500")`) no longer force re-tokenization
+  on every call: the raw-key cache skips falsy primitives, making cached
+  conditional-pattern calls ~4x faster.
+- **Cheaper compile passes** — duplicate class names across `@apply` rules
+  resolve once per pass, the `@slot`/`@apply` walks no longer traverse the
+  generated utility CSS, custom `@utility` bodies parse once per body text
+  instead of once per variant form, and the editor candidate collector's
+  context assignment went from quadratic to a sorted sweep. As part of the
+  compile-result replay, engine-level compilation warnings are now
+  deduplicated (final project output already was).
+- **Internal restructuring (behavior-preserving)** — the directive body
+  parsers were split by grammar family: `@color` and `@font` now own their
+  own modules, and the generic key-value/entry grammars sit together in the
+  directives foundation. The `parsers` import surface is unchanged.
+
+### Deprecated
+
+- The older `@font` forms still parse and desugar into the new model, but
+  warn (RI-1218) and will be removed in a future release: `@face { src: …; }`
+  blocks and the `italic:` shorthand (use `face:`), `from "<path>"` (use
+  `face:`), `from system` (use bare `system`), the `fallback:` key (list
+  fallbacks in the slot preamble), the five-key metrics cluster
+  `metricsFallback`/`sizeAdjust`/`ascent`/`descent`/`lineGap` (use
+  `metrics:`), and the `unicodeRange` spelling (use `unicode-range`).
+
+### Removed
+
+- **`@font` `subset:`** — the Google css2 API takes no subset hint, so the
+  key never affected the emitted URL. It now warns (RI-1218) and is ignored.
+- **`FontSlot` / `FontFace` fields** — the five slot-level metrics fields
+  (`metricsFallback`, `sizeAdjust`, `ascent`, `descent`, `lineGap`) are
+  replaced by a single `metrics?: FontMetricsConfig | null`; slot-level
+  `preload` moved onto the faces; `FontFace.subset` is gone. Stylesheets are
+  unaffected — this only touches code importing those types directly.
+
+### Fixed
+
+- **`ri()` stroke-width vs stroke-color conflict — for real this time.** The
+  v0.4.0 changelog described this fix, but the implementation did not ship in
+  that release: `ri("stroke-2 stroke-red-500")` still dropped `stroke-2`. The
+  `stroke` prefix is now actually width-vs-color dual-mode (mirroring
+  `border`/`outline`): decimal and non-color arbitrary values claim
+  `stroke-width`, color values claim `stroke`. Same-property conflicts
+  (`stroke-2` vs `stroke-4`, `stroke-red-500` vs `stroke-blue-500`) still
+  merge as before. The emission↔claim parity suite no longer carries a
+  stroke exception, and regression tests pin the merged output.
+- **Directive rewriter no longer duplicates unclosed blocks** — an
+  unterminated `{` inside a `@color` body made the Vite-plugin pre-pass
+  re-emit the text before it (`@color { accent: 0.18 330 { inline` came out
+  with the entry doubled). The rewriter's two hand-rolled brace walks were
+  replaced by one shared walker built on the same brace matcher the directive
+  scan already uses, which also makes quotes and comments inside blocks
+  behave consistently across the rewrite passes.
+
 ## [0.4.0] - 2026-08-20
 
 ### Added

package/README.md

@@ -211,7 +211,7 @@ Customization happens in your CSS input, not a JS config. The engine recognizes:
 | `@color` | Define color tokens. Supports generative (`chroma hue`), explicit (`oklch(...)`, `#rrggbb`), light/dark pairs, and aliases. |
 | `@spacing` | Set the spacing base unit. |
 | `@text` | Define text size tokens (`size, line-height`). |
-| `@font`, `@font-face` | Register font families inside a single `@font { … }` block. One slot can own multiple `@face` faces (e.g. upright + italic) or use the `italic:` shorthand. |
+| `@font`, `@font-face` | Register font families inside a single `@font { … }` block. Local files are repeatable `face:` entries (e.g. upright + italic). Known families get an automatic zero-CLS metrics fallback (`metrics: none` opts out). |
 | `@rounded` | Border-radius tokens; modifier sets corner shape (`round`, `squircle`, `superellipse(N)`, etc). |
 | `@fluid` | Configure fluid type/spacing range. |
 | `@animate` | Register named animations with inline `@keyframes`. |
@@ -242,10 +242,11 @@ Example:
 }
 
 @font {
-	sans: "Inter" from google { weight: 400 700; }
-	display: "Satoshi" from "/fonts/Satoshi.woff2" {
+	sans: "Inter", ui-sans-serif, sans-serif from google { weight: 400 700; }
+	display: "Satoshi" {
 		weight: 300 900;
-		italic: "/fonts/Satoshi-Italic.woff2";   /* second face, font-style: italic */
+		face: /fonts/Satoshi.woff2;
+		face: /fonts/Satoshi-Italic.woff2 { style: italic; }
 	}
 }
 

package/dist/browser.mjs

@@ -13,7 +13,7 @@ import {
   registerCustomTextSizes,
   registerCustomUtility,
   ri
-} from "./chunk-5Y7EXXLS.mjs";
+} from "./chunk-KRZL4IDK.mjs";
 
 // src/entries/browser.ts
 function browserEntryUnavailable() {

package/dist/{chunk-4SVFFDS2.mjs → chunk-53WD6U2X.mjs}

@@ -19,12 +19,12 @@ import {
   renderCSS,
   scanCSSForTokenUsage,
   withTimeout
-} from "./chunk-6DAHUFNU.mjs";
+} from "./chunk-6GTG5SZJ.mjs";
 import {
   checkPaletteContrast,
   generateAllColorVariables,
   generateThemeOverrides
-} from "./chunk-5Y7EXXLS.mjs";
+} from "./chunk-KRZL4IDK.mjs";
 
 // src/integrations/font-providers/google/state.ts
 var googleFontInternals = {
@@ -318,8 +318,13 @@ async function fetchGoogleFontList() {
   googleFontInternals.googleFontListPromise = localPromise;
   return localPromise;
 }
+var refreshMemo = /* @__PURE__ */ new WeakMap();
 function refreshFontWeightDefaults(fonts) {
-  return fonts.map((slot) => {
+  const state = googleFontInternals.googleFontState;
+  const memo = refreshMemo.get(fonts);
+  if (memo && memo.state === state) return memo.result;
+  let anyChanged = false;
+  const refreshed = fonts.map((slot) => {
     if (slot.kind !== "google") return slot;
     const meta = googleFontInternals.googleFontState.cache.get(slot.family);
     if (!meta) return slot;
@@ -339,8 +344,12 @@ function refreshFontWeightDefaults(fonts) {
       if (next !== f) changed = true;
       return next;
     });
+    if (changed) anyChanged = true;
     return changed ? { ...slot, faces } : slot;
   });
+  const result = anyChanged ? refreshed : fonts;
+  refreshMemo.set(fonts, { state, result });
+  return result;
 }
 var FONT_FETCH_TIMEOUT_MS = 1e4;
 async function resolveGoogleFonts(fonts) {
@@ -359,6 +368,145 @@ async function resolveGoogleFonts(fonts) {
   return refreshFontWeightDefaults(fonts);
 }
 
+// src/integrations/font-providers/metrics-data.ts
+var FONT_METRICS_TABLE = {
+  abel: [2006, -604, 0, 2048, 783, "sans-serif"],
+  alegreya: [1016, -345, 0, 1e3, 410, "serif"],
+  "anonymous pro": [1675, -373, 0, 2048, 1118, "monospace"],
+  archivo: [878, -210, 0, 1e3, 440, "sans-serif"],
+  arial: [1854, -434, 67, 2048, 913, "sans-serif"],
+  asap: [934, -212, 0, 1e3, 442, "sans-serif"],
+  barlow: [1e3, -200, 0, 1e3, 431, "sans-serif"],
+  bitter: [935, -265, 0, 1e3, 465, "serif"],
+  "bricolage grotesque": [930, -270, 0, 1e3, 470, "sans-serif"],
+  cabin: [1930, -500, 0, 2e3, 844, "sans-serif"],
+  catamaran: [1100, -540, 0, 1e3, 411, "sans-serif"],
+  chivo: [940, -250, 0, 1e3, 478, "sans-serif"],
+  "cormorant garamond": [924, -287, 0, 1e3, 394, "serif"],
+  "courier new": [1705, -615, 0, 2048, 1229, "monospace"],
+  "crimson pro": [918, -220, 0, 1024, 410, "serif"],
+  "crimson text": [972, -359, 0, 1024, 405, "serif"],
+  "dm sans": [992, -310, 0, 1e3, 466, "sans-serif"],
+  "dm serif display": [1036, -335, 0, 1e3, 446, "serif"],
+  dosis: [1027, -237, 0, 1e3, 377, "sans-serif"],
+  "eb garamond": [1007, -298, 0, 1e3, 385, "serif"],
+  epilogue: [1580, -470, 0, 2e3, 990, "sans-serif"],
+  "exo 2": [999, -201, 0, 1e3, 455, "sans-serif"],
+  figtree: [950, -250, 0, 1e3, 449, "sans-serif"],
+  "fira code": [1980, -644, 0, 2e3, 1200, "monospace"],
+  "fira sans": [935, -265, 0, 1e3, 458, "sans-serif"],
+  fraunces: [1956, -510, 0, 2e3, 938, "serif"],
+  gabarito: [940, -260, 0, 1e3, 442, "display"],
+  "geist mono": [1005, -295, 0, 1e3, 600, "monospace"],
+  geist: [1005, -295, 0, 1e3, 467, "sans-serif"],
+  georgia: [1878, -449, 0, 2048, 913, "serif"],
+  heebo: [2146, -862, 0, 2048, 912, "sans-serif"],
+  "helvetica neue": [952, -213, 28, 1e3, 450, "sans-serif"],
+  helvetica: [1577, -471, 0, 2048, 913, "sans-serif"],
+  hind: [1055, -546, 0, 1e3, 429, "sans-serif"],
+  "ibm plex mono": [1025, -275, 0, 1e3, 600, "monospace"],
+  "ibm plex sans": [1025, -275, 0, 1e3, 451, "sans-serif"],
+  "ibm plex serif": [1025, -275, 0, 1e3, 473, "serif"],
+  inconsolata: [859, -190, 0, 1e3, 500, "monospace"],
+  "instrument sans": [970, -250, 0, 1e3, 458, "sans-serif"],
+  "instrument serif": [990, -310, 0, 1e3, 341, "serif"],
+  inter: [1984, -494, 0, 2048, 978, "sans-serif"],
+  "jetbrains mono": [1020, -300, 0, 1e3, 600, "monospace"],
+  "josefin sans": [750, -250, 0, 1e3, 456, "sans-serif"],
+  kanit: [1100, -395, 0, 1e3, 452, "sans-serif"],
+  karla: [1834, -504, 0, 2e3, 913, "sans-serif"],
+  lato: [1974, -426, 0, 2e3, 871, "sans-serif"],
+  lexend: [1e3, -250, 0, 1e3, 490, "sans-serif"],
+  "libre baskerville": [970, -270, 0, 1e3, 517, "serif"],
+  "libre franklin": [966, -246, 0, 1e3, 465, "sans-serif"],
+  lora: [1006, -274, 0, 1e3, 468, "serif"],
+  manrope: [2132, -600, 0, 2e3, 920, "sans-serif"],
+  "maven pro": [965, -210, 0, 1e3, 462, "sans-serif"],
+  merriweather: [1968, -546, 0, 2e3, 970, "serif"],
+  montserrat: [968, -251, 0, 1e3, 503, "sans-serif"],
+  mulish: [1005, -250, 0, 1e3, 464, "sans-serif"],
+  newsreader: [1470, -530, 0, 2e3, 857, "serif"],
+  "noto sans": [1069, -293, 0, 1e3, 474, "sans-serif"],
+  "noto serif": [1069, -293, 0, 1e3, 481, "serif"],
+  "nunito sans": [1011, -353, 0, 1e3, 452, "sans-serif"],
+  nunito: [1011, -353, 0, 1e3, 452, "sans-serif"],
+  onest: [970, -305, 0, 1e3, 469, "sans-serif"],
+  "open sans": [2189, -600, 0, 2048, 960, "sans-serif"],
+  oswald: [1193, -289, 0, 1e3, 363, "sans-serif"],
+  outfit: [1e3, -260, 0, 1e3, 445, "sans-serif"],
+  overpass: [1766, -766, 0, 2e3, 898, "sans-serif"],
+  oxygen: [2103, -483, 0, 2048, 923, "sans-serif"],
+  "playfair display": [1082, -251, 0, 1e3, 452, "serif"],
+  "plus jakarta sans": [1038, -222, 0, 1e3, 468, "sans-serif"],
+  poppins: [1050, -350, 100, 1e3, 500, "sans-serif"],
+  "pt sans": [1018, -276, 0, 1e3, 431, "sans-serif"],
+  "pt serif": [1039, -286, 0, 1e3, 448, "serif"],
+  "public sans": [1900, -450, 0, 2e3, 935, "sans-serif"],
+  quicksand: [1e3, -250, 0, 1e3, 465, "sans-serif"],
+  raleway: [940, -234, 0, 1e3, 463, "sans-serif"],
+  "red hat display": [1018, -305, 0, 1e3, 442, "sans-serif"],
+  "red hat text": [1018, -305, 0, 1e3, 447, "sans-serif"],
+  "roboto condensed": [1900, -500, 0, 2048, 811, "sans-serif"],
+  "roboto flex": [1900, -500, 0, 2048, 908, "sans-serif"],
+  "roboto mono": [2146, -555, 0, 2048, 1229, "monospace"],
+  "roboto slab": [2146, -555, 0, 2048, 972, "serif"],
+  roboto: [1900, -500, 0, 2048, 911, "sans-serif"],
+  rubik: [935, -250, 0, 1e3, 468, "sans-serif"],
+  "schibsted grotesk": [2e3, -528, 0, 2048, 954, "sans-serif"],
+  "segoe ui": [2210, -514, 0, 2048, 908, "sans-serif"],
+  sora: [970, -290, 0, 1e3, 507, "sans-serif"],
+  "source code pro": [984, -273, 0, 1e3, 600, "monospace"],
+  "source sans 3": [1024, -400, 0, 1e3, 418, "sans-serif"],
+  "source serif 4": [1036, -335, 0, 1e3, 479, "serif"],
+  "space grotesk": [984, -292, 0, 1e3, 489, "sans-serif"],
+  "space mono": [1120, -361, 0, 1e3, 612, "monospace"],
+  spectral: [1059, -463, 0, 1e3, 446, "serif"],
+  tahoma: [2049, -423, 0, 2048, 917, "sans-serif"],
+  "times new roman": [1825, -443, 87, 2048, 832, "serif"],
+  "titillium web": [1133, -388, 0, 1e3, 421, "sans-serif"],
+  "trebuchet ms": [1923, -455, 0, 2048, 934, "sans-serif"],
+  "ubuntu mono": [830, -170, 0, 1e3, 500, "monospace"],
+  ubuntu: [932, -189, 28, 1e3, 455, "sans-serif"],
+  urbanist: [1900, -500, 0, 2e3, 883, "sans-serif"],
+  "varela round": [918, -286, 0, 1e3, 478, "sans-serif"],
+  verdana: [2059, -430, 0, 2048, 1049, "sans-serif"],
+  "victor mono": [1100, -250, 0, 1e3, 600, "monospace"],
+  vollkorn: [952, -441, 0, 1e3, 438, "serif"],
+  "work sans": [930, -243, 0, 1e3, 499, "sans-serif"],
+  "zilla slab": [944, -256, 0, 1e3, 434, "serif"]
+};
+
+// src/integrations/font-providers/metrics.ts
+var CATEGORY_FALLBACK = {
+  "sans-serif": "Arial",
+  serif: "Times New Roman",
+  monospace: "Courier New"
+};
+function lookupFontMetrics(family) {
+  return FONT_METRICS_TABLE[family.trim().toLowerCase()];
+}
+var round4 = (n) => Math.round(n * 1e4) / 1e4;
+function computeFallbackMetrics(fallbackName, font, fallbackFont) {
+  const [ascent, descent, lineGap, unitsPerEm, xWidthAvg] = font;
+  const [, , , fbUnitsPerEm, fbXWidthAvg] = fallbackFont;
+  const sizeAdjust = xWidthAvg / unitsPerEm / (fbXWidthAvg / fbUnitsPerEm);
+  return {
+    fallback: fallbackName,
+    sizeAdjust: round4(sizeAdjust * 100),
+    ascent: round4(ascent / unitsPerEm / sizeAdjust * 100),
+    descent: round4(Math.abs(descent) / unitsPerEm / sizeAdjust * 100),
+    lineGap: round4(lineGap / unitsPerEm / sizeAdjust * 100)
+  };
+}
+function resolveAutoMetrics(family, fallbackStack, explicitFallback) {
+  const font = lookupFontMetrics(family);
+  if (!font) return null;
+  const fallbackName = explicitFallback ?? fallbackStack.find((f) => lookupFontMetrics(f)) ?? CATEGORY_FALLBACK[font[5]] ?? "Arial";
+  const fallbackFont = lookupFontMetrics(fallbackName);
+  if (!fallbackFont) return null;
+  return computeFallbackMetrics(fallbackName, font, fallbackFont);
+}
+
 // src/integrations/font-providers/index.ts
 var SYSTEM_STACKS = Object.freeze({
   sans: 'ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"',
@@ -390,8 +538,7 @@ function googleFontsUrl(family, face) {
     axisParam = face.style.includes("italic") ? `ital,wght@0,${w};1,${w}` : `wght@${w}`;
   }
   const display = face.display || "swap";
-  const subset = face.subset && face.subset !== "latin" ? `&subset=${encodeURIComponent(face.subset)}` : "";
-  return `https://fonts.googleapis.com/css2?family=${encodedFamily}:${axisParam}&display=${display}${subset}`;
+  return `https://fonts.googleapis.com/css2?family=${encodedFamily}:${axisParam}&display=${display}`;
 }
 function escapeFontFamily(name) {
   return name.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\n/g, "\\a ").replace(/\r/g, "\\d ");
@@ -400,7 +547,7 @@ function generateFallbackFontFace(family, metrics) {
   const safeFamily = escapeFontFamily(family);
   return `@font-face {
   font-family: "${safeFamily} Fallback";
-  src: local("${metrics.fallback}");
+  src: local("${escapeFontFamily(metrics.fallback)}");
   size-adjust: ${metrics.sizeAdjust}%;
   ascent-override: ${metrics.ascent}%;
   descent-override: ${metrics.descent}%;
@@ -425,7 +572,7 @@ function generateWebFontFace(family, face) {
   if (face.provider === "google") {
     return { type: "import", css: `@import url("${googleFontsUrl(family, face)}");` };
   }
-  const safeProvider = face.provider.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const safeProvider = escapeFontFamily(face.provider);
   const format = inferFontFormat(face.provider);
   const src = `url("${safeProvider}") format("${format}")`;
   const declarations = [`  font-family: "${escapeFontFamily(family)}";`, `  src: ${src};`];
@@ -447,6 +594,27 @@ function normalizeLocalStyle(style, family, warnings) {
   }
   return style;
 }
+function resolveSlotMetrics(slot, warnings) {
+  const cfg = slot.metrics;
+  if (cfg === null) return null;
+  if (cfg?.sizeAdjust !== void 0) {
+    return {
+      fallback: cfg.fallback || slot.fallback[0] || "Arial",
+      sizeAdjust: cfg.sizeAdjust,
+      ascent: cfg.ascent,
+      descent: cfg.descent,
+      lineGap: cfg.lineGap
+    };
+  }
+  const resolved = resolveAutoMetrics(slot.family, slot.fallback, cfg?.fallback);
+  if (!resolved && cfg?.fallback) {
+    const missing = lookupFontMetrics(slot.family) ? cfg.fallback : slot.family;
+    warnings.push(
+      `[RI-1220] @font slot "${slot.slot}" requests metrics matching against "${cfg.fallback}", but "${missing}" is not in the built-in metrics table \u2014 no fallback @font-face was generated. Provide the four percentages explicitly (metrics: "${cfg.fallback}" <size-adjust> <ascent> <descent> <line-gap>) or use \`metrics: none\`.`
+    );
+  }
+  return resolved;
+}
 function generateFontCSS(slot) {
   const imports = [];
   const fontFaces = [];
@@ -466,20 +634,8 @@ function generateFontCSS(slot) {
     pushFeatureVars();
     return { imports, fontFaces, variables, warnings };
   }
-  const { sizeAdjust, ascent, descent, lineGap } = slot;
-  const hasMetrics = sizeAdjust !== void 0 && ascent !== void 0 && descent !== void 0 && lineGap !== void 0;
-  if (hasMetrics) {
-    const metricsFallbackFont = slot.metricsFallback || slot.fallback[0] || "Arial";
-    fontFaces.push(
-      generateFallbackFontFace(slot.family, {
-        fallback: metricsFallbackFont,
-        sizeAdjust,
-        ascent,
-        descent,
-        lineGap
-      })
-    );
-  }
+  const metrics = resolveSlotMetrics(slot, warnings);
+  if (metrics) fontFaces.push(generateFallbackFontFace(slot.family, metrics));
   for (const face of slot.faces) {
     if (face.provider !== "google" && !face.provider.startsWith("/") && !face.provider.startsWith("http") && !face.provider.startsWith(".")) {
       warnings.push(
@@ -496,7 +652,7 @@ function generateFontCSS(slot) {
   const fallbackStack = slot.fallback.length > 0 ? slot.fallback.join(", ") : getFallbackStack(slot.slot);
   const safeFamily = escapeFontFamily(slot.family);
   const stackParts = [`"${safeFamily}"`];
-  if (hasMetrics) stackParts.push(`"${safeFamily} Fallback"`);
+  if (metrics) stackParts.push(`"${safeFamily} Fallback"`);
   stackParts.push(fallbackStack);
   variables.push(`--font-${slot.slot}: ${stackParts.join(", ")};`);
   pushFeatureVars();
@@ -507,8 +663,7 @@ function getFontPreloadLinks(slots) {
   const seen = /* @__PURE__ */ new Set();
   for (const slot of slots) {
     for (const face of slot.faces) {
-      const preload = face.preload ?? slot.preload;
-      if (!preload) continue;
+      if (!face.preload) continue;
       if (face.provider === "system" || face.provider === "google" || !face.provider) continue;
       if (seen.has(face.provider)) continue;
       seen.add(face.provider);
@@ -775,31 +930,38 @@ function collectInlineClasses(sources) {
   return { classes, warnings };
 }
 var FILE_IO_TIMEOUT_MS = 1e4;
+var SCAN_CACHE_MAX_ENTRIES = 2e4;
+var scanCache = /* @__PURE__ */ new Map();
 async function scanOneFile(file) {
   const warnings = [];
   try {
-    const fileSize = await withTimeout(
-      stat(file).then((s) => s.size),
-      FILE_IO_TIMEOUT_MS,
-      "stat() timed out"
-    );
-    if (fileSize > MAX_FILE_SIZE) {
-      return {
+    const stats = await withTimeout(stat(file), FILE_IO_TIMEOUT_MS, "stat() timed out");
+    const cached = scanCache.get(file);
+    if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
+      return cached.result;
+    }
+    let result;
+    if (stats.size > MAX_FILE_SIZE) {
+      result = {
         classes: null,
         warnings,
-        failure: `[RI-1405] Skipping source file "${file}" (${fileSize} bytes) \u2014 exceeds ${MAX_FILE_SIZE} byte limit.`
+        failure: `[RI-1405] Skipping source file "${file}" (${stats.size} bytes) \u2014 exceeds ${MAX_FILE_SIZE} byte limit.`
+      };
+    } else {
+      const content = await withTimeout(
+        readFile(file, "utf-8"),
+        FILE_IO_TIMEOUT_MS,
+        "readFile() timed out"
+      );
+      result = {
+        classes: extractClassesFromSource({ path: file, content }, warnings),
+        warnings,
+        failure: null
       };
     }
-    const content = await withTimeout(
-      readFile(file, "utf-8"),
-      FILE_IO_TIMEOUT_MS,
-      "readFile() timed out"
-    );
-    return {
-      classes: extractClassesFromSource({ path: file, content }, warnings),
-      warnings,
-      failure: null
-    };
+    if (scanCache.size >= SCAN_CACHE_MAX_ENTRIES) scanCache.clear();
+    scanCache.set(file, { mtimeMs: stats.mtimeMs, size: stats.size, result });
+    return result;
   } catch (err) {
     return {
       classes: null,
@@ -1575,13 +1737,20 @@ function collectApplyClassNames(css, warnings) {
   }
   return classes;
 }
+var effectiveThemeMemo = /* @__PURE__ */ new WeakMap();
 async function finalizeProjectCompilation(options) {
   const { analysis } = options;
   let effectiveTheme = analysis.theme;
   if (options.resolveFonts) {
     const resolvedFonts = await options.resolveFonts(analysis.theme.fonts);
     if (resolvedFonts !== analysis.theme.fonts) {
-      effectiveTheme = { ...analysis.theme, fonts: [...resolvedFonts] };
+      const memo = effectiveThemeMemo.get(analysis.theme);
+      if (memo && memo.fonts === resolvedFonts) {
+        effectiveTheme = memo.theme;
+      } else {
+        effectiveTheme = { ...analysis.theme, fonts: [...resolvedFonts] };
+        effectiveThemeMemo.set(analysis.theme, { fonts: resolvedFonts, theme: effectiveTheme });
+      }
     }
   }
   const expansionWarnings = [];
@@ -1625,8 +1794,21 @@ async function finalizeProjectCompilation(options) {
 }
 
 // src/project/scan.ts
+var lastAnalysis = null;
+function analyzeProjectCSSMemo(css) {
+  if (lastAnalysis === null || lastAnalysis.css !== css) {
+    lastAnalysis = { css, analysis: analyzeProjectCSS(css) };
+  }
+  const cached = lastAnalysis.analysis;
+  return {
+    ...cached,
+    warnings: [...cached.warnings],
+    warningSeen: new Set(cached.warningSeen),
+    diagnostics: [...cached.diagnostics]
+  };
+}
 async function compileScannedProject(options) {
-  const analysis = analyzeProjectCSS(options.css);
+  const analysis = analyzeProjectCSSMemo(options.css);
   const resolveFonts = options.resolveFonts ?? resolveGoogleFonts;
   const fontsReady = Promise.resolve(resolveFonts(analysis.theme.fonts));
   fontsReady.catch(() => {