@csszyx/unplugin 0.8.0 → 0.9.0

package/dist/shared/{unplugin.BNsv2szs.cjs → unplugin.CL0F6RZa.cjs}

@@ -1,15 +1,20 @@
 'use strict';
 
 const fs = require('node:fs');
+const node_module = require('node:module');
 const path = require('node:path');
+const node_perf_hooks = require('node:perf_hooks');
+const node_url = require('node:url');
 const compiler = require('@csszyx/compiler');
 const core = require('@csszyx/core');
 const svelteAdapter = require('@csszyx/svelte-adapter');
+const types = require('@csszyx/types');
 const vueAdapter = require('@csszyx/vue-adapter');
 const unplugin$1 = require('unplugin');
 const cssMangler = require('../css-mangler.cjs');
 const node_crypto = require('node:crypto');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespaceCompat(e) {
     if (e && typeof e === 'object' && 'default' in e) return e;
     const n = Object.create(null);
@@ -27,12 +32,16 @@ const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
 
 const SERVER_DIRECTIVE_RE = /^['"]use server['"];?$/;
 const CLIENT_DIRECTIVE_RE = /^['"]use client['"];?$/;
-const RUNTIME_MODULES = /* @__PURE__ */ new Set([
+const RUNTIME_HELPER_MODULES = /* @__PURE__ */ new Set([
   "@csszyx/runtime",
   "@csszyx/runtime/lite",
   "csszyx",
   "csszyx/lite"
 ]);
+const CLIENT_RUNTIME_MODULES = /* @__PURE__ */ new Set(["csszyx/browser"]);
+const CLIENT_RUNTIME_MODULE_ROOTS = ["@csszyx/dynamic", "csszyx/dynamic"];
+const normalizedModuleIdCache = /* @__PURE__ */ new Map();
+const resolvedLocalModuleCache = /* @__PURE__ */ new Map();
 const FORBIDDEN_SYMBOLS = /* @__PURE__ */ new Set([
   "_sz",
   "_sz2",
@@ -102,6 +111,20 @@ function createRSCModuleRecord(code, id) {
     )
   };
 }
+function deleteRSCModuleRecord(records, id) {
+  const normalized = normalizeModuleId(id);
+  const clean = id.split("?")[0]?.replace(/\\/g, "/") ?? id;
+  const resolved = path__namespace.resolve(clean).replace(/\\/g, "/");
+  pruneRSCModulePathCaches(/* @__PURE__ */ new Set([normalized, resolved, clean]));
+  let deleted = records.delete(normalized);
+  if (resolved !== normalized) {
+    deleted = records.delete(resolved) || deleted;
+  }
+  if (clean !== normalized && clean !== resolved) {
+    deleted = records.delete(clean) || deleted;
+  }
+  return deleted;
+}
 function findRSCGraphViolation(records) {
   for (const root of records.values()) {
     if (!root.isServer) {
@@ -125,11 +148,26 @@ function assertNoRSCGraphViolation(records) {
   }
   throw new Error(formatRSCViolation(violation));
 }
+const APP_ROUTER_ENTRIES = /* @__PURE__ */ new Set([
+  "page",
+  "layout",
+  "template",
+  "loading",
+  "error",
+  "not-found",
+  "global-error",
+  "default",
+  "route"
+]);
 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
-  );
+  if (!clean.includes("/app/") && !clean.startsWith("app/")) return false;
+  const basename = clean.split("/").pop() ?? "";
+  const dotIdx = basename.indexOf(".");
+  if (dotIdx === -1) return false;
+  const stem = basename.slice(0, dotIdx);
+  const ext = basename.slice(dotIdx + 1);
+  return APP_ROUTER_ENTRIES.has(stem) && /^[cm]?[tj]sx?$/.test(ext);
 }
 function assertNoRSCBoundaryViolation(code, id) {
   const violation = findRSCBoundaryViolation(code, id);
@@ -230,35 +268,51 @@ function skipWhitespaceAndComments(code, start) {
 }
 function findRuntimeImports(code) {
   const imports = [];
-  const staticImportRe = /import\s+(?!type\b)([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+  const scanCode = stripCommentsForImportScan(code);
+  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)) {
+  for (const match of scanCode.matchAll(staticImportRe)) {
     const clause = match[1];
     const source = match[2];
-    if (!RUNTIME_MODULES.has(source)) {
+    if (!isRuntimeImportSource(source)) {
       continue;
     }
-    imports.push({ source, symbols: readImportedSymbols(clause) });
+    imports.push({ source, symbols: readRuntimeImportSymbols(source, clause) });
   }
-  for (const match of code.matchAll(sideEffectImportRe)) {
+  for (const match of scanCode.matchAll(sideEffectImportRe)) {
     const source = match[1];
-    if (RUNTIME_MODULES.has(source)) {
-      imports.push({ source, symbols: [] });
+    if (isRuntimeImportSource(source)) {
+      imports.push({
+        source,
+        symbols: isWholeRuntimeModuleForbidden(source) ? Array.from(FORBIDDEN_SYMBOLS) : []
+      });
     }
   }
-  for (const match of code.matchAll(dynamicImportRe)) {
+  for (const match of scanCode.matchAll(dynamicImportRe)) {
     const source = match[1];
-    if (RUNTIME_MODULES.has(source)) {
+    if (isRuntimeImportSource(source)) {
       imports.push({ source, symbols: Array.from(FORBIDDEN_SYMBOLS) });
     }
   }
   return imports;
 }
+function isRuntimeImportSource(source) {
+  return RUNTIME_HELPER_MODULES.has(source) || source.startsWith("@csszyx/runtime/") || CLIENT_RUNTIME_MODULES.has(source) || CLIENT_RUNTIME_MODULE_ROOTS.some((root) => source === root || source.startsWith(`${root}/`));
+}
+function isWholeRuntimeModuleForbidden(source) {
+  return source.startsWith("@csszyx/runtime/") || CLIENT_RUNTIME_MODULES.has(source) || CLIENT_RUNTIME_MODULE_ROOTS.some((root) => source === root || source.startsWith(`${root}/`));
+}
+function readRuntimeImportSymbols(source, clause) {
+  if (isWholeRuntimeModuleForbidden(source)) {
+    return Array.from(FORBIDDEN_SYMBOLS);
+  }
+  return readImportedSymbols(clause);
+}
 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 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)) {
@@ -272,13 +326,25 @@ function findLocalImportSources(code) {
 }
 function normalizeModuleId(id) {
   const clean = id.split("?")[0] ?? id;
+  const cached = normalizedModuleIdCache.get(clean);
+  if (cached) {
+    return cached;
+  }
+  let normalized;
   try {
-    return fs__namespace.realpathSync.native(clean).replace(/\\/g, "/");
+    normalized = fs__namespace.realpathSync.native(clean).replace(/\\/g, "/");
   } catch {
-    return path__namespace.resolve(clean).replace(/\\/g, "/");
+    normalized = path__namespace.resolve(clean).replace(/\\/g, "/");
   }
+  normalizedModuleIdCache.set(clean, normalized);
+  return normalized;
 }
 function resolveLocalModule(importer, source) {
+  const cacheKey = `${importer}\0${source}`;
+  const cached = resolvedLocalModuleCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
   const base = source.startsWith("/") ? source : path__namespace.resolve(path__namespace.dirname(importer), source);
   const candidates = [
     base,
@@ -295,11 +361,26 @@ function resolveLocalModule(importer, source) {
   ];
   for (const candidate of candidates) {
     if (fs__namespace.existsSync(candidate) && fs__namespace.statSync(candidate).isFile()) {
-      return normalizeModuleId(candidate);
+      const resolved = normalizeModuleId(candidate);
+      resolvedLocalModuleCache.set(cacheKey, resolved);
+      return resolved;
     }
   }
   return null;
 }
+function pruneRSCModulePathCaches(moduleIds) {
+  for (const [key, value] of normalizedModuleIdCache) {
+    const normalizedKey = key.replace(/\\/g, "/");
+    if (moduleIds.has(value) || moduleIds.has(normalizedKey)) {
+      normalizedModuleIdCache.delete(key);
+    }
+  }
+  for (const [key, value] of resolvedLocalModuleCache) {
+    if (moduleIds.has(value)) {
+      resolvedLocalModuleCache.delete(key);
+    }
+  }
+}
 function readImportedSymbols(clause) {
   const symbols = [];
   const named = clause.match(/\{([\s\S]*?)\}/);
@@ -318,8 +399,72 @@ function readImportedSymbols(clause) {
   if (/\*\s+as\s+\w+/.test(clause)) {
     symbols.push(...FORBIDDEN_SYMBOLS);
   }
+  const braceStart = clause.indexOf("{");
+  const braceEnd = clause.indexOf("}", braceStart);
+  const stripped = braceStart !== -1 && braceEnd !== -1 ? clause.slice(0, braceStart) + clause.slice(braceEnd + 1) : clause;
+  const defaultImport = stripped.match(/^\s*([A-Z_$][\w$]*)\s*(?:,|$)/i);
+  const defaultSymbol = defaultImport?.[1];
+  if (defaultSymbol && FORBIDDEN_SYMBOLS.has(defaultSymbol)) {
+    symbols.push(defaultSymbol);
+  }
   return symbols;
 }
+function stripCommentsForImportScan(code) {
+  let out = "";
+  let i = 0;
+  let quote = null;
+  let escaped = false;
+  while (i < code.length) {
+    const ch = code[i];
+    const next = code[i + 1];
+    if (quote) {
+      out += ch;
+      if (escaped) {
+        escaped = false;
+      } else if (ch === "\\") {
+        escaped = true;
+      } else if (ch === quote) {
+        quote = null;
+      }
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      quote = ch;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "/" && next === "/") {
+      out += "  ";
+      i += 2;
+      while (i < code.length && code[i] !== "\n") {
+        out += " ";
+        i++;
+      }
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      out += "  ";
+      i += 2;
+      while (i < code.length) {
+        const blockCh = code[i];
+        const blockNext = code[i + 1];
+        if (blockCh === "*" && blockNext === "/") {
+          out += "  ";
+          i += 2;
+          break;
+        }
+        out += blockCh === "\n" ? "\n" : " ";
+        i++;
+      }
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
 
 const EMPTY_THEME = { colors: [], spacings: [], fonts: [], radii: [], shadows: [] };
 function stripLayerWrappers(css) {
@@ -718,6 +863,149 @@ function writeThemeDts(opts) {
   fs.writeFileSync(opts.outputPath, content, "utf-8");
 }
 
+const CACHE_SCHEMA_VERSION = 2;
+function resolveTransformCacheDir(rootDir, cacheDir) {
+  return path__namespace.resolve(rootDir, cacheDir ?? ".csszyx/cache", "transform");
+}
+function createTransformCacheKey(input) {
+  const inputSha256 = node_crypto.createHash("sha256").update(input.source).digest("hex");
+  const keyMaterial = [
+    `schema=${CACHE_SCHEMA_VERSION}`,
+    `plugin=${input.pluginVersion}`,
+    `compiler=${input.compilerVersion}`,
+    `parser=${input.parserMode}`,
+    `producer=${input.producer}`,
+    `astBudget=${input.astBudget ?? "default"}`,
+    `filename=${input.filename}`,
+    `source=${inputSha256}`
+  ].join("\n");
+  return {
+    key: node_crypto.createHash("sha256").update(keyMaterial).digest("hex").slice(0, 16),
+    inputSha256
+  };
+}
+function readTransformCache(cacheRoot, input, precomputedKey) {
+  const { key, inputSha256 } = precomputedKey ?? createTransformCacheKey(input);
+  const file = cacheEntryPath(cacheRoot, key);
+  let entry;
+  try {
+    entry = JSON.parse(fs__namespace.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (entry.version !== CACHE_SCHEMA_VERSION || entry.pluginVersion !== input.pluginVersion || entry.compilerVersion !== input.compilerVersion || entry.parserMode !== input.parserMode || entry.producer !== input.producer || entry.astBudget !== (input.astBudget ?? null) || entry.filename !== input.filename || entry.inputSha256 !== inputSha256) {
+    return null;
+  }
+  return deserializeResult(entry.result);
+}
+function writeTransformCache(cacheRoot, input, result, precomputedKey) {
+  const { key, inputSha256 } = precomputedKey ?? createTransformCacheKey(input);
+  const file = cacheEntryPath(cacheRoot, key);
+  const dir = path__namespace.dirname(file);
+  const tmp = path__namespace.join(
+    dir,
+    `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`
+  );
+  const entry = {
+    version: CACHE_SCHEMA_VERSION,
+    pluginVersion: input.pluginVersion,
+    compilerVersion: input.compilerVersion,
+    parserMode: input.parserMode,
+    producer: input.producer,
+    astBudget: input.astBudget ?? null,
+    filename: input.filename,
+    inputSha256,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    result: serializeResult(result)
+  };
+  try {
+    fs__namespace.mkdirSync(dir, { recursive: true });
+    fs__namespace.writeFileSync(tmp, JSON.stringify(entry), "utf8");
+    fs__namespace.renameSync(tmp, file);
+  } catch {
+    try {
+      fs__namespace.rmSync(tmp, { force: true });
+    } catch {
+    }
+  }
+}
+function evictOldTransformCacheEntries(cacheRoot, options) {
+  let deleted = 0;
+  const now = options.now ?? Date.now();
+  const survivors = [];
+  for (const file of listJsonFiles(cacheRoot)) {
+    try {
+      const entry = JSON.parse(fs__namespace.readFileSync(file, "utf8"));
+      const timestamp = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : 0;
+      if (!Number.isFinite(timestamp) || now - timestamp > options.maxAgeMs) {
+        fs__namespace.rmSync(file, { force: true });
+        deleted++;
+      } else {
+        survivors.push({ file, timestamp });
+      }
+    } catch {
+      fs__namespace.rmSync(file, { force: true });
+      deleted++;
+    }
+  }
+  const overflow = survivors.length - options.maxEntries ;
+  if (overflow > 0) {
+    survivors.sort((a, b) => a.timestamp - b.timestamp);
+    for (const survivor of survivors.slice(0, overflow)) {
+      fs__namespace.rmSync(survivor.file, { force: true });
+      deleted++;
+    }
+  }
+  return deleted;
+}
+function cacheEntryPath(cacheRoot, key) {
+  return path__namespace.join(cacheRoot, key.slice(0, 2), `${key.slice(2)}.json`);
+}
+function serializeResult(result) {
+  return {
+    code: result.code,
+    transformed: result.transformed,
+    usesRuntime: result.usesRuntime,
+    usesMerge: result.usesMerge,
+    usesColorVar: result.usesColorVar,
+    classes: [...result.classes],
+    rawClassNames: [...result.rawClassNames],
+    diagnostics: [...result.diagnostics],
+    recoveryTokens: [...result.recoveryTokens]
+  };
+}
+function deserializeResult(result) {
+  return {
+    code: result.code,
+    transformed: result.transformed,
+    usesRuntime: result.usesRuntime,
+    usesMerge: result.usesMerge,
+    usesColorVar: result.usesColorVar,
+    classes: new Set(result.classes),
+    rawClassNames: new Set(result.rawClassNames),
+    diagnostics: [...result.diagnostics],
+    recoveryTokens: new Map(result.recoveryTokens)
+  };
+}
+function listJsonFiles(dir) {
+  let entries;
+  try {
+    entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path__namespace.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listJsonFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
 const VIRTUAL_MODULE_ID = "virtual:csszyx/mangle-map";
 const RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
 const VIRTUAL_CHECKSUM_ID = "virtual:csszyx/checksum";
@@ -768,7 +1056,37 @@ function resolveVirtualModule(id) {
 
 const CHECKSUM_PLACEHOLDER = "___CSSZYX_CHECKSUM___";
 const MANGLE_MAP_PLACEHOLDER = "___CSSZYX_MANGLE_MAP___";
+const UNKNOWN_PACKAGE_VERSION = "0.0.0";
+const TRANSFORM_CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+const TRANSFORM_CACHE_MAX_ENTRIES = 1e4;
+const TRANSFORM_MEMORY_CACHE_MAX_ENTRIES = 1e3;
+const DIRECTIVE_PROLOGUE_PREFIX_RE = /^((?:\s|\/\/[^\n]*\n|\/\*(?:[^*]|\*(?!\/))*\*\/)*)(['"]use (?:client|server)['"];?\s*)/;
+const RUNTIME_HELPER_IMPORT_RE = {
+  _sz: /\{[^}]*\b_sz\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/,
+  _szMerge: /\{[^}]*\b_szMerge\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/,
+  __szColorVar: /\{[^}]*\b__szColorVar\b[^}]*\}\s*from\s*['"]@csszyx\/runtime['"]/
+};
 let _hasWarnedTsConfig = false;
+let _hasWarnedTransformCacheVersion = false;
+const requireFromHere = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.CL0F6RZa.cjs', document.baseURI).href)));
+const PLUGIN_VERSION = findPackageVersionFromFile(
+  node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.CL0F6RZa.cjs', document.baseURI).href))),
+  UNKNOWN_PACKAGE_VERSION
+);
+const COMPILER_VERSION = findPackageVersionFromModule("@csszyx/compiler", UNKNOWN_PACKAGE_VERSION);
+const BENCH_TRACE_ENABLED = process.env.CSSZYX_BENCH_TRACE === "1";
+const BENCH_TRACE_FILE = process.env.CSSZYX_BENCH_TRACE_FILE;
+function traceBenchTiming(label, filename, elapsedMs) {
+  if (!BENCH_TRACE_ENABLED) {
+    return;
+  }
+  if (BENCH_TRACE_FILE && !filename.includes(BENCH_TRACE_FILE)) {
+    return;
+  }
+  console.log(
+    `[csszyx:bench] ${label} ${elapsedMs.toFixed(3)}ms ${normalizeSourceFilename(filename)}`
+  );
+}
 function runThemeScan(rootDir, scanCss) {
   if (!scanCss) {
     return;
@@ -811,6 +1129,42 @@ function runThemeScan(rootDir, scanCss) {
     }
   }
 }
+function findPackageVersionFromModule(specifier, fallback) {
+  try {
+    return findPackageVersionFromFile(requireFromHere.resolve(specifier), fallback);
+  } catch {
+    return fallback;
+  }
+}
+function findPackageVersionFromFile(file, fallback) {
+  let dir = path__namespace.dirname(file);
+  while (true) {
+    const packageJson = path__namespace.join(dir, "package.json");
+    try {
+      const parsed = JSON.parse(fs__namespace.readFileSync(packageJson, "utf8"));
+      if (typeof parsed.version === "string") {
+        return parsed.version;
+      }
+      return fallback;
+    } catch {
+    }
+    const parent = path__namespace.dirname(dir);
+    if (parent === dir) {
+      return fallback;
+    }
+    dir = parent;
+  }
+}
+function normalizeSourceFilename(filename) {
+  return filename.replace(/\\/g, "/");
+}
+function insertRuntimeImport(code, importStmt) {
+  const directiveMatch = code.match(DIRECTIVE_PROLOGUE_PREFIX_RE);
+  if (!directiveMatch) {
+    return `${importStmt}${code}`;
+  }
+  return code.replace(directiveMatch[0], `${directiveMatch[1]}${directiveMatch[2]}${importStmt}`);
+}
 function mangleCodeClassesSync(code, mangleMap) {
   function mangleClassString(classString) {
     return classString.split(/\s+/).filter(Boolean).map((cls) => {
@@ -986,8 +1340,20 @@ function mangleCodeClassesSync(code, mangleMap) {
 function createCsszyxPlugins(options = {}) {
   const manglingEnabled = options.production?.mangle !== false;
   const astBudgetOverride = options.build?.astBudgetLimit;
+  const cacheRequested = (options.build?.cache ?? types.DEFAULT_BUILD_CONFIG.cache) !== false;
+  const cacheVersionsKnown = PLUGIN_VERSION !== UNKNOWN_PACKAGE_VERSION && COMPILER_VERSION !== UNKNOWN_PACKAGE_VERSION;
+  const cacheEnabled = cacheRequested && cacheVersionsKnown;
+  if (cacheRequested && !cacheVersionsKnown && !_hasWarnedTransformCacheVersion) {
+    _hasWarnedTransformCacheVersion = true;
+    console.warn(
+      "[csszyx] Transform cache disabled because package versions could not be resolved."
+    );
+  }
   const parserOverride = process.env.CSSZYX_PARSER;
-  const parserMode = parserOverride === "babel" || parserOverride === "oxc" ? parserOverride : options.build?.parser ?? "oxc";
+  const defaultParser = types.DEFAULT_BUILD_CONFIG.parser ?? "rust";
+  const parserMode = parserOverride === "babel" || parserOverride === "oxc" || parserOverride === "rust" ? parserOverride : options.build?.parser ?? defaultParser;
+  let evictedCacheRoot = null;
+  const transformMemoryCache = /* @__PURE__ */ new Map();
   const state = {
     classes: /* @__PURE__ */ new Set(),
     mangleMap: {},
@@ -1017,19 +1383,84 @@ function createCsszyxPlugins(options = {}) {
   }
   function transformConfiguredSource(source, filename) {
     const compilerOptions = { astBudget: astBudgetOverride };
-    if (parserMode !== "oxc") {
-      return compiler.transformSourceCode(source, filename, compilerOptions);
+    const effectiveFilename = normalizeSourceFilename(filename);
+    const cacheRoot = resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
+    if (cacheEnabled) {
+      evictTransformCacheOnce();
+    }
+    const cacheInput = {
+      pluginVersion: PLUGIN_VERSION,
+      compilerVersion: COMPILER_VERSION,
+      parserMode,
+      producer: parserMode,
+      astBudget: astBudgetOverride,
+      filename: effectiveFilename,
+      source
+    };
+    if (parserMode === "rust") {
+      compiler.ensureRustTransformAvailable();
+    }
+    const cacheKey = cacheEnabled ? createTransformCacheKey(cacheInput) : null;
+    if (cacheEnabled && cacheKey) {
+      const memoryCached = transformMemoryCache.get(cacheKey.key);
+      if (memoryCached) {
+        transformMemoryCache.delete(cacheKey.key);
+        transformMemoryCache.set(cacheKey.key, memoryCached);
+        return memoryCached;
+      }
+      const cached = readTransformCache(cacheRoot, cacheInput, cacheKey);
+      if (cached) {
+        rememberTransformCacheEntry(cacheKey.key, cached);
+        return cached;
+      }
     }
-    try {
-      return compiler.transformOxc(source, filename, compilerOptions);
-    } catch (err) {
-      const result = compiler.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;
+    let result;
+    if (parserMode === "babel") {
+      result = compiler.transformSourceCode(source, effectiveFilename, compilerOptions);
+    } else if (parserMode === "rust") {
+      result = compiler.transformRust(source, effectiveFilename, compilerOptions);
+    } else {
+      try {
+        result = compiler.transformOxc(source, effectiveFilename, compilerOptions);
+      } catch (err) {
+        result = compiler.transformSourceCode(source, effectiveFilename, compilerOptions);
+        const reason = err instanceof Error ? err.message : String(err);
+        result.diagnostics.push(
+          `[csszyx] oxc parser fell back to Babel for ${effectiveFilename}: ${reason}`
+        );
+        return result;
+      }
     }
+    if (cacheEnabled && cacheKey) {
+      writeTransformCache(cacheRoot, cacheInput, result, cacheKey);
+      rememberTransformCacheEntry(cacheKey.key, result);
+    }
+    return result;
+  }
+  function rememberTransformCacheEntry(key, result) {
+    transformMemoryCache.delete(key);
+    transformMemoryCache.set(key, result);
+    if (transformMemoryCache.size <= TRANSFORM_MEMORY_CACHE_MAX_ENTRIES) {
+      return;
+    }
+    const oldest = transformMemoryCache.keys().next().value;
+    if (oldest) {
+      transformMemoryCache.delete(oldest);
+    }
+  }
+  function evictTransformCacheOnce() {
+    if (!cacheEnabled) {
+      return;
+    }
+    const cacheRoot = resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
+    if (evictedCacheRoot === cacheRoot) {
+      return;
+    }
+    evictedCacheRoot = cacheRoot;
+    evictOldTransformCacheEntries(cacheRoot, {
+      maxAgeMs: TRANSFORM_CACHE_MAX_AGE_MS,
+      maxEntries: TRANSFORM_CACHE_MAX_ENTRIES
+    });
   }
   function writeSafelistFile(classes) {
     if (classes.size === 0) {
@@ -1311,7 +1742,13 @@ ${sourceDirective}`
               transformed = true;
             }
           } else {
+            const transformStarted = node_perf_hooks.performance.now();
             const result = transformConfiguredSource(code, id);
+            traceBenchTiming(
+              "transform-hook",
+              id,
+              node_perf_hooks.performance.now() - transformStarted
+            );
             transformedCode = result.code;
             usesRuntime = result.usesRuntime;
             usesMerge = result.usesMerge;
@@ -1355,11 +1792,10 @@ ${sourceDirective}`
           if (usesColorVar) {
             imports.push("__szColorVar");
           }
-          const needed = imports.filter(
-            (name) => !new RegExp(
-              `\\{[^}]*\\b${name}\\b[^}]*\\}\\s*from\\s*['"]@csszyx/runtime['"]`
-            ).test(transformedCode)
-          );
+          const hasRuntimeImport = imports.length > 0 && transformedCode.includes("@csszyx/runtime");
+          const needed = hasRuntimeImport ? imports.filter(
+            (name) => !RUNTIME_HELPER_IMPORT_RE[name]?.test(transformedCode)
+          ) : imports;
           if (needed.length > 0) {
             const existingImport = transformedCode.match(
               /^(import\s*\{[^}]*)\}\s*from\s*'@csszyx\/runtime'/m
@@ -1372,18 +1808,7 @@ ${sourceDirective}`
             } 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}`;
-              }
+              transformedCode = insertRuntimeImport(transformedCode, importStmt);
             }
             transformed = true;
           }
@@ -1413,6 +1838,11 @@ ${sourceDirective}`
           globalThis.__csszyx_ssr_mangle_map = state.mangleMap;
         }
       },
+      watchChange(id, change) {
+        if (change.event === "delete") {
+          deleteRSCModuleRecord(state.rscModules, id);
+        }
+      },
       /**
        * Webpack hook: pre-scans source files before compilation for Tailwind class discovery.
        * @param compiler - the Webpack compiler instance
@@ -1421,6 +1851,7 @@ ${sourceDirective}`
         compiler.hooks.beforeCompile.tap("csszyx:prescan", () => {
           const root = compiler.context || process.cwd();
           state.rootDir = root;
+          evictTransformCacheOnce();
           if (state.classes.size === 0) {
             prescanAndWriteClasses();
           }
@@ -1444,6 +1875,7 @@ ${sourceDirective}`
         configResolved(config) {
           const root = config.root || process.cwd();
           state.rootDir = root;
+          evictTransformCacheOnce();
           prescanAndWriteClasses();
           runThemeScan(root, options.build?.scanCss);
         },
@@ -1473,7 +1905,13 @@ ${sourceDirective}`
             return;
           }
           try {
+            const hmrTransformStarted = node_perf_hooks.performance.now();
             result = transformConfiguredSource(fileContent, ctx.file);
+            traceBenchTiming(
+              "handle-hot-update",
+              ctx.file,
+              node_perf_hooks.performance.now() - hmrTransformStarted
+            );
           } catch {
             return;
           }
@@ -1737,6 +2175,7 @@ const esbuildPlugin = (options = {}) => {
 exports.assertNoRSCBoundaryViolation = assertNoRSCBoundaryViolation;
 exports.assertNoRSCGraphViolation = assertNoRSCGraphViolation;
 exports.createRSCModuleRecord = createRSCModuleRecord;
+exports.deleteRSCModuleRecord = deleteRSCModuleRecord;
 exports.esbuildPlugin = esbuildPlugin;
 exports.findRSCBoundaryViolation = findRSCBoundaryViolation;
 exports.findRSCGraphViolation = findRSCGraphViolation;