tailwind-styled-v4 5.0.12 → 5.0.14

package/dist/index.js

@@ -885,27 +885,15 @@ function resolveNativeBinary(runtimeDir) {
     }
     tried.push(`env:${envPath} (not found)`);
   }
-  const prebuiltPkgs = PLATFORM_MAP[platform] ?? [];
-  for (const pkg of prebuiltPkgs) {
-    try {
-      const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs3__namespace.existsSync(candidate)) {
-        return { path: candidate, source: "prebuilt", platform, tried };
-      }
-      tried.push(`prebuilt:${pkg} (resolved but missing)`);
-    } catch {
-      tried.push(`prebuilt:${pkg} (not installed)`);
-    }
-  }
   const napiPlatform = platform === "linux-x64" ? "linux-x64-gnu" : platform === "linux-arm64" ? "linux-arm64-gnu" : platform;
-  const BINARY_NAMES_SELF = ["tailwind-styled-native", "tailwind_styled_parser"];
+  const BINARY_NAMES_SELF = ["tailwind-styled-native", "tailwind_styled_parser", "index"];
   if (runtimeDir) {
     for (const depth of ["..", path9__namespace.join("..", ".."), path9__namespace.join("..", "..", "..")]) {
       const pkgRoot = path9__namespace.resolve(runtimeDir, depth);
       for (const bin of BINARY_NAMES_SELF) {
         for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
           const candidate = path9__namespace.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
-          tried.push(`self-bundled:${candidate}`);
+          tried.push(`native:${candidate}`);
           if (fs3__namespace.existsSync(candidate)) {
             return { path: candidate, source: "prebuilt", platform, tried };
           }
@@ -913,6 +901,18 @@ function resolveNativeBinary(runtimeDir) {
       }
     }
   }
+  const prebuiltPkgs = PLATFORM_MAP[platform] ?? [];
+  for (const pkg of prebuiltPkgs) {
+    try {
+      const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
+      if (fs3__namespace.existsSync(candidate)) {
+        return { path: candidate, source: "prebuilt", platform, tried };
+      }
+      tried.push(`prebuilt:${pkg} (resolved but missing)`);
+    } catch {
+      tried.push(`prebuilt:${pkg} (not installed)`);
+    }
+  }
   const cwd = process.cwd();
   const base = runtimeDir ?? cwd;
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
@@ -1085,11 +1085,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,
@@ -1123,48 +1596,6 @@ function clearCache() {
   _cacheHits = 0;
   _cacheMisses = 0;
 }
-function loadTailwindEngine() {
-  if (_twEngine) return _twEngine;
-  if (_twEngineError) throw _twEngineError;
-  try {
-    const tw2 = require2("tailwindcss");
-    if (typeof tw2.compile !== "function") {
-      throw new Error("tailwindcss v4 not found \u2014 compile() API missing. Check tailwindcss version >= 4.");
-    }
-    _twEngine = tw2;
-    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 tw2 = loadTailwindEngine();
-  const input = cssEntryContent ?? "@import 'tailwindcss';";
-  const { readFileSync, existsSync: existsSync3 } = await import('fs');
-  const { dirname: dirname2, resolve: resolve2 } = await import('path');
-  const projectRoot = root ?? process.cwd();
-  const req = module$1.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: dirname2(pkgPath) };
-    } catch {
-      try {
-        const absPath = resolve2(base, id);
-        if (existsSync3(absPath)) {
-          return { content: readFileSync(absPath, "utf-8"), base: dirname2(absPath) };
-        }
-      } catch {
-      }
-      return { content: "", base };
-    }
-  };
-  const compiler = await Promise.resolve(tw2.compile(input, { loadStylesheet }));
-  return compiler.build(classes);
-}
 function getThemeConfig() {
   return {
     colors: {
@@ -1261,20 +1692,9 @@ async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
   _cacheMisses++;
   let rawCss;
   let usedRustCompiler = false;
-  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 theme = getThemeConfig();
+  rawCss = await generateCssNative(unique, { theme });
+  usedRustCompiler = true;
   const finalCss = minify ? postProcessWithLightning(rawCss) : rawCss;
   if (process.env.DEBUG?.includes("compiler")) {
     console.log(
@@ -1292,67 +1712,900 @@ async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
   _cssCache.set(cacheKey, result);
   return result;
 }
-function runCssPipelineSync(_classes) {
-  return { css: "", classes: [], sizeBytes: 0, optimized: false };
+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();
+    module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
+    _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 {
+    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 processTailwindCssWithTargets(css, targets) {
+function scanCacheOptimizations() {
   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");
+  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 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
-    _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) {
@@ -1389,10 +2642,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_src = __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) {
@@ -1436,58 +2695,19 @@ var init_src = __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();
@@ -1520,16 +2740,10 @@ var init_src = __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) => path9__namespace.default.resolve(cwd, dir));
-      const results = batchExtractClasses(files) || [];
+      const results = batchExtractClasses2(files) || [];
       const combined = {};
       for (const result of results) {
         if (result.ok && result.classes) {
@@ -1541,109 +2755,6 @@ var init_src = __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();
@@ -1707,7 +2818,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 || "",
@@ -1792,7 +2904,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();
@@ -1801,23 +2952,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);
     };
   }
 });
@@ -1826,75 +2979,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_src();
     init_tailwindEngine();
+    init_compiler();
+    init_parser();
+    init_analyzer();
+    init_cache();
+    init_redis();
+    init_watch();
   }
 });
 function getNative() {
@@ -2241,7 +3538,7 @@ __export(src_exports, {
   getPipelinePercentages: () => getPipelinePercentages,
   getSuggestion: () => getSuggestion,
   getTailwindVersion: () => getTailwindVersion,
-  hashContent: () => hashContent,
+  hashContent: () => hashContent2,
   isTailwindV4: () => isTailwindV4,
   isTwError: () => isTwError,
   loadNativeBinding: () => loadNativeBinding,
@@ -2371,7 +3668,7 @@ function resolveRuntimeDir(dir, importMetaUrl) {
     return process.cwd();
   }
 }
-function hashContent(content, algorithm = "md5", length) {
+function hashContent2(content, algorithm = "md5", length) {
   const hash = crypto.createHash(algorithm).update(content).digest("hex");
   return length ? hash.slice(0, length) : hash;
 }
@@ -2496,7 +3793,7 @@ var init_src2 = __esm({
 // packages/domain/scanner/src/native-bridge.ts
 var native_bridge_exports = {};
 __export(native_bridge_exports, {
-  batchExtractClassesNative: () => batchExtractClassesNative,
+  batchExtractClassesNative: () => batchExtractClassesNative2,
   cachePriorityNative: () => cachePriorityNative,
   cacheReadNative: () => cacheReadNative,
   cacheWriteNative: () => cacheWriteNative,
@@ -2516,8 +3813,8 @@ __export(native_bridge_exports, {
   scanCacheInvalidate: () => scanCacheInvalidate,
   scanCachePut: () => scanCachePut,
   scanCacheStats: () => scanCacheStats,
-  scanFileNative: () => scanFileNative,
-  scanFilesBatchNative: () => scanFilesBatchNative,
+  scanFileNative: () => scanFileNative2,
+  scanFilesBatchNative: () => scanFilesBatchNative2,
   scanWorkspaceNative: () => scanWorkspaceNative,
   startWatchNative: () => startWatchNative,
   stopWatchNative: () => stopWatchNative
@@ -2608,7 +3905,7 @@ function cachePriorityNative(mtimeMs, size, cachedMtimeMs, cachedSize, cachedHit
   }
   return result;
 }
-function batchExtractClassesNative(filePaths) {
+function batchExtractClassesNative2(filePaths) {
   const binding = scannerGetBinding();
   if (!binding.batchExtractClasses) {
     throw new Error("FATAL: Native binding 'batchExtractClasses' is required but not available.");
@@ -2643,7 +3940,7 @@ function scanCacheStats() {
   }
   return binding.scanCacheStats();
 }
-function scanFileNative(filePath) {
+function scanFileNative2(filePath) {
   const binding = scannerGetBinding();
   if (!binding.scanFile) {
     throw new Error("FATAL: Native binding 'scanFile' is required but not available.");
@@ -2655,7 +3952,7 @@ function collectFilesNative(root, extensions, ignoreDirs) {
   if (!binding.collectFiles) return null;
   return binding.collectFiles(root, extensions, ignoreDirs);
 }
-function scanFilesBatchNative(filePaths) {
+function scanFilesBatchNative2(filePaths) {
   const binding = scannerGetBinding();
   if (!binding.scanFilesBatch) {
     return filePaths.map((fp) => {
@@ -2860,7 +4157,7 @@ var init_cache_native = __esm({
     init_native_bridge();
   }
 });
-function collectFiles(rootDir, extensions, ignoreDirs) {
+function collectFiles2(rootDir, extensions, ignoreDirs) {
   const native = collectFilesNative(rootDir, extensions, ignoreDirs);
   if (native !== null) return native;
   throw new Error("FATAL: Native binding 'collectFiles' is required but not available.");
@@ -2900,9 +4197,9 @@ async function scanWorkspaceParallel(rootDir, options = {}) {
     maxWorkers = Math.max(1, os.availableParallelism() - 1),
     chunkSize = DEFAULT_CHUNK_SIZE
   } = options;
-  const files = collectFiles(path9__namespace.default.resolve(rootDir), extensions, ignoreDirs);
+  const files = collectFiles2(path9__namespace.default.resolve(rootDir), extensions, ignoreDirs);
   if (files.length < PARALLEL_THRESHOLD) {
-    return mergeResults(batchExtractClassesNative(files));
+    return mergeResults(batchExtractClassesNative2(files));
   }
   const chunks = [];
   for (let i = 0; i < files.length; i += chunkSize) {
@@ -2926,7 +4223,7 @@ var init_parallel_scanner = __esm({
     if (!worker_threads.isMainThread && worker_threads.parentPort) {
       const { filePaths } = worker_threads.workerData;
       try {
-        const results = batchExtractClassesNative(filePaths);
+        const results = batchExtractClassesNative2(filePaths);
         const msg = { ok: true, results };
         worker_threads.parentPort.postMessage(msg);
       } catch (error) {
@@ -3010,15 +4307,15 @@ var src_exports2 = {};
 __export(src_exports2, {
   DEFAULT_EXTENSIONS: () => DEFAULT_EXTENSIONS,
   DEFAULT_IGNORES: () => DEFAULT_IGNORES,
-  batchExtractClassesNative: () => batchExtractClassesNative,
+  batchExtractClassesNative: () => batchExtractClassesNative2,
   extractClassesNative: () => extractClassesNative,
   isScannableFile: () => isScannableFile2,
   parseScanWorkspaceOptions: () => parseScanWorkspaceOptions,
   parseScanWorkspaceResult: () => parseScanWorkspaceResult,
   parseScannerWorkerMessage: () => parseScannerWorkerMessage,
-  scanFile: () => scanFile,
+  scanFile: () => scanFile2,
   scanSource: () => scanSource,
-  scanWorkspace: () => scanWorkspace,
+  scanWorkspace: () => scanWorkspace2,
   scanWorkspaceAsync: () => scanWorkspaceAsync
 });
 function getRuntimeDir() {
@@ -3144,9 +4441,9 @@ function scanSource(source) {
 function isScannableFile2(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
   return includeExtensions.includes(path9__namespace.default.extname(filePath));
 }
-function scanFile(filePath) {
-  const { scanFileNative: scanFileNative2 } = (init_native_bridge(), __toCommonJS(native_bridge_exports));
-  const result = scanFileNative2(filePath);
+function scanFile2(filePath) {
+  const { scanFileNative: scanFileNative3 } = (init_native_bridge(), __toCommonJS(native_bridge_exports));
+  const result = scanFileNative3(filePath);
   if (!result.ok) {
     throw new Error(`scanFile failed for ${filePath}: ${result.error ?? "unknown error"}`);
   }
@@ -3156,7 +4453,7 @@ function scanFile(filePath) {
     ...result.hash ? { hash: result.hash } : {}
   };
 }
-function scanWorkspace(rootDir, options = {}) {
+function scanWorkspace2(rootDir, options = {}) {
   const normalizedOptions = parseScanWorkspaceOptions(options);
   const includeExtensions = normalizedOptions.includeExtensions ?? DEFAULT_EXTENSIONS;
   const extensionSet = buildExtensionSet(includeExtensions);
@@ -3279,7 +4576,7 @@ function scanWorkspace(rootDir, options = {}) {
     }
   } else {
     for (const filePath of candidates) {
-      processResult(scanFile(filePath));
+      processResult(scanFile2(filePath));
     }
   }
   return parseScanWorkspaceResult({
@@ -3306,7 +4603,7 @@ async function scanWorkspaceAsync(rootDir, options = {}) {
     log3.debug(
       `worker scan failed, retrying with sync native scanner: ${error instanceof Error ? error.message : String(error)}`
     );
-    return scanWorkspace(rootDir, normalizedOptions);
+    return scanWorkspace2(rootDir, normalizedOptions);
   }
 }
 var log3, SCAN_WORKER_TIMEOUT_MS, createNativeParserLoader, nativeParserLoader, DEFAULT_EXTENSIONS, DEFAULT_IGNORES;
@@ -3499,24 +4796,31 @@ var init_native_bridge2 = __esm({
 
 // packages/domain/core/src/native.ts
 init_src2();
-var isBrowser4 = typeof window !== "undefined" || typeof document !== "undefined";
-var NATIVE_UNAVAILABLE_MESSAGE2 = "[tailwind-styled/core] Native binding is required but not available.\nPlease ensure you have run: npm run build:rust";
+var isBrowser4 = typeof window !== "undefined" && typeof document !== "undefined";
+var NATIVE_UNAVAILABLE_MESSAGE2 = "[tailwind-styled/core] Native binding is required but not available.\nMake sure:\n  1. .node files were copied to dist/ during build\n  2. You installed the correct native package for your platform\n  3. npm run build:rust was executed successfully";
 var _nodeRequire = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
 var _loadNative2 = (path15) => _nodeRequire(path15);
 var nativeBinding = null;
 var bindingLoadAttempted = false;
+var bindingError = null;
 var getBinding = () => {
-  if (isBrowser4) {
-    throw new Error(NATIVE_UNAVAILABLE_MESSAGE2 + "\n\nNative bindings are not available in browser. Use the compiled CSS output instead.");
-  }
   if (nativeBinding) return nativeBinding;
+  if (bindingError) {
+    throw bindingError;
+  }
   if (bindingLoadAttempted) {
     throw new Error(NATIVE_UNAVAILABLE_MESSAGE2);
   }
   bindingLoadAttempted = true;
   try {
-    const runtimeDir = isBrowser4 ? "" : path9.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href))));
-    const result = isBrowser4 ? { path: null, source: "not-found", platform: "browser", tried: [] } : resolveNativeBinary(runtimeDir);
+    if (isBrowser4) {
+      bindingError = new Error(
+        "[tailwind-styled/core] Cannot use template literals (tw`...`) in browser environment.\n\nTemplate literal parsing requires native Rust bindings compiled to WebAssembly,\nwhich is not currently supported.\n\nSolutions:\n1. Use object config only: tw.button({ base: '...', variants: {...} })\n2. Pre-compile components on the server (Next.js Server Components)\n3. Use @tailwind-styled browser-safe packages if available\n\nFor more info: https://github.com/Dictionar32/css-in-rust/discussions"
+      );
+      throw bindingError;
+    }
+    const runtimeDir = path9.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href))));
+    const result = resolveNativeBinary(runtimeDir);
     if (result.path && result.path.endsWith(".node")) {
       const mod = _loadNative2(result.path);
       if (mod?.batchSplitClasses) {
@@ -3524,11 +4828,22 @@ var getBinding = () => {
         return nativeBinding;
       }
     }
-    throw new Error(`${NATIVE_UNAVAILABLE_MESSAGE2}
+    bindingError = new Error(
+      `${NATIVE_UNAVAILABLE_MESSAGE2}
+
+Resolution Attempts:
+${result.tried.map((t2) => `  - ${t2}`).join("\n")}
 
-Tried: ${result.tried.join("\n")}`);
+Quick fixes:
+  1. npm run build:rust         # Build native binaries
+  2. npm install                # Reinstall with pre-built binaries
+  3. TW_NATIVE_PATH=/path/to/index.node npm run dev  # Specify binary path`
+    );
+    throw bindingError;
   } catch (err) {
-    throw err instanceof Error ? err : new Error(String(err));
+    const error = err instanceof Error ? err : new Error(String(err));
+    bindingError = error;
+    throw error;
   }
 };
 var getNativeBinding = getBinding;
@@ -3559,7 +4874,7 @@ function hashContainer(tag, container, name) {
   _hashContainerCache.set(sortedKey, id);
   return id;
 }
-function layoutClassesToCss(classes) {
+function layoutClassesToCss2(classes) {
   const native = getNativeBinding();
   if (!native?.layoutClassesToCss) {
     throw new Error("FATAL: Native binding 'layoutClassesToCss' is required but not available.");
@@ -3570,7 +4885,7 @@ function buildContainerRules(id, container, containerName) {
   const rules = Object.entries(container).map(([key, value]) => {
     const minWidth = typeof value === "string" ? CONTAINER_BREAKPOINTS[key] ?? key : value.minWidth ?? CONTAINER_BREAKPOINTS[key] ?? key;
     const classes = typeof value === "string" ? value : value.classes;
-    const css = layoutClassesToCss(classes);
+    const css = layoutClassesToCss2(classes);
     if (!css) return null;
     const query = containerName ? `@container ${containerName} (min-width: ${minWidth})` : `@container (min-width: ${minWidth})`;
     return `${query}{.${id}{${css}}}`;
@@ -3655,7 +4970,7 @@ function getContainerRegistry() {
 
 // packages/domain/core/src/merge.ts
 function createTwMerge(_options = {}) {
-  return function twMerge2(...classLists) {
+  return function twMerge3(...classLists) {
     const inputs = [];
     for (let i = 0; i < classLists.length; i++) {
       const v = classLists[i];
@@ -3669,11 +4984,11 @@ function createTwMerge(_options = {}) {
     return native.twMergeRaw(inputs);
   };
 }
-var twMerge = createTwMerge();
+var twMerge2 = createTwMerge();
 function mergeWithRules(rules, ...classLists) {
-  const base = twMerge(...classLists);
+  const base = twMerge2(...classLists);
   const classes = Object.values(rules).reduce(
-    (acc, rule) => twMerge(rule(acc)).split(/\s+/).filter(Boolean),
+    (acc, rule) => twMerge2(rule(acc)).split(/\s+/).filter(Boolean),
     base.split(/\s+/).filter(Boolean)
   );
   return classes.join(" ");
@@ -3938,7 +5253,7 @@ function makeFilterProps(variantKeys, stateKeys = /* @__PURE__ */ new Set()) {
     return out;
   };
 }
-function resolveVariants(variants, props, defaults) {
+function resolveVariants2(variants, props, defaults) {
   const variantKeys = Object.keys(variants);
   const cleanProps = {};
   for (const k of variantKeys) {
@@ -3989,7 +5304,7 @@ function attachExtend(component, originalTag, base, config) {
   function extendWithClasses(stringsOrConfig) {
     if (Array.isArray(stringsOrConfig) && "raw" in stringsOrConfig) {
       const rawExtra = stringsOrConfig.raw.join("").trim().replace(/\s+/g, " ");
-      const merged2 = twMerge(extractBaseClasses(base), extractBaseClasses(rawExtra));
+      const merged2 = twMerge2(extractBaseClasses(base), extractBaseClasses(rawExtra));
       const extended2 = createComponent(
         originalTag,
         typeof config === "string" ? merged2 : { ...config, base: merged2 }
@@ -4007,7 +5322,7 @@ function attachExtend(component, originalTag, base, config) {
     }
     const extCfg = stringsOrConfig;
     const extraClasses = extCfg.classes ?? "";
-    const merged = twMerge(extractBaseClasses(base), extraClasses);
+    const merged = twMerge2(extractBaseClasses(base), extraClasses);
     const existing = typeof config === "object" ? config : {};
     const extended = createComponent(originalTag, {
       ...existing,
@@ -4101,7 +5416,7 @@ function createComponent(tag, config) {
       const { className, ...rest } = props;
       const runtimeClassName = normalizeClassName(className);
       const statesClasses = statesConfig ? resolveStates(statesConfig, stateKeys, statesLookup, props) : "";
-      const mergedBase = twMerge(extractBaseClasses(base), engineClasses, runtimeClassName);
+      const mergedBase = twMerge2(extractBaseClasses(base), engineClasses, runtimeClassName);
       const className2 = statesClasses ? `${mergedBase} ${statesClasses}`.trim() : mergedBase;
       return React3__default.default.createElement(tag, {
         ref,
@@ -4118,10 +5433,10 @@ function createComponent(tag, config) {
   const baseComponent = React3__default.default.forwardRef((props, ref) => {
     const { className, ...rest } = props;
     const runtimeClassName = normalizeClassName(className);
-    const variantClasses = resolveVariants(variants, props, defaultVariants);
+    const variantClasses = resolveVariants2(variants, props, defaultVariants);
     const compoundClasses = resolveCompound(compoundVariants, props);
     const statesClasses = statesConfig ? resolveStates(statesConfig, stateKeys, statesLookup, props) : "";
-    const mergedBase = twMerge(extractBaseClasses(base), variantClasses, compoundClasses, engineClasses, runtimeClassName);
+    const mergedBase = twMerge2(extractBaseClasses(base), variantClasses, compoundClasses, engineClasses, runtimeClassName);
     const className2 = statesClasses ? `${mergedBase} ${statesClasses}`.trim() : mergedBase;
     return React3__default.default.createElement(tag, {
       ref,
@@ -4283,7 +5598,7 @@ function cv(config, componentId) {
     } else {
       result = resolveVariantsNative(config, props);
     }
-    return props.className ? twMerge(result, props.className) : result;
+    return props.className ? twMerge2(result, props.className) : result;
   };
 }
 
@@ -4586,7 +5901,7 @@ function resolveVariantClass(options, props) {
 }
 function resolveStyledClassName(options, props = {}) {
   const parts = [options.base ?? "", ...resolveVariantClass(options, props), props.className ?? ""];
-  return twMerge(...parts);
+  return twMerge2(...parts);
 }
 function styled(options) {
   return function getClassName(props = {}) {
@@ -4752,7 +6067,9 @@ function parseTemplate(strings, exprs) {
   if (cached) return cached;
   const binding = getNativeBinding();
   if (!binding?.parseTemplate) {
-    throw new Error("FATAL: Native binding 'parseTemplate' is required but not available.");
+    throw new Error(
+      "FATAL: Native binding 'parseTemplate' is required but not available in this environment.\n\nThis function is only available on Node.js with native bindings loaded.\nFor browser environments, use object config instead:\n  tw.button({ base: '...', variants: {...} })"
+    );
   }
   const r = binding.parseTemplate(raw);
   const subs = r.hasSubs ? JSON.parse(r.subsJson) : {};
@@ -5587,7 +6904,7 @@ init_src2();
 init_native_bridge2();
 var DEFAULT_EXTENSIONS2 = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
 var log5 = createLogger2("engine:incremental");
-function rebuildWorkspaceResult(byFile) {
+function rebuildWorkspaceResult2(byFile) {
   const files = Array.from(byFile.values());
   const native = getNativeEngineBinding();
   if (native?.rebuildWorkspaceResult) {
@@ -5630,10 +6947,10 @@ function applyIncrementalChange(previous, filePath, type, scanner) {
     log5.debug(`native unlink ${normalizedPath}`);
     native.processFileChange(normalizedPath, existing2?.classes ?? [], null);
     byFile.delete(normalizedPath);
-    return rebuildWorkspaceResult(byFile);
+    return rebuildWorkspaceResult2(byFile);
   }
   log5.debug(`native change ${normalizedPath}`);
-  const scanned = scanFile(normalizedPath);
+  const scanned = scanFile2(normalizedPath);
   const content = fs3__namespace.default.readFileSync(normalizedPath, "utf8");
   const diff = native.processFileChange(normalizedPath, scanned.classes, content);
   const existing = byFile.get(normalizedPath);
@@ -5646,7 +6963,7 @@ function applyIncrementalChange(previous, filePath, type, scanner) {
     log5.debug(`native diff cold-sync ${normalizedPath}`);
     byFile.set(normalizedPath, { file: normalizedPath, classes: scanned.classes });
   }
-  return rebuildWorkspaceResult(byFile);
+  return rebuildWorkspaceResult2(byFile);
 }
 
 // packages/domain/engine/src/metrics.ts
@@ -6324,7 +7641,7 @@ exports.t = t;
 exports.tokenRef = tokenRef;
 exports.tokenVar = tokenVar;
 exports.tw = tw;
-exports.twMerge = twMerge;
+exports.twMerge = twMerge2;
 exports.twVar = twVar;
 exports.v4Tokens = v4Tokens;
 exports.withSubComponents = withSubComponents;