tailwind-styled-v4 5.0.9 → 5.0.10

package/dist/analyzer.mjs

@@ -1,8 +1,10 @@
-import path3 from 'path';
+import 'crypto';
+import fs3 from 'fs';
+import path5 from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
-import fs from 'fs';
 import { createRequire } from 'module';
-import { Worker } from 'worker_threads';
+import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
+import { availableParallelism } from 'os';
 import { z } from 'zod';
 
 /* tailwind-styled-v4 v5.0.4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
@@ -10,12 +12,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -32,41 +28,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// packages/domain/shared/src/index.ts
-function getNodeModuleRef() {
-  if (isBrowser) return null;
-  if (nodeModuleRef !== null) return nodeModuleRef;
-  try {
-    const test = typeof __require === "function" ? __require("module") : null;
-    nodeModuleRef = test;
-    return test;
-  } catch {
-    nodeModuleRef = null;
-    return null;
-  }
-}
-function getNodeFs() {
-  if (isBrowser) throw new Error("node:fs not available in browser");
-  const nodeRequire = getNodeModuleRef();
-  if (!nodeRequire) throw new Error("require not available");
-  if (!_nodeFs) _nodeFs = nodeRequire.createRequire(import.meta.url)("node:fs");
-  return _nodeFs;
-}
-function getNodePath() {
-  if (isBrowser) throw new Error("node:path not available in browser");
-  const nodeRequire = getNodeModuleRef();
-  if (!nodeRequire) throw new Error("require not available");
-  if (!_nodePath) _nodePath = nodeRequire.createRequire(import.meta.url)("node:path");
-  return _nodePath;
-}
-function getNodeUrl() {
-  if (isBrowser) throw new Error("node:url not available in browser");
-  const nodeRequire = getNodeModuleRef();
-  if (!nodeRequire) throw new Error("require not available");
-  if (!_nodeUrl) _nodeUrl = nodeRequire.createRequire(import.meta.url)("node:url");
-  return _nodeUrl;
-}
 function createLogger(namespace) {
   const prefix = `[${namespace}]`;
   return {
@@ -96,24 +57,19 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path6) {
-  if (!path6 || path6.length === 0) return "(root)";
-  return path6.map(
+function formatIssuePath(path8) {
+  if (!path8 || path8.length === 0) return "(root)";
+  return path8.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
 function loadNativeBinding(options) {
-  if (isBrowser) {
-    return { binding: null, loadErrors: [{ path: "", message: "Native bindings not available in browser" }] };
-  }
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
-  const path6 = getNodePath();
-  const fs4 = getNodeFs();
   for (const candidate of candidates) {
-    const candidatePath = path6.resolve(runtimeDir, candidate);
+    const candidatePath = path5.resolve(runtimeDir, candidate);
     try {
-      if (!fs4.existsSync(candidatePath) && !fs4.existsSync(candidatePath + ".node")) {
+      if (!fs3.existsSync(candidatePath) && !fs3.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -127,72 +83,56 @@ function loadNativeBinding(options) {
   }
   return { binding: null, loadErrors };
 }
-function getRequire() {
-  if (isBrowser) return (() => {
-    throw new Error("require not available in browser");
-  });
-  const nodeRequire = getNodeModuleRef();
-  if (!nodeRequire) return (() => {
-    throw new Error("require not available");
-  });
-  return nodeRequire.createRequire(import.meta.url);
-}
-function requireNativeModule(path6) {
-  return _require(path6);
+function requireNativeModule(p) {
+  return _require(p);
 }
 function resolveNativeBindingCandidates(options) {
-  if (isBrowser) 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 path6 = getNodePath();
-  const fs4 = getNodeFs();
   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 (fs4.existsSync(runtimeDir)) {
+  if (fs3.existsSync(runtimeDir)) {
     try {
-      const entries = fs4.readdirSync(runtimeDir);
-      for (const entry of entries) {
-        if (entry.endsWith(".node")) {
-          candidates.push(entry);
-        }
+      for (const entry of fs3.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(path6.resolve(runtimeDir, "..", "..", "..", "native", defaultBindingName));
-  candidates.push(path6.resolve(runtimeDir, "..", "..", "..", "..", "native", defaultBindingName));
-  candidates.push(path6.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(path5.resolve(runtimeDir, `${bin}.node`));
+    candidates.push(path5.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(path5.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path5.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path5.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(path5.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(path5.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+  }
   return Array.from(new Set(candidates));
 }
 function resolveRuntimeDir(dir, importMetaUrl) {
-  if (isBrowser) return "";
-  if (dir) return getNodePath().resolve(dir);
+  if (dir) return path5.resolve(dir);
   try {
-    return getNodeUrl().fileURLToPath(importMetaUrl);
+    return path5.dirname(fileURLToPath(importMetaUrl));
   } catch {
     return process.cwd();
   }
 }
-var isBrowser, nodeModuleRef, _nodeFs, _nodePath, _nodeUrl, TwError, _require;
+var TwError, _require;
 var init_src = __esm({
   "packages/domain/shared/src/index.ts"() {
-    isBrowser = typeof window !== "undefined" || typeof document !== "undefined";
-    nodeModuleRef = null;
-    _nodeFs = null;
-    _nodePath = null;
-    _nodeUrl = null;
     TwError = class _TwError extends Error {
       /** @deprecated Gunakan source */
       domain;
@@ -226,8 +166,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 path6 = formatIssuePath(first?.path);
-        const message = first ? `${path6}: ${first.message}` : "Schema validation failed";
+        const path8 = formatIssuePath(first?.path);
+        const message = first ? `${path8}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -245,21 +185,33 @@ var init_src = __esm({
         return `[${this.source.toUpperCase()}:${this.code}] ${this.message}`;
       }
     };
-    _require = getRequire();
+    _require = 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 getDirname() {
@@ -267,7 +219,7 @@ function getDirname() {
     return __dirname;
   }
   if (typeof import.meta !== "undefined" && import.meta.url) {
-    return path3.dirname(fileURLToPath(import.meta.url));
+    return path5.dirname(fileURLToPath(import.meta.url));
   }
   return process.cwd();
 }
@@ -348,6 +300,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"() {
@@ -431,15 +472,9 @@ var init_native_bridge = __esm({
     resetScannerBridgeCache = scannerBridgeLoader.reset;
   }
 });
-
-// packages/domain/scanner/src/index.ts
-init_src();
-
-// packages/domain/scanner/src/cache-native.ts
-init_native_bridge();
 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 ? path5.resolve(rootDir, cacheDir) : path5.join(process.cwd(), ".cache", "tailwind-styled");
+  return path5.join(dir, "scanner-cache.json");
 }
 function readCache(rootDir, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
@@ -475,158 +510,219 @@ function filePriority(mtimeMs, size, cached, nowMs = Date.now()) {
     nowMs
   );
 }
-
-// packages/domain/scanner/src/index.ts
-init_native_bridge();
-
-// packages/domain/scanner/src/schemas.ts
-init_src();
-var formatIssuePath2 = (path6) => path6.length > 0 ? path6.map(
-  (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
-).join(".") : "<root>";
-var formatIssues = (error) => error.issues.map((issue) => {
-  const path6 = formatIssuePath2(issue.path);
-  return `${path6}: ${issue.message}`;
-}).join("; ");
-var parseWithSchema = (schema, data, label) => {
-  const parsed = schema.safeParse(data);
-  if (parsed.success) return parsed.data;
-  const details = formatIssues(parsed.error);
-  throw new TwError(
-    "validation",
-    "SCHEMA_VALIDATION_FAILED",
-    details ? `${label}: ${details}` : label,
-    parsed.error
-  );
-};
-var NonNegativeIntegerSchema = z.number().int().min(0);
-var ScanWorkspaceOptionsSchema = z.object({
-  includeExtensions: z.array(z.string()).optional(),
-  ignoreDirectories: z.array(z.string()).optional(),
-  useCache: z.boolean().optional(),
-  cacheDir: z.string().min(1).optional(),
-  smartInvalidation: z.boolean().optional()
-});
-var ScanFileResultSchema = z.object({
-  file: z.string(),
-  classes: z.array(z.string()),
-  hash: z.string().optional()
-});
-var ScanWorkspaceResultSchema = z.object({
-  files: z.array(ScanFileResultSchema),
-  totalFiles: NonNegativeIntegerSchema,
-  uniqueClasses: z.array(z.string())
-}).refine((value) => value.totalFiles === value.files.length, {
-  message: "scan result totalFiles must match files.length",
-  path: ["totalFiles"]
-});
-z.object({
-  rootDir: z.string().min(1),
-  options: ScanWorkspaceOptionsSchema.optional()
+var init_cache_native = __esm({
+  "packages/domain/scanner/src/cache-native.ts"() {
+    init_native_bridge();
+  }
 });
-var ScannerWorkerSuccessMessageSchema = z.object({
-  ok: z.literal(true),
-  result: ScanWorkspaceResultSchema
+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 = fs3.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path5.join(dir, entry.name);
+      const rel = path5.relative(rootDir, fullPath);
+      if (entry.isDirectory()) {
+        const ignored = ignoreDirs.some((d) => entry.name === d || rel.startsWith(d + path5.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((resolve, reject) => {
+    const worker = new Worker(_workerFilename, {
+      workerData: { filePaths }
+    });
+    worker.once("message", (payload) => {
+      if (payload.ok) {
+        resolve(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(path5.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 ScannerWorkerErrorMessageSchema = z.object({
-  ok: z.literal(false),
-  error: z.string().optional()
+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 = (path8) => path8.length > 0 ? path8.map(
+      (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
+    ).join(".") : "<root>";
+    formatIssues = (error) => error.issues.map((issue) => {
+      const path8 = formatIssuePath2(issue.path);
+      return `${path8}: ${issue.message}`;
+    }).join("; ");
+    parseWithSchema = (schema, data, label) => {
+      const parsed = schema.safeParse(data);
+      if (parsed.success) return parsed.data;
+      const details = formatIssues(parsed.error);
+      throw new TwError(
+        "validation",
+        "SCHEMA_VALIDATION_FAILED",
+        details ? `${label}: ${details}` : label,
+        parsed.error
+      );
+    };
+    NonNegativeIntegerSchema = z.number().int().min(0);
+    ScanWorkspaceOptionsSchema = z.object({
+      includeExtensions: z.array(z.string()).optional(),
+      ignoreDirectories: z.array(z.string()).optional(),
+      useCache: z.boolean().optional(),
+      cacheDir: z.string().min(1).optional(),
+      smartInvalidation: z.boolean().optional()
+    });
+    ScanFileResultSchema = z.object({
+      file: z.string(),
+      classes: z.array(z.string()),
+      hash: z.string().optional()
+    });
+    ScanWorkspaceResultSchema = z.object({
+      files: z.array(ScanFileResultSchema),
+      totalFiles: NonNegativeIntegerSchema,
+      uniqueClasses: z.array(z.string())
+    }).refine((value) => value.totalFiles === value.files.length, {
+      message: "scan result totalFiles must match files.length",
+      path: ["totalFiles"]
+    });
+    z.object({
+      rootDir: z.string().min(1),
+      options: ScanWorkspaceOptionsSchema.optional()
+    });
+    ScannerWorkerSuccessMessageSchema = z.object({
+      ok: z.literal(true),
+      result: ScanWorkspaceResultSchema
+    });
+    ScannerWorkerErrorMessageSchema = z.object({
+      ok: z.literal(false),
+      error: z.string().optional()
+    });
+    ScannerWorkerMessageSchema = z.union([
+      ScannerWorkerSuccessMessageSchema,
+      ScannerWorkerErrorMessageSchema
+    ]);
+    parseScanWorkspaceOptions = (options) => parseWithSchema(ScanWorkspaceOptionsSchema, options ?? {}, "scanner options are invalid");
+    parseScanWorkspaceResult = (result) => parseWithSchema(ScanWorkspaceResultSchema, result, "scanner workspace result is invalid");
+    parseScannerWorkerMessage = (message) => parseWithSchema(ScannerWorkerMessageSchema, message, "scanner worker message is invalid");
+  }
 });
-var ScannerWorkerMessageSchema = z.union([
-  ScannerWorkerSuccessMessageSchema,
-  ScannerWorkerErrorMessageSchema
-]);
-var parseScanWorkspaceOptions = (options) => parseWithSchema(ScanWorkspaceOptionsSchema, options ?? {}, "scanner options are invalid");
-var parseScanWorkspaceResult = (result) => parseWithSchema(ScanWorkspaceResultSchema, result, "scanner workspace result is invalid");
-var parseScannerWorkerMessage = (message) => parseWithSchema(ScannerWorkerMessageSchema, message, "scanner worker message is invalid");
 
 // packages/domain/scanner/src/index.ts
-var log2 = createLogger("scanner");
-var SCAN_WORKER_TIMEOUT_MS = 12e4;
+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 path5.dirname(fileURLToPath(import.meta.url));
   }
   return process.cwd();
 }
-var createNativeParserLoader = () => {
-  const _state = {
-    binding: void 0,
-    initError: null
-  };
-  const debugNative = (message) => {
-    log2.debug(`[native] ${message}`);
-  };
-  const loadNativeParserBinding = () => {
-    if (_state.binding !== void 0) return _state.binding;
-    const runtimeDir = getRuntimeDir();
-    const req = createRequire(path3.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(
-        runtimeDir,
-        "..",
-        "..",
-        "..",
-        "native",
-        "build",
-        "Release",
-        "tailwind_styled_parser.node"
-      )
-    ];
-    for (const fullPath of candidates) {
-      if (!fs.existsSync(fullPath)) continue;
-      try {
-        const required = req(fullPath);
-        if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
-          _state.binding = required;
-          debugNative(`using native parser from ${fullPath}`);
-          return _state.binding;
-        }
-      } catch (error) {
-        _state.initError = error instanceof Error ? error.message : String(error);
-      }
-    }
-    _state.binding = null;
-    if (!_state.initError) {
-      _state.initError = "native .node binding not found";
-    }
-    debugNative(`native binding not available: ${_state.initError}`);
-    return _state.binding;
-  };
-  return {
-    get: loadNativeParserBinding,
-    reset: () => {
-      _state.binding = void 0;
-      _state.initError = null;
-    }
-  };
-};
-var nativeParserLoader = createNativeParserLoader();
-var DEFAULT_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
-var DEFAULT_IGNORES = ["node_modules", ".git", ".next", "dist", "out", ".turbo", ".cache"];
 function resolveScannerWorkerModulePath() {
   const runtimeDir = (() => {
     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 path5.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")
+    path5.resolve(runtimeDir, "worker.cjs"),
+    path5.resolve(runtimeDir, "worker.js"),
+    path5.resolve(runtimeDir, "worker.ts")
   ];
   for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) return candidate;
+    if (fs3.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -683,19 +779,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs.readdirSync(currentDir, { withFileTypes: true });
+        return fs3.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
     })();
     for (const entry of entries) {
-      const fullPath = path3.join(currentDir, entry.name);
+      const fullPath = path5.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(path5.extname(entry.name))) continue;
       candidates.push(fullPath);
     }
   }
@@ -709,22 +805,31 @@ 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(
     "FATAL: Native parser binding is required but not available.\nThis package requires native Rust bindings.\n\nResolution steps:\n1. Build the native Rust module: npm run build:rust"
   );
 }
+function isScannableFile(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
+  return includeExtensions.includes(path5.extname(filePath));
+}
 function scanFile(filePath) {
-  const source = fs.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 = {}) {
@@ -773,7 +878,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs.statSync(filePath);
+          return fs3.statSync(filePath);
         } catch {
           return null;
         }
@@ -799,7 +904,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs.readFileSync(filePath, "utf8");
+          return fs3.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -861,18 +966,113 @@ 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);
   }
 }
+var log2, SCAN_WORKER_TIMEOUT_MS, createNativeParserLoader, nativeParserLoader, DEFAULT_EXTENSIONS, DEFAULT_IGNORES;
+var init_src2 = __esm({
+  "packages/domain/scanner/src/index.ts"() {
+    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 = () => {
+      const _state = {
+        binding: void 0,
+        initError: null
+      };
+      const debugNative = (message) => {
+        log2.debug(`[native] ${message}`);
+      };
+      const loadNativeParserBinding = () => {
+        if (_state.binding !== void 0) return _state.binding;
+        const runtimeDir = getRuntimeDir();
+        const req = createRequire(path5.join(runtimeDir, "noop.cjs"));
+        const candidates = [
+          // ── binaryName baru: tailwind-styled-native (napi-rs naming) ──
+          // cwd = repo root saat run dari root, atau package dir saat workspaces
+          path5.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+          path5.resolve(process.cwd(), "native", `tailwind-styled-native.${process.platform}-${process.arch}.node`),
+          path5.resolve(process.cwd(), "native", `tailwind-styled-native.${process.platform}-${process.arch}-gnu.node`),
+          // runtimeDir = dist/ → naik 4 level ke repo root
+          path5.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+          path5.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${process.platform}-${process.arch}-gnu.node`),
+          // 3 level fallback (jika package di-nest lebih dangkal)
+          path5.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+          path5.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${process.platform}-${process.arch}-gnu.node`),
+          // ── binaryName lama: tailwind_styled_parser (backward compat) ──
+          path5.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+          path5.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
+          path5.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+          path5.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
+          path5.resolve(
+            runtimeDir,
+            "..",
+            "..",
+            "..",
+            "native",
+            "build",
+            "Release",
+            "tailwind_styled_parser.node"
+          )
+        ];
+        for (const fullPath of candidates) {
+          if (!fs3.existsSync(fullPath)) continue;
+          try {
+            const required = req(fullPath);
+            if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
+              _state.binding = required;
+              debugNative(`using native parser from ${fullPath}`);
+              return _state.binding;
+            }
+          } catch (error) {
+            _state.initError = error instanceof Error ? error.message : String(error);
+          }
+        }
+        _state.binding = null;
+        if (!_state.initError) {
+          _state.initError = "native .node binding not found";
+        }
+        debugNative(`native binding not available: ${_state.initError}`);
+        return _state.binding;
+      };
+      return {
+        get: loadNativeParserBinding,
+        reset: () => {
+          _state.binding = void 0;
+          _state.initError = null;
+        }
+      };
+    };
+    nativeParserLoader = createNativeParserLoader();
+    DEFAULT_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
+    DEFAULT_IGNORES = ["node_modules", ".git", ".next", "dist", "out", ".turbo", ".cache"];
+  }
+});
+
+// packages/domain/analyzer/src/analyzeWorkspace.ts
+init_src2();
 
 // packages/domain/analyzer/src/binding.ts
 init_src();
@@ -892,7 +1092,7 @@ function isRecord(value) {
 }
 async function pathExists(filePath) {
   try {
-    await fs.promises.access(filePath, fs.constants.F_OK);
+    await fs3.promises.access(filePath, fs3.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -955,6 +1155,9 @@ var createAnalyzerBindingLoader = () => {
   };
 };
 var analyzerBindingLoader = createAnalyzerBindingLoader();
+async function getNativeBinding() {
+  return analyzerBindingLoader.get();
+}
 async function requireNativeBinding() {
   const binding = await analyzerBindingLoader.get();
   if (binding?.analyzeClasses) return binding;
@@ -993,7 +1196,7 @@ async function requireNativeCssCompiler() {
 
 // packages/domain/analyzer/src/schemas.ts
 init_src();
-var formatIssuePath3 = (path6) => path6.length > 0 ? path6.map(
+var formatIssuePath3 = (path8) => path8.length > 0 ? path8.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var isPlainObject = (value) => {
@@ -1002,8 +1205,8 @@ var isPlainObject = (value) => {
   return proto === Object.prototype || proto === null;
 };
 var formatIssues2 = (error) => error.issues.map((issue) => {
-  const path6 = formatIssuePath3(issue.path);
-  return `${path6}: ${issue.message}`;
+  const path8 = formatIssuePath3(issue.path);
+  return `${path8}: ${issue.message}`;
 }).join("; ");
 var parseWithSchema2 = (schema, data, label) => {
   const parsed = schema.safeParse(data);
@@ -1098,112 +1301,6 @@ var parseNativeCssCompileResult = (result, className) => parseWithSchema2(
 );
 var parseClassToCssOptions = (options) => parseWithSchema2(ClassToCssOptionsSchema, options ?? {}, "classToCss options are invalid");
 var SUPPORTED_TAILWIND_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".cjs", ".mjs"]);
-var 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"
-]);
 var tailwindConfigCache = /* @__PURE__ */ new Map();
 var splitVariantAndBase = (className) => {
   const parts = className.split(":");
@@ -1233,48 +1330,28 @@ var resolveConflictGroup = (base) => {
   if (base.startsWith("m-") || base.startsWith("mx-") || base.startsWith("my-")) return "margin";
   return null;
 };
-var 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}".`
-    });
+var 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)
+  };
 };
 var isSupportedTailwindConfigPath = (configPath) => {
-  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path3.extname(configPath).toLowerCase());
+  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path5.extname(configPath).toLowerCase());
 };
 var resolveTailwindConfigPath = async (root, explicitPath) => {
   if (explicitPath) {
-    const resolved = path3.resolve(root, explicitPath);
+    const resolved = path5.resolve(root, explicitPath);
     if (!await pathExists(resolved)) return null;
     return resolved;
   }
@@ -1285,7 +1362,7 @@ var resolveTailwindConfigPath = async (root, explicitPath) => {
     "tailwind.config.mjs"
   ];
   for (const candidate of candidates) {
-    const fullPath = path3.resolve(root, candidate);
+    const fullPath = path5.resolve(root, candidate);
     if (await pathExists(fullPath)) return fullPath;
   }
   return null;
@@ -1339,15 +1416,19 @@ var collectCustomUtilities = (config) => {
   return out;
 };
 var collectSafelistFromSource = async (configPath) => {
-  const source = await fs.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 fs3.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));
 };
 var loadTailwindConfig = async (root, semanticOption) => {
   const startMs = Date.now();
@@ -1362,7 +1443,7 @@ var loadTailwindConfig = async (root, semanticOption) => {
       customUtilities: /* @__PURE__ */ new Set()
     };
   }
-  const configStat = await fs.promises.stat(configPath).catch(() => null);
+  const configStat = await fs3.promises.stat(configPath).catch(() => null);
   if (configStat) {
     const cached = tailwindConfigCache.get(configPath);
     if (cached && cached.mtimeMs === configStat.mtimeMs && cached.size === configStat.size) {
@@ -1448,21 +1529,27 @@ var utilityPrefix = (baseClass) => {
   if (hyphen < 0) return normalized;
   return normalized.slice(0, hyphen);
 };
-var 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);
-};
 var 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,
@@ -1498,13 +1585,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) {
@@ -1513,29 +1604,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 = path5.resolve(root);
   const normalizedOptions = parseAnalyzerOptions(options);
   const scan = await (async () => {
     const scanStartedAtMs = Date.now();
@@ -1579,7 +1665,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) {
@@ -1605,13 +1691,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,
@@ -1622,16 +1714,21 @@ 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 } : {}
   };
 }
 
 // packages/domain/analyzer/src/classToCss.ts
-var normalizeClassInput = (input) => {
+var 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)) {
@@ -1653,27 +1750,26 @@ var normalizeClassToCssOptions = (options) => {
   const prefix = parsed.prefix ?? null;
   return { prefix, strict };
 };
-var 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);
-    }
+var 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);
   }
 };
-var declarationMapToString = (declarationMap) => {
-  return Array.from(declarationMap.entries()).map(([property, value]) => `${property}: ${value}`).join("; ");
+var 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("; ");
 };
 var 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 {
@@ -1685,7 +1781,6 @@ var classToCss = async (input, options = {}) => {
       sizeBytes: 0
     };
   }
-  const binding = await requireNativeCssCompiler();
   const prefix = normalizedOptions.prefix;
   const results = await Promise.all(
     inputClasses.map(async (className) => {
@@ -1718,7 +1813,7 @@ var classToCss = async (input, options = {}) => {
   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) {
@@ -1727,7 +1822,7 @@ var classToCss = async (input, options = {}) => {
   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