tailwind-styled-v4 5.0.36 → 5.0.38

package/dist/engine.js

@@ -1,48 +1,11 @@
-'use strict';
-
-var zod = require('zod');
-var module$1 = require('module');
-var fs3 = require('fs');
-var path9 = require('path');
-var crypto = require('crypto');
-var url = require('url');
-var worker_threads = require('worker_threads');
-var os = require('os');
-require('perf_hooks');
-
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
-var path9__namespace = /*#__PURE__*/_interopNamespace(path9);
-
 /* tailwind-styled-v4 v5.0.4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
+"use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -58,6 +21,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/domain/shared/src/trace.ts
@@ -152,6 +123,7 @@ function getPipelinePercentages(metrics) {
 }
 var init_trace = __esm({
   "packages/domain/shared/src/trace.ts"() {
+    "use strict";
   }
 });
 
@@ -166,6 +138,7 @@ function formatErrorCode(code) {
 var ERROR_CODES, ERROR_SUGGESTIONS;
 var init_error_codes = __esm({
   "packages/domain/shared/src/error-codes.ts"() {
+    "use strict";
     ERROR_CODES = {
       // E0xx — Native binding
       NATIVE_NOT_FOUND: "E001",
@@ -207,8 +180,8 @@ var init_error_codes = __esm({
 // packages/domain/shared/src/compatibility.ts
 function detectTailwind() {
   try {
-    const pkgPath = __require.resolve("tailwindcss/package.json");
-    const { version } = __require(pkgPath);
+    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 {
@@ -232,8 +205,11 @@ function isTailwindV4() {
 }
 var init_compatibility = __esm({
   "packages/domain/shared/src/compatibility.ts"() {
+    "use strict";
   }
 });
+
+// packages/domain/shared/src/native-schemas.ts
 function safeParseNative(schema, data, fallback) {
   const result = schema.safeParse(data);
   return result.success ? result.data : fallback;
@@ -249,67 +225,69 @@ function parseNative(schema, data, context) {
   }
   return result.data;
 }
-var NativeScanFileSchema, NativeScanResultSchema, NativeClassUsageSchema, NativeAnalyzerReportSchema, NativeTransformResultSchema, NativeCssCompileResultSchema, NativeWatchResultSchema, NativeCacheEntrySchema, NativeCacheReadResultSchema;
+var import_zod, NativeScanFileSchema, NativeScanResultSchema, NativeClassUsageSchema, NativeAnalyzerReportSchema, NativeTransformResultSchema, NativeCssCompileResultSchema, NativeWatchEventSchema, NativeWatchResultSchema, NativeCacheEntrySchema, NativeCacheReadResultSchema;
 var init_native_schemas = __esm({
   "packages/domain/shared/src/native-schemas.ts"() {
-    NativeScanFileSchema = zod.z.object({
-      file: zod.z.string().min(1, "file path cannot be empty"),
-      classes: zod.z.array(zod.z.string()),
-      hash: zod.z.string().optional()
+    "use strict";
+    import_zod = require("zod");
+    NativeScanFileSchema = import_zod.z.object({
+      file: import_zod.z.string().min(1, "file path cannot be empty"),
+      classes: import_zod.z.array(import_zod.z.string()),
+      hash: import_zod.z.string().optional()
     });
-    NativeScanResultSchema = zod.z.object({
-      files: zod.z.array(NativeScanFileSchema),
-      totalFiles: zod.z.number().int().nonnegative(),
-      uniqueClasses: zod.z.array(zod.z.string())
+    NativeScanResultSchema = import_zod.z.object({
+      files: import_zod.z.array(NativeScanFileSchema),
+      totalFiles: import_zod.z.number().int().nonnegative(),
+      uniqueClasses: import_zod.z.array(import_zod.z.string())
     });
-    NativeClassUsageSchema = zod.z.object({
-      name: zod.z.string(),
-      count: zod.z.number().int().nonnegative(),
-      files: zod.z.array(zod.z.string()).optional()
+    NativeClassUsageSchema = import_zod.z.object({
+      name: import_zod.z.string(),
+      count: import_zod.z.number().int().nonnegative(),
+      files: import_zod.z.array(import_zod.z.string()).optional()
     });
-    NativeAnalyzerReportSchema = zod.z.object({
-      root: zod.z.string(),
-      topClasses: zod.z.array(NativeClassUsageSchema).optional(),
-      safelist: zod.z.array(zod.z.string()).optional(),
-      css: zod.z.string().optional(),
-      conflicts: zod.z.array(zod.z.unknown()).optional(),
-      unusedClasses: zod.z.array(zod.z.string()).optional(),
-      durationMs: zod.z.number().nonnegative().optional()
+    NativeAnalyzerReportSchema = import_zod.z.object({
+      root: import_zod.z.string(),
+      topClasses: import_zod.z.array(NativeClassUsageSchema).optional(),
+      safelist: import_zod.z.array(import_zod.z.string()).optional(),
+      css: import_zod.z.string().optional(),
+      conflicts: import_zod.z.array(import_zod.z.unknown()).optional(),
+      unusedClasses: import_zod.z.array(import_zod.z.string()).optional(),
+      durationMs: import_zod.z.number().nonnegative().optional()
     });
-    NativeTransformResultSchema = zod.z.object({
-      code: zod.z.string(),
-      classes: zod.z.array(zod.z.string()),
-      changed: zod.z.boolean(),
-      rsc: zod.z.object({
-        isServer: zod.z.boolean(),
-        needsClientDirective: zod.z.boolean(),
-        clientReasons: zod.z.array(zod.z.string())
+    NativeTransformResultSchema = import_zod.z.object({
+      code: import_zod.z.string(),
+      classes: import_zod.z.array(import_zod.z.string()),
+      changed: import_zod.z.boolean(),
+      rsc: import_zod.z.object({
+        isServer: import_zod.z.boolean(),
+        needsClientDirective: import_zod.z.boolean(),
+        clientReasons: import_zod.z.array(import_zod.z.string())
       }).optional()
     });
-    NativeCssCompileResultSchema = zod.z.object({
-      css: zod.z.string(),
-      resolvedClasses: zod.z.array(zod.z.string()),
-      unresolvedClasses: zod.z.array(zod.z.string()).optional()
+    NativeCssCompileResultSchema = import_zod.z.object({
+      css: import_zod.z.string(),
+      resolvedClasses: import_zod.z.array(import_zod.z.string()),
+      unresolvedClasses: import_zod.z.array(import_zod.z.string()).optional()
     });
-    zod.z.object({
-      type: zod.z.enum(["change", "unlink", "create"]),
-      path: zod.z.string()
+    NativeWatchEventSchema = import_zod.z.object({
+      type: import_zod.z.enum(["change", "unlink", "create"]),
+      path: import_zod.z.string()
     });
-    NativeWatchResultSchema = zod.z.object({
-      status: zod.z.enum(["ok", "error"]),
-      handleId: zod.z.string().optional(),
-      error: zod.z.string().optional()
+    NativeWatchResultSchema = import_zod.z.object({
+      status: import_zod.z.enum(["ok", "error"]),
+      handleId: import_zod.z.string().optional(),
+      error: import_zod.z.string().optional()
     });
-    NativeCacheEntrySchema = zod.z.object({
-      file: zod.z.string(),
-      hash: zod.z.string(),
-      classes: zod.z.array(zod.z.string()),
-      timestamp: zod.z.number(),
-      size: zod.z.number().optional()
+    NativeCacheEntrySchema = import_zod.z.object({
+      file: import_zod.z.string(),
+      hash: import_zod.z.string(),
+      classes: import_zod.z.array(import_zod.z.string()),
+      timestamp: import_zod.z.number(),
+      size: import_zod.z.number().optional()
     });
-    NativeCacheReadResultSchema = zod.z.object({
-      entries: zod.z.array(NativeCacheEntrySchema),
-      version: zod.z.string().optional()
+    NativeCacheReadResultSchema = import_zod.z.object({
+      entries: import_zod.z.array(NativeCacheEntrySchema),
+      version: import_zod.z.string().optional()
     });
   }
 });
@@ -319,7 +297,7 @@ function getNodeModuleRef() {
   if (isBrowser) return null;
   if (nodeModuleRef !== null) return nodeModuleRef;
   try {
-    const test = typeof __require === "function" ? __require("module") : null;
+    const test = typeof require === "function" ? require("module") : null;
     nodeModuleRef = test;
     return test;
   } catch {
@@ -331,21 +309,21 @@ function getNodePath() {
   if (isBrowser) throw new Error("node:path not available in browser");
   const nodeRequire = getNodeModuleRef();
   if (!nodeRequire) throw new Error("require not available");
-  if (!_nodePath) _nodePath = nodeRequire.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)))("node:path");
+  if (!_nodePath) _nodePath = nodeRequire.createRequire(import_meta.url)("node:path");
   return _nodePath;
 }
 function getNodeUrl() {
   if (isBrowser) throw new Error("node:url not available in browser");
   const nodeRequire = getNodeModuleRef();
   if (!nodeRequire) throw new Error("require not available");
-  if (!_nodeUrl) _nodeUrl = nodeRequire.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)))("node:url");
+  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((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)))("node:fs");
+  if (!_nodeFs) _nodeFs = nodeRequire.createRequire(import_meta.url)("node:fs");
   return _nodeFs;
 }
 function createEsmRequire(importMetaUrl) {
@@ -368,7 +346,7 @@ function resolveFromRoot(...segments) {
   if (isBrowser) return segments.join("/");
   const nodePath = getNodePath();
   const nodeFs = getNodeFs();
-  let dir = getDirname((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)));
+  let dir = getDirname(import_meta.url);
   for (let i = 0; i < 10; i++) {
     const pkgPath = nodePath.join(dir, "package.json");
     try {
@@ -394,9 +372,11 @@ function resolveNativeNodePath(importMetaUrl, ...relativeSegments) {
   if (isBrowser) return relativeSegments.join("/");
   return getNodePath().resolve(getDirname(importMetaUrl), ...relativeSegments);
 }
-var isBrowser, nodeModuleRef, _nodePath, _nodeUrl, _nodeFs;
+var import_meta, isBrowser, nodeModuleRef, _nodePath, _nodeUrl, _nodeFs;
 var init_esmHelpers = __esm({
   "packages/domain/shared/src/esmHelpers.ts"() {
+    "use strict";
+    import_meta = {};
     isBrowser = typeof window !== "undefined" || typeof document !== "undefined";
     nodeModuleRef = null;
     _nodePath = null;
@@ -447,6 +427,7 @@ function createBuildTimer() {
 var RING_BUFFER_SIZE, TelemetryCollector, _globalCollector;
 var init_telemetry = __esm({
   "packages/domain/shared/src/telemetry.ts"() {
+    "use strict";
     RING_BUFFER_SIZE = 100;
     TelemetryCollector = class {
       data = [];
@@ -513,6 +494,8 @@ var init_telemetry = __esm({
     _globalCollector = null;
   }
 });
+
+// packages/domain/shared/src/configSchemas.ts
 function parseJsonWithSchema(jsonString, schema, sourceName) {
   let parsed;
   try {
@@ -531,8 +514,8 @@ ${issues}`);
   return result.data;
 }
 function parseJsonFileWithSchema(filePath, schema) {
-  const { readFileSync } = __require("fs");
-  const { basename } = __require("path");
+  const { readFileSync } = require("fs");
+  const { basename } = require("path");
   let content;
   try {
     content = readFileSync(filePath, "utf-8");
@@ -543,70 +526,72 @@ function parseJsonFileWithSchema(filePath, schema) {
   }
   return parseJsonWithSchema(content, schema, basename(filePath));
 }
-var ScanCacheClassEntrySchema, ScanCacheSchema, TailwindContentItemSchema, TailwindConfigSchema, RegistryPluginEntrySchema, RegistryFileSchema, PackageJsonSchema;
+var import_zod2, ScanCacheClassEntrySchema, ScanCacheSchema, TailwindContentItemSchema, TailwindConfigSchema, RegistryPluginEntrySchema, RegistryFileSchema, PackageJsonSchema;
 var init_configSchemas = __esm({
   "packages/domain/shared/src/configSchemas.ts"() {
-    ScanCacheClassEntrySchema = zod.z.object({
-      name: zod.z.string().min(1),
-      usedIn: zod.z.array(zod.z.string()),
-      risk: zod.z.enum(["low", "medium", "high"]).default("low"),
-      bundleContribution: zod.z.number().nonnegative().default(0),
-      variants: zod.z.array(zod.z.string()).default([])
+    "use strict";
+    import_zod2 = require("zod");
+    ScanCacheClassEntrySchema = import_zod2.z.object({
+      name: import_zod2.z.string().min(1),
+      usedIn: import_zod2.z.array(import_zod2.z.string()),
+      risk: import_zod2.z.enum(["low", "medium", "high"]).default("low"),
+      bundleContribution: import_zod2.z.number().nonnegative().default(0),
+      variants: import_zod2.z.array(import_zod2.z.string()).default([])
     });
-    ScanCacheSchema = zod.z.object({
-      version: zod.z.string().default("1"),
-      generatedAt: zod.z.string(),
-      root: zod.z.string(),
-      classNames: zod.z.array(ScanCacheClassEntrySchema),
-      totalFiles: zod.z.number().int().nonnegative(),
-      uniqueCount: zod.z.number().int().nonnegative()
+    ScanCacheSchema = import_zod2.z.object({
+      version: import_zod2.z.string().default("1"),
+      generatedAt: import_zod2.z.string(),
+      root: import_zod2.z.string(),
+      classNames: import_zod2.z.array(ScanCacheClassEntrySchema),
+      totalFiles: import_zod2.z.number().int().nonnegative(),
+      uniqueCount: import_zod2.z.number().int().nonnegative()
     });
-    TailwindContentItemSchema = zod.z.union([
-      zod.z.string(),
-      zod.z.object({
-        raw: zod.z.string(),
-        extension: zod.z.string().optional()
+    TailwindContentItemSchema = import_zod2.z.union([
+      import_zod2.z.string(),
+      import_zod2.z.object({
+        raw: import_zod2.z.string(),
+        extension: import_zod2.z.string().optional()
       }),
-      zod.z.object({
-        files: zod.z.array(zod.z.string()),
-        transform: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+      import_zod2.z.object({
+        files: import_zod2.z.array(import_zod2.z.string()),
+        transform: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional()
       })
     ]);
-    TailwindConfigSchema = zod.z.object({
-      content: zod.z.array(TailwindContentItemSchema).optional(),
-      theme: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
-      plugins: zod.z.array(zod.z.unknown()).optional(),
-      darkMode: zod.z.union([zod.z.literal("class"), zod.z.literal("media"), zod.z.literal(false)]).optional(),
-      prefix: zod.z.string().optional(),
-      safelist: zod.z.array(zod.z.union([zod.z.string(), zod.z.object({ pattern: zod.z.instanceof(RegExp) })])).optional(),
-      blocklist: zod.z.array(zod.z.string()).optional()
+    TailwindConfigSchema = import_zod2.z.object({
+      content: import_zod2.z.array(TailwindContentItemSchema).optional(),
+      theme: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.unknown()).optional(),
+      plugins: import_zod2.z.array(import_zod2.z.unknown()).optional(),
+      darkMode: import_zod2.z.union([import_zod2.z.literal("class"), import_zod2.z.literal("media"), import_zod2.z.literal(false)]).optional(),
+      prefix: import_zod2.z.string().optional(),
+      safelist: import_zod2.z.array(import_zod2.z.union([import_zod2.z.string(), import_zod2.z.object({ pattern: import_zod2.z.instanceof(RegExp) })])).optional(),
+      blocklist: import_zod2.z.array(import_zod2.z.string()).optional()
     }).passthrough();
-    RegistryPluginEntrySchema = zod.z.object({
-      name: zod.z.string().min(1),
-      description: zod.z.string(),
-      version: zod.z.string(),
-      tags: zod.z.array(zod.z.string()).default([]),
-      official: zod.z.boolean().default(false),
-      docs: zod.z.string().url().optional(),
-      install: zod.z.string().optional(),
-      integrity: zod.z.string().optional()
+    RegistryPluginEntrySchema = import_zod2.z.object({
+      name: import_zod2.z.string().min(1),
+      description: import_zod2.z.string(),
+      version: import_zod2.z.string(),
+      tags: import_zod2.z.array(import_zod2.z.string()).default([]),
+      official: import_zod2.z.boolean().default(false),
+      docs: import_zod2.z.string().url().optional(),
+      install: import_zod2.z.string().optional(),
+      integrity: import_zod2.z.string().optional()
     });
-    RegistryFileSchema = zod.z.object({
-      version: zod.z.string(),
-      official: zod.z.array(RegistryPluginEntrySchema).default([]),
-      community: zod.z.array(RegistryPluginEntrySchema).default([])
+    RegistryFileSchema = import_zod2.z.object({
+      version: import_zod2.z.string(),
+      official: import_zod2.z.array(RegistryPluginEntrySchema).default([]),
+      community: import_zod2.z.array(RegistryPluginEntrySchema).default([])
     });
-    PackageJsonSchema = zod.z.object({
-      name: zod.z.string(),
-      version: zod.z.string(),
-      scripts: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-      dependencies: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-      devDependencies: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-      peerDependencies: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-      main: zod.z.string().optional(),
-      module: zod.z.string().optional(),
-      exports: zod.z.unknown().optional(),
-      type: zod.z.enum(["module", "commonjs"]).optional()
+    PackageJsonSchema = import_zod2.z.object({
+      name: import_zod2.z.string(),
+      version: import_zod2.z.string(),
+      scripts: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional(),
+      dependencies: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional(),
+      devDependencies: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional(),
+      peerDependencies: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional(),
+      main: import_zod2.z.string().optional(),
+      module: import_zod2.z.string().optional(),
+      exports: import_zod2.z.unknown().optional(),
+      type: import_zod2.z.enum(["module", "commonjs"]).optional()
     }).passthrough();
   }
 });
@@ -616,8 +601,8 @@ function getDirnameFromUrl(importMetaUrl) {
   if (!importMetaUrl) return "";
   if (isBrowser2) return "";
   try {
-    const nodeUrl = __require(NODE_URL);
-    const nodePath = __require(NODE_PATH);
+    const nodeUrl = require(NODE_URL);
+    const nodePath = require(NODE_PATH);
     return nodePath.dirname(nodeUrl.fileURLToPath(importMetaUrl));
   } catch {
     if (importMetaUrl.startsWith("file://")) {
@@ -631,7 +616,7 @@ function getDirnameFromUrl(importMetaUrl) {
 function resolvePath(...segments) {
   if (isBrowser2) return segments.join("/").replace(/\/+/g, "/");
   try {
-    const nodePath = __require(NODE_PATH);
+    const nodePath = require(NODE_PATH);
     return nodePath.resolve(...segments);
   } catch {
     return segments.join("/").replace(/\/+/g, "/");
@@ -640,7 +625,7 @@ function resolvePath(...segments) {
 function existsSync(path16) {
   if (isBrowser2) return false;
   try {
-    const nodeFs = __require(NODE_FS);
+    const nodeFs = require(NODE_FS);
     return nodeFs.existsSync(path16);
   } catch {
     return false;
@@ -694,6 +679,7 @@ function resolveLoaderPath(loaderBasename, importMetaUrl) {
 var isBrowser2, NODE_URL, NODE_FS, NODE_PATH;
 var init_workerResolver = __esm({
   "packages/domain/shared/src/workerResolver.ts"() {
+    "use strict";
     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;
@@ -843,13 +829,13 @@ function generateClassRenameCodemod(renames, opts = {}) {
   }
   return lines.join("\n");
 }
-function generateBarrelFile(exports$1, dir, opts = {}) {
+function generateBarrelFile(exports2, 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) {
+  for (const name of exports2) {
     lines.push(`export { default as ${name}, type ${name}Props } from "./${name}"`);
     if (includeTypes) {
       lines.push(`export type * from "./${name}"`);
@@ -859,8 +845,11 @@ function generateBarrelFile(exports$1, dir, opts = {}) {
 }
 var init_codegen = __esm({
   "packages/domain/shared/src/codegen.ts"() {
+    "use strict";
   }
 });
+
+// packages/domain/shared/src/native-resolution.ts
 function platformKey() {
   if (isBrowser3) return "browser";
   return `${process.platform}-${process.arch}`;
@@ -876,7 +865,7 @@ function resolveNativeBinary(runtimeDir) {
   }
   const envPath = process.env.TW_NATIVE_PATH?.trim();
   if (envPath) {
-    if (fs3__namespace.existsSync(envPath)) {
+    if (fs.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
@@ -885,7 +874,7 @@ function resolveNativeBinary(runtimeDir) {
   for (const pkg of prebuiltPkgs) {
     try {
       const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs3__namespace.existsSync(candidate)) {
+      if (fs.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -896,13 +885,13 @@ function resolveNativeBinary(runtimeDir) {
   const napiPlatform = platform === "linux-x64" ? "linux-x64-gnu" : platform === "linux-arm64" ? "linux-arm64-gnu" : platform;
   const BINARY_NAMES_SELF = ["tailwind-styled-native", "tailwind_styled_parser"];
   if (runtimeDir) {
-    for (const depth of ["..", path9__namespace.join("..", ".."), path9__namespace.join("..", "..", "..")]) {
-      const pkgRoot = path9__namespace.resolve(runtimeDir, depth);
+    for (const depth of ["..", path.join("..", ".."), path.join("..", "..", "..")]) {
+      const pkgRoot = path.resolve(runtimeDir, depth);
       for (const bin of BINARY_NAMES_SELF) {
         for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
-          const candidate = path9__namespace.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
+          const candidate = path.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
           tried.push(`self-bundled:${candidate}`);
-          if (fs3__namespace.existsSync(candidate)) {
+          if (fs.existsSync(candidate)) {
             return { path: candidate, source: "prebuilt", platform, tried };
           }
         }
@@ -914,29 +903,29 @@ function resolveNativeBinary(runtimeDir) {
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const localCandidates = [];
   for (const bin of BINARY_NAMES) {
-    localCandidates.push(path9__namespace.resolve(base, `${bin}.node`));
-    localCandidates.push(path9__namespace.resolve(base, "..", `${bin}.node`));
-    localCandidates.push(path9__namespace.resolve(base, `${bin}.${platform}.node`));
-    localCandidates.push(path9__namespace.resolve(base, `${bin}.${napiPlatform}.node`));
+    localCandidates.push(path.resolve(base, `${bin}.node`));
+    localCandidates.push(path.resolve(base, "..", `${bin}.node`));
+    localCandidates.push(path.resolve(base, `${bin}.${platform}.node`));
+    localCandidates.push(path.resolve(base, `${bin}.${napiPlatform}.node`));
   }
   for (const startDir of [cwd, base]) {
     let dir = startDir;
     for (let i = 0; i < 6; i++) {
-      const nativeDir = path9__namespace.resolve(dir, "native");
+      const nativeDir = path.resolve(dir, "native");
       for (const bin of BINARY_NAMES) {
-        localCandidates.push(path9__namespace.resolve(nativeDir, `${bin}.node`));
-        localCandidates.push(path9__namespace.resolve(nativeDir, `${bin}.${platform}.node`));
-        localCandidates.push(path9__namespace.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
-        localCandidates.push(path9__namespace.resolve(nativeDir, "target", "release", `${bin}.node`));
+        localCandidates.push(path.resolve(nativeDir, `${bin}.node`));
+        localCandidates.push(path.resolve(nativeDir, `${bin}.${platform}.node`));
+        localCandidates.push(path.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
+        localCandidates.push(path.resolve(nativeDir, "target", "release", `${bin}.node`));
       }
-      const parent = path9__namespace.resolve(dir, "..");
+      const parent = path.resolve(dir, "..");
       if (parent === dir) break;
       dir = parent;
     }
   }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs3__namespace.existsSync(candidate)) {
+    if (fs.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
@@ -956,11 +945,16 @@ function formatNativeNotFoundError(result) {
   ];
   return lines.join("\n");
 }
-var isBrowser3, _require, PLATFORM_MAP;
+var import_node_module, fs, path, import_meta2, isBrowser3, _require, PLATFORM_MAP;
 var init_native_resolution = __esm({
   "packages/domain/shared/src/native-resolution.ts"() {
+    "use strict";
+    import_node_module = require("module");
+    fs = __toESM(require("fs"));
+    path = __toESM(require("path"));
+    import_meta2 = {};
     isBrowser3 = typeof window !== "undefined" || typeof document !== "undefined";
-    _require = typeof __require !== "undefined" ? __require : module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)));
+    _require = typeof require !== "undefined" ? require : (0, import_node_module.createRequire)(import_meta2.url);
     PLATFORM_MAP = {
       "linux-x64": ["@tailwind-styled/native-linux-x64-gnu", "@tailwind-styled/native-linux-x64"],
       "linux-arm64": ["@tailwind-styled/native-linux-arm64-gnu", "@tailwind-styled/native-linux-arm64"],
@@ -1006,15 +1000,18 @@ function createObservabilityClient(opts = {}) {
 }
 var init_observability = __esm({
   "packages/domain/shared/src/observability.ts"() {
+    "use strict";
   }
 });
 
 // packages/domain/compiler/src/nativeBridge.ts
-var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge, adaptNativeResult;
+var import_meta3, _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge, adaptNativeResult;
 var init_nativeBridge = __esm({
   "packages/domain/compiler/src/nativeBridge.ts"() {
+    "use strict";
     init_src2();
-    _loadNative = (path16) => __require(path16);
+    import_meta3 = {};
+    _loadNative = (path16) => require(path16);
     log = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -1040,7 +1037,7 @@ var init_nativeBridge = __esm({
       }
       bridgeLoadAttempted = true;
       try {
-        const runtimeDir = resolveRuntimeDir(void 0, (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)));
+        const runtimeDir = resolveRuntimeDir(void 0, import_meta3.url);
         const result = resolveNativeBinary(runtimeDir);
         if (result.path && result.path.endsWith(".node")) {
           try {
@@ -1152,6 +1149,7 @@ function resetCacheStats() {
 }
 var init_cssGeneratorNative = __esm({
   "packages/domain/compiler/src/compiler/cssGeneratorNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -1224,6 +1222,7 @@ function atomicRegistrySize() {
 }
 var init_compilationNative = __esm({
   "packages/domain/compiler/src/compiler/compilationNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -1367,6 +1366,7 @@ function twMergeRaw(classLists) {
 }
 var init_cssCompilationNative = __esm({
   "packages/domain/compiler/src/compiler/cssCompilationNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -1466,6 +1466,7 @@ function idRegistryImport(importedData) {
 }
 var init_idRegistryNative = __esm({
   "packages/domain/compiler/src/compiler/idRegistryNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -1607,9 +1608,12 @@ function scanFilesBatchNative(filesJson) {
 }
 var init_streamingNative = __esm({
   "packages/domain/compiler/src/compiler/streamingNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
+
+// packages/domain/compiler/src/tailwindEngine.ts
 function loadTailwindEngine() {
   if (_twEngine) return _twEngine;
   if (_twEngineError) throw _twEngineError;
@@ -1629,10 +1633,10 @@ async function generateRawCss(classes, cssEntryContent, root) {
   if (classes.length === 0) return "";
   const tw = loadTailwindEngine();
   const input = cssEntryContent ?? "@import 'tailwindcss';";
-  const { readFileSync, existsSync: existsSync3 } = await import('fs');
-  const { dirname, resolve: resolve2 } = await import('path');
+  const { readFileSync, existsSync: existsSync3 } = await import("fs");
+  const { dirname, resolve: resolve2 } = await import("path");
   const projectRoot = root ?? process.cwd();
-  const req = module$1.createRequire(resolve2(projectRoot, "package.json"));
+  const req = (0, import_node_module2.createRequire)(resolve2(projectRoot, "package.json"));
   const loadStylesheet = async (id, base) => {
     try {
       const cssId = id === "tailwindcss" ? "tailwindcss/index.css" : id === "tailwindcss/preflight" ? "tailwindcss/preflight.css" : id === "tailwindcss/utilities" ? "tailwindcss/utilities.css" : id === "tailwindcss/theme" ? "tailwindcss/theme.css" : id;
@@ -1652,10 +1656,14 @@ async function generateRawCss(classes, cssEntryContent, root) {
   const compiler = await Promise.resolve(tw.compile(input, { loadStylesheet }));
   return compiler.build(classes);
 }
-var require2, _twEngine, _twEngineError;
+var import_node_module2, import_meta4, require2, MAX_CACHE_MEMORY, _twEngine, _twEngineError;
 var init_tailwindEngine = __esm({
   "packages/domain/compiler/src/tailwindEngine.ts"() {
-    require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)));
+    "use strict";
+    import_node_module2 = require("module");
+    import_meta4 = {};
+    require2 = (0, import_node_module2.createRequire)(import_meta4.url);
+    MAX_CACHE_MEMORY = 256 * 1024;
     _twEngine = null;
     _twEngineError = null;
   }
@@ -1836,24 +1844,29 @@ function processTailwindCssWithTargets(css, targets) {
   }
   return result.css;
 }
-var _cssCache, _cacheHits, _cacheMisses, MAX_CACHE_SIZE;
+var import_node_module3, import_meta5, require3, _cssCache, _cacheHits, _cacheMisses, MAX_CACHE_SIZE, MAX_CACHE_MEMORY2;
 var init_tailwindEngine2 = __esm({
   "packages/domain/compiler/src/compiler/tailwindEngine.ts"() {
+    "use strict";
+    import_node_module3 = require("module");
     init_nativeBridge();
     init_cssGeneratorNative();
     init_cssCompilationNative();
     init_tailwindEngine();
-    module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)));
+    import_meta5 = {};
+    require3 = (0, import_node_module3.createRequire)(import_meta5.url);
     _cssCache = /* @__PURE__ */ new Map();
     _cacheHits = 0;
     _cacheMisses = 0;
     MAX_CACHE_SIZE = 100;
+    MAX_CACHE_MEMORY2 = 256 * 1024;
   }
 });
 
 // packages/domain/compiler/src/compiler/index.ts
 var init_compiler = __esm({
   "packages/domain/compiler/src/compiler/index.ts"() {
+    "use strict";
     init_cssGeneratorNative();
     init_compilationNative();
     init_cssCompilationNative();
@@ -1866,6 +1879,7 @@ var init_compiler = __esm({
 var parseClasses, parseClass, extractAllClasses, extractClassesFromSource, astExtractClasses, normalizeClasses, mergeClassesStatic, normalizeAndDedupClasses, extractComponentUsage, batchExtractClasses, checkAgainstSafelist, diffClassLists;
 var init_parser = __esm({
   "packages/domain/compiler/src/parser/index.ts"() {
+    "use strict";
     init_nativeBridge();
     parseClasses = (raw) => {
       const native = getNativeBridge();
@@ -2044,6 +2058,7 @@ function resetMemoryStats() {
 }
 var init_analyzerNative = __esm({
   "packages/domain/compiler/src/analyzer/analyzerNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2137,6 +2152,7 @@ function resolveSimpleVariants(configJson) {
 }
 var init_themeResolutionNative = __esm({
   "packages/domain/compiler/src/analyzer/themeResolutionNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2184,6 +2200,7 @@ function generateSubComponentTypes(root, outputPath) {
 }
 var init_scannerNative = __esm({
   "packages/domain/compiler/src/analyzer/scannerNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2191,6 +2208,7 @@ var init_scannerNative = __esm({
 // packages/domain/compiler/src/analyzer/index.ts
 var init_analyzer = __esm({
   "packages/domain/compiler/src/analyzer/index.ts"() {
+    "use strict";
     init_analyzerNative();
     init_themeResolutionNative();
     init_scannerNative();
@@ -2379,6 +2397,7 @@ function resetResolverPoolStats() {
 }
 var init_cacheNative = __esm({
   "packages/domain/compiler/src/cache/cacheNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2386,6 +2405,7 @@ var init_cacheNative = __esm({
 // packages/domain/compiler/src/cache/index.ts
 var init_cache = __esm({
   "packages/domain/compiler/src/cache/index.ts"() {
+    "use strict";
     init_cacheNative();
   }
 });
@@ -2634,6 +2654,7 @@ function redisDiagnose() {
 }
 var init_redisNative = __esm({
   "packages/domain/compiler/src/redis/redisNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2641,6 +2662,7 @@ var init_redisNative = __esm({
 // packages/domain/compiler/src/redis/index.ts
 var init_redis = __esm({
   "packages/domain/compiler/src/redis/index.ts"() {
+    "use strict";
     init_redisNative();
   }
 });
@@ -2779,6 +2801,7 @@ function getCompilerDiagnostics() {
 }
 var init_watchSystemNative = __esm({
   "packages/domain/compiler/src/watch/watchSystemNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2786,9 +2809,12 @@ var init_watchSystemNative = __esm({
 // packages/domain/compiler/src/watch/index.ts
 var init_watch = __esm({
   "packages/domain/compiler/src/watch/index.ts"() {
+    "use strict";
     init_watchSystemNative();
   }
 });
+
+// packages/domain/compiler/src/index.ts
 function _layoutClassesToCss(classes) {
   const native = getNativeBridge();
   if (!native?.layoutClassesToCss) {
@@ -2823,9 +2849,13 @@ function extractContainerCssFromSource(source) {
   }
   return rules.join("\n");
 }
-var _require2, transformSource, hasTwUsage, isAlreadyTransformed, shouldProcess, compileCssFromClasses, buildStyleTag, generateCssForClasses, eliminateDeadCss, findDeadVariants, runElimination, scanProjectUsage, generateSafelist, loadSafelist, loadTailwindConfig, getContentPaths, _CONTAINER_BREAKPOINTS, runLoaderTransform, shouldSkipFile, fileToRoute, getAllRoutes, getRouteClasses, registerFileClasses, registerGlobalClasses, _incrementalEngineInstance, getIncrementalEngine, resetIncrementalEngine, IncrementalEngine, getBucketEngine, resetBucketEngine, classifyNode, detectConflicts, bucketSort, analyzeFile, analyzeVariantUsage, injectClientDirective, injectServerOnlyComment, analyzeClasses, extractTwStateConfigs, generateStaticStateCss, extractAndGenerateStateCss;
+var import_node_fs, import_node_path, import_node_module4, import_meta6, _require2, transformSource, hasTwUsage, isAlreadyTransformed, shouldProcess, compileCssFromClasses, buildStyleTag, generateCssForClasses, eliminateDeadCss, findDeadVariants, runElimination, scanProjectUsage, generateSafelist, loadSafelist, loadTailwindConfig, getContentPaths, _CONTAINER_BREAKPOINTS, runLoaderTransform, shouldSkipFile, fileToRoute, getAllRoutes, getRouteClasses, registerFileClasses, registerGlobalClasses, _incrementalEngineInstance, getIncrementalEngine, resetIncrementalEngine, IncrementalEngine, getBucketEngine, resetBucketEngine, classifyNode, detectConflicts, bucketSort, analyzeFile, analyzeVariantUsage, injectClientDirective, injectServerOnlyComment, analyzeClasses, extractTwStateConfigs, generateStaticStateCss, extractAndGenerateStateCss;
 var init_src = __esm({
   "packages/domain/compiler/src/index.ts"() {
+    "use strict";
+    import_node_fs = __toESM(require("fs"), 1);
+    import_node_path = __toESM(require("path"), 1);
+    import_node_module4 = require("module");
     init_nativeBridge();
     init_compiler();
     init_parser();
@@ -2833,7 +2863,8 @@ var init_src = __esm({
     init_cache();
     init_redis();
     init_watch();
-    _require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)));
+    import_meta6 = {};
+    _require2 = (0, import_node_module4.createRequire)(import_meta6.url);
     transformSource = (source, opts) => {
       const native = getNativeBridge();
       if (!native?.transformSource) {
@@ -2925,7 +2956,7 @@ var init_src = __esm({
     };
     scanProjectUsage = (dirs, cwd) => {
       const { batchExtractClasses: batchExtractClasses2 } = _require2("./parser");
-      const files = dirs.map((dir) => path9__namespace.default.resolve(cwd, dir));
+      const files = dirs.map((dir) => import_node_path.default.resolve(cwd, dir));
       const results = batchExtractClasses2(files) || [];
       const combined = {};
       for (const result of results) {
@@ -2942,13 +2973,13 @@ var init_src = __esm({
       const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
       const allClasses = Object.keys(classes).sort();
       if (outputPath) {
-        fs3__namespace.default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+        import_node_fs.default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
       }
       return allClasses;
     };
     loadSafelist = (safelistPath) => {
       try {
-        const content = fs3__namespace.default.readFileSync(safelistPath, "utf-8");
+        const content = import_node_fs.default.readFileSync(safelistPath, "utf-8");
         return JSON.parse(content);
       } catch {
         return [];
@@ -2962,9 +2993,9 @@ var init_src = __esm({
         "tailwind.config.cjs"
       ];
       for (const file of configFiles) {
-        const fullPath = path9__namespace.default.join(cwd, file);
-        if (fs3__namespace.default.existsSync(fullPath)) {
-          const mod = __require(fullPath);
+        const fullPath = import_node_path.default.join(cwd, file);
+        if (import_node_fs.default.existsSync(fullPath)) {
+          const mod = require(fullPath);
           return mod.default || mod;
         }
       }
@@ -2973,9 +3004,9 @@ var init_src = __esm({
     getContentPaths = (cwd = process.cwd()) => {
       return {
         content: [
-          path9__namespace.default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
-          path9__namespace.default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
-          path9__namespace.default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
+          import_node_path.default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          import_node_path.default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          import_node_path.default.join(cwd, "pages/**/*.{js,ts,jsx,tsx}")
         ]
       };
     };
@@ -3389,6 +3420,7 @@ __export(internal_exports, {
 });
 var init_internal = __esm({
   "packages/domain/compiler/src/internal.ts"() {
+    "use strict";
     init_src();
     init_tailwindEngine2();
     init_compiler();
@@ -3399,6 +3431,8 @@ var init_internal = __esm({
     init_watch();
   }
 });
+
+// packages/domain/shared/src/staticStateExtractor.ts
 function getNative() {
   if (_native) return _native;
   try {
@@ -3428,17 +3462,17 @@ function getNative() {
 function* walkSourceFiles(dir) {
   let entries;
   try {
-    entries = fs3__namespace.default.readdirSync(dir, { withFileTypes: true });
+    entries = import_node_fs2.default.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
-    const fullPath = path9__namespace.default.join(dir, entry.name);
+    const fullPath = import_node_path2.default.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (IGNORE_PATTERNS.some((p) => entry.name === p || entry.name.startsWith(p))) continue;
       yield* walkSourceFiles(fullPath);
     } else if (entry.isFile()) {
-      const ext = path9__namespace.default.extname(entry.name);
+      const ext = import_node_path2.default.extname(entry.name);
       if (SOURCE_EXTENSIONS.has(ext)) yield fullPath;
     }
   }
@@ -3502,7 +3536,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${path9__namespace.default.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${import_node_path2.default.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -3513,7 +3547,7 @@ function extractStaticStateCss(srcDir, options = {}) {
       if (filesScanned >= maxFiles) break;
       let source;
       try {
-        source = fs3__namespace.default.readFileSync(filePath, "utf-8");
+        source = import_node_fs2.default.readFileSync(filePath, "utf-8");
       } catch {
         continue;
       }
@@ -3526,7 +3560,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${path9__namespace.default.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${import_node_path2.default.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -3620,12 +3654,12 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     resolvedCss: options.resolvedCss || ""
     // ← ensure always passed
   });
-  const twClassesDir = path9__namespace.default.join(path9__namespace.default.dirname(safelistPath), "tw-classes");
-  fs3__namespace.default.mkdirSync(twClassesDir, { recursive: true });
-  const stateFilePath = path9__namespace.default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+  const twClassesDir = import_node_path2.default.join(import_node_path2.default.dirname(safelistPath), "tw-classes");
+  import_node_fs2.default.mkdirSync(twClassesDir, { recursive: true });
+  const stateFilePath = import_node_path2.default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
   if (result.rulesGenerated === 0) {
     try {
-      fs3__namespace.default.writeFileSync(
+      import_node_fs2.default.writeFileSync(
         stateFilePath,
         "/* tw-state-static.css \u2014 tidak ada state rules yang di-generate */\n",
         "utf-8"
@@ -3635,7 +3669,7 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     return `[tw:static-state] tidak ada state rules yang di-generate (${result.filesScanned} files di-scan)`;
   }
   try {
-    fs3__namespace.default.writeFileSync(stateFilePath, result.generatedCss, "utf-8");
+    import_node_fs2.default.writeFileSync(stateFilePath, result.generatedCss, "utf-8");
     return [
       `[tw:static-state] ${result.rulesGenerated} static state rules di-generate`,
       `  \u2192 ${result.filesScanned} files scanned, ${result.filesWithStates} dengan states`,
@@ -3647,15 +3681,20 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     return `[tw:static-state] gagal tulis state CSS: ${msg}`;
   }
 }
-var SOURCE_EXTENSIONS, IGNORE_PATTERNS, _native, TW_STATE_STATIC_FILENAME;
+var import_node_fs2, import_node_path2, SOURCE_EXTENSIONS, IGNORE_PATTERNS, _native, TW_STATE_STATIC_FILENAME;
 var init_staticStateExtractor = __esm({
   "packages/domain/shared/src/staticStateExtractor.ts"() {
+    "use strict";
+    import_node_fs2 = __toESM(require("fs"));
+    import_node_path2 = __toESM(require("path"));
     SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"]);
     IGNORE_PATTERNS = ["node_modules", ".next", "dist", "build", ".git", "coverage", "__tests__"];
     _native = null;
     TW_STATE_STATIC_FILENAME = "_tw-state-static.css";
   }
 });
+
+// packages/domain/shared/src/logger.ts
 function getEnvLevel() {
   const env = process.env.TWS_LOG_LEVEL?.toLowerCase();
   if (env && env in LEVELS) return env;
@@ -3665,8 +3704,8 @@ function setGlobalLogFile(filePath) {
   _globalLogFile = filePath;
   _logFileInitialized = false;
   try {
-    fs3__namespace.default.mkdirSync(path9__namespace.default.dirname(filePath), { recursive: true });
-    fs3__namespace.default.writeFileSync(
+    import_node_fs3.default.mkdirSync(import_node_path3.default.dirname(filePath), { recursive: true });
+    import_node_fs3.default.writeFileSync(
       filePath,
       `# tailwind-styled build log \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
 `,
@@ -3679,13 +3718,13 @@ function setGlobalLogFile(filePath) {
 function writeToFile(line) {
   if (!_globalLogFile || !_logFileInitialized) return;
   try {
-    fs3__namespace.default.appendFileSync(_globalLogFile, line);
+    import_node_fs3.default.appendFileSync(_globalLogFile, line);
   } catch {
   }
 }
 function createLogger(prefix, level) {
   const loggerState = {
-    currentLevel: getEnvLevel(),
+    currentLevel: level ?? getEnvLevel(),
     setLevel(l) {
       this.currentLevel = l;
     }
@@ -3706,13 +3745,16 @@ function createLogger(prefix, level) {
     setLogFile: (filePath) => setGlobalLogFile(filePath)
   };
 }
-var LEVELS, _globalLogFile, _logFileInitialized;
+var import_node_fs3, import_node_path3, LEVELS, _globalLogFile, _logFileInitialized, logger;
 var init_logger = __esm({
   "packages/domain/shared/src/logger.ts"() {
+    "use strict";
+    import_node_fs3 = __toESM(require("fs"));
+    import_node_path3 = __toESM(require("path"));
     LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
     _globalLogFile = null;
     _logFileInitialized = false;
-    createLogger("tailwind-styled");
+    logger = createLogger("tailwind-styled");
   }
 });
 
@@ -3833,9 +3875,9 @@ function loadNativeBinding(options) {
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
   for (const candidate of candidates) {
-    const candidatePath = path9__namespace.default.resolve(runtimeDir, candidate);
+    const candidatePath = import_node_path4.default.resolve(runtimeDir, candidate);
     try {
-      if (!fs3__namespace.default.existsSync(candidatePath) && !fs3__namespace.default.existsSync(candidatePath + ".node")) {
+      if (!import_node_fs4.default.existsSync(candidatePath) && !import_node_fs4.default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -3867,9 +3909,9 @@ function resolveNativeBindingCandidates(options) {
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs3__namespace.default.existsSync(runtimeDir)) {
+  if (import_node_fs4.default.existsSync(runtimeDir)) {
     try {
-      for (const entry of fs3__namespace.default.readdirSync(runtimeDir)) {
+      for (const entry of import_node_fs4.default.readdirSync(runtimeDir)) {
         if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
@@ -3878,28 +3920,28 @@ function resolveNativeBindingCandidates(options) {
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const napiPlatform = process.platform === "linux" && process.arch === "x64" ? "linux-x64-gnu" : process.platform === "linux" && process.arch === "arm64" ? "linux-arm64-gnu" : `${process.platform}-${process.arch}`;
   for (const bin of BINARY_NAMES) {
-    candidates.push(path9__namespace.default.resolve(runtimeDir, `${bin}.node`));
-    candidates.push(path9__namespace.default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
-    candidates.push(path9__namespace.default.resolve(runtimeDir, "..", "native", `${bin}.node`));
-    candidates.push(path9__namespace.default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path9__namespace.default.resolve(process.cwd(), "native", `${bin}.node`));
-    candidates.push(path9__namespace.default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
-    candidates.push(path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(import_node_path4.default.resolve(runtimeDir, `${bin}.node`));
+    candidates.push(import_node_path4.default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(import_node_path4.default.resolve(runtimeDir, "..", "native", `${bin}.node`));
+    candidates.push(import_node_path4.default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(import_node_path4.default.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(import_node_path4.default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(import_node_path4.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
+    candidates.push(import_node_path4.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(import_node_path4.default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
   }
   return Array.from(new Set(candidates));
 }
 function resolveRuntimeDir(dir, importMetaUrl) {
-  if (dir) return path9__namespace.default.resolve(dir);
+  if (dir) return import_node_path4.default.resolve(dir);
   try {
-    return path9__namespace.default.dirname(url.fileURLToPath(importMetaUrl));
+    return import_node_path4.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
   } catch {
     return process.cwd();
   }
 }
 function hashContent2(content, algorithm = "md5", length) {
-  const hash = crypto.createHash(algorithm).update(content).digest("hex");
+  const hash = (0, import_node_crypto.createHash)(algorithm).update(content).digest("hex");
   return length ? hash.slice(0, length) : hash;
 }
 function formatErrorMessage(error) {
@@ -3907,9 +3949,15 @@ function formatErrorMessage(error) {
   if (error instanceof Error) return error.message;
   return String(error);
 }
-var TwError, _require3, LRUCache;
+var import_node_crypto, import_node_fs4, import_node_path4, import_node_url, import_node_module5, import_meta7, TwError, _require3, LRUCache;
 var init_src2 = __esm({
   "packages/domain/shared/src/index.ts"() {
+    "use strict";
+    import_node_crypto = require("crypto");
+    import_node_fs4 = __toESM(require("fs"));
+    import_node_path4 = __toESM(require("path"));
+    import_node_url = require("url");
+    import_node_module5 = require("module");
     init_trace();
     init_error_codes();
     init_compatibility();
@@ -3923,6 +3971,7 @@ var init_src2 = __esm({
     init_observability();
     init_staticStateExtractor();
     init_logger();
+    import_meta7 = {};
     TwError = class _TwError extends Error {
       /** @deprecated Gunakan source */
       domain;
@@ -3975,7 +4024,7 @@ var init_src2 = __esm({
         return `[${this.source.toUpperCase()}:${this.code}] ${this.message}`;
       }
     };
-    _require3 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)));
+    _require3 = (0, import_node_module5.createRequire)(import_meta7.url);
     LRUCache = class {
       capacity;
       cache;
@@ -4053,8 +4102,8 @@ function getDirname2() {
   if (typeof __dirname !== "undefined") {
     return __dirname;
   }
-  if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)) }) !== "undefined" && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href))) {
-    return path9__namespace.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href))));
+  if (typeof import_meta8 !== "undefined" && import_meta8.url) {
+    return import_node_path5.default.dirname((0, import_node_url2.fileURLToPath)(import_meta8.url));
   }
   return process.cwd();
 }
@@ -4259,13 +4308,17 @@ function hasNativeWatchBinding() {
     return false;
   }
 }
-var log2, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
+var import_node_path5, import_node_url2, import_meta8, log2, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
 var init_native_bridge = __esm({
   "packages/domain/scanner/src/native-bridge.ts"() {
+    "use strict";
+    import_node_path5 = __toESM(require("path"), 1);
+    import_node_url2 = require("url");
     init_src2();
+    import_meta8 = {};
     log2 = createDebugLogger("scanner:native");
-    isValidScannerBinding = (module) => {
-      const candidate = module;
+    isValidScannerBinding = (module2) => {
+      const candidate = module2;
       return !!(candidate && (candidate.scanWorkspace || candidate.extractClassesFromSource || candidate.hashFileContent || candidate.cacheRead || candidate.cacheWrite));
     };
     createScannerBridgeLoader = () => {
@@ -4342,13 +4395,15 @@ var init_native_bridge = __esm({
     resetScannerBridgeCache = scannerBridgeLoader.reset;
   }
 });
+
+// packages/domain/scanner/src/cache-native.ts
 function defaultCachePath(rootDir, cacheDir) {
-  const dir = cacheDir ? path9__namespace.default.resolve(rootDir, cacheDir) : path9__namespace.default.join(process.cwd(), ".cache", "tailwind-styled");
-  return path9__namespace.default.join(dir, "scanner-cache.json");
+  const dir = cacheDir ? import_node_path6.default.resolve(rootDir, cacheDir) : import_node_path6.default.join(process.cwd(), ".cache", "tailwind-styled");
+  return import_node_path6.default.join(dir, "scanner-cache.json");
 }
 function readCache(rootDir, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs3__namespace.default.mkdirSync(path9__namespace.default.dirname(cachePath), { recursive: true });
+  import_node_fs5.default.mkdirSync(import_node_path6.default.dirname(cachePath), { recursive: true });
   const result = cacheReadNative(cachePath);
   if (!result) return [];
   return result.entries.map((e) => ({
@@ -4363,7 +4418,7 @@ function readCache(rootDir, cacheDir) {
 }
 function writeCache(rootDir, entries, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs3__namespace.default.mkdirSync(path9__namespace.default.dirname(cachePath), { recursive: true });
+  import_node_fs5.default.mkdirSync(import_node_path6.default.dirname(cachePath), { recursive: true });
   const success = cacheWriteNative(cachePath, entries);
   if (!success) {
     throw new Error(
@@ -4382,11 +4437,18 @@ function filePriority(mtimeMs, size, cached, nowMs = Date.now()) {
     nowMs
   );
 }
+var import_node_fs5, import_node_path6, STALE_THRESHOLD_MS;
 var init_cache_native = __esm({
   "packages/domain/scanner/src/cache-native.ts"() {
+    "use strict";
+    import_node_fs5 = __toESM(require("fs"), 1);
+    import_node_path6 = __toESM(require("path"), 1);
     init_native_bridge();
+    STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
   }
 });
+
+// packages/domain/scanner/src/parallel-scanner.ts
 function collectFiles2(rootDir, extensions, ignoreDirs) {
   const native = collectFilesNative(rootDir, extensions, ignoreDirs);
   if (native !== null) return native;
@@ -4404,7 +4466,7 @@ function mergeResults(batchResults) {
 }
 function runChunkInWorker(filePaths) {
   return new Promise((resolve2, reject) => {
-    const worker = new worker_threads.Worker(_workerFilename, {
+    const worker = new import_node_worker_threads.Worker(_workerFilename, {
       workerData: { filePaths }
     });
     worker.once("message", (payload) => {
@@ -4424,10 +4486,10 @@ async function scanWorkspaceParallel(rootDir, options = {}) {
   const {
     extensions = DEFAULT_EXTENSIONS,
     ignoreDirs = DEFAULT_IGNORES,
-    maxWorkers = Math.max(1, os.availableParallelism() - 1),
+    maxWorkers = Math.max(1, (0, import_node_os.availableParallelism)() - 1),
     chunkSize = DEFAULT_CHUNK_SIZE
   } = options;
-  const files = collectFiles2(path9__namespace.default.resolve(rootDir), extensions, ignoreDirs);
+  const files = collectFiles2(import_node_path7.default.resolve(rootDir), extensions, ignoreDirs);
   if (files.length < PARALLEL_THRESHOLD) {
     return mergeResults(batchExtractClassesNative2(files));
   }
@@ -4443,33 +4505,43 @@ async function scanWorkspaceParallel(rootDir, options = {}) {
   }
   return mergeResults(allResults);
 }
-var PARALLEL_THRESHOLD, DEFAULT_CHUNK_SIZE, _workerFilename;
+var import_node_worker_threads, import_node_path7, import_node_os, import_node_url3, import_meta9, PARALLEL_THRESHOLD, DEFAULT_CHUNK_SIZE, _workerFilename;
 var init_parallel_scanner = __esm({
   "packages/domain/scanner/src/parallel-scanner.ts"() {
+    "use strict";
+    import_node_worker_threads = require("worker_threads");
+    import_node_path7 = __toESM(require("path"), 1);
+    import_node_os = require("os");
+    import_node_url3 = require("url");
     init_src3();
     init_native_bridge();
+    import_meta9 = {};
     PARALLEL_THRESHOLD = 50;
     DEFAULT_CHUNK_SIZE = 150;
-    if (!worker_threads.isMainThread && worker_threads.parentPort) {
-      const { filePaths } = worker_threads.workerData;
+    if (!import_node_worker_threads.isMainThread && import_node_worker_threads.parentPort) {
+      const { filePaths } = import_node_worker_threads.workerData;
       try {
         const results = batchExtractClassesNative2(filePaths);
         const msg = { ok: true, results };
-        worker_threads.parentPort.postMessage(msg);
+        import_node_worker_threads.parentPort.postMessage(msg);
       } catch (error) {
         const msg = {
           ok: false,
           error: error instanceof Error ? error.message : String(error)
         };
-        worker_threads.parentPort.postMessage(msg);
+        import_node_worker_threads.parentPort.postMessage(msg);
       }
     }
-    _workerFilename = typeof __filename !== "undefined" ? __filename : url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)));
+    _workerFilename = typeof __filename !== "undefined" ? __filename : (0, import_node_url3.fileURLToPath)(import_meta9.url);
   }
 });
-var formatIssuePath2, formatIssues, parseWithSchema, NonNegativeIntegerSchema, ScanWorkspaceOptionsSchema, ScanFileResultSchema, ScanWorkspaceResultSchema, ScannerWorkerSuccessMessageSchema, ScannerWorkerErrorMessageSchema, ScannerWorkerMessageSchema, parseScanWorkspaceOptions, parseScanWorkspaceResult, parseScannerWorkerMessage;
+
+// packages/domain/scanner/src/schemas.ts
+var import_zod3, formatIssuePath2, formatIssues, parseWithSchema, NonNegativeIntegerSchema, ScanWorkspaceOptionsSchema, ScanFileResultSchema, ScanWorkspaceResultSchema, ScannerWorkerRequestSchema, ScannerWorkerSuccessMessageSchema, ScannerWorkerErrorMessageSchema, ScannerWorkerMessageSchema, parseScanWorkspaceOptions, parseScanWorkspaceResult, parseScannerWorkerMessage;
 var init_schemas = __esm({
   "packages/domain/scanner/src/schemas.ts"() {
+    "use strict";
+    import_zod3 = require("zod");
     init_src2();
     formatIssuePath2 = (path16) => path16.length > 0 ? path16.map(
       (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
@@ -4489,40 +4561,40 @@ var init_schemas = __esm({
         parsed.error
       );
     };
-    NonNegativeIntegerSchema = zod.z.number().int().min(0);
-    ScanWorkspaceOptionsSchema = zod.z.object({
-      includeExtensions: zod.z.array(zod.z.string()).optional(),
-      ignoreDirectories: zod.z.array(zod.z.string()).optional(),
-      useCache: zod.z.boolean().optional(),
-      cacheDir: zod.z.string().min(1).optional(),
-      smartInvalidation: zod.z.boolean().optional()
+    NonNegativeIntegerSchema = import_zod3.z.number().int().min(0);
+    ScanWorkspaceOptionsSchema = import_zod3.z.object({
+      includeExtensions: import_zod3.z.array(import_zod3.z.string()).optional(),
+      ignoreDirectories: import_zod3.z.array(import_zod3.z.string()).optional(),
+      useCache: import_zod3.z.boolean().optional(),
+      cacheDir: import_zod3.z.string().min(1).optional(),
+      smartInvalidation: import_zod3.z.boolean().optional()
     });
-    ScanFileResultSchema = zod.z.object({
-      file: zod.z.string(),
-      classes: zod.z.array(zod.z.string()),
-      hash: zod.z.string().optional()
+    ScanFileResultSchema = import_zod3.z.object({
+      file: import_zod3.z.string(),
+      classes: import_zod3.z.array(import_zod3.z.string()),
+      hash: import_zod3.z.string().optional()
     });
-    ScanWorkspaceResultSchema = zod.z.object({
-      files: zod.z.array(ScanFileResultSchema),
+    ScanWorkspaceResultSchema = import_zod3.z.object({
+      files: import_zod3.z.array(ScanFileResultSchema),
       totalFiles: NonNegativeIntegerSchema,
-      uniqueClasses: zod.z.array(zod.z.string())
+      uniqueClasses: import_zod3.z.array(import_zod3.z.string())
     }).refine((value) => value.totalFiles === value.files.length, {
       message: "scan result totalFiles must match files.length",
       path: ["totalFiles"]
     });
-    zod.z.object({
-      rootDir: zod.z.string().min(1),
+    ScannerWorkerRequestSchema = import_zod3.z.object({
+      rootDir: import_zod3.z.string().min(1),
       options: ScanWorkspaceOptionsSchema.optional()
     });
-    ScannerWorkerSuccessMessageSchema = zod.z.object({
-      ok: zod.z.literal(true),
+    ScannerWorkerSuccessMessageSchema = import_zod3.z.object({
+      ok: import_zod3.z.literal(true),
       result: ScanWorkspaceResultSchema
     });
-    ScannerWorkerErrorMessageSchema = zod.z.object({
-      ok: zod.z.literal(false),
-      error: zod.z.string().optional()
+    ScannerWorkerErrorMessageSchema = import_zod3.z.object({
+      ok: import_zod3.z.literal(false),
+      error: import_zod3.z.string().optional()
     });
-    ScannerWorkerMessageSchema = zod.z.union([
+    ScannerWorkerMessageSchema = import_zod3.z.union([
       ScannerWorkerSuccessMessageSchema,
       ScannerWorkerErrorMessageSchema
     ]);
@@ -4552,8 +4624,8 @@ function getRuntimeDir() {
   if (typeof __dirname !== "undefined" && __dirname.length > 0) {
     return __dirname;
   }
-  if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)) }) !== "undefined" && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href))) {
-    return path9__namespace.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href))));
+  if (typeof import_meta10 !== "undefined" && import_meta10.url) {
+    return import_node_path8.default.dirname((0, import_node_url4.fileURLToPath)(import_meta10.url));
   }
   return process.cwd();
 }
@@ -4562,18 +4634,18 @@ function resolveScannerWorkerModulePath() {
     if (typeof __dirname !== "undefined" && __dirname.length > 0) {
       return __dirname;
     }
-    if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)) }) !== "undefined" && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href))) {
-      return path9__namespace.default.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href))));
+    if (typeof import_meta10 !== "undefined" && import_meta10.url) {
+      return import_node_path8.default.dirname((0, import_node_url4.fileURLToPath)(import_meta10.url));
     }
     return process.cwd();
   })();
   const candidates = [
-    path9__namespace.default.resolve(runtimeDir, "worker.cjs"),
-    path9__namespace.default.resolve(runtimeDir, "worker.js"),
-    path9__namespace.default.resolve(runtimeDir, "worker.ts")
+    import_node_path8.default.resolve(runtimeDir, "worker.cjs"),
+    import_node_path8.default.resolve(runtimeDir, "worker.js"),
+    import_node_path8.default.resolve(runtimeDir, "worker.ts")
   ];
   for (const candidate of candidates) {
-    if (fs3__namespace.default.existsSync(candidate)) return candidate;
+    if (import_node_fs6.default.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -4585,7 +4657,7 @@ function scanWorkspaceInWorker(rootDir, options) {
   }
   return new Promise((resolve2, reject) => {
     const settleState = { settled: false };
-    const worker = new worker_threads.Worker(modulePath, { workerData: { rootDir, options: normalizedOptions } });
+    const worker = new import_node_worker_threads2.Worker(modulePath, { workerData: { rootDir, options: normalizedOptions } });
     const timeout = setTimeout(() => {
       if (!settleState.settled) {
         settleState.settled = true;
@@ -4630,19 +4702,19 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs3__namespace.default.readdirSync(currentDir, { withFileTypes: true });
+        return import_node_fs6.default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
     })();
     for (const entry of entries) {
-      const fullPath = path9__namespace.default.join(currentDir, entry.name);
+      const fullPath = import_node_path8.default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (!ignoreDirectories.has(entry.name)) directories.push(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
-      if (!extensionSet.has(path9__namespace.default.extname(entry.name))) continue;
+      if (!extensionSet.has(import_node_path8.default.extname(entry.name))) continue;
       candidates.push(fullPath);
     }
   }
@@ -4669,7 +4741,7 @@ function scanSource(source) {
   );
 }
 function isScannableFile2(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
-  return includeExtensions.includes(path9__namespace.default.extname(filePath));
+  return includeExtensions.includes(import_node_path8.default.extname(filePath));
 }
 function scanFile2(filePath) {
   const { scanFileNative: scanFileNative3 } = (init_native_bridge(), __toCommonJS(native_bridge_exports));
@@ -4689,7 +4761,7 @@ function scanWorkspace2(rootDir, options = {}) {
   const extensionSet = buildExtensionSet(includeExtensions);
   const ignoreDirectories = new Set(normalizedOptions.ignoreDirectories ?? DEFAULT_IGNORES);
   const useCache = normalizedOptions.useCache ?? true;
-  normalizedOptions.smartInvalidation ?? true;
+  const _smartInvalidation = normalizedOptions.smartInvalidation ?? true;
   const files = [];
   const unique = /* @__PURE__ */ new Set();
   const candidates = collectCandidates(rootDir, ignoreDirectories, extensionSet);
@@ -4729,7 +4801,7 @@ function scanWorkspace2(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs3__namespace.default.statSync(filePath);
+          return import_node_fs6.default.statSync(filePath);
         } catch {
           return null;
         }
@@ -4755,7 +4827,7 @@ function scanWorkspace2(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs3__namespace.default.readFileSync(filePath, "utf8");
+          return import_node_fs6.default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -4836,9 +4908,15 @@ async function scanWorkspaceAsync(rootDir, options = {}) {
     return scanWorkspace2(rootDir, normalizedOptions);
   }
 }
-var log3, SCAN_WORKER_TIMEOUT_MS, createNativeParserLoader, nativeParserLoader, DEFAULT_EXTENSIONS, DEFAULT_IGNORES;
+var import_node_fs6, import_node_module6, import_node_path8, import_node_url4, import_node_worker_threads2, import_meta10, log3, SCAN_WORKER_TIMEOUT_MS, createNativeParserLoader, nativeParserLoader, DEFAULT_EXTENSIONS, DEFAULT_IGNORES;
 var init_src3 = __esm({
   "packages/domain/scanner/src/index.ts"() {
+    "use strict";
+    import_node_fs6 = __toESM(require("fs"), 1);
+    import_node_module6 = require("module");
+    import_node_path8 = __toESM(require("path"), 1);
+    import_node_url4 = require("url");
+    import_node_worker_threads2 = require("worker_threads");
     init_src2();
     init_cache_native();
     init_native_bridge();
@@ -4846,6 +4924,7 @@ var init_src3 = __esm({
     init_schemas();
     init_schemas();
     init_native_bridge();
+    import_meta10 = {};
     log3 = createLogger2("scanner");
     SCAN_WORKER_TIMEOUT_MS = 12e4;
     createNativeParserLoader = () => {
@@ -4859,7 +4938,7 @@ var init_src3 = __esm({
       const loadNativeParserBinding = () => {
         if (_state.binding !== void 0) return _state.binding;
         const runtimeDir = getRuntimeDir();
-        const req = module$1.createRequire(path9__namespace.default.join(runtimeDir, "noop.cjs"));
+        const req = (0, import_node_module6.createRequire)(import_node_path8.default.join(runtimeDir, "noop.cjs"));
         const _platform = process.platform;
         const _arch = process.arch;
         const _platformArch = `${_platform}-${_arch}`;
@@ -4867,27 +4946,27 @@ var init_src3 = __esm({
         const candidates = [
           // ── binaryName baru: tailwind-styled-native (napi-rs naming) ──
           // cwd = repo root saat run dari root, atau package dir saat workspaces
-          path9__namespace.default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
-          path9__namespace.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
-          path9__namespace.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          import_node_path8.default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+          import_node_path8.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
+          import_node_path8.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // runtimeDir = dist/ → naik 1 level ke package root (npm install case)
           // e.g. node_modules/tailwind-styled-v4/dist/ → node_modules/tailwind-styled-v4/native/
-          path9__namespace.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
-          path9__namespace.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
-          path9__namespace.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          import_node_path8.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+          import_node_path8.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
+          import_node_path8.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // runtimeDir = dist/ → naik 4 level ke repo root (monorepo dev case)
-          path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
-          path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+          import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // 3 level fallback (jika package di-nest lebih dangkal)
-          path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
-          path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+          import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // ── binaryName lama: tailwind_styled_parser (backward compat) ──
-          path9__namespace.default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
-          path9__namespace.default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
-          path9__namespace.default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
-          path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
-          path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
-          path9__namespace.default.resolve(
+          import_node_path8.default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
+          import_node_path8.default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
+          import_node_path8.default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
+          import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+          import_node_path8.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
+          import_node_path8.default.resolve(
             runtimeDir,
             "..",
             "..",
@@ -4899,7 +4978,7 @@ var init_src3 = __esm({
           )
         ];
         for (const fullPath of candidates) {
-          if (!fs3__namespace.default.existsSync(fullPath)) continue;
+          if (!import_node_fs6.default.existsSync(fullPath)) continue;
           try {
             const required = req(fullPath);
             if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
@@ -4935,21 +5014,23 @@ var init_src3 = __esm({
 // packages/domain/engine/src/native-bridge.ts
 function getDirname3() {
   if (typeof __dirname !== "undefined") return __dirname;
-  if (typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)) }) !== "undefined" && (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href))) {
-    return getDirname((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)));
+  if (typeof import_meta12 !== "undefined" && import_meta12.url) {
+    return getDirname(import_meta12.url);
   }
   return process.cwd();
 }
 function getNativeEngineBinding() {
   return engineBindingLoader.get();
 }
-var log4, isValidEngineBinding, createEngineBindingLoader, engineBindingLoader;
+var import_meta12, log4, isValidEngineBinding, createEngineBindingLoader, engineBindingLoader;
 var init_native_bridge2 = __esm({
   "packages/domain/engine/src/native-bridge.ts"() {
+    "use strict";
     init_src2();
+    import_meta12 = {};
     log4 = createDebugLogger("engine:native");
-    isValidEngineBinding = (module) => {
-      const candidate = module;
+    isValidEngineBinding = (module2) => {
+      const candidate = module2;
       return !!(candidate && (candidate.computeIncrementalDiff || candidate.processFileChange || candidate.hashFileContent));
     };
     createEngineBindingLoader = () => {
@@ -5066,11 +5147,12 @@ function createResolutionReason(causes, finalDecision) {
     finalDecision
   };
 }
-exports.RuleId = void 0; exports.SelectorId = void 0; exports.VariantChainId = void 0; exports.PropertyId = void 0; exports.ValueId = void 0; exports.LayerId = void 0; exports.ConditionId = void 0; exports.CascadeResolutionId = void 0; exports.Origin = void 0; exports.Importance = void 0; exports.ConditionResult = void 0; exports.CascadeStage = void 0;
+var RuleId, SelectorId, VariantChainId, PropertyId, ValueId, LayerId, ConditionId, CascadeResolutionId, Origin, Importance, ConditionResult, CascadeStage;
 var init_ir = __esm({
   "packages/domain/engine/src/ir.ts"() {
+    "use strict";
     init_native_bridge2();
-    exports.RuleId = class {
+    RuleId = class {
       constructor(value) {
         this.value = value;
       }
@@ -5079,7 +5161,7 @@ var init_ir = __esm({
         return `R${this.value}`;
       }
     };
-    exports.SelectorId = class {
+    SelectorId = class {
       constructor(value) {
         this.value = value;
       }
@@ -5088,7 +5170,7 @@ var init_ir = __esm({
         return `S${this.value}`;
       }
     };
-    exports.VariantChainId = class {
+    VariantChainId = class {
       constructor(value) {
         this.value = value;
       }
@@ -5097,7 +5179,7 @@ var init_ir = __esm({
         return `V${this.value}`;
       }
     };
-    exports.PropertyId = class {
+    PropertyId = class {
       constructor(value, name) {
         this.value = value;
         this.name = name;
@@ -5112,7 +5194,7 @@ var init_ir = __esm({
         return propertyIdToString2(this);
       }
     };
-    exports.ValueId = class {
+    ValueId = class {
       constructor(value, name) {
         this.value = value;
         this.name = name;
@@ -5127,7 +5209,7 @@ var init_ir = __esm({
         return valueIdToString2(this);
       }
     };
-    exports.LayerId = class {
+    LayerId = class {
       constructor(value) {
         this.value = value;
       }
@@ -5136,7 +5218,7 @@ var init_ir = __esm({
         return `L${this.value}`;
       }
     };
-    exports.ConditionId = class {
+    ConditionId = class {
       constructor(value) {
         this.value = value;
       }
@@ -5145,7 +5227,7 @@ var init_ir = __esm({
         return `C${this.value}`;
       }
     };
-    exports.CascadeResolutionId = class {
+    CascadeResolutionId = class {
       constructor(value) {
         this.value = value;
       }
@@ -5154,40 +5236,40 @@ var init_ir = __esm({
         return `R${this.value}`;
       }
     };
-    exports.Origin = /* @__PURE__ */ ((Origin2) => {
+    Origin = /* @__PURE__ */ ((Origin2) => {
       Origin2[Origin2["UserAgent"] = 0] = "UserAgent";
       Origin2[Origin2["UserNormal"] = 1] = "UserNormal";
       Origin2[Origin2["AuthorNormal"] = 2] = "AuthorNormal";
       Origin2[Origin2["AuthorImportant"] = 3] = "AuthorImportant";
       Origin2[Origin2["UserImportant"] = 4] = "UserImportant";
       return Origin2;
-    })(exports.Origin || {});
-    exports.Importance = /* @__PURE__ */ ((Importance2) => {
+    })(Origin || {});
+    Importance = /* @__PURE__ */ ((Importance2) => {
       Importance2[Importance2["Normal"] = 0] = "Normal";
       Importance2[Importance2["Important"] = 1] = "Important";
       return Importance2;
-    })(exports.Importance || {});
-    exports.ConditionResult = /* @__PURE__ */ ((ConditionResult2) => {
+    })(Importance || {});
+    ConditionResult = /* @__PURE__ */ ((ConditionResult2) => {
       ConditionResult2[ConditionResult2["Active"] = 0] = "Active";
       ConditionResult2[ConditionResult2["Inactive"] = 1] = "Inactive";
       ConditionResult2[ConditionResult2["Unknown"] = 2] = "Unknown";
       return ConditionResult2;
-    })(exports.ConditionResult || {});
-    exports.CascadeStage = /* @__PURE__ */ ((CascadeStage2) => {
+    })(ConditionResult || {});
+    CascadeStage = /* @__PURE__ */ ((CascadeStage2) => {
       CascadeStage2[CascadeStage2["Origin"] = 0] = "Origin";
       CascadeStage2[CascadeStage2["Layer"] = 1] = "Layer";
       CascadeStage2[CascadeStage2["Importance"] = 2] = "Importance";
       CascadeStage2[CascadeStage2["Specificity"] = 3] = "Specificity";
       CascadeStage2[CascadeStage2["Order"] = 4] = "Order";
       return CascadeStage2;
-    })(exports.CascadeStage || {});
+    })(CascadeStage || {});
   }
 });
 
 // packages/domain/engine/src/resolver.ts
 var resolver_exports = {};
 __export(resolver_exports, {
-  CascadeResolver: () => exports.CascadeResolver
+  CascadeResolver: () => CascadeResolver
 });
 function toNativeInput(rule) {
   return {
@@ -5227,7 +5309,7 @@ function buildResolutionsMap(nativeResult, rules, styleGraph) {
     const existing = styleGraph.ruleConflicts.get(winner) ?? [];
     styleGraph.ruleConflicts.set(winner, [...existing, ...losers.filter((l) => !existing.some((e) => e.value === l.value))]);
     resolvedProperties.set(propertyId, {
-      id: new exports.CascadeResolutionId(res.id),
+      id: new CascadeResolutionId(res.id),
       property: propertyId,
       winner,
       losers,
@@ -5237,12 +5319,13 @@ function buildResolutionsMap(nativeResult, rules, styleGraph) {
   }
   return resolvedProperties;
 }
-exports.CascadeResolver = void 0;
+var CascadeResolver;
 var init_resolver = __esm({
   "packages/domain/engine/src/resolver.ts"() {
+    "use strict";
     init_ir();
     init_native_bridge2();
-    exports.CascadeResolver = class {
+    CascadeResolver = class {
       rules = /* @__PURE__ */ new Map();
       classRules = /* @__PURE__ */ new Map();
       styleGraph = { ruleConflicts: /* @__PURE__ */ new Map() };
@@ -5328,20 +5411,20 @@ function createIdGenerator() {
     insertionOrderCounter: 0
   };
   return {
-    generateRuleId: () => new exports.RuleId(state.ruleIdCounter++),
-    generateSelectorId: () => new exports.SelectorId(state.selectorIdCounter++),
+    generateRuleId: () => new RuleId(state.ruleIdCounter++),
+    generateSelectorId: () => new SelectorId(state.selectorIdCounter++),
     generatePropertyId: (name) => {
-      const id = new exports.PropertyId(state.propertyIdCounter++);
+      const id = new PropertyId(state.propertyIdCounter++);
       registerPropertyName2(id, name);
       return id;
     },
     generateValueId: (name) => {
-      const id = new exports.ValueId(state.valueIdCounter++);
+      const id = new ValueId(state.valueIdCounter++);
       registerValueName2(id, name);
       return id;
     },
-    generateLayerId: () => new exports.LayerId(state.layerIdCounter++),
-    generateConditionId: () => new exports.ConditionId(state.conditionIdCounter++),
+    generateLayerId: () => new LayerId(state.layerIdCounter++),
+    generateConditionId: () => new ConditionId(state.conditionIdCounter++),
     getNextInsertionOrder: () => state.insertionOrderCounter++,
     reset: () => {
       state.ruleIdCounter = 0;
@@ -5379,13 +5462,13 @@ function _parseCssToIrFast(assembled) {
   layerMap.clear();
   layerOrderMap.clear();
   for (const le of assembled.layers) {
-    const lid = new exports.LayerId(le.layerId);
+    const lid = new LayerId(le.layerId);
     layerMap.set(le.name, lid);
     layerOrderMap.set(le.name, le.order);
   }
   const rules = assembled.rules.map((r) => {
-    const propertyId = new exports.PropertyId(r.propertyId);
-    const valueId = new exports.ValueId(r.valueId);
+    const propertyId = new PropertyId(r.propertyId);
+    const valueId = new ValueId(r.valueId);
     if (native?.registerPropertyName) {
       native.registerPropertyName(r.propertyId, r.propertyName);
     } else {
@@ -5397,17 +5480,17 @@ function _parseCssToIrFast(assembled) {
       registerValueName2(valueId, r.valueName);
     }
     return {
-      id: new exports.RuleId(r.ruleId),
-      selector: new exports.SelectorId(r.selectorId),
-      variantChain: new exports.VariantChainId(0),
+      id: new RuleId(r.ruleId),
+      selector: new SelectorId(r.selectorId),
+      variantChain: new VariantChainId(0),
       property: propertyId,
       value: valueId,
       origin: r.origin,
       importance: r.importance,
-      layer: r.layerId >= 0 ? new exports.LayerId(r.layerId) : null,
+      layer: r.layerId >= 0 ? new LayerId(r.layerId) : null,
       layerOrder: r.layerOrder,
       specificity: r.specificity,
-      condition: r.conditionId >= 0 ? new exports.ConditionId(r.conditionId) : null,
+      condition: r.conditionId >= 0 ? new ConditionId(r.conditionId) : null,
       conditionResult: r.conditionResult,
       insertionOrder: r.insertionOrder,
       fingerprint: r.fingerprint,
@@ -5417,7 +5500,7 @@ function _parseCssToIrFast(assembled) {
   const classToRuleIds = new Map(
     assembled.classToRuleIds.map((m) => [
       m.className,
-      m.ruleIds.map((id) => new exports.RuleId(id))
+      m.ruleIds.map((id) => new RuleId(id))
     ])
   );
   return { rules, classToRuleIds };
@@ -5434,7 +5517,7 @@ function _parseCssToIrFallback(css, prefix, native) {
   const parsed = native.parseCssRules(css);
   for (const r of parsed) {
     const className = prefix + r.className;
-    r.variants.length > 0;
+    const hasVariants = r.variants.length > 0;
     const layerName = detectLayerFromClassName(className);
     const layer = layerName ? getOrCreateLayerId(layerName) : null;
     const layerOrder = layerName ? layerOrderMap.get(layerName) ?? 4 : 4;
@@ -5449,7 +5532,7 @@ function _parseCssToIrFallback(css, prefix, native) {
     const rule = {
       id: ruleId,
       selector: selectorId,
-      variantChain: new exports.VariantChainId(0),
+      variantChain: new VariantChainId(0),
       property: propertyId,
       value: valueId,
       origin: 2 /* AuthorNormal */,
@@ -5473,6 +5556,7 @@ function _parseCssToIrFallback(css, prefix, native) {
 var _defaultIdGen, generateRuleId, generateSelectorId, generatePropertyId, generateValueId, generateLayerId, generateConditionId, getNextInsertionOrder, resetIdGenerator, layerMap, layerOrderMap, LAYER_ORDER;
 var init_cssToIr = __esm({
   "packages/domain/engine/src/cssToIr.ts"() {
+    "use strict";
     init_native_bridge2();
     init_ir();
     _defaultIdGen = createIdGenerator();
@@ -5578,7 +5662,7 @@ function trace(className, resolver) {
           property,
           winner: winnerRule?.value.toString() ?? "",
           loser: loserRule.value.toString(),
-          stage: exports.CascadeStage[resolution.stage],
+          stage: CascadeStage[resolution.stage],
           causes: resolution.reason.causes.map(formatCause)
         });
       }
@@ -5605,17 +5689,77 @@ function trace(className, resolver) {
 }
 var init_trace2 = __esm({
   "packages/domain/engine/src/trace.ts"() {
+    "use strict";
     init_ir();
   }
 });
 
+// src/umbrella/engine.ts
+var engine_exports = {};
+__export(engine_exports, {
+  BuildResultSchema: () => BuildResultSchema,
+  BundleAnalyzer: () => BundleAnalyzer,
+  CascadeResolutionId: () => CascadeResolutionId,
+  CascadeResolver: () => CascadeResolver,
+  CascadeStage: () => CascadeStage,
+  ConditionId: () => ConditionId,
+  ConditionResult: () => ConditionResult,
+  EngineMetricsCollector: () => EngineMetricsCollector,
+  EngineOptionsSchema: () => EngineOptionsSchema,
+  EngineWatchOptionsSchema: () => EngineWatchOptionsSchema,
+  ImpactTracker: () => ImpactTracker,
+  Importance: () => Importance,
+  LayerId: () => LayerId,
+  Origin: () => Origin,
+  PropertyId: () => PropertyId,
+  ReverseLookup: () => ReverseLookup,
+  RuleId: () => RuleId,
+  SelectorId: () => SelectorId,
+  ValueId: () => ValueId,
+  VariantChainId: () => VariantChainId,
+  analyzeWorkspace: () => analyzeWorkspace2,
+  applyIncrementalChange: () => applyIncrementalChange,
+  build: () => build,
+  buildProvenanceChain: () => buildProvenanceChain,
+  createEngine: () => createEngine,
+  createFingerprint: () => createFingerprint2,
+  createResolutionReason: () => createResolutionReason,
+  generateSafelist: () => generateSafelist2,
+  inspectClass: () => inspectClass,
+  parseCssToIr: () => parseCssToIr,
+  parseEngineOptions: () => parseEngineOptions,
+  parseEngineWatchOptions: () => parseEngineWatchOptions,
+  runAfterBuild: () => runAfterBuild,
+  runAfterScan: () => runAfterScan,
+  runAfterWatch: () => runAfterWatch,
+  runBeforeBuild: () => runBeforeBuild,
+  runBeforeScan: () => runBeforeScan,
+  runBeforeWatch: () => runBeforeWatch,
+  runOnError: () => runOnError,
+  runTransformClasses: () => runTransformClasses,
+  scanWorkspace: () => scanWorkspace3,
+  trace: () => trace,
+  traceClass: () => traceClass,
+  traceClasses: () => traceClasses,
+  watchWorkspaceLegacy: () => watchWorkspace,
+  watchWorkspaceNative: () => watchWorkspace2
+});
+module.exports = __toCommonJS(engine_exports);
+
+// packages/domain/engine/src/index.ts
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
+var import_node_url6 = require("url");
+
 // packages/domain/analyzer/src/analyzeWorkspace.ts
+var import_node_path10 = __toESM(require("path"), 1);
 init_src3();
 
 // packages/domain/analyzer/src/binding.ts
 init_src2();
 
 // packages/domain/analyzer/src/utils.ts
+var import_node_fs7 = __toESM(require("fs"), 1);
 init_src2();
 var DEFAULT_TOP_LIMIT = 10;
 var DEFAULT_FREQUENT_THRESHOLD = 2;
@@ -5630,7 +5774,7 @@ function isRecord(value) {
 }
 async function pathExists(filePath) {
   try {
-    await fs3__namespace.default.promises.access(filePath, fs3__namespace.default.constants.F_OK);
+    await import_node_fs7.default.promises.access(filePath, import_node_fs7.default.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -5647,8 +5791,9 @@ function sanitizeFrequentThreshold(value) {
 }
 
 // packages/domain/analyzer/src/binding.ts
-var isAnalyzerModule = (module) => {
-  const candidate = module;
+var import_meta11 = {};
+var isAnalyzerModule = (module2) => {
+  const candidate = module2;
   return typeof candidate?.analyzeClasses === "function" || typeof candidate?.analyzeClassesWorkspace === "function";
 };
 var createAnalyzerBindingLoader = () => {
@@ -5658,7 +5803,7 @@ var createAnalyzerBindingLoader = () => {
     _state.bindingPromise = (async () => {
       const runtimeDir = resolveRuntimeDir(
         typeof __dirname === "string" ? __dirname : void 0,
-        (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href))
+        import_meta11.url
       );
       const candidates = resolveNativeBindingCandidates({
         runtimeDir,
@@ -5701,7 +5846,7 @@ async function requireNativeBinding() {
   if (binding?.analyzeClasses) return binding;
   const runtimeDir = resolveRuntimeDir(
     typeof __dirname === "string" ? __dirname : void 0,
-    (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href))
+    import_meta11.url
   );
   const candidates = resolveNativeBindingCandidates({
     runtimeDir,
@@ -5729,6 +5874,7 @@ async function requireNativeBinding() {
 
 // packages/domain/analyzer/src/schemas.ts
 init_src2();
+var import_zod4 = require("zod");
 var formatIssuePath3 = (path16) => path16.length > 0 ? path16.map(
   (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
 ).join(".") : "<root>";
@@ -5752,81 +5898,86 @@ var parseWithSchema2 = (schema, data, label) => {
     parsed.error
   );
 };
-var CountSchema = zod.z.number().int().min(0);
-zod.z.object({
-  name: zod.z.string(),
+var CountSchema = import_zod4.z.number().int().min(0);
+var ClassUsageSchema = import_zod4.z.object({
+  name: import_zod4.z.string(),
   count: CountSchema,
-  isUnused: zod.z.boolean().optional(),
-  isConflict: zod.z.boolean().optional()
+  isUnused: import_zod4.z.boolean().optional(),
+  isConflict: import_zod4.z.boolean().optional()
 });
-zod.z.object({
-  className: zod.z.string(),
-  variants: zod.z.array(zod.z.string()),
-  classes: zod.z.array(zod.z.string()),
-  message: zod.z.string()
+var ClassConflictSchema = import_zod4.z.object({
+  className: import_zod4.z.string(),
+  variants: import_zod4.z.array(import_zod4.z.string()),
+  classes: import_zod4.z.array(import_zod4.z.string()),
+  message: import_zod4.z.string()
 });
-var ClassCountSchema = zod.z.object({
-  name: zod.z.string(),
+var ClassCountSchema = import_zod4.z.object({
+  name: import_zod4.z.string(),
   count: CountSchema
 });
-var NativeReportSchema = zod.z.object({
-  root: zod.z.string(),
+var NativeReportSchema = import_zod4.z.object({
+  root: import_zod4.z.string(),
   totalFiles: CountSchema,
   uniqueClassCount: CountSchema,
   totalClassOccurrences: CountSchema,
-  topClasses: zod.z.array(ClassCountSchema),
-  duplicateCandidates: zod.z.array(ClassCountSchema),
-  safelist: zod.z.array(zod.z.string())
+  topClasses: import_zod4.z.array(ClassCountSchema),
+  duplicateCandidates: import_zod4.z.array(ClassCountSchema),
+  safelist: import_zod4.z.array(import_zod4.z.string())
 });
-zod.z.object({
-  css: zod.z.string(),
-  resolvedClasses: zod.z.array(zod.z.string()),
-  unknownClasses: zod.z.array(zod.z.string()),
+var NativeCssCompileResultSchema2 = import_zod4.z.object({
+  css: import_zod4.z.string(),
+  resolvedClasses: import_zod4.z.array(import_zod4.z.string()),
+  unknownClasses: import_zod4.z.array(import_zod4.z.string()),
   sizeBytes: CountSchema
 });
-var AnalyzerClassStatsSchema = zod.z.object({
-  top: zod.z.number({
+var AnalyzerClassStatsSchema = import_zod4.z.object({
+  top: import_zod4.z.number({
     error: "analyzeWorkspace options.classStats.top must be a number when provided."
   }).finite().optional(),
-  frequentThreshold: zod.z.number({
+  frequentThreshold: import_zod4.z.number({
     error: "analyzeWorkspace options.classStats.frequentThreshold must be a number when provided."
   }).finite().optional()
 });
-var AnalyzerSemanticOptionsSchema = zod.z.object({
-  tailwindConfigPath: zod.z.string({
+var AnalyzerSemanticOptionsSchema = import_zod4.z.object({
+  tailwindConfigPath: import_zod4.z.string({
     error: "analyzeWorkspace options.semantic.tailwindConfigPath must be a non-empty string when provided."
   }).min(
     1,
     "analyzeWorkspace options.semantic.tailwindConfigPath must be a non-empty string when provided."
   ).optional()
 });
-var AnalyzerOptionsSchema = zod.z.object({
-  scanner: zod.z.custom(
+var AnalyzerOptionsSchema = import_zod4.z.object({
+  scanner: import_zod4.z.custom(
     (value) => isPlainObject(value),
     "analyzeWorkspace options.scanner must be an object when provided."
   ).optional(),
   classStats: AnalyzerClassStatsSchema.optional(),
-  semantic: zod.z.union([
-    zod.z.boolean({
+  semantic: import_zod4.z.union([
+    import_zod4.z.boolean({
       error: "analyzeWorkspace options.semantic must be a boolean or an object when provided."
     }),
     AnalyzerSemanticOptionsSchema
   ]).optional(),
-  includeClass: zod.z.custom(
+  includeClass: import_zod4.z.custom(
     (value) => typeof value === "function",
     "analyzeWorkspace options.includeClass must be a function when provided."
   ).optional()
 });
-zod.z.object({
-  prefix: zod.z.union([zod.z.string(), zod.z.null()], {
+var ClassToCssOptionsSchema = import_zod4.z.object({
+  prefix: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.null()], {
     error: "classToCss options.prefix must be a string or null when provided."
   }).optional(),
-  strict: zod.z.boolean({
+  strict: import_zod4.z.boolean({
     error: "classToCss options.strict must be a boolean when provided."
   }).optional()
 });
 var parseAnalyzerOptions = (options) => parseWithSchema2(AnalyzerOptionsSchema, options ?? {}, "analyzeWorkspace options are invalid");
 var parseNativeReport = (report) => parseWithSchema2(NativeReportSchema, report, "Native analyzer report is invalid");
+
+// packages/domain/analyzer/src/semantic.ts
+var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
+var import_node_url5 = require("url");
 var SUPPORTED_TAILWIND_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".cjs", ".mjs"]);
 var tailwindConfigCache = /* @__PURE__ */ new Map();
 var detectConflicts2 = async (usages) => {
@@ -5846,11 +5997,11 @@ var detectConflicts2 = async (usages) => {
   };
 };
 var isSupportedTailwindConfigPath = (configPath) => {
-  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(path9__namespace.default.extname(configPath).toLowerCase());
+  return SUPPORTED_TAILWIND_CONFIG_EXTENSIONS.has(import_node_path9.default.extname(configPath).toLowerCase());
 };
 var resolveTailwindConfigPath = async (root, explicitPath) => {
   if (explicitPath) {
-    const resolved = path9__namespace.default.resolve(root, explicitPath);
+    const resolved = import_node_path9.default.resolve(root, explicitPath);
     if (!await pathExists(resolved)) return null;
     return resolved;
   }
@@ -5861,7 +6012,7 @@ var resolveTailwindConfigPath = async (root, explicitPath) => {
     "tailwind.config.mjs"
   ];
   for (const candidate of candidates) {
-    const fullPath = path9__namespace.default.resolve(root, candidate);
+    const fullPath = import_node_path9.default.resolve(root, candidate);
     if (await pathExists(fullPath)) return fullPath;
   }
   return null;
@@ -5915,7 +6066,7 @@ var collectCustomUtilities = (config) => {
   return out;
 };
 var collectSafelistFromSource = async (configPath) => {
-  const source = await fs3__namespace.default.promises.readFile(configPath, "utf8");
+  const source = await import_node_fs8.default.promises.readFile(configPath, "utf8");
   const { extractClassesNative: extractClassesNative2 } = await Promise.resolve().then(() => (init_src3(), src_exports2));
   const allTokens = extractClassesNative2(source);
   const hasSafelist = source.includes("safelist");
@@ -5942,7 +6093,7 @@ var loadTailwindConfig2 = async (root, semanticOption) => {
       customUtilities: /* @__PURE__ */ new Set()
     };
   }
-  const configStat = await fs3__namespace.default.promises.stat(configPath).catch(() => null);
+  const configStat = await import_node_fs8.default.promises.stat(configPath).catch(() => null);
   if (configStat) {
     const cached = tailwindConfigCache.get(configPath);
     if (cached && cached.mtimeMs === configStat.mtimeMs && cached.size === configStat.size) {
@@ -5955,7 +6106,7 @@ var loadTailwindConfig2 = async (root, semanticOption) => {
   const result = await (async () => {
     try {
       const cacheBustToken = Math.trunc(configStat?.mtimeMs ?? Date.now());
-      const imported = await import(`${url.pathToFileURL(configPath).href}?tws_mtime=${cacheBustToken}`);
+      const imported = await import(`${(0, import_node_url5.pathToFileURL)(configPath).href}?tws_mtime=${cacheBustToken}`);
       const candidate = imported.default ?? imported;
       if (isRecord(candidate)) {
         return { config: candidate, warning: void 0 };
@@ -6101,7 +6252,7 @@ async function buildDistribution(usages, native) {
 }
 async function analyzeWorkspace(root, options = {}) {
   const startedAtMs = Date.now();
-  const resolvedRoot = path9__namespace.default.resolve(root);
+  const resolvedRoot = import_node_path10.default.resolve(root);
   const normalizedOptions = parseAnalyzerOptions(options);
   const scan = await (async () => {
     const scanStartedAtMs = Date.now();
@@ -6210,6 +6361,8 @@ init_src3();
 init_src2();
 
 // packages/domain/engine/src/incremental.ts
+var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 init_src3();
 init_src2();
 init_native_bridge2();
@@ -6245,8 +6398,8 @@ function areClassSetsEqual(a, b) {
 function applyIncrementalChange(previous, filePath, type, scanner) {
   const includeExtensions = scanner?.includeExtensions ?? DEFAULT_EXTENSIONS2;
   if (!isScannableFile2(filePath, includeExtensions)) return previous;
-  const byFile = new Map(previous.files.map((f) => [path9__namespace.default.resolve(f.file), f]));
-  const normalizedPath = path9__namespace.default.resolve(filePath);
+  const byFile = new Map(previous.files.map((f) => [import_node_path11.default.resolve(f.file), f]));
+  const normalizedPath = import_node_path11.default.resolve(filePath);
   const native = getNativeEngineBinding();
   if (!native?.processFileChange) {
     throw new Error(
@@ -6262,7 +6415,7 @@ function applyIncrementalChange(previous, filePath, type, scanner) {
   }
   log5.debug(`native change ${normalizedPath}`);
   const scanned = scanFile2(normalizedPath);
-  const content = fs3__namespace.default.readFileSync(normalizedPath, "utf8");
+  const content = import_node_fs9.default.readFileSync(normalizedPath, "utf8");
   const diff = native.processFileChange(normalizedPath, scanned.classes, content);
   const existing = byFile.get(normalizedPath);
   if (diff && existing) {
@@ -6607,13 +6760,17 @@ var EngineMetricsCollector = class {
 };
 
 // packages/domain/engine/src/metricsWriter.ts
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
+var import_node_perf_hooks = require("perf_hooks");
 init_src2();
+var _log = createLogger2("tw:metrics");
 var METRICS_FILE_NAME = "metrics.json";
 var CACHE_DIR = ".tw-cache";
 function writeMetrics(metrics, cwd = process.cwd()) {
   try {
-    const cacheDir = path9__namespace.default.join(cwd, CACHE_DIR);
-    fs3__namespace.default.mkdirSync(cacheDir, { recursive: true });
+    const cacheDir = import_node_path12.default.join(cwd, CACHE_DIR);
+    import_node_fs10.default.mkdirSync(cacheDir, { recursive: true });
     const mem = process.memoryUsage();
     const data = {
       ...metrics,
@@ -6624,7 +6781,7 @@ function writeMetrics(metrics, cwd = process.cwd()) {
       },
       generatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    fs3__namespace.default.writeFileSync(path9__namespace.default.join(cacheDir, METRICS_FILE_NAME), JSON.stringify(data, null, 2));
+    import_node_fs10.default.writeFileSync(import_node_path12.default.join(cacheDir, METRICS_FILE_NAME), JSON.stringify(data, null, 2));
   } catch {
   }
 }
@@ -6676,6 +6833,9 @@ async function runAfterWatch(plugins, context) {
     await plugin.afterWatch?.(context);
   }
 }
+
+// packages/domain/engine/src/schemas.ts
+var import_zod5 = require("zod");
 var formatIssues3 = (error) => error.issues.map((issue) => {
   const p = issue.path.length > 0 ? issue.path.join(".") : "<root>";
   return `${p}: ${issue.message}`;
@@ -6685,46 +6845,46 @@ var parseWithSchema3 = (schema, data, label) => {
   if (parsed.success) return parsed.data;
   throw new TypeError(`${label}: ${formatIssues3(parsed.error)}`);
 };
-var EngineOptionsSchema = zod.z.object({
-  root: zod.z.string().optional(),
-  scanner: zod.z.object({
-    includeExtensions: zod.z.array(zod.z.string()).optional(),
-    ignoreDirectories: zod.z.array(zod.z.string()).optional(),
-    useCache: zod.z.boolean().optional(),
-    cacheDir: zod.z.string().min(1).optional(),
-    smartInvalidation: zod.z.boolean().optional()
+var EngineOptionsSchema = import_zod5.z.object({
+  root: import_zod5.z.string().optional(),
+  scanner: import_zod5.z.object({
+    includeExtensions: import_zod5.z.array(import_zod5.z.string()).optional(),
+    ignoreDirectories: import_zod5.z.array(import_zod5.z.string()).optional(),
+    useCache: import_zod5.z.boolean().optional(),
+    cacheDir: import_zod5.z.string().min(1).optional(),
+    smartInvalidation: import_zod5.z.boolean().optional()
   }).optional(),
-  compileCss: zod.z.boolean().optional(),
-  tailwindConfigPath: zod.z.string().optional(),
-  analyze: zod.z.boolean().optional(),
-  plugins: zod.z.array(zod.z.custom()).optional()
+  compileCss: import_zod5.z.boolean().optional(),
+  tailwindConfigPath: import_zod5.z.string().optional(),
+  analyze: import_zod5.z.boolean().optional(),
+  plugins: import_zod5.z.array(import_zod5.z.custom()).optional()
 });
-var EngineWatchOptionsSchema = zod.z.object({
-  debounceMs: zod.z.number().int().min(0).optional(),
-  maxEventsPerFlush: zod.z.number().int().min(1).optional(),
-  largeFileThreshold: zod.z.number().int().min(0).optional()
+var EngineWatchOptionsSchema = import_zod5.z.object({
+  debounceMs: import_zod5.z.number().int().min(0).optional(),
+  maxEventsPerFlush: import_zod5.z.number().int().min(1).optional(),
+  largeFileThreshold: import_zod5.z.number().int().min(0).optional()
 });
-var BuildResultSchema = zod.z.object({
-  scan: zod.z.object({
-    files: zod.z.array(
-      zod.z.object({ file: zod.z.string(), classes: zod.z.array(zod.z.string()), hash: zod.z.string().optional() })
+var BuildResultSchema = import_zod5.z.object({
+  scan: import_zod5.z.object({
+    files: import_zod5.z.array(
+      import_zod5.z.object({ file: import_zod5.z.string(), classes: import_zod5.z.array(import_zod5.z.string()), hash: import_zod5.z.string().optional() })
     ),
-    totalFiles: zod.z.number().int().min(0),
-    uniqueClasses: zod.z.array(zod.z.string())
+    totalFiles: import_zod5.z.number().int().min(0),
+    uniqueClasses: import_zod5.z.array(import_zod5.z.string())
   }),
-  mergedClassList: zod.z.string(),
-  css: zod.z.string(),
-  analysis: zod.z.object({
-    unusedClasses: zod.z.array(zod.z.string()),
-    classConflicts: zod.z.array(
-      zod.z.object({
-        className: zod.z.string(),
-        files: zod.z.array(zod.z.string()),
-        classes: zod.z.array(zod.z.string()).optional(),
-        message: zod.z.string().optional()
+  mergedClassList: import_zod5.z.string(),
+  css: import_zod5.z.string(),
+  analysis: import_zod5.z.object({
+    unusedClasses: import_zod5.z.array(import_zod5.z.string()),
+    classConflicts: import_zod5.z.array(
+      import_zod5.z.object({
+        className: import_zod5.z.string(),
+        files: import_zod5.z.array(import_zod5.z.string()),
+        classes: import_zod5.z.array(import_zod5.z.string()).optional(),
+        message: import_zod5.z.string().optional()
       })
     ),
-    classUsage: zod.z.record(zod.z.string(), zod.z.number())
+    classUsage: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.number())
   }).optional()
 });
 var parseEngineOptions = (options) => parseWithSchema3(EngineOptionsSchema, options ?? {}, "engine options are invalid");
@@ -6738,7 +6898,7 @@ function getNativeWatcher() {
     const { resolveNativeBinary: resolveNativeBinary2 } = (init_src2(), __toCommonJS(src_exports));
     const { path: binPath } = resolveNativeBinary2(__dirname);
     if (binPath) {
-      _native2 = __require(binPath);
+      _native2 = require(binPath);
     }
   } catch {
     _native2 = {};
@@ -6885,7 +7045,10 @@ init_resolver();
 init_cssToIr();
 
 // packages/domain/engine/src/watch-native.ts
+var import_node_module7 = require("module");
+var import_node_path13 = __toESM(require("path"), 1);
 init_src2();
+var import_meta13 = {};
 var watchBindingState = {
   binding: void 0
 };
@@ -6899,27 +7062,27 @@ var getBinding = () => {
     return watchBindingState.binding;
   }
   const runtimeDir = typeof __dirname === "string" ? __dirname : process.cwd();
-  const req = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('engine.js', document.baseURI).href)));
+  const req = (0, import_node_module7.createRequire)(import_meta13.url);
   const _pa = `${process.platform}-${process.arch}`;
   const _paGnu = _pa === "linux-x64" ? "linux-x64-gnu" : _pa === "linux-arm64" ? "linux-arm64-gnu" : _pa;
   const candidates = [
     // new binary name: tailwind-styled-native
-    path9__namespace.default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
-    path9__namespace.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_pa}.node`),
+    import_node_path13.default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
+    import_node_path13.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_pa}.node`),
     // npm install case: dist/../native/
-    path9__namespace.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
-    path9__namespace.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_pa}.node`),
-    path9__namespace.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_paGnu}.node`),
+    import_node_path13.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+    import_node_path13.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_pa}.node`),
+    import_node_path13.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_paGnu}.node`),
     // monorepo dev: 4-level up
-    path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
-    path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_paGnu}.node`),
+    import_node_path13.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
+    import_node_path13.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_paGnu}.node`),
     // 3-level fallback
-    path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
+    import_node_path13.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
     // backward compat: tailwind_styled_parser
-    path9__namespace.default.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
-    path9__namespace.default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
-    path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
-    path9__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node")
+    import_node_path13.default.resolve(process.cwd(), "native", "tailwind_styled_parser.node"),
+    import_node_path13.default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
+    import_node_path13.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
+    import_node_path13.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node")
   ];
   for (const c of candidates) {
     try {
@@ -6940,7 +7103,7 @@ var log6 = createLogger2("engine:watch-native");
 function watchWorkspace2(rootDir, callback, options = {}) {
   const binding = getBinding();
   const pollMs = options.pollIntervalMs ?? 500;
-  const resolvedRoot = path9__namespace.default.resolve(rootDir);
+  const resolvedRoot = import_node_path13.default.resolve(rootDir);
   const result = (() => {
     try {
       return binding.startWatch(resolvedRoot);
@@ -6977,7 +7140,7 @@ This package requires native Rust bindings.`
     const deduped = /* @__PURE__ */ new Set();
     const events = [];
     for (const e of raw) {
-      const absPath = path9__namespace.default.isAbsolute(e.path) ? path9__namespace.default.normalize(e.path) : path9__namespace.default.resolve(resolvedRoot, e.path);
+      const absPath = import_node_path13.default.isAbsolute(e.path) ? import_node_path13.default.normalize(e.path) : import_node_path13.default.resolve(resolvedRoot, e.path);
       const kind = e.kind;
       const key = `${kind}:${absPath}`;
       if (deduped.has(key)) continue;
@@ -7017,11 +7180,11 @@ var configState = {
 var log7 = createLogger2("engine");
 async function loadTailwindConfigFromPath(root, tailwindConfigPath) {
   if (!tailwindConfigPath) return void 0;
-  const configPath = path9__namespace.default.resolve(root, tailwindConfigPath);
-  if (!fs3__namespace.default.existsSync(configPath)) {
+  const configPath = import_node_path14.default.resolve(root, tailwindConfigPath);
+  if (!import_node_fs11.default.existsSync(configPath)) {
     throw TwError.fromIo("CONFIG_NOT_FOUND", `tailwindConfigPath not found: ${configPath}`);
   }
-  const imported = await import(url.pathToFileURL(configPath).href);
+  const imported = await import((0, import_node_url6.pathToFileURL)(configPath).href);
   const config = imported.default ?? imported;
   return config;
 }
@@ -7084,11 +7247,11 @@ async function buildFromScan(scan, root, options, tailwindConfig) {
   };
 }
 function countWorkspacePackages(root) {
-  const packagesDir = path9__namespace.default.join(root, "packages");
-  if (!fs3__namespace.default.existsSync(packagesDir)) return 0;
+  const packagesDir = import_node_path14.default.join(root, "packages");
+  if (!import_node_fs11.default.existsSync(packagesDir)) return 0;
   try {
-    return fs3__namespace.default.readdirSync(packagesDir, { withFileTypes: true }).filter(
-      (entry) => entry.isDirectory() && fs3__namespace.default.existsSync(path9__namespace.default.join(packagesDir, entry.name, "package.json"))
+    return import_node_fs11.default.readdirSync(packagesDir, { withFileTypes: true }).filter(
+      (entry) => entry.isDirectory() && import_node_fs11.default.existsSync(import_node_path14.default.join(packagesDir, entry.name, "package.json"))
     ).length;
   } catch (err) {
     log7.debug(`countWorkspacePackages: ${err instanceof Error ? err.message : String(err)}`);
@@ -7125,7 +7288,7 @@ function writeDashboardMetrics(root, mode, result, metrics) {
 async function createEngine(rawOptions = {}) {
   const options = parseEngineOptions(rawOptions);
   const root = options.root ?? process.cwd();
-  const resolvedRoot = path9__namespace.default.resolve(root);
+  const resolvedRoot = import_node_path14.default.resolve(root);
   const plugins = rawOptions.plugins ?? [];
   const getTailwindConfig = async () => {
     if (configState.isLoaded()) return configState.getConfig();
@@ -7272,7 +7435,7 @@ async function createEngine(rawOptions = {}) {
       const shouldForceFullRescan = (event) => {
         if (event.type === "unlink") return false;
         try {
-          const stat = fs3__namespace.default.statSync(event.filePath);
+          const stat = import_node_fs11.default.statSync(event.filePath);
           if (stat.size > largeFileThreshold) {
             metrics.markSkippedLargeFile();
             return true;
@@ -7390,14 +7553,14 @@ async function createEngine(rawOptions = {}) {
   };
 }
 async function scanWorkspace3(opts = {}) {
-  const root = path9__namespace.default.resolve(opts.root ?? process.cwd());
+  const root = import_node_path14.default.resolve(opts.root ?? process.cwd());
   return scanWorkspaceAsync(root, {
     includeExtensions: opts.extensions,
     ignoreDirectories: opts.ignoreDirectories
   });
 }
 async function analyzeWorkspace2(opts = {}) {
-  const root = path9__namespace.default.resolve(opts.root ?? process.cwd());
+  const root = import_node_path14.default.resolve(opts.root ?? process.cwd());
   return analyzeWorkspace(root, {
     classStats: { top: opts.top ?? 20 }
   });
@@ -7469,39 +7632,53 @@ async function inspectClass(className, scanResult, css = "") {
     bundleBytes: impact.bundleSizeBytes
   };
 }
-
-exports.BuildResultSchema = BuildResultSchema;
-exports.BundleAnalyzer = BundleAnalyzer;
-exports.EngineMetricsCollector = EngineMetricsCollector;
-exports.EngineOptionsSchema = EngineOptionsSchema;
-exports.EngineWatchOptionsSchema = EngineWatchOptionsSchema;
-exports.ImpactTracker = ImpactTracker;
-exports.ReverseLookup = ReverseLookup;
-exports.analyzeWorkspace = analyzeWorkspace2;
-exports.applyIncrementalChange = applyIncrementalChange;
-exports.build = build;
-exports.buildProvenanceChain = buildProvenanceChain;
-exports.createEngine = createEngine;
-exports.createFingerprint = createFingerprint2;
-exports.createResolutionReason = createResolutionReason;
-exports.generateSafelist = generateSafelist2;
-exports.inspectClass = inspectClass;
-exports.parseCssToIr = parseCssToIr;
-exports.parseEngineOptions = parseEngineOptions;
-exports.parseEngineWatchOptions = parseEngineWatchOptions;
-exports.runAfterBuild = runAfterBuild;
-exports.runAfterScan = runAfterScan;
-exports.runAfterWatch = runAfterWatch;
-exports.runBeforeBuild = runBeforeBuild;
-exports.runBeforeScan = runBeforeScan;
-exports.runBeforeWatch = runBeforeWatch;
-exports.runOnError = runOnError;
-exports.runTransformClasses = runTransformClasses;
-exports.scanWorkspace = scanWorkspace3;
-exports.trace = trace;
-exports.traceClass = traceClass;
-exports.traceClasses = traceClasses;
-exports.watchWorkspaceLegacy = watchWorkspace;
-exports.watchWorkspaceNative = watchWorkspace2;
-//# sourceMappingURL=engine.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuildResultSchema,
+  BundleAnalyzer,
+  CascadeResolutionId,
+  CascadeResolver,
+  CascadeStage,
+  ConditionId,
+  ConditionResult,
+  EngineMetricsCollector,
+  EngineOptionsSchema,
+  EngineWatchOptionsSchema,
+  ImpactTracker,
+  Importance,
+  LayerId,
+  Origin,
+  PropertyId,
+  ReverseLookup,
+  RuleId,
+  SelectorId,
+  ValueId,
+  VariantChainId,
+  analyzeWorkspace,
+  applyIncrementalChange,
+  build,
+  buildProvenanceChain,
+  createEngine,
+  createFingerprint,
+  createResolutionReason,
+  generateSafelist,
+  inspectClass,
+  parseCssToIr,
+  parseEngineOptions,
+  parseEngineWatchOptions,
+  runAfterBuild,
+  runAfterScan,
+  runAfterWatch,
+  runBeforeBuild,
+  runBeforeScan,
+  runBeforeWatch,
+  runOnError,
+  runTransformClasses,
+  scanWorkspace,
+  trace,
+  traceClass,
+  traceClasses,
+  watchWorkspaceLegacy,
+  watchWorkspaceNative
+});
 //# sourceMappingURL=engine.js.map