rainbowindex 0.2.2 → 0.4.0

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

@@ -5,6 +5,7 @@ import {
   RI_IMPORT_SPECIFIER_ALTERNATION,
   SAFE_FONT_FAMILY_RE,
   SHADOW_VAR_REF_RE,
+  analyzeProjectCSS,
   codepointCompare,
   compileCSSFunctions,
   createCompiler,
@@ -18,341 +19,12 @@ import {
   renderCSS,
   scanCSSForTokenUsage,
   withTimeout
-} from "./chunk-W6XIBM4M.mjs";
+} from "./chunk-6DAHUFNU.mjs";
 import {
   checkPaletteContrast,
   generateAllColorVariables,
   generateThemeOverrides
-} from "./chunk-SOMDX7V6.mjs";
-
-// src/scanner/glob-utils.ts
-import { isAbsolute, 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 (isAbsolute(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;
-}
-
-// src/scanner/sources.ts
-import { readFile, stat } from "fs/promises";
-import { resolve as resolve2 } from "path";
-import { glob } from "tinyglobby";
-
-// 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 {
-    mtimeMs = statSync(join(cwdAbs, "package.json")).mtimeMs;
-  } catch {
-    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;
-}
-function runDiscovery(cwdAbs) {
-  let consumer;
-  try {
-    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 {
-      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 });
-    }
-  }
-  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 = join(dir, "node_modules", depName, "package.json");
-    if (existsSync(candidate)) return candidate;
-    const parent = dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-function realpathOrFallback(path) {
-  try {
-    return realpathSync(path);
-  } catch {
-    return path;
-  }
-}
-function errMessage(err) {
-  return err instanceof Error ? err.message : String(err);
-}
-
-// src/scanner/sources.ts
-var DEFAULT_PATTERNS = Object.freeze([
-  "index.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);
-  }
-  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);
-    }
-  }
-  return {
-    includePatterns,
-    nodeModulesIncludePatterns,
-    excludePatterns,
-    warnings,
-    hasUserPositiveGlobs
-  };
-}
-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) => resolve2(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) {
-    warnings.push(
-      `[RI-1402] Invalid glob pattern \u2014 skipping. Check @source syntax. (${err instanceof Error ? err.message : String(err)})`
-    );
-    return { files: [], warnings };
-  }
-}
-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 FILE_IO_TIMEOUT_MS = 1e4;
-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 {
-        classes: null,
-        warnings,
-        failure: `[RI-1405] Skipping source file "${file}" (${fileSize} bytes) \u2014 exceeds ${MAX_FILE_SIZE} byte limit.`
-      };
-    }
-    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
-    };
-  } 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 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);
-      }
-    }
-    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;
-}
+} from "./chunk-5Y7EXXLS.mjs";
 
 // src/integrations/font-providers/google/state.ts
 var googleFontInternals = {
@@ -366,13 +38,13 @@ var googleFontInternals = {
 // 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 { 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 (isAbsolute2(raw) || win32IsAbsolute(raw)) {
+  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".`
     );
@@ -392,7 +64,7 @@ function getResolvedCachePath() {
   if (googleFontInternals.resolvedCachePath !== null && googleFontInternals.validatedCacheDir !== null) {
     return googleFontInternals.resolvedCachePath;
   }
-  googleFontInternals.resolvedCachePath = resolve3(process.cwd(), getFontCacheFile());
+  googleFontInternals.resolvedCachePath = resolve(process.cwd(), getFontCacheFile());
   return googleFontInternals.resolvedCachePath;
 }
 function getFontCacheTTL() {
@@ -475,12 +147,12 @@ async function loadFontCache(ignoreExpiry = false) {
 async function saveFontCache() {
   try {
     const cachePath = getResolvedCachePath();
-    await mkdir(dirname2(cachePath), { recursive: true });
+    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 = join2(dirname2(cachePath), `.google-${process.pid}-${randomUUID()}.tmp`);
+    const tmpPath = join(dirname(cachePath), `.google-${process.pid}-${randomUUID()}.tmp`);
     try {
       await writeFile(tmpPath, payload);
       await rename(tmpPath, cachePath);
@@ -753,102 +425,431 @@ 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 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")}
-}` };
+  const safeProvider = face.provider.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  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 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 stack = [`"${escapeFontFamily(slot.family)}"`, ...slot.fallback].join(", ");
+    variables.push(`--font-${slot.slot}: ${stack};`);
+    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
+      })
+    );
+  }
+  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 (hasMetrics) stackParts.push(`"${safeFamily} Fallback"`);
+  stackParts.push(fallbackStack);
+  variables.push(`--font-${slot.slot}: ${stackParts.join(", ")};`);
+  pushFeatureVars();
+  return { imports, fontFaces, variables, warnings };
+}
+function getFontPreloadLinks(slots) {
+  const links = [];
+  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.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;
+}
+
+// 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;
+}
+
+// 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;
+  }
+  const cached = discoveryCache.get(cwdAbs);
+  if (cached && cached.mtimeMs === mtimeMs) return cached.result;
+  const result = runDiscovery(cwdAbs);
+  discoveryCache.set(cwdAbs, { mtimeMs, result });
+  return result;
+}
+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 });
+    }
+  }
+  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;
+  }
+}
+function realpathOrFallback(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function errMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+// src/scanner/sources.ts
+var DEFAULT_PATTERNS = Object.freeze([
+  "index.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);
+  }
+  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);
+    }
+  }
+  return {
+    includePatterns,
+    nodeModulesIncludePatterns,
+    excludePatterns,
+    warnings,
+    hasUserPositiveGlobs
+  };
 }
-function normalizeLocalStyle(style, family, warnings) {
-  if (style.includes(" ") && !style.startsWith("oblique")) {
-    const first = style.split(/\s+/)[0];
+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) {
     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}".`
+      `[RI-1402] Invalid glob pattern \u2014 skipping. Check @source syntax. (${err instanceof Error ? err.message : String(err)})`
     );
-    return first;
+    return { files: [], warnings };
   }
-  return style;
 }
-function generateFontCSS(slot) {
-  const imports = [];
-  const fontFaces = [];
-  const variables = [];
+function collectInlineClasses(sources) {
+  const classes = /* @__PURE__ */ new Set();
   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 stack = [`"${escapeFontFamily(slot.family)}"`, ...slot.fallback].join(", ");
-    variables.push(`--font-${slot.slot}: ${stack};`);
-    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
-      })
-    );
-  }
-  for (const face of slot.faces) {
-    if (face.provider !== "google" && !face.provider.startsWith("/") && !face.provider.startsWith("http") && !face.provider.startsWith(".")) {
+  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-1201] Unknown font provider "${face.provider}" for "${slot.family}" \u2014 supported: google, or a file path/URL.`
+        `[RI-1406] Inline @source content exceeds ${MAX_INLINE_SOURCE_SIZE} byte limit (${contentLength} bytes) \u2014 skipping.`
       );
       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);
+    for (const cls of items) {
+      if (cls) classes.add(cls);
+    }
   }
-  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"`);
-  stackParts.push(fallbackStack);
-  variables.push(`--font-${slot.slot}: ${stackParts.join(", ")};`);
-  pushFeatureVars();
-  return { imports, fontFaces, variables, warnings };
+  return { classes, warnings };
 }
-function getFontPreloadLinks(slots) {
-  const links = [];
-  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.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
-      });
+var FILE_IO_TIMEOUT_MS = 1e4;
+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 {
+        classes: null,
+        warnings,
+        failure: `[RI-1405] Skipping source file "${file}" (${fileSize} bytes) \u2014 exceeds ${MAX_FILE_SIZE} byte limit.`
+      };
     }
+    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
+    };
+  } catch (err) {
+    return {
+      classes: null,
+      warnings,
+      failure: `[RI-1403] Could not read source file "${file}" \u2014 skipping. (${err instanceof Error ? err.message : String(err)})`
+    };
   }
-  return links;
+}
+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);
+      }
+    }
+    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;
 }
 
 // src/css/strip.ts
@@ -1459,7 +1460,7 @@ function collectPropertyBlocks(registered, engineProperties) {
   return blocks;
 }
 function assembleSections(compilation, theme, fontOutputCache) {
-  const sections = [];
+  const baseSections = [];
   const fontImports = [];
   const fontFaceBlocks = [];
   const assemblyWarnings = [];
@@ -1480,18 +1481,16 @@ function assembleSections(compilation, theme, fontOutputCache) {
       }
     }
   }
-  if (fontImports.length > 0) {
-    sections.push(fontImports.join("\n"));
-  }
+  const importsSection = fontImports.length > 0 ? fontImports.join("\n") : null;
   const propertyBlocks = collectPropertyBlocks(theme.registeredProperties, compilation.properties);
   if (propertyBlocks.length > 0) {
-    sections.push(propertyBlocks.join("\n\n"));
+    baseSections.push(propertyBlocks.join("\n\n"));
   }
   if (fontFaceBlocks.length > 0) {
-    sections.push(fontFaceBlocks.join("\n\n"));
+    baseSections.push(fontFaceBlocks.join("\n\n"));
   }
   const tokenLayer = generateTokenLayer(theme, compilation, fontOutputCache);
-  if (tokenLayer) sections.push(tokenLayer);
+  if (tokenLayer) baseSections.push(tokenLayer);
   for (const w of checkPaletteContrast(theme.colors, compilation.usedColorStops)) {
     assemblyWarnings.push(w);
   }
@@ -1500,25 +1499,32 @@ function assembleSections(compilation, theme, fontOutputCache) {
     compilation.usedColorStops.get("theme")
   );
   if (themeOverrides.length > 0) {
-    sections.push(themeOverrides.join("\n\n"));
+    baseSections.push(themeOverrides.join("\n\n"));
   }
   const cornerShape = generateCornerShapeBlock(theme);
-  if (cornerShape) sections.push(cornerShape);
+  if (cornerShape) baseSections.push(cornerShape);
   if (compilation.keyframes.length > 0) {
-    sections.push(compilation.keyframes.join("\n\n"));
+    baseSections.push(compilation.keyframes.join("\n\n"));
   }
   const preflight = generatePreflight(theme.preflight);
-  if (preflight) sections.push(preflight);
+  if (preflight) baseSections.push(preflight);
   const utilityCSS = renderCSS({
     ...compilation,
     properties: [],
     keyframes: []
   });
-  if (utilityCSS) sections.push(utilityCSS);
-  if (theme.layer) {
-    applyLayerWrapping(sections, fontImports, theme.layer, utilityCSS !== "");
-  }
-  return { sections, fontImports, warnings: assemblyWarnings };
+  const utilitiesSection = utilityCSS !== "" ? utilityCSS : null;
+  const parts = {
+    imports: importsSection,
+    base: baseSections,
+    utilities: utilitiesSection
+  };
+  const sections = theme.layer ? applyLayerWrapping(parts, theme.layer) : [
+    ...importsSection !== null ? [importsSection] : [],
+    ...baseSections,
+    ...utilitiesSection !== null ? [utilitiesSection] : []
+  ];
+  return { sections, warnings: assemblyWarnings };
 }
 function wrapInLayer(content, layerName) {
   const indented = content.replace(/^(?=.)/gm, "  ");
@@ -1526,42 +1532,36 @@ function wrapInLayer(content, layerName) {
 ${indented}
 }`;
 }
-function applyLayerWrapping(sections, fontImports, layer, hasUtilitySection) {
-  const hasImportSection = fontImports.length > 0 && sections.length > 0;
-  const importSection = hasImportSection ? sections[0] : null;
-  const contentSections = hasImportSection ? sections.slice(1) : [...sections];
+function applyLayerWrapping(parts, layer) {
+  const sections = [];
+  if (parts.imports !== null) sections.push(parts.imports);
   if (layer.wrapAll) {
-    const joined = contentSections.join("\n\n");
-    sections.length = 0;
-    if (importSection) sections.push(importSection);
     sections.push(`@layer ${layer.wrapAll};`);
+    const joined = [...parts.base, ...parts.utilities !== null ? [parts.utilities] : []].join(
+      "\n\n"
+    );
     if (joined) sections.push(wrapInLayer(joined, layer.wrapAll));
-    return;
+    return sections;
   }
-  const utilitySection = hasUtilitySection ? contentSections.pop() ?? null : null;
-  const baseSections = contentSections;
-  const finalSections = [];
-  if (importSection) finalSections.push(importSection);
   if (layer.order && layer.order.length > 0) {
-    finalSections.push(`@layer ${layer.order.join(", ")};`);
+    sections.push(`@layer ${layer.order.join(", ")};`);
   }
-  if (baseSections.length > 0) {
-    const baseJoined = baseSections.join("\n\n");
+  if (parts.base.length > 0) {
+    const baseJoined = parts.base.join("\n\n");
     if (layer.base) {
-      finalSections.push(wrapInLayer(baseJoined, layer.base));
+      sections.push(wrapInLayer(baseJoined, layer.base));
     } else {
-      finalSections.push(baseJoined);
+      sections.push(baseJoined);
     }
   }
-  if (utilitySection) {
+  if (parts.utilities !== null) {
     if (layer.utilities) {
-      finalSections.push(wrapInLayer(utilitySection, layer.utilities));
+      sections.push(wrapInLayer(parts.utilities, layer.utilities));
     } else {
-      finalSections.push(utilitySection);
+      sections.push(parts.utilities);
     }
   }
-  sections.length = 0;
-  sections.push(...finalSections);
+  return sections;
 }
 
 // src/project/pipeline.ts
@@ -1624,12 +1624,46 @@ async function finalizeProjectCompilation(options) {
   };
 }
 
+// src/project/scan.ts
+async function compileScannedProject(options) {
+  const analysis = analyzeProjectCSS(options.css);
+  const resolveFonts = options.resolveFonts ?? resolveGoogleFonts;
+  const fontsReady = Promise.resolve(resolveFonts(analysis.theme.fonts));
+  fontsReady.catch(() => {
+  });
+  const surfaceSources = [];
+  for (const pattern of options.surfacePatterns ?? []) {
+    const error = validateGlobPattern(pattern);
+    if (error) {
+      const warning = options.onInvalidPattern(error);
+      if (warning !== void 0) {
+        pushWarningsDeduped(analysis.warnings, [warning], analysis.warningSeen);
+      }
+      continue;
+    }
+    surfaceSources.push({ pattern, negated: false, inline: false });
+  }
+  const classNames = await collectProjectClasses(
+    analysis.theme.sources,
+    surfaceSources,
+    options.cwd,
+    analysis.warnings,
+    analysis.warningSeen
+  );
+  const compiled = await finalizeProjectCompilation({
+    css: options.css,
+    classNames,
+    analysis,
+    resolveFonts: () => fontsReady
+  });
+  return { compiled, warningSeen: analysis.warningSeen };
+}
+
 export {
-  validateGlobPattern,
-  DEFAULT_PATTERNS,
-  DEFAULT_EXCLUDES,
-  collectProjectClasses,
   resolveGoogleFonts,
   getFontPreloadLinks,
-  finalizeProjectCompilation
+  DEFAULT_PATTERNS,
+  DEFAULT_EXCLUDES,
+  finalizeProjectCompilation,
+  compileScannedProject
 };