tailwind-styled-v4 5.0.12 → 5.0.13

package/dist/turbopackLoader.mjs

@@ -215,11 +215,484 @@ Tried paths: ${result.tried.join("\n")}`);
   }
 });
 
-// packages/domain/compiler/src/tailwindEngine.ts
+// 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 clearThemeCache() {
+  try {
+    const native = getNativeBridge();
+    if (!native?.clearThemeCache) {
+      return;
+    }
+    native.clearThemeCache();
+  } catch {
+  }
+}
+var init_cssGeneratorNative = __esm({
+  "packages/domain/compiler/src/compiler/cssGeneratorNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/compiler/compilationNative.ts
+function compileCssNative2(classes, prefix) {
+  const native = getNativeBridge();
+  if (!native?.compileCss) throw new Error("compileCss not available");
+  return native.compileCss(classes, prefix);
+}
+function compileCssLightning(classes) {
+  const native = getNativeBridge();
+  if (!native?.compileCssLightning) throw new Error("compileCssLightning not available");
+  return native.compileCssLightning(classes);
+}
+function extractTwStateConfigsNative(source, filename) {
+  const native = getNativeBridge();
+  if (!native?.extractTwStateConfigs) throw new Error("extractTwStateConfigs not available");
+  return native.extractTwStateConfigs(source, filename);
+}
+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();
+  }
+});
+
+// packages/domain/compiler/src/compiler/cssCompilationNative.ts
+function compileClass(input) {
+  const native = getNativeBridge();
+  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
+    };
+  }
+}
+function compileClasses(inputs) {
+  const native = getNativeBridge();
+  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
+    };
+  }
+}
+function compileToCss(input, minify) {
+  const native = getNativeBridge();
+  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?.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?.minify_css) throw new Error("minify_css not available");
+  return native.minify_css(css);
+}
+function compileAnimation(animationName, from, to) {
+  const native = getNativeBridge();
+  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
+    };
+  }
+}
+function compileKeyframes(name, stopsJson) {
+  const native = getNativeBridge();
+  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
+    };
+  }
+}
+function compileTheme(tokensJson, themeName, prefix) {
+  const native = getNativeBridge();
+  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
+    };
+  }
+}
+function twMerge(classString) {
+  const native = getNativeBridge();
+  if (!native?.tw_merge) throw new Error("tw_merge not available");
+  return native.tw_merge(classString);
+}
+function twMergeMany(classStrings) {
+  const native = getNativeBridge();
+  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
+  };
+  return native.tw_merge_with_separator(classString, opts);
+}
+function twMergeManyWithSeparator(classStrings, options) {
+  const native = getNativeBridge();
+  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?.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();
+  }
+});
+
+// packages/domain/compiler/src/compiler/idRegistryNative.ts
+function idRegistryCreate() {
+  const native = getNativeBridge();
+  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?.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?.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?.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
+    };
+  }
+}
+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?.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();
+  }
+});
+
+// packages/domain/compiler/src/compiler/streamingNative.ts
+function processFileChange(fileChangeJson) {
+  const native = getNativeBridge();
+  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"
+    };
+  }
+}
+function computeIncrementalDiff(oldScanJson, newScanJson) {
+  const native = getNativeBridge();
+  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
+    };
+  }
+}
+function createFingerprint(filePath, fileContent) {
+  const native = getNativeBridge();
+  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: ""
+    };
+  }
+}
+function injectStateHash(css, stateHash) {
+  const native = getNativeBridge();
+  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
+    };
+  }
+}
+function pruneStaleCacheEntries(maxAgeSeconds, maxEntries) {
+  const native = getNativeBridge();
+  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
+    };
+  }
+}
+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
+    };
+  }
+}
+function scanFileNative(filePath, fileContent) {
+  const native = getNativeBridge();
+  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
+    };
+  }
+}
+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 {
+    return JSON.parse(resultJson);
+  } catch {
+    return [];
+  }
+}
+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,
-  generateRawCss: () => generateRawCss,
   getCacheStats: () => getCacheStats,
   processTailwindCssWithTargets: () => processTailwindCssWithTargets,
   runCssPipeline: () => runCssPipeline,
@@ -253,48 +726,6 @@ function clearCache() {
   _cacheHits = 0;
   _cacheMisses = 0;
 }
-function loadTailwindEngine() {
-  if (_twEngine) return _twEngine;
-  if (_twEngineError) throw _twEngineError;
-  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 compiler = await Promise.resolve(tw.compile(input, { loadStylesheet }));
-  return compiler.build(classes);
-}
 function getThemeConfig() {
   return {
     colors: {
@@ -391,98 +822,920 @@ async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
   _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`
+    );
+  }
+  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?.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();
+  }
+});
+
+// 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 {
+    css: result.css,
+    originalSize: css.length,
+    optimizedSize: result.size_bytes,
+    reductionPercentage: (css.length - result.size_bytes) / css.length * 100
+  };
+}
+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();
+  }
+});
+
+// packages/domain/compiler/src/analyzer/themeResolutionNative.ts
+function resolveVariants(configJson) {
+  const native = getNativeBridge();
+  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: []
+    };
+  }
+}
+function validateThemeConfig(configJson) {
+  const native = getNativeBridge();
+  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: []
+    };
+  }
+}
+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 {
-    const theme = getThemeConfig();
-    rawCss = await generateCssNative(unique, {
-      theme,
-      fallbackToJs: true,
-      logFallback: process.env.DEBUG?.includes("compiler") === true
-    });
-    usedRustCompiler = true;
-  } catch (error) {
-    if (process.env.DEBUG?.includes("compiler")) {
-      console.warn("[Compiler] Rust compiler failed, using JavaScript Tailwind:", error);
-    }
-    rawCss = await generateRawCss(unique, cssEntryContent, root);
-  }
-  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`
-    );
+    return JSON.parse(result);
+  } catch {
+    return [];
   }
-  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 watchClearAll() {
+  const native = getNativeBridge();
+  if (!native?.watch_clear_all) throw new Error("watch_clear_all not available");
+  return native.watch_clear_all();
 }
-function processTailwindCssWithTargets(css, targets) {
+function watchEventTypeToString(event_type_code) {
   const native = getNativeBridge();
-  if (!native?.processTailwindCssWithTargets) {
-    throw new Error("FATAL: Native binding 'processTailwindCssWithTargets' is required but not available.");
+  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
+    };
   }
-  const result = native.processTailwindCssWithTargets(css, targets ?? null);
-  if (!result?.css) {
-    throw new Error("FATAL: processTailwindCssWithTargets returned null");
+}
+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 [];
   }
-  return result.css;
 }
-var require2, _cssCache, _cacheHits, _cacheMisses, MAX_CACHE_SIZE, _twEngine, _twEngineError;
-var init_tailwindEngine = __esm({
-  "packages/domain/compiler/src/tailwindEngine.ts"() {
+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();
-    init_cssGeneratorNative();
-    require2 = createRequire(import.meta.url);
-    _cssCache = /* @__PURE__ */ new Map();
-    _cacheHits = 0;
-    _cacheMisses = 0;
-    MAX_CACHE_SIZE = 100;
-    _twEngine = null;
-    _twEngineError = null;
   }
 });
 
-// packages/domain/compiler/src/cssGeneratorNative.ts
-async function generateCssNative(classes, options) {
-  const {
-    theme,
-    fallbackToJs = true,
-    logFallback = false
-  } = options;
-  try {
-    const native = getNativeBridge();
-    if (!native?.generateCssNative) {
-      throw new Error("generateCssNative not available in native binding");
-    }
-    const themeJson = JSON.stringify(theme);
-    const css = native.generateCssNative(classes, themeJson);
-    return css;
-  } catch (error) {
-    if (!fallbackToJs) {
-      throw error;
-    }
-    if (logFallback) {
-      console.warn(
-        "[CSS Compiler] Rust CSS generator unavailable, falling back to JavaScript Tailwind",
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-    return generateRawCss(classes);
-  }
-}
-var init_cssGeneratorNative = __esm({
-  "packages/domain/compiler/src/cssGeneratorNative.ts"() {
-    init_nativeBridge();
-    init_tailwindEngine();
+// packages/domain/compiler/src/watch/index.ts
+var init_watch = __esm({
+  "packages/domain/compiler/src/watch/index.ts"() {
+    init_watchSystemNative();
   }
 });
 function _layoutClassesToCss(classes) {
@@ -519,10 +1772,16 @@ function extractContainerCssFromSource(source) {
   }
   return rules.join("\n");
 }
-var transformSource, hasTwUsage, isAlreadyTransformed, shouldProcess, compileCssFromClasses, buildStyleTag, compileCssNative, generateCssForClasses, extractAllClasses, extractClassesFromSource, astExtractClasses, parseClasses, normalizeClasses, mergeClassesStatic, normalizeAndDedupClasses, eliminateDeadCss, findDeadVariants, runElimination, optimizeCss, scanProjectUsage, extractComponentUsage, diffClassLists, batchExtractClasses, checkAgainstSafelist, hoistComponents, compileVariantTable, compileVariants, classifyAndSortClasses, mergeCssDeclarations, analyzeClassUsage, analyzeRsc, analyzeFile, analyzeVariantUsage, injectClientDirective, injectServerOnlyComment, analyzeClasses, generateSafelist, loadSafelist, loadTailwindConfig, getContentPaths, _CONTAINER_BREAKPOINTS, runLoaderTransform, shouldSkipFile, fileToRoute, getAllRoutes, getRouteClasses, registerFileClasses, registerGlobalClasses, _incrementalEngineInstance, getIncrementalEngine, resetIncrementalEngine, IncrementalEngine, getBucketEngine, resetBucketEngine, classifyNode, detectConflicts, bucketSort, extractTwStateConfigs, generateStaticStateCss, extractAndGenerateStateCss;
+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, 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) {
@@ -566,58 +1825,19 @@ var init_src2 = __esm({
       const result = compileCssFromClasses(classes);
       return result?.code ? `<style data-tailwind-styled>${result.code}</style>` : "";
     };
-    compileCssNative = (classes, prefix = null) => {
-      return compileCssFromClasses(classes, prefix);
-    };
     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;
-    };
-    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) || [];
-    };
-    parseClasses = (raw) => {
-      const native = getNativeBridge();
-      if (!native?.parseClasses) {
-        throw new Error("FATAL: Native binding 'parseClasses' is required but not available.");
-      }
-      return native.parseClasses(raw) || [];
-    };
-    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.");
+      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 || "";
       }
-      const result = native.normalizeAndDedupClasses(raw);
-      return result || { normalized: "", duplicatesRemoved: 0, uniqueCount: 0 };
     };
     eliminateDeadCss = (css, deadClasses) => {
       const native = getNativeBridge();
@@ -650,16 +1870,10 @@ var init_src2 = __esm({
       const dead = native.detectDeadCode(JSON.stringify(scanResult), css);
       return eliminateDeadCss(css, new Set(dead.deadInCss ?? []));
     };
-    optimizeCss = (css) => {
-      const native = getNativeBridge();
-      if (!native?.optimizeCss) {
-        throw new Error("FATAL: Native binding 'optimizeCss' is required but not available.");
-      }
-      return native.optimizeCss(css);
-    };
     scanProjectUsage = (dirs, cwd) => {
+      const { batchExtractClasses: batchExtractClasses2 } = (init_parser(), __toCommonJS(parser_exports));
       const files = dirs.map((dir) => path4__default.resolve(cwd, dir));
-      const results = batchExtractClasses(files) || [];
+      const results = batchExtractClasses2(files) || [];
       const combined = {};
       for (const result of results) {
         if (result.ok && result.classes) {
@@ -671,109 +1885,6 @@ var init_src2 = __esm({
       }
       return combined;
     };
-    extractComponentUsage = (source) => {
-      const native = getNativeBridge();
-      if (!native?.extractComponentUsage) {
-        throw new Error("FATAL: Native binding 'extractComponentUsage' is required but not available.");
-      }
-      return native.extractComponentUsage(source) || [];
-    };
-    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 };
-    };
-    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 };
-    };
-    hoistComponents = (source) => {
-      const native = getNativeBridge();
-      if (!native?.hoistComponents) {
-        throw new Error("FATAL: Native binding 'hoistComponents' is required but not available.");
-      }
-      return native.hoistComponents(source) || { code: source, hoisted: [], warnings: [] };
-    };
-    compileVariantTable = (configJson) => {
-      const native = getNativeBridge();
-      if (!native?.compileVariantTable) {
-        throw new Error("FATAL: Native binding 'compileVariantTable' is required but not available.");
-      }
-      return native.compileVariantTable(configJson) || { id: "", tableJson: "{}", keys: [], defaultKey: "", combinations: 0 };
-    };
-    compileVariants = (componentId, config) => {
-      return compileVariantTable(JSON.stringify({ componentId, ...config }));
-    };
-    classifyAndSortClasses = (classes) => {
-      const native = getNativeBridge();
-      if (!native?.classifyAndSortClasses) {
-        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
-      }
-      return native.classifyAndSortClasses(classes) || [];
-    };
-    mergeCssDeclarations = (cssChunks) => {
-      const native = getNativeBridge();
-      if (!native?.mergeCssDeclarations) {
-        throw new Error("FATAL: Native binding 'mergeCssDeclarations' is required but not available.");
-      }
-      return native.mergeCssDeclarations(cssChunks) || { declarationsJson: "{}", declarationString: "", count: 0 };
-    };
-    analyzeClassUsage = (classes, scanResultJson, css) => {
-      const native = getNativeBridge();
-      if (!native?.analyzeClassUsage) {
-        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
-      }
-      return native.analyzeClassUsage(classes, scanResultJson, css) || [];
-    };
-    analyzeRsc = (source, filename) => {
-      const native = getNativeBridge();
-      if (!native?.analyzeRsc) {
-        throw new Error("FATAL: Native binding 'analyzeRsc' is required but not available.");
-      }
-      return native.analyzeRsc(source, filename) || { isServer: true, needsClientDirective: false, clientReasons: [] };
-    };
-    analyzeFile = (source, filename) => {
-      const rsc = 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);
-    };
     generateSafelist = (scanDirs, outputPath, cwd) => {
       const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
       const allClasses = Object.keys(classes).sort();
@@ -837,7 +1948,8 @@ ${source}`;
         if (containerCss) cssChunks.push(containerCss);
         const combined = cssChunks.join("\n").trim();
         if (combined) staticCss = combined;
-      } catch {
+      } catch (err) {
+        console.debug("Static CSS extraction warning:", err);
       }
       return {
         code: result?.code || "",
@@ -922,7 +2034,46 @@ ${source}`;
       return [];
     };
     bucketSort = (classes) => {
-      return classifyAndSortClasses(classes).map((c) => c.raw ?? c);
+      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();
@@ -931,23 +2082,25 @@ ${source}`;
       }
       return native.extractTwStateConfigs(source, filename);
     };
-    generateStaticStateCss = (inputs, resolvedCss = null) => {
-      const native = getNativeBridge();
-      if (!native?.generateStaticStateCss) {
-        throw new Error("FATAL: Native binding 'generateStaticStateCss' is required but not available.");
+    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 native.generateStaticStateCss(inputs, resolvedCss);
+      return rules;
     };
     extractAndGenerateStateCss = (source, filename) => {
-      const native = getNativeBridge();
-      if (!native?.extractAndGenerateStateCss) {
-        const configs = extractTwStateConfigs(source, filename);
-        if (configs.length === 0) return [];
-        return generateStaticStateCss(
-          configs.map((c) => ({ tag: c.tag, componentName: c.componentName, statesJson: c.statesJson }))
-        );
-      }
-      return native.extractAndGenerateStateCss(source, filename);
+      const entries = extractTwStateConfigs(source, filename);
+      return generateStaticStateCss(entries);
     };
   }
 });
@@ -956,75 +2109,219 @@ ${source}`;
 var internal_exports = {};
 __export(internal_exports, {
   adaptNativeResult: () => adaptNativeResult,
-  analyzeClassUsage: () => analyzeClassUsage,
+  analyzeClassUsageNative: () => analyzeClassUsageNative,
   analyzeClasses: () => analyzeClasses,
+  analyzeClassesNative: () => analyzeClassesNative,
   analyzeFile: () => analyzeFile,
-  analyzeRsc: () => analyzeRsc,
+  analyzeRscNative: () => analyzeRscNative,
   analyzeVariantUsage: () => analyzeVariantUsage,
   astExtractClasses: () => astExtractClasses,
+  atomicRegistrySize: () => atomicRegistrySize,
   batchExtractClasses: () => batchExtractClasses,
+  batchExtractClassesNative: () => batchExtractClassesNative,
   bucketSort: () => bucketSort,
   buildStyleTag: () => buildStyleTag,
+  cachePriority: () => cachePriority,
+  cacheRead: () => cacheRead,
+  cacheWrite: () => cacheWrite,
   checkAgainstSafelist: () => checkAgainstSafelist,
-  classifyAndSortClasses: () => classifyAndSortClasses,
+  checkAgainstSafelistNative: () => checkAgainstSafelistNative,
+  classifyAndSortClassesNative: () => classifyAndSortClassesNative,
   classifyNode: () => classifyNode,
+  clearAllCaches: () => clearAllCaches,
+  clearAtomicRegistry: () => clearAtomicRegistry,
   clearCache: () => clearCache,
+  clearCompileCache: () => clearCompileCache,
+  clearCssGenCache: () => clearCssGenCache,
+  clearParseCache: () => clearParseCache,
+  clearResolveCache: () => clearResolveCache,
+  clearThemeCache: () => clearThemeCache,
+  collectFiles: () => collectFiles,
+  compileAnimation: () => compileAnimation,
+  compileClass: () => compileClass,
+  compileClasses: () => compileClasses,
   compileCssFromClasses: () => compileCssFromClasses,
-  compileCssNative: () => compileCssNative,
-  compileVariantTable: () => compileVariantTable,
-  compileVariants: () => compileVariants,
+  compileCssLightning: () => compileCssLightning,
+  compileCssNative2: () => compileCssNative2,
+  compileKeyframes: () => compileKeyframes,
+  compileTheme: () => compileTheme,
+  compileToCss: () => compileToCss,
+  compileToCssBatch: () => compileToCssBatch,
+  compileVariantTableNative: () => compileVariantTableNative,
+  computeIncrementalDiff: () => computeIncrementalDiff,
+  createFingerprint: () => createFingerprint,
   detectConflicts: () => detectConflicts,
+  detectDeadCode: () => detectDeadCode,
   diffClassLists: () => diffClassLists,
   eliminateDeadCss: () => eliminateDeadCss,
+  eliminateDeadCssNative: () => eliminateDeadCssNative,
+  emitPluginHook: () => emitPluginHook,
+  estimateOptimalCacheConfig: () => estimateOptimalCacheConfig,
   extractAllClasses: () => extractAllClasses,
   extractAndGenerateStateCss: () => extractAndGenerateStateCss,
+  extractAndGenerateStateCssNative: () => extractAndGenerateStateCssNative,
   extractClassesFromSource: () => extractClassesFromSource,
+  extractClassesFromSourceNative: () => extractClassesFromSourceNative,
   extractComponentUsage: () => extractComponentUsage,
   extractContainerCssFromSource: () => extractContainerCssFromSource,
+  extractTwContainerConfigs: () => extractTwContainerConfigs,
   extractTwStateConfigs: () => extractTwStateConfigs,
+  extractTwStateConfigsNative: () => extractTwStateConfigsNative,
   fileToRoute: () => fileToRoute,
   findDeadVariants: () => findDeadVariants,
+  generateAtomicCss: () => generateAtomicCss,
   generateCssForClasses: () => generateCssForClasses,
-  generateRawCss: () => generateRawCss,
+  generateCssNative: () => generateCssNative,
   generateSafelist: () => generateSafelist,
   generateStaticStateCss: () => generateStaticStateCss,
+  generateStaticStateCssNative: () => generateStaticStateCssNative,
+  generateSubComponentTypes: () => generateSubComponentTypes,
   getAllRoutes: () => getAllRoutes,
   getBucketEngine: () => getBucketEngine,
+  getCacheOptimizationHints: () => getCacheOptimizationHints,
+  getCacheStatistics: () => getCacheStatistics,
   getCacheStats: () => getCacheStats,
+  getCompilationMetrics: () => getCompilationMetrics,
+  getCompilerDiagnostics: () => getCompilerDiagnostics,
   getContentPaths: () => getContentPaths,
   getIncrementalEngine: () => getIncrementalEngine,
   getNativeBridge: () => getNativeBridge,
+  getPluginHooks: () => getPluginHooks,
   getRouteClasses: () => getRouteClasses,
+  getWatchStats: () => getWatchStats,
   hasTwUsage: () => hasTwUsage,
-  hoistComponents: () => hoistComponents,
+  hashContent: () => hashContent,
+  hoistComponentsNative: () => hoistComponentsNative,
+  idRegistryActiveCount: () => idRegistryActiveCount,
+  idRegistryCreate: () => idRegistryCreate,
+  idRegistryDestroy: () => idRegistryDestroy,
+  idRegistryExport: () => idRegistryExport,
+  idRegistryGenerate: () => idRegistryGenerate,
+  idRegistryImport: () => idRegistryImport,
+  idRegistryLookup: () => idRegistryLookup,
+  idRegistryNext: () => idRegistryNext,
+  idRegistryReset: () => idRegistryReset,
+  idRegistrySnapshot: () => idRegistrySnapshot,
   injectClientDirective: () => injectClientDirective,
   injectServerOnlyComment: () => injectServerOnlyComment,
+  injectStateHash: () => injectStateHash,
   isAlreadyTransformed: () => isAlreadyTransformed,
+  isWatchRunning: () => isWatchRunning,
+  layoutClassesToCss: () => layoutClassesToCss,
   loadSafelist: () => loadSafelist,
   loadTailwindConfig: () => loadTailwindConfig,
   mergeClassesStatic: () => mergeClassesStatic,
-  mergeCssDeclarations: () => mergeCssDeclarations,
+  mergeCssDeclarationsNative: () => mergeCssDeclarationsNative,
+  minifyCss: () => minifyCss,
   normalizeAndDedupClasses: () => normalizeAndDedupClasses,
   normalizeClasses: () => normalizeClasses,
-  optimizeCss: () => optimizeCss,
+  optimizeCssNative: () => optimizeCssNative,
+  parseAtomicClass: () => parseAtomicClass,
   parseClasses: () => parseClasses,
+  pollWatchEvents: () => pollWatchEvents,
+  processFileChange: () => processFileChange,
+  processTailwindCssLightning: () => processTailwindCssLightning,
+  propertyIdToString: () => propertyIdToString,
+  pruneStaleCacheEntries: () => pruneStaleCacheEntries,
+  rebuildWorkspaceResult: () => rebuildWorkspaceResult,
+  redisCacheClear: () => redisCacheClear,
+  redisCacheHitRate: () => redisCacheHitRate,
+  redisCacheKeyCount: () => redisCacheKeyCount,
+  redisCacheSize: () => redisCacheSize,
+  redisCacheSync: () => redisCacheSync,
+  redisClusterStatus: () => redisClusterStatus,
+  redisDelete: () => redisDelete,
+  redisDiagnose: () => redisDiagnose,
+  redisDisableCacheWarming: () => redisDisableCacheWarming,
+  redisDisableCluster: () => redisDisableCluster,
+  redisDisablePersistence: () => redisDisablePersistence,
+  redisEnableCacheWarming: () => redisEnableCacheWarming,
+  redisEnableCluster: () => redisEnableCluster,
+  redisEnablePersistence: () => redisEnablePersistence,
+  redisExists: () => redisExists,
+  redisExpirationGet: () => redisExpirationGet,
+  redisExpirationSet: () => redisExpirationSet,
+  redisFlushAll: () => redisFlushAll,
+  redisFlushDb: () => redisFlushDb,
+  redisGet: () => redisGet,
+  redisGetEvictionPolicy: () => redisGetEvictionPolicy,
+  redisInfo: () => redisInfo,
+  redisMemoryStats: () => redisMemoryStats,
+  redisMget: () => redisMget,
+  redisMonitor: () => redisMonitor,
+  redisMset: () => redisMset,
+  redisOptimizeMemory: () => redisOptimizeMemory,
+  redisPing: () => redisPing,
+  redisPoolConnect: () => redisPoolConnect,
+  redisPoolReconnect: () => redisPoolReconnect,
+  redisPoolStats: () => redisPoolStats,
+  redisPublish: () => redisPublish,
+  redisReplicate: () => redisReplicate,
+  redisReplicationStatus: () => redisReplicationStatus,
+  redisSet: () => redisSet,
+  redisSetEvictionPolicy: () => redisSetEvictionPolicy,
+  redisSnapshot: () => redisSnapshot,
+  redisSubscribe: () => redisSubscribe,
   registerFileClasses: () => registerFileClasses,
   registerGlobalClasses: () => registerGlobalClasses,
+  registerPluginHook: () => registerPluginHook,
+  registerPropertyName: () => registerPropertyName,
+  registerValueName: () => registerValueName,
   resetBucketEngine: () => resetBucketEngine,
+  resetCompilationMetrics: () => resetCompilationMetrics,
   resetIncrementalEngine: () => resetIncrementalEngine,
+  resolveCascade: () => resolveCascade,
+  resolveClassNames: () => resolveClassNames,
+  resolveConflictGroup: () => resolveConflictGroup,
+  resolveSimpleVariants: () => resolveSimpleVariants,
+  resolveThemeValue: () => resolveThemeValue,
+  resolveVariants: () => resolveVariants,
+  reverseLookupProperty: () => reverseLookupProperty,
+  reverseLookupValue: () => reverseLookupValue,
   runCssPipeline: () => runCssPipeline,
   runCssPipelineSync: () => runCssPipelineSync,
   runElimination: () => runElimination,
   runLoaderTransform: () => runLoaderTransform,
+  scanCacheOptimizations: () => scanCacheOptimizations,
+  scanFile: () => scanFile,
+  scanFileNative: () => scanFileNative,
+  scanFilesBatchNative: () => scanFilesBatchNative,
   scanProjectUsage: () => scanProjectUsage,
+  scanWorkspace: () => scanWorkspace,
   shouldProcess: () => shouldProcess,
   shouldSkipFile: () => shouldSkipFile,
-  transformSource: () => transformSource
+  startWatch: () => startWatch,
+  stopWatch: () => stopWatch,
+  toAtomicClasses: () => toAtomicClasses,
+  transformSource: () => transformSource,
+  twMerge: () => twMerge,
+  twMergeMany: () => twMergeMany,
+  twMergeManyWithSeparator: () => twMergeManyWithSeparator,
+  twMergeRaw: () => twMergeRaw,
+  twMergeWithSeparator: () => twMergeWithSeparator,
+  unregisterPluginHook: () => unregisterPluginHook,
+  validateCssOutput: () => validateCssOutput,
+  validateThemeConfig: () => validateThemeConfig,
+  valueIdToString: () => valueIdToString,
+  walkAndPrefilterSourceFiles: () => walkAndPrefilterSourceFiles,
+  watchAddPattern: () => watchAddPattern,
+  watchClearAll: () => watchClearAll,
+  watchEventTypeToString: () => watchEventTypeToString,
+  watchGetActiveHandles: () => watchGetActiveHandles,
+  watchPause: () => watchPause,
+  watchRemovePattern: () => watchRemovePattern,
+  watchResume: () => watchResume
 });
 var init_internal = __esm({
   "packages/domain/compiler/src/internal.ts"() {
     init_src2();
     init_tailwindEngine();
+    init_compiler();
+    init_parser();
+    init_analyzer();
+    init_cache();
+    init_redis();
+    init_watch();
   }
 });