tailwind-styled-v4 5.0.11 → 5.0.13

package/dist/vite.mjs

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createRequire } from 'module';
-import * as fs5 from 'fs';
-import fs5__default from 'fs';
-import * as path6 from 'path';
-import path6__default from 'path';
+import * as fs13 from 'fs';
+import fs13__default from 'fs';
+import * as path9 from 'path';
+import path9__default from 'path';
 import { createHash } from 'crypto';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
@@ -220,9 +220,9 @@ function parseNative(schema, data, context) {
   const result = schema.safeParse(data);
   if (!result.success) {
     const first = result.error.issues[0];
-    const path13 = first?.path?.join(".") ?? "(root)";
+    const path16 = first?.path?.join(".") ?? "(root)";
     throw new Error(
-      `[${context}] Native binding returned unexpected data: ${path13}: ${first?.message ?? "validation failed"}`
+      `[${context}] Native binding returned unexpected data: ${path16}: ${first?.message ?? "validation failed"}`
     );
   }
   return result.data;
@@ -615,11 +615,11 @@ function resolvePath(...segments) {
     return segments.join("/").replace(/\/+/g, "/");
   }
 }
-function existsSync(path13) {
+function existsSync(path16) {
   if (isBrowser2) return false;
   try {
     const nodeFs = __require(NODE_FS);
-    return nodeFs.existsSync(path13);
+    return nodeFs.existsSync(path16);
   } catch {
     return false;
   }
@@ -849,12 +849,12 @@ function resolveNativeBinary(runtimeDir) {
   if (isBrowser3) {
     return { path: null, source: "not-found", platform, tried: ["not available in browser"] };
   }
-  if (process.env.TWS_DISABLE_NATIVE === "1") {
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_DISABLE_NATIVE === "1") {
     return { path: null, source: "not-found", platform, tried: [] };
   }
   const envPath = process.env.TW_NATIVE_PATH?.trim();
   if (envPath) {
-    if (fs5.existsSync(envPath)) {
+    if (fs13.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
@@ -863,7 +863,7 @@ function resolveNativeBinary(runtimeDir) {
   for (const pkg of prebuiltPkgs) {
     try {
       const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs5.existsSync(candidate)) {
+      if (fs13.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -874,13 +874,13 @@ function resolveNativeBinary(runtimeDir) {
   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"];
   if (runtimeDir) {
-    for (const depth of ["..", path6.join("..", ".."), path6.join("..", "..", "..")]) {
-      const pkgRoot = path6.resolve(runtimeDir, depth);
+    for (const depth of ["..", path9.join("..", ".."), path9.join("..", "..", "..")]) {
+      const pkgRoot = path9.resolve(runtimeDir, depth);
       for (const bin of BINARY_NAMES_SELF) {
         for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
-          const candidate = path6.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
+          const candidate = path9.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
           tried.push(`self-bundled:${candidate}`);
-          if (fs5.existsSync(candidate)) {
+          if (fs13.existsSync(candidate)) {
             return { path: candidate, source: "prebuilt", platform, tried };
           }
         }
@@ -892,29 +892,29 @@ function resolveNativeBinary(runtimeDir) {
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const localCandidates = [];
   for (const bin of BINARY_NAMES) {
-    localCandidates.push(path6.resolve(base, `${bin}.node`));
-    localCandidates.push(path6.resolve(base, "..", `${bin}.node`));
-    localCandidates.push(path6.resolve(base, `${bin}.${platform}.node`));
-    localCandidates.push(path6.resolve(base, `${bin}.${napiPlatform}.node`));
+    localCandidates.push(path9.resolve(base, `${bin}.node`));
+    localCandidates.push(path9.resolve(base, "..", `${bin}.node`));
+    localCandidates.push(path9.resolve(base, `${bin}.${platform}.node`));
+    localCandidates.push(path9.resolve(base, `${bin}.${napiPlatform}.node`));
   }
   for (const startDir of [cwd, base]) {
     let dir = startDir;
     for (let i = 0; i < 6; i++) {
-      const nativeDir = path6.resolve(dir, "native");
+      const nativeDir = path9.resolve(dir, "native");
       for (const bin of BINARY_NAMES) {
-        localCandidates.push(path6.resolve(nativeDir, `${bin}.node`));
-        localCandidates.push(path6.resolve(nativeDir, `${bin}.${platform}.node`));
-        localCandidates.push(path6.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
-        localCandidates.push(path6.resolve(nativeDir, "target", "release", `${bin}.node`));
+        localCandidates.push(path9.resolve(nativeDir, `${bin}.node`));
+        localCandidates.push(path9.resolve(nativeDir, `${bin}.${platform}.node`));
+        localCandidates.push(path9.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
+        localCandidates.push(path9.resolve(nativeDir, "target", "release", `${bin}.node`));
       }
-      const parent = path6.resolve(dir, "..");
+      const parent = path9.resolve(dir, "..");
       if (parent === dir) break;
       dir = parent;
     }
   }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs5.existsSync(candidate)) {
+    if (fs13.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
@@ -953,9 +953,9 @@ var init_native_resolution = __esm({
 // packages/domain/shared/src/observability.ts
 function createObservabilityClient(opts = {}) {
   const { baseUrl = "http://localhost:7421", timeoutMs = 3e3 } = opts;
-  async function fetchJson(path13) {
+  async function fetchJson(path16) {
     try {
-      const res = await fetch(`${baseUrl}${path13}`, {
+      const res = await fetch(`${baseUrl}${path16}`, {
         signal: AbortSignal.timeout(timeoutMs)
       });
       if (!res.ok) return null;
@@ -987,6 +987,2041 @@ var init_observability = __esm({
   }
 });
 
+// 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/tailwindEngine.ts
+var tailwindEngine_exports = {};
+__export(tailwindEngine_exports, {
+  clearCache: () => clearCache,
+  getCacheStats: () => getCacheStats,
+  processTailwindCssWithTargets: () => processTailwindCssWithTargets,
+  runCssPipeline: () => runCssPipeline,
+  runCssPipelineSync: () => runCssPipelineSync
+});
+function _getCacheKey(classes, minify, cssEntry, root) {
+  const sorted = [...classes].sort().join(",");
+  const flags = `${minify ? "1" : "0"}${cssEntry ? "1" : "0"}${root ? "1" : "0"}`;
+  return `${sorted}|${flags}`;
+}
+function _evictOldestIfNeeded() {
+  if (_cssCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = _cssCache.keys().next().value;
+    if (firstKey !== void 0) {
+      _cssCache.delete(firstKey);
+    }
+  }
+}
+function getCacheStats() {
+  const total = _cacheHits + _cacheMisses;
+  return {
+    hits: _cacheHits,
+    misses: _cacheMisses,
+    hitRate: total > 0 ? _cacheHits / total : 0,
+    size: _cssCache.size,
+    maxSize: MAX_CACHE_SIZE
+  };
+}
+function clearCache() {
+  _cssCache.clear();
+  _cacheHits = 0;
+  _cacheMisses = 0;
+}
+function getThemeConfig() {
+  return {
+    colors: {
+      slate: {
+        "50": "#f8fafc",
+        "100": "#f1f5f9",
+        "200": "#e2e8f0",
+        "300": "#cbd5e1",
+        "400": "#94a3b8",
+        "500": "#64748b",
+        "600": "#475569",
+        "700": "#334155",
+        "800": "#1e293b",
+        "900": "#0f172a"
+      },
+      gray: {
+        "50": "#f9fafb",
+        "100": "#f3f4f6",
+        "200": "#e5e7eb",
+        "300": "#d1d5db",
+        "400": "#9ca3af",
+        "500": "#6b7280",
+        "600": "#4b5563",
+        "700": "#374151",
+        "800": "#1f2937",
+        "900": "#111827"
+      },
+      white: "#ffffff",
+      black: "#000000",
+      red: {
+        "500": "#ef4444",
+        "600": "#dc2626"
+      },
+      blue: {
+        "500": "#3b82f6",
+        "600": "#1e40af"
+      }
+    },
+    spacing: {
+      "0": "0px",
+      "1": "0.25rem",
+      "2": "0.5rem",
+      "3": "0.75rem",
+      "4": "1rem",
+      "5": "1.25rem",
+      "6": "1.5rem",
+      "8": "2rem",
+      "10": "2.5rem",
+      "12": "3rem",
+      "16": "4rem",
+      "20": "5rem",
+      "24": "6rem"
+    },
+    breakpoints: {
+      "sm": "640px",
+      "md": "768px",
+      "lg": "1024px",
+      "xl": "1280px",
+      "2xl": "1536px"
+    }
+  };
+}
+function postProcessWithLightning(rawCss) {
+  if (!rawCss) return "";
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssLightning) {
+    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
+  }
+  const result = native.processTailwindCssLightning(rawCss);
+  if (!result?.css) {
+    throw new Error("FATAL: processTailwindCssLightning returned null");
+  }
+  return result.css;
+}
+async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
+  const filtered = classes.filter(Boolean);
+  const uniqueMap = /* @__PURE__ */ new Map();
+  filtered.forEach((cls) => uniqueMap.set(cls, cls));
+  const unique = Array.from(uniqueMap.values());
+  if (unique.length === 0) {
+    return { css: "", classes: [], sizeBytes: 0, optimized: false };
+  }
+  const cacheKey = _getCacheKey(unique, minify, cssEntryContent, root);
+  const cached = _cssCache.get(cacheKey);
+  if (cached) {
+    _cacheHits++;
+    if (process.env.DEBUG?.includes("compiler")) {
+      console.log(
+        `[Compiler] Cache HIT: ${unique.length} classes (hit rate: ${(getCacheStats().hitRate * 100).toFixed(1)}%)`
+      );
+    }
+    return cached;
+  }
+  _cacheMisses++;
+  let rawCss;
+  let usedRustCompiler = false;
+  const theme = getThemeConfig();
+  rawCss = await generateCssNative(unique, { theme });
+  usedRustCompiler = true;
+  const finalCss = minify ? postProcessWithLightning(rawCss) : rawCss;
+  if (process.env.DEBUG?.includes("compiler")) {
+    console.log(
+      `[Compiler] Generated CSS from ${unique.length} classes (${usedRustCompiler ? "Rust" : "JavaScript"})`,
+      `Size: ${finalCss.length} bytes`
+    );
+  }
+  const result = {
+    css: finalCss,
+    classes: unique,
+    sizeBytes: finalCss.length,
+    optimized: minify
+  };
+  _evictOldestIfNeeded();
+  _cssCache.set(cacheKey, result);
+  return result;
+}
+function runCssPipelineSync(_classes) {
+  return { css: "", classes: [], sizeBytes: 0, optimized: false };
+}
+function processTailwindCssWithTargets(css, targets) {
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssWithTargets) {
+    throw new Error("FATAL: Native binding 'processTailwindCssWithTargets' is required but not available.");
+  }
+  const result = native.processTailwindCssWithTargets(css, targets ?? null);
+  if (!result?.css) {
+    throw new Error("FATAL: processTailwindCssWithTargets returned null");
+  }
+  return result.css;
+}
+var _cssCache, _cacheHits, _cacheMisses, MAX_CACHE_SIZE;
+var init_tailwindEngine = __esm({
+  "packages/domain/compiler/src/compiler/tailwindEngine.ts"() {
+    init_nativeBridge();
+    init_cssGeneratorNative();
+    createRequire(import.meta.url);
+    _cssCache = /* @__PURE__ */ new Map();
+    _cacheHits = 0;
+    _cacheMisses = 0;
+    MAX_CACHE_SIZE = 100;
+  }
+});
+
+// packages/domain/compiler/src/compiler/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/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 scanCacheOptimizations() {
+  const native = getNativeBridge();
+  if (!native?.scan_cache_optimizations) throw new Error("scan_cache_optimizations not available");
+  return native.scan_cache_optimizations();
+}
+function getPluginHooks() {
+  const native = getNativeBridge();
+  if (!native?.get_plugin_hooks) throw new Error("get_plugin_hooks not available");
+  const result = native.get_plugin_hooks();
+  try {
+    return JSON.parse(result);
+  } catch {
+    return [];
+  }
+}
+function registerPluginHook(hook_name, handler_id) {
+  const native = getNativeBridge();
+  if (!native?.register_plugin_hook) throw new Error("register_plugin_hook not available");
+  return native.register_plugin_hook(hook_name, handler_id);
+}
+function unregisterPluginHook(hook_name, handler_id) {
+  const native = getNativeBridge();
+  if (!native?.unregister_plugin_hook) throw new Error("unregister_plugin_hook not available");
+  return native.unregister_plugin_hook(hook_name, handler_id);
+}
+function emitPluginHook(hook_name, data_json) {
+  const native = getNativeBridge();
+  if (!native?.emit_plugin_hook) throw new Error("emit_plugin_hook not available");
+  return native.emit_plugin_hook(hook_name, data_json);
+}
+function getCompilationMetrics() {
+  const native = getNativeBridge();
+  if (!native?.get_compilation_metrics) throw new Error("get_compilation_metrics not available");
+  return native.get_compilation_metrics();
+}
+function resetCompilationMetrics() {
+  const native = getNativeBridge();
+  if (!native?.reset_compilation_metrics) throw new Error("reset_compilation_metrics not available");
+  return native.reset_compilation_metrics();
+}
+function validateCssOutput(css) {
+  const native = getNativeBridge();
+  if (!native?.validate_css_output) throw new Error("validate_css_output not available");
+  return native.validate_css_output(css);
+}
+function getCompilerDiagnostics() {
+  const native = getNativeBridge();
+  if (!native?.get_compiler_diagnostics) throw new Error("get_compiler_diagnostics not available");
+  return native.get_compiler_diagnostics();
+}
+var init_watchSystemNative = __esm({
+  "packages/domain/compiler/src/watch/watchSystemNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/watch/index.ts
+var init_watch = __esm({
+  "packages/domain/compiler/src/watch/index.ts"() {
+    init_watchSystemNative();
+  }
+});
+
+// packages/domain/compiler/src/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  adaptNativeResult: () => adaptNativeResult,
+  analyzeClassUsageNative: () => analyzeClassUsageNative,
+  analyzeClasses: () => analyzeClasses,
+  analyzeClassesNative: () => analyzeClassesNative,
+  analyzeFile: () => analyzeFile,
+  analyzeRscNative: () => analyzeRscNative,
+  analyzeVariantUsage: () => analyzeVariantUsage,
+  astExtractClasses: () => astExtractClasses,
+  atomicRegistrySize: () => atomicRegistrySize,
+  batchExtractClasses: () => batchExtractClasses,
+  batchExtractClassesNative: () => batchExtractClassesNative,
+  bucketSort: () => bucketSort,
+  buildStyleTag: () => buildStyleTag,
+  cachePriority: () => cachePriority,
+  cacheRead: () => cacheRead,
+  cacheWrite: () => cacheWrite,
+  checkAgainstSafelist: () => checkAgainstSafelist,
+  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,
+  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,
+  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,
+  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,
+  mergeCssDeclarationsNative: () => mergeCssDeclarationsNative,
+  minifyCss: () => minifyCss,
+  normalizeAndDedupClasses: () => normalizeAndDedupClasses,
+  normalizeClasses: () => normalizeClasses,
+  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,
+  startWatch: () => startWatch,
+  stopWatch: () => stopWatch,
+  toAtomicClasses: () => toAtomicClasses,
+  transformSource: () => transformSource,
+  twMerge: () => twMerge,
+  twMergeMany: () => twMergeMany,
+  twMergeManyWithSeparator: () => twMergeManyWithSeparator,
+  twMergeRaw: () => twMergeRaw,
+  twMergeWithSeparator: () => twMergeWithSeparator,
+  unregisterPluginHook: () => unregisterPluginHook,
+  validateCssOutput: () => validateCssOutput,
+  validateThemeConfig: () => validateThemeConfig,
+  valueIdToString: () => valueIdToString,
+  walkAndPrefilterSourceFiles: () => walkAndPrefilterSourceFiles,
+  watchAddPattern: () => watchAddPattern,
+  watchClearAll: () => watchClearAll,
+  watchEventTypeToString: () => watchEventTypeToString,
+  watchGetActiveHandles: () => watchGetActiveHandles,
+  watchPause: () => watchPause,
+  watchRemovePattern: () => watchRemovePattern,
+  watchResume: () => watchResume
+});
+var init_internal = __esm({
+  "packages/domain/compiler/src/internal.ts"() {
+    init_src2();
+    init_tailwindEngine();
+    init_compiler();
+    init_parser();
+    init_analyzer();
+    init_cache();
+    init_redis();
+    init_watch();
+  }
+});
+function getNative() {
+  if (_native) return _native;
+  try {
+    const mod = (init_internal(), __toCommonJS(internal_exports));
+    if (typeof mod?.extractTwStateConfigs !== "function" || typeof mod?.generateStaticStateCss !== "function") {
+      return null;
+    }
+    _native = {
+      extractTwStateConfigs: mod.extractTwStateConfigs,
+      generateStaticStateCss: mod.generateStaticStateCss,
+      extractAndGenerateStateCss: mod.extractAndGenerateStateCss ?? // Fallback jika extractAndGenerateStateCss belum di-export
+      ((source, filename) => {
+        const configs = mod.extractTwStateConfigs(source, filename);
+        if (configs.length === 0) return [];
+        return mod.generateStaticStateCss(configs.map((c) => ({
+          tag: c.tag,
+          componentName: c.componentName,
+          statesJson: c.statesJson
+        })));
+      })
+    };
+    return _native;
+  } catch {
+    return null;
+  }
+}
+function* walkSourceFiles(dir) {
+  let entries;
+  try {
+    entries = fs13__default.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path9__default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (IGNORE_PATTERNS.some((p) => entry.name === p || entry.name.startsWith(p))) continue;
+      yield* walkSourceFiles(fullPath);
+    } else if (entry.isFile()) {
+      const ext = path9__default.extname(entry.name);
+      if (SOURCE_EXTENSIONS.has(ext)) yield fullPath;
+    }
+  }
+}
+function buildCssHeader(result) {
+  return [
+    "/* \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    " * tw-state-static.css \u2014 Auto-generated by staticStateExtractor.ts",
+    " * DO NOT EDIT. Re-generated on each build.",
+    " *",
+    ` * Files scanned:      ${result.filesScanned}`,
+    ` * Files with states:  ${result.filesWithStates}`,
+    ` * Components found:   ${result.componentsFound}`,
+    ` * Rules generated:    ${result.rulesGenerated}`,
+    ` * Rules skipped:      ${result.rulesSkipped} (akan di-inject runtime sebagai fallback)`,
+    " *",
+    ' * Selector format: .tw-s-[hash][data-stateName="true"] { ... }',
+    " * Hash identik dengan yang dibuat oleh stateEngine.ts di runtime.",
+    " * \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */",
+    ""
+  ].join("\n");
+}
+function extractStaticStateCss(srcDir, options = {}) {
+  const { verbose = false, maxFiles = Infinity } = options;
+  const native = getNative();
+  if (!native) {
+    if (verbose) {
+      process.stderr.write(
+        "[tw:static-state] native module tidak tersedia \u2014 skip static CSS pre-generation\n"
+      );
+    }
+    return {
+      filesScanned: 0,
+      filesWithStates: 0,
+      componentsFound: 0,
+      rulesGenerated: 0,
+      rulesSkipped: 0,
+      generatedCss: "",
+      rules: []
+    };
+  }
+  const allConfigs = [];
+  let filesScanned = 0;
+  let filesWithStates = 0;
+  if (native.walkAndPrefilterSourceFiles) {
+    const prefiltered = native.walkAndPrefilterSourceFiles(
+      srcDir,
+      [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"],
+      ["node_modules", ".next", "dist", "build", ".git", "coverage", "__tests__"],
+      // Required substrings — AND logic, identik dengan JS pre-filter di bawah
+      ["states:", "tw."],
+      maxFiles === Infinity ? null : maxFiles,
+      null
+      // sequential — parallel mode opsional untuk large monorepo
+    );
+    for (const { path: filePath, content: source } of prefiltered) {
+      filesScanned++;
+      const configs = native.extractTwStateConfigs(source, filePath);
+      if (configs.length > 0) {
+        filesWithStates++;
+        allConfigs.push(...configs);
+        if (verbose) {
+          process.stderr.write(
+            `[tw:static-state] ${path9__default.relative(srcDir, filePath)}: ${configs.length} komponen
+`
+          );
+        }
+      }
+    }
+  } else {
+    for (const filePath of walkSourceFiles(srcDir)) {
+      if (filesScanned >= maxFiles) break;
+      let source;
+      try {
+        source = fs13__default.readFileSync(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      filesScanned++;
+      if (!source.includes("states:") && !source.includes("states :")) continue;
+      if (!source.includes("tw.") && !source.includes("tailwind-styled")) continue;
+      const configs = native.extractTwStateConfigs(source, filePath);
+      if (configs.length > 0) {
+        filesWithStates++;
+        allConfigs.push(...configs);
+        if (verbose) {
+          process.stderr.write(
+            `[tw:static-state] ${path9__default.relative(srcDir, filePath)}: ${configs.length} komponen
+`
+          );
+        }
+      }
+    }
+  }
+  if (allConfigs.length === 0) {
+    return {
+      filesScanned,
+      filesWithStates: 0,
+      componentsFound: 0,
+      rulesGenerated: 0,
+      rulesSkipped: 0,
+      generatedCss: "",
+      rules: []
+    };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueConfigs = [];
+  for (const config of allConfigs) {
+    const key = `${config.tag}::${config.statesJson}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueConfigs.push({
+        tag: config.tag,
+        componentName: config.componentName,
+        statesJson: config.statesJson
+      });
+    }
+  }
+  const allRules = native.generateStaticStateCss(uniqueConfigs, options.resolvedCss ?? null);
+  const rulesSkipped = uniqueConfigs.reduce((total, cfg) => {
+    try {
+      const stateMap = JSON.parse(cfg.statesJson);
+      return total + Object.keys(stateMap).length;
+    } catch {
+      return total;
+    }
+  }, 0) - allRules.length;
+  const byComponent = /* @__PURE__ */ new Map();
+  for (const rule of allRules) {
+    const existing = byComponent.get(rule.componentName) ?? [];
+    existing.push(rule);
+    byComponent.set(rule.componentName, existing);
+  }
+  const cssBlocks = [];
+  for (const [componentName, rules] of byComponent) {
+    cssBlocks.push(`/* ${componentName} */`);
+    for (const rule of rules) {
+      cssBlocks.push(`/* state: ${rule.stateName} */`);
+      cssBlocks.push(rule.cssRule);
+    }
+    cssBlocks.push("");
+  }
+  const result = {
+    filesScanned,
+    filesWithStates,
+    componentsFound: allConfigs.length,
+    rulesGenerated: allRules.length,
+    rulesSkipped: Math.max(0, rulesSkipped),
+    generatedCss: cssBlocks.join("\n"),
+    rules: allRules
+  };
+  result.generatedCss = buildCssHeader(result) + result.generatedCss;
+  return result;
+}
+function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
+  const result = extractStaticStateCss(srcDir, options);
+  const twClassesDir = path9__default.join(path9__default.dirname(safelistPath), "tw-classes");
+  fs13__default.mkdirSync(twClassesDir, { recursive: true });
+  const stateFilePath = path9__default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+  if (result.rulesGenerated === 0) {
+    try {
+      fs13__default.writeFileSync(
+        stateFilePath,
+        "/* tw-state-static.css \u2014 tidak ada state rules yang di-generate */\n",
+        "utf-8"
+      );
+    } catch {
+    }
+    return `[tw:static-state] tidak ada state rules yang di-generate (${result.filesScanned} files di-scan)`;
+  }
+  try {
+    fs13__default.writeFileSync(stateFilePath, result.generatedCss, "utf-8");
+    return [
+      `[tw:static-state] ${result.rulesGenerated} static state rules di-generate`,
+      `  \u2192 ${result.filesScanned} files scanned, ${result.filesWithStates} dengan states`,
+      `  \u2192 ${result.componentsFound} components, ${result.rulesSkipped} rules skipped (fallback ke runtime)`,
+      `  \u2192 ditulis ke tw-classes/${TW_STATE_STATIC_FILENAME}`
+    ].join("\n");
+  } catch (writeErr) {
+    const msg = writeErr instanceof Error ? writeErr.message : String(writeErr);
+    return `[tw:static-state] gagal tulis state CSS: ${msg}`;
+  }
+}
+var SOURCE_EXTENSIONS, IGNORE_PATTERNS, _native, TW_STATE_STATIC_FILENAME;
+var init_staticStateExtractor = __esm({
+  "packages/domain/shared/src/staticStateExtractor.ts"() {
+    SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"]);
+    IGNORE_PATTERNS = ["node_modules", ".next", "dist", "build", ".git", "coverage", "__tests__"];
+    _native = null;
+    TW_STATE_STATIC_FILENAME = "_tw-state-static.css";
+  }
+});
+function getEnvLevel() {
+  const env = process.env.TWS_LOG_LEVEL?.toLowerCase();
+  if (env && env in LEVELS) return env;
+  return process.env.TWS_DEBUG_SCANNER === "1" ? "debug" : "info";
+}
+function setGlobalLogFile(filePath) {
+  _globalLogFile = filePath;
+  _logFileInitialized = false;
+  try {
+    fs13__default.mkdirSync(path9__default.dirname(filePath), { recursive: true });
+    fs13__default.writeFileSync(
+      filePath,
+      `# tailwind-styled build log \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
+`,
+      "utf-8"
+    );
+    _logFileInitialized = true;
+  } catch {
+  }
+}
+function writeToFile(line) {
+  if (!_globalLogFile || !_logFileInitialized) return;
+  try {
+    fs13__default.appendFileSync(_globalLogFile, line);
+  } catch {
+  }
+}
+function createLogger(prefix, level) {
+  const loggerState = {
+    currentLevel: getEnvLevel(),
+    setLevel(l) {
+      this.currentLevel = l;
+    }
+  };
+  const log7 = (msgLevel, stream, args) => {
+    if (LEVELS[msgLevel] > LEVELS[loggerState.currentLevel]) return;
+    const line = `[${prefix}] ${args.map(String).join(" ")}
+`;
+    process[stream].write(line);
+    writeToFile(line);
+  };
+  return {
+    error: (...a) => log7("error", "stderr", a),
+    warn: (...a) => log7("warn", "stderr", a),
+    info: (...a) => log7("info", "stdout", a),
+    debug: (...a) => log7("debug", "stderr", a),
+    setLevel: loggerState.setLevel,
+    setLogFile: (filePath) => setGlobalLogFile(filePath)
+  };
+}
+var LEVELS, _globalLogFile, _logFileInitialized;
+var init_logger = __esm({
+  "packages/domain/shared/src/logger.ts"() {
+    LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
+    _globalLogFile = null;
+    _logFileInitialized = false;
+    createLogger("tailwind-styled");
+  }
+});
+
 // packages/domain/shared/src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -1005,18 +3040,21 @@ __export(src_exports, {
   RegistryPluginEntrySchema: () => RegistryPluginEntrySchema,
   ScanCacheClassEntrySchema: () => ScanCacheClassEntrySchema,
   ScanCacheSchema: () => ScanCacheSchema,
+  TW_STATE_STATIC_FILENAME: () => TW_STATE_STATIC_FILENAME,
   TailwindConfigSchema: () => TailwindConfigSchema,
   TelemetryCollector: () => TelemetryCollector,
   TwError: () => TwError,
+  appendStaticStateCssToSafelist: () => appendStaticStateCssToSafelist,
   assertTailwindV4: () => assertTailwindV4,
   calculateHealth: () => calculateHealth,
   createBuildTimer: () => createBuildTimer,
   createDebugLogger: () => createDebugLogger,
   createEsmRequire: () => createEsmRequire,
-  createLogger: () => createLogger,
+  createLogger: () => createLogger2,
   createObservabilityClient: () => createObservabilityClient,
   createTraceSnapshot: () => createTraceSnapshot,
   detectTailwind: () => detectTailwind,
+  extractStaticStateCss: () => extractStaticStateCss,
   formatDuration: () => formatDuration,
   formatErrorCode: () => formatErrorCode,
   formatErrorMessage: () => formatErrorMessage,
@@ -1036,7 +3074,7 @@ __export(src_exports, {
   getPipelinePercentages: () => getPipelinePercentages,
   getSuggestion: () => getSuggestion,
   getTailwindVersion: () => getTailwindVersion,
-  hashContent: () => hashContent,
+  hashContent: () => hashContent2,
   isTailwindV4: () => isTailwindV4,
   isTwError: () => isTwError,
   loadNativeBinding: () => loadNativeBinding,
@@ -1052,10 +3090,11 @@ __export(src_exports, {
   resolveRuntimeDir: () => resolveRuntimeDir,
   resolveWorkerPath: () => resolveWorkerPath,
   safeParseNative: () => safeParseNative,
+  setGlobalLogFile: () => setGlobalLogFile,
   tryRequire: () => tryRequire,
   wrapUnknownError: () => wrapUnknownError
 });
-function createLogger(namespace) {
+function createLogger2(namespace) {
   const prefix = `[${namespace}]`;
   return {
     warn(...args) {
@@ -1084,9 +3123,9 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path13) {
-  if (!path13 || path13.length === 0) return "(root)";
-  return path13.map(
+function formatIssuePath(path16) {
+  if (!path16 || path16.length === 0) return "(root)";
+  return path16.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
@@ -1100,9 +3139,9 @@ function loadNativeBinding(options) {
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
   for (const candidate of candidates) {
-    const candidatePath = path6__default.resolve(runtimeDir, candidate);
+    const candidatePath = path9__default.resolve(runtimeDir, candidate);
     try {
-      if (!fs5__default.existsSync(candidatePath) && !fs5__default.existsSync(candidatePath + ".node")) {
+      if (!fs13__default.existsSync(candidatePath) && !fs13__default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -1134,9 +3173,9 @@ function resolveNativeBindingCandidates(options) {
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs5__default.existsSync(runtimeDir)) {
+  if (fs13__default.existsSync(runtimeDir)) {
     try {
-      for (const entry of fs5__default.readdirSync(runtimeDir)) {
+      for (const entry of fs13__default.readdirSync(runtimeDir)) {
         if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
@@ -1145,27 +3184,27 @@ function resolveNativeBindingCandidates(options) {
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const napiPlatform = process.platform === "linux" && process.arch === "x64" ? "linux-x64-gnu" : process.platform === "linux" && process.arch === "arm64" ? "linux-arm64-gnu" : `${process.platform}-${process.arch}`;
   for (const bin of BINARY_NAMES) {
-    candidates.push(path6__default.resolve(runtimeDir, `${bin}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, "..", "native", `${bin}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path6__default.resolve(process.cwd(), "native", `${bin}.node`));
-    candidates.push(path6__default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, `${bin}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, "..", "native", `${bin}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path9__default.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(path9__default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
   }
   return Array.from(new Set(candidates));
 }
 function resolveRuntimeDir(dir, importMetaUrl) {
-  if (dir) return path6__default.resolve(dir);
+  if (dir) return path9__default.resolve(dir);
   try {
-    return path6__default.dirname(fileURLToPath(importMetaUrl));
+    return path9__default.dirname(fileURLToPath(importMetaUrl));
   } catch {
     return process.cwd();
   }
 }
-function hashContent(content, algorithm = "md5", length) {
+function hashContent2(content, algorithm = "md5", length) {
   const hash = createHash(algorithm).update(content).digest("hex");
   return length ? hash.slice(0, length) : hash;
 }
@@ -1188,6 +3227,8 @@ var init_src = __esm({
     init_codegen();
     init_native_resolution();
     init_observability();
+    init_staticStateExtractor();
+    init_logger();
     TwError = class _TwError extends Error {
       /** @deprecated Gunakan source */
       domain;
@@ -1221,8 +3262,8 @@ var init_src = __esm({
       /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
       static fromZod(err) {
         const first = err.issues?.[0] ?? err.errors?.[0];
-        const path13 = formatIssuePath(first?.path);
-        const message = first ? `${path13}: ${first.message}` : "Schema validation failed";
+        const path16 = formatIssuePath(first?.path);
+        const message = first ? `${path16}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -1286,11 +3327,11 @@ var init_src = __esm({
 });
 
 // packages/domain/compiler/src/nativeBridge.ts
-var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge;
+var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge, adaptNativeResult;
 var init_nativeBridge = __esm({
   "packages/domain/compiler/src/nativeBridge.ts"() {
     init_src();
-    _loadNative = (path13) => __require(path13);
+    _loadNative = (path16) => __require(path16);
     log = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -1339,6 +3380,15 @@ Tried paths: ${result.tried.join("\n")}`);
         throw bridgeLoadError;
       }
     };
+    adaptNativeResult = (raw) => {
+      return {
+        code: raw.code ?? "",
+        classes: raw.classes ?? [],
+        changed: raw.changed ?? false,
+        rsc: raw.rscJson ? JSON.parse(raw.rscJson) : void 0,
+        metadata: raw.metadataJson ? JSON.parse(raw.metadataJson) : void 0
+      };
+    };
     if (typeof process !== "undefined" && !bridgeLoadAttempted) {
       try {
         getNativeBridge();
@@ -1347,110 +3397,377 @@ Tried paths: ${result.tried.join("\n")}`);
     }
   }
 });
-
-// packages/domain/compiler/src/tailwindEngine.ts
-var tailwindEngine_exports = {};
-__export(tailwindEngine_exports, {
-  generateRawCss: () => generateRawCss,
-  processTailwindCssWithTargets: () => processTailwindCssWithTargets,
-  runCssPipeline: () => runCssPipeline,
-  runCssPipelineSync: () => runCssPipelineSync
-});
-function loadTailwindEngine() {
-  if (_twEngine) return _twEngine;
-  if (_twEngineError) throw _twEngineError;
-  try {
-    const tw = require2("tailwindcss");
-    if (typeof tw.compile !== "function") {
-      throw new Error("tailwindcss v4 not found \u2014 compile() API missing. Check tailwindcss version >= 4.");
-    }
-    _twEngine = tw;
-    return _twEngine;
-  } catch (e) {
-    _twEngineError = e instanceof Error ? e : new Error(String(e));
-    throw _twEngineError;
-  }
-}
-async function generateRawCss(classes, cssEntryContent, root) {
-  if (classes.length === 0) return "";
-  const tw = loadTailwindEngine();
-  const input = cssEntryContent ?? "@import 'tailwindcss';";
-  const { readFileSync, existsSync: existsSync3 } = await import('fs');
-  const { dirname, resolve: resolve2 } = await import('path');
-  const projectRoot = root ?? process.cwd();
-  const req = createRequire(resolve2(projectRoot, "package.json"));
-  const loadStylesheet = async (id, base) => {
-    try {
-      const cssId = id === "tailwindcss" ? "tailwindcss/index.css" : id === "tailwindcss/preflight" ? "tailwindcss/preflight.css" : id === "tailwindcss/utilities" ? "tailwindcss/utilities.css" : id === "tailwindcss/theme" ? "tailwindcss/theme.css" : id;
-      const pkgPath = req.resolve(cssId);
-      return {
-        content: readFileSync(pkgPath, "utf-8"),
-        base: dirname(pkgPath)
-      };
-    } catch {
-      try {
-        const absPath = resolve2(base, id);
-        if (existsSync3(absPath)) {
-          return { content: readFileSync(absPath, "utf-8"), base: dirname(absPath) };
-        }
-      } catch {
-      }
-      return { content: "", base };
-    }
-  };
-  const compiler = await Promise.resolve(tw.compile(input, { loadStylesheet }));
-  return compiler.build(classes);
-}
-function postProcessWithLightning(rawCss) {
-  if (!rawCss) return "";
+function _layoutClassesToCss(classes) {
   const native = getNativeBridge();
-  if (typeof native.processTailwindCssLightning !== "function") {
-    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
+  if (!native?.layoutClassesToCss) {
+    throw new Error("FATAL: Native binding 'layoutClassesToCss' is required but not available.");
   }
-  const result = native.processTailwindCssLightning(rawCss);
-  return result?.css ?? rawCss;
+  return native.layoutClassesToCss(classes);
 }
-async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
-  const unique = [...new Set(classes.filter(Boolean))];
-  if (unique.length === 0) {
-    return { css: "", classes: [], sizeBytes: 0, optimized: false };
-  }
-  const rawCss = await generateRawCss(unique, cssEntryContent, root);
+function _hashContainer(tag, containerJson, name) {
+  const sortedKey = tag + (name ?? "") + containerJson;
   const native = getNativeBridge();
-  const hasLightning = minify && typeof native.processTailwindCssLightning === "function";
-  const finalCss = hasLightning ? postProcessWithLightning(rawCss) : rawCss;
-  return {
-    css: finalCss,
-    classes: unique,
-    sizeBytes: finalCss.length,
-    optimized: hasLightning
-  };
-}
-function runCssPipelineSync(_classes) {
-  return { css: "", classes: [], sizeBytes: 0, optimized: false };
+  if (!native?.hashContent) {
+    throw new Error("FATAL: Native binding 'hashContent' is required but not available.");
+  }
+  return `tw-cq-${native.hashContent(sortedKey, "fnv", 6)}`;
 }
-function processTailwindCssWithTargets(css, targets) {
+function extractContainerCssFromSource(source) {
   const native = getNativeBridge();
-  if (!native?.processTailwindCssWithTargets) {
-    throw new Error("FATAL: Native binding 'processTailwindCssWithTargets' is required but not available.");
+  if (!native?.extractTwContainerConfigs) {
+    throw new Error("FATAL: Native binding 'extractTwContainerConfigs' is required but not available.");
+  }
+  const configs = native.extractTwContainerConfigs(source);
+  const rules = [];
+  for (const cfg of configs) {
+    const id = _hashContainer(cfg.tag, cfg.containerJson, cfg.containerName);
+    for (const { key, classes } of cfg.breakpoints) {
+      const minWidth = _CONTAINER_BREAKPOINTS[key] ?? key;
+      const css = _layoutClassesToCss(classes);
+      if (!css) continue;
+      const query = cfg.containerName ? `@container ${cfg.containerName} (min-width: ${minWidth})` : `@container (min-width: ${minWidth})`;
+      rules.push(`${query}{.${id}{${css}}}`);
+    }
   }
-  const result = native.processTailwindCssWithTargets(css, targets ?? null);
-  return (result?.css ?? css).trim();
+  return rules.join("\n");
 }
-var require2, _twEngine, _twEngineError;
-var init_tailwindEngine = __esm({
-  "packages/domain/compiler/src/tailwindEngine.ts"() {
+var transformSource, hasTwUsage, isAlreadyTransformed, shouldProcess, compileCssFromClasses, buildStyleTag, generateCssForClasses, eliminateDeadCss, findDeadVariants, runElimination, scanProjectUsage, generateSafelist, loadSafelist, loadTailwindConfig, getContentPaths, _CONTAINER_BREAKPOINTS, runLoaderTransform, shouldSkipFile, fileToRoute, getAllRoutes, getRouteClasses, registerFileClasses, registerGlobalClasses, _incrementalEngineInstance, getIncrementalEngine, resetIncrementalEngine, IncrementalEngine, getBucketEngine, resetBucketEngine, classifyNode, detectConflicts, bucketSort, analyzeFile, analyzeVariantUsage, injectClientDirective, injectServerOnlyComment, analyzeClasses, extractTwStateConfigs, generateStaticStateCss, extractAndGenerateStateCss;
+var init_src2 = __esm({
+  "packages/domain/compiler/src/index.ts"() {
     init_nativeBridge();
-    require2 = createRequire(import.meta.url);
-    _twEngine = null;
-    _twEngineError = null;
+    init_compiler();
+    init_parser();
+    init_analyzer();
+    init_cache();
+    init_redis();
+    init_watch();
+    transformSource = (source, opts) => {
+      const native = getNativeBridge();
+      if (!native?.transformSource) {
+        throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+      }
+      const result = native.transformSource(source, opts);
+      if (!result) {
+        throw new Error("FATAL: transformSource returned null");
+      }
+      return result;
+    };
+    hasTwUsage = (source) => {
+      const native = getNativeBridge();
+      if (!native?.hasTwUsage) {
+        throw new Error("FATAL: Native binding 'hasTwUsage' is required but not available.");
+      }
+      return native.hasTwUsage(source);
+    };
+    isAlreadyTransformed = (source) => {
+      const native = getNativeBridge();
+      if (!native?.isAlreadyTransformed) {
+        throw new Error("FATAL: Native binding 'isAlreadyTransformed' is required but not available.");
+      }
+      return native.isAlreadyTransformed(source);
+    };
+    shouldProcess = (source) => {
+      return hasTwUsage(source) && !isAlreadyTransformed(source);
+    };
+    compileCssFromClasses = (classes, prefix) => {
+      const native = getNativeBridge();
+      if (!native?.transformSource) {
+        throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+      }
+      const result = native.transformSource(classes.join(" "), { prefix: prefix ?? "" });
+      if (!result) {
+        throw new Error("FATAL: transformSource returned null");
+      }
+      return result;
+    };
+    buildStyleTag = (classes) => {
+      const result = compileCssFromClasses(classes);
+      return result?.code ? `<style data-tailwind-styled>${result.code}</style>` : "";
+    };
+    generateCssForClasses = async (classes, _tailwindConfig, root, cssEntryContent, minify = false) => {
+      try {
+        const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
+        const result = await runCssPipeline2(classes, cssEntryContent, root, minify);
+        return result.css;
+      } catch {
+        const native = getNativeBridge();
+        if (!native?.transformSource) {
+          throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+        }
+        const result = native.transformSource(classes.join(" "), {});
+        return result?.code || "";
+      }
+    };
+    eliminateDeadCss = (css, deadClasses) => {
+      const native = getNativeBridge();
+      if (!native?.eliminateDeadCss) {
+        throw new Error("FATAL: Native binding 'eliminateDeadCss' is required but not available.");
+      }
+      return native.eliminateDeadCss(css, Array.from(deadClasses));
+    };
+    findDeadVariants = (variantConfig, usage) => {
+      const unused = [];
+      const configs = Array.isArray(variantConfig) ? variantConfig : [{ name: "__root__", variants: variantConfig }];
+      for (const component of configs) {
+        const componentUsage = usage[component.name] ?? /* @__PURE__ */ new Set();
+        const variants = component.variants;
+        for (const [key, values] of Object.entries(variants)) {
+          for (const [value] of Object.entries(values)) {
+            if (!componentUsage.has(`${key}:${value}`)) {
+              unused.push(`${component.name !== "__root__" ? `${component.name}/` : ""}${key}:${value}`);
+            }
+          }
+        }
+      }
+      return { unusedCount: unused.length, unused };
+    };
+    runElimination = (css, scanResult) => {
+      const native = getNativeBridge();
+      if (!native?.detectDeadCode) {
+        throw new Error("FATAL: Native binding 'detectDeadCode' is required but not available.");
+      }
+      const dead = native.detectDeadCode(JSON.stringify(scanResult), css);
+      return eliminateDeadCss(css, new Set(dead.deadInCss ?? []));
+    };
+    scanProjectUsage = (dirs, cwd) => {
+      const { batchExtractClasses: batchExtractClasses2 } = (init_parser(), __toCommonJS(parser_exports));
+      const files = dirs.map((dir) => path9__default.resolve(cwd, dir));
+      const results = batchExtractClasses2(files) || [];
+      const combined = {};
+      for (const result of results) {
+        if (result.ok && result.classes) {
+          for (const cls of result.classes) {
+            if (!combined[cls]) combined[cls] = {};
+            combined[cls][result.file] = /* @__PURE__ */ new Set([cls]);
+          }
+        }
+      }
+      return combined;
+    };
+    generateSafelist = (scanDirs, outputPath, cwd) => {
+      const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
+      const allClasses = Object.keys(classes).sort();
+      if (outputPath) {
+        fs13__default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+      }
+      return allClasses;
+    };
+    loadSafelist = (safelistPath) => {
+      try {
+        const content = fs13__default.readFileSync(safelistPath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return [];
+      }
+    };
+    loadTailwindConfig = (cwd = process.cwd()) => {
+      const configFiles = [
+        "tailwind.config.ts",
+        "tailwind.config.js",
+        "tailwind.config.mjs",
+        "tailwind.config.cjs"
+      ];
+      for (const file of configFiles) {
+        const fullPath = path9__default.join(cwd, file);
+        if (fs13__default.existsSync(fullPath)) {
+          const mod = __require(fullPath);
+          return mod.default || mod;
+        }
+      }
+      return {};
+    };
+    getContentPaths = (cwd = process.cwd()) => {
+      return {
+        content: [
+          path9__default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          path9__default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          path9__default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
+        ]
+      };
+    };
+    _CONTAINER_BREAKPOINTS = {
+      xs: "240px",
+      sm: "320px",
+      md: "640px",
+      lg: "1024px",
+      xl: "1280px",
+      "2xl": "1536px"
+    };
+    runLoaderTransform = (ctx) => {
+      const { filepath, source, options } = ctx;
+      const result = transformSource(source, { filename: filepath, ...options });
+      let staticCss;
+      try {
+        const cssChunks = [];
+        const stateRules = extractAndGenerateStateCss(source, filepath);
+        if (stateRules.length > 0) {
+          cssChunks.push(stateRules.map((r) => r.cssRule).join("\n"));
+        }
+        const containerCss = extractContainerCssFromSource(source);
+        if (containerCss) cssChunks.push(containerCss);
+        const combined = cssChunks.join("\n").trim();
+        if (combined) staticCss = combined;
+      } catch (err) {
+        console.debug("Static CSS extraction warning:", err);
+      }
+      return {
+        code: result?.code || "",
+        changed: result?.changed || false,
+        classes: result?.classes || [],
+        staticCss
+      };
+    };
+    shouldSkipFile = (filepath) => {
+      const SKIP_PATHS = ["node_modules", ".next", ".rspack-dist", ".turbo", "dist/", "out/"];
+      const skipExtensions = [".css", ".json", ".md", ".txt", ".yaml", ".yml"];
+      for (const p of SKIP_PATHS) {
+        if (filepath.includes(p)) return true;
+      }
+      for (const ext of skipExtensions) {
+        if (filepath.endsWith(ext)) return true;
+      }
+      return false;
+    };
+    fileToRoute = (filepath) => {
+      const normalized = filepath.replace(/\\/g, "/");
+      if (normalized.includes("/layout.") || normalized.includes("/loading.") || normalized.includes("/error.")) {
+        return "__global";
+      }
+      const pageMatch = normalized.match(/\/app\/(.+?)\/page\.[tj]sx?$/);
+      if (pageMatch) return `/${pageMatch[1]}`;
+      const rootPage = normalized.match(/\/app\/page\.[tj]sx?$/);
+      if (rootPage) return "/";
+      return null;
+    };
+    getAllRoutes = () => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return ["/", "__global"];
+    };
+    getRouteClasses = (_route) => /* @__PURE__ */ new Set();
+    registerFileClasses = (_filepath, _classes) => {
+    };
+    registerGlobalClasses = (_classes) => {
+    };
+    _incrementalEngineInstance = null;
+    getIncrementalEngine = () => {
+      if (!_incrementalEngineInstance) {
+        _incrementalEngineInstance = new IncrementalEngine();
+      }
+      return _incrementalEngineInstance;
+    };
+    resetIncrementalEngine = () => {
+      _incrementalEngineInstance = null;
+    };
+    IncrementalEngine = class {
+      compile(source) {
+        return transformSource(source);
+      }
+    };
+    getBucketEngine = () => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return {
+        add: (className) => className,
+        get: (_bucket) => []
+      };
+    };
+    resetBucketEngine = () => {
+    };
+    classifyNode = (_node) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return "unknown";
+    };
+    detectConflicts = (_classes) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClassUsage) {
+        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+      }
+      return [];
+    };
+    bucketSort = (classes) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      const sorted = native.classifyAndSortClasses(classes);
+      return sorted.map((c) => c.raw ?? c);
+    };
+    analyzeFile = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeRsc) {
+        throw new Error("FATAL: Native binding 'analyzeRsc' is required but not available.");
+      }
+      const rsc = native.analyzeRsc(source, filename);
+      return {
+        isServer: rsc?.isServer ?? true,
+        needsClientDirective: rsc?.needsClientDirective ?? false,
+        clientReasons: rsc?.clientReasons ?? [],
+        interactiveClasses: [],
+        canStaticResolveVariants: true
+      };
+    };
+    analyzeVariantUsage = (_source, _componentName, _variantKeys) => {
+      return { resolved: {}, dynamic: [] };
+    };
+    injectClientDirective = (source) => {
+      if (!source.includes('"use client"') && !source.includes("'use client'")) {
+        return '"use client";\n' + source;
+      }
+      return source;
+    };
+    injectServerOnlyComment = (source) => {
+      return `/* @server-only */
+${source}`;
+    };
+    analyzeClasses = (filesJson, cwd, flags) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return native.analyzeClasses(filesJson, cwd, flags);
+    };
+    extractTwStateConfigs = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.extractTwStateConfigs) {
+        throw new Error("FATAL: Native binding 'extractTwStateConfigs' is required but not available.");
+      }
+      return native.extractTwStateConfigs(source, filename);
+    };
+    generateStaticStateCss = (entries, _themeConfig) => {
+      const rules = [];
+      for (const entry of entries) {
+        const stateConfig = JSON.parse(entry.statesJson);
+        for (const [stateName, classes] of Object.entries(stateConfig)) {
+          rules.push({
+            selector: `.${entry.componentName}[data-state="${stateName}"]`,
+            declarations: classes,
+            cssRule: `.${entry.componentName}[data-state="${stateName}"]{${classes}}`,
+            componentName: entry.componentName,
+            stateName
+          });
+        }
+      }
+      return rules;
+    };
+    extractAndGenerateStateCss = (source, filename) => {
+      const entries = extractTwStateConfigs(source, filename);
+      return generateStaticStateCss(entries);
+    };
   }
 });
 
 // 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,
@@ -1470,8 +3787,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
@@ -1481,7 +3798,7 @@ function getDirname2() {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path6__default.dirname(fileURLToPath(import.meta.url));
+    return path9__default.dirname(fileURLToPath(import.meta.url));
   }
   return process.cwd();
 }
@@ -1562,7 +3879,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.");
@@ -1597,7 +3914,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.");
@@ -1609,7 +3926,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) => {
@@ -1770,12 +4087,12 @@ var init_native_bridge = __esm({
   }
 });
 function defaultCachePath(rootDir, cacheDir) {
-  const dir = cacheDir ? path6__default.resolve(rootDir, cacheDir) : path6__default.join(process.cwd(), ".cache", "tailwind-styled");
-  return path6__default.join(dir, "scanner-cache.json");
+  const dir = cacheDir ? path9__default.resolve(rootDir, cacheDir) : path9__default.join(process.cwd(), ".cache", "tailwind-styled");
+  return path9__default.join(dir, "scanner-cache.json");
 }
 function readCache(rootDir, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs5__default.mkdirSync(path6__default.dirname(cachePath), { recursive: true });
+  fs13__default.mkdirSync(path9__default.dirname(cachePath), { recursive: true });
   const result = cacheReadNative(cachePath);
   if (!result) return [];
   return result.entries.map((e) => ({
@@ -1790,7 +4107,7 @@ function readCache(rootDir, cacheDir) {
 }
 function writeCache(rootDir, entries, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs5__default.mkdirSync(path6__default.dirname(cachePath), { recursive: true });
+  fs13__default.mkdirSync(path9__default.dirname(cachePath), { recursive: true });
   const success = cacheWriteNative(cachePath, entries);
   if (!success) {
     throw new Error(
@@ -1814,30 +4131,10 @@ 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;
-  const files = [];
-  function walk(dir) {
-    let entries;
-    try {
-      entries = fs5__default.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const fullPath = path6__default.join(dir, entry.name);
-      const rel = path6__default.relative(rootDir, fullPath);
-      if (entry.isDirectory()) {
-        const ignored = ignoreDirs.some((d) => entry.name === d || rel.startsWith(d + path6__default.sep));
-        if (!ignored) walk(fullPath);
-      } else if (isScannableFile(entry.name, extensions)) {
-        files.push(fullPath);
-      }
-    }
-  }
-  walk(rootDir);
-  return files;
+  throw new Error("FATAL: Native binding 'collectFiles' is required but not available.");
 }
 function mergeResults(batchResults) {
   const files = batchResults.map((r) => ({
@@ -1847,8 +4144,7 @@ function mergeResults(batchResults) {
   }));
   const native = rebuildWorkspaceResultNative(files);
   if (native) return native;
-  const unique = new Set(files.flatMap((f) => f.classes));
-  return { files, totalFiles: files.length, uniqueClasses: Array.from(unique).sort() };
+  throw new Error("FATAL: Native binding 'rebuildWorkspaceResult' is required but not available.");
 }
 function runChunkInWorker(filePaths) {
   return new Promise((resolve2, reject) => {
@@ -1875,9 +4171,9 @@ async function scanWorkspaceParallel(rootDir, options = {}) {
     maxWorkers = Math.max(1, availableParallelism() - 1),
     chunkSize = DEFAULT_CHUNK_SIZE
   } = options;
-  const files = collectFiles(path6__default.resolve(rootDir), extensions, ignoreDirs);
+  const files = collectFiles2(path9__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) {
@@ -1894,14 +4190,14 @@ async function scanWorkspaceParallel(rootDir, options = {}) {
 var PARALLEL_THRESHOLD, DEFAULT_CHUNK_SIZE, _workerFilename;
 var init_parallel_scanner = __esm({
   "packages/domain/scanner/src/parallel-scanner.ts"() {
-    init_src2();
+    init_src3();
     init_native_bridge();
     PARALLEL_THRESHOLD = 50;
     DEFAULT_CHUNK_SIZE = 150;
     if (!isMainThread && parentPort) {
       const { filePaths } = workerData;
       try {
-        const results = batchExtractClassesNative(filePaths);
+        const results = batchExtractClassesNative2(filePaths);
         const msg = { ok: true, results };
         parentPort.postMessage(msg);
       } catch (error) {
@@ -1919,12 +4215,12 @@ var formatIssuePath2, formatIssues, parseWithSchema, NonNegativeIntegerSchema, S
 var init_schemas = __esm({
   "packages/domain/scanner/src/schemas.ts"() {
     init_src();
-    formatIssuePath2 = (path13) => path13.length > 0 ? path13.map(
+    formatIssuePath2 = (path16) => path16.length > 0 ? path16.map(
       (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
     ).join(".") : "<root>";
     formatIssues = (error) => error.issues.map((issue) => {
-      const path13 = formatIssuePath2(issue.path);
-      return `${path13}: ${issue.message}`;
+      const path16 = formatIssuePath2(issue.path);
+      return `${path16}: ${issue.message}`;
     }).join("; ");
     parseWithSchema = (schema, data, label) => {
       const parsed = schema.safeParse(data);
@@ -1985,15 +4281,15 @@ var src_exports2 = {};
 __export(src_exports2, {
   DEFAULT_EXTENSIONS: () => DEFAULT_EXTENSIONS,
   DEFAULT_IGNORES: () => DEFAULT_IGNORES,
-  batchExtractClassesNative: () => batchExtractClassesNative,
+  batchExtractClassesNative: () => batchExtractClassesNative2,
   extractClassesNative: () => extractClassesNative,
-  isScannableFile: () => isScannableFile,
+  isScannableFile: () => isScannableFile2,
   parseScanWorkspaceOptions: () => parseScanWorkspaceOptions,
   parseScanWorkspaceResult: () => parseScanWorkspaceResult,
   parseScannerWorkerMessage: () => parseScannerWorkerMessage,
-  scanFile: () => scanFile,
+  scanFile: () => scanFile2,
   scanSource: () => scanSource,
-  scanWorkspace: () => scanWorkspace,
+  scanWorkspace: () => scanWorkspace2,
   scanWorkspaceAsync: () => scanWorkspaceAsync
 });
 function getRuntimeDir() {
@@ -2001,7 +4297,7 @@ function getRuntimeDir() {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path6__default.dirname(fileURLToPath(import.meta.url));
+    return path9__default.dirname(fileURLToPath(import.meta.url));
   }
   return process.cwd();
 }
@@ -2011,17 +4307,17 @@ function resolveScannerWorkerModulePath() {
       return __dirname;
     }
     if (typeof import.meta !== "undefined" && import.meta.url) {
-      return path6__default.dirname(fileURLToPath(import.meta.url));
+      return path9__default.dirname(fileURLToPath(import.meta.url));
     }
     return process.cwd();
   })();
   const candidates = [
-    path6__default.resolve(runtimeDir, "worker.cjs"),
-    path6__default.resolve(runtimeDir, "worker.js"),
-    path6__default.resolve(runtimeDir, "worker.ts")
+    path9__default.resolve(runtimeDir, "worker.cjs"),
+    path9__default.resolve(runtimeDir, "worker.js"),
+    path9__default.resolve(runtimeDir, "worker.ts")
   ];
   for (const candidate of candidates) {
-    if (fs5__default.existsSync(candidate)) return candidate;
+    if (fs13__default.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -2078,19 +4374,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs5__default.readdirSync(currentDir, { withFileTypes: true });
+        return fs13__default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
     })();
     for (const entry of entries) {
-      const fullPath = path6__default.join(currentDir, entry.name);
+      const fullPath = path9__default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      if (!extensionSet.has(path6__default.extname(entry.name))) continue;
+      if (!extensionSet.has(path9__default.extname(entry.name))) continue;
       candidates.push(fullPath);
     }
   }
@@ -2116,12 +4412,12 @@ function scanSource(source) {
     "FATAL: Native parser binding is required but not available.\nThis package requires native Rust bindings.\n\nResolution steps:\n1. Build the native Rust module: npm run build:rust"
   );
 }
-function isScannableFile(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
-  return includeExtensions.includes(path6__default.extname(filePath));
+function isScannableFile2(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
+  return includeExtensions.includes(path9__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"}`);
   }
@@ -2131,7 +4427,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);
@@ -2177,7 +4473,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs5__default.statSync(filePath);
+          return fs13__default.statSync(filePath);
         } catch {
           return null;
         }
@@ -2203,7 +4499,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs5__default.readFileSync(filePath, "utf8");
+          return fs13__default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -2254,7 +4550,7 @@ function scanWorkspace(rootDir, options = {}) {
     }
   } else {
     for (const filePath of candidates) {
-      processResult(scanFile(filePath));
+      processResult(scanFile2(filePath));
     }
   }
   return parseScanWorkspaceResult({
@@ -2281,11 +4577,11 @@ 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;
-var init_src2 = __esm({
+var init_src3 = __esm({
   "packages/domain/scanner/src/index.ts"() {
     init_src();
     init_cache_native();
@@ -2294,7 +4590,7 @@ var init_src2 = __esm({
     init_schemas();
     init_schemas();
     init_native_bridge();
-    log3 = createLogger("scanner");
+    log3 = createLogger2("scanner");
     SCAN_WORKER_TIMEOUT_MS = 12e4;
     createNativeParserLoader = () => {
       const _state = {
@@ -2307,7 +4603,7 @@ var init_src2 = __esm({
       const loadNativeParserBinding = () => {
         if (_state.binding !== void 0) return _state.binding;
         const runtimeDir = getRuntimeDir();
-        const req = createRequire(path6__default.join(runtimeDir, "noop.cjs"));
+        const req = createRequire(path9__default.join(runtimeDir, "noop.cjs"));
         const _platform = process.platform;
         const _arch = process.arch;
         const _platformArch = `${_platform}-${_arch}`;
@@ -2315,27 +4611,27 @@ var init_src2 = __esm({
         const candidates = [
           // ── binaryName baru: tailwind-styled-native (napi-rs naming) ──
           // cwd = repo root saat run dari root, atau package dir saat workspaces
-          path6__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
-          path6__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
-          path6__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          path9__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+          path9__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
+          path9__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // runtimeDir = dist/ → naik 1 level ke package root (npm install case)
           // e.g. node_modules/tailwind-styled-v4/dist/ → node_modules/tailwind-styled-v4/native/
-          path6__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
-          path6__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
-          path6__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          path9__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+          path9__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
+          path9__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // runtimeDir = dist/ → naik 4 level ke repo root (monorepo dev case)
-          path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
-          path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // 3 level fallback (jika package di-nest lebih dangkal)
-          path6__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
-          path6__default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // ── binaryName lama: tailwind_styled_parser (backward compat) ──
-          path6__default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
-          path6__default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
-          path6__default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
-          path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
-          path6__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
-          path6__default.resolve(
+          path9__default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+          path9__default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
+          path9__default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
+          path9__default.resolve(
             runtimeDir,
             "..",
             "..",
@@ -2347,7 +4643,7 @@ var init_src2 = __esm({
           )
         ];
         for (const fullPath of candidates) {
-          if (!fs5__default.existsSync(fullPath)) continue;
+          if (!fs13__default.existsSync(fullPath)) continue;
           try {
             const required = req(fullPath);
             if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
@@ -2472,48 +4768,11 @@ var init_native_bridge2 = __esm({
   }
 });
 
-// packages/domain/compiler/src/index.ts
-init_nativeBridge();
-var transformSource = (source, opts) => {
-  const native = getNativeBridge();
-  if (!native?.transformSource) {
-    throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
-  }
-  const result = native.transformSource(source, opts);
-  if (!result) {
-    throw new Error("FATAL: transformSource returned null");
-  }
-  return result;
-};
-var generateCssForClasses = async (classes, _tailwindConfig, root, cssEntryContent, minify = false) => {
-  const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
-  const result = await runCssPipeline2(classes, cssEntryContent, root, minify);
-  return result.css;
-};
-var mergeClassesStatic = (classes) => {
-  const result = normalizeAndDedupClasses(classes);
-  return result?.normalized || "";
-};
-var 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 };
-};
-var runLoaderTransform = (ctx) => {
-  const { filepath, source, options } = ctx;
-  const result = transformSource(source, { filename: filepath, ...options });
-  return {
-    code: result?.code || "",
-    changed: result?.changed || false,
-    classes: result?.classes || []
-  };
-};
+// packages/presentation/vite/src/plugin.ts
+init_src2();
 
 // packages/domain/analyzer/src/analyzeWorkspace.ts
-init_src2();
+init_src3();
 
 // packages/domain/analyzer/src/binding.ts
 init_src();
@@ -2533,7 +4792,7 @@ function isRecord(value) {
 }
 async function pathExists(filePath) {
   try {
-    await fs5__default.promises.access(filePath, fs5__default.constants.F_OK);
+    await fs13__default.promises.access(filePath, fs13__default.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -2632,7 +4891,7 @@ async function requireNativeBinding() {
 
 // packages/domain/analyzer/src/schemas.ts
 init_src();
-var formatIssuePath3 = (path13) => path13.length > 0 ? path13.map(
+var formatIssuePath3 = (path16) => path16.length > 0 ? path16.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var isPlainObject = (value) => {
@@ -2641,8 +4900,8 @@ var isPlainObject = (value) => {
   return proto === Object.prototype || proto === null;
 };
 var formatIssues2 = (error) => error.issues.map((issue) => {
-  const path13 = formatIssuePath3(issue.path);
-  return `${path13}: ${issue.message}`;
+  const path16 = formatIssuePath3(issue.path);
+  return `${path16}: ${issue.message}`;
 }).join("; ");
 var parseWithSchema2 = (schema, data, label) => {
   const parsed = schema.safeParse(data);
@@ -2732,7 +4991,7 @@ var parseAnalyzerOptions = (options) => parseWithSchema2(AnalyzerOptionsSchema,
 var parseNativeReport = (report) => parseWithSchema2(NativeReportSchema, report, "Native analyzer report is invalid");
 var SUPPORTED_TAILWIND_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".cjs", ".mjs"]);
 var tailwindConfigCache = /* @__PURE__ */ new Map();
-var detectConflicts = async (usages) => {
+var detectConflicts2 = async (usages) => {
   const native = await getNativeBinding();
   if (!native?.detectClassConflicts) {
     throw new Error("FATAL: Native binding 'detectClassConflicts' is required but not available.");
@@ -2749,11 +5008,11 @@ var detectConflicts = async (usages) => {
   };
 };
 var isSupportedTailwindConfigPath = (configPath) => {
-  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path6__default.extname(configPath).toLowerCase());
+  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path9__default.extname(configPath).toLowerCase());
 };
 var resolveTailwindConfigPath = async (root, explicitPath) => {
   if (explicitPath) {
-    const resolved = path6__default.resolve(root, explicitPath);
+    const resolved = path9__default.resolve(root, explicitPath);
     if (!await pathExists(resolved)) return null;
     return resolved;
   }
@@ -2764,7 +5023,7 @@ var resolveTailwindConfigPath = async (root, explicitPath) => {
     "tailwind.config.mjs"
   ];
   for (const candidate of candidates) {
-    const fullPath = path6__default.resolve(root, candidate);
+    const fullPath = path9__default.resolve(root, candidate);
     if (await pathExists(fullPath)) return fullPath;
   }
   return null;
@@ -2818,8 +5077,8 @@ var collectCustomUtilities = (config) => {
   return out;
 };
 var collectSafelistFromSource = async (configPath) => {
-  const source = await fs5__default.promises.readFile(configPath, "utf8");
-  const { extractClassesNative: extractClassesNative2 } = await Promise.resolve().then(() => (init_src2(), src_exports2));
+  const source = await fs13__default.promises.readFile(configPath, "utf8");
+  const { extractClassesNative: extractClassesNative2 } = await Promise.resolve().then(() => (init_src3(), src_exports2));
   const allTokens = extractClassesNative2(source);
   const hasSafelist = source.includes("safelist");
   if (!hasSafelist) return [];
@@ -2832,7 +5091,7 @@ var collectSafelistFromSource = async (configPath) => {
   }
   return allTokens.filter((t) => safelistSet.has(t));
 };
-var loadTailwindConfig = async (root, semanticOption) => {
+var loadTailwindConfig2 = async (root, semanticOption) => {
   const startMs = Date.now();
   const configPath = await resolveTailwindConfigPath(root, semanticOption?.tailwindConfigPath);
   if (!configPath) return null;
@@ -2845,7 +5104,7 @@ var loadTailwindConfig = async (root, semanticOption) => {
       customUtilities: /* @__PURE__ */ new Set()
     };
   }
-  const configStat = await fs5__default.promises.stat(configPath).catch(() => null);
+  const configStat = await fs13__default.promises.stat(configPath).catch(() => null);
   if (configStat) {
     const cached = tailwindConfigCache.get(configPath);
     if (cached && cached.mtimeMs === configStat.mtimeMs && cached.size === configStat.size) {
@@ -2913,7 +5172,7 @@ var loadTailwindConfig = async (root, semanticOption) => {
   return loaded;
 };
 var buildSemanticReport = async (usages, root, semanticOption) => {
-  const loadedConfig = await loadTailwindConfig(root, semanticOption);
+  const loadedConfig = await loadTailwindConfig2(root, semanticOption);
   const safelist = loadedConfig?.safelist ?? /* @__PURE__ */ new Set();
   const customUtilities = loadedConfig?.customUtilities ?? /* @__PURE__ */ new Set();
   const usageNames = new Set(usages.map((usage) => usage.name));
@@ -2932,7 +5191,7 @@ var buildSemanticReport = async (usages, root, semanticOption) => {
     results.filter((r) => !r.isKnown).map((r) => r.className)
   );
   const unknownClasses = usages.filter((usage) => unknownSet.has(usage.name)).map((usage) => ({ ...usage, isUnused: true }));
-  const { conflicts } = await detectConflicts(usages);
+  const { conflicts } = await detectConflicts2(usages);
   return {
     unusedClasses,
     unknownClasses,
@@ -3004,7 +5263,7 @@ async function buildDistribution(usages, native) {
 }
 async function analyzeWorkspace(root, options = {}) {
   const startedAtMs = Date.now();
-  const resolvedRoot = path6__default.resolve(root);
+  const resolvedRoot = path9__default.resolve(root);
   const normalizedOptions = parseAnalyzerOptions(options);
   const scan = await (async () => {
     const scanStartedAtMs = Date.now();
@@ -3107,16 +5366,17 @@ async function analyzeWorkspace(root, options = {}) {
 }
 
 // packages/domain/engine/src/index.ts
-init_src2();
+init_internal();
+init_src3();
 init_src();
 
 // packages/domain/engine/src/incremental.ts
-init_src2();
+init_src3();
 init_src();
 init_native_bridge2();
 var DEFAULT_EXTENSIONS2 = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
-var log5 = createLogger("engine:incremental");
-function rebuildWorkspaceResult(byFile) {
+var log5 = createLogger2("engine:incremental");
+function rebuildWorkspaceResult2(byFile) {
   const files = Array.from(byFile.values());
   const native = getNativeEngineBinding();
   if (native?.rebuildWorkspaceResult) {
@@ -3145,9 +5405,9 @@ function areClassSetsEqual(a, b) {
 }
 function applyIncrementalChange(previous, filePath, type, scanner) {
   const includeExtensions = scanner?.includeExtensions ?? DEFAULT_EXTENSIONS2;
-  if (!isScannableFile(filePath, includeExtensions)) return previous;
-  const byFile = new Map(previous.files.map((f) => [path6__default.resolve(f.file), f]));
-  const normalizedPath = path6__default.resolve(filePath);
+  if (!isScannableFile2(filePath, includeExtensions)) return previous;
+  const byFile = new Map(previous.files.map((f) => [path9__default.resolve(f.file), f]));
+  const normalizedPath = path9__default.resolve(filePath);
   const native = getNativeEngineBinding();
   if (!native?.processFileChange) {
     throw new Error(
@@ -3159,11 +5419,11 @@ 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 content = fs5__default.readFileSync(normalizedPath, "utf8");
+  const scanned = scanFile2(normalizedPath);
+  const content = fs13__default.readFileSync(normalizedPath, "utf8");
   const diff = native.processFileChange(normalizedPath, scanned.classes, content);
   const existing = byFile.get(normalizedPath);
   if (diff && existing) {
@@ -3175,7 +5435,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
@@ -3232,8 +5492,8 @@ var METRICS_FILE_NAME = "metrics.json";
 var CACHE_DIR = ".tw-cache";
 function writeMetrics(metrics, cwd = process.cwd()) {
   try {
-    const cacheDir = path6__default.join(cwd, CACHE_DIR);
-    fs5__default.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = path9__default.join(cwd, CACHE_DIR);
+    fs13__default.mkdirSync(cacheDir, { recursive: true });
     const mem = process.memoryUsage();
     const data = {
       ...metrics,
@@ -3244,7 +5504,7 @@ function writeMetrics(metrics, cwd = process.cwd()) {
       },
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs5__default.writeFileSync(path6__default.join(cacheDir, METRICS_FILE_NAME), JSON.stringify(data, null, 2));
+    fs13__default.writeFileSync(path9__default.join(cacheDir, METRICS_FILE_NAME), JSON.stringify(data, null, 2));
   } catch {
   }
 }
@@ -3351,19 +5611,19 @@ var parseEngineOptions = (options) => parseWithSchema3(EngineOptionsSchema, opti
 var parseEngineWatchOptions = (options) => parseWithSchema3(EngineWatchOptionsSchema, options ?? {}, "engine watch options are invalid");
 
 // packages/domain/engine/src/watch.ts
-var _native = null;
+var _native2 = null;
 function getNativeWatcher() {
-  if (_native !== null) return _native;
+  if (_native2 !== null) return _native2;
   try {
     const { resolveNativeBinary: resolveNativeBinary2 } = (init_src(), __toCommonJS(src_exports));
     const { path: binPath } = resolveNativeBinary2(__dirname);
     if (binPath) {
-      _native = __require(binPath);
+      _native2 = __require(binPath);
     }
   } catch {
-    _native = {};
+    _native2 = {};
   }
-  return _native;
+  return _native2;
 }
 function watchWorkspaceNative(rootDir, onEvent, options) {
   const native = getNativeWatcher();
@@ -3440,11 +5700,11 @@ var configState = {
     return this.tailwindConfigLoaded;
   }
 };
-var log6 = createLogger("engine");
+var log6 = createLogger2("engine");
 async function loadTailwindConfigFromPath(root, tailwindConfigPath) {
   if (!tailwindConfigPath) return void 0;
-  const configPath = path6__default.resolve(root, tailwindConfigPath);
-  if (!fs5__default.existsSync(configPath)) {
+  const configPath = path9__default.resolve(root, tailwindConfigPath);
+  if (!fs13__default.existsSync(configPath)) {
     throw TwError.fromIo("CONFIG_NOT_FOUND", `tailwindConfigPath not found: ${configPath}`);
   }
   const imported = await import(pathToFileURL(configPath).href);
@@ -3510,13 +5770,14 @@ async function buildFromScan(scan, root, options, tailwindConfig) {
   };
 }
 function countWorkspacePackages(root) {
-  const packagesDir = path6__default.join(root, "packages");
-  if (!fs5__default.existsSync(packagesDir)) return 0;
+  const packagesDir = path9__default.join(root, "packages");
+  if (!fs13__default.existsSync(packagesDir)) return 0;
   try {
-    return fs5__default.readdirSync(packagesDir, { withFileTypes: true }).filter(
-      (entry) => entry.isDirectory() && fs5__default.existsSync(path6__default.join(packagesDir, entry.name, "package.json"))
+    return fs13__default.readdirSync(packagesDir, { withFileTypes: true }).filter(
+      (entry) => entry.isDirectory() && fs13__default.existsSync(path9__default.join(packagesDir, entry.name, "package.json"))
     ).length;
-  } catch {
+  } catch (err) {
+    log6.debug(`countWorkspacePackages: ${err instanceof Error ? err.message : String(err)}`);
     return 0;
   }
 }
@@ -3550,7 +5811,7 @@ function writeDashboardMetrics(root, mode, result, metrics) {
 async function createEngine(rawOptions = {}) {
   const options = parseEngineOptions(rawOptions);
   const root = options.root ?? process.cwd();
-  const resolvedRoot = path6__default.resolve(root);
+  const resolvedRoot = path9__default.resolve(root);
   const plugins = rawOptions.plugins ?? [];
   const getTailwindConfig = async () => {
     if (configState.isLoaded()) return configState.getConfig();
@@ -3697,12 +5958,13 @@ async function createEngine(rawOptions = {}) {
       const shouldForceFullRescan = (event) => {
         if (event.type === "unlink") return false;
         try {
-          const stat = fs5__default.statSync(event.filePath);
+          const stat = fs13__default.statSync(event.filePath);
           if (stat.size > largeFileThreshold) {
             metrics.markSkippedLargeFile();
             return true;
           }
-        } catch {
+        } catch (statErr) {
+          log6.debug(`stat failed for ${event.filePath}: ${statErr instanceof Error ? statErr.message : String(statErr)}`);
           return false;
         }
         return false;
@@ -3816,7 +6078,7 @@ async function createEngine(rawOptions = {}) {
 
 // packages/presentation/vite/src/schemas.ts
 init_src();
-var formatIssuePath4 = (path13) => path13.length > 0 ? path13.map(
+var formatIssuePath4 = (path16) => path16.length > 0 ? path16.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var formatIssues4 = (error) => error.issues.map((issue) => {
@@ -3862,14 +6124,14 @@ function warnDeprecated(options, key, message) {
   }
 }
 function isInsideDirectory(filePath, directory) {
-  const relative = path6__default.relative(directory, filePath);
-  return relative === "" || !relative.startsWith("..") && !path6__default.isAbsolute(relative);
+  const relative = path9__default.relative(directory, filePath);
+  return relative === "" || !relative.startsWith("..") && !path9__default.isAbsolute(relative);
 }
 function filterScanToDirs(scan, root, scanDirs) {
-  const resolvedDirs = scanDirs.map((dir) => path6__default.resolve(root, dir));
+  const resolvedDirs = scanDirs.map((dir) => path9__default.resolve(root, dir));
   if (resolvedDirs.length === 0) return scan;
   const files = scan.files.filter((file) => {
-    const absoluteFile = path6__default.resolve(file.file);
+    const absoluteFile = path9__default.resolve(file.file);
     return resolvedDirs.some((directory) => isInsideDirectory(absoluteFile, directory));
   });
   const uniqueClasses = Array.from(new Set(files.flatMap((file) => file.classes))).sort();
@@ -3880,9 +6142,9 @@ function filterScanToDirs(scan, root, scanDirs) {
   };
 }
 function writeJsonArtifact(root, relativePath, value) {
-  const outputPath = path6__default.resolve(root, relativePath);
-  fs5__default.mkdirSync(path6__default.dirname(outputPath), { recursive: true });
-  fs5__default.writeFileSync(outputPath, `${JSON.stringify(value, null, 2)}
+  const outputPath = path9__default.resolve(root, relativePath);
+  fs13__default.mkdirSync(path9__default.dirname(outputPath), { recursive: true });
+  fs13__default.writeFileSync(outputPath, `${JSON.stringify(value, null, 2)}
 `);
 }
 function tailwindStyledPlugin(opts = {}) {
@@ -3909,12 +6171,77 @@ function tailwindStyledPlugin(opts = {}) {
   const transformRunner = rawOptions.__internalTransformRunner ?? runLoaderTransform;
   const engineFactory = rawOptions.__internalCreateEngine ?? createEngine;
   const pluginState = { root: process.cwd(), isDev: true };
+  const staticCssPerFile = /* @__PURE__ */ new Map();
+  function deduplicateStaticCss(css) {
+    const seen = /* @__PURE__ */ new Set();
+    const rules = [];
+    for (const chunk of css.split(/(?<=\})\s*/)) {
+      const rule = chunk.trim();
+      if (rule && !seen.has(rule)) {
+        seen.add(rule);
+        rules.push(rule);
+      }
+    }
+    return rules.join("\n");
+  }
+  function getStaticCssOutputPath(root, safelistOutputPath) {
+    return path9__default.resolve(root, path9__default.dirname(safelistOutputPath), "_tw-state-static.css");
+  }
+  function flushStaticCss(root) {
+    if (staticCssPerFile.size === 0) return;
+    const combined = Array.from(staticCssPerFile.values()).join("\n");
+    const deduped = deduplicateStaticCss(combined);
+    if (!deduped.trim()) return;
+    const outPath = getStaticCssOutputPath(root, safelistOutput);
+    try {
+      fs13__default.mkdirSync(path9__default.dirname(outPath), { recursive: true });
+      fs13__default.writeFileSync(
+        outPath,
+        `/* _tw-state-static.css \u2014 Auto-generated by tailwind-styled-v4. DO NOT EDIT.
+ * Import this in globals.css: @import "./_tw-state-static.css";
+ * Contains: state CSS (.tw-s-*[data-*="true"]) + container queries (@container .tw-cq-*).
+ */
+
+${deduped}
+`
+      );
+    } catch (e) {
+      console.warn("[tailwind-styled-v4] Could not write _tw-state-static.css:", e);
+    }
+  }
   return {
     name: "tailwind-styled-v4",
     enforce: "pre",
     configResolved(config) {
       pluginState.root = config.root;
       pluginState.isDev = config.command === "serve";
+      try {
+        const outPath = getStaticCssOutputPath(config.root, safelistOutput);
+        const CSS_CANDIDATES = [
+          "src/index.css",
+          "src/main.css",
+          "src/App.css",
+          "src/styles/index.css",
+          "src/styles/main.css",
+          "src/globals.css",
+          "src/style.css"
+        ];
+        for (const candidate of CSS_CANDIDATES) {
+          const candidatePath = path9__default.resolve(config.root, candidate);
+          if (!fs13__default.existsSync(candidatePath)) continue;
+          const content = fs13__default.readFileSync(candidatePath, "utf-8");
+          if (content.includes("_tw-state-static.css")) break;
+          const rel = path9__default.relative(path9__default.dirname(candidatePath), outPath).replace(/\\/g, "/");
+          const importLine = `@import "./${rel}";`;
+          const tailwindImportRe = /(@import\s+["']tailwindcss["']\s*;[^\n]*\n?)/;
+          const updated = tailwindImportRe.test(content) ? content.replace(tailwindImportRe, `$1${importLine}
+`) : `${importLine}
+${content}`;
+          fs13__default.writeFileSync(candidatePath, updated, "utf-8");
+          break;
+        }
+      } catch {
+      }
     },
     transform(source, id) {
       const filepath = id.split("?")[0];
@@ -3940,6 +6267,12 @@ function tailwindStyledPlugin(opts = {}) {
         return null;
       }
       if (!output.changed) return null;
+      if (output.staticCss) {
+        staticCssPerFile.set(filepath, output.staticCss);
+        if (pluginState.isDev) {
+          flushStaticCss(pluginState.root);
+        }
+      }
       return { code: output.code, map: null };
     },
     async buildEnd() {
@@ -3957,6 +6290,10 @@ function tailwindStyledPlugin(opts = {}) {
         if (doSafelist) {
           writeJsonArtifact(pluginState.root, safelistOutput, scan.uniqueClasses);
         }
+        flushStaticCss(pluginState.root);
+        console.log(
+          `[tailwind-styled-v4] Static CSS: ${staticCssPerFile.size} files \u2192 _tw-state-static.css`
+        );
         writeJsonArtifact(pluginState.root, scanReportOutput, {
           root: pluginState.root,
           totalFiles: scan.totalFiles,