@csszyx/unplugin 0.9.0 → 0.9.2

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

@@ -13,8 +13,13 @@ const vueAdapter = require('@csszyx/vue-adapter');
 const unplugin$1 = require('unplugin');
 const cssMangler = require('../css-mangler.cjs');
 const node_crypto = require('node:crypto');
+const transformCache = require('./unplugin.DUxdYaSG.cjs');
+const postcss = require('postcss');
+const valueParser = require('postcss-value-parser');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
 function _interopNamespaceCompat(e) {
     if (e && typeof e === 'object' && 'default' in e) return e;
     const n = Object.create(null);
@@ -29,6 +34,432 @@ function _interopNamespaceCompat(e) {
 
 const fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs);
 const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
+const postcss__default = /*#__PURE__*/_interopDefaultCompat(postcss);
+const valueParser__default = /*#__PURE__*/_interopDefaultCompat(valueParser);
+
+function resolveGlobalVarScanCacheDir(cacheDir) {
+  return path__namespace.join(cacheDir, "global-vars");
+}
+function createGlobalVarScanCacheKey(input) {
+  const hash = node_crypto.createHash("sha256");
+  hash.update(input.filePath);
+  hash.update("\0");
+  hash.update(String(input.mtimeMs));
+  hash.update("\0");
+  hash.update(node_crypto.createHash("sha256").update(input.css).digest("hex"));
+  return hash.digest("hex");
+}
+function readGlobalVarScanCache(cacheDir, key) {
+  try {
+    const raw = fs__namespace.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__namespace.mkdirSync(cacheDir, { recursive: true });
+    fs__namespace.writeFileSync(
+      globalVarScanCacheFile(cacheDir, key),
+      JSON.stringify({ key, result }),
+      "utf8"
+    );
+  } catch {
+  }
+}
+function globalVarScanCacheFile(cacheDir, key) {
+  return path__namespace.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__default.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 ?? types.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}${core.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 types.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 (types.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__default.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__default(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__default.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) => compiler.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__namespace.isAbsolute(fileName) ? fileName : path__namespace.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['"];?$/;
@@ -269,24 +700,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)) {
@@ -297,6 +722,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}/`));
 }
@@ -360,10 +877,17 @@ function resolveLocalModule(importer, source) {
     path__namespace.join(base, "index.js")
   ];
   for (const candidate of candidates) {
-    if (fs__namespace.existsSync(candidate) && fs__namespace.statSync(candidate).isFile()) {
+    try {
+      if (!fs__namespace.statSync(candidate).isFile()) {
+        continue;
+      }
       const resolved = normalizeModuleId(candidate);
       resolvedLocalModuleCache.set(cacheKey, resolved);
       return resolved;
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
     }
   }
   return null;
@@ -383,32 +907,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;
@@ -720,6 +1279,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;
@@ -732,10 +1295,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 = types.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>")) {
@@ -747,9 +1318,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) {
@@ -764,11 +1335,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;
@@ -776,6 +1347,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 = [];
@@ -817,6 +1407,36 @@ function injectRecoveryManifest(html, manifest) {
   return html + scriptTag;
 }
 
+const DEFAULT_MAX_ATTEMPTS = 3;
+const NODE_FS = {
+  openSync: fs__namespace.openSync,
+  fstatSync: (fd, options) => fs__namespace.fstatSync(fd, options),
+  readFileSync: (fd, encoding) => fs__namespace.readFileSync(fd, encoding),
+  closeSync: fs__namespace.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();
@@ -863,219 +1483,368 @@ function writeThemeDts(opts) {
   fs.writeFileSync(opts.outputPath, content, "utf-8");
 }
 
-const CACHE_SCHEMA_VERSION = 2;
-function resolveTransformCacheDir(rootDir, cacheDir) {
-  return path__namespace.resolve(rootDir, cacheDir ?? ".csszyx/cache", "transform");
-}
-function createTransformCacheKey(input) {
-  const inputSha256 = node_crypto.createHash("sha256").update(input.source).digest("hex");
-  const keyMaterial = [
-    `schema=${CACHE_SCHEMA_VERSION}`,
-    `plugin=${input.pluginVersion}`,
-    `compiler=${input.compilerVersion}`,
-    `parser=${input.parserMode}`,
-    `producer=${input.producer}`,
-    `astBudget=${input.astBudget ?? "default"}`,
-    `filename=${input.filename}`,
-    `source=${inputSha256}`
-  ].join("\n");
-  return {
-    key: node_crypto.createHash("sha256").update(keyMaterial).digest("hex").slice(0, 16),
-    inputSha256
-  };
+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__namespace.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__namespace.dirname(file);
-  const tmp = path__namespace.join(
-    dir,
-    `.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.json`
-  );
-  const entry = {
-    version: CACHE_SCHEMA_VERSION,
-    pluginVersion: input.pluginVersion,
-    compilerVersion: input.compilerVersion,
-    parserMode: input.parserMode,
-    producer: input.producer,
-    astBudget: input.astBudget ?? null,
-    filename: input.filename,
-    inputSha256,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    result: serializeResult(result)
-  };
-  try {
-    fs__namespace.mkdirSync(dir, { recursive: true });
-    fs__namespace.writeFileSync(tmp, JSON.stringify(entry), "utf8");
-    fs__namespace.renameSync(tmp, file);
-  } catch {
-    try {
-      fs__namespace.rmSync(tmp, { force: true });
-    } catch {
+
+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 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.CFp386gH.cjs', document.baseURI).href)));
+const PLUGIN_VERSION = findPackageVersionFromFile(
+  node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.CFp386gH.cjs', document.baseURI).href))),
+  UNKNOWN_PACKAGE_VERSION
+);
+const COMPILER_VERSION = findPackageVersionFromModule("@csszyx/compiler", UNKNOWN_PACKAGE_VERSION);
+const BENCH_TRACE_ENABLED = process.env.CSSZYX_BENCH_TRACE === "1";
+const BENCH_TRACE_FILE = process.env.CSSZYX_BENCH_TRACE_FILE;
+function 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 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 evictOldTransformCacheEntries(cacheRoot, options) {
-  let deleted = 0;
-  const now = options.now ?? Date.now();
-  const survivors = [];
-  for (const file of listJsonFiles(cacheRoot)) {
+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__namespace.readFileSync(file, "utf8"));
-      const timestamp = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : 0;
-      if (!Number.isFinite(timestamp) || now - timestamp > options.maxAgeMs) {
-        fs__namespace.rmSync(file, { force: true });
-        deleted++;
-      } else {
-        survivors.push({ file, timestamp });
-      }
+      const snapshot = readStableTextFileSnapshotSync(file);
+      return [
+        {
+          fileName: file,
+          source: snapshot.source,
+          mtimeMs: snapshot.mtimeMs
+        }
+      ];
     } catch {
-      fs__namespace.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}.`
+    );
   }
-  const overflow = survivors.length - options.maxEntries ;
-  if (overflow > 0) {
-    survivors.sort((a, b) => a.timestamp - b.timestamp);
-    for (const survivor of survivors.slice(0, overflow)) {
-      fs__namespace.rmSync(survivor.file, { force: true });
-      deleted++;
+}
+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);
     }
   }
-  return deleted;
+  return next;
 }
-function cacheEntryPath(cacheRoot, key) {
-  return path__namespace.join(cacheRoot, key.slice(0, 2), `${key.slice(2)}.json`);
+function extractGlobalVarAliasesForManifest(varMangleMap, aliasPrefix = types.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;
+    }
+  }
+  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 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 createGlobalVarMapAssetSource(varMangleMap, aliasPrefix = types.CSSZYX_GLOBAL_ALIAS_PREFIX, validationResult = null) {
+  const aliases = extractGlobalVarAliasesForManifest(varMangleMap, aliasPrefix, validationResult);
+  return Object.keys(aliases).length > 0 ? JSON.stringify(aliases) : null;
 }
-function deserializeResult(result) {
+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}${core.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 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__namespace.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__namespace.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 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.CL0F6RZa.cjs', document.baseURI).href)));
-const PLUGIN_VERSION = findPackageVersionFromFile(
-  node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('shared/unplugin.CL0F6RZa.cjs', document.baseURI).href))),
-  UNKNOWN_PACKAGE_VERSION
-);
-const COMPILER_VERSION = findPackageVersionFromModule("@csszyx/compiler", UNKNOWN_PACKAGE_VERSION);
-const BENCH_TRACE_ENABLED = process.env.CSSZYX_BENCH_TRACE === "1";
-const BENCH_TRACE_FILE = process.env.CSSZYX_BENCH_TRACE_FILE;
 function traceBenchTiming(label, filename, elapsedMs) {
   if (!BENCH_TRACE_ENABLED) {
     return;
@@ -1097,7 +1866,7 @@ function runThemeScan(rootDir, scanCss) {
   }
   const themes = sourceFiles.map((f) => {
     try {
-      return parseThemeBlocks(fs__namespace.readFileSync(f, "utf-8"));
+      return parseThemeBlocks(readStableTextFileSnapshotSync(f).source);
     } catch {
       return null;
     }
@@ -1109,18 +1878,23 @@ function runThemeScan(rootDir, scanCss) {
     _hasWarnedTsConfig = true;
     try {
       const checkFile = (cfgPath) => {
-        if (fs__namespace.existsSync(cfgPath)) {
-          const content = fs__namespace.readFileSync(cfgPath, "utf-8");
-          if (!content.includes(".csszyx")) {
-            console.warn(
-              `
+        let content;
+        try {
+          content = fs__namespace.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__namespace.join(rootDir, "tsconfig.json"))) {
         checkFile(path__namespace.join(rootDir, "tsconfig.app.json"));
@@ -1337,12 +2111,43 @@ function mangleCodeClassesSync(code, mangleMap) {
   });
   return result;
 }
+function assertGlobalVarMangleConfig(options) {
+  const config = options.production?.mangleGlobalVars;
+  const errors = types.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 ?? types.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 ?? types.CSSZYX_GLOBAL_ALIAS_PREFIX;
+  const encodedGlobalVarAliasPrefix = encodeURIComponent(globalVarAliasPrefix);
+  const earlyGlobalVarAliasEntries = createEarlyGlobalVarAliasEntries(
+    globalVarMangleConfig,
+    globalVarAliasPrefix
+  );
   if (cacheRequested && !cacheVersionsKnown && !_hasWarnedTransformCacheVersion) {
     _hasWarnedTransformCacheVersion = true;
     console.warn(
@@ -1357,12 +2162,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"]);
@@ -1372,6 +2186,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__namespace.resolve(
+      state.rootDir,
+      options.build?.cacheDir ?? types.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");
   }
@@ -1382,25 +2230,21 @@ 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);
+    const cacheRoot = transformCache.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") {
       compiler.ensureRustTransformAvailable();
     }
-    const cacheKey = cacheEnabled ? createTransformCacheKey(cacheInput) : null;
+    const cacheKey = cacheEnabled ? transformCache.createTransformCacheKey(cacheInput) : null;
     if (cacheEnabled && cacheKey) {
       const memoryCached = transformMemoryCache.get(cacheKey.key);
       if (memoryCached) {
@@ -1408,7 +2252,7 @@ function createCsszyxPlugins(options = {}) {
         transformMemoryCache.set(cacheKey.key, memoryCached);
         return memoryCached;
       }
-      const cached = readTransformCache(cacheRoot, cacheInput, cacheKey);
+      const cached = transformCache.readTransformCache(cacheRoot, cacheInput, cacheKey);
       if (cached) {
         rememberTransformCacheEntry(cacheKey.key, cached);
         return cached;
@@ -1432,11 +2276,131 @@ function createCsszyxPlugins(options = {}) {
       }
     }
     if (cacheEnabled && cacheKey) {
-      writeTransformCache(cacheRoot, cacheInput, result, cacheKey);
+      transformCache.writeTransformCache(cacheRoot, cacheInput, result, cacheKey);
       rememberTransformCacheEntry(cacheKey.key, result);
     }
     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 = transformCache.resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
+    const results = /* @__PURE__ */ new Map();
+    const misses = [];
+    if (cacheEnabled) {
+      evictTransformCacheOnce();
+    }
+    compiler.ensureRustTransformAvailable();
+    for (const file of files) {
+      const effectiveFilename = normalizeSourceFilename(file.filePath);
+      const cacheInput = createConfiguredTransformCacheInput(
+        file.content,
+        effectiveFilename,
+        compilerOptions
+      );
+      const cacheKey = cacheEnabled ? transformCache.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 = transformCache.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 = compiler.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) {
+          transformCache.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);
@@ -1452,12 +2416,12 @@ function createCsszyxPlugins(options = {}) {
     if (!cacheEnabled) {
       return;
     }
-    const cacheRoot = resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
+    const cacheRoot = transformCache.resolveTransformCacheDir(state.rootDir, options.build?.cacheDir);
     if (evictedCacheRoot === cacheRoot) {
       return;
     }
     evictedCacheRoot = cacheRoot;
-    evictOldTransformCacheEntries(cacheRoot, {
+    transformCache.evictOldTransformCacheEntries(cacheRoot, {
       maxAgeMs: TRANSFORM_CACHE_MAX_AGE_MS,
       maxEntries: TRANSFORM_CACHE_MAX_ENTRIES
     });
@@ -1473,7 +2437,14 @@ function createCsszyxPlugins(options = {}) {
 <div class="${classList}"><div class="${classList}">x</div><div class="${classList}">x</div></div>
 `;
     try {
-      const existing = fs__namespace.existsSync(safelistPath) ? fs__namespace.readFileSync(safelistPath, "utf-8") : "";
+      let existing = "";
+      try {
+        existing = fs__namespace.readFileSync(safelistPath, "utf-8");
+      } catch (err) {
+        if (err?.code !== "ENOENT") {
+          throw err;
+        }
+      }
       if (existing !== content) {
         fs__namespace.writeFileSync(safelistPath, content);
       }
@@ -1481,8 +2452,10 @@ function createCsszyxPlugins(options = {}) {
     }
   }
   function prescanAndWriteClasses() {
+    const prescanStarted = node_perf_hooks.performance.now();
     const discoveredClasses = /* @__PURE__ */ new Set();
     const rawDiscoveredClasses = /* @__PURE__ */ new Set();
+    const prescanSources = [];
     function scanDir(dir) {
       let entries;
       try {
@@ -1500,85 +2473,107 @@ function createCsszyxPlugins(options = {}) {
           if (!shouldProcessSource(filePath)) {
             continue;
           }
+          let content;
           try {
-            const content = fs__namespace.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 = compiler.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 = compiler.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 = compiler.transform({ [kv[1]]: kv[2] === "true" });
-                    for (const c of r.className.split(/\s+/).filter(Boolean)) {
-                      discoveredClasses.add(c);
-                    }
-                  } catch {
-                  }
-                }
-              }
-            }
+            content = fs__namespace.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, node_perf_hooks.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(compiler.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(
+          compiler.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(
+          compiler.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;
@@ -1621,7 +2616,10 @@ function createCsszyxPlugins(options = {}) {
       newMap[sortedClasses[i]] = core.encode(i);
     }
     state.mangleMap = newMap;
-    state.checksum = core.compute_mangle_checksum(state.mangleMap);
+    assertVarMangleMapSize(state.varMangleMap, varMangleMapMaxBytes);
+    state.checksum = core.compute_mangle_checksum(
+      createHydrationMangleMap(state.mangleMap, state.varMangleMap)
+    );
     state.finalized = true;
   }
   function mangleCodeClasses(code) {
@@ -1637,6 +2635,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 = unplugin$1.createUnplugin(
@@ -1662,7 +2665,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();
@@ -1693,6 +2701,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);
         }
@@ -1755,6 +2766,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}
@@ -1765,14 +2778,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,
@@ -1841,6 +2857,9 @@ ${sourceDirective}`
       watchChange(id, change) {
         if (change.event === "delete") {
           deleteRSCModuleRecord(state.rscModules, id);
+          recordGlobalVarSourceFile(state, id, null);
+          recordFileVarMangleEntries(state, id, []);
+          recordFileCSSVariableMetrics(state, id, null);
         }
       },
       /**
@@ -1902,6 +2921,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 {
@@ -1913,15 +2935,24 @@ ${sourceDirective}`
               node_perf_hooks.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);
           }
@@ -1943,7 +2974,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";
@@ -1987,6 +3020,9 @@ ${sourceDirective}`
           },
           (assets) => {
             finalizeMangleMap();
+            state.globalVarValidationResult = validateGlobalVarBundleInputs(
+              collectWebpackGlobalVarCssAssets(assets)
+            );
             const isWebpackDevMode = compiler.options.mode === "development";
             const manifestData = {
               version: "0.4.0",
@@ -1996,33 +3032,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 = cssMangler.mangleCSSSync(source, state.mangleMap, {
+                    const result = cssMangler.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) => {
@@ -2077,6 +3151,9 @@ ${sourceDirective}`
        */
       generateBundle(_options, bundle) {
         finalizeMangleMap();
+        state.globalVarValidationResult = validateGlobalVarBundleInputs(
+          collectRollupGlobalVarCssAssets(bundle)
+        );
         const manifestData = {
           version: "0.4.0",
           buildId: state.checksum,
@@ -2085,31 +3162,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 = cssMangler.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) {
@@ -2174,19 +3290,32 @@ const esbuildPlugin = (options = {}) => {
 
 exports.assertNoRSCBoundaryViolation = assertNoRSCBoundaryViolation;
 exports.assertNoRSCGraphViolation = assertNoRSCGraphViolation;
+exports.createGlobalVarAliasValidationOptions = createGlobalVarAliasValidationOptions;
+exports.createGlobalVarMapAssetSource = createGlobalVarMapAssetSource;
+exports.createGlobalVarScanCacheKey = createGlobalVarScanCacheKey;
 exports.createRSCModuleRecord = createRSCModuleRecord;
 exports.deleteRSCModuleRecord = deleteRSCModuleRecord;
 exports.esbuildPlugin = esbuildPlugin;
+exports.extractGlobalVarAliasesForManifest = extractGlobalVarAliasesForManifest;
 exports.findRSCBoundaryViolation = findRSCBoundaryViolation;
 exports.findRSCGraphViolation = findRSCGraphViolation;
 exports.hasTokens = hasTokens;
 exports.hasUseClientDirective = hasUseClientDirective;
 exports.hasUseServerDirective = hasUseServerDirective;
 exports.isRSCServerModule = isRSCServerModule;
+exports.isTailwindReservedGlobalVar = isTailwindReservedGlobalVar;
 exports.mangleCodeClassesSync = mangleCodeClassesSync;
 exports.mergeThemes = mergeThemes;
+exports.normalizeGlobalVarAliasesForCache = normalizeGlobalVarAliasesForCache;
 exports.parseThemeBlocks = parseThemeBlocks;
+exports.planGlobalVarAliases = planGlobalVarAliases;
+exports.readGlobalVarScanCache = readGlobalVarScanCache;
+exports.resolveGlobalVarScanCacheDir = resolveGlobalVarScanCacheDir;
+exports.rewriteGlobalVarCssAliases = rewriteGlobalVarCssAliases;
 exports.rollupPlugin = rollupPlugin;
+exports.scanGlobalVarCss = scanGlobalVarCss;
 exports.unplugin = unplugin;
+exports.validateGlobalVarAliasInputs = validateGlobalVarAliasInputs;
 exports.vitePlugin = vitePlugin;
 exports.webpackPlugin = webpackPlugin;
+exports.writeGlobalVarScanCache = writeGlobalVarScanCache;