tailwind-styled-v4 5.0.8 → 5.0.10

package/dist/cli.mjs

@@ -1,10 +1,14 @@
-import path3, { join, extname } from 'path';
-import { pathToFileURL, fileURLToPath } from 'url';
-import { z } from 'zod';
-import fs8, { readFileSync, readdirSync } from 'fs';
 import { createRequire } from 'module';
-import { Worker } from 'worker_threads';
-import fs4 from 'fs/promises';
+import * as fs11 from 'fs';
+import fs11__default, { readFileSync, readdirSync } from 'fs';
+import * as path6 from 'path';
+import path6__default, { join, extname } from 'path';
+import 'crypto';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
+import { availableParallelism } from 'os';
+import { z } from 'zod';
+import fs7 from 'fs/promises';
 import { isTTY, spinner, note, outro, intro, text, isCancel, select, confirm } from '@clack/prompts';
 import { parseArgs } from 'util';
 import { spawn } from 'child_process';
@@ -983,8 +987,8 @@ var require_command = __commonJS({
   "packages/infrastructure/cli/node_modules/commander/lib/command.js"(exports$1) {
     var EventEmitter = __require("events").EventEmitter;
     var childProcess = __require("child_process");
-    var path26 = __require("path");
-    var fs12 = __require("fs");
+    var path29 = __require("path");
+    var fs15 = __require("fs");
     var process2 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1915,11 +1919,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path26.resolve(baseDir, baseName);
-          if (fs12.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path26.extname(baseName))) return void 0;
+          const localBin = path29.resolve(baseDir, baseName);
+          if (fs15.existsSync(localBin)) return localBin;
+          if (sourceExt.includes(path29.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs12.existsSync(`${localBin}${ext}`)
+            (ext) => fs15.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1931,21 +1935,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs12.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs15.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path26.resolve(
-            path26.dirname(resolvedScriptPath),
+          executableDir = path29.resolve(
+            path29.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path26.basename(
+            const legacyName = path29.basename(
               this._scriptPath,
-              path26.extname(this._scriptPath)
+              path29.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1956,7 +1960,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path26.extname(executableFile));
+        launchWithNode = sourceExt.includes(path29.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -2796,7 +2800,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path26.basename(filename, path26.extname(filename));
+        this._name = path29.basename(filename, path29.extname(filename));
         return this;
       }
       /**
@@ -2810,9 +2814,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path27) {
-        if (path27 === void 0) return this._executableDir;
-        this._executableDir = path27;
+      executableDir(path30) {
+        if (path30 === void 0) return this._executableDir;
+        this._executableDir = path30;
         return this;
       }
       /**
@@ -3152,45 +3156,6 @@ var init_esmHelpers = __esm({
     _nodeUrl = null;
   }
 });
-
-// packages/domain/shared/src/native-resolution.ts
-function getNodeModuleRef2() {
-  if (isBrowser2) return null;
-  if (nodeModuleRef2 !== null) return nodeModuleRef2;
-  try {
-    const test = typeof __require === "function" ? __require("module") : null;
-    nodeModuleRef2 = test;
-    return test;
-  } catch {
-    nodeModuleRef2 = null;
-    return null;
-  }
-}
-function getNodeFs() {
-  if (isBrowser2) return { existsSync: () => false };
-  const nodeRequire = getNodeModuleRef2();
-  if (!nodeRequire) return { existsSync: () => false };
-  if (!_nodeFs) _nodeFs = nodeRequire.createRequire(import.meta.url)("node:fs");
-  return _nodeFs;
-}
-function getNodePath2() {
-  if (isBrowser2) return { resolve: () => "", dirname: "" };
-  const nodeRequire = getNodeModuleRef2();
-  if (!nodeRequire) return { resolve: () => "", dirname: "" };
-  if (!_nodePath2) _nodePath2 = nodeRequire.createRequire(import.meta.url)("node:path");
-  return _nodePath2;
-}
-function getRequire(_importMetaUrl) {
-  if (isBrowser2) return () => {
-    throw new Error("node:module not available");
-  };
-  const nodeRequire = getNodeModuleRef2();
-  if (!nodeRequire) return () => {
-    throw new Error("require not available");
-  };
-  if (!_require) _require = nodeRequire.createRequire(_importMetaUrl);
-  return _require;
-}
 function platformKey() {
   if (isBrowser2) return "browser";
   return `${process.platform}-${process.arch}`;
@@ -3201,24 +3166,21 @@ function resolveNativeBinary(runtimeDir) {
   if (isBrowser2) {
     return { path: null, source: "not-found", platform, tried: ["not available in browser"] };
   }
-  const fs12 = getNodeFs();
-  const path26 = getNodePath2();
-  const _req = getRequire(import.meta.url);
+  if (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 (fs12.existsSync(envPath)) {
+    if (fs11.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
   }
-  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_NO_RUST === "1" || process.env.TWS_DISABLE_NATIVE === "1") {
-    return { path: null, source: "not-found", platform, tried: ["disabled by env"] };
-  }
   const prebuiltPkgs = PLATFORM_MAP[platform] ?? [];
   for (const pkg of prebuiltPkgs) {
     try {
-      const candidate = _req.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs12.existsSync(candidate)) {
+      const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
+      if (fs11.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -3228,30 +3190,43 @@ function resolveNativeBinary(runtimeDir) {
   }
   const cwd2 = process.cwd();
   const base = runtimeDir ?? cwd2;
-  const localCandidates = [
-    path26.resolve(base, "tailwind_styled_parser.node"),
-    path26.resolve(base, "..", "tailwind_styled_parser.node"),
-    path26.resolve(cwd2, "native", "tailwind_styled_parser.node"),
-    path26.resolve(cwd2, "native", "target", "release", "tailwind_styled_parser.node"),
-    // napi-rs conventional output
-    path26.resolve(base, `tailwind_styled_parser.${platform}.node`)
-  ];
+  const napiPlatform = platform === "linux-x64" ? "linux-x64-gnu" : platform === "linux-arm64" ? "linux-arm64-gnu" : platform;
+  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`));
+  }
+  for (const startDir of [cwd2, base]) {
+    let dir = startDir;
+    for (let i = 0; i < 6; i++) {
+      const nativeDir = path6.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`));
+      }
+      const parent = path6.resolve(dir, "..");
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs12.existsSync(candidate)) {
+    if (fs11.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
   return { path: null, source: "not-found", platform, tried };
 }
-var isBrowser2, nodeModuleRef2, _nodeFs, _nodePath2, _require, PLATFORM_MAP;
+var isBrowser2, _require, PLATFORM_MAP;
 var init_native_resolution = __esm({
   "packages/domain/shared/src/native-resolution.ts"() {
     isBrowser2 = typeof window !== "undefined" || typeof document !== "undefined";
-    nodeModuleRef2 = null;
-    _nodeFs = null;
-    _nodePath2 = null;
-    _require = null;
+    _require = typeof __require !== "undefined" ? __require : createRequire(import.meta.url);
     PLATFORM_MAP = {
       "linux-x64": ["@tailwind-styled/native-linux-x64"],
       "linux-arm64": ["@tailwind-styled/native-linux-arm64"],
@@ -3262,41 +3237,6 @@ var init_native_resolution = __esm({
     };
   }
 });
-
-// packages/domain/shared/src/index.ts
-function getNodeModuleRef3() {
-  if (isBrowser3) return null;
-  if (nodeModuleRef3 !== null) return nodeModuleRef3;
-  try {
-    const test = typeof __require === "function" ? __require("module") : null;
-    nodeModuleRef3 = test;
-    return test;
-  } catch {
-    nodeModuleRef3 = null;
-    return null;
-  }
-}
-function getNodeFs2() {
-  if (isBrowser3) throw new Error("node:fs not available in browser");
-  const nodeRequire = getNodeModuleRef3();
-  if (!nodeRequire) throw new Error("require not available");
-  if (!_nodeFs2) _nodeFs2 = nodeRequire.createRequire(import.meta.url)("node:fs");
-  return _nodeFs2;
-}
-function getNodePath3() {
-  if (isBrowser3) throw new Error("node:path not available in browser");
-  const nodeRequire = getNodeModuleRef3();
-  if (!nodeRequire) throw new Error("require not available");
-  if (!_nodePath3) _nodePath3 = nodeRequire.createRequire(import.meta.url)("node:path");
-  return _nodePath3;
-}
-function getNodeUrl2() {
-  if (isBrowser3) throw new Error("node:url not available in browser");
-  const nodeRequire = getNodeModuleRef3();
-  if (!nodeRequire) throw new Error("require not available");
-  if (!_nodeUrl2) _nodeUrl2 = nodeRequire.createRequire(import.meta.url)("node:url");
-  return _nodeUrl2;
-}
 function createLogger(namespace) {
   const prefix = `[${namespace}]`;
   return {
@@ -3326,9 +3266,9 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path26) {
-  if (!path26 || path26.length === 0) return "(root)";
-  return path26.map(
+function formatIssuePath(path29) {
+  if (!path29 || path29.length === 0) return "(root)";
+  return path29.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
@@ -3336,17 +3276,12 @@ function wrapUnknownError(domain, code, error) {
   return TwError.wrap(domain, code, error);
 }
 function loadNativeBinding(options) {
-  if (isBrowser3) {
-    return { binding: null, loadErrors: [{ path: "", message: "Native bindings not available in browser" }] };
-  }
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
-  const path26 = getNodePath3();
-  const fs12 = getNodeFs2();
   for (const candidate of candidates) {
-    const candidatePath = path26.resolve(runtimeDir, candidate);
+    const candidatePath = path6__default.resolve(runtimeDir, candidate);
     try {
-      if (!fs12.existsSync(candidatePath) && !fs12.existsSync(candidatePath + ".node")) {
+      if (!fs11__default.existsSync(candidatePath) && !fs11__default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -3360,74 +3295,58 @@ function loadNativeBinding(options) {
   }
   return { binding: null, loadErrors };
 }
-function getRequire2() {
-  if (isBrowser3) return (() => {
-    throw new Error("require not available in browser");
-  });
-  const nodeRequire = getNodeModuleRef3();
-  if (!nodeRequire) return (() => {
-    throw new Error("require not available");
-  });
-  return nodeRequire.createRequire(import.meta.url);
-}
-function requireNativeModule(path26) {
-  return _require2(path26);
+function requireNativeModule(p) {
+  return _require2(p);
 }
 function resolveNativeBindingCandidates(options) {
-  if (isBrowser3) return [];
-  const { runtimeDir, envVarNames = [], includeDefaultCandidates = true, enforceNodeExtensionForEnvPath = false } = options;
+  const {
+    envVarNames = ["TW_NATIVE_PATH", "TWS_NATIVE_PATH"],
+    includeDefaultCandidates = true,
+    enforceNodeExtensionForEnvPath = false
+  } = options;
+  const runtimeDir = options.runtimeDir || process.cwd();
   const candidates = [];
-  const path26 = getNodePath3();
-  const fs12 = getNodeFs2();
   for (const envVar of envVarNames) {
     const envPath = process.env[envVar];
     if (envPath) {
-      if (enforceNodeExtensionForEnvPath && !envPath.endsWith(".node")) {
-        candidates.push(envPath + ".node");
-      } else {
-        candidates.push(envPath);
-      }
+      candidates.push(enforceNodeExtensionForEnvPath && !envPath.endsWith(".node") ? envPath + ".node" : envPath);
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs12.existsSync(runtimeDir)) {
+  if (fs11__default.existsSync(runtimeDir)) {
     try {
-      const entries = fs12.readdirSync(runtimeDir);
-      for (const entry of entries) {
-        if (entry.endsWith(".node")) {
-          candidates.push(entry);
-        }
+      for (const entry of fs11__default.readdirSync(runtimeDir)) {
+        if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
     }
   }
-  const platform = typeof process !== "undefined" ? process.platform : "";
-  const ext = platform === "win32" ? ".dll" : platform === "darwin" ? ".dylib" : ".so";
-  const defaultBindingName = `tailwind_styled_parser${ext}`;
-  candidates.push(path26.resolve(runtimeDir, "..", "..", "..", "native", defaultBindingName));
-  candidates.push(path26.resolve(runtimeDir, "..", "..", "..", "..", "native", defaultBindingName));
-  candidates.push(path26.resolve(process.cwd(), "native", defaultBindingName));
+  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(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path6__default.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(path6__default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+  }
   return Array.from(new Set(candidates));
 }
 function resolveRuntimeDir(dir, importMetaUrl) {
-  if (isBrowser3) return "";
-  if (dir) return getNodePath3().resolve(dir);
+  if (dir) return path6__default.resolve(dir);
   try {
-    return getNodeUrl2().fileURLToPath(importMetaUrl);
+    return path6__default.dirname(fileURLToPath(importMetaUrl));
   } catch {
     return process.cwd();
   }
 }
-var isBrowser3, nodeModuleRef3, _nodeFs2, _nodePath3, _nodeUrl2, TwError, _require2;
+var TwError, _require2;
 var init_src = __esm({
   "packages/domain/shared/src/index.ts"() {
     init_esmHelpers();
     init_native_resolution();
-    isBrowser3 = typeof window !== "undefined" || typeof document !== "undefined";
-    nodeModuleRef3 = null;
-    _nodeFs2 = null;
-    _nodePath3 = null;
-    _nodeUrl2 = null;
     TwError = class _TwError extends Error {
       /** @deprecated Gunakan source */
       domain;
@@ -3461,8 +3380,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 path26 = formatIssuePath(first?.path);
-        const message = first ? `${path26}: ${first.message}` : "Schema validation failed";
+        const path29 = formatIssuePath(first?.path);
+        const message = first ? `${path29}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -3480,21 +3399,33 @@ var init_src = __esm({
         return `[${this.source.toUpperCase()}:${this.code}] ${this.message}`;
       }
     };
-    _require2 = getRequire2();
+    _require2 = createRequire(import.meta.url);
   }
 });
 
 // packages/domain/scanner/src/native-bridge.ts
 var native_bridge_exports = {};
 __export(native_bridge_exports, {
+  batchExtractClassesNative: () => batchExtractClassesNative,
   cachePriorityNative: () => cachePriorityNative,
   cacheReadNative: () => cacheReadNative,
   cacheWriteNative: () => cacheWriteNative,
+  collectFilesNative: () => collectFilesNative,
+  computeCacheStatsNative: () => computeCacheStatsNative,
   extractClassesNative: () => extractClassesNative,
+  generateSubComponentTypesNative: () => generateSubComponentTypesNative,
   hasNativeScannerBinding: () => hasNativeScannerBinding,
   hashContentNative: () => hashContentNative,
   isRustCacheAvailable: () => isRustCacheAvailable,
+  pruneStaleEntriesNative: () => pruneStaleEntriesNative,
+  rebuildWorkspaceResultNative: () => rebuildWorkspaceResultNative,
   resetScannerBridgeCache: () => resetScannerBridgeCache,
+  scanCacheGet: () => scanCacheGet,
+  scanCacheInvalidate: () => scanCacheInvalidate,
+  scanCachePut: () => scanCachePut,
+  scanCacheStats: () => scanCacheStats,
+  scanFileNative: () => scanFileNative,
+  scanFilesBatchNative: () => scanFilesBatchNative,
   scanWorkspaceNative: () => scanWorkspaceNative
 });
 function getDirname2() {
@@ -3502,7 +3433,7 @@ function getDirname2() {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path3.dirname(fileURLToPath(import.meta.url));
+    return path6__default.dirname(fileURLToPath(import.meta.url));
   }
   return process.cwd();
 }
@@ -3583,6 +3514,95 @@ function cachePriorityNative(mtimeMs, size, cachedMtimeMs, cachedSize, cachedHit
   }
   return result;
 }
+function batchExtractClassesNative(filePaths) {
+  const binding = scannerGetBinding();
+  if (!binding.batchExtractClasses) {
+    throw new Error("FATAL: Native binding 'batchExtractClasses' is required but not available.");
+  }
+  return binding.batchExtractClasses(filePaths) ?? [];
+}
+function scanCacheGet(filePath, contentHash) {
+  const binding = scannerGetBinding();
+  if (!binding.scanCacheGet) {
+    throw new Error("FATAL: Native binding 'scanCacheGet' is required but not available.");
+  }
+  return binding.scanCacheGet(filePath, contentHash) ?? null;
+}
+function scanCachePut(filePath, contentHash, classes, mtimeMs, size) {
+  const binding = scannerGetBinding();
+  if (!binding.scanCachePut) {
+    throw new Error("FATAL: Native binding 'scanCachePut' is required but not available.");
+  }
+  binding.scanCachePut(filePath, contentHash, classes, mtimeMs, size);
+}
+function scanCacheInvalidate(filePath) {
+  const binding = scannerGetBinding();
+  if (!binding.scanCacheInvalidate) {
+    throw new Error("FATAL: Native binding 'scanCacheInvalidate' is required but not available.");
+  }
+  binding.scanCacheInvalidate(filePath);
+}
+function scanCacheStats() {
+  const binding = scannerGetBinding();
+  if (!binding.scanCacheStats) {
+    throw new Error("FATAL: Native binding 'scanCacheStats' is required but not available.");
+  }
+  return binding.scanCacheStats();
+}
+function scanFileNative(filePath) {
+  const binding = scannerGetBinding();
+  if (!binding.scanFile) {
+    throw new Error("FATAL: Native binding 'scanFile' is required but not available.");
+  }
+  return binding.scanFile(filePath);
+}
+function collectFilesNative(root, extensions, ignoreDirs) {
+  const binding = scannerGetBinding();
+  if (!binding.collectFiles) return null;
+  return binding.collectFiles(root, extensions, ignoreDirs);
+}
+function scanFilesBatchNative(filePaths) {
+  const binding = scannerGetBinding();
+  if (!binding.scanFilesBatch) {
+    return filePaths.map((fp) => {
+      try {
+        const r = binding.scanFile?.(fp);
+        return r ? { file: r.file, classes: r.classes, hash: r.hash ?? "" } : { file: fp, classes: [], hash: "" };
+      } catch {
+        return { file: fp, classes: [], hash: "" };
+      }
+    });
+  }
+  return binding.scanFilesBatch(filePaths);
+}
+function generateSubComponentTypesNative(root, outputPath) {
+  const binding = scannerGetBinding();
+  if (!binding.generateSubComponentTypes) return null;
+  return binding.generateSubComponentTypes(root, outputPath ?? null);
+}
+function pruneStaleEntriesNative(entries, maxAgeMs, checkExists) {
+  const binding = scannerGetBinding();
+  if (!binding.pruneStaleEntries) return null;
+  return binding.pruneStaleEntries(
+    entries.map((e) => ({ file: e.file, lastSeenMs: e.lastSeenMs ?? 0 })),
+    maxAgeMs ?? null,
+    checkExists ?? null
+  );
+}
+function rebuildWorkspaceResultNative(files) {
+  const binding = scannerBridgeLoader.get();
+  if (!binding?.rebuildWorkspaceResult) return null;
+  try {
+    return binding.rebuildWorkspaceResult(files);
+  } catch {
+    return null;
+  }
+}
+function computeCacheStatsNative(filesClasses, sizes, top) {
+  const binding = scannerGetBinding();
+  if (!binding.computeCacheStats) return null;
+  return binding.computeCacheStats(filesClasses, sizes, top ?? null);
+}
 var log, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
 var init_native_bridge = __esm({
   "packages/domain/scanner/src/native-bridge.ts"() {
@@ -3667,8 +3687,8 @@ var init_native_bridge = __esm({
   }
 });
 function defaultCachePath(rootDir, cacheDir) {
-  const dir = cacheDir ? path3.resolve(rootDir, cacheDir) : path3.join(process.cwd(), ".cache", "tailwind-styled");
-  return path3.join(dir, "scanner-cache.json");
+  const dir = cacheDir ? path6__default.resolve(rootDir, cacheDir) : path6__default.join(process.cwd(), ".cache", "tailwind-styled");
+  return path6__default.join(dir, "scanner-cache.json");
 }
 function readCache(rootDir, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
@@ -3709,16 +3729,117 @@ var init_cache_native = __esm({
     init_native_bridge();
   }
 });
+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 = fs11__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;
+}
+function mergeResults(batchResults) {
+  const files = batchResults.map((r) => ({
+    file: r.file,
+    classes: r.classes,
+    hash: r.content_hash
+  }));
+  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() };
+}
+function runChunkInWorker(filePaths) {
+  return new Promise((resolve2, reject) => {
+    const worker = new Worker(_workerFilename, {
+      workerData: { filePaths }
+    });
+    worker.once("message", (payload) => {
+      if (payload.ok) {
+        resolve2(payload.results);
+      } else {
+        reject(new Error(payload.error ?? "parallel-scanner worker failed"));
+      }
+    });
+    worker.once("error", reject);
+    worker.once("exit", (code) => {
+      if (code !== 0) reject(new Error(`parallel-scanner worker exited with code ${code}`));
+    });
+  });
+}
+async function scanWorkspaceParallel(rootDir, options = {}) {
+  const {
+    extensions = DEFAULT_EXTENSIONS,
+    ignoreDirs = DEFAULT_IGNORES,
+    maxWorkers = Math.max(1, availableParallelism() - 1),
+    chunkSize = DEFAULT_CHUNK_SIZE
+  } = options;
+  const files = collectFiles(path6__default.resolve(rootDir), extensions, ignoreDirs);
+  if (files.length < PARALLEL_THRESHOLD) {
+    return mergeResults(batchExtractClassesNative(files));
+  }
+  const chunks = [];
+  for (let i = 0; i < files.length; i += chunkSize) {
+    chunks.push(files.slice(i, i + chunkSize));
+  }
+  const allResults = [];
+  for (let i = 0; i < chunks.length; i += maxWorkers) {
+    const batch = chunks.slice(i, i + maxWorkers);
+    const batchResults = await Promise.all(batch.map(runChunkInWorker));
+    allResults.push(...batchResults.flat());
+  }
+  return mergeResults(allResults);
+}
+var PARALLEL_THRESHOLD, DEFAULT_CHUNK_SIZE, _workerFilename;
+var init_parallel_scanner = __esm({
+  "packages/domain/scanner/src/parallel-scanner.ts"() {
+    init_src2();
+    init_native_bridge();
+    PARALLEL_THRESHOLD = 50;
+    DEFAULT_CHUNK_SIZE = 150;
+    if (!isMainThread && parentPort) {
+      const { filePaths } = workerData;
+      try {
+        const results = batchExtractClassesNative(filePaths);
+        const msg = { ok: true, results };
+        parentPort.postMessage(msg);
+      } catch (error) {
+        const msg = {
+          ok: false,
+          error: error instanceof Error ? error.message : String(error)
+        };
+        parentPort.postMessage(msg);
+      }
+    }
+    _workerFilename = typeof __filename !== "undefined" ? __filename : fileURLToPath(import.meta.url);
+  }
+});
 var formatIssuePath2, formatIssues, parseWithSchema, NonNegativeIntegerSchema, ScanWorkspaceOptionsSchema, ScanFileResultSchema, ScanWorkspaceResultSchema, ScannerWorkerSuccessMessageSchema, ScannerWorkerErrorMessageSchema, ScannerWorkerMessageSchema, parseScanWorkspaceOptions, parseScanWorkspaceResult, parseScannerWorkerMessage;
 var init_schemas = __esm({
   "packages/domain/scanner/src/schemas.ts"() {
     init_src();
-    formatIssuePath2 = (path26) => path26.length > 0 ? path26.map(
+    formatIssuePath2 = (path29) => path29.length > 0 ? path29.map(
       (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
     ).join(".") : "<root>";
     formatIssues = (error) => error.issues.map((issue) => {
-      const path26 = formatIssuePath2(issue.path);
-      return `${path26}: ${issue.message}`;
+      const path29 = formatIssuePath2(issue.path);
+      return `${path29}: ${issue.message}`;
     }).join("; ");
     parseWithSchema = (schema, data, label) => {
       const parsed = schema.safeParse(data);
@@ -3773,12 +3894,29 @@ var init_schemas = __esm({
     parseScannerWorkerMessage = (message) => parseWithSchema(ScannerWorkerMessageSchema, message, "scanner worker message is invalid");
   }
 });
+
+// packages/domain/scanner/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_EXTENSIONS: () => DEFAULT_EXTENSIONS,
+  DEFAULT_IGNORES: () => DEFAULT_IGNORES,
+  batchExtractClassesNative: () => batchExtractClassesNative,
+  extractClassesNative: () => extractClassesNative,
+  isScannableFile: () => isScannableFile,
+  parseScanWorkspaceOptions: () => parseScanWorkspaceOptions,
+  parseScanWorkspaceResult: () => parseScanWorkspaceResult,
+  parseScannerWorkerMessage: () => parseScannerWorkerMessage,
+  scanFile: () => scanFile,
+  scanSource: () => scanSource,
+  scanWorkspace: () => scanWorkspace,
+  scanWorkspaceAsync: () => scanWorkspaceAsync
+});
 function getRuntimeDir() {
   if (typeof __dirname !== "undefined" && __dirname.length > 0) {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path3.dirname(fileURLToPath(import.meta.url));
+    return path6__default.dirname(fileURLToPath(import.meta.url));
   }
   return process.cwd();
 }
@@ -3788,17 +3926,17 @@ function resolveScannerWorkerModulePath() {
       return __dirname;
     }
     if (typeof import.meta !== "undefined" && import.meta.url) {
-      return path3.dirname(fileURLToPath(import.meta.url));
+      return path6__default.dirname(fileURLToPath(import.meta.url));
     }
     return process.cwd();
   })();
   const candidates = [
-    path3.resolve(runtimeDir, "worker.cjs"),
-    path3.resolve(runtimeDir, "worker.js"),
-    path3.resolve(runtimeDir, "worker.ts")
+    path6__default.resolve(runtimeDir, "worker.cjs"),
+    path6__default.resolve(runtimeDir, "worker.js"),
+    path6__default.resolve(runtimeDir, "worker.ts")
   ];
   for (const candidate of candidates) {
-    if (fs8.existsSync(candidate)) return candidate;
+    if (fs11__default.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -3808,7 +3946,7 @@ function scanWorkspaceInWorker(rootDir, options) {
   if (!modulePath) {
     return Promise.reject(new Error("scanner worker module path could not be resolved"));
   }
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const settleState = { settled: false };
     const worker = new Worker(modulePath, { workerData: { rootDir, options: normalizedOptions } });
     const timeout = setTimeout(() => {
@@ -3828,7 +3966,7 @@ function scanWorkspaceInWorker(rootDir, options) {
       const message = parseScannerWorkerMessage(payload);
       finish(() => {
         if (message?.ok) {
-          resolve(parseScanWorkspaceResult(message.result));
+          resolve2(parseScanWorkspaceResult(message.result));
           return;
         }
         reject(new Error(message?.error ?? "scanner worker failed without an error message"));
@@ -3855,19 +3993,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs8.readdirSync(currentDir, { withFileTypes: true });
+        return fs11__default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
     })();
     for (const entry of entries) {
-      const fullPath = path3.join(currentDir, entry.name);
+      const fullPath = path6__default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      if (!extensionSet.has(path3.extname(entry.name))) continue;
+      if (!extensionSet.has(path6__default.extname(entry.name))) continue;
       candidates.push(fullPath);
     }
   }
@@ -3881,9 +4019,12 @@ function toCacheSize(size) {
 function scanSource(source) {
   const nativeBinding = nativeParserLoader.get();
   if (nativeBinding?.extractClassesFromSource) {
-    const classes = nativeBinding.extractClassesFromSource(source);
-    if (Array.isArray(classes)) {
-      return Array.from(new Set(classes.filter(Boolean)));
+    const result = nativeBinding.extractClassesFromSource(source);
+    if (Array.isArray(result)) {
+      return Array.from(new Set(result.filter(Boolean)));
+    }
+    if (result !== null && result !== void 0 && Array.isArray(result.classes)) {
+      return Array.from(new Set(result.classes.filter(Boolean)));
     }
   }
   throw new Error(
@@ -3891,15 +4032,18 @@ function scanSource(source) {
   );
 }
 function isScannableFile(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
-  return includeExtensions.includes(path3.extname(filePath));
+  return includeExtensions.includes(path6__default.extname(filePath));
 }
 function scanFile(filePath) {
-  const source = fs8.readFileSync(filePath, "utf8");
-  const hash = hashContentNative(source) ?? void 0;
+  const { scanFileNative: scanFileNative2 } = (init_native_bridge(), __toCommonJS(native_bridge_exports));
+  const result = scanFileNative2(filePath);
+  if (!result.ok) {
+    throw new Error(`scanFile failed for ${filePath}: ${result.error ?? "unknown error"}`);
+  }
   return {
-    file: filePath,
-    classes: scanSource(source),
-    ...hash ? { hash } : {}
+    file: result.file,
+    classes: result.classes,
+    ...result.hash ? { hash: result.hash } : {}
   };
 }
 function scanWorkspace(rootDir, options = {}) {
@@ -3948,7 +4092,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs8.statSync(filePath);
+          return fs11__default.statSync(filePath);
         } catch {
           return null;
         }
@@ -3974,7 +4118,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs8.readFileSync(filePath, "utf8");
+          return fs11__default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -4036,14 +4180,21 @@ function scanWorkspace(rootDir, options = {}) {
 }
 async function scanWorkspaceAsync(rootDir, options = {}) {
   const normalizedOptions = parseScanWorkspaceOptions(options);
-  if (process.env.TWS_DISABLE_SCANNER_WORKER === "1") {
-    return scanWorkspace(rootDir, normalizedOptions);
+  try {
+    return await scanWorkspaceParallel(rootDir, {
+      extensions: normalizedOptions.includeExtensions,
+      ignoreDirs: normalizedOptions.ignoreDirectories
+    });
+  } catch (parallelError) {
+    log2.debug(
+      `parallel scan failed, retrying with single worker: ${parallelError instanceof Error ? parallelError.message : String(parallelError)}`
+    );
   }
   try {
     return await scanWorkspaceInWorker(rootDir, normalizedOptions);
   } catch (error) {
     log2.debug(
-      `worker scan failed, falling back to sync scanner: ${error instanceof Error ? error.message : String(error)}`
+      `worker scan failed, retrying with sync native scanner: ${error instanceof Error ? error.message : String(error)}`
     );
     return scanWorkspace(rootDir, normalizedOptions);
   }
@@ -4054,7 +4205,10 @@ var init_src2 = __esm({
     init_src();
     init_cache_native();
     init_native_bridge();
+    init_parallel_scanner();
     init_schemas();
+    init_schemas();
+    init_native_bridge();
     log2 = createLogger("scanner");
     SCAN_WORKER_TIMEOUT_MS = 12e4;
     createNativeParserLoader = () => {
@@ -4068,12 +4222,25 @@ var init_src2 = __esm({
       const loadNativeParserBinding = () => {
         if (_state.binding !== void 0) return _state.binding;
         const runtimeDir = getRuntimeDir();
-        const req = createRequire(path3.join(runtimeDir, "noop.cjs"));
+        const req = createRequire(path6__default.join(runtimeDir, "noop.cjs"));
         const candidates = [
-          path3.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
-          path3.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
-          path3.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
-          path3.resolve(
+          // ── 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.${process.platform}-${process.arch}.node`),
+          path6__default.resolve(process.cwd(), "native", `tailwind-styled-native.${process.platform}-${process.arch}-gnu.node`),
+          // runtimeDir = dist/ → naik 4 level ke repo root
+          path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+          path6__default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${process.platform}-${process.arch}-gnu.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.${process.platform}-${process.arch}-gnu.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,
             "..",
             "..",
@@ -4085,7 +4252,7 @@ var init_src2 = __esm({
           )
         ];
         for (const fullPath of candidates) {
-          if (!fs8.existsSync(fullPath)) continue;
+          if (!fs11__default.existsSync(fullPath)) continue;
           try {
             const required = req(fullPath);
             if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
@@ -4127,7 +4294,7 @@ function isRecord(value) {
 }
 async function pathExists(filePath) {
   try {
-    await fs8.promises.access(filePath, fs8.constants.F_OK);
+    await fs11__default.promises.access(filePath, fs11__default.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -4153,6 +4320,9 @@ var init_utils = __esm({
 });
 
 // packages/domain/analyzer/src/binding.ts
+async function getNativeBinding() {
+  return analyzerBindingLoader.get();
+}
 async function requireNativeBinding() {
   const binding = await analyzerBindingLoader.get();
   if (binding?.analyzeClasses) return binding;
@@ -4245,7 +4415,7 @@ var formatIssuePath3, isPlainObject, formatIssues2, parseWithSchema2, CountSchem
 var init_schemas2 = __esm({
   "packages/domain/analyzer/src/schemas.ts"() {
     init_src();
-    formatIssuePath3 = (path26) => path26.length > 0 ? path26.map(
+    formatIssuePath3 = (path29) => path29.length > 0 ? path29.map(
       (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
     ).join(".") : "<root>";
     isPlainObject = (value) => {
@@ -4254,8 +4424,8 @@ var init_schemas2 = __esm({
       return proto === Object.prototype || proto === null;
     };
     formatIssues2 = (error) => error.issues.map((issue) => {
-      const path26 = formatIssuePath3(issue.path);
-      return `${path26}: ${issue.message}`;
+      const path29 = formatIssuePath3(issue.path);
+      return `${path29}: ${issue.message}`;
     }).join("; ");
     parseWithSchema2 = (schema, data, label) => {
       const parsed = schema.safeParse(data);
@@ -4351,117 +4521,12 @@ var init_schemas2 = __esm({
     parseClassToCssOptions = (options) => parseWithSchema2(ClassToCssOptionsSchema, options ?? {}, "classToCss options are invalid");
   }
 });
-var SUPPORTED_TAILWIND_CONFIG_EXTENSIONS, KNOWN_UTILITY_PREFIXES, tailwindConfigCache, splitVariantAndBase, isArbitraryUtility, resolveConflictGroup, detectConflicts, isSupportedTailwindConfigPath, resolveTailwindConfigPath, collectSafelistFromConfig, collectCustomUtilities, collectSafelistFromSource, loadTailwindConfig, utilityPrefix, isKnownTailwindClass, buildSemanticReport;
+var SUPPORTED_TAILWIND_CONFIG_EXTENSIONS, tailwindConfigCache, splitVariantAndBase, isArbitraryUtility, resolveConflictGroup, detectConflicts, isSupportedTailwindConfigPath, resolveTailwindConfigPath, collectSafelistFromConfig, collectCustomUtilities, collectSafelistFromSource, loadTailwindConfig, utilityPrefix, buildSemanticReport;
 var init_semantic = __esm({
   "packages/domain/analyzer/src/semantic.ts"() {
+    init_binding();
     init_utils();
     SUPPORTED_TAILWIND_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".cjs", ".mjs"]);
-    KNOWN_UTILITY_PREFIXES = /* @__PURE__ */ new Set([
-      "absolute",
-      "align",
-      "animate",
-      "arbitrary",
-      "aspect",
-      "backdrop",
-      "basis",
-      "bg",
-      "block",
-      "border",
-      "bottom",
-      "col",
-      "container",
-      "contents",
-      "cursor",
-      "dark",
-      "display",
-      "divide",
-      "fill",
-      "fixed",
-      "flex",
-      "float",
-      "font",
-      "from",
-      "gap",
-      "grid",
-      "grow",
-      "h",
-      "hidden",
-      "inset",
-      "inline",
-      "isolate",
-      "items",
-      "justify",
-      "left",
-      "leading",
-      "line",
-      "list",
-      "m",
-      "max-h",
-      "max-w",
-      "mb",
-      "min-h",
-      "min-w",
-      "ml",
-      "mr",
-      "mt",
-      "mx",
-      "my",
-      "object",
-      "opacity",
-      "order",
-      "origin",
-      "outline",
-      "overflow",
-      "overscroll",
-      "p",
-      "pb",
-      "pe",
-      "perspective",
-      "place",
-      "pl",
-      "pointer",
-      "position",
-      "pr",
-      "ps",
-      "pt",
-      "px",
-      "py",
-      "relative",
-      "right",
-      "ring",
-      "rotate",
-      "rounded",
-      "row",
-      "scale",
-      "shadow",
-      "shrink",
-      "size",
-      "skew",
-      "snap",
-      "space-x",
-      "space-y",
-      "sr",
-      "start",
-      "static",
-      "sticky",
-      "stroke",
-      "table",
-      "text",
-      "to",
-      "top",
-      "touch",
-      "tracking",
-      "transform",
-      "transition",
-      "translate",
-      "truncate",
-      "underline",
-      "via",
-      "visible",
-      "w",
-      "whitespace",
-      "z"
-    ]);
     tailwindConfigCache = /* @__PURE__ */ new Map();
     splitVariantAndBase = (className) => {
       const parts = className.split(":");
@@ -4491,48 +4556,28 @@ var init_semantic = __esm({
       if (base.startsWith("m-") || base.startsWith("mx-") || base.startsWith("my-")) return "margin";
       return null;
     };
-    detectConflicts = (usages) => {
-      const buckets = /* @__PURE__ */ new Map();
-      for (const usage of usages) {
-        const { variantKey, base } = splitVariantAndBase(usage.name);
-        const group = resolveConflictGroup(base);
-        if (!group) continue;
-        const key = `${variantKey}::${group}`;
-        const bucket = buckets.get(key) ?? {
-          variantKey,
-          group,
-          classes: /* @__PURE__ */ new Set()
-        };
-        bucket.classes.add(usage.name);
-        buckets.set(key, bucket);
-      }
-      const conflicts = [];
-      const conflictedClassNames = /* @__PURE__ */ new Set();
-      for (const bucket of buckets.values()) {
-        if (bucket.classes.size <= 1) continue;
-        const classes = Array.from(bucket.classes).sort();
-        for (const className of classes) conflictedClassNames.add(className);
-        const variantLabel = bucket.variantKey.length > 0 ? bucket.variantKey : "base";
-        conflicts.push({
-          className: bucket.group,
-          variants: bucket.variantKey.length > 0 ? bucket.variantKey.split(":") : [],
-          classes,
-          message: `Multiple ${bucket.group} utilities detected for "${variantLabel}".`
-        });
+    detectConflicts = async (usages) => {
+      const native = await getNativeBinding();
+      if (!native?.detectClassConflicts) {
+        throw new Error("FATAL: Native binding 'detectClassConflicts' is required but not available.");
       }
-      conflicts.sort((left, right) => {
-        if (right.classes.length !== left.classes.length)
-          return right.classes.length - left.classes.length;
-        return left.className.localeCompare(right.className);
-      });
-      return { conflicts, conflictedClassNames };
+      const result = native.detectClassConflicts(JSON.stringify(usages.map((u) => ({ name: u.name, count: u.count }))));
+      return {
+        conflicts: result.conflicts.map((c) => ({
+          className: c.group,
+          variants: c.variantKey.length > 0 ? c.variantKey.split(":") : [],
+          classes: c.classes,
+          message: c.message
+        })),
+        conflictedClassNames: new Set(result.conflictedClassNames)
+      };
     };
     isSupportedTailwindConfigPath = (configPath) => {
-      return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path3.extname(configPath).toLowerCase());
+      return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path6__default.extname(configPath).toLowerCase());
     };
     resolveTailwindConfigPath = async (root, explicitPath) => {
       if (explicitPath) {
-        const resolved = path3.resolve(root, explicitPath);
+        const resolved = path6__default.resolve(root, explicitPath);
         if (!await pathExists(resolved)) return null;
         return resolved;
       }
@@ -4543,7 +4588,7 @@ var init_semantic = __esm({
         "tailwind.config.mjs"
       ];
       for (const candidate of candidates) {
-        const fullPath = path3.resolve(root, candidate);
+        const fullPath = path6__default.resolve(root, candidate);
         if (await pathExists(fullPath)) return fullPath;
       }
       return null;
@@ -4597,15 +4642,19 @@ var init_semantic = __esm({
       return out;
     };
     collectSafelistFromSource = async (configPath) => {
-      const source = await fs8.promises.readFile(configPath, "utf8");
-      const safelistBlock = source.match(/safelist\s*:\s*\[([\s\S]*?)\]/m)?.[1];
-      if (!safelistBlock) return [];
-      const out = /* @__PURE__ */ new Set();
-      for (const token of safelistBlock.matchAll(/["'`]([^"'`]+)["'`]/g)) {
+      const source = await fs11__default.promises.readFile(configPath, "utf8");
+      const { extractClassesNative: extractClassesNative2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+      const allTokens = extractClassesNative2(source);
+      const hasSafelist = source.includes("safelist");
+      if (!hasSafelist) return [];
+      const safelistMatch = source.match(/safelist\s*:\s*\[([\s\S]*?)\]/m)?.[1];
+      if (!safelistMatch) return [];
+      const safelistSet = /* @__PURE__ */ new Set();
+      for (const token of safelistMatch.matchAll(/["'`]([^"'`]+)["'`]/g)) {
         const value = token[1].trim();
-        if (value.length > 0) out.add(value);
+        if (value.length > 0) safelistSet.add(value);
       }
-      return Array.from(out);
+      return allTokens.filter((t) => safelistSet.has(t));
     };
     loadTailwindConfig = async (root, semanticOption) => {
       const startMs = Date.now();
@@ -4620,7 +4669,7 @@ var init_semantic = __esm({
           customUtilities: /* @__PURE__ */ new Set()
         };
       }
-      const configStat = await fs8.promises.stat(configPath).catch(() => null);
+      const configStat = await fs11__default.promises.stat(configPath).catch(() => null);
       if (configStat) {
         const cached = tailwindConfigCache.get(configPath);
         if (cached && cached.mtimeMs === configStat.mtimeMs && cached.size === configStat.size) {
@@ -4706,21 +4755,27 @@ var init_semantic = __esm({
       if (hyphen < 0) return normalized;
       return normalized.slice(0, hyphen);
     };
-    isKnownTailwindClass = (className, safelist, customUtilities) => {
-      if (safelist.has(className) || customUtilities.has(className)) return true;
-      const { base } = splitVariantAndBase(className);
-      if (customUtilities.has(base)) return true;
-      const prefix = utilityPrefix(base);
-      return KNOWN_UTILITY_PREFIXES.has(prefix);
-    };
     buildSemanticReport = async (usages, root, semanticOption) => {
       const loadedConfig = await loadTailwindConfig(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));
       const unusedClasses = Array.from(safelist).filter((className) => !usageNames.has(className)).sort().map((className) => ({ name: className, count: 0, isUnused: true }));
-      const unknownClasses = usages.filter((usage) => !isKnownTailwindClass(usage.name, safelist, customUtilities)).map((usage) => ({ ...usage, isUnused: true }));
-      const { conflicts } = detectConflicts(usages);
+      const native = await getNativeBinding();
+      if (!native?.classifyKnownClasses) {
+        throw new Error("FATAL: Native binding 'classifyKnownClasses' is required but not available.");
+      }
+      const classNames = usages.map((u) => u.name);
+      const results = native.classifyKnownClasses(
+        classNames,
+        Array.from(safelist),
+        Array.from(customUtilities)
+      );
+      const unknownSet = new Set(
+        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);
       return {
         unusedClasses,
         unknownClasses,
@@ -4756,13 +4811,17 @@ function normalizeScan(scan, includeClass) {
     uniqueClasses: Array.from(unique).sort()
   };
 }
-function collectClassCounts(scan) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const file of scan.files) {
-    for (const className of file.classes) {
-      counts.set(className, (counts.get(className) ?? 0) + 1);
-    }
+async function collectClassCounts(scan) {
+  const native = await requireNativeBinding();
+  if (!native?.collectClassCounts) {
+    throw new Error("FATAL: Native binding 'collectClassCounts' is required but not available.");
   }
+  const filesJson = JSON.stringify(
+    scan.files.map((f) => ({ file: f.file ?? "", classes: f.classes }))
+  );
+  const result = native.collectClassCounts(filesJson);
+  const counts = /* @__PURE__ */ new Map();
+  for (const entry of result) counts.set(entry.name, entry.count);
   return counts;
 }
 function buildClassUsage(counts) {
@@ -4771,29 +4830,24 @@ function buildClassUsage(counts) {
     return left.name.localeCompare(right.name);
   });
 }
-function buildDistribution(usages) {
-  const distribution = {
-    "1": 0,
-    "2-3": 0,
-    "4-7": 0,
-    "8+": 0
-  };
-  for (const usage of usages) {
-    if (usage.count === 1) {
-      distribution["1"] += 1;
-    } else if (usage.count <= 3) {
-      distribution["2-3"] += 1;
-    } else if (usage.count <= 7) {
-      distribution["4-7"] += 1;
-    } else {
-      distribution["8+"] += 1;
-    }
+async function buildDistribution(usages, native) {
+  const binding = native ?? await requireNativeBinding();
+  if (!binding?.buildDistribution) {
+    throw new Error("FATAL: Native binding 'buildDistribution' is required but not available.");
   }
-  return distribution;
+  const result = binding.buildDistribution(
+    JSON.stringify(usages.map((u) => ({ name: u.name, count: u.count })))
+  );
+  return {
+    "1": result.once,
+    "2-3": result.few,
+    "4-7": result.moderate,
+    "8+": result.frequent
+  };
 }
 async function analyzeWorkspace(root, options = {}) {
   const startedAtMs = Date.now();
-  const resolvedRoot = path3.resolve(root);
+  const resolvedRoot = path6__default.resolve(root);
   const normalizedOptions = parseAnalyzerOptions(options);
   const scan = await (async () => {
     const scanStartedAtMs = Date.now();
@@ -4837,7 +4891,7 @@ async function analyzeWorkspace(root, options = {}) {
       );
     }
   })();
-  const counts = collectClassCounts(normalizedScan);
+  const counts = await collectClassCounts(normalizedScan);
   const baseAll = buildClassUsage(counts);
   const { all, semanticReport } = await (async () => {
     if (!normalizedOptions.semantic) {
@@ -4863,13 +4917,19 @@ async function analyzeWorkspace(root, options = {}) {
       );
     }
   })();
-  const top = all.slice(0, topLimit);
-  const frequent = all.filter((usage) => usage.count >= frequentThreshold).slice(0, topLimit);
-  const unique = all.filter((usage) => usage.count === 1);
-  const totalClassOccurrences = all.reduce((sum, usage) => sum + usage.count, 0);
+  const classStatsNative = binding?.computeClassStats?.(
+    JSON.stringify(all),
+    topLimit,
+    frequentThreshold
+  );
+  const top = classStatsNative ? JSON.parse(classStatsNative.topJson) : all.slice(0, topLimit);
+  const frequent = classStatsNative ? JSON.parse(classStatsNative.frequentJson) : all.filter((usage) => usage.count >= frequentThreshold).slice(0, topLimit);
+  const unique = classStatsNative ? JSON.parse(classStatsNative.uniqueJson) : all.filter((usage) => usage.count === 1);
+  const totalClassOccurrences = classStatsNative ? classStatsNative.totalClassOccurrences : all.reduce((sum, usage) => sum + usage.count, 0);
   debugLog(
     `analyzeWorkspace completed in ${Date.now() - startedAtMs}ms (files=${normalizedScan.totalFiles}, uniqueClasses=${all.length})`
   );
+  const distribution = await buildDistribution(all, binding);
   return {
     root: nativeReport.root || resolvedRoot,
     totalFiles: nativeReport.totalFiles,
@@ -4880,8 +4940,10 @@ async function analyzeWorkspace(root, options = {}) {
       top,
       frequent,
       unique,
-      distribution: buildDistribution(all)
+      distribution
     },
+    // topClasses — alias for classStats.top (test contract & backward compat)
+    topClasses: top,
     safelist: all.map((usage) => usage.name),
     ...semanticReport ? { semantic: semanticReport } : {}
   };
@@ -4903,8 +4965,11 @@ var init_classToCss = __esm({
     init_binding();
     init_schemas2();
     init_utils();
-    normalizeClassInput = (input) => {
+    normalizeClassInput = (input, _binding) => {
       if (typeof input === "string") {
+        if (_binding?.normalizeClassInput) {
+          return _binding.normalizeClassInput(input);
+        }
         return input.split(/\s+/).map((item) => item.trim()).filter((item) => item.length > 0);
       }
       if (!Array.isArray(input)) {
@@ -4926,27 +4991,26 @@ var init_classToCss = __esm({
       const prefix = parsed.prefix ?? null;
       return { prefix, strict };
     };
-    mergeDeclarationMap = (target, css) => {
-      for (const ruleMatch of css.matchAll(/\{([^}]*)\}/g)) {
-        const body = ruleMatch[1];
-        for (const raw of body.split(";")) {
-          const declaration = raw.trim();
-          if (declaration.length === 0) continue;
-          const colonIndex = declaration.indexOf(":");
-          if (colonIndex <= 0) continue;
-          const property = declaration.slice(0, colonIndex).trim();
-          const value = declaration.slice(colonIndex + 1).trim();
-          if (property.length === 0 || value.length === 0) continue;
-          if (target.has(property)) target.delete(property);
-          target.set(property, value);
-        }
+    mergeDeclarationMap = (target, css, binding) => {
+      if (!binding.parseCssRules) {
+        throw new Error("FATAL: Native binding 'parseCssRules' is required but not available.");
+      }
+      const rules = binding.parseCssRules(css);
+      for (const rule of rules) {
+        if (target.has(rule.property)) target.delete(rule.property);
+        target.set(rule.property, rule.isImportant ? `${rule.value} !important` : rule.value);
       }
     };
-    declarationMapToString = (declarationMap) => {
-      return Array.from(declarationMap.entries()).map(([property, value]) => `${property}: ${value}`).join("; ");
+    declarationMapToString = (declarationMap, binding) => {
+      const entries = Array.from(declarationMap.entries()).map(([property, value]) => ({ property, value }));
+      if (binding?.declarationMapToString) {
+        return binding.declarationMapToString(entries);
+      }
+      return entries.map(({ property, value }) => `${property}: ${value}`).join("; ");
     };
     classToCss = async (input, options = {}) => {
-      const inputClasses = normalizeClassInput(input);
+      const binding = await requireNativeCssCompiler();
+      const inputClasses = normalizeClassInput(input, binding);
       const normalizedOptions = normalizeClassToCssOptions(options);
       if (inputClasses.length === 0) {
         return {
@@ -4958,7 +5022,6 @@ var init_classToCss = __esm({
           sizeBytes: 0
         };
       }
-      const binding = await requireNativeCssCompiler();
       const prefix = normalizedOptions.prefix;
       const results = await Promise.all(
         inputClasses.map(async (className) => {
@@ -4991,7 +5054,7 @@ var init_classToCss = __esm({
       const sizeBytes = results.reduce((sum, r) => sum + r.sizeBytes, 0);
       const declarationMap = /* @__PURE__ */ new Map();
       for (const result of results) {
-        mergeDeclarationMap(declarationMap, result.css);
+        mergeDeclarationMap(declarationMap, result.css, binding);
       }
       const uniqueUnknown = Array.from(new Set(unknownClasses));
       if (normalizedOptions.strict && uniqueUnknown.length > 0) {
@@ -5000,7 +5063,7 @@ var init_classToCss = __esm({
       return {
         inputClasses,
         css: cssChunks.filter((chunk) => chunk.length > 0).join("\n"),
-        declarations: declarationMapToString(declarationMap),
+        declarations: declarationMapToString(declarationMap, binding),
         resolvedClasses: Array.from(new Set(resolvedClasses)),
         unknownClasses: uniqueUnknown,
         sizeBytes
@@ -5010,8 +5073,8 @@ var init_classToCss = __esm({
 });
 
 // packages/domain/analyzer/src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var src_exports2 = {};
+__export(src_exports2, {
   __internal: () => __internal,
   analyzeWorkspace: () => analyzeWorkspace,
   classToCss: () => classToCss
@@ -5039,7 +5102,7 @@ var init_src3 = __esm({
 });
 async function pathExists2(filePath) {
   try {
-    await fs4.access(filePath);
+    await fs7.access(filePath);
     return true;
   } catch {
     return false;
@@ -5047,7 +5110,7 @@ async function pathExists2(filePath) {
 }
 async function readFileSafe(filePath) {
   try {
-    return await fs4.readFile(filePath, "utf8");
+    return await fs7.readFile(filePath, "utf8");
   } catch {
     return null;
   }
@@ -5066,8 +5129,8 @@ async function writeFileSafe(filePath, content, options = {}) {
     options.onDryRun?.(`write ${filePath}`);
     return;
   }
-  await fs4.mkdir(path3.dirname(filePath), { recursive: true });
-  await fs4.writeFile(filePath, content, "utf8");
+  await fs7.mkdir(path6__default.dirname(filePath), { recursive: true });
+  await fs7.writeFile(filePath, content, "utf8");
 }
 async function ensureFileSafe(filePath, content, options = {}) {
   if (await pathExists2(filePath)) return "skipped";
@@ -5355,11 +5418,11 @@ var init_args = __esm({
 });
 function runtimeDirFromImportMeta(importMetaUrl) {
   const filename = fileURLToPath(importMetaUrl);
-  return path3.dirname(filename);
+  return path6__default.dirname(filename);
 }
 async function resolveMonorepoPath(runtimeDir, relativeToRepoRoot) {
-  const fromRuntime = path3.resolve(runtimeDir, "..", "..", "..", relativeToRepoRoot);
-  const fromCwd = path3.resolve(process.cwd(), relativeToRepoRoot);
+  const fromRuntime = path6__default.resolve(runtimeDir, "..", "..", "..", relativeToRepoRoot);
+  const fromCwd = path6__default.resolve(process.cwd(), relativeToRepoRoot);
   return await pathExists2(fromRuntime) ? fromRuntime : fromCwd;
 }
 async function firstExistingPath(paths) {
@@ -5435,7 +5498,8 @@ async function runCliMain(options) {
     await program2.parseAsync(argv);
   } catch (error) {
     const isHelpError = isHelpExit(error);
-    if (isHelpError) return;
+    const isVersionError = isVersionExit(error);
+    if (isHelpError || isVersionError) return;
     const normalized = normalizeCliError(error);
     const isJson = input.json;
     if (isJson) {
@@ -5450,7 +5514,7 @@ async function runCliMain(options) {
     process.exitCode = errorExitCode(normalized);
   }
 }
-var isCommanderLikeError, isHelpExit, normalizeCliError, findCommandByPath, resolveCommandHelp, resolveHelpPath, walkCommands;
+var isCommanderLikeError, isHelpExit, isVersionExit, normalizeCliError, findCommandByPath, resolveCommandHelp, resolveHelpPath, walkCommands;
 var init_runtime = __esm({
   "packages/infrastructure/cli/src/utils/runtime.ts"() {
     init_args();
@@ -5463,6 +5527,9 @@ var init_runtime = __esm({
     isHelpExit = (error) => {
       return isCommanderLikeError(error) && error.code === "commander.helpDisplayed";
     };
+    isVersionExit = (error) => {
+      return isCommanderLikeError(error) && error.code === "commander.version";
+    };
     normalizeCliError = (error) => {
       if (!isCommanderLikeError(error)) return error;
       if (!error.code?.startsWith("commander.")) return error;
@@ -5543,7 +5610,7 @@ async function resolveCreateInput(options) {
   return { name: resolvedName, template: templateValue };
 }
 async function writeProjectFile(context, relativePath, content) {
-  const filePath = path3.join(context.projectDir, relativePath);
+  const filePath = path6__default.join(context.projectDir, relativePath);
   await writeFileSafe(filePath, content, { dryRun: context.dryRun });
   context.writtenFiles.push(relativePath.replaceAll("\\", "/"));
 }
@@ -5662,7 +5729,6 @@ async function createViteVueApp(context) {
         scripts: { dev: "vite", build: "vite build", preview: "vite preview" },
         dependencies: {
           vue: "^3.4.0",
-          "tailwind-merge": "^3.5.0",
           "tailwind-styled-v4/vue": "^5.0.0"
         },
         devDependencies: {
@@ -5759,7 +5825,7 @@ async function createViteSvelteApp(context) {
         private: true,
         type: "module",
         scripts: { dev: "vite", build: "vite build", preview: "vite preview" },
-        dependencies: { "tailwind-merge": "^3.5.0", "tailwind-styled-v4/svelte": "^5.0.0" },
+        dependencies: { "tailwind-styled-v4/svelte": "^5.0.0" },
         devDependencies: {
           svelte: "^5.0.0",
           "@sveltejs/vite-plugin-svelte": "^3.0.0",
@@ -5860,7 +5926,7 @@ async function createSimpleApp(context) {
 }
 async function createProject(options, output) {
   const { name, template } = await resolveCreateInput(options);
-  const projectDir = path3.resolve(process.cwd(), name);
+  const projectDir = path6__default.resolve(process.cwd(), name);
   if (await pathExists2(projectDir)) {
     throw new CliUsageError(`Directory ${name} already exists.`);
   }
@@ -5931,10 +5997,13 @@ var init_createApp = __esm({
     };
   }
 });
-var log3, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge;
+
+// packages/domain/compiler/src/nativeBridge.ts
+var _loadNative, log3, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge;
 var init_nativeBridge = __esm({
   "packages/domain/compiler/src/nativeBridge.ts"() {
     init_src();
+    _loadNative = (path29) => __require(path29);
     log3 = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -5961,11 +6030,10 @@ var init_nativeBridge = __esm({
       bridgeLoadAttempted = true;
       try {
         const runtimeDir = resolveRuntimeDir(void 0, import.meta.url);
-        const require2 = createRequire(import.meta.url);
         const result = resolveNativeBinary(runtimeDir);
         if (result.path && result.path.endsWith(".node")) {
           try {
-            const binding = require2(result.path);
+            const binding = _loadNative(result.path);
             if (isValidNativeBridge(binding)) {
               nativeBridge = binding;
               log3("Native bridge loaded successfully from:", result.path);
@@ -6000,7 +6068,7 @@ init_esm();
 init_errors();
 async function loadAnalyzerModule() {
   try {
-    const mod = await Promise.resolve().then(() => (init_src3(), src_exports));
+    const mod = await Promise.resolve().then(() => (init_src3(), src_exports2));
     if (typeof mod.analyzeWorkspace !== "function") {
       throw new Error("analyzeWorkspace export not found");
     }
@@ -6067,7 +6135,7 @@ async function runAnalyzeCli(args) {
     verbose: process.env.TWS_VERBOSE === "1" || process.env.VERBOSE === "1"
   });
   const dirArg = parsed.positionals[0] ?? ".";
-  const dir = path3.resolve(process.cwd(), dirArg);
+  const dir = path6__default.resolve(process.cwd(), dirArg);
   if (!await pathExists2(dir)) {
     throw new CliUsageError(`Directory not found: ${dir}`);
   }
@@ -6123,7 +6191,7 @@ async function runExtractCli(args) {
   const parsedMin = parseInt(minRaw, 10);
   const minCount = Number.isFinite(parsedMin) && parsedMin > 0 ? parsedMin : 2;
   const dirArg = parsed.positionals[0] ?? ".";
-  const dir = path3.resolve(process.cwd(), dirArg);
+  const dir = path6__default.resolve(process.cwd(), dirArg);
   if (!await pathExists2(dir)) {
     throw new CliUsageError(`Directory not found: ${dir}`);
   }
@@ -6196,15 +6264,15 @@ async function runInitCli(rawArgs) {
     verbose: process.env.TWS_VERBOSE === "1" || process.env.VERBOSE === "1"
   });
   const target = rawArgs.find((arg) => !arg.startsWith("-")) ?? ".";
-  const root = path3.resolve(process.cwd(), target);
+  const root = path6__default.resolve(process.cwd(), target);
   const report = { created: [], skipped: [] };
   await ensureFile(
-    path3.join(root, "src", "tailwind.css"),
+    path6__default.join(root, "src", "tailwind.css"),
     '@import "tailwindcss";\n\n@theme {\n  --color-primary: #3b82f6;\n  --spacing-section: 3rem;\n}\n',
     report
   );
   await ensureFile(
-    path3.join(root, "tailwind-styled.config.json"),
+    path6__default.join(root, "tailwind-styled.config.json"),
     `${JSON.stringify(
       {
         version: 1,
@@ -6223,12 +6291,12 @@ async function runInitCli(rawArgs) {
   output.writeText("\nInit complete");
   output.writeText(`Created: ${report.created.length}`);
   for (const filePath of report.created) {
-    output.writeText(`  + ${path3.relative(root, filePath)}`);
+    output.writeText(`  + ${path6__default.relative(root, filePath)}`);
   }
   if (report.skipped.length > 0) {
     output.writeText(`Skipped: ${report.skipped.length}`);
     for (const filePath of report.skipped) {
-      output.writeText(`  - ${path3.relative(root, filePath)} (exists)`);
+      output.writeText(`  - ${path6__default.relative(root, filePath)} (exists)`);
     }
   }
 }
@@ -6289,15 +6357,15 @@ async function findSourceFiles(dir) {
   const out = [];
   async function walk(currentDir) {
     if (!await pathExists2(currentDir)) return;
-    const entries = await fs4.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs7.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path3.join(currentDir, entry.name);
+      const fullPath = path6__default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (IGNORED_DIRS.has(entry.name)) continue;
         await walk(fullPath);
         continue;
       }
-      if (SOURCE_EXTENSIONS.has(path3.extname(entry.name))) {
+      if (SOURCE_EXTENSIONS.has(path6__default.extname(entry.name))) {
         out.push(fullPath);
       }
     }
@@ -6318,7 +6386,7 @@ function migrateSource(source, options) {
   return { output, classRenames: 0, importRenames };
 }
 async function migrateConfig(root, dryRun) {
-  const cssPath = path3.join(root, "src", "tailwind.css");
+  const cssPath = path6__default.join(root, "src", "tailwind.css");
   if (await pathExists2(cssPath)) return 0;
   await writeFileSafe(cssPath, DEFAULT_TAILWIND_CSS, { dryRun });
   return 1;
@@ -6331,7 +6399,7 @@ async function runMigrateCli(rawArgs) {
     verbose: process.env.TWS_VERBOSE === "1" || process.env.VERBOSE === "1"
   });
   const target = firstPositional(rawArgs) ?? ".";
-  const root = path3.resolve(process.cwd(), target);
+  const root = path6__default.resolve(process.cwd(), target);
   const dryRunFlag = hasFlag("dry-run", rawArgs);
   const wizardOptions = hasFlag("wizard", rawArgs) ? await runMigrationWizard() : null;
   const { dryRun, includeConfig, includeClasses, includeImports } = wizardOptions ? {
@@ -6355,12 +6423,12 @@ async function runMigrateCli(rawArgs) {
     report.configWrites += await migrateConfig(root, dryRun);
   }
   for (const filePath of files) {
-    const source = await fs4.readFile(filePath, "utf8");
+    const source = await fs7.readFile(filePath, "utf8");
     const migrated = migrateSource(source, { includeImports, includeClasses });
     if (migrated.output !== source) {
       report.updatedFiles++;
       if (!dryRun) {
-        await fs4.writeFile(filePath, migrated.output, "utf8");
+        await fs7.writeFile(filePath, migrated.output, "utf8");
       }
     }
     report.classRenames += migrated.classRenames;
@@ -6424,10 +6492,10 @@ function buildClassNames(files, uniqueClasses) {
   });
 }
 function writeScanCache(root, cacheData) {
-  const cacheDir = path3.join(root, ".tailwind-styled");
-  const cachePath = path3.join(cacheDir, "scan-cache.json");
-  fs8.mkdirSync(cacheDir, { recursive: true });
-  fs8.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2), "utf-8");
+  const cacheDir = path6__default.join(root, ".tailwind-styled");
+  const cachePath = path6__default.join(cacheDir, "scan-cache.json");
+  fs11__default.mkdirSync(cacheDir, { recursive: true });
+  fs11__default.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2), "utf-8");
   return cachePath;
 }
 async function runScanCli(rawArgs) {
@@ -6439,7 +6507,7 @@ async function runScanCli(rawArgs) {
     debug: process.env.TWS_DEBUG === "1" || process.env.DEBUG === "1",
     verbose: process.env.TWS_VERBOSE === "1" || process.env.VERBOSE === "1"
   });
-  const root = path3.resolve(process.cwd(), target);
+  const root = path6__default.resolve(process.cwd(), target);
   const spinner = output.spinner();
   spinner.start(`Scanning ${root}`);
   const scanned = await scanWorkspaceAsync(root);
@@ -6729,7 +6797,7 @@ var writeVerboseLine = (binary, args) => {
   console.error(`  [verbose] $ ${formatCommand(binary, args)}`);
 };
 var runCommand = async (binary, args, options = {}) => {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (isVerboseEnabled(options)) {
       writeVerboseLine(binary, args);
     }
@@ -6756,7 +6824,7 @@ var runCommand = async (binary, args, options = {}) => {
         );
         return;
       }
-      resolve(exitCode);
+      resolve2(exitCode);
     });
   });
 };
@@ -6785,7 +6853,7 @@ var formatCommandFailureOutput = (stdout, stderr) => {
   return "Command failed with no output.";
 };
 var runCommandCapture = async (binary, args, options = {}) => {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     if (isVerboseEnabled(options)) {
       writeVerboseLine(binary, args);
     }
@@ -6828,7 +6896,7 @@ ${formatCommandFailureOutput(stdout, stderr)}`,
         );
         return;
       }
-      resolve({
+      resolve2({
         exitCode,
         stdout,
         stderr
@@ -6866,12 +6934,12 @@ function configureSetupFlags(rawArgs) {
   };
 }
 async function readPackageJson(cwd2) {
-  return readJsonSafe(path3.join(cwd2, "package.json"));
+  return readJsonSafe(path6__default.join(cwd2, "package.json"));
 }
 async function detectPm(cwd2) {
-  if (await pathExists2(path3.join(cwd2, "bun.lockb"))) return "bun";
-  if (await pathExists2(path3.join(cwd2, "pnpm-lock.yaml"))) return "pnpm";
-  if (await pathExists2(path3.join(cwd2, "yarn.lock"))) return "yarn";
+  if (await pathExists2(path6__default.join(cwd2, "bun.lockb"))) return "bun";
+  if (await pathExists2(path6__default.join(cwd2, "pnpm-lock.yaml"))) return "pnpm";
+  if (await pathExists2(path6__default.join(cwd2, "yarn.lock"))) return "yarn";
   return "npm";
 }
 async function detectBundler(cwd2) {
@@ -6892,7 +6960,7 @@ async function alreadyInstalled(cwd2, pkgName) {
 }
 async function findExisting(cwd2, names) {
   for (const name of names) {
-    const resolved = path3.join(cwd2, name);
+    const resolved = path6__default.join(cwd2, name);
     if (await pathExists2(resolved)) return resolved;
   }
   return null;
@@ -7032,16 +7100,10 @@ var runSetupCli = async (rawArgs) => {
   output.writeText(import_picocolors3.default.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   output.writeText("");
   output.writeText(import_picocolors3.default.bold("  [1/4]") + import_picocolors3.default.cyan("  packages"));
-  const [hasCorePkg, hasMergePkg] = await Promise.all([
-    alreadyInstalled(cwd, "tailwind-styled-v4"),
-    alreadyInstalled(cwd, "tailwind-merge")
-  ]);
-  const toInstall = [
-    hasCorePkg ? null : "tailwind-styled-v4",
-    hasMergePkg ? null : "tailwind-merge"
-  ].filter(Boolean);
+  const hasCorePkg = await alreadyInstalled(cwd, "tailwind-styled-v4");
+  const toInstall = hasCorePkg ? [] : ["tailwind-styled-v4"];
   if (toInstall.length > 0) await installPackages(cwd, pm, toInstall, false, setupFlags, logger);
-  else logger.skip("tailwind-styled-v4 + tailwind-merge sudah terpasang");
+  else logger.skip("tailwind-styled-v4 sudah terpasang");
   output.writeText("\n" + import_picocolors3.default.bold("  [2/4]") + import_picocolors3.default.cyan("  bundler config"));
   const bundlerConfigMap = {
     next: {
@@ -7064,7 +7126,7 @@ var runSetupCli = async (rawArgs) => {
   if (bundlerConfig) {
     const cfg = await findExisting(cwd, bundlerConfig.files);
     if (cfg)
-      await patchFileWithDryRun(cfg, bundlerConfig.patcher, path3.basename(cfg), setupFlags, logger);
+      await patchFileWithDryRun(cfg, bundlerConfig.patcher, path6__default.basename(cfg), setupFlags, logger);
     else logger.warn(bundlerConfig.warnMsg);
   } else {
     logger.skip("React tanpa bundler - tidak ada bundler config yang di-patch");
@@ -7083,8 +7145,8 @@ var runSetupCli = async (rawArgs) => {
   if (cssFile) {
     await patchFileWithDryRun(
       cssFile,
-      (src) => patchTailwindCss(src, bundler, path3.relative(cwd, cssFile), cwd),
-      path3.relative(cwd, cssFile),
+      (src) => patchTailwindCss(src, bundler, path6__default.relative(cwd, cssFile), cwd),
+      path6__default.relative(cwd, cssFile),
       setupFlags,
       logger
     );
@@ -7092,7 +7154,7 @@ var runSetupCli = async (rawArgs) => {
     logger.warn('CSS entry tidak ditemukan \u2014 tambahkan @import "tailwindcss" manual ke globals.css');
   }
   output.writeText("\n" + import_picocolors3.default.bold("  [4/4]") + import_picocolors3.default.cyan("  tsconfig.json"));
-  const tsCfg = path3.join(cwd, "tsconfig.json");
+  const tsCfg = path6__default.join(cwd, "tsconfig.json");
   const hasTsConfig = await findExisting(cwd, ["tsconfig.json"]);
   if (hasTsConfig) {
     await patchFileWithDryRun(tsCfg, patchTsConfig, "tsconfig.json", setupFlags, logger);
@@ -7158,7 +7220,7 @@ async function runStatsCli(args) {
     verbose: process.env.TWS_VERBOSE === "1" || process.env.VERBOSE === "1"
   });
   const dirArg = parsed.positionals[0] ?? ".";
-  const dir = path3.resolve(process.cwd(), dirArg);
+  const dir = path6__default.resolve(process.cwd(), dirArg);
   if (!await pathExists2(dir)) {
     throw new CliUsageError(`Directory not found: ${dir}`);
   }
@@ -7370,7 +7432,7 @@ function enumerateVariantProps(matrix) {
 }
 async function resolveScript(context, relativeToRepoRoot) {
   const fromRuntime = await resolveMonorepoPath(context.runtimeDir, relativeToRepoRoot);
-  const fromCwd = path3.resolve(process.cwd(), relativeToRepoRoot);
+  const fromCwd = path6__default.resolve(process.cwd(), relativeToRepoRoot);
   const resolved = await firstExistingPath([fromRuntime, fromCwd]);
   if (!resolved) {
     throw new CliUsageError(`Required script not found: ${relativeToRepoRoot}`);
@@ -7384,13 +7446,13 @@ async function loadRegistry(context) {
   );
   const candidates = [
     runtimeRegistryPath,
-    path3.resolve(process.cwd(), "packages/domain/plugin-registry/registry.json")
+    path6__default.resolve(process.cwd(), "packages/domain/plugin-registry/registry.json")
   ];
   const registryPath = await firstExistingPath(candidates);
   if (!registryPath) {
     throw new CliUsageError("Plugin registry file not found.");
   }
-  const raw = await fs4.readFile(registryPath, "utf8");
+  const raw = await fs7.readFile(registryPath, "utf8");
   const data = JSON.parse(raw);
   return [
     ...data.official.map((item) => ({ ...item, official: true })),
@@ -7440,7 +7502,7 @@ init_json();
 var postJson = async (url, body, token) => {
   const { default: https } = await import('https');
   const { default: http } = await import('http');
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const client = url.protocol === "https:" ? https : http;
     const req = client.request(
       url,
@@ -7458,9 +7520,9 @@ var postJson = async (url, body, token) => {
         res.on("end", () => {
           const raw = Buffer.concat(chunks).toString("utf8");
           try {
-            resolve({ status: res.statusCode, body: JSON.parse(raw) });
+            resolve2({ status: res.statusCode, body: JSON.parse(raw) });
           } catch {
-            resolve({ status: res.statusCode, body: raw });
+            resolve2({ status: res.statusCode, body: raw });
           }
         });
       }
@@ -7489,7 +7551,7 @@ var deployCommand = {
     const version = typeof parsed.values.version === "string" ? parsed.values.version : "0.1.0";
     const tag = typeof parsed.values.tag === "string" ? parsed.values.tag : "latest";
     const registryUrl = typeof parsed.values.registry === "string" ? parsed.values.registry : process.env.TW_REGISTRY_URL ?? null;
-    const pkgPath = path3.join(process.cwd(), "package.json");
+    const pkgPath = path6__default.join(process.cwd(), "package.json");
     if (!await pathExists2(pkgPath)) {
       throw new CliUsageError("[tw deploy] No package.json found in current directory");
     }
@@ -7524,10 +7586,10 @@ var deployCommand = {
       }
       return;
     }
-    const cacheDir = path3.join(process.cwd(), ".tw-cache");
-    await fs4.mkdir(cacheDir, { recursive: true });
-    await fs4.writeFile(
-      path3.join(cacheDir, "deploy-manifest.json"),
+    const cacheDir = path6__default.join(process.cwd(), ".tw-cache");
+    await fs7.mkdir(cacheDir, { recursive: true });
+    await fs7.writeFile(
+      path6__default.join(cacheDir, "deploy-manifest.json"),
       JSON.stringify(manifest, null, 2)
     );
     if (!registryUrl) {
@@ -7627,24 +7689,24 @@ function addIssue(issues, severity, type, message, suggestion, location) {
   issues.push({ severity, type, message, suggestion, location });
 }
 function readJsonFile(filePath) {
-  if (!fs8.existsSync(filePath)) return null;
+  if (!fs11__default.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs8.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs11__default.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
 }
 function findWorkspacePackageJsonFiles(root) {
-  const packagesDir = path3.join(root, "packages");
-  if (!fs8.existsSync(packagesDir)) return [];
-  return fs8.readdirSync(packagesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path3.join(packagesDir, entry.name, "package.json")).filter((filePath) => fs8.existsSync(filePath));
+  const packagesDir = path6__default.join(root, "packages");
+  if (!fs11__default.existsSync(packagesDir)) return [];
+  return fs11__default.readdirSync(packagesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path6__default.join(packagesDir, entry.name, "package.json")).filter((filePath) => fs11__default.existsSync(filePath));
 }
 function findFiles(dir, ext) {
   const files = [];
   try {
-    const entries = fs8.readdirSync(dir, { withFileTypes: true });
+    const entries = fs11__default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path3.join(dir, entry.name);
+      const fullPath = path6__default.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
         files.push(...findFiles(fullPath, ext));
       } else if (entry.isFile() && entry.name.endsWith(ext)) {
@@ -7657,7 +7719,7 @@ function findFiles(dir, ext) {
   return files;
 }
 function runWorkspaceDiagnostics(root, issues, checks) {
-  const rootPackageJsonPath = path3.join(root, "package.json");
+  const rootPackageJsonPath = path6__default.join(root, "package.json");
   const rootPackageJson = readJsonFile(rootPackageJsonPath);
   if (!rootPackageJson) {
     addCheck(
@@ -7710,7 +7772,7 @@ function runWorkspaceDiagnostics(root, issues, checks) {
     const scripts = typeof manifest.scripts === "object" && manifest.scripts !== null ? manifest.scripts : {};
     const missing = requiredScripts.filter((name) => typeof scripts[name] !== "string");
     if (missing.length === 0) return [];
-    const packageName = typeof manifest.name === "string" && manifest.name.length > 0 ? manifest.name : path3.basename(path3.dirname(filePath));
+    const packageName = typeof manifest.name === "string" && manifest.name.length > 0 ? manifest.name : path6__default.basename(path6__default.dirname(filePath));
     return [{ packageName, missing }];
   });
   if (missingScripts.length === 0) {
@@ -7745,7 +7807,7 @@ function runWorkspaceDiagnostics(root, issues, checks) {
   );
 }
 function runTailwindProjectDiagnostics(root, issues, checks) {
-  const packageJsonPath = path3.join(root, "package.json");
+  const packageJsonPath = path6__default.join(root, "package.json");
   const packageJson = readJsonFile(packageJsonPath);
   if (!packageJson) {
     addCheck(
@@ -7804,7 +7866,7 @@ function runTailwindProjectDiagnostics(root, issues, checks) {
   const cssFiles = findFiles(root, ".css");
   const hasTailwindImport = cssFiles.slice(0, 10).some((filePath) => {
     try {
-      const content = fs8.readFileSync(filePath, "utf8");
+      const content = fs11__default.readFileSync(filePath, "utf8");
       return content.includes("@tailwind") || content.includes('@import "tailwindcss"');
     } catch {
       return false;
@@ -7828,7 +7890,7 @@ function runTailwindProjectDiagnostics(root, issues, checks) {
     );
   }
   const configFiles = ["tailwind.config.js", "tailwind.config.ts", "tailwind.config.mjs"];
-  const hasConfig = configFiles.some((name) => fs8.existsSync(path3.join(root, name)));
+  const hasConfig = configFiles.some((name) => fs11__default.existsSync(path6__default.join(root, name)));
   addCheck(
     checks,
     "tailwind",
@@ -7837,7 +7899,7 @@ function runTailwindProjectDiagnostics(root, issues, checks) {
     "info",
     hasConfig ? "Tailwind config file detected." : "No tailwind.config file found."
   );
-  const tsconfig = readJsonFile(path3.join(root, "tsconfig.json"));
+  const tsconfig = readJsonFile(path6__default.join(root, "tsconfig.json"));
   const jsx = tsconfig?.compilerOptions?.jsx;
   addCheck(
     checks,
@@ -8003,7 +8065,7 @@ async function runAnalysisDiagnostics(root, issues, checks, verbose) {
   }
 }
 var runDiagnostics = async (options = {}) => {
-  const root = path3.resolve(options.root ?? process.cwd());
+  const root = path6__default.resolve(options.root ?? process.cwd());
   const includes = parseIncludes(options.include);
   const issues = [];
   const checks = [];
@@ -8153,7 +8215,7 @@ var shareCommand = {
   name: "share",
   async run(args, context) {
     const name = args.find((arg) => !arg.startsWith("-")) ?? "component-name";
-    const manifestPath = path3.join(process.cwd(), ".tw-cache", "deploy-manifest.json");
+    const manifestPath = path6__default.join(process.cwd(), ".tw-cache", "deploy-manifest.json");
     const defaultManifest = {
       name,
       version: "0.1.0"
@@ -8239,14 +8301,14 @@ var isVersionOutdated = (currentVersion, latestVersion) => {
 };
 var resolveCurrentCliVersion = async (context) => {
   const candidates = [
-    path3.resolve(context.runtimeDir, "..", "package.json"),
-    path3.resolve(process.cwd(), "packages", "cli", "package.json"),
-    path3.resolve(process.cwd(), "package.json")
+    path6__default.resolve(context.runtimeDir, "..", "package.json"),
+    path6__default.resolve(process.cwd(), "packages", "cli", "package.json"),
+    path6__default.resolve(process.cwd(), "package.json")
   ];
   for (const candidate of candidates) {
     if (!await pathExists2(candidate)) continue;
     const pkg = await readJsonSafe(candidate);
-    const isCliPackage = pkg?.version && (pkg.name === CLI_PACKAGE_NAME || candidate.includes(`${path3.sep}packages${path3.sep}cli${path3.sep}`));
+    const isCliPackage = pkg?.version && (pkg.name === CLI_PACKAGE_NAME || candidate.includes(`${path6__default.sep}packages${path6__default.sep}cli${path6__default.sep}`));
     if (isCliPackage) return pkg.version ?? "0.0.0";
   }
   return "0.0.0";
@@ -8519,7 +8581,7 @@ function resolveCliEntry(scriptPath) {
 async function hasTailwindCssImport(cwd2) {
   const cssFiles = ["src/app/globals.css", "src/index.css", "src/style.css", "app/globals.css"];
   for (const file of cssFiles) {
-    const raw = await readFileSafe(path3.join(cwd2, file));
+    const raw = await readFileSafe(path6__default.join(cwd2, file));
     if (raw?.includes("tailwindcss")) return true;
   }
   return false;
@@ -8535,7 +8597,7 @@ async function hasSafelistSource(cwd2) {
     "app/globals.css"
   ];
   for (const file of cssFiles) {
-    const raw = await readFileSafe(path3.join(cwd2, file));
+    const raw = await readFileSafe(path6__default.join(cwd2, file));
     if (raw === null) continue;
     if (raw.includes("tw-classes")) return { found: true, cssFile: file };
     if (raw.includes("tailwindcss")) return { found: false, cssFile: file };
@@ -8543,8 +8605,8 @@ async function hasSafelistSource(cwd2) {
   return { found: false, cssFile: null };
 }
 async function applyTailwindInit(cwd2) {
-  await ensureFileSafe(path3.join(cwd2, "src", "tailwind.css"), DEFAULT_TAILWIND_CSS2);
-  await ensureFileSafe(path3.join(cwd2, "tailwind-styled.config.json"), DEFAULT_TW_CONFIG);
+  await ensureFileSafe(path6__default.join(cwd2, "src", "tailwind.css"), DEFAULT_TAILWIND_CSS2);
+  await ensureFileSafe(path6__default.join(cwd2, "tailwind-styled.config.json"), DEFAULT_TW_CONFIG);
 }
 function check(results, id, label, pass, message, fix) {
   results.push({ id, label, pass, message, fix });
@@ -8566,7 +8628,7 @@ async function runPreflightCli(rawArgs) {
     node.major >= 20 ? `Node ${node.full} OK` : `Node ${node.full} - requires >=20. Download: https://nodejs.org`,
     node.major < 20 ? "Install Node.js 20 LTS or newer from https://nodejs.org" : void 0
   );
-  const pkg = await readJsonSafe(path3.join(cwd2, "package.json"));
+  const pkg = await readJsonSafe(path6__default.join(cwd2, "package.json"));
   check(
     results,
     "package-json",
@@ -8597,19 +8659,10 @@ async function runPreflightCli(rawArgs) {
       hasBundler ? `${bundlerName} detected OK` : "No supported bundler (Vite/Next.js/Rspack) found",
       "Install a bundler: npm install vite @vitejs/plugin-react OR npx create-next-app"
     );
-    const hasMerge = pkgHasDep(pkg, "tailwind-merge");
-    check(
-      results,
-      "tailwind-merge",
-      "tailwind-merge installed",
-      hasMerge,
-      hasMerge ? "tailwind-merge found OK" : "Missing peer dep - run: npm install tailwind-merge",
-      "npm install tailwind-merge"
-    );
   }
   const twConfigFiles = ["tailwind.config.ts", "tailwind.config.js", "tailwind.config.mjs"];
   const twConfigChecks = await Promise.all(
-    twConfigFiles.map(async (file) => ({ file, exists: await pathExists2(path3.join(cwd2, file)) }))
+    twConfigFiles.map(async (file) => ({ file, exists: await pathExists2(path6__default.join(cwd2, file)) }))
   );
   const foundTwConfig = twConfigChecks.find((item) => item.exists)?.file ?? null;
   const hasCssConfig = await hasTailwindCssImport(cwd2);
@@ -8621,7 +8674,7 @@ async function runPreflightCli(rawArgs) {
     foundTwConfig ? `${foundTwConfig} found OK` : hasCssConfig ? "@import tailwindcss found in CSS OK" : "No Tailwind config found - run: tw init",
     "tw init"
   );
-  const oldConfig = await readJsonSafe(path3.join(cwd2, "tailwind.config.js")) ?? await readJsonSafe(path3.join(cwd2, "tailwind.config.ts"));
+  const oldConfig = await readJsonSafe(path6__default.join(cwd2, "tailwind.config.js")) ?? await readJsonSafe(path6__default.join(cwd2, "tailwind.config.ts"));
   if (oldConfig) {
     const hasOldJit = oldConfig.mode === "jit";
     const hasOldPurge = "purge" in oldConfig;
@@ -8635,7 +8688,7 @@ async function runPreflightCli(rawArgs) {
       "Run: tw migrate --dry-run to see migration steps"
     );
   }
-  const hasTsConfig = await pathExists2(path3.join(cwd2, "tsconfig.json"));
+  const hasTsConfig = await pathExists2(path6__default.join(cwd2, "tsconfig.json"));
   check(
     results,
     "typescript",
@@ -9029,7 +9082,7 @@ var storybookCommand = {
     context.output.writeText(
       `[tw storybook] Tip: use --variants='{"size":["sm","lg"]}' to enumerate variant combinations`
     );
-    const localBin = path3.join(
+    const localBin = path6__default.join(
       process.cwd(),
       "node_modules",
       ".bin",
@@ -9226,418 +9279,269 @@ function getNativeEngineBinding() {
 // packages/domain/engine/src/bundleAnalyzer.ts
 var BundleAnalyzer = class {
   analyzeClass(className, scanResult, css) {
-    if (!className || className.trim() === "") {
-      throw new Error("Class name cannot be empty");
-    }
-    if (!scanResult) {
-      throw new Error("Scan result is required for analysis");
+    if (!className || className.trim() === "") throw new Error("Class name cannot be empty");
+    if (!scanResult) throw new Error("Scan result is required for analysis");
+    if (typeof css !== "string") throw new Error("CSS string is required for analysis");
+    const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
+    const native = getNativeEngineBinding();
+    if (!native.analyzeClassUsage) {
+      throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
     }
-    if (typeof css !== "string") {
-      throw new Error("CSS string is required for analysis");
+    if (!native.buildDependencyChain) {
+      throw new Error("FATAL: Native binding 'buildDependencyChain' is required but not available.");
     }
-    const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    const usageCount = this.countClassUsage(normalizedClass, scanResult);
-    const files = this.getFilesUsingClass(normalizedClass, scanResult);
-    const bundleSize = this.calculateBundleContribution(normalizedClass, css);
-    const variantChains = this.extractVariantChains(normalizedClass, css);
-    const dependencies = this.extractDependencies(normalizedClass, css);
-    const isDeadCode = this.checkIsDeadCode(normalizedClass, scanResult, css);
+    const results = native.analyzeClassUsage(
+      [normalizedClass],
+      JSON.stringify(scanResult),
+      css
+    );
+    const info = results[0];
+    const files = info ? JSON.parse(info.filesJson).map((f) => ({ file: f, line: 1, column: 1 })) : [];
+    const dependencies = native.buildDependencyChain(normalizedClass);
     return {
       className: normalizedClass,
-      totalUsage: usageCount,
+      totalUsage: info?.usageCount ?? 0,
       files,
-      bundleSizeBytes: bundleSize,
-      variantChains,
-      isDeadCode,
+      bundleSizeBytes: info?.bundleSizeBytes ?? 0,
+      variantChains: [],
+      isDeadCode: info?.isDeadCode ?? true,
       dependencies
     };
   }
   analyzeAll(scanResult, css) {
-    if (!scanResult) {
-      throw new Error("Scan result is required for analysis");
-    }
-    if (typeof css !== "string") {
-      throw new Error("CSS string is required for analysis");
-    }
-    const results = /* @__PURE__ */ new Map();
-    const allClasses = new Set(scanResult.uniqueClasses);
-    const cssClasses = this.extractClassesFromCss(css);
-    for (const cssClass of cssClasses) {
-      allClasses.add(cssClass);
-    }
-    for (const className of allClasses) {
-      try {
-        const result = this.analyzeClass(className, scanResult, css);
-        results.set(className, result);
-      } catch (error) {
-        console.warn(`Failed to analyze class "${className}":`, error);
-      }
+    if (!scanResult) throw new Error("Scan result is required for analysis");
+    if (typeof css !== "string") throw new Error("CSS string is required for analysis");
+    const native = getNativeEngineBinding();
+    if (!native.analyzeClassUsage) {
+      throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+    }
+    if (!native.buildDependencyChain) {
+      throw new Error("FATAL: Native binding 'buildDependencyChain' is required but not available.");
+    }
+    const allClasses = Array.from(/* @__PURE__ */ new Set([
+      ...scanResult.uniqueClasses,
+      ...native.extractAllClasses ? native.extractAllClasses(css) : []
+    ]));
+    const results = native.analyzeClassUsage(
+      allClasses,
+      JSON.stringify(scanResult),
+      css
+    );
+    const map = /* @__PURE__ */ new Map();
+    for (const info of results) {
+      const files = JSON.parse(info.filesJson).map((f) => ({
+        file: f,
+        line: 1,
+        column: 1
+      }));
+      const dependencies = native.buildDependencyChain ? native.buildDependencyChain(info.className) : [];
+      map.set(info.className, {
+        className: info.className,
+        totalUsage: info.usageCount,
+        files,
+        bundleSizeBytes: info.bundleSizeBytes,
+        variantChains: [],
+        isDeadCode: info.isDeadCode,
+        dependencies
+      });
     }
-    return results;
+    return map;
   }
   calculateBundleContribution(className, css) {
     if (!className || className.trim() === "") throw new Error("Class name cannot be empty");
     if (typeof css !== "string") throw new Error("CSS string is required");
-    try {
-      const native = (() => {
-        try {
-          return getNativeEngineBinding();
-        } catch {
-          return null;
-        }
-      })();
-      if (native?.calculateBundleContributionsNative) {
-        const r = native.calculateBundleContributionsNative([className], css);
-        return r?.[0]?.sizeBytes ?? 0;
-      }
-    } catch (err) {
+    const native = getNativeEngineBinding();
+    if (!native.calculateBundleContributions) {
+      throw new Error("FATAL: Native binding 'calculateBundleContributions' is required but not available.");
     }
-    const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    const escapedClass = normalizedClass.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const selectorPattern = new RegExp(`\\.${escapedClass}([\\s:{]|$)`, "g");
-    if (!css.match(selectorPattern)) return 0;
-    const classSelector = `.${normalizedClass}`;
-    return css.split("\n").filter((l) => l.includes(classSelector)).reduce((sum, l) => {
-      const s = l.indexOf("{");
-      return s !== -1 ? sum + l.substring(s).length + 1 : sum;
-    }, 0);
+    const r = native.calculateBundleContributions([className], css);
+    return r?.[0]?.sizeBytes ?? 0;
   }
   detectDeadCode(scanResult, css) {
     if (!scanResult) throw new Error("Scan result is required for dead code detection");
     if (typeof css !== "string") throw new Error("CSS string is required for dead code detection");
-    try {
-      const native = (() => {
-        try {
-          return getNativeEngineBinding();
-        } catch {
-          return null;
-        }
-      })();
-      if (native?.detectDeadCodeNative) {
-        const r = native.detectDeadCodeNative(JSON.stringify(scanResult), css);
-        return r?.deadInCss ?? [];
-      }
-    } catch (err) {
-    }
-    const cssClasses = this.extractClassesFromCss(css);
-    const usedClasses = new Set(scanResult.uniqueClasses);
-    return cssClasses.filter((c) => !usedClasses.has(c));
-  }
-  countClassUsage(className, scanResult) {
-    const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    const count = scanResult.files.reduce((sum, file) => {
-      return sum + file.classes.filter((fileClass) => {
-        const normalizedFileClass = fileClass.startsWith(".") ? fileClass.slice(1) : fileClass;
-        return normalizedFileClass === normalizedClass;
-      }).length;
-    }, 0);
-    return count;
-  }
-  getFilesUsingClass(className, scanResult) {
-    const files = [];
-    const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    for (const file of scanResult.files) {
-      for (const fileClass of file.classes) {
-        const normalizedFileClass = fileClass.startsWith(".") ? fileClass.slice(1) : fileClass;
-        if (normalizedFileClass === normalizedClass) {
-          files.push({
-            file: file.file,
-            line: 1,
-            column: 1
-          });
-          break;
-        }
-      }
-    }
-    return files;
-  }
-  extractVariantChains(className, css) {
-    const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    const variantChains = [];
-    const escapedClass = normalizedClass.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const variantPattern = new RegExp(`([\\w-]+:${escapedClass}|${escapedClass})`, "g");
-    const lines = css.split("\n");
-    for (const line of lines) {
-      const matches = line.match(variantPattern);
-      if (matches) {
-        for (const match of matches) {
-          if (match.includes(":")) {
-            variantChains.push(match);
-          }
-        }
-      }
-    }
-    return [...new Set(variantChains)];
-  }
-  extractDependencies(className, _css) {
-    const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    const parts = normalizedClass.split(":");
-    const dependencies = parts.slice(0, -1).map((_, i) => parts.slice(0, i + 1).join(":"));
-    return dependencies;
-  }
-  checkIsDeadCode(className, scanResult, css) {
-    const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    const cssClasses = this.extractClassesFromCss(css);
-    if (!cssClasses.includes(normalizedClass)) {
-      return true;
-    }
-    const usageCount = this.countClassUsage(normalizedClass, scanResult);
-    return usageCount === 0;
-  }
-  extractClassesFromCss(css) {
-    const classes = [];
-    const classPattern = /\.([a-zA-Z0-9_-]+(?::[a-zA-Z0-9_-]+)*)/g;
-    for (const match of css.matchAll(classPattern)) {
-      const className = match[1];
-      if (!classes.includes(className)) {
-        classes.push(className);
-      }
+    const native = getNativeEngineBinding();
+    if (!native.detectDeadCode) {
+      throw new Error("FATAL: Native binding 'detectDeadCode' is required but not available.");
     }
-    return classes;
+    const r = native.detectDeadCode(JSON.stringify(scanResult), css);
+    return r?.deadInCss ?? [];
   }
 };
 
 // packages/domain/engine/src/impactTracker.ts
 var ImpactTracker = class {
   bundleAnalyzer;
-  criticalPatterns = [
-    "fixed",
-    "absolute",
-    "sticky",
-    "z-50",
-    "z-index",
-    "top-0",
-    "right-0",
-    "bottom-0",
-    "left-0",
-    "w-full",
-    "h-full",
-    "min-h-screen",
-    "flex",
-    "grid",
-    "block",
-    "inline",
-    "hidden",
-    "visible",
-    "opacity",
-    "pointer-events",
-    "cursor"
-  ];
   constructor() {
     this.bundleAnalyzer = new BundleAnalyzer();
   }
-  /**
-   * Analisis impact sebuah class menggunakan BundleAnalyzer untuk dapat
-   * data akurat tentang bundle size contribution.
-   *
-   * @param className - Tailwind class yang ingin dianalisis
-   * @param scanResult - Hasil scan workspace
-   * @param css - CSS string dari build output (opsional — jika tidak ada, gunakan estimasi)
-   */
   analyzeWithBundle(className, scanResult, css = "") {
     const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    let bundleAnalysis = null;
-    try {
-      if (scanResult && css) {
-        bundleAnalysis = this.bundleAnalyzer.analyzeClass(normalizedClass, scanResult, css);
-      }
-    } catch {
-    }
-    const resolvedBundleAnalysis = bundleAnalysis ?? (() => {
-      const usedIn = (scanResult?.files ?? []).filter(
-        (f) => f.classes?.includes(normalizedClass)
-      );
-      return {
-        className: normalizedClass,
-        totalUsage: usedIn.length,
-        files: usedIn.map((f) => ({
-          file: f.file,
-          line: 1,
-          column: 1
-        })),
-        bundleSizeBytes: 0,
-        variantChains: [],
-        isDeadCode: usedIn.length === 0,
-        dependencies: []
-      };
-    })();
-    return this.calculateImpact(normalizedClass, resolvedBundleAnalysis, scanResult);
+    const native = getNativeEngineBinding();
+    if (!native?.calculateImpactScores) {
+      throw new Error("FATAL: Native binding 'calculateImpactScores' is required but not available.");
+    }
+    const scores = native.calculateImpactScores(
+      [normalizedClass],
+      JSON.stringify(scanResult),
+      css,
+      0.6,
+      0.4
+    );
+    const score = scores[0];
+    const bundleAnalysis = {
+      className: normalizedClass,
+      totalUsage: score?.usageCount ?? 0,
+      files: [],
+      bundleSizeBytes: score?.sizeBytes ?? 0,
+      variantChains: [],
+      isDeadCode: (score?.usageCount ?? 0) === 0,
+      dependencies: []
+    };
+    return this.calculateImpact(normalizedClass, bundleAnalysis, scanResult, score);
   }
-  /**
-   * Analisis semua class dalam workspace sekaligus.
-   */
   analyzeAll(scanResult, css = "") {
-    const results = /* @__PURE__ */ new Map();
+    const native = getNativeEngineBinding();
+    if (!native?.calculateImpactScores) {
+      throw new Error("FATAL: Native binding 'calculateImpactScores' is required but not available.");
+    }
     const classes = scanResult?.uniqueClasses ?? [];
+    const scores = native.calculateImpactScores(
+      classes,
+      JSON.stringify(scanResult),
+      css,
+      0.6,
+      0.4
+    );
+    const scoreMap = new Map(scores.map((s) => [s.className, s]));
+    const results = /* @__PURE__ */ new Map();
     for (const cls of classes) {
-      try {
-        results.set(cls, this.analyzeWithBundle(cls, scanResult, css));
-      } catch {
-      }
+      const score = scoreMap.get(cls);
+      const bundleAnalysis = {
+        className: cls,
+        totalUsage: score?.usageCount ?? 0,
+        files: [],
+        bundleSizeBytes: score?.sizeBytes ?? 0,
+        variantChains: [],
+        isDeadCode: (score?.usageCount ?? 0) === 0,
+        dependencies: []
+      };
+      results.set(cls, this.calculateImpact(cls, bundleAnalysis, scanResult, score));
     }
     return results;
   }
-  calculateImpact(className, bundleAnalysis, scanResult) {
-    if (!className || className.trim() === "") {
-      return this.createEmptyReport(className);
-    }
-    if (!bundleAnalysis) {
-      return this.createEmptyReport(className);
-    }
+  calculateImpact(className, bundleAnalysis, scanResult, nativeScore) {
+    if (!className || className.trim() === "") return this.createEmptyReport(className);
+    if (!bundleAnalysis) return this.createEmptyReport(className);
     const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    const affectedComponents = this.findAffectedComponents(normalizedClass, scanResult);
-    const directUsage = affectedComponents.filter((c) => c.usageType === "direct").length;
-    const indirectUsage = affectedComponents.filter((c) => c.usageType !== "direct").length;
-    const totalComponents = affectedComponents.length;
+    const totalComponents = nativeScore?.usageCount ?? bundleAnalysis.totalUsage ?? 0;
+    const directUsage = totalComponents;
+    const indirectUsage = 0;
     const bundleSizeBytes = bundleAnalysis.bundleSizeBytes || 0;
-    const estimatedSavings = this.calculateSavings(bundleSizeBytes, totalComponents);
-    const impactReport = {
-      className: normalizedClass,
-      totalComponents,
-      directUsage,
-      indirectUsage,
-      bundleSizeBytes,
-      estimatedSavings,
-      riskLevel: "low",
-      suggestions: []
-    };
-    impactReport.riskLevel = this.calculateRisk(normalizedClass, impactReport);
-    impactReport.suggestions = this.generateSuggestions(normalizedClass, impactReport);
-    return impactReport;
-  }
-  findAffectedComponents(className, scanResult) {
-    const components = [];
-    if (!className || className.trim() === "") {
-      return components;
-    }
-    if (!scanResult || !Array.isArray(scanResult.files)) {
-      return components;
-    }
-    const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    const classParts = normalizedClass.split(":");
-    for (const file of scanResult.files) {
-      if (!file || !file.file) continue;
-      const filePath = file.file;
-      const classes = file.classes || [];
-      const variants = file.variants || [];
-      for (const [i, fileClass] of classes.entries()) {
-        if (!fileClass) continue;
-        const normalizedFileClass = fileClass.startsWith(".") ? fileClass.slice(1) : fileClass;
-        if (normalizedFileClass === normalizedClass) {
-          components.push({
-            file: filePath,
-            line: file.lineNumbers?.[i] || 1,
-            column: file.columnNumbers?.[i] || 1,
-            usageType: "direct"
-          });
-        } else if (normalizedFileClass.includes(normalizedClass)) {
-          const variant = classParts.length > 1 ? classParts[0] : void 0;
-          components.push({
-            file: filePath,
-            line: file.lineNumbers?.[i] || 1,
-            column: file.columnNumbers?.[i] || 1,
-            usageType: "variant",
-            variant
-          });
-        }
-      }
-      for (const [i, variant] of variants.entries()) {
-        if (!variant) continue;
-        if (variant.includes(normalizedClass)) {
-          const baseClass = variant.split(":").pop();
-          if (baseClass === normalizedClass) {
-            components.push({
-              file: filePath,
-              line: file.lineNumbers?.[i] || 1,
-              column: file.columnNumbers?.[i] || 1,
-              usageType: "variant",
-              variant: variant.split(":")[0]
-            });
-          }
-        }
-      }
-    }
-    return components;
-  }
-  calculateRisk(className, impact) {
-    if (!className || className.trim() === "") {
-      return "low";
-    }
-    if (!impact) {
-      return "low";
-    }
-    const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    if (impact.totalComponents > 10) {
-      return "high";
-    }
-    if (this.isCriticalClass(normalizedClass)) {
-      return "high";
+    const native = getNativeEngineBinding();
+    if (native?.computeImpactMetadata) {
+      const impactJson = JSON.stringify({
+        className: normalizedClass,
+        totalComponents,
+        indirectUsage,
+        bundleSizeBytes
+      });
+      const result = JSON.parse(native.computeImpactMetadata(normalizedClass, impactJson));
+      return {
+        className: normalizedClass,
+        totalComponents,
+        directUsage,
+        indirectUsage,
+        bundleSizeBytes,
+        estimatedSavings: result.estimatedSavings,
+        riskLevel: result.riskLevel,
+        suggestions: result.suggestions
+      };
     }
-    if (impact.totalComponents >= 5 && impact.totalComponents <= 10) {
-      return "medium";
+    if (native?.calculateImpact) {
+      const impactJson = JSON.stringify({
+        className: normalizedClass,
+        totalComponents,
+        indirectUsage,
+        bundleSizeBytes
+      });
+      const result = JSON.parse(native.calculateImpact(impactJson));
+      return {
+        className: normalizedClass,
+        totalComponents,
+        directUsage,
+        indirectUsage,
+        bundleSizeBytes,
+        estimatedSavings: result.estimatedSavings,
+        riskLevel: result.riskLevel,
+        suggestions: result.suggestions
+      };
     }
-    return "low";
+    throw new Error("FATAL: Native binding 'computeImpactMetadata' or 'calculateImpact' is required but not available.");
   }
-  generateSuggestions(className, impact) {
-    const suggestions = [];
-    if (!className || className.trim() === "") {
-      return suggestions;
-    }
-    if (!impact) {
-      return suggestions;
+  findAffectedComponents(className, scanResult) {
+    if (!className || !scanResult) return [];
+    const native = getNativeEngineBinding();
+    if (!native?.calculateImpactScores) {
+      throw new Error("FATAL: Native binding 'calculateImpactScores' is required but not available.");
     }
     const normalizedClass = className.startsWith(".") ? className.slice(1) : className;
-    if (impact.riskLevel === "high") {
-      if (impact.totalComponents > 10) {
-        suggestions.push(
-          `This class is used in ${impact.totalComponents} components. Consider creating a utility component instead.`
-        );
-      }
-      if (this.isCriticalClass(normalizedClass)) {
-        suggestions.push(
-          "This is a critical positioning/display class. Review all usages before removal."
-        );
-      }
-      suggestions.push("Manual code review recommended before removing this class.");
-    } else if (impact.riskLevel === "medium") {
-      suggestions.push(
-        `This class is used in ${impact.totalComponents} components. Test each component after removal.`
-      );
-      if (impact.indirectUsage > 0) {
-        suggestions.push("Check for indirect usages via variants before removing.");
-      }
-    } else {
-      if (impact.totalComponents > 0) {
-        suggestions.push("Low risk: class is used in fewer than 5 components.");
-      } else {
-        suggestions.push("This class appears to be unused. Consider removing it.");
-      }
-    }
-    if (impact.estimatedSavings > 0) {
-      suggestions.push(`Estimated bundle size savings: ~${impact.estimatedSavings} bytes.`);
-    }
-    if (impact.bundleSizeBytes > 100) {
-      suggestions.push(
-        "This class has significant CSS bundle contribution. Removal will improve load times."
-      );
+    const scores = native.calculateImpactScores(
+      [normalizedClass],
+      JSON.stringify(scanResult),
+      "",
+      1,
+      0
+    );
+    if (!scores[0]?.usageCount) return [];
+    const components = [];
+    for (const file of scanResult.files) {
+      if (!file.classes?.includes(normalizedClass)) continue;
+      components.push({
+        file: file.file,
+        line: 1,
+        column: 1,
+        usageType: "direct"
+      });
     }
-    return suggestions;
+    return components;
   }
+  /**
+   * Cek apakah sebuah class dianggap "critical" (tidak boleh dihapus).
+   *
+   * Native: Rust `is_critical_class()` — O(n) pattern match di CRITICAL_PATTERNS.
+   * Lebih cepat dari regex JS untuk daftar panjang karena no backtracking.
+   *
+   * @example
+   * tracker.isCriticalClass("sr-only")     // true
+   * tracker.isCriticalClass("hidden")      // true
+   * tracker.isCriticalClass("bg-red-500")  // false
+   */
   isCriticalClass(className) {
-    const normalized = className.startsWith(".") ? className.slice(1) : className;
-    return this.criticalPatterns.some(
-      (pattern) => normalized === pattern || normalized.startsWith(`${pattern}:`)
-    );
+    const native = getNativeEngineBinding();
+    if (native?.isCriticalClass) {
+      return native.isCriticalClass(className);
+    }
+    return false;
   }
-  calculateSavings(bundleSize, componentCount) {
-    const baseSavings = bundleSize;
-    const componentOverhead = componentCount * 50;
-    return Math.max(0, baseSavings - componentOverhead);
+  /**
+   * Generate human-readable suggestions berdasarkan impact analysis.
+   *
+   * Native: `generate_suggestions()` di Rust — pattern matching di CRITICAL_PATTERNS
+   * + threshold-based risk categories.
+   *
+   * Biasanya dipanggil setelah `calculateImpact` yang sudah set riskLevel.
+   */
+  generateSuggestions(className, report) {
+    const native = getNativeEngineBinding();
+    if (native?.generateSuggestions) {
+      return native.generateSuggestions(className, JSON.stringify(report));
+    }
+    return [];
   }
   createEmptyReport(className) {
-    const normalizedClass = className?.startsWith(".") ? className.slice(1) : className || "";
     return {
-      className: normalizedClass,
+      className: className?.startsWith(".") ? className.slice(1) : className || "",
       totalComponents: 0,
       directUsage: 0,
       indirectUsage: 0,
@@ -9659,6 +9563,15 @@ var RuleId = class {
     return `R${this.value}`;
   }
 };
+var SelectorId = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  toString() {
+    return `S${this.value}`;
+  }
+};
 var VariantChainId = class {
   constructor(value) {
     this.value = value;
@@ -9716,322 +9629,308 @@ var ConditionId = class {
     return `C${this.value}`;
   }
 };
-var propertyNames = /* @__PURE__ */ new Map();
-var valueNames = /* @__PURE__ */ new Map();
+var CascadeResolutionId = class {
+  constructor(value) {
+    this.value = value;
+  }
+  value;
+  toString() {
+    return `R${this.value}`;
+  }
+};
+var _propertyNamesFallback = /* @__PURE__ */ new Map();
+var _valueNamesFallback = /* @__PURE__ */ new Map();
+function registerPropertyName(id, name) {
+  const native = getNativeEngineBinding();
+  if (native?.registerPropertyName) {
+    native.registerPropertyName(id.value, name);
+    return;
+  }
+  _propertyNamesFallback.set(id.value, name);
+}
+function registerValueName(id, name) {
+  const native = getNativeEngineBinding();
+  if (native?.registerValueName) {
+    native.registerValueName(id.value, name);
+    return;
+  }
+  _valueNamesFallback.set(id.value, name);
+}
 function propertyIdToString(id) {
-  return propertyNames.get(id.value) ?? `P${id.value}`;
+  const native = getNativeEngineBinding();
+  if (native?.propertyIdToString) {
+    return native.propertyIdToString(id.value);
+  }
+  return _propertyNamesFallback.get(id.value) ?? `P${id.value}`;
 }
 function valueIdToString(id) {
-  return valueNames.get(id.value) ?? `V${id.value}`;
-}
-function createFingerprint(parts) {
+  const native = getNativeEngineBinding();
+  if (native?.valueIdToString) {
+    return native.valueIdToString(id.value);
+  }
+  return _valueNamesFallback.get(id.value) ?? `V${id.value}`;
+}
+var CascadeStage = /* @__PURE__ */ ((CascadeStage2) => {
+  CascadeStage2[CascadeStage2["Origin"] = 0] = "Origin";
+  CascadeStage2[CascadeStage2["Layer"] = 1] = "Layer";
+  CascadeStage2[CascadeStage2["Importance"] = 2] = "Importance";
+  CascadeStage2[CascadeStage2["Specificity"] = 3] = "Specificity";
+  CascadeStage2[CascadeStage2["Order"] = 4] = "Order";
+  return CascadeStage2;
+})(CascadeStage || {});
+function createFingerprintFallback(parts) {
   const hash = parts.reduce(
     (acc, part) => part.split("").reduce((h, char) => (h << 5) - h + char.charCodeAt(0) & h, acc),
     0
   );
   return Math.abs(hash).toString(36);
 }
+function createFingerprint(parts) {
+  const native = getNativeEngineBinding();
+  if (native?.createFingerprint) {
+    return native.createFingerprint(parts);
+  }
+  return createFingerprintFallback(parts);
+}
 
 // packages/domain/engine/src/reverseLookup.ts
-var ReverseLookup = class _ReverseLookup {
-  parsedCache = /* @__PURE__ */ new Map();
-  static MAX_CACHE_SIZE = 1e3;
-  /** Jumlah karakter total yang disimpan di cache (approx) */
-  cacheSizeBytes = 0;
-  static MAX_CACHE_BYTES = 10 * 1024 * 1024;
-  // 10MB
-  parseCSS(css) {
-    const cached = this.parsedCache.get(css);
-    if (cached) {
-      return cached;
-    }
-    try {
-      const native = (() => {
-        try {
-          return getNativeEngineBinding();
-        } catch {
-          return null;
-        }
-      })();
-      if (native?.parseCssRulesNative) {
-        const raw = native.parseCssRulesNative(css);
-        const rules2 = (raw ?? []).map((r) => ({
-          className: r.className,
-          property: r.property,
-          value: r.value,
-          specificity: r.specificity,
-          source: { file: "", line: 0, column: 0 },
-          isImportant: r.isImportant,
-          variants: r.variants,
-          isOverride: false
-        }));
-        this.pruneCache();
-        this.parsedCache.set(css, rules2);
-        return rules2;
-      }
-    } catch {
-    }
-    const rules = [];
-    const classMap = /* @__PURE__ */ new Map();
-    const selectorRegex = /\.([a-zA-Z_][a-zA-Z0-9_-]*)/g;
-    const propertyRegex = /([a-zA-Z-]+)\s*:\s*([^;]+)/g;
-    const importantRegex = /!important\s*;?\s*$/;
-    const lines = css.split("\n");
-    const columnState = { offset: 0 };
-    for (const [i, line] of lines.entries()) {
-      const lineEnd = columnState.offset + line.length + 1;
-      for (const match of line.matchAll(selectorRegex)) {
-        const className = match[1];
-        const selectorStart = match.index;
-        const lineColumn = selectorStart + 1;
-        if (!classMap.has(className)) {
-          classMap.set(className, /* @__PURE__ */ new Map());
-        }
-        const braceMatch = css.indexOf("{", lineEnd - 1);
-        if (braceMatch !== -1) {
-          const closingBraceMatch = this.findClosingBrace(css, braceMatch);
-          const ruleContent = css.substring(braceMatch + 1, closingBraceMatch);
-          const variants = [];
-          const variantMatch = className.match(/^(.+?)(?::([a-zA-Z0-9_-]+))?$/);
-          if (variantMatch?.[2]) {
-            variants.push(variantMatch[2]);
-          }
-          const specificity = this.calculateSpecificity(className);
-          const source = {
-            file: "inline",
-            line: i + 1,
-            column: lineColumn
-          };
-          for (const propMatch of ruleContent.matchAll(propertyRegex)) {
-            const property = propMatch[1].trim();
-            const rawValue = propMatch[2].trim();
-            const isImportant = importantRegex.test(rawValue);
-            const value = isImportant ? rawValue.replace(importantRegex, "").trim() : rawValue;
-            const rule = {
-              className,
-              property,
-              value,
-              specificity,
-              source,
-              isImportant,
-              variants,
-              isOverride: false
-            };
-            rules.push(rule);
-            const classRules = classMap.get(className);
-            const existingProp = classRules.get(property);
-            if (existingProp) {
-              rule.isOverride = true;
-            }
-            classRules.set(property, rule);
-          }
-        }
-      }
-      columnState.offset = lineEnd;
-    }
-    this.pruneCache();
-    this.parsedCache.set(css, rules);
-    return rules;
+function getNative() {
+  const native = getNativeEngineBinding();
+  if (!native?.reverseLookupFromCss || !native?.reverseLookupByProperty || !native?.reverseLookupFindDependents) {
+    throw new Error(
+      "FATAL: Native bindings 'reverseLookupFromCss', 'reverseLookupByProperty', 'reverseLookupFindDependents' are required but not available.\nBuild the native Rust module: npm run build:rust"
+    );
   }
-  findClosingBrace(css, start) {
-    let depth = 1;
-    for (let pos = start + 1; pos < css.length; pos++) {
-      const char = css[pos];
-      if (char === "{") depth++;
-      else if (char === "}") {
-        depth--;
-        if (depth === 0) return pos;
-      }
-    }
-    return css.length;
+  return native;
+}
+function normaliseNativeResults(raw) {
+  return raw.map((r) => ({
+    property: r.property,
+    value: r.value,
+    usedInClasses: r.usedInClasses.map((u) => ({
+      className: u.className,
+      source: { file: "", line: 0, column: 0 },
+      specificity: u.specificity,
+      isOverride: u.isOverride,
+      variants: u.variants
+    }))
+  }));
+}
+var ReverseLookup = class {
+  fromCSS(cssProperty, cssValue, css) {
+    if (!css || !cssProperty) return [];
+    return normaliseNativeResults(getNative().reverseLookupFromCss(css, cssProperty, cssValue));
   }
-  calculateSpecificity(className) {
-    const pseudoClasses = className.match(/:[a-zA-Z-]+/g) || [];
-    const attributes = className.match(/\[[^\]]+\]/g) || [];
-    const pseudoElements = className.match(/::[a-zA-Z-]+/g) || [];
-    return 1 + pseudoClasses.length * 10 + attributes.length * 10 + pseudoElements.length * 100;
+  findByProperty(property, css) {
+    if (!css || !property) return [];
+    return normaliseNativeResults(getNative().reverseLookupByProperty(css, property));
   }
-  fromCSS(cssProperty, cssValue, css) {
-    if (!css || !cssProperty) {
-      return [];
-    }
-    const rules = this.parseCSS(css);
-    const normalizedProperty = cssProperty.toLowerCase();
-    const normalizedValue = cssValue.toLowerCase().trim();
-    const usages = [];
-    for (const rule of rules) {
-      if (rule.property.toLowerCase() !== normalizedProperty) {
-        continue;
-      }
-      const ruleValueLower = rule.value.toLowerCase().trim();
-      if (ruleValueLower !== normalizedValue && !ruleValueLower.includes(normalizedValue)) {
-        continue;
-      }
-      usages.push({
-        className: rule.className,
-        source: rule.source,
-        specificity: rule.specificity,
-        isOverride: rule.isOverride || false,
-        variants: rule.variants
-      });
-    }
-    if (usages.length === 0) {
-      return [];
-    }
-    return [{ property: normalizedProperty, value: cssValue, usedInClasses: usages }];
+  findDependents(className, css) {
+    if (!css || !className) return [];
+    return getNative().reverseLookupFindDependents(css, className);
   }
   fromBundle(className, css) {
-    if (!css || !className) {
-      return [];
+    if (!css || !className) return [];
+    const native = getNativeEngineBinding();
+    if (!native?.parseCssRules) {
+      throw new Error("FATAL: Native binding 'parseCssRules' is required but not available.");
     }
-    const rules = this.parseCSS(css);
+    const raw = native.parseCssRules(css);
     const results = [];
-    for (const rule of rules) {
-      if (rule.className === className || rule.className.startsWith(`${className}:`)) {
-        const ruleIR = {
-          id: { value: results.length },
-          selector: { value: 0 },
-          variantChain: { value: 0 },
-          property: { value: 0 },
-          value: { value: 0 },
-          origin: 2,
-          importance: rule.isImportant ? 1 : 0,
-          layer: null,
-          layerOrder: 0,
-          specificity: rule.specificity,
-          condition: null,
-          conditionResult: 0,
-          insertionOrder: results.length,
-          fingerprint: "",
-          source: rule.source
-        };
-        results.push(ruleIR);
-      }
+    for (const rule of raw ?? []) {
+      if (rule.className !== className && !rule.className.startsWith(`${className}:`)) continue;
+      results.push({
+        id: { value: results.length },
+        selector: { value: 0 },
+        variantChain: { value: 0 },
+        property: { value: 0 },
+        value: { value: 0 },
+        origin: 2,
+        importance: rule.isImportant ? 1 : 0,
+        layer: null,
+        layerOrder: 0,
+        specificity: rule.specificity,
+        condition: null,
+        conditionResult: 0,
+        insertionOrder: results.length,
+        fingerprint: "",
+        source: { file: "", line: 0, column: 0 }
+      });
     }
     return results;
   }
-  findDependents(className, css) {
-    if (!css || !className) {
-      return [];
-    }
-    const rules = this.parseCSS(css);
-    const dependents = /* @__PURE__ */ new Set();
-    const classParts = className.split(":");
-    const baseClass = classParts[0];
-    for (const rule of rules) {
-      const ruleBaseClass = rule.className.split(":")[0];
-      if (ruleBaseClass === baseClass && rule.className !== className) {
-        dependents.add(rule.className);
-      }
-      if (rule.className.includes(baseClass) && rule.className !== className) {
-        const isVariant = rule.className.includes(":");
-        if (isVariant && !rule.className.startsWith(`${className}:`)) {
-          dependents.add(rule.className);
-        }
-      }
-    }
-    return Array.from(dependents);
+  clearCache() {
+    getNativeEngineBinding()?.reverseLookupClearCache?.();
   }
-  findByProperty(property, css) {
-    if (!css || !property) {
-      return [];
-    }
-    const rules = this.parseCSS(css);
-    const normalizedProperty = property.toLowerCase();
-    const valueMap = /* @__PURE__ */ new Map();
-    for (const rule of rules) {
-      if (rule.property.toLowerCase() !== normalizedProperty) {
-        continue;
-      }
-      const classUsage = {
-        className: rule.className,
-        source: rule.source,
-        specificity: rule.specificity,
-        isOverride: rule.isOverride || false,
-        variants: rule.variants
-      };
-      let usages = valueMap.get(rule.value);
-      if (!usages) {
-        usages = [];
-        valueMap.set(rule.value, usages);
-      }
-      usages.push(classUsage);
-    }
-    const results = [];
-    for (const [value, usedInClasses] of valueMap) {
-      results.push({ property: normalizedProperty, value, usedInClasses });
-    }
-    return results;
+  get cacheSize() {
+    return getNativeEngineBinding()?.reverseLookupCacheSize?.() ?? 0;
+  }
+};
+
+// packages/domain/engine/src/resolver.ts
+function toNativeInput(rule) {
+  return {
+    id: rule.id.value,
+    property: rule.property.value,
+    origin: rule.origin,
+    importance: rule.importance,
+    layerOrder: rule.layerOrder,
+    specificity: rule.specificity,
+    conditionResult: rule.conditionResult,
+    insertionOrder: rule.insertionOrder
+  };
+}
+function callResolveCascade(rules) {
+  const native = getNativeEngineBinding();
+  if (!native.resolveCascade) {
+    throw new Error(
+      "FATAL: Native binding 'resolveCascade' is required but not available.\nThis function requires native Rust bindings.\n\nResolution steps:\n1. Build the native Rust module: npm run build:rust"
+    );
+  }
+  const json = JSON.stringify(rules.map(toNativeInput));
+  return JSON.parse(native.resolveCascade(json));
+}
+function buildResolutionsMap(nativeResult, rules, styleGraph) {
+  const propertyIdMap = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (!propertyIdMap.has(rule.property.value)) {
+      propertyIdMap.set(rule.property.value, rule.property);
+    }
+  }
+  const resolvedProperties = /* @__PURE__ */ new Map();
+  for (const res of nativeResult.resolutions) {
+    const propertyId = propertyIdMap.get(res.propertyId);
+    if (!propertyId) continue;
+    const winner = { value: res.winnerId };
+    const losers = res.loserIds.map((v) => ({ value: v }));
+    const existing = styleGraph.ruleConflicts.get(winner) ?? [];
+    styleGraph.ruleConflicts.set(winner, [...existing, ...losers.filter((l) => !existing.some((e) => e.value === l.value))]);
+    resolvedProperties.set(propertyId, {
+      id: new CascadeResolutionId(res.id),
+      property: propertyId,
+      winner,
+      losers,
+      reason: { causes: res.causes, finalDecision: res.finalDecision },
+      stage: res.stage
+    });
+  }
+  return resolvedProperties;
+}
+var CascadeResolver = class {
+  rules = /* @__PURE__ */ new Map();
+  classRules = /* @__PURE__ */ new Map();
+  styleGraph = { ruleConflicts: /* @__PURE__ */ new Map() };
+  addRule(rule) {
+    this.rules.set(rule.id, rule);
+  }
+  addRules(rules) {
+    for (const rule of rules) this.addRule(rule);
+  }
+  registerClass(className, ruleIds) {
+    this.classRules.set(className, ruleIds);
+  }
+  getRule(ruleId) {
+    return this.rules.get(ruleId);
+  }
+  getClassRules(className) {
+    return this.classRules.get(className);
+  }
+  getStyleGraph() {
+    return this.styleGraph;
   }
   /**
-   * Kosongkan seluruh parsed cache.
-   * Panggil ini saat CSS berubah (watch mode) atau saat memory pressure.
+   * Resolve cascade for a specific class.
+   * Delegates sort + winner selection to Rust.
    */
-  clearCache() {
-    this.parsedCache.clear();
-    this.cacheSizeBytes = 0;
+  resolveByClassName(className) {
+    const ruleIds = this.classRules.get(className);
+    if (!ruleIds || ruleIds.length === 0) return null;
+    const classRules = ruleIds.map((id) => this.rules.get(id)).filter((r) => r !== void 0);
+    if (classRules.length === 0) return null;
+    const nativeResult = callResolveCascade(classRules);
+    return { resolvedProperties: buildResolutionsMap(nativeResult, classRules, this.styleGraph) };
   }
   /**
-   * Hapus entri cache lama sampai di bawah threshold.
-   * Dipakai oleh parseCSS secara internal.
+   * Resolve cascade for all rules.
+   * Delegates sort + winner selection to Rust.
    */
-  pruneCache() {
-    while ((this.parsedCache.size >= _ReverseLookup.MAX_CACHE_SIZE || this.cacheSizeBytes >= _ReverseLookup.MAX_CACHE_BYTES) && this.parsedCache.size > 0) {
-      const firstKey = this.parsedCache.keys().next().value;
-      if (firstKey === void 0) break;
-      const removed = this.parsedCache.get(firstKey);
-      this.parsedCache.delete(firstKey);
-      this.cacheSizeBytes -= firstKey.length + (removed?.length ?? 0) * 100;
-      if (this.cacheSizeBytes < 0) this.cacheSizeBytes = 0;
-    }
+  resolveAllProperties() {
+    const allRules = Array.from(this.rules.values());
+    if (allRules.length === 0) return /* @__PURE__ */ new Map();
+    const nativeResult = callResolveCascade(allRules);
+    return buildResolutionsMap(nativeResult, allRules, this.styleGraph);
   }
-  /** Cache size untuk observability/diagnostics */
-  get cacheSize() {
-    return this.parsedCache.size;
+  /**
+   * Resolve cascade for a specific set of rule IDs.
+   */
+  resolveForClass(classRuleIds) {
+    const classRules = classRuleIds.map((id) => this.rules.get(id)).filter((r) => r !== void 0);
+    if (classRules.length === 0) return /* @__PURE__ */ new Map();
+    const nativeResult = callResolveCascade(classRules);
+    return buildResolutionsMap(nativeResult, classRules, this.styleGraph);
+  }
+  /**
+   * Resolve cascade for a single property bucket.
+   */
+  resolveProperty(property) {
+    const bucketRuleIds = Array.from(this.rules.values()).filter((r) => r.property.value === property.value);
+    if (bucketRuleIds.length === 0) return null;
+    const nativeResult = callResolveCascade(bucketRuleIds);
+    const resolved = buildResolutionsMap(nativeResult, bucketRuleIds, this.styleGraph);
+    return resolved.get(property) ?? null;
+  }
+  getResolution(_id) {
+    return void 0;
   }
 };
 
-// packages/infrastructure/cli/src/utils/traceService.ts
-init_src2();
-init_src();
-var createIdGenerator = () => {
-  const _counters = {
-    ruleId: 0,
-    selectorId: 0,
-    propertyId: 0,
-    valueId: 0,
-    layerId: 0,
-    conditionId: 0,
-    insertionOrder: 0
-  };
-  const generateRuleId = () => new RuleId(_counters.ruleId++);
-  const generateSelectorId = () => new RuleId(_counters.selectorId++);
-  const generatePropertyId = (propertyName) => new PropertyId(_counters.propertyId++, propertyName);
-  const generateValueId = (valueName) => new ValueId(_counters.valueId++, valueName);
-  const generateLayerId = () => new LayerId(_counters.layerId++);
-  const generateConditionId = () => new ConditionId(_counters.conditionId++);
-  const getNextInsertionOrder = () => _counters.insertionOrder++;
-  const reset = () => {
-    _counters.ruleId = 0;
-    _counters.selectorId = 0;
-    _counters.propertyId = 0;
-    _counters.valueId = 0;
-    _counters.layerId = 0;
-    _counters.conditionId = 0;
-    _counters.insertionOrder = 0;
+// packages/domain/engine/src/cssToIr.ts
+function createIdGenerator() {
+  const state = {
+    ruleIdCounter: 0,
+    selectorIdCounter: 0,
+    propertyIdCounter: 0,
+    valueIdCounter: 0,
+    layerIdCounter: 0,
+    conditionIdCounter: 0,
+    insertionOrderCounter: 0
   };
   return {
-    generateRuleId,
-    generateSelectorId,
-    generatePropertyId,
-    generateValueId,
-    generateLayerId,
-    generateConditionId,
-    getNextInsertionOrder,
-    reset
+    generateRuleId: () => new RuleId(state.ruleIdCounter++),
+    generateSelectorId: () => new SelectorId(state.selectorIdCounter++),
+    generatePropertyId: (name) => {
+      const id = new PropertyId(state.propertyIdCounter++);
+      registerPropertyName(id, name);
+      return id;
+    },
+    generateValueId: (name) => {
+      const id = new ValueId(state.valueIdCounter++);
+      registerValueName(id, name);
+      return id;
+    },
+    generateLayerId: () => new LayerId(state.layerIdCounter++),
+    generateConditionId: () => new ConditionId(state.conditionIdCounter++),
+    getNextInsertionOrder: () => state.insertionOrderCounter++,
+    reset: () => {
+      state.ruleIdCounter = 0;
+      state.selectorIdCounter = 0;
+      state.propertyIdCounter = 0;
+      state.valueIdCounter = 0;
+      state.layerIdCounter = 0;
+      state.conditionIdCounter = 0;
+      state.insertionOrderCounter = 0;
+    }
   };
-};
-var idGenerator = createIdGenerator();
+}
+var _defaultIdGen = createIdGenerator();
+var generateRuleId = () => _defaultIdGen.generateRuleId();
+var generateSelectorId = () => _defaultIdGen.generateSelectorId();
+var generatePropertyId = (name) => _defaultIdGen.generatePropertyId(name);
+var generateValueId = (name) => _defaultIdGen.generateValueId(name);
+var generateLayerId = () => _defaultIdGen.generateLayerId();
+var generateConditionId = () => _defaultIdGen.generateConditionId();
+var getNextInsertionOrder = () => _defaultIdGen.getNextInsertionOrder();
+var resetIdGenerator = () => _defaultIdGen.reset();
 var layerMap = /* @__PURE__ */ new Map();
 var layerOrderMap = /* @__PURE__ */ new Map();
 var LAYER_ORDER = {
@@ -10043,109 +9942,41 @@ var LAYER_ORDER = {
 function getOrCreateLayerId(layerName) {
   const existing = layerMap.get(layerName);
   if (existing) return existing;
-  const order = LAYER_ORDER[layerName] ?? 4;
-  const layerId = idGenerator.generateLayerId();
+  const layerId = generateLayerId();
   layerMap.set(layerName, layerId);
-  layerOrderMap.set(layerName, order);
+  layerOrderMap.set(layerName, LAYER_ORDER[layerName] ?? 4);
   return layerId;
 }
-function calculateSpecificity(selector) {
-  const classCount = selector.className.split(":").length * 10;
-  const pseudoCount = selector.pseudoClasses.length * 10;
-  const mediaCount = selector.mediaQuery ? 1e3 : 0;
-  return classCount + pseudoCount + mediaCount;
-}
-function parseSelector(selectorText) {
-  const mediaMatch = selectorText.match(/^@media[^{]+\{(.+)$/);
-  const mediaQuery = mediaMatch ? mediaMatch[0] : null;
-  const baseClass = (mediaMatch ? mediaMatch[1].trim() : selectorText).startsWith(".") ? (mediaMatch ? mediaMatch[1].trim() : selectorText).slice(1) : mediaMatch ? mediaMatch[1].trim() : selectorText;
-  const escapedColon = /\\:/g;
-  const baseClassClean = baseClass.startsWith(".") ? baseClass.slice(1) : baseClass;
-  const baseClassFinal = baseClassClean.replace(escapedColon, "\u200B").split(":")[0].replace(/\u200B/g, ":");
-  const variantRegex = /^(hover|focus|active|visited|checked|disabled|required|optional|first|last|odd|even|before|after|placeholder|file|selection|backdrop|group|peer)/i;
-  const pseudoRegex = /^:([a-zA-Z-]+)$/;
-  const parts = baseClassFinal.split(":").slice(1);
-  const { variants, pseudoClasses } = parts.reduce(
-    (acc, part) => {
-      const normalized = `:${part}`;
-      if (variantRegex.test(part)) {
-        acc.variants.push(part);
-      } else if (pseudoRegex.test(normalized)) {
-        acc.pseudoClasses.push(normalized);
-      } else {
-        acc.variants.push(part);
-      }
-      return acc;
-    },
-    { variants: [], pseudoClasses: [] }
-  );
-  return {
-    className: baseClassFinal,
-    variants,
-    pseudoClasses,
-    mediaQuery
-  };
-}
-function parseDeclaration(block) {
-  const declarations = [];
-  for (const match of block.matchAll(/([a-zA-Z-]+)\s*:\s*([^;!]+)(!important)?/g)) {
-    const property = match[1].trim();
-    const value = match[2].trim();
-    const important = match[3] !== void 0;
-    declarations.push({ property, value, important });
-  }
-  return declarations;
-}
-function parseRules(css) {
-  const rules = [];
-  for (const match of css.matchAll(/([^{}]+)\s*\{([^{}]*)\}/g)) {
-    const selectorText = match[1].trim();
-    const declarationBlock = match[2].trim();
-    if (selectorText.startsWith("@")) {
-      continue;
-    }
-    const parsedSelector = parseSelector(selectorText);
-    const declarations = parseDeclaration(declarationBlock);
-    for (const decl of declarations) {
-      rules.push({
-        selector: parsedSelector,
-        property: decl.property,
-        value: decl.value,
-        important: decl.important
-      });
-    }
-  }
-  return rules;
-}
-function detectLayerFromSelector(className) {
-  const layerPrefixes = ["tw-", "tailwind-"];
-  for (const prefix of layerPrefixes) {
-    if (className.startsWith(prefix)) {
-      return "tailwind";
-    }
-  }
+function detectLayerFromClassName(className) {
+  if (className.startsWith("tw-") || className.startsWith("tailwind-")) return "tailwind";
   return null;
 }
-function parseCssToIr(css, prefix = "") {
-  idGenerator.reset();
+function parseCssToIr(css, options = {}) {
+  resetIdGenerator();
   layerMap.clear();
   layerOrderMap.clear();
+  const native = getNativeEngineBinding();
+  if (!native?.parseCssRules) {
+    throw new Error("FATAL: Native binding 'parseCssRules' is required but not available.");
+  }
+  const prefix = options.prefix ?? "";
   const rules = [];
   const classToRuleIds = /* @__PURE__ */ new Map();
-  const parsedRules = parseRules(css);
-  for (const parsedRule of parsedRules) {
-    const className = prefix + parsedRule.selector.className;
-    const specificity = calculateSpecificity(parsedRule.selector);
-    const layerName = detectLayerFromSelector(className);
+  const parsed = native.parseCssRules(css);
+  for (const r of parsed) {
+    const className = prefix + r.className;
+    r.variants.length > 0;
+    const layerName = detectLayerFromClassName(className);
     const layer = layerName ? getOrCreateLayerId(layerName) : null;
     const layerOrder = layerName ? layerOrderMap.get(layerName) ?? 4 : 4;
-    const selectorId = idGenerator.generateSelectorId();
-    const propertyId = idGenerator.generatePropertyId(parsedRule.property);
-    const valueId = idGenerator.generateValueId(parsedRule.value);
-    const conditionId = parsedRule.selector.mediaQuery ? idGenerator.generateConditionId() : null;
-    const conditionResult = parsedRule.selector.mediaQuery ? 2 /* Unknown */ : 2 /* Unknown */;
-    const fingerprint = createFingerprint([className, parsedRule.property, parsedRule.value]);
-    const ruleId = idGenerator.generateRuleId();
+    const selectorId = generateSelectorId();
+    const propertyId = generatePropertyId(r.property);
+    const valueId = generateValueId(r.value);
+    const hasMedia = r.variants.some((v) => v.startsWith("@") || v === "dark" || v === "print");
+    const conditionId = hasMedia ? generateConditionId() : null;
+    const conditionResult = hasMedia ? 2 /* Unknown */ : 2 /* Unknown */;
+    const ruleId = generateRuleId();
+    const fingerprint = createFingerprint([className, r.property, r.value]);
     const rule = {
       id: ruleId,
       selector: selectorId,
@@ -10153,117 +9984,58 @@ function parseCssToIr(css, prefix = "") {
       property: propertyId,
       value: valueId,
       origin: 2 /* AuthorNormal */,
-      importance: parsedRule.important ? 1 /* Important */ : 0 /* Normal */,
+      importance: r.isImportant ? 1 /* Important */ : 0 /* Normal */,
       layer,
       layerOrder,
-      specificity,
+      specificity: r.specificity,
+      // from native — no JS recalculation
       condition: conditionId,
       conditionResult,
-      insertionOrder: idGenerator.getNextInsertionOrder(),
+      insertionOrder: getNextInsertionOrder(),
       fingerprint,
-      source: {
-        file: "",
-        line: 1,
-        column: 1
-      }
+      source: { file: "", line: 1, column: 1 }
     };
     rules.push(rule);
-    const existingRuleIds = classToRuleIds.get(className) || [];
-    existingRuleIds.push(ruleId);
-    classToRuleIds.set(className, existingRuleIds);
+    const existing = classToRuleIds.get(className) ?? [];
+    existing.push(ruleId);
+    classToRuleIds.set(className, existing);
   }
   return { rules, classToRuleIds };
 }
-var CascadeResolver = class {
-  propertyBuckets = /* @__PURE__ */ new Map();
-  rules = /* @__PURE__ */ new Map();
-  classRules = /* @__PURE__ */ new Map();
-  addRule(rule) {
-    this.rules.set(rule.id, rule);
-    const property = rule.property;
-    const existingBucket = this.propertyBuckets.get(property);
-    if (!existingBucket) {
-      this.propertyBuckets.set(property, {
-        property,
-        rules: [rule.id]
-      });
-    } else {
-      this.propertyBuckets.set(property, {
-        ...existingBucket,
-        rules: [...existingBucket.rules, rule.id]
-      });
-    }
-  }
-  addRules(rules) {
-    for (const rule of rules) {
-      this.addRule(rule);
-    }
-  }
-  getRule(ruleId) {
-    return this.rules.get(ruleId);
-  }
-  registerClass(className, ruleIds) {
-    this.classRules.set(className, ruleIds);
-  }
-  getClassRules(className) {
-    return this.classRules.get(className);
-  }
-  resolveByClassName(className) {
-    const ruleIds = this.classRules.get(className);
-    if (!ruleIds) {
-      return null;
-    }
-    const classRules = [];
-    for (const ruleId of ruleIds) {
-      const rule = this.rules.get(ruleId);
-      if (rule) {
-        classRules.push(rule);
-      }
-    }
-    const propertyMap = /* @__PURE__ */ new Map();
-    for (const rule of classRules) {
-      const existing = propertyMap.get(rule.property) || [];
-      existing.push(rule);
-      propertyMap.set(rule.property, existing);
-    }
-    const resolved = /* @__PURE__ */ new Map();
-    for (const [property, rules] of propertyMap) {
-      if (rules.length > 0) {
-        const activeRules = rules.filter((r) => r.conditionResult !== 1 /* Inactive */);
-        if (activeRules.length > 0) {
-          activeRules.sort((a, b) => {
-            const originDiff = b.origin - a.origin;
-            if (originDiff !== 0) return originDiff;
-            const layerDiff = b.layerOrder - a.layerOrder;
-            if (layerDiff !== 0) return layerDiff;
-            const importanceDiff = b.importance - a.importance;
-            if (importanceDiff !== 0) return importanceDiff;
-            const specificityDiff = b.specificity - a.specificity;
-            if (specificityDiff !== 0) return specificityDiff;
-            return b.insertionOrder - a.insertionOrder;
-          });
-          const winner = activeRules[0];
-          resolved.set(property, { winner: winner.id });
-        }
-      }
-    }
-    return { resolvedProperties: resolved };
-  }
-};
-function trace(className, resolver) {
-  const provenance = {
+
+// packages/domain/engine/src/trace.ts
+function buildProvenanceChain(className) {
+  return {
+    className,
     source: { file: "", line: 0, column: 0 },
     variants: /* @__PURE__ */ new Map(),
     rules: /* @__PURE__ */ new Map()
   };
+}
+function formatCause(c) {
+  switch (c.type) {
+    case "LowerOrigin":
+      return "lower origin";
+    case "LowerLayer":
+      return "lower layer";
+    case "LowerImportance":
+      return "lower importance";
+    case "LowerSpecificity":
+      return `specificity ${c.delta}`;
+    case "EarlierOrder":
+      return `earlier order ${c.delta}`;
+    case "InactiveCondition":
+      return "inactive condition";
+  }
+}
+function trace(className, resolver) {
+  const provenance = buildProvenanceChain(className);
   const classRuleIds = resolver.getClassRules(className);
   const allRules = [];
   if (classRuleIds) {
     for (const ruleId of classRuleIds) {
       const rule = resolver.getRule(ruleId);
-      if (rule) {
-        allRules.push(rule);
-      }
+      if (rule) allRules.push(rule);
     }
   }
   for (const rules of provenance.rules.values()) {
@@ -10272,57 +10044,49 @@ function trace(className, resolver) {
   const rulesByProperty = /* @__PURE__ */ new Map();
   for (const rule of allRules) {
     const propKey = rule.property.toString();
-    if (!rulesByProperty.has(propKey)) {
-      rulesByProperty.set(propKey, []);
-    }
-    rulesByProperty.get(propKey).push(rule);
+    const bucket = rulesByProperty.get(propKey) ?? [];
+    bucket.push(rule);
+    rulesByProperty.set(propKey, bucket);
   }
+  const resolved = resolver.resolveByClassName(className);
   const ruleTraces = [];
   const conflictTraces = [];
-  for (const [property, rules] of rulesByProperty) {
-    if (rules.length === 0) continue;
-    const activeRules = rules.filter((r) => r.conditionResult !== 1 /* Inactive */);
-    if (activeRules.length === 0) continue;
-    activeRules.sort((a, b) => {
-      const originDiff = b.origin - a.origin;
-      if (originDiff !== 0) return originDiff;
-      const layerDiff = b.layerOrder - a.layerOrder;
-      if (layerDiff !== 0) return layerDiff;
-      const importanceDiff = b.importance - a.importance;
-      if (importanceDiff !== 0) return importanceDiff;
-      const specificityDiff = b.specificity - a.specificity;
-      if (specificityDiff !== 0) return specificityDiff;
-      return b.insertionOrder - a.insertionOrder;
-    });
-    const winnerRule = activeRules[0];
-    const losers = activeRules.slice(1);
-    ruleTraces.push({
-      property,
-      value: winnerRule.value.toString(),
-      applied: true,
-      reason: null,
-      source: winnerRule.source,
-      specificity: winnerRule.specificity
-    });
-    for (const loserRule of losers) {
-      ruleTraces.push({
-        property,
-        value: loserRule.value.toString(),
-        applied: false,
-        reason: "lower specificity",
-        source: loserRule.source,
-        specificity: loserRule.specificity
-      });
-      conflictTraces.push({
-        property,
-        winner: winnerRule.value.toString(),
-        loser: loserRule.value.toString(),
-        stage: "Specificity",
-        causes: ["lower specificity"]
-      });
+  if (resolved) {
+    for (const [propId, resolution] of resolved.resolvedProperties) {
+      const property = propId.toString();
+      const rules = rulesByProperty.get(property) ?? [];
+      const winnerRule = rules.find((r) => r.id.value === resolution.winner.value);
+      if (winnerRule) {
+        ruleTraces.push({
+          property,
+          value: winnerRule.value.toString(),
+          applied: true,
+          reason: null,
+          source: winnerRule.source,
+          specificity: winnerRule.specificity
+        });
+      }
+      for (const loserId of resolution.losers) {
+        const loserRule = rules.find((r) => r.id.value === loserId.value);
+        if (!loserRule) continue;
+        ruleTraces.push({
+          property,
+          value: loserRule.value.toString(),
+          applied: false,
+          reason: resolution.reason.finalDecision,
+          source: loserRule.source,
+          specificity: loserRule.specificity
+        });
+        conflictTraces.push({
+          property,
+          winner: winnerRule?.value.toString() ?? "",
+          loser: loserRule.value.toString(),
+          stage: CascadeStage[resolution.stage],
+          causes: resolution.reason.causes.map(formatCause)
+        });
+      }
     }
   }
-  const resolved = resolver.resolveByClassName(className);
   const finalStyle = [];
   if (resolved) {
     for (const [propId, resolution] of resolved.resolvedProperties) {
@@ -10342,6 +10106,30 @@ function trace(className, resolver) {
     finalStyle
   };
 }
+
+// packages/infrastructure/cli/src/utils/traceService.ts
+init_src2();
+init_src();
+function safeToString(value) {
+  if (value === null || value === void 0) return "";
+  if (typeof value === "string") return value;
+  if (typeof value === "number") return String(value);
+  if (typeof value === "object") {
+    const obj = value;
+    if (typeof obj.name === "string" && obj.name.length > 0) return obj.name;
+    if (obj.value !== void 0) return String(obj.value);
+    const toStr = obj.toString;
+    if (typeof toStr === "function") {
+      try {
+        const result = toStr.call(value);
+        if (typeof result === "string" && result !== "[object Object]") return result;
+      } catch {
+      }
+    }
+    return "?";
+  }
+  return String(value);
+}
 async function traceClass(className, options) {
   const root = options?.root ?? process.cwd();
   const scanResult = await scanWorkspace(root, {
@@ -10375,53 +10163,16 @@ async function traceClass(className, options) {
   const { rules, classToRuleIds } = parseCssToIr(cssResult.code);
   const ruleIds = classToRuleIds.get(className);
   if (!ruleIds || ruleIds.length === 0) {
-    throw TwError.fromCompile("TRACE_NO_RULES_FOUND", `No rules found for class "${className}" after parsing CSS.`);
+    throw TwError.fromCompile(
+      "TRACE_NO_RULES_FOUND",
+      `No rules found for class "${className}" after parsing CSS.`
+    );
   }
   const resolver = new CascadeResolver();
   resolver.addRules(rules);
   resolver.registerClass(className, ruleIds);
-  const engineTraceResult = trace(className, resolver);
-  return convertTraceResult(engineTraceResult);
-}
-function safeToString(value) {
-  if (value === null || value === void 0) return "";
-  if (typeof value === "string") return String(value);
-  if (typeof value === "number") return String(value);
-  if (typeof value === "boolean") return String(value);
-  if (typeof value === "object" && value !== null) {
-    const obj = value;
-    const name = obj.name;
-    if (typeof name === "string" && name.length > 0) {
-      return name;
-    }
-    const objValue = obj.value;
-    if (objValue !== void 0) {
-      return String(objValue);
-    }
-    const objValueOf = obj.valueOf;
-    if (typeof objValueOf === "function") {
-      try {
-        const vo = objValueOf.call(value);
-        if (vo !== value) return String(vo);
-      } catch {
-      }
-    }
-    const toStr = obj.toString;
-    if (typeof toStr === "function") {
-      try {
-        const result = toStr.call(value);
-        if (typeof result === "string" && result !== "[object Object]") {
-          return result;
-        }
-      } catch {
-      }
-    }
-    return "?";
-  }
-  return String(value);
-}
-function convertTraceResult(engineResult) {
-  return {
+  const engineResult = trace(className, resolver);
+  const result = {
     class: safeToString(engineResult.class),
     definedAt: {
       file: safeToString(engineResult.definedAt.file),
@@ -10433,7 +10184,8 @@ function convertTraceResult(engineResult) {
       value: safeToString(v.value),
       source: {
         file: safeToString(v.source?.file ?? ""),
-        line: Number(v.source?.line ?? 0)
+        line: Number(v.source?.line ?? 0),
+        column: Number(v.source?.column ?? 0)
       }
     })),
     rules: engineResult.rules.map((r) => ({
@@ -10443,7 +10195,8 @@ function convertTraceResult(engineResult) {
       reason: r.reason ? safeToString(r.reason) : null,
       source: {
         file: safeToString(r.source?.file ?? ""),
-        line: Number(r.source?.line ?? 0)
+        line: Number(r.source?.line ?? 0),
+        column: Number(r.source?.column ?? 0)
       },
       specificity: Number(r.specificity ?? 0)
     })),
@@ -10452,17 +10205,18 @@ function convertTraceResult(engineResult) {
       winner: safeToString(c.winner),
       loser: safeToString(c.loser),
       stage: safeToString(c.stage),
-      causes: c.causes?.map(safeToString) ?? []
+      causes: (c.causes ?? []).map(safeToString)
     })),
     finalStyle: engineResult.finalStyle.map((f) => ({
       property: safeToString(f.property),
       value: safeToString(f.value)
     }))
   };
+  return result;
 }
 init_src2();
 function toRelativePath(root, value) {
-  const relative = path3.relative(root, value);
+  const relative = path6__default.relative(root, value);
   return relative.length > 0 ? relative : ".";
 }
 function uniqueSorted(values) {
@@ -10531,7 +10285,7 @@ function tryCompileClasses(classes) {
   }
 }
 function traceSingleFile(filePath, root) {
-  const source = fs8.readFileSync(filePath, "utf8");
+  const source = fs11__default.readFileSync(filePath, "utf8");
   const classes = uniqueSorted(scanSource(source));
   const imports = extractImports(source);
   const compiled = tryCompileClasses(classes);
@@ -10562,7 +10316,7 @@ function traceDirectory(targetDir, root) {
   const imports = [];
   const importKeys = /* @__PURE__ */ new Set();
   const files = scanResult.files.filter((entry) => isScannableFile(entry.file, DEFAULT_EXTENSIONS)).map((entry) => {
-    const source = fs8.readFileSync(entry.file, "utf8");
+    const source = fs11__default.readFileSync(entry.file, "utf8");
     const fileImports = extractImports(source);
     for (const fileImport of fileImports) {
       const key = `${fileImport.kind}:${fileImport.source}`;
@@ -10593,12 +10347,12 @@ function traceDirectory(targetDir, root) {
   };
 }
 async function traceTarget(target, options = {}) {
-  const root = path3.resolve(options.root ?? process.cwd());
-  const resolvedTarget = path3.resolve(root, target);
-  if (!fs8.existsSync(resolvedTarget)) {
+  const root = path6__default.resolve(options.root ?? process.cwd());
+  const resolvedTarget = path6__default.resolve(root, target);
+  if (!fs11__default.existsSync(resolvedTarget)) {
     throw new Error(`Trace target not found: ${resolvedTarget}`);
   }
-  const stat = fs8.statSync(resolvedTarget);
+  const stat = fs11__default.statSync(resolvedTarget);
   if (stat.isDirectory()) {
     return traceDirectory(resolvedTarget, root);
   }
@@ -10767,7 +10521,7 @@ async function runGenerateTypesCli(rawArgs) {
   const logger = createCliLogger({ output });
   const cwd2 = process.cwd();
   const outFile = rawArgs.find((a) => a.startsWith("--out="))?.slice(6) ?? "src/types/tailwind-styled.d.ts";
-  const outPath = path3.resolve(cwd2, outFile);
+  const outPath = path6__default.resolve(cwd2, outFile);
   output.writeText("");
   output.writeText(import_picocolors6.default.bold(import_picocolors6.default.cyan("  \u25C6 tw generate-types")));
   output.writeText(import_picocolors6.default.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
@@ -10781,12 +10535,11 @@ async function runGenerateTypesCli(rawArgs) {
       throw new Error("Native binding 'generateSubComponentTypes' tidak tersedia \u2014 pastikan build:rust sudah dijalankan");
     }
     result = binding.generateSubComponentTypes(cwd2, outPath);
+    if (!result) throw new Error("generateSubComponentTypes mengembalikan null");
     spinner.stop(`Scanned ${result.filesScanned} files`);
   } catch (err) {
     spinner.error("Scan gagal");
-    logger.warn(err instanceof Error ? err.message : String(err));
-    output.writeText(import_picocolors6.default.dim("  \u2192 fallback ke JS scanner..."));
-    result = await fallbackJsScan(cwd2);
+    throw err instanceof Error ? err : new Error(String(err));
   }
   if (!result) {
     logger.warn("Tidak ada hasil scan");
@@ -10804,12 +10557,12 @@ async function runGenerateTypesCli(rawArgs) {
   }
   output.writeText("");
   output.writeText(import_picocolors6.default.bold("  [2/2]") + import_picocolors6.default.cyan("  generate .d.ts"));
-  const outDir = path3.dirname(outPath);
-  if (!fs8.existsSync(outDir)) {
-    fs8.mkdirSync(outDir, { recursive: true });
+  const outDir = path6__default.dirname(outPath);
+  if (!fs11__default.existsSync(outDir)) {
+    fs11__default.mkdirSync(outDir, { recursive: true });
   }
-  fs8.writeFileSync(outPath, result.dtsContent, "utf-8");
-  logger.ok(path3.relative(cwd2, outPath));
+  fs11__default.writeFileSync(outPath, result.dtsContent, "utf-8");
+  logger.ok(path6__default.relative(cwd2, outPath));
   output.writeText("");
   output.writeText(import_picocolors6.default.dim("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   output.writeText(import_picocolors6.default.bold(import_picocolors6.default.green("  \u2713 types generated")));
@@ -10820,11 +10573,11 @@ async function runGenerateTypesCli(rawArgs) {
 }
 async function loadNativeBinding2(cwd2) {
   const candidates = [
-    path3.join(cwd2, "native", "tailwind-styled-native.node"),
-    path3.join(cwd2, "node_modules", "tailwind-styled-v4", "native", "tailwind-styled-native.node")
+    path6__default.join(cwd2, "native", "tailwind-styled-native.node"),
+    path6__default.join(cwd2, "node_modules", "tailwind-styled-v4", "native", "tailwind-styled-native.node")
   ];
   for (const candidate of candidates) {
-    if (fs8.existsSync(candidate)) {
+    if (fs11__default.existsSync(candidate)) {
       try {
         return __require(candidate);
       } catch {
@@ -10833,42 +10586,6 @@ async function loadNativeBinding2(cwd2) {
   }
   return null;
 }
-async function fallbackJsScan(cwd2, outPath) {
-  const { execSync } = await import('child_process');
-  const registerRe = /registerSubComponent\s*\(\s*\{[^}]*name\s*:\s*["']([a-zA-Z][a-zA-Z0-9_-]*)["']/g;
-  const withSubRe = /\.withSub\s*<\s*([^>]+)\s*>/g;
-  const literalRe = /["']([a-zA-Z][a-zA-Z0-9_-]*)["']/g;
-  const names = /* @__PURE__ */ new Set();
-  let filesScanned = 0;
-  try {
-    const files = execSync(
-      `find . -name "*.tsx" -o -name "*.ts" -o -name "*.jsx" -o -name "*.js" | grep -v node_modules | grep -v .next | grep -v dist`,
-      { cwd: cwd2, encoding: "utf-8" }
-    ).trim().split("\n").filter(Boolean);
-    for (const file of files) {
-      try {
-        const source = fs8.readFileSync(path3.join(cwd2, file), "utf-8");
-        filesScanned++;
-        for (const m of source.matchAll(registerRe)) names.add(m[1]);
-        for (const m of source.matchAll(withSubRe)) {
-          for (const lit of m[1].matchAll(literalRe)) names.add(lit[1]);
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  const sorted = [...names].sort();
-  const union = sorted.map((n) => `"${n}"`).join(" | ") || "never";
-  const dtsContent = `// AUTO-GENERATED by tailwind-styled-v4 (JS fallback)
-// DO NOT EDIT \u2014 Run: npx tw generate-types to regenerate
-
-declare module "tailwind-styled-v4" {
-  export type DetectedSubComponents = ${union}
-}
-`;
-  return { names: sorted, dtsContent, filesScanned };
-}
 
 // packages/infrastructure/cli/src/commands/why.ts
 init_errors();
@@ -10919,7 +10636,7 @@ async function whyClass(className, options) {
   for (const file of scanResult.files) {
     const source = (() => {
       try {
-        return fs8.readFileSync(file.file, "utf8");
+        return fs11__default.readFileSync(file.file, "utf8");
       } catch {
         return "";
       }
@@ -10933,7 +10650,7 @@ async function whyClass(className, options) {
           className
         ]);
         usedIn.push({
-          file: path3.relative(root, file.file) || path3.basename(file.file),
+          file: path6__default.relative(root, file.file) || path6__default.basename(file.file),
           line: location.line,
           column: location.column,
           usage: normalizeScannedClass(fileClass)
@@ -11099,7 +10816,7 @@ function buildMainProgram(context) {
   new Map(miscCommands.map((command) => [command.name, command]));
   const scriptByName = new Map(scriptCommands.map((command) => [command.name, command]));
   const program2 = new Command("tw");
-  program2.name("tw").description("tailwind-styled-v4 CLI").option("--json", "Output strict JSON envelope").option("--debug", "Include stack traces for errors").option("--verbose", "Verbose runtime logs");
+  program2.name("tw").description("tailwind-styled-v4 CLI").version("5.0.4", "--version", "Output the current version").option("--json", "Output strict JSON envelope").option("--debug", "Include stack traces for errors").option("--verbose", "Verbose runtime logs");
   program2.command("setup").description("Auto-setup project").option("--yes", "Skip prompts").option("--next", "Force Next.js").option("--vite", "Force Vite").option("--rspack", "Force Rspack").option("--react", "Force React").option("--dry-run", "Preview changes").option("--skip-install", "Skip package install").action(async (...actionArgs) => {
     const options = actionCommand(actionArgs).opts();
     const args = [];
@@ -11388,12 +11105,20 @@ function buildMainProgram(context) {
 
 // packages/infrastructure/cli/src/index.ts
 init_runtime();
+init_args();
+init_args();
+init_output();
 async function main2() {
   await runCliMain({
     importMetaUrl: import.meta.url,
     buildProgram: buildMainProgram
   });
 }
-main2();
+var __filename2 = fileURLToPath(import.meta.url);
+if (process.argv[1] === __filename2) {
+  main2();
+}
+
+export { createCliOutput, ensureFlag, parseCliInput as parseCliArgs, runScanCli };
 //# sourceMappingURL=cli.mjs.map
 //# sourceMappingURL=cli.mjs.map