tailwind-styled-v4 5.0.11 → 5.0.12

package/dist/vite.mjs

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createRequire } from 'module';
-import * as fs5 from 'fs';
-import fs5__default from 'fs';
-import * as path6 from 'path';
-import path6__default from 'path';
+import * as fs13 from 'fs';
+import fs13__default from 'fs';
+import * as path9 from 'path';
+import path9__default from 'path';
 import { createHash } from 'crypto';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
@@ -220,9 +220,9 @@ function parseNative(schema, data, context) {
   const result = schema.safeParse(data);
   if (!result.success) {
     const first = result.error.issues[0];
-    const path13 = first?.path?.join(".") ?? "(root)";
+    const path16 = first?.path?.join(".") ?? "(root)";
     throw new Error(
-      `[${context}] Native binding returned unexpected data: ${path13}: ${first?.message ?? "validation failed"}`
+      `[${context}] Native binding returned unexpected data: ${path16}: ${first?.message ?? "validation failed"}`
     );
   }
   return result.data;
@@ -615,11 +615,11 @@ function resolvePath(...segments) {
     return segments.join("/").replace(/\/+/g, "/");
   }
 }
-function existsSync(path13) {
+function existsSync(path16) {
   if (isBrowser2) return false;
   try {
     const nodeFs = __require(NODE_FS);
-    return nodeFs.existsSync(path13);
+    return nodeFs.existsSync(path16);
   } catch {
     return false;
   }
@@ -849,12 +849,12 @@ function resolveNativeBinary(runtimeDir) {
   if (isBrowser3) {
     return { path: null, source: "not-found", platform, tried: ["not available in browser"] };
   }
-  if (process.env.TWS_DISABLE_NATIVE === "1") {
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_DISABLE_NATIVE === "1") {
     return { path: null, source: "not-found", platform, tried: [] };
   }
   const envPath = process.env.TW_NATIVE_PATH?.trim();
   if (envPath) {
-    if (fs5.existsSync(envPath)) {
+    if (fs13.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
@@ -863,7 +863,7 @@ function resolveNativeBinary(runtimeDir) {
   for (const pkg of prebuiltPkgs) {
     try {
       const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs5.existsSync(candidate)) {
+      if (fs13.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -874,13 +874,13 @@ function resolveNativeBinary(runtimeDir) {
   const napiPlatform = platform === "linux-x64" ? "linux-x64-gnu" : platform === "linux-arm64" ? "linux-arm64-gnu" : platform;
   const BINARY_NAMES_SELF = ["tailwind-styled-native", "tailwind_styled_parser"];
   if (runtimeDir) {
-    for (const depth of ["..", path6.join("..", ".."), path6.join("..", "..", "..")]) {
-      const pkgRoot = path6.resolve(runtimeDir, depth);
+    for (const depth of ["..", path9.join("..", ".."), path9.join("..", "..", "..")]) {
+      const pkgRoot = path9.resolve(runtimeDir, depth);
       for (const bin of BINARY_NAMES_SELF) {
         for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
-          const candidate = path6.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
+          const candidate = path9.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
           tried.push(`self-bundled:${candidate}`);
-          if (fs5.existsSync(candidate)) {
+          if (fs13.existsSync(candidate)) {
             return { path: candidate, source: "prebuilt", platform, tried };
           }
         }
@@ -892,29 +892,29 @@ function resolveNativeBinary(runtimeDir) {
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const localCandidates = [];
   for (const bin of BINARY_NAMES) {
-    localCandidates.push(path6.resolve(base, `${bin}.node`));
-    localCandidates.push(path6.resolve(base, "..", `${bin}.node`));
-    localCandidates.push(path6.resolve(base, `${bin}.${platform}.node`));
-    localCandidates.push(path6.resolve(base, `${bin}.${napiPlatform}.node`));
+    localCandidates.push(path9.resolve(base, `${bin}.node`));
+    localCandidates.push(path9.resolve(base, "..", `${bin}.node`));
+    localCandidates.push(path9.resolve(base, `${bin}.${platform}.node`));
+    localCandidates.push(path9.resolve(base, `${bin}.${napiPlatform}.node`));
   }
   for (const startDir of [cwd, base]) {
     let dir = startDir;
     for (let i = 0; i < 6; i++) {
-      const nativeDir = path6.resolve(dir, "native");
+      const nativeDir = path9.resolve(dir, "native");
       for (const bin of BINARY_NAMES) {
-        localCandidates.push(path6.resolve(nativeDir, `${bin}.node`));
-        localCandidates.push(path6.resolve(nativeDir, `${bin}.${platform}.node`));
-        localCandidates.push(path6.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
-        localCandidates.push(path6.resolve(nativeDir, "target", "release", `${bin}.node`));
+        localCandidates.push(path9.resolve(nativeDir, `${bin}.node`));
+        localCandidates.push(path9.resolve(nativeDir, `${bin}.${platform}.node`));
+        localCandidates.push(path9.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
+        localCandidates.push(path9.resolve(nativeDir, "target", "release", `${bin}.node`));
       }
-      const parent = path6.resolve(dir, "..");
+      const parent = path9.resolve(dir, "..");
       if (parent === dir) break;
       dir = parent;
     }
   }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs5.existsSync(candidate)) {
+    if (fs13.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
@@ -953,9 +953,9 @@ var init_native_resolution = __esm({
 // packages/domain/shared/src/observability.ts
 function createObservabilityClient(opts = {}) {
   const { baseUrl = "http://localhost:7421", timeoutMs = 3e3 } = opts;
-  async function fetchJson(path13) {
+  async function fetchJson(path16) {
     try {
-      const res = await fetch(`${baseUrl}${path13}`, {
+      const res = await fetch(`${baseUrl}${path16}`, {
         signal: AbortSignal.timeout(timeoutMs)
       });
       if (!res.ok) return null;
@@ -987,6 +987,644 @@ var init_observability = __esm({
   }
 });
 
+// packages/domain/compiler/src/cssGeneratorNative.ts
+async function generateCssNative(classes, options) {
+  const {
+    theme,
+    fallbackToJs = true,
+    logFallback = false
+  } = options;
+  try {
+    const native = getNativeBridge();
+    if (!native?.generateCssNative) {
+      throw new Error("generateCssNative not available in native binding");
+    }
+    const themeJson = JSON.stringify(theme);
+    const css = native.generateCssNative(classes, themeJson);
+    return css;
+  } catch (error) {
+    if (!fallbackToJs) {
+      throw error;
+    }
+    if (logFallback) {
+      console.warn(
+        "[CSS Compiler] Rust CSS generator unavailable, falling back to JavaScript Tailwind",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    return generateRawCss(classes);
+  }
+}
+var init_cssGeneratorNative = __esm({
+  "packages/domain/compiler/src/cssGeneratorNative.ts"() {
+    init_nativeBridge();
+    init_tailwindEngine();
+  }
+});
+
+// packages/domain/compiler/src/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/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_src2();
+    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 = fs13__default.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path9__default.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (IGNORE_PATTERNS.some((p) => entry.name === p || entry.name.startsWith(p))) continue;
+      yield* walkSourceFiles(fullPath);
+    } else if (entry.isFile()) {
+      const ext = path9__default.extname(entry.name);
+      if (SOURCE_EXTENSIONS.has(ext)) yield fullPath;
+    }
+  }
+}
+function buildCssHeader(result) {
+  return [
+    "/* \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    " * tw-state-static.css \u2014 Auto-generated by staticStateExtractor.ts",
+    " * DO NOT EDIT. Re-generated on each build.",
+    " *",
+    ` * Files scanned:      ${result.filesScanned}`,
+    ` * Files with states:  ${result.filesWithStates}`,
+    ` * Components found:   ${result.componentsFound}`,
+    ` * Rules generated:    ${result.rulesGenerated}`,
+    ` * Rules skipped:      ${result.rulesSkipped} (akan di-inject runtime sebagai fallback)`,
+    " *",
+    ' * Selector format: .tw-s-[hash][data-stateName="true"] { ... }',
+    " * Hash identik dengan yang dibuat oleh stateEngine.ts di runtime.",
+    " * \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */",
+    ""
+  ].join("\n");
+}
+function extractStaticStateCss(srcDir, options = {}) {
+  const { verbose = false, maxFiles = Infinity } = options;
+  const native = getNative();
+  if (!native) {
+    if (verbose) {
+      process.stderr.write(
+        "[tw:static-state] native module tidak tersedia \u2014 skip static CSS pre-generation\n"
+      );
+    }
+    return {
+      filesScanned: 0,
+      filesWithStates: 0,
+      componentsFound: 0,
+      rulesGenerated: 0,
+      rulesSkipped: 0,
+      generatedCss: "",
+      rules: []
+    };
+  }
+  const allConfigs = [];
+  let filesScanned = 0;
+  let filesWithStates = 0;
+  if (native.walkAndPrefilterSourceFiles) {
+    const prefiltered = native.walkAndPrefilterSourceFiles(
+      srcDir,
+      [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"],
+      ["node_modules", ".next", "dist", "build", ".git", "coverage", "__tests__"],
+      // Required substrings — AND logic, identik dengan JS pre-filter di bawah
+      ["states:", "tw."],
+      maxFiles === Infinity ? null : maxFiles,
+      null
+      // sequential — parallel mode opsional untuk large monorepo
+    );
+    for (const { path: filePath, content: source } of prefiltered) {
+      filesScanned++;
+      const configs = native.extractTwStateConfigs(source, filePath);
+      if (configs.length > 0) {
+        filesWithStates++;
+        allConfigs.push(...configs);
+        if (verbose) {
+          process.stderr.write(
+            `[tw:static-state] ${path9__default.relative(srcDir, filePath)}: ${configs.length} komponen
+`
+          );
+        }
+      }
+    }
+  } else {
+    for (const filePath of walkSourceFiles(srcDir)) {
+      if (filesScanned >= maxFiles) break;
+      let source;
+      try {
+        source = fs13__default.readFileSync(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      filesScanned++;
+      if (!source.includes("states:") && !source.includes("states :")) continue;
+      if (!source.includes("tw.") && !source.includes("tailwind-styled")) continue;
+      const configs = native.extractTwStateConfigs(source, filePath);
+      if (configs.length > 0) {
+        filesWithStates++;
+        allConfigs.push(...configs);
+        if (verbose) {
+          process.stderr.write(
+            `[tw:static-state] ${path9__default.relative(srcDir, filePath)}: ${configs.length} komponen
+`
+          );
+        }
+      }
+    }
+  }
+  if (allConfigs.length === 0) {
+    return {
+      filesScanned,
+      filesWithStates: 0,
+      componentsFound: 0,
+      rulesGenerated: 0,
+      rulesSkipped: 0,
+      generatedCss: "",
+      rules: []
+    };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueConfigs = [];
+  for (const config of allConfigs) {
+    const key = `${config.tag}::${config.statesJson}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueConfigs.push({
+        tag: config.tag,
+        componentName: config.componentName,
+        statesJson: config.statesJson
+      });
+    }
+  }
+  const allRules = native.generateStaticStateCss(uniqueConfigs, options.resolvedCss ?? null);
+  const rulesSkipped = uniqueConfigs.reduce((total, cfg) => {
+    try {
+      const stateMap = JSON.parse(cfg.statesJson);
+      return total + Object.keys(stateMap).length;
+    } catch {
+      return total;
+    }
+  }, 0) - allRules.length;
+  const byComponent = /* @__PURE__ */ new Map();
+  for (const rule of allRules) {
+    const existing = byComponent.get(rule.componentName) ?? [];
+    existing.push(rule);
+    byComponent.set(rule.componentName, existing);
+  }
+  const cssBlocks = [];
+  for (const [componentName, rules] of byComponent) {
+    cssBlocks.push(`/* ${componentName} */`);
+    for (const rule of rules) {
+      cssBlocks.push(`/* state: ${rule.stateName} */`);
+      cssBlocks.push(rule.cssRule);
+    }
+    cssBlocks.push("");
+  }
+  const result = {
+    filesScanned,
+    filesWithStates,
+    componentsFound: allConfigs.length,
+    rulesGenerated: allRules.length,
+    rulesSkipped: Math.max(0, rulesSkipped),
+    generatedCss: cssBlocks.join("\n"),
+    rules: allRules
+  };
+  result.generatedCss = buildCssHeader(result) + result.generatedCss;
+  return result;
+}
+function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
+  const result = extractStaticStateCss(srcDir, options);
+  const twClassesDir = path9__default.join(path9__default.dirname(safelistPath), "tw-classes");
+  fs13__default.mkdirSync(twClassesDir, { recursive: true });
+  const stateFilePath = path9__default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+  if (result.rulesGenerated === 0) {
+    try {
+      fs13__default.writeFileSync(
+        stateFilePath,
+        "/* tw-state-static.css \u2014 tidak ada state rules yang di-generate */\n",
+        "utf-8"
+      );
+    } catch {
+    }
+    return `[tw:static-state] tidak ada state rules yang di-generate (${result.filesScanned} files di-scan)`;
+  }
+  try {
+    fs13__default.writeFileSync(stateFilePath, result.generatedCss, "utf-8");
+    return [
+      `[tw:static-state] ${result.rulesGenerated} static state rules di-generate`,
+      `  \u2192 ${result.filesScanned} files scanned, ${result.filesWithStates} dengan states`,
+      `  \u2192 ${result.componentsFound} components, ${result.rulesSkipped} rules skipped (fallback ke runtime)`,
+      `  \u2192 ditulis ke tw-classes/${TW_STATE_STATIC_FILENAME}`
+    ].join("\n");
+  } catch (writeErr) {
+    const msg = writeErr instanceof Error ? writeErr.message : String(writeErr);
+    return `[tw:static-state] gagal tulis state CSS: ${msg}`;
+  }
+}
+var SOURCE_EXTENSIONS, IGNORE_PATTERNS, _native, TW_STATE_STATIC_FILENAME;
+var init_staticStateExtractor = __esm({
+  "packages/domain/shared/src/staticStateExtractor.ts"() {
+    SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"]);
+    IGNORE_PATTERNS = ["node_modules", ".next", "dist", "build", ".git", "coverage", "__tests__"];
+    _native = null;
+    TW_STATE_STATIC_FILENAME = "_tw-state-static.css";
+  }
+});
+function getEnvLevel() {
+  const env = process.env.TWS_LOG_LEVEL?.toLowerCase();
+  if (env && env in LEVELS) return env;
+  return process.env.TWS_DEBUG_SCANNER === "1" ? "debug" : "info";
+}
+function setGlobalLogFile(filePath) {
+  _globalLogFile = filePath;
+  _logFileInitialized = false;
+  try {
+    fs13__default.mkdirSync(path9__default.dirname(filePath), { recursive: true });
+    fs13__default.writeFileSync(
+      filePath,
+      `# tailwind-styled build log \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
+`,
+      "utf-8"
+    );
+    _logFileInitialized = true;
+  } catch {
+  }
+}
+function writeToFile(line) {
+  if (!_globalLogFile || !_logFileInitialized) return;
+  try {
+    fs13__default.appendFileSync(_globalLogFile, line);
+  } catch {
+  }
+}
+function createLogger(prefix, level) {
+  const loggerState = {
+    currentLevel: getEnvLevel(),
+    setLevel(l) {
+      this.currentLevel = l;
+    }
+  };
+  const log7 = (msgLevel, stream, args) => {
+    if (LEVELS[msgLevel] > LEVELS[loggerState.currentLevel]) return;
+    const line = `[${prefix}] ${args.map(String).join(" ")}
+`;
+    process[stream].write(line);
+    writeToFile(line);
+  };
+  return {
+    error: (...a) => log7("error", "stderr", a),
+    warn: (...a) => log7("warn", "stderr", a),
+    info: (...a) => log7("info", "stdout", a),
+    debug: (...a) => log7("debug", "stderr", a),
+    setLevel: loggerState.setLevel,
+    setLogFile: (filePath) => setGlobalLogFile(filePath)
+  };
+}
+var LEVELS, _globalLogFile, _logFileInitialized;
+var init_logger = __esm({
+  "packages/domain/shared/src/logger.ts"() {
+    LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
+    _globalLogFile = null;
+    _logFileInitialized = false;
+    createLogger("tailwind-styled");
+  }
+});
+
 // packages/domain/shared/src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -1005,18 +1643,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 +1693,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 +1726,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 +1742,9 @@ function loadNativeBinding(options) {
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
   for (const candidate of candidates) {
-    const candidatePath = path6__default.resolve(runtimeDir, candidate);
+    const candidatePath = path9__default.resolve(runtimeDir, candidate);
     try {
-      if (!fs5__default.existsSync(candidatePath) && !fs5__default.existsSync(candidatePath + ".node")) {
+      if (!fs13__default.existsSync(candidatePath) && !fs13__default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -1134,9 +1776,9 @@ function resolveNativeBindingCandidates(options) {
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs5__default.existsSync(runtimeDir)) {
+  if (fs13__default.existsSync(runtimeDir)) {
     try {
-      for (const entry of fs5__default.readdirSync(runtimeDir)) {
+      for (const entry of fs13__default.readdirSync(runtimeDir)) {
         if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
@@ -1145,22 +1787,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();
   }
@@ -1188,6 +1830,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 +1865,8 @@ var init_src = __esm({
       /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
       static fromZod(err) {
         const first = err.issues?.[0] ?? err.errors?.[0];
-        const path13 = formatIssuePath(first?.path);
-        const message = first ? `${path13}: ${first.message}` : "Schema validation failed";
+        const path16 = formatIssuePath(first?.path);
+        const message = first ? `${path16}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -1286,11 +1930,11 @@ var init_src = __esm({
 });
 
 // packages/domain/compiler/src/nativeBridge.ts
-var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge;
+var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge, adaptNativeResult;
 var init_nativeBridge = __esm({
   "packages/domain/compiler/src/nativeBridge.ts"() {
     init_src();
-    _loadNative = (path13) => __require(path13);
+    _loadNative = (path16) => __require(path16);
     log = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -1339,6 +1983,15 @@ Tried paths: ${result.tried.join("\n")}`);
         throw bridgeLoadError;
       }
     };
+    adaptNativeResult = (raw) => {
+      return {
+        code: raw.code ?? "",
+        classes: raw.classes ?? [],
+        changed: raw.changed ?? false,
+        rsc: raw.rscJson ? JSON.parse(raw.rscJson) : void 0,
+        metadata: raw.metadataJson ? JSON.parse(raw.metadataJson) : void 0
+      };
+    };
     if (typeof process !== "undefined" && !bridgeLoadAttempted) {
       try {
         getNativeBridge();
@@ -1347,103 +2000,470 @@ Tried paths: ${result.tried.join("\n")}`);
     }
   }
 });
-
-// packages/domain/compiler/src/tailwindEngine.ts
-var tailwindEngine_exports = {};
-__export(tailwindEngine_exports, {
-  generateRawCss: () => generateRawCss,
-  processTailwindCssWithTargets: () => processTailwindCssWithTargets,
-  runCssPipeline: () => runCssPipeline,
-  runCssPipelineSync: () => runCssPipelineSync
-});
-function loadTailwindEngine() {
-  if (_twEngine) return _twEngine;
-  if (_twEngineError) throw _twEngineError;
-  try {
-    const tw = require2("tailwindcss");
-    if (typeof tw.compile !== "function") {
-      throw new Error("tailwindcss v4 not found \u2014 compile() API missing. Check tailwindcss version >= 4.");
-    }
-    _twEngine = tw;
-    return _twEngine;
-  } catch (e) {
-    _twEngineError = e instanceof Error ? e : new Error(String(e));
-    throw _twEngineError;
-  }
-}
-async function generateRawCss(classes, cssEntryContent, root) {
-  if (classes.length === 0) return "";
-  const tw = loadTailwindEngine();
-  const input = cssEntryContent ?? "@import 'tailwindcss';";
-  const { readFileSync, existsSync: existsSync3 } = await import('fs');
-  const { dirname, resolve: resolve2 } = await import('path');
-  const projectRoot = root ?? process.cwd();
-  const req = createRequire(resolve2(projectRoot, "package.json"));
-  const loadStylesheet = async (id, base) => {
-    try {
-      const cssId = id === "tailwindcss" ? "tailwindcss/index.css" : id === "tailwindcss/preflight" ? "tailwindcss/preflight.css" : id === "tailwindcss/utilities" ? "tailwindcss/utilities.css" : id === "tailwindcss/theme" ? "tailwindcss/theme.css" : id;
-      const pkgPath = req.resolve(cssId);
-      return {
-        content: readFileSync(pkgPath, "utf-8"),
-        base: dirname(pkgPath)
-      };
-    } catch {
-      try {
-        const absPath = resolve2(base, id);
-        if (existsSync3(absPath)) {
-          return { content: readFileSync(absPath, "utf-8"), base: dirname(absPath) };
-        }
-      } catch {
-      }
-      return { content: "", base };
-    }
-  };
-  const compiler = await Promise.resolve(tw.compile(input, { loadStylesheet }));
-  return compiler.build(classes);
-}
-function postProcessWithLightning(rawCss) {
-  if (!rawCss) return "";
+function _layoutClassesToCss(classes) {
   const native = getNativeBridge();
-  if (typeof native.processTailwindCssLightning !== "function") {
-    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
+  if (!native?.layoutClassesToCss) {
+    throw new Error("FATAL: Native binding 'layoutClassesToCss' is required but not available.");
   }
-  const result = native.processTailwindCssLightning(rawCss);
-  return result?.css ?? rawCss;
+  return native.layoutClassesToCss(classes);
 }
-async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
-  const unique = [...new Set(classes.filter(Boolean))];
-  if (unique.length === 0) {
-    return { css: "", classes: [], sizeBytes: 0, optimized: false };
-  }
-  const rawCss = await generateRawCss(unique, cssEntryContent, root);
+function _hashContainer(tag, containerJson, name) {
+  const sortedKey = tag + (name ?? "") + containerJson;
   const native = getNativeBridge();
-  const hasLightning = minify && typeof native.processTailwindCssLightning === "function";
-  const finalCss = hasLightning ? postProcessWithLightning(rawCss) : rawCss;
-  return {
-    css: finalCss,
-    classes: unique,
-    sizeBytes: finalCss.length,
-    optimized: hasLightning
-  };
-}
-function runCssPipelineSync(_classes) {
-  return { css: "", classes: [], sizeBytes: 0, optimized: false };
+  if (!native?.hashContent) {
+    throw new Error("FATAL: Native binding 'hashContent' is required but not available.");
+  }
+  return `tw-cq-${native.hashContent(sortedKey, "fnv", 6)}`;
 }
-function processTailwindCssWithTargets(css, targets) {
+function extractContainerCssFromSource(source) {
   const native = getNativeBridge();
-  if (!native?.processTailwindCssWithTargets) {
-    throw new Error("FATAL: Native binding 'processTailwindCssWithTargets' is required but not available.");
+  if (!native?.extractTwContainerConfigs) {
+    throw new Error("FATAL: Native binding 'extractTwContainerConfigs' is required but not available.");
+  }
+  const configs = native.extractTwContainerConfigs(source);
+  const rules = [];
+  for (const cfg of configs) {
+    const id = _hashContainer(cfg.tag, cfg.containerJson, cfg.containerName);
+    for (const { key, classes } of cfg.breakpoints) {
+      const minWidth = _CONTAINER_BREAKPOINTS[key] ?? key;
+      const css = _layoutClassesToCss(classes);
+      if (!css) continue;
+      const query = cfg.containerName ? `@container ${cfg.containerName} (min-width: ${minWidth})` : `@container (min-width: ${minWidth})`;
+      rules.push(`${query}{.${id}{${css}}}`);
+    }
   }
-  const result = native.processTailwindCssWithTargets(css, targets ?? null);
-  return (result?.css ?? css).trim();
+  return rules.join("\n");
 }
-var require2, _twEngine, _twEngineError;
-var init_tailwindEngine = __esm({
-  "packages/domain/compiler/src/tailwindEngine.ts"() {
+var transformSource, hasTwUsage, isAlreadyTransformed, shouldProcess, compileCssFromClasses, buildStyleTag, 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_src2 = __esm({
+  "packages/domain/compiler/src/index.ts"() {
     init_nativeBridge();
-    require2 = createRequire(import.meta.url);
-    _twEngine = null;
-    _twEngineError = null;
+    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) {
+        fs13__default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+      }
+      return allClasses;
+    };
+    loadSafelist = (safelistPath) => {
+      try {
+        const content = fs13__default.readFileSync(safelistPath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return [];
+      }
+    };
+    loadTailwindConfig = (cwd = process.cwd()) => {
+      const configFiles = [
+        "tailwind.config.ts",
+        "tailwind.config.js",
+        "tailwind.config.mjs",
+        "tailwind.config.cjs"
+      ];
+      for (const file of configFiles) {
+        const fullPath = path9__default.join(cwd, file);
+        if (fs13__default.existsSync(fullPath)) {
+          const mod = __require(fullPath);
+          return mod.default || mod;
+        }
+      }
+      return {};
+    };
+    getContentPaths = (cwd = process.cwd()) => {
+      return {
+        content: [
+          path9__default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          path9__default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          path9__default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
+        ]
+      };
+    };
+    _CONTAINER_BREAKPOINTS = {
+      xs: "240px",
+      sm: "320px",
+      md: "640px",
+      lg: "1024px",
+      xl: "1280px",
+      "2xl": "1536px"
+    };
+    runLoaderTransform = (ctx) => {
+      const { filepath, source, options } = ctx;
+      const result = transformSource(source, { filename: filepath, ...options });
+      let staticCss;
+      try {
+        const cssChunks = [];
+        const stateRules = extractAndGenerateStateCss(source, filepath);
+        if (stateRules.length > 0) {
+          cssChunks.push(stateRules.map((r) => r.cssRule).join("\n"));
+        }
+        const containerCss = extractContainerCssFromSource(source);
+        if (containerCss) cssChunks.push(containerCss);
+        const combined = cssChunks.join("\n").trim();
+        if (combined) staticCss = combined;
+      } catch {
+      }
+      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);
+    };
   }
 });
 
@@ -1481,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();
 }
@@ -1770,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 });
+  fs13__default.mkdirSync(path9__default.dirname(cachePath), { recursive: true });
   const result = cacheReadNative(cachePath);
   if (!result) return [];
   return result.entries.map((e) => ({
@@ -1790,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 });
+  fs13__default.mkdirSync(path9__default.dirname(cachePath), { recursive: true });
   const success = cacheWriteNative(cachePath, entries);
   if (!success) {
     throw new Error(
@@ -1817,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) => ({
@@ -1847,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) => {
@@ -1875,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));
   }
@@ -1894,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;
@@ -1919,12 +2918,12 @@ var formatIssuePath2, formatIssues, parseWithSchema, NonNegativeIntegerSchema, S
 var init_schemas = __esm({
   "packages/domain/scanner/src/schemas.ts"() {
     init_src();
-    formatIssuePath2 = (path13) => path13.length > 0 ? path13.map(
+    formatIssuePath2 = (path16) => path16.length > 0 ? path16.map(
       (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
     ).join(".") : "<root>";
     formatIssues = (error) => error.issues.map((issue) => {
-      const path13 = formatIssuePath2(issue.path);
-      return `${path13}: ${issue.message}`;
+      const path16 = formatIssuePath2(issue.path);
+      return `${path16}: ${issue.message}`;
     }).join("; ");
     parseWithSchema = (schema, data, label) => {
       const parsed = schema.safeParse(data);
@@ -1987,7 +2986,7 @@ __export(src_exports2, {
   DEFAULT_IGNORES: () => DEFAULT_IGNORES,
   batchExtractClassesNative: () => batchExtractClassesNative,
   extractClassesNative: () => extractClassesNative,
-  isScannableFile: () => isScannableFile,
+  isScannableFile: () => isScannableFile2,
   parseScanWorkspaceOptions: () => parseScanWorkspaceOptions,
   parseScanWorkspaceResult: () => parseScanWorkspaceResult,
   parseScannerWorkerMessage: () => parseScannerWorkerMessage,
@@ -2001,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();
 }
@@ -2011,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 (fs13__default.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -2078,19 +3077,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs5__default.readdirSync(currentDir, { withFileTypes: true });
+        return fs13__default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
     })();
     for (const entry of entries) {
-      const fullPath = path6__default.join(currentDir, entry.name);
+      const fullPath = path9__default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      if (!extensionSet.has(path6__default.extname(entry.name))) continue;
+      if (!extensionSet.has(path9__default.extname(entry.name))) continue;
       candidates.push(fullPath);
     }
   }
@@ -2116,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));
@@ -2177,7 +3176,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs5__default.statSync(filePath);
+          return fs13__default.statSync(filePath);
         } catch {
           return null;
         }
@@ -2203,7 +3202,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs5__default.readFileSync(filePath, "utf8");
+          return fs13__default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -2285,7 +3284,7 @@ async function scanWorkspaceAsync(rootDir, options = {}) {
   }
 }
 var log3, SCAN_WORKER_TIMEOUT_MS, createNativeParserLoader, nativeParserLoader, DEFAULT_EXTENSIONS, DEFAULT_IGNORES;
-var init_src2 = __esm({
+var init_src3 = __esm({
   "packages/domain/scanner/src/index.ts"() {
     init_src();
     init_cache_native();
@@ -2294,7 +3293,7 @@ var init_src2 = __esm({
     init_schemas();
     init_schemas();
     init_native_bridge();
-    log3 = createLogger("scanner");
+    log3 = createLogger2("scanner");
     SCAN_WORKER_TIMEOUT_MS = 12e4;
     createNativeParserLoader = () => {
       const _state = {
@@ -2307,7 +3306,7 @@ var init_src2 = __esm({
       const loadNativeParserBinding = () => {
         if (_state.binding !== void 0) return _state.binding;
         const runtimeDir = getRuntimeDir();
-        const req = createRequire(path6__default.join(runtimeDir, "noop.cjs"));
+        const req = createRequire(path9__default.join(runtimeDir, "noop.cjs"));
         const _platform = process.platform;
         const _arch = process.arch;
         const _platformArch = `${_platform}-${_arch}`;
@@ -2315,27 +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,
             "..",
             "..",
@@ -2347,7 +3346,7 @@ var init_src2 = __esm({
           )
         ];
         for (const fullPath of candidates) {
-          if (!fs5__default.existsSync(fullPath)) continue;
+          if (!fs13__default.existsSync(fullPath)) continue;
           try {
             const required = req(fullPath);
             if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
@@ -2472,48 +3471,11 @@ var init_native_bridge2 = __esm({
   }
 });
 
-// packages/domain/compiler/src/index.ts
-init_nativeBridge();
-var transformSource = (source, opts) => {
-  const native = getNativeBridge();
-  if (!native?.transformSource) {
-    throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
-  }
-  const result = native.transformSource(source, opts);
-  if (!result) {
-    throw new Error("FATAL: transformSource returned null");
-  }
-  return result;
-};
-var generateCssForClasses = async (classes, _tailwindConfig, root, cssEntryContent, minify = false) => {
-  const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
-  const result = await runCssPipeline2(classes, cssEntryContent, root, minify);
-  return result.css;
-};
-var mergeClassesStatic = (classes) => {
-  const result = normalizeAndDedupClasses(classes);
-  return result?.normalized || "";
-};
-var normalizeAndDedupClasses = (raw) => {
-  const native = getNativeBridge();
-  if (!native?.normalizeAndDedupClasses) {
-    throw new Error("FATAL: Native binding 'normalizeAndDedupClasses' is required but not available.");
-  }
-  const result = native.normalizeAndDedupClasses(raw);
-  return result || { normalized: "", duplicatesRemoved: 0, uniqueCount: 0 };
-};
-var runLoaderTransform = (ctx) => {
-  const { filepath, source, options } = ctx;
-  const result = transformSource(source, { filename: filepath, ...options });
-  return {
-    code: result?.code || "",
-    changed: result?.changed || false,
-    classes: result?.classes || []
-  };
-};
+// packages/presentation/vite/src/plugin.ts
+init_src2();
 
 // packages/domain/analyzer/src/analyzeWorkspace.ts
-init_src2();
+init_src3();
 
 // packages/domain/analyzer/src/binding.ts
 init_src();
@@ -2533,7 +3495,7 @@ function isRecord(value) {
 }
 async function pathExists(filePath) {
   try {
-    await fs5__default.promises.access(filePath, fs5__default.constants.F_OK);
+    await fs13__default.promises.access(filePath, fs13__default.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -2632,7 +3594,7 @@ async function requireNativeBinding() {
 
 // packages/domain/analyzer/src/schemas.ts
 init_src();
-var formatIssuePath3 = (path13) => path13.length > 0 ? path13.map(
+var formatIssuePath3 = (path16) => path16.length > 0 ? path16.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var isPlainObject = (value) => {
@@ -2641,8 +3603,8 @@ var isPlainObject = (value) => {
   return proto === Object.prototype || proto === null;
 };
 var formatIssues2 = (error) => error.issues.map((issue) => {
-  const path13 = formatIssuePath3(issue.path);
-  return `${path13}: ${issue.message}`;
+  const path16 = formatIssuePath3(issue.path);
+  return `${path16}: ${issue.message}`;
 }).join("; ");
 var parseWithSchema2 = (schema, data, label) => {
   const parsed = schema.safeParse(data);
@@ -2732,7 +3694,7 @@ var parseAnalyzerOptions = (options) => parseWithSchema2(AnalyzerOptionsSchema,
 var parseNativeReport = (report) => parseWithSchema2(NativeReportSchema, report, "Native analyzer report is invalid");
 var SUPPORTED_TAILWIND_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".cjs", ".mjs"]);
 var tailwindConfigCache = /* @__PURE__ */ new Map();
-var detectConflicts = async (usages) => {
+var detectConflicts2 = async (usages) => {
   const native = await getNativeBinding();
   if (!native?.detectClassConflicts) {
     throw new Error("FATAL: Native binding 'detectClassConflicts' is required but not available.");
@@ -2749,11 +3711,11 @@ var detectConflicts = async (usages) => {
   };
 };
 var isSupportedTailwindConfigPath = (configPath) => {
-  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path6__default.extname(configPath).toLowerCase());
+  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path9__default.extname(configPath).toLowerCase());
 };
 var resolveTailwindConfigPath = async (root, explicitPath) => {
   if (explicitPath) {
-    const resolved = path6__default.resolve(root, explicitPath);
+    const resolved = path9__default.resolve(root, explicitPath);
     if (!await pathExists(resolved)) return null;
     return resolved;
   }
@@ -2764,7 +3726,7 @@ var resolveTailwindConfigPath = async (root, explicitPath) => {
     "tailwind.config.mjs"
   ];
   for (const candidate of candidates) {
-    const fullPath = path6__default.resolve(root, candidate);
+    const fullPath = path9__default.resolve(root, candidate);
     if (await pathExists(fullPath)) return fullPath;
   }
   return null;
@@ -2818,8 +3780,8 @@ var collectCustomUtilities = (config) => {
   return out;
 };
 var collectSafelistFromSource = async (configPath) => {
-  const source = await fs5__default.promises.readFile(configPath, "utf8");
-  const { extractClassesNative: extractClassesNative2 } = await Promise.resolve().then(() => (init_src2(), src_exports2));
+  const source = await fs13__default.promises.readFile(configPath, "utf8");
+  const { extractClassesNative: extractClassesNative2 } = await Promise.resolve().then(() => (init_src3(), src_exports2));
   const allTokens = extractClassesNative2(source);
   const hasSafelist = source.includes("safelist");
   if (!hasSafelist) return [];
@@ -2832,7 +3794,7 @@ var collectSafelistFromSource = async (configPath) => {
   }
   return allTokens.filter((t) => safelistSet.has(t));
 };
-var loadTailwindConfig = async (root, semanticOption) => {
+var loadTailwindConfig2 = async (root, semanticOption) => {
   const startMs = Date.now();
   const configPath = await resolveTailwindConfigPath(root, semanticOption?.tailwindConfigPath);
   if (!configPath) return null;
@@ -2845,7 +3807,7 @@ var loadTailwindConfig = async (root, semanticOption) => {
       customUtilities: /* @__PURE__ */ new Set()
     };
   }
-  const configStat = await fs5__default.promises.stat(configPath).catch(() => null);
+  const configStat = await fs13__default.promises.stat(configPath).catch(() => null);
   if (configStat) {
     const cached = tailwindConfigCache.get(configPath);
     if (cached && cached.mtimeMs === configStat.mtimeMs && cached.size === configStat.size) {
@@ -2913,7 +3875,7 @@ var loadTailwindConfig = async (root, semanticOption) => {
   return loaded;
 };
 var buildSemanticReport = async (usages, root, semanticOption) => {
-  const loadedConfig = await loadTailwindConfig(root, semanticOption);
+  const loadedConfig = await loadTailwindConfig2(root, semanticOption);
   const safelist = loadedConfig?.safelist ?? /* @__PURE__ */ new Set();
   const customUtilities = loadedConfig?.customUtilities ?? /* @__PURE__ */ new Set();
   const usageNames = new Set(usages.map((usage) => usage.name));
@@ -2932,7 +3894,7 @@ var buildSemanticReport = async (usages, root, semanticOption) => {
     results.filter((r) => !r.isKnown).map((r) => r.className)
   );
   const unknownClasses = usages.filter((usage) => unknownSet.has(usage.name)).map((usage) => ({ ...usage, isUnused: true }));
-  const { conflicts } = await detectConflicts(usages);
+  const { conflicts } = await detectConflicts2(usages);
   return {
     unusedClasses,
     unknownClasses,
@@ -3004,7 +3966,7 @@ async function buildDistribution(usages, native) {
 }
 async function analyzeWorkspace(root, options = {}) {
   const startedAtMs = Date.now();
-  const resolvedRoot = path6__default.resolve(root);
+  const resolvedRoot = path9__default.resolve(root);
   const normalizedOptions = parseAnalyzerOptions(options);
   const scan = await (async () => {
     const scanStartedAtMs = Date.now();
@@ -3107,15 +4069,16 @@ async function analyzeWorkspace(root, options = {}) {
 }
 
 // packages/domain/engine/src/index.ts
-init_src2();
+init_internal();
+init_src3();
 init_src();
 
 // packages/domain/engine/src/incremental.ts
-init_src2();
+init_src3();
 init_src();
 init_native_bridge2();
 var DEFAULT_EXTENSIONS2 = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
-var log5 = createLogger("engine:incremental");
+var log5 = createLogger2("engine:incremental");
 function rebuildWorkspaceResult(byFile) {
   const files = Array.from(byFile.values());
   const native = getNativeEngineBinding();
@@ -3145,9 +4108,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(
@@ -3163,7 +4126,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 = fs13__default.readFileSync(normalizedPath, "utf8");
   const diff = native.processFileChange(normalizedPath, scanned.classes, content);
   const existing = byFile.get(normalizedPath);
   if (diff && existing) {
@@ -3232,8 +4195,8 @@ var METRICS_FILE_NAME = "metrics.json";
 var CACHE_DIR = ".tw-cache";
 function writeMetrics(metrics, cwd = process.cwd()) {
   try {
-    const cacheDir = path6__default.join(cwd, CACHE_DIR);
-    fs5__default.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = path9__default.join(cwd, CACHE_DIR);
+    fs13__default.mkdirSync(cacheDir, { recursive: true });
     const mem = process.memoryUsage();
     const data = {
       ...metrics,
@@ -3244,7 +4207,7 @@ function writeMetrics(metrics, cwd = process.cwd()) {
       },
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs5__default.writeFileSync(path6__default.join(cacheDir, METRICS_FILE_NAME), JSON.stringify(data, null, 2));
+    fs13__default.writeFileSync(path9__default.join(cacheDir, METRICS_FILE_NAME), JSON.stringify(data, null, 2));
   } catch {
   }
 }
@@ -3351,19 +4314,19 @@ var parseEngineOptions = (options) => parseWithSchema3(EngineOptionsSchema, opti
 var parseEngineWatchOptions = (options) => parseWithSchema3(EngineWatchOptionsSchema, options ?? {}, "engine watch options are invalid");
 
 // packages/domain/engine/src/watch.ts
-var _native = null;
+var _native2 = null;
 function getNativeWatcher() {
-  if (_native !== null) return _native;
+  if (_native2 !== null) return _native2;
   try {
     const { resolveNativeBinary: resolveNativeBinary2 } = (init_src(), __toCommonJS(src_exports));
     const { path: binPath } = resolveNativeBinary2(__dirname);
     if (binPath) {
-      _native = __require(binPath);
+      _native2 = __require(binPath);
     }
   } catch {
-    _native = {};
+    _native2 = {};
   }
-  return _native;
+  return _native2;
 }
 function watchWorkspaceNative(rootDir, onEvent, options) {
   const native = getNativeWatcher();
@@ -3440,11 +4403,11 @@ var configState = {
     return this.tailwindConfigLoaded;
   }
 };
-var log6 = createLogger("engine");
+var log6 = createLogger2("engine");
 async function loadTailwindConfigFromPath(root, tailwindConfigPath) {
   if (!tailwindConfigPath) return void 0;
-  const configPath = path6__default.resolve(root, tailwindConfigPath);
-  if (!fs5__default.existsSync(configPath)) {
+  const configPath = path9__default.resolve(root, tailwindConfigPath);
+  if (!fs13__default.existsSync(configPath)) {
     throw TwError.fromIo("CONFIG_NOT_FOUND", `tailwindConfigPath not found: ${configPath}`);
   }
   const imported = await import(pathToFileURL(configPath).href);
@@ -3510,13 +4473,14 @@ async function buildFromScan(scan, root, options, tailwindConfig) {
   };
 }
 function countWorkspacePackages(root) {
-  const packagesDir = path6__default.join(root, "packages");
-  if (!fs5__default.existsSync(packagesDir)) return 0;
+  const packagesDir = path9__default.join(root, "packages");
+  if (!fs13__default.existsSync(packagesDir)) return 0;
   try {
-    return fs5__default.readdirSync(packagesDir, { withFileTypes: true }).filter(
-      (entry) => entry.isDirectory() && fs5__default.existsSync(path6__default.join(packagesDir, entry.name, "package.json"))
+    return fs13__default.readdirSync(packagesDir, { withFileTypes: true }).filter(
+      (entry) => entry.isDirectory() && fs13__default.existsSync(path9__default.join(packagesDir, entry.name, "package.json"))
     ).length;
-  } catch {
+  } catch (err) {
+    log6.debug(`countWorkspacePackages: ${err instanceof Error ? err.message : String(err)}`);
     return 0;
   }
 }
@@ -3550,7 +4514,7 @@ function writeDashboardMetrics(root, mode, result, metrics) {
 async function createEngine(rawOptions = {}) {
   const options = parseEngineOptions(rawOptions);
   const root = options.root ?? process.cwd();
-  const resolvedRoot = path6__default.resolve(root);
+  const resolvedRoot = path9__default.resolve(root);
   const plugins = rawOptions.plugins ?? [];
   const getTailwindConfig = async () => {
     if (configState.isLoaded()) return configState.getConfig();
@@ -3697,12 +4661,13 @@ async function createEngine(rawOptions = {}) {
       const shouldForceFullRescan = (event) => {
         if (event.type === "unlink") return false;
         try {
-          const stat = fs5__default.statSync(event.filePath);
+          const stat = fs13__default.statSync(event.filePath);
           if (stat.size > largeFileThreshold) {
             metrics.markSkippedLargeFile();
             return true;
           }
-        } catch {
+        } catch (statErr) {
+          log6.debug(`stat failed for ${event.filePath}: ${statErr instanceof Error ? statErr.message : String(statErr)}`);
           return false;
         }
         return false;
@@ -3816,7 +4781,7 @@ async function createEngine(rawOptions = {}) {
 
 // packages/presentation/vite/src/schemas.ts
 init_src();
-var formatIssuePath4 = (path13) => path13.length > 0 ? path13.map(
+var formatIssuePath4 = (path16) => path16.length > 0 ? path16.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var formatIssues4 = (error) => error.issues.map((issue) => {
@@ -3862,14 +4827,14 @@ function warnDeprecated(options, key, message) {
   }
 }
 function isInsideDirectory(filePath, directory) {
-  const relative = path6__default.relative(directory, filePath);
-  return relative === "" || !relative.startsWith("..") && !path6__default.isAbsolute(relative);
+  const relative = path9__default.relative(directory, filePath);
+  return relative === "" || !relative.startsWith("..") && !path9__default.isAbsolute(relative);
 }
 function filterScanToDirs(scan, root, scanDirs) {
-  const resolvedDirs = scanDirs.map((dir) => path6__default.resolve(root, dir));
+  const resolvedDirs = scanDirs.map((dir) => path9__default.resolve(root, dir));
   if (resolvedDirs.length === 0) return scan;
   const files = scan.files.filter((file) => {
-    const absoluteFile = path6__default.resolve(file.file);
+    const absoluteFile = path9__default.resolve(file.file);
     return resolvedDirs.some((directory) => isInsideDirectory(absoluteFile, directory));
   });
   const uniqueClasses = Array.from(new Set(files.flatMap((file) => file.classes))).sort();
@@ -3880,9 +4845,9 @@ function filterScanToDirs(scan, root, scanDirs) {
   };
 }
 function writeJsonArtifact(root, relativePath, value) {
-  const outputPath = path6__default.resolve(root, relativePath);
-  fs5__default.mkdirSync(path6__default.dirname(outputPath), { recursive: true });
-  fs5__default.writeFileSync(outputPath, `${JSON.stringify(value, null, 2)}
+  const outputPath = path9__default.resolve(root, relativePath);
+  fs13__default.mkdirSync(path9__default.dirname(outputPath), { recursive: true });
+  fs13__default.writeFileSync(outputPath, `${JSON.stringify(value, null, 2)}
 `);
 }
 function tailwindStyledPlugin(opts = {}) {
@@ -3909,12 +4874,77 @@ function tailwindStyledPlugin(opts = {}) {
   const transformRunner = rawOptions.__internalTransformRunner ?? runLoaderTransform;
   const engineFactory = rawOptions.__internalCreateEngine ?? createEngine;
   const pluginState = { root: process.cwd(), isDev: true };
+  const staticCssPerFile = /* @__PURE__ */ new Map();
+  function deduplicateStaticCss(css) {
+    const seen = /* @__PURE__ */ new Set();
+    const rules = [];
+    for (const chunk of css.split(/(?<=\})\s*/)) {
+      const rule = chunk.trim();
+      if (rule && !seen.has(rule)) {
+        seen.add(rule);
+        rules.push(rule);
+      }
+    }
+    return rules.join("\n");
+  }
+  function getStaticCssOutputPath(root, safelistOutputPath) {
+    return path9__default.resolve(root, path9__default.dirname(safelistOutputPath), "_tw-state-static.css");
+  }
+  function flushStaticCss(root) {
+    if (staticCssPerFile.size === 0) return;
+    const combined = Array.from(staticCssPerFile.values()).join("\n");
+    const deduped = deduplicateStaticCss(combined);
+    if (!deduped.trim()) return;
+    const outPath = getStaticCssOutputPath(root, safelistOutput);
+    try {
+      fs13__default.mkdirSync(path9__default.dirname(outPath), { recursive: true });
+      fs13__default.writeFileSync(
+        outPath,
+        `/* _tw-state-static.css \u2014 Auto-generated by tailwind-styled-v4. DO NOT EDIT.
+ * Import this in globals.css: @import "./_tw-state-static.css";
+ * Contains: state CSS (.tw-s-*[data-*="true"]) + container queries (@container .tw-cq-*).
+ */
+
+${deduped}
+`
+      );
+    } catch (e) {
+      console.warn("[tailwind-styled-v4] Could not write _tw-state-static.css:", e);
+    }
+  }
   return {
     name: "tailwind-styled-v4",
     enforce: "pre",
     configResolved(config) {
       pluginState.root = config.root;
       pluginState.isDev = config.command === "serve";
+      try {
+        const outPath = getStaticCssOutputPath(config.root, safelistOutput);
+        const CSS_CANDIDATES = [
+          "src/index.css",
+          "src/main.css",
+          "src/App.css",
+          "src/styles/index.css",
+          "src/styles/main.css",
+          "src/globals.css",
+          "src/style.css"
+        ];
+        for (const candidate of CSS_CANDIDATES) {
+          const candidatePath = path9__default.resolve(config.root, candidate);
+          if (!fs13__default.existsSync(candidatePath)) continue;
+          const content = fs13__default.readFileSync(candidatePath, "utf-8");
+          if (content.includes("_tw-state-static.css")) break;
+          const rel = path9__default.relative(path9__default.dirname(candidatePath), outPath).replace(/\\/g, "/");
+          const importLine = `@import "./${rel}";`;
+          const tailwindImportRe = /(@import\s+["']tailwindcss["']\s*;[^\n]*\n?)/;
+          const updated = tailwindImportRe.test(content) ? content.replace(tailwindImportRe, `$1${importLine}
+`) : `${importLine}
+${content}`;
+          fs13__default.writeFileSync(candidatePath, updated, "utf-8");
+          break;
+        }
+      } catch {
+      }
     },
     transform(source, id) {
       const filepath = id.split("?")[0];
@@ -3940,6 +4970,12 @@ function tailwindStyledPlugin(opts = {}) {
         return null;
       }
       if (!output.changed) return null;
+      if (output.staticCss) {
+        staticCssPerFile.set(filepath, output.staticCss);
+        if (pluginState.isDev) {
+          flushStaticCss(pluginState.root);
+        }
+      }
       return { code: output.code, map: null };
     },
     async buildEnd() {
@@ -3957,6 +4993,10 @@ function tailwindStyledPlugin(opts = {}) {
         if (doSafelist) {
           writeJsonArtifact(pluginState.root, safelistOutput, scan.uniqueClasses);
         }
+        flushStaticCss(pluginState.root);
+        console.log(
+          `[tailwind-styled-v4] Static CSS: ${staticCssPerFile.size} files \u2192 _tw-state-static.css`
+        );
         writeJsonArtifact(pluginState.root, scanReportOutput, {
           root: pluginState.root,
           totalFiles: scan.totalFiles,