@csszyx/unplugin 0.9.0 → 0.9.2

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

@@ -5,14 +5,441 @@ import * as path from 'node:path';
 import { dirname } from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { fileURLToPath } from 'node:url';
-import { ensureRustTransformAvailable, transformSourceCode, transformRust, transformOxc, transform } from '@csszyx/compiler';
+import { scanGlobalVarUsages, ensureRustTransformAvailable, transformSourceCode, transformRust, transformOxc, transformRustBatch, 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 { isTailwindReservedCustomProperty, CSSZYX_GLOBAL_ALIAS_PREFIX, isCsszyxGlobalAliasCustomProperty, DEFAULT_BUILD_CONFIG, validateGlobalVarMangleConfig } from '@csszyx/types';
 import { preprocess } from '@csszyx/vue-adapter';
 import { createUnplugin } from 'unplugin';
 import { mangleCSSSync } from '../css-mangler.mjs';
 import { createHash } from 'node:crypto';
+import { r as resolveTransformCacheDir, c as createTransformCacheKey, a as readTransformCache, w as writeTransformCache, e as evictOldTransformCacheEntries } from './unplugin.BceVw1eW.mjs';
+import postcss from 'postcss';
+import valueParser from 'postcss-value-parser';
+
+function resolveGlobalVarScanCacheDir(cacheDir) {
+  return path.join(cacheDir, "global-vars");
+}
+function createGlobalVarScanCacheKey(input) {
+  const hash = createHash("sha256");
+  hash.update(input.filePath);
+  hash.update("\0");
+  hash.update(String(input.mtimeMs));
+  hash.update("\0");
+  hash.update(createHash("sha256").update(input.css).digest("hex"));
+  return hash.digest("hex");
+}
+function readGlobalVarScanCache(cacheDir, key) {
+  try {
+    const raw = fs.readFileSync(globalVarScanCacheFile(cacheDir, key), "utf8");
+    const entry = JSON.parse(raw);
+    if (entry.key !== key || !entry.result) {
+      return null;
+    }
+    return entry.result;
+  } catch {
+    return null;
+  }
+}
+function writeGlobalVarScanCache(cacheDir, key, result) {
+  try {
+    fs.mkdirSync(cacheDir, { recursive: true });
+    fs.writeFileSync(
+      globalVarScanCacheFile(cacheDir, key),
+      JSON.stringify({ key, result }),
+      "utf8"
+    );
+  } catch {
+  }
+}
+function globalVarScanCacheFile(cacheDir, key) {
+  return path.join(cacheDir, `${key}.json`);
+}
+
+const DEFAULT_SCOPE_ID = "<root>";
+function isInsideThemeAtRule(node) {
+  let current = node.parent;
+  while (current && current.type !== "root") {
+    if (current.type === "atrule" && current.name === "theme") {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function hasSiblingDeclaration(decl, prop) {
+  const parent = decl.parent;
+  if (!parent || !("nodes" in parent)) {
+    return false;
+  }
+  return parent.nodes.some((node) => node.type === "decl" && node.prop === prop);
+}
+function nodeLocation(node, filePath) {
+  return {
+    filePath,
+    line: node.source?.start?.line ?? 1,
+    column: node.source?.start?.column ?? 1
+  };
+}
+function buildScopeId(node) {
+  const parts = [];
+  let current = node.parent;
+  while (current && current.type !== "root") {
+    if (current.type === "rule") {
+      parts.push(`rule:${current.selector}`);
+    } else if (current.type === "atrule") {
+      const atRule = current;
+      parts.push(`@${atRule.name} ${atRule.params}`.trim());
+    }
+    current = current.parent;
+  }
+  return parts.reverse().join(" > ") || DEFAULT_SCOPE_ID;
+}
+
+const VAR_REFERENCE_RE = /var\(\s*(--[\w-]+)/g;
+function scanGlobalVarCss(css, options = {}) {
+  const filePath = options.filePath ?? "<inline>";
+  const root = postcss.parse(css, { from: filePath });
+  const registered = collectRegisteredProperties(root);
+  const definitions = [];
+  const references = [];
+  root.walkDecls((decl) => {
+    const scopeId = buildScopeId(decl);
+    const tailwindOwned = isInsideThemeAtRule(decl);
+    if (decl.prop.startsWith("--")) {
+      definitions.push({
+        name: decl.prop,
+        scopeId,
+        tailwindOwned,
+        registered: registered.has(decl.prop),
+        ...nodeLocation(decl, filePath)
+      });
+    }
+    for (const name of extractVarReferences(decl.value)) {
+      references.push({
+        name,
+        scopeId,
+        owner: decl.prop,
+        tailwindOwned,
+        ...nodeLocation(decl, filePath)
+      });
+    }
+  });
+  root.walkAtRules((atRule) => {
+    if (atRule.name === "property") {
+      return;
+    }
+    for (const name of extractVarReferences(atRule.params)) {
+      references.push({
+        name,
+        scopeId: buildScopeId(atRule),
+        owner: `@${atRule.name}`,
+        tailwindOwned: isInsideThemeAtRule(atRule),
+        ...nodeLocation(atRule, filePath)
+      });
+    }
+  });
+  return {
+    filePath,
+    definitions,
+    references,
+    registered: [...registered].sort(),
+    thirdParty: isThirdPartyCssPath(filePath)
+  };
+}
+function collectRegisteredProperties(root) {
+  const registered = /* @__PURE__ */ new Set();
+  root.walkAtRules("property", (atRule) => {
+    const name = atRule.params.trim();
+    if (name.startsWith("--")) {
+      registered.add(name);
+    }
+  });
+  return registered;
+}
+function extractVarReferences(value) {
+  const references = /* @__PURE__ */ new Set();
+  for (const match of value.matchAll(VAR_REFERENCE_RE)) {
+    references.add(match[1]);
+  }
+  return [...references].sort();
+}
+function isThirdPartyCssPath(filePath) {
+  return filePath.split(/[\\/]/).includes("node_modules");
+}
+
+function planGlobalVarAliases(input) {
+  const definitions = flattenDefinitions(input.scans);
+  const candidates = collectCandidates(input, definitions);
+  const aliasPrefix = input.aliasPrefix ?? CSSZYX_GLOBAL_ALIAS_PREFIX;
+  const diagnostics = validateCandidates(
+    candidates,
+    definitions,
+    input.reserved ?? [],
+    aliasPrefix
+  );
+  if (diagnostics.length > 0) {
+    return { entries: [], aliases: /* @__PURE__ */ new Map(), diagnostics };
+  }
+  const definitionNames = new Set(definitions.keys());
+  const entries = [];
+  for (const [index, original] of candidates.entries()) {
+    const alias = `${aliasPrefix}${encode(index)}`;
+    if (definitionNames.has(alias)) {
+      return {
+        entries: [],
+        aliases: /* @__PURE__ */ new Map(),
+        diagnostics: [
+          {
+            code: "alias-collision",
+            severity: "error",
+            name: alias,
+            message: `Generated alias ${alias} collides with an existing CSS custom property.`,
+            location: definitions.get(alias)?.[0]
+          }
+        ]
+      };
+    }
+    entries.push({
+      original,
+      alias,
+      scopes: [
+        ...new Set((definitions.get(original) ?? []).map((definition) => definition.scopeId))
+      ].sort()
+    });
+  }
+  return {
+    entries,
+    aliases: new Map(entries.map((entry) => [entry.original, entry.alias])),
+    diagnostics: []
+  };
+}
+function isTailwindReservedGlobalVar(name) {
+  return isTailwindReservedCustomProperty(name);
+}
+function flattenDefinitions(scans) {
+  const definitions = /* @__PURE__ */ new Map();
+  for (const scan of scans) {
+    for (const definition of scan.definitions) {
+      const existing = definitions.get(definition.name) ?? [];
+      existing.push(definition);
+      definitions.set(definition.name, existing);
+    }
+  }
+  return definitions;
+}
+function collectCandidates(input, definitions) {
+  const candidates = new Set(input.tokens ?? []);
+  const autoPrefix = input.autoPrefix ?? "";
+  if (autoPrefix !== "") {
+    for (const name of definitions.keys()) {
+      if (name.startsWith(autoPrefix)) {
+        candidates.add(name);
+      }
+    }
+  }
+  return [...candidates].sort();
+}
+function validateCandidates(candidates, definitions, reserved, aliasPrefix) {
+  const diagnostics = [];
+  for (const name of candidates) {
+    const tokenDefinitions = definitions.get(name) ?? [];
+    if (tokenDefinitions.length === 0) {
+      diagnostics.push({
+        code: "missing-definition",
+        severity: "error",
+        name,
+        message: `Global variable token ${name} is not defined in scanned CSS.`
+      });
+      continue;
+    }
+    if (isTailwindReservedGlobalVar(name) || matchesUserReserved(name, reserved)) {
+      diagnostics.push({
+        code: "tailwind-reserved",
+        severity: "error",
+        name,
+        message: `Global variable token ${name} is reserved and cannot be aliased.`,
+        location: tokenDefinitions[0]
+      });
+    }
+    if (isCsszyxGlobalAliasCustomProperty(name, aliasPrefix)) {
+      diagnostics.push({
+        code: "tailwind-reserved",
+        severity: "error",
+        name,
+        message: `Global variable token ${name} uses csszyx reserved namespace ${aliasPrefix}* and cannot be aliased.`,
+        location: tokenDefinitions[0]
+      });
+    }
+    const tailwindDefinition = tokenDefinitions.find((definition) => definition.tailwindOwned);
+    if (tailwindDefinition) {
+      diagnostics.push({
+        code: "tailwind-owned",
+        severity: "error",
+        name,
+        message: `Global variable token ${name} is declared inside @theme and cannot be aliased.`,
+        location: tailwindDefinition
+      });
+    }
+    const registeredDefinition = tokenDefinitions.find((definition) => definition.registered);
+    if (registeredDefinition) {
+      diagnostics.push({
+        code: "registered-property",
+        severity: "error",
+        name,
+        message: `Registered custom property ${name} is not aliasable in Phase H v1.`,
+        location: registeredDefinition
+      });
+    }
+  }
+  return diagnostics;
+}
+function matchesUserReserved(name, reserved) {
+  return reserved.some((pattern) => {
+    if (pattern.endsWith("*")) {
+      return name.startsWith(pattern.slice(0, -1));
+    }
+    return name === pattern;
+  });
+}
+
+function rewriteGlobalVarCssAliases(options) {
+  if (options.plan.diagnostics.length > 0 || options.plan.entries.length === 0) {
+    return {
+      css: options.css,
+      aliasDeclarations: 0,
+      rewrittenReferences: 0,
+      diagnostics: options.plan.diagnostics
+    };
+  }
+  const root = postcss.parse(options.css, { from: options.filePath });
+  const aliasNames = new Set(options.plan.entries.map((entry) => entry.alias));
+  const referenceAliases = new Map(
+    options.plan.entries.filter((entry) => canRewriteGlobalVarReferences(entry)).map((entry) => [entry.original, entry.alias])
+  );
+  let aliasDeclarations = 0;
+  let rewrittenReferences = 0;
+  root.walkDecls((decl) => {
+    if (isInsideThemeAtRule(decl)) {
+      return;
+    }
+    const alias = options.plan.aliases.get(decl.prop);
+    if (alias && !hasSiblingDeclaration(decl, alias)) {
+      decl.cloneAfter({ prop: alias, value: `var(${decl.prop})` });
+      aliasDeclarations++;
+    }
+    if (options.plan.aliases.has(decl.prop) || aliasNames.has(decl.prop)) {
+      return;
+    }
+    const rewrite = rewriteGlobalVarValue(decl.value, referenceAliases);
+    if (rewrite.count > 0) {
+      decl.value = rewrite.value;
+      rewrittenReferences += rewrite.count;
+    }
+  });
+  return {
+    css: root.toString(),
+    aliasDeclarations,
+    rewrittenReferences,
+    diagnostics: []
+  };
+}
+function canRewriteGlobalVarReferences(entry) {
+  return entry.scopes.some(isInheritedGlobalAliasScope);
+}
+function isInheritedGlobalAliasScope(scope) {
+  const leaf = scope.split(" > ").at(-1);
+  if (!leaf?.startsWith("rule:")) {
+    return false;
+  }
+  const selector = leaf.slice("rule:".length);
+  return selector.split(",").some((part) => {
+    const normalized = part.trim();
+    return normalized === ":root" || normalized === "html" || normalized === "body";
+  });
+}
+function rewriteGlobalVarValue(value, aliases) {
+  const parsed = valueParser(value);
+  let count = 0;
+  parsed.walk((node) => {
+    if (node.type !== "function" || node.value.toLowerCase() !== "var") {
+      return;
+    }
+    const firstArgument = node.nodes.find((child) => child.type !== "space");
+    if (!firstArgument || firstArgument.type !== "word") {
+      return;
+    }
+    const alias = aliases.get(firstArgument.value);
+    if (!alias) {
+      return;
+    }
+    firstArgument.value = alias;
+    count++;
+  });
+  return { value: count > 0 ? valueParser.stringify(parsed.nodes) : value, count };
+}
+
+function validateGlobalVarAliasInputs(options) {
+  const scans = options.cssFiles.map(
+    (file) => scanCssSourceWithOptionalCache(file, options.cacheDir)
+  );
+  const plan = planGlobalVarAliases({
+    scans,
+    tokens: options.tokens,
+    autoPrefix: options.autoPrefix,
+    aliasPrefix: options.aliasPrefix,
+    reserved: options.reserved
+  });
+  if (plan.diagnostics.length > 0 || plan.entries.length === 0) {
+    return { scans, plan, usageDiagnostics: [] };
+  }
+  const candidateTokens = plan.entries.map((entry) => entry.original);
+  const usageDiagnostics = (options.sourceFiles ?? []).flatMap(
+    (file) => scanGlobalVarUsages(file.code, file.filePath, { tokens: candidateTokens })
+  );
+  return { scans, plan, usageDiagnostics };
+}
+function createGlobalVarAliasValidationOptions(input) {
+  return {
+    cssFiles: input.cssAssets.filter((asset) => /\.css(?:$|\?)/.test(asset.fileName)).map((asset) => ({
+      filePath: normalizeBuildAssetPath(input.rootDir, asset.fileName),
+      css: cssAssetSourceToString(asset.source),
+      mtimeMs: asset.mtimeMs
+    })),
+    sourceFiles: input.sourceFiles ?? [],
+    tokens: input.tokens,
+    autoPrefix: input.autoPrefix,
+    aliasPrefix: input.aliasPrefix,
+    reserved: input.reserved,
+    cacheDir: input.cacheDir
+  };
+}
+function scanCssSourceWithOptionalCache(file, cacheDir) {
+  if (cacheDir === void 0 || file.mtimeMs === void 0) {
+    return scanGlobalVarCss(file.css, { filePath: file.filePath });
+  }
+  const key = createGlobalVarScanCacheKey({
+    filePath: file.filePath,
+    css: file.css,
+    mtimeMs: file.mtimeMs
+  });
+  const cached = readGlobalVarScanCache(cacheDir, key);
+  if (cached) {
+    return cached;
+  }
+  const result = scanGlobalVarCss(file.css, { filePath: file.filePath });
+  writeGlobalVarScanCache(cacheDir, key, result);
+  return result;
+}
+function normalizeBuildAssetPath(rootDir, fileName) {
+  return (path.isAbsolute(fileName) ? fileName : path.join(rootDir, fileName)).replace(
+    /\\/g,
+    "/"
+  );
+}
+function cssAssetSourceToString(source) {
+  return typeof source === "string" ? source : Buffer.from(source).toString("utf8");
+}
 
 const SERVER_DIRECTIVE_RE = /^['"]use server['"];?$/;
 const CLIENT_DIRECTIVE_RE = /^['"]use client['"];?$/;
@@ -253,24 +680,18 @@ function skipWhitespaceAndComments(code, start) {
 function findRuntimeImports(code) {
   const imports = [];
   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 scanCode.matchAll(staticImportRe)) {
-    const clause = match[1];
-    const source = match[2];
+  for (const { clause, source } of findStaticImports(scanCode)) {
     if (!isRuntimeImportSource(source)) {
       continue;
     }
-    imports.push({ source, symbols: readRuntimeImportSymbols(source, clause) });
-  }
-  for (const match of scanCode.matchAll(sideEffectImportRe)) {
-    const source = match[1];
-    if (isRuntimeImportSource(source)) {
+    if (clause === null) {
       imports.push({
         source,
         symbols: isWholeRuntimeModuleForbidden(source) ? Array.from(FORBIDDEN_SYMBOLS) : []
       });
+    } else {
+      imports.push({ source, symbols: readRuntimeImportSymbols(source, clause) });
     }
   }
   for (const match of scanCode.matchAll(dynamicImportRe)) {
@@ -281,6 +702,98 @@ function findRuntimeImports(code) {
   }
   return imports;
 }
+function findStaticImports(code) {
+  const imports = [];
+  let cursor = 0;
+  while (cursor < code.length) {
+    const importStart = code.indexOf("import", cursor);
+    if (importStart === -1) {
+      break;
+    }
+    cursor = importStart + 6;
+    if (importStart > 0 && isIdentifierPart(code.charCodeAt(importStart - 1)) || isIdentifierPart(code.charCodeAt(cursor))) {
+      continue;
+    }
+    let position = skipAsciiWhitespace(code, cursor);
+    const opener = code.charAt(position);
+    if (opener === "(") {
+      continue;
+    }
+    if (opener === '"' || opener === "'") {
+      const literal2 = readQuotedString(code, position);
+      if (literal2) {
+        imports.push({ clause: null, source: literal2.value });
+        cursor = literal2.end;
+      }
+      continue;
+    }
+    const clauseStart = position;
+    let fromStart = -1;
+    while (position < code.length) {
+      if (code.startsWith("from", position) && (position === clauseStart || !isIdentifierPart(code.charCodeAt(position - 1))) && !isIdentifierPart(code.charCodeAt(position + 4))) {
+        fromStart = position;
+        break;
+      }
+      if (code.charAt(position) === ";") {
+        break;
+      }
+      position += 1;
+    }
+    if (fromStart === -1) {
+      continue;
+    }
+    const clause = code.slice(clauseStart, fromStart).trim();
+    if (splitAsciiWhitespace(clause)[0] === "type") {
+      cursor = fromStart + 4;
+      continue;
+    }
+    position = skipAsciiWhitespace(code, fromStart + 4);
+    const literal = readQuotedString(code, position);
+    if (literal) {
+      imports.push({ clause, source: literal.value });
+      cursor = literal.end;
+    }
+  }
+  return imports;
+}
+function readQuotedString(code, start) {
+  const quote = code.charAt(start);
+  if (quote !== '"' && quote !== "'") {
+    return null;
+  }
+  let value = "";
+  for (let index = start + 1; index < code.length; index += 1) {
+    const char = code.charAt(index);
+    if (char === "\\") {
+      if (index + 1 >= code.length) {
+        return null;
+      }
+      value += code.charAt(index + 1);
+      index += 1;
+    } else if (char === quote) {
+      return { end: index + 1, value };
+    } else if (char === "\n" || char === "\r") {
+      return null;
+    } else {
+      value += char;
+    }
+  }
+  return null;
+}
+function skipAsciiWhitespace(code, start) {
+  let index = start;
+  while (index < code.length) {
+    const charCode = code.charCodeAt(index);
+    if (charCode !== 9 && charCode !== 10 && charCode !== 13 && charCode !== 32) {
+      break;
+    }
+    index += 1;
+  }
+  return index;
+}
+function isIdentifierPart(code) {
+  return isIdentifierStart(code) || code >= 48 && code <= 57;
+}
 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}/`));
 }
@@ -344,10 +857,17 @@ function resolveLocalModule(importer, source) {
     path.join(base, "index.js")
   ];
   for (const candidate of candidates) {
-    if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+    try {
+      if (!fs.statSync(candidate).isFile()) {
+        continue;
+      }
       const resolved = normalizeModuleId(candidate);
       resolvedLocalModuleCache.set(cacheKey, resolved);
       return resolved;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
     }
   }
   return null;
@@ -367,32 +887,67 @@ function pruneRSCModulePathCaches(moduleIds) {
 }
 function readImportedSymbols(clause) {
   const symbols = [];
-  const named = clause.match(/\{([\s\S]*?)\}/);
-  if (named) {
-    for (const part of named[1].split(",")) {
+  const openBrace = clause.indexOf("{");
+  const closeBrace = openBrace === -1 ? -1 : clause.indexOf("}", openBrace);
+  if (openBrace !== -1 && closeBrace !== -1) {
+    const namedPart = clause.slice(openBrace + 1, closeBrace);
+    for (const part of namedPart.split(",")) {
       const trimmed = part.trim();
       if (!trimmed || trimmed.startsWith("type ")) {
         continue;
       }
-      const sourceName = trimmed.replace(/^type\s+/, "").split(/\s+as\s+/)[0]?.trim();
+      const sourceName = trimmed.replace(/^type[ \t]+/, "").split(/[ \t]+as[ \t]+/)[0]?.trim();
       if (sourceName) {
         symbols.push(sourceName);
       }
     }
   }
-  if (/\*\s+as\s+\w+/.test(clause)) {
+  const namespaceParts = splitAsciiWhitespace(clause);
+  if (namespaceParts.length >= 3 && namespaceParts[0] === "*" && namespaceParts[1] === "as" && isIdentifier(namespaceParts[2] ?? "")) {
     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];
+  const defaultCandidate = stripped.trimStart().split(",", 1)[0]?.trim() ?? "";
+  const defaultSymbol = isIdentifier(defaultCandidate) ? defaultCandidate : void 0;
   if (defaultSymbol && FORBIDDEN_SYMBOLS.has(defaultSymbol)) {
     symbols.push(defaultSymbol);
   }
   return symbols;
 }
+function isIdentifier(value) {
+  if (value.length === 0 || !isIdentifierStart(value.charCodeAt(0))) {
+    return false;
+  }
+  for (let index = 1; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (!isIdentifierStart(code) && (code < 48 || code > 57)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isIdentifierStart(code) {
+  return code === 36 || code === 95 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function splitAsciiWhitespace(value) {
+  const parts = [];
+  let start = -1;
+  for (let index = 0; index <= value.length; index += 1) {
+    const code = index < value.length ? value.charCodeAt(index) : 32;
+    const whitespace = code === 9 || code === 10 || code === 13 || code === 32;
+    if (whitespace) {
+      if (start !== -1) {
+        parts.push(value.slice(start, index));
+        start = -1;
+      }
+    } else if (start === -1) {
+      start = index;
+    }
+  }
+  return parts;
+}
 function stripCommentsForImportScan(code) {
   let out = "";
   let i = 0;
@@ -704,6 +1259,10 @@ function expandFilePatterns(rootDir, patterns) {
   return Array.from(files).sort();
 }
 
+function safeJsonForScriptTag(value, prettyPrint = false) {
+  const json = prettyPrint ? JSON.stringify(value, null, 2) : JSON.stringify(value);
+  return json.replace(/</g, "\\u003C").replace(/>/g, "\\u003E").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
 function injectChecksum(html, checksum, minify = false) {
   const attrName = minify ? "data-sz-cs" : "data-sz-checksum";
   const htmlTagPattern = /<html([^>]*)>/i;
@@ -716,10 +1275,18 @@ function injectChecksum(html, checksum, minify = false) {
   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 {
+    prettyPrint = false,
+    varMangleMap = {},
+    globalVarAliasPrefix = CSSZYX_GLOBAL_ALIAS_PREFIX
+  } = options;
+  const checksumMap = createHydrationMangleMap(mangleMap, varMangleMap);
+  const jsonContent = safeJsonForScriptTag(checksumMap, prettyPrint);
+  const classMapContent = safeJsonForScriptTag(mangleMap);
+  const varMapContent = safeJsonForScriptTag(varMangleMap);
   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 prefixContent = safeJsonForScriptTag(globalVarAliasPrefix);
+  const debugScript = `<script>(function(){var m=${classMapContent};var vm=${varMapContent};var gp=${prefixContent};var r={};var vr={};for(var k in m)r[m[k]]=k;for(var vk in vm){var vv=vm[vk];var vs=Array.isArray(vv)?vv:[vv];for(var vi=0;vi<vs.length;vi++)(vr[vs[vi]]||(vr[vs[vi]]=[])).push(vk)}var cs=document.documentElement.getAttribute("data-sz-checksum")||"";window.__csszyx={mangleMap:m,varMangleMap:vm,checksum:cs,decode:function(c){return r[c]},encode:function(c){return m[c]},decodeVar:function(v){return vr[v]||[]},encodeVar:function(v){return vm[v]},decodeGlobalVar:function(v){var a=vr[v]||[];return v.indexOf(gp)===0?a[0]:void 0},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()<\/script>`;
   const combined = `${scriptTag}
 ${debugScript}`;
   if (html.includes("</head>")) {
@@ -731,9 +1298,9 @@ ${debugScript}`;
   }
   return html + combined;
 }
-function injectMangleMapAttribute(html, mangleMap, minify = false) {
+function injectMangleMapAttribute(html, mangleMap, minify = false, varMangleMap = {}) {
   const attrName = minify ? "data-sz-m" : "data-sz-map";
-  const jsonContent = JSON.stringify(mangleMap);
+  const jsonContent = JSON.stringify(createHydrationMangleMap(mangleMap, varMangleMap));
   const htmlTagPattern = /<html([^>]*)>/i;
   const match = html.match(htmlTagPattern);
   if (!match) {
@@ -748,11 +1315,11 @@ function injectHydrationData(html, mangleMap, checksum, options = {}) {
   let result = html;
   result = injectChecksum(result, checksum, minify);
   if (mode === "inline") {
-    result = injectMangleMapAttribute(result, mangleMap, minify);
+    result = injectMangleMapAttribute(result, mangleMap, minify, options.varMangleMap);
   } else if (mode === "script") {
     result = injectMangleMapScript(result, mangleMap, options);
   } else if (mode === "both") {
-    result = injectMangleMapAttribute(result, mangleMap, minify);
+    result = injectMangleMapAttribute(result, mangleMap, minify, options.varMangleMap);
     result = injectMangleMapScript(result, mangleMap, options);
   }
   return result;
@@ -760,6 +1327,25 @@ function injectHydrationData(html, mangleMap, checksum, options = {}) {
 function transformIndexHtml(html, mangleMap, checksum, options = {}) {
   return injectHydrationData(html, mangleMap, checksum, options);
 }
+function createHydrationMangleMap(classMap, varMap = {}) {
+  if (Object.keys(varMap).length === 0) {
+    return classMap;
+  }
+  const payload = {};
+  for (const [key, value] of Object.entries(classMap)) {
+    payload[`class:${key}`] = value;
+  }
+  for (const [key, value] of Object.entries(varMap)) {
+    if (Array.isArray(value)) {
+      for (const mangled of value) {
+        payload[`var:${key}:${mangled}`] = mangled;
+      }
+    } else {
+      payload[`var:${key}`] = value;
+    }
+  }
+  return payload;
+}
 function buildRecoveryManifest(tokens, options) {
   const stripped = options.production === true;
   const strippedDevOnlyPaths = [];
@@ -801,6 +1387,36 @@ function injectRecoveryManifest(html, manifest) {
   return html + scriptTag;
 }
 
+const DEFAULT_MAX_ATTEMPTS = 3;
+const NODE_FS = {
+  openSync: fs.openSync,
+  fstatSync: (fd, options) => fs.fstatSync(fd, options),
+  readFileSync: (fd, encoding) => fs.readFileSync(fd, encoding),
+  closeSync: fs.closeSync
+};
+function readStableTextFileSnapshotSync(file, maxAttempts = DEFAULT_MAX_ATTEMPTS, fsApi = NODE_FS) {
+  if (!Number.isInteger(maxAttempts) || maxAttempts < 1) {
+    throw new RangeError("maxAttempts must be a positive integer.");
+  }
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    const fd = fsApi.openSync(file, "r");
+    try {
+      const before = fsApi.fstatSync(fd, { bigint: true });
+      const source = fsApi.readFileSync(fd, "utf8");
+      const after = fsApi.fstatSync(fd, { bigint: true });
+      if (isSameFileVersion(before, after)) {
+        return { source, mtimeMs: Number(after.mtimeMs) };
+      }
+    } finally {
+      fsApi.closeSync(fd);
+    }
+  }
+  throw new Error(`CSS source changed while being read: ${file}`);
+}
+function isSameFileVersion(before, after) {
+  return before.dev === after.dev && before.ino === after.ino && before.size === after.size && before.mtimeNs === after.mtimeNs && before.ctimeNs === after.ctimeNs;
+}
+
 function generateThemeDts(opts) {
   const { theme, sourceFiles } = opts;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -847,219 +1463,368 @@ 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
-  };
+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, varMangleMap = {}, cssVarMetrics = null) {
+  return `/**
+ * Auto-generated mangle map for csszyx.
+ * This module is generated at build time and contains the mapping
+ * from original class names and CSS variable names to mangled names.
+ *
+ * @generated
+ */
+
+export const mangleMap = ${JSON.stringify(mangleMap, null, 2)};
+
+export const varMangleMap = ${JSON.stringify(varMangleMap, null, 2)};
+
+export const cssVarMetrics = ${JSON.stringify(cssVarMetrics, null, 2)};
+
+export const checksum = ${JSON.stringify(checksum)};
+
+export default {
+  mangleMap,
+  varMangleMap,
+  cssVarMetrics,
+  checksum,
+};
+`;
 }
-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;
+function createChecksumModule(checksum) {
+  return `/**
+ * Auto-generated checksum for csszyx mangle map.
+ *
+ * @generated
+ */
+
+export const checksum = ${JSON.stringify(checksum)};
+
+export default checksum;
+`;
+}
+function isVirtualModule(id) {
+  return id === VIRTUAL_MODULE_ID || id === VIRTUAL_CHECKSUM_ID;
+}
+function resolveVirtualModule(id) {
+  if (id === VIRTUAL_MODULE_ID) {
+    return RESOLVED_VIRTUAL_MODULE_ID;
   }
-  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;
+  if (id === VIRTUAL_CHECKSUM_ID) {
+    return RESOLVED_VIRTUAL_CHECKSUM_ID;
   }
-  return deserializeResult(entry.result);
+  return void 0;
 }
-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 {
+
+const CHECKSUM_PLACEHOLDER = "___CSSZYX_CHECKSUM___";
+const MANGLE_MAP_PLACEHOLDER = "___CSSZYX_MANGLE_MAP___";
+const VAR_MANGLE_MAP_PLACEHOLDER = "___CSSZYX_VAR_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 DEFAULT_VAR_MANGLE_MAP_MAX_BYTES = 100 * 1024;
+const GLOBAL_VAR_ALIAS_MAP_OWNER = "\0csszyx:global-var-aliases";
+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 cssVariableEntries(result) {
+  const entries = [];
+  for (const [original, value] of result.cssVariableMap ?? []) {
+    if (Array.isArray(value)) {
+      for (const mangled of value) {
+        entries.push([original, mangled]);
+      }
+    } else {
+      entries.push([original, value]);
     }
   }
+  return entries;
+}
+function recordFileVarMangleEntries(state, filename, entries) {
+  const normalizedFilename = normalizeSourceFilename(filename);
+  if (entries.length === 0) {
+    state.varMangleEntriesByFile.delete(normalizedFilename);
+  } else {
+    state.varMangleEntriesByFile.set(normalizedFilename, entries);
+  }
+  state.varMangleMap = buildVarMangleMap(state.varMangleEntriesByFile);
 }
-function evictOldTransformCacheEntries(cacheRoot, options) {
-  let deleted = 0;
-  const now = options.now ?? Date.now();
-  const survivors = [];
-  for (const file of listJsonFiles(cacheRoot)) {
+function recordGlobalVarSourceFile(state, filename, code) {
+  const normalizedFilename = normalizeSourceFilename(filename);
+  if (!/\.[tj]sx?(?:\?.*)?$/.test(normalizedFilename)) {
+    return;
+  }
+  if (code === null) {
+    state.globalVarSourceFilesByFile.delete(normalizedFilename);
+  } else {
+    state.globalVarSourceFilesByFile.set(normalizedFilename, code);
+  }
+}
+function buildGlobalVarSourceFiles(state) {
+  return [...state.globalVarSourceFilesByFile.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([filePath, code]) => ({ filePath, code }));
+}
+function collectRollupGlobalVarCssAssets(bundle) {
+  return Object.values(bundle).filter(
+    (chunk) => chunk.type === "asset" && typeof chunk.fileName === "string" && /\.css(?:$|\?)/.test(chunk.fileName) && (typeof chunk.source === "string" || chunk.source instanceof Uint8Array)
+  ).sort((left, right) => left.fileName.localeCompare(right.fileName)).map((asset) => ({
+    fileName: asset.fileName,
+    source: asset.source
+  }));
+}
+function collectConfiguredGlobalVarCssSources(rootDir, scanCss) {
+  if (!scanCss) {
+    return [];
+  }
+  return expandFilePatterns(rootDir, scanCss).filter((file) => file.endsWith(".css")).sort((left, right) => left.localeCompare(right)).flatMap((file) => {
     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 });
-      }
+      const snapshot = readStableTextFileSnapshotSync(file);
+      return [
+        {
+          fileName: file,
+          source: snapshot.source,
+          mtimeMs: snapshot.mtimeMs
+        }
+      ];
     } catch {
-      fs.rmSync(file, { force: true });
-      deleted++;
+      return [];
+    }
+  });
+}
+function collectWebpackGlobalVarCssAssets(assets) {
+  return Object.entries(assets).flatMap(([fileName, asset]) => {
+    if (!/\.css(?:$|\?)/.test(fileName)) {
+      return [];
+    }
+    const source = asset.source();
+    if (typeof source !== "string" && !(source instanceof Uint8Array)) {
+      return [];
+    }
+    return [{ fileName, source }];
+  }).sort((left, right) => left.fileName.localeCompare(right.fileName)).map(({ fileName, source }) => ({ fileName, source }));
+}
+function assertNoGlobalVarAliasValidationErrors(result) {
+  const messages = [
+    ...result.plan.diagnostics.map((diagnostic) => {
+      const location = diagnostic.location ? ` (${diagnostic.location.filePath}:${diagnostic.location.line}:${diagnostic.location.column})` : "";
+      return `[${diagnostic.code}] ${diagnostic.name}${location}: ${diagnostic.message}`;
+    }),
+    ...result.usageDiagnostics.map((diagnostic) => {
+      const location = diagnostic.location;
+      return `[${diagnostic.kind}] ${diagnostic.name} (${location.filePath}:${location.line}:${location.column}): ${diagnostic.message}`;
+    })
+  ];
+  if (messages.length > 0) {
+    throw new Error(
+      `[csszyx] production.mangleGlobalVars validation failed:
+${messages.join("\n")}`
+    );
+  }
+}
+function rewriteCssWithValidatedGlobalVarPlan(css, filePath, result) {
+  if (result === null || result.plan.entries.length === 0) {
+    return css;
+  }
+  const rewrite = rewriteGlobalVarCssAliases({
+    css,
+    plan: result.plan,
+    filePath
+  });
+  assertNoGlobalVarAliasValidationErrors({
+    scans: result.scans,
+    plan: {
+      ...result.plan,
+      diagnostics: rewrite.diagnostics
+    },
+    usageDiagnostics: []
+  });
+  return rewrite.css;
+}
+function assertGlobalVarPlanMatchesEarlyAliases(result, expectedEntries) {
+  const actualEntries = [...result.plan.aliases.entries()].sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  const expected = expectedEntries.map(([original, alias]) => [original, alias]).sort(([left], [right]) => left.localeCompare(right));
+  const expectedJson = JSON.stringify(expected);
+  const actualJson = JSON.stringify(actualEntries);
+  if (expectedJson !== actualJson) {
+    throw new Error(
+      `[csszyx] production.mangleGlobalVars validation failed:
+CSS alias plan ${actualJson} does not match source-transform alias table ${expectedJson}.`
+    );
+  }
+}
+function buildVarMangleMap(entriesByFile) {
+  const next = {};
+  const files = [...entriesByFile.keys()].sort();
+  for (const file of files) {
+    for (const [original, mangled] of entriesByFile.get(file) ?? []) {
+      addVarMangleMapping(next, original, mangled);
     }
   }
-  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 next;
+}
+function extractGlobalVarAliasesForManifest(varMangleMap, aliasPrefix = CSSZYX_GLOBAL_ALIAS_PREFIX, validationResult = null) {
+  const aliases = {};
+  for (const [original, value] of Object.entries(varMangleMap).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    const values = Array.isArray(value) ? value : [value];
+    const alias = values.find((candidate) => candidate.startsWith(aliasPrefix));
+    if (alias) {
+      aliases[original] = alias;
     }
   }
-  return deleted;
+  for (const entry of validationResult?.plan.entries ?? []) {
+    if (entry.alias.startsWith(aliasPrefix)) {
+      aliases[entry.original] = entry.alias;
+    }
+  }
+  return Object.fromEntries(
+    Object.entries(aliases).sort(([left], [right]) => left.localeCompare(right))
+  );
 }
-function cacheEntryPath(cacheRoot, key) {
-  return path.join(cacheRoot, key.slice(0, 2), `${key.slice(2)}.json`);
+function createGlobalVarMapAssetSource(varMangleMap, aliasPrefix = CSSZYX_GLOBAL_ALIAS_PREFIX, validationResult = null) {
+  const aliases = extractGlobalVarAliasesForManifest(varMangleMap, aliasPrefix, validationResult);
+  return Object.keys(aliases).length > 0 ? JSON.stringify(aliases) : null;
 }
-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 normalizeGlobalVarAliasesForCache(aliases) {
+  if (!aliases) {
+    return [];
+  }
+  const entries = aliases instanceof Map ? aliases.entries() : Array.isArray(aliases) ? aliases : Object.entries(aliases);
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [original, alias] of entries) {
+    if (original.startsWith("--") && alias.startsWith("--")) {
+      normalized.set(original, alias);
+    }
+  }
+  return [...normalized].sort(([left], [right]) => left.localeCompare(right));
+}
+function createEarlyGlobalVarAliasEntries(config, aliasPrefix) {
+  if (config?.enabled !== true || !config.tokens || config.tokens.length === 0) {
+    return [];
+  }
+  const tokens = [...new Set(config.tokens)].sort();
+  return tokens.map((original, index) => [original, `${aliasPrefix}${encode(index)}`]);
+}
+function shouldEmitGlobalVarMapAsset(config) {
+  return config?.emitMap !== false;
+}
+function assertVarMangleMapSize(varMangleMap, maxBytes) {
+  const size = Buffer.byteLength(JSON.stringify(varMangleMap), "utf8");
+  if (size <= maxBytes) {
+    return;
+  }
+  throw new Error(
+    `[csszyx] CSS variable mangle map is ${size} bytes, which exceeds the ${maxBytes} byte safety cap. Reduce production.mangleVars usage, split the bundle, or raise CSSZYX_VAR_MANGLE_MAP_MAX_BYTES if this payload size is intentional.`
+  );
+}
+function resolveVarMangleMapMaxBytes() {
+  const raw = process.env.CSSZYX_VAR_MANGLE_MAP_MAX_BYTES;
+  if (!raw) {
+    return DEFAULT_VAR_MANGLE_MAP_MAX_BYTES;
+  }
+  const value = Number.parseInt(raw, 10);
+  return Number.isFinite(value) && value > 0 ? value : DEFAULT_VAR_MANGLE_MAP_MAX_BYTES;
 }
-function deserializeResult(result) {
+function addVarMangleMapping(map, original, mangled) {
+  const existing = map[original];
+  if (!existing) {
+    map[original] = mangled;
+    return;
+  }
+  const values = Array.isArray(existing) ? existing : [existing];
+  if (!values.includes(mangled)) {
+    map[original] = [...values, mangled];
+  }
+}
+function emptyCSSVariableMetrics() {
   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)
+    componentClassUses: 0,
+    componentStyleDeclarations: 0,
+    estimatedHoistedDeclarationsSaved: 0,
+    scopedClassUses: 0,
+    scopedStyleDeclarations: 0
   };
 }
-function listJsonFiles(dir) {
-  let entries;
-  try {
-    entries = fs.readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return [];
+function recordFileCSSVariableMetrics(state, filename, code) {
+  const normalizedFilename = normalizeSourceFilename(filename);
+  if (!code) {
+    state.cssVarMetricsByFile.delete(normalizedFilename);
+  } else {
+    const metrics = collectCSSVariableMetrics(code);
+    if (hasCSSVariableMetrics(metrics)) {
+      state.cssVarMetricsByFile.set(normalizedFilename, metrics);
+    } else {
+      state.cssVarMetricsByFile.delete(normalizedFilename);
+    }
+  }
+  state.cssVarMetrics = buildCSSVariableMetrics(state.cssVarMetricsByFile);
+}
+function collectCSSVariableMetrics(code) {
+  const componentUses = /* @__PURE__ */ new Map();
+  const componentDeclarations = /* @__PURE__ */ new Map();
+  const metrics = emptyCSSVariableMetrics();
+  for (const match of code.matchAll(/\(--([cs][A-Za-z0-9]+)\)/g)) {
+    const name = `--${match[1]}`;
+    if (name.startsWith("--c")) {
+      metrics.componentClassUses++;
+      incrementCount(componentUses, name);
+    } else {
+      metrics.scopedClassUses++;
+    }
   }
-  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);
+  for (const match of code.matchAll(/["'](--([cs][A-Za-z0-9]+))["']\s*:/g)) {
+    const name = match[1];
+    if (name.startsWith("--c")) {
+      metrics.componentStyleDeclarations++;
+      incrementCount(componentDeclarations, name);
+    } else {
+      metrics.scopedStyleDeclarations++;
     }
   }
-  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";
-const RESOLVED_VIRTUAL_CHECKSUM_ID = `\0${VIRTUAL_CHECKSUM_ID}`;
-function createMangleMapModule(mangleMap, checksum) {
-  return `/**
- * Auto-generated mangle map for csszyx.
- * This module is generated at build time and contains the mapping
- * from original class names to mangled class names.
- *
- * @generated
- */
-
-export const mangleMap = ${JSON.stringify(mangleMap, null, 2)};
-
-export const checksum = ${JSON.stringify(checksum)};
-
-export default {
-  mangleMap,
-  checksum,
-};
-`;
+  for (const [name, uses] of componentUses) {
+    const declarations = componentDeclarations.get(name) ?? 0;
+    metrics.estimatedHoistedDeclarationsSaved += Math.max(0, uses - declarations);
+  }
+  return metrics;
 }
-function createChecksumModule(checksum) {
-  return `/**
- * Auto-generated checksum for csszyx mangle map.
- *
- * @generated
- */
-
-export const checksum = ${JSON.stringify(checksum)};
-
-export default checksum;
-`;
+function buildCSSVariableMetrics(metricsByFile) {
+  const total = emptyCSSVariableMetrics();
+  for (const file of [...metricsByFile.keys()].sort()) {
+    const metrics = metricsByFile.get(file);
+    if (!metrics) {
+      continue;
+    }
+    total.componentClassUses += metrics.componentClassUses;
+    total.componentStyleDeclarations += metrics.componentStyleDeclarations;
+    total.estimatedHoistedDeclarationsSaved += metrics.estimatedHoistedDeclarationsSaved;
+    total.scopedClassUses += metrics.scopedClassUses;
+    total.scopedStyleDeclarations += metrics.scopedStyleDeclarations;
+  }
+  return total;
 }
-function isVirtualModule(id) {
-  return id === VIRTUAL_MODULE_ID || id === VIRTUAL_CHECKSUM_ID;
+function hasCSSVariableMetrics(metrics) {
+  return Object.values(metrics).some((value) => value > 0);
 }
-function resolveVirtualModule(id) {
-  if (id === VIRTUAL_MODULE_ID) {
-    return RESOLVED_VIRTUAL_MODULE_ID;
-  }
-  if (id === VIRTUAL_CHECKSUM_ID) {
-    return RESOLVED_VIRTUAL_CHECKSUM_ID;
-  }
-  return void 0;
+function incrementCount(map, key) {
+  map.set(key, (map.get(key) ?? 0) + 1);
 }
-
-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;
@@ -1081,7 +1846,7 @@ function runThemeScan(rootDir, scanCss) {
   }
   const themes = sourceFiles.map((f) => {
     try {
-      return parseThemeBlocks(fs.readFileSync(f, "utf-8"));
+      return parseThemeBlocks(readStableTextFileSnapshotSync(f).source);
     } catch {
       return null;
     }
@@ -1093,18 +1858,23 @@ function runThemeScan(rootDir, scanCss) {
     _hasWarnedTsConfig = true;
     try {
       const checkFile = (cfgPath) => {
-        if (fs.existsSync(cfgPath)) {
-          const content = fs.readFileSync(cfgPath, "utf-8");
-          if (!content.includes(".csszyx")) {
-            console.warn(
-              `
+        let content;
+        try {
+          content = fs.readFileSync(cfgPath, "utf-8");
+        } catch (err) {
+          if (err?.code === "ENOENT") {
+            return false;
+          }
+          throw err;
+        }
+        if (!content.includes(".csszyx")) {
+          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;
+          );
         }
-        return false;
+        return true;
       };
       if (!checkFile(path.join(rootDir, "tsconfig.json"))) {
         checkFile(path.join(rootDir, "tsconfig.app.json"));
@@ -1321,12 +2091,43 @@ function mangleCodeClassesSync(code, mangleMap) {
   });
   return result;
 }
+function assertGlobalVarMangleConfig(options) {
+  const config = options.production?.mangleGlobalVars;
+  const errors = validateGlobalVarMangleConfig(config);
+  if (errors.length > 0) {
+    throw new Error(
+      `[csszyx] Invalid production.mangleGlobalVars config:
+${errors.join("\n")}`
+    );
+  }
+  if (config?.enabled === true) {
+    if (!config.tokens || config.tokens.length === 0) {
+      throw new Error(
+        "[csszyx] production.mangleGlobalVars.enabled requires explicit tokens in Phase H v1."
+      );
+    }
+    if (config.autoPrefix !== void 0 && config.autoPrefix !== "") {
+      throw new Error(
+        "[csszyx] production.mangleGlobalVars.autoPrefix requires CSS pre-scan support and is not enabled in Phase H v1."
+      );
+    }
+  }
+}
 function createCsszyxPlugins(options = {}) {
+  assertGlobalVarMangleConfig(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;
+  const varMangleMapMaxBytes = resolveVarMangleMapMaxBytes();
+  const globalVarMangleConfig = options.production?.mangleGlobalVars;
+  const globalVarAliasPrefix = globalVarMangleConfig?.aliasPrefix ?? CSSZYX_GLOBAL_ALIAS_PREFIX;
+  const encodedGlobalVarAliasPrefix = encodeURIComponent(globalVarAliasPrefix);
+  const earlyGlobalVarAliasEntries = createEarlyGlobalVarAliasEntries(
+    globalVarMangleConfig,
+    globalVarAliasPrefix
+  );
   if (cacheRequested && !cacheVersionsKnown && !_hasWarnedTransformCacheVersion) {
     _hasWarnedTransformCacheVersion = true;
     console.warn(
@@ -1341,12 +2142,21 @@ function createCsszyxPlugins(options = {}) {
   const state = {
     classes: /* @__PURE__ */ new Set(),
     mangleMap: {},
+    varMangleEntriesByFile: /* @__PURE__ */ new Map(),
+    varMangleMap: Object.fromEntries(earlyGlobalVarAliasEntries),
+    cssVarMetricsByFile: /* @__PURE__ */ new Map(),
+    cssVarMetrics: emptyCSSVariableMetrics(),
     checksum: "",
     finalized: false,
     rootDir: process.cwd(),
     recoveryTokens: /* @__PURE__ */ new Map(),
-    rscModules: /* @__PURE__ */ new Map()
+    rscModules: /* @__PURE__ */ new Map(),
+    globalVarSourceFilesByFile: /* @__PURE__ */ new Map(),
+    globalVarValidationResult: null
   };
+  if (earlyGlobalVarAliasEntries.length > 0) {
+    state.varMangleEntriesByFile.set(GLOBAL_VAR_ALIAS_MAP_OWNER, earlyGlobalVarAliasEntries);
+  }
   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"]);
@@ -1356,6 +2166,40 @@ function createCsszyxPlugins(options = {}) {
   function isUserIncluded(id) {
     return !options.include || matchesAnyPattern(id, options.include, state.rootDir);
   }
+  function resolveGlobalVarValidationCacheDir() {
+    if (!cacheEnabled) {
+      return void 0;
+    }
+    const cacheRoot = path.resolve(
+      state.rootDir,
+      options.build?.cacheDir ?? DEFAULT_BUILD_CONFIG.cacheDir ?? ".csszyx/cache"
+    );
+    return resolveGlobalVarScanCacheDir(cacheRoot);
+  }
+  function validateGlobalVarBundleInputs(cssAssets) {
+    if (globalVarMangleConfig?.enabled !== true) {
+      return null;
+    }
+    const configuredCssAssets = collectConfiguredGlobalVarCssSources(
+      state.rootDir,
+      options.build?.scanCss
+    );
+    const result = validateGlobalVarAliasInputs(
+      createGlobalVarAliasValidationOptions({
+        rootDir: state.rootDir,
+        cssAssets: [...configuredCssAssets, ...cssAssets],
+        sourceFiles: buildGlobalVarSourceFiles(state),
+        tokens: globalVarMangleConfig.tokens,
+        autoPrefix: globalVarMangleConfig.autoPrefix,
+        aliasPrefix: globalVarAliasPrefix,
+        reserved: globalVarMangleConfig.reserved,
+        cacheDir: resolveGlobalVarValidationCacheDir()
+      })
+    );
+    assertNoGlobalVarAliasValidationErrors(result);
+    assertGlobalVarPlanMatchesEarlyAliases(result, earlyGlobalVarAliasEntries);
+    return result;
+  }
   function isHardIgnored(id) {
     return id.includes("node_modules") || id.includes("/packages/") || id.includes(".next") && !id.includes("static");
   }
@@ -1366,21 +2210,17 @@ function createCsszyxPlugins(options = {}) {
     return !isHardIgnored(id) && !isUserExcluded(id) && /\.css(\?.*)?$/.test(id);
   }
   function transformConfiguredSource(source, filename) {
-    const compilerOptions = { astBudget: astBudgetOverride };
+    const compilerOptions = createCompilerOptions();
     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
-    };
+    const cacheInput = createConfiguredTransformCacheInput(
+      source,
+      effectiveFilename,
+      compilerOptions
+    );
     if (parserMode === "rust") {
       ensureRustTransformAvailable();
     }
@@ -1421,6 +2261,126 @@ function createCsszyxPlugins(options = {}) {
     }
     return result;
   }
+  function createCompilerOptions() {
+    return {
+      astBudget: astBudgetOverride,
+      mangleVars: options.production?.mangleVars === true,
+      mangleVarHoistMaxDepth: options.production?.mangleVarHoistMaxDepth,
+      globalVarAliases: earlyGlobalVarAliasEntries.length > 0 ? earlyGlobalVarAliasEntries : void 0
+    };
+  }
+  function createConfiguredTransformCacheInput(source, effectiveFilename, compilerOptions) {
+    return {
+      pluginVersion: PLUGIN_VERSION,
+      compilerVersion: COMPILER_VERSION,
+      parserMode,
+      producer: parserMode,
+      astBudget: astBudgetOverride,
+      mangleVars: compilerOptions.mangleVars,
+      mangleVarHoistMaxDepth: compilerOptions.mangleVarHoistMaxDepth,
+      globalVarAliases: normalizeGlobalVarAliasesForCache(compilerOptions.globalVarAliases),
+      filename: effectiveFilename,
+      source
+    };
+  }
+  function transformPrescanSources(files) {
+    if (parserMode !== "rust" || files.length <= 1) {
+      return transformPrescanSourcesIndividually(files);
+    }
+    const compilerOptions = createCompilerOptions();
+    const cacheRoot = resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
+    const results = /* @__PURE__ */ new Map();
+    const misses = [];
+    if (cacheEnabled) {
+      evictTransformCacheOnce();
+    }
+    ensureRustTransformAvailable();
+    for (const file of files) {
+      const effectiveFilename = normalizeSourceFilename(file.filePath);
+      const cacheInput = createConfiguredTransformCacheInput(
+        file.content,
+        effectiveFilename,
+        compilerOptions
+      );
+      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);
+          results.set(file.filePath, memoryCached);
+          continue;
+        }
+        const cached = readTransformCache(cacheRoot, cacheInput, cacheKey);
+        if (cached) {
+          rememberTransformCacheEntry(cacheKey.key, cached);
+          results.set(file.filePath, cached);
+          continue;
+        }
+      }
+      misses.push({
+        filePath: file.filePath,
+        effectiveFilename,
+        content: file.content,
+        cacheInput,
+        cacheKey
+      });
+    }
+    if (misses.length === 0) {
+      return files.map((file) => {
+        const result = results.get(file.filePath);
+        return result ? { filePath: file.filePath, result } : null;
+      }).filter((entry) => entry !== null);
+    }
+    try {
+      const batchResults = transformRustBatch(
+        misses.map((file) => ({
+          filename: file.effectiveFilename,
+          source: file.content
+        })),
+        compilerOptions
+      );
+      for (let index = 0; index < misses.length; index++) {
+        const miss = misses[index];
+        const result = batchResults[index];
+        if (!miss || !result) {
+          continue;
+        }
+        if (cacheEnabled && miss.cacheKey) {
+          writeTransformCache(cacheRoot, miss.cacheInput, result, miss.cacheKey);
+          rememberTransformCacheEntry(miss.cacheKey.key, result);
+        }
+        results.set(miss.filePath, result);
+      }
+    } catch {
+      for (const miss of misses) {
+        try {
+          results.set(
+            miss.filePath,
+            transformConfiguredSource(miss.content, miss.effectiveFilename)
+          );
+        } catch {
+        }
+      }
+    }
+    return files.map((file) => {
+      const result = results.get(file.filePath);
+      return result ? { filePath: file.filePath, result } : null;
+    }).filter((entry) => entry !== null);
+  }
+  function transformPrescanSourcesIndividually(files) {
+    const results = [];
+    for (const file of files) {
+      try {
+        results.push({
+          filePath: file.filePath,
+          result: transformConfiguredSource(file.content, file.filePath)
+        });
+      } catch {
+      }
+    }
+    return results;
+  }
   function rememberTransformCacheEntry(key, result) {
     transformMemoryCache.delete(key);
     transformMemoryCache.set(key, result);
@@ -1457,7 +2417,14 @@ function createCsszyxPlugins(options = {}) {
 <div class="${classList}"><div class="${classList}">x</div><div class="${classList}">x</div></div>
 `;
     try {
-      const existing = fs.existsSync(safelistPath) ? fs.readFileSync(safelistPath, "utf-8") : "";
+      let existing = "";
+      try {
+        existing = fs.readFileSync(safelistPath, "utf-8");
+      } catch (err) {
+        if (err?.code !== "ENOENT") {
+          throw err;
+        }
+      }
       if (existing !== content) {
         fs.writeFileSync(safelistPath, content);
       }
@@ -1465,8 +2432,10 @@ function createCsszyxPlugins(options = {}) {
     }
   }
   function prescanAndWriteClasses() {
+    const prescanStarted = performance.now();
     const discoveredClasses = /* @__PURE__ */ new Set();
     const rawDiscoveredClasses = /* @__PURE__ */ new Set();
+    const prescanSources = [];
     function scanDir(dir) {
       let entries;
       try {
@@ -1484,85 +2453,107 @@ function createCsszyxPlugins(options = {}) {
           if (!shouldProcessSource(filePath)) {
             continue;
           }
+          let content;
           try {
-            const content = fs.readFileSync(filePath, "utf-8");
-            if (!content.includes("sz=") && !content.includes("sz:")) {
-              continue;
-            }
-            const result = transformConfiguredSource(content, filePath);
-            if (!result.transformed) {
-              continue;
-            }
-            for (const cls of result.classes) {
-              discoveredClasses.add(cls);
-            }
-            for (const cls of result.rawClassNames) {
-              rawDiscoveredClasses.add(cls);
-            }
-            for (const [token, data] of result.recoveryTokens) {
-              state.recoveryTokens.set(token, data);
-            }
-            if (result.usesRuntime) {
-              const szCallRe = /_sz\(\s*\{/g;
-              for (const szMatch of result.code.matchAll(szCallRe)) {
-                let depth = 1;
-                let idx = (szMatch.index ?? 0) + szMatch[0].length;
-                while (idx < result.code.length && depth > 0) {
-                  if (result.code[idx] === "{") {
-                    depth++;
-                  } else if (result.code[idx] === "}") {
-                    depth--;
-                  }
-                  idx++;
-                }
-                const objStr = result.code.slice(
-                  (szMatch.index ?? 0) + szMatch[0].length,
-                  idx - 1
-                );
-                const strKv = /(\w+)\s*:\s*(?:"([^"]*)"|'([^']*)')/g;
-                for (const kv of objStr.matchAll(strKv)) {
-                  try {
-                    const val = kv[2] ?? kv[3];
-                    const r = transform({ [kv[1]]: val });
-                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
-                      discoveredClasses.add(c);
-                    }
-                  } catch {
-                  }
-                }
-                const numKv = /(\w+)\s*:\s*(-?\d+(?:\.\d+)?)\s*(?=[,}\n])/g;
-                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)) {
-                      discoveredClasses.add(c);
-                    }
-                  } catch {
-                  }
-                }
-                const boolKv = /(\w+)\s*:\s*(true|false)\s*(?=[,}\n])/g;
-                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)) {
-                      discoveredClasses.add(c);
-                    }
-                  } catch {
-                  }
-                }
-              }
-            }
+            content = fs.readFileSync(filePath, "utf-8");
           } catch {
+            continue;
+          }
+          if (!content.includes("sz=") && !content.includes("sz:")) {
+            continue;
           }
+          prescanSources.push({ filePath, content });
         }
       }
     }
     scanDir(state.rootDir);
+    for (const { filePath, result } of transformPrescanSources(prescanSources)) {
+      if (!result.transformed) {
+        continue;
+      }
+      collectPrescanResult(result, filePath, discoveredClasses, rawDiscoveredClasses);
+    }
     for (const cls of discoveredClasses) {
       state.classes.add(cls);
     }
     const safelistClasses = /* @__PURE__ */ new Set([...discoveredClasses, ...rawDiscoveredClasses]);
     writeSafelistFile(safelistClasses);
+    traceBenchTiming("prescan", state.rootDir, performance.now() - prescanStarted);
+  }
+  function collectPrescanResult(result, filePath, discoveredClasses, rawDiscoveredClasses) {
+    for (const cls of result.classes) {
+      discoveredClasses.add(cls);
+    }
+    for (const cls of result.rawClassNames) {
+      rawDiscoveredClasses.add(cls);
+    }
+    for (const [token, data] of result.recoveryTokens) {
+      state.recoveryTokens.set(token, data);
+    }
+    recordFileVarMangleEntries(state, filePath, cssVariableEntries(result));
+    recordFileCSSVariableMetrics(state, filePath, result.code);
+    collectRuntimeStaticClasses(result, discoveredClasses);
+  }
+  function collectRuntimeStaticClasses(result, discoveredClasses) {
+    if (!result.usesRuntime) {
+      return;
+    }
+    const szCallRe = /_sz\(\s*\{/g;
+    for (const szMatch of result.code.matchAll(szCallRe)) {
+      let depth = 1;
+      let idx = (szMatch.index ?? 0) + szMatch[0].length;
+      while (idx < result.code.length && depth > 0) {
+        if (result.code[idx] === "{") {
+          depth++;
+        } else if (result.code[idx] === "}") {
+          depth--;
+        }
+        idx++;
+      }
+      const objStr = result.code.slice((szMatch.index ?? 0) + szMatch[0].length, idx - 1);
+      collectRuntimeStringClasses(objStr, discoveredClasses);
+      collectRuntimeNumberClasses(objStr, discoveredClasses);
+      collectRuntimeBooleanClasses(objStr, discoveredClasses);
+    }
+  }
+  function collectRuntimeStringClasses(objStr, discoveredClasses) {
+    const strKv = /(\w+)\s*:\s*(?:"([^"]*)"|'([^']*)')/g;
+    for (const kv of objStr.matchAll(strKv)) {
+      try {
+        const val = kv[2] ?? kv[3];
+        collectTransformClasses(transform({ [kv[1]]: val }), discoveredClasses);
+      } catch {
+      }
+    }
+  }
+  function collectRuntimeNumberClasses(objStr, discoveredClasses) {
+    const numKv = /(\w+)\s*:\s*(-?\d+(?:\.\d+)?)\s*(?=[,}\n])/g;
+    for (const kv of objStr.matchAll(numKv)) {
+      try {
+        collectTransformClasses(
+          transform({ [kv[1]]: parseFloat(kv[2]) }),
+          discoveredClasses
+        );
+      } catch {
+      }
+    }
+  }
+  function collectRuntimeBooleanClasses(objStr, discoveredClasses) {
+    const boolKv = /(\w+)\s*:\s*(true|false)\s*(?=[,}\n])/g;
+    for (const kv of objStr.matchAll(boolKv)) {
+      try {
+        collectTransformClasses(
+          transform({ [kv[1]]: kv[2] === "true" }),
+          discoveredClasses
+        );
+      } catch {
+      }
+    }
+  }
+  function collectTransformClasses(result, discoveredClasses) {
+    for (const cls of result.className.split(/\s+/).filter(Boolean)) {
+      discoveredClasses.add(cls);
+    }
   }
   function extractClasses(code) {
     const dqPattern = /(?:class(?:Name)?|sz)[:=]\s*"([^"]*)"/g;
@@ -1605,7 +2596,10 @@ function createCsszyxPlugins(options = {}) {
       newMap[sortedClasses[i]] = encode(i);
     }
     state.mangleMap = newMap;
-    state.checksum = compute_mangle_checksum(state.mangleMap);
+    assertVarMangleMapSize(state.varMangleMap, varMangleMapMaxBytes);
+    state.checksum = compute_mangle_checksum(
+      createHydrationMangleMap(state.mangleMap, state.varMangleMap)
+    );
     state.finalized = true;
   }
   function mangleCodeClasses(code) {
@@ -1621,6 +2615,11 @@ function createCsszyxPlugins(options = {}) {
       const escapedMap = result.includes("eval(") ? jsonMap.replace(/"/g, '\\"') : jsonMap;
       result = result.split(MANGLE_MAP_PLACEHOLDER).join(escapedMap);
     }
+    if (result.includes(VAR_MANGLE_MAP_PLACEHOLDER)) {
+      const jsonMap = JSON.stringify(state.varMangleMap);
+      const escapedMap = result.includes("eval(") ? jsonMap.replace(/"/g, '\\"') : jsonMap;
+      result = result.split(VAR_MANGLE_MAP_PLACEHOLDER).join(escapedMap);
+    }
     return result;
   }
   const prePlugin = createUnplugin(
@@ -1646,7 +2645,12 @@ function createCsszyxPlugins(options = {}) {
       load(id) {
         if (id === RESOLVED_VIRTUAL_MODULE_ID) {
           finalizeMangleMap();
-          return createMangleMapModule(state.mangleMap, state.checksum);
+          return createMangleMapModule(
+            state.mangleMap,
+            state.checksum,
+            state.varMangleMap,
+            state.cssVarMetrics
+          );
         }
         if (id === RESOLVED_VIRTUAL_CHECKSUM_ID) {
           finalizeMangleMap();
@@ -1677,6 +2681,9 @@ function createCsszyxPlugins(options = {}) {
         if (!shouldProcessCss(id) && !shouldProcessSource(id)) {
           return null;
         }
+        if (shouldProcessSource(id)) {
+          recordGlobalVarSourceFile(state, id, code);
+        }
         if (/\.[tj]sx?(\?.*)?$/.test(id)) {
           assertNoRSCBoundaryViolation(code, id);
         }
@@ -1739,6 +2746,8 @@ ${sourceDirective}`
             usesColorVar = result.usesColorVar;
             transformed = result.transformed;
             szClasses = result.classes;
+            recordFileVarMangleEntries(state, id, cssVariableEntries(result));
+            recordFileCSSVariableMetrics(state, id, result.code);
             if (result.diagnostics.length > 0 && process.env.NODE_ENV !== "production") {
               for (const msg of result.diagnostics) {
                 this.warn(`[csszyx] ${id}
@@ -1749,14 +2758,17 @@ ${sourceDirective}`
               state.recoveryTokens.set(token, data);
             }
           }
+        } else if (shouldProcessSource(id)) {
+          recordFileVarMangleEntries(state, id, []);
+          recordFileCSSVariableMetrics(state, id, null);
         }
-        if (transformedCode.includes("<html") && /layout|Root|Document|app\\.tsx?$/i.test(id)) {
+        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})}}})()\`}} />`;
+          const debugScript = `<script dangerouslySetInnerHTML={{__html: \`(function(){var m=${MANGLE_MAP_PLACEHOLDER};var vm=${VAR_MANGLE_MAP_PLACEHOLDER};var gp=decodeURIComponent(${JSON.stringify(encodedGlobalVarAliasPrefix)});var r={};var vr={};for(var k in m)r[m[k]]=k;for(var vk in vm){var vv=vm[vk];var vs=Array.isArray(vv)?vv:[vv];for(var vi=0;vi<vs.length;vi++)(vr[vs[vi]]||(vr[vs[vi]]=[])).push(vk)}window.__csszyx={mangleMap:m,varMangleMap:vm,checksum:"${CHECKSUM_PLACEHOLDER}",decode:function(c){return r[c]},encode:function(c){return m[c]},decodeVar:function(v){return vr[v]||[]},encodeVar:function(v){return vm[v]},decodeGlobalVar:function(v){var a=vr[v]||[];return v.indexOf(gp)===0?a[0]:void 0},decodeAll:function(el){return(el.className||"").split(" ").map(function(c){return r[c]||c})}}})()\`}} />`;
           if (transformedCode.includes("<body")) {
             transformedCode = transformedCode.replace(
               /(<body[^>]*>)/i,
@@ -1825,6 +2837,9 @@ ${sourceDirective}`
       watchChange(id, change) {
         if (change.event === "delete") {
           deleteRSCModuleRecord(state.rscModules, id);
+          recordGlobalVarSourceFile(state, id, null);
+          recordFileVarMangleEntries(state, id, []);
+          recordFileCSSVariableMetrics(state, id, null);
         }
       },
       /**
@@ -1886,6 +2901,9 @@ ${sourceDirective}`
             return;
           }
           if (!fileContent.includes("sz=") && !/\bsz\s*:\s*["'{]/.test(fileContent)) {
+            recordGlobalVarSourceFile(state, ctx.file, fileContent);
+            recordFileVarMangleEntries(state, ctx.file, []);
+            recordFileCSSVariableMetrics(state, ctx.file, null);
             return;
           }
           try {
@@ -1897,15 +2915,24 @@ ${sourceDirective}`
               performance.now() - hmrTransformStarted
             );
           } catch {
+            recordGlobalVarSourceFile(state, ctx.file, fileContent);
+            recordFileVarMangleEntries(state, ctx.file, []);
+            recordFileCSSVariableMetrics(state, ctx.file, null);
             return;
           }
           if (!result.transformed) {
+            recordGlobalVarSourceFile(state, ctx.file, fileContent);
+            recordFileVarMangleEntries(state, ctx.file, []);
+            recordFileCSSVariableMetrics(state, ctx.file, null);
             return;
           }
           const sizeBefore = state.classes.size;
+          recordGlobalVarSourceFile(state, ctx.file, fileContent);
           for (const cls of result.classes) {
             state.classes.add(cls);
           }
+          recordFileVarMangleEntries(state, ctx.file, cssVariableEntries(result));
+          recordFileCSSVariableMetrics(state, ctx.file, result.code);
           for (const [token, data] of result.recoveryTokens) {
             state.recoveryTokens.set(token, data);
           }
@@ -1927,7 +2954,9 @@ ${sourceDirective}`
             finalizeMangleMap();
             let result = transformIndexHtml(html, state.mangleMap, state.checksum, {
               mode: options.production?.injectChecksum === false ? "script" : "script",
-              minify: process.env.NODE_ENV === "production"
+              minify: process.env.NODE_ENV === "production",
+              varMangleMap: state.varMangleMap,
+              globalVarAliasPrefix
             });
             if (state.recoveryTokens.size > 0) {
               const isProduction = process.env.NODE_ENV === "production";
@@ -1971,6 +3000,9 @@ ${sourceDirective}`
           },
           (assets) => {
             finalizeMangleMap();
+            state.globalVarValidationResult = validateGlobalVarBundleInputs(
+              collectWebpackGlobalVarCssAssets(assets)
+            );
             const isWebpackDevMode = compiler.options.mode === "development";
             const manifestData = {
               version: "0.4.0",
@@ -1980,33 +3012,71 @@ ${sourceDirective}`
             if (manglingEnabled && !isWebpackDevMode && Object.keys(state.mangleMap).length > 0) {
               manifestData.mangleMap = state.mangleMap;
             }
+            if (Object.keys(state.varMangleMap).length > 0) {
+              manifestData.varMangleMap = state.varMangleMap;
+            }
+            const globalVarAliases = extractGlobalVarAliasesForManifest(
+              state.varMangleMap,
+              globalVarAliasPrefix,
+              state.globalVarValidationResult
+            );
+            if (Object.keys(globalVarAliases).length > 0) {
+              manifestData.globalVarAliases = globalVarAliases;
+            }
+            if (hasCSSVariableMetrics(state.cssVarMetrics)) {
+              manifestData.cssVarMetrics = state.cssVarMetrics;
+            }
             compilation.emitAsset(
               "csszyx-manifest.json",
               new compiler.webpack.sources.RawSource(JSON.stringify(manifestData))
             );
+            if (shouldEmitGlobalVarMapAsset(globalVarMangleConfig)) {
+              const globalVarMapAsset = createGlobalVarMapAssetSource(
+                state.varMangleMap,
+                globalVarAliasPrefix,
+                state.globalVarValidationResult
+              );
+              if (globalVarMapAsset) {
+                compilation.emitAsset(
+                  ".csszyx/global-var-map.json",
+                  new compiler.webpack.sources.RawSource(globalVarMapAsset)
+                );
+              }
+            }
             for (const file in assets) {
               const asset = assets[file];
               const source = asset.source().toString();
-              if (manglingEnabled && !isWebpackDevMode && Object.keys(state.mangleMap).length > 0) {
-                if (file.endsWith(".css")) {
+              if (file.endsWith(".css")) {
+                let css = rewriteCssWithValidatedGlobalVarPlan(
+                  source,
+                  file,
+                  state.globalVarValidationResult
+                );
+                if (manglingEnabled && !isWebpackDevMode && Object.keys(state.mangleMap).length > 0) {
                   try {
-                    const result = mangleCSSSync(source, state.mangleMap, {
+                    const result = mangleCSSSync(css, state.mangleMap, {
                       debug: options.development?.debug,
                       from: file
                     });
                     if (result.transformedCount > 0) {
-                      compilation.updateAsset(
-                        file,
-                        new compiler.webpack.sources.RawSource(result.css)
-                      );
-                      continue;
+                      css = result.css;
                     }
                   } catch (e) {
                     if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") ; else {
                       throw e;
                     }
                   }
-                } else if (file.endsWith(".html")) {
+                }
+                if (css !== source) {
+                  compilation.updateAsset(
+                    file,
+                    new compiler.webpack.sources.RawSource(css)
+                  );
+                }
+                continue;
+              }
+              if (manglingEnabled && !isWebpackDevMode && Object.keys(state.mangleMap).length > 0) {
+                if (file.endsWith(".html")) {
                   const mangledHtml = source.replace(
                     /\bclass="([^"]*)"/g,
                     (_m, cls) => {
@@ -2061,6 +3131,9 @@ ${sourceDirective}`
        */
       generateBundle(_options, bundle) {
         finalizeMangleMap();
+        state.globalVarValidationResult = validateGlobalVarBundleInputs(
+          collectRollupGlobalVarCssAssets(bundle)
+        );
         const manifestData = {
           version: "0.4.0",
           buildId: state.checksum,
@@ -2069,31 +3142,70 @@ ${sourceDirective}`
         if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
           manifestData.mangleMap = state.mangleMap;
         }
+        if (Object.keys(state.varMangleMap).length > 0) {
+          manifestData.varMangleMap = state.varMangleMap;
+        }
+        const globalVarAliases = extractGlobalVarAliasesForManifest(
+          state.varMangleMap,
+          globalVarAliasPrefix,
+          state.globalVarValidationResult
+        );
+        if (Object.keys(globalVarAliases).length > 0) {
+          manifestData.globalVarAliases = globalVarAliases;
+        }
+        if (hasCSSVariableMetrics(state.cssVarMetrics)) {
+          manifestData.cssVarMetrics = state.cssVarMetrics;
+        }
         this.emitFile({
           type: "asset",
           fileName: "csszyx-manifest.json",
           source: JSON.stringify(manifestData)
         });
+        if (shouldEmitGlobalVarMapAsset(globalVarMangleConfig)) {
+          const globalVarMapAsset = createGlobalVarMapAssetSource(
+            state.varMangleMap,
+            globalVarAliasPrefix,
+            state.globalVarValidationResult
+          );
+          if (globalVarMapAsset) {
+            this.emitFile({
+              type: "asset",
+              fileName: ".csszyx/global-var-map.json",
+              source: globalVarMapAsset
+            });
+          }
+        }
         for (const file in bundle) {
           const chunk = bundle[file];
-          if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
-            if (chunk.type === "asset" && chunk.fileName.endsWith(".css")) {
-              const css = chunk.source.toString();
+          if (chunk.type === "asset" && chunk.fileName.endsWith(".css")) {
+            const originalCss = chunk.source.toString();
+            let css = rewriteCssWithValidatedGlobalVarPlan(
+              originalCss,
+              file,
+              state.globalVarValidationResult
+            );
+            if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
               try {
                 const result = mangleCSSSync(css, state.mangleMap, {
                   debug: options.development?.debug,
                   from: file
                 });
                 if (result.transformedCount > 0) {
-                  chunk.source = result.css;
+                  css = result.css;
                 }
               } catch (e) {
                 if (e && typeof e === "object" && "name" in e && e.name === "CssSyntaxError") ; else {
                   throw e;
                 }
               }
-              continue;
-            } else if (chunk.type === "chunk") {
+            }
+            if (css !== originalCss) {
+              chunk.source = css;
+            }
+            continue;
+          }
+          if (manglingEnabled && Object.keys(state.mangleMap).length > 0) {
+            if (chunk.type === "chunk") {
               let mangledCode = mangleCodeClasses(chunk.code);
               mangledCode = replacePlaceholders(mangledCode);
               if (mangledCode !== chunk.code) {
@@ -2156,4 +3268,4 @@ const esbuildPlugin = (options = {}) => {
   };
 };
 
-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 };
+export { scanGlobalVarCss as A, validateGlobalVarAliasInputs as B, vitePlugin as C, webpackPlugin as D, writeGlobalVarScanCache as E, assertNoRSCBoundaryViolation as a, assertNoRSCGraphViolation as b, createGlobalVarAliasValidationOptions as c, createGlobalVarMapAssetSource as d, createGlobalVarScanCacheKey as e, createRSCModuleRecord as f, deleteRSCModuleRecord as g, esbuildPlugin as h, extractGlobalVarAliasesForManifest as i, findRSCBoundaryViolation as j, findRSCGraphViolation as k, hasTokens as l, hasUseClientDirective as m, hasUseServerDirective as n, isRSCServerModule as o, isTailwindReservedGlobalVar as p, mangleCodeClassesSync as q, mergeThemes as r, normalizeGlobalVarAliasesForCache as s, parseThemeBlocks as t, unplugin as u, planGlobalVarAliases as v, readGlobalVarScanCache as w, resolveGlobalVarScanCacheDir as x, rewriteGlobalVarCssAliases as y, rollupPlugin as z };