tailwind-styled-v4 5.0.11 → 5.0.12

package/dist/engine.mjs

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createRequire } from 'module';
-import * as fs5 from 'fs';
-import fs5__default from 'fs';
-import * as path6 from 'path';
-import path6__default from 'path';
+import * as fs3 from 'fs';
+import fs3__default from 'fs';
+import * as path9 from 'path';
+import path9__default from 'path';
 import { createHash } from 'crypto';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
@@ -220,9 +220,9 @@ function parseNative(schema, data, context) {
   const result = schema.safeParse(data);
   if (!result.success) {
     const first = result.error.issues[0];
-    const path13 = first?.path?.join(".") ?? "(root)";
+    const path16 = first?.path?.join(".") ?? "(root)";
     throw new Error(
-      `[${context}] Native binding returned unexpected data: ${path13}: ${first?.message ?? "validation failed"}`
+      `[${context}] Native binding returned unexpected data: ${path16}: ${first?.message ?? "validation failed"}`
     );
   }
   return result.data;
@@ -615,11 +615,11 @@ function resolvePath(...segments) {
     return segments.join("/").replace(/\/+/g, "/");
   }
 }
-function existsSync(path13) {
+function existsSync(path16) {
   if (isBrowser2) return false;
   try {
     const nodeFs = __require(NODE_FS);
-    return nodeFs.existsSync(path13);
+    return nodeFs.existsSync(path16);
   } catch {
     return false;
   }
@@ -849,12 +849,12 @@ function resolveNativeBinary(runtimeDir) {
   if (isBrowser3) {
     return { path: null, source: "not-found", platform, tried: ["not available in browser"] };
   }
-  if (process.env.TWS_DISABLE_NATIVE === "1") {
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_DISABLE_NATIVE === "1") {
     return { path: null, source: "not-found", platform, tried: [] };
   }
   const envPath = process.env.TW_NATIVE_PATH?.trim();
   if (envPath) {
-    if (fs5.existsSync(envPath)) {
+    if (fs3.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
@@ -863,7 +863,7 @@ function resolveNativeBinary(runtimeDir) {
   for (const pkg of prebuiltPkgs) {
     try {
       const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs5.existsSync(candidate)) {
+      if (fs3.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -874,13 +874,13 @@ function resolveNativeBinary(runtimeDir) {
   const napiPlatform = platform === "linux-x64" ? "linux-x64-gnu" : platform === "linux-arm64" ? "linux-arm64-gnu" : platform;
   const BINARY_NAMES_SELF = ["tailwind-styled-native", "tailwind_styled_parser"];
   if (runtimeDir) {
-    for (const depth of ["..", path6.join("..", ".."), path6.join("..", "..", "..")]) {
-      const pkgRoot = path6.resolve(runtimeDir, depth);
+    for (const depth of ["..", path9.join("..", ".."), path9.join("..", "..", "..")]) {
+      const pkgRoot = path9.resolve(runtimeDir, depth);
       for (const bin of BINARY_NAMES_SELF) {
         for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
-          const candidate = path6.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
+          const candidate = path9.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
           tried.push(`self-bundled:${candidate}`);
-          if (fs5.existsSync(candidate)) {
+          if (fs3.existsSync(candidate)) {
             return { path: candidate, source: "prebuilt", platform, tried };
           }
         }
@@ -892,29 +892,29 @@ function resolveNativeBinary(runtimeDir) {
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const localCandidates = [];
   for (const bin of BINARY_NAMES) {
-    localCandidates.push(path6.resolve(base, `${bin}.node`));
-    localCandidates.push(path6.resolve(base, "..", `${bin}.node`));
-    localCandidates.push(path6.resolve(base, `${bin}.${platform}.node`));
-    localCandidates.push(path6.resolve(base, `${bin}.${napiPlatform}.node`));
+    localCandidates.push(path9.resolve(base, `${bin}.node`));
+    localCandidates.push(path9.resolve(base, "..", `${bin}.node`));
+    localCandidates.push(path9.resolve(base, `${bin}.${platform}.node`));
+    localCandidates.push(path9.resolve(base, `${bin}.${napiPlatform}.node`));
   }
   for (const startDir of [cwd, base]) {
     let dir = startDir;
     for (let i = 0; i < 6; i++) {
-      const nativeDir = path6.resolve(dir, "native");
+      const nativeDir = path9.resolve(dir, "native");
       for (const bin of BINARY_NAMES) {
-        localCandidates.push(path6.resolve(nativeDir, `${bin}.node`));
-        localCandidates.push(path6.resolve(nativeDir, `${bin}.${platform}.node`));
-        localCandidates.push(path6.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
-        localCandidates.push(path6.resolve(nativeDir, "target", "release", `${bin}.node`));
+        localCandidates.push(path9.resolve(nativeDir, `${bin}.node`));
+        localCandidates.push(path9.resolve(nativeDir, `${bin}.${platform}.node`));
+        localCandidates.push(path9.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
+        localCandidates.push(path9.resolve(nativeDir, "target", "release", `${bin}.node`));
       }
-      const parent = path6.resolve(dir, "..");
+      const parent = path9.resolve(dir, "..");
       if (parent === dir) break;
       dir = parent;
     }
   }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs5.existsSync(candidate)) {
+    if (fs3.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
@@ -953,9 +953,9 @@ var init_native_resolution = __esm({
 // packages/domain/shared/src/observability.ts
 function createObservabilityClient(opts = {}) {
   const { baseUrl = "http://localhost:7421", timeoutMs = 3e3 } = opts;
-  async function fetchJson(path13) {
+  async function fetchJson(path16) {
     try {
-      const res = await fetch(`${baseUrl}${path13}`, {
+      const res = await fetch(`${baseUrl}${path16}`, {
         signal: AbortSignal.timeout(timeoutMs)
       });
       if (!res.ok) return null;
@@ -987,6 +987,1182 @@ var init_observability = __esm({
   }
 });
 
+// packages/domain/compiler/src/nativeBridge.ts
+var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge, adaptNativeResult;
+var init_nativeBridge = __esm({
+  "packages/domain/compiler/src/nativeBridge.ts"() {
+    init_src2();
+    _loadNative = (path16) => __require(path16);
+    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;
+      }
+    };
+    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 _evictOldestIfNeeded() {
+  if (_cssCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = _cssCache.keys().next().value;
+    if (firstKey !== void 0) {
+      _cssCache.delete(firstKey);
+    }
+  }
+}
+function getCacheStats() {
+  const total = _cacheHits + _cacheMisses;
+  return {
+    hits: _cacheHits,
+    misses: _cacheMisses,
+    hitRate: total > 0 ? _cacheHits / total : 0,
+    size: _cssCache.size,
+    maxSize: MAX_CACHE_SIZE
+  };
+}
+function clearCache() {
+  _cssCache.clear();
+  _cacheHits = 0;
+  _cacheMisses = 0;
+}
+function loadTailwindEngine() {
+  if (_twEngine) return _twEngine;
+  if (_twEngineError) throw _twEngineError;
+  try {
+    const tw = require2("tailwindcss");
+    if (typeof tw.compile !== "function") {
+      throw new Error("tailwindcss v4 not found \u2014 compile() API missing. Check tailwindcss version >= 4.");
+    }
+    _twEngine = tw;
+    return _twEngine;
+  } catch (e) {
+    _twEngineError = e instanceof Error ? e : new Error(String(e));
+    throw _twEngineError;
+  }
+}
+async function generateRawCss(classes, cssEntryContent, root) {
+  if (classes.length === 0) return "";
+  const tw = loadTailwindEngine();
+  const input = cssEntryContent ?? "@import 'tailwindcss';";
+  const { readFileSync, existsSync: existsSync3 } = await import('fs');
+  const { dirname, resolve: resolve2 } = await import('path');
+  const projectRoot = root ?? process.cwd();
+  const req = createRequire(resolve2(projectRoot, "package.json"));
+  const loadStylesheet = async (id, base) => {
+    try {
+      const cssId = id === "tailwindcss" ? "tailwindcss/index.css" : id === "tailwindcss/preflight" ? "tailwindcss/preflight.css" : id === "tailwindcss/utilities" ? "tailwindcss/utilities.css" : id === "tailwindcss/theme" ? "tailwindcss/theme.css" : id;
+      const pkgPath = req.resolve(cssId);
+      return { content: readFileSync(pkgPath, "utf-8"), base: dirname(pkgPath) };
+    } catch {
+      try {
+        const absPath = resolve2(base, id);
+        if (existsSync3(absPath)) {
+          return { content: readFileSync(absPath, "utf-8"), base: dirname(absPath) };
+        }
+      } catch {
+      }
+      return { content: "", base };
+    }
+  };
+  const compiler = await Promise.resolve(tw.compile(input, { loadStylesheet }));
+  return compiler.build(classes);
+}
+function getThemeConfig() {
+  return {
+    colors: {
+      slate: {
+        "50": "#f8fafc",
+        "100": "#f1f5f9",
+        "200": "#e2e8f0",
+        "300": "#cbd5e1",
+        "400": "#94a3b8",
+        "500": "#64748b",
+        "600": "#475569",
+        "700": "#334155",
+        "800": "#1e293b",
+        "900": "#0f172a"
+      },
+      gray: {
+        "50": "#f9fafb",
+        "100": "#f3f4f6",
+        "200": "#e5e7eb",
+        "300": "#d1d5db",
+        "400": "#9ca3af",
+        "500": "#6b7280",
+        "600": "#4b5563",
+        "700": "#374151",
+        "800": "#1f2937",
+        "900": "#111827"
+      },
+      white: "#ffffff",
+      black: "#000000",
+      red: {
+        "500": "#ef4444",
+        "600": "#dc2626"
+      },
+      blue: {
+        "500": "#3b82f6",
+        "600": "#1e40af"
+      }
+    },
+    spacing: {
+      "0": "0px",
+      "1": "0.25rem",
+      "2": "0.5rem",
+      "3": "0.75rem",
+      "4": "1rem",
+      "5": "1.25rem",
+      "6": "1.5rem",
+      "8": "2rem",
+      "10": "2.5rem",
+      "12": "3rem",
+      "16": "4rem",
+      "20": "5rem",
+      "24": "6rem"
+    },
+    breakpoints: {
+      "sm": "640px",
+      "md": "768px",
+      "lg": "1024px",
+      "xl": "1280px",
+      "2xl": "1536px"
+    }
+  };
+}
+function postProcessWithLightning(rawCss) {
+  if (!rawCss) return "";
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssLightning) {
+    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
+  }
+  const result = native.processTailwindCssLightning(rawCss);
+  if (!result?.css) {
+    throw new Error("FATAL: processTailwindCssLightning returned null");
+  }
+  return result.css;
+}
+async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
+  const filtered = classes.filter(Boolean);
+  const uniqueMap = /* @__PURE__ */ new Map();
+  filtered.forEach((cls) => uniqueMap.set(cls, cls));
+  const unique = Array.from(uniqueMap.values());
+  if (unique.length === 0) {
+    return { css: "", classes: [], sizeBytes: 0, optimized: false };
+  }
+  const cacheKey = _getCacheKey(unique, minify, cssEntryContent, root);
+  const cached = _cssCache.get(cacheKey);
+  if (cached) {
+    _cacheHits++;
+    if (process.env.DEBUG?.includes("compiler")) {
+      console.log(
+        `[Compiler] Cache HIT: ${unique.length} classes (hit rate: ${(getCacheStats().hitRate * 100).toFixed(1)}%)`
+      );
+    }
+    return cached;
+  }
+  _cacheMisses++;
+  let rawCss;
+  let usedRustCompiler = false;
+  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 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 {
+    theme,
+    fallbackToJs = true,
+    logFallback = false
+  } = options;
+  try {
+    const native = getNativeBridge();
+    if (!native?.generateCssNative) {
+      throw new Error("generateCssNative not available in native binding");
+    }
+    const themeJson = JSON.stringify(theme);
+    const css = native.generateCssNative(classes, themeJson);
+    return css;
+  } catch (error) {
+    if (!fallbackToJs) {
+      throw error;
+    }
+    if (logFallback) {
+      console.warn(
+        "[CSS Compiler] Rust CSS generator unavailable, falling back to JavaScript Tailwind",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    return generateRawCss(classes);
+  }
+}
+var init_cssGeneratorNative = __esm({
+  "packages/domain/compiler/src/cssGeneratorNative.ts"() {
+    init_nativeBridge();
+    init_tailwindEngine();
+  }
+});
+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, classifyNode, detectConflicts, bucketSort, extractTwStateConfigs, generateStaticStateCss, extractAndGenerateStateCss;
+var init_src = __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;
+    };
+    hasTwUsage = (source) => {
+      const native = getNativeBridge();
+      if (!native?.hasTwUsage) {
+        throw new Error("FATAL: Native binding 'hasTwUsage' is required but not available.");
+      }
+      return native.hasTwUsage(source);
+    };
+    isAlreadyTransformed = (source) => {
+      const native = getNativeBridge();
+      if (!native?.isAlreadyTransformed) {
+        throw new Error("FATAL: Native binding 'isAlreadyTransformed' is required but not available.");
+      }
+      return native.isAlreadyTransformed(source);
+    };
+    shouldProcess = (source) => {
+      return hasTwUsage(source) && !isAlreadyTransformed(source);
+    };
+    compileCssFromClasses = (classes, prefix) => {
+      const native = getNativeBridge();
+      if (!native?.transformSource) {
+        throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+      }
+      const result = native.transformSource(classes.join(" "), { prefix: prefix ?? "" });
+      if (!result) {
+        throw new Error("FATAL: transformSource returned null");
+      }
+      return result;
+    };
+    buildStyleTag = (classes) => {
+      const result = compileCssFromClasses(classes);
+      return result?.code ? `<style data-tailwind-styled>${result.code}</style>` : "";
+    };
+    compileCssNative = (classes, prefix = null) => {
+      return compileCssFromClasses(classes, prefix);
+    };
+    generateCssForClasses = async (classes, _tailwindConfig, root, cssEntryContent, minify = false) => {
+      const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
+      const result = await runCssPipeline2(classes, cssEntryContent, root, minify);
+      return result.css;
+    };
+    extractAllClasses = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractAllClasses) {
+        throw new Error("FATAL: Native binding 'extractAllClasses' is required but not available.");
+      }
+      return native.extractAllClasses(source) || [];
+    };
+    extractClassesFromSource = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractClassesFromSource) {
+        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
+      }
+      const result = native.extractClassesFromSource(source);
+      return Array.isArray(result) ? result.join(" ") : String(result || "");
+    };
+    astExtractClasses = (source, _filename) => {
+      const native = getNativeBridge();
+      if (!native?.extractClassesFromSource) {
+        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
+      }
+      return native.extractClassesFromSource(source) || [];
+    };
+    parseClasses = (raw) => {
+      const native = getNativeBridge();
+      if (!native?.parseClasses) {
+        throw new Error("FATAL: Native binding 'parseClasses' is required but not available.");
+      }
+      return native.parseClasses(raw) || [];
+    };
+    normalizeClasses = (raw) => {
+      const result = normalizeAndDedupClasses(raw);
+      return result?.normalized || "";
+    };
+    mergeClassesStatic = (classes) => {
+      const result = normalizeAndDedupClasses(classes);
+      return result?.normalized || "";
+    };
+    normalizeAndDedupClasses = (raw) => {
+      const native = getNativeBridge();
+      if (!native?.normalizeAndDedupClasses) {
+        throw new Error("FATAL: Native binding 'normalizeAndDedupClasses' is required but not available.");
+      }
+      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) => path9__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);
+      return {
+        isServer: rsc?.isServer ?? true,
+        needsClientDirective: rsc?.needsClientDirective ?? false,
+        clientReasons: rsc?.clientReasons ?? [],
+        interactiveClasses: [],
+        canStaticResolveVariants: true
+      };
+    };
+    analyzeVariantUsage = (_source, _componentName, _variantKeys) => {
+      return { resolved: {}, dynamic: [] };
+    };
+    injectClientDirective = (source) => {
+      if (!source.includes('"use client"') && !source.includes("'use client'")) {
+        return '"use client";\n' + source;
+      }
+      return source;
+    };
+    injectServerOnlyComment = (source) => {
+      return `/* @server-only */
+${source}`;
+    };
+    analyzeClasses = (filesJson, cwd, flags) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return native.analyzeClasses(filesJson, cwd, flags);
+    };
+    generateSafelist = (scanDirs, outputPath, cwd) => {
+      const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
+      const allClasses = Object.keys(classes).sort();
+      if (outputPath) {
+        fs3__default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+      }
+      return allClasses;
+    };
+    loadSafelist = (safelistPath) => {
+      try {
+        const content = fs3__default.readFileSync(safelistPath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return [];
+      }
+    };
+    loadTailwindConfig = (cwd = process.cwd()) => {
+      const configFiles = [
+        "tailwind.config.ts",
+        "tailwind.config.js",
+        "tailwind.config.mjs",
+        "tailwind.config.cjs"
+      ];
+      for (const file of configFiles) {
+        const fullPath = path9__default.join(cwd, file);
+        if (fs3__default.existsSync(fullPath)) {
+          const mod = __require(fullPath);
+          return mod.default || mod;
+        }
+      }
+      return {};
+    };
+    getContentPaths = (cwd = process.cwd()) => {
+      return {
+        content: [
+          path9__default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          path9__default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          path9__default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
+        ]
+      };
+    };
+    _CONTAINER_BREAKPOINTS = {
+      xs: "240px",
+      sm: "320px",
+      md: "640px",
+      lg: "1024px",
+      xl: "1280px",
+      "2xl": "1536px"
+    };
+    runLoaderTransform = (ctx) => {
+      const { filepath, source, options } = ctx;
+      const result = transformSource(source, { filename: filepath, ...options });
+      let staticCss;
+      try {
+        const cssChunks = [];
+        const stateRules = extractAndGenerateStateCss(source, filepath);
+        if (stateRules.length > 0) {
+          cssChunks.push(stateRules.map((r) => r.cssRule).join("\n"));
+        }
+        const containerCss = extractContainerCssFromSource(source);
+        if (containerCss) cssChunks.push(containerCss);
+        const combined = cssChunks.join("\n").trim();
+        if (combined) staticCss = combined;
+      } catch {
+      }
+      return {
+        code: result?.code || "",
+        changed: result?.changed || false,
+        classes: result?.classes || [],
+        staticCss
+      };
+    };
+    shouldSkipFile = (filepath) => {
+      const SKIP_PATHS = ["node_modules", ".next", ".rspack-dist", ".turbo", "dist/", "out/"];
+      const skipExtensions = [".css", ".json", ".md", ".txt", ".yaml", ".yml"];
+      for (const p of SKIP_PATHS) {
+        if (filepath.includes(p)) return true;
+      }
+      for (const ext of skipExtensions) {
+        if (filepath.endsWith(ext)) return true;
+      }
+      return false;
+    };
+    fileToRoute = (filepath) => {
+      const normalized = filepath.replace(/\\/g, "/");
+      if (normalized.includes("/layout.") || normalized.includes("/loading.") || normalized.includes("/error.")) {
+        return "__global";
+      }
+      const pageMatch = normalized.match(/\/app\/(.+?)\/page\.[tj]sx?$/);
+      if (pageMatch) return `/${pageMatch[1]}`;
+      const rootPage = normalized.match(/\/app\/page\.[tj]sx?$/);
+      if (rootPage) return "/";
+      return null;
+    };
+    getAllRoutes = () => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return ["/", "__global"];
+    };
+    getRouteClasses = (_route) => /* @__PURE__ */ new Set();
+    registerFileClasses = (_filepath, _classes) => {
+    };
+    registerGlobalClasses = (_classes) => {
+    };
+    _incrementalEngineInstance = null;
+    getIncrementalEngine = () => {
+      if (!_incrementalEngineInstance) {
+        _incrementalEngineInstance = new IncrementalEngine();
+      }
+      return _incrementalEngineInstance;
+    };
+    resetIncrementalEngine = () => {
+      _incrementalEngineInstance = null;
+    };
+    IncrementalEngine = class {
+      compile(source) {
+        return transformSource(source);
+      }
+    };
+    getBucketEngine = () => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return {
+        add: (className) => className,
+        get: (_bucket) => []
+      };
+    };
+    resetBucketEngine = () => {
+    };
+    classifyNode = (_node) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return "unknown";
+    };
+    detectConflicts = (_classes) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClassUsage) {
+        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+      }
+      return [];
+    };
+    bucketSort = (classes) => {
+      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 = fs3__default.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path9__default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (IGNORE_PATTERNS.some((p) => entry.name === p || entry.name.startsWith(p))) continue;
+      yield* walkSourceFiles(fullPath);
+    } else if (entry.isFile()) {
+      const ext = path9__default.extname(entry.name);
+      if (SOURCE_EXTENSIONS.has(ext)) yield fullPath;
+    }
+  }
+}
+function buildCssHeader(result) {
+  return [
+    "/* \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    " * tw-state-static.css \u2014 Auto-generated by staticStateExtractor.ts",
+    " * DO NOT EDIT. Re-generated on each build.",
+    " *",
+    ` * Files scanned:      ${result.filesScanned}`,
+    ` * Files with states:  ${result.filesWithStates}`,
+    ` * Components found:   ${result.componentsFound}`,
+    ` * Rules generated:    ${result.rulesGenerated}`,
+    ` * Rules skipped:      ${result.rulesSkipped} (akan di-inject runtime sebagai fallback)`,
+    " *",
+    ' * Selector format: .tw-s-[hash][data-stateName="true"] { ... }',
+    " * Hash identik dengan yang dibuat oleh stateEngine.ts di runtime.",
+    " * \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */",
+    ""
+  ].join("\n");
+}
+function extractStaticStateCss(srcDir, options = {}) {
+  const { verbose = false, maxFiles = Infinity } = options;
+  const native = getNative();
+  if (!native) {
+    if (verbose) {
+      process.stderr.write(
+        "[tw:static-state] native module tidak tersedia \u2014 skip static CSS pre-generation\n"
+      );
+    }
+    return {
+      filesScanned: 0,
+      filesWithStates: 0,
+      componentsFound: 0,
+      rulesGenerated: 0,
+      rulesSkipped: 0,
+      generatedCss: "",
+      rules: []
+    };
+  }
+  const allConfigs = [];
+  let filesScanned = 0;
+  let filesWithStates = 0;
+  if (native.walkAndPrefilterSourceFiles) {
+    const prefiltered = native.walkAndPrefilterSourceFiles(
+      srcDir,
+      [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"],
+      ["node_modules", ".next", "dist", "build", ".git", "coverage", "__tests__"],
+      // Required substrings — AND logic, identik dengan JS pre-filter di bawah
+      ["states:", "tw."],
+      maxFiles === Infinity ? null : maxFiles,
+      null
+      // sequential — parallel mode opsional untuk large monorepo
+    );
+    for (const { path: filePath, content: source } of prefiltered) {
+      filesScanned++;
+      const configs = native.extractTwStateConfigs(source, filePath);
+      if (configs.length > 0) {
+        filesWithStates++;
+        allConfigs.push(...configs);
+        if (verbose) {
+          process.stderr.write(
+            `[tw:static-state] ${path9__default.relative(srcDir, filePath)}: ${configs.length} komponen
+`
+          );
+        }
+      }
+    }
+  } else {
+    for (const filePath of walkSourceFiles(srcDir)) {
+      if (filesScanned >= maxFiles) break;
+      let source;
+      try {
+        source = fs3__default.readFileSync(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      filesScanned++;
+      if (!source.includes("states:") && !source.includes("states :")) continue;
+      if (!source.includes("tw.") && !source.includes("tailwind-styled")) continue;
+      const configs = native.extractTwStateConfigs(source, filePath);
+      if (configs.length > 0) {
+        filesWithStates++;
+        allConfigs.push(...configs);
+        if (verbose) {
+          process.stderr.write(
+            `[tw:static-state] ${path9__default.relative(srcDir, filePath)}: ${configs.length} komponen
+`
+          );
+        }
+      }
+    }
+  }
+  if (allConfigs.length === 0) {
+    return {
+      filesScanned,
+      filesWithStates: 0,
+      componentsFound: 0,
+      rulesGenerated: 0,
+      rulesSkipped: 0,
+      generatedCss: "",
+      rules: []
+    };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueConfigs = [];
+  for (const config of allConfigs) {
+    const key = `${config.tag}::${config.statesJson}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueConfigs.push({
+        tag: config.tag,
+        componentName: config.componentName,
+        statesJson: config.statesJson
+      });
+    }
+  }
+  const allRules = native.generateStaticStateCss(uniqueConfigs, options.resolvedCss ?? null);
+  const rulesSkipped = uniqueConfigs.reduce((total, cfg) => {
+    try {
+      const stateMap = JSON.parse(cfg.statesJson);
+      return total + Object.keys(stateMap).length;
+    } catch {
+      return total;
+    }
+  }, 0) - allRules.length;
+  const byComponent = /* @__PURE__ */ new Map();
+  for (const rule of allRules) {
+    const existing = byComponent.get(rule.componentName) ?? [];
+    existing.push(rule);
+    byComponent.set(rule.componentName, existing);
+  }
+  const cssBlocks = [];
+  for (const [componentName, rules] of byComponent) {
+    cssBlocks.push(`/* ${componentName} */`);
+    for (const rule of rules) {
+      cssBlocks.push(`/* state: ${rule.stateName} */`);
+      cssBlocks.push(rule.cssRule);
+    }
+    cssBlocks.push("");
+  }
+  const result = {
+    filesScanned,
+    filesWithStates,
+    componentsFound: allConfigs.length,
+    rulesGenerated: allRules.length,
+    rulesSkipped: Math.max(0, rulesSkipped),
+    generatedCss: cssBlocks.join("\n"),
+    rules: allRules
+  };
+  result.generatedCss = buildCssHeader(result) + result.generatedCss;
+  return result;
+}
+function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
+  const result = extractStaticStateCss(srcDir, options);
+  const twClassesDir = path9__default.join(path9__default.dirname(safelistPath), "tw-classes");
+  fs3__default.mkdirSync(twClassesDir, { recursive: true });
+  const stateFilePath = path9__default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+  if (result.rulesGenerated === 0) {
+    try {
+      fs3__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 {
+    fs3__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 {
+    fs3__default.mkdirSync(path9__default.dirname(filePath), { recursive: true });
+    fs3__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 {
+    fs3__default.appendFileSync(_globalLogFile, line);
+  } catch {
+  }
+}
+function createLogger(prefix, level) {
+  const loggerState = {
+    currentLevel: getEnvLevel(),
+    setLevel(l) {
+      this.currentLevel = l;
+    }
+  };
+  const log8 = (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) => log8("error", "stderr", a),
+    warn: (...a) => log8("warn", "stderr", a),
+    info: (...a) => log8("info", "stdout", a),
+    debug: (...a) => log8("debug", "stderr", a),
+    setLevel: loggerState.setLevel,
+    setLogFile: (filePath) => setGlobalLogFile(filePath)
+  };
+}
+var LEVELS, _globalLogFile, _logFileInitialized;
+var init_logger = __esm({
+  "packages/domain/shared/src/logger.ts"() {
+    LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
+    _globalLogFile = null;
+    _logFileInitialized = false;
+    createLogger("tailwind-styled");
+  }
+});
+
 // packages/domain/shared/src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -1005,18 +2181,21 @@ __export(src_exports, {
   RegistryPluginEntrySchema: () => RegistryPluginEntrySchema,
   ScanCacheClassEntrySchema: () => ScanCacheClassEntrySchema,
   ScanCacheSchema: () => ScanCacheSchema,
+  TW_STATE_STATIC_FILENAME: () => TW_STATE_STATIC_FILENAME,
   TailwindConfigSchema: () => TailwindConfigSchema,
   TelemetryCollector: () => TelemetryCollector,
   TwError: () => TwError,
+  appendStaticStateCssToSafelist: () => appendStaticStateCssToSafelist,
   assertTailwindV4: () => assertTailwindV4,
   calculateHealth: () => calculateHealth,
   createBuildTimer: () => createBuildTimer,
   createDebugLogger: () => createDebugLogger,
   createEsmRequire: () => createEsmRequire,
-  createLogger: () => createLogger,
+  createLogger: () => createLogger2,
   createObservabilityClient: () => createObservabilityClient,
   createTraceSnapshot: () => createTraceSnapshot,
   detectTailwind: () => detectTailwind,
+  extractStaticStateCss: () => extractStaticStateCss,
   formatDuration: () => formatDuration,
   formatErrorCode: () => formatErrorCode,
   formatErrorMessage: () => formatErrorMessage,
@@ -1052,10 +2231,11 @@ __export(src_exports, {
   resolveRuntimeDir: () => resolveRuntimeDir,
   resolveWorkerPath: () => resolveWorkerPath,
   safeParseNative: () => safeParseNative,
+  setGlobalLogFile: () => setGlobalLogFile,
   tryRequire: () => tryRequire,
   wrapUnknownError: () => wrapUnknownError
 });
-function createLogger(namespace) {
+function createLogger2(namespace) {
   const prefix = `[${namespace}]`;
   return {
     warn(...args) {
@@ -1084,9 +2264,9 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path13) {
-  if (!path13 || path13.length === 0) return "(root)";
-  return path13.map(
+function formatIssuePath(path16) {
+  if (!path16 || path16.length === 0) return "(root)";
+  return path16.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
@@ -1100,9 +2280,9 @@ function loadNativeBinding(options) {
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
   for (const candidate of candidates) {
-    const candidatePath = path6__default.resolve(runtimeDir, candidate);
+    const candidatePath = path9__default.resolve(runtimeDir, candidate);
     try {
-      if (!fs5__default.existsSync(candidatePath) && !fs5__default.existsSync(candidatePath + ".node")) {
+      if (!fs3__default.existsSync(candidatePath) && !fs3__default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -1134,9 +2314,9 @@ function resolveNativeBindingCandidates(options) {
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs5__default.existsSync(runtimeDir)) {
+  if (fs3__default.existsSync(runtimeDir)) {
     try {
-      for (const entry of fs5__default.readdirSync(runtimeDir)) {
+      for (const entry of fs3__default.readdirSync(runtimeDir)) {
         if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
@@ -1145,22 +2325,22 @@ function resolveNativeBindingCandidates(options) {
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const napiPlatform = process.platform === "linux" && process.arch === "x64" ? "linux-x64-gnu" : process.platform === "linux" && process.arch === "arm64" ? "linux-arm64-gnu" : `${process.platform}-${process.arch}`;
   for (const bin of BINARY_NAMES) {
-    candidates.push(path6__default.resolve(runtimeDir, `${bin}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, "..", "native", `${bin}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path6__default.resolve(process.cwd(), "native", `${bin}.node`));
-    candidates.push(path6__default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path6__default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, `${bin}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, "..", "native", `${bin}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path9__default.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(path9__default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path9__default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
   }
   return Array.from(new Set(candidates));
 }
 function resolveRuntimeDir(dir, importMetaUrl) {
-  if (dir) return path6__default.resolve(dir);
+  if (dir) return path9__default.resolve(dir);
   try {
-    return path6__default.dirname(fileURLToPath(importMetaUrl));
+    return path9__default.dirname(fileURLToPath(importMetaUrl));
   } catch {
     return process.cwd();
   }
@@ -1175,7 +2355,7 @@ function formatErrorMessage(error) {
   return String(error);
 }
 var TwError, _require2, LRUCache;
-var init_src = __esm({
+var init_src2 = __esm({
   "packages/domain/shared/src/index.ts"() {
     init_trace();
     init_error_codes();
@@ -1188,6 +2368,8 @@ var init_src = __esm({
     init_codegen();
     init_native_resolution();
     init_observability();
+    init_staticStateExtractor();
+    init_logger();
     TwError = class _TwError extends Error {
       /** @deprecated Gunakan source */
       domain;
@@ -1221,8 +2403,8 @@ var init_src = __esm({
       /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
       static fromZod(err) {
         const first = err.issues?.[0] ?? err.errors?.[0];
-        const path13 = formatIssuePath(first?.path);
-        const message = first ? `${path13}: ${first.message}` : "Schema validation failed";
+        const path16 = formatIssuePath(first?.path);
+        const message = first ? `${path16}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -1319,7 +2501,7 @@ function getDirname2() {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path6__default.dirname(fileURLToPath(import.meta.url));
+    return path9__default.dirname(fileURLToPath(import.meta.url));
   }
   return process.cwd();
 }
@@ -1524,11 +2706,11 @@ function hasNativeWatchBinding() {
     return false;
   }
 }
-var log, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
+var log2, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
 var init_native_bridge = __esm({
   "packages/domain/scanner/src/native-bridge.ts"() {
-    init_src();
-    log = createDebugLogger("scanner:native");
+    init_src2();
+    log2 = createDebugLogger("scanner:native");
     isValidScannerBinding = (module) => {
       const candidate = module;
       return !!(candidate && (candidate.scanWorkspace || candidate.extractClassesFromSource || candidate.hashFileContent || candidate.cacheRead || candidate.cacheWrite));
@@ -1582,7 +2764,7 @@ var init_native_bridge = __esm({
           invalidExportMessage: "Module loaded but missing expected scanner binding functions"
         });
         if (binding) {
-          log(`scanner native binding loaded successfully`);
+          log2(`scanner native binding loaded successfully`);
           _state.binding = binding;
           return _state.binding;
         }
@@ -1608,12 +2790,12 @@ var init_native_bridge = __esm({
   }
 });
 function defaultCachePath(rootDir, cacheDir) {
-  const dir = cacheDir ? path6__default.resolve(rootDir, cacheDir) : path6__default.join(process.cwd(), ".cache", "tailwind-styled");
-  return path6__default.join(dir, "scanner-cache.json");
+  const dir = cacheDir ? path9__default.resolve(rootDir, cacheDir) : path9__default.join(process.cwd(), ".cache", "tailwind-styled");
+  return path9__default.join(dir, "scanner-cache.json");
 }
 function readCache(rootDir, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs5__default.mkdirSync(path6__default.dirname(cachePath), { recursive: true });
+  fs3__default.mkdirSync(path9__default.dirname(cachePath), { recursive: true });
   const result = cacheReadNative(cachePath);
   if (!result) return [];
   return result.entries.map((e) => ({
@@ -1628,7 +2810,7 @@ function readCache(rootDir, cacheDir) {
 }
 function writeCache(rootDir, entries, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs5__default.mkdirSync(path6__default.dirname(cachePath), { recursive: true });
+  fs3__default.mkdirSync(path9__default.dirname(cachePath), { recursive: true });
   const success = cacheWriteNative(cachePath, entries);
   if (!success) {
     throw new Error(
@@ -1655,27 +2837,7 @@ var init_cache_native = __esm({
 function collectFiles(rootDir, extensions, ignoreDirs) {
   const native = collectFilesNative(rootDir, extensions, ignoreDirs);
   if (native !== null) return native;
-  const files = [];
-  function walk(dir) {
-    let entries;
-    try {
-      entries = fs5__default.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const fullPath = path6__default.join(dir, entry.name);
-      const rel = path6__default.relative(rootDir, fullPath);
-      if (entry.isDirectory()) {
-        const ignored = ignoreDirs.some((d) => entry.name === d || rel.startsWith(d + path6__default.sep));
-        if (!ignored) walk(fullPath);
-      } else if (isScannableFile(entry.name, extensions)) {
-        files.push(fullPath);
-      }
-    }
-  }
-  walk(rootDir);
-  return files;
+  throw new Error("FATAL: Native binding 'collectFiles' is required but not available.");
 }
 function mergeResults(batchResults) {
   const files = batchResults.map((r) => ({
@@ -1685,8 +2847,7 @@ function mergeResults(batchResults) {
   }));
   const native = rebuildWorkspaceResultNative(files);
   if (native) return native;
-  const unique = new Set(files.flatMap((f) => f.classes));
-  return { files, totalFiles: files.length, uniqueClasses: Array.from(unique).sort() };
+  throw new Error("FATAL: Native binding 'rebuildWorkspaceResult' is required but not available.");
 }
 function runChunkInWorker(filePaths) {
   return new Promise((resolve2, reject) => {
@@ -1713,7 +2874,7 @@ async function scanWorkspaceParallel(rootDir, options = {}) {
     maxWorkers = Math.max(1, availableParallelism() - 1),
     chunkSize = DEFAULT_CHUNK_SIZE
   } = options;
-  const files = collectFiles(path6__default.resolve(rootDir), extensions, ignoreDirs);
+  const files = collectFiles(path9__default.resolve(rootDir), extensions, ignoreDirs);
   if (files.length < PARALLEL_THRESHOLD) {
     return mergeResults(batchExtractClassesNative(files));
   }
@@ -1732,7 +2893,7 @@ async function scanWorkspaceParallel(rootDir, options = {}) {
 var PARALLEL_THRESHOLD, DEFAULT_CHUNK_SIZE, _workerFilename;
 var init_parallel_scanner = __esm({
   "packages/domain/scanner/src/parallel-scanner.ts"() {
-    init_src2();
+    init_src3();
     init_native_bridge();
     PARALLEL_THRESHOLD = 50;
     DEFAULT_CHUNK_SIZE = 150;
@@ -1756,13 +2917,13 @@ var init_parallel_scanner = __esm({
 var formatIssuePath2, formatIssues, parseWithSchema, NonNegativeIntegerSchema, ScanWorkspaceOptionsSchema, ScanFileResultSchema, ScanWorkspaceResultSchema, ScannerWorkerSuccessMessageSchema, ScannerWorkerErrorMessageSchema, ScannerWorkerMessageSchema, parseScanWorkspaceOptions, parseScanWorkspaceResult, parseScannerWorkerMessage;
 var init_schemas = __esm({
   "packages/domain/scanner/src/schemas.ts"() {
-    init_src();
-    formatIssuePath2 = (path13) => path13.length > 0 ? path13.map(
+    init_src2();
+    formatIssuePath2 = (path16) => path16.length > 0 ? path16.map(
       (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
     ).join(".") : "<root>";
     formatIssues = (error) => error.issues.map((issue) => {
-      const path13 = formatIssuePath2(issue.path);
-      return `${path13}: ${issue.message}`;
+      const path16 = formatIssuePath2(issue.path);
+      return `${path16}: ${issue.message}`;
     }).join("; ");
     parseWithSchema = (schema, data, label) => {
       const parsed = schema.safeParse(data);
@@ -1825,7 +2986,7 @@ __export(src_exports2, {
   DEFAULT_IGNORES: () => DEFAULT_IGNORES,
   batchExtractClassesNative: () => batchExtractClassesNative,
   extractClassesNative: () => extractClassesNative,
-  isScannableFile: () => isScannableFile,
+  isScannableFile: () => isScannableFile2,
   parseScanWorkspaceOptions: () => parseScanWorkspaceOptions,
   parseScanWorkspaceResult: () => parseScanWorkspaceResult,
   parseScannerWorkerMessage: () => parseScannerWorkerMessage,
@@ -1839,7 +3000,7 @@ function getRuntimeDir() {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path6__default.dirname(fileURLToPath(import.meta.url));
+    return path9__default.dirname(fileURLToPath(import.meta.url));
   }
   return process.cwd();
 }
@@ -1849,17 +3010,17 @@ function resolveScannerWorkerModulePath() {
       return __dirname;
     }
     if (typeof import.meta !== "undefined" && import.meta.url) {
-      return path6__default.dirname(fileURLToPath(import.meta.url));
+      return path9__default.dirname(fileURLToPath(import.meta.url));
     }
     return process.cwd();
   })();
   const candidates = [
-    path6__default.resolve(runtimeDir, "worker.cjs"),
-    path6__default.resolve(runtimeDir, "worker.js"),
-    path6__default.resolve(runtimeDir, "worker.ts")
+    path9__default.resolve(runtimeDir, "worker.cjs"),
+    path9__default.resolve(runtimeDir, "worker.js"),
+    path9__default.resolve(runtimeDir, "worker.ts")
   ];
   for (const candidate of candidates) {
-    if (fs5__default.existsSync(candidate)) return candidate;
+    if (fs3__default.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -1916,19 +3077,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs5__default.readdirSync(currentDir, { withFileTypes: true });
+        return fs3__default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
     })();
     for (const entry of entries) {
-      const fullPath = path6__default.join(currentDir, entry.name);
+      const fullPath = path9__default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      if (!extensionSet.has(path6__default.extname(entry.name))) continue;
+      if (!extensionSet.has(path9__default.extname(entry.name))) continue;
       candidates.push(fullPath);
     }
   }
@@ -1954,8 +3115,8 @@ function scanSource(source) {
     "FATAL: Native parser binding is required but not available.\nThis package requires native Rust bindings.\n\nResolution steps:\n1. Build the native Rust module: npm run build:rust"
   );
 }
-function isScannableFile(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
-  return includeExtensions.includes(path6__default.extname(filePath));
+function isScannableFile2(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
+  return includeExtensions.includes(path9__default.extname(filePath));
 }
 function scanFile(filePath) {
   const { scanFileNative: scanFileNative2 } = (init_native_bridge(), __toCommonJS(native_bridge_exports));
@@ -2003,7 +3164,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 [];
@@ -2015,7 +3176,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs5__default.statSync(filePath);
+          return fs3__default.statSync(filePath);
         } catch {
           return null;
         }
@@ -2041,7 +3202,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs5__default.readFileSync(filePath, "utf8");
+          return fs3__default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -2049,7 +3210,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,
@@ -2061,7 +3222,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({
@@ -2076,7 +3237,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,
@@ -2109,30 +3270,30 @@ async function scanWorkspaceAsync(rootDir, options = {}) {
       ignoreDirs: normalizedOptions.ignoreDirectories
     });
   } catch (parallelError) {
-    log2.debug(
+    log3.debug(
       `parallel scan failed, retrying with single worker: ${parallelError instanceof Error ? parallelError.message : String(parallelError)}`
     );
   }
   try {
     return await scanWorkspaceInWorker(rootDir, normalizedOptions);
   } catch (error) {
-    log2.debug(
+    log3.debug(
       `worker scan failed, retrying with sync native scanner: ${error instanceof Error ? error.message : String(error)}`
     );
     return scanWorkspace(rootDir, normalizedOptions);
   }
 }
-var log2, SCAN_WORKER_TIMEOUT_MS, createNativeParserLoader, nativeParserLoader, DEFAULT_EXTENSIONS, DEFAULT_IGNORES;
-var init_src2 = __esm({
+var log3, SCAN_WORKER_TIMEOUT_MS, createNativeParserLoader, nativeParserLoader, DEFAULT_EXTENSIONS, DEFAULT_IGNORES;
+var init_src3 = __esm({
   "packages/domain/scanner/src/index.ts"() {
-    init_src();
+    init_src2();
     init_cache_native();
     init_native_bridge();
     init_parallel_scanner();
     init_schemas();
     init_schemas();
     init_native_bridge();
-    log2 = createLogger("scanner");
+    log3 = createLogger2("scanner");
     SCAN_WORKER_TIMEOUT_MS = 12e4;
     createNativeParserLoader = () => {
       const _state = {
@@ -2140,12 +3301,12 @@ var init_src2 = __esm({
         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(path6__default.join(runtimeDir, "noop.cjs"));
+        const req = createRequire(path9__default.join(runtimeDir, "noop.cjs"));
         const _platform = process.platform;
         const _arch = process.arch;
         const _platformArch = `${_platform}-${_arch}`;
@@ -2153,27 +3314,27 @@ var init_src2 = __esm({
         const candidates = [
           // ── binaryName baru: tailwind-styled-native (napi-rs naming) ──
           // cwd = repo root saat run dari root, atau package dir saat workspaces
-          path6__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
-          path6__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
-          path6__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          path9__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+          path9__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
+          path9__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // runtimeDir = dist/ → naik 1 level ke package root (npm install case)
           // e.g. node_modules/tailwind-styled-v4/dist/ → node_modules/tailwind-styled-v4/native/
-          path6__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
-          path6__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
-          path6__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          path9__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+          path9__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
+          path9__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // runtimeDir = dist/ → naik 4 level ke repo root (monorepo dev case)
-          path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
-          path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // 3 level fallback (jika package di-nest lebih dangkal)
-          path6__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
-          path6__default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // ── binaryName lama: tailwind_styled_parser (backward compat) ──
-          path6__default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
-          path6__default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
-          path6__default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
-          path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
-          path6__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
-          path6__default.resolve(
+          path9__default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+          path9__default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
+          path9__default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+          path9__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
+          path9__default.resolve(
             runtimeDir,
             "..",
             "..",
@@ -2185,7 +3346,7 @@ var init_src2 = __esm({
           )
         ];
         for (const fullPath of candidates) {
-          if (!fs5__default.existsSync(fullPath)) continue;
+          if (!fs3__default.existsSync(fullPath)) continue;
           try {
             const required = req(fullPath);
             if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
@@ -2218,168 +3379,6 @@ var init_src2 = __esm({
   }
 });
 
-// packages/domain/compiler/src/nativeBridge.ts
-var _loadNative, log3, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge;
-var init_nativeBridge = __esm({
-  "packages/domain/compiler/src/nativeBridge.ts"() {
-    init_src();
-    _loadNative = (path13) => __require(path13);
-    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;
-      }
-    };
-    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;
-  try {
-    const tw = require2("tailwindcss");
-    if (typeof tw.compile !== "function") {
-      throw new Error("tailwindcss v4 not found \u2014 compile() API missing. Check tailwindcss version >= 4.");
-    }
-    _twEngine = tw;
-    return _twEngine;
-  } catch (e) {
-    _twEngineError = e instanceof Error ? e : new Error(String(e));
-    throw _twEngineError;
-  }
-}
-async function generateRawCss(classes, cssEntryContent, root) {
-  if (classes.length === 0) return "";
-  const tw = loadTailwindEngine();
-  const input = cssEntryContent ?? "@import 'tailwindcss';";
-  const { readFileSync, existsSync: existsSync3 } = await import('fs');
-  const { dirname, resolve: resolve2 } = await import('path');
-  const projectRoot = root ?? process.cwd();
-  const req = createRequire(resolve2(projectRoot, "package.json"));
-  const loadStylesheet = async (id, base) => {
-    try {
-      const cssId = id === "tailwindcss" ? "tailwindcss/index.css" : id === "tailwindcss/preflight" ? "tailwindcss/preflight.css" : id === "tailwindcss/utilities" ? "tailwindcss/utilities.css" : id === "tailwindcss/theme" ? "tailwindcss/theme.css" : id;
-      const pkgPath = req.resolve(cssId);
-      return {
-        content: readFileSync(pkgPath, "utf-8"),
-        base: dirname(pkgPath)
-      };
-    } catch {
-      try {
-        const absPath = resolve2(base, id);
-        if (existsSync3(absPath)) {
-          return { content: readFileSync(absPath, "utf-8"), base: dirname(absPath) };
-        }
-      } catch {
-      }
-      return { content: "", base };
-    }
-  };
-  const compiler = await Promise.resolve(tw.compile(input, { loadStylesheet }));
-  return compiler.build(classes);
-}
-function postProcessWithLightning(rawCss) {
-  if (!rawCss) return "";
-  const native = getNativeBridge();
-  if (typeof native.processTailwindCssLightning !== "function") {
-    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
-  }
-  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);
-  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 };
-}
-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);
-  return (result?.css ?? css).trim();
-}
-var require2, _twEngine, _twEngineError;
-var init_tailwindEngine = __esm({
-  "packages/domain/compiler/src/tailwindEngine.ts"() {
-    init_nativeBridge();
-    require2 = createRequire(import.meta.url);
-    _twEngine = null;
-    _twEngineError = null;
-  }
-});
-
 // packages/domain/engine/src/native-bridge.ts
 function getDirname3() {
   if (typeof __dirname !== "undefined") return __dirname;
@@ -2394,7 +3393,7 @@ function getNativeEngineBinding() {
 var log4, isValidEngineBinding, createEngineBindingLoader, engineBindingLoader;
 var init_native_bridge2 = __esm({
   "packages/domain/engine/src/native-bridge.ts"() {
-    init_src();
+    init_src2();
     log4 = createDebugLogger("engine:native");
     isValidEngineBinding = (module) => {
       const candidate = module;
@@ -2475,47 +3474,38 @@ var init_native_bridge2 = __esm({
 // packages/domain/engine/src/ir.ts
 function registerPropertyName(id, name) {
   const native = getNativeEngineBinding();
-  if (native?.registerPropertyName) {
-    native.registerPropertyName(id.value, name);
-    return;
+  if (!native?.registerPropertyName) {
+    throw new Error("FATAL: Native binding 'registerPropertyName' is required but not available.");
   }
-  _propertyNamesFallback.set(id.value, name);
+  native.registerPropertyName(id.value, name);
 }
 function registerValueName(id, name) {
   const native = getNativeEngineBinding();
-  if (native?.registerValueName) {
-    native.registerValueName(id.value, name);
-    return;
+  if (!native?.registerValueName) {
+    throw new Error("FATAL: Native binding 'registerValueName' is required but not available.");
   }
-  _valueNamesFallback.set(id.value, name);
+  native.registerValueName(id.value, name);
 }
 function propertyIdToString(id) {
   const native = getNativeEngineBinding();
-  if (native?.propertyIdToString) {
-    return native.propertyIdToString(id.value);
+  if (!native?.propertyIdToString) {
+    throw new Error("FATAL: Native binding 'propertyIdToString' is required but not available.");
   }
-  return _propertyNamesFallback.get(id.value) ?? `P${id.value}`;
+  return native.propertyIdToString(id.value);
 }
 function valueIdToString(id) {
   const native = getNativeEngineBinding();
-  if (native?.valueIdToString) {
-    return native.valueIdToString(id.value);
+  if (!native?.valueIdToString) {
+    throw new Error("FATAL: Native binding 'valueIdToString' is required but not available.");
   }
-  return _valueNamesFallback.get(id.value) ?? `V${id.value}`;
-}
-function createFingerprintFallback(parts) {
-  const hash = parts.reduce(
-    (acc, part) => part.split("").reduce((h, char) => (h << 5) - h + char.charCodeAt(0) & h, acc),
-    0
-  );
-  return Math.abs(hash).toString(36);
+  return native.valueIdToString(id.value);
 }
 function createFingerprint(parts) {
   const native = getNativeEngineBinding();
-  if (native?.createFingerprint) {
-    return native.createFingerprint(parts);
+  if (!native?.createFingerprint) {
+    throw new Error("FATAL: Native binding 'createFingerprint' is required but not available.");
   }
-  return createFingerprintFallback(parts);
+  return native.createFingerprint(parts);
 }
 function createResolutionReason(causes, finalDecision) {
   return {
@@ -2523,7 +3513,7 @@ function createResolutionReason(causes, finalDecision) {
     finalDecision
   };
 }
-var RuleId, SelectorId, VariantChainId, PropertyId, ValueId, LayerId, ConditionId, CascadeResolutionId, _propertyNamesFallback, _valueNamesFallback, Origin, Importance, ConditionResult, CascadeStage;
+var RuleId, SelectorId, VariantChainId, PropertyId, ValueId, LayerId, ConditionId, CascadeResolutionId, Origin, Importance, ConditionResult, CascadeStage;
 var init_ir = __esm({
   "packages/domain/engine/src/ir.ts"() {
     init_native_bridge2();
@@ -2611,8 +3601,6 @@ var init_ir = __esm({
         return `R${this.value}`;
       }
     };
-    _propertyNamesFallback = /* @__PURE__ */ new Map();
-    _valueNamesFallback = /* @__PURE__ */ new Map();
     Origin = /* @__PURE__ */ ((Origin2) => {
       Origin2[Origin2["UserAgent"] = 0] = "UserAgent";
       Origin2[Origin2["UserNormal"] = 1] = "UserNormal";
@@ -2826,14 +3814,68 @@ function detectLayerFromClassName(className) {
   return null;
 }
 function parseCssToIr(css, options = {}) {
-  resetIdGenerator();
+  const native = getNativeEngineBinding();
+  const prefix = options.prefix ?? "";
+  if (native?.assembleCssIr) {
+    return _parseCssToIrFast(native.assembleCssIr(css, prefix || null));
+  }
+  return _parseCssToIrFallback(css, prefix, native);
+}
+function _parseCssToIrFast(assembled) {
+  const native = getNativeEngineBinding();
   layerMap.clear();
   layerOrderMap.clear();
-  const native = getNativeEngineBinding();
+  for (const le of assembled.layers) {
+    const lid = new LayerId(le.layerId);
+    layerMap.set(le.name, lid);
+    layerOrderMap.set(le.name, le.order);
+  }
+  const rules = assembled.rules.map((r) => {
+    const propertyId = new PropertyId(r.propertyId);
+    const valueId = new ValueId(r.valueId);
+    if (native?.registerPropertyName) {
+      native.registerPropertyName(r.propertyId, r.propertyName);
+    } else {
+      registerPropertyName(propertyId, r.propertyName);
+    }
+    if (native?.registerValueName) {
+      native.registerValueName(r.valueId, r.valueName);
+    } else {
+      registerValueName(valueId, r.valueName);
+    }
+    return {
+      id: new RuleId(r.ruleId),
+      selector: new SelectorId(r.selectorId),
+      variantChain: new VariantChainId(0),
+      property: propertyId,
+      value: valueId,
+      origin: r.origin,
+      importance: r.importance,
+      layer: r.layerId >= 0 ? new LayerId(r.layerId) : null,
+      layerOrder: r.layerOrder,
+      specificity: r.specificity,
+      condition: r.conditionId >= 0 ? new ConditionId(r.conditionId) : null,
+      conditionResult: r.conditionResult,
+      insertionOrder: r.insertionOrder,
+      fingerprint: r.fingerprint,
+      source: { file: "", line: 1, column: 1 }
+    };
+  });
+  const classToRuleIds = new Map(
+    assembled.classToRuleIds.map((m) => [
+      m.className,
+      m.ruleIds.map((id) => new RuleId(id))
+    ])
+  );
+  return { rules, classToRuleIds };
+}
+function _parseCssToIrFallback(css, prefix, native) {
   if (!native?.parseCssRules) {
     throw new Error("FATAL: Native binding 'parseCssRules' is required but not available.");
   }
-  const prefix = options.prefix ?? "";
+  resetIdGenerator();
+  layerMap.clear();
+  layerOrderMap.clear();
   const rules = [];
   const classToRuleIds = /* @__PURE__ */ new Map();
   const parsed = native.parseCssRules(css);
@@ -2848,7 +3890,7 @@ function parseCssToIr(css, options = {}) {
     const valueId = generateValueId(r.value);
     const hasMedia = r.variants.some((v) => v.startsWith("@") || v === "dark" || v === "print");
     const conditionId = hasMedia ? generateConditionId() : null;
-    const conditionResult = hasMedia ? 2 /* Unknown */ : 2 /* Unknown */;
+    const conditionResult = 2 /* Unknown */;
     const ruleId = generateRuleId();
     const fingerprint = createFingerprint([className, r.property, r.value]);
     const rule = {
@@ -2862,7 +3904,6 @@ function parseCssToIr(css, options = {}) {
       layer,
       layerOrder,
       specificity: r.specificity,
-      // from native — no JS recalculation
       condition: conditionId,
       conditionResult,
       insertionOrder: getNextInsertionOrder(),
@@ -3016,13 +4057,13 @@ var init_trace2 = __esm({
 });
 
 // packages/domain/analyzer/src/analyzeWorkspace.ts
-init_src2();
+init_src3();
 
 // packages/domain/analyzer/src/binding.ts
-init_src();
+init_src2();
 
 // packages/domain/analyzer/src/utils.ts
-init_src();
+init_src2();
 var DEFAULT_TOP_LIMIT = 10;
 var DEFAULT_FREQUENT_THRESHOLD = 2;
 var DEBUG_NAMESPACE = "tailwind-styled:analyzer";
@@ -3036,7 +4077,7 @@ function isRecord(value) {
 }
 async function pathExists(filePath) {
   try {
-    await fs5__default.promises.access(filePath, fs5__default.constants.F_OK);
+    await fs3__default.promises.access(filePath, fs3__default.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -3134,8 +4175,8 @@ async function requireNativeBinding() {
 }
 
 // packages/domain/analyzer/src/schemas.ts
-init_src();
-var formatIssuePath3 = (path13) => path13.length > 0 ? path13.map(
+init_src2();
+var formatIssuePath3 = (path16) => path16.length > 0 ? path16.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var isPlainObject = (value) => {
@@ -3144,8 +4185,8 @@ var isPlainObject = (value) => {
   return proto === Object.prototype || proto === null;
 };
 var formatIssues2 = (error) => error.issues.map((issue) => {
-  const path13 = formatIssuePath3(issue.path);
-  return `${path13}: ${issue.message}`;
+  const path16 = formatIssuePath3(issue.path);
+  return `${path16}: ${issue.message}`;
 }).join("; ");
 var parseWithSchema2 = (schema, data, label) => {
   const parsed = schema.safeParse(data);
@@ -3235,7 +4276,7 @@ var parseAnalyzerOptions = (options) => parseWithSchema2(AnalyzerOptionsSchema,
 var parseNativeReport = (report) => parseWithSchema2(NativeReportSchema, report, "Native analyzer report is invalid");
 var SUPPORTED_TAILWIND_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".cjs", ".mjs"]);
 var tailwindConfigCache = /* @__PURE__ */ new Map();
-var detectConflicts = async (usages) => {
+var detectConflicts2 = async (usages) => {
   const native = await getNativeBinding();
   if (!native?.detectClassConflicts) {
     throw new Error("FATAL: Native binding 'detectClassConflicts' is required but not available.");
@@ -3252,11 +4293,11 @@ var detectConflicts = async (usages) => {
   };
 };
 var isSupportedTailwindConfigPath = (configPath) => {
-  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path6__default.extname(configPath).toLowerCase());
+  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path9__default.extname(configPath).toLowerCase());
 };
 var resolveTailwindConfigPath = async (root, explicitPath) => {
   if (explicitPath) {
-    const resolved = path6__default.resolve(root, explicitPath);
+    const resolved = path9__default.resolve(root, explicitPath);
     if (!await pathExists(resolved)) return null;
     return resolved;
   }
@@ -3267,7 +4308,7 @@ var resolveTailwindConfigPath = async (root, explicitPath) => {
     "tailwind.config.mjs"
   ];
   for (const candidate of candidates) {
-    const fullPath = path6__default.resolve(root, candidate);
+    const fullPath = path9__default.resolve(root, candidate);
     if (await pathExists(fullPath)) return fullPath;
   }
   return null;
@@ -3321,8 +4362,8 @@ var collectCustomUtilities = (config) => {
   return out;
 };
 var collectSafelistFromSource = async (configPath) => {
-  const source = await fs5__default.promises.readFile(configPath, "utf8");
-  const { extractClassesNative: extractClassesNative2 } = await Promise.resolve().then(() => (init_src2(), src_exports2));
+  const source = await fs3__default.promises.readFile(configPath, "utf8");
+  const { extractClassesNative: extractClassesNative2 } = await Promise.resolve().then(() => (init_src3(), src_exports2));
   const allTokens = extractClassesNative2(source);
   const hasSafelist = source.includes("safelist");
   if (!hasSafelist) return [];
@@ -3335,7 +4376,7 @@ var collectSafelistFromSource = async (configPath) => {
   }
   return allTokens.filter((t) => safelistSet.has(t));
 };
-var loadTailwindConfig = async (root, semanticOption) => {
+var loadTailwindConfig2 = async (root, semanticOption) => {
   const startMs = Date.now();
   const configPath = await resolveTailwindConfigPath(root, semanticOption?.tailwindConfigPath);
   if (!configPath) return null;
@@ -3348,7 +4389,7 @@ var loadTailwindConfig = async (root, semanticOption) => {
       customUtilities: /* @__PURE__ */ new Set()
     };
   }
-  const configStat = await fs5__default.promises.stat(configPath).catch(() => null);
+  const configStat = await fs3__default.promises.stat(configPath).catch(() => null);
   if (configStat) {
     const cached = tailwindConfigCache.get(configPath);
     if (cached && cached.mtimeMs === configStat.mtimeMs && cached.size === configStat.size) {
@@ -3416,7 +4457,7 @@ var loadTailwindConfig = async (root, semanticOption) => {
   return loaded;
 };
 var buildSemanticReport = async (usages, root, semanticOption) => {
-  const loadedConfig = await loadTailwindConfig(root, semanticOption);
+  const loadedConfig = await loadTailwindConfig2(root, semanticOption);
   const safelist = loadedConfig?.safelist ?? /* @__PURE__ */ new Set();
   const customUtilities = loadedConfig?.customUtilities ?? /* @__PURE__ */ new Set();
   const usageNames = new Set(usages.map((usage) => usage.name));
@@ -3435,7 +4476,7 @@ var buildSemanticReport = async (usages, root, semanticOption) => {
     results.filter((r) => !r.isKnown).map((r) => r.className)
   );
   const unknownClasses = usages.filter((usage) => unknownSet.has(usage.name)).map((usage) => ({ ...usage, isUnused: true }));
-  const { conflicts } = await detectConflicts(usages);
+  const { conflicts } = await detectConflicts2(usages);
   return {
     unusedClasses,
     unknownClasses,
@@ -3507,7 +4548,7 @@ async function buildDistribution(usages, native) {
 }
 async function analyzeWorkspace(root, options = {}) {
   const startedAtMs = Date.now();
-  const resolvedRoot = path6__default.resolve(root);
+  const resolvedRoot = path9__default.resolve(root);
   const normalizedOptions = parseAnalyzerOptions(options);
   const scan = await (async () => {
     const scanStartedAtMs = Date.now();
@@ -3609,36 +4650,17 @@ async function analyzeWorkspace(root, options = {}) {
   };
 }
 
-// packages/domain/compiler/src/index.ts
-init_nativeBridge();
-var generateCssForClasses = async (classes, _tailwindConfig, root, cssEntryContent, minify = false) => {
-  const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
-  const result = await runCssPipeline2(classes, cssEntryContent, root, minify);
-  return result.css;
-};
-var mergeClassesStatic = (classes) => {
-  const result = normalizeAndDedupClasses(classes);
-  return result?.normalized || "";
-};
-var normalizeAndDedupClasses = (raw) => {
-  const native = getNativeBridge();
-  if (!native?.normalizeAndDedupClasses) {
-    throw new Error("FATAL: Native binding 'normalizeAndDedupClasses' is required but not available.");
-  }
-  const result = native.normalizeAndDedupClasses(raw);
-  return result || { normalized: "", duplicatesRemoved: 0, uniqueCount: 0 };
-};
-
 // packages/domain/engine/src/index.ts
+init_internal();
+init_src3();
 init_src2();
-init_src();
 
 // packages/domain/engine/src/incremental.ts
+init_src3();
 init_src2();
-init_src();
 init_native_bridge2();
 var DEFAULT_EXTENSIONS2 = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
-var log5 = createLogger("engine:incremental");
+var log5 = createLogger2("engine:incremental");
 function rebuildWorkspaceResult(byFile) {
   const files = Array.from(byFile.values());
   const native = getNativeEngineBinding();
@@ -3668,9 +4690,9 @@ function areClassSetsEqual(a, b) {
 }
 function applyIncrementalChange(previous, filePath, type, scanner) {
   const includeExtensions = scanner?.includeExtensions ?? DEFAULT_EXTENSIONS2;
-  if (!isScannableFile(filePath, includeExtensions)) return previous;
-  const byFile = new Map(previous.files.map((f) => [path6__default.resolve(f.file), f]));
-  const normalizedPath = path6__default.resolve(filePath);
+  if (!isScannableFile2(filePath, includeExtensions)) return previous;
+  const byFile = new Map(previous.files.map((f) => [path9__default.resolve(f.file), f]));
+  const normalizedPath = path9__default.resolve(filePath);
   const native = getNativeEngineBinding();
   if (!native?.processFileChange) {
     throw new Error(
@@ -3686,7 +4708,7 @@ function applyIncrementalChange(previous, filePath, type, scanner) {
   }
   log5.debug(`native change ${normalizedPath}`);
   const scanned = scanFile(normalizedPath);
-  const content = fs5__default.readFileSync(normalizedPath, "utf8");
+  const content = fs3__default.readFileSync(normalizedPath, "utf8");
   const diff = native.processFileChange(normalizedPath, scanned.classes, content);
   const existing = byFile.get(normalizedPath);
   if (diff && existing) {
@@ -4031,13 +5053,13 @@ var EngineMetricsCollector = class {
 };
 
 // packages/domain/engine/src/metricsWriter.ts
-init_src();
+init_src2();
 var METRICS_FILE_NAME = "metrics.json";
 var CACHE_DIR = ".tw-cache";
 function writeMetrics(metrics, cwd = process.cwd()) {
   try {
-    const cacheDir = path6__default.join(cwd, CACHE_DIR);
-    fs5__default.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = path9__default.join(cwd, CACHE_DIR);
+    fs3__default.mkdirSync(cacheDir, { recursive: true });
     const mem = process.memoryUsage();
     const data = {
       ...metrics,
@@ -4048,7 +5070,7 @@ function writeMetrics(metrics, cwd = process.cwd()) {
       },
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs5__default.writeFileSync(path6__default.join(cacheDir, METRICS_FILE_NAME), JSON.stringify(data, null, 2));
+    fs3__default.writeFileSync(path9__default.join(cacheDir, METRICS_FILE_NAME), JSON.stringify(data, null, 2));
   } catch {
   }
 }
@@ -4155,19 +5177,19 @@ var parseEngineOptions = (options) => parseWithSchema3(EngineOptionsSchema, opti
 var parseEngineWatchOptions = (options) => parseWithSchema3(EngineWatchOptionsSchema, options ?? {}, "engine watch options are invalid");
 
 // packages/domain/engine/src/watch.ts
-var _native = null;
+var _native2 = null;
 function getNativeWatcher() {
-  if (_native !== null) return _native;
+  if (_native2 !== null) return _native2;
   try {
-    const { resolveNativeBinary: resolveNativeBinary2 } = (init_src(), __toCommonJS(src_exports));
+    const { resolveNativeBinary: resolveNativeBinary2 } = (init_src2(), __toCommonJS(src_exports));
     const { path: binPath } = resolveNativeBinary2(__dirname);
     if (binPath) {
-      _native = __require(binPath);
+      _native2 = __require(binPath);
     }
   } catch {
-    _native = {};
+    _native2 = {};
   }
-  return _native;
+  return _native2;
 }
 function watchWorkspaceNative(rootDir, onEvent, options) {
   const native = getNativeWatcher();
@@ -4231,7 +5253,7 @@ init_ir();
 
 // packages/domain/engine/src/reverseLookup.ts
 init_native_bridge2();
-function getNative() {
+function getNative2() {
   const native = getNativeEngineBinding();
   if (!native?.reverseLookupFromCss || !native?.reverseLookupByProperty || !native?.reverseLookupFindDependents) {
     throw new Error(
@@ -4256,15 +5278,15 @@ function normaliseNativeResults(raw) {
 var ReverseLookup = class {
   fromCSS(cssProperty, cssValue, css) {
     if (!css || !cssProperty) return [];
-    return normaliseNativeResults(getNative().reverseLookupFromCss(css, cssProperty, cssValue));
+    return normaliseNativeResults(getNative2().reverseLookupFromCss(css, cssProperty, cssValue));
   }
   findByProperty(property, css) {
     if (!css || !property) return [];
-    return normaliseNativeResults(getNative().reverseLookupByProperty(css, property));
+    return normaliseNativeResults(getNative2().reverseLookupByProperty(css, property));
   }
   findDependents(className, css) {
     if (!css || !className) return [];
-    return getNative().reverseLookupFindDependents(css, className);
+    return getNative2().reverseLookupFindDependents(css, className);
   }
   fromBundle(className, css) {
     if (!css || !className) return [];
@@ -4309,7 +5331,7 @@ init_resolver();
 init_cssToIr();
 
 // packages/domain/engine/src/watch-native.ts
-init_src();
+init_src2();
 var watchBindingState = {
   binding: void 0
 };
@@ -4328,22 +5350,22 @@ var getBinding = () => {
   const _paGnu = _pa === "linux-x64" ? "linux-x64-gnu" : _pa === "linux-arm64" ? "linux-arm64-gnu" : _pa;
   const candidates = [
     // new binary name: tailwind-styled-native
-    path6__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
-    path6__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_pa}.node`),
+    path9__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+    path9__default.resolve(process.cwd(), "native", `tailwind-styled-native.${_pa}.node`),
     // npm install case: dist/../native/
-    path6__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
-    path6__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_pa}.node`),
-    path6__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_paGnu}.node`),
+    path9__default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+    path9__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_pa}.node`),
+    path9__default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_paGnu}.node`),
     // monorepo dev: 4-level up
-    path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
-    path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_paGnu}.node`),
+    path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+    path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_paGnu}.node`),
     // 3-level fallback
-    path6__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+    path9__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
     // backward compat: tailwind_styled_parser
-    path6__default.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
-    path6__default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
-    path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
-    path6__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node")
+    path9__default.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
+    path9__default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
+    path9__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+    path9__default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node")
   ];
   for (const c of candidates) {
     try {
@@ -4360,11 +5382,11 @@ var getBinding = () => {
     "FATAL: Native watch binding not found in any candidate path.\nThis package requires native Rust bindings.\n\nCandidates checked:\n" + candidates.map((p) => `  - ${p}`).join("\n") + "\n\nResolution steps:\n1. Build the native Rust module: npm run build:rust"
   );
 };
-var log6 = createLogger("engine:watch-native");
+var log6 = createLogger2("engine:watch-native");
 function watchWorkspace2(rootDir, callback, options = {}) {
   const binding = getBinding();
   const pollMs = options.pollIntervalMs ?? 500;
-  const resolvedRoot = path6__default.resolve(rootDir);
+  const resolvedRoot = path9__default.resolve(rootDir);
   const result = (() => {
     try {
       return binding.startWatch(resolvedRoot);
@@ -4401,7 +5423,7 @@ This package requires native Rust bindings.`
     const deduped = /* @__PURE__ */ new Set();
     const events = [];
     for (const e of raw) {
-      const absPath = path6__default.isAbsolute(e.path) ? path6__default.normalize(e.path) : path6__default.resolve(resolvedRoot, e.path);
+      const absPath = path9__default.isAbsolute(e.path) ? path9__default.normalize(e.path) : path9__default.resolve(resolvedRoot, e.path);
       const kind = e.kind;
       const key = `${kind}:${absPath}`;
       if (deduped.has(key)) continue;
@@ -4438,11 +5460,11 @@ var configState = {
     return this.tailwindConfigLoaded;
   }
 };
-var log7 = createLogger("engine");
+var log7 = createLogger2("engine");
 async function loadTailwindConfigFromPath(root, tailwindConfigPath) {
   if (!tailwindConfigPath) return void 0;
-  const configPath = path6__default.resolve(root, tailwindConfigPath);
-  if (!fs5__default.existsSync(configPath)) {
+  const configPath = path9__default.resolve(root, tailwindConfigPath);
+  if (!fs3__default.existsSync(configPath)) {
     throw TwError.fromIo("CONFIG_NOT_FOUND", `tailwindConfigPath not found: ${configPath}`);
   }
   const imported = await import(pathToFileURL(configPath).href);
@@ -4508,13 +5530,14 @@ async function buildFromScan(scan, root, options, tailwindConfig) {
   };
 }
 function countWorkspacePackages(root) {
-  const packagesDir = path6__default.join(root, "packages");
-  if (!fs5__default.existsSync(packagesDir)) return 0;
+  const packagesDir = path9__default.join(root, "packages");
+  if (!fs3__default.existsSync(packagesDir)) return 0;
   try {
-    return fs5__default.readdirSync(packagesDir, { withFileTypes: true }).filter(
-      (entry) => entry.isDirectory() && fs5__default.existsSync(path6__default.join(packagesDir, entry.name, "package.json"))
+    return fs3__default.readdirSync(packagesDir, { withFileTypes: true }).filter(
+      (entry) => entry.isDirectory() && fs3__default.existsSync(path9__default.join(packagesDir, entry.name, "package.json"))
     ).length;
-  } catch {
+  } catch (err) {
+    log7.debug(`countWorkspacePackages: ${err instanceof Error ? err.message : String(err)}`);
     return 0;
   }
 }
@@ -4548,7 +5571,7 @@ function writeDashboardMetrics(root, mode, result, metrics) {
 async function createEngine(rawOptions = {}) {
   const options = parseEngineOptions(rawOptions);
   const root = options.root ?? process.cwd();
-  const resolvedRoot = path6__default.resolve(root);
+  const resolvedRoot = path9__default.resolve(root);
   const plugins = rawOptions.plugins ?? [];
   const getTailwindConfig = async () => {
     if (configState.isLoaded()) return configState.getConfig();
@@ -4695,12 +5718,13 @@ async function createEngine(rawOptions = {}) {
       const shouldForceFullRescan = (event) => {
         if (event.type === "unlink") return false;
         try {
-          const stat = fs5__default.statSync(event.filePath);
+          const stat = fs3__default.statSync(event.filePath);
           if (stat.size > largeFileThreshold) {
             metrics.markSkippedLargeFile();
             return true;
           }
-        } catch {
+        } catch (statErr) {
+          log7.debug(`stat failed for ${event.filePath}: ${statErr instanceof Error ? statErr.message : String(statErr)}`);
           return false;
         }
         return false;
@@ -4812,14 +5836,14 @@ async function createEngine(rawOptions = {}) {
   };
 }
 async function scanWorkspace2(opts = {}) {
-  const root = path6__default.resolve(opts.root ?? process.cwd());
+  const root = path9__default.resolve(opts.root ?? process.cwd());
   return scanWorkspaceAsync(root, {
     includeExtensions: opts.extensions,
     ignoreDirectories: opts.ignoreDirectories
   });
 }
 async function analyzeWorkspace2(opts = {}) {
-  const root = path6__default.resolve(opts.root ?? process.cwd());
+  const root = path9__default.resolve(opts.root ?? process.cwd());
   return analyzeWorkspace(root, {
     classStats: { top: opts.top ?? 20 }
   });
@@ -4850,7 +5874,8 @@ async function traceClass(className, scanResult, css) {
       resolver.registerClass(registeredClassName, ruleIds);
     }
     return trace2(className, resolver);
-  } catch {
+  } catch (traceErr) {
+    log7.debug(`traceClass("${className}"): ${traceErr instanceof Error ? traceErr.message : String(traceErr)}`);
     return null;
   }
 }