rainbowindex 0.2.1 → 0.2.2

package/dist/chunk-FHATRQMN.mjs

@@ -0,0 +1,1635 @@
+import {
+  APPLY_LIKE_MATCH_RE,
+  COLOR_STOP_REF_RE,
+  EXTRACTABLE_DIRECTIVE_NAMES,
+  RI_IMPORT_SPECIFIER_ALTERNATION,
+  SAFE_FONT_FAMILY_RE,
+  SHADOW_VAR_REF_RE,
+  codepointCompare,
+  compileCSSFunctions,
+  createCompiler,
+  directiveAtRulePattern,
+  expandVariantGroups,
+  extractClassesFromSource,
+  hasCSSFunctions,
+  isAtRuleBoundary,
+  isRIDebug,
+  pushWarningsDeduped,
+  renderCSS,
+  scanCSSForTokenUsage,
+  withTimeout
+} from "./chunk-W6XIBM4M.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;
+}
+
+// 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;
+}
+function refreshFontWeightDefaults(fonts) {
+  return 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;
+    });
+    return changed ? { ...slot, faces } : slot;
+  });
+}
+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/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";
+  const subset = face.subset && face.subset !== "latin" ? `&subset=${encodeURIComponent(face.subset)}` : "";
+  return `https://fonts.googleapis.com/css2?family=${encodedFamily}:${axisParam}&display=${display}${subset}`;
+}
+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("${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 = 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/css/strip.ts
+var DIRECTIVE_AT_RULE_PATTERNS = [...EXTRACTABLE_DIRECTIVE_NAMES].map(directiveAtRulePattern);
+function buildProtectedRanges(css) {
+  const ranges = [];
+  let i = 0;
+  while (i < css.length) {
+    if (css[i] === "/" && css[i + 1] === "*") {
+      const start = i;
+      const end = css.indexOf("*/", i + 2);
+      i = end === -1 ? css.length : end + 2;
+      ranges.push([start, i]);
+      continue;
+    }
+    if (css[i] === '"' || css[i] === "'") {
+      const quote = css[i];
+      const start = i;
+      i++;
+      while (i < css.length && css[i] !== quote) {
+        if (css[i] === "\\" && i + 1 < css.length) i++;
+        i++;
+      }
+      if (i < css.length) i++;
+      ranges.push([start, i]);
+    } else {
+      i++;
+    }
+  }
+  return ranges;
+}
+function isInsideProtectedRange(pos, ranges) {
+  let lo = 0;
+  let hi = ranges.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >>> 1;
+    const [start, end] = ranges[mid];
+    if (pos < start) hi = mid - 1;
+    else if (pos >= end) lo = mid + 1;
+    else return true;
+  }
+  return false;
+}
+function replaceOutsideProtectedRanges(css, re, ranges) {
+  re.lastIndex = 0;
+  const parts = [];
+  let lastIdx = 0;
+  for (; ; ) {
+    const match = re.exec(css);
+    if (match === null) break;
+    if (isInsideProtectedRange(match.index, ranges) || !isAtRuleBoundary(css, match.index)) {
+      continue;
+    }
+    let end = match.index + match[0].length;
+    if (isInsideProtectedRange(end - 1, ranges)) {
+      let k = end;
+      let aborted = false;
+      while (k < css.length) {
+        if (!isInsideProtectedRange(k, ranges)) {
+          const ch = css[k];
+          if (ch === ";") break;
+          if (ch === "{" || ch === "}") {
+            aborted = true;
+            break;
+          }
+        }
+        k++;
+      }
+      if (aborted) continue;
+      end = k < css.length ? k + 1 : css.length;
+      re.lastIndex = end;
+    }
+    parts.push(css.slice(lastIdx, match.index));
+    lastIdx = end;
+  }
+  parts.push(css.slice(lastIdx));
+  return parts.join("");
+}
+function stripBalancedBlocks(css, re, protectedRanges) {
+  re.lastIndex = 0;
+  const ranges = [];
+  for (; ; ) {
+    const match = re.exec(css);
+    if (match === null) break;
+    const start = match.index;
+    if (isInsideProtectedRange(start, protectedRanges)) {
+      continue;
+    }
+    if (!isAtRuleBoundary(css, start)) {
+      continue;
+    }
+    let braceIdx = css.indexOf("{", start);
+    while (braceIdx !== -1 && isInsideProtectedRange(braceIdx, protectedRanges)) {
+      braceIdx = css.indexOf("{", braceIdx + 1);
+    }
+    const preludeEnd = braceIdx === -1 ? css.length : braceIdx;
+    let semiIdx = -1;
+    for (let k = start; k < preludeEnd; k++) {
+      if (css[k] === ";" && !isInsideProtectedRange(k, protectedRanges)) {
+        semiIdx = k;
+        break;
+      }
+    }
+    if (semiIdx !== -1) {
+      ranges.push([start, semiIdx + 1]);
+      re.lastIndex = semiIdx + 1;
+      continue;
+    }
+    if (braceIdx === -1) {
+      ranges.push([start, css.length]);
+      break;
+    }
+    let depth = 1;
+    let j = braceIdx + 1;
+    while (j < css.length && depth > 0) {
+      const ch = css[j];
+      if (ch === '"' || ch === "'") {
+        const quote = ch;
+        j++;
+        while (j < css.length && css[j] !== quote) {
+          if (css[j] === "\\" && j + 1 < css.length) j++;
+          j++;
+        }
+        j++;
+        continue;
+      }
+      if (ch === "/" && css[j + 1] === "*") {
+        const end = css.indexOf("*/", j + 2);
+        j = end === -1 ? css.length : end + 2;
+        continue;
+      }
+      if (ch === "{") depth++;
+      else if (ch === "}") depth--;
+      j++;
+    }
+    ranges.push([start, j]);
+    re.lastIndex = j;
+  }
+  if (ranges.length === 0) return css;
+  const parts = [];
+  let lastEnd = 0;
+  for (const [start, end] of ranges) {
+    parts.push(css.slice(lastEnd, start));
+    lastEnd = end;
+  }
+  parts.push(css.slice(lastEnd));
+  return parts.join("");
+}
+var ALL_SEMI_DIRECTIVES_RE = new RegExp(
+  DIRECTIVE_AT_RULE_PATTERNS.map((p) => `${p}[^{;]*;`).join("|"),
+  "g"
+);
+var ALL_BRACE_DIRECTIVES_RE = new RegExp(
+  DIRECTIVE_AT_RULE_PATTERNS.map((p) => `${p}[^{]*{`).join("|"),
+  "g"
+);
+var RI_IMPORT_RE = new RegExp(
+  `@import\\s+(?:url\\(\\s*)?["'](?:${RI_IMPORT_SPECIFIER_ALTERNATION})["']\\s*\\)?[^;]*;`,
+  "g"
+);
+function stripRIDirectives(css) {
+  let currentRanges = buildProtectedRanges(css);
+  let result = replaceOutsideProtectedRanges(css, RI_IMPORT_RE, currentRanges);
+  if (result !== css) {
+    currentRanges = buildProtectedRanges(result);
+  }
+  const beforePhase1 = result;
+  result = replaceOutsideProtectedRanges(result, ALL_SEMI_DIRECTIVES_RE, currentRanges);
+  const dirty = result !== beforePhase1;
+  if (dirty) {
+    currentRanges = buildProtectedRanges(result);
+  }
+  result = stripBalancedBlocks(result, ALL_BRACE_DIRECTIVES_RE, currentRanges);
+  return result.trim();
+}
+
+// src/css/preflight.ts
+var DEFAULT_PREFLIGHT = {
+  core: true,
+  typography: true,
+  content: true,
+  forms: true,
+  interactive: true,
+  modern: true
+};
+var modules = [
+  // ── Core ─────────────────────────────────────────────────
+  {
+    name: "box-sizing",
+    category: "core",
+    css: `*, *::before, *::after {
+  box-sizing: border-box;
+}`
+  },
+  {
+    name: "margins",
+    category: "core",
+    css: `body, h1, h2, h3, h4, h5, h6, p, figure, blockquote, dl, dd, pre {
+  margin: 0;
+}`
+  },
+  {
+    name: "borders",
+    category: "core",
+    css: `*, *::before, *::after {
+  border-width: 0;
+  border-style: solid;
+  border-color: inherit;
+}`
+  },
+  {
+    name: "root-defaults",
+    category: "core",
+    css: `:root {
+  --sans-fallback: ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  --serif-fallback: ui-serif, Georgia, Cambria, "Times New Roman", Times, serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  --mono-fallback: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+  line-height: 1.5;
+  -webkit-text-size-adjust: 100%;
+  tab-size: 4;
+}
+body {
+  line-height: inherit;
+  font-family: var(--font-sans);
+}
+code, kbd, samp, pre {
+  font-family: var(--font-mono);
+  font-size: 1em;
+}`
+  },
+  // ── Typography ───────────────────────────────────────────
+  {
+    name: "font-smoothing",
+    category: "typography",
+    css: `body {
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}`
+  },
+  {
+    name: "font-inherit",
+    category: "typography",
+    css: `button, input, optgroup, select, textarea {
+  font-family: inherit;
+  font-feature-settings: inherit;
+  font-variation-settings: inherit;
+  font-size: 100%;
+  font-weight: inherit;
+  line-height: inherit;
+  letter-spacing: inherit;
+  color: inherit;
+}`
+  },
+  {
+    name: "heading-sizes",
+    category: "typography",
+    css: `h1, h2, h3, h4, h5, h6 {
+  font-size: inherit;
+  font-weight: inherit;
+}`
+  },
+  {
+    name: "link-reset",
+    category: "typography",
+    css: `a {
+  color: inherit;
+  text-decoration: inherit;
+}`
+  },
+  // ── Content ──────────────────────────────────────────────
+  {
+    name: "media-block",
+    category: "content",
+    css: `img, svg, video, canvas, audio, iframe, embed, object {
+  display: block;
+  max-inline-size: 100%;
+}
+img, video {
+  block-size: auto;
+}`
+  },
+  {
+    name: "list-reset",
+    category: "content",
+    css: `ol, ul, menu {
+  list-style: none;
+  padding: 0;
+}`
+  },
+  {
+    name: "table-reset",
+    category: "content",
+    css: `table {
+  text-indent: 0;
+  border-color: inherit;
+  border-collapse: collapse;
+}`
+  },
+  {
+    name: "hr-reset",
+    category: "content",
+    css: `hr {
+  block-size: 0;
+  border-top-width: 1px;
+  color: inherit;
+}`
+  },
+  // ── Forms ────────────────────────────────────────────────
+  {
+    name: "button-reset",
+    category: "forms",
+    css: `button, [role="button"] {
+  cursor: pointer;
+  padding: 0;
+}
+button {
+  background-color: transparent;
+  background-image: none;
+}`
+  },
+  {
+    name: "input-reset",
+    category: "forms",
+    css: `input::placeholder, textarea::placeholder {
+  opacity: 1;
+  color: oklch(0.556 0 0);
+}
+input:where([type="button"], [type="reset"], [type="submit"]) {
+  -webkit-appearance: button;
+  appearance: button;
+}`
+  },
+  {
+    name: "textarea-reset",
+    category: "forms",
+    css: `textarea {
+  resize: vertical;
+}`
+  },
+  {
+    name: "select-reset",
+    category: "forms",
+    css: `select {
+  -webkit-appearance: none;
+  appearance: none;
+  background-image: url("data:image/svg+xml,%3csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16' fill='currentColor'%3e%3cpath fill-rule='evenodd' d='M4.22 6.22a.75.75 0 0 1 1.06 0L8 8.94l2.72-2.72a.75.75 0 1 1 1.06 1.06l-3.25 3.25a.75.75 0 0 1-1.06 0L4.22 7.28a.75.75 0 0 1 0-1.06z' clip-rule='evenodd'/%3e%3c/svg%3e");
+  background-position: right 0.5rem center;
+  background-repeat: no-repeat;
+  background-size: 1.5em 1.5em;
+  padding-inline-end: 2.5rem;
+}`
+  },
+  // ── Interactive ──────────────────────────────────────────
+  {
+    name: "focus-visible",
+    category: "interactive",
+    css: `:focus-visible {
+  outline-width: var(--spacing);
+  outline-style: solid;
+  outline-offset: calc(var(--spacing) * 0.5);
+  outline-color: currentColor;
+}
+:focus:not(:focus-visible) {
+  outline: none;
+}`
+  },
+  {
+    name: "dialog-reset",
+    category: "interactive",
+    css: `dialog {
+  padding: 0;
+}
+dialog::backdrop {
+  background-color: oklch(0 0 0 / 0.5);
+}`
+  },
+  {
+    name: "summary-reset",
+    category: "interactive",
+    css: `summary {
+  display: list-item;
+  cursor: pointer;
+}`
+  },
+  // ── Modern ───────────────────────────────────────────────
+  {
+    name: "interpolate-size",
+    category: "modern",
+    css: `@supports (interpolate-size: allow-keywords) {
+  :root {
+    interpolate-size: allow-keywords;
+  }
+}`
+  },
+  {
+    name: "overflow-wrap",
+    category: "modern",
+    css: `body {
+  overflow-wrap: break-word;
+}`
+  },
+  {
+    name: "color-scheme",
+    category: "modern",
+    css: `html {
+  color-scheme: light dark;
+}
+html[data-appearance="dark"] {
+  color-scheme: dark;
+}
+html[data-appearance="light"] {
+  color-scheme: light;
+}`
+  }
+];
+function generatePreflight(config = DEFAULT_PREFLIGHT) {
+  const enabledModules = modules.filter((m) => config[m.category]);
+  if (enabledModules.length === 0) return "";
+  return enabledModules.map((m) => `/* preflight: ${m.name} */
+${m.css}`).join("\n\n");
+}
+
+// src/assembly.ts
+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 effectiveStops = new Map(
+    [...usage.usedColorStops].map(([k, v]) => [k, new Set(v)])
+  );
+  const themeDef = theme.colors.theme;
+  const themeSuffixes = effectiveStops.get("theme");
+  if (themeDef && themeSuffixes && themeDef.type === "alias") {
+    let sourceSuffixes = effectiveStops.get(themeDef.source);
+    if (!sourceSuffixes) {
+      sourceSuffixes = /* @__PURE__ */ new Set();
+      effectiveStops.set(themeDef.source, sourceSuffixes);
+    }
+    for (const s of themeSuffixes) sourceSuffixes.add(s);
+  }
+  if (themeDef && themeSuffixes) {
+    for (const [name, def] of Object.entries(theme.colors)) {
+      if (name === "theme" || def.type !== "generative" || !def.inline) continue;
+      let stops = effectiveStops.get(name);
+      if (!stops) {
+        stops = /* @__PURE__ */ new Set();
+        effectiveStops.set(name, stops);
+      }
+      for (const s of themeSuffixes) stops.add(s);
+    }
+  }
+  for (const def of Object.values(theme.colors)) {
+    const values = def.type === "explicit" ? [def.value] : def.type === "pair" ? [def.light, def.dark] : null;
+    if (!values) continue;
+    for (const v of values) {
+      for (const m of v.matchAll(COLOR_STOP_REF_RE)) {
+        if (!m[2]) continue;
+        const hue = m[1];
+        const stop = Number(m[2]);
+        let set = effectiveStops.get(hue);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          effectiveStops.set(hue, set);
+        }
+        set.add(stop);
+      }
+    }
+  }
+  const colorVars = generateAllColorVariables(theme.colors, theme.darkConfig, effectiveStops);
+  vars.push(...colorVars);
+  for (const [name, size] of Object.entries(theme.text).sort(
+    ([a], [b]) => codepointCompare(a, b)
+  )) {
+    if (!usage.usedTextSizes.has(name)) continue;
+    vars.push(`--text-${name}: ${size.fontSize};`);
+    vars.push(`--text-${name}-leading: ${size.lineHeight};`);
+  }
+  const configuredSlots = /* @__PURE__ */ new Set();
+  for (const fontConfig of theme.fonts) {
+    if (!usage.usedFonts.has(fontConfig.slot)) continue;
+    const output = getCachedFontOutput(fontConfig, fontOutputCache);
+    vars.push(...output.variables);
+    configuredSlots.add(fontConfig.slot);
+  }
+  for (const [slot, stack] of Object.entries(SYSTEM_STACKS).sort(
+    ([a], [b]) => codepointCompare(a, b)
+  )) {
+    if (!configuredSlots.has(slot) && usage.usedFonts.has(slot)) {
+      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)
+  )) {
+    if (!shadowsToEmit.has(name)) continue;
+    vars.push(`--shadow-${name}: ${val};`);
+  }
+  for (const [name, def] of Object.entries(theme.animations).sort(
+    ([a], [b]) => codepointCompare(a, b)
+  )) {
+    if (!usage.usedAnimations.has(name)) continue;
+    vars.push(`--animate-${name}: ${def.shorthand};`);
+  }
+  return `:root {
+  ${vars.join("\n  ")}
+}`;
+}
+function resolveTransitiveShadowDeps(shadows, seeds) {
+  const out = /* @__PURE__ */ new Set();
+  const worklist = [];
+  for (const name of seeds) {
+    if (Object.hasOwn(shadows, name)) {
+      out.add(name);
+      worklist.push(name);
+    }
+  }
+  while (worklist.length > 0) {
+    const name = worklist.pop();
+    const value = shadows[name];
+    if (!value?.includes("var(--shadow-")) continue;
+    for (const m of value.matchAll(SHADOW_VAR_REF_RE)) {
+      const dep = m[1];
+      if (!out.has(dep) && Object.hasOwn(shadows, dep)) {
+        out.add(dep);
+        worklist.push(dep);
+      }
+    }
+  }
+  return out;
+}
+function cornerShapeValue(shape) {
+  return typeof shape === "string" ? shape : `superellipse(${shape.superellipse})`;
+}
+function generateCornerShapeBlock(theme) {
+  if (theme.roundedShape === null) return null;
+  const value = cornerShapeValue(theme.roundedShape);
+  const shapeRule = `:root {
+  corner-shape: ${value};
+}
+*, ::before, ::after {
+  corner-shape: inherit;
+}`;
+  if (theme.roundedShapeScale === 1) return shapeRule;
+  const scaleBlock = `@supports (corner-shape: ${value}) {
+  :root {
+    --ri-rounded-scale: ${theme.roundedShapeScale};
+  }
+}`;
+  return `${shapeRule}
+
+${scaleBlock}`;
+}
+function fontCacheKey(config) {
+  return JSON.stringify(config);
+}
+function getCachedFontOutput(config, cache) {
+  const key = fontCacheKey(config);
+  let cached = cache.get(key);
+  if (!cached) {
+    cached = generateFontCSS(config);
+    cache.set(key, cached);
+  }
+  return cached;
+}
+function renderRegisteredProperty(reg) {
+  const lines = [
+    `@property ${reg.name} {`,
+    `  syntax: ${reg.syntax};`,
+    `  inherits: ${reg.inherits};`
+  ];
+  if (reg.initialValue !== void 0) lines.push(`  initial-value: ${reg.initialValue};`);
+  lines.push("}");
+  return lines.join("\n");
+}
+var PROPERTY_NAME_RE = /@property\s+(--[A-Za-z0-9_-]+)/;
+function collectPropertyBlocks(registered, engineProperties) {
+  const blocks = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (block) => {
+    const name = PROPERTY_NAME_RE.exec(block)?.[1];
+    if (name) {
+      if (seen.has(name)) return;
+      seen.add(name);
+    }
+    blocks.push(block);
+  };
+  for (const reg of registered) push(renderRegisteredProperty(reg));
+  for (const block of engineProperties) push(block);
+  return blocks;
+}
+function assembleSections(compilation, theme, fontOutputCache) {
+  const sections = [];
+  const fontImports = [];
+  const fontFaceBlocks = [];
+  const assemblyWarnings = [];
+  const fontWarningsEmitted = /* @__PURE__ */ new Set();
+  if (theme.preflight.core !== false) {
+    compilation.usedFonts.add("sans");
+    compilation.usedFonts.add("mono");
+  }
+  for (const fontConfig of theme.fonts) {
+    if (!compilation.usedFonts.has(fontConfig.slot)) continue;
+    const output = getCachedFontOutput(fontConfig, fontOutputCache);
+    fontImports.push(...output.imports);
+    fontFaceBlocks.push(...output.fontFaces);
+    for (const w of output.warnings) {
+      if (!fontWarningsEmitted.has(w)) {
+        assemblyWarnings.push(w);
+        fontWarningsEmitted.add(w);
+      }
+    }
+  }
+  if (fontImports.length > 0) {
+    sections.push(fontImports.join("\n"));
+  }
+  const propertyBlocks = collectPropertyBlocks(theme.registeredProperties, compilation.properties);
+  if (propertyBlocks.length > 0) {
+    sections.push(propertyBlocks.join("\n\n"));
+  }
+  if (fontFaceBlocks.length > 0) {
+    sections.push(fontFaceBlocks.join("\n\n"));
+  }
+  const tokenLayer = generateTokenLayer(theme, compilation, fontOutputCache);
+  if (tokenLayer) sections.push(tokenLayer);
+  for (const w of checkPaletteContrast(theme.colors, compilation.usedColorStops)) {
+    assemblyWarnings.push(w);
+  }
+  const themeOverrides = generateThemeOverrides(
+    theme.colors,
+    compilation.usedColorStops.get("theme")
+  );
+  if (themeOverrides.length > 0) {
+    sections.push(themeOverrides.join("\n\n"));
+  }
+  const cornerShape = generateCornerShapeBlock(theme);
+  if (cornerShape) sections.push(cornerShape);
+  if (compilation.keyframes.length > 0) {
+    sections.push(compilation.keyframes.join("\n\n"));
+  }
+  const preflight = generatePreflight(theme.preflight);
+  if (preflight) sections.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 };
+}
+function wrapInLayer(content, layerName) {
+  const indented = content.replace(/^(?=.)/gm, "  ");
+  return `@layer ${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];
+  if (layer.wrapAll) {
+    const joined = contentSections.join("\n\n");
+    sections.length = 0;
+    if (importSection) sections.push(importSection);
+    sections.push(`@layer ${layer.wrapAll};`);
+    if (joined) sections.push(wrapInLayer(joined, layer.wrapAll));
+    return;
+  }
+  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(", ")};`);
+  }
+  if (baseSections.length > 0) {
+    const baseJoined = baseSections.join("\n\n");
+    if (layer.base) {
+      finalSections.push(wrapInLayer(baseJoined, layer.base));
+    } else {
+      finalSections.push(baseJoined);
+    }
+  }
+  if (utilitySection) {
+    if (layer.utilities) {
+      finalSections.push(wrapInLayer(utilitySection, layer.utilities));
+    } else {
+      finalSections.push(utilitySection);
+    }
+  }
+  sections.length = 0;
+  sections.push(...finalSections);
+}
+
+// src/project/pipeline.ts
+function collectApplyClassNames(css, warnings) {
+  const classes = [];
+  for (const match of css.matchAll(APPLY_LIKE_MATCH_RE)) {
+    const params = expandVariantGroups(match[1], warnings);
+    for (const className of params.trim().split(/\s+/)) {
+      if (className) classes.push(className);
+    }
+  }
+  return classes;
+}
+async function finalizeProjectCompilation(options) {
+  const { analysis } = options;
+  let effectiveTheme = analysis.theme;
+  if (options.resolveFonts) {
+    const resolvedFonts = await options.resolveFonts(analysis.theme.fonts);
+    if (resolvedFonts !== analysis.theme.fonts) {
+      effectiveTheme = { ...analysis.theme, fonts: [...resolvedFonts] };
+    }
+  }
+  const expansionWarnings = [];
+  const classNameSet = new Set(options.classNames);
+  for (const cls of collectApplyClassNames(options.css, expansionWarnings)) {
+    classNameSet.add(cls);
+  }
+  const classNames = [...classNameSet];
+  pushWarningsDeduped(analysis.warnings, expansionWarnings, analysis.warningSeen);
+  const compiler = createCompiler();
+  const compilation = compiler.compile(classNames, effectiveTheme);
+  let userCSS = stripRIDirectives(options.css);
+  if ((options.processCssFunctions ?? true) && userCSS && hasCSSFunctions(userCSS)) {
+    userCSS = compileCSSFunctions(userCSS, effectiveTheme, analysis.warnings);
+  }
+  if (userCSS) {
+    scanCSSForTokenUsage(userCSS, compilation);
+  }
+  const { sections, warnings: assemblyWarnings } = assembleSections(
+    compilation,
+    effectiveTheme,
+    compiler.fontOutputCache
+  );
+  pushWarningsDeduped(analysis.warnings, assemblyWarnings, analysis.warningSeen);
+  pushWarningsDeduped(analysis.warnings, compilation.warnings, analysis.warningSeen);
+  let joinedCSS = null;
+  return {
+    get css() {
+      if (joinedCSS === null) {
+        joinedCSS = userCSS ? [...sections, userCSS].join("\n\n") : sections.join("\n\n");
+      }
+      return joinedCSS;
+    },
+    sections,
+    userCSS,
+    classNames,
+    theme: effectiveTheme,
+    directives: analysis.directives,
+    warnings: analysis.warnings
+  };
+}
+
+export {
+  validateGlobPattern,
+  DEFAULT_PATTERNS,
+  DEFAULT_EXCLUDES,
+  collectProjectClasses,
+  resolveGoogleFonts,
+  getFontPreloadLinks,
+  finalizeProjectCompilation
+};