tailwind-styled-v4 5.0.36 → 5.0.38

package/dist/shared.js

@@ -1,45 +1,11 @@
-'use strict';
-
-var zod = require('zod');
-var module$1 = require('module');
-var fs3 = require('fs');
-var path = require('path');
-var crypto = require('crypto');
-var url = require('url');
-
-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 path__namespace = /*#__PURE__*/_interopNamespace(path);
-
 /* 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;
 };
@@ -55,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
@@ -149,6 +123,7 @@ function getPipelinePercentages(metrics) {
 }
 var init_trace = __esm({
   "packages/domain/shared/src/trace.ts"() {
+    "use strict";
   }
 });
 
@@ -160,10 +135,11 @@ function formatErrorCode(code) {
   const prefix = code.startsWith("E") ? "Error" : code.startsWith("W") ? "Warning" : "Code";
   return `[${prefix} ${code}]`;
 }
-exports.ERROR_CODES = void 0; var ERROR_SUGGESTIONS;
+var ERROR_CODES, ERROR_SUGGESTIONS;
 var init_error_codes = __esm({
   "packages/domain/shared/src/error-codes.ts"() {
-    exports.ERROR_CODES = {
+    "use strict";
+    ERROR_CODES = {
       // E0xx — Native binding
       NATIVE_NOT_FOUND: "E001",
       NATIVE_LOAD_FAILED: "E002",
@@ -204,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 {
@@ -229,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;
@@ -246,67 +225,69 @@ function parseNative(schema, data, context) {
   }
   return result.data;
 }
-exports.NativeScanFileSchema = void 0; exports.NativeScanResultSchema = void 0; var NativeClassUsageSchema; exports.NativeAnalyzerReportSchema = void 0; exports.NativeTransformResultSchema = void 0; exports.NativeCssCompileResultSchema = void 0; exports.NativeWatchResultSchema = void 0; exports.NativeCacheEntrySchema = void 0; exports.NativeCacheReadResultSchema = void 0;
+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"() {
-    exports.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()
     });
-    exports.NativeScanResultSchema = zod.z.object({
-      files: zod.z.array(exports.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()
     });
-    exports.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()
     });
-    exports.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()
     });
-    exports.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()
     });
-    exports.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()
     });
-    exports.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()
     });
-    exports.NativeCacheReadResultSchema = zod.z.object({
-      entries: zod.z.array(exports.NativeCacheEntrySchema),
-      version: zod.z.string().optional()
+    NativeCacheReadResultSchema = import_zod.z.object({
+      entries: import_zod.z.array(NativeCacheEntrySchema),
+      version: import_zod.z.string().optional()
     });
   }
 });
@@ -316,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 {
@@ -328,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('shared.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('shared.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('shared.js', document.baseURI).href)))("node:fs");
+  if (!_nodeFs) _nodeFs = nodeRequire.createRequire(import_meta.url)("node:fs");
   return _nodeFs;
 }
 function createEsmRequire(importMetaUrl) {
@@ -365,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('shared.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 {
@@ -391,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;
@@ -405,7 +388,7 @@ var init_esmHelpers = __esm({
 // packages/domain/shared/src/telemetry.ts
 function getGlobalTelemetry() {
   if (!_globalCollector) {
-    _globalCollector = new exports.TelemetryCollector();
+    _globalCollector = new TelemetryCollector();
   }
   return _globalCollector;
 }
@@ -441,11 +424,12 @@ function createBuildTimer() {
     }
   };
 }
-var RING_BUFFER_SIZE; exports.TelemetryCollector = void 0; var _globalCollector;
+var RING_BUFFER_SIZE, TelemetryCollector, _globalCollector;
 var init_telemetry = __esm({
   "packages/domain/shared/src/telemetry.ts"() {
+    "use strict";
     RING_BUFFER_SIZE = 100;
-    exports.TelemetryCollector = class {
+    TelemetryCollector = class {
       data = [];
       enabled;
       constructor(enabled) {
@@ -510,6 +494,8 @@ var init_telemetry = __esm({
     _globalCollector = null;
   }
 });
+
+// packages/domain/shared/src/configSchemas.ts
 function parseJsonWithSchema(jsonString, schema, sourceName) {
   let parsed;
   try {
@@ -528,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");
@@ -540,70 +526,72 @@ function parseJsonFileWithSchema(filePath, schema) {
   }
   return parseJsonWithSchema(content, schema, basename(filePath));
 }
-exports.ScanCacheClassEntrySchema = void 0; exports.ScanCacheSchema = void 0; var TailwindContentItemSchema; exports.TailwindConfigSchema = void 0; exports.RegistryPluginEntrySchema = void 0; exports.RegistryFileSchema = void 0; exports.PackageJsonSchema = void 0;
+var import_zod2, ScanCacheClassEntrySchema, ScanCacheSchema, TailwindContentItemSchema, TailwindConfigSchema, RegistryPluginEntrySchema, RegistryFileSchema, PackageJsonSchema;
 var init_configSchemas = __esm({
   "packages/domain/shared/src/configSchemas.ts"() {
-    exports.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([])
     });
-    exports.ScanCacheSchema = zod.z.object({
-      version: zod.z.string().default("1"),
-      generatedAt: zod.z.string(),
-      root: zod.z.string(),
-      classNames: zod.z.array(exports.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()
       })
     ]);
-    exports.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();
-    exports.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()
     });
-    exports.RegistryFileSchema = zod.z.object({
-      version: zod.z.string(),
-      official: zod.z.array(exports.RegistryPluginEntrySchema).default([]),
-      community: zod.z.array(exports.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([])
     });
-    exports.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();
   }
 });
@@ -613,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://")) {
@@ -628,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, "/");
@@ -637,7 +625,7 @@ function resolvePath(...segments) {
 function existsSync(path6) {
   if (isBrowser2) return false;
   try {
-    const nodeFs = __require(NODE_FS);
+    const nodeFs = require(NODE_FS);
     return nodeFs.existsSync(path6);
   } catch {
     return false;
@@ -691,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;
@@ -840,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}"`);
@@ -856,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}`;
@@ -873,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)`);
@@ -882,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)`);
@@ -893,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 ["..", path__namespace.join("..", ".."), path__namespace.join("..", "..", "..")]) {
-      const pkgRoot = path__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 = path__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 };
           }
         }
@@ -911,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(path__namespace.resolve(base, `${bin}.node`));
-    localCandidates.push(path__namespace.resolve(base, "..", `${bin}.node`));
-    localCandidates.push(path__namespace.resolve(base, `${bin}.${platform}.node`));
-    localCandidates.push(path__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 = path__namespace.resolve(dir, "native");
+      const nativeDir = path.resolve(dir, "native");
       for (const bin of BINARY_NAMES) {
-        localCandidates.push(path__namespace.resolve(nativeDir, `${bin}.node`));
-        localCandidates.push(path__namespace.resolve(nativeDir, `${bin}.${platform}.node`));
-        localCandidates.push(path__namespace.resolve(nativeDir, `${bin}.${napiPlatform}.node`));
-        localCandidates.push(path__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 = path__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 };
     }
   }
@@ -953,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('shared.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"],
@@ -1003,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 = (path6) => __require(path6);
+    import_meta3 = {};
+    _loadNative = (path6) => require(path6);
     log = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -1037,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('shared.js', document.baseURI).href)));
+        const runtimeDir = resolveRuntimeDir(void 0, import_meta3.url);
         const result = resolveNativeBinary(runtimeDir);
         if (result.path && result.path.endsWith(".node")) {
           try {
@@ -1149,6 +1149,7 @@ function resetCacheStats() {
 }
 var init_cssGeneratorNative = __esm({
   "packages/domain/compiler/src/compiler/cssGeneratorNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -1221,6 +1222,7 @@ function atomicRegistrySize() {
 }
 var init_compilationNative = __esm({
   "packages/domain/compiler/src/compiler/compilationNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -1364,6 +1366,7 @@ function twMergeRaw(classLists) {
 }
 var init_cssCompilationNative = __esm({
   "packages/domain/compiler/src/compiler/cssCompilationNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -1463,6 +1466,7 @@ function idRegistryImport(importedData) {
 }
 var init_idRegistryNative = __esm({
   "packages/domain/compiler/src/compiler/idRegistryNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -1604,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;
@@ -1626,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;
@@ -1649,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('shared.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;
   }
@@ -1833,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('shared.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();
@@ -1863,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();
@@ -2041,6 +2058,7 @@ function resetMemoryStats() {
 }
 var init_analyzerNative = __esm({
   "packages/domain/compiler/src/analyzer/analyzerNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2134,6 +2152,7 @@ function resolveSimpleVariants(configJson) {
 }
 var init_themeResolutionNative = __esm({
   "packages/domain/compiler/src/analyzer/themeResolutionNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2181,6 +2200,7 @@ function generateSubComponentTypes(root, outputPath) {
 }
 var init_scannerNative = __esm({
   "packages/domain/compiler/src/analyzer/scannerNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2188,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();
@@ -2376,6 +2397,7 @@ function resetResolverPoolStats() {
 }
 var init_cacheNative = __esm({
   "packages/domain/compiler/src/cache/cacheNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2383,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();
   }
 });
@@ -2631,6 +2654,7 @@ function redisDiagnose() {
 }
 var init_redisNative = __esm({
   "packages/domain/compiler/src/redis/redisNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2638,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();
   }
 });
@@ -2776,6 +2801,7 @@ function getCompilerDiagnostics() {
 }
 var init_watchSystemNative = __esm({
   "packages/domain/compiler/src/watch/watchSystemNative.ts"() {
+    "use strict";
     init_nativeBridge();
   }
 });
@@ -2783,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) {
@@ -2820,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();
@@ -2830,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('shared.js', document.baseURI).href)));
+    import_meta6 = {};
+    _require2 = (0, import_node_module4.createRequire)(import_meta6.url);
     transformSource = (source, opts) => {
       const native = getNativeBridge();
       if (!native?.transformSource) {
@@ -2922,7 +2956,7 @@ var init_src = __esm({
     };
     scanProjectUsage = (dirs, cwd) => {
       const { batchExtractClasses: batchExtractClasses2 } = _require2("./parser");
-      const files = dirs.map((dir) => path__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) {
@@ -2939,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 [];
@@ -2959,9 +2993,9 @@ var init_src = __esm({
         "tailwind.config.cjs"
       ];
       for (const file of configFiles) {
-        const fullPath = path__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;
         }
       }
@@ -2970,9 +3004,9 @@ var init_src = __esm({
     getContentPaths = (cwd = process.cwd()) => {
       return {
         content: [
-          path__namespace.default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
-          path__namespace.default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
-          path__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}")
         ]
       };
     };
@@ -3386,6 +3420,7 @@ __export(internal_exports, {
 });
 var init_internal = __esm({
   "packages/domain/compiler/src/internal.ts"() {
+    "use strict";
     init_src();
     init_tailwindEngine2();
     init_compiler();
@@ -3396,6 +3431,8 @@ var init_internal = __esm({
     init_watch();
   }
 });
+
+// packages/domain/shared/src/staticStateExtractor.ts
 function getNative() {
   if (_native) return _native;
   try {
@@ -3425,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 = path__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 = path__namespace.default.extname(entry.name);
+      const ext = import_node_path2.default.extname(entry.name);
       if (SOURCE_EXTENSIONS.has(ext)) yield fullPath;
     }
   }
@@ -3499,7 +3536,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${path__namespace.default.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${import_node_path2.default.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -3510,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;
       }
@@ -3523,7 +3560,7 @@ function extractStaticStateCss(srcDir, options = {}) {
         allConfigs.push(...configs);
         if (verbose) {
           process.stderr.write(
-            `[tw:static-state] ${path__namespace.default.relative(srcDir, filePath)}: ${configs.length} komponen
+            `[tw:static-state] ${import_node_path2.default.relative(srcDir, filePath)}: ${configs.length} komponen
 `
           );
         }
@@ -3617,12 +3654,12 @@ function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
     resolvedCss: options.resolvedCss || ""
     // ← ensure always passed
   });
-  const twClassesDir = path__namespace.default.join(path__namespace.default.dirname(safelistPath), "tw-classes");
-  fs3__namespace.default.mkdirSync(twClassesDir, { recursive: true });
-  const stateFilePath = path__namespace.default.join(twClassesDir, exports.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"
@@ -3632,27 +3669,32 @@ 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`,
       `  \u2192 ${result.componentsFound} components, ${result.rulesSkipped} rules skipped (fallback ke runtime)`,
-      `  \u2192 ditulis ke tw-classes/${exports.TW_STATE_STATIC_FILENAME}`
+      `  \u2192 ditulis ke tw-classes/${TW_STATE_STATIC_FILENAME}`
     ].join("\n");
   } catch (writeErr) {
     const msg = writeErr instanceof Error ? writeErr.message : String(writeErr);
     return `[tw:static-state] gagal tulis state CSS: ${msg}`;
   }
 }
-var SOURCE_EXTENSIONS, IGNORE_PATTERNS, _native; exports.TW_STATE_STATIC_FILENAME = void 0;
+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;
-    exports.TW_STATE_STATIC_FILENAME = "_tw-state-static.css";
+    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;
@@ -3662,8 +3704,8 @@ function setGlobalLogFile(filePath) {
   _globalLogFile = filePath;
   _logFileInitialized = false;
   try {
-    fs3__namespace.default.mkdirSync(path__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()}
 `,
@@ -3676,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;
     }
@@ -3703,15 +3745,20 @@ 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");
   }
 });
+
+// packages/domain/shared/src/index.ts
 function createLogger2(namespace) {
   const prefix = `[${namespace}]`;
   return {
@@ -3748,18 +3795,18 @@ function formatIssuePath(path6) {
   ).join(".");
 }
 function wrapUnknownError(domain, code, error) {
-  return exports.TwError.wrap(domain, code, error);
+  return TwError.wrap(domain, code, error);
 }
 function isTwError(err) {
-  return err instanceof exports.TwError;
+  return err instanceof TwError;
 }
 function loadNativeBinding(options) {
   const { runtimeDir, candidates, isValid } = options;
   const loadErrors = [];
   for (const candidate of candidates) {
-    const candidatePath = path__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);
@@ -3791,9 +3838,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 {
@@ -3802,38 +3849,44 @@ 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(path__namespace.default.resolve(runtimeDir, `${bin}.node`));
-    candidates.push(path__namespace.default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
-    candidates.push(path__namespace.default.resolve(runtimeDir, "..", "native", `${bin}.node`));
-    candidates.push(path__namespace.default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path__namespace.default.resolve(process.cwd(), "native", `${bin}.node`));
-    candidates.push(path__namespace.default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
-    candidates.push(path__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
-    candidates.push(path__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 path__namespace.default.resolve(dir);
+  if (dir) return import_node_path4.default.resolve(dir);
   try {
-    return path__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) {
-  if (error instanceof exports.TwError) return error.toString();
+  if (error instanceof TwError) return error.toString();
   if (error instanceof Error) return error.message;
   return String(error);
 }
-exports.TwError = void 0; var _require3; exports.LRUCache = void 0;
+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();
@@ -3847,7 +3900,8 @@ var init_src2 = __esm({
     init_observability();
     init_staticStateExtractor();
     init_logger();
-    exports.TwError = class _TwError extends Error {
+    import_meta7 = {};
+    TwError = class _TwError extends Error {
       /** @deprecated Gunakan source */
       domain;
       source;
@@ -3899,8 +3953,8 @@ 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('shared.js', document.baseURI).href)));
-    exports.LRUCache = class {
+    _require3 = (0, import_node_module5.createRequire)(import_meta7.url);
+    LRUCache = class {
       capacity;
       cache;
       constructor(capacity) {
@@ -3945,56 +3999,148 @@ var init_src2 = __esm({
 });
 
 // src/umbrella/shared.ts
+var shared_exports = {};
+__export(shared_exports, {
+  ERROR_CODES: () => ERROR_CODES,
+  LRUCache: () => LRUCache,
+  NativeAnalyzerReportSchema: () => NativeAnalyzerReportSchema,
+  NativeCacheEntrySchema: () => NativeCacheEntrySchema,
+  NativeCacheReadResultSchema: () => NativeCacheReadResultSchema,
+  NativeCssCompileResultSchema: () => NativeCssCompileResultSchema,
+  NativeScanFileSchema: () => NativeScanFileSchema,
+  NativeScanResultSchema: () => NativeScanResultSchema,
+  NativeTransformResultSchema: () => NativeTransformResultSchema,
+  NativeWatchResultSchema: () => NativeWatchResultSchema,
+  PackageJsonSchema: () => PackageJsonSchema,
+  RegistryFileSchema: () => RegistryFileSchema,
+  RegistryPluginEntrySchema: () => RegistryPluginEntrySchema,
+  ScanCacheClassEntrySchema: () => ScanCacheClassEntrySchema,
+  ScanCacheSchema: () => ScanCacheSchema,
+  TW_STATE_STATIC_FILENAME: () => TW_STATE_STATIC_FILENAME,
+  TailwindConfigSchema: () => TailwindConfigSchema,
+  TelemetryCollector: () => TelemetryCollector,
+  TwError: () => TwError,
+  appendStaticStateCssToSafelist: () => appendStaticStateCssToSafelist,
+  assertTailwindV4: () => assertTailwindV4,
+  calculateHealth: () => calculateHealth,
+  createBuildTimer: () => createBuildTimer,
+  createDebugLogger: () => createDebugLogger,
+  createEsmRequire: () => createEsmRequire,
+  createLogger: () => createLogger2,
+  createObservabilityClient: () => createObservabilityClient,
+  createTraceSnapshot: () => createTraceSnapshot,
+  detectTailwind: () => detectTailwind,
+  extractStaticStateCss: () => extractStaticStateCss,
+  formatDuration: () => formatDuration,
+  formatErrorCode: () => formatErrorCode,
+  formatErrorMessage: () => formatErrorMessage,
+  formatMemory: () => formatMemory,
+  formatNativeNotFoundError: () => formatNativeNotFoundError,
+  generateBarrelFile: () => generateBarrelFile,
+  generateClassRenameCodemod: () => generateClassRenameCodemod,
+  generateComponentCode: () => generateComponentCode,
+  generateStorybookStory: () => generateStorybookStory,
+  getBuildTimeColor: () => getBuildTimeColor,
+  getDirname: () => getDirname,
+  getFilename: () => getFilename,
+  getGlobalTelemetry: () => getGlobalTelemetry,
+  getHealthColor: () => getHealthColor,
+  getMemoryColor: () => getMemoryColor,
+  getModeColor: () => getModeColor,
+  getPipelinePercentages: () => getPipelinePercentages,
+  getSuggestion: () => getSuggestion,
+  getTailwindVersion: () => getTailwindVersion,
+  hashContent: () => hashContent2,
+  isTailwindV4: () => isTailwindV4,
+  isTwError: () => isTwError,
+  loadNativeBinding: () => loadNativeBinding,
+  parseJsonFileWithSchema: () => parseJsonFileWithSchema,
+  parseJsonWithSchema: () => parseJsonWithSchema,
+  parseNative: () => parseNative,
+  resetGlobalTelemetry: () => resetGlobalTelemetry,
+  resolveFromRoot: () => resolveFromRoot,
+  resolveLoaderPath: () => resolveLoaderPath,
+  resolveNativeBinary: () => resolveNativeBinary,
+  resolveNativeBindingCandidates: () => resolveNativeBindingCandidates,
+  resolveNativeNodePath: () => resolveNativeNodePath,
+  resolveRuntimeDir: () => resolveRuntimeDir,
+  resolveWorkerPath: () => resolveWorkerPath,
+  safeParseNative: () => safeParseNative,
+  setGlobalLogFile: () => setGlobalLogFile,
+  tryRequire: () => tryRequire,
+  wrapUnknownError: () => wrapUnknownError
+});
+module.exports = __toCommonJS(shared_exports);
 init_src2();
-
-exports.appendStaticStateCssToSafelist = appendStaticStateCssToSafelist;
-exports.assertTailwindV4 = assertTailwindV4;
-exports.calculateHealth = calculateHealth;
-exports.createBuildTimer = createBuildTimer;
-exports.createDebugLogger = createDebugLogger;
-exports.createEsmRequire = createEsmRequire;
-exports.createLogger = createLogger2;
-exports.createObservabilityClient = createObservabilityClient;
-exports.createTraceSnapshot = createTraceSnapshot;
-exports.detectTailwind = detectTailwind;
-exports.extractStaticStateCss = extractStaticStateCss;
-exports.formatDuration = formatDuration;
-exports.formatErrorCode = formatErrorCode;
-exports.formatErrorMessage = formatErrorMessage;
-exports.formatMemory = formatMemory;
-exports.formatNativeNotFoundError = formatNativeNotFoundError;
-exports.generateBarrelFile = generateBarrelFile;
-exports.generateClassRenameCodemod = generateClassRenameCodemod;
-exports.generateComponentCode = generateComponentCode;
-exports.generateStorybookStory = generateStorybookStory;
-exports.getBuildTimeColor = getBuildTimeColor;
-exports.getDirname = getDirname;
-exports.getFilename = getFilename;
-exports.getGlobalTelemetry = getGlobalTelemetry;
-exports.getHealthColor = getHealthColor;
-exports.getMemoryColor = getMemoryColor;
-exports.getModeColor = getModeColor;
-exports.getPipelinePercentages = getPipelinePercentages;
-exports.getSuggestion = getSuggestion;
-exports.getTailwindVersion = getTailwindVersion;
-exports.hashContent = hashContent2;
-exports.isTailwindV4 = isTailwindV4;
-exports.isTwError = isTwError;
-exports.loadNativeBinding = loadNativeBinding;
-exports.parseJsonFileWithSchema = parseJsonFileWithSchema;
-exports.parseJsonWithSchema = parseJsonWithSchema;
-exports.parseNative = parseNative;
-exports.resetGlobalTelemetry = resetGlobalTelemetry;
-exports.resolveFromRoot = resolveFromRoot;
-exports.resolveLoaderPath = resolveLoaderPath;
-exports.resolveNativeBinary = resolveNativeBinary;
-exports.resolveNativeBindingCandidates = resolveNativeBindingCandidates;
-exports.resolveNativeNodePath = resolveNativeNodePath;
-exports.resolveRuntimeDir = resolveRuntimeDir;
-exports.resolveWorkerPath = resolveWorkerPath;
-exports.safeParseNative = safeParseNative;
-exports.setGlobalLogFile = setGlobalLogFile;
-exports.tryRequire = tryRequire;
-exports.wrapUnknownError = wrapUnknownError;
-//# sourceMappingURL=shared.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ERROR_CODES,
+  LRUCache,
+  NativeAnalyzerReportSchema,
+  NativeCacheEntrySchema,
+  NativeCacheReadResultSchema,
+  NativeCssCompileResultSchema,
+  NativeScanFileSchema,
+  NativeScanResultSchema,
+  NativeTransformResultSchema,
+  NativeWatchResultSchema,
+  PackageJsonSchema,
+  RegistryFileSchema,
+  RegistryPluginEntrySchema,
+  ScanCacheClassEntrySchema,
+  ScanCacheSchema,
+  TW_STATE_STATIC_FILENAME,
+  TailwindConfigSchema,
+  TelemetryCollector,
+  TwError,
+  appendStaticStateCssToSafelist,
+  assertTailwindV4,
+  calculateHealth,
+  createBuildTimer,
+  createDebugLogger,
+  createEsmRequire,
+  createLogger,
+  createObservabilityClient,
+  createTraceSnapshot,
+  detectTailwind,
+  extractStaticStateCss,
+  formatDuration,
+  formatErrorCode,
+  formatErrorMessage,
+  formatMemory,
+  formatNativeNotFoundError,
+  generateBarrelFile,
+  generateClassRenameCodemod,
+  generateComponentCode,
+  generateStorybookStory,
+  getBuildTimeColor,
+  getDirname,
+  getFilename,
+  getGlobalTelemetry,
+  getHealthColor,
+  getMemoryColor,
+  getModeColor,
+  getPipelinePercentages,
+  getSuggestion,
+  getTailwindVersion,
+  hashContent,
+  isTailwindV4,
+  isTwError,
+  loadNativeBinding,
+  parseJsonFileWithSchema,
+  parseJsonWithSchema,
+  parseNative,
+  resetGlobalTelemetry,
+  resolveFromRoot,
+  resolveLoaderPath,
+  resolveNativeBinary,
+  resolveNativeBindingCandidates,
+  resolveNativeNodePath,
+  resolveRuntimeDir,
+  resolveWorkerPath,
+  safeParseNative,
+  setGlobalLogFile,
+  tryRequire,
+  wrapUnknownError
+});
 //# sourceMappingURL=shared.js.map