tailwind-styled-v4 5.0.8 → 5.0.10

package/dist/scanner.mjs

@@ -1,8 +1,10 @@
-import path3 from 'path';
+import 'crypto';
+import fs3 from 'fs';
+import path5 from 'path';
 import { fileURLToPath } from 'url';
-import fs from 'fs';
 import { createRequire } from 'module';
-import { Worker } from 'worker_threads';
+import { isMainThread, parentPort, workerData, Worker } 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,34 +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 createLogger(namespace) {
   const prefix = `[${namespace}]`;
   return {
@@ -89,24 +57,19 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path4) {
-  if (!path4 || path4.length === 0) return "(root)";
-  return path4.map(
+function formatIssuePath(path6) {
+  if (!path6 || path6.length === 0) return "(root)";
+  return path6.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 path4 = getNodePath();
-  const fs2 = getNodeFs();
   for (const candidate of candidates) {
-    const candidatePath = path4.resolve(runtimeDir, candidate);
+    const candidatePath = path5.resolve(runtimeDir, candidate);
     try {
-      if (!fs2.existsSync(candidatePath) && !fs2.existsSync(candidatePath + ".node")) {
+      if (!fs3.existsSync(candidatePath) && !fs3.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -120,62 +83,48 @@ 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(path4) {
-  return _require(path4);
+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 path4 = getNodePath();
-  const fs2 = 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 (fs2.existsSync(runtimeDir)) {
+  if (fs3.existsSync(runtimeDir)) {
     try {
-      const entries = fs2.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(path4.resolve(runtimeDir, "..", "..", "..", "native", defaultBindingName));
-  candidates.push(path4.resolve(runtimeDir, "..", "..", "..", "..", "native", defaultBindingName));
-  candidates.push(path4.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));
 }
-var isBrowser, nodeModuleRef, _nodeFs, _nodePath, 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;
     TwError = class _TwError extends Error {
       /** @deprecated Gunakan source */
       domain;
@@ -209,8 +158,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 path4 = formatIssuePath(first?.path);
-        const message = first ? `${path4}: ${first.message}` : "Schema validation failed";
+        const path6 = formatIssuePath(first?.path);
+        const message = first ? `${path6}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -228,21 +177,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() {
@@ -250,7 +211,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();
 }
@@ -331,6 +292,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"() {
@@ -421,8 +471,8 @@ 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);
@@ -461,15 +511,110 @@ function filePriority(mtimeMs, size, cached, nowMs = Date.now()) {
 
 // packages/domain/scanner/src/index.ts
 init_native_bridge();
+init_native_bridge();
+var PARALLEL_THRESHOLD = 50;
+var DEFAULT_CHUNK_SIZE = 150;
+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() };
+}
+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);
+  }
+}
+var _workerFilename = typeof __filename !== "undefined" ? __filename : fileURLToPath(import.meta.url);
+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);
+}
 
 // packages/domain/scanner/src/schemas.ts
 init_src();
-var formatIssuePath2 = (path4) => path4.length > 0 ? path4.map(
+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 path4 = formatIssuePath2(issue.path);
-  return `${path4}: ${issue.message}`;
+  const path6 = formatIssuePath2(issue.path);
+  return `${path6}: ${issue.message}`;
 }).join("; ");
 var parseWithSchema = (schema, data, label) => {
   const parsed = schema.safeParse(data);
@@ -524,6 +669,7 @@ var parseScanWorkspaceResult = (result) => parseWithSchema(ScanWorkspaceResultSc
 var parseScannerWorkerMessage = (message) => parseWithSchema(ScannerWorkerMessageSchema, message, "scanner worker message is invalid");
 
 // packages/domain/scanner/src/index.ts
+init_native_bridge();
 var log2 = createLogger("scanner");
 var SCAN_WORKER_TIMEOUT_MS = 12e4;
 function getRuntimeDir() {
@@ -531,7 +677,7 @@ function getRuntimeDir() {
     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();
 }
@@ -546,12 +692,25 @@ var createNativeParserLoader = () => {
   const loadNativeParserBinding = () => {
     if (_state.binding !== void 0) return _state.binding;
     const runtimeDir = getRuntimeDir();
-    const req = createRequire(path3.join(runtimeDir, "noop.cjs"));
+    const req = createRequire(path5.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
+      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,
         "..",
         "..",
@@ -563,7 +722,7 @@ var createNativeParserLoader = () => {
       )
     ];
     for (const fullPath of candidates) {
-      if (!fs.existsSync(fullPath)) continue;
+      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")) {
@@ -599,17 +758,17 @@ function resolveScannerWorkerModulePath() {
       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;
 }
@@ -666,19 +825,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);
     }
   }
@@ -692,9 +851,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(
@@ -702,15 +864,18 @@ function scanSource(source) {
   );
 }
 function isScannableFile(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
-  return includeExtensions.includes(path3.extname(filePath));
+  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 = {}) {
@@ -759,7 +924,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs.statSync(filePath);
+          return fs3.statSync(filePath);
         } catch {
           return null;
         }
@@ -785,7 +950,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;
         }
@@ -847,19 +1012,26 @@ 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);
   }
 }
 
-export { DEFAULT_EXTENSIONS, DEFAULT_IGNORES, isScannableFile, parseScanWorkspaceOptions, parseScanWorkspaceResult, parseScannerWorkerMessage, scanFile, scanSource, scanWorkspace, scanWorkspaceAsync };
+export { DEFAULT_EXTENSIONS, DEFAULT_IGNORES, batchExtractClassesNative, extractClassesNative, isScannableFile, parseScanWorkspaceOptions, parseScanWorkspaceResult, parseScannerWorkerMessage, scanFile, scanSource, scanWorkspace, scanWorkspaceAsync };
 //# sourceMappingURL=scanner.mjs.map
 //# sourceMappingURL=scanner.mjs.map