tailwind-styled-v4 5.0.8 → 5.0.10

package/dist/vite.mjs

@@ -1,9 +1,13 @@
+import { z } from 'zod';
 import { createRequire } from 'module';
-import path3 from 'path';
+import * as fs4 from 'fs';
+import fs4__default from 'fs';
+import * as path6 from 'path';
+import path6__default from 'path';
+import { createHash } from 'crypto';
 import { fileURLToPath, pathToFileURL } from 'url';
-import fs from 'fs';
-import { Worker } from 'worker_threads';
-import { z } from 'zod';
+import { Worker, isMainThread, parentPort, workerData } from 'worker_threads';
+import { availableParallelism } from 'os';
 import 'perf_hooks';
 
 /* tailwind-styled-v4 v5.0.4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
@@ -34,6 +38,260 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// packages/domain/shared/src/trace.ts
+function getHealthColor(status) {
+  switch (status) {
+    case "healthy":
+      return "#34d399";
+    case "degraded":
+      return "#fbbf24";
+    case "unhealthy":
+      return "#f87171";
+    default:
+      return "#52525b";
+  }
+}
+function getModeColor(mode) {
+  switch (mode) {
+    case "build":
+      return "#fbbf24";
+    case "watch":
+      return "#34d399";
+    case "jit":
+      return "#60a5fa";
+    case "error":
+      return "#f87171";
+    case "idle":
+      return "#71717a";
+    default:
+      return "#52525b";
+  }
+}
+function formatMemory(bytes) {
+  if (bytes < 1024) return `${Math.round(bytes)}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+function formatDuration(ms) {
+  if (ms === null) return "\u2014";
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function calculateHealth(metrics, summary) {
+  if (summary?.health?.status) return summary.health.status;
+  if (metrics.mode === "error") return "unhealthy";
+  if ((metrics.buildMs ?? 0) > 5e3) return "degraded";
+  if (metrics.memoryMb && metrics.memoryMb.heapUsed > 500) return "degraded";
+  return "healthy";
+}
+function getBuildTimeColor(ms) {
+  if (ms === null) return "#52525b";
+  if (ms > 1e3) return "#f87171";
+  if (ms > 500) return "#fbbf24";
+  return "#34d399";
+}
+function getMemoryColor(mb) {
+  if (mb > 500) return "#f87171";
+  if (mb > 250) return "#fbbf24";
+  return "#34d399";
+}
+function createTraceSnapshot(data) {
+  return {
+    generatedAt: data.generatedAt || (/* @__PURE__ */ new Date()).toISOString(),
+    buildMs: data.buildMs ?? null,
+    scanMs: data.scanMs ?? null,
+    analyzeMs: data.analyzeMs ?? null,
+    compileMs: data.compileMs ?? null,
+    memoryMb: data.memoryMb ?? null,
+    classCount: data.classCount ?? null,
+    fileCount: data.fileCount ?? null,
+    cssBytes: data.cssBytes ?? null,
+    mode: data.mode ?? null,
+    eventsReceived: data.eventsReceived ?? void 0,
+    eventsProcessed: data.eventsProcessed ?? void 0,
+    batchesProcessed: data.batchesProcessed ?? void 0,
+    incrementalUpdates: data.incrementalUpdates ?? void 0,
+    fullRescans: data.fullRescans ?? void 0
+  };
+}
+function getPipelinePercentages(metrics) {
+  const scan = metrics.scanMs ?? 0;
+  const analyze = metrics.analyzeMs ?? 0;
+  const compile = metrics.compileMs ?? 0;
+  const total = scan + analyze + compile;
+  if (total === 0) {
+    return { scanPct: 0, analyzePct: 0, compilePct: 0 };
+  }
+  return {
+    scanPct: scan / total * 100,
+    analyzePct: analyze / total * 100,
+    compilePct: compile / total * 100
+  };
+}
+var init_trace = __esm({
+  "packages/domain/shared/src/trace.ts"() {
+  }
+});
+
+// packages/domain/shared/src/error-codes.ts
+function getSuggestion(code) {
+  return ERROR_SUGGESTIONS[code];
+}
+function formatErrorCode(code) {
+  const prefix = code.startsWith("E") ? "Error" : code.startsWith("W") ? "Warning" : "Code";
+  return `[${prefix} ${code}]`;
+}
+var ERROR_CODES, ERROR_SUGGESTIONS;
+var init_error_codes = __esm({
+  "packages/domain/shared/src/error-codes.ts"() {
+    ERROR_CODES = {
+      // E0xx — Native binding
+      NATIVE_NOT_FOUND: "E001",
+      NATIVE_LOAD_FAILED: "E002",
+      NATIVE_VERSION_MISMATCH: "E003",
+      SCANNER_NATIVE_NOT_FOUND: "E004",
+      SCANNER_HASH_FAILED: "E005",
+      NATIVE_TRANSFORM_UNAVAILABLE: "E006",
+      // E2xx — Compilation
+      MISSING_REACT_IMPORT: "E201",
+      UNSUPPORTED_PATTERN: "E202",
+      TEMPLATE_PARSE_ERROR: "E203",
+      COMPILE_TIMEOUT: "E204",
+      // E3xx — Compatibility
+      TAILWIND_VERSION_UNSUPPORTED: "E301",
+      NODE_VERSION_UNSUPPORTED: "E302",
+      // E4xx — Cache
+      CACHE_READ_FAILED: "E401",
+      CACHE_WRITE_FAILED: "E402",
+      CACHE_CORRUPTED: "E403",
+      // E5xx — RSC
+      RSC_BOUNDARY_CONFLICT: "E501",
+      // W1xx — Warnings
+      DYNAMIC_CONTENT: "W101",
+      INVALID_VARIANT_VALUE: "W201",
+      DEPRECATED_MODE: "W301"
+    };
+    ERROR_SUGGESTIONS = {
+      E001: "Run: npm install @tailwind-styled/native-{platform} or build from source",
+      E002: "Try: npm rebuild or reinstall the package",
+      E003: "Run: npm install tailwind-styled-v4@latest to sync versions",
+      E004: "Run: npm install @tailwind-styled/scanner",
+      E006: "Run: npm install @tailwind-styled/compiler",
+      E301: "Upgrade: npm install tailwindcss@^4"
+    };
+  }
+});
+
+// packages/domain/shared/src/compatibility.ts
+function detectTailwind() {
+  try {
+    const pkgPath = __require.resolve("tailwindcss/package.json");
+    const { version } = __require(pkgPath);
+    const major = Number.parseInt(version.split(".")[0], 10);
+    return { version, major, supported: major >= 4, path: pkgPath };
+  } catch {
+    return { version: "not-installed", major: 0, supported: false, path: null };
+  }
+}
+function assertTailwindV4() {
+  const info = detectTailwind();
+  if (!info.supported) {
+    const message = info.major === 0 ? "tailwindcss is not installed. Run: npm install tailwindcss@^4" : `tailwind-styled-v4 requires Tailwind CSS v4.x. Found: v${info.version}. Upgrade: npm install tailwindcss@^4`;
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(`[tailwind-styled] ${message}`);
+    }
+  }
+}
+function getTailwindVersion() {
+  return detectTailwind().version;
+}
+function isTailwindV4() {
+  return detectTailwind().supported;
+}
+var init_compatibility = __esm({
+  "packages/domain/shared/src/compatibility.ts"() {
+  }
+});
+function safeParseNative(schema, data, fallback) {
+  const result = schema.safeParse(data);
+  return result.success ? result.data : fallback;
+}
+function parseNative(schema, data, context) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    const first = result.error.issues[0];
+    const path13 = first?.path?.join(".") ?? "(root)";
+    throw new Error(
+      `[${context}] Native binding returned unexpected data: ${path13}: ${first?.message ?? "validation failed"}`
+    );
+  }
+  return result.data;
+}
+var NativeScanFileSchema, NativeScanResultSchema, NativeClassUsageSchema, NativeAnalyzerReportSchema, NativeTransformResultSchema, NativeCssCompileResultSchema, NativeWatchResultSchema, NativeCacheEntrySchema, NativeCacheReadResultSchema;
+var init_native_schemas = __esm({
+  "packages/domain/shared/src/native-schemas.ts"() {
+    NativeScanFileSchema = z.object({
+      file: z.string().min(1, "file path cannot be empty"),
+      classes: z.array(z.string()),
+      hash: z.string().optional()
+    });
+    NativeScanResultSchema = z.object({
+      files: z.array(NativeScanFileSchema),
+      totalFiles: z.number().int().nonnegative(),
+      uniqueClasses: z.array(z.string())
+    });
+    NativeClassUsageSchema = z.object({
+      name: z.string(),
+      count: z.number().int().nonnegative(),
+      files: z.array(z.string()).optional()
+    });
+    NativeAnalyzerReportSchema = z.object({
+      root: z.string(),
+      topClasses: z.array(NativeClassUsageSchema).optional(),
+      safelist: z.array(z.string()).optional(),
+      css: z.string().optional(),
+      conflicts: z.array(z.unknown()).optional(),
+      unusedClasses: z.array(z.string()).optional(),
+      durationMs: z.number().nonnegative().optional()
+    });
+    NativeTransformResultSchema = z.object({
+      code: z.string(),
+      classes: z.array(z.string()),
+      changed: z.boolean(),
+      rsc: z.object({
+        isServer: z.boolean(),
+        needsClientDirective: z.boolean(),
+        clientReasons: z.array(z.string())
+      }).optional()
+    });
+    NativeCssCompileResultSchema = z.object({
+      css: z.string(),
+      resolvedClasses: z.array(z.string()),
+      unresolvedClasses: z.array(z.string()).optional()
+    });
+    z.object({
+      type: z.enum(["change", "unlink", "create"]),
+      path: z.string()
+    });
+    NativeWatchResultSchema = z.object({
+      status: z.enum(["ok", "error"]),
+      handleId: z.string().optional(),
+      error: z.string().optional()
+    });
+    NativeCacheEntrySchema = z.object({
+      file: z.string(),
+      hash: z.string(),
+      classes: z.array(z.string()),
+      timestamp: z.number(),
+      size: z.number().optional()
+    });
+    NativeCacheReadResultSchema = z.object({
+      entries: z.array(NativeCacheEntrySchema),
+      version: z.string().optional()
+    });
+  }
+});
+
 // packages/domain/shared/src/esmHelpers.ts
 function getNodeModuleRef() {
   if (isBrowser) return null;
@@ -61,88 +319,551 @@ function getNodeUrl() {
   if (!_nodeUrl) _nodeUrl = nodeRequire.createRequire(import.meta.url)("node:url");
   return _nodeUrl;
 }
+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 createEsmRequire(importMetaUrl) {
+  if (isBrowser) throw new Error("require not available in browser");
+  const nodeRequire = getNodeModuleRef();
+  if (!nodeRequire) throw new Error("require not available");
+  return nodeRequire.createRequire(importMetaUrl);
+}
 function getDirname(importMetaUrl) {
   if (isBrowser) return "";
   const nodePath = getNodePath();
   const nodeUrl = getNodeUrl();
   return nodePath.dirname(nodeUrl.fileURLToPath(importMetaUrl));
 }
-var isBrowser, nodeModuleRef, _nodePath, _nodeUrl;
+function getFilename(importMetaUrl) {
+  if (isBrowser) return "";
+  return getNodeUrl().fileURLToPath(importMetaUrl);
+}
+function resolveFromRoot(...segments) {
+  if (isBrowser) return segments.join("/");
+  const nodePath = getNodePath();
+  const nodeFs = getNodeFs();
+  let dir = getDirname(import.meta.url);
+  for (let i = 0; i < 10; i++) {
+    const pkgPath = nodePath.join(dir, "package.json");
+    try {
+      const pkg = JSON.parse(nodeFs.readFileSync(pkgPath, "utf-8"));
+      if (pkg.workspaces) {
+        return nodePath.resolve(dir, ...segments);
+      }
+    } catch {
+    }
+    dir = nodePath.dirname(dir);
+  }
+  return nodePath.resolve(process.cwd(), ...segments);
+}
+function tryRequire(moduleName, importMetaUrl) {
+  if (isBrowser) return null;
+  try {
+    return createEsmRequire(importMetaUrl)(moduleName);
+  } catch {
+  }
+  return null;
+}
+function resolveNativeNodePath(importMetaUrl, ...relativeSegments) {
+  if (isBrowser) return relativeSegments.join("/");
+  return getNodePath().resolve(getDirname(importMetaUrl), ...relativeSegments);
+}
+var isBrowser, nodeModuleRef, _nodePath, _nodeUrl, _nodeFs;
 var init_esmHelpers = __esm({
   "packages/domain/shared/src/esmHelpers.ts"() {
     isBrowser = typeof window !== "undefined" || typeof document !== "undefined";
     nodeModuleRef = null;
     _nodePath = null;
     _nodeUrl = null;
+    _nodeFs = null;
   }
 });
 
-// packages/domain/shared/src/native-resolution.ts
-function getNodeModuleRef2() {
-  if (isBrowser2) return null;
-  if (nodeModuleRef2 !== null) return nodeModuleRef2;
+// packages/domain/shared/src/telemetry.ts
+function getGlobalTelemetry() {
+  if (!_globalCollector) {
+    _globalCollector = new TelemetryCollector();
+  }
+  return _globalCollector;
+}
+function resetGlobalTelemetry() {
+  _globalCollector = null;
+}
+function createBuildTimer() {
+  const start = Date.now();
+  const phases = {};
+  let phaseStart = start;
+  return {
+    phase(name) {
+      const now = Date.now();
+      phases[name] = now - phaseStart;
+      phaseStart = now;
+    },
+    finish(opts) {
+      const now = Date.now();
+      const record = {
+        timestamp: start,
+        durationMs: now - start,
+        phases: {
+          scan: phases.scan ?? 0,
+          compile: phases.compile ?? 0,
+          engine: phases.engine ?? 0,
+          output: phases.output ?? now - start
+        },
+        cacheHitRate: opts.cacheHitRate ?? 0,
+        ...opts
+      };
+      getGlobalTelemetry().record(record);
+      return record;
+    }
+  };
+}
+var RING_BUFFER_SIZE, TelemetryCollector, _globalCollector;
+var init_telemetry = __esm({
+  "packages/domain/shared/src/telemetry.ts"() {
+    RING_BUFFER_SIZE = 100;
+    TelemetryCollector = class {
+      data = [];
+      enabled;
+      constructor(enabled) {
+        this.enabled = enabled ?? (process.env.TWS_TELEMETRY === "1" || process.env.TWS_TELEMETRY === "true");
+      }
+      record(build) {
+        if (!this.enabled) return;
+        if (this.data.length >= RING_BUFFER_SIZE) {
+          this.data.shift();
+        }
+        this.data.push(build);
+      }
+      snapshot() {
+        return [...this.data];
+      }
+      summary() {
+        if (this.data.length === 0) return null;
+        const durations = this.data.map((d) => d.durationMs).sort((a, b) => a - b);
+        const p95Idx = Math.floor(durations.length * 0.95);
+        const avg = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
+        return {
+          totalBuilds: this.data.length,
+          avgDurationMs: avg(durations),
+          p95DurationMs: durations[p95Idx] ?? durations[durations.length - 1] ?? 0,
+          avgCacheHitRate: avg(this.data.map((d) => d.cacheHitRate)),
+          avgFilesScanned: avg(this.data.map((d) => d.filesScanned)),
+          avgClassesExtracted: avg(this.data.map((d) => d.classesExtracted)),
+          phaseAvgs: {
+            scan: avg(this.data.map((d) => d.phases.scan)),
+            compile: avg(this.data.map((d) => d.phases.compile)),
+            engine: avg(this.data.map((d) => d.phases.engine)),
+            output: avg(this.data.map((d) => d.phases.output))
+          },
+          slowestBuildMs: durations[durations.length - 1] ?? 0,
+          fastestBuildMs: durations[0] ?? 0
+        };
+      }
+      reset() {
+        this.data = [];
+      }
+      /** Format ringkas untuk CLI output */
+      formatCli() {
+        const s = this.summary();
+        if (!s) return "[telemetry] no data";
+        return [
+          `[telemetry] ${s.totalBuilds} builds`,
+          `avg ${s.avgDurationMs.toFixed(0)}ms`,
+          `p95 ${s.p95DurationMs.toFixed(0)}ms`,
+          `cache hit ${(s.avgCacheHitRate * 100).toFixed(0)}%`,
+          `${s.avgFilesScanned.toFixed(0)} files`
+        ].join(" \xB7 ");
+      }
+      /** Export sebagai JSON untuk dashboard/prometheus */
+      toJSON() {
+        return {
+          summary: this.summary(),
+          history: this.data.slice(-20)
+          // last 20 builds
+        };
+      }
+    };
+    _globalCollector = null;
+  }
+});
+function parseJsonWithSchema(jsonString, schema, sourceName) {
+  let parsed;
   try {
-    const test = typeof __require === "function" ? __require("module") : null;
-    nodeModuleRef2 = test;
-    return test;
+    parsed = JSON.parse(jsonString);
+  } catch (err) {
+    throw new Error(
+      `[${sourceName}] Invalid JSON: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const result = schema.safeParse(parsed);
+  if (!result.success) {
+    const issues = result.error.issues.map((e) => `  ${e.path.join(".")}: ${e.message}`).join("\n");
+    throw new Error(`[${sourceName}] Schema validation failed:
+${issues}`);
+  }
+  return result.data;
+}
+function parseJsonFileWithSchema(filePath, schema) {
+  const { readFileSync } = __require("fs");
+  const { basename } = __require("path");
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    throw new Error(
+      `[${basename(filePath)}] Could not read file: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return parseJsonWithSchema(content, schema, basename(filePath));
+}
+var ScanCacheClassEntrySchema, ScanCacheSchema, TailwindContentItemSchema, TailwindConfigSchema, RegistryPluginEntrySchema, RegistryFileSchema, PackageJsonSchema;
+var init_configSchemas = __esm({
+  "packages/domain/shared/src/configSchemas.ts"() {
+    ScanCacheClassEntrySchema = z.object({
+      name: z.string().min(1),
+      usedIn: z.array(z.string()),
+      risk: z.enum(["low", "medium", "high"]).default("low"),
+      bundleContribution: z.number().nonnegative().default(0),
+      variants: z.array(z.string()).default([])
+    });
+    ScanCacheSchema = z.object({
+      version: z.string().default("1"),
+      generatedAt: z.string(),
+      root: z.string(),
+      classNames: z.array(ScanCacheClassEntrySchema),
+      totalFiles: z.number().int().nonnegative(),
+      uniqueCount: z.number().int().nonnegative()
+    });
+    TailwindContentItemSchema = z.union([
+      z.string(),
+      z.object({
+        raw: z.string(),
+        extension: z.string().optional()
+      }),
+      z.object({
+        files: z.array(z.string()),
+        transform: z.record(z.string(), z.unknown()).optional()
+      })
+    ]);
+    TailwindConfigSchema = z.object({
+      content: z.array(TailwindContentItemSchema).optional(),
+      theme: z.record(z.string(), z.unknown()).optional(),
+      plugins: z.array(z.unknown()).optional(),
+      darkMode: z.union([z.literal("class"), z.literal("media"), z.literal(false)]).optional(),
+      prefix: z.string().optional(),
+      safelist: z.array(z.union([z.string(), z.object({ pattern: z.instanceof(RegExp) })])).optional(),
+      blocklist: z.array(z.string()).optional()
+    }).passthrough();
+    RegistryPluginEntrySchema = z.object({
+      name: z.string().min(1),
+      description: z.string(),
+      version: z.string(),
+      tags: z.array(z.string()).default([]),
+      official: z.boolean().default(false),
+      docs: z.string().url().optional(),
+      install: z.string().optional(),
+      integrity: z.string().optional()
+    });
+    RegistryFileSchema = z.object({
+      version: z.string(),
+      official: z.array(RegistryPluginEntrySchema).default([]),
+      community: z.array(RegistryPluginEntrySchema).default([])
+    });
+    PackageJsonSchema = z.object({
+      name: z.string(),
+      version: z.string(),
+      scripts: z.record(z.string(), z.string()).optional(),
+      dependencies: z.record(z.string(), z.string()).optional(),
+      devDependencies: z.record(z.string(), z.string()).optional(),
+      peerDependencies: z.record(z.string(), z.string()).optional(),
+      main: z.string().optional(),
+      module: z.string().optional(),
+      exports: z.unknown().optional(),
+      type: z.enum(["module", "commonjs"]).optional()
+    }).passthrough();
+  }
+});
+
+// packages/domain/shared/src/workerResolver.ts
+function getDirnameFromUrl(importMetaUrl) {
+  if (!importMetaUrl) return "";
+  if (isBrowser2) return "";
+  try {
+    const nodeUrl = __require(NODE_URL);
+    const nodePath = __require(NODE_PATH);
+    return nodePath.dirname(nodeUrl.fileURLToPath(importMetaUrl));
   } catch {
-    nodeModuleRef2 = null;
-    return null;
+    if (importMetaUrl.startsWith("file://")) {
+      const filePath = importMetaUrl.slice(7);
+      const lastSlash = filePath.lastIndexOf("/");
+      return lastSlash >= 0 ? filePath.slice(0, lastSlash) : filePath;
+    }
+    return "";
   }
 }
-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 resolvePath(...segments) {
+  if (isBrowser2) return segments.join("/").replace(/\/+/g, "/");
+  try {
+    const nodePath = __require(NODE_PATH);
+    return nodePath.resolve(...segments);
+  } catch {
+    return segments.join("/").replace(/\/+/g, "/");
+  }
 }
-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 existsSync(path13) {
+  if (isBrowser2) return false;
+  try {
+    const nodeFs = __require(NODE_FS);
+    return nodeFs.existsSync(path13);
+  } catch {
+    return false;
+  }
 }
-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 resolveWorkerPath(opts) {
+  if (isBrowser2) {
+    throw new Error("Worker resolution not available in browser");
+  }
+  const {
+    basename,
+    importMetaUrl,
+    extensions = [".cjs", ".js", ".mjs"],
+    subdirs = [".", "workers", "lib"],
+    required = true
+  } = opts;
+  const runtimeDir = getDirnameFromUrl(importMetaUrl);
+  for (const subdir of subdirs) {
+    for (const ext of extensions) {
+      const candidate = resolvePath(runtimeDir, subdir, `${basename}${ext}`);
+      if (existsSync(candidate)) {
+        return {
+          path: candidate,
+          extension: ext,
+          format: ext === ".cjs" ? "cjs" : "esm"
+        };
+      }
+    }
+  }
+  if (required) {
+    const tried = subdirs.flatMap(
+      (d) => extensions.map((e) => resolvePath(runtimeDir, d, `${basename}${e}`))
+    );
+    throw new Error(
+      `[worker-resolver] Could not find worker script "${basename}".
+Tried:
+${tried.map((p) => `  - ${p}`).join("\n")}
+Ensure the package is built: npm run build`
+    );
+  }
+  return { path: "", extension: "", format: "cjs" };
+}
+function resolveLoaderPath(loaderBasename, importMetaUrl) {
+  return resolveWorkerPath({
+    basename: loaderBasename,
+    importMetaUrl,
+    extensions: [".cjs", ".js", ".mjs"],
+    subdirs: [".", "loaders", "lib"]
+  }).path;
+}
+var isBrowser2, NODE_URL, NODE_FS, NODE_PATH;
+var init_workerResolver = __esm({
+  "packages/domain/shared/src/workerResolver.ts"() {
+    isBrowser2 = typeof window !== "undefined" || typeof document !== "undefined";
+    NODE_URL = typeof window === "undefined" || typeof document === "undefined" ? "node:url" : null;
+    NODE_FS = typeof window === "undefined" || typeof document === "undefined" ? "node:fs" : null;
+    NODE_PATH = typeof window === "undefined" || typeof document === "undefined" ? "node:path" : null;
+  }
+});
+
+// packages/domain/shared/src/codegen.ts
+function generateComponentCode(opts) {
+  const {
+    name,
+    tag = "div",
+    base = "",
+    variants = {},
+    defaultVariants = {},
+    compoundVariants = [],
+    framework = "react",
+    withTypes = true
+  } = opts;
+  const variantKeys = Object.keys(variants);
+  const lines = [];
+  if (framework === "react") {
+    lines.push(`import { tw } from "tailwind-styled-v4"`);
+    if (withTypes && variantKeys.length > 0) {
+      lines.push(`import type { InferVariantProps } from "tailwind-styled-v4"`);
+    }
+  } else if (framework === "vue") {
+    lines.push(`import { tw } from "@tailwind-styled/vue"`);
+  } else if (framework === "svelte") {
+    lines.push(`import { tw } from "@tailwind-styled/svelte"`);
+  }
+  lines.push("");
+  const configLines = [`export const ${name} = tw.${tag}({`];
+  if (base) configLines.push(`  base: "${base}",`);
+  if (variantKeys.length > 0) {
+    configLines.push(`  variants: {`);
+    for (const [key, values] of Object.entries(variants)) {
+      configLines.push(`    ${key}: {`);
+      for (const [val, cls] of Object.entries(values)) {
+        configLines.push(`      ${val}: "${cls}",`);
+      }
+      configLines.push(`    },`);
+    }
+    configLines.push(`  },`);
+  }
+  if (compoundVariants.length > 0) {
+    configLines.push(`  compoundVariants: [`);
+    for (const cv of compoundVariants) {
+      const { class: cls, ...conditions } = cv;
+      const condStr = Object.entries(conditions).map(([k, v]) => `${k}: "${v}"`).join(", ");
+      configLines.push(`    { ${condStr}, class: "${cls}" },`);
+    }
+    configLines.push(`  ],`);
+  }
+  if (Object.keys(defaultVariants).length > 0) {
+    configLines.push(`  defaultVariants: {`);
+    for (const [k, v] of Object.entries(defaultVariants)) {
+      configLines.push(`    ${k}: "${v}",`);
+    }
+    configLines.push(`  },`);
+  }
+  configLines.push(`})`);
+  lines.push(...configLines);
+  if (withTypes && variantKeys.length > 0 && framework === "react") {
+    lines.push("");
+    lines.push(`export type ${name}Props = InferVariantProps<typeof ${name}> & {`);
+    lines.push(`  children?: React.ReactNode`);
+    lines.push(`  className?: string`);
+    lines.push(`}`);
+  }
+  return lines.join("\n");
+}
+function generateStorybookStory(opts) {
+  const { name, variants = {}, defaultVariants = {} } = opts;
+  const lines = [];
+  lines.push(`import type { Meta, StoryObj } from "@storybook/react"`);
+  lines.push(`import { ${name} } from "./${name}"`);
+  lines.push(`import { generateArgTypes, generateDefaultArgs } from "tailwind-styled-v4"`);
+  lines.push(``);
+  lines.push(`const config = {`);
+  if (Object.keys(variants).length > 0) {
+    lines.push(`  variants: ${JSON.stringify(variants, null, 2).replace(/^/gm, "  ")},`);
+  }
+  if (Object.keys(defaultVariants).length > 0) {
+    lines.push(`  defaultVariants: ${JSON.stringify(defaultVariants)},`);
+  }
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`const meta: Meta<typeof ${name}> = {`);
+  lines.push(`  title: "Components/${name}",`);
+  lines.push(`  component: ${name},`);
+  lines.push(`  argTypes: generateArgTypes(config),`);
+  lines.push(`  args: generateDefaultArgs(config),`);
+  lines.push(`}`);
+  lines.push(``);
+  lines.push(`export default meta`);
+  lines.push(`type Story = StoryObj<typeof ${name}>`);
+  lines.push(``);
+  lines.push(`export const Default: Story = {}`);
+  const variantEntries = Object.entries(variants);
+  if (variantEntries.length > 0) {
+    const [firstKey, firstValues] = variantEntries[0];
+    const valueKeys = Object.keys(firstValues).slice(0, 4);
+    for (const val of valueKeys) {
+      const storyName = `${firstKey.charAt(0).toUpperCase()}${firstKey.slice(1)}${val.charAt(0).toUpperCase()}${val.slice(1)}`;
+      lines.push(``);
+      lines.push(`export const ${storyName}: Story = {`);
+      lines.push(`  args: { ${firstKey}: "${val}" },`);
+      lines.push(`}`);
+    }
+  }
+  return lines.join("\n");
+}
+function generateClassRenameCodemod(renames, opts = {}) {
+  const { format = "regex", filename = "rename-classes.mjs" } = opts;
+  const lines = [];
+  if (format === "regex") {
+    lines.push(`#!/usr/bin/env node`);
+    lines.push(`/**`);
+    lines.push(` * Auto-generated class rename codemod`);
+    lines.push(` * Usage: node ${filename} ./src`);
+    lines.push(` */`);
+    lines.push(`import fs from "node:fs"`);
+    lines.push(`import path from "node:path"`);
+    lines.push(`import { execSync } from "node:child_process"`);
+    lines.push(``);
+    lines.push(`const RENAMES = {`);
+    for (const [from, to] of Object.entries(renames)) {
+      lines.push(`  "${from}": "${to}",`);
+    }
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(`const dir = process.argv[2] ?? "."`);
+    lines.push(`const files = execSync(\`find \${dir} -name "*.tsx" -o -name "*.ts" -o -name "*.jsx"\`, { encoding: "utf-8" }).split("\\n").filter(Boolean)`);
+    lines.push(``);
+    lines.push(`let total = 0`);
+    lines.push(`for (const file of files) {`);
+    lines.push(`  let content = fs.readFileSync(file, "utf-8")`);
+    lines.push(`  let changed = false`);
+    lines.push(`  for (const [from, to] of Object.entries(RENAMES)) {`);
+    lines.push('    const re = new RegExp(`\\\\b${from.replace(/[.*+?^${}()|[\\\\]\\\\]/g, "\\\\$&")}\\\\b`, "g")');
+    lines.push(`    if (re.test(content)) { content = content.replace(re, to); changed = true; total++ }`);
+    lines.push(`  }`);
+    lines.push(`  if (changed) fs.writeFileSync(file, content)`);
+    lines.push(`}`);
+    lines.push(`console.log(\`Renamed \${total} occurrences in \${files.length} files\`)`);
+  }
+  return lines.join("\n");
+}
+function generateBarrelFile(exports$1, dir, opts = {}) {
+  const { includeTypes = true } = opts;
+  const lines = [];
+  lines.push(`// Auto-generated barrel file for ${dir}`);
+  lines.push(`// Run: npx tsx scripts/generate-barrel.ts to regenerate`);
+  lines.push(``);
+  for (const name of exports$1) {
+    lines.push(`export { default as ${name}, type ${name}Props } from "./${name}"`);
+    if (includeTypes) {
+      lines.push(`export type * from "./${name}"`);
+    }
+  }
+  return lines.join("\n");
 }
+var init_codegen = __esm({
+  "packages/domain/shared/src/codegen.ts"() {
+  }
+});
 function platformKey() {
-  if (isBrowser2) return "browser";
+  if (isBrowser3) return "browser";
   return `${process.platform}-${process.arch}`;
 }
 function resolveNativeBinary(runtimeDir) {
   const platform = platformKey();
   const tried = [];
-  if (isBrowser2) {
+  if (isBrowser3) {
     return { path: null, source: "not-found", platform, tried: ["not available in browser"] };
   }
-  const fs9 = getNodeFs();
-  const path11 = 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 (fs9.existsSync(envPath)) {
+    if (fs4.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 (fs9.existsSync(candidate)) {
+      const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
+      if (fs4.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -152,30 +873,57 @@ function resolveNativeBinary(runtimeDir) {
   }
   const cwd = process.cwd();
   const base = runtimeDir ?? cwd;
-  const localCandidates = [
-    path11.resolve(base, "tailwind_styled_parser.node"),
-    path11.resolve(base, "..", "tailwind_styled_parser.node"),
-    path11.resolve(cwd, "native", "tailwind_styled_parser.node"),
-    path11.resolve(cwd, "native", "target", "release", "tailwind_styled_parser.node"),
-    // napi-rs conventional output
-    path11.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 [cwd, 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 (fs9.existsSync(candidate)) {
+    if (fs4.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;
+function formatNativeNotFoundError(result) {
+  const lines = [
+    `[tailwind-styled] Native binding not found for ${result.platform}`,
+    ``,
+    `Tried:`,
+    ...result.tried.map((t) => `  - ${t}`),
+    ``,
+    `Solutions:`,
+    `  1. Build locally:     npm run build:rust`,
+    `  2. Install prebuilt:  npm install @tailwind-styled/native-${result.platform}`,
+    `  3. Override path:     TW_NATIVE_PATH=/path/to/parser.node`
+  ];
+  return lines.join("\n");
+}
+var isBrowser3, _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;
+    isBrowser3 = typeof window !== "undefined" || typeof document !== "undefined";
+    _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"],
@@ -187,40 +935,111 @@ 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;
+// packages/domain/shared/src/observability.ts
+function createObservabilityClient(opts = {}) {
+  const { baseUrl = "http://localhost:7421", timeoutMs = 3e3 } = opts;
+  async function fetchJson(path13) {
+    try {
+      const res = await fetch(`${baseUrl}${path13}`, {
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!res.ok) return null;
+      return await res.json();
+    } catch {
+      return null;
+    }
   }
+  return {
+    async inspectClass(className) {
+      const data = await fetchJson(`/inspect?class=${encodeURIComponent(className)}`);
+      if (!data) return null;
+      return { ...data, inspectedAt: Date.now() };
+    },
+    async getMetrics() {
+      return fetchJson("/metrics");
+    },
+    async getSummary() {
+      return fetchJson("/summary");
+    },
+    async getHistory() {
+      const data = await fetchJson("/history");
+      return Array.isArray(data) ? data : [];
+    }
+  };
 }
-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;
-}
+var init_observability = __esm({
+  "packages/domain/shared/src/observability.ts"() {
+  }
+});
+
+// packages/domain/shared/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ERROR_CODES: () => ERROR_CODES,
+  LRUCache: () => LRUCache,
+  NativeAnalyzerReportSchema: () => NativeAnalyzerReportSchema,
+  NativeCacheEntrySchema: () => NativeCacheEntrySchema,
+  NativeCacheReadResultSchema: () => NativeCacheReadResultSchema,
+  NativeCssCompileResultSchema: () => NativeCssCompileResultSchema,
+  NativeScanFileSchema: () => NativeScanFileSchema,
+  NativeScanResultSchema: () => NativeScanResultSchema,
+  NativeTransformResultSchema: () => NativeTransformResultSchema,
+  NativeWatchResultSchema: () => NativeWatchResultSchema,
+  PackageJsonSchema: () => PackageJsonSchema,
+  RegistryFileSchema: () => RegistryFileSchema,
+  RegistryPluginEntrySchema: () => RegistryPluginEntrySchema,
+  ScanCacheClassEntrySchema: () => ScanCacheClassEntrySchema,
+  ScanCacheSchema: () => ScanCacheSchema,
+  TailwindConfigSchema: () => TailwindConfigSchema,
+  TelemetryCollector: () => TelemetryCollector,
+  TwError: () => TwError,
+  assertTailwindV4: () => assertTailwindV4,
+  calculateHealth: () => calculateHealth,
+  createBuildTimer: () => createBuildTimer,
+  createDebugLogger: () => createDebugLogger,
+  createEsmRequire: () => createEsmRequire,
+  createLogger: () => createLogger,
+  createObservabilityClient: () => createObservabilityClient,
+  createTraceSnapshot: () => createTraceSnapshot,
+  detectTailwind: () => detectTailwind,
+  formatDuration: () => formatDuration,
+  formatErrorCode: () => formatErrorCode,
+  formatErrorMessage: () => formatErrorMessage,
+  formatMemory: () => formatMemory,
+  formatNativeNotFoundError: () => formatNativeNotFoundError,
+  generateBarrelFile: () => generateBarrelFile,
+  generateClassRenameCodemod: () => generateClassRenameCodemod,
+  generateComponentCode: () => generateComponentCode,
+  generateStorybookStory: () => generateStorybookStory,
+  getBuildTimeColor: () => getBuildTimeColor,
+  getDirname: () => getDirname,
+  getFilename: () => getFilename,
+  getGlobalTelemetry: () => getGlobalTelemetry,
+  getHealthColor: () => getHealthColor,
+  getMemoryColor: () => getMemoryColor,
+  getModeColor: () => getModeColor,
+  getPipelinePercentages: () => getPipelinePercentages,
+  getSuggestion: () => getSuggestion,
+  getTailwindVersion: () => getTailwindVersion,
+  hashContent: () => hashContent,
+  isTailwindV4: () => isTailwindV4,
+  isTwError: () => isTwError,
+  loadNativeBinding: () => loadNativeBinding,
+  parseJsonFileWithSchema: () => parseJsonFileWithSchema,
+  parseJsonWithSchema: () => parseJsonWithSchema,
+  parseNative: () => parseNative,
+  resetGlobalTelemetry: () => resetGlobalTelemetry,
+  resolveFromRoot: () => resolveFromRoot,
+  resolveLoaderPath: () => resolveLoaderPath,
+  resolveNativeBinary: () => resolveNativeBinary,
+  resolveNativeBindingCandidates: () => resolveNativeBindingCandidates,
+  resolveNativeNodePath: () => resolveNativeNodePath,
+  resolveRuntimeDir: () => resolveRuntimeDir,
+  resolveWorkerPath: () => resolveWorkerPath,
+  safeParseNative: () => safeParseNative,
+  tryRequire: () => tryRequire,
+  wrapUnknownError: () => wrapUnknownError
+});
 function createLogger(namespace) {
   const prefix = `[${namespace}]`;
   return {
@@ -250,27 +1069,25 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path11) {
-  if (!path11 || path11.length === 0) return "(root)";
-  return path11.map(
+function formatIssuePath(path13) {
+  if (!path13 || path13.length === 0) return "(root)";
+  return path13.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
 function wrapUnknownError(domain, code, error) {
   return TwError.wrap(domain, code, error);
 }
+function isTwError(err) {
+  return err instanceof TwError;
+}
 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 path11 = getNodePath3();
-  const fs9 = getNodeFs2();
   for (const candidate of candidates) {
-    const candidatePath = path11.resolve(runtimeDir, candidate);
+    const candidatePath = path6__default.resolve(runtimeDir, candidate);
     try {
-      if (!fs9.existsSync(candidatePath) && !fs9.existsSync(candidatePath + ".node")) {
+      if (!fs4__default.existsSync(candidatePath) && !fs4__default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -284,74 +1101,76 @@ 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(path11) {
-  return _require2(path11);
+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 path11 = getNodePath3();
-  const fs9 = 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 (fs9.existsSync(runtimeDir)) {
+  if (fs4__default.existsSync(runtimeDir)) {
     try {
-      const entries = fs9.readdirSync(runtimeDir);
-      for (const entry of entries) {
-        if (entry.endsWith(".node")) {
-          candidates.push(entry);
-        }
+      for (const entry of fs4__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(path11.resolve(runtimeDir, "..", "..", "..", "native", defaultBindingName));
-  candidates.push(path11.resolve(runtimeDir, "..", "..", "..", "..", "native", defaultBindingName));
-  candidates.push(path11.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;
+function hashContent(content, algorithm = "md5", length) {
+  const hash = createHash(algorithm).update(content).digest("hex");
+  return length ? hash.slice(0, length) : hash;
+}
+function formatErrorMessage(error) {
+  if (error instanceof TwError) return error.toString();
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+var TwError, _require2, LRUCache;
 var init_src = __esm({
   "packages/domain/shared/src/index.ts"() {
+    init_trace();
+    init_error_codes();
+    init_compatibility();
+    init_native_schemas();
     init_esmHelpers();
+    init_telemetry();
+    init_configSchemas();
+    init_workerResolver();
+    init_codegen();
     init_native_resolution();
-    isBrowser3 = typeof window !== "undefined" || typeof document !== "undefined";
-    nodeModuleRef3 = null;
-    _nodeFs2 = null;
-    _nodePath3 = null;
-    _nodeUrl2 = null;
+    init_observability();
     TwError = class _TwError extends Error {
       /** @deprecated Gunakan source */
       domain;
@@ -385,8 +1204,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 path11 = formatIssuePath(first?.path);
-        const message = first ? `${path11}: ${first.message}` : "Schema validation failed";
+        const path13 = formatIssuePath(first?.path);
+        const message = first ? `${path13}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -404,13 +1223,57 @@ var init_src = __esm({
         return `[${this.source.toUpperCase()}:${this.code}] ${this.message}`;
       }
     };
-    _require2 = getRequire2();
+    _require2 = createRequire(import.meta.url);
+    LRUCache = class {
+      capacity;
+      cache;
+      constructor(capacity) {
+        this.capacity = capacity;
+        this.cache = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        if (!this.cache.has(key)) return void 0;
+        const value = this.cache.get(key);
+        this.cache.delete(key);
+        this.cache.set(key, value);
+        return value;
+      }
+      set(key, value) {
+        if (this.cache.has(key)) {
+          this.cache.delete(key);
+        } else if (this.cache.size >= this.capacity) {
+          const firstKey = this.cache.keys().next().value;
+          if (firstKey !== void 0) {
+            this.cache.delete(firstKey);
+          }
+        }
+        this.cache.set(key, value);
+      }
+      delete(key) {
+        return this.cache.delete(key);
+      }
+      has(key) {
+        return this.cache.has(key);
+      }
+      clear() {
+        this.cache.clear();
+      }
+      entries() {
+        return this.cache.entries();
+      }
+      get size() {
+        return this.cache.size;
+      }
+    };
   }
 });
-var log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge;
+
+// packages/domain/compiler/src/nativeBridge.ts
+var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge;
 var init_nativeBridge = __esm({
   "packages/domain/compiler/src/nativeBridge.ts"() {
     init_src();
+    _loadNative = (path13) => __require(path13);
     log = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -437,11 +1300,10 @@ var init_nativeBridge = __esm({
       bridgeLoadAttempted = true;
       try {
         const runtimeDir = resolveRuntimeDir(void 0, import.meta.url);
-        const require3 = createRequire(import.meta.url);
         const result = resolveNativeBinary(runtimeDir);
         if (result.path && result.path.endsWith(".node")) {
           try {
-            const binding = require3(result.path);
+            const binding = _loadNative(result.path);
             if (isValidNativeBridge(binding)) {
               nativeBridge = binding;
               log("Native bridge loaded successfully from:", result.path);
@@ -473,6 +1335,7 @@ Tried paths: ${result.tried.join("\n")}`);
 var tailwindEngine_exports = {};
 __export(tailwindEngine_exports, {
   generateRawCss: () => generateRawCss,
+  processTailwindCssWithTargets: () => processTailwindCssWithTargets,
   runCssPipeline: () => runCssPipeline,
   runCssPipelineSync: () => runCssPipelineSync
 });
@@ -500,12 +1363,11 @@ function generateRawCss(classes) {
 function postProcessWithLightning(rawCss) {
   if (!rawCss) return "";
   const native = getNativeBridge();
-  if (typeof native.processTailwindCssLightning === "function") {
-    const result = native.processTailwindCssLightning(rawCss);
-    return result?.css ?? rawCss;
+  if (typeof native.processTailwindCssLightning !== "function") {
+    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
   }
-  console.warn("[tailwind-styled] processTailwindCssLightning tidak tersedia \u2014 gunakan raw CSS");
-  return rawCss;
+  const result = native.processTailwindCssLightning(rawCss);
+  return result?.css ?? rawCss;
 }
 async function runCssPipeline(classes) {
   const unique = [...new Set(classes.filter(Boolean))];
@@ -539,6 +1401,14 @@ function runCssPipelineSync(classes) {
     optimized: hasLightning
   };
 }
+function processTailwindCssWithTargets(css, targets) {
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssWithTargets) {
+    throw new Error("FATAL: Native binding 'processTailwindCssWithTargets' is required but not available.");
+  }
+  const result = native.processTailwindCssWithTargets(css, targets ?? null);
+  return (result?.css ?? css).trim();
+}
 var require2, _twEngine, _twEngineError;
 var init_tailwindEngine = __esm({
   "packages/domain/compiler/src/tailwindEngine.ts"() {
@@ -552,14 +1422,26 @@ var init_tailwindEngine = __esm({
 // 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() {
@@ -567,7 +1449,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();
 }
@@ -648,6 +1530,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 log2, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
 var init_native_bridge = __esm({
   "packages/domain/scanner/src/native-bridge.ts"() {
@@ -731,74 +1702,9 @@ var init_native_bridge = __esm({
     resetScannerBridgeCache = scannerBridgeLoader.reset;
   }
 });
-
-// packages/domain/compiler/src/index.ts
-init_nativeBridge();
-var transformSource = (source, opts) => {
-  const native = getNativeBridge();
-  if (!native?.transformSource) {
-    throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
-  }
-  const result = native.transformSource(source, opts);
-  if (!result) {
-    throw new Error("FATAL: transformSource returned null");
-  }
-  return result;
-};
-var generateCssForClasses = async (classes, _tailwindConfig, _root) => {
-  const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
-  const result = await runCssPipeline2(classes);
-  return result.css;
-};
-var mergeClassesStatic = (classes) => {
-  const result = normalizeAndDedupClasses(classes);
-  return result?.normalized || "";
-};
-function normalizeAndDedupClassesJs(raw) {
-  const seen = /* @__PURE__ */ new Set();
-  const result = [];
-  let duplicatesRemoved = 0;
-  for (const token of raw.split(/\s+/)) {
-    if (token.length === 0) continue;
-    if (seen.has(token)) {
-      duplicatesRemoved++;
-    } else {
-      seen.add(token);
-      result.push(token);
-    }
-  }
-  return {
-    normalized: result.join(" "),
-    duplicatesRemoved,
-    uniqueCount: result.length
-  };
-}
-var normalizeAndDedupClasses = (raw) => {
-  const native = getNativeBridge();
-  if (!native?.normalizeAndDedupClasses) {
-    return normalizeAndDedupClassesJs(raw);
-  }
-  const result = native.normalizeAndDedupClasses(raw);
-  return result || { normalized: "", duplicatesRemoved: 0, uniqueCount: 0 };
-};
-var runLoaderTransform = (ctx) => {
-  const { filepath, source, options } = ctx;
-  const result = transformSource(source, { filename: filepath, ...options });
-  return {
-    code: result?.code || "",
-    changed: result?.changed || false,
-    classes: result?.classes || []
-  };
-};
-
-// packages/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 ? 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);
@@ -834,158 +1740,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 = (path11) => path11.length > 0 ? path11.map(
-  (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
-).join(".") : "<root>";
-var formatIssues = (error) => error.issues.map((issue) => {
-  const path11 = formatIssuePath2(issue.path);
-  return `${path11}: ${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 = fs4__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 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 = (path13) => path13.length > 0 ? path13.map(
+      (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
+    ).join(".") : "<root>";
+    formatIssues = (error) => error.issues.map((issue) => {
+      const path13 = formatIssuePath2(issue.path);
+      return `${path13}: ${issue.message}`;
+    }).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 log3 = createLogger("scanner");
-var SCAN_WORKER_TIMEOUT_MS = 12e4;
+var src_exports2 = {};
+__export(src_exports2, {
+  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();
-}
-var createNativeParserLoader = () => {
-  const _state = {
-    binding: void 0,
-    initError: null
-  };
-  const debugNative = (message) => {
-    log3.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 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 (fs.existsSync(candidate)) return candidate;
+    if (fs4__default.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -995,7 +1962,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(() => {
@@ -1015,7 +1982,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"));
@@ -1042,19 +2009,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs.readdirSync(currentDir, { withFileTypes: true });
+        return fs4__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);
     }
   }
@@ -1068,9 +2035,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(
@@ -1078,15 +2048,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 = 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 = {}) {
@@ -1135,7 +2108,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs.statSync(filePath);
+          return fs4__default.statSync(filePath);
         } catch {
           return null;
         }
@@ -1161,7 +2134,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs.readFileSync(filePath, "utf8");
+          return fs4__default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -1223,18 +2196,245 @@ 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) {
+    log3.debug(
+      `parallel scan failed, retrying with single worker: ${parallelError instanceof Error ? parallelError.message : String(parallelError)}`
+    );
   }
   try {
     return await scanWorkspaceInWorker(rootDir, normalizedOptions);
   } catch (error) {
     log3.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 log3, 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();
+    log3 = createLogger("scanner");
+    SCAN_WORKER_TIMEOUT_MS = 12e4;
+    createNativeParserLoader = () => {
+      const _state = {
+        binding: void 0,
+        initError: null
+      };
+      const debugNative = (message) => {
+        log3.debug(`[native] ${message}`);
+      };
+      const loadNativeParserBinding = () => {
+        if (_state.binding !== void 0) return _state.binding;
+        const runtimeDir = getRuntimeDir();
+        const req = createRequire(path6__default.join(runtimeDir, "noop.cjs"));
+        const candidates = [
+          // ── binaryName baru: tailwind-styled-native (napi-rs naming) ──
+          // cwd = repo root saat run dari root, atau package dir saat workspaces
+          path6__default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+          path6__default.resolve(process.cwd(), "native", `tailwind-styled-native.${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,
+            "..",
+            "..",
+            "..",
+            "native",
+            "build",
+            "Release",
+            "tailwind_styled_parser.node"
+          )
+        ];
+        for (const fullPath of candidates) {
+          if (!fs4__default.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/engine/src/native-bridge.ts
+function getDirname3() {
+  if (typeof __dirname !== "undefined") return __dirname;
+  if (typeof import.meta !== "undefined" && import.meta.url) {
+    return getDirname(import.meta.url);
+  }
+  return process.cwd();
+}
+function getNativeEngineBinding() {
+  return engineBindingLoader.get();
+}
+var log4, isValidEngineBinding, createEngineBindingLoader, engineBindingLoader;
+var init_native_bridge2 = __esm({
+  "packages/domain/engine/src/native-bridge.ts"() {
+    init_src();
+    log4 = createDebugLogger("engine:native");
+    isValidEngineBinding = (module) => {
+      const candidate = module;
+      return !!(candidate && (candidate.computeIncrementalDiff || candidate.processFileChange || candidate.hashFileContent));
+    };
+    createEngineBindingLoader = () => {
+      const _state = {
+        binding: void 0,
+        loadError: null,
+        candidatePaths: []
+      };
+      const throwNativeBindingError = () => {
+        const lines = [
+          "FATAL: Native engine binding not found.",
+          "",
+          "This package requires the Rust native binding 'tailwind_styled_parser.node'.",
+          "The binding was not found in any of these paths:",
+          ..._state.candidatePaths.map((p) => `  - ${p}`),
+          ""
+        ];
+        if (_state.loadError) {
+          lines.push("Load error:", `  ${_state.loadError}`, "");
+        }
+        lines.push(
+          "To fix this, run:",
+          "  npm run build:rust",
+          "",
+          "This will build the native Rust module from the 'native/' directory.",
+          "If you're using this package in a CI/CD environment, ensure Rust toolchain is installed",
+          "and 'npm run build:rust' is executed before running tests or building."
+        );
+        throw new TwError("rust", "ENGINE_NATIVE_BINDING_NOT_FOUND", lines.join("\n"));
+      };
+      const getBinding = () => {
+        const cached = _state.binding;
+        if (cached !== void 0) {
+          if (cached === null) {
+            return throwNativeBindingError();
+          }
+          return cached;
+        }
+        const runtimeDir = getDirname3();
+        const candidates = resolveNativeBindingCandidates({
+          runtimeDir,
+          includeDefaultCandidates: true
+        });
+        _state.candidatePaths = candidates;
+        const { binding, loadErrors } = loadNativeBinding({
+          runtimeDir,
+          candidates,
+          isValid: isValidEngineBinding,
+          invalidExportMessage: "Module loaded but missing expected engine binding functions"
+        });
+        if (binding) {
+          log4(`engine native binding loaded successfully`);
+          _state.binding = binding;
+          return binding;
+        }
+        if (loadErrors.length > 0) {
+          _state.loadError = loadErrors.map((e) => `${e.path}: ${e.message}`).join("; ");
+        }
+        _state.binding = null;
+        return throwNativeBindingError();
+      };
+      return {
+        get: getBinding,
+        reset: () => {
+          _state.binding = void 0;
+          _state.loadError = null;
+          _state.candidatePaths = [];
+        }
+      };
+    };
+    engineBindingLoader = createEngineBindingLoader();
+  }
+});
+
+// packages/domain/compiler/src/index.ts
+init_nativeBridge();
+var transformSource = (source, opts) => {
+  const native = getNativeBridge();
+  if (!native?.transformSource) {
+    throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+  }
+  const result = native.transformSource(source, opts);
+  if (!result) {
+    throw new Error("FATAL: transformSource returned null");
+  }
+  return result;
+};
+var generateCssForClasses = async (classes, _tailwindConfig, _root) => {
+  const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
+  const result = await runCssPipeline2(classes);
+  return result.css;
+};
+var mergeClassesStatic = (classes) => {
+  const result = normalizeAndDedupClasses(classes);
+  return result?.normalized || "";
+};
+var normalizeAndDedupClasses = (raw) => {
+  const native = getNativeBridge();
+  if (!native?.normalizeAndDedupClasses) {
+    throw new Error("FATAL: Native binding 'normalizeAndDedupClasses' is required but not available.");
+  }
+  const result = native.normalizeAndDedupClasses(raw);
+  return result || { normalized: "", duplicatesRemoved: 0, uniqueCount: 0 };
+};
+var runLoaderTransform = (ctx) => {
+  const { filepath, source, options } = ctx;
+  const result = transformSource(source, { filename: filepath, ...options });
+  return {
+    code: result?.code || "",
+    changed: result?.changed || false,
+    classes: result?.classes || []
+  };
+};
+
+// packages/domain/analyzer/src/analyzeWorkspace.ts
+init_src2();
 
 // packages/domain/analyzer/src/binding.ts
 init_src();
@@ -1244,7 +2444,7 @@ init_src();
 var DEFAULT_TOP_LIMIT = 10;
 var DEFAULT_FREQUENT_THRESHOLD = 2;
 var DEBUG_NAMESPACE = "tailwind-styled:analyzer";
-function formatErrorMessage(error) {
+function formatErrorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function isRecord(value) {
@@ -1254,7 +2454,7 @@ function isRecord(value) {
 }
 async function pathExists(filePath) {
   try {
-    await fs.promises.access(filePath, fs.constants.F_OK);
+    await fs4__default.promises.access(filePath, fs4__default.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -1317,6 +2517,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;
@@ -1350,7 +2553,7 @@ async function requireNativeBinding() {
 
 // packages/domain/analyzer/src/schemas.ts
 init_src();
-var formatIssuePath3 = (path11) => path11.length > 0 ? path11.map(
+var formatIssuePath3 = (path13) => path13.length > 0 ? path13.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var isPlainObject = (value) => {
@@ -1359,8 +2562,8 @@ var isPlainObject = (value) => {
   return proto === Object.prototype || proto === null;
 };
 var formatIssues2 = (error) => error.issues.map((issue) => {
-  const path11 = formatIssuePath3(issue.path);
-  return `${path11}: ${issue.message}`;
+  const path13 = formatIssuePath3(issue.path);
+  return `${path13}: ${issue.message}`;
 }).join("; ");
 var parseWithSchema2 = (schema, data, label) => {
   const parsed = schema.safeParse(data);
@@ -1449,183 +2652,29 @@ z.object({
 var parseAnalyzerOptions = (options) => parseWithSchema2(AnalyzerOptionsSchema, options ?? {}, "analyzeWorkspace options are invalid");
 var parseNativeReport = (report) => parseWithSchema2(NativeReportSchema, report, "Native analyzer report is 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(":");
-  if (parts.length <= 1) return { variantKey: "", base: className };
-  const base = parts.pop() ?? className;
-  return { variantKey: parts.join(":"), base };
-};
-var isArbitraryUtility = (baseClass) => {
-  return baseClass.includes("[") && baseClass.includes("]");
-};
-var resolveConflictGroup = (base) => {
-  if (isArbitraryUtility(base)) return null;
-  if (["block", "inline", "inline-block", "inline-flex", "flex", "grid", "hidden"].includes(base))
-    return "display";
-  if (base.startsWith("bg-")) return "bg";
-  if (base.startsWith("text-")) return "text";
-  if (base.startsWith("font-")) return "font";
-  if (base.startsWith("rounded")) return "rounded";
-  if (base.startsWith("shadow")) return "shadow";
-  if (base.startsWith("border-")) return "border";
-  if (base.startsWith("opacity-")) return "opacity";
-  if (base.startsWith("w-") || base.startsWith("min-w-") || base.startsWith("max-w-"))
-    return "width";
-  if (base.startsWith("h-") || base.startsWith("min-h-") || base.startsWith("max-h-"))
-    return "height";
-  if (base.startsWith("p-") || base.startsWith("px-") || base.startsWith("py-")) return "padding";
-  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(path6__default.extname(configPath).toLowerCase());
 };
 var 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;
   }
@@ -1636,7 +2685,7 @@ var resolveTailwindConfigPath = async (root, explicitPath) => {
     "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;
@@ -1690,15 +2739,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 fs4__default.promises.readFile(configPath, "utf8");
+  const { extractClassesNative: extractClassesNative2 } = await Promise.resolve().then(() => (init_src2(), src_exports2));
+  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();
@@ -1713,7 +2766,7 @@ var loadTailwindConfig = async (root, semanticOption) => {
       customUtilities: /* @__PURE__ */ new Set()
     };
   }
-  const configStat = await fs.promises.stat(configPath).catch(() => null);
+  const configStat = await fs4__default.promises.stat(configPath).catch(() => null);
   if (configStat) {
     const cached = tailwindConfigCache.get(configPath);
     if (cached && cached.mtimeMs === configStat.mtimeMs && cached.size === configStat.size) {
@@ -1742,7 +2795,7 @@ var loadTailwindConfig = async (root, semanticOption) => {
         warning: "Tailwind config export must be an object or a function returning an object."
       };
     } catch (error) {
-      return { config: null, warning: formatErrorMessage(error) };
+      return { config: null, warning: formatErrorMessage2(error) };
     }
   })();
   const { config, warning } = result;
@@ -1757,7 +2810,7 @@ var loadTailwindConfig = async (root, semanticOption) => {
       for (const item of await collectSafelistFromSource(configPath)) safelist.add(item);
     } catch (error) {
       debugLog(
-        `failed to parse safelist from source at "${configPath}": ${formatErrorMessage(error)}`
+        `failed to parse safelist from source at "${configPath}": ${formatErrorMessage2(error)}`
       );
     }
   }
@@ -1780,40 +2833,27 @@ var loadTailwindConfig = async (root, semanticOption) => {
   );
   return loaded;
 };
-var utilityPrefix = (baseClass) => {
-  const normalized = baseClass.startsWith("-") ? baseClass.slice(1) : baseClass;
-  if (normalized.includes("[") && normalized.includes("]")) return "arbitrary";
-  if (normalized.startsWith("min-w-")) return "min-w";
-  if (normalized.startsWith("max-w-")) return "max-w";
-  if (normalized.startsWith("min-h-")) return "min-h";
-  if (normalized.startsWith("max-h-")) return "max-h";
-  if (normalized.startsWith("space-x-")) return "space-x";
-  if (normalized.startsWith("space-y-")) return "space-y";
-  if (normalized.startsWith("inline-")) return "inline";
-  if (normalized.startsWith("border-")) return "border";
-  if (normalized.startsWith("text-")) return "text";
-  if (normalized.startsWith("bg-")) return "bg";
-  if (normalized.startsWith("rounded")) return "rounded";
-  if (normalized.startsWith("shadow")) return "shadow";
-  const hyphen = normalized.indexOf("-");
-  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,
@@ -1849,13 +2889,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) {
@@ -1864,29 +2908,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();
@@ -1898,7 +2937,7 @@ async function analyzeWorkspace(root, options = {}) {
       return result;
     } catch (error) {
       throw new Error(
-        `Failed to scan workspace at "${resolvedRoot}": ${formatErrorMessage(error)}`,
+        `Failed to scan workspace at "${resolvedRoot}": ${formatErrorMessage2(error)}`,
         {
           cause: error
         }
@@ -1923,14 +2962,14 @@ async function analyzeWorkspace(root, options = {}) {
       return parseNativeReport(report);
     } catch (error) {
       throw new Error(
-        `Native analyzer failed for "${resolvedRoot}": ${formatErrorMessage(error)}`,
+        `Native analyzer failed for "${resolvedRoot}": ${formatErrorMessage2(error)}`,
         {
           cause: error
         }
       );
     }
   })();
-  const counts = collectClassCounts(normalizedScan);
+  const counts = await collectClassCounts(normalizedScan);
   const baseAll = buildClassUsage(counts);
   const { all, semanticReport } = await (async () => {
     if (!normalizedOptions.semantic) {
@@ -1951,18 +2990,24 @@ async function analyzeWorkspace(root, options = {}) {
       return { all: updatedAll, semanticReport: report };
     } catch (error) {
       throw new Error(
-        `Failed to build semantic report for "${resolvedRoot}": ${formatErrorMessage(error)}`,
+        `Failed to build semantic report for "${resolvedRoot}": ${formatErrorMessage2(error)}`,
         { cause: error }
       );
     }
   })();
-  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,
@@ -1973,138 +3018,57 @@ 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/engine/src/index.ts
+init_src2();
 init_src();
-init_src();
-
-// packages/domain/engine/src/native-bridge.ts
-init_src();
-var log4 = createDebugLogger("engine:native");
-function getDirname3() {
-  if (typeof __dirname !== "undefined") return __dirname;
-  if (typeof import.meta !== "undefined" && import.meta.url) {
-    return getDirname(import.meta.url);
-  }
-  return process.cwd();
-}
-var isValidEngineBinding = (module) => {
-  const candidate = module;
-  return !!(candidate && (candidate.computeIncrementalDiff || candidate.processFileChange || candidate.hashFileContent));
-};
-var createEngineBindingLoader = () => {
-  const _state = {
-    binding: void 0,
-    loadError: null,
-    candidatePaths: []
-  };
-  const throwNativeBindingError = () => {
-    const lines = [
-      "FATAL: Native engine binding not found.",
-      "",
-      "This package requires the Rust native binding 'tailwind_styled_parser.node'.",
-      "The binding was not found in any of these paths:",
-      ..._state.candidatePaths.map((p) => `  - ${p}`),
-      ""
-    ];
-    if (_state.loadError) {
-      lines.push("Load error:", `  ${_state.loadError}`, "");
-    }
-    lines.push(
-      "To fix this, run:",
-      "  npm run build:rust",
-      "",
-      "This will build the native Rust module from the 'native/' directory.",
-      "If you're using this package in a CI/CD environment, ensure Rust toolchain is installed",
-      "and 'npm run build:rust' is executed before running tests or building."
-    );
-    throw new TwError("rust", "ENGINE_NATIVE_BINDING_NOT_FOUND", lines.join("\n"));
-  };
-  const getBinding = () => {
-    const cached = _state.binding;
-    if (cached !== void 0) {
-      if (cached === null) {
-        return throwNativeBindingError();
-      }
-      return cached;
-    }
-    const runtimeDir = getDirname3();
-    const candidates = resolveNativeBindingCandidates({
-      runtimeDir,
-      includeDefaultCandidates: true
-    });
-    _state.candidatePaths = candidates;
-    const { binding, loadErrors } = loadNativeBinding({
-      runtimeDir,
-      candidates,
-      isValid: isValidEngineBinding,
-      invalidExportMessage: "Module loaded but missing expected engine binding functions"
-    });
-    if (binding) {
-      log4(`engine native binding loaded successfully`);
-      _state.binding = binding;
-      return binding;
-    }
-    if (loadErrors.length > 0) {
-      _state.loadError = loadErrors.map((e) => `${e.path}: ${e.message}`).join("; ");
-    }
-    _state.binding = null;
-    return throwNativeBindingError();
-  };
-  return {
-    get: getBinding,
-    reset: () => {
-      _state.binding = void 0;
-      _state.loadError = null;
-      _state.candidatePaths = [];
-    }
-  };
-};
-var engineBindingLoader = createEngineBindingLoader();
-function getNativeEngineBinding() {
-  return engineBindingLoader.get();
-}
 
 // packages/domain/engine/src/incremental.ts
+init_src2();
+init_src();
+init_native_bridge2();
 var DEFAULT_EXTENSIONS2 = [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"];
 var log5 = createLogger("engine:incremental");
 function rebuildWorkspaceResult(byFile) {
   const files = Array.from(byFile.values());
-  const unique = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    for (const cls of file.classes) unique.add(cls);
+  const native = getNativeEngineBinding();
+  if (native?.rebuildWorkspaceResult) {
+    const result = native.rebuildWorkspaceResult(files);
+    return {
+      files: result.files,
+      totalFiles: result.totalFiles,
+      uniqueClasses: result.uniqueClasses
+    };
   }
-  return {
-    files,
-    totalFiles: files.length,
-    uniqueClasses: Array.from(unique).sort()
-  };
+  throw new Error("FATAL: Native binding 'rebuildWorkspaceResult' is required but not available.");
 }
 function applyClassDiff(existing, added, removed) {
-  const next = new Set(existing);
-  for (const cls of added) next.add(cls);
-  for (const cls of removed) next.delete(cls);
-  return Array.from(next);
+  const native = getNativeEngineBinding();
+  if (native?.applyClassDiff) {
+    return native.applyClassDiff(existing, added, removed);
+  }
+  throw new Error("FATAL: Native binding 'applyClassDiff' is required but not available.");
 }
 function areClassSetsEqual(a, b) {
-  if (a.length !== b.length) return false;
-  const bSet = new Set(b);
-  for (const cls of a) {
-    if (!bSet.has(cls)) return false;
+  const native = getNativeEngineBinding();
+  if (native?.areClassSetsEqual) {
+    return native.areClassSetsEqual(a, b);
   }
-  return true;
+  throw new Error("FATAL: Native binding 'areClassSetsEqual' is required but not available.");
 }
 function applyIncrementalChange(previous, filePath, type, scanner) {
   const includeExtensions = scanner?.includeExtensions ?? DEFAULT_EXTENSIONS2;
   if (!isScannableFile(filePath, includeExtensions)) return previous;
-  const byFile = new Map(previous.files.map((f) => [path3.resolve(f.file), f]));
-  const normalizedPath = path3.resolve(filePath);
+  const byFile = new Map(previous.files.map((f) => [path6__default.resolve(f.file), f]));
+  const normalizedPath = path6__default.resolve(filePath);
   const native = getNativeEngineBinding();
   if (!native?.processFileChange) {
     throw new Error(
@@ -2120,7 +3084,7 @@ function applyIncrementalChange(previous, filePath, type, scanner) {
   }
   log5.debug(`native change ${normalizedPath}`);
   const scanned = scanFile(normalizedPath);
-  const content = fs.readFileSync(normalizedPath, "utf8");
+  const content = fs4__default.readFileSync(normalizedPath, "utf8");
   const diff = native.processFileChange(normalizedPath, scanned.classes, content);
   const existing = byFile.get(normalizedPath);
   if (diff && existing) {
@@ -2189,8 +3153,8 @@ var METRICS_FILE_NAME = "metrics.json";
 var CACHE_DIR = ".tw-cache";
 function writeMetrics(metrics, cwd = process.cwd()) {
   try {
-    const cacheDir = path3.join(cwd, CACHE_DIR);
-    fs.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = path6__default.join(cwd, CACHE_DIR);
+    fs4__default.mkdirSync(cacheDir, { recursive: true });
     const mem = process.memoryUsage();
     const data = {
       ...metrics,
@@ -2201,7 +3165,7 @@ function writeMetrics(metrics, cwd = process.cwd()) {
       },
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs.writeFileSync(path3.join(cacheDir, METRICS_FILE_NAME), JSON.stringify(data, null, 2));
+    fs4__default.writeFileSync(path6__default.join(cacheDir, METRICS_FILE_NAME), JSON.stringify(data, null, 2));
   } catch {
   }
 }
@@ -2306,96 +3270,78 @@ z.object({
 });
 var parseEngineOptions = (options) => parseWithSchema3(EngineOptionsSchema, options ?? {}, "engine options are invalid");
 var parseEngineWatchOptions = (options) => parseWithSchema3(EngineWatchOptionsSchema, options ?? {}, "engine watch options are invalid");
-var DEFAULT_IGNORES2 = ["node_modules", ".git", ".next", "dist", "out", ".turbo", ".cache"];
-function watchWorkspace(rootDir, onEvent, options = {}) {
-  const ignoreDirectories = new Set(options.ignoreDirectories ?? DEFAULT_IGNORES2);
-  const watchers = /* @__PURE__ */ new Map();
-  const restartTimers = /* @__PURE__ */ new Map();
-  const debounceMs = options.debounceMs ?? 100;
+
+// packages/domain/engine/src/watch.ts
+var _native = null;
+function getNativeWatcher() {
+  if (_native !== null) return _native;
+  try {
+    const { resolveNativeBinary: resolveNativeBinary2 } = (init_src(), __toCommonJS(src_exports));
+    const { path: binPath } = resolveNativeBinary2(__dirname);
+    if (binPath) {
+      _native = __require(binPath);
+    }
+  } catch {
+    _native = {};
+  }
+  return _native;
+}
+function watchWorkspaceNative(rootDir, onEvent, options) {
+  const native = getNativeWatcher();
+  if (!native?.startWatch || !native?.pollWatchEvents || !native?.stopWatch) {
+    return null;
+  }
+  const result = native.startWatch(rootDir);
+  if (!result || result.status !== "ok") {
+    return null;
+  }
+  const { handleId } = result;
+  const pollMs = options.pollIntervalMs ?? 200;
   const pending = /* @__PURE__ */ new Map();
-  const shouldIgnore = (targetPath) => {
-    const parts = targetPath.split(path3.sep);
-    return parts.some((part) => ignoreDirectories.has(part));
-  };
-  const enqueue = (event) => {
+  const debounceMs = options.debounceMs ?? 100;
+  function enqueue(event) {
     const key = `${event.type}:${event.filePath}`;
     const existing = pending.get(key);
-    if (existing) clearTimeout(existing);
+    if (existing) clearTimeout(existing.timer);
     const timer = setTimeout(() => {
       pending.delete(key);
       onEvent(event);
     }, debounceMs);
-    pending.set(key, timer);
-  };
-  const safeUnwatch = (dir) => {
-    const watcher = watchers.get(dir);
-    if (!watcher) return;
-    try {
-      watcher.close();
-    } catch {
-    }
-    watchers.delete(dir);
-  };
-  const scheduleRestart = (dir) => {
-    const previous = restartTimers.get(dir);
-    if (previous) clearTimeout(previous);
-    const timer = setTimeout(() => {
-      restartTimers.delete(dir);
-      watchDir(dir);
-    }, 250);
-    restartTimers.set(dir, timer);
-  };
-  const watchDir = (dir) => {
-    if (watchers.has(dir) || shouldIgnore(dir) || !fs.existsSync(dir)) return;
+    pending.set(key, { event, timer });
+  }
+  const intervalId = setInterval(() => {
     try {
-      const stat = fs.lstatSync(dir);
-      if (!stat.isDirectory() || stat.isSymbolicLink()) return;
-    } catch {
-      return;
-    }
-    const watcher = fs.watch(dir, { persistent: true }, (_eventType, fileName) => {
-      if (!fileName) return;
-      const fullPath = path3.join(dir, fileName.toString());
-      if (shouldIgnore(fullPath)) return;
-      if (fs.existsSync(fullPath)) {
-        try {
-          const stat = fs.lstatSync(fullPath);
-          if (stat.isSymbolicLink()) return;
-          if (stat.isDirectory()) {
-            watchDir(fullPath);
-            return;
-          }
-          enqueue({ type: "change", filePath: fullPath });
-          return;
-        } catch {
-        }
+      const events = native.pollWatchEvents(handleId);
+      for (const ev of events) {
+        const type = ev.kind === "unlink" ? "unlink" : "change";
+        enqueue({ type, filePath: ev.path });
       }
-      enqueue({ type: "unlink", filePath: fullPath });
-    });
-    watcher.on("error", (error) => {
-      safeUnwatch(dir);
-      const watcherError = error instanceof Error ? error : new Error(String(error));
-      options.onError?.(watcherError, dir);
-      scheduleRestart(dir);
-    });
-    watchers.set(dir, watcher);
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      watchDir(path3.join(dir, entry.name));
+    } catch (err) {
+      options.onError?.(
+        err instanceof Error ? err : new Error(String(err)),
+        rootDir
+      );
     }
-  };
-  watchDir(path3.resolve(rootDir));
+  }, pollMs);
   return {
     close() {
-      for (const timer of pending.values()) clearTimeout(timer);
+      clearInterval(intervalId);
+      for (const { timer } of pending.values()) clearTimeout(timer);
       pending.clear();
-      for (const timer of restartTimers.values()) clearTimeout(timer);
-      restartTimers.clear();
-      for (const watcher of watchers.values()) watcher.close();
-      watchers.clear();
+      try {
+        native.stopWatch(handleId);
+      } catch {
+      }
     }
   };
 }
+function watchWorkspace(rootDir, onEvent, options = {}) {
+  const nativeWatcher = watchWorkspaceNative(rootDir, onEvent, options);
+  if (!nativeWatcher) {
+    throw new Error("FATAL: Native watcher is required but not available. Build the native module: npm run build:rust");
+  }
+  return nativeWatcher;
+}
 
 // packages/domain/engine/src/index.ts
 var DEFAULT_LARGE_FILE_THRESHOLD_BYTES = 10 * 1024 * 1024;
@@ -2418,8 +3364,8 @@ var configState = {
 var log6 = createLogger("engine");
 async function loadTailwindConfigFromPath(root, tailwindConfigPath) {
   if (!tailwindConfigPath) return void 0;
-  const configPath = path3.resolve(root, tailwindConfigPath);
-  if (!fs.existsSync(configPath)) {
+  const configPath = path6__default.resolve(root, tailwindConfigPath);
+  if (!fs4__default.existsSync(configPath)) {
     throw TwError.fromIo("CONFIG_NOT_FOUND", `tailwindConfigPath not found: ${configPath}`);
   }
   const imported = await import(pathToFileURL(configPath).href);
@@ -2482,11 +3428,11 @@ async function buildFromScan(scan, root, options, tailwindConfig) {
   };
 }
 function countWorkspacePackages(root) {
-  const packagesDir = path3.join(root, "packages");
-  if (!fs.existsSync(packagesDir)) return 0;
+  const packagesDir = path6__default.join(root, "packages");
+  if (!fs4__default.existsSync(packagesDir)) return 0;
   try {
-    return fs.readdirSync(packagesDir, { withFileTypes: true }).filter(
-      (entry) => entry.isDirectory() && fs.existsSync(path3.join(packagesDir, entry.name, "package.json"))
+    return fs4__default.readdirSync(packagesDir, { withFileTypes: true }).filter(
+      (entry) => entry.isDirectory() && fs4__default.existsSync(path6__default.join(packagesDir, entry.name, "package.json"))
     ).length;
   } catch {
     return 0;
@@ -2522,7 +3468,7 @@ function writeDashboardMetrics(root, mode, result, metrics) {
 async function createEngine(rawOptions = {}) {
   const options = parseEngineOptions(rawOptions);
   const root = options.root ?? process.cwd();
-  const resolvedRoot = path3.resolve(root);
+  const resolvedRoot = path6__default.resolve(root);
   const plugins = rawOptions.plugins ?? [];
   const getTailwindConfig = async () => {
     if (configState.isLoaded()) return configState.getConfig();
@@ -2669,7 +3615,7 @@ async function createEngine(rawOptions = {}) {
       const shouldForceFullRescan = (event) => {
         if (event.type === "unlink") return false;
         try {
-          const stat = fs.statSync(event.filePath);
+          const stat = fs4__default.statSync(event.filePath);
           if (stat.size > largeFileThreshold) {
             metrics.markSkippedLargeFile();
             return true;
@@ -2788,7 +3734,7 @@ async function createEngine(rawOptions = {}) {
 
 // packages/presentation/vite/src/schemas.ts
 init_src();
-var formatIssuePath4 = (path11) => path11.length > 0 ? path11.map(
+var formatIssuePath4 = (path13) => path13.length > 0 ? path13.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
 var formatIssues4 = (error) => error.issues.map((issue) => {
@@ -2834,14 +3780,14 @@ function warnDeprecated(options, key, message) {
   }
 }
 function isInsideDirectory(filePath, directory) {
-  const relative = path3.relative(directory, filePath);
-  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
+  const relative = path6__default.relative(directory, filePath);
+  return relative === "" || !relative.startsWith("..") && !path6__default.isAbsolute(relative);
 }
 function filterScanToDirs(scan, root, scanDirs) {
-  const resolvedDirs = scanDirs.map((dir) => path3.resolve(root, dir));
+  const resolvedDirs = scanDirs.map((dir) => path6__default.resolve(root, dir));
   if (resolvedDirs.length === 0) return scan;
   const files = scan.files.filter((file) => {
-    const absoluteFile = path3.resolve(file.file);
+    const absoluteFile = path6__default.resolve(file.file);
     return resolvedDirs.some((directory) => isInsideDirectory(absoluteFile, directory));
   });
   const uniqueClasses = Array.from(new Set(files.flatMap((file) => file.classes))).sort();
@@ -2852,9 +3798,9 @@ function filterScanToDirs(scan, root, scanDirs) {
   };
 }
 function writeJsonArtifact(root, relativePath, value) {
-  const outputPath = path3.resolve(root, relativePath);
-  fs.mkdirSync(path3.dirname(outputPath), { recursive: true });
-  fs.writeFileSync(outputPath, `${JSON.stringify(value, null, 2)}
+  const outputPath = path6__default.resolve(root, relativePath);
+  fs4__default.mkdirSync(path6__default.dirname(outputPath), { recursive: true });
+  fs4__default.writeFileSync(outputPath, `${JSON.stringify(value, null, 2)}
 `);
 }
 function tailwindStyledPlugin(opts = {}) {