@csszyx/unplugin 0.6.2 → 0.8.0

package/dist/{chunk-JGJOUK2R.js → shared/unplugin.DCv0RtVZ.mjs}

@@ -1,9 +1,312 @@
-import {
-  mangleCSSSync
-} from "./chunk-4M7CPGP7.js";
+import * as fs from 'node:fs';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import * as path from 'node:path';
+import { dirname } from 'node:path';
+import { transformSourceCode, transformOxc, transform } from '@csszyx/compiler';
+import { encode, compute_mangle_checksum } from '@csszyx/core';
+import { preprocess as preprocess$1 } from '@csszyx/svelte-adapter';
+import { preprocess } from '@csszyx/vue-adapter';
+import { createUnplugin } from 'unplugin';
+import { mangleCSSSync } from '../css-mangler.mjs';
+import { createHash } from 'node:crypto';
 
-// src/theme-scanner.ts
-var EMPTY_THEME = { colors: [], spacings: [], fonts: [], radii: [], shadows: [] };
+const SERVER_DIRECTIVE_RE = /^['"]use server['"];?$/;
+const CLIENT_DIRECTIVE_RE = /^['"]use client['"];?$/;
+const RUNTIME_MODULES = /* @__PURE__ */ new Set([
+  "@csszyx/runtime",
+  "@csszyx/runtime/lite",
+  "csszyx",
+  "csszyx/lite"
+]);
+const FORBIDDEN_SYMBOLS = /* @__PURE__ */ new Set([
+  "_sz",
+  "_sz2",
+  "_sz3",
+  "_szIf",
+  "_szMerge",
+  "_szSwitch",
+  "__csszyx_runtime__"
+]);
+function hasUseServerDirective(code) {
+  for (const statement of readDirectivePrologue(code)) {
+    if (SERVER_DIRECTIVE_RE.test(statement)) {
+      return true;
+    }
+    if (CLIENT_DIRECTIVE_RE.test(statement)) {
+      return false;
+    }
+  }
+  return false;
+}
+function hasUseClientDirective(code) {
+  for (const statement of readDirectivePrologue(code)) {
+    if (CLIENT_DIRECTIVE_RE.test(statement)) {
+      return true;
+    }
+    if (SERVER_DIRECTIVE_RE.test(statement)) {
+      return false;
+    }
+  }
+  return false;
+}
+function isRSCServerModule(code, id) {
+  if (hasUseServerDirective(code)) {
+    return true;
+  }
+  if (hasUseClientDirective(code)) {
+    return false;
+  }
+  return isNextAppRouterEntry(id);
+}
+function findRSCBoundaryViolation(code, id) {
+  if (!isRSCServerModule(code, id)) {
+    return null;
+  }
+  for (const imported of findRuntimeImports(code)) {
+    for (const symbol of imported.symbols) {
+      if (FORBIDDEN_SYMBOLS.has(symbol)) {
+        return {
+          symbol,
+          path: id,
+          importChain: [id, imported.source]
+        };
+      }
+    }
+  }
+  return null;
+}
+function createRSCModuleRecord(code, id) {
+  const normalized = normalizeModuleId(id);
+  return {
+    id: normalized,
+    isServer: isRSCServerModule(code, normalized),
+    isClient: hasUseClientDirective(code),
+    imports: findLocalImportSources(code).map((source) => resolveLocalModule(normalized, source)).filter((resolved) => resolved !== null),
+    runtimeImports: findRuntimeImports(code).filter(
+      (imported) => imported.symbols.some((symbol) => FORBIDDEN_SYMBOLS.has(symbol))
+    )
+  };
+}
+function findRSCGraphViolation(records) {
+  for (const root of records.values()) {
+    if (!root.isServer) {
+      continue;
+    }
+    const violation = walkRSCGraph(root, records, [root.id], /* @__PURE__ */ new Set([root.id]));
+    if (violation) {
+      return {
+        symbol: violation.symbol,
+        path: root.id,
+        importChain: violation.importChain
+      };
+    }
+  }
+  return null;
+}
+function assertNoRSCGraphViolation(records) {
+  const violation = findRSCGraphViolation(records);
+  if (!violation) {
+    return;
+  }
+  throw new Error(formatRSCViolation(violation));
+}
+function isNextAppRouterEntry(id) {
+  const clean = id.split("?")[0]?.replace(/\\/g, "/") ?? id;
+  return /(^|\/)app\/.*\/?(?:page|layout|template|loading|error|not-found|global-error|default|route)\.[cm]?[tj]sx?$/.test(
+    clean
+  );
+}
+function assertNoRSCBoundaryViolation(code, id) {
+  const violation = findRSCBoundaryViolation(code, id);
+  if (!violation) {
+    return;
+  }
+  throw new Error(formatRSCViolation(violation));
+}
+function formatRSCViolation(violation) {
+  return `csszyxRSCViolation: ${violation.symbol} imported in Server Component ${violation.path}
+  Import chain: ${violation.importChain.join(" -> ")}`;
+}
+function walkRSCGraph(current, records, chain, seen) {
+  if (current.isClient) {
+    return null;
+  }
+  const runtime = current.runtimeImports[0];
+  const symbol = runtime?.symbols.find((s) => FORBIDDEN_SYMBOLS.has(s));
+  if (runtime && symbol) {
+    return {
+      symbol,
+      path: chain[0] ?? current.id,
+      importChain: [...chain, runtime.source]
+    };
+  }
+  for (const importedId of current.imports) {
+    if (seen.has(importedId)) {
+      continue;
+    }
+    const next = records.get(importedId);
+    if (!next) {
+      continue;
+    }
+    seen.add(importedId);
+    const violation = walkRSCGraph(next, records, [...chain, importedId], seen);
+    if (violation) {
+      return violation;
+    }
+  }
+  return null;
+}
+function readDirectivePrologue(code) {
+  const out = [];
+  let i = code.charCodeAt(0) === 65279 ? 1 : 0;
+  while (i < code.length) {
+    i = skipWhitespaceAndComments(code, i);
+    const quote = code[i];
+    if (quote !== '"' && quote !== "'") {
+      break;
+    }
+    let j = i + 1;
+    let escaped = false;
+    while (j < code.length) {
+      const ch = code[j];
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === quote) {
+        break;
+      }
+      j++;
+    }
+    if (j >= code.length) {
+      break;
+    }
+    let end = j + 1;
+    while (end < code.length && /[ \t\r\n]/.test(code[end])) {
+      end++;
+    }
+    if (code[end] === ";") {
+      end++;
+    }
+    out.push(code.slice(i, end).trim());
+    i = end;
+  }
+  return out;
+}
+function skipWhitespaceAndComments(code, start) {
+  let i = start;
+  while (i < code.length) {
+    while (i < code.length && /\s/.test(code[i])) {
+      i++;
+    }
+    if (code.startsWith("//", i)) {
+      const next = code.indexOf("\n", i + 2);
+      i = next === -1 ? code.length : next + 1;
+      continue;
+    }
+    if (code.startsWith("/*", i)) {
+      const next = code.indexOf("*/", i + 2);
+      i = next === -1 ? code.length : next + 2;
+      continue;
+    }
+    break;
+  }
+  return i;
+}
+function findRuntimeImports(code) {
+  const imports = [];
+  const staticImportRe = /import\s+(?!type\b)([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+  const sideEffectImportRe = /import\s+['"]([^'"]+)['"]/g;
+  const dynamicImportRe = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  for (const match of code.matchAll(staticImportRe)) {
+    const clause = match[1];
+    const source = match[2];
+    if (!RUNTIME_MODULES.has(source)) {
+      continue;
+    }
+    imports.push({ source, symbols: readImportedSymbols(clause) });
+  }
+  for (const match of code.matchAll(sideEffectImportRe)) {
+    const source = match[1];
+    if (RUNTIME_MODULES.has(source)) {
+      imports.push({ source, symbols: [] });
+    }
+  }
+  for (const match of code.matchAll(dynamicImportRe)) {
+    const source = match[1];
+    if (RUNTIME_MODULES.has(source)) {
+      imports.push({ source, symbols: Array.from(FORBIDDEN_SYMBOLS) });
+    }
+  }
+  return imports;
+}
+function findLocalImportSources(code) {
+  const out = [];
+  const staticImportRe = /import\s+(?!type\b)(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
+  const exportFromRe = /export\s+(?!type\b)(?:[\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+  const dynamicImportRe = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  for (const re of [staticImportRe, exportFromRe, dynamicImportRe]) {
+    for (const match of code.matchAll(re)) {
+      const source = match[1];
+      if (source.startsWith(".") || source.startsWith("/")) {
+        out.push(source);
+      }
+    }
+  }
+  return out;
+}
+function normalizeModuleId(id) {
+  const clean = id.split("?")[0] ?? id;
+  try {
+    return fs.realpathSync.native(clean).replace(/\\/g, "/");
+  } catch {
+    return path.resolve(clean).replace(/\\/g, "/");
+  }
+}
+function resolveLocalModule(importer, source) {
+  const base = source.startsWith("/") ? source : path.resolve(path.dirname(importer), source);
+  const candidates = [
+    base,
+    `${base}.tsx`,
+    `${base}.ts`,
+    `${base}.jsx`,
+    `${base}.js`,
+    `${base}.mjs`,
+    `${base}.cjs`,
+    path.join(base, "index.tsx"),
+    path.join(base, "index.ts"),
+    path.join(base, "index.jsx"),
+    path.join(base, "index.js")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+      return normalizeModuleId(candidate);
+    }
+  }
+  return null;
+}
+function readImportedSymbols(clause) {
+  const symbols = [];
+  const named = clause.match(/\{([\s\S]*?)\}/);
+  if (named) {
+    for (const part of named[1].split(",")) {
+      const trimmed = part.trim();
+      if (!trimmed || trimmed.startsWith("type ")) {
+        continue;
+      }
+      const sourceName = trimmed.replace(/^type\s+/, "").split(/\s+as\s+/)[0]?.trim();
+      if (sourceName) {
+        symbols.push(sourceName);
+      }
+    }
+  }
+  if (/\*\s+as\s+\w+/.test(clause)) {
+    symbols.push(...FORBIDDEN_SYMBOLS);
+  }
+  return symbols;
+}
+
+const EMPTY_THEME = { colors: [], spacings: [], fonts: [], radii: [], shadows: [] };
 function stripLayerWrappers(css) {
   let result = "";
   let i = 0;
@@ -45,8 +348,7 @@ function stripLayerWrappers(css) {
 function extractThemeBlocks(css) {
   const blocks = [];
   const themeStart = /@theme\s+(?:inline\s+)?\{|@theme\{/g;
-  let match;
-  while ((match = themeStart.exec(css)) !== null) {
+  for (const match of css.matchAll(themeStart)) {
     const openPos = css.indexOf("{", match.index);
     let depth = 0;
     let j = openPos;
@@ -97,14 +399,12 @@ function parseThemeBlocks(cssContent) {
   const blocks = extractThemeBlocks(stripped);
   const propPattern = /--([a-z][a-z0-9-]*)(?:\s*:[^;]+)?;/g;
   for (const block of blocks) {
-    let match;
-    while ((match = propPattern.exec(block)) !== null) {
+    for (const match of block.matchAll(propPattern)) {
       const categorized = categorizeProperty(match[1]);
       if (categorized) {
         result[categorized.category].add(categorized.token);
       }
     }
-    propPattern.lastIndex = 0;
   }
   return {
     colors: [...result.colors].sort(),
@@ -144,17 +444,122 @@ function hasTokens(theme) {
   return Object.values(theme).some((arr) => arr.length > 0);
 }
 
-// src/unplugin.ts
-import * as fs from "fs";
-import * as path from "path";
-import { transform, transformSourceCode } from "@csszyx/compiler";
-import { compute_mangle_checksum, encode } from "@csszyx/core";
-import { preprocess as sveltePreprocess } from "@csszyx/svelte-adapter";
-import { preprocess as vuePreprocess } from "@csszyx/vue-adapter";
-import { createUnplugin } from "unplugin";
+const GLOB_MAGIC_RE = /[*?[\]{}]/;
+const DEFAULT_IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".next", ".turbo", "dist", "build"]);
+function normalizeFileId(id) {
+  return id.split(/[?#]/, 1)[0].replace(/\\/g, "/");
+}
+function normalizeRoot(rootDir) {
+  return path.resolve(rootDir).replace(/\\/g, "/");
+}
+function hasGlobMagic(pattern) {
+  return GLOB_MAGIC_RE.test(pattern);
+}
+function escapeRegExp(ch) {
+  return /[|\\{}()[\]^$+?.]/.test(ch) ? `\\${ch}` : ch;
+}
+function globToRegExp(pattern) {
+  const normalized = pattern.replace(/\\/g, "/");
+  let out = "^";
+  for (let i = 0; i < normalized.length; i++) {
+    const ch = normalized[i];
+    if (ch === "*") {
+      if (normalized[i + 1] === "*") {
+        out += ".*";
+        i++;
+      } else {
+        out += "[^/]*";
+      }
+    } else if (ch === "?") {
+      out += "[^/]";
+    } else {
+      out += escapeRegExp(ch);
+    }
+  }
+  out += "$";
+  return new RegExp(out);
+}
+function relativeToRoot(file, rootDir) {
+  const root = normalizeRoot(rootDir);
+  const normalizedFile = normalizeFileId(file);
+  return path.posix.relative(root, normalizedFile).replace(/\\/g, "/");
+}
+function matchesPattern(id, pattern, rootDir) {
+  const file = normalizeFileId(id);
+  const relative = relativeToRoot(file, rootDir);
+  if (pattern instanceof RegExp) {
+    pattern.lastIndex = 0;
+    return pattern.test(file) || pattern.test(relative);
+  }
+  const normalizedPattern = pattern.replace(/\\/g, "/");
+  if (hasGlobMagic(normalizedPattern)) {
+    const re = globToRegExp(normalizedPattern);
+    return re.test(file) || re.test(relative);
+  }
+  const absolutePattern = path.isAbsolute(normalizedPattern) ? normalizeFileId(normalizedPattern) : normalizeFileId(path.join(rootDir, normalizedPattern));
+  return file === absolutePattern || relative === normalizedPattern;
+}
+function matchesAnyPattern(id, patterns, rootDir) {
+  if (!patterns) {
+    return false;
+  }
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  return list.some((pattern) => matchesPattern(id, pattern, rootDir));
+}
+function expandFilePatterns(rootDir, patterns) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  const files = /* @__PURE__ */ new Set();
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!DEFAULT_IGNORED_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
+          walk(full);
+        }
+      } else {
+        files.add(path.resolve(full));
+      }
+    }
+  };
+  let needsWalk = false;
+  for (const pattern of list) {
+    const resolved = path.isAbsolute(pattern) ? pattern : path.join(rootDir, pattern);
+    if (hasGlobMagic(pattern)) {
+      needsWalk = true;
+      continue;
+    }
+    if (fs.existsSync(resolved)) {
+      files.add(path.resolve(resolved));
+    }
+  }
+  if (needsWalk) {
+    walk(rootDir);
+    for (const file of Array.from(files)) {
+      if (!list.some(
+        (pattern) => hasGlobMagic(pattern) && matchesPattern(file, pattern, rootDir)
+      )) {
+        const isLiteralMatch = list.some((pattern) => {
+          if (hasGlobMagic(pattern)) {
+            return false;
+          }
+          const resolved = path.isAbsolute(pattern) ? pattern : path.join(rootDir, pattern);
+          return normalizeFileId(path.resolve(resolved)) === normalizeFileId(file);
+        });
+        if (!isLiteralMatch) {
+          files.delete(file);
+        }
+      }
+    }
+  }
+  return Array.from(files).sort();
+}
 
-// src/html-transformer.ts
-import { createHash } from "crypto";
 function injectChecksum(html, checksum, minify = false) {
   const attrName = minify ? "data-sz-cs" : "data-sz-checksum";
   const htmlTagPattern = /<html([^>]*)>/i;
@@ -164,16 +569,13 @@ function injectChecksum(html, checksum, minify = false) {
   }
   const existingAttrs = match[1];
   const checksumAttr = ` ${attrName}="${checksum}"`;
-  return html.replace(
-    htmlTagPattern,
-    `<html${checksumAttr}${existingAttrs}>`
-  );
+  return html.replace(htmlTagPattern, `<html${checksumAttr}${existingAttrs}>`);
 }
 function injectMangleMapScript(html, mangleMap, options = {}) {
   const { prettyPrint = false } = options;
   const jsonContent = prettyPrint ? JSON.stringify(mangleMap, null, 2) : JSON.stringify(mangleMap);
-  const scriptTag = `<script id="__CSSZYX_MANGLE_MAP__" type="application/json">${jsonContent}</script>`;
-  const debugScript = `<script>(function(){var m=${jsonContent};var r={};for(var k in m)r[m[k]]=k;var cs=document.documentElement.getAttribute("data-sz-checksum")||"";window.__csszyx={mangleMap:m,checksum:cs,decode:function(c){return r[c]},encode:function(c){return m[c]},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()</script>`;
+  const scriptTag = `<script id="__CSSZYX_MANGLE_MAP__" type="application/json">${jsonContent}<\/script>`;
+  const debugScript = `<script>(function(){var m=${jsonContent};var r={};for(var k in m)r[m[k]]=k;var cs=document.documentElement.getAttribute("data-sz-checksum")||"";window.__csszyx={mangleMap:m,checksum:cs,decode:function(c){return r[c]},encode:function(c){return m[c]},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()<\/script>`;
   const combined = `${scriptTag}
 ${debugScript}`;
   if (html.includes("</head>")) {
@@ -214,7 +616,7 @@ function injectHydrationData(html, mangleMap, checksum, options = {}) {
 function transformIndexHtml(html, mangleMap, checksum, options = {}) {
   return injectHydrationData(html, mangleMap, checksum, options);
 }
-function buildRecoveryManifest(tokens, options = {}) {
+function buildRecoveryManifest(tokens, options) {
   const stripped = options.production === true;
   const strippedDevOnlyPaths = [];
   const sorted = {};
@@ -235,7 +637,7 @@ function buildRecoveryManifest(tokens, options = {}) {
   const checksum = fullChecksum.substring(0, 16);
   const buildId = `${Date.now().toString(36)}-${fullChecksum.substring(0, 6)}`;
   return {
-    manifest: { buildId, checksum, tokens: sorted },
+    manifest: { buildId, checksum, mangleChecksum: options.mangleChecksum, tokens: sorted },
     strippedDevOnlyPaths
   };
 }
@@ -244,7 +646,7 @@ function injectRecoveryManifest(html, manifest) {
     return html;
   }
   const json = JSON.stringify(manifest);
-  const scriptTag = `<script id="__SZ_RECOVERY_MANIFEST__" type="application/json">${json}</script>`;
+  const scriptTag = `<script id="__SZ_RECOVERY_MANIFEST__" type="application/json">${json}<\/script>`;
   if (html.includes("</head>")) {
     return html.replace("</head>", `${scriptTag}
 </head>`);
@@ -255,9 +657,6 @@ function injectRecoveryManifest(html, manifest) {
   return html + scriptTag;
 }
 
-// src/theme-type-writer.ts
-import { mkdirSync, writeFileSync } from "fs";
-import { dirname } from "path";
 function generateThemeDts(opts) {
   const { theme, sourceFiles } = opts;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -304,11 +703,10 @@ function writeThemeDts(opts) {
   writeFileSync(opts.outputPath, content, "utf-8");
 }
 
-// src/virtual-modules.ts
-var VIRTUAL_MODULE_ID = "virtual:csszyx/mangle-map";
-var RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
-var VIRTUAL_CHECKSUM_ID = "virtual:csszyx/checksum";
-var RESOLVED_VIRTUAL_CHECKSUM_ID = "\0" + VIRTUAL_CHECKSUM_ID;
+const VIRTUAL_MODULE_ID = "virtual:csszyx/mangle-map";
+const RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
+const VIRTUAL_CHECKSUM_ID = "virtual:csszyx/checksum";
+const RESOLVED_VIRTUAL_CHECKSUM_ID = `\0${VIRTUAL_CHECKSUM_ID}`;
 function createMangleMapModule(mangleMap, checksum) {
   return `/**
  * Auto-generated mangle map for csszyx.
@@ -353,22 +751,14 @@ function resolveVirtualModule(id) {
   return void 0;
 }
 
-// src/unplugin.ts
-var CHECKSUM_PLACEHOLDER = "___CSSZYX_CHECKSUM___";
-var MANGLE_MAP_PLACEHOLDER = "___CSSZYX_MANGLE_MAP___";
-var _hasWarnedTsConfig = false;
+const CHECKSUM_PLACEHOLDER = "___CSSZYX_CHECKSUM___";
+const MANGLE_MAP_PLACEHOLDER = "___CSSZYX_MANGLE_MAP___";
+let _hasWarnedTsConfig = false;
 function runThemeScan(rootDir, scanCss) {
   if (!scanCss) {
     return;
   }
-  const patterns = Array.isArray(scanCss) ? scanCss : [scanCss];
-  const sourceFiles = [];
-  for (const pattern of patterns) {
-    const resolved = path.isAbsolute(pattern) ? pattern : path.join(rootDir, pattern);
-    if (fs.existsSync(resolved)) {
-      sourceFiles.push(resolved);
-    }
-  }
+  const sourceFiles = expandFilePatterns(rootDir, scanCss).filter((file) => file.endsWith(".css"));
   if (sourceFiles.length === 0) {
     return;
   }
@@ -389,9 +779,11 @@ function runThemeScan(rootDir, scanCss) {
         if (fs.existsSync(cfgPath)) {
           const content = fs.readFileSync(cfgPath, "utf-8");
           if (!content.includes(".csszyx")) {
-            console.warn(`
+            console.warn(
+              `
 \x1B[33m\u26A0\uFE0F CSSzyx: Theme Auto-Scan enabled, but TypeScript isn't configured. Run "npx @csszyx/cli init" to fix.\x1B[0m
-`);
+`
+            );
           }
           return true;
         }
@@ -483,12 +875,12 @@ function mangleCodeClassesSync(code, mangleMap) {
           return qm;
         }
         changed = true;
-        return '"' + m + '"';
+        return `"${m}"`;
       });
-      out += "${" + mangledInner + "}";
+      out += `\${${mangledInner}}`;
       i = j;
     }
-    return changed ? "className:`" + out + "`" : fullMatch;
+    return changed ? `className:\`${out}\`` : fullMatch;
   });
   {
     const marker = "className:";
@@ -543,7 +935,7 @@ function mangleCodeClassesSync(code, mangleMap) {
         const mangledStr = parts.map((p) => mangleMap[p] || p).join(" ");
         if (mangledStr !== inner) {
           changed = true;
-          return '"' + mangledStr + '"';
+          return `"${mangledStr}"`;
         }
         return qm;
       });
@@ -572,24 +964,58 @@ function mangleCodeClassesSync(code, mangleMap) {
     if (!changed) {
       return match;
     }
-    return '"' + mangled.join(" ") + '"';
+    return `"${mangled.join(" ")}"`;
   });
   return result;
 }
 function createCsszyxPlugins(options = {}) {
   const manglingEnabled = options.production?.mangle !== false;
   const astBudgetOverride = options.build?.astBudgetLimit;
+  const parserOverride = process.env.CSSZYX_PARSER;
+  const parserMode = parserOverride === "babel" || parserOverride === "oxc" ? parserOverride : options.build?.parser ?? "oxc";
   const state = {
     classes: /* @__PURE__ */ new Set(),
     mangleMap: {},
     checksum: "",
     finalized: false,
     rootDir: process.cwd(),
-    recoveryTokens: /* @__PURE__ */ new Map()
+    recoveryTokens: /* @__PURE__ */ new Map(),
+    rscModules: /* @__PURE__ */ new Map()
   };
   const SAFELIST_FILENAME = "csszyx-classes.html";
   const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".tsx", ".jsx", ".ts", ".js"]);
   const IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".next", ".git", "dist", "build", ".turbo"]);
+  function isUserExcluded(id) {
+    return matchesAnyPattern(id, options.exclude, state.rootDir);
+  }
+  function isUserIncluded(id) {
+    return !options.include || matchesAnyPattern(id, options.include, state.rootDir);
+  }
+  function isHardIgnored(id) {
+    return id.includes("node_modules") || id.includes("/packages/") || id.includes(".next") && !id.includes("static");
+  }
+  function shouldProcessSource(id) {
+    return !isHardIgnored(id) && !isUserExcluded(id) && isUserIncluded(id) && (/\.[tj]sx?(\?.*)?$/.test(id) || id.endsWith(".vue") || id.endsWith(".svelte"));
+  }
+  function shouldProcessCss(id) {
+    return !isHardIgnored(id) && !isUserExcluded(id) && /\.css(\?.*)?$/.test(id);
+  }
+  function transformConfiguredSource(source, filename) {
+    const compilerOptions = { astBudget: astBudgetOverride };
+    if (parserMode !== "oxc") {
+      return transformSourceCode(source, filename, compilerOptions);
+    }
+    try {
+      return transformOxc(source, filename, compilerOptions);
+    } catch (err) {
+      const result = transformSourceCode(source, filename, compilerOptions);
+      const reason = err instanceof Error ? err.message : String(err);
+      result.diagnostics.push(
+        `[csszyx] oxc parser fell back to Babel for ${filename}: ${reason}`
+      );
+      return result;
+    }
+  }
   function writeSafelistFile(classes) {
     if (classes.size === 0) {
       return;
@@ -625,12 +1051,15 @@ function createCsszyxPlugins(options = {}) {
           }
         } else if (SOURCE_EXTENSIONS.has(path.extname(entry.name))) {
           const filePath = path.join(dir, entry.name);
+          if (!shouldProcessSource(filePath)) {
+            continue;
+          }
           try {
             const content = fs.readFileSync(filePath, "utf-8");
             if (!content.includes("sz=") && !content.includes("sz:")) {
               continue;
             }
-            const result = transformSourceCode(content, filePath, { astBudget: astBudgetOverride });
+            const result = transformConfiguredSource(content, filePath);
             if (!result.transformed) {
               continue;
             }
@@ -645,10 +1074,9 @@ function createCsszyxPlugins(options = {}) {
             }
             if (result.usesRuntime) {
               const szCallRe = /_sz\(\s*\{/g;
-              let szMatch;
-              while ((szMatch = szCallRe.exec(result.code)) !== null) {
+              for (const szMatch of result.code.matchAll(szCallRe)) {
                 let depth = 1;
-                let idx = szMatch.index + szMatch[0].length;
+                let idx = (szMatch.index ?? 0) + szMatch[0].length;
                 while (idx < result.code.length && depth > 0) {
                   if (result.code[idx] === "{") {
                     depth++;
@@ -657,10 +1085,12 @@ function createCsszyxPlugins(options = {}) {
                   }
                   idx++;
                 }
-                const objStr = result.code.slice(szMatch.index + szMatch[0].length, idx - 1);
+                const objStr = result.code.slice(
+                  (szMatch.index ?? 0) + szMatch[0].length,
+                  idx - 1
+                );
                 const strKv = /(\w+)\s*:\s*(?:"([^"]*)"|'([^']*)')/g;
-                let kv;
-                while ((kv = strKv.exec(objStr)) !== null) {
+                for (const kv of objStr.matchAll(strKv)) {
                   try {
                     const val = kv[2] ?? kv[3];
                     const r = transform({ [kv[1]]: val });
@@ -671,7 +1101,7 @@ function createCsszyxPlugins(options = {}) {
                   }
                 }
                 const numKv = /(\w+)\s*:\s*(-?\d+(?:\.\d+)?)\s*(?=[,}\n])/g;
-                while ((kv = numKv.exec(objStr)) !== null) {
+                for (const kv of objStr.matchAll(numKv)) {
                   try {
                     const r = transform({ [kv[1]]: parseFloat(kv[2]) });
                     for (const c of r.className.split(/\s+/).filter(Boolean)) {
@@ -681,7 +1111,7 @@ function createCsszyxPlugins(options = {}) {
                   }
                 }
                 const boolKv = /(\w+)\s*:\s*(true|false)\s*(?=[,}\n])/g;
-                while ((kv = boolKv.exec(objStr)) !== null) {
+                for (const kv of objStr.matchAll(boolKv)) {
                   try {
                     const r = transform({ [kv[1]]: kv[2] === "true" });
                     for (const c of r.className.split(/\s+/).filter(Boolean)) {
@@ -707,9 +1137,8 @@ function createCsszyxPlugins(options = {}) {
   function extractClasses(code) {
     const dqPattern = /(?:class(?:Name)?|sz)[:=]\s*"([^"]*)"/g;
     const sqPattern = /(?:class(?:Name)?|sz)[:=]\s*'([^']*)'/g;
-    let match;
     for (const classPattern of [dqPattern, sqPattern]) {
-      while ((match = classPattern.exec(code)) !== null) {
+      for (const match of code.matchAll(classPattern)) {
         const classes = match[1].split(/\s+/).filter(Boolean);
         for (const cls of classes) {
           state.classes.add(cls);
@@ -717,9 +1146,9 @@ function createCsszyxPlugins(options = {}) {
       }
     }
     const exprStart = /className=\{/g;
-    while ((match = exprStart.exec(code)) !== null) {
+    for (const match of code.matchAll(exprStart)) {
       let depth = 1;
-      let i = match.index + match[0].length;
+      let i = (match.index ?? 0) + match[0].length;
       while (i < code.length && depth > 0) {
         if (code[i] === "{") {
           depth++;
@@ -728,10 +1157,9 @@ function createCsszyxPlugins(options = {}) {
         }
         i++;
       }
-      const expr = code.slice(match.index + match[0].length, i - 1);
+      const expr = code.slice((match.index ?? 0) + match[0].length, i - 1);
       const strPattern = /"([^"]+)"|'([^']+)'/g;
-      let strMatch;
-      while ((strMatch = strPattern.exec(expr)) !== null) {
+      for (const strMatch of expr.matchAll(strPattern)) {
         const str = strMatch[1] || strMatch[2];
         const classes = str.split(/\s+/).filter(Boolean);
         for (const cls of classes) {
@@ -765,313 +1193,327 @@ function createCsszyxPlugins(options = {}) {
     }
     return result;
   }
-  const prePlugin = createUnplugin((_pluginOptions) => ({
-    name: "csszyx:pre",
-    enforce: "pre",
-    /**
-     * Resolves virtual module IDs for csszyx mangle-map and checksum modules.
-     * @param id - the module ID to resolve
-     * @returns resolved ID if virtual, null otherwise
-     */
-    resolveId(id) {
-      if (isVirtualModule(id)) {
-        return resolveVirtualModule(id);
-      }
-      return null;
-    },
-    /**
-     * Loads virtual module content — generates mangle map or checksum module code.
-     * @param id - the resolved module ID to load
-     * @returns generated module source if virtual, null otherwise
-     */
-    load(id) {
-      if (id === RESOLVED_VIRTUAL_MODULE_ID) {
-        finalizeMangleMap();
-        return createMangleMapModule(state.mangleMap, state.checksum);
-      }
-      if (id === RESOLVED_VIRTUAL_CHECKSUM_ID) {
-        finalizeMangleMap();
-        return createChecksumModule(state.checksum);
-      }
-      return null;
-    },
-    /**
-     * Filters files for the pre-transform phase — source files plus CSS files.
-     * CSS files need special handling to inject @source inline() for Tailwind class discovery.
-     * @param id - the file path to check for inclusion
-     * @returns true if the file should be transformed, false otherwise
-     */
-    transformInclude(id) {
-      if (id.includes("node_modules") || id.includes("/packages/") || id.includes(".next") && !id.includes("static")) {
-        return false;
-      }
-      if (/\.css(\?.*)?$/.test(id)) {
-        return true;
-      }
-      return /\.[tj]sx?$/.test(id) || id.endsWith(".vue") || id.endsWith(".svelte");
-    },
-    /**
-     * Core transform: detects sz prop, compiles to className, injects runtime, collects classes.
-     * For CSS files: injects @source inline() so Tailwind generates CSS for sz-derived classes.
-     * @param code - the source code to transform
-     * @param id - the file path of the module being transformed
-     * @returns transformed code with source map, or null if no changes were made
-     */
-    transform(code, id) {
-      if (/\.css(\?.*)?$/.test(id)) {
-        const hasTailwindImport = code.includes('@import "tailwindcss') || code.includes("@import 'tailwindcss");
-        if (hasTailwindImport && state.classes.size > 0) {
-          const candidates = Array.from(state.classes).filter((c) => c.length >= 2 && /^[a-z]/.test(c)).join(" ");
-          if (candidates) {
-            const safelistPath = path.join(state.rootDir, SAFELIST_FILENAME).replace(/\\/g, "/");
-            const cssDir = path.dirname(id).replace(/\\/g, "/");
-            let relPath = path.posix.relative(cssDir, safelistPath);
-            if (!relPath.startsWith(".")) {
-              relPath = "./" + relPath;
-            }
-            const sourceDirective = `@source "${relPath}";
+  const prePlugin = createUnplugin(
+    (_pluginOptions) => ({
+      name: "csszyx:pre",
+      enforce: "pre",
+      /**
+       * Resolves virtual module IDs for csszyx mangle-map and checksum modules.
+       * @param id - the module ID to resolve
+       * @returns resolved ID if virtual, null otherwise
+       */
+      resolveId(id) {
+        if (isVirtualModule(id)) {
+          return resolveVirtualModule(id);
+        }
+        return null;
+      },
+      /**
+       * Loads virtual module content — generates mangle map or checksum module code.
+       * @param id - the resolved module ID to load
+       * @returns generated module source if virtual, null otherwise
+       */
+      load(id) {
+        if (id === RESOLVED_VIRTUAL_MODULE_ID) {
+          finalizeMangleMap();
+          return createMangleMapModule(state.mangleMap, state.checksum);
+        }
+        if (id === RESOLVED_VIRTUAL_CHECKSUM_ID) {
+          finalizeMangleMap();
+          return createChecksumModule(state.checksum);
+        }
+        return null;
+      },
+      /**
+       * Filters files for the pre-transform phase — source files plus CSS files.
+       * CSS files need special handling to inject @source inline() for Tailwind class discovery.
+       * @param id - the file path to check for inclusion
+       * @returns true if the file should be transformed, false otherwise
+       */
+      transformInclude(id) {
+        if (shouldProcessCss(id)) {
+          return true;
+        }
+        return shouldProcessSource(id);
+      },
+      /**
+       * Core transform: detects sz prop, compiles to className, injects runtime, collects classes.
+       * For CSS files: injects @source inline() so Tailwind generates CSS for sz-derived classes.
+       * @param code - the source code to transform
+       * @param id - the file path of the module being transformed
+       * @returns transformed code with source map, or null if no changes were made
+       */
+      transform(code, id) {
+        if (!shouldProcessCss(id) && !shouldProcessSource(id)) {
+          return null;
+        }
+        if (/\.[tj]sx?(\?.*)?$/.test(id)) {
+          assertNoRSCBoundaryViolation(code, id);
+        }
+        if (/\.css(\?.*)?$/.test(id)) {
+          const hasTailwindImport = code.includes('@import "tailwindcss') || code.includes("@import 'tailwindcss");
+          if (hasTailwindImport && state.classes.size > 0) {
+            const candidates = Array.from(state.classes).filter((c) => c.length >= 2 && /^[a-z]/.test(c)).join(" ");
+            if (candidates) {
+              const safelistPath = path.join(state.rootDir, SAFELIST_FILENAME).replace(/\\/g, "/");
+              const cssDir = path.dirname(id).replace(/\\/g, "/");
+              let relPath = path.posix.relative(cssDir, safelistPath);
+              if (!relPath.startsWith(".")) {
+                relPath = `./${relPath}`;
+              }
+              const sourceDirective = `@source "${relPath}";
 `;
-            const transformed2 = code.replace(
-              /(@import\s+["']tailwindcss[^"']*["'];)/,
-              `$1
+              const transformed2 = code.replace(
+                /(@import\s+["']tailwindcss[^"']*["'];)/,
+                `$1
 ${sourceDirective}`
-            );
-            if (transformed2 !== code) {
-              return { code: transformed2, map: null };
+              );
+              if (transformed2 !== code) {
+                return { code: transformed2, map: null };
+              }
             }
           }
+          return null;
         }
-        return null;
-      }
-      let transformedCode = code;
-      let usesRuntime = false;
-      let usesMerge = false;
-      let usesColorVar = false;
-      let transformed = false;
-      let szClasses;
-      const hasSzProp = code.includes("sz=") || /\bsz\s*:\s*["'{]/.test(code) || code.includes('sz: "');
-      if (hasSzProp) {
-        if (id.endsWith(".vue")) {
-          const result = vuePreprocess(code, options);
-          if (result.transformed) {
-            transformedCode = result.code;
-            transformed = true;
-          }
-        } else if (id.endsWith(".svelte")) {
-          const result = sveltePreprocess(code, options);
-          if (result) {
+        let transformedCode = code;
+        let usesRuntime = false;
+        let usesMerge = false;
+        let usesColorVar = false;
+        let transformed = false;
+        let szClasses;
+        const hasSzProp = code.includes("sz=") || /\bsz\s*:\s*["'{]/.test(code) || code.includes('sz: "');
+        if (hasSzProp) {
+          if (id.endsWith(".vue")) {
+            const result = preprocess(code, options);
+            if (result.transformed) {
+              transformedCode = result.code;
+              transformed = true;
+            }
+          } else if (id.endsWith(".svelte")) {
+            const result = preprocess$1(code, options);
+            if (result) {
+              transformedCode = result.code;
+              transformed = true;
+            }
+          } else {
+            const result = transformConfiguredSource(code, id);
             transformedCode = result.code;
-            transformed = true;
-          }
-        } else {
-          const result = transformSourceCode(code, id, { astBudget: astBudgetOverride });
-          transformedCode = result.code;
-          usesRuntime = result.usesRuntime;
-          usesMerge = result.usesMerge;
-          usesColorVar = result.usesColorVar;
-          transformed = result.transformed;
-          szClasses = result.classes;
-          if (result.diagnostics.length > 0 && process.env.NODE_ENV !== "production") {
-            for (const msg of result.diagnostics) {
-              this.warn(`[csszyx] ${id}
+            usesRuntime = result.usesRuntime;
+            usesMerge = result.usesMerge;
+            usesColorVar = result.usesColorVar;
+            transformed = result.transformed;
+            szClasses = result.classes;
+            if (result.diagnostics.length > 0 && process.env.NODE_ENV !== "production") {
+              for (const msg of result.diagnostics) {
+                this.warn(`[csszyx] ${id}
   ${msg}`);
+              }
+            }
+            for (const [token, data] of result.recoveryTokens) {
+              state.recoveryTokens.set(token, data);
             }
-          }
-          for (const [token, data] of result.recoveryTokens) {
-            state.recoveryTokens.set(token, data);
           }
         }
-      }
-      if (transformedCode.includes("<html") && /layout|Root|Document|app\\.tsx?$/i.test(id)) {
-        const attrName = options.production?.minify ? "data-sz-cs" : "data-sz-checksum";
-        transformedCode = transformedCode.replace(/<html([^>]*)>/i, `<html$1 ${attrName}="${CHECKSUM_PLACEHOLDER}">`);
-        const debugScript = `<script dangerouslySetInnerHTML={{__html: \`(function(){var m=${MANGLE_MAP_PLACEHOLDER};var r={};for(var k in m)r[m[k]]=k;window.__csszyx={mangleMap:m,checksum:"${CHECKSUM_PLACEHOLDER}",decode:function(c){return r[c]},encode:function(c){return m[c]},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()\`}} />`;
-        if (transformedCode.includes("<body")) {
+        if (transformedCode.includes("<html") && /layout|Root|Document|app\\.tsx?$/i.test(id)) {
+          const attrName = options.production?.minify ? "data-sz-cs" : "data-sz-checksum";
           transformedCode = transformedCode.replace(
-            /(<body[^>]*>)/i,
-            `$1${debugScript}`
+            /<html([^>]*)>/i,
+            `<html$1 ${attrName}="${CHECKSUM_PLACEHOLDER}">`
           );
-        }
-        transformed = true;
-      }
-      {
-        const imports = [];
-        if (usesRuntime) {
-          imports.push("_sz");
-        }
-        if (usesMerge) {
-          imports.push("_szMerge");
-        }
-        if (usesColorVar) {
-          imports.push("__szColorVar");
-        }
-        const needed = imports.filter(
-          (name) => !new RegExp(`\\{[^}]*\\b${name}\\b[^}]*\\}\\s*from\\s*['"]@csszyx/runtime['"]`).test(transformedCode)
-        );
-        if (needed.length > 0) {
-          const existingImport = transformedCode.match(/^(import\s*\{[^}]*)\}\s*from\s*'@csszyx\/runtime'/m);
-          if (existingImport) {
+          const debugScript = `<script dangerouslySetInnerHTML={{__html: \`(function(){var m=${MANGLE_MAP_PLACEHOLDER};var r={};for(var k in m)r[m[k]]=k;window.__csszyx={mangleMap:m,checksum:"${CHECKSUM_PLACEHOLDER}",decode:function(c){return r[c]},encode:function(c){return m[c]},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()\`}} />`;
+          if (transformedCode.includes("<body")) {
             transformedCode = transformedCode.replace(
-              existingImport[0],
-              `${existingImport[1]}, ${needed.join(", ")} } from '@csszyx/runtime'`
+              /(<body[^>]*>)/i,
+              `$1${debugScript}`
             );
-          } else {
-            const importStmt = `import { ${needed.join(", ")} } from '@csszyx/runtime';
-`;
-            const directiveMatch = transformedCode.match(/^['"]use (client|server)['"];?\s*/);
-            if (directiveMatch) {
-              const directive = directiveMatch[0];
-              transformedCode = transformedCode.replace(directive, `${directive}${importStmt}`);
-            } else {
-              transformedCode = `${importStmt}${transformedCode}`;
-            }
           }
           transformed = true;
         }
-      }
-      if (transformed || transformedCode.includes("class=") || transformedCode.includes("className=")) {
-        if (szClasses !== void 0) {
-          for (const cls of szClasses) {
-            state.classes.add(cls);
+        {
+          const imports = [];
+          if (usesRuntime) {
+            imports.push("_sz");
+          }
+          if (usesMerge) {
+            imports.push("_szMerge");
+          }
+          if (usesColorVar) {
+            imports.push("__szColorVar");
+          }
+          const needed = imports.filter(
+            (name) => !new RegExp(
+              `\\{[^}]*\\b${name}\\b[^}]*\\}\\s*from\\s*['"]@csszyx/runtime['"]`
+            ).test(transformedCode)
+          );
+          if (needed.length > 0) {
+            const existingImport = transformedCode.match(
+              /^(import\s*\{[^}]*)\}\s*from\s*'@csszyx\/runtime'/m
+            );
+            if (existingImport) {
+              transformedCode = transformedCode.replace(
+                existingImport[0],
+                `${existingImport[1]}, ${needed.join(", ")} } from '@csszyx/runtime'`
+              );
+            } else {
+              const importStmt = `import { ${needed.join(", ")} } from '@csszyx/runtime';
+`;
+              const directiveMatch = transformedCode.match(
+                /^['"]use (client|server)['"];?\s*/
+              );
+              if (directiveMatch) {
+                const directive = directiveMatch[0];
+                transformedCode = transformedCode.replace(
+                  directive,
+                  `${directive}${importStmt}`
+                );
+              } else {
+                transformedCode = `${importStmt}${transformedCode}`;
+              }
+            }
+            transformed = true;
           }
-        } else {
-          extractClasses(transformedCode);
         }
-        return { code: transformedCode, map: null };
-      }
-      return null;
-    },
-    /** Finalizes the mangle map after all source modules have been processed. */
-    buildEnd() {
-      finalizeMangleMap();
-      if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
-        globalThis.__csszyx_ssr_mangle_map = state.mangleMap;
-      }
-    },
-    /**
-     * Webpack hook: pre-scans source files before compilation for Tailwind class discovery.
-     * @param compiler - the Webpack compiler instance
-     */
-    webpack(compiler) {
-      compiler.hooks.beforeCompile.tap("csszyx:prescan", () => {
-        const root = compiler.context || process.cwd();
-        state.rootDir = root;
-        if (state.classes.size === 0) {
-          prescanAndWriteClasses();
+        if (/\.[tj]sx?(\?.*)?$/.test(id)) {
+          assertNoRSCBoundaryViolation(transformedCode, id);
+          const record = createRSCModuleRecord(transformedCode, id);
+          state.rscModules.set(record.id, record);
         }
-        runThemeScan(root, options.build?.scanCss);
-      });
-      if (options.build?.scanCss) {
-        const patterns = Array.isArray(options.build.scanCss) ? options.build.scanCss : [options.build.scanCss];
-        compiler.hooks.thisCompilation.tap("csszyx:theme-deps", (compilation) => {
-          const root = compiler.context || process.cwd();
-          for (const pattern of patterns) {
-            const resolved = path.isAbsolute(pattern) ? pattern : path.join(root, pattern);
-            if (fs.existsSync(resolved)) {
-              compilation.fileDependencies.add(resolved);
+        if (transformed || transformedCode.includes("class=") || transformedCode.includes("className=")) {
+          if (szClasses !== void 0) {
+            for (const cls of szClasses) {
+              state.classes.add(cls);
             }
+          } else {
+            extractClasses(transformedCode);
           }
-        });
-      }
-    },
-    vite: {
-      /**
-       * Vite hook: pre-scans source files when config is resolved.
-       * Also runs theme scan to generate .csszyx/theme.d.ts if scanCss is configured.
-       * @param config - the resolved Vite configuration object
-       */
-      configResolved(config) {
-        const root = config.root || process.cwd();
-        state.rootDir = root;
-        prescanAndWriteClasses();
-        runThemeScan(root, options.build?.scanCss);
+          return { code: transformedCode, map: null };
+        }
+        return null;
+      },
+      /** Finalizes the mangle map after all source modules have been processed. */
+      buildEnd() {
+        finalizeMangleMap();
+        assertNoRSCGraphViolation(state.rscModules);
+        if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
+          globalThis.__csszyx_ssr_mangle_map = state.mangleMap;
+        }
       },
       /**
-       * Vite HMR hook: re-runs theme scan when a watched CSS file changes,
-       * and incrementally updates csszyx-classes.html when a source file gains new sz classes.
-       * @param ctx - HMR context containing the changed file
+       * Webpack hook: pre-scans source files before compilation for Tailwind class discovery.
+       * @param compiler - the Webpack compiler instance
        */
-      handleHotUpdate(ctx) {
-        const scanCss = options.build?.scanCss;
-        if (scanCss) {
-          const patterns = Array.isArray(scanCss) ? scanCss : [scanCss];
-          const root = ctx.server.config.root || process.cwd();
-          const isWatched = patterns.some((p) => {
-            const resolved = path.isAbsolute(p) ? p : path.join(root, p);
-            return ctx.file === resolved;
-          });
-          if (isWatched) {
-            runThemeScan(root, scanCss);
+      webpack(compiler) {
+        compiler.hooks.beforeCompile.tap("csszyx:prescan", () => {
+          const root = compiler.context || process.cwd();
+          state.rootDir = root;
+          if (state.classes.size === 0) {
+            prescanAndWriteClasses();
           }
-        }
-        if (!SOURCE_EXTENSIONS.has(path.extname(ctx.file))) {
-          return;
-        }
-        if (ctx.file.includes("node_modules")) {
-          return;
-        }
-        let fileContent, result;
-        try {
-          fileContent = fs.readFileSync(ctx.file, "utf-8");
-        } catch {
-          return;
-        }
-        if (!fileContent.includes("sz=") && !/\bsz\s*:\s*["'{]/.test(fileContent)) {
-          return;
-        }
-        try {
-          result = transformSourceCode(fileContent, ctx.file, { astBudget: astBudgetOverride });
-        } catch {
-          return;
-        }
-        if (!result.transformed) {
-          return;
-        }
-        const sizeBefore = state.classes.size;
-        for (const cls of result.classes) {
-          state.classes.add(cls);
-        }
-        for (const [token, data] of result.recoveryTokens) {
-          state.recoveryTokens.set(token, data);
-        }
-        if (state.classes.size > sizeBefore) {
-          writeSafelistFile(state.classes);
-          const safelistPath = path.join(state.rootDir, SAFELIST_FILENAME);
-          ctx.server.watcher.emit("change", safelistPath);
+          runThemeScan(root, options.build?.scanCss);
+        });
+        if (options.build?.scanCss) {
+          compiler.hooks.thisCompilation.tap("csszyx:theme-deps", (compilation) => {
+            const root = compiler.context || process.cwd();
+            for (const file of expandFilePatterns(root, options.build?.scanCss ?? [])) {
+              compilation.fileDependencies.add(file);
+            }
+          });
         }
       },
-      transformIndexHtml: {
-        order: "pre",
+      vite: {
         /**
-         * Injects hydration data (mangle map + checksum) into the HTML document.
-         * Also mangles class attributes in SSR-rendered HTML so they match mangled CSS selectors.
-         * @param html - the raw HTML string to transform
-         * @returns transformed HTML with injected hydration data
+         * Vite hook: pre-scans source files when config is resolved.
+         * Also runs theme scan to generate .csszyx/theme.d.ts if scanCss is configured.
+         * @param config - the resolved Vite configuration object
          */
-        handler(html) {
-          finalizeMangleMap();
-          let result = transformIndexHtml(html, state.mangleMap, state.checksum, {
-            mode: options.production?.injectChecksum === false ? "script" : "script",
-            minify: process.env.NODE_ENV === "production"
-          });
-          if (state.recoveryTokens.size > 0) {
-            const isProduction = process.env.NODE_ENV === "production";
-            const { manifest, strippedDevOnlyPaths } = buildRecoveryManifest(
-              state.recoveryTokens,
-              { production: isProduction }
-            );
-            if (strippedDevOnlyPaths.length > 0) {
-              console.warn(
-                `[csszyx] Stripped ${strippedDevOnlyPaths.length} szRecover="dev-only" token(s) from the production manifest. Recovery for these elements is disabled in production by design. Sites: ${strippedDevOnlyPaths.join(", ")}`
+        configResolved(config) {
+          const root = config.root || process.cwd();
+          state.rootDir = root;
+          prescanAndWriteClasses();
+          runThemeScan(root, options.build?.scanCss);
+        },
+        /**
+         * Vite HMR hook: re-runs theme scan when a watched CSS file changes,
+         * and incrementally updates csszyx-classes.html when a source file gains new sz classes.
+         * @param ctx - HMR context containing the changed file
+         */
+        handleHotUpdate(ctx) {
+          const scanCss = options.build?.scanCss;
+          if (scanCss) {
+            const root = ctx.server.config.root || process.cwd();
+            if (matchesAnyPattern(ctx.file, scanCss, root)) {
+              runThemeScan(root, scanCss);
+            }
+          }
+          if (!shouldProcessSource(ctx.file)) {
+            return;
+          }
+          let fileContent, result;
+          try {
+            fileContent = fs.readFileSync(ctx.file, "utf-8");
+          } catch {
+            return;
+          }
+          if (!fileContent.includes("sz=") && !/\bsz\s*:\s*["'{]/.test(fileContent)) {
+            return;
+          }
+          try {
+            result = transformConfiguredSource(fileContent, ctx.file);
+          } catch {
+            return;
+          }
+          if (!result.transformed) {
+            return;
+          }
+          const sizeBefore = state.classes.size;
+          for (const cls of result.classes) {
+            state.classes.add(cls);
+          }
+          for (const [token, data] of result.recoveryTokens) {
+            state.recoveryTokens.set(token, data);
+          }
+          if (state.classes.size > sizeBefore) {
+            writeSafelistFile(state.classes);
+            const safelistPath = path.join(state.rootDir, SAFELIST_FILENAME);
+            ctx.server.watcher.emit("change", safelistPath);
+          }
+        },
+        transformIndexHtml: {
+          order: "pre",
+          /**
+           * Injects hydration data (mangle map + checksum) into the HTML document.
+           * Also mangles class attributes in SSR-rendered HTML so they match mangled CSS selectors.
+           * @param html - the raw HTML string to transform
+           * @returns transformed HTML with injected hydration data
+           */
+          handler(html) {
+            finalizeMangleMap();
+            let result = transformIndexHtml(html, state.mangleMap, state.checksum, {
+              mode: options.production?.injectChecksum === false ? "script" : "script",
+              minify: process.env.NODE_ENV === "production"
+            });
+            if (state.recoveryTokens.size > 0) {
+              const isProduction = process.env.NODE_ENV === "production";
+              const { manifest, strippedDevOnlyPaths } = buildRecoveryManifest(
+                state.recoveryTokens,
+                {
+                  production: isProduction,
+                  mangleChecksum: state.checksum
+                }
               );
+              if (strippedDevOnlyPaths.length > 0) {
+                console.warn(
+                  `[csszyx] Stripped ${strippedDevOnlyPaths.length} szRecover="dev-only" token(s) from the production manifest. Recovery for these elements is disabled in production by design. Sites: ${strippedDevOnlyPaths.join(", ")}`
+                );
+              }
+              result = injectRecoveryManifest(result, manifest);
             }
-            result = injectRecoveryManifest(result, manifest);
+            return result;
           }
-          return result;
         }
       }
-    }
-  }));
+    })
+  );
   const postPlugin = createUnplugin(() => ({
     name: "csszyx:post",
     enforce: "post",
@@ -1083,8 +1525,7 @@ ${sourceDirective}`
      */
     webpack(compiler) {
       compiler.hooks.compilation.tap("csszyx:post", (compilation) => {
-        const stage = compiler.webpack?.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE || // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE;
+        const stage = compiler.webpack?.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE || compilation.constructor.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE;
         compilation.hooks.processAssets.tap(
           {
             name: "csszyx:post",
@@ -1124,19 +1565,24 @@ ${sourceDirective}`
                       continue;
                     }
                   } catch (e) {
-                    if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") {
-                    } else {
+                    if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") ; else {
                       throw e;
                     }
                   }
                 } else if (file.endsWith(".html")) {
-                  const mangledHtml = source.replace(/\bclass="([^"]*)"/g, (_m, cls) => {
-                    const out = cls.split(/\s+/).filter(Boolean).map((c) => state.mangleMap[c] || c).join(" ");
-                    return out !== cls ? `class="${out}"` : _m;
-                  }).replace(/\bclass='([^']*)'/g, (_m, cls) => {
-                    const out = cls.split(/\s+/).filter(Boolean).map((c) => state.mangleMap[c] || c).join(" ");
-                    return out !== cls ? `class='${out}'` : _m;
-                  });
+                  const mangledHtml = source.replace(
+                    /\bclass="([^"]*)"/g,
+                    (_m, cls) => {
+                      const out = cls.split(/\s+/).filter(Boolean).map((c) => state.mangleMap[c] || c).join(" ");
+                      return out !== cls ? `class="${out}"` : _m;
+                    }
+                  ).replace(
+                    /\bclass='([^']*)'/g,
+                    (_m, cls) => {
+                      const out = cls.split(/\s+/).filter(Boolean).map((c) => state.mangleMap[c] || c).join(" ");
+                      return out !== cls ? `class='${out}'` : _m;
+                    }
+                  );
                   if (mangledHtml !== source) {
                     compilation.updateAsset(
                       file,
@@ -1205,8 +1651,7 @@ ${sourceDirective}`
                   chunk.source = result.css;
                 }
               } catch (e) {
-                if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") {
-                } else {
+                if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") ; else {
                   throw e;
                 }
               }
@@ -1232,13 +1677,13 @@ ${sourceDirective}`
   }));
   return { prePlugin, postPlugin };
 }
-var defaultInstance = createCsszyxPlugins();
-var unplugin = defaultInstance.prePlugin;
-var vitePlugin = (options = {}) => {
+const defaultInstance = createCsszyxPlugins();
+const unplugin = defaultInstance.prePlugin;
+const vitePlugin = (options = {}) => {
   const { prePlugin, postPlugin } = createCsszyxPlugins(options);
   return [prePlugin.vite(options), postPlugin.vite(options)];
 };
-var webpackPlugin = (options = {}) => {
+const webpackPlugin = (options = {}) => {
   const { prePlugin, postPlugin } = createCsszyxPlugins(options);
   return {
     /**
@@ -1251,11 +1696,14 @@ var webpackPlugin = (options = {}) => {
     }
   };
 };
-var rollupPlugin = (options = {}) => {
+const rollupPlugin = (options = {}) => {
   const { prePlugin, postPlugin } = createCsszyxPlugins(options);
-  return [prePlugin.rollup(options), postPlugin.rollup(options)];
+  return [
+    prePlugin.rollup(options),
+    postPlugin.rollup(options)
+  ];
 };
-var esbuildPlugin = (options = {}) => {
+const esbuildPlugin = (options = {}) => {
   const { prePlugin, postPlugin } = createCsszyxPlugins(options);
   return {
     name: "csszyx",
@@ -1271,14 +1719,4 @@ var esbuildPlugin = (options = {}) => {
   };
 };
 
-export {
-  parseThemeBlocks,
-  mergeThemes,
-  hasTokens,
-  mangleCodeClassesSync,
-  unplugin,
-  vitePlugin,
-  webpackPlugin,
-  rollupPlugin,
-  esbuildPlugin
-};
+export { assertNoRSCBoundaryViolation as a, assertNoRSCGraphViolation as b, createRSCModuleRecord as c, findRSCGraphViolation as d, esbuildPlugin as e, findRSCBoundaryViolation as f, hasUseClientDirective as g, hasTokens as h, hasUseServerDirective as i, isRSCServerModule as j, mergeThemes as k, mangleCodeClassesSync as m, parseThemeBlocks as p, rollupPlugin as r, unplugin as u, vitePlugin as v, webpackPlugin as w };