tailwind-styled-v4 5.0.11 → 5.0.13

package/dist/compiler.mjs

@@ -1,5 +1,6 @@
 import { createRequire } from 'module';
 import * as fs from 'fs';
+import fs__default from 'fs';
 import * as path from 'path';
 import path__default from 'path';
 import 'crypto';
@@ -7,7 +8,9 @@ import { fileURLToPath } from 'url';
 
 /* tailwind-styled-v4 v5.0.4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -21,6 +24,15 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 function platformKey() {
   if (isBrowser) return "browser";
   return `${process.platform}-${process.arch}`;
@@ -31,7 +43,7 @@ function resolveNativeBinary(runtimeDir) {
   if (isBrowser) {
     return { path: null, source: "not-found", platform, tried: ["not available in browser"] };
   }
-  if (process.env.TWS_DISABLE_NATIVE === "1") {
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_DISABLE_NATIVE === "1") {
     return { path: null, source: "not-found", platform, tried: [] };
   }
   const envPath = process.env.TW_NATIVE_PATH?.trim();
@@ -136,7 +148,7 @@ var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttemp
 var init_nativeBridge = __esm({
   "packages/domain/compiler/src/nativeBridge.ts"() {
     init_src();
-    _loadNative = (path3) => __require(path3);
+    _loadNative = (path4) => __require(path4);
     log = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -209,530 +221,1917 @@ Tried paths: ${result.tried.join("\n")}`);
   }
 });
 
-// packages/domain/compiler/src/tailwindEngine.ts
-var tailwindEngine_exports = {};
-__export(tailwindEngine_exports, {
-  generateRawCss: () => generateRawCss,
-  processTailwindCssWithTargets: () => processTailwindCssWithTargets,
-  runCssPipeline: () => runCssPipeline,
-  runCssPipelineSync: () => runCssPipelineSync
-});
-function loadTailwindEngine() {
-  if (_twEngine) return _twEngine;
-  if (_twEngineError) throw _twEngineError;
+// packages/domain/compiler/src/compiler/cssGeneratorNative.ts
+async function generateCssNative(classes, options) {
+  const { theme } = options;
+  const native = getNativeBridge();
+  if (!native?.generateCssNative) {
+    throw new Error(
+      "FATAL: Rust CSS generator (generateCssNative) is required but not available. Ensure native binding is properly loaded. Check that native/.node binary exists."
+    );
+  }
+  const themeJson = JSON.stringify(theme);
+  const css = native.generateCssNative(classes, themeJson);
+  return css;
+}
+function getCacheStats() {
   try {
-    const tw = require2("tailwindcss");
-    if (typeof tw.compile !== "function") {
-      throw new Error("tailwindcss v4 not found \u2014 compile() API missing. Check tailwindcss version >= 4.");
-    }
-    _twEngine = tw;
-    return _twEngine;
-  } catch (e) {
-    _twEngineError = e instanceof Error ? e : new Error(String(e));
-    throw _twEngineError;
-  }
-}
-async function generateRawCss(classes, cssEntryContent, root) {
-  if (classes.length === 0) return "";
-  const tw = loadTailwindEngine();
-  const input = cssEntryContent ?? "@import 'tailwindcss';";
-  const { readFileSync, existsSync: existsSync2 } = await import('fs');
-  const { dirname, resolve: resolve2 } = await import('path');
-  const projectRoot = root ?? process.cwd();
-  const req = createRequire(resolve2(projectRoot, "package.json"));
-  const loadStylesheet = async (id, base) => {
-    try {
-      const cssId = id === "tailwindcss" ? "tailwindcss/index.css" : id === "tailwindcss/preflight" ? "tailwindcss/preflight.css" : id === "tailwindcss/utilities" ? "tailwindcss/utilities.css" : id === "tailwindcss/theme" ? "tailwindcss/theme.css" : id;
-      const pkgPath = req.resolve(cssId);
-      return {
-        content: readFileSync(pkgPath, "utf-8"),
-        base: dirname(pkgPath)
-      };
-    } catch {
-      try {
-        const absPath = resolve2(base, id);
-        if (existsSync2(absPath)) {
-          return { content: readFileSync(absPath, "utf-8"), base: dirname(absPath) };
-        }
-      } catch {
-      }
-      return { content: "", base };
+    const native = getNativeBridge();
+    if (!native?.getCacheStats) {
+      return null;
     }
-  };
-  const compiler = await Promise.resolve(tw.compile(input, { loadStylesheet }));
-  return compiler.build(classes);
+    const [hits, misses] = native.getCacheStats();
+    return { hits, misses };
+  } catch {
+    return null;
+  }
 }
-function postProcessWithLightning(rawCss) {
-  if (!rawCss) return "";
-  const native = getNativeBridge();
-  if (typeof native.processTailwindCssLightning !== "function") {
-    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
+function clearThemeCache() {
+  try {
+    const native = getNativeBridge();
+    if (!native?.clearThemeCache) {
+      return;
+    }
+    native.clearThemeCache();
+  } catch {
   }
-  const result = native.processTailwindCssLightning(rawCss);
-  return result?.css ?? rawCss;
 }
-async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
-  const unique = [...new Set(classes.filter(Boolean))];
-  if (unique.length === 0) {
-    return { css: "", classes: [], sizeBytes: 0, optimized: false };
+var init_cssGeneratorNative = __esm({
+  "packages/domain/compiler/src/compiler/cssGeneratorNative.ts"() {
+    init_nativeBridge();
   }
-  const rawCss = await generateRawCss(unique, cssEntryContent, root);
+});
+
+// packages/domain/compiler/src/compiler/compilationNative.ts
+function compileCssNative2(classes, prefix) {
   const native = getNativeBridge();
-  const hasLightning = minify && typeof native.processTailwindCssLightning === "function";
-  const finalCss = hasLightning ? postProcessWithLightning(rawCss) : rawCss;
-  return {
-    css: finalCss,
-    classes: unique,
-    sizeBytes: finalCss.length,
-    optimized: hasLightning
-  };
+  if (!native?.compileCss) throw new Error("compileCss not available");
+  return native.compileCss(classes, prefix);
 }
-function runCssPipelineSync(_classes) {
-  return { css: "", classes: [], sizeBytes: 0, optimized: false };
+function compileCssLightning(classes) {
+  const native = getNativeBridge();
+  if (!native?.compileCssLightning) throw new Error("compileCssLightning not available");
+  return native.compileCssLightning(classes);
 }
-function processTailwindCssWithTargets(css, targets) {
+function extractTwStateConfigsNative(source, filename) {
   const native = getNativeBridge();
-  if (!native?.processTailwindCssWithTargets) {
-    throw new Error("FATAL: Native binding 'processTailwindCssWithTargets' is required but not available.");
-  }
-  const result = native.processTailwindCssWithTargets(css, targets ?? null);
-  return (result?.css ?? css).trim();
+  if (!native?.extractTwStateConfigs) throw new Error("extractTwStateConfigs not available");
+  return native.extractTwStateConfigs(source, filename);
 }
-var require2, _twEngine, _twEngineError;
-var init_tailwindEngine = __esm({
-  "packages/domain/compiler/src/tailwindEngine.ts"() {
+function generateStaticStateCssNative(inputs, resolvedCss) {
+  const native = getNativeBridge();
+  if (!native?.generateStaticStateCss) throw new Error("generateStaticStateCss not available");
+  return native.generateStaticStateCss(inputs, resolvedCss ?? null);
+}
+function extractAndGenerateStateCssNative(source, filename) {
+  const native = getNativeBridge();
+  if (!native?.extractAndGenerateStateCss) throw new Error("extractAndGenerateStateCss not available");
+  return native.extractAndGenerateStateCss(source, filename);
+}
+function layoutClassesToCss(classes) {
+  const native = getNativeBridge();
+  if (!native?.layoutClassesToCss) throw new Error("layoutClassesToCss not available");
+  return native.layoutClassesToCss(classes);
+}
+function hashContent(input, algorithm = "sha256", length = 8) {
+  const native = getNativeBridge();
+  if (!native?.hashContent) throw new Error("hashContent not available");
+  return native.hashContent(input, algorithm, length);
+}
+function extractTwContainerConfigs(source) {
+  const native = getNativeBridge();
+  if (!native?.extractTwContainerConfigs) throw new Error("extractTwContainerConfigs not available");
+  return native.extractTwContainerConfigs(source);
+}
+function parseAtomicClass(twClass) {
+  const native = getNativeBridge();
+  if (!native?.parseAtomicClass) throw new Error("parseAtomicClass not available");
+  return native.parseAtomicClass(twClass);
+}
+function generateAtomicCss(rulesJson) {
+  const native = getNativeBridge();
+  if (!native?.generateAtomicCss) throw new Error("generateAtomicCss not available");
+  return native.generateAtomicCss(rulesJson);
+}
+function toAtomicClasses(twClasses) {
+  const native = getNativeBridge();
+  if (!native?.toAtomicClasses) throw new Error("toAtomicClasses not available");
+  return native.toAtomicClasses(twClasses);
+}
+function clearAtomicRegistry() {
+  const native = getNativeBridge();
+  if (!native?.clearAtomicRegistry) return;
+  native.clearAtomicRegistry();
+}
+function atomicRegistrySize() {
+  const native = getNativeBridge();
+  if (!native?.atomicRegistrySize) return 0;
+  return native.atomicRegistrySize();
+}
+var init_compilationNative = __esm({
+  "packages/domain/compiler/src/compiler/compilationNative.ts"() {
     init_nativeBridge();
-    require2 = createRequire(import.meta.url);
-    _twEngine = null;
-    _twEngineError = null;
   }
 });
 
-// packages/domain/compiler/src/index.ts
-init_nativeBridge();
-var transformSource = (source, opts) => {
+// packages/domain/compiler/src/compiler/cssCompilationNative.ts
+function compileClass(input) {
   const native = getNativeBridge();
-  if (!native?.transformSource) {
-    throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
-  }
-  const result = native.transformSource(source, opts);
-  if (!result) {
-    throw new Error("FATAL: transformSource returned null");
+  if (!native?.compile_class) throw new Error("compile_class not available");
+  const resultJson = native.compile_class(input);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      selector: "",
+      declarations: "",
+      properties: [],
+      specificity: 0
+    };
   }
-  return result;
-};
-var hasTwUsage = (source) => {
+}
+function compileClasses(inputs) {
   const native = getNativeBridge();
-  if (!native?.hasTwUsage) {
-    throw new Error("FATAL: Native binding 'hasTwUsage' is required but not available.");
+  if (!native?.compile_classes) throw new Error("compile_classes not available");
+  const resultJson = native.compile_classes(inputs);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      css: "",
+      resolved_classes: [],
+      unknown_classes: [],
+      size_bytes: 0,
+      duration_ms: 0
+    };
   }
-  return native.hasTwUsage(source);
-};
-var isAlreadyTransformed = (source) => {
+}
+function compileToCss(input, minify) {
   const native = getNativeBridge();
-  if (!native?.isAlreadyTransformed) {
-    throw new Error("FATAL: Native binding 'isAlreadyTransformed' is required but not available.");
-  }
-  return native.isAlreadyTransformed(source);
-};
-var shouldProcess = (source) => {
-  return hasTwUsage(source) && !isAlreadyTransformed(source);
-};
-var compileCssFromClasses = (classes, prefix) => {
+  if (!native?.compile_to_css) throw new Error("compile_to_css not available");
+  return native.compile_to_css(input, minify ?? false);
+}
+function compileToCssBatch(inputs, minify) {
   const native = getNativeBridge();
-  if (!native?.transformSource) {
-    throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
-  }
-  const result = native.transformSource(classes.join(" "), { prefix: prefix ?? "" });
-  if (!result) {
-    throw new Error("FATAL: transformSource returned null");
-  }
-  return result;
-};
-var buildStyleTag = (classes) => {
-  const result = compileCssFromClasses(classes);
-  return result?.code ? `<style data-tailwind-styled>${result.code}</style>` : "";
-};
-var compileCssNative = (classes, prefix = null) => {
-  return compileCssFromClasses(classes, prefix);
-};
-var generateCssForClasses = async (classes, _tailwindConfig, root, cssEntryContent, minify = false) => {
-  const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
-  const result = await runCssPipeline2(classes, cssEntryContent, root, minify);
-  return result.css;
-};
-var extractAllClasses = (source) => {
+  if (!native?.compile_to_css_batch) throw new Error("compile_to_css_batch not available");
+  return native.compile_to_css_batch(inputs, minify ?? false);
+}
+function minifyCss(css) {
   const native = getNativeBridge();
-  if (!native?.extractAllClasses) {
-    throw new Error("FATAL: Native binding 'extractAllClasses' is required but not available.");
-  }
-  return native.extractAllClasses(source) || [];
-};
-var extractClassesFromSource = (source) => {
+  if (!native?.minify_css) throw new Error("minify_css not available");
+  return native.minify_css(css);
+}
+function compileAnimation(animationName, from, to) {
   const native = getNativeBridge();
-  if (!native?.extractClassesFromSource) {
-    throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
+  if (!native?.compile_animation) throw new Error("compile_animation not available");
+  const resultJson = native.compile_animation(animationName, from, to);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      animation_id: "",
+      keyframes_css: "",
+      animation_rule: "",
+      duration_ms: 0
+    };
   }
-  const result = native.extractClassesFromSource(source);
-  return Array.isArray(result) ? result.join(" ") : String(result || "");
-};
-var astExtractClasses = (source, filename) => {
+}
+function compileKeyframes(name, stopsJson) {
   const native = getNativeBridge();
-  if (!native?.extractClassesFromSource) {
-    throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
+  if (!native?.compile_keyframes) throw new Error("compile_keyframes not available");
+  const resultJson = native.compile_keyframes(name, stopsJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      animation_id: "",
+      keyframes_css: "",
+      animation_rule: "",
+      duration_ms: 0
+    };
   }
-  return native.extractClassesFromSource(source) || [];
-};
-var parseClasses = (raw) => {
+}
+function compileTheme(tokensJson, themeName, prefix) {
   const native = getNativeBridge();
-  if (!native?.parseClasses) {
-    throw new Error("FATAL: Native binding 'parseClasses' is required but not available.");
+  if (!native?.compile_theme) throw new Error("compile_theme not available");
+  const resultJson = native.compile_theme(tokensJson, themeName, prefix);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      selector: ":root",
+      variables: [],
+      variables_css: "",
+      theme_name: themeName
+    };
   }
-  return native.parseClasses(raw) || [];
-};
-var normalizeClasses = (raw) => {
-  const result = normalizeAndDedupClasses(raw);
-  return result?.normalized || "";
-};
-var mergeClassesStatic = (classes) => {
-  const result = normalizeAndDedupClasses(classes);
-  return result?.normalized || "";
-};
-var normalizeAndDedupClasses = (raw) => {
+}
+function twMerge(classString) {
   const native = getNativeBridge();
-  if (!native?.normalizeAndDedupClasses) {
-    throw new Error("FATAL: Native binding 'normalizeAndDedupClasses' is required but not available.");
-  }
-  const result = native.normalizeAndDedupClasses(raw);
-  return result || { normalized: "", duplicatesRemoved: 0, uniqueCount: 0 };
-};
-var eliminateDeadCss = (css, deadClasses) => {
+  if (!native?.tw_merge) throw new Error("tw_merge not available");
+  return native.tw_merge(classString);
+}
+function twMergeMany(classStrings) {
   const native = getNativeBridge();
-  if (!native?.processTailwindCssLightning) {
-    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
-  }
-  const deadSet = deadClasses;
-  const pruned = css.split(/(?<=\})\s*/).filter((rule) => {
-    const m = rule.match(/\.([a-zA-Z0-9_-]+)/);
-    return !m || !deadSet.has(m[1]);
-  }).join("\n");
-  const compiled = native.processTailwindCssLightning(pruned);
-  return (compiled?.css ?? pruned).trim();
-};
-var findDeadVariants = (variantConfig, usage) => {
-  const unused = [];
-  const configs = Array.isArray(variantConfig) ? variantConfig : [{ name: "__root__", variants: variantConfig }];
-  for (const component of configs) {
-    const componentUsage = usage[component.name] ?? /* @__PURE__ */ new Set();
-    const variants = component.variants;
-    for (const [key, values] of Object.entries(variants)) {
-      for (const [value] of Object.entries(values)) {
-        if (!componentUsage.has(`${key}:${value}`)) {
-          unused.push(`${component.name !== "__root__" ? `${component.name}/` : ""}${key}:${value}`);
-        }
-      }
-    }
-  }
-  return {
-    unusedCount: unused.length,
-    unused
+  if (!native?.tw_merge_many) throw new Error("tw_merge_many not available");
+  return native.tw_merge_many(classStrings);
+}
+function twMergeWithSeparator(classString, options) {
+  const native = getNativeBridge();
+  if (!native?.tw_merge_with_separator)
+    throw new Error("tw_merge_with_separator not available");
+  const opts = {
+    separator: options.separator,
+    debug: options.debug
   };
-};
-var runElimination = (css, scanResult) => {
+  return native.tw_merge_with_separator(classString, opts);
+}
+function twMergeManyWithSeparator(classStrings, options) {
   const native = getNativeBridge();
-  if (!native?.detectDeadCode) {
-    throw new Error("FATAL: Native binding 'detectDeadCode' is required but not available.");
-  }
-  const dead = native.detectDeadCode(
-    JSON.stringify(scanResult),
-    css
-  );
-  return eliminateDeadCss(css, new Set(dead.deadInCss ?? []));
-};
-var optimizeCss = (css) => {
+  if (!native?.tw_merge_many_with_separator)
+    throw new Error("tw_merge_many_with_separator not available");
+  const opts = {
+    separator: options.separator,
+    debug: options.debug
+  };
+  return native.tw_merge_many_with_separator(classStrings, opts);
+}
+function twMergeRaw(classLists) {
   const native = getNativeBridge();
-  if (!native?.detectDeadCode) {
-    throw new Error("FATAL: Native binding 'detectDeadCode' is required but not available.");
-  }
-  const deadResult = native.detectDeadCode(
-    JSON.stringify({ uniqueClasses: [] }),
-    css
-  );
-  if (!native?.processTailwindCssLightning) {
-    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
-  }
-  const deadSet = new Set(deadResult.deadInCss ?? []);
-  const pruned = css.split(/(?<=\})\s*/).filter((rule) => {
-    const selectorMatch = rule.match(/\.([a-zA-Z0-9_-]+)/);
-    if (!selectorMatch) return true;
-    return !deadSet.has(selectorMatch[1]);
-  }).join("\n");
-  const compiled = native.processTailwindCssLightning(pruned);
-  return (compiled?.css ?? pruned).trim();
-};
-var scanProjectUsage = (dirs, cwd) => {
-  const path3 = __require("path");
-  const files = dirs.map((dir) => path3.resolve(cwd, dir));
-  const results = batchExtractClasses(files) || [];
-  const combined = {};
-  for (const result of results) {
-    if (result.ok && result.classes) {
-      for (const cls of result.classes) {
-        if (!combined[cls]) combined[cls] = {};
-        combined[cls][result.file] = /* @__PURE__ */ new Set([cls]);
-      }
-    }
+  if (!native?.tw_merge_raw) throw new Error("tw_merge_raw not available");
+  return native.tw_merge_raw(classLists);
+}
+var init_cssCompilationNative = __esm({
+  "packages/domain/compiler/src/compiler/cssCompilationNative.ts"() {
+    init_nativeBridge();
   }
-  return combined;
-};
-var extractComponentUsage = (source) => {
+});
+
+// packages/domain/compiler/src/compiler/idRegistryNative.ts
+function idRegistryCreate() {
   const native = getNativeBridge();
-  if (!native?.extractComponentUsage) {
-    throw new Error("FATAL: Native binding 'extractComponentUsage' is required but not available.");
-  }
-  return native.extractComponentUsage(source) || [];
-};
-var diffClassLists = (previous, current) => {
+  if (!native?.id_registry_create) throw new Error("id_registry_create not available");
+  return native.id_registry_create();
+}
+function idRegistryGenerate(handle, name) {
   const native = getNativeBridge();
-  if (!native?.diffClassLists) {
-    throw new Error("FATAL: Native binding 'diffClassLists' is required but not available.");
-  }
-  return native.diffClassLists(previous, current) || { added: [], removed: [], unchanged: [], hasChanges: false };
-};
-var batchExtractClasses = (filePaths) => {
+  if (!native?.id_registry_generate) throw new Error("id_registry_generate not available");
+  return native.id_registry_generate(handle, name);
+}
+function idRegistryLookup(handle, name) {
   const native = getNativeBridge();
-  if (!native?.batchExtractClasses) {
-    throw new Error("FATAL: Native binding 'batchExtractClasses' is required but not available.");
-  }
-  return native.batchExtractClasses(filePaths) || [];
-};
-var checkAgainstSafelist = (classes, safelist) => {
+  if (!native?.id_registry_lookup) throw new Error("id_registry_lookup not available");
+  return native.id_registry_lookup(handle, name);
+}
+function idRegistryNext(handle) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_next) throw new Error("id_registry_next not available");
+  return native.id_registry_next(handle);
+}
+function idRegistryDestroy(handle) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_destroy) return;
+  native.id_registry_destroy(handle);
+}
+function idRegistryReset(handle) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_reset) return;
+  native.id_registry_reset(handle);
+}
+function idRegistrySnapshot(handle) {
   const native = getNativeBridge();
-  if (!native?.checkAgainstSafelist) {
-    throw new Error("FATAL: Native binding 'checkAgainstSafelist' is required but not available.");
+  if (!native?.id_registry_snapshot) throw new Error("id_registry_snapshot not available");
+  const snapshotJson = native.id_registry_snapshot(handle);
+  try {
+    return JSON.parse(snapshotJson);
+  } catch {
+    return {
+      handle,
+      next_id: 0,
+      entries: [],
+      total_entries: 0
+    };
   }
-  return native.checkAgainstSafelist(classes, safelist) || { matched: [], unmatched: [], safelistSize: 0 };
-};
-var hoistComponents = (source) => {
+}
+function idRegistryActiveCount() {
+  const native = getNativeBridge();
+  if (!native?.id_registry_active_count) throw new Error("id_registry_active_count not available");
+  return native.id_registry_active_count();
+}
+function registerPropertyName(propertyName) {
+  const native = getNativeBridge();
+  if (!native?.register_property_name)
+    throw new Error("register_property_name not available");
+  return native.register_property_name(propertyName);
+}
+function registerValueName(valueName) {
+  const native = getNativeBridge();
+  if (!native?.register_value_name) throw new Error("register_value_name not available");
+  return native.register_value_name(valueName);
+}
+function propertyIdToString(propertyId) {
   const native = getNativeBridge();
-  if (!native?.hoistComponents) {
-    throw new Error("FATAL: Native binding 'hoistComponents' is required but not available.");
+  if (!native?.property_id_to_string) throw new Error("property_id_to_string not available");
+  return native.property_id_to_string(propertyId);
+}
+function valueIdToString(valueId) {
+  const native = getNativeBridge();
+  if (!native?.value_id_to_string) throw new Error("value_id_to_string not available");
+  return native.value_id_to_string(valueId);
+}
+function reverseLookupProperty(propertyId) {
+  const native = getNativeBridge();
+  if (!native?.reverse_lookup_property)
+    throw new Error("reverse_lookup_property not available");
+  return native.reverse_lookup_property(propertyId);
+}
+function reverseLookupValue(valueId) {
+  const native = getNativeBridge();
+  if (!native?.reverse_lookup_value) throw new Error("reverse_lookup_value not available");
+  return native.reverse_lookup_value(valueId);
+}
+function idRegistryExport(handle) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_export) throw new Error("id_registry_export not available");
+  return native.id_registry_export(handle);
+}
+function idRegistryImport(importedData) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_import) throw new Error("id_registry_import not available");
+  return native.id_registry_import(importedData);
+}
+var init_idRegistryNative = __esm({
+  "packages/domain/compiler/src/compiler/idRegistryNative.ts"() {
+    init_nativeBridge();
   }
-  return native.hoistComponents(source) || { code: source, hoisted: [], warnings: [] };
-};
-var compileVariantTable = (configJson) => {
+});
+
+// packages/domain/compiler/src/compiler/streamingNative.ts
+function processFileChange(fileChangeJson) {
   const native = getNativeBridge();
-  if (!native?.compileVariantTable) {
-    throw new Error("FATAL: Native binding 'compileVariantTable' is required but not available.");
+  if (!native?.process_file_change) throw new Error("process_file_change not available");
+  const resultJson = native.process_file_change(fileChangeJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      file_path: "",
+      status: "error",
+      old_classes: [],
+      new_classes: [],
+      added_classes: [],
+      removed_classes: [],
+      changed: false,
+      fingerprint: "",
+      error: "Failed to parse result"
+    };
   }
-  return native.compileVariantTable(configJson) || { id: "", tableJson: "{}", keys: [], defaultKey: "", combinations: 0 };
-};
-var compileVariants = (componentId, config) => {
-  return compileVariantTable(JSON.stringify({ componentId, ...config }));
-};
-var classifyAndSortClasses = (classes) => {
+}
+function computeIncrementalDiff(oldScanJson, newScanJson) {
   const native = getNativeBridge();
-  if (!native?.classifyAndSortClasses) {
-    throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+  if (!native?.compute_incremental_diff)
+    throw new Error("compute_incremental_diff not available");
+  const resultJson = native.compute_incremental_diff(oldScanJson, newScanJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      is_changed: false,
+      changes_count: 0,
+      diff: {
+        added_files: [],
+        removed_files: [],
+        modified_files: [],
+        added_classes: [],
+        removed_classes: [],
+        total_changes: 0
+      },
+      processing_time_ms: 0
+    };
   }
-  return native.classifyAndSortClasses(classes) || [];
-};
-var mergeCssDeclarations = (cssChunks) => {
+}
+function createFingerprint(filePath, fileContent) {
   const native = getNativeBridge();
-  if (!native?.mergeCssDeclarations) {
-    throw new Error("FATAL: Native binding 'mergeCssDeclarations' is required but not available.");
+  if (!native?.create_fingerprint) throw new Error("create_fingerprint not available");
+  const fingerprintJson = native.create_fingerprint(filePath, fileContent);
+  try {
+    return JSON.parse(fingerprintJson);
+  } catch {
+    return {
+      file_path: filePath,
+      content_hash: "",
+      size_bytes: fileContent.length,
+      mtime_ms: Date.now(),
+      class_hash: "",
+      signature: ""
+    };
   }
-  return native.mergeCssDeclarations(cssChunks) || { declarationsJson: "{}", declarationString: "", count: 0 };
-};
-var analyzeClassUsage = (classes, scanResultJson, css) => {
+}
+function injectStateHash(css, stateHash) {
   const native = getNativeBridge();
-  if (!native?.analyzeClassUsage) {
-    throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+  if (!native?.inject_state_hash) throw new Error("inject_state_hash not available");
+  const resultJson = native.inject_state_hash(css, stateHash);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      injected: false,
+      state_hash: stateHash,
+      affected_files: 0,
+      total_injected_bytes: 0
+    };
   }
-  return native.analyzeClassUsage(classes, scanResultJson, css) || [];
-};
-var analyzeRsc = (source, filename) => {
+}
+function pruneStaleCacheEntries(maxAgeSeconds, maxEntries) {
   const native = getNativeBridge();
-  if (!native?.analyzeRsc) {
-    throw new Error("FATAL: Native binding 'analyzeRsc' is required but not available.");
+  if (!native?.prune_stale_entries) throw new Error("prune_stale_entries not available");
+  const resultJson = native.prune_stale_entries(maxAgeSeconds, maxEntries);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      entries_before: 0,
+      entries_after: 0,
+      entries_removed: 0,
+      freed_bytes: 0
+    };
   }
-  return native.analyzeRsc(source, filename) || { isServer: true, needsClientDirective: false, clientReasons: [] };
-};
-var analyzeFile = (source, filename) => {
-  const rsc = analyzeRsc(source, filename);
-  return {
-    isServer: rsc?.isServer ?? true,
-    needsClientDirective: rsc?.needsClientDirective ?? false,
-    clientReasons: rsc?.clientReasons ?? [],
-    interactiveClasses: [],
-    canStaticResolveVariants: true
-  };
-};
-var analyzeVariantUsage = (source, componentName, variantKeys) => {
-  analyzeRsc(source, componentName);
-  return {
-    resolved: {},
-    dynamic: []
-  };
-};
-var injectClientDirective = (source) => {
-  if (!source.includes('"use client"') && !source.includes("'use client'")) {
-    return '"use client";\n' + source;
+}
+function rebuildWorkspaceResult(rootDir, extensions) {
+  const native = getNativeBridge();
+  if (!native?.rebuild_workspace_result)
+    throw new Error("rebuild_workspace_result not available");
+  const resultJson = native.rebuild_workspace_result(rootDir, extensions || []);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      total_files_scanned: 0,
+      total_classes_found: 0,
+      unique_classes: 0,
+      build_time_ms: 0,
+      files_with_changes: 0
+    };
   }
-  return source;
-};
-var injectServerOnlyComment = (source) => {
-  return `/* @server-only */
-${source}`;
-};
-var analyzeClasses = (filesJson, cwd, flags) => {
+}
+function scanFileNative(filePath, fileContent) {
   const native = getNativeBridge();
-  if (!native?.analyzeClasses) {
-    throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+  if (!native?.scan_file_native) throw new Error("scan_file_native not available");
+  const resultJson = native.scan_file_native(filePath, fileContent);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      file: filePath,
+      classes: [],
+      added_classes: [],
+      removed_classes: [],
+      changed: false
+    };
   }
-  return native.analyzeClasses(filesJson, cwd, flags);
-};
-var generateSafelist = (scanDirs, outputPath, cwd) => {
-  const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
-  const allClasses = Object.keys(classes).sort();
-  if (outputPath) {
-    const fs3 = __require("fs");
-    fs3.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
-  }
-  return allClasses;
-};
-var loadSafelist = (safelistPath) => {
-  const fs3 = __require("fs");
+}
+function scanFilesBatchNative(filesJson) {
+  const native = getNativeBridge();
+  if (!native?.scan_files_batch_native)
+    throw new Error("scan_files_batch_native not available");
+  const resultJson = native.scan_files_batch_native(filesJson);
   try {
-    const content = fs3.readFileSync(safelistPath, "utf-8");
-    return JSON.parse(content);
+    return JSON.parse(resultJson);
   } catch {
     return [];
   }
-};
-var loadTailwindConfig = (cwd = process.cwd()) => {
-  const fs3 = __require("fs");
-  const path3 = __require("path");
-  const configFiles = [
-    "tailwind.config.ts",
-    "tailwind.config.js",
-    "tailwind.config.mjs",
-    "tailwind.config.cjs"
-  ];
-  for (const file of configFiles) {
-    const fullPath = path3.join(cwd, file);
-    if (fs3.existsSync(fullPath)) {
-      const mod = __require(fullPath);
-      return mod.default || mod;
+}
+var init_streamingNative = __esm({
+  "packages/domain/compiler/src/compiler/streamingNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/compiler/tailwindEngine.ts
+var tailwindEngine_exports = {};
+__export(tailwindEngine_exports, {
+  clearCache: () => clearCache,
+  getCacheStats: () => getCacheStats2,
+  processTailwindCssWithTargets: () => processTailwindCssWithTargets,
+  runCssPipeline: () => runCssPipeline,
+  runCssPipelineSync: () => runCssPipelineSync
+});
+function _getCacheKey(classes, minify, cssEntry, root) {
+  const sorted = [...classes].sort().join(",");
+  const flags = `${minify ? "1" : "0"}${cssEntry ? "1" : "0"}${root ? "1" : "0"}`;
+  return `${sorted}|${flags}`;
+}
+function _evictOldestIfNeeded() {
+  if (_cssCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = _cssCache.keys().next().value;
+    if (firstKey !== void 0) {
+      _cssCache.delete(firstKey);
     }
   }
-  return {};
-};
-var getContentPaths = (cwd = process.cwd()) => {
-  const path3 = __require("path");
+}
+function getCacheStats2() {
+  const total = _cacheHits + _cacheMisses;
   return {
-    content: [
-      path3.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
-      path3.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
-      path3.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
-    ]
+    hits: _cacheHits,
+    misses: _cacheMisses,
+    hitRate: total > 0 ? _cacheHits / total : 0,
+    size: _cssCache.size,
+    maxSize: MAX_CACHE_SIZE
   };
-};
-var runLoaderTransform = (ctx) => {
-  const { filepath, source, options } = ctx;
-  const result = transformSource(source, { filename: filepath, ...options });
+}
+function clearCache() {
+  _cssCache.clear();
+  _cacheHits = 0;
+  _cacheMisses = 0;
+}
+function getThemeConfig() {
   return {
-    code: result?.code || "",
-    changed: result?.changed || false,
-    classes: result?.classes || []
+    colors: {
+      slate: {
+        "50": "#f8fafc",
+        "100": "#f1f5f9",
+        "200": "#e2e8f0",
+        "300": "#cbd5e1",
+        "400": "#94a3b8",
+        "500": "#64748b",
+        "600": "#475569",
+        "700": "#334155",
+        "800": "#1e293b",
+        "900": "#0f172a"
+      },
+      gray: {
+        "50": "#f9fafb",
+        "100": "#f3f4f6",
+        "200": "#e5e7eb",
+        "300": "#d1d5db",
+        "400": "#9ca3af",
+        "500": "#6b7280",
+        "600": "#4b5563",
+        "700": "#374151",
+        "800": "#1f2937",
+        "900": "#111827"
+      },
+      white: "#ffffff",
+      black: "#000000",
+      red: {
+        "500": "#ef4444",
+        "600": "#dc2626"
+      },
+      blue: {
+        "500": "#3b82f6",
+        "600": "#1e40af"
+      }
+    },
+    spacing: {
+      "0": "0px",
+      "1": "0.25rem",
+      "2": "0.5rem",
+      "3": "0.75rem",
+      "4": "1rem",
+      "5": "1.25rem",
+      "6": "1.5rem",
+      "8": "2rem",
+      "10": "2.5rem",
+      "12": "3rem",
+      "16": "4rem",
+      "20": "5rem",
+      "24": "6rem"
+    },
+    breakpoints: {
+      "sm": "640px",
+      "md": "768px",
+      "lg": "1024px",
+      "xl": "1280px",
+      "2xl": "1536px"
+    }
   };
-};
-var shouldSkipFile = (filepath) => {
-  const SKIP_PATHS = ["node_modules", ".next", ".rspack-dist", ".turbo", "dist/", "out/"];
-  const skipExtensions = [".css", ".json", ".md", ".txt", ".yaml", ".yml"];
-  for (const p of SKIP_PATHS) {
-    if (filepath.includes(p)) return true;
+}
+function postProcessWithLightning(rawCss) {
+  if (!rawCss) return "";
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssLightning) {
+    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
   }
-  for (const ext of skipExtensions) {
-    if (filepath.endsWith(ext)) return true;
+  const result = native.processTailwindCssLightning(rawCss);
+  if (!result?.css) {
+    throw new Error("FATAL: processTailwindCssLightning returned null");
   }
-  return false;
-};
-var fileToRoute = (filepath) => {
-  const normalized = filepath.replace(/\\/g, "/");
-  if (normalized.includes("/layout.") || normalized.includes("/loading.") || normalized.includes("/error.")) {
-    return "__global";
-  }
-  const pageMatch = normalized.match(/\/app\/(.+?)\/page\.[tj]sx?$/);
-  if (pageMatch) return `/${pageMatch[1]}`;
-  const rootPage = normalized.match(/\/app\/page\.[tj]sx?$/);
-  if (rootPage) return "/";
-  return null;
-};
-var getAllRoutes = () => {
-  const native = getNativeBridge();
-  if (!native?.analyzeClasses) {
-    throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+  return result.css;
+}
+async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
+  const filtered = classes.filter(Boolean);
+  const uniqueMap = /* @__PURE__ */ new Map();
+  filtered.forEach((cls) => uniqueMap.set(cls, cls));
+  const unique = Array.from(uniqueMap.values());
+  if (unique.length === 0) {
+    return { css: "", classes: [], sizeBytes: 0, optimized: false };
   }
-  return ["/", "__global"];
-};
-var getRouteClasses = (_route) => {
-  return /* @__PURE__ */ new Set();
-};
-var registerFileClasses = (_filepath, _classes) => {
-};
-var registerGlobalClasses = (_classes) => {
-};
-var _incrementalEngineInstance = null;
-var getIncrementalEngine = () => {
-  if (!_incrementalEngineInstance) {
-    _incrementalEngineInstance = new IncrementalEngine();
+  const cacheKey = _getCacheKey(unique, minify, cssEntryContent, root);
+  const cached = _cssCache.get(cacheKey);
+  if (cached) {
+    _cacheHits++;
+    if (process.env.DEBUG?.includes("compiler")) {
+      console.log(
+        `[Compiler] Cache HIT: ${unique.length} classes (hit rate: ${(getCacheStats2().hitRate * 100).toFixed(1)}%)`
+      );
+    }
+    return cached;
   }
-  return _incrementalEngineInstance;
-};
-var resetIncrementalEngine = () => {
-  _incrementalEngineInstance = null;
-};
-var IncrementalEngine = class {
-  compile(source) {
-    return transformSource(source);
+  _cacheMisses++;
+  let rawCss;
+  let usedRustCompiler = false;
+  const theme = getThemeConfig();
+  rawCss = await generateCssNative(unique, { theme });
+  usedRustCompiler = true;
+  const finalCss = minify ? postProcessWithLightning(rawCss) : rawCss;
+  if (process.env.DEBUG?.includes("compiler")) {
+    console.log(
+      `[Compiler] Generated CSS from ${unique.length} classes (${usedRustCompiler ? "Rust" : "JavaScript"})`,
+      `Size: ${finalCss.length} bytes`
+    );
   }
-};
-var getBucketEngine = () => {
+  const result = {
+    css: finalCss,
+    classes: unique,
+    sizeBytes: finalCss.length,
+    optimized: minify
+  };
+  _evictOldestIfNeeded();
+  _cssCache.set(cacheKey, result);
+  return result;
+}
+function runCssPipelineSync(_classes) {
+  return { css: "", classes: [], sizeBytes: 0, optimized: false };
+}
+function processTailwindCssWithTargets(css, targets) {
   const native = getNativeBridge();
-  if (!native?.classifyAndSortClasses) {
-    throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+  if (!native?.processTailwindCssWithTargets) {
+    throw new Error("FATAL: Native binding 'processTailwindCssWithTargets' is required but not available.");
+  }
+  const result = native.processTailwindCssWithTargets(css, targets ?? null);
+  if (!result?.css) {
+    throw new Error("FATAL: processTailwindCssWithTargets returned null");
+  }
+  return result.css;
+}
+var _cssCache, _cacheHits, _cacheMisses, MAX_CACHE_SIZE;
+var init_tailwindEngine = __esm({
+  "packages/domain/compiler/src/compiler/tailwindEngine.ts"() {
+    init_nativeBridge();
+    init_cssGeneratorNative();
+    createRequire(import.meta.url);
+    _cssCache = /* @__PURE__ */ new Map();
+    _cacheHits = 0;
+    _cacheMisses = 0;
+    MAX_CACHE_SIZE = 100;
+  }
+});
+
+// packages/domain/compiler/src/compiler/index.ts
+var init_compiler = __esm({
+  "packages/domain/compiler/src/compiler/index.ts"() {
+    init_cssGeneratorNative();
+    init_compilationNative();
+    init_cssCompilationNative();
+    init_idRegistryNative();
+    init_streamingNative();
+    init_tailwindEngine();
   }
+});
+
+// packages/domain/compiler/src/parser/index.ts
+var parser_exports = {};
+__export(parser_exports, {
+  astExtractClasses: () => astExtractClasses,
+  batchExtractClasses: () => batchExtractClasses,
+  checkAgainstSafelist: () => checkAgainstSafelist,
+  diffClassLists: () => diffClassLists,
+  extractAllClasses: () => extractAllClasses,
+  extractClassesFromSource: () => extractClassesFromSource,
+  extractComponentUsage: () => extractComponentUsage,
+  mergeClassesStatic: () => mergeClassesStatic,
+  normalizeAndDedupClasses: () => normalizeAndDedupClasses,
+  normalizeClasses: () => normalizeClasses,
+  parseClasses: () => parseClasses
+});
+var parseClasses, extractAllClasses, extractClassesFromSource, astExtractClasses, normalizeClasses, mergeClassesStatic, normalizeAndDedupClasses, extractComponentUsage, batchExtractClasses, checkAgainstSafelist, diffClassLists;
+var init_parser = __esm({
+  "packages/domain/compiler/src/parser/index.ts"() {
+    init_nativeBridge();
+    parseClasses = (raw) => {
+      const native = getNativeBridge();
+      if (!native?.parseClasses) {
+        throw new Error("FATAL: Native binding 'parseClasses' is required but not available.");
+      }
+      return native.parseClasses(raw) || [];
+    };
+    extractAllClasses = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractAllClasses) {
+        throw new Error("FATAL: Native binding 'extractAllClasses' is required but not available.");
+      }
+      return native.extractAllClasses(source) || [];
+    };
+    extractClassesFromSource = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractClassesFromSource) {
+        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
+      }
+      const result = native.extractClassesFromSource(source);
+      return Array.isArray(result) ? result.join(" ") : String(result || "");
+    };
+    astExtractClasses = (source, _filename) => {
+      const native = getNativeBridge();
+      if (!native?.extractClassesFromSource) {
+        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
+      }
+      return native.extractClassesFromSource(source) || [];
+    };
+    normalizeClasses = (raw) => {
+      const result = normalizeAndDedupClasses(raw);
+      return result?.normalized || "";
+    };
+    mergeClassesStatic = (classes) => {
+      const result = normalizeAndDedupClasses(classes);
+      return result?.normalized || "";
+    };
+    normalizeAndDedupClasses = (raw) => {
+      const native = getNativeBridge();
+      if (!native?.normalizeAndDedupClasses) {
+        throw new Error("FATAL: Native binding 'normalizeAndDedupClasses' is required but not available.");
+      }
+      const result = native.normalizeAndDedupClasses(raw);
+      return result || { normalized: "", duplicatesRemoved: 0, uniqueCount: 0 };
+    };
+    extractComponentUsage = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractComponentUsage) {
+        throw new Error("FATAL: Native binding 'extractComponentUsage' is required but not available.");
+      }
+      return native.extractComponentUsage(source) || [];
+    };
+    batchExtractClasses = (filePaths) => {
+      const native = getNativeBridge();
+      if (!native?.batchExtractClasses) {
+        throw new Error("FATAL: Native binding 'batchExtractClasses' is required but not available.");
+      }
+      return native.batchExtractClasses(filePaths) || [];
+    };
+    checkAgainstSafelist = (classes, safelist) => {
+      const native = getNativeBridge();
+      if (!native?.checkAgainstSafelist) {
+        throw new Error("FATAL: Native binding 'checkAgainstSafelist' is required but not available.");
+      }
+      return native.checkAgainstSafelist(classes, safelist) || { matched: [], unmatched: [], safelistSize: 0 };
+    };
+    diffClassLists = (previous, current) => {
+      const native = getNativeBridge();
+      if (!native?.diffClassLists) {
+        throw new Error("FATAL: Native binding 'diffClassLists' is required but not available.");
+      }
+      return native.diffClassLists(previous, current) || { added: [], removed: [], unchanged: [], hasChanges: false };
+    };
+  }
+});
+
+// packages/domain/compiler/src/analyzer/analyzerNative.ts
+function detectDeadCode(scanResultJson, css) {
+  const native = getNativeBridge();
+  if (!native?.detectDeadCode) throw new Error("detectDeadCode not available");
+  return native.detectDeadCode(scanResultJson, css);
+}
+function analyzeClassUsageNative(classes, scanResultJson, css) {
+  const native = getNativeBridge();
+  if (!native?.analyzeClassUsage) throw new Error("analyzeClassUsage not available");
+  return native.analyzeClassUsage(classes, scanResultJson, css);
+}
+function analyzeClassesNative(filesJson, cwd, flags) {
+  const native = getNativeBridge();
+  if (!native?.analyzeClasses) throw new Error("analyzeClasses not available");
+  return native.analyzeClasses(filesJson, cwd, flags ?? 0);
+}
+function analyzeRscNative(source, filename) {
+  const native = getNativeBridge();
+  if (!native?.analyzeRsc) throw new Error("analyzeRsc not available");
+  return native.analyzeRsc(source, filename);
+}
+function optimizeCssNative(css) {
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssLightning) throw new Error("processTailwindCssLightning not available");
+  const result = native.processTailwindCssLightning(css);
   return {
-    add: (className) => className,
-    get: (_bucket) => []
+    css: result.css,
+    originalSize: css.length,
+    optimizedSize: result.size_bytes,
+    reductionPercentage: (css.length - result.size_bytes) / css.length * 100
   };
-};
-var resetBucketEngine = () => {
-};
-var BucketEngine = class {
-  add(className) {
-    return className;
+}
+function processTailwindCssLightning(css) {
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssLightning) throw new Error("processTailwindCssLightning not available");
+  return native.processTailwindCssLightning(css);
+}
+function eliminateDeadCssNative(css, deadClasses) {
+  const native = getNativeBridge();
+  if (!native?.eliminateDeadCss) throw new Error("eliminateDeadCss not available");
+  return native.eliminateDeadCss(css, deadClasses);
+}
+function hoistComponentsNative(source) {
+  const native = getNativeBridge();
+  if (!native?.hoistComponents) throw new Error("hoistComponents not available");
+  return native.hoistComponents(source);
+}
+function compileVariantTableNative(configJson) {
+  const native = getNativeBridge();
+  if (!native?.compileVariantTable) throw new Error("compileVariantTable not available");
+  return native.compileVariantTable(configJson);
+}
+function classifyAndSortClassesNative(classes) {
+  const native = getNativeBridge();
+  if (!native?.classifyAndSortClasses) throw new Error("classifyAndSortClasses not available");
+  return native.classifyAndSortClasses(classes);
+}
+function mergeCssDeclarationsNative(cssChunks) {
+  const native = getNativeBridge();
+  if (!native?.mergeCssDeclarations) throw new Error("mergeCssDeclarations not available");
+  return native.mergeCssDeclarations(cssChunks);
+}
+var init_analyzerNative = __esm({
+  "packages/domain/compiler/src/analyzer/analyzerNative.ts"() {
+    init_nativeBridge();
   }
-};
-var classifyNode = (_node) => {
+});
+
+// packages/domain/compiler/src/analyzer/themeResolutionNative.ts
+function resolveVariants(configJson) {
   const native = getNativeBridge();
-  if (!native?.classifyAndSortClasses) {
-    throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+  if (!native?.resolve_variants) throw new Error("resolve_variants not available");
+  const resultJson = native.resolve_variants(configJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      variants: [],
+      supported: [],
+      deprecated: [],
+      conflicting: []
+    };
   }
-  return "unknown";
-};
-var detectConflicts = (classes) => {
+}
+function validateThemeConfig(configJson) {
   const native = getNativeBridge();
-  if (!native?.analyzeClassUsage) {
-    throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+  if (!native?.validate_variant_config) throw new Error("validate_variant_config not available");
+  const resultJson = native.validate_variant_config(configJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      is_valid: false,
+      errors: ["Unable to parse configuration"],
+      warnings: [],
+      suggestions: []
+    };
   }
-  return [];
-};
-var bucketSort = (classes) => {
-  return classifyAndSortClasses(classes).map((c) => c.raw ?? c);
-};
+}
+function resolveCascade(baseThemeJson, overridesJson) {
+  const native = getNativeBridge();
+  if (!native?.resolve_cascade) throw new Error("resolve_cascade not available");
+  const resultJson = native.resolve_cascade(baseThemeJson, overridesJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      base_theme: {},
+      user_overrides: {},
+      merged_theme: {},
+      conflict_resolutions: []
+    };
+  }
+}
+function resolveClassNames(classNames, themeJson) {
+  const native = getNativeBridge();
+  if (!native?.resolve_class_names) throw new Error("resolve_class_names not available");
+  const resultJson = native.resolve_class_names(classNames, themeJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return [];
+  }
+}
+function resolveConflictGroup(groupName, themeJson) {
+  const native = getNativeBridge();
+  if (!native?.resolve_conflict_group)
+    throw new Error("resolve_conflict_group not available");
+  const resultJson = native.resolve_conflict_group(groupName, themeJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      group_name: groupName,
+      conflicting_classes: [],
+      description: "",
+      resolution_strategy: "last-wins"
+    };
+  }
+}
+function resolveThemeValue(keyPath, themeJson) {
+  const native = getNativeBridge();
+  if (!native?.resolve_theme_value) throw new Error("resolve_theme_value not available");
+  return native.resolve_theme_value(keyPath, themeJson);
+}
+function resolveSimpleVariants(configJson) {
+  const native = getNativeBridge();
+  if (!native?.resolve_simple_variants) throw new Error("resolve_simple_variants not available");
+  const resultJson = native.resolve_simple_variants(configJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return [];
+  }
+}
+var init_themeResolutionNative = __esm({
+  "packages/domain/compiler/src/analyzer/themeResolutionNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/analyzer/scannerNative.ts
+function scanWorkspace(root, extensions) {
+  const native = getNativeBridge();
+  if (!native?.scan_workspace) throw new Error("scan_workspace not available");
+  return native.scan_workspace(root, extensions);
+}
+function extractClassesFromSourceNative(source) {
+  const native = getNativeBridge();
+  if (!native?.extract_classes_from_source) throw new Error("extract_classes_from_source not available");
+  return native.extract_classes_from_source(source);
+}
+function batchExtractClassesNative(filePaths) {
+  const native = getNativeBridge();
+  if (!native?.batch_extract_classes) throw new Error("batch_extract_classes not available");
+  return native.batch_extract_classes(filePaths);
+}
+function checkAgainstSafelistNative(classes, safelist) {
+  const native = getNativeBridge();
+  if (!native?.check_against_safelist) throw new Error("check_against_safelist not available");
+  return native.check_against_safelist(classes, safelist);
+}
+function scanFile(filePath) {
+  const native = getNativeBridge();
+  if (!native?.scan_file) throw new Error("scan_file not available");
+  return native.scan_file(filePath);
+}
+function collectFiles(root, extensions) {
+  const native = getNativeBridge();
+  if (!native?.collect_files) throw new Error("collect_files not available");
+  return native.collect_files(root, extensions);
+}
+function walkAndPrefilterSourceFiles(root, extensions, _parallel) {
+  const native = getNativeBridge();
+  if (!native?.walk_and_prefilter_source_files) throw new Error("walk_and_prefilter_source_files not available");
+  return native.walk_and_prefilter_source_files(root, extensions);
+}
+function generateSubComponentTypes(root, outputPath) {
+  const native = getNativeBridge();
+  if (!native?.generate_sub_component_types) throw new Error("generate_sub_component_types not available");
+  return native.generate_sub_component_types(root, outputPath);
+}
+var init_scannerNative = __esm({
+  "packages/domain/compiler/src/analyzer/scannerNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/analyzer/index.ts
+var init_analyzer = __esm({
+  "packages/domain/compiler/src/analyzer/index.ts"() {
+    init_analyzerNative();
+    init_themeResolutionNative();
+    init_scannerNative();
+  }
+});
+
+// packages/domain/compiler/src/cache/cacheNative.ts
+function getCacheStatistics() {
+  const native = getNativeBridge();
+  if (!native?.get_cache_statistics) throw new Error("get_cache_statistics not available");
+  const statsJson = native.get_cache_statistics();
+  try {
+    return JSON.parse(statsJson);
+  } catch {
+    return {
+      parse_cache: { hits: 0, misses: 0, size: 0 },
+      resolve_cache: { hits: 0, misses: 0, size: 0 },
+      compile_cache: { hits: 0, misses: 0, size: 0 },
+      css_gen_cache: { hits: 0, misses: 0, size: 0 },
+      overall_hit_rate: 0,
+      total_memory_bytes: 0
+    };
+  }
+}
+function clearAllCaches() {
+  const native = getNativeBridge();
+  if (!native?.clear_all_caches) return;
+  try {
+    native.clear_all_caches();
+  } catch {
+  }
+}
+function clearParseCache() {
+  const native = getNativeBridge();
+  if (!native?.clear_parse_cache) return;
+  try {
+    native.clear_parse_cache();
+  } catch {
+  }
+}
+function clearResolveCache() {
+  const native = getNativeBridge();
+  if (!native?.clear_resolve_cache) return;
+  try {
+    native.clear_resolve_cache();
+  } catch {
+  }
+}
+function clearCompileCache() {
+  const native = getNativeBridge();
+  if (!native?.clear_compile_cache) return;
+  try {
+    native.clear_compile_cache();
+  } catch {
+  }
+}
+function clearCssGenCache() {
+  const native = getNativeBridge();
+  if (!native?.clear_css_gen_cache) return;
+  try {
+    native.clear_css_gen_cache();
+  } catch {
+  }
+}
+function getCacheOptimizationHints(hitRatePercent, memoryUsedMb) {
+  const native = getNativeBridge();
+  if (!native?.get_cache_optimization_hints)
+    throw new Error("get_cache_optimization_hints not available");
+  const hintsJson = native.get_cache_optimization_hints(
+    Math.min(100, Math.max(0, hitRatePercent)),
+    Math.max(1, memoryUsedMb)
+  );
+  try {
+    return JSON.parse(hintsJson);
+  } catch {
+    return {
+      current_strategy: "unknown",
+      recommended_strategy: "increase_size",
+      estimated_improvement_percent: 0,
+      suggested_memory_mb: 256,
+      notes: ["Unable to analyze cache statistics"]
+    };
+  }
+}
+function estimateOptimalCacheConfig(totalBudgetMb, workloadType) {
+  const native = getNativeBridge();
+  if (!native?.estimate_optimal_cache_config_native)
+    throw new Error("estimate_optimal_cache_config_native not available");
+  const configJson = native.estimate_optimal_cache_config_native(
+    Math.max(64, totalBudgetMb),
+    workloadType
+  );
+  try {
+    return JSON.parse(configJson);
+  } catch {
+    return {
+      parse_cache_size: 128,
+      resolve_cache_size: 64,
+      compile_cache_size: 256,
+      css_gen_cache_size: 128,
+      recommended_eviction_policy: "lru",
+      ttl_seconds: 3600,
+      expected_hit_rate_percent: 75
+    };
+  }
+}
+function cacheRead(cachePath) {
+  const native = getNativeBridge();
+  if (!native?.cache_read) throw new Error("cache_read not available");
+  const result = native.cache_read(cachePath);
+  try {
+    return JSON.parse(result.entries_json || "[]");
+  } catch {
+    return [];
+  }
+}
+function cacheWrite(cachePath, entries) {
+  const native = getNativeBridge();
+  if (!native?.cache_write) throw new Error("cache_write not available");
+  try {
+    const result = native.cache_write(
+      cachePath,
+      entries.map((e) => ({
+        file: e.file,
+        content_hash: e.contentHash,
+        classes: e.classes,
+        mtime_ms: e.mtimeMs,
+        size_bytes: e.sizeBytes
+      }))
+    );
+    return typeof result === "boolean" ? result : result === true;
+  } catch {
+    return false;
+  }
+}
+function cachePriority(mtimeMs, sizeBytes, hitCount) {
+  const native = getNativeBridge();
+  if (!native?.cache_priority) throw new Error("cache_priority not available");
+  return native.cache_priority(mtimeMs, sizeBytes, hitCount);
+}
+var init_cacheNative = __esm({
+  "packages/domain/compiler/src/cache/cacheNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/cache/index.ts
+var init_cache = __esm({
+  "packages/domain/compiler/src/cache/index.ts"() {
+    init_cacheNative();
+  }
+});
+
+// packages/domain/compiler/src/redis/redisNative.ts
+function redisPing() {
+  const native = getNativeBridge();
+  if (!native?.redis_ping) throw new Error("redis_ping not available");
+  return native.redis_ping();
+}
+function redisGet(key) {
+  const native = getNativeBridge();
+  if (!native?.redis_get) throw new Error("redis_get not available");
+  const result = native.redis_get(key);
+  return result === "nil" ? null : result;
+}
+function redisSet(key, value, ttl_seconds) {
+  const native = getNativeBridge();
+  if (!native?.redis_set) throw new Error("redis_set not available");
+  return native.redis_set(key, value, ttl_seconds);
+}
+function redisDelete(key) {
+  const native = getNativeBridge();
+  if (!native?.redis_delete) throw new Error("redis_delete not available");
+  return native.redis_delete(key);
+}
+function redisExists(key) {
+  const native = getNativeBridge();
+  if (!native?.redis_exists) throw new Error("redis_exists not available");
+  return native.redis_exists(key);
+}
+function redisMget(keys) {
+  const native = getNativeBridge();
+  if (!native?.redis_mget) throw new Error("redis_mget not available");
+  const result = native.redis_mget(keys);
+  try {
+    return JSON.parse(result);
+  } catch {
+    return keys.map(() => null);
+  }
+}
+function redisMset(pairs) {
+  const native = getNativeBridge();
+  if (!native?.redis_mset) throw new Error("redis_mset not available");
+  return native.redis_mset(pairs);
+}
+function redisFlushDb() {
+  const native = getNativeBridge();
+  if (!native?.redis_flush_db) throw new Error("redis_flush_db not available");
+  return native.redis_flush_db();
+}
+function redisFlushAll() {
+  const native = getNativeBridge();
+  if (!native?.redis_flush_all) throw new Error("redis_flush_all not available");
+  return native.redis_flush_all();
+}
+function redisPoolConnect(host, port, pool_size) {
+  const native = getNativeBridge();
+  if (!native?.redis_pool_connect) throw new Error("redis_pool_connect not available");
+  return native.redis_pool_connect(host, port, pool_size);
+}
+function redisPoolStats() {
+  const native = getNativeBridge();
+  if (!native?.redis_pool_stats) throw new Error("redis_pool_stats not available");
+  const result = native.redis_pool_stats();
+  try {
+    return JSON.parse(result);
+  } catch {
+    return {
+      connected_count: 0,
+      idle_count: 0,
+      waiting_count: 0,
+      total_requests: 0,
+      total_errors: 0
+    };
+  }
+}
+function redisPoolReconnect() {
+  const native = getNativeBridge();
+  if (!native?.redis_pool_reconnect) throw new Error("redis_pool_reconnect not available");
+  return native.redis_pool_reconnect();
+}
+function redisEnableCluster(initial_nodes) {
+  const native = getNativeBridge();
+  if (!native?.redis_enable_cluster) throw new Error("redis_enable_cluster not available");
+  const result = native.redis_enable_cluster(initial_nodes);
+  try {
+    return JSON.parse(result);
+  } catch {
+    return {
+      enabled: false,
+      cluster_state: "error",
+      nodes: [],
+      slots_assigned: 0,
+      slots_ok: 0,
+      slots_fail: 0
+    };
+  }
+}
+function redisDisableCluster() {
+  const native = getNativeBridge();
+  if (!native?.redis_disable_cluster) throw new Error("redis_disable_cluster not available");
+  return native.redis_disable_cluster();
+}
+function redisClusterStatus() {
+  const native = getNativeBridge();
+  if (!native?.redis_cluster_status) throw new Error("redis_cluster_status not available");
+  const result = native.redis_cluster_status();
+  try {
+    return JSON.parse(result);
+  } catch {
+    return {
+      enabled: false,
+      cluster_state: "unknown",
+      nodes: [],
+      slots_assigned: 0,
+      slots_ok: 0,
+      slots_fail: 0
+    };
+  }
+}
+function redisSubscribe(channel) {
+  const native = getNativeBridge();
+  if (!native?.redis_subscribe) throw new Error("redis_subscribe not available");
+  return native.redis_subscribe(channel);
+}
+function redisPublish(channel, message) {
+  const native = getNativeBridge();
+  if (!native?.redis_publish) throw new Error("redis_publish not available");
+  return native.redis_publish(channel, message);
+}
+function redisExpirationSet(key, ttl_seconds) {
+  const native = getNativeBridge();
+  if (!native?.redis_expiration_set) throw new Error("redis_expiration_set not available");
+  return native.redis_expiration_set(key, ttl_seconds);
+}
+function redisExpirationGet(key) {
+  const native = getNativeBridge();
+  if (!native?.redis_expiration_get) throw new Error("redis_expiration_get not available");
+  const result = native.redis_expiration_get(key);
+  try {
+    return JSON.parse(result);
+  } catch {
+    return {
+      key,
+      ttl_seconds: -1,
+      expiration_timestamp: 0,
+      is_persistent: true
+    };
+  }
+}
+function redisInfo() {
+  const native = getNativeBridge();
+  if (!native?.redis_info) throw new Error("redis_info not available");
+  return native.redis_info();
+}
+function redisMonitor() {
+  const native = getNativeBridge();
+  if (!native?.redis_monitor) throw new Error("redis_monitor not available");
+  return native.redis_monitor();
+}
+function redisCacheSize() {
+  const native = getNativeBridge();
+  if (!native?.redis_cache_size) throw new Error("redis_cache_size not available");
+  return native.redis_cache_size();
+}
+function redisCacheKeyCount() {
+  const native = getNativeBridge();
+  if (!native?.redis_cache_key_count) throw new Error("redis_cache_key_count not available");
+  return native.redis_cache_key_count();
+}
+function redisCacheClear() {
+  const native = getNativeBridge();
+  if (!native?.redis_cache_clear) throw new Error("redis_cache_clear not available");
+  return native.redis_cache_clear();
+}
+function redisCacheHitRate() {
+  const native = getNativeBridge();
+  if (!native?.redis_cache_hit_rate) throw new Error("redis_cache_hit_rate not available");
+  return native.redis_cache_hit_rate();
+}
+function redisEnablePersistence(mode) {
+  const native = getNativeBridge();
+  if (!native?.redis_enable_persistence) throw new Error("redis_enable_persistence not available");
+  return native.redis_enable_persistence(mode);
+}
+function redisDisablePersistence() {
+  const native = getNativeBridge();
+  if (!native?.redis_disable_persistence) throw new Error("redis_disable_persistence not available");
+  return native.redis_disable_persistence();
+}
+function redisSnapshot() {
+  const native = getNativeBridge();
+  if (!native?.redis_snapshot) throw new Error("redis_snapshot not available");
+  return native.redis_snapshot();
+}
+function redisMemoryStats() {
+  const native = getNativeBridge();
+  if (!native?.redis_memory_stats) throw new Error("redis_memory_stats not available");
+  return native.redis_memory_stats();
+}
+function redisOptimizeMemory() {
+  const native = getNativeBridge();
+  if (!native?.redis_optimize_memory) throw new Error("redis_optimize_memory not available");
+  return native.redis_optimize_memory();
+}
+function redisSetEvictionPolicy(policy) {
+  const native = getNativeBridge();
+  if (!native?.redis_set_eviction_policy) throw new Error("redis_set_eviction_policy not available");
+  return native.redis_set_eviction_policy(policy);
+}
+function redisGetEvictionPolicy() {
+  const native = getNativeBridge();
+  if (!native?.redis_get_eviction_policy) throw new Error("redis_get_eviction_policy not available");
+  return native.redis_get_eviction_policy();
+}
+function redisReplicate(target_host, target_port) {
+  const native = getNativeBridge();
+  if (!native?.redis_replicate) throw new Error("redis_replicate not available");
+  return native.redis_replicate(target_host, target_port);
+}
+function redisReplicationStatus() {
+  const native = getNativeBridge();
+  if (!native?.redis_replication_status) throw new Error("redis_replication_status not available");
+  return native.redis_replication_status();
+}
+function redisCacheSync(peers) {
+  const native = getNativeBridge();
+  if (!native?.redis_cache_sync) throw new Error("redis_cache_sync not available");
+  return native.redis_cache_sync(peers);
+}
+function redisEnableCacheWarming(key_pattern) {
+  const native = getNativeBridge();
+  if (!native?.redis_enable_cache_warming) throw new Error("redis_enable_cache_warming not available");
+  return native.redis_enable_cache_warming(key_pattern);
+}
+function redisDisableCacheWarming() {
+  const native = getNativeBridge();
+  if (!native?.redis_disable_cache_warming) throw new Error("redis_disable_cache_warming not available");
+  return native.redis_disable_cache_warming();
+}
+function redisDiagnose() {
+  const native = getNativeBridge();
+  if (!native?.redis_diagnose) throw new Error("redis_diagnose not available");
+  return native.redis_diagnose();
+}
+var init_redisNative = __esm({
+  "packages/domain/compiler/src/redis/redisNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/redis/index.ts
+var init_redis = __esm({
+  "packages/domain/compiler/src/redis/index.ts"() {
+    init_redisNative();
+  }
+});
+
+// packages/domain/compiler/src/watch/watchSystemNative.ts
+function startWatch(root_path, patterns) {
+  const native = getNativeBridge();
+  if (!native?.start_watch) throw new Error("start_watch not available");
+  return native.start_watch(root_path, patterns);
+}
+function pollWatchEvents(handle, timeout_ms) {
+  const native = getNativeBridge();
+  if (!native?.poll_watch_events) throw new Error("poll_watch_events not available");
+  const result = native.poll_watch_events(handle, timeout_ms);
+  try {
+    return JSON.parse(result);
+  } catch {
+    return [];
+  }
+}
+function stopWatch(handle) {
+  const native = getNativeBridge();
+  if (!native?.stop_watch) throw new Error("stop_watch not available");
+  return native.stop_watch(handle);
+}
+function watchAddPattern(handle, pattern) {
+  const native = getNativeBridge();
+  if (!native?.watch_add_pattern) throw new Error("watch_add_pattern not available");
+  return native.watch_add_pattern(handle, pattern);
+}
+function watchRemovePattern(handle, pattern) {
+  const native = getNativeBridge();
+  if (!native?.watch_remove_pattern) throw new Error("watch_remove_pattern not available");
+  return native.watch_remove_pattern(handle, pattern);
+}
+function watchGetActiveHandles() {
+  const native = getNativeBridge();
+  if (!native?.watch_get_active_handles) throw new Error("watch_get_active_handles not available");
+  const result = native.watch_get_active_handles();
+  try {
+    return JSON.parse(result);
+  } catch {
+    return [];
+  }
+}
+function watchClearAll() {
+  const native = getNativeBridge();
+  if (!native?.watch_clear_all) throw new Error("watch_clear_all not available");
+  return native.watch_clear_all();
+}
+function watchEventTypeToString(event_type_code) {
+  const native = getNativeBridge();
+  if (!native?.watch_event_type_to_string) throw new Error("watch_event_type_to_string not available");
+  return native.watch_event_type_to_string(event_type_code);
+}
+function isWatchRunning(handle) {
+  const native = getNativeBridge();
+  if (!native?.is_watch_running) throw new Error("is_watch_running not available");
+  return native.is_watch_running(handle);
+}
+function getWatchStats() {
+  const native = getNativeBridge();
+  if (!native?.get_watch_stats) throw new Error("get_watch_stats not available");
+  const result = native.get_watch_stats();
+  try {
+    return JSON.parse(result);
+  } catch {
+    return {
+      active_watchers: 0,
+      total_events: 0,
+      events_this_second: 0,
+      average_latency_ms: 0,
+      largest_batch_size: 0
+    };
+  }
+}
+function watchPause(handle) {
+  const native = getNativeBridge();
+  if (!native?.watch_pause) throw new Error("watch_pause not available");
+  return native.watch_pause(handle);
+}
+function watchResume(handle) {
+  const native = getNativeBridge();
+  if (!native?.watch_resume) throw new Error("watch_resume not available");
+  return native.watch_resume(handle);
+}
+function scanCacheOptimizations() {
+  const native = getNativeBridge();
+  if (!native?.scan_cache_optimizations) throw new Error("scan_cache_optimizations not available");
+  return native.scan_cache_optimizations();
+}
+function getPluginHooks() {
+  const native = getNativeBridge();
+  if (!native?.get_plugin_hooks) throw new Error("get_plugin_hooks not available");
+  const result = native.get_plugin_hooks();
+  try {
+    return JSON.parse(result);
+  } catch {
+    return [];
+  }
+}
+function registerPluginHook(hook_name, handler_id) {
+  const native = getNativeBridge();
+  if (!native?.register_plugin_hook) throw new Error("register_plugin_hook not available");
+  return native.register_plugin_hook(hook_name, handler_id);
+}
+function unregisterPluginHook(hook_name, handler_id) {
+  const native = getNativeBridge();
+  if (!native?.unregister_plugin_hook) throw new Error("unregister_plugin_hook not available");
+  return native.unregister_plugin_hook(hook_name, handler_id);
+}
+function emitPluginHook(hook_name, data_json) {
+  const native = getNativeBridge();
+  if (!native?.emit_plugin_hook) throw new Error("emit_plugin_hook not available");
+  return native.emit_plugin_hook(hook_name, data_json);
+}
+function getCompilationMetrics() {
+  const native = getNativeBridge();
+  if (!native?.get_compilation_metrics) throw new Error("get_compilation_metrics not available");
+  return native.get_compilation_metrics();
+}
+function resetCompilationMetrics() {
+  const native = getNativeBridge();
+  if (!native?.reset_compilation_metrics) throw new Error("reset_compilation_metrics not available");
+  return native.reset_compilation_metrics();
+}
+function validateCssOutput(css) {
+  const native = getNativeBridge();
+  if (!native?.validate_css_output) throw new Error("validate_css_output not available");
+  return native.validate_css_output(css);
+}
+function getCompilerDiagnostics() {
+  const native = getNativeBridge();
+  if (!native?.get_compiler_diagnostics) throw new Error("get_compiler_diagnostics not available");
+  return native.get_compiler_diagnostics();
+}
+var init_watchSystemNative = __esm({
+  "packages/domain/compiler/src/watch/watchSystemNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/watch/index.ts
+var init_watch = __esm({
+  "packages/domain/compiler/src/watch/index.ts"() {
+    init_watchSystemNative();
+  }
+});
+function _layoutClassesToCss(classes) {
+  const native = getNativeBridge();
+  if (!native?.layoutClassesToCss) {
+    throw new Error("FATAL: Native binding 'layoutClassesToCss' is required but not available.");
+  }
+  return native.layoutClassesToCss(classes);
+}
+function _hashContainer(tag, containerJson, name) {
+  const sortedKey = tag + (name ?? "") + containerJson;
+  const native = getNativeBridge();
+  if (!native?.hashContent) {
+    throw new Error("FATAL: Native binding 'hashContent' is required but not available.");
+  }
+  return `tw-cq-${native.hashContent(sortedKey, "fnv", 6)}`;
+}
+function extractContainerCssFromSource(source) {
+  const native = getNativeBridge();
+  if (!native?.extractTwContainerConfigs) {
+    throw new Error("FATAL: Native binding 'extractTwContainerConfigs' is required but not available.");
+  }
+  const configs = native.extractTwContainerConfigs(source);
+  const rules = [];
+  for (const cfg of configs) {
+    const id = _hashContainer(cfg.tag, cfg.containerJson, cfg.containerName);
+    for (const { key, classes } of cfg.breakpoints) {
+      const minWidth = _CONTAINER_BREAKPOINTS[key] ?? key;
+      const css = _layoutClassesToCss(classes);
+      if (!css) continue;
+      const query = cfg.containerName ? `@container ${cfg.containerName} (min-width: ${minWidth})` : `@container (min-width: ${minWidth})`;
+      rules.push(`${query}{.${id}{${css}}}`);
+    }
+  }
+  return rules.join("\n");
+}
+var transformSource, hasTwUsage, isAlreadyTransformed, shouldProcess, compileCssFromClasses, buildStyleTag, generateCssForClasses, eliminateDeadCss, findDeadVariants, runElimination, scanProjectUsage, generateSafelist, loadSafelist, loadTailwindConfig, getContentPaths, _CONTAINER_BREAKPOINTS, runLoaderTransform, shouldSkipFile, fileToRoute, getAllRoutes, getRouteClasses, registerFileClasses, registerGlobalClasses, _incrementalEngineInstance, getIncrementalEngine, resetIncrementalEngine, IncrementalEngine, getBucketEngine, resetBucketEngine, BucketEngine, classifyNode, detectConflicts, bucketSort, analyzeFile, analyzeVariantUsage, injectClientDirective, injectServerOnlyComment, analyzeClasses, extractTwStateConfigs, generateStaticStateCss, extractAndGenerateStateCss;
+var init_src2 = __esm({
+  "packages/domain/compiler/src/index.ts"() {
+    init_nativeBridge();
+    init_compiler();
+    init_parser();
+    init_analyzer();
+    init_cache();
+    init_redis();
+    init_watch();
+    transformSource = (source, opts) => {
+      const native = getNativeBridge();
+      if (!native?.transformSource) {
+        throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+      }
+      const result = native.transformSource(source, opts);
+      if (!result) {
+        throw new Error("FATAL: transformSource returned null");
+      }
+      return result;
+    };
+    hasTwUsage = (source) => {
+      const native = getNativeBridge();
+      if (!native?.hasTwUsage) {
+        throw new Error("FATAL: Native binding 'hasTwUsage' is required but not available.");
+      }
+      return native.hasTwUsage(source);
+    };
+    isAlreadyTransformed = (source) => {
+      const native = getNativeBridge();
+      if (!native?.isAlreadyTransformed) {
+        throw new Error("FATAL: Native binding 'isAlreadyTransformed' is required but not available.");
+      }
+      return native.isAlreadyTransformed(source);
+    };
+    shouldProcess = (source) => {
+      return hasTwUsage(source) && !isAlreadyTransformed(source);
+    };
+    compileCssFromClasses = (classes, prefix) => {
+      const native = getNativeBridge();
+      if (!native?.transformSource) {
+        throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+      }
+      const result = native.transformSource(classes.join(" "), { prefix: prefix ?? "" });
+      if (!result) {
+        throw new Error("FATAL: transformSource returned null");
+      }
+      return result;
+    };
+    buildStyleTag = (classes) => {
+      const result = compileCssFromClasses(classes);
+      return result?.code ? `<style data-tailwind-styled>${result.code}</style>` : "";
+    };
+    generateCssForClasses = async (classes, _tailwindConfig, root, cssEntryContent, minify = false) => {
+      try {
+        const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
+        const result = await runCssPipeline2(classes, cssEntryContent, root, minify);
+        return result.css;
+      } catch {
+        const native = getNativeBridge();
+        if (!native?.transformSource) {
+          throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+        }
+        const result = native.transformSource(classes.join(" "), {});
+        return result?.code || "";
+      }
+    };
+    eliminateDeadCss = (css, deadClasses) => {
+      const native = getNativeBridge();
+      if (!native?.eliminateDeadCss) {
+        throw new Error("FATAL: Native binding 'eliminateDeadCss' is required but not available.");
+      }
+      return native.eliminateDeadCss(css, Array.from(deadClasses));
+    };
+    findDeadVariants = (variantConfig, usage) => {
+      const unused = [];
+      const configs = Array.isArray(variantConfig) ? variantConfig : [{ name: "__root__", variants: variantConfig }];
+      for (const component of configs) {
+        const componentUsage = usage[component.name] ?? /* @__PURE__ */ new Set();
+        const variants = component.variants;
+        for (const [key, values] of Object.entries(variants)) {
+          for (const [value] of Object.entries(values)) {
+            if (!componentUsage.has(`${key}:${value}`)) {
+              unused.push(`${component.name !== "__root__" ? `${component.name}/` : ""}${key}:${value}`);
+            }
+          }
+        }
+      }
+      return { unusedCount: unused.length, unused };
+    };
+    runElimination = (css, scanResult) => {
+      const native = getNativeBridge();
+      if (!native?.detectDeadCode) {
+        throw new Error("FATAL: Native binding 'detectDeadCode' is required but not available.");
+      }
+      const dead = native.detectDeadCode(JSON.stringify(scanResult), css);
+      return eliminateDeadCss(css, new Set(dead.deadInCss ?? []));
+    };
+    scanProjectUsage = (dirs, cwd) => {
+      const { batchExtractClasses: batchExtractClasses2 } = (init_parser(), __toCommonJS(parser_exports));
+      const files = dirs.map((dir) => path__default.resolve(cwd, dir));
+      const results = batchExtractClasses2(files) || [];
+      const combined = {};
+      for (const result of results) {
+        if (result.ok && result.classes) {
+          for (const cls of result.classes) {
+            if (!combined[cls]) combined[cls] = {};
+            combined[cls][result.file] = /* @__PURE__ */ new Set([cls]);
+          }
+        }
+      }
+      return combined;
+    };
+    generateSafelist = (scanDirs, outputPath, cwd) => {
+      const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
+      const allClasses = Object.keys(classes).sort();
+      if (outputPath) {
+        fs__default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+      }
+      return allClasses;
+    };
+    loadSafelist = (safelistPath) => {
+      try {
+        const content = fs__default.readFileSync(safelistPath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return [];
+      }
+    };
+    loadTailwindConfig = (cwd = process.cwd()) => {
+      const configFiles = [
+        "tailwind.config.ts",
+        "tailwind.config.js",
+        "tailwind.config.mjs",
+        "tailwind.config.cjs"
+      ];
+      for (const file of configFiles) {
+        const fullPath = path__default.join(cwd, file);
+        if (fs__default.existsSync(fullPath)) {
+          const mod = __require(fullPath);
+          return mod.default || mod;
+        }
+      }
+      return {};
+    };
+    getContentPaths = (cwd = process.cwd()) => {
+      return {
+        content: [
+          path__default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          path__default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          path__default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
+        ]
+      };
+    };
+    _CONTAINER_BREAKPOINTS = {
+      xs: "240px",
+      sm: "320px",
+      md: "640px",
+      lg: "1024px",
+      xl: "1280px",
+      "2xl": "1536px"
+    };
+    runLoaderTransform = (ctx) => {
+      const { filepath, source, options } = ctx;
+      const result = transformSource(source, { filename: filepath, ...options });
+      let staticCss;
+      try {
+        const cssChunks = [];
+        const stateRules = extractAndGenerateStateCss(source, filepath);
+        if (stateRules.length > 0) {
+          cssChunks.push(stateRules.map((r) => r.cssRule).join("\n"));
+        }
+        const containerCss = extractContainerCssFromSource(source);
+        if (containerCss) cssChunks.push(containerCss);
+        const combined = cssChunks.join("\n").trim();
+        if (combined) staticCss = combined;
+      } catch (err) {
+        console.debug("Static CSS extraction warning:", err);
+      }
+      return {
+        code: result?.code || "",
+        changed: result?.changed || false,
+        classes: result?.classes || [],
+        staticCss
+      };
+    };
+    shouldSkipFile = (filepath) => {
+      const SKIP_PATHS = ["node_modules", ".next", ".rspack-dist", ".turbo", "dist/", "out/"];
+      const skipExtensions = [".css", ".json", ".md", ".txt", ".yaml", ".yml"];
+      for (const p of SKIP_PATHS) {
+        if (filepath.includes(p)) return true;
+      }
+      for (const ext of skipExtensions) {
+        if (filepath.endsWith(ext)) return true;
+      }
+      return false;
+    };
+    fileToRoute = (filepath) => {
+      const normalized = filepath.replace(/\\/g, "/");
+      if (normalized.includes("/layout.") || normalized.includes("/loading.") || normalized.includes("/error.")) {
+        return "__global";
+      }
+      const pageMatch = normalized.match(/\/app\/(.+?)\/page\.[tj]sx?$/);
+      if (pageMatch) return `/${pageMatch[1]}`;
+      const rootPage = normalized.match(/\/app\/page\.[tj]sx?$/);
+      if (rootPage) return "/";
+      return null;
+    };
+    getAllRoutes = () => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return ["/", "__global"];
+    };
+    getRouteClasses = (_route) => /* @__PURE__ */ new Set();
+    registerFileClasses = (_filepath, _classes) => {
+    };
+    registerGlobalClasses = (_classes) => {
+    };
+    _incrementalEngineInstance = null;
+    getIncrementalEngine = () => {
+      if (!_incrementalEngineInstance) {
+        _incrementalEngineInstance = new IncrementalEngine();
+      }
+      return _incrementalEngineInstance;
+    };
+    resetIncrementalEngine = () => {
+      _incrementalEngineInstance = null;
+    };
+    IncrementalEngine = class {
+      compile(source) {
+        return transformSource(source);
+      }
+    };
+    getBucketEngine = () => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return {
+        add: (className) => className,
+        get: (_bucket) => []
+      };
+    };
+    resetBucketEngine = () => {
+    };
+    BucketEngine = class {
+      add(className) {
+        return className;
+      }
+    };
+    classifyNode = (_node) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return "unknown";
+    };
+    detectConflicts = (_classes) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClassUsage) {
+        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+      }
+      return [];
+    };
+    bucketSort = (classes) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      const sorted = native.classifyAndSortClasses(classes);
+      return sorted.map((c) => c.raw ?? c);
+    };
+    analyzeFile = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeRsc) {
+        throw new Error("FATAL: Native binding 'analyzeRsc' is required but not available.");
+      }
+      const rsc = native.analyzeRsc(source, filename);
+      return {
+        isServer: rsc?.isServer ?? true,
+        needsClientDirective: rsc?.needsClientDirective ?? false,
+        clientReasons: rsc?.clientReasons ?? [],
+        interactiveClasses: [],
+        canStaticResolveVariants: true
+      };
+    };
+    analyzeVariantUsage = (_source, _componentName, _variantKeys) => {
+      return { resolved: {}, dynamic: [] };
+    };
+    injectClientDirective = (source) => {
+      if (!source.includes('"use client"') && !source.includes("'use client'")) {
+        return '"use client";\n' + source;
+      }
+      return source;
+    };
+    injectServerOnlyComment = (source) => {
+      return `/* @server-only */
+${source}`;
+    };
+    analyzeClasses = (filesJson, cwd, flags) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return native.analyzeClasses(filesJson, cwd, flags);
+    };
+    extractTwStateConfigs = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.extractTwStateConfigs) {
+        throw new Error("FATAL: Native binding 'extractTwStateConfigs' is required but not available.");
+      }
+      return native.extractTwStateConfigs(source, filename);
+    };
+    generateStaticStateCss = (entries, _themeConfig) => {
+      const rules = [];
+      for (const entry of entries) {
+        const stateConfig = JSON.parse(entry.statesJson);
+        for (const [stateName, classes] of Object.entries(stateConfig)) {
+          rules.push({
+            selector: `.${entry.componentName}[data-state="${stateName}"]`,
+            declarations: classes,
+            cssRule: `.${entry.componentName}[data-state="${stateName}"]{${classes}}`,
+            componentName: entry.componentName,
+            stateName
+          });
+        }
+      }
+      return rules;
+    };
+    extractAndGenerateStateCss = (source, filename) => {
+      const entries = extractTwStateConfigs(source, filename);
+      return generateStaticStateCss(entries);
+    };
+  }
+});
+
+// src/umbrella/compiler.ts
+init_src2();
 
-export { BucketEngine, IncrementalEngine, adaptNativeResult, analyzeClassUsage, analyzeClasses, analyzeFile, analyzeRsc, analyzeVariantUsage, astExtractClasses, batchExtractClasses, bucketSort, buildStyleTag, checkAgainstSafelist, classifyAndSortClasses, classifyNode, compileCssFromClasses, compileCssNative, compileVariantTable, compileVariants, detectConflicts, diffClassLists, eliminateDeadCss, extractAllClasses, extractClassesFromSource, extractComponentUsage, fileToRoute, findDeadVariants, generateCssForClasses, generateSafelist, getAllRoutes, getBucketEngine, getContentPaths, getIncrementalEngine, getNativeBridge, getRouteClasses, hasTwUsage, hoistComponents, injectClientDirective, injectServerOnlyComment, isAlreadyTransformed, loadSafelist, loadTailwindConfig, mergeClassesStatic, mergeCssDeclarations, normalizeAndDedupClasses, normalizeClasses, optimizeCss, parseClasses, registerFileClasses, registerGlobalClasses, resetBucketEngine, resetIncrementalEngine, resetNativeBridgeCache, runElimination, runLoaderTransform, scanProjectUsage, shouldProcess, shouldSkipFile, transformSource };
+export { BucketEngine, IncrementalEngine, adaptNativeResult, analyzeClassUsageNative, analyzeClasses, analyzeClassesNative, analyzeFile, analyzeRscNative, analyzeVariantUsage, astExtractClasses, atomicRegistrySize, batchExtractClasses, batchExtractClassesNative, bucketSort, buildStyleTag, cachePriority, cacheRead, cacheWrite, checkAgainstSafelist, checkAgainstSafelistNative, classifyAndSortClassesNative, classifyNode, clearAllCaches, clearAtomicRegistry, clearCompileCache, clearCssGenCache, clearParseCache, clearResolveCache, clearThemeCache, collectFiles, compileAnimation, compileClass, compileClasses, compileCssFromClasses, compileCssLightning, compileCssNative2, compileKeyframes, compileTheme, compileToCss, compileToCssBatch, compileVariantTableNative, computeIncrementalDiff, createFingerprint, detectConflicts, detectDeadCode, diffClassLists, eliminateDeadCss, eliminateDeadCssNative, emitPluginHook, estimateOptimalCacheConfig, extractAllClasses, extractAndGenerateStateCss, extractAndGenerateStateCssNative, extractClassesFromSource, extractClassesFromSourceNative, extractComponentUsage, extractContainerCssFromSource, extractTwContainerConfigs, extractTwStateConfigs, extractTwStateConfigsNative, fileToRoute, findDeadVariants, generateAtomicCss, generateCssForClasses, generateCssNative, generateSafelist, generateStaticStateCss, generateStaticStateCssNative, generateSubComponentTypes, getAllRoutes, getBucketEngine, getCacheOptimizationHints, getCacheStatistics, getCacheStats, getCompilationMetrics, getCompilerDiagnostics, getContentPaths, getIncrementalEngine, getNativeBridge, getPluginHooks, getRouteClasses, getWatchStats, hasTwUsage, hashContent, hoistComponentsNative, idRegistryActiveCount, idRegistryCreate, idRegistryDestroy, idRegistryExport, idRegistryGenerate, idRegistryImport, idRegistryLookup, idRegistryNext, idRegistryReset, idRegistrySnapshot, injectClientDirective, injectServerOnlyComment, injectStateHash, isAlreadyTransformed, isWatchRunning, layoutClassesToCss, loadSafelist, loadTailwindConfig, mergeClassesStatic, mergeCssDeclarationsNative, minifyCss, normalizeAndDedupClasses, normalizeClasses, optimizeCssNative, parseAtomicClass, parseClasses, pollWatchEvents, processFileChange, processTailwindCssLightning, propertyIdToString, pruneStaleCacheEntries, rebuildWorkspaceResult, redisCacheClear, redisCacheHitRate, redisCacheKeyCount, redisCacheSize, redisCacheSync, redisClusterStatus, redisDelete, redisDiagnose, redisDisableCacheWarming, redisDisableCluster, redisDisablePersistence, redisEnableCacheWarming, redisEnableCluster, redisEnablePersistence, redisExists, redisExpirationGet, redisExpirationSet, redisFlushAll, redisFlushDb, redisGet, redisGetEvictionPolicy, redisInfo, redisMemoryStats, redisMget, redisMonitor, redisMset, redisOptimizeMemory, redisPing, redisPoolConnect, redisPoolReconnect, redisPoolStats, redisPublish, redisReplicate, redisReplicationStatus, redisSet, redisSetEvictionPolicy, redisSnapshot, redisSubscribe, registerFileClasses, registerGlobalClasses, registerPluginHook, registerPropertyName, registerValueName, resetBucketEngine, resetCompilationMetrics, resetIncrementalEngine, resetNativeBridgeCache, resolveCascade, resolveClassNames, resolveConflictGroup, resolveSimpleVariants, resolveThemeValue, resolveVariants, reverseLookupProperty, reverseLookupValue, runCssPipeline, runElimination, runLoaderTransform, scanCacheOptimizations, scanFile, scanFileNative, scanFilesBatchNative, scanProjectUsage, scanWorkspace, shouldProcess, shouldSkipFile, startWatch, stopWatch, toAtomicClasses, transformSource, twMerge, twMergeMany, twMergeManyWithSeparator, twMergeRaw, twMergeWithSeparator, unregisterPluginHook, validateCssOutput, validateThemeConfig, valueIdToString, walkAndPrefilterSourceFiles, watchAddPattern, watchClearAll, watchEventTypeToString, watchGetActiveHandles, watchPause, watchRemovePattern, watchResume };
 //# sourceMappingURL=compiler.mjs.map
 //# sourceMappingURL=compiler.mjs.map