rainbowindex 0.5.0 → 0.6.0

package/dist/{chunk-DT5HYIM3.mjs → chunk-WK6S4HTC.mjs}

@@ -5,7 +5,7 @@ import {
   RI_IMPORT_SPECIFIER_ALTERNATION,
   SAFE_FONT_FAMILY_RE,
   SHADOW_VAR_REF_RE,
-  analyzeProjectCSS,
+  analyzeProjectCSSMemo,
   codepointCompare,
   compileCSSFunctions,
   createCompiler,
@@ -19,367 +19,766 @@ import {
   renderCSS,
   scanCSSForTokenUsage,
   withTimeout
-} from "./chunk-ZI5ZYNSU.mjs";
+} from "./chunk-KSNYSR3C.mjs";
 import {
   checkPaletteContrast,
   generateAllColorVariables,
   generateThemeOverrides
-} from "./chunk-KRZL4IDK.mjs";
+} from "./chunk-6U4IOFOS.mjs";
 
-// src/integrations/font-providers/google/state.ts
-var googleFontInternals = {
-  googleFontState: { cache: /* @__PURE__ */ new Map(), fetched: false },
-  googleFontListPromise: null,
-  lastFetchFailureMs: 0,
-  validatedCacheDir: null,
-  resolvedCachePath: null
-};
+// src/scanner/sources.ts
+import { readFile, stat } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { glob } from "tinyglobby";
 
-// src/integrations/font-providers/google/cache.ts
-import { createHash, randomUUID } from "crypto";
-import { open as fsOpen, writeFile, rename, unlink, mkdir } from "fs/promises";
-import { resolve, dirname, join, isAbsolute } from "path";
-import { isAbsolute as win32IsAbsolute } from "path/win32";
-var MAX_FONT_CACHE_TTL_SECONDS = 30 * 24 * 60 * 60;
-function getFontCacheDir() {
-  if (googleFontInternals.validatedCacheDir !== null) return googleFontInternals.validatedCacheDir;
-  const raw = process.env.RI_CACHE_DIR || "node_modules/.cache/rainbowindex";
-  if (isAbsolute(raw) || win32IsAbsolute(raw)) {
-    throw new Error(
-      `[RI-1208] RI_CACHE_DIR must be a relative path, got absolute path: "${raw}". Use a relative path like "node_modules/.cache/rainbowindex".`
-    );
-  }
-  if (raw.split(/[\\/]/).some((s) => s === "..")) {
-    throw new Error(
-      `[RI-1209] RI_CACHE_DIR must not contain ".." segments: "${raw}". Use a direct relative path like "node_modules/.cache/rainbowindex".`
-    );
-  }
-  googleFontInternals.validatedCacheDir = raw;
-  return raw;
-}
-function getFontCacheFile() {
-  return `${getFontCacheDir()}/google.json`;
-}
-function getResolvedCachePath() {
-  if (googleFontInternals.resolvedCachePath !== null && googleFontInternals.validatedCacheDir !== null) {
-    return googleFontInternals.resolvedCachePath;
+// src/scanner/glob-utils.ts
+import { isAbsolute, win32 } from "path";
+function validateGlobPattern(pattern) {
+  if (!pattern?.trim()) {
+    return "Glob pattern is empty.";
   }
-  googleFontInternals.resolvedCachePath = resolve(process.cwd(), getFontCacheFile());
-  return googleFontInternals.resolvedCachePath;
-}
-function getFontCacheTTL() {
-  const envVal = process.env.RI_FONT_CACHE_TTL;
-  if (envVal) {
-    const seconds = Number(envVal);
-    if (!Number.isNaN(seconds) && seconds >= 0) {
-      if (seconds > MAX_FONT_CACHE_TTL_SECONDS) {
-        console.warn(
-          `[RI-1211] RI_FONT_CACHE_TTL=${seconds} exceeds maximum of ${MAX_FONT_CACHE_TTL_SECONDS} seconds (30 days). Clamping to 30 days.`
-        );
-        return MAX_FONT_CACHE_TTL_SECONDS * 1e3;
-      }
-      return seconds * 1e3;
-    }
+  if (pattern.includes("\0")) {
+    return "Glob pattern contains a null byte, which is invalid in file paths.";
   }
-  return 7 * 24 * 60 * 60 * 1e3;
-}
-function parseCachedMetaEntries(raw) {
-  const parsed = JSON.parse(raw);
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !("checksum" in parsed) || !("entries" in parsed)) {
-    return null;
+  if (isAbsolute(pattern) || win32.isAbsolute(pattern)) {
+    return `Glob pattern "${pattern}" must be relative, not absolute.`;
   }
-  if (!Array.isArray(parsed.entries)) return null;
-  const entriesJson = JSON.stringify(parsed.entries);
-  const expected = createHash("sha256").update(entriesJson).digest("hex");
-  if (typeof parsed.checksum !== "string" || parsed.checksum !== expected) return null;
-  const entries = parsed.entries;
-  const newCache = /* @__PURE__ */ new Map();
-  for (const rawItem of entries) {
-    if (!rawItem || typeof rawItem !== "object") continue;
-    const item = rawItem;
-    if (typeof item.family !== "string" || typeof item.variable !== "boolean" || typeof item.category !== "string" || item.axes !== void 0 && !Array.isArray(item.axes)) {
-      continue;
+  const segments = pattern.split(/[\\/]+/);
+  for (const seg of segments) {
+    if (seg === "..") {
+      return `Glob pattern "${pattern}" must not traverse parent directories (".."). Restructure your project layout so source files are within the project root, or use @source with a pattern rooted at the project directory.`;
     }
-    if (!SAFE_FONT_FAMILY_RE.test(item.family)) continue;
-    const axes = Array.isArray(item.axes) ? item.axes.filter((a) => {
-      if (!a || typeof a !== "object") return false;
-      const axis = a;
-      return typeof axis.tag === "string" && typeof axis.start === "number" && Number.isFinite(axis.start) && typeof axis.end === "number" && Number.isFinite(axis.end);
-    }).map((a) => {
-      const axis = { tag: a.tag, start: a.start, end: a.end };
-      Object.freeze(axis);
-      return axis;
-    }) : void 0;
-    if (axes) Object.freeze(axes);
-    const entry = {
-      family: item.family,
-      variable: item.variable,
-      axes,
-      category: item.category
-    };
-    Object.freeze(entry);
-    newCache.set(entry.family, entry);
   }
-  return newCache.size > 0 ? newCache : null;
+  return null;
 }
-async function loadFontCache(ignoreExpiry = false) {
+
+// src/scanner/package-discovery.ts
+import { existsSync, readFileSync, realpathSync, statSync } from "fs";
+import { dirname, join, posix, resolve } from "path";
+var EMPTY = Object.freeze({ sources: [], warnings: [] });
+var discoveryCache = /* @__PURE__ */ new Map();
+function discoverPackageSafelistSources(cwd) {
+  const cwdAbs = resolve(cwd);
+  let mtimeMs;
   try {
-    const cachePath = getResolvedCachePath();
-    const fh = await fsOpen(cachePath, "r");
-    let raw;
-    try {
-      if (!ignoreExpiry) {
-        const st = await fh.stat();
-        if (Date.now() - st.mtimeMs > getFontCacheTTL()) return false;
-      }
-      raw = await fh.readFile("utf-8");
-    } finally {
-      await fh.close();
-    }
-    const newCache = parseCachedMetaEntries(raw);
-    if (!newCache) return false;
-    googleFontInternals.googleFontState = { cache: newCache, fetched: true };
-    return true;
+    mtimeMs = statSync(join(cwdAbs, "package.json")).mtimeMs;
   } catch {
-    return false;
+    return EMPTY;
   }
+  const cached = discoveryCache.get(cwdAbs);
+  if (cached && cached.mtimeMs === mtimeMs) return cached.result;
+  const result = runDiscovery(cwdAbs);
+  discoveryCache.set(cwdAbs, { mtimeMs, result });
+  return result;
 }
-async function saveFontCache() {
+function runDiscovery(cwdAbs) {
+  let consumer;
   try {
-    const cachePath = getResolvedCachePath();
-    await mkdir(dirname(cachePath), { recursive: true });
-    const entries = Array.from(googleFontInternals.googleFontState.cache.values());
-    const entriesJson = JSON.stringify(entries);
-    const checksum = createHash("sha256").update(entriesJson).digest("hex");
-    const payload = `{"checksum":${JSON.stringify(checksum)},"entries":${entriesJson}}`;
-    const tmpPath = join(dirname(cachePath), `.google-${process.pid}-${randomUUID()}.tmp`);
+    consumer = readPackageJson(join(cwdAbs, "package.json"));
+  } catch {
+    return EMPTY;
+  }
+  const deps = [
+    ...Object.keys(consumer.dependencies ?? {}),
+    ...Object.keys(consumer.peerDependencies ?? {})
+  ];
+  if (deps.length === 0) return EMPTY;
+  const sources = [];
+  const warnings = [];
+  for (const depName of deps) {
+    const depPkgPath = findDepPackageJson(cwdAbs, depName);
+    if (!depPkgPath) {
+      continue;
+    }
+    let depPkg;
     try {
-      await writeFile(tmpPath, payload);
-      await rename(tmpPath, cachePath);
-    } finally {
-      await unlink(tmpPath).catch(() => {
-      });
+      depPkg = readPackageJson(depPkgPath);
+    } catch (err) {
+      warnings.push(
+        `[RI-1410] Could not read ${depName}/package.json during safelist discovery: ${errMessage(err)}`
+      );
+      continue;
+    }
+    const patterns = depPkg.rainbowindex?.safelistSources;
+    if (patterns == null) continue;
+    if (!Array.isArray(patterns)) {
+      warnings.push(
+        `[RI-1410] Invalid rainbowindex.safelistSources in ${depName} \u2014 expected an array of glob strings.`
+      );
+      continue;
+    }
+    if (patterns.length === 0) continue;
+    const depRoot = realpathOrFallback(dirname(depPkgPath)).replace(/\\/g, "/");
+    for (const pattern of patterns) {
+      if (typeof pattern !== "string" || !pattern) {
+        warnings.push(
+          `[RI-1410] Invalid rainbowindex.safelistSources entry in ${depName} \u2014 expected a non-empty glob string.`
+        );
+        continue;
+      }
+      if (validateGlobPattern(pattern) !== null) {
+        warnings.push(
+          `[RI-1410] Invalid rainbowindex.safelistSources entry "${pattern}" in ${depName} \u2014 patterns must be relative to the package root and must not traverse parent directories.`
+        );
+        continue;
+      }
+      const absolute = posix.normalize(`${depRoot}/${pattern.replace(/^\.\//, "")}`);
+      if (absolute !== depRoot && !absolute.startsWith(`${depRoot}/`)) {
+        warnings.push(
+          `[RI-1410] Invalid rainbowindex.safelistSources entry "${pattern}" in ${depName} \u2014 resolved outside the package root.`
+        );
+        continue;
+      }
+      sources.push({ pattern: absolute, negated: false, inline: false, absolute: true });
     }
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    console.warn(
-      `[RI-1210] Failed to write font cache to ${getFontCacheFile()}: ${reason}. Each build will fetch from Google Fonts. Set RI_CACHE_DIR to a writable path or use RI_OFFLINE=1 with a pre-populated cache.`
-    );
   }
+  return { sources, warnings };
 }
-
-// src/integrations/font-providers/google/client.ts
-var MAX_RESPONSE_SIZE = 10 * 1024 * 1024;
-var MAX_RETRIES = 2;
-var FETCH_TIMEOUT_MS = 5e3;
-function wait(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+function readPackageJson(path) {
+  const raw = readFileSync(path, "utf8");
+  return JSON.parse(raw);
 }
-function toGoogleFontMetaMap(data) {
-  const newCache = /* @__PURE__ */ new Map();
-  for (const font of data.familyMetadataList) {
-    const wghtAxis = font.axes.find((a) => a.tag === "wght");
-    const axes = font.axes.map((a) => {
-      const axis = { tag: a.tag, start: a.min, end: a.max };
-      Object.freeze(axis);
-      return axis;
-    });
-    Object.freeze(axes);
-    const entry = {
-      family: font.family,
-      variable: wghtAxis ? wghtAxis.min !== wghtAxis.max : false,
-      axes,
-      category: font.category
-    };
-    Object.freeze(entry);
-    newCache.set(font.family, entry);
+function findDepPackageJson(cwd, depName) {
+  let dir = cwd;
+  while (true) {
+    const candidate = join(dir, "node_modules", depName, "package.json");
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
   }
-  return newCache;
 }
-async function readJsonResponse(res) {
-  const reader = res.body?.getReader();
-  if (!reader) {
-    throw new Error("[RI-1207] Google Fonts metadata response has no readable body.");
+function realpathOrFallback(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
   }
-  const chunks = [];
-  let totalBytes = 0;
-  for (; ; ) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    totalBytes += value.byteLength;
-    if (totalBytes > MAX_RESPONSE_SIZE) {
-      reader.cancel();
-      throw new Error(
-        `[RI-1207] Google Fonts metadata response too large (>${MAX_RESPONSE_SIZE} bytes).`
-      );
-    }
-    chunks.push(value);
-  }
-  const text = new TextDecoder().decode(
-    chunks.length === 1 ? chunks[0] : await new Blob(chunks).arrayBuffer()
-  );
-  return JSON.parse(text);
 }
-async function fetchGoogleFontMetadata() {
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-    try {
-      const res = await fetch("https://fonts.google.com/metadata/fonts", {
-        signal: controller.signal
-      });
-      const contentLength = res.headers.get("content-length");
-      if (contentLength && Number(contentLength) > MAX_RESPONSE_SIZE) {
-        throw new Error(
-          `[RI-1207] Google Fonts metadata response too large (${contentLength} bytes).`
-        );
-      }
-      if (!res.ok) {
-        throw new Error(`[RI-1205] Google Fonts metadata request failed with HTTP ${res.status}.`);
-      }
-      const contentType = res.headers.get("content-type") ?? "";
-      if (contentType && !contentType.includes("json")) {
-        throw new Error(
-          `[RI-1207] Google Fonts metadata returned unexpected Content-Type "${contentType}" instead of JSON.`
-        );
-      }
-      const data = await readJsonResponse(res);
-      return toGoogleFontMetaMap(data);
-    } catch (err) {
-      if (attempt < MAX_RETRIES) {
-        await wait(1e3 * 2 ** attempt);
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/scanner/sources.ts
+var DEFAULT_PATTERNS = Object.freeze([
+  "*.html",
+  "src/**/*.{html,js,jsx,ts,tsx,mdx,vue,svelte}"
+]);
+var DEFAULT_EXCLUDES = Object.freeze([
+  "node_modules/**",
+  "dist/**",
+  "build/**",
+  "coverage/**",
+  "public/**",
+  "**/*.config.*",
+  "**/*.d.ts"
+]);
+var MAX_FILE_SIZE = 1048576;
+var MAX_INLINE_SOURCE_SIZE = 102400;
+var GLOB_TIMEOUT_MS = 3e4;
+var GLOB_TIMEOUT_MESSAGE = `glob() timed out after ${GLOB_TIMEOUT_MS / 1e3}s \u2014 check for network filesystem issues or overly broad @source patterns`;
+var SOURCE_LIST_CACHE_MAX_ENTRIES = 50;
+var sourceListCacheEnabled = false;
+var sourceListCache = /* @__PURE__ */ new Map();
+var sourceListCacheGeneration = 0;
+function enableSourceFileListCache() {
+  sourceListCacheEnabled = true;
+}
+function invalidateSourceFileListCache() {
+  sourceListCacheGeneration++;
+  sourceListCache.clear();
+}
+function collectPatterns(sources) {
+  const includePatterns = [];
+  const nodeModulesIncludePatterns = [];
+  const excludePatterns = [...DEFAULT_EXCLUDES];
+  const hasUserPositiveGlobs = sources.some((s) => !s.inline && !s.negated && !s.absolute);
+  if (!hasUserPositiveGlobs) {
+    includePatterns.push(...DEFAULT_PATTERNS);
+  }
+  const warnings = [];
+  for (const src of sources) {
+    if (src.inline) continue;
+    if (!src.absolute) {
+      const err = validateGlobPattern(src.pattern);
+      if (err) {
+        warnings.push(`[RI-1404] @source pattern rejected: ${err}`);
         continue;
       }
-      throw err;
-    } finally {
-      clearTimeout(timeout);
+    }
+    if (src.negated) {
+      excludePatterns.push(src.pattern);
+    } else if (src.absolute || src.pattern.replace(/^\.\//, "").startsWith("node_modules/")) {
+      nodeModulesIncludePatterns.push(src.pattern);
+    } else {
+      includePatterns.push(src.pattern);
     }
   }
-  throw new Error("[RI-1205] Exhausted Google Fonts metadata fetch retries.");
+  return {
+    includePatterns,
+    nodeModulesIncludePatterns,
+    excludePatterns,
+    warnings,
+    hasUserPositiveGlobs
+  };
 }
-
-// src/integrations/font-providers/google/index.ts
-var FETCH_RETRY_COOLDOWN_MS = 3e4;
-async function fetchGoogleFontList() {
-  if (googleFontInternals.googleFontState.fetched) return;
-  if (googleFontInternals.googleFontListPromise) return googleFontInternals.googleFontListPromise;
-  if (googleFontInternals.lastFetchFailureMs > 0 && Date.now() - googleFontInternals.lastFetchFailureMs < FETCH_RETRY_COOLDOWN_MS) {
-    return;
-  }
-  const localPromise = (async () => {
-    try {
-      const isOffline = process.env.RI_OFFLINE === "1" || process.env.RI_OFFLINE === "true";
-      if (isOffline) {
-        if (await loadFontCache(true)) return;
-        console.warn(
-          `[RI-1206] RI_OFFLINE is set but no local font cache found at ${getFontCacheFile()}. Run once with network access to populate it. Non-variable fonts will default to weight "100 900" and may produce broken Google Fonts URLs \u2014 set an explicit weight in the @font directive to avoid this.`
-        );
-        return;
-      }
-      if (await loadFontCache()) return;
-      const fetchDisabled = process.env.RI_FETCH_FONTS === "0" || process.env.RI_FETCH_FONTS === "false";
-      if (fetchDisabled) {
-        if (await loadFontCache(true)) return;
-        return;
-      }
-      if (typeof globalThis.fetch !== "function") {
-        console.warn(
-          "[RI-1212] Global fetch() is not available. Google Fonts metadata requires Node.js >= 18. Skipping font fetch."
+async function resolveSourceFilesAsync(sources, cwd, hasInlineClasses = false) {
+  const {
+    includePatterns,
+    nodeModulesIncludePatterns,
+    excludePatterns,
+    warnings,
+    hasUserPositiveGlobs
+  } = collectPatterns(sources);
+  const allIncludes = [...includePatterns, ...nodeModulesIncludePatterns];
+  if (allIncludes.length === 0) return { files: [], warnings };
+  const cacheKey = sourceListCacheEnabled ? [
+    cwd,
+    includePatterns.join("\0"),
+    nodeModulesIncludePatterns.join("\0"),
+    excludePatterns.join("\0")
+  ].join("
") : null;
+  try {
+    const generationAtStart = sourceListCacheGeneration;
+    let files = cacheKey !== null ? sourceListCache.get(cacheKey) : void 0;
+    if (files === void 0) {
+      const globPasses = [];
+      if (includePatterns.length > 0) {
+        globPasses.push(
+          withTimeout(
+            glob(includePatterns, { cwd, ignore: excludePatterns }),
+            GLOB_TIMEOUT_MS,
+            GLOB_TIMEOUT_MESSAGE
+          )
         );
-        return;
       }
-      if (isRIDebug()) {
-        console.warn("[RI-DEBUG] Fetching Google Fonts metadata...");
-      }
-      try {
-        const newCache = await fetchGoogleFontMetadata();
-        googleFontInternals.googleFontState = { cache: newCache, fetched: true };
-        await saveFontCache();
-        return;
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (message.startsWith("[RI-1207]")) {
-          console.warn(`${message} Skipping.`);
-          if (await loadFontCache(true)) return;
-          return;
-        }
-        if (await loadFontCache(true)) return;
-        console.warn(
-          `[RI-1205] Could not fetch Google Fonts metadata after 3 attempts (${message}). Fonts without explicit weight/style will default to "100 900" + "normal italic" \u2014 non-variable fonts may produce broken Google Fonts URLs. Run with network access to populate the metadata cache, or set an explicit weight/style in the @font directive.`
+      if (nodeModulesIncludePatterns.length > 0) {
+        const relaxedExcludes = excludePatterns.filter((p) => p !== "node_modules/**");
+        globPasses.push(
+          withTimeout(
+            glob(nodeModulesIncludePatterns, { cwd, ignore: relaxedExcludes }),
+            GLOB_TIMEOUT_MS,
+            GLOB_TIMEOUT_MESSAGE
+          )
         );
       }
-    } finally {
-      if (!googleFontInternals.googleFontState.fetched) {
-        googleFontInternals.lastFetchFailureMs = Date.now();
+      const matched = (await Promise.all(globPasses)).flat();
+      files = [...new Set(matched.map((f) => resolve2(cwd, f)))].sort(codepointCompare);
+      if (cacheKey !== null && sourceListCacheGeneration === generationAtStart) {
+        if (sourceListCache.size >= SOURCE_LIST_CACHE_MAX_ENTRIES) sourceListCache.clear();
+        sourceListCache.set(cacheKey, files);
       }
-      googleFontInternals.googleFontListPromise = null;
     }
-  })();
-  googleFontInternals.googleFontListPromise = localPromise;
-  return localPromise;
+    if (files.length === 0 && !(hasInlineClasses && !hasUserPositiveGlobs)) {
+      warnings.push(
+        `[RI-1401] No source files found matching ${allIncludes.map((p) => `"${p}"`).join(", ")} \u2014 check @source paths or project structure.`
+      );
+    }
+    return { files, warnings };
+  } catch (err) {
+    warnings.push(
+      `[RI-1402] Invalid glob pattern \u2014 skipping. Check @source syntax. (${err instanceof Error ? err.message : String(err)})`
+    );
+    return { files: [], warnings };
+  }
 }
-var refreshMemo = /* @__PURE__ */ new WeakMap();
-function refreshFontWeightDefaults(fonts) {
-  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;
-    let changed = false;
-    const faces = slot.faces.map((f) => {
-      let next = f;
-      if (!f._weightExplicit) {
-        const wghtAxis = meta.axes?.find((a) => a.tag === "wght");
-        const axisWeight = wghtAxis && wghtAxis.start !== wghtAxis.end ? `${wghtAxis.start} ${wghtAxis.end}` : "400";
-        if (next.weight !== axisWeight) next = { ...next, weight: axisWeight };
-      }
-      if (!f._styleExplicit) {
-        const italAxis = meta.axes?.find((a) => a.tag === "ital");
-        const axisStyle = italAxis ? "normal italic" : "normal";
-        if (next.style !== axisStyle) next = { ...next, style: axisStyle };
-      }
-      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;
+function collectInlineClasses(sources) {
+  const classes = /* @__PURE__ */ new Set();
+  const warnings = [];
+  for (const src of sources) {
+    if (!src.inline) continue;
+    const items = src.classes ?? [];
+    let contentLength = 0;
+    for (const cls of items) contentLength += cls.length;
+    if (contentLength > MAX_INLINE_SOURCE_SIZE) {
+      warnings.push(
+        `[RI-1406] Inline @source content exceeds ${MAX_INLINE_SOURCE_SIZE} byte limit (${contentLength} bytes) \u2014 skipping.`
+      );
+      continue;
+    }
+    for (const cls of items) {
+      if (cls) classes.add(cls);
+    }
+  }
+  return { classes, warnings };
 }
-var FONT_FETCH_TIMEOUT_MS = 1e4;
-async function resolveGoogleFonts(fonts) {
-  if (!fonts.some((slot) => slot.kind === "google")) return fonts;
-  try {
-    await withTimeout(
-      fetchGoogleFontList(),
-      FONT_FETCH_TIMEOUT_MS,
-      "[RI-1213] Google Fonts metadata fetch timed out"
-    );
-  } catch {
-    console.warn(
-      `[RI-1213] Could not fetch Google Fonts metadata within ${FONT_FETCH_TIMEOUT_MS / 1e3}s \u2014 proceeding with default font weights. Variable-weight fonts may use "400" instead of their full range.`
-    );
+var FILE_IO_TIMEOUT_MS = 1e4;
+var SCAN_CACHE_MAX_ENTRIES = 2e4;
+var scanCache = /* @__PURE__ */ new Map();
+var scanChangeTrackingEnabled = false;
+function enableScanChangeTracking() {
+  scanChangeTrackingEnabled = true;
+}
+function markSourceFileChanged(file, cwd) {
+  scanCache.delete(cwd === void 0 ? file : resolve2(cwd, file));
+}
+function disableScanChangeTracking() {
+  scanChangeTrackingEnabled = false;
+  scanCache.clear();
+}
+var fileUnion = null;
+function applyToUnion(union, result, delta) {
+  if (!result?.classes) return;
+  for (const cls of result.classes) {
+    const next = (union.counts.get(cls) ?? 0) + delta;
+    if (next > 0) {
+      union.counts.set(cls, next);
+      if (delta === 1) union.classes.add(cls);
+    } else {
+      union.counts.delete(cls);
+      union.classes.delete(cls);
+    }
   }
-  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"],
+async function scanOneFile(file) {
+  const warnings = [];
+  if (scanChangeTrackingEnabled) {
+    const tracked = scanCache.get(file);
+    if (tracked) return tracked.result;
+  }
+  try {
+    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}" (${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
+      };
+    }
+    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,
+      warnings,
+      failure: `[RI-1403] Could not read source file "${file}" \u2014 skipping. (${err instanceof Error ? err.message : String(err)})`
+    };
+  }
+}
+async function scanSourceFilesAsync(sources, cwd) {
+  const { classes: allClasses, warnings: inlineWarnings } = collectInlineClasses(sources);
+  const authored = new Set(allClasses);
+  const allWarnings = [...inlineWarnings];
+  const { files, warnings: resolveWarnings } = await resolveSourceFilesAsync(
+    sources,
+    cwd,
+    allClasses.size > 0
+  );
+  allWarnings.push(...resolveWarnings);
+  const CONCURRENCY_LIMIT = 32;
+  const results = new Array(files.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < files.length) {
+      const index = nextIndex++;
+      results[index] = await scanOneFile(files[index]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(CONCURRENCY_LIMIT, files.length) }, worker));
+  const seen = new Set(allWarnings);
+  for (const result of results) {
+    if (result.failure) {
+      allWarnings.push(result.failure);
+      seen.add(result.failure);
+      continue;
+    }
+    pushWarningsDeduped(allWarnings, result.warnings, seen);
+  }
+  if (fileUnion === null || fileUnion.results.length !== results.length) {
+    fileUnion = { results, counts: /* @__PURE__ */ new Map(), classes: /* @__PURE__ */ new Set() };
+    for (const result of results) applyToUnion(fileUnion, result, 1);
+  } else {
+    const previous = fileUnion.results;
+    for (let i = 0; i < results.length; i++) {
+      if (previous[i] === results[i]) continue;
+      applyToUnion(fileUnion, previous[i], -1);
+      applyToUnion(fileUnion, results[i], 1);
+    }
+    fileUnion.results = results;
+  }
+  for (const cls of fileUnion.classes) allClasses.add(cls);
+  return { classes: allClasses, authored, warnings: allWarnings };
+}
+async function collectProjectClasses(themeSources, surfaceSources, cwd, warnings, warningSeen, suppressed) {
+  const discovered = discoverPackageSafelistSources(cwd);
+  pushWarningsDeduped(warnings, discovered.warnings, warningSeen, suppressed);
+  const allSources = [...themeSources, ...surfaceSources, ...discovered.sources];
+  const scanResult = await scanSourceFilesAsync(allSources, cwd);
+  pushWarningsDeduped(warnings, scanResult.warnings, warningSeen, suppressed);
+  return { classes: scanResult.classes, authored: scanResult.authored };
+}
+
+// src/integrations/font-providers/google/state.ts
+var googleFontInternals = {
+  googleFontState: { cache: /* @__PURE__ */ new Map(), fetched: false },
+  googleFontListPromise: null,
+  lastFetchFailureMs: 0,
+  validatedCacheDir: null,
+  resolvedCachePath: null
+};
+
+// src/integrations/font-providers/google/cache.ts
+import { createHash, randomUUID } from "crypto";
+import { open as fsOpen, writeFile, rename, unlink, mkdir } from "fs/promises";
+import { resolve as resolve3, dirname as dirname2, join as join2, isAbsolute as isAbsolute2 } from "path";
+import { isAbsolute as win32IsAbsolute } from "path/win32";
+var MAX_FONT_CACHE_TTL_SECONDS = 30 * 24 * 60 * 60;
+function getFontCacheDir() {
+  if (googleFontInternals.validatedCacheDir !== null) return googleFontInternals.validatedCacheDir;
+  const raw = process.env.RI_CACHE_DIR || "node_modules/.cache/rainbowindex";
+  if (isAbsolute2(raw) || win32IsAbsolute(raw)) {
+    throw new Error(
+      `[RI-1208] RI_CACHE_DIR must be a relative path, got absolute path: "${raw}". Use a relative path like "node_modules/.cache/rainbowindex".`
+    );
+  }
+  if (raw.split(/[\\/]/).some((s) => s === "..")) {
+    throw new Error(
+      `[RI-1209] RI_CACHE_DIR must not contain ".." segments: "${raw}". Use a direct relative path like "node_modules/.cache/rainbowindex".`
+    );
+  }
+  googleFontInternals.validatedCacheDir = raw;
+  return raw;
+}
+function getFontCacheFile() {
+  return `${getFontCacheDir()}/google.json`;
+}
+function getResolvedCachePath() {
+  if (googleFontInternals.resolvedCachePath !== null && googleFontInternals.validatedCacheDir !== null) {
+    return googleFontInternals.resolvedCachePath;
+  }
+  googleFontInternals.resolvedCachePath = resolve3(process.cwd(), getFontCacheFile());
+  return googleFontInternals.resolvedCachePath;
+}
+function getFontCacheTTL() {
+  const envVal = process.env.RI_FONT_CACHE_TTL;
+  if (envVal) {
+    const seconds = Number(envVal);
+    if (!Number.isNaN(seconds) && seconds >= 0) {
+      if (seconds > MAX_FONT_CACHE_TTL_SECONDS) {
+        console.warn(
+          `[RI-1211] RI_FONT_CACHE_TTL=${seconds} exceeds maximum of ${MAX_FONT_CACHE_TTL_SECONDS} seconds (30 days). Clamping to 30 days.`
+        );
+        return MAX_FONT_CACHE_TTL_SECONDS * 1e3;
+      }
+      return seconds * 1e3;
+    }
+  }
+  return 7 * 24 * 60 * 60 * 1e3;
+}
+function parseCachedMetaEntries(raw) {
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !("checksum" in parsed) || !("entries" in parsed)) {
+    return null;
+  }
+  if (!Array.isArray(parsed.entries)) return null;
+  const entriesJson = JSON.stringify(parsed.entries);
+  const expected = createHash("sha256").update(entriesJson).digest("hex");
+  if (typeof parsed.checksum !== "string" || parsed.checksum !== expected) return null;
+  const entries = parsed.entries;
+  const newCache = /* @__PURE__ */ new Map();
+  for (const rawItem of entries) {
+    if (!rawItem || typeof rawItem !== "object") continue;
+    const item = rawItem;
+    if (typeof item.family !== "string" || typeof item.variable !== "boolean" || typeof item.category !== "string" || item.axes !== void 0 && !Array.isArray(item.axes)) {
+      continue;
+    }
+    if (!SAFE_FONT_FAMILY_RE.test(item.family)) continue;
+    const axes = Array.isArray(item.axes) ? item.axes.filter((a) => {
+      if (!a || typeof a !== "object") return false;
+      const axis = a;
+      return typeof axis.tag === "string" && typeof axis.start === "number" && Number.isFinite(axis.start) && typeof axis.end === "number" && Number.isFinite(axis.end);
+    }).map((a) => {
+      const axis = { tag: a.tag, start: a.start, end: a.end };
+      Object.freeze(axis);
+      return axis;
+    }) : void 0;
+    if (axes) Object.freeze(axes);
+    const entry = {
+      family: item.family,
+      variable: item.variable,
+      axes,
+      category: item.category
+    };
+    Object.freeze(entry);
+    newCache.set(entry.family, entry);
+  }
+  return newCache.size > 0 ? newCache : null;
+}
+async function loadFontCache(ignoreExpiry = false) {
+  try {
+    const cachePath = getResolvedCachePath();
+    const fh = await fsOpen(cachePath, "r");
+    let raw;
+    try {
+      if (!ignoreExpiry) {
+        const st = await fh.stat();
+        if (Date.now() - st.mtimeMs > getFontCacheTTL()) return false;
+      }
+      raw = await fh.readFile("utf-8");
+    } finally {
+      await fh.close();
+    }
+    const newCache = parseCachedMetaEntries(raw);
+    if (!newCache) return false;
+    googleFontInternals.googleFontState = { cache: newCache, fetched: true };
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function saveFontCache() {
+  try {
+    const cachePath = getResolvedCachePath();
+    await mkdir(dirname2(cachePath), { recursive: true });
+    const entries = Array.from(googleFontInternals.googleFontState.cache.values());
+    const entriesJson = JSON.stringify(entries);
+    const checksum = createHash("sha256").update(entriesJson).digest("hex");
+    const payload = `{"checksum":${JSON.stringify(checksum)},"entries":${entriesJson}}`;
+    const tmpPath = join2(dirname2(cachePath), `.google-${process.pid}-${randomUUID()}.tmp`);
+    try {
+      await writeFile(tmpPath, payload);
+      await rename(tmpPath, cachePath);
+    } finally {
+      await unlink(tmpPath).catch(() => {
+      });
+    }
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    console.warn(
+      `[RI-1210] Failed to write font cache to ${getFontCacheFile()}: ${reason}. Each build will fetch from Google Fonts. Set RI_CACHE_DIR to a writable path or use RI_OFFLINE=1 with a pre-populated cache.`
+    );
+  }
+}
+
+// src/integrations/font-providers/google/client.ts
+var MAX_RESPONSE_SIZE = 10 * 1024 * 1024;
+var MAX_RETRIES = 2;
+var FETCH_TIMEOUT_MS = 5e3;
+function wait(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function toGoogleFontMetaMap(data) {
+  const newCache = /* @__PURE__ */ new Map();
+  for (const font of data.familyMetadataList) {
+    const wghtAxis = font.axes.find((a) => a.tag === "wght");
+    const axes = font.axes.map((a) => {
+      const axis = { tag: a.tag, start: a.min, end: a.max };
+      Object.freeze(axis);
+      return axis;
+    });
+    Object.freeze(axes);
+    const entry = {
+      family: font.family,
+      variable: wghtAxis ? wghtAxis.min !== wghtAxis.max : false,
+      axes,
+      category: font.category
+    };
+    Object.freeze(entry);
+    newCache.set(font.family, entry);
+  }
+  return newCache;
+}
+async function readJsonResponse(res) {
+  const reader = res.body?.getReader();
+  if (!reader) {
+    throw new Error("[RI-1207] Google Fonts metadata response has no readable body.");
+  }
+  const chunks = [];
+  let totalBytes = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    totalBytes += value.byteLength;
+    if (totalBytes > MAX_RESPONSE_SIZE) {
+      reader.cancel();
+      throw new Error(
+        `[RI-1207] Google Fonts metadata response too large (>${MAX_RESPONSE_SIZE} bytes).`
+      );
+    }
+    chunks.push(value);
+  }
+  const text = new TextDecoder().decode(
+    chunks.length === 1 ? chunks[0] : await new Blob(chunks).arrayBuffer()
+  );
+  return JSON.parse(text);
+}
+async function fetchGoogleFontMetadata() {
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const res = await fetch("https://fonts.google.com/metadata/fonts", {
+        signal: controller.signal
+      });
+      const contentLength = res.headers.get("content-length");
+      if (contentLength && Number(contentLength) > MAX_RESPONSE_SIZE) {
+        throw new Error(
+          `[RI-1207] Google Fonts metadata response too large (${contentLength} bytes).`
+        );
+      }
+      if (!res.ok) {
+        throw new Error(`[RI-1205] Google Fonts metadata request failed with HTTP ${res.status}.`);
+      }
+      const contentType = res.headers.get("content-type") ?? "";
+      if (contentType && !contentType.includes("json")) {
+        throw new Error(
+          `[RI-1207] Google Fonts metadata returned unexpected Content-Type "${contentType}" instead of JSON.`
+        );
+      }
+      const data = await readJsonResponse(res);
+      return toGoogleFontMetaMap(data);
+    } catch (err) {
+      if (attempt < MAX_RETRIES) {
+        await wait(1e3 * 2 ** attempt);
+        continue;
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  throw new Error("[RI-1205] Exhausted Google Fonts metadata fetch retries.");
+}
+
+// src/integrations/font-providers/google/index.ts
+var FETCH_RETRY_COOLDOWN_MS = 3e4;
+async function fetchGoogleFontList() {
+  if (googleFontInternals.googleFontState.fetched) return;
+  if (googleFontInternals.googleFontListPromise) return googleFontInternals.googleFontListPromise;
+  if (googleFontInternals.lastFetchFailureMs > 0 && Date.now() - googleFontInternals.lastFetchFailureMs < FETCH_RETRY_COOLDOWN_MS) {
+    return;
+  }
+  const localPromise = (async () => {
+    try {
+      const isOffline = process.env.RI_OFFLINE === "1" || process.env.RI_OFFLINE === "true";
+      if (isOffline) {
+        if (await loadFontCache(true)) return;
+        console.warn(
+          `[RI-1206] RI_OFFLINE is set but no local font cache found at ${getFontCacheFile()}. Run once with network access to populate it. Non-variable fonts will default to weight "100 900" and may produce broken Google Fonts URLs \u2014 set an explicit weight in the @font directive to avoid this.`
+        );
+        return;
+      }
+      if (await loadFontCache()) return;
+      const fetchDisabled = process.env.RI_FETCH_FONTS === "0" || process.env.RI_FETCH_FONTS === "false";
+      if (fetchDisabled) {
+        if (await loadFontCache(true)) return;
+        return;
+      }
+      if (typeof globalThis.fetch !== "function") {
+        console.warn(
+          "[RI-1212] Global fetch() is not available. Google Fonts metadata requires Node.js >= 18. Skipping font fetch."
+        );
+        return;
+      }
+      if (isRIDebug()) {
+        console.warn("[RI-DEBUG] Fetching Google Fonts metadata...");
+      }
+      try {
+        const newCache = await fetchGoogleFontMetadata();
+        googleFontInternals.googleFontState = { cache: newCache, fetched: true };
+        await saveFontCache();
+        return;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.startsWith("[RI-1207]")) {
+          console.warn(`${message} Skipping.`);
+          if (await loadFontCache(true)) return;
+          return;
+        }
+        if (await loadFontCache(true)) return;
+        console.warn(
+          `[RI-1205] Could not fetch Google Fonts metadata after 3 attempts (${message}). Fonts without explicit weight/style will default to "100 900" + "normal italic" \u2014 non-variable fonts may produce broken Google Fonts URLs. Run with network access to populate the metadata cache, or set an explicit weight/style in the @font directive.`
+        );
+      }
+    } finally {
+      if (!googleFontInternals.googleFontState.fetched) {
+        googleFontInternals.lastFetchFailureMs = Date.now();
+      }
+      googleFontInternals.googleFontListPromise = null;
+    }
+  })();
+  googleFontInternals.googleFontListPromise = localPromise;
+  return localPromise;
+}
+var refreshMemo = /* @__PURE__ */ new WeakMap();
+function refreshFontWeightDefaults(fonts) {
+  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;
+    let changed = false;
+    const faces = slot.faces.map((f) => {
+      let next = f;
+      if (!f._weightExplicit) {
+        const wghtAxis = meta.axes?.find((a) => a.tag === "wght");
+        const axisWeight = wghtAxis && wghtAxis.start !== wghtAxis.end ? `${wghtAxis.start} ${wghtAxis.end}` : "400";
+        if (next.weight !== axisWeight) next = { ...next, weight: axisWeight };
+      }
+      if (!f._styleExplicit) {
+        const italAxis = meta.axes?.find((a) => a.tag === "ital");
+        const axisStyle = italAxis ? "normal italic" : "normal";
+        if (next.style !== axisStyle) next = { ...next, style: axisStyle };
+      }
+      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) {
+  if (!fonts.some((slot) => slot.kind === "google")) return fonts;
+  try {
+    await withTimeout(
+      fetchGoogleFontList(),
+      FONT_FETCH_TIMEOUT_MS,
+      "[RI-1213] Google Fonts metadata fetch timed out"
+    );
+  } catch {
+    console.warn(
+      `[RI-1213] Could not fetch Google Fonts metadata within ${FONT_FETCH_TIMEOUT_MS / 1e3}s \u2014 proceeding with default font weights. Variable-weight fonts may use "400" instead of their full range.`
+    );
+  }
+  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"],
@@ -448,571 +847,235 @@ var FONT_METRICS_TABLE = {
   "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"',
-  serif: 'ui-serif, Georgia, Cambria, "Times New Roman", Times, serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"',
-  mono: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"'
-});
-function getFallbackStack(slot) {
-  if (!SYSTEM_STACKS[slot] && isRIDebug()) {
-    console.warn(`[RI-DEBUG] Unknown font slot "${slot}" \u2014 falling back to sans stack.`);
-  }
-  return SYSTEM_STACKS[slot] || SYSTEM_STACKS.sans;
-}
-function googleFontsUrl(family, face) {
-  const encodedFamily = encodeURIComponent(family).replace(/%20/g, "+");
-  let axisParam;
-  if (face.weight.includes(",")) {
-    const weights = face.weight.split(",").map((w) => w.trim());
-    if (face.style.includes("italic")) {
-      const tuples = weights.flatMap((w) => [`0,${w}`, `1,${w}`]);
-      axisParam = `ital,wght@${tuples.join(";")}`;
-    } else {
-      axisParam = `wght@${weights.join(";")}`;
-    }
-  } else if (face.weight.includes(" ")) {
-    const range = face.weight.replace(" ", "..");
-    axisParam = face.style.includes("italic") ? `ital,wght@0,${range};1,${range}` : `wght@${range}`;
-  } else {
-    const w = face.weight || "400";
-    axisParam = face.style.includes("italic") ? `ital,wght@0,${w};1,${w}` : `wght@${w}`;
-  }
-  const display = face.display || "swap";
-  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 ");
-}
-function generateFallbackFontFace(family, metrics) {
-  const safeFamily = escapeFontFamily(family);
-  return `@font-face {
-  font-family: "${safeFamily} Fallback";
-  src: local("${escapeFontFamily(metrics.fallback)}");
-  size-adjust: ${metrics.sizeAdjust}%;
-  ascent-override: ${metrics.ascent}%;
-  descent-override: ${metrics.descent}%;
-  line-gap-override: ${metrics.lineGap}%;
-}`;
-}
-var FONT_FORMAT_MIME = {
-  woff2: "font/woff2",
-  woff: "font/woff",
-  truetype: "font/ttf",
-  opentype: "font/otf"
-};
-function inferFontFormat(path) {
-  if (path.endsWith(".woff2")) return "woff2";
-  if (path.endsWith(".woff")) return "woff";
-  if (path.endsWith(".ttf")) return "truetype";
-  if (path.endsWith(".otf")) return "opentype";
-  return "woff2";
-}
-function generateWebFontFace(family, face) {
-  if (face.provider === "system" || !face.provider) return null;
-  if (face.provider === "google") {
-    return { type: "import", css: `@import url("${googleFontsUrl(family, face)}");` };
-  }
-  const safeProvider = escapeFontFamily(face.provider);
-  const format = inferFontFormat(face.provider);
-  const src = `url("${safeProvider}") format("${format}")`;
-  const declarations = [`  font-family: "${escapeFontFamily(family)}";`, `  src: ${src};`];
-  if (face.weight) declarations.push(`  font-weight: ${face.weight};`);
-  if (face.style && face.style !== "normal") declarations.push(`  font-style: ${face.style};`);
-  if (face.display) declarations.push(`  font-display: ${face.display};`);
-  if (face.unicodeRange) declarations.push(`  unicode-range: ${face.unicodeRange};`);
-  return { type: "font-face", css: `@font-face {
-${declarations.join("\n")}
-}` };
-}
-function normalizeLocalStyle(style, family, warnings) {
-  if (style.includes(" ") && !style.startsWith("oblique")) {
-    const first = style.split(/\s+/)[0];
-    warnings.push(
-      `[RI-1203] Local font "${family}" has a compound font-style "${style}" \u2014 a single @font-face takes one style. Split upright and italic into separate @face blocks (or use the italic: shorthand). Using "${first}".`
-    );
-    return first;
-  }
-  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 = [];
-  const variables = [];
-  const warnings = [];
-  const pushFeatureVars = () => {
-    if (slot.features) variables.push(`--font-${slot.slot}--features: ${slot.features};`);
-    if (slot.variation) variables.push(`--font-${slot.slot}--variations: ${slot.variation};`);
-  };
-  if (slot.kind === "system") {
-    variables.push(`--font-${slot.slot}: ${getFallbackStack(slot.slot)};`);
-    return { imports, fontFaces, variables, warnings };
-  }
-  if (slot.kind === "manual") {
-    const fallback = slot.fallback.length > 0 ? slot.fallback.join(", ") : getFallbackStack(slot.slot);
-    const stack = [`"${escapeFontFamily(slot.family)}"`, fallback].join(", ");
-    variables.push(`--font-${slot.slot}: ${stack};`);
-    pushFeatureVars();
-    return { imports, fontFaces, variables, warnings };
-  }
-  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(
-        `[RI-1201] Unknown font provider "${face.provider}" for "${slot.family}" \u2014 supported: google, or a file path/URL.`
-      );
-      continue;
-    }
-    const emitFace = face.provider === "google" ? face : { ...face, style: normalizeLocalStyle(face.style, slot.family, warnings) };
-    const webFont = generateWebFontFace(slot.family, emitFace);
-    if (!webFont) continue;
-    if (webFont.type === "import") imports.push(webFont.css);
-    else fontFaces.push(webFont.css);
-  }
-  const fallbackStack = slot.fallback.length > 0 ? slot.fallback.join(", ") : getFallbackStack(slot.slot);
-  const safeFamily = escapeFontFamily(slot.family);
-  const stackParts = [`"${safeFamily}"`];
-  if (metrics) stackParts.push(`"${safeFamily} Fallback"`);
-  stackParts.push(fallbackStack);
-  variables.push(`--font-${slot.slot}: ${stackParts.join(", ")};`);
-  pushFeatureVars();
-  return { imports, fontFaces, variables, warnings };
+  "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()];
 }
-function getFontPreloadLinks(slots) {
-  const links = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const slot of slots) {
-    for (const face of slot.faces) {
-      if (!face.preload) continue;
-      if (face.provider === "system" || face.provider === "google" || !face.provider) continue;
-      if (seen.has(face.provider)) continue;
-      seen.add(face.provider);
-      links.push({
-        href: face.provider,
-        as: "font",
-        type: FONT_FORMAT_MIME[inferFontFormat(face.provider)],
-        crossorigin: true
-      });
-    }
-  }
-  return links;
+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)
+  };
 }
-
-// src/scanner/sources.ts
-import { readFile, stat } from "fs/promises";
-import { resolve as resolve3 } from "path";
-import { glob } from "tinyglobby";
-
-// src/scanner/glob-utils.ts
-import { isAbsolute as isAbsolute2, win32 } from "path";
-function validateGlobPattern(pattern) {
-  if (!pattern?.trim()) {
-    return "Glob pattern is empty.";
-  }
-  if (pattern.includes("\0")) {
-    return "Glob pattern contains a null byte, which is invalid in file paths.";
-  }
-  if (isAbsolute2(pattern) || win32.isAbsolute(pattern)) {
-    return `Glob pattern "${pattern}" must be relative, not absolute.`;
-  }
-  const segments = pattern.split(/[\\/]+/);
-  for (const seg of segments) {
-    if (seg === "..") {
-      return `Glob pattern "${pattern}" must not traverse parent directories (".."). Restructure your project layout so source files are within the project root, or use @source with a pattern rooted at the project directory.`;
-    }
-  }
-  return null;
+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/scanner/package-discovery.ts
-import { existsSync, readFileSync, realpathSync, statSync } from "fs";
-import { dirname as dirname2, join as join2, posix, resolve as resolve2 } from "path";
-var EMPTY = Object.freeze({ sources: [], warnings: [] });
-var discoveryCache = /* @__PURE__ */ new Map();
-function discoverPackageSafelistSources(cwd) {
-  const cwdAbs = resolve2(cwd);
-  let mtimeMs;
-  try {
-    mtimeMs = statSync(join2(cwdAbs, "package.json")).mtimeMs;
-  } catch {
-    return EMPTY;
+// 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"',
+  serif: 'ui-serif, Georgia, Cambria, "Times New Roman", Times, serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"',
+  mono: 'ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"'
+});
+function getFallbackStack(slot) {
+  if (!SYSTEM_STACKS[slot] && isRIDebug()) {
+    console.warn(`[RI-DEBUG] Unknown font slot "${slot}" \u2014 falling back to sans stack.`);
   }
-  const cached = discoveryCache.get(cwdAbs);
-  if (cached && cached.mtimeMs === mtimeMs) return cached.result;
-  const result = runDiscovery(cwdAbs);
-  discoveryCache.set(cwdAbs, { mtimeMs, result });
-  return result;
+  return SYSTEM_STACKS[slot] || SYSTEM_STACKS.sans;
 }
-function runDiscovery(cwdAbs) {
-  let consumer;
-  try {
-    consumer = readPackageJson(join2(cwdAbs, "package.json"));
-  } catch {
-    return EMPTY;
-  }
-  const deps = [
-    ...Object.keys(consumer.dependencies ?? {}),
-    ...Object.keys(consumer.peerDependencies ?? {})
-  ];
-  if (deps.length === 0) return EMPTY;
-  const sources = [];
-  const warnings = [];
-  for (const depName of deps) {
-    const depPkgPath = findDepPackageJson(cwdAbs, depName);
-    if (!depPkgPath) {
-      continue;
-    }
-    let depPkg;
-    try {
-      depPkg = readPackageJson(depPkgPath);
-    } catch (err) {
-      warnings.push(
-        `[RI-1410] Could not read ${depName}/package.json during safelist discovery: ${errMessage(err)}`
-      );
-      continue;
-    }
-    const patterns = depPkg.rainbowindex?.safelistSources;
-    if (patterns == null) continue;
-    if (!Array.isArray(patterns)) {
-      warnings.push(
-        `[RI-1410] Invalid rainbowindex.safelistSources in ${depName} \u2014 expected an array of glob strings.`
-      );
-      continue;
-    }
-    if (patterns.length === 0) continue;
-    const depRoot = realpathOrFallback(dirname2(depPkgPath)).replace(/\\/g, "/");
-    for (const pattern of patterns) {
-      if (typeof pattern !== "string" || !pattern) {
-        warnings.push(
-          `[RI-1410] Invalid rainbowindex.safelistSources entry in ${depName} \u2014 expected a non-empty glob string.`
-        );
-        continue;
-      }
-      if (validateGlobPattern(pattern) !== null) {
-        warnings.push(
-          `[RI-1410] Invalid rainbowindex.safelistSources entry "${pattern}" in ${depName} \u2014 patterns must be relative to the package root and must not traverse parent directories.`
-        );
-        continue;
-      }
-      const absolute = posix.normalize(`${depRoot}/${pattern.replace(/^\.\//, "")}`);
-      if (absolute !== depRoot && !absolute.startsWith(`${depRoot}/`)) {
-        warnings.push(
-          `[RI-1410] Invalid rainbowindex.safelistSources entry "${pattern}" in ${depName} \u2014 resolved outside the package root.`
-        );
-        continue;
-      }
-      sources.push({ pattern: absolute, negated: false, inline: false, absolute: true });
+function googleFontsUrl(family, face) {
+  const encodedFamily = encodeURIComponent(family).replace(/%20/g, "+");
+  let axisParam;
+  if (face.weight.includes(",")) {
+    const weights = face.weight.split(",").map((w) => w.trim());
+    if (face.style.includes("italic")) {
+      const tuples = weights.flatMap((w) => [`0,${w}`, `1,${w}`]);
+      axisParam = `ital,wght@${tuples.join(";")}`;
+    } else {
+      axisParam = `wght@${weights.join(";")}`;
     }
+  } else if (face.weight.includes(" ")) {
+    const range = face.weight.replace(" ", "..");
+    axisParam = face.style.includes("italic") ? `ital,wght@0,${range};1,${range}` : `wght@${range}`;
+  } else {
+    const w = face.weight || "400";
+    axisParam = face.style.includes("italic") ? `ital,wght@0,${w};1,${w}` : `wght@${w}`;
   }
-  return { sources, warnings };
-}
-function readPackageJson(path) {
-  const raw = readFileSync(path, "utf8");
-  return JSON.parse(raw);
-}
-function findDepPackageJson(cwd, depName) {
-  let dir = cwd;
-  while (true) {
-    const candidate = join2(dir, "node_modules", depName, "package.json");
-    if (existsSync(candidate)) return candidate;
-    const parent = dirname2(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
+  const display = face.display || "swap";
+  return `https://fonts.googleapis.com/css2?family=${encodedFamily}:${axisParam}&display=${display}`;
 }
-function realpathOrFallback(path) {
-  try {
-    return realpathSync(path);
-  } catch {
-    return path;
-  }
+function escapeFontFamily(name) {
+  return name.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\0/g, "\\0").replace(/\n/g, "\\a ").replace(/\r/g, "\\d ");
 }
-function errMessage(err) {
-  return err instanceof Error ? err.message : String(err);
+function generateFallbackFontFace(family, metrics) {
+  const safeFamily = escapeFontFamily(family);
+  return `@font-face {
+  font-family: "${safeFamily} Fallback";
+  src: local("${escapeFontFamily(metrics.fallback)}");
+  size-adjust: ${metrics.sizeAdjust}%;
+  ascent-override: ${metrics.ascent}%;
+  descent-override: ${metrics.descent}%;
+  line-gap-override: ${metrics.lineGap}%;
+}`;
 }
-
-// src/scanner/sources.ts
-var DEFAULT_PATTERNS = Object.freeze([
-  "*.html",
-  "src/**/*.{html,js,jsx,ts,tsx,mdx,vue,svelte}"
-]);
-var DEFAULT_EXCLUDES = Object.freeze([
-  "node_modules/**",
-  "dist/**",
-  "build/**",
-  "coverage/**",
-  "public/**",
-  "**/*.config.*",
-  "**/*.d.ts"
-]);
-var MAX_FILE_SIZE = 1048576;
-var MAX_INLINE_SOURCE_SIZE = 102400;
-var GLOB_TIMEOUT_MS = 3e4;
-var GLOB_TIMEOUT_MESSAGE = `glob() timed out after ${GLOB_TIMEOUT_MS / 1e3}s \u2014 check for network filesystem issues or overly broad @source patterns`;
-function collectPatterns(sources) {
-  const includePatterns = [];
-  const nodeModulesIncludePatterns = [];
-  const excludePatterns = [...DEFAULT_EXCLUDES];
-  const hasUserPositiveGlobs = sources.some((s) => !s.inline && !s.negated && !s.absolute);
-  if (!hasUserPositiveGlobs) {
-    includePatterns.push(...DEFAULT_PATTERNS);
+var FONT_FORMAT_MIME = {
+  woff2: "font/woff2",
+  woff: "font/woff",
+  truetype: "font/ttf",
+  opentype: "font/otf"
+};
+function inferFontFormat(path) {
+  if (path.endsWith(".woff2")) return "woff2";
+  if (path.endsWith(".woff")) return "woff";
+  if (path.endsWith(".ttf")) return "truetype";
+  if (path.endsWith(".otf")) return "opentype";
+  return "woff2";
+}
+function generateWebFontFace(family, face) {
+  if (face.provider === "system" || !face.provider) return null;
+  if (face.provider === "google") {
+    return { type: "import", css: `@import url("${googleFontsUrl(family, face)}");` };
   }
-  const warnings = [];
-  for (const src of sources) {
-    if (src.inline) continue;
-    if (!src.absolute) {
-      const err = validateGlobPattern(src.pattern);
-      if (err) {
-        warnings.push(`[RI-1404] @source pattern rejected: ${err}`);
-        continue;
-      }
-    }
-    if (src.negated) {
-      excludePatterns.push(src.pattern);
-    } else if (src.absolute || src.pattern.replace(/^\.\//, "").startsWith("node_modules/")) {
-      nodeModulesIncludePatterns.push(src.pattern);
-    } else {
-      includePatterns.push(src.pattern);
-    }
+  const safeProvider = escapeFontFamily(face.provider);
+  const format = inferFontFormat(face.provider);
+  const src = `url("${safeProvider}") format("${format}")`;
+  const declarations = [`  font-family: "${escapeFontFamily(family)}";`, `  src: ${src};`];
+  if (face.weight) declarations.push(`  font-weight: ${face.weight};`);
+  if (face.style && face.style !== "normal") declarations.push(`  font-style: ${face.style};`);
+  if (face.display) declarations.push(`  font-display: ${face.display};`);
+  if (face.unicodeRange) declarations.push(`  unicode-range: ${face.unicodeRange};`);
+  return { type: "font-face", css: `@font-face {
+${declarations.join("\n")}
+}` };
+}
+function normalizeLocalStyle(style, family, warnings) {
+  if (style.includes(" ") && !style.startsWith("oblique")) {
+    const first = style.split(/\s+/)[0];
+    warnings.push(
+      `[RI-1203] Local font "${family}" has a compound font-style "${style}" \u2014 a single @font-face takes one style. Split upright and italic into separate @face blocks (or use the italic: shorthand). Using "${first}".`
+    );
+    return first;
   }
-  return {
-    includePatterns,
-    nodeModulesIncludePatterns,
-    excludePatterns,
-    warnings,
-    hasUserPositiveGlobs
-  };
+  return style;
 }
-async function resolveSourceFilesAsync(sources, cwd, hasInlineClasses = false) {
-  const {
-    includePatterns,
-    nodeModulesIncludePatterns,
-    excludePatterns,
-    warnings,
-    hasUserPositiveGlobs
-  } = collectPatterns(sources);
-  const allIncludes = [...includePatterns, ...nodeModulesIncludePatterns];
-  if (allIncludes.length === 0) return { files: [], warnings };
-  try {
-    const globPasses = [];
-    if (includePatterns.length > 0) {
-      globPasses.push(
-        withTimeout(
-          glob(includePatterns, { cwd, ignore: excludePatterns }),
-          GLOB_TIMEOUT_MS,
-          GLOB_TIMEOUT_MESSAGE
-        )
-      );
-    }
-    if (nodeModulesIncludePatterns.length > 0) {
-      const relaxedExcludes = excludePatterns.filter((p) => p !== "node_modules/**");
-      globPasses.push(
-        withTimeout(
-          glob(nodeModulesIncludePatterns, { cwd, ignore: relaxedExcludes }),
-          GLOB_TIMEOUT_MS,
-          GLOB_TIMEOUT_MESSAGE
-        )
-      );
-    }
-    const matched = (await Promise.all(globPasses)).flat();
-    const files = [...new Set(matched.map((f) => resolve3(cwd, f)))].sort(codepointCompare);
-    if (files.length === 0 && !(hasInlineClasses && !hasUserPositiveGlobs)) {
-      warnings.push(
-        `[RI-1401] No source files found matching ${allIncludes.map((p) => `"${p}"`).join(", ")} \u2014 check @source paths or project structure.`
-      );
-    }
-    return { files, warnings };
-  } catch (err) {
+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-1402] Invalid glob pattern \u2014 skipping. Check @source syntax. (${err instanceof Error ? err.message : String(err)})`
+      `[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 { files: [], warnings };
   }
+  return resolved;
 }
-function collectInlineClasses(sources) {
-  const classes = /* @__PURE__ */ new Set();
+function generateFontCSS(slot) {
+  const imports = [];
+  const fontFaces = [];
+  const variables = [];
   const warnings = [];
-  for (const src of sources) {
-    if (!src.inline) continue;
-    const items = src.classes ?? [];
-    let contentLength = 0;
-    for (const cls of items) contentLength += cls.length;
-    if (contentLength > MAX_INLINE_SOURCE_SIZE) {
+  const pushFeatureVars = () => {
+    if (slot.features) variables.push(`--font-${slot.slot}--features: ${slot.features};`);
+    if (slot.variation) variables.push(`--font-${slot.slot}--variations: ${slot.variation};`);
+  };
+  if (slot.kind === "system") {
+    variables.push(`--font-${slot.slot}: ${getFallbackStack(slot.slot)};`);
+    return { imports, fontFaces, variables, warnings };
+  }
+  if (slot.kind === "manual") {
+    const fallback = slot.fallback.length > 0 ? slot.fallback.join(", ") : getFallbackStack(slot.slot);
+    const stack = [`"${escapeFontFamily(slot.family)}"`, fallback].join(", ");
+    variables.push(`--font-${slot.slot}: ${stack};`);
+    pushFeatureVars();
+    return { imports, fontFaces, variables, warnings };
+  }
+  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(
-        `[RI-1406] Inline @source content exceeds ${MAX_INLINE_SOURCE_SIZE} byte limit (${contentLength} bytes) \u2014 skipping.`
+        `[RI-1201] Unknown font provider "${face.provider}" for "${slot.family}" \u2014 supported: google, or a file path/URL.`
       );
       continue;
     }
-    for (const cls of items) {
-      if (cls) classes.add(cls);
-    }
-  }
-  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 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}" (${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
-      };
-    }
-    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,
-      warnings,
-      failure: `[RI-1403] Could not read source file "${file}" \u2014 skipping. (${err instanceof Error ? err.message : String(err)})`
-    };
+    const emitFace = face.provider === "google" ? face : { ...face, style: normalizeLocalStyle(face.style, slot.family, warnings) };
+    const webFont = generateWebFontFace(slot.family, emitFace);
+    if (!webFont) continue;
+    if (webFont.type === "import") imports.push(webFont.css);
+    else fontFaces.push(webFont.css);
   }
+  const fallbackStack = slot.fallback.length > 0 ? slot.fallback.join(", ") : getFallbackStack(slot.slot);
+  const safeFamily = escapeFontFamily(slot.family);
+  const stackParts = [`"${safeFamily}"`];
+  if (metrics) stackParts.push(`"${safeFamily} Fallback"`);
+  stackParts.push(fallbackStack);
+  variables.push(`--font-${slot.slot}: ${stackParts.join(", ")};`);
+  pushFeatureVars();
+  return { imports, fontFaces, variables, warnings };
 }
-async function scanSourceFilesAsync(sources, cwd) {
-  const { classes: allClasses, warnings: inlineWarnings } = collectInlineClasses(sources);
-  const allWarnings = [...inlineWarnings];
-  const { files, warnings: resolveWarnings } = await resolveSourceFilesAsync(
-    sources,
-    cwd,
-    allClasses.size > 0
-  );
-  allWarnings.push(...resolveWarnings);
-  const CONCURRENCY_LIMIT = 32;
-  const results = new Array(files.length);
-  let nextIndex = 0;
-  const worker = async () => {
-    while (nextIndex < files.length) {
-      const index = nextIndex++;
-      results[index] = await scanOneFile(files[index]);
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(CONCURRENCY_LIMIT, files.length) }, worker));
-  const seen = new Set(allWarnings);
-  for (const result of results) {
-    if (result.failure) {
-      allWarnings.push(result.failure);
-      seen.add(result.failure);
-      continue;
-    }
-    if (result.classes) {
-      for (const cls of result.classes) {
-        allClasses.add(cls);
-      }
+function getFontPreloadLinks(slots) {
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const slot of slots) {
+    for (const face of slot.faces) {
+      if (!face.preload) continue;
+      if (face.provider === "system" || face.provider === "google" || !face.provider) continue;
+      if (seen.has(face.provider)) continue;
+      seen.add(face.provider);
+      links.push({
+        href: face.provider,
+        as: "font",
+        type: FONT_FORMAT_MIME[inferFontFormat(face.provider)],
+        crossorigin: true
+      });
     }
-    pushWarningsDeduped(allWarnings, result.warnings, seen);
   }
-  return { classes: allClasses, warnings: allWarnings };
-}
-async function collectProjectClasses(themeSources, surfaceSources, cwd, warnings, warningSeen) {
-  const discovered = discoverPackageSafelistSources(cwd);
-  pushWarningsDeduped(warnings, discovered.warnings, warningSeen);
-  const allSources = [...themeSources, ...surfaceSources, ...discovered.sources];
-  const scanResult = await scanSourceFilesAsync(allSources, cwd);
-  pushWarningsDeduped(warnings, scanResult.warnings, warningSeen);
-  return scanResult.classes;
+  return links;
 }
 
 // src/css/strip.ts
@@ -1431,15 +1494,15 @@ ${m.css}`).join("\n\n");
 function generateTokenLayer(theme, usage, fontOutputCache) {
   const vars = [];
   vars.push(`--spacing: ${theme.spacing.base};`);
-  vars.push(`--fluid-min: ${theme.fluid.min};`);
-  vars.push(`--fluid-max: ${theme.fluid.max};`);
-  if (theme.textFluid) {
-    vars.push(`--fluid-text-min: ${theme.textFluid.min};`);
-    vars.push(`--fluid-text-max: ${theme.textFluid.max};`);
-  }
-  if (theme.spacingFluid) {
-    vars.push(`--fluid-spacing-min: ${theme.spacingFluid.min};`);
-    vars.push(`--fluid-spacing-max: ${theme.spacingFluid.max};`);
+  const pushBounds = (prefix, config) => {
+    if (config?.min !== void 0) vars.push(`${prefix}-min: ${config.min};`);
+    if (config?.max !== void 0) vars.push(`${prefix}-max: ${config.max};`);
+  };
+  pushBounds("--fluid", theme.fluid);
+  pushBounds("--fluid-text", theme.textFluid);
+  pushBounds("--fluid-spacing", theme.spacingFluid);
+  for (const [name, range] of Object.entries(theme.fluidRanges)) {
+    pushBounds(`--fluid-${name}`, range);
   }
   const effectiveStops = new Map(
     [...usage.usedColorStops].map(([k, v]) => [k, new Set(v)])
@@ -1505,15 +1568,6 @@ function generateTokenLayer(theme, usage, fontOutputCache) {
       vars.push(`--font-${slot}: ${stack};`);
     }
   }
-  if (usage.usedRounded.size > 0) {
-    vars.push(`--rounded-roof: ${theme.roundedRoof};`);
-    for (const [name, val] of Object.entries(theme.rounded).sort(
-      ([a], [b]) => codepointCompare(a, b)
-    )) {
-      if (!usage.usedRounded.has(name)) continue;
-      vars.push(`--rounded-${name}: ${val};`);
-    }
-  }
   const shadowsToEmit = resolveTransitiveShadowDeps(theme.shadows, usage.usedShadows);
   for (const [name, val] of Object.entries(theme.shadows).sort(
     ([a], [b]) => codepointCompare(a, b)
@@ -1521,6 +1575,11 @@ function generateTokenLayer(theme, usage, fontOutputCache) {
     if (!shadowsToEmit.has(name)) continue;
     vars.push(`--shadow-${name}: ${val};`);
   }
+  for (const [name, val] of Object.entries(theme.radii).sort(
+    ([a], [b]) => codepointCompare(a, b)
+  )) {
+    vars.push(`--rounded-${name}: ${val};`);
+  }
   for (const [name, def] of Object.entries(theme.animations).sort(
     ([a], [b]) => codepointCompare(a, b)
   )) {
@@ -1720,10 +1779,10 @@ function applyLayerWrapping(parts, layer) {
 }
 
 // src/project/pipeline.ts
-function collectApplyClassNames(css, warnings) {
+function collectApplyClassNames(css, warnings, cssPath) {
   const classes = [];
   for (const match of css.matchAll(APPLY_LIKE_MATCH_RE)) {
-    const params = expandVariantGroups(match[1], warnings);
+    const params = expandVariantGroups(match[1], warnings, cssPath);
     for (const className of params.trim().split(/\s+/)) {
       if (className) classes.push(className);
     }
@@ -1748,13 +1807,20 @@ async function finalizeProjectCompilation(options) {
   }
   const expansionWarnings = [];
   const classNameSet = new Set(options.classNames);
-  for (const cls of collectApplyClassNames(options.css, expansionWarnings)) {
+  const authored = options.authoredClassNames && new Set(options.authoredClassNames);
+  for (const cls of collectApplyClassNames(options.css, expansionWarnings, options.cssPath)) {
     classNameSet.add(cls);
+    authored?.add(cls);
   }
   const classNames = [...classNameSet];
-  pushWarningsDeduped(analysis.warnings, expansionWarnings, analysis.warningSeen);
+  pushWarningsDeduped(
+    analysis.warnings,
+    expansionWarnings,
+    analysis.warningSeen,
+    analysis.suppressed
+  );
   const compiler = createCompiler();
-  const compilation = compiler.compile(classNames, effectiveTheme);
+  const compilation = compiler.compile(classNames, effectiveTheme, authored);
   let userCSS = stripRIDirectives(options.css);
   if ((options.processCssFunctions ?? true) && userCSS && hasCSSFunctions(userCSS)) {
     userCSS = compileCSSFunctions(userCSS, effectiveTheme, analysis.warnings);
@@ -1767,8 +1833,18 @@ async function finalizeProjectCompilation(options) {
     effectiveTheme,
     compiler.fontOutputCache
   );
-  pushWarningsDeduped(analysis.warnings, assemblyWarnings, analysis.warningSeen);
-  pushWarningsDeduped(analysis.warnings, compilation.warnings, analysis.warningSeen);
+  pushWarningsDeduped(
+    analysis.warnings,
+    assemblyWarnings,
+    analysis.warningSeen,
+    analysis.suppressed
+  );
+  pushWarningsDeduped(
+    analysis.warnings,
+    compilation.warnings,
+    analysis.warningSeen,
+    analysis.suppressed
+  );
   let joinedCSS = null;
   return {
     get css() {
@@ -1782,24 +1858,12 @@ async function finalizeProjectCompilation(options) {
     classNames,
     theme: effectiveTheme,
     directives: analysis.directives,
-    warnings: analysis.warnings
+    warnings: analysis.warnings,
+    suppressed: analysis.suppressed
   };
 }
 
 // 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 = analyzeProjectCSSMemo(options.css);
   const resolveFonts = options.resolveFonts ?? resolveGoogleFonts;
@@ -1812,22 +1876,30 @@ async function compileScannedProject(options) {
     if (error) {
       const warning = options.onInvalidPattern(error);
       if (warning !== void 0) {
-        pushWarningsDeduped(analysis.warnings, [warning], analysis.warningSeen);
+        pushWarningsDeduped(
+          analysis.warnings,
+          [warning],
+          analysis.warningSeen,
+          analysis.suppressed
+        );
       }
       continue;
     }
     surfaceSources.push({ pattern, negated: false, inline: false });
   }
-  const classNames = await collectProjectClasses(
+  const { classes: classNames, authored } = await collectProjectClasses(
     analysis.theme.sources,
     surfaceSources,
     options.cwd,
     analysis.warnings,
-    analysis.warningSeen
+    analysis.warningSeen,
+    analysis.suppressed
   );
   const compiled = await finalizeProjectCompilation({
     css: options.css,
+    cssPath: options.cssPath,
     classNames,
+    authoredClassNames: authored,
     analysis,
     resolveFonts: () => fontsReady
   });
@@ -1839,6 +1911,11 @@ export {
   getFontPreloadLinks,
   DEFAULT_PATTERNS,
   DEFAULT_EXCLUDES,
+  enableSourceFileListCache,
+  invalidateSourceFileListCache,
+  enableScanChangeTracking,
+  markSourceFileChanged,
+  disableScanChangeTracking,
   finalizeProjectCompilation,
   compileScannedProject
 };