tailwind-styled-v4 5.0.11 → 5.0.12

package/dist/next.mjs

@@ -1,8 +1,8 @@
 import { createRequire } from 'module';
-import * as fs5 from 'fs';
-import fs5__default from 'fs';
-import * as path5 from 'path';
-import path5__default from 'path';
+import * as fs9 from 'fs';
+import fs9__default from 'fs';
+import * as path10 from 'path';
+import path10__default from 'path';
 import 'crypto';
 import { fileURLToPath } from 'url';
 import { z } from 'zod';
@@ -62,11 +62,11 @@ function resolvePath(...segments) {
     return segments.join("/").replace(/\/+/g, "/");
   }
 }
-function existsSync(path7) {
+function existsSync(path11) {
   if (isBrowser) return false;
   try {
     const nodeFs = __require(NODE_FS);
-    return nodeFs.existsSync(path7);
+    return nodeFs.existsSync(path11);
   } catch {
     return false;
   }
@@ -135,12 +135,12 @@ function resolveNativeBinary(runtimeDir) {
   if (isBrowser2) {
     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 (fs9.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
@@ -149,7 +149,7 @@ function resolveNativeBinary(runtimeDir) {
   for (const pkg of prebuiltPkgs) {
     try {
       const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs5.existsSync(candidate)) {
+      if (fs9.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -160,13 +160,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 ["..", path5.join("..", ".."), path5.join("..", "..", "..")]) {
-      const pkgRoot = path5.resolve(runtimeDir, depth);
+    for (const depth of ["..", path10.join("..", ".."), path10.join("..", "..", "..")]) {
+      const pkgRoot = path10.resolve(runtimeDir, depth);
       for (const bin of BINARY_NAMES_SELF) {
         for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
-          const candidate = path5.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
+          const candidate = path10.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
           tried.push(`self-bundled:${candidate}`);
-          if (fs5.existsSync(candidate)) {
+          if (fs9.existsSync(candidate)) {
             return { path: candidate, source: "prebuilt", platform, tried };
           }
         }
@@ -178,29 +178,29 @@ function resolveNativeBinary(runtimeDir) {
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const localCandidates = [];
   for (const bin of BINARY_NAMES) {
-    localCandidates.push(path5.resolve(base, `${bin}.node`));
-    localCandidates.push(path5.resolve(base, "..", `${bin}.node`));
-    localCandidates.push(path5.resolve(base, `${bin}.${platform}.node`));
-    localCandidates.push(path5.resolve(base, `${bin}.${napiPlatform}.node`));
+    localCandidates.push(path10.resolve(base, `${bin}.node`));
+    localCandidates.push(path10.resolve(base, "..", `${bin}.node`));
+    localCandidates.push(path10.resolve(base, `${bin}.${platform}.node`));
+    localCandidates.push(path10.resolve(base, `${bin}.${napiPlatform}.node`));
   }
   for (const startDir of [cwd, base]) {
     let dir = startDir;
     for (let i = 0; i < 6; i++) {
-      const nativeDir = path5.resolve(dir, "native");
+      const nativeDir = path10.resolve(dir, "native");
       for (const bin of BINARY_NAMES) {
-        localCandidates.push(path5.resolve(nativeDir, `${bin}.node`));
-        localCandidates.push(path5.resolve(nativeDir, `${bin}.${platform}.node`));
-        localCandidates.push(path5.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
-        localCandidates.push(path5.resolve(nativeDir, "target", "release", `${bin}.node`));
+        localCandidates.push(path10.resolve(nativeDir, `${bin}.node`));
+        localCandidates.push(path10.resolve(nativeDir, `${bin}.${platform}.node`));
+        localCandidates.push(path10.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
+        localCandidates.push(path10.resolve(nativeDir, "target", "release", `${bin}.node`));
       }
-      const parent = path5.resolve(dir, "..");
+      const parent = path10.resolve(dir, "..");
       if (parent === dir) break;
       dir = parent;
     }
   }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs5.existsSync(candidate)) {
+    if (fs9.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
@@ -221,984 +221,2042 @@ var init_native_resolution = __esm({
     };
   }
 });
-function createLogger(namespace) {
-  const prefix = `[${namespace}]`;
-  return {
-    warn(...args) {
-      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
-`);
-    },
-    debug(...args) {
-      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
-`);
-    },
-    error(...args) {
-      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
-`);
-    },
-    log(...args) {
-      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
-`);
+
+// packages/domain/compiler/src/nativeBridge.ts
+var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge, resetNativeBridgeCache, adaptNativeResult;
+var init_nativeBridge = __esm({
+  "packages/domain/compiler/src/nativeBridge.ts"() {
+    init_src2();
+    _loadNative = (path11) => __require(path11);
+    log = (...args) => {
+      if (process.env.DEBUG?.includes("compiler:native")) {
+        console.log("[compiler:native]", ...args);
+      }
+    };
+    NATIVE_UNAVAILABLE_MESSAGE = "[tailwind-styled/compiler v5] Native binding is required but not available.\nThis package requires native Rust bindings. There is no JavaScript fallback.\nPlease ensure:\n  1. The native module is properly installed\n  2. You have run: npm run build:rust (or use prebuilt binary)\n\nFor help, see: https://tailwind-styled.dev/docs/install";
+    nativeBridge = null;
+    bridgeLoadAttempted = false;
+    bridgeLoadError = null;
+    isValidNativeBridge = (mod) => {
+      const m = mod;
+      return !!(typeof m.transformSource === "function" || typeof m.extractAllClasses === "function" || typeof m.hasTwUsage === "function");
+    };
+    getNativeBridge = () => {
+      if (nativeBridge) {
+        return nativeBridge;
+      }
+      if (bridgeLoadAttempted) {
+        if (bridgeLoadError) {
+          throw bridgeLoadError;
+        }
+        throw new Error(NATIVE_UNAVAILABLE_MESSAGE);
+      }
+      bridgeLoadAttempted = true;
+      try {
+        const runtimeDir = resolveRuntimeDir(void 0, import.meta.url);
+        const result = resolveNativeBinary(runtimeDir);
+        if (result.path && result.path.endsWith(".node")) {
+          try {
+            const binding = _loadNative(result.path);
+            if (isValidNativeBridge(binding)) {
+              nativeBridge = binding;
+              log("Native bridge loaded successfully from:", result.path);
+              return nativeBridge;
+            }
+          } catch (e) {
+            log("Failed to require native binding:", e);
+          }
+        }
+        throw new Error(`${NATIVE_UNAVAILABLE_MESSAGE}
+
+Tried paths: ${result.tried.join("\n")}`);
+      } catch (err) {
+        bridgeLoadError = err instanceof Error ? err : new Error(String(err));
+        log("Failed to load native bridge:", bridgeLoadError.message);
+        throw bridgeLoadError;
+      }
+    };
+    resetNativeBridgeCache = () => {
+      nativeBridge = null;
+      bridgeLoadAttempted = false;
+      bridgeLoadError = null;
+      log("Native bridge cache reset");
+    };
+    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();
+      } catch {
+      }
     }
-  };
+  }
+});
+
+// packages/domain/compiler/src/tailwindEngine.ts
+var tailwindEngine_exports = {};
+__export(tailwindEngine_exports, {
+  clearCache: () => clearCache,
+  generateRawCss: () => generateRawCss,
+  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 createDebugLogger(namespace, label) {
-  const prefix = `[${namespace}]`;
-  return (msg) => {
-    if (process.env.DEBUG?.includes(namespace) || process.env.TW_DEBUG) {
-      console.debug(prefix, msg);
+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 formatIssuePath(path7) {
-  if (!path7 || path7.length === 0) return "(root)";
-  return path7.map(
-    (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
-  ).join(".");
+function clearCache() {
+  _cssCache.clear();
+  _cacheHits = 0;
+  _cacheMisses = 0;
 }
-function loadNativeBinding(options) {
-  const { runtimeDir, candidates, isValid } = options;
-  const loadErrors = [];
-  for (const candidate of candidates) {
-    const candidatePath = path5__default.resolve(runtimeDir, candidate);
+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 {
-      if (!fs5__default.existsSync(candidatePath) && !fs5__default.existsSync(candidatePath + ".node")) {
-        continue;
+      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 {
       }
-      const mod = requireNativeModule(candidatePath);
-      if (mod && isValid(mod)) {
-        return { binding: mod, loadErrors, loadedPath: candidatePath };
+      return { content: "", base };
+    }
+  };
+  const compiler = await Promise.resolve(tw.compile(input, { loadStylesheet }));
+  return compiler.build(classes);
+}
+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"
       }
-      loadErrors.push({ path: candidatePath, message: options.invalidExportMessage });
-    } catch (e) {
-      loadErrors.push({ path: candidatePath, message: e instanceof Error ? e.message : String(e) });
+    },
+    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.");
   }
-  return { binding: null, loadErrors };
+  const result = native.processTailwindCssLightning(rawCss);
+  if (!result?.css) {
+    throw new Error("FATAL: processTailwindCssLightning returned null");
+  }
+  return result.css;
 }
-function requireNativeModule(p) {
-  return _require2(p);
+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;
+  try {
+    const theme = getThemeConfig();
+    rawCss = await generateCssNative(unique, {
+      theme,
+      fallbackToJs: true,
+      logFallback: process.env.DEBUG?.includes("compiler") === true
+    });
+    usedRustCompiler = true;
+  } catch (error) {
+    if (process.env.DEBUG?.includes("compiler")) {
+      console.warn("[Compiler] Rust compiler failed, using JavaScript Tailwind:", error);
+    }
+    rawCss = await generateRawCss(unique, cssEntryContent, root);
+  }
+  const finalCss = minify ? postProcessWithLightning(rawCss) : rawCss;
+  if (process.env.DEBUG?.includes("compiler")) {
+    console.log(
+      `[Compiler] Generated CSS from ${unique.length} classes (${usedRustCompiler ? "Rust" : "JavaScript"})`,
+      `Size: ${finalCss.length} bytes`
+    );
+  }
+  const result = {
+    css: finalCss,
+    classes: unique,
+    sizeBytes: finalCss.length,
+    optimized: minify
+  };
+  _evictOldestIfNeeded();
+  _cssCache.set(cacheKey, result);
+  return result;
 }
-function resolveNativeBindingCandidates(options) {
+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 require2, _cssCache, _cacheHits, _cacheMisses, MAX_CACHE_SIZE, _twEngine, _twEngineError;
+var init_tailwindEngine = __esm({
+  "packages/domain/compiler/src/tailwindEngine.ts"() {
+    init_nativeBridge();
+    init_cssGeneratorNative();
+    require2 = createRequire(import.meta.url);
+    _cssCache = /* @__PURE__ */ new Map();
+    _cacheHits = 0;
+    _cacheMisses = 0;
+    MAX_CACHE_SIZE = 100;
+    _twEngine = null;
+    _twEngineError = null;
+  }
+});
+
+// packages/domain/compiler/src/cssGeneratorNative.ts
+async function generateCssNative(classes, options) {
   const {
-    envVarNames = ["TW_NATIVE_PATH", "TWS_NATIVE_PATH"],
-    includeDefaultCandidates = true,
-    enforceNodeExtensionForEnvPath = false
+    theme,
+    fallbackToJs = true,
+    logFallback = false
   } = options;
-  const runtimeDir = options.runtimeDir || process.cwd();
-  const candidates = [];
-  for (const envVar of envVarNames) {
-    const envPath = process.env[envVar];
-    if (envPath) {
-      candidates.push(enforceNodeExtensionForEnvPath && !envPath.endsWith(".node") ? envPath + ".node" : envPath);
+  try {
+    const native = getNativeBridge();
+    if (!native?.generateCssNative) {
+      throw new Error("generateCssNative not available in native binding");
     }
-  }
-  if (!includeDefaultCandidates) return candidates;
-  if (fs5__default.existsSync(runtimeDir)) {
-    try {
-      for (const entry of fs5__default.readdirSync(runtimeDir)) {
-        if (entry.endsWith(".node")) candidates.push(entry);
-      }
-    } catch {
+    const themeJson = JSON.stringify(theme);
+    const css = native.generateCssNative(classes, themeJson);
+    return css;
+  } catch (error) {
+    if (!fallbackToJs) {
+      throw error;
     }
+    if (logFallback) {
+      console.warn(
+        "[CSS Compiler] Rust CSS generator unavailable, falling back to JavaScript Tailwind",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    return generateRawCss(classes);
   }
-  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(path5__default.resolve(runtimeDir, `${bin}.node`));
-    candidates.push(path5__default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
-    candidates.push(path5__default.resolve(runtimeDir, "..", "native", `${bin}.node`));
-    candidates.push(path5__default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path5__default.resolve(process.cwd(), "native", `${bin}.node`));
-    candidates.push(path5__default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path5__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
-    candidates.push(path5__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path5__default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+}
+function getCacheStats2() {
+  try {
+    const native = getNativeBridge();
+    if (!native?.getCacheStats) {
+      return null;
+    }
+    const [hits, misses] = native.getCacheStats();
+    return { hits, misses };
+  } catch {
+    return null;
   }
-  return Array.from(new Set(candidates));
 }
-function resolveRuntimeDir(dir, importMetaUrl) {
+function clearThemeCache() {
   try {
-    return path5__default.dirname(fileURLToPath(importMetaUrl));
+    const native = getNativeBridge();
+    if (!native?.clearThemeCache) {
+      return;
+    }
+    native.clearThemeCache();
   } catch {
-    return process.cwd();
   }
 }
-var TwError, _require2;
-var init_src = __esm({
-  "packages/domain/shared/src/index.ts"() {
-    init_workerResolver();
-    init_native_resolution();
-    TwError = class _TwError extends Error {
-      /** @deprecated Gunakan source */
-      domain;
-      source;
-      code;
-      originalCause;
-      constructor(domainOrSource, code, message, cause) {
-        super(message);
-        this.name = "TwError";
-        this.domain = domainOrSource;
-        this.source = domainOrSource;
-        this.code = code;
-        this.originalCause = cause;
-        if (Error.captureStackTrace) Error.captureStackTrace(this, _TwError);
-      }
-      static fromIo(code, message) {
-        return new _TwError("io", code, message);
-      }
-      static fromCompile(code, message) {
-        return new _TwError("compile", code, message);
-      }
-      static fromRust(err) {
-        if (err instanceof _TwError) return err;
-        if (err instanceof Error) return new _TwError("rust", "RUST_ERROR", err.message, err);
-        if (err && typeof err === "object") {
-          const e = err;
-          return new _TwError("rust", e.code ?? "RUST_ERROR", e.message ?? String(err), err);
-        }
-        return new _TwError("rust", "RUST_ERROR", String(err), err);
-      }
-      /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
-      static fromZod(err) {
-        const first = err.issues?.[0] ?? err.errors?.[0];
-        const path7 = formatIssuePath(first?.path);
-        const message = first ? `${path7}: ${first.message}` : "Schema validation failed";
-        return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
-      }
-      static wrap(source, code, err) {
-        if (err instanceof _TwError) return err;
-        if (err instanceof Error) return new _TwError(source, code, err.message, err);
-        return new _TwError(source, code, String(err), err);
-      }
-      toString() {
-        return `TwError [${this.source}:${this.code}] ${this.message}`;
-      }
-      toJSON() {
-        return { name: this.name, source: this.source, code: this.code, message: this.message };
-      }
-      toCliMessage() {
-        return `[${this.source.toUpperCase()}:${this.code}] ${this.message}`;
-      }
-    };
-    _require2 = createRequire(import.meta.url);
+var init_cssGeneratorNative = __esm({
+  "packages/domain/compiler/src/cssGeneratorNative.ts"() {
+    init_nativeBridge();
+    init_tailwindEngine();
   }
 });
 
-// packages/domain/scanner/src/native-bridge.ts
-var native_bridge_exports = {};
-__export(native_bridge_exports, {
-  batchExtractClassesNative: () => batchExtractClassesNative,
-  cachePriorityNative: () => cachePriorityNative,
-  cacheReadNative: () => cacheReadNative,
-  cacheWriteNative: () => cacheWriteNative,
-  collectFilesNative: () => collectFilesNative,
-  computeCacheStatsNative: () => computeCacheStatsNative,
-  extractClassesNative: () => extractClassesNative,
-  generateSubComponentTypesNative: () => generateSubComponentTypesNative,
-  hasNativeScannerBinding: () => hasNativeScannerBinding,
-  hasNativeWatchBinding: () => hasNativeWatchBinding,
-  hashContentNative: () => hashContentNative,
-  isRustCacheAvailable: () => isRustCacheAvailable,
-  pollWatchEventsNative: () => pollWatchEventsNative,
-  pruneStaleEntriesNative: () => pruneStaleEntriesNative,
-  rebuildWorkspaceResultNative: () => rebuildWorkspaceResultNative,
-  resetScannerBridgeCache: () => resetScannerBridgeCache,
-  scanCacheGet: () => scanCacheGet,
-  scanCacheInvalidate: () => scanCacheInvalidate,
-  scanCachePut: () => scanCachePut,
-  scanCacheStats: () => scanCacheStats,
-  scanFileNative: () => scanFileNative,
-  scanFilesBatchNative: () => scanFilesBatchNative,
-  scanWorkspaceNative: () => scanWorkspaceNative,
-  startWatchNative: () => startWatchNative,
-  stopWatchNative: () => stopWatchNative
-});
-function getDirname() {
-  if (typeof __dirname !== "undefined") {
-    return __dirname;
-  }
-  if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path5__default.dirname(fileURLToPath(import.meta.url));
-  }
-  return process.cwd();
+// packages/domain/compiler/src/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 scanWorkspaceNative(root, extensions) {
-  return scannerGetBinding().scanWorkspace(root, extensions ?? null);
+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 extractClassesNative(source) {
-  const result = scannerGetBinding().extractClassesFromSource?.(source);
-  if (result === null || result === void 0) {
-    throw new TwError(
-      "rust",
-      "SCANNER_EXTRACT_FAILED",
-      "Native extractClassesFromSource returned null/undefined"
-    );
-  }
-  return result;
+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 hashContentNative(content) {
-  const result = scannerGetBinding().hashFileContent?.(content);
-  if (result === null || result === void 0) {
-    throw new TwError(
-      "rust",
-      "SCANNER_HASH_FAILED",
-      "Native hashFileContent returned null/undefined"
-    );
-  }
-  return result;
+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 isRustCacheAvailable() {
-  return true;
+function scanFile(filePath) {
+  const native = getNativeBridge();
+  if (!native?.scan_file) throw new Error("scan_file not available");
+  return native.scan_file(filePath);
 }
-function hasNativeScannerBinding() {
-  try {
-    scannerBridgeLoader.get();
-    return true;
-  } catch {
-    return false;
-  }
+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 cacheReadNative(cachePath) {
-  const result = scannerGetBinding().cacheRead?.(cachePath);
-  if (result === null || result === void 0) {
-    throw new TwError(
-      "rust",
-      "SCANNER_CACHE_READ_FAILED",
-      "Native cacheRead returned null/undefined"
-    );
-  }
-  return result;
+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 cacheWriteNative(cachePath, entries) {
-  const result = scannerGetBinding().cacheWrite?.(cachePath, entries);
-  if (result === null || result === void 0) {
-    throw new TwError(
-      "rust",
-      "SCANNER_CACHE_WRITE_FAILED",
-      "Native cacheWrite returned null/undefined"
-    );
-  }
-  return result;
+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);
 }
-function cachePriorityNative(mtimeMs, size, cachedMtimeMs, cachedSize, cachedHitCount, cachedLastSeenMs, nowMs = Date.now()) {
-  const result = scannerGetBinding().cachePriority?.(
-    mtimeMs,
-    size,
-    cachedMtimeMs,
-    cachedSize,
-    cachedHitCount,
-    cachedLastSeenMs,
-    nowMs
-  );
-  if (result === null || result === void 0) {
-    throw new TwError(
-      "rust",
-      "SCANNER_CACHE_PRIORITY_FAILED",
-      "Native cachePriority returned null/undefined"
-    );
+var init_scannerNative = __esm({
+  "packages/domain/compiler/src/scannerNative.ts"() {
+    init_nativeBridge();
   }
-  return result;
+});
+
+// packages/domain/compiler/src/analyzerNative.ts
+function detectDeadCode(scanResultJson, css) {
+  const native = getNativeBridge();
+  if (!native?.detectDeadCode) throw new Error("detectDeadCode not available");
+  return native.detectDeadCode(scanResultJson, css);
 }
-function batchExtractClassesNative(filePaths) {
-  const binding = scannerGetBinding();
-  if (!binding.batchExtractClasses) {
-    throw new Error("FATAL: Native binding 'batchExtractClasses' is required but not available.");
-  }
-  return binding.batchExtractClasses(filePaths) ?? [];
+function analyzeClassUsageNative(classes, scanResultJson, css) {
+  const native = getNativeBridge();
+  if (!native?.analyzeClassUsage) throw new Error("analyzeClassUsage not available");
+  return native.analyzeClassUsage(classes, scanResultJson, css);
 }
-function scanCacheGet(filePath, contentHash) {
-  const binding = scannerGetBinding();
-  if (!binding.scanCacheGet) {
-    throw new Error("FATAL: Native binding 'scanCacheGet' is required but not available.");
-  }
-  return binding.scanCacheGet(filePath, contentHash) ?? null;
+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 scanCachePut(filePath, contentHash, classes, mtimeMs, size) {
-  const binding = scannerGetBinding();
-  if (!binding.scanCachePut) {
-    throw new Error("FATAL: Native binding 'scanCachePut' is required but not available.");
-  }
-  binding.scanCachePut(filePath, contentHash, classes, mtimeMs, size);
+function analyzeRscNative(source, filename) {
+  const native = getNativeBridge();
+  if (!native?.analyzeRsc) throw new Error("analyzeRsc not available");
+  return native.analyzeRsc(source, filename);
 }
-function scanCacheInvalidate(filePath) {
-  const binding = scannerGetBinding();
-  if (!binding.scanCacheInvalidate) {
-    throw new Error("FATAL: Native binding 'scanCacheInvalidate' is required but not available.");
-  }
-  binding.scanCacheInvalidate(filePath);
+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 scanCacheStats() {
-  const binding = scannerGetBinding();
-  if (!binding.scanCacheStats) {
-    throw new Error("FATAL: Native binding 'scanCacheStats' is required but not available.");
-  }
-  return binding.scanCacheStats();
+function processTailwindCssLightning(css) {
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssLightning) throw new Error("processTailwindCssLightning not available");
+  return native.processTailwindCssLightning(css);
 }
-function scanFileNative(filePath) {
-  const binding = scannerGetBinding();
-  if (!binding.scanFile) {
-    throw new Error("FATAL: Native binding 'scanFile' is required but not available.");
-  }
-  return binding.scanFile(filePath);
+function eliminateDeadCssNative(css, deadClasses) {
+  const native = getNativeBridge();
+  if (!native?.eliminateDeadCss) throw new Error("eliminateDeadCss not available");
+  return native.eliminateDeadCss(css, deadClasses);
 }
-function collectFilesNative(root, extensions, ignoreDirs) {
-  const binding = scannerGetBinding();
-  if (!binding.collectFiles) return null;
-  return binding.collectFiles(root, extensions, ignoreDirs);
+function hoistComponentsNative(source) {
+  const native = getNativeBridge();
+  if (!native?.hoistComponents) throw new Error("hoistComponents not available");
+  return native.hoistComponents(source);
 }
-function scanFilesBatchNative(filePaths) {
-  const binding = scannerGetBinding();
-  if (!binding.scanFilesBatch) {
-    return filePaths.map((fp) => {
-      try {
-        const r = binding.scanFile?.(fp);
-        return r ? { file: r.file, classes: r.classes, hash: r.hash ?? "" } : { file: fp, classes: [], hash: "" };
-      } catch {
-        return { file: fp, classes: [], hash: "" };
-      }
-    });
-  }
-  return binding.scanFilesBatch(filePaths);
+function compileVariantTableNative(configJson) {
+  const native = getNativeBridge();
+  if (!native?.compileVariantTable) throw new Error("compileVariantTable not available");
+  return native.compileVariantTable(configJson);
 }
-function generateSubComponentTypesNative(root, outputPath) {
-  const binding = scannerGetBinding();
-  if (!binding.generateSubComponentTypes) return null;
-  return binding.generateSubComponentTypes(root, outputPath ?? null);
+function classifyAndSortClassesNative(classes) {
+  const native = getNativeBridge();
+  if (!native?.classifyAndSortClasses) throw new Error("classifyAndSortClasses not available");
+  return native.classifyAndSortClasses(classes);
 }
-function pruneStaleEntriesNative(entries, maxAgeMs, checkExists) {
-  const binding = scannerGetBinding();
-  if (!binding.pruneStaleEntries) return null;
-  return binding.pruneStaleEntries(
-    entries.map((e) => ({ file: e.file, lastSeenMs: e.lastSeenMs ?? 0 })),
-    maxAgeMs ?? null,
-    checkExists ?? null
-  );
+function mergeCssDeclarationsNative(cssChunks) {
+  const native = getNativeBridge();
+  if (!native?.mergeCssDeclarations) throw new Error("mergeCssDeclarations not available");
+  return native.mergeCssDeclarations(cssChunks);
 }
-function rebuildWorkspaceResultNative(files) {
-  const binding = scannerBridgeLoader.get();
-  if (!binding?.rebuildWorkspaceResult) return null;
-  try {
-    return binding.rebuildWorkspaceResult(files);
-  } catch {
-    return null;
+var init_analyzerNative = __esm({
+  "packages/domain/compiler/src/analyzerNative.ts"() {
+    init_nativeBridge();
   }
+});
+
+// packages/domain/compiler/src/compilationNative.ts
+function compileCssNative2(classes, prefix) {
+  const native = getNativeBridge();
+  if (!native?.compileCss) throw new Error("compileCss not available");
+  return native.compileCss(classes, prefix);
 }
-function computeCacheStatsNative(filesClasses, sizes, top) {
-  const binding = scannerGetBinding();
-  if (!binding.computeCacheStats) return null;
-  return binding.computeCacheStats(filesClasses, sizes, top ?? null);
+function compileCssLightning(classes) {
+  const native = getNativeBridge();
+  if (!native?.compileCssLightning) throw new Error("compileCssLightning not available");
+  return native.compileCssLightning(classes);
 }
-function startWatchNative(rootDir) {
-  try {
-    const binding = scannerGetBinding();
-    if (!binding.startWatch) return null;
-    return binding.startWatch(rootDir);
+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/compilationNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/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 null;
+    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 pollWatchEventsNative(handleId) {
+function clearAllCaches() {
+  const native = getNativeBridge();
+  if (!native?.clear_all_caches) return;
   try {
-    const binding = scannerGetBinding();
-    if (!binding.pollWatchEvents) return [];
-    return binding.pollWatchEvents(handleId);
+    native.clear_all_caches();
   } catch {
-    return [];
   }
 }
-function stopWatchNative(handleId) {
+function clearParseCache() {
+  const native = getNativeBridge();
+  if (!native?.clear_parse_cache) return;
   try {
-    const binding = scannerGetBinding();
-    if (!binding.stopWatch) return false;
-    return binding.stopWatch(handleId);
+    native.clear_parse_cache();
   } catch {
-    return false;
   }
 }
-function hasNativeWatchBinding() {
+function clearResolveCache() {
+  const native = getNativeBridge();
+  if (!native?.clear_resolve_cache) return;
   try {
-    const binding = scannerGetBinding();
-    return !!(binding.startWatch && binding.pollWatchEvents && binding.stopWatch);
+    native.clear_resolve_cache();
   } catch {
-    return false;
   }
 }
-var log, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
-var init_native_bridge = __esm({
-  "packages/domain/scanner/src/native-bridge.ts"() {
-    init_src();
-    log = createDebugLogger("scanner:native");
-    isValidScannerBinding = (module) => {
-      const candidate = module;
-      return !!(candidate && (candidate.scanWorkspace || candidate.extractClassesFromSource || candidate.hashFileContent || candidate.cacheRead || candidate.cacheWrite));
+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"]
     };
-    createScannerBridgeLoader = () => {
-      const _state = {
-        binding: void 0,
-        loadError: null,
-        candidatePaths: []
-      };
-      const throwNativeBindingError = () => {
-        const lines = [
-          "FATAL: Native scanner binding not found.",
-          "",
-          "This package requires the Rust native binding 'tailwind_styled_parser.node'.",
-          "The binding was not found in any of these paths:",
-          ..._state.candidatePaths.map((p) => `  - ${p}`),
-          ""
-        ];
-        if (_state.loadError) {
-          lines.push("Load error:", `  ${_state.loadError}`, "");
-        }
-        lines.push(
-          "To fix this, run:",
-          "  npm run build:rust",
-          "",
-          "This will build the native Rust module from the 'native/' directory.",
-          "If you're using this package in a CI/CD environment, ensure Rust toolchain is installed",
-          "and 'npm run build:rust' is executed before running tests or building."
-        );
-        throw new TwError("rust", "SCANNER_NATIVE_BINDING_NOT_FOUND", lines.join("\n"));
-      };
-      const scannerGetBinding2 = () => {
-        const cachedBinding = _state.binding;
-        if (cachedBinding !== void 0) {
-          if (cachedBinding !== null) {
-            return cachedBinding;
-          }
-          return throwNativeBindingError();
-        }
-        const runtimeDir = getDirname();
-        const candidates = resolveNativeBindingCandidates({
-          runtimeDir,
-          includeDefaultCandidates: true
-        });
-        _state.candidatePaths = candidates;
-        const { binding, loadErrors } = loadNativeBinding({
-          runtimeDir,
-          candidates,
-          isValid: isValidScannerBinding,
-          invalidExportMessage: "Module loaded but missing expected scanner binding functions"
-        });
-        if (binding) {
-          log(`scanner native binding loaded successfully`);
-          _state.binding = binding;
-          return _state.binding;
-        }
-        if (loadErrors.length > 0) {
-          _state.loadError = loadErrors.map((e) => `${e.path}: ${e.message}`).join("; ");
-        }
-        _state.binding = null;
-        return throwNativeBindingError();
-      };
-      return {
-        get: scannerGetBinding2,
-        scannerGetBinding: scannerGetBinding2,
-        reset: () => {
-          _state.binding = void 0;
-          _state.loadError = null;
-          _state.candidatePaths = [];
-        }
-      };
+  }
+}
+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
     };
-    scannerBridgeLoader = createScannerBridgeLoader();
-    scannerGetBinding = scannerBridgeLoader.get;
-    resetScannerBridgeCache = scannerBridgeLoader.reset;
+  }
+}
+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/cacheNative.ts"() {
+    init_nativeBridge();
   }
 });
 
-// packages/domain/compiler/src/nativeBridge.ts
-var _loadNative, log3, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge, resetNativeBridgeCache, adaptNativeResult;
-var init_nativeBridge = __esm({
-  "packages/domain/compiler/src/nativeBridge.ts"() {
-    init_src();
-    _loadNative = (path7) => __require(path7);
-    log3 = (...args) => {
-      if (process.env.DEBUG?.includes("compiler:native")) {
-        console.log("[compiler:native]", ...args);
-      }
-    };
-    NATIVE_UNAVAILABLE_MESSAGE = "[tailwind-styled/compiler v5] Native binding is required but not available.\nThis package requires native Rust bindings. There is no JavaScript fallback.\nPlease ensure:\n  1. The native module is properly installed\n  2. You have run: npm run build:rust (or use prebuilt binary)\n\nFor help, see: https://tailwind-styled.dev/docs/install";
-    nativeBridge = null;
-    bridgeLoadAttempted = false;
-    bridgeLoadError = null;
-    isValidNativeBridge = (mod) => {
-      const m = mod;
-      return !!(typeof m.transformSource === "function" || typeof m.extractAllClasses === "function" || typeof m.hasTwUsage === "function");
-    };
-    getNativeBridge = () => {
-      if (nativeBridge) {
-        return nativeBridge;
-      }
-      if (bridgeLoadAttempted) {
-        if (bridgeLoadError) {
-          throw bridgeLoadError;
-        }
-        throw new Error(NATIVE_UNAVAILABLE_MESSAGE);
-      }
-      bridgeLoadAttempted = true;
-      try {
-        const runtimeDir = resolveRuntimeDir(void 0, import.meta.url);
-        const result = resolveNativeBinary(runtimeDir);
-        if (result.path && result.path.endsWith(".node")) {
-          try {
-            const binding = _loadNative(result.path);
-            if (isValidNativeBridge(binding)) {
-              nativeBridge = binding;
-              log3("Native bridge loaded successfully from:", result.path);
-              return nativeBridge;
-            }
-          } catch (e) {
-            log3("Failed to require native binding:", e);
-          }
-        }
-        throw new Error(`${NATIVE_UNAVAILABLE_MESSAGE}
-
-Tried paths: ${result.tried.join("\n")}`);
-      } catch (err) {
-        bridgeLoadError = err instanceof Error ? err : new Error(String(err));
-        log3("Failed to load native bridge:", bridgeLoadError.message);
-        throw bridgeLoadError;
-      }
+// packages/domain/compiler/src/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: []
     };
-    resetNativeBridgeCache = () => {
-      nativeBridge = null;
-      bridgeLoadAttempted = false;
-      bridgeLoadError = null;
-      log3("Native bridge cache reset");
+  }
+}
+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: []
     };
-    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
-      };
+  }
+}
+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: []
     };
-    if (typeof process !== "undefined" && !bridgeLoadAttempted) {
-      try {
-        getNativeBridge();
-      } catch {
-      }
-    }
   }
-});
-
-// 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;
+}
+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 {
-    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;
+    return JSON.parse(resultJson);
+  } catch {
+    return [];
   }
 }
-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 resolveConflictGroup(groupName, themeJson) {
   const native = getNativeBridge();
-  if (typeof native.processTailwindCssLightning !== "function") {
-    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
+  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"
+    };
   }
-  const result = native.processTailwindCssLightning(rawCss);
-  return result?.css ?? rawCss;
 }
-async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
-  const unique = [...new Set(classes.filter(Boolean))];
-  if (unique.length === 0) {
-    return { css: "", classes: [], sizeBytes: 0, optimized: false };
-  }
-  const rawCss = await generateRawCss(unique, cssEntryContent, root);
+function resolveThemeValue(keyPath, themeJson) {
   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?.resolve_theme_value) throw new Error("resolve_theme_value not available");
+  return native.resolve_theme_value(keyPath, themeJson);
 }
-function processTailwindCssWithTargets(css, targets) {
+function resolveSimpleVariants(configJson) {
   const native = getNativeBridge();
-  if (!native?.processTailwindCssWithTargets) {
-    throw new Error("FATAL: Native binding 'processTailwindCssWithTargets' is required but not available.");
+  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 [];
   }
-  const result = native.processTailwindCssWithTargets(css, targets ?? null);
-  return (result?.css ?? css).trim();
 }
-var require2, _twEngine, _twEngineError;
-var init_tailwindEngine = __esm({
-  "packages/domain/compiler/src/tailwindEngine.ts"() {
+var init_themeResolutionNative = __esm({
+  "packages/domain/compiler/src/themeResolutionNative.ts"() {
     init_nativeBridge();
-    require2 = createRequire(import.meta.url);
-    _twEngine = null;
-    _twEngineError = null;
   }
 });
 
-// packages/domain/compiler/src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  BucketEngine: () => BucketEngine,
-  IncrementalEngine: () => IncrementalEngine,
-  adaptNativeResult: () => adaptNativeResult,
-  analyzeClassUsage: () => analyzeClassUsage,
-  analyzeClasses: () => analyzeClasses,
-  analyzeFile: () => analyzeFile,
-  analyzeRsc: () => analyzeRsc,
-  analyzeVariantUsage: () => analyzeVariantUsage,
-  astExtractClasses: () => astExtractClasses,
-  batchExtractClasses: () => batchExtractClasses,
-  bucketSort: () => bucketSort,
-  buildStyleTag: () => buildStyleTag,
-  checkAgainstSafelist: () => checkAgainstSafelist,
-  classifyAndSortClasses: () => classifyAndSortClasses,
-  classifyNode: () => classifyNode,
-  compileCssFromClasses: () => compileCssFromClasses,
-  compileCssNative: () => compileCssNative,
-  compileVariantTable: () => compileVariantTable,
-  compileVariants: () => compileVariants,
-  detectConflicts: () => detectConflicts,
-  diffClassLists: () => diffClassLists,
-  eliminateDeadCss: () => eliminateDeadCss,
-  extractAllClasses: () => extractAllClasses,
-  extractClassesFromSource: () => extractClassesFromSource,
-  extractComponentUsage: () => extractComponentUsage,
-  fileToRoute: () => fileToRoute,
-  findDeadVariants: () => findDeadVariants,
-  generateCssForClasses: () => generateCssForClasses,
-  generateSafelist: () => generateSafelist,
-  getAllRoutes: () => getAllRoutes,
-  getBucketEngine: () => getBucketEngine,
-  getContentPaths: () => getContentPaths,
-  getIncrementalEngine: () => getIncrementalEngine,
-  getNativeBridge: () => getNativeBridge,
-  getRouteClasses: () => getRouteClasses,
-  hasTwUsage: () => hasTwUsage,
-  hoistComponents: () => hoistComponents,
-  injectClientDirective: () => injectClientDirective,
-  injectServerOnlyComment: () => injectServerOnlyComment,
-  isAlreadyTransformed: () => isAlreadyTransformed,
-  loadSafelist: () => loadSafelist,
-  loadTailwindConfig: () => loadTailwindConfig,
-  mergeClassesStatic: () => mergeClassesStatic,
-  mergeCssDeclarations: () => mergeCssDeclarations,
-  normalizeAndDedupClasses: () => normalizeAndDedupClasses,
-  normalizeClasses: () => normalizeClasses,
-  optimizeCss: () => optimizeCss,
-  parseClasses: () => parseClasses,
-  registerFileClasses: () => registerFileClasses,
-  registerGlobalClasses: () => registerGlobalClasses,
-  resetBucketEngine: () => resetBucketEngine,
-  resetIncrementalEngine: () => resetIncrementalEngine,
-  resetNativeBridgeCache: () => resetNativeBridgeCache,
-  runElimination: () => runElimination,
-  runLoaderTransform: () => runLoaderTransform,
-  scanProjectUsage: () => scanProjectUsage,
-  shouldProcess: () => shouldProcess,
-  shouldSkipFile: () => shouldSkipFile,
-  transformSource: () => transformSource
-});
-var transformSource, hasTwUsage, isAlreadyTransformed, shouldProcess, compileCssFromClasses, buildStyleTag, compileCssNative, generateCssForClasses, extractAllClasses, extractClassesFromSource, astExtractClasses, parseClasses, normalizeClasses, mergeClassesStatic, normalizeAndDedupClasses, eliminateDeadCss, findDeadVariants, runElimination, optimizeCss, scanProjectUsage, extractComponentUsage, diffClassLists, batchExtractClasses, checkAgainstSafelist, hoistComponents, compileVariantTable, compileVariants, classifyAndSortClasses, mergeCssDeclarations, analyzeClassUsage, analyzeRsc, analyzeFile, analyzeVariantUsage, injectClientDirective, injectServerOnlyComment, analyzeClasses, generateSafelist, loadSafelist, loadTailwindConfig, getContentPaths, runLoaderTransform, shouldSkipFile, fileToRoute, getAllRoutes, getRouteClasses, registerFileClasses, registerGlobalClasses, _incrementalEngineInstance, getIncrementalEngine, resetIncrementalEngine, IncrementalEngine, getBucketEngine, resetBucketEngine, BucketEngine, classifyNode, detectConflicts, bucketSort;
-var init_src2 = __esm({
-  "packages/domain/compiler/src/index.ts"() {
-    init_nativeBridge();
-    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;
+// packages/domain/compiler/src/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"
     };
-    hasTwUsage = (source) => {
-      const native = getNativeBridge();
-      if (!native?.hasTwUsage) {
-        throw new Error("FATAL: Native binding 'hasTwUsage' is required but not available.");
-      }
-      return native.hasTwUsage(source);
+  }
+}
+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
     };
-    isAlreadyTransformed = (source) => {
-      const native = getNativeBridge();
-      if (!native?.isAlreadyTransformed) {
-        throw new Error("FATAL: Native binding 'isAlreadyTransformed' is required but not available.");
-      }
-      return native.isAlreadyTransformed(source);
+  }
+}
+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: ""
     };
-    shouldProcess = (source) => {
-      return hasTwUsage(source) && !isAlreadyTransformed(source);
+  }
+}
+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
     };
-    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;
+  }
+}
+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
     };
-    buildStyleTag = (classes) => {
-      const result = compileCssFromClasses(classes);
-      return result?.code ? `<style data-tailwind-styled>${result.code}</style>` : "";
+  }
+}
+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
     };
-    compileCssNative = (classes, prefix = null) => {
-      return compileCssFromClasses(classes, prefix);
+  }
+}
+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
     };
-    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;
+  }
+}
+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/streamingNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/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
     };
-    extractAllClasses = (source) => {
-      const native = getNativeBridge();
-      if (!native?.extractAllClasses) {
-        throw new Error("FATAL: Native binding 'extractAllClasses' is required but not available.");
-      }
-      return native.extractAllClasses(source) || [];
+  }
+}
+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
     };
-    extractClassesFromSource = (source) => {
-      const native = getNativeBridge();
-      if (!native?.extractClassesFromSource) {
-        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
-      }
-      const result = native.extractClassesFromSource(source);
-      return Array.isArray(result) ? result.join(" ") : String(result || "");
-    };
-    astExtractClasses = (source, filename) => {
-      const native = getNativeBridge();
-      if (!native?.extractClassesFromSource) {
-        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
-      }
-      return native.extractClassesFromSource(source) || [];
-    };
-    parseClasses = (raw) => {
-      const native = getNativeBridge();
-      if (!native?.parseClasses) {
-        throw new Error("FATAL: Native binding 'parseClasses' is required but not available.");
-      }
-      return native.parseClasses(raw) || [];
-    };
-    normalizeClasses = (raw) => {
-      const result = normalizeAndDedupClasses(raw);
-      return result?.normalized || "";
-    };
-    mergeClassesStatic = (classes) => {
-      const result = normalizeAndDedupClasses(classes);
-      return result?.normalized || "";
-    };
-    normalizeAndDedupClasses = (raw) => {
-      const native = getNativeBridge();
-      if (!native?.normalizeAndDedupClasses) {
-        throw new Error("FATAL: Native binding 'normalizeAndDedupClasses' is required but not available.");
-      }
-      const result = native.normalizeAndDedupClasses(raw);
-      return result || { normalized: "", duplicatesRemoved: 0, uniqueCount: 0 };
-    };
-    eliminateDeadCss = (css, deadClasses) => {
-      const native = getNativeBridge();
-      if (!native?.processTailwindCssLightning) {
-        throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
-      }
-      const deadSet = deadClasses;
-      const pruned = css.split(/(?<=\})\s*/).filter((rule) => {
-        const m = rule.match(/\.([a-zA-Z0-9_-]+)/);
-        return !m || !deadSet.has(m[1]);
-      }).join("\n");
-      const compiled = native.processTailwindCssLightning(pruned);
-      return (compiled?.css ?? pruned).trim();
-    };
-    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 ?? []));
+  }
+}
+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
     };
-    optimizeCss = (css) => {
-      const native = getNativeBridge();
-      if (!native?.detectDeadCode) {
-        throw new Error("FATAL: Native binding 'detectDeadCode' is required but not available.");
-      }
-      const deadResult = native.detectDeadCode(
-        JSON.stringify({ uniqueClasses: [] }),
-        css
-      );
-      if (!native?.processTailwindCssLightning) {
-        throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
-      }
-      const deadSet = new Set(deadResult.deadInCss ?? []);
-      const pruned = css.split(/(?<=\})\s*/).filter((rule) => {
-        const selectorMatch = rule.match(/\.([a-zA-Z0-9_-]+)/);
-        if (!selectorMatch) return true;
-        return !deadSet.has(selectorMatch[1]);
-      }).join("\n");
-      const compiled = native.processTailwindCssLightning(pruned);
-      return (compiled?.css ?? pruned).trim();
+  }
+}
+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
     };
-    scanProjectUsage = (dirs, cwd) => {
-      const path7 = __require("path");
-      const files = dirs.map((dir) => path7.resolve(cwd, dir));
-      const results = batchExtractClasses(files) || [];
-      const combined = {};
-      for (const result of results) {
-        if (result.ok && result.classes) {
-          for (const cls of result.classes) {
-            if (!combined[cls]) combined[cls] = {};
-            combined[cls][result.file] = /* @__PURE__ */ new Set([cls]);
-          }
-        }
-      }
-      return combined;
+  }
+}
+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
     };
-    extractComponentUsage = (source) => {
-      const native = getNativeBridge();
-      if (!native?.extractComponentUsage) {
-        throw new Error("FATAL: Native binding 'extractComponentUsage' is required but not available.");
-      }
-      return native.extractComponentUsage(source) || [];
+  }
+}
+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/cssCompilationNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/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
     };
-    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 };
+  }
+}
+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/idRegistryNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/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
     };
-    batchExtractClasses = (filePaths) => {
-      const native = getNativeBridge();
-      if (!native?.batchExtractClasses) {
-        throw new Error("FATAL: Native binding 'batchExtractClasses' is required but not available.");
-      }
-      return native.batchExtractClasses(filePaths) || [];
+  }
+}
+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
     };
-    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 };
+  }
+}
+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
     };
-    hoistComponents = (source) => {
-      const native = getNativeBridge();
-      if (!native?.hoistComponents) {
-        throw new Error("FATAL: Native binding 'hoistComponents' is required but not available.");
-      }
-      return native.hoistComponents(source) || { code: source, hoisted: [], warnings: [] };
+  }
+}
+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
     };
-    compileVariantTable = (configJson) => {
-      const native = getNativeBridge();
-      if (!native?.compileVariantTable) {
-        throw new Error("FATAL: Native binding 'compileVariantTable' is required but not available.");
+  }
+}
+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/redisNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/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/watchSystemNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BucketEngine: () => BucketEngine,
+  IncrementalEngine: () => IncrementalEngine,
+  adaptNativeResult: () => adaptNativeResult,
+  analyzeClassUsage: () => analyzeClassUsage,
+  analyzeClassUsageNative: () => analyzeClassUsageNative,
+  analyzeClasses: () => analyzeClasses,
+  analyzeClassesNative: () => analyzeClassesNative,
+  analyzeFile: () => analyzeFile,
+  analyzeRsc: () => analyzeRsc,
+  analyzeRscNative: () => analyzeRscNative,
+  analyzeVariantUsage: () => analyzeVariantUsage,
+  astExtractClasses: () => astExtractClasses,
+  atomicRegistrySize: () => atomicRegistrySize,
+  batchExtractClasses: () => batchExtractClasses,
+  batchExtractClassesNative: () => batchExtractClassesNative,
+  bucketSort: () => bucketSort,
+  buildStyleTag: () => buildStyleTag,
+  cachePriority: () => cachePriority,
+  cacheRead: () => cacheRead,
+  cacheWrite: () => cacheWrite,
+  checkAgainstSafelist: () => checkAgainstSafelist,
+  checkAgainstSafelistNative: () => checkAgainstSafelistNative,
+  classifyAndSortClasses: () => classifyAndSortClasses,
+  classifyAndSortClassesNative: () => classifyAndSortClassesNative,
+  classifyNode: () => classifyNode,
+  clearAllCaches: () => clearAllCaches,
+  clearAtomicRegistry: () => clearAtomicRegistry,
+  clearCompileCache: () => clearCompileCache,
+  clearCssGenCache: () => clearCssGenCache,
+  clearParseCache: () => clearParseCache,
+  clearResolveCache: () => clearResolveCache,
+  clearThemeCache: () => clearThemeCache,
+  collectFiles: () => collectFiles,
+  compileAnimation: () => compileAnimation,
+  compileClass: () => compileClass,
+  compileClasses: () => compileClasses,
+  compileCssFromClasses: () => compileCssFromClasses,
+  compileCssLightning: () => compileCssLightning,
+  compileCssNative: () => compileCssNative,
+  compileCssNative2: () => compileCssNative2,
+  compileKeyframes: () => compileKeyframes,
+  compileTheme: () => compileTheme,
+  compileToCss: () => compileToCss,
+  compileToCssBatch: () => compileToCssBatch,
+  compileVariantTable: () => compileVariantTable,
+  compileVariantTableNative: () => compileVariantTableNative,
+  compileVariants: () => compileVariants,
+  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: () => getCacheStats2,
+  getCompilationMetrics: () => getCompilationMetrics,
+  getCompilerDiagnostics: () => getCompilerDiagnostics,
+  getContentPaths: () => getContentPaths,
+  getIncrementalEngine: () => getIncrementalEngine,
+  getNativeBridge: () => getNativeBridge,
+  getPluginHooks: () => getPluginHooks,
+  getRouteClasses: () => getRouteClasses,
+  getWatchStats: () => getWatchStats,
+  hasTwUsage: () => hasTwUsage,
+  hashContent: () => hashContent,
+  hoistComponents: () => hoistComponents,
+  hoistComponentsNative: () => hoistComponentsNative,
+  idRegistryActiveCount: () => idRegistryActiveCount,
+  idRegistryCreate: () => idRegistryCreate,
+  idRegistryDestroy: () => idRegistryDestroy,
+  idRegistryExport: () => idRegistryExport,
+  idRegistryGenerate: () => idRegistryGenerate,
+  idRegistryImport: () => idRegistryImport,
+  idRegistryLookup: () => idRegistryLookup,
+  idRegistryNext: () => idRegistryNext,
+  idRegistryReset: () => idRegistryReset,
+  idRegistrySnapshot: () => idRegistrySnapshot,
+  injectClientDirective: () => injectClientDirective,
+  injectServerOnlyComment: () => injectServerOnlyComment,
+  injectStateHash: () => injectStateHash,
+  isAlreadyTransformed: () => isAlreadyTransformed,
+  isWatchRunning: () => isWatchRunning,
+  layoutClassesToCss: () => layoutClassesToCss,
+  loadSafelist: () => loadSafelist,
+  loadTailwindConfig: () => loadTailwindConfig,
+  mergeClassesStatic: () => mergeClassesStatic,
+  mergeCssDeclarations: () => mergeCssDeclarations,
+  mergeCssDeclarationsNative: () => mergeCssDeclarationsNative,
+  minifyCss: () => minifyCss,
+  normalizeAndDedupClasses: () => normalizeAndDedupClasses,
+  normalizeClasses: () => normalizeClasses,
+  optimizeCss: () => optimizeCss,
+  optimizeCssNative: () => optimizeCssNative,
+  parseAtomicClass: () => parseAtomicClass,
+  parseClasses: () => parseClasses,
+  pollWatchEvents: () => pollWatchEvents,
+  processFileChange: () => processFileChange,
+  processTailwindCssLightning: () => processTailwindCssLightning,
+  propertyIdToString: () => propertyIdToString,
+  pruneStaleCacheEntries: () => pruneStaleCacheEntries,
+  rebuildWorkspaceResult: () => rebuildWorkspaceResult,
+  redisCacheClear: () => redisCacheClear,
+  redisCacheHitRate: () => redisCacheHitRate,
+  redisCacheKeyCount: () => redisCacheKeyCount,
+  redisCacheSize: () => redisCacheSize,
+  redisCacheSync: () => redisCacheSync,
+  redisClusterStatus: () => redisClusterStatus,
+  redisDelete: () => redisDelete,
+  redisDiagnose: () => redisDiagnose,
+  redisDisableCacheWarming: () => redisDisableCacheWarming,
+  redisDisableCluster: () => redisDisableCluster,
+  redisDisablePersistence: () => redisDisablePersistence,
+  redisEnableCacheWarming: () => redisEnableCacheWarming,
+  redisEnableCluster: () => redisEnableCluster,
+  redisEnablePersistence: () => redisEnablePersistence,
+  redisExists: () => redisExists,
+  redisExpirationGet: () => redisExpirationGet,
+  redisExpirationSet: () => redisExpirationSet,
+  redisFlushAll: () => redisFlushAll,
+  redisFlushDb: () => redisFlushDb,
+  redisGet: () => redisGet,
+  redisGetEvictionPolicy: () => redisGetEvictionPolicy,
+  redisInfo: () => redisInfo,
+  redisMemoryStats: () => redisMemoryStats,
+  redisMget: () => redisMget,
+  redisMonitor: () => redisMonitor,
+  redisMset: () => redisMset,
+  redisOptimizeMemory: () => redisOptimizeMemory,
+  redisPing: () => redisPing,
+  redisPoolConnect: () => redisPoolConnect,
+  redisPoolReconnect: () => redisPoolReconnect,
+  redisPoolStats: () => redisPoolStats,
+  redisPublish: () => redisPublish,
+  redisReplicate: () => redisReplicate,
+  redisReplicationStatus: () => redisReplicationStatus,
+  redisSet: () => redisSet,
+  redisSetEvictionPolicy: () => redisSetEvictionPolicy,
+  redisSnapshot: () => redisSnapshot,
+  redisSubscribe: () => redisSubscribe,
+  registerFileClasses: () => registerFileClasses,
+  registerGlobalClasses: () => registerGlobalClasses,
+  registerPluginHook: () => registerPluginHook,
+  registerPropertyName: () => registerPropertyName,
+  registerValueName: () => registerValueName,
+  resetBucketEngine: () => resetBucketEngine,
+  resetCompilationMetrics: () => resetCompilationMetrics,
+  resetIncrementalEngine: () => resetIncrementalEngine,
+  resetNativeBridgeCache: () => resetNativeBridgeCache,
+  resolveCascade: () => resolveCascade,
+  resolveClassNames: () => resolveClassNames,
+  resolveConflictGroup: () => resolveConflictGroup,
+  resolveSimpleVariants: () => resolveSimpleVariants,
+  resolveThemeValue: () => resolveThemeValue,
+  resolveVariants: () => resolveVariants,
+  reverseLookupProperty: () => reverseLookupProperty,
+  reverseLookupValue: () => reverseLookupValue,
+  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
+});
+function _layoutClassesToCss(classes) {
+  const native = getNativeBridge();
+  if (!native?.layoutClassesToCss) {
+    throw new Error("FATAL: Native binding 'layoutClassesToCss' is required but not available.");
+  }
+  return native.layoutClassesToCss(classes);
+}
+function _hashContainer(tag, containerJson, name) {
+  const sortedKey = tag + (name ?? "") + containerJson;
+  const native = getNativeBridge();
+  if (!native?.hashContent) {
+    throw new Error("FATAL: Native binding 'hashContent' is required but not available.");
+  }
+  return `tw-cq-${native.hashContent(sortedKey, "fnv", 6)}`;
+}
+function extractContainerCssFromSource(source) {
+  const native = getNativeBridge();
+  if (!native?.extractTwContainerConfigs) {
+    throw new Error("FATAL: Native binding 'extractTwContainerConfigs' is required but not available.");
+  }
+  const configs = native.extractTwContainerConfigs(source);
+  const rules = [];
+  for (const cfg of configs) {
+    const id = _hashContainer(cfg.tag, cfg.containerJson, cfg.containerName);
+    for (const { key, classes } of cfg.breakpoints) {
+      const minWidth = _CONTAINER_BREAKPOINTS[key] ?? key;
+      const css = _layoutClassesToCss(classes);
+      if (!css) continue;
+      const query = cfg.containerName ? `@container ${cfg.containerName} (min-width: ${minWidth})` : `@container (min-width: ${minWidth})`;
+      rules.push(`${query}{.${id}{${css}}}`);
+    }
+  }
+  return rules.join("\n");
+}
+var transformSource, hasTwUsage, isAlreadyTransformed, shouldProcess, compileCssFromClasses, buildStyleTag, compileCssNative, generateCssForClasses, extractAllClasses, extractClassesFromSource, astExtractClasses, parseClasses, normalizeClasses, mergeClassesStatic, normalizeAndDedupClasses, eliminateDeadCss, findDeadVariants, runElimination, optimizeCss, scanProjectUsage, extractComponentUsage, diffClassLists, batchExtractClasses, checkAgainstSafelist, hoistComponents, compileVariantTable, compileVariants, classifyAndSortClasses, mergeCssDeclarations, analyzeClassUsage, analyzeRsc, analyzeFile, analyzeVariantUsage, injectClientDirective, injectServerOnlyComment, analyzeClasses, generateSafelist, loadSafelist, loadTailwindConfig, getContentPaths, _CONTAINER_BREAKPOINTS, runLoaderTransform, shouldSkipFile, fileToRoute, getAllRoutes, getRouteClasses, registerFileClasses, registerGlobalClasses, _incrementalEngineInstance, getIncrementalEngine, resetIncrementalEngine, IncrementalEngine, getBucketEngine, resetBucketEngine, BucketEngine, classifyNode, detectConflicts, bucketSort, extractTwStateConfigs, generateStaticStateCss, extractAndGenerateStateCss;
+var init_src = __esm({
+  "packages/domain/compiler/src/index.ts"() {
+    init_nativeBridge();
+    init_cssGeneratorNative();
+    init_scannerNative();
+    init_analyzerNative();
+    init_compilationNative();
+    init_cacheNative();
+    init_themeResolutionNative();
+    init_streamingNative();
+    init_cssCompilationNative();
+    init_idRegistryNative();
+    init_redisNative();
+    init_watchSystemNative();
+    transformSource = (source, opts) => {
+      const native = getNativeBridge();
+      if (!native?.transformSource) {
+        throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
       }
-      return native.compileVariantTable(configJson) || { id: "", tableJson: "{}", keys: [], defaultKey: "", combinations: 0 };
+      const result = native.transformSource(source, opts);
+      if (!result) {
+        throw new Error("FATAL: transformSource returned null");
+      }
+      return result;
     };
-    compileVariants = (componentId, config) => {
-      return compileVariantTable(JSON.stringify({ componentId, ...config }));
+    hasTwUsage = (source) => {
+      const native = getNativeBridge();
+      if (!native?.hasTwUsage) {
+        throw new Error("FATAL: Native binding 'hasTwUsage' is required but not available.");
+      }
+      return native.hasTwUsage(source);
     };
-    classifyAndSortClasses = (classes) => {
+    isAlreadyTransformed = (source) => {
       const native = getNativeBridge();
-      if (!native?.classifyAndSortClasses) {
-        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      if (!native?.isAlreadyTransformed) {
+        throw new Error("FATAL: Native binding 'isAlreadyTransformed' is required but not available.");
       }
-      return native.classifyAndSortClasses(classes) || [];
+      return native.isAlreadyTransformed(source);
     };
-    mergeCssDeclarations = (cssChunks) => {
+    shouldProcess = (source) => {
+      return hasTwUsage(source) && !isAlreadyTransformed(source);
+    };
+    compileCssFromClasses = (classes, prefix) => {
       const native = getNativeBridge();
-      if (!native?.mergeCssDeclarations) {
-        throw new Error("FATAL: Native binding 'mergeCssDeclarations' is required but not available.");
+      if (!native?.transformSource) {
+        throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
       }
-      return native.mergeCssDeclarations(cssChunks) || { declarationsJson: "{}", declarationString: "", count: 0 };
+      const result = native.transformSource(classes.join(" "), { prefix: prefix ?? "" });
+      if (!result) {
+        throw new Error("FATAL: transformSource returned null");
+      }
+      return result;
     };
-    analyzeClassUsage = (classes, scanResultJson, css) => {
+    buildStyleTag = (classes) => {
+      const result = compileCssFromClasses(classes);
+      return result?.code ? `<style data-tailwind-styled>${result.code}</style>` : "";
+    };
+    compileCssNative = (classes, prefix = null) => {
+      return compileCssFromClasses(classes, prefix);
+    };
+    generateCssForClasses = async (classes, _tailwindConfig, root, cssEntryContent, minify = false) => {
+      const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
+      const result = await runCssPipeline2(classes, cssEntryContent, root, minify);
+      return result.css;
+    };
+    extractAllClasses = (source) => {
       const native = getNativeBridge();
-      if (!native?.analyzeClassUsage) {
-        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+      if (!native?.extractAllClasses) {
+        throw new Error("FATAL: Native binding 'extractAllClasses' is required but not available.");
       }
-      return native.analyzeClassUsage(classes, scanResultJson, css) || [];
+      return native.extractAllClasses(source) || [];
     };
-    analyzeRsc = (source, filename) => {
+    extractClassesFromSource = (source) => {
       const native = getNativeBridge();
-      if (!native?.analyzeRsc) {
-        throw new Error("FATAL: Native binding 'analyzeRsc' is required but not available.");
+      if (!native?.extractClassesFromSource) {
+        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
       }
-      return native.analyzeRsc(source, filename) || { isServer: true, needsClientDirective: false, clientReasons: [] };
+      const result = native.extractClassesFromSource(source);
+      return Array.isArray(result) ? result.join(" ") : String(result || "");
+    };
+    astExtractClasses = (source, _filename) => {
+      const native = getNativeBridge();
+      if (!native?.extractClassesFromSource) {
+        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
+      }
+      return native.extractClassesFromSource(source) || [];
+    };
+    parseClasses = (raw) => {
+      const native = getNativeBridge();
+      if (!native?.parseClasses) {
+        throw new Error("FATAL: Native binding 'parseClasses' is required but not available.");
+      }
+      return native.parseClasses(raw) || [];
+    };
+    normalizeClasses = (raw) => {
+      const result = normalizeAndDedupClasses(raw);
+      return result?.normalized || "";
+    };
+    mergeClassesStatic = (classes) => {
+      const result = normalizeAndDedupClasses(classes);
+      return result?.normalized || "";
+    };
+    normalizeAndDedupClasses = (raw) => {
+      const native = getNativeBridge();
+      if (!native?.normalizeAndDedupClasses) {
+        throw new Error("FATAL: Native binding 'normalizeAndDedupClasses' is required but not available.");
+      }
+      const result = native.normalizeAndDedupClasses(raw);
+      return result || { normalized: "", duplicatesRemoved: 0, uniqueCount: 0 };
+    };
+    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 ?? []));
+    };
+    optimizeCss = (css) => {
+      const native = getNativeBridge();
+      if (!native?.optimizeCss) {
+        throw new Error("FATAL: Native binding 'optimizeCss' is required but not available.");
+      }
+      return native.optimizeCss(css);
+    };
+    scanProjectUsage = (dirs, cwd) => {
+      const files = dirs.map((dir) => path10__default.resolve(cwd, dir));
+      const results = batchExtractClasses(files) || [];
+      const combined = {};
+      for (const result of results) {
+        if (result.ok && result.classes) {
+          for (const cls of result.classes) {
+            if (!combined[cls]) combined[cls] = {};
+            combined[cls][result.file] = /* @__PURE__ */ new Set([cls]);
+          }
+        }
+      }
+      return combined;
+    };
+    extractComponentUsage = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractComponentUsage) {
+        throw new Error("FATAL: Native binding 'extractComponentUsage' is required but not available.");
+      }
+      return native.extractComponentUsage(source) || [];
+    };
+    diffClassLists = (previous, current) => {
+      const native = getNativeBridge();
+      if (!native?.diffClassLists) {
+        throw new Error("FATAL: Native binding 'diffClassLists' is required but not available.");
+      }
+      return native.diffClassLists(previous, current) || { added: [], removed: [], unchanged: [], hasChanges: false };
+    };
+    batchExtractClasses = (filePaths) => {
+      const native = getNativeBridge();
+      if (!native?.batchExtractClasses) {
+        throw new Error("FATAL: Native binding 'batchExtractClasses' is required but not available.");
+      }
+      return native.batchExtractClasses(filePaths) || [];
+    };
+    checkAgainstSafelist = (classes, safelist) => {
+      const native = getNativeBridge();
+      if (!native?.checkAgainstSafelist) {
+        throw new Error("FATAL: Native binding 'checkAgainstSafelist' is required but not available.");
+      }
+      return native.checkAgainstSafelist(classes, safelist) || { matched: [], unmatched: [], safelistSize: 0 };
+    };
+    hoistComponents = (source) => {
+      const native = getNativeBridge();
+      if (!native?.hoistComponents) {
+        throw new Error("FATAL: Native binding 'hoistComponents' is required but not available.");
+      }
+      return native.hoistComponents(source) || { code: source, hoisted: [], warnings: [] };
+    };
+    compileVariantTable = (configJson) => {
+      const native = getNativeBridge();
+      if (!native?.compileVariantTable) {
+        throw new Error("FATAL: Native binding 'compileVariantTable' is required but not available.");
+      }
+      return native.compileVariantTable(configJson) || { id: "", tableJson: "{}", keys: [], defaultKey: "", combinations: 0 };
+    };
+    compileVariants = (componentId, config) => {
+      return compileVariantTable(JSON.stringify({ componentId, ...config }));
+    };
+    classifyAndSortClasses = (classes) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return native.classifyAndSortClasses(classes) || [];
+    };
+    mergeCssDeclarations = (cssChunks) => {
+      const native = getNativeBridge();
+      if (!native?.mergeCssDeclarations) {
+        throw new Error("FATAL: Native binding 'mergeCssDeclarations' is required but not available.");
+      }
+      return native.mergeCssDeclarations(cssChunks) || { declarationsJson: "{}", declarationString: "", count: 0 };
+    };
+    analyzeClassUsage = (classes, scanResultJson, css) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClassUsage) {
+        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+      }
+      return native.analyzeClassUsage(classes, scanResultJson, css) || [];
+    };
+    analyzeRsc = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeRsc) {
+        throw new Error("FATAL: Native binding 'analyzeRsc' is required but not available.");
+      }
+      return native.analyzeRsc(source, filename) || { isServer: true, needsClientDirective: false, clientReasons: [] };
     };
     analyzeFile = (source, filename) => {
       const rsc = analyzeRsc(source, filename);
@@ -1210,170 +2268,1061 @@ var init_src2 = __esm({
         canStaticResolveVariants: true
       };
     };
-    analyzeVariantUsage = (source, componentName, variantKeys) => {
-      analyzeRsc(source, componentName);
-      return {
-        resolved: {},
-        dynamic: []
+    analyzeVariantUsage = (_source, _componentName, _variantKeys) => {
+      return { resolved: {}, dynamic: [] };
+    };
+    injectClientDirective = (source) => {
+      if (!source.includes('"use client"') && !source.includes("'use client'")) {
+        return '"use client";\n' + source;
+      }
+      return source;
+    };
+    injectServerOnlyComment = (source) => {
+      return `/* @server-only */
+${source}`;
+    };
+    analyzeClasses = (filesJson, cwd, flags) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return native.analyzeClasses(filesJson, cwd, flags);
+    };
+    generateSafelist = (scanDirs, outputPath, cwd) => {
+      const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
+      const allClasses = Object.keys(classes).sort();
+      if (outputPath) {
+        fs9__default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+      }
+      return allClasses;
+    };
+    loadSafelist = (safelistPath) => {
+      try {
+        const content = fs9__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 = path10__default.join(cwd, file);
+        if (fs9__default.existsSync(fullPath)) {
+          const mod = __require(fullPath);
+          return mod.default || mod;
+        }
+      }
+      return {};
+    };
+    getContentPaths = (cwd = process.cwd()) => {
+      return {
+        content: [
+          path10__default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          path10__default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          path10__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 {
+      }
+      return {
+        code: result?.code || "",
+        changed: result?.changed || false,
+        classes: result?.classes || [],
+        staticCss
+      };
+    };
+    shouldSkipFile = (filepath) => {
+      const SKIP_PATHS = ["node_modules", ".next", ".rspack-dist", ".turbo", "dist/", "out/"];
+      const skipExtensions = [".css", ".json", ".md", ".txt", ".yaml", ".yml"];
+      for (const p of SKIP_PATHS) {
+        if (filepath.includes(p)) return true;
+      }
+      for (const ext of skipExtensions) {
+        if (filepath.endsWith(ext)) return true;
+      }
+      return false;
+    };
+    fileToRoute = (filepath) => {
+      const normalized = filepath.replace(/\\/g, "/");
+      if (normalized.includes("/layout.") || normalized.includes("/loading.") || normalized.includes("/error.")) {
+        return "__global";
+      }
+      const pageMatch = normalized.match(/\/app\/(.+?)\/page\.[tj]sx?$/);
+      if (pageMatch) return `/${pageMatch[1]}`;
+      const rootPage = normalized.match(/\/app\/page\.[tj]sx?$/);
+      if (rootPage) return "/";
+      return null;
+    };
+    getAllRoutes = () => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return ["/", "__global"];
+    };
+    getRouteClasses = (_route) => /* @__PURE__ */ new Set();
+    registerFileClasses = (_filepath, _classes) => {
+    };
+    registerGlobalClasses = (_classes) => {
+    };
+    _incrementalEngineInstance = null;
+    getIncrementalEngine = () => {
+      if (!_incrementalEngineInstance) {
+        _incrementalEngineInstance = new IncrementalEngine();
+      }
+      return _incrementalEngineInstance;
+    };
+    resetIncrementalEngine = () => {
+      _incrementalEngineInstance = null;
+    };
+    IncrementalEngine = class {
+      compile(source) {
+        return transformSource(source);
+      }
+    };
+    getBucketEngine = () => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return {
+        add: (className) => className,
+        get: (_bucket) => []
+      };
+    };
+    resetBucketEngine = () => {
+    };
+    BucketEngine = class {
+      add(className) {
+        return className;
+      }
+    };
+    classifyNode = (_node) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return "unknown";
+    };
+    detectConflicts = (_classes) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClassUsage) {
+        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+      }
+      return [];
+    };
+    bucketSort = (classes) => {
+      return classifyAndSortClasses(classes).map((c) => c.raw ?? c);
+    };
+    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 = (inputs, resolvedCss = null) => {
+      const native = getNativeBridge();
+      if (!native?.generateStaticStateCss) {
+        throw new Error("FATAL: Native binding 'generateStaticStateCss' is required but not available.");
+      }
+      return native.generateStaticStateCss(inputs, resolvedCss);
+    };
+    extractAndGenerateStateCss = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.extractAndGenerateStateCss) {
+        const configs = extractTwStateConfigs(source, filename);
+        if (configs.length === 0) return [];
+        return generateStaticStateCss(
+          configs.map((c) => ({ tag: c.tag, componentName: c.componentName, statesJson: c.statesJson }))
+        );
+      }
+      return native.extractAndGenerateStateCss(source, filename);
+    };
+  }
+});
+
+// packages/domain/compiler/src/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  adaptNativeResult: () => adaptNativeResult,
+  analyzeClassUsage: () => analyzeClassUsage,
+  analyzeClasses: () => analyzeClasses,
+  analyzeFile: () => analyzeFile,
+  analyzeRsc: () => analyzeRsc,
+  analyzeVariantUsage: () => analyzeVariantUsage,
+  astExtractClasses: () => astExtractClasses,
+  batchExtractClasses: () => batchExtractClasses,
+  bucketSort: () => bucketSort,
+  buildStyleTag: () => buildStyleTag,
+  checkAgainstSafelist: () => checkAgainstSafelist,
+  classifyAndSortClasses: () => classifyAndSortClasses,
+  classifyNode: () => classifyNode,
+  clearCache: () => clearCache,
+  compileCssFromClasses: () => compileCssFromClasses,
+  compileCssNative: () => compileCssNative,
+  compileVariantTable: () => compileVariantTable,
+  compileVariants: () => compileVariants,
+  detectConflicts: () => detectConflicts,
+  diffClassLists: () => diffClassLists,
+  eliminateDeadCss: () => eliminateDeadCss,
+  extractAllClasses: () => extractAllClasses,
+  extractAndGenerateStateCss: () => extractAndGenerateStateCss,
+  extractClassesFromSource: () => extractClassesFromSource,
+  extractComponentUsage: () => extractComponentUsage,
+  extractContainerCssFromSource: () => extractContainerCssFromSource,
+  extractTwStateConfigs: () => extractTwStateConfigs,
+  fileToRoute: () => fileToRoute,
+  findDeadVariants: () => findDeadVariants,
+  generateCssForClasses: () => generateCssForClasses,
+  generateRawCss: () => generateRawCss,
+  generateSafelist: () => generateSafelist,
+  generateStaticStateCss: () => generateStaticStateCss,
+  getAllRoutes: () => getAllRoutes,
+  getBucketEngine: () => getBucketEngine,
+  getCacheStats: () => getCacheStats,
+  getContentPaths: () => getContentPaths,
+  getIncrementalEngine: () => getIncrementalEngine,
+  getNativeBridge: () => getNativeBridge,
+  getRouteClasses: () => getRouteClasses,
+  hasTwUsage: () => hasTwUsage,
+  hoistComponents: () => hoistComponents,
+  injectClientDirective: () => injectClientDirective,
+  injectServerOnlyComment: () => injectServerOnlyComment,
+  isAlreadyTransformed: () => isAlreadyTransformed,
+  loadSafelist: () => loadSafelist,
+  loadTailwindConfig: () => loadTailwindConfig,
+  mergeClassesStatic: () => mergeClassesStatic,
+  mergeCssDeclarations: () => mergeCssDeclarations,
+  normalizeAndDedupClasses: () => normalizeAndDedupClasses,
+  normalizeClasses: () => normalizeClasses,
+  optimizeCss: () => optimizeCss,
+  parseClasses: () => parseClasses,
+  registerFileClasses: () => registerFileClasses,
+  registerGlobalClasses: () => registerGlobalClasses,
+  resetBucketEngine: () => resetBucketEngine,
+  resetIncrementalEngine: () => resetIncrementalEngine,
+  runCssPipeline: () => runCssPipeline,
+  runCssPipelineSync: () => runCssPipelineSync,
+  runElimination: () => runElimination,
+  runLoaderTransform: () => runLoaderTransform,
+  scanProjectUsage: () => scanProjectUsage,
+  shouldProcess: () => shouldProcess,
+  shouldSkipFile: () => shouldSkipFile,
+  transformSource: () => transformSource
+});
+var init_internal = __esm({
+  "packages/domain/compiler/src/internal.ts"() {
+    init_src();
+    init_tailwindEngine();
+  }
+});
+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 = fs9__default.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path10__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 = path10__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] ${path10__default.relative(srcDir, filePath)}: ${configs.length} komponen
+`
+          );
+        }
+      }
+    }
+  } else {
+    for (const filePath of walkSourceFiles(srcDir)) {
+      if (filesScanned >= maxFiles) break;
+      let source;
+      try {
+        source = fs9__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] ${path10__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 = path10__default.join(path10__default.dirname(safelistPath), "tw-classes");
+  fs9__default.mkdirSync(twClassesDir, { recursive: true });
+  const stateFilePath = path10__default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+  if (result.rulesGenerated === 0) {
+    try {
+      fs9__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 {
+    fs9__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 {
+    fs9__default.mkdirSync(path10__default.dirname(filePath), { recursive: true });
+    fs9__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 {
+    fs9__default.appendFileSync(_globalLogFile, line);
+  } catch {
+  }
+}
+function createLogger(prefix, level) {
+  const loggerState = {
+    currentLevel: getEnvLevel(),
+    setLevel(l) {
+      this.currentLevel = l;
+    }
+  };
+  const log4 = (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) => log4("error", "stderr", a),
+    warn: (...a) => log4("warn", "stderr", a),
+    info: (...a) => log4("info", "stdout", a),
+    debug: (...a) => log4("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");
+  }
+});
+function createLogger2(namespace) {
+  const prefix = `[${namespace}]`;
+  return {
+    warn(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    },
+    debug(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    },
+    error(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    },
+    log(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    }
+  };
+}
+function createDebugLogger(namespace, label) {
+  const prefix = `[${namespace}]`;
+  return (msg) => {
+    if (process.env.DEBUG?.includes(namespace) || process.env.TW_DEBUG) {
+      console.debug(prefix, msg);
+    }
+  };
+}
+function formatIssuePath(path11) {
+  if (!path11 || path11.length === 0) return "(root)";
+  return path11.map(
+    (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
+  ).join(".");
+}
+function loadNativeBinding(options) {
+  const { runtimeDir, candidates, isValid } = options;
+  const loadErrors = [];
+  for (const candidate of candidates) {
+    const candidatePath = path10__default.resolve(runtimeDir, candidate);
+    try {
+      if (!fs9__default.existsSync(candidatePath) && !fs9__default.existsSync(candidatePath + ".node")) {
+        continue;
+      }
+      const mod = requireNativeModule(candidatePath);
+      if (mod && isValid(mod)) {
+        return { binding: mod, loadErrors, loadedPath: candidatePath };
+      }
+      loadErrors.push({ path: candidatePath, message: options.invalidExportMessage });
+    } catch (e) {
+      loadErrors.push({ path: candidatePath, message: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  return { binding: null, loadErrors };
+}
+function requireNativeModule(p) {
+  return _require2(p);
+}
+function resolveNativeBindingCandidates(options) {
+  const {
+    envVarNames = ["TW_NATIVE_PATH", "TWS_NATIVE_PATH"],
+    includeDefaultCandidates = true,
+    enforceNodeExtensionForEnvPath = false
+  } = options;
+  const runtimeDir = options.runtimeDir || process.cwd();
+  const candidates = [];
+  for (const envVar of envVarNames) {
+    const envPath = process.env[envVar];
+    if (envPath) {
+      candidates.push(enforceNodeExtensionForEnvPath && !envPath.endsWith(".node") ? envPath + ".node" : envPath);
+    }
+  }
+  if (!includeDefaultCandidates) return candidates;
+  if (fs9__default.existsSync(runtimeDir)) {
+    try {
+      for (const entry of fs9__default.readdirSync(runtimeDir)) {
+        if (entry.endsWith(".node")) candidates.push(entry);
+      }
+    } catch {
+    }
+  }
+  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(path10__default.resolve(runtimeDir, `${bin}.node`));
+    candidates.push(path10__default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(path10__default.resolve(runtimeDir, "..", "native", `${bin}.node`));
+    candidates.push(path10__default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path10__default.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(path10__default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path10__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path10__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path10__default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+  }
+  return Array.from(new Set(candidates));
+}
+function resolveRuntimeDir(dir, importMetaUrl) {
+  try {
+    return path10__default.dirname(fileURLToPath(importMetaUrl));
+  } catch {
+    return process.cwd();
+  }
+}
+var TwError, _require2;
+var init_src2 = __esm({
+  "packages/domain/shared/src/index.ts"() {
+    init_workerResolver();
+    init_native_resolution();
+    init_staticStateExtractor();
+    init_logger();
+    TwError = class _TwError extends Error {
+      /** @deprecated Gunakan source */
+      domain;
+      source;
+      code;
+      originalCause;
+      constructor(domainOrSource, code, message, cause) {
+        super(message);
+        this.name = "TwError";
+        this.domain = domainOrSource;
+        this.source = domainOrSource;
+        this.code = code;
+        this.originalCause = cause;
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _TwError);
+      }
+      static fromIo(code, message) {
+        return new _TwError("io", code, message);
+      }
+      static fromCompile(code, message) {
+        return new _TwError("compile", code, message);
+      }
+      static fromRust(err) {
+        if (err instanceof _TwError) return err;
+        if (err instanceof Error) return new _TwError("rust", "RUST_ERROR", err.message, err);
+        if (err && typeof err === "object") {
+          const e = err;
+          return new _TwError("rust", e.code ?? "RUST_ERROR", e.message ?? String(err), err);
+        }
+        return new _TwError("rust", "RUST_ERROR", String(err), err);
+      }
+      /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
+      static fromZod(err) {
+        const first = err.issues?.[0] ?? err.errors?.[0];
+        const path11 = formatIssuePath(first?.path);
+        const message = first ? `${path11}: ${first.message}` : "Schema validation failed";
+        return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
+      }
+      static wrap(source, code, err) {
+        if (err instanceof _TwError) return err;
+        if (err instanceof Error) return new _TwError(source, code, err.message, err);
+        return new _TwError(source, code, String(err), err);
+      }
+      toString() {
+        return `TwError [${this.source}:${this.code}] ${this.message}`;
+      }
+      toJSON() {
+        return { name: this.name, source: this.source, code: this.code, message: this.message };
+      }
+      toCliMessage() {
+        return `[${this.source.toUpperCase()}:${this.code}] ${this.message}`;
+      }
+    };
+    _require2 = createRequire(import.meta.url);
+  }
+});
+
+// packages/domain/scanner/src/native-bridge.ts
+var native_bridge_exports = {};
+__export(native_bridge_exports, {
+  batchExtractClassesNative: () => batchExtractClassesNative2,
+  cachePriorityNative: () => cachePriorityNative,
+  cacheReadNative: () => cacheReadNative,
+  cacheWriteNative: () => cacheWriteNative,
+  collectFilesNative: () => collectFilesNative,
+  computeCacheStatsNative: () => computeCacheStatsNative,
+  extractClassesNative: () => extractClassesNative,
+  generateSubComponentTypesNative: () => generateSubComponentTypesNative,
+  hasNativeScannerBinding: () => hasNativeScannerBinding,
+  hasNativeWatchBinding: () => hasNativeWatchBinding,
+  hashContentNative: () => hashContentNative,
+  isRustCacheAvailable: () => isRustCacheAvailable,
+  pollWatchEventsNative: () => pollWatchEventsNative,
+  pruneStaleEntriesNative: () => pruneStaleEntriesNative,
+  rebuildWorkspaceResultNative: () => rebuildWorkspaceResultNative,
+  resetScannerBridgeCache: () => resetScannerBridgeCache,
+  scanCacheGet: () => scanCacheGet,
+  scanCacheInvalidate: () => scanCacheInvalidate,
+  scanCachePut: () => scanCachePut,
+  scanCacheStats: () => scanCacheStats,
+  scanFileNative: () => scanFileNative2,
+  scanFilesBatchNative: () => scanFilesBatchNative2,
+  scanWorkspaceNative: () => scanWorkspaceNative,
+  startWatchNative: () => startWatchNative,
+  stopWatchNative: () => stopWatchNative
+});
+function getDirname() {
+  if (typeof __dirname !== "undefined") {
+    return __dirname;
+  }
+  if (typeof import.meta !== "undefined" && import.meta.url) {
+    return path10__default.dirname(fileURLToPath(import.meta.url));
+  }
+  return process.cwd();
+}
+function scanWorkspaceNative(root, extensions) {
+  return scannerGetBinding().scanWorkspace(root, extensions ?? null);
+}
+function extractClassesNative(source) {
+  const result = scannerGetBinding().extractClassesFromSource?.(source);
+  if (result === null || result === void 0) {
+    throw new TwError(
+      "rust",
+      "SCANNER_EXTRACT_FAILED",
+      "Native extractClassesFromSource returned null/undefined"
+    );
+  }
+  return result;
+}
+function hashContentNative(content) {
+  const result = scannerGetBinding().hashFileContent?.(content);
+  if (result === null || result === void 0) {
+    throw new TwError(
+      "rust",
+      "SCANNER_HASH_FAILED",
+      "Native hashFileContent returned null/undefined"
+    );
+  }
+  return result;
+}
+function isRustCacheAvailable() {
+  return true;
+}
+function hasNativeScannerBinding() {
+  try {
+    scannerBridgeLoader.get();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cacheReadNative(cachePath) {
+  const result = scannerGetBinding().cacheRead?.(cachePath);
+  if (result === null || result === void 0) {
+    throw new TwError(
+      "rust",
+      "SCANNER_CACHE_READ_FAILED",
+      "Native cacheRead returned null/undefined"
+    );
+  }
+  return result;
+}
+function cacheWriteNative(cachePath, entries) {
+  const result = scannerGetBinding().cacheWrite?.(cachePath, entries);
+  if (result === null || result === void 0) {
+    throw new TwError(
+      "rust",
+      "SCANNER_CACHE_WRITE_FAILED",
+      "Native cacheWrite returned null/undefined"
+    );
+  }
+  return result;
+}
+function cachePriorityNative(mtimeMs, size, cachedMtimeMs, cachedSize, cachedHitCount, cachedLastSeenMs, nowMs = Date.now()) {
+  const result = scannerGetBinding().cachePriority?.(
+    mtimeMs,
+    size,
+    cachedMtimeMs,
+    cachedSize,
+    cachedHitCount,
+    cachedLastSeenMs,
+    nowMs
+  );
+  if (result === null || result === void 0) {
+    throw new TwError(
+      "rust",
+      "SCANNER_CACHE_PRIORITY_FAILED",
+      "Native cachePriority returned null/undefined"
+    );
+  }
+  return result;
+}
+function batchExtractClassesNative2(filePaths) {
+  const binding = scannerGetBinding();
+  if (!binding.batchExtractClasses) {
+    throw new Error("FATAL: Native binding 'batchExtractClasses' is required but not available.");
+  }
+  return binding.batchExtractClasses(filePaths) ?? [];
+}
+function scanCacheGet(filePath, contentHash) {
+  const binding = scannerGetBinding();
+  if (!binding.scanCacheGet) {
+    throw new Error("FATAL: Native binding 'scanCacheGet' is required but not available.");
+  }
+  return binding.scanCacheGet(filePath, contentHash) ?? null;
+}
+function scanCachePut(filePath, contentHash, classes, mtimeMs, size) {
+  const binding = scannerGetBinding();
+  if (!binding.scanCachePut) {
+    throw new Error("FATAL: Native binding 'scanCachePut' is required but not available.");
+  }
+  binding.scanCachePut(filePath, contentHash, classes, mtimeMs, size);
+}
+function scanCacheInvalidate(filePath) {
+  const binding = scannerGetBinding();
+  if (!binding.scanCacheInvalidate) {
+    throw new Error("FATAL: Native binding 'scanCacheInvalidate' is required but not available.");
+  }
+  binding.scanCacheInvalidate(filePath);
+}
+function scanCacheStats() {
+  const binding = scannerGetBinding();
+  if (!binding.scanCacheStats) {
+    throw new Error("FATAL: Native binding 'scanCacheStats' is required but not available.");
+  }
+  return binding.scanCacheStats();
+}
+function scanFileNative2(filePath) {
+  const binding = scannerGetBinding();
+  if (!binding.scanFile) {
+    throw new Error("FATAL: Native binding 'scanFile' is required but not available.");
+  }
+  return binding.scanFile(filePath);
+}
+function collectFilesNative(root, extensions, ignoreDirs) {
+  const binding = scannerGetBinding();
+  if (!binding.collectFiles) return null;
+  return binding.collectFiles(root, extensions, ignoreDirs);
+}
+function scanFilesBatchNative2(filePaths) {
+  const binding = scannerGetBinding();
+  if (!binding.scanFilesBatch) {
+    return filePaths.map((fp) => {
+      try {
+        const r = binding.scanFile?.(fp);
+        return r ? { file: r.file, classes: r.classes, hash: r.hash ?? "" } : { file: fp, classes: [], hash: "" };
+      } catch {
+        return { file: fp, classes: [], hash: "" };
+      }
+    });
+  }
+  return binding.scanFilesBatch(filePaths);
+}
+function generateSubComponentTypesNative(root, outputPath) {
+  const binding = scannerGetBinding();
+  if (!binding.generateSubComponentTypes) return null;
+  return binding.generateSubComponentTypes(root, outputPath ?? null);
+}
+function pruneStaleEntriesNative(entries, maxAgeMs, checkExists) {
+  const binding = scannerGetBinding();
+  if (!binding.pruneStaleEntries) return null;
+  return binding.pruneStaleEntries(
+    entries.map((e) => ({ file: e.file, lastSeenMs: e.lastSeenMs ?? 0 })),
+    maxAgeMs ?? null,
+    checkExists ?? null
+  );
+}
+function rebuildWorkspaceResultNative(files) {
+  const binding = scannerBridgeLoader.get();
+  if (!binding?.rebuildWorkspaceResult) return null;
+  try {
+    return binding.rebuildWorkspaceResult(files);
+  } catch {
+    return null;
+  }
+}
+function computeCacheStatsNative(filesClasses, sizes, top) {
+  const binding = scannerGetBinding();
+  if (!binding.computeCacheStats) return null;
+  return binding.computeCacheStats(filesClasses, sizes, top ?? null);
+}
+function startWatchNative(rootDir) {
+  try {
+    const binding = scannerGetBinding();
+    if (!binding.startWatch) return null;
+    return binding.startWatch(rootDir);
+  } catch {
+    return null;
+  }
+}
+function pollWatchEventsNative(handleId) {
+  try {
+    const binding = scannerGetBinding();
+    if (!binding.pollWatchEvents) return [];
+    return binding.pollWatchEvents(handleId);
+  } catch {
+    return [];
+  }
+}
+function stopWatchNative(handleId) {
+  try {
+    const binding = scannerGetBinding();
+    if (!binding.stopWatch) return false;
+    return binding.stopWatch(handleId);
+  } catch {
+    return false;
+  }
+}
+function hasNativeWatchBinding() {
+  try {
+    const binding = scannerGetBinding();
+    return !!(binding.startWatch && binding.pollWatchEvents && binding.stopWatch);
+  } catch {
+    return false;
+  }
+}
+var log2, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
+var init_native_bridge = __esm({
+  "packages/domain/scanner/src/native-bridge.ts"() {
+    init_src2();
+    log2 = createDebugLogger("scanner:native");
+    isValidScannerBinding = (module) => {
+      const candidate = module;
+      return !!(candidate && (candidate.scanWorkspace || candidate.extractClassesFromSource || candidate.hashFileContent || candidate.cacheRead || candidate.cacheWrite));
+    };
+    createScannerBridgeLoader = () => {
+      const _state = {
+        binding: void 0,
+        loadError: null,
+        candidatePaths: []
       };
-    };
-    injectClientDirective = (source) => {
-      if (!source.includes('"use client"') && !source.includes("'use client'")) {
-        return '"use client";\n' + source;
-      }
-      return source;
-    };
-    injectServerOnlyComment = (source) => {
-      return `/* @server-only */
-${source}`;
-    };
-    analyzeClasses = (filesJson, cwd, flags) => {
-      const native = getNativeBridge();
-      if (!native?.analyzeClasses) {
-        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
-      }
-      return native.analyzeClasses(filesJson, cwd, flags);
-    };
-    generateSafelist = (scanDirs, outputPath, cwd) => {
-      const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
-      const allClasses = Object.keys(classes).sort();
-      if (outputPath) {
-        const fs6 = __require("fs");
-        fs6.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
-      }
-      return allClasses;
-    };
-    loadSafelist = (safelistPath) => {
-      const fs6 = __require("fs");
-      try {
-        const content = fs6.readFileSync(safelistPath, "utf-8");
-        return JSON.parse(content);
-      } catch {
-        return [];
-      }
-    };
-    loadTailwindConfig = (cwd = process.cwd()) => {
-      const fs6 = __require("fs");
-      const path7 = __require("path");
-      const configFiles = [
-        "tailwind.config.ts",
-        "tailwind.config.js",
-        "tailwind.config.mjs",
-        "tailwind.config.cjs"
-      ];
-      for (const file of configFiles) {
-        const fullPath = path7.join(cwd, file);
-        if (fs6.existsSync(fullPath)) {
-          const mod = __require(fullPath);
-          return mod.default || mod;
+      const throwNativeBindingError = () => {
+        const lines = [
+          "FATAL: Native scanner binding not found.",
+          "",
+          "This package requires the Rust native binding 'tailwind_styled_parser.node'.",
+          "The binding was not found in any of these paths:",
+          ..._state.candidatePaths.map((p) => `  - ${p}`),
+          ""
+        ];
+        if (_state.loadError) {
+          lines.push("Load error:", `  ${_state.loadError}`, "");
         }
-      }
-      return {};
-    };
-    getContentPaths = (cwd = process.cwd()) => {
-      const path7 = __require("path");
-      return {
-        content: [
-          path7.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
-          path7.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
-          path7.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
-        ]
+        lines.push(
+          "To fix this, run:",
+          "  npm run build:rust",
+          "",
+          "This will build the native Rust module from the 'native/' directory.",
+          "If you're using this package in a CI/CD environment, ensure Rust toolchain is installed",
+          "and 'npm run build:rust' is executed before running tests or building."
+        );
+        throw new TwError("rust", "SCANNER_NATIVE_BINDING_NOT_FOUND", lines.join("\n"));
       };
-    };
-    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 || []
+      const scannerGetBinding2 = () => {
+        const cachedBinding = _state.binding;
+        if (cachedBinding !== void 0) {
+          if (cachedBinding !== null) {
+            return cachedBinding;
+          }
+          return throwNativeBindingError();
+        }
+        const runtimeDir = getDirname();
+        const candidates = resolveNativeBindingCandidates({
+          runtimeDir,
+          includeDefaultCandidates: true
+        });
+        _state.candidatePaths = candidates;
+        const { binding, loadErrors } = loadNativeBinding({
+          runtimeDir,
+          candidates,
+          isValid: isValidScannerBinding,
+          invalidExportMessage: "Module loaded but missing expected scanner binding functions"
+        });
+        if (binding) {
+          log2(`scanner native binding loaded successfully`);
+          _state.binding = binding;
+          return _state.binding;
+        }
+        if (loadErrors.length > 0) {
+          _state.loadError = loadErrors.map((e) => `${e.path}: ${e.message}`).join("; ");
+        }
+        _state.binding = null;
+        return throwNativeBindingError();
       };
-    };
-    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) => {
-      return /* @__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) => []
+        get: scannerGetBinding2,
+        scannerGetBinding: scannerGetBinding2,
+        reset: () => {
+          _state.binding = void 0;
+          _state.loadError = null;
+          _state.candidatePaths = [];
+        }
       };
     };
-    resetBucketEngine = () => {
-    };
-    BucketEngine = class {
-      add(className) {
-        return className;
-      }
-    };
-    classifyNode = (_node) => {
-      const native = getNativeBridge();
-      if (!native?.classifyAndSortClasses) {
-        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
-      }
-      return "unknown";
-    };
-    detectConflicts = (classes) => {
-      const native = getNativeBridge();
-      if (!native?.analyzeClassUsage) {
-        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
-      }
-      return [];
-    };
-    bucketSort = (classes) => {
-      return classifyAndSortClasses(classes).map((c) => c.raw ?? c);
-    };
+    scannerBridgeLoader = createScannerBridgeLoader();
+    scannerGetBinding = scannerBridgeLoader.get;
+    resetScannerBridgeCache = scannerBridgeLoader.reset;
   }
 });
 var formatIssues = (error) => error.issues.map((issue) => {
@@ -1399,20 +3348,20 @@ var NextAdapterOptionsSchema = z.object({
 var parseNextAdapterOptions = (options) => parseWithSchema(NextAdapterOptionsSchema, options ?? {}, "next adapter options are invalid");
 
 // packages/presentation/next/src/withTailwindStyled.ts
-init_src();
+init_src2();
 
 // packages/domain/scanner/src/index.ts
-init_src();
+init_src2();
 
 // packages/domain/scanner/src/cache-native.ts
 init_native_bridge();
 function defaultCachePath(rootDir, cacheDir) {
-  const dir = cacheDir ? path5__default.resolve(rootDir, cacheDir) : path5__default.join(process.cwd(), ".cache", "tailwind-styled");
-  return path5__default.join(dir, "scanner-cache.json");
+  const dir = cacheDir ? path10__default.resolve(rootDir, cacheDir) : path10__default.join(process.cwd(), ".cache", "tailwind-styled");
+  return path10__default.join(dir, "scanner-cache.json");
 }
 function readCache(rootDir, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs5__default.mkdirSync(path5__default.dirname(cachePath), { recursive: true });
+  fs9__default.mkdirSync(path10__default.dirname(cachePath), { recursive: true });
   const result = cacheReadNative(cachePath);
   if (!result) return [];
   return result.entries.map((e) => ({
@@ -1427,7 +3376,7 @@ function readCache(rootDir, cacheDir) {
 }
 function writeCache(rootDir, entries, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs5__default.mkdirSync(path5__default.dirname(cachePath), { recursive: true });
+  fs9__default.mkdirSync(path10__default.dirname(cachePath), { recursive: true });
   const success = cacheWriteNative(cachePath, entries);
   if (!success) {
     throw new Error(
@@ -1451,13 +3400,13 @@ function filePriority(mtimeMs, size, cached, nowMs = Date.now()) {
 init_native_bridge();
 
 // packages/domain/scanner/src/schemas.ts
-init_src();
-var formatIssuePath2 = (path7) => path7.length > 0 ? path7.map(
+init_src2();
+var formatIssuePath2 = (path11) => path11.length > 0 ? path11.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var formatIssues2 = (error) => error.issues.map((issue) => {
-  const path7 = formatIssuePath2(issue.path);
-  return `${path7}: ${issue.message}`;
+  const path11 = formatIssuePath2(issue.path);
+  return `${path11}: ${issue.message}`;
 }).join("; ");
 var parseWithSchema2 = (schema, data, label) => {
   const parsed = schema.safeParse(data);
@@ -1511,13 +3460,13 @@ var parseScanWorkspaceOptions = (options) => parseWithSchema2(ScanWorkspaceOptio
 var parseScanWorkspaceResult = (result) => parseWithSchema2(ScanWorkspaceResultSchema, result, "scanner workspace result is invalid");
 
 // packages/domain/scanner/src/index.ts
-var log2 = createLogger("scanner");
+var log3 = createLogger2("scanner");
 function getRuntimeDir() {
   if (typeof __dirname !== "undefined" && __dirname.length > 0) {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path5__default.dirname(fileURLToPath(import.meta.url));
+    return path10__default.dirname(fileURLToPath(import.meta.url));
   }
   return process.cwd();
 }
@@ -1527,12 +3476,12 @@ var createNativeParserLoader = () => {
     initError: null
   };
   const debugNative = (message) => {
-    log2.debug(`[native] ${message}`);
+    log3.debug(`[native] ${message}`);
   };
   const loadNativeParserBinding = () => {
     if (_state.binding !== void 0) return _state.binding;
     const runtimeDir = getRuntimeDir();
-    const req = createRequire(path5__default.join(runtimeDir, "noop.cjs"));
+    const req = createRequire(path10__default.join(runtimeDir, "noop.cjs"));
     const _platform = process.platform;
     const _arch = process.arch;
     const _platformArch = `${_platform}-${_arch}`;
@@ -1540,27 +3489,27 @@ var createNativeParserLoader = () => {
     const candidates = [
       // ── binaryName baru: tailwind-styled-native (napi-rs naming) ──
       // cwd = repo root saat run dari root, atau package dir saat workspaces
-      path5__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
-      path5__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
-      path5__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path10__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+      path10__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
+      path10__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/
-      path5__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
-      path5__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
-      path5__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path10__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+      path10__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
+      path10__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // runtimeDir = dist/ → naik 4 level ke repo root (monorepo dev case)
-      path5__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
-      path5__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path10__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+      path10__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // 3 level fallback (jika package di-nest lebih dangkal)
-      path5__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
-      path5__default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+      path10__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+      path10__default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
       // ── binaryName lama: tailwind_styled_parser (backward compat) ──
-      path5__default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
-      path5__default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
-      path5__default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
-      path5__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
-      path5__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
-      path5__default.resolve(
+      path10__default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+      path10__default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
+      path10__default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
+      path10__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      path10__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
+      path10__default.resolve(
         runtimeDir,
         "..",
         "..",
@@ -1572,7 +3521,7 @@ var createNativeParserLoader = () => {
       )
     ];
     for (const fullPath of candidates) {
-      if (!fs5__default.existsSync(fullPath)) continue;
+      if (!fs9__default.existsSync(fullPath)) continue;
       try {
         const required = req(fullPath);
         if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
@@ -1613,19 +3562,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs5__default.readdirSync(currentDir, { withFileTypes: true });
+        return fs9__default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
     })();
     for (const entry of entries) {
-      const fullPath = path5__default.join(currentDir, entry.name);
+      const fullPath = path10__default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      if (!extensionSet.has(path5__default.extname(entry.name))) continue;
+      if (!extensionSet.has(path10__default.extname(entry.name))) continue;
       candidates.push(fullPath);
     }
   }
@@ -1651,9 +3600,9 @@ 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 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"}`);
   }
@@ -1663,7 +3612,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);
@@ -1697,7 +3646,7 @@ function scanWorkspace(rootDir, options = {}) {
       try {
         return readCache(rootDir, normalizedOptions.cacheDir);
       } catch (error) {
-        log2.debug(
+        log3.debug(
           `cache read failed, continuing without persisted cache: ${error instanceof Error ? error.message : String(error)}`
         );
         return [];
@@ -1709,7 +3658,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs5__default.statSync(filePath);
+          return fs9__default.statSync(filePath);
         } catch {
           return null;
         }
@@ -1735,7 +3684,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs5__default.readFileSync(filePath, "utf8");
+          return fs9__default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -1743,7 +3692,7 @@ function scanWorkspace(rootDir, options = {}) {
       if (!content) continue;
       const hash = hashContentNative(content);
       if (cached && cached.hash === hash && cached.mtimeMs === stat.mtimeMs && cached.size === size) {
-        log2.debug(`cache HIT ${filePath}`);
+        log3.debug(`cache HIT ${filePath}`);
         processResult({ file: filePath, classes: cached.classes });
         updatedEntries.push({
           file: filePath,
@@ -1755,7 +3704,7 @@ function scanWorkspace(rootDir, options = {}) {
         });
         continue;
       }
-      log2.debug(`cache MISS ${filePath}`);
+      log3.debug(`cache MISS ${filePath}`);
       const classes = scanSource(content);
       processResult({ file: filePath, classes });
       updatedEntries.push({
@@ -1770,7 +3719,7 @@ function scanWorkspace(rootDir, options = {}) {
     try {
       writeCache(rootDir, updatedEntries, normalizedOptions.cacheDir);
     } catch (error) {
-      log2.debug(`cache write failed: ${error instanceof Error ? error.message : String(error)}`);
+      log3.debug(`cache write failed: ${error instanceof Error ? error.message : String(error)}`);
     }
     return parseScanWorkspaceResult({
       files,
@@ -1786,7 +3735,7 @@ function scanWorkspace(rootDir, options = {}) {
     }
   } else {
     for (const filePath of candidates) {
-      processResult(scanFile(filePath));
+      processResult(scanFile2(filePath));
     }
   }
   return parseScanWorkspaceResult({
@@ -1796,6 +3745,60 @@ function scanWorkspace(rootDir, options = {}) {
   });
 }
 
+// packages/presentation/next/src/withTailwindStyled.ts
+init_src2();
+var _fileStaticCssMap = /* @__PURE__ */ new Map();
+function setFileStaticCss(filepath, css) {
+  if (css && css.trim()) {
+    _fileStaticCssMap.set(filepath, css.trim());
+  } else {
+    _fileStaticCssMap.delete(filepath);
+  }
+}
+function buildContent(map) {
+  const seen = /* @__PURE__ */ new Set();
+  const rules = [];
+  for (const css of map.values()) {
+    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");
+}
+var HEADER = `/* _tw-state-static.css \u2014 Auto-generated by tailwind-styled-v4. DO NOT EDIT.
+ * Import di globals.css: @import "./_tw-state-static.css";
+ * Berisi: state CSS (.tw-s-*[data-*="true"]) + container queries (@container .tw-cq-*).
+ * Di-rebuild penuh setiap webpack compilation selesai \u2014 tidak ada stale rules.
+ */
+
+`;
+var StaticCssWebpackPlugin = class _StaticCssWebpackPlugin {
+  static PLUGIN_NAME = "TailwindStyledStaticCss";
+  outPath;
+  constructor(safelistPath) {
+    this.outPath = path10__default.join(path10__default.dirname(safelistPath), "_tw-state-static.css");
+  }
+  apply(compiler) {
+    compiler.hooks.done.tap(_StaticCssWebpackPlugin.PLUGIN_NAME, () => {
+      try {
+        const content = buildContent(_fileStaticCssMap);
+        fs9__default.mkdirSync(path10__default.dirname(this.outPath), { recursive: true });
+        fs9__default.writeFileSync(
+          this.outPath,
+          HEADER + (content || "/* no static rules yet */") + "\n",
+          "utf-8"
+        );
+      } catch (e) {
+        console.warn("[tailwind-styled] Could not write _tw-state-static.css:", e);
+      }
+    });
+  }
+};
+
 // packages/presentation/next/src/withTailwindStyled.ts
 function getDirnameFromUrl2(importMetaUrl) {
   if (typeof importMetaUrl !== "string") return "";
@@ -1818,12 +3821,12 @@ var resolveLoaderPath2 = (basename) => {
   } catch {
     const runtimeDir = resolveRuntimeDir2();
     const candidates = [
-      path5__default.resolve(runtimeDir, `${basename}.mjs`),
-      path5__default.resolve(runtimeDir, `${basename}.js`),
-      path5__default.resolve(runtimeDir, `${basename}.cjs`)
+      path10__default.resolve(runtimeDir, `${basename}.mjs`),
+      path10__default.resolve(runtimeDir, `${basename}.js`),
+      path10__default.resolve(runtimeDir, `${basename}.cjs`)
     ];
     for (const candidate of candidates) {
-      if (fs5__default.existsSync(candidate)) {
+      if (fs9__default.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -1847,7 +3850,7 @@ function checkNextVersion() {
 }
 var DEFAULT_INCLUDE = /\.[jt]sx?$/;
 var DEFAULT_EXCLUDE = /node_modules/;
-var NEXT_RSC_ENTRIES = /(?:^|[\\/])(?:layout|page|loading|error|not-found|template|default)\.[jt]sx?$/;
+var NEXT_RSC_ENTRIES = /(?:^|[\\\/])(?:layout|page|loading|error|not-found|template|default)\.[jt]sx?$/;
 var buildExcludePattern = (userExclude) => {
   if (!userExclude) return new RegExp(`(?:${DEFAULT_EXCLUDE.source})|(?:${NEXT_RSC_ENTRIES.source})`);
   return new RegExp(`(?:${userExclude.source})|(?:${NEXT_RSC_ENTRIES.source})`);
@@ -1861,7 +3864,7 @@ var createLoaderOptions = (options) => {
     preserveImports: true
   };
   if (options.verbose !== void 0) opts.verbose = options.verbose;
-  opts.safelistPath = options.safelistPath ?? path5__default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
+  opts.safelistPath = options.safelistPath ?? path10__default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
   return Object.freeze(opts);
 };
 var buildTurbopackRules = (loaderPath, loaderOptions) => {
@@ -1874,7 +3877,7 @@ var buildTurbopackRules = (loaderPath, loaderOptions) => {
     ])
   );
 };
-var normalizeLoaderPath = (loaderPath) => path5__default.resolve(loaderPath);
+var normalizeLoaderPath = (loaderPath) => path10__default.resolve(loaderPath);
 var applyWebpackRule = (config, options, loaderPath) => {
   const loaderOptions = createLoaderOptions(options);
   const rules = config.module?.rules ?? [];
@@ -1887,16 +3890,20 @@ var applyWebpackRule = (config, options, loaderPath) => {
   if (alreadyRegistered) return config;
   const tailwindStyledRule = {
     test: options.include ?? DEFAULT_INCLUDE,
-    // Selalu kecualikan Next.js RSC entry files (layout, page, dll) bahkan jika
-    // user menyuplai exclude pattern sendiri — lihat buildExcludePattern.
     exclude: buildExcludePattern(options.exclude),
     enforce: "pre",
     use: [{ loader: loaderPath, options: loaderOptions }]
   };
+  const safelistPath = loaderOptions.safelistPath ?? path10__default.join(process.cwd(), ".next", "tailwind-styled-safelist.css");
+  const pluginAlreadyRegistered = (config.plugins ?? []).some(
+    (p) => p?.constructor?.name === StaticCssWebpackPlugin.PLUGIN_NAME
+  );
+  const plugins = pluginAlreadyRegistered ? config.plugins ?? [] : [...config.plugins ?? [], new StaticCssWebpackPlugin(safelistPath)];
   config.module = {
     ...config.module ?? {},
     rules: [...rules, tailwindStyledRule]
   };
+  config.plugins = plugins;
   const externalPackages = [
     "tailwind-styled-v4",
     "@tailwind-styled/shared",
@@ -1987,36 +3994,85 @@ function withTailwindStyled(options = {}) {
           return fullCss.slice(startIdx, endIdx + 1);
         };
         var extractUtilitiesLayer = extractUtilitiesLayer2;
-        const twClassesDir = path5__default.join(path5__default.dirname(safelistPath), "tw-classes");
-        fs5__default.mkdirSync(twClassesDir, { recursive: true });
-        fs5__default.writeFileSync(
-          path5__default.join(twClassesDir, "_start.txt"),
+        const twClassesDir = path10__default.join(path10__default.dirname(safelistPath), "tw-classes");
+        fs9__default.mkdirSync(twClassesDir, { recursive: true });
+        setGlobalLogFile(path10__default.join(twClassesDir, "_tw-build.log"));
+        fs9__default.writeFileSync(
+          path10__default.join(twClassesDir, "_start.txt"),
           String(Date.now()),
           "utf-8"
         );
+        const stateStaticPath = path10__default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+        if (!fs9__default.existsSync(stateStaticPath)) {
+          fs9__default.writeFileSync(
+            stateStaticPath,
+            "/* tw-state-static.css \u2014 placeholder, akan di-generate setelah scan */\n",
+            "utf-8"
+          );
+        }
+        try {
+          const CSS_CANDIDATES = [
+            "src/app/globals.css",
+            "src/globals.css",
+            "src/styles/globals.css",
+            "src/tailwind.css",
+            "src/index.css",
+            "styles/globals.css"
+          ];
+          const safelistDir = path10__default.dirname(safelistPath);
+          for (const candidate of CSS_CANDIDATES) {
+            const candidatePath = path10__default.join(process.cwd(), candidate);
+            if (!fs9__default.existsSync(candidatePath)) continue;
+            const content = fs9__default.readFileSync(candidatePath, "utf-8");
+            if (content.includes("_tw-state-static.css")) break;
+            const globalsDir = path10__default.dirname(candidatePath);
+            const rel = path10__default.relative(globalsDir, stateStaticPath).replace(/\\/g, "/");
+            const importLine = `@import "./${rel}";`;
+            const tailwindImportRe = /(@import\s+["']tailwindcss["']\s*;[^\n]*\n?)/;
+            let updated;
+            if (tailwindImportRe.test(content)) {
+              updated = content.replace(
+                tailwindImportRe,
+                `$1${importLine}
+`
+              );
+            } else {
+              updated = `${importLine}
+${content}`;
+            }
+            fs9__default.writeFileSync(candidatePath, updated, "utf-8");
+            if (options.verbose) {
+              console.log(
+                `[tailwind-styled] Auto-injected "${importLine}" into ${candidate}`
+              );
+            }
+            break;
+          }
+        } catch {
+        }
         if (!process.env.TW_NATIVE_PATH) {
           const runtimeDir = resolveRuntimeDir2();
-          const nativePath = path5__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node");
-          if (fs5__default.existsSync(nativePath)) {
+          const nativePath = path10__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node");
+          if (fs9__default.existsSync(nativePath)) {
             process.env.TW_NATIVE_PATH = nativePath;
           }
         }
-        const srcDir = path5__default.join(process.cwd(), "src");
-        if (fs5__default.existsSync(srcDir)) {
+        const srcDir = path10__default.join(process.cwd(), "src");
+        if (fs9__default.existsSync(srcDir)) {
           try {
-            const result = scanWorkspace(srcDir);
+            const result = scanWorkspace2(srcDir);
             if (result.uniqueClasses.length > 0) {
               let atomicWriteFile2 = function(filePath, content) {
                 const tmpPath = `${filePath}.tmp`;
                 try {
-                  fs5__default.writeFileSync(tmpPath, content, "utf-8");
-                  fs5__default.renameSync(tmpPath, filePath);
+                  fs9__default.writeFileSync(tmpPath, content, "utf-8");
+                  fs9__default.renameSync(tmpPath, filePath);
                 } catch {
                   try {
-                    fs5__default.unlinkSync(tmpPath);
+                    fs9__default.unlinkSync(tmpPath);
                   } catch {
                   }
-                  fs5__default.writeFileSync(filePath, content, "utf-8");
+                  fs9__default.writeFileSync(filePath, content, "utf-8");
                 }
               };
               var atomicWriteFile = atomicWriteFile2;
@@ -2079,14 +4135,14 @@ function withTailwindStyled(options = {}) {
                 "styles/globals.css"
               ];
               try {
-                const twConfigPath = path5__default.join(process.cwd(), "tailwind-styled.config.json");
-                if (fs5__default.existsSync(twConfigPath)) {
-                  const twConfig = JSON.parse(fs5__default.readFileSync(twConfigPath, "utf-8"));
+                const twConfigPath = path10__default.join(process.cwd(), "tailwind-styled.config.json");
+                if (fs9__default.existsSync(twConfigPath)) {
+                  const twConfig = JSON.parse(fs9__default.readFileSync(twConfigPath, "utf-8"));
                   const cssEntry = twConfig.css?.entry;
                   if (cssEntry) {
-                    const cssEntryPath = path5__default.join(process.cwd(), cssEntry);
-                    if (fs5__default.existsSync(cssEntryPath)) {
-                      cssEntryContent = fs5__default.readFileSync(cssEntryPath, "utf-8");
+                    const cssEntryPath = path10__default.join(process.cwd(), cssEntry);
+                    if (fs9__default.existsSync(cssEntryPath)) {
+                      cssEntryContent = fs9__default.readFileSync(cssEntryPath, "utf-8");
                     }
                   }
                 }
@@ -2094,9 +4150,9 @@ function withTailwindStyled(options = {}) {
               }
               if (!cssEntryContent) {
                 for (const candidate of CSS_CANDIDATES) {
-                  const candidatePath = path5__default.join(process.cwd(), candidate);
-                  if (fs5__default.existsSync(candidatePath)) {
-                    cssEntryContent = fs5__default.readFileSync(candidatePath, "utf-8");
+                  const candidatePath = path10__default.join(process.cwd(), candidate);
+                  if (fs9__default.existsSync(candidatePath)) {
+                    cssEntryContent = fs9__default.readFileSync(candidatePath, "utf-8");
                     break;
                   }
                 }
@@ -2104,8 +4160,8 @@ function withTailwindStyled(options = {}) {
               if (cssEntryContent) {
                 cssEntryContent = cssEntryContent.replace(/@source\s+["'][^"']+["']\s*;?\s*/g, "").replace(/←[^\n]*/g, "").trim();
               }
-              const initialScanPath = path5__default.join(twClassesDir, "_initial-scan.css");
-              if (!fs5__default.existsSync(initialScanPath)) {
+              const initialScanPath = path10__default.join(twClassesDir, "_initial-scan.css");
+              if (!fs9__default.existsSync(initialScanPath)) {
                 atomicWriteFile2(
                   initialScanPath,
                   "/* tw-classes: initial scan \u2014 generating... */\n@layer utilities {}\n"
@@ -2113,7 +4169,7 @@ function withTailwindStyled(options = {}) {
               }
               void (async () => {
                 try {
-                  const compiler = await Promise.resolve().then(() => (init_src2(), src_exports));
+                  const compiler = await Promise.resolve().then(() => (init_src(), src_exports));
                   const generateCssForClasses2 = compiler.generateCssForClasses;
                   const css = await generateCssForClasses2(
                     filteredClasses,
@@ -2130,25 +4186,36 @@ function withTailwindStyled(options = {}) {
                       `/* tw-classes: initial scan \u2014 auto-generated by withTailwindStyled */
 ${utilitiesOnly}`
                     );
+                    const summary = appendStaticStateCssToSafelist(srcDir, safelistPath, {
+                      verbose: options.verbose ?? false,
+                      resolvedCss: css
+                    });
+                    if (options.verbose) console.log(summary);
                   }
                 } catch (err) {
-                  console.warn("[tailwind-styled] generateCssForClasses gagal, fallback ke empty rules:", err.message?.split("\n")[0]);
-                  const css = [
-                    "/* tw-safelist: initial scan \u2014 auto-generated by withTailwindStyled (fallback) */",
-                    "@layer utilities {",
-                    filteredClasses.map((cls) => `.${cls.replace(/([^a-zA-Z0-9_-])/g, "\\$1")} {}`).join("\n"),
-                    "}"
-                  ].join("\n");
-                  atomicWriteFile2(initialScanPath, css);
+                  throw new Error(
+                    `[tailwind-styled] generateCssForClasses gagal \u2014 build-time CSS generation wajib berhasil.
+${err.message}`,
+                    { cause: err }
+                  );
                 }
               })();
             }
           } catch (e) {
-            console.warn("[tailwind-styled] Initial scan skipped:", e.message?.split("\n")[0]);
+            throw new Error(
+              `[tailwind-styled] Scanner gagal \u2014 Rust native binary tidak tersedia. Build tidak bisa dilanjutkan.
+${e.message}`,
+              { cause: e }
+            );
           }
         }
       }
-    } catch {
+    } catch (err) {
+      throw new Error(
+        `[tailwind-styled] Build-time CSS generation gagal.
+${err.message}`,
+        { cause: err }
+      );
     }
     return {
       ...nextConfig,
@@ -2215,6 +4282,6 @@ ${utilitiesOnly}`
   };
 }
 
-export { NextAdapterOptionsSchema, parseNextAdapterOptions, withTailwindStyled };
+export { NextAdapterOptionsSchema, StaticCssWebpackPlugin, parseNextAdapterOptions, setFileStaticCss, withTailwindStyled };
 //# sourceMappingURL=next.mjs.map
 //# sourceMappingURL=next.mjs.map