@csszyx/unplugin 0.8.0 → 0.9.0

package/dist/shared/{unplugin.DCv0RtVZ.mjs → unplugin.BEOG6ePC.mjs}

@@ -1,10 +1,14 @@
 import * as fs from 'node:fs';
 import { mkdirSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import * as path from 'node:path';
 import { dirname } from 'node:path';
-import { transformSourceCode, transformOxc, transform } from '@csszyx/compiler';
+import { performance } from 'node:perf_hooks';
+import { fileURLToPath } from 'node:url';
+import { ensureRustTransformAvailable, transformSourceCode, transformRust, transformOxc, transform } from '@csszyx/compiler';
 import { encode, compute_mangle_checksum } from '@csszyx/core';
 import { preprocess as preprocess$1 } from '@csszyx/svelte-adapter';
+import { DEFAULT_BUILD_CONFIG } from '@csszyx/types';
 import { preprocess } from '@csszyx/vue-adapter';
 import { createUnplugin } from 'unplugin';
 import { mangleCSSSync } from '../css-mangler.mjs';
@@ -12,12 +16,16 @@ import { createHash } from 'node:crypto';
 
 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",
@@ -87,6 +95,20 @@ function createRSCModuleRecord(code, id) {
     )
   };
 }
+function deleteRSCModuleRecord(records, id) {
+  const normalized = normalizeModuleId(id);
+  const clean = id.split("?")[0]?.replace(/\\/g, "/") ?? id;
+  const resolved = path.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) {
@@ -110,11 +132,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);
@@ -215,35 +252,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)) {
@@ -257,13 +310,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.realpathSync.native(clean).replace(/\\/g, "/");
+    normalized = fs.realpathSync.native(clean).replace(/\\/g, "/");
   } catch {
-    return path.resolve(clean).replace(/\\/g, "/");
+    normalized = path.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.resolve(path.dirname(importer), source);
   const candidates = [
     base,
@@ -280,11 +345,26 @@ function resolveLocalModule(importer, source) {
   ];
   for (const candidate of candidates) {
     if (fs.existsSync(candidate) && fs.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]*?)\}/);
@@ -303,8 +383,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) {
@@ -703,6 +847,149 @@ function writeThemeDts(opts) {
   writeFileSync(opts.outputPath, content, "utf-8");
 }
 
+const CACHE_SCHEMA_VERSION = 2;
+function resolveTransformCacheDir(rootDir, cacheDir) {
+  return path.resolve(rootDir, cacheDir ?? ".csszyx/cache", "transform");
+}
+function createTransformCacheKey(input) {
+  const inputSha256 = 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: 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.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.dirname(file);
+  const tmp = path.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.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(tmp, JSON.stringify(entry), "utf8");
+    fs.renameSync(tmp, file);
+  } catch {
+    try {
+      fs.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.readFileSync(file, "utf8"));
+      const timestamp = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : 0;
+      if (!Number.isFinite(timestamp) || now - timestamp > options.maxAgeMs) {
+        fs.rmSync(file, { force: true });
+        deleted++;
+      } else {
+        survivors.push({ file, timestamp });
+      }
+    } catch {
+      fs.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.rmSync(survivor.file, { force: true });
+      deleted++;
+    }
+  }
+  return deleted;
+}
+function cacheEntryPath(cacheRoot, key) {
+  return path.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.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path.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";
@@ -753,7 +1040,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 = createRequire(import.meta.url);
+const PLUGIN_VERSION = findPackageVersionFromFile(
+  fileURLToPath(import.meta.url),
+  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;
@@ -796,6 +1113,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.dirname(file);
+  while (true) {
+    const packageJson = path.join(dir, "package.json");
+    try {
+      const parsed = JSON.parse(fs.readFileSync(packageJson, "utf8"));
+      if (typeof parsed.version === "string") {
+        return parsed.version;
+      }
+      return fallback;
+    } catch {
+    }
+    const parent = path.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) => {
@@ -971,8 +1324,20 @@ function mangleCodeClassesSync(code, mangleMap) {
 function createCsszyxPlugins(options = {}) {
   const manglingEnabled = options.production?.mangle !== false;
   const astBudgetOverride = options.build?.astBudgetLimit;
+  const cacheRequested = (options.build?.cache ?? 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 = 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: {},
@@ -1002,19 +1367,84 @@ function createCsszyxPlugins(options = {}) {
   }
   function transformConfiguredSource(source, filename) {
     const compilerOptions = { astBudget: astBudgetOverride };
-    if (parserMode !== "oxc") {
-      return transformSourceCode(source, filename, compilerOptions);
+    const effectiveFilename = normalizeSourceFilename(filename);
+    const cacheRoot = resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
+    if (cacheEnabled) {
+      evictTransformCacheOnce();
     }
-    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;
+    const cacheInput = {
+      pluginVersion: PLUGIN_VERSION,
+      compilerVersion: COMPILER_VERSION,
+      parserMode,
+      producer: parserMode,
+      astBudget: astBudgetOverride,
+      filename: effectiveFilename,
+      source
+    };
+    if (parserMode === "rust") {
+      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;
+      }
     }
+    let result;
+    if (parserMode === "babel") {
+      result = transformSourceCode(source, effectiveFilename, compilerOptions);
+    } else if (parserMode === "rust") {
+      result = transformRust(source, effectiveFilename, compilerOptions);
+    } else {
+      try {
+        result = transformOxc(source, effectiveFilename, compilerOptions);
+      } catch (err) {
+        result = 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) {
@@ -1296,7 +1726,13 @@ ${sourceDirective}`
               transformed = true;
             }
           } else {
+            const transformStarted = performance.now();
             const result = transformConfiguredSource(code, id);
+            traceBenchTiming(
+              "transform-hook",
+              id,
+              performance.now() - transformStarted
+            );
             transformedCode = result.code;
             usesRuntime = result.usesRuntime;
             usesMerge = result.usesMerge;
@@ -1340,11 +1776,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
@@ -1357,18 +1792,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;
           }
@@ -1398,6 +1822,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
@@ -1406,6 +1835,7 @@ ${sourceDirective}`
         compiler.hooks.beforeCompile.tap("csszyx:prescan", () => {
           const root = compiler.context || process.cwd();
           state.rootDir = root;
+          evictTransformCacheOnce();
           if (state.classes.size === 0) {
             prescanAndWriteClasses();
           }
@@ -1429,6 +1859,7 @@ ${sourceDirective}`
         configResolved(config) {
           const root = config.root || process.cwd();
           state.rootDir = root;
+          evictTransformCacheOnce();
           prescanAndWriteClasses();
           runThemeScan(root, options.build?.scanCss);
         },
@@ -1458,7 +1889,13 @@ ${sourceDirective}`
             return;
           }
           try {
+            const hmrTransformStarted = performance.now();
             result = transformConfiguredSource(fileContent, ctx.file);
+            traceBenchTiming(
+              "handle-hot-update",
+              ctx.file,
+              performance.now() - hmrTransformStarted
+            );
           } catch {
             return;
           }
@@ -1719,4 +2156,4 @@ const esbuildPlugin = (options = {}) => {
   };
 };
 
-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 };
+export { assertNoRSCBoundaryViolation as a, assertNoRSCGraphViolation as b, createRSCModuleRecord as c, deleteRSCModuleRecord as d, esbuildPlugin as e, findRSCBoundaryViolation as f, findRSCGraphViolation as g, hasTokens as h, hasUseClientDirective as i, hasUseServerDirective as j, isRSCServerModule as k, mergeThemes as l, mangleCodeClassesSync as m, parseThemeBlocks as p, rollupPlugin as r, unplugin as u, vitePlugin as v, webpackPlugin as w };