tailwind-styled-v4 5.0.11 → 5.0.13

package/dist/shared.js

@@ -1,11 +1,11 @@
 'use strict';
 
-var crypto = require('crypto');
-var fs = require('fs');
+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 module$1 = require('module');
-var zod = require('zod');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespace(e) {
@@ -26,16 +26,36 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
+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 */
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // packages/domain/shared/src/trace.ts
 function getHealthColor(status) {
@@ -127,43 +147,12 @@ function getPipelinePercentages(metrics) {
     compilePct: compile / total * 100
   };
 }
+var init_trace = __esm({
+  "packages/domain/shared/src/trace.ts"() {
+  }
+});
 
 // packages/domain/shared/src/error-codes.ts
-var ERROR_CODES = {
-  // E0xx — Native binding
-  NATIVE_NOT_FOUND: "E001",
-  NATIVE_LOAD_FAILED: "E002",
-  NATIVE_VERSION_MISMATCH: "E003",
-  SCANNER_NATIVE_NOT_FOUND: "E004",
-  SCANNER_HASH_FAILED: "E005",
-  NATIVE_TRANSFORM_UNAVAILABLE: "E006",
-  // E2xx — Compilation
-  MISSING_REACT_IMPORT: "E201",
-  UNSUPPORTED_PATTERN: "E202",
-  TEMPLATE_PARSE_ERROR: "E203",
-  COMPILE_TIMEOUT: "E204",
-  // E3xx — Compatibility
-  TAILWIND_VERSION_UNSUPPORTED: "E301",
-  NODE_VERSION_UNSUPPORTED: "E302",
-  // E4xx — Cache
-  CACHE_READ_FAILED: "E401",
-  CACHE_WRITE_FAILED: "E402",
-  CACHE_CORRUPTED: "E403",
-  // E5xx — RSC
-  RSC_BOUNDARY_CONFLICT: "E501",
-  // W1xx — Warnings
-  DYNAMIC_CONTENT: "W101",
-  INVALID_VARIANT_VALUE: "W201",
-  DEPRECATED_MODE: "W301"
-};
-var ERROR_SUGGESTIONS = {
-  E001: "Run: npm install @tailwind-styled/native-{platform} or build from source",
-  E002: "Try: npm rebuild or reinstall the package",
-  E003: "Run: npm install tailwind-styled-v4@latest to sync versions",
-  E004: "Run: npm install @tailwind-styled/scanner",
-  E006: "Run: npm install @tailwind-styled/compiler",
-  E301: "Upgrade: npm install tailwindcss@^4"
-};
 function getSuggestion(code) {
   return ERROR_SUGGESTIONS[code];
 }
@@ -171,6 +160,46 @@ 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 init_error_codes = __esm({
+  "packages/domain/shared/src/error-codes.ts"() {
+    exports.ERROR_CODES = {
+      // E0xx — Native binding
+      NATIVE_NOT_FOUND: "E001",
+      NATIVE_LOAD_FAILED: "E002",
+      NATIVE_VERSION_MISMATCH: "E003",
+      SCANNER_NATIVE_NOT_FOUND: "E004",
+      SCANNER_HASH_FAILED: "E005",
+      NATIVE_TRANSFORM_UNAVAILABLE: "E006",
+      // E2xx — Compilation
+      MISSING_REACT_IMPORT: "E201",
+      UNSUPPORTED_PATTERN: "E202",
+      TEMPLATE_PARSE_ERROR: "E203",
+      COMPILE_TIMEOUT: "E204",
+      // E3xx — Compatibility
+      TAILWIND_VERSION_UNSUPPORTED: "E301",
+      NODE_VERSION_UNSUPPORTED: "E302",
+      // E4xx — Cache
+      CACHE_READ_FAILED: "E401",
+      CACHE_WRITE_FAILED: "E402",
+      CACHE_CORRUPTED: "E403",
+      // E5xx — RSC
+      RSC_BOUNDARY_CONFLICT: "E501",
+      // W1xx — Warnings
+      DYNAMIC_CONTENT: "W101",
+      INVALID_VARIANT_VALUE: "W201",
+      DEPRECATED_MODE: "W301"
+    };
+    ERROR_SUGGESTIONS = {
+      E001: "Run: npm install @tailwind-styled/native-{platform} or build from source",
+      E002: "Try: npm rebuild or reinstall the package",
+      E003: "Run: npm install tailwind-styled-v4@latest to sync versions",
+      E004: "Run: npm install @tailwind-styled/scanner",
+      E006: "Run: npm install @tailwind-styled/compiler",
+      E301: "Upgrade: npm install tailwindcss@^4"
+    };
+  }
+});
 
 // packages/domain/shared/src/compatibility.ts
 function detectTailwind() {
@@ -198,64 +227,9 @@ function getTailwindVersion() {
 function isTailwindV4() {
   return detectTailwind().supported;
 }
-var 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()
-});
-var NativeScanResultSchema = zod.z.object({
-  files: zod.z.array(NativeScanFileSchema),
-  totalFiles: zod.z.number().int().nonnegative(),
-  uniqueClasses: zod.z.array(zod.z.string())
-});
-var NativeClassUsageSchema = zod.z.object({
-  name: zod.z.string(),
-  count: zod.z.number().int().nonnegative(),
-  files: zod.z.array(zod.z.string()).optional()
-});
-var 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()
-});
-var 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())
-  }).optional()
-});
-var NativeCssCompileResultSchema = zod.z.object({
-  css: zod.z.string(),
-  resolvedClasses: zod.z.array(zod.z.string()),
-  unresolvedClasses: zod.z.array(zod.z.string()).optional()
-});
-zod.z.object({
-  type: zod.z.enum(["change", "unlink", "create"]),
-  path: zod.z.string()
-});
-var NativeWatchResultSchema = zod.z.object({
-  status: zod.z.enum(["ok", "error"]),
-  handleId: zod.z.string().optional(),
-  error: zod.z.string().optional()
-});
-var 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()
-});
-var NativeCacheReadResultSchema = zod.z.object({
-  entries: zod.z.array(NativeCacheEntrySchema),
-  version: zod.z.string().optional()
+var init_compatibility = __esm({
+  "packages/domain/shared/src/compatibility.ts"() {
+  }
 });
 function safeParseNative(schema, data, fallback) {
   const result = schema.safeParse(data);
@@ -265,17 +239,79 @@ function parseNative(schema, data, context) {
   const result = schema.safeParse(data);
   if (!result.success) {
     const first = result.error.issues[0];
-    const path3 = first?.path?.join(".") ?? "(root)";
+    const path6 = first?.path?.join(".") ?? "(root)";
     throw new Error(
-      `[${context}] Native binding returned unexpected data: ${path3}: ${first?.message ?? "validation failed"}`
+      `[${context}] Native binding returned unexpected data: ${path6}: ${first?.message ?? "validation failed"}`
     );
   }
   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 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()
+    });
+    exports.NativeScanResultSchema = zod.z.object({
+      files: zod.z.array(exports.NativeScanFileSchema),
+      totalFiles: zod.z.number().int().nonnegative(),
+      uniqueClasses: zod.z.array(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()
+    });
+    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()
+    });
+    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())
+      }).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()
+    });
+    zod.z.object({
+      type: zod.z.enum(["change", "unlink", "create"]),
+      path: zod.z.string()
+    });
+    exports.NativeWatchResultSchema = zod.z.object({
+      status: zod.z.enum(["ok", "error"]),
+      handleId: zod.z.string().optional(),
+      error: 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()
+    });
+    exports.NativeCacheReadResultSchema = zod.z.object({
+      entries: zod.z.array(exports.NativeCacheEntrySchema),
+      version: zod.z.string().optional()
+    });
+  }
+});
 
 // packages/domain/shared/src/esmHelpers.ts
-var isBrowser = typeof window !== "undefined" || typeof document !== "undefined";
-var nodeModuleRef = null;
 function getNodeModuleRef() {
   if (isBrowser) return null;
   if (nodeModuleRef !== null) return nodeModuleRef;
@@ -288,9 +324,6 @@ function getNodeModuleRef() {
     return null;
   }
 }
-var _nodePath = null;
-var _nodeUrl = null;
-var _nodeFs = null;
 function getNodePath() {
   if (isBrowser) throw new Error("node:path not available in browser");
   const nodeRequire = getNodeModuleRef();
@@ -358,75 +391,21 @@ function resolveNativeNodePath(importMetaUrl, ...relativeSegments) {
   if (isBrowser) return relativeSegments.join("/");
   return getNodePath().resolve(getDirname(importMetaUrl), ...relativeSegments);
 }
+var isBrowser, nodeModuleRef, _nodePath, _nodeUrl, _nodeFs;
+var init_esmHelpers = __esm({
+  "packages/domain/shared/src/esmHelpers.ts"() {
+    isBrowser = typeof window !== "undefined" || typeof document !== "undefined";
+    nodeModuleRef = null;
+    _nodePath = null;
+    _nodeUrl = null;
+    _nodeFs = null;
+  }
+});
 
 // packages/domain/shared/src/telemetry.ts
-var RING_BUFFER_SIZE = 100;
-var TelemetryCollector = class {
-  data = [];
-  enabled;
-  constructor(enabled) {
-    this.enabled = enabled ?? (process.env.TWS_TELEMETRY === "1" || process.env.TWS_TELEMETRY === "true");
-  }
-  record(build) {
-    if (!this.enabled) return;
-    if (this.data.length >= RING_BUFFER_SIZE) {
-      this.data.shift();
-    }
-    this.data.push(build);
-  }
-  snapshot() {
-    return [...this.data];
-  }
-  summary() {
-    if (this.data.length === 0) return null;
-    const durations = this.data.map((d) => d.durationMs).sort((a, b) => a - b);
-    const p95Idx = Math.floor(durations.length * 0.95);
-    const avg = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
-    return {
-      totalBuilds: this.data.length,
-      avgDurationMs: avg(durations),
-      p95DurationMs: durations[p95Idx] ?? durations[durations.length - 1] ?? 0,
-      avgCacheHitRate: avg(this.data.map((d) => d.cacheHitRate)),
-      avgFilesScanned: avg(this.data.map((d) => d.filesScanned)),
-      avgClassesExtracted: avg(this.data.map((d) => d.classesExtracted)),
-      phaseAvgs: {
-        scan: avg(this.data.map((d) => d.phases.scan)),
-        compile: avg(this.data.map((d) => d.phases.compile)),
-        engine: avg(this.data.map((d) => d.phases.engine)),
-        output: avg(this.data.map((d) => d.phases.output))
-      },
-      slowestBuildMs: durations[durations.length - 1] ?? 0,
-      fastestBuildMs: durations[0] ?? 0
-    };
-  }
-  reset() {
-    this.data = [];
-  }
-  /** Format ringkas untuk CLI output */
-  formatCli() {
-    const s = this.summary();
-    if (!s) return "[telemetry] no data";
-    return [
-      `[telemetry] ${s.totalBuilds} builds`,
-      `avg ${s.avgDurationMs.toFixed(0)}ms`,
-      `p95 ${s.p95DurationMs.toFixed(0)}ms`,
-      `cache hit ${(s.avgCacheHitRate * 100).toFixed(0)}%`,
-      `${s.avgFilesScanned.toFixed(0)} files`
-    ].join(" \xB7 ");
-  }
-  /** Export sebagai JSON untuk dashboard/prometheus */
-  toJSON() {
-    return {
-      summary: this.summary(),
-      history: this.data.slice(-20)
-      // last 20 builds
-    };
-  }
-};
-var _globalCollector = null;
 function getGlobalTelemetry() {
   if (!_globalCollector) {
-    _globalCollector = new TelemetryCollector();
+    _globalCollector = new exports.TelemetryCollector();
   }
   return _globalCollector;
 }
@@ -462,68 +441,75 @@ function createBuildTimer() {
     }
   };
 }
-var 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([])
-});
-var 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()
-});
-var TailwindContentItemSchema = zod.z.union([
-  zod.z.string(),
-  zod.z.object({
-    raw: zod.z.string(),
-    extension: zod.z.string().optional()
-  }),
-  zod.z.object({
-    files: zod.z.array(zod.z.string()),
-    transform: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-  })
-]);
-var 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()
-}).passthrough();
-var 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()
-});
-var RegistryFileSchema = zod.z.object({
-  version: zod.z.string(),
-  official: zod.z.array(RegistryPluginEntrySchema).default([]),
-  community: zod.z.array(RegistryPluginEntrySchema).default([])
+var RING_BUFFER_SIZE; exports.TelemetryCollector = void 0; var _globalCollector;
+var init_telemetry = __esm({
+  "packages/domain/shared/src/telemetry.ts"() {
+    RING_BUFFER_SIZE = 100;
+    exports.TelemetryCollector = class {
+      data = [];
+      enabled;
+      constructor(enabled) {
+        this.enabled = enabled ?? (process.env.TWS_TELEMETRY === "1" || process.env.TWS_TELEMETRY === "true");
+      }
+      record(build) {
+        if (!this.enabled) return;
+        if (this.data.length >= RING_BUFFER_SIZE) {
+          this.data.shift();
+        }
+        this.data.push(build);
+      }
+      snapshot() {
+        return [...this.data];
+      }
+      summary() {
+        if (this.data.length === 0) return null;
+        const durations = this.data.map((d) => d.durationMs).sort((a, b) => a - b);
+        const p95Idx = Math.floor(durations.length * 0.95);
+        const avg = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
+        return {
+          totalBuilds: this.data.length,
+          avgDurationMs: avg(durations),
+          p95DurationMs: durations[p95Idx] ?? durations[durations.length - 1] ?? 0,
+          avgCacheHitRate: avg(this.data.map((d) => d.cacheHitRate)),
+          avgFilesScanned: avg(this.data.map((d) => d.filesScanned)),
+          avgClassesExtracted: avg(this.data.map((d) => d.classesExtracted)),
+          phaseAvgs: {
+            scan: avg(this.data.map((d) => d.phases.scan)),
+            compile: avg(this.data.map((d) => d.phases.compile)),
+            engine: avg(this.data.map((d) => d.phases.engine)),
+            output: avg(this.data.map((d) => d.phases.output))
+          },
+          slowestBuildMs: durations[durations.length - 1] ?? 0,
+          fastestBuildMs: durations[0] ?? 0
+        };
+      }
+      reset() {
+        this.data = [];
+      }
+      /** Format ringkas untuk CLI output */
+      formatCli() {
+        const s = this.summary();
+        if (!s) return "[telemetry] no data";
+        return [
+          `[telemetry] ${s.totalBuilds} builds`,
+          `avg ${s.avgDurationMs.toFixed(0)}ms`,
+          `p95 ${s.p95DurationMs.toFixed(0)}ms`,
+          `cache hit ${(s.avgCacheHitRate * 100).toFixed(0)}%`,
+          `${s.avgFilesScanned.toFixed(0)} files`
+        ].join(" \xB7 ");
+      }
+      /** Export sebagai JSON untuk dashboard/prometheus */
+      toJSON() {
+        return {
+          summary: this.summary(),
+          history: this.data.slice(-20)
+          // last 20 builds
+        };
+      }
+    };
+    _globalCollector = null;
+  }
 });
-var 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()
-}).passthrough();
 function parseJsonWithSchema(jsonString, schema, sourceName) {
   let parsed;
   try {
@@ -554,12 +540,75 @@ 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 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([])
+    });
+    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()
+    });
+    TailwindContentItemSchema = zod.z.union([
+      zod.z.string(),
+      zod.z.object({
+        raw: zod.z.string(),
+        extension: zod.z.string().optional()
+      }),
+      zod.z.object({
+        files: zod.z.array(zod.z.string()),
+        transform: zod.z.record(zod.z.string(), zod.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()
+    }).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()
+    });
+    exports.RegistryFileSchema = zod.z.object({
+      version: zod.z.string(),
+      official: zod.z.array(exports.RegistryPluginEntrySchema).default([]),
+      community: zod.z.array(exports.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()
+    }).passthrough();
+  }
+});
 
 // packages/domain/shared/src/workerResolver.ts
-var isBrowser2 = typeof window !== "undefined" || typeof document !== "undefined";
-var NODE_URL = typeof window === "undefined" || typeof document === "undefined" ? "node:url" : null;
-var NODE_FS = typeof window === "undefined" || typeof document === "undefined" ? "node:fs" : null;
-var NODE_PATH = typeof window === "undefined" || typeof document === "undefined" ? "node:path" : null;
 function getDirnameFromUrl(importMetaUrl) {
   if (!importMetaUrl) return "";
   if (isBrowser2) return "";
@@ -585,11 +634,11 @@ function resolvePath(...segments) {
     return segments.join("/").replace(/\/+/g, "/");
   }
 }
-function existsSync(path3) {
+function existsSync(path6) {
   if (isBrowser2) return false;
   try {
     const nodeFs = __require(NODE_FS);
-    return nodeFs.existsSync(path3);
+    return nodeFs.existsSync(path6);
   } catch {
     return false;
   }
@@ -639,6 +688,15 @@ function resolveLoaderPath(loaderBasename, importMetaUrl) {
     subdirs: [".", "loaders", "lib"]
   }).path;
 }
+var isBrowser2, NODE_URL, NODE_FS, NODE_PATH;
+var init_workerResolver = __esm({
+  "packages/domain/shared/src/workerResolver.ts"() {
+    isBrowser2 = typeof window !== "undefined" || typeof document !== "undefined";
+    NODE_URL = typeof window === "undefined" || typeof document === "undefined" ? "node:url" : null;
+    NODE_FS = typeof window === "undefined" || typeof document === "undefined" ? "node:fs" : null;
+    NODE_PATH = typeof window === "undefined" || typeof document === "undefined" ? "node:path" : null;
+  }
+});
 
 // packages/domain/shared/src/codegen.ts
 function generateComponentCode(opts) {
@@ -796,16 +854,10 @@ function generateBarrelFile(exports$1, dir, opts = {}) {
   }
   return lines.join("\n");
 }
-var isBrowser3 = typeof window !== "undefined" || typeof document !== "undefined";
-var _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)));
-var 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"],
-  "darwin-x64": ["@tailwind-styled/native-darwin-x64"],
-  "darwin-arm64": ["@tailwind-styled/native-darwin-arm64"],
-  "win32-x64": ["@tailwind-styled/native-win32-x64-msvc", "@tailwind-styled/native-win32-x64"],
-  "win32-arm64": ["@tailwind-styled/native-win32-arm64-msvc", "@tailwind-styled/native-win32-arm64"]
-};
+var init_codegen = __esm({
+  "packages/domain/shared/src/codegen.ts"() {
+  }
+});
 function platformKey() {
   if (isBrowser3) return "browser";
   return `${process.platform}-${process.arch}`;
@@ -816,12 +868,12 @@ function resolveNativeBinary(runtimeDir) {
   if (isBrowser3) {
     return { path: null, source: "not-found", platform, tried: ["not available in browser"] };
   }
-  if (process.env.TWS_DISABLE_NATIVE === "1") {
+  if (process.env.TWS_NO_NATIVE === "1" || process.env.TWS_DISABLE_NATIVE === "1") {
     return { path: null, source: "not-found", platform, tried: [] };
   }
   const envPath = process.env.TW_NATIVE_PATH?.trim();
   if (envPath) {
-    if (fs__namespace.existsSync(envPath)) {
+    if (fs3__namespace.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
@@ -830,7 +882,7 @@ function resolveNativeBinary(runtimeDir) {
   for (const pkg of prebuiltPkgs) {
     try {
       const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs__namespace.existsSync(candidate)) {
+      if (fs3__namespace.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -847,7 +899,7 @@ function resolveNativeBinary(runtimeDir) {
         for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
           const candidate = path__namespace.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
           tried.push(`self-bundled:${candidate}`);
-          if (fs__namespace.existsSync(candidate)) {
+          if (fs3__namespace.existsSync(candidate)) {
             return { path: candidate, source: "prebuilt", platform, tried };
           }
         }
@@ -881,7 +933,7 @@ function resolveNativeBinary(runtimeDir) {
   }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs__namespace.existsSync(candidate)) {
+    if (fs3__namespace.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
@@ -901,13 +953,28 @@ function formatNativeNotFoundError(result) {
   ];
   return lines.join("\n");
 }
+var isBrowser3, _require, PLATFORM_MAP;
+var init_native_resolution = __esm({
+  "packages/domain/shared/src/native-resolution.ts"() {
+    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)));
+    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"],
+      "darwin-x64": ["@tailwind-styled/native-darwin-x64"],
+      "darwin-arm64": ["@tailwind-styled/native-darwin-arm64"],
+      "win32-x64": ["@tailwind-styled/native-win32-x64-msvc", "@tailwind-styled/native-win32-x64"],
+      "win32-arm64": ["@tailwind-styled/native-win32-arm64-msvc", "@tailwind-styled/native-win32-arm64"]
+    };
+  }
+});
 
 // packages/domain/shared/src/observability.ts
 function createObservabilityClient(opts = {}) {
   const { baseUrl = "http://localhost:7421", timeoutMs = 3e3 } = opts;
-  async function fetchJson(path3) {
+  async function fetchJson(path6) {
     try {
-      const res = await fetch(`${baseUrl}${path3}`, {
+      const res = await fetch(`${baseUrl}${path6}`, {
         signal: AbortSignal.timeout(timeoutMs)
       });
       if (!res.ok) return null;
@@ -934,249 +1001,2729 @@ function createObservabilityClient(opts = {}) {
     }
   };
 }
+var init_observability = __esm({
+  "packages/domain/shared/src/observability.ts"() {
+  }
+});
 
-// packages/domain/shared/src/index.ts
-function createLogger(namespace) {
-  const prefix = `[${namespace}]`;
-  return {
-    warn(...args) {
-      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
-`);
-    },
-    debug(...args) {
-      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
-`);
-    },
-    error(...args) {
-      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
-`);
-    },
-    log(...args) {
-      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
-`);
-    }
-  };
-}
-function createDebugLogger(namespace, label) {
-  const prefix = label ? `[${namespace}:${label}]` : `[${namespace}]`;
-  return (msg) => {
-    if (process.env.DEBUG?.includes(namespace) || process.env.TW_DEBUG) {
-      console.debug(prefix, msg);
-    }
-  };
-}
-function formatIssuePath(path3) {
-  if (!path3 || path3.length === 0) return "(root)";
-  return path3.map(
-    (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
-  ).join(".");
-}
-var TwError = class _TwError extends Error {
-  /** @deprecated Gunakan source */
-  domain;
-  source;
-  code;
-  originalCause;
-  constructor(domainOrSource, code, message, cause) {
-    super(message);
-    this.name = "TwError";
-    this.domain = domainOrSource;
-    this.source = domainOrSource;
-    this.code = code;
-    this.originalCause = cause;
-    if (Error.captureStackTrace) Error.captureStackTrace(this, _TwError);
-  }
-  static fromIo(code, message) {
-    return new _TwError("io", code, message);
-  }
-  static fromCompile(code, message) {
-    return new _TwError("compile", code, message);
-  }
-  static fromRust(err) {
-    if (err instanceof _TwError) return err;
-    if (err instanceof Error) return new _TwError("rust", "RUST_ERROR", err.message, err);
-    if (err && typeof err === "object") {
-      const e = err;
-      return new _TwError("rust", e.code ?? "RUST_ERROR", e.message ?? String(err), err);
+// packages/domain/compiler/src/nativeBridge.ts
+var _loadNative, log, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttempted, bridgeLoadError, isValidNativeBridge, getNativeBridge, adaptNativeResult;
+var init_nativeBridge = __esm({
+  "packages/domain/compiler/src/nativeBridge.ts"() {
+    init_src2();
+    _loadNative = (path6) => __require(path6);
+    log = (...args) => {
+      if (process.env.DEBUG?.includes("compiler:native")) {
+        console.log("[compiler:native]", ...args);
+      }
+    };
+    NATIVE_UNAVAILABLE_MESSAGE = "[tailwind-styled/compiler v5] Native binding is required but not available.\nThis package requires native Rust bindings. There is no JavaScript fallback.\nPlease ensure:\n  1. The native module is properly installed\n  2. You have run: npm run build:rust (or use prebuilt binary)\n\nFor help, see: https://tailwind-styled.dev/docs/install";
+    nativeBridge = null;
+    bridgeLoadAttempted = false;
+    bridgeLoadError = null;
+    isValidNativeBridge = (mod) => {
+      const m = mod;
+      return !!(typeof m.transformSource === "function" || typeof m.extractAllClasses === "function" || typeof m.hasTwUsage === "function");
+    };
+    getNativeBridge = () => {
+      if (nativeBridge) {
+        return nativeBridge;
+      }
+      if (bridgeLoadAttempted) {
+        if (bridgeLoadError) {
+          throw bridgeLoadError;
+        }
+        throw new Error(NATIVE_UNAVAILABLE_MESSAGE);
+      }
+      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 result = resolveNativeBinary(runtimeDir);
+        if (result.path && result.path.endsWith(".node")) {
+          try {
+            const binding = _loadNative(result.path);
+            if (isValidNativeBridge(binding)) {
+              nativeBridge = binding;
+              log("Native bridge loaded successfully from:", result.path);
+              return nativeBridge;
+            }
+          } catch (e) {
+            log("Failed to require native binding:", e);
+          }
+        }
+        throw new Error(`${NATIVE_UNAVAILABLE_MESSAGE}
+
+Tried paths: ${result.tried.join("\n")}`);
+      } catch (err) {
+        bridgeLoadError = err instanceof Error ? err : new Error(String(err));
+        log("Failed to load native bridge:", bridgeLoadError.message);
+        throw bridgeLoadError;
+      }
+    };
+    adaptNativeResult = (raw) => {
+      return {
+        code: raw.code ?? "",
+        classes: raw.classes ?? [],
+        changed: raw.changed ?? false,
+        rsc: raw.rscJson ? JSON.parse(raw.rscJson) : void 0,
+        metadata: raw.metadataJson ? JSON.parse(raw.metadataJson) : void 0
+      };
+    };
+    if (typeof process !== "undefined" && !bridgeLoadAttempted) {
+      try {
+        getNativeBridge();
+      } catch {
+      }
     }
-    return new _TwError("rust", "RUST_ERROR", String(err), err);
-  }
-  /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
-  static fromZod(err) {
-    const first = err.issues?.[0] ?? err.errors?.[0];
-    const path3 = formatIssuePath(first?.path);
-    const message = first ? `${path3}: ${first.message}` : "Schema validation failed";
-    return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
-  }
-  static wrap(source, code, err) {
-    if (err instanceof _TwError) return err;
-    if (err instanceof Error) return new _TwError(source, code, err.message, err);
-    return new _TwError(source, code, String(err), err);
   }
-  toString() {
-    return `TwError [${this.source}:${this.code}] ${this.message}`;
+});
+
+// packages/domain/compiler/src/compiler/cssGeneratorNative.ts
+async function generateCssNative(classes, options) {
+  const { theme } = options;
+  const native = getNativeBridge();
+  if (!native?.generateCssNative) {
+    throw new Error(
+      "FATAL: Rust CSS generator (generateCssNative) is required but not available. Ensure native binding is properly loaded. Check that native/.node binary exists."
+    );
   }
-  toJSON() {
-    return { name: this.name, source: this.source, code: this.code, message: this.message };
+  const themeJson = JSON.stringify(theme);
+  const css = native.generateCssNative(classes, themeJson);
+  return css;
+}
+function clearThemeCache() {
+  try {
+    const native = getNativeBridge();
+    if (!native?.clearThemeCache) {
+      return;
+    }
+    native.clearThemeCache();
+  } catch {
   }
-  toCliMessage() {
-    return `[${this.source.toUpperCase()}:${this.code}] ${this.message}`;
+}
+var init_cssGeneratorNative = __esm({
+  "packages/domain/compiler/src/compiler/cssGeneratorNative.ts"() {
+    init_nativeBridge();
   }
-};
-function wrapUnknownError(domain, code, error) {
-  return TwError.wrap(domain, code, error);
+});
+
+// packages/domain/compiler/src/compiler/compilationNative.ts
+function compileCssNative2(classes, prefix) {
+  const native = getNativeBridge();
+  if (!native?.compileCss) throw new Error("compileCss not available");
+  return native.compileCss(classes, prefix);
 }
-function isTwError(err) {
-  return err instanceof TwError;
+function compileCssLightning(classes) {
+  const native = getNativeBridge();
+  if (!native?.compileCssLightning) throw new Error("compileCssLightning not available");
+  return native.compileCssLightning(classes);
 }
-function loadNativeBinding(options) {
-  const { runtimeDir, candidates, isValid } = options;
-  const loadErrors = [];
-  for (const candidate of candidates) {
-    const candidatePath = path__namespace.default.resolve(runtimeDir, candidate);
-    try {
-      if (!fs__namespace.default.existsSync(candidatePath) && !fs__namespace.default.existsSync(candidatePath + ".node")) {
-        continue;
-      }
-      const mod = requireNativeModule(candidatePath);
-      if (mod && isValid(mod)) {
-        return { binding: mod, loadErrors, loadedPath: candidatePath };
-      }
-      loadErrors.push({ path: candidatePath, message: options.invalidExportMessage });
-    } catch (e) {
-      loadErrors.push({ path: candidatePath, message: e instanceof Error ? e.message : String(e) });
-    }
-  }
-  return { binding: null, loadErrors };
+function extractTwStateConfigsNative(source, filename) {
+  const native = getNativeBridge();
+  if (!native?.extractTwStateConfigs) throw new Error("extractTwStateConfigs not available");
+  return native.extractTwStateConfigs(source, filename);
 }
-var _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)));
-function requireNativeModule(p) {
-  return _require2(p);
+function generateStaticStateCssNative(inputs, resolvedCss) {
+  const native = getNativeBridge();
+  if (!native?.generateStaticStateCss) throw new Error("generateStaticStateCss not available");
+  return native.generateStaticStateCss(inputs, resolvedCss ?? null);
 }
-function resolveNativeBindingCandidates(options) {
-  const {
-    envVarNames = ["TW_NATIVE_PATH", "TWS_NATIVE_PATH"],
-    includeDefaultCandidates = true,
-    enforceNodeExtensionForEnvPath = false
-  } = options;
-  const runtimeDir = options.runtimeDir || process.cwd();
-  const candidates = [];
-  for (const envVar of envVarNames) {
-    const envPath = process.env[envVar];
-    if (envPath) {
-      candidates.push(enforceNodeExtensionForEnvPath && !envPath.endsWith(".node") ? envPath + ".node" : envPath);
-    }
-  }
-  if (!includeDefaultCandidates) return candidates;
-  if (fs__namespace.default.existsSync(runtimeDir)) {
-    try {
-      for (const entry of fs__namespace.default.readdirSync(runtimeDir)) {
-        if (entry.endsWith(".node")) candidates.push(entry);
-      }
-    } catch {
-    }
+function extractAndGenerateStateCssNative(source, filename) {
+  const native = getNativeBridge();
+  if (!native?.extractAndGenerateStateCss) throw new Error("extractAndGenerateStateCss not available");
+  return native.extractAndGenerateStateCss(source, filename);
+}
+function layoutClassesToCss(classes) {
+  const native = getNativeBridge();
+  if (!native?.layoutClassesToCss) throw new Error("layoutClassesToCss not available");
+  return native.layoutClassesToCss(classes);
+}
+function hashContent(input, algorithm = "sha256", length = 8) {
+  const native = getNativeBridge();
+  if (!native?.hashContent) throw new Error("hashContent not available");
+  return native.hashContent(input, algorithm, length);
+}
+function extractTwContainerConfigs(source) {
+  const native = getNativeBridge();
+  if (!native?.extractTwContainerConfigs) throw new Error("extractTwContainerConfigs not available");
+  return native.extractTwContainerConfigs(source);
+}
+function parseAtomicClass(twClass) {
+  const native = getNativeBridge();
+  if (!native?.parseAtomicClass) throw new Error("parseAtomicClass not available");
+  return native.parseAtomicClass(twClass);
+}
+function generateAtomicCss(rulesJson) {
+  const native = getNativeBridge();
+  if (!native?.generateAtomicCss) throw new Error("generateAtomicCss not available");
+  return native.generateAtomicCss(rulesJson);
+}
+function toAtomicClasses(twClasses) {
+  const native = getNativeBridge();
+  if (!native?.toAtomicClasses) throw new Error("toAtomicClasses not available");
+  return native.toAtomicClasses(twClasses);
+}
+function clearAtomicRegistry() {
+  const native = getNativeBridge();
+  if (!native?.clearAtomicRegistry) return;
+  native.clearAtomicRegistry();
+}
+function atomicRegistrySize() {
+  const native = getNativeBridge();
+  if (!native?.atomicRegistrySize) return 0;
+  return native.atomicRegistrySize();
+}
+var init_compilationNative = __esm({
+  "packages/domain/compiler/src/compiler/compilationNative.ts"() {
+    init_nativeBridge();
   }
-  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`));
+});
+
+// packages/domain/compiler/src/compiler/cssCompilationNative.ts
+function compileClass(input) {
+  const native = getNativeBridge();
+  if (!native?.compile_class) throw new Error("compile_class not available");
+  const resultJson = native.compile_class(input);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      selector: "",
+      declarations: "",
+      properties: [],
+      specificity: 0
+    };
   }
-  return Array.from(new Set(candidates));
 }
-function resolveRuntimeDir(dir, importMetaUrl) {
-  if (dir) return path__namespace.default.resolve(dir);
+function compileClasses(inputs) {
+  const native = getNativeBridge();
+  if (!native?.compile_classes) throw new Error("compile_classes not available");
+  const resultJson = native.compile_classes(inputs);
   try {
-    return path__namespace.default.dirname(url.fileURLToPath(importMetaUrl));
+    return JSON.parse(resultJson);
   } catch {
-    return process.cwd();
+    return {
+      css: "",
+      resolved_classes: [],
+      unknown_classes: [],
+      size_bytes: 0,
+      duration_ms: 0
+    };
   }
 }
-function hashContent(content, algorithm = "md5", length) {
-  const hash = crypto.createHash(algorithm).update(content).digest("hex");
-  return length ? hash.slice(0, length) : hash;
+function compileToCss(input, minify) {
+  const native = getNativeBridge();
+  if (!native?.compile_to_css) throw new Error("compile_to_css not available");
+  return native.compile_to_css(input, minify ?? false);
 }
-function formatErrorMessage(error) {
-  if (error instanceof TwError) return error.toString();
-  if (error instanceof Error) return error.message;
-  return String(error);
+function compileToCssBatch(inputs, minify) {
+  const native = getNativeBridge();
+  if (!native?.compile_to_css_batch) throw new Error("compile_to_css_batch not available");
+  return native.compile_to_css_batch(inputs, minify ?? false);
 }
-var LRUCache = class {
-  capacity;
-  cache;
-  constructor(capacity) {
-    this.capacity = capacity;
-    this.cache = /* @__PURE__ */ new Map();
-  }
-  get(key) {
-    if (!this.cache.has(key)) return void 0;
-    const value = this.cache.get(key);
-    this.cache.delete(key);
-    this.cache.set(key, value);
-    return value;
-  }
-  set(key, value) {
-    if (this.cache.has(key)) {
-      this.cache.delete(key);
-    } else if (this.cache.size >= this.capacity) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey !== void 0) {
-        this.cache.delete(firstKey);
-      }
-    }
-    this.cache.set(key, value);
-  }
-  delete(key) {
-    return this.cache.delete(key);
-  }
-  has(key) {
-    return this.cache.has(key);
+function minifyCss(css) {
+  const native = getNativeBridge();
+  if (!native?.minify_css) throw new Error("minify_css not available");
+  return native.minify_css(css);
+}
+function compileAnimation(animationName, from, to) {
+  const native = getNativeBridge();
+  if (!native?.compile_animation) throw new Error("compile_animation not available");
+  const resultJson = native.compile_animation(animationName, from, to);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      animation_id: "",
+      keyframes_css: "",
+      animation_rule: "",
+      duration_ms: 0
+    };
   }
-  clear() {
-    this.cache.clear();
+}
+function compileKeyframes(name, stopsJson) {
+  const native = getNativeBridge();
+  if (!native?.compile_keyframes) throw new Error("compile_keyframes not available");
+  const resultJson = native.compile_keyframes(name, stopsJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      animation_id: "",
+      keyframes_css: "",
+      animation_rule: "",
+      duration_ms: 0
+    };
   }
-  entries() {
-    return this.cache.entries();
+}
+function compileTheme(tokensJson, themeName, prefix) {
+  const native = getNativeBridge();
+  if (!native?.compile_theme) throw new Error("compile_theme not available");
+  const resultJson = native.compile_theme(tokensJson, themeName, prefix);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      selector: ":root",
+      variables: [],
+      variables_css: "",
+      theme_name: themeName
+    };
   }
-  get size() {
-    return this.cache.size;
+}
+function twMerge(classString) {
+  const native = getNativeBridge();
+  if (!native?.tw_merge) throw new Error("tw_merge not available");
+  return native.tw_merge(classString);
+}
+function twMergeMany(classStrings) {
+  const native = getNativeBridge();
+  if (!native?.tw_merge_many) throw new Error("tw_merge_many not available");
+  return native.tw_merge_many(classStrings);
+}
+function twMergeWithSeparator(classString, options) {
+  const native = getNativeBridge();
+  if (!native?.tw_merge_with_separator)
+    throw new Error("tw_merge_with_separator not available");
+  const opts = {
+    separator: options.separator,
+    debug: options.debug
+  };
+  return native.tw_merge_with_separator(classString, opts);
+}
+function twMergeManyWithSeparator(classStrings, options) {
+  const native = getNativeBridge();
+  if (!native?.tw_merge_many_with_separator)
+    throw new Error("tw_merge_many_with_separator not available");
+  const opts = {
+    separator: options.separator,
+    debug: options.debug
+  };
+  return native.tw_merge_many_with_separator(classStrings, opts);
+}
+function twMergeRaw(classLists) {
+  const native = getNativeBridge();
+  if (!native?.tw_merge_raw) throw new Error("tw_merge_raw not available");
+  return native.tw_merge_raw(classLists);
+}
+var init_cssCompilationNative = __esm({
+  "packages/domain/compiler/src/compiler/cssCompilationNative.ts"() {
+    init_nativeBridge();
   }
-};
+});
+
+// packages/domain/compiler/src/compiler/idRegistryNative.ts
+function idRegistryCreate() {
+  const native = getNativeBridge();
+  if (!native?.id_registry_create) throw new Error("id_registry_create not available");
+  return native.id_registry_create();
+}
+function idRegistryGenerate(handle, name) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_generate) throw new Error("id_registry_generate not available");
+  return native.id_registry_generate(handle, name);
+}
+function idRegistryLookup(handle, name) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_lookup) throw new Error("id_registry_lookup not available");
+  return native.id_registry_lookup(handle, name);
+}
+function idRegistryNext(handle) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_next) throw new Error("id_registry_next not available");
+  return native.id_registry_next(handle);
+}
+function idRegistryDestroy(handle) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_destroy) return;
+  native.id_registry_destroy(handle);
+}
+function idRegistryReset(handle) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_reset) return;
+  native.id_registry_reset(handle);
+}
+function idRegistrySnapshot(handle) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_snapshot) throw new Error("id_registry_snapshot not available");
+  const snapshotJson = native.id_registry_snapshot(handle);
+  try {
+    return JSON.parse(snapshotJson);
+  } catch {
+    return {
+      handle,
+      next_id: 0,
+      entries: [],
+      total_entries: 0
+    };
+  }
+}
+function idRegistryActiveCount() {
+  const native = getNativeBridge();
+  if (!native?.id_registry_active_count) throw new Error("id_registry_active_count not available");
+  return native.id_registry_active_count();
+}
+function registerPropertyName(propertyName) {
+  const native = getNativeBridge();
+  if (!native?.register_property_name)
+    throw new Error("register_property_name not available");
+  return native.register_property_name(propertyName);
+}
+function registerValueName(valueName) {
+  const native = getNativeBridge();
+  if (!native?.register_value_name) throw new Error("register_value_name not available");
+  return native.register_value_name(valueName);
+}
+function propertyIdToString(propertyId) {
+  const native = getNativeBridge();
+  if (!native?.property_id_to_string) throw new Error("property_id_to_string not available");
+  return native.property_id_to_string(propertyId);
+}
+function valueIdToString(valueId) {
+  const native = getNativeBridge();
+  if (!native?.value_id_to_string) throw new Error("value_id_to_string not available");
+  return native.value_id_to_string(valueId);
+}
+function reverseLookupProperty(propertyId) {
+  const native = getNativeBridge();
+  if (!native?.reverse_lookup_property)
+    throw new Error("reverse_lookup_property not available");
+  return native.reverse_lookup_property(propertyId);
+}
+function reverseLookupValue(valueId) {
+  const native = getNativeBridge();
+  if (!native?.reverse_lookup_value) throw new Error("reverse_lookup_value not available");
+  return native.reverse_lookup_value(valueId);
+}
+function idRegistryExport(handle) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_export) throw new Error("id_registry_export not available");
+  return native.id_registry_export(handle);
+}
+function idRegistryImport(importedData) {
+  const native = getNativeBridge();
+  if (!native?.id_registry_import) throw new Error("id_registry_import not available");
+  return native.id_registry_import(importedData);
+}
+var init_idRegistryNative = __esm({
+  "packages/domain/compiler/src/compiler/idRegistryNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/compiler/streamingNative.ts
+function processFileChange(fileChangeJson) {
+  const native = getNativeBridge();
+  if (!native?.process_file_change) throw new Error("process_file_change not available");
+  const resultJson = native.process_file_change(fileChangeJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      file_path: "",
+      status: "error",
+      old_classes: [],
+      new_classes: [],
+      added_classes: [],
+      removed_classes: [],
+      changed: false,
+      fingerprint: "",
+      error: "Failed to parse result"
+    };
+  }
+}
+function computeIncrementalDiff(oldScanJson, newScanJson) {
+  const native = getNativeBridge();
+  if (!native?.compute_incremental_diff)
+    throw new Error("compute_incremental_diff not available");
+  const resultJson = native.compute_incremental_diff(oldScanJson, newScanJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      is_changed: false,
+      changes_count: 0,
+      diff: {
+        added_files: [],
+        removed_files: [],
+        modified_files: [],
+        added_classes: [],
+        removed_classes: [],
+        total_changes: 0
+      },
+      processing_time_ms: 0
+    };
+  }
+}
+function createFingerprint(filePath, fileContent) {
+  const native = getNativeBridge();
+  if (!native?.create_fingerprint) throw new Error("create_fingerprint not available");
+  const fingerprintJson = native.create_fingerprint(filePath, fileContent);
+  try {
+    return JSON.parse(fingerprintJson);
+  } catch {
+    return {
+      file_path: filePath,
+      content_hash: "",
+      size_bytes: fileContent.length,
+      mtime_ms: Date.now(),
+      class_hash: "",
+      signature: ""
+    };
+  }
+}
+function injectStateHash(css, stateHash) {
+  const native = getNativeBridge();
+  if (!native?.inject_state_hash) throw new Error("inject_state_hash not available");
+  const resultJson = native.inject_state_hash(css, stateHash);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      injected: false,
+      state_hash: stateHash,
+      affected_files: 0,
+      total_injected_bytes: 0
+    };
+  }
+}
+function pruneStaleCacheEntries(maxAgeSeconds, maxEntries) {
+  const native = getNativeBridge();
+  if (!native?.prune_stale_entries) throw new Error("prune_stale_entries not available");
+  const resultJson = native.prune_stale_entries(maxAgeSeconds, maxEntries);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      entries_before: 0,
+      entries_after: 0,
+      entries_removed: 0,
+      freed_bytes: 0
+    };
+  }
+}
+function rebuildWorkspaceResult(rootDir, extensions) {
+  const native = getNativeBridge();
+  if (!native?.rebuild_workspace_result)
+    throw new Error("rebuild_workspace_result not available");
+  const resultJson = native.rebuild_workspace_result(rootDir, extensions || []);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      total_files_scanned: 0,
+      total_classes_found: 0,
+      unique_classes: 0,
+      build_time_ms: 0,
+      files_with_changes: 0
+    };
+  }
+}
+function scanFileNative(filePath, fileContent) {
+  const native = getNativeBridge();
+  if (!native?.scan_file_native) throw new Error("scan_file_native not available");
+  const resultJson = native.scan_file_native(filePath, fileContent);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      file: filePath,
+      classes: [],
+      added_classes: [],
+      removed_classes: [],
+      changed: false
+    };
+  }
+}
+function scanFilesBatchNative(filesJson) {
+  const native = getNativeBridge();
+  if (!native?.scan_files_batch_native)
+    throw new Error("scan_files_batch_native not available");
+  const resultJson = native.scan_files_batch_native(filesJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return [];
+  }
+}
+var init_streamingNative = __esm({
+  "packages/domain/compiler/src/compiler/streamingNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/compiler/tailwindEngine.ts
+var tailwindEngine_exports = {};
+__export(tailwindEngine_exports, {
+  clearCache: () => clearCache,
+  getCacheStats: () => getCacheStats,
+  processTailwindCssWithTargets: () => processTailwindCssWithTargets,
+  runCssPipeline: () => runCssPipeline,
+  runCssPipelineSync: () => runCssPipelineSync
+});
+function _getCacheKey(classes, minify, cssEntry, root) {
+  const sorted = [...classes].sort().join(",");
+  const flags = `${minify ? "1" : "0"}${cssEntry ? "1" : "0"}${root ? "1" : "0"}`;
+  return `${sorted}|${flags}`;
+}
+function _evictOldestIfNeeded() {
+  if (_cssCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = _cssCache.keys().next().value;
+    if (firstKey !== void 0) {
+      _cssCache.delete(firstKey);
+    }
+  }
+}
+function getCacheStats() {
+  const total = _cacheHits + _cacheMisses;
+  return {
+    hits: _cacheHits,
+    misses: _cacheMisses,
+    hitRate: total > 0 ? _cacheHits / total : 0,
+    size: _cssCache.size,
+    maxSize: MAX_CACHE_SIZE
+  };
+}
+function clearCache() {
+  _cssCache.clear();
+  _cacheHits = 0;
+  _cacheMisses = 0;
+}
+function getThemeConfig() {
+  return {
+    colors: {
+      slate: {
+        "50": "#f8fafc",
+        "100": "#f1f5f9",
+        "200": "#e2e8f0",
+        "300": "#cbd5e1",
+        "400": "#94a3b8",
+        "500": "#64748b",
+        "600": "#475569",
+        "700": "#334155",
+        "800": "#1e293b",
+        "900": "#0f172a"
+      },
+      gray: {
+        "50": "#f9fafb",
+        "100": "#f3f4f6",
+        "200": "#e5e7eb",
+        "300": "#d1d5db",
+        "400": "#9ca3af",
+        "500": "#6b7280",
+        "600": "#4b5563",
+        "700": "#374151",
+        "800": "#1f2937",
+        "900": "#111827"
+      },
+      white: "#ffffff",
+      black: "#000000",
+      red: {
+        "500": "#ef4444",
+        "600": "#dc2626"
+      },
+      blue: {
+        "500": "#3b82f6",
+        "600": "#1e40af"
+      }
+    },
+    spacing: {
+      "0": "0px",
+      "1": "0.25rem",
+      "2": "0.5rem",
+      "3": "0.75rem",
+      "4": "1rem",
+      "5": "1.25rem",
+      "6": "1.5rem",
+      "8": "2rem",
+      "10": "2.5rem",
+      "12": "3rem",
+      "16": "4rem",
+      "20": "5rem",
+      "24": "6rem"
+    },
+    breakpoints: {
+      "sm": "640px",
+      "md": "768px",
+      "lg": "1024px",
+      "xl": "1280px",
+      "2xl": "1536px"
+    }
+  };
+}
+function postProcessWithLightning(rawCss) {
+  if (!rawCss) return "";
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssLightning) {
+    throw new Error("FATAL: Native binding 'processTailwindCssLightning' is required but not available.");
+  }
+  const result = native.processTailwindCssLightning(rawCss);
+  if (!result?.css) {
+    throw new Error("FATAL: processTailwindCssLightning returned null");
+  }
+  return result.css;
+}
+async function runCssPipeline(classes, cssEntryContent, root, minify = true) {
+  const filtered = classes.filter(Boolean);
+  const uniqueMap = /* @__PURE__ */ new Map();
+  filtered.forEach((cls) => uniqueMap.set(cls, cls));
+  const unique = Array.from(uniqueMap.values());
+  if (unique.length === 0) {
+    return { css: "", classes: [], sizeBytes: 0, optimized: false };
+  }
+  const cacheKey = _getCacheKey(unique, minify, cssEntryContent, root);
+  const cached = _cssCache.get(cacheKey);
+  if (cached) {
+    _cacheHits++;
+    if (process.env.DEBUG?.includes("compiler")) {
+      console.log(
+        `[Compiler] Cache HIT: ${unique.length} classes (hit rate: ${(getCacheStats().hitRate * 100).toFixed(1)}%)`
+      );
+    }
+    return cached;
+  }
+  _cacheMisses++;
+  let rawCss;
+  let usedRustCompiler = false;
+  const theme = getThemeConfig();
+  rawCss = await generateCssNative(unique, { theme });
+  usedRustCompiler = true;
+  const finalCss = minify ? postProcessWithLightning(rawCss) : rawCss;
+  if (process.env.DEBUG?.includes("compiler")) {
+    console.log(
+      `[Compiler] Generated CSS from ${unique.length} classes (${usedRustCompiler ? "Rust" : "JavaScript"})`,
+      `Size: ${finalCss.length} bytes`
+    );
+  }
+  const result = {
+    css: finalCss,
+    classes: unique,
+    sizeBytes: finalCss.length,
+    optimized: minify
+  };
+  _evictOldestIfNeeded();
+  _cssCache.set(cacheKey, result);
+  return result;
+}
+function runCssPipelineSync(_classes) {
+  return { css: "", classes: [], sizeBytes: 0, optimized: false };
+}
+function processTailwindCssWithTargets(css, targets) {
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssWithTargets) {
+    throw new Error("FATAL: Native binding 'processTailwindCssWithTargets' is required but not available.");
+  }
+  const result = native.processTailwindCssWithTargets(css, targets ?? null);
+  if (!result?.css) {
+    throw new Error("FATAL: processTailwindCssWithTargets returned null");
+  }
+  return result.css;
+}
+var _cssCache, _cacheHits, _cacheMisses, MAX_CACHE_SIZE;
+var init_tailwindEngine = __esm({
+  "packages/domain/compiler/src/compiler/tailwindEngine.ts"() {
+    init_nativeBridge();
+    init_cssGeneratorNative();
+    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)));
+    _cssCache = /* @__PURE__ */ new Map();
+    _cacheHits = 0;
+    _cacheMisses = 0;
+    MAX_CACHE_SIZE = 100;
+  }
+});
+
+// packages/domain/compiler/src/compiler/index.ts
+var init_compiler = __esm({
+  "packages/domain/compiler/src/compiler/index.ts"() {
+    init_cssGeneratorNative();
+    init_compilationNative();
+    init_cssCompilationNative();
+    init_idRegistryNative();
+    init_streamingNative();
+  }
+});
+
+// packages/domain/compiler/src/parser/index.ts
+var parser_exports = {};
+__export(parser_exports, {
+  astExtractClasses: () => astExtractClasses,
+  batchExtractClasses: () => batchExtractClasses,
+  checkAgainstSafelist: () => checkAgainstSafelist,
+  diffClassLists: () => diffClassLists,
+  extractAllClasses: () => extractAllClasses,
+  extractClassesFromSource: () => extractClassesFromSource,
+  extractComponentUsage: () => extractComponentUsage,
+  mergeClassesStatic: () => mergeClassesStatic,
+  normalizeAndDedupClasses: () => normalizeAndDedupClasses,
+  normalizeClasses: () => normalizeClasses,
+  parseClasses: () => parseClasses
+});
+var parseClasses, extractAllClasses, extractClassesFromSource, astExtractClasses, normalizeClasses, mergeClassesStatic, normalizeAndDedupClasses, extractComponentUsage, batchExtractClasses, checkAgainstSafelist, diffClassLists;
+var init_parser = __esm({
+  "packages/domain/compiler/src/parser/index.ts"() {
+    init_nativeBridge();
+    parseClasses = (raw) => {
+      const native = getNativeBridge();
+      if (!native?.parseClasses) {
+        throw new Error("FATAL: Native binding 'parseClasses' is required but not available.");
+      }
+      return native.parseClasses(raw) || [];
+    };
+    extractAllClasses = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractAllClasses) {
+        throw new Error("FATAL: Native binding 'extractAllClasses' is required but not available.");
+      }
+      return native.extractAllClasses(source) || [];
+    };
+    extractClassesFromSource = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractClassesFromSource) {
+        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
+      }
+      const result = native.extractClassesFromSource(source);
+      return Array.isArray(result) ? result.join(" ") : String(result || "");
+    };
+    astExtractClasses = (source, _filename) => {
+      const native = getNativeBridge();
+      if (!native?.extractClassesFromSource) {
+        throw new Error("FATAL: Native binding 'extractClassesFromSource' is required but not available.");
+      }
+      return native.extractClassesFromSource(source) || [];
+    };
+    normalizeClasses = (raw) => {
+      const result = normalizeAndDedupClasses(raw);
+      return result?.normalized || "";
+    };
+    mergeClassesStatic = (classes) => {
+      const result = normalizeAndDedupClasses(classes);
+      return result?.normalized || "";
+    };
+    normalizeAndDedupClasses = (raw) => {
+      const native = getNativeBridge();
+      if (!native?.normalizeAndDedupClasses) {
+        throw new Error("FATAL: Native binding 'normalizeAndDedupClasses' is required but not available.");
+      }
+      const result = native.normalizeAndDedupClasses(raw);
+      return result || { normalized: "", duplicatesRemoved: 0, uniqueCount: 0 };
+    };
+    extractComponentUsage = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractComponentUsage) {
+        throw new Error("FATAL: Native binding 'extractComponentUsage' is required but not available.");
+      }
+      return native.extractComponentUsage(source) || [];
+    };
+    batchExtractClasses = (filePaths) => {
+      const native = getNativeBridge();
+      if (!native?.batchExtractClasses) {
+        throw new Error("FATAL: Native binding 'batchExtractClasses' is required but not available.");
+      }
+      return native.batchExtractClasses(filePaths) || [];
+    };
+    checkAgainstSafelist = (classes, safelist) => {
+      const native = getNativeBridge();
+      if (!native?.checkAgainstSafelist) {
+        throw new Error("FATAL: Native binding 'checkAgainstSafelist' is required but not available.");
+      }
+      return native.checkAgainstSafelist(classes, safelist) || { matched: [], unmatched: [], safelistSize: 0 };
+    };
+    diffClassLists = (previous, current) => {
+      const native = getNativeBridge();
+      if (!native?.diffClassLists) {
+        throw new Error("FATAL: Native binding 'diffClassLists' is required but not available.");
+      }
+      return native.diffClassLists(previous, current) || { added: [], removed: [], unchanged: [], hasChanges: false };
+    };
+  }
+});
+
+// packages/domain/compiler/src/analyzer/analyzerNative.ts
+function detectDeadCode(scanResultJson, css) {
+  const native = getNativeBridge();
+  if (!native?.detectDeadCode) throw new Error("detectDeadCode not available");
+  return native.detectDeadCode(scanResultJson, css);
+}
+function analyzeClassUsageNative(classes, scanResultJson, css) {
+  const native = getNativeBridge();
+  if (!native?.analyzeClassUsage) throw new Error("analyzeClassUsage not available");
+  return native.analyzeClassUsage(classes, scanResultJson, css);
+}
+function analyzeClassesNative(filesJson, cwd, flags) {
+  const native = getNativeBridge();
+  if (!native?.analyzeClasses) throw new Error("analyzeClasses not available");
+  return native.analyzeClasses(filesJson, cwd, flags ?? 0);
+}
+function analyzeRscNative(source, filename) {
+  const native = getNativeBridge();
+  if (!native?.analyzeRsc) throw new Error("analyzeRsc not available");
+  return native.analyzeRsc(source, filename);
+}
+function optimizeCssNative(css) {
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssLightning) throw new Error("processTailwindCssLightning not available");
+  const result = native.processTailwindCssLightning(css);
+  return {
+    css: result.css,
+    originalSize: css.length,
+    optimizedSize: result.size_bytes,
+    reductionPercentage: (css.length - result.size_bytes) / css.length * 100
+  };
+}
+function processTailwindCssLightning(css) {
+  const native = getNativeBridge();
+  if (!native?.processTailwindCssLightning) throw new Error("processTailwindCssLightning not available");
+  return native.processTailwindCssLightning(css);
+}
+function eliminateDeadCssNative(css, deadClasses) {
+  const native = getNativeBridge();
+  if (!native?.eliminateDeadCss) throw new Error("eliminateDeadCss not available");
+  return native.eliminateDeadCss(css, deadClasses);
+}
+function hoistComponentsNative(source) {
+  const native = getNativeBridge();
+  if (!native?.hoistComponents) throw new Error("hoistComponents not available");
+  return native.hoistComponents(source);
+}
+function compileVariantTableNative(configJson) {
+  const native = getNativeBridge();
+  if (!native?.compileVariantTable) throw new Error("compileVariantTable not available");
+  return native.compileVariantTable(configJson);
+}
+function classifyAndSortClassesNative(classes) {
+  const native = getNativeBridge();
+  if (!native?.classifyAndSortClasses) throw new Error("classifyAndSortClasses not available");
+  return native.classifyAndSortClasses(classes);
+}
+function mergeCssDeclarationsNative(cssChunks) {
+  const native = getNativeBridge();
+  if (!native?.mergeCssDeclarations) throw new Error("mergeCssDeclarations not available");
+  return native.mergeCssDeclarations(cssChunks);
+}
+var init_analyzerNative = __esm({
+  "packages/domain/compiler/src/analyzer/analyzerNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/analyzer/themeResolutionNative.ts
+function resolveVariants(configJson) {
+  const native = getNativeBridge();
+  if (!native?.resolve_variants) throw new Error("resolve_variants not available");
+  const resultJson = native.resolve_variants(configJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      variants: [],
+      supported: [],
+      deprecated: [],
+      conflicting: []
+    };
+  }
+}
+function validateThemeConfig(configJson) {
+  const native = getNativeBridge();
+  if (!native?.validate_variant_config) throw new Error("validate_variant_config not available");
+  const resultJson = native.validate_variant_config(configJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      is_valid: false,
+      errors: ["Unable to parse configuration"],
+      warnings: [],
+      suggestions: []
+    };
+  }
+}
+function resolveCascade(baseThemeJson, overridesJson) {
+  const native = getNativeBridge();
+  if (!native?.resolve_cascade) throw new Error("resolve_cascade not available");
+  const resultJson = native.resolve_cascade(baseThemeJson, overridesJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      base_theme: {},
+      user_overrides: {},
+      merged_theme: {},
+      conflict_resolutions: []
+    };
+  }
+}
+function resolveClassNames(classNames, themeJson) {
+  const native = getNativeBridge();
+  if (!native?.resolve_class_names) throw new Error("resolve_class_names not available");
+  const resultJson = native.resolve_class_names(classNames, themeJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return [];
+  }
+}
+function resolveConflictGroup(groupName, themeJson) {
+  const native = getNativeBridge();
+  if (!native?.resolve_conflict_group)
+    throw new Error("resolve_conflict_group not available");
+  const resultJson = native.resolve_conflict_group(groupName, themeJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return {
+      group_name: groupName,
+      conflicting_classes: [],
+      description: "",
+      resolution_strategy: "last-wins"
+    };
+  }
+}
+function resolveThemeValue(keyPath, themeJson) {
+  const native = getNativeBridge();
+  if (!native?.resolve_theme_value) throw new Error("resolve_theme_value not available");
+  return native.resolve_theme_value(keyPath, themeJson);
+}
+function resolveSimpleVariants(configJson) {
+  const native = getNativeBridge();
+  if (!native?.resolve_simple_variants) throw new Error("resolve_simple_variants not available");
+  const resultJson = native.resolve_simple_variants(configJson);
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    return [];
+  }
+}
+var init_themeResolutionNative = __esm({
+  "packages/domain/compiler/src/analyzer/themeResolutionNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/analyzer/scannerNative.ts
+function scanWorkspace(root, extensions) {
+  const native = getNativeBridge();
+  if (!native?.scan_workspace) throw new Error("scan_workspace not available");
+  return native.scan_workspace(root, extensions);
+}
+function extractClassesFromSourceNative(source) {
+  const native = getNativeBridge();
+  if (!native?.extract_classes_from_source) throw new Error("extract_classes_from_source not available");
+  return native.extract_classes_from_source(source);
+}
+function batchExtractClassesNative(filePaths) {
+  const native = getNativeBridge();
+  if (!native?.batch_extract_classes) throw new Error("batch_extract_classes not available");
+  return native.batch_extract_classes(filePaths);
+}
+function checkAgainstSafelistNative(classes, safelist) {
+  const native = getNativeBridge();
+  if (!native?.check_against_safelist) throw new Error("check_against_safelist not available");
+  return native.check_against_safelist(classes, safelist);
+}
+function scanFile(filePath) {
+  const native = getNativeBridge();
+  if (!native?.scan_file) throw new Error("scan_file not available");
+  return native.scan_file(filePath);
+}
+function collectFiles(root, extensions) {
+  const native = getNativeBridge();
+  if (!native?.collect_files) throw new Error("collect_files not available");
+  return native.collect_files(root, extensions);
+}
+function walkAndPrefilterSourceFiles(root, extensions, _parallel) {
+  const native = getNativeBridge();
+  if (!native?.walk_and_prefilter_source_files) throw new Error("walk_and_prefilter_source_files not available");
+  return native.walk_and_prefilter_source_files(root, extensions);
+}
+function generateSubComponentTypes(root, outputPath) {
+  const native = getNativeBridge();
+  if (!native?.generate_sub_component_types) throw new Error("generate_sub_component_types not available");
+  return native.generate_sub_component_types(root, outputPath);
+}
+var init_scannerNative = __esm({
+  "packages/domain/compiler/src/analyzer/scannerNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/analyzer/index.ts
+var init_analyzer = __esm({
+  "packages/domain/compiler/src/analyzer/index.ts"() {
+    init_analyzerNative();
+    init_themeResolutionNative();
+    init_scannerNative();
+  }
+});
+
+// packages/domain/compiler/src/cache/cacheNative.ts
+function getCacheStatistics() {
+  const native = getNativeBridge();
+  if (!native?.get_cache_statistics) throw new Error("get_cache_statistics not available");
+  const statsJson = native.get_cache_statistics();
+  try {
+    return JSON.parse(statsJson);
+  } catch {
+    return {
+      parse_cache: { hits: 0, misses: 0, size: 0 },
+      resolve_cache: { hits: 0, misses: 0, size: 0 },
+      compile_cache: { hits: 0, misses: 0, size: 0 },
+      css_gen_cache: { hits: 0, misses: 0, size: 0 },
+      overall_hit_rate: 0,
+      total_memory_bytes: 0
+    };
+  }
+}
+function clearAllCaches() {
+  const native = getNativeBridge();
+  if (!native?.clear_all_caches) return;
+  try {
+    native.clear_all_caches();
+  } catch {
+  }
+}
+function clearParseCache() {
+  const native = getNativeBridge();
+  if (!native?.clear_parse_cache) return;
+  try {
+    native.clear_parse_cache();
+  } catch {
+  }
+}
+function clearResolveCache() {
+  const native = getNativeBridge();
+  if (!native?.clear_resolve_cache) return;
+  try {
+    native.clear_resolve_cache();
+  } catch {
+  }
+}
+function clearCompileCache() {
+  const native = getNativeBridge();
+  if (!native?.clear_compile_cache) return;
+  try {
+    native.clear_compile_cache();
+  } catch {
+  }
+}
+function clearCssGenCache() {
+  const native = getNativeBridge();
+  if (!native?.clear_css_gen_cache) return;
+  try {
+    native.clear_css_gen_cache();
+  } catch {
+  }
+}
+function getCacheOptimizationHints(hitRatePercent, memoryUsedMb) {
+  const native = getNativeBridge();
+  if (!native?.get_cache_optimization_hints)
+    throw new Error("get_cache_optimization_hints not available");
+  const hintsJson = native.get_cache_optimization_hints(
+    Math.min(100, Math.max(0, hitRatePercent)),
+    Math.max(1, memoryUsedMb)
+  );
+  try {
+    return JSON.parse(hintsJson);
+  } catch {
+    return {
+      current_strategy: "unknown",
+      recommended_strategy: "increase_size",
+      estimated_improvement_percent: 0,
+      suggested_memory_mb: 256,
+      notes: ["Unable to analyze cache statistics"]
+    };
+  }
+}
+function estimateOptimalCacheConfig(totalBudgetMb, workloadType) {
+  const native = getNativeBridge();
+  if (!native?.estimate_optimal_cache_config_native)
+    throw new Error("estimate_optimal_cache_config_native not available");
+  const configJson = native.estimate_optimal_cache_config_native(
+    Math.max(64, totalBudgetMb),
+    workloadType
+  );
+  try {
+    return JSON.parse(configJson);
+  } catch {
+    return {
+      parse_cache_size: 128,
+      resolve_cache_size: 64,
+      compile_cache_size: 256,
+      css_gen_cache_size: 128,
+      recommended_eviction_policy: "lru",
+      ttl_seconds: 3600,
+      expected_hit_rate_percent: 75
+    };
+  }
+}
+function cacheRead(cachePath) {
+  const native = getNativeBridge();
+  if (!native?.cache_read) throw new Error("cache_read not available");
+  const result = native.cache_read(cachePath);
+  try {
+    return JSON.parse(result.entries_json || "[]");
+  } catch {
+    return [];
+  }
+}
+function cacheWrite(cachePath, entries) {
+  const native = getNativeBridge();
+  if (!native?.cache_write) throw new Error("cache_write not available");
+  try {
+    const result = native.cache_write(
+      cachePath,
+      entries.map((e) => ({
+        file: e.file,
+        content_hash: e.contentHash,
+        classes: e.classes,
+        mtime_ms: e.mtimeMs,
+        size_bytes: e.sizeBytes
+      }))
+    );
+    return typeof result === "boolean" ? result : result === true;
+  } catch {
+    return false;
+  }
+}
+function cachePriority(mtimeMs, sizeBytes, hitCount) {
+  const native = getNativeBridge();
+  if (!native?.cache_priority) throw new Error("cache_priority not available");
+  return native.cache_priority(mtimeMs, sizeBytes, hitCount);
+}
+var init_cacheNative = __esm({
+  "packages/domain/compiler/src/cache/cacheNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/cache/index.ts
+var init_cache = __esm({
+  "packages/domain/compiler/src/cache/index.ts"() {
+    init_cacheNative();
+  }
+});
+
+// packages/domain/compiler/src/redis/redisNative.ts
+function redisPing() {
+  const native = getNativeBridge();
+  if (!native?.redis_ping) throw new Error("redis_ping not available");
+  return native.redis_ping();
+}
+function redisGet(key) {
+  const native = getNativeBridge();
+  if (!native?.redis_get) throw new Error("redis_get not available");
+  const result = native.redis_get(key);
+  return result === "nil" ? null : result;
+}
+function redisSet(key, value, ttl_seconds) {
+  const native = getNativeBridge();
+  if (!native?.redis_set) throw new Error("redis_set not available");
+  return native.redis_set(key, value, ttl_seconds);
+}
+function redisDelete(key) {
+  const native = getNativeBridge();
+  if (!native?.redis_delete) throw new Error("redis_delete not available");
+  return native.redis_delete(key);
+}
+function redisExists(key) {
+  const native = getNativeBridge();
+  if (!native?.redis_exists) throw new Error("redis_exists not available");
+  return native.redis_exists(key);
+}
+function redisMget(keys) {
+  const native = getNativeBridge();
+  if (!native?.redis_mget) throw new Error("redis_mget not available");
+  const result = native.redis_mget(keys);
+  try {
+    return JSON.parse(result);
+  } catch {
+    return keys.map(() => null);
+  }
+}
+function redisMset(pairs) {
+  const native = getNativeBridge();
+  if (!native?.redis_mset) throw new Error("redis_mset not available");
+  return native.redis_mset(pairs);
+}
+function redisFlushDb() {
+  const native = getNativeBridge();
+  if (!native?.redis_flush_db) throw new Error("redis_flush_db not available");
+  return native.redis_flush_db();
+}
+function redisFlushAll() {
+  const native = getNativeBridge();
+  if (!native?.redis_flush_all) throw new Error("redis_flush_all not available");
+  return native.redis_flush_all();
+}
+function redisPoolConnect(host, port, pool_size) {
+  const native = getNativeBridge();
+  if (!native?.redis_pool_connect) throw new Error("redis_pool_connect not available");
+  return native.redis_pool_connect(host, port, pool_size);
+}
+function redisPoolStats() {
+  const native = getNativeBridge();
+  if (!native?.redis_pool_stats) throw new Error("redis_pool_stats not available");
+  const result = native.redis_pool_stats();
+  try {
+    return JSON.parse(result);
+  } catch {
+    return {
+      connected_count: 0,
+      idle_count: 0,
+      waiting_count: 0,
+      total_requests: 0,
+      total_errors: 0
+    };
+  }
+}
+function redisPoolReconnect() {
+  const native = getNativeBridge();
+  if (!native?.redis_pool_reconnect) throw new Error("redis_pool_reconnect not available");
+  return native.redis_pool_reconnect();
+}
+function redisEnableCluster(initial_nodes) {
+  const native = getNativeBridge();
+  if (!native?.redis_enable_cluster) throw new Error("redis_enable_cluster not available");
+  const result = native.redis_enable_cluster(initial_nodes);
+  try {
+    return JSON.parse(result);
+  } catch {
+    return {
+      enabled: false,
+      cluster_state: "error",
+      nodes: [],
+      slots_assigned: 0,
+      slots_ok: 0,
+      slots_fail: 0
+    };
+  }
+}
+function redisDisableCluster() {
+  const native = getNativeBridge();
+  if (!native?.redis_disable_cluster) throw new Error("redis_disable_cluster not available");
+  return native.redis_disable_cluster();
+}
+function redisClusterStatus() {
+  const native = getNativeBridge();
+  if (!native?.redis_cluster_status) throw new Error("redis_cluster_status not available");
+  const result = native.redis_cluster_status();
+  try {
+    return JSON.parse(result);
+  } catch {
+    return {
+      enabled: false,
+      cluster_state: "unknown",
+      nodes: [],
+      slots_assigned: 0,
+      slots_ok: 0,
+      slots_fail: 0
+    };
+  }
+}
+function redisSubscribe(channel) {
+  const native = getNativeBridge();
+  if (!native?.redis_subscribe) throw new Error("redis_subscribe not available");
+  return native.redis_subscribe(channel);
+}
+function redisPublish(channel, message) {
+  const native = getNativeBridge();
+  if (!native?.redis_publish) throw new Error("redis_publish not available");
+  return native.redis_publish(channel, message);
+}
+function redisExpirationSet(key, ttl_seconds) {
+  const native = getNativeBridge();
+  if (!native?.redis_expiration_set) throw new Error("redis_expiration_set not available");
+  return native.redis_expiration_set(key, ttl_seconds);
+}
+function redisExpirationGet(key) {
+  const native = getNativeBridge();
+  if (!native?.redis_expiration_get) throw new Error("redis_expiration_get not available");
+  const result = native.redis_expiration_get(key);
+  try {
+    return JSON.parse(result);
+  } catch {
+    return {
+      key,
+      ttl_seconds: -1,
+      expiration_timestamp: 0,
+      is_persistent: true
+    };
+  }
+}
+function redisInfo() {
+  const native = getNativeBridge();
+  if (!native?.redis_info) throw new Error("redis_info not available");
+  return native.redis_info();
+}
+function redisMonitor() {
+  const native = getNativeBridge();
+  if (!native?.redis_monitor) throw new Error("redis_monitor not available");
+  return native.redis_monitor();
+}
+function redisCacheSize() {
+  const native = getNativeBridge();
+  if (!native?.redis_cache_size) throw new Error("redis_cache_size not available");
+  return native.redis_cache_size();
+}
+function redisCacheKeyCount() {
+  const native = getNativeBridge();
+  if (!native?.redis_cache_key_count) throw new Error("redis_cache_key_count not available");
+  return native.redis_cache_key_count();
+}
+function redisCacheClear() {
+  const native = getNativeBridge();
+  if (!native?.redis_cache_clear) throw new Error("redis_cache_clear not available");
+  return native.redis_cache_clear();
+}
+function redisCacheHitRate() {
+  const native = getNativeBridge();
+  if (!native?.redis_cache_hit_rate) throw new Error("redis_cache_hit_rate not available");
+  return native.redis_cache_hit_rate();
+}
+function redisEnablePersistence(mode) {
+  const native = getNativeBridge();
+  if (!native?.redis_enable_persistence) throw new Error("redis_enable_persistence not available");
+  return native.redis_enable_persistence(mode);
+}
+function redisDisablePersistence() {
+  const native = getNativeBridge();
+  if (!native?.redis_disable_persistence) throw new Error("redis_disable_persistence not available");
+  return native.redis_disable_persistence();
+}
+function redisSnapshot() {
+  const native = getNativeBridge();
+  if (!native?.redis_snapshot) throw new Error("redis_snapshot not available");
+  return native.redis_snapshot();
+}
+function redisMemoryStats() {
+  const native = getNativeBridge();
+  if (!native?.redis_memory_stats) throw new Error("redis_memory_stats not available");
+  return native.redis_memory_stats();
+}
+function redisOptimizeMemory() {
+  const native = getNativeBridge();
+  if (!native?.redis_optimize_memory) throw new Error("redis_optimize_memory not available");
+  return native.redis_optimize_memory();
+}
+function redisSetEvictionPolicy(policy) {
+  const native = getNativeBridge();
+  if (!native?.redis_set_eviction_policy) throw new Error("redis_set_eviction_policy not available");
+  return native.redis_set_eviction_policy(policy);
+}
+function redisGetEvictionPolicy() {
+  const native = getNativeBridge();
+  if (!native?.redis_get_eviction_policy) throw new Error("redis_get_eviction_policy not available");
+  return native.redis_get_eviction_policy();
+}
+function redisReplicate(target_host, target_port) {
+  const native = getNativeBridge();
+  if (!native?.redis_replicate) throw new Error("redis_replicate not available");
+  return native.redis_replicate(target_host, target_port);
+}
+function redisReplicationStatus() {
+  const native = getNativeBridge();
+  if (!native?.redis_replication_status) throw new Error("redis_replication_status not available");
+  return native.redis_replication_status();
+}
+function redisCacheSync(peers) {
+  const native = getNativeBridge();
+  if (!native?.redis_cache_sync) throw new Error("redis_cache_sync not available");
+  return native.redis_cache_sync(peers);
+}
+function redisEnableCacheWarming(key_pattern) {
+  const native = getNativeBridge();
+  if (!native?.redis_enable_cache_warming) throw new Error("redis_enable_cache_warming not available");
+  return native.redis_enable_cache_warming(key_pattern);
+}
+function redisDisableCacheWarming() {
+  const native = getNativeBridge();
+  if (!native?.redis_disable_cache_warming) throw new Error("redis_disable_cache_warming not available");
+  return native.redis_disable_cache_warming();
+}
+function redisDiagnose() {
+  const native = getNativeBridge();
+  if (!native?.redis_diagnose) throw new Error("redis_diagnose not available");
+  return native.redis_diagnose();
+}
+var init_redisNative = __esm({
+  "packages/domain/compiler/src/redis/redisNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/redis/index.ts
+var init_redis = __esm({
+  "packages/domain/compiler/src/redis/index.ts"() {
+    init_redisNative();
+  }
+});
+
+// packages/domain/compiler/src/watch/watchSystemNative.ts
+function startWatch(root_path, patterns) {
+  const native = getNativeBridge();
+  if (!native?.start_watch) throw new Error("start_watch not available");
+  return native.start_watch(root_path, patterns);
+}
+function pollWatchEvents(handle, timeout_ms) {
+  const native = getNativeBridge();
+  if (!native?.poll_watch_events) throw new Error("poll_watch_events not available");
+  const result = native.poll_watch_events(handle, timeout_ms);
+  try {
+    return JSON.parse(result);
+  } catch {
+    return [];
+  }
+}
+function stopWatch(handle) {
+  const native = getNativeBridge();
+  if (!native?.stop_watch) throw new Error("stop_watch not available");
+  return native.stop_watch(handle);
+}
+function watchAddPattern(handle, pattern) {
+  const native = getNativeBridge();
+  if (!native?.watch_add_pattern) throw new Error("watch_add_pattern not available");
+  return native.watch_add_pattern(handle, pattern);
+}
+function watchRemovePattern(handle, pattern) {
+  const native = getNativeBridge();
+  if (!native?.watch_remove_pattern) throw new Error("watch_remove_pattern not available");
+  return native.watch_remove_pattern(handle, pattern);
+}
+function watchGetActiveHandles() {
+  const native = getNativeBridge();
+  if (!native?.watch_get_active_handles) throw new Error("watch_get_active_handles not available");
+  const result = native.watch_get_active_handles();
+  try {
+    return JSON.parse(result);
+  } catch {
+    return [];
+  }
+}
+function watchClearAll() {
+  const native = getNativeBridge();
+  if (!native?.watch_clear_all) throw new Error("watch_clear_all not available");
+  return native.watch_clear_all();
+}
+function watchEventTypeToString(event_type_code) {
+  const native = getNativeBridge();
+  if (!native?.watch_event_type_to_string) throw new Error("watch_event_type_to_string not available");
+  return native.watch_event_type_to_string(event_type_code);
+}
+function isWatchRunning(handle) {
+  const native = getNativeBridge();
+  if (!native?.is_watch_running) throw new Error("is_watch_running not available");
+  return native.is_watch_running(handle);
+}
+function getWatchStats() {
+  const native = getNativeBridge();
+  if (!native?.get_watch_stats) throw new Error("get_watch_stats not available");
+  const result = native.get_watch_stats();
+  try {
+    return JSON.parse(result);
+  } catch {
+    return {
+      active_watchers: 0,
+      total_events: 0,
+      events_this_second: 0,
+      average_latency_ms: 0,
+      largest_batch_size: 0
+    };
+  }
+}
+function watchPause(handle) {
+  const native = getNativeBridge();
+  if (!native?.watch_pause) throw new Error("watch_pause not available");
+  return native.watch_pause(handle);
+}
+function watchResume(handle) {
+  const native = getNativeBridge();
+  if (!native?.watch_resume) throw new Error("watch_resume not available");
+  return native.watch_resume(handle);
+}
+function scanCacheOptimizations() {
+  const native = getNativeBridge();
+  if (!native?.scan_cache_optimizations) throw new Error("scan_cache_optimizations not available");
+  return native.scan_cache_optimizations();
+}
+function getPluginHooks() {
+  const native = getNativeBridge();
+  if (!native?.get_plugin_hooks) throw new Error("get_plugin_hooks not available");
+  const result = native.get_plugin_hooks();
+  try {
+    return JSON.parse(result);
+  } catch {
+    return [];
+  }
+}
+function registerPluginHook(hook_name, handler_id) {
+  const native = getNativeBridge();
+  if (!native?.register_plugin_hook) throw new Error("register_plugin_hook not available");
+  return native.register_plugin_hook(hook_name, handler_id);
+}
+function unregisterPluginHook(hook_name, handler_id) {
+  const native = getNativeBridge();
+  if (!native?.unregister_plugin_hook) throw new Error("unregister_plugin_hook not available");
+  return native.unregister_plugin_hook(hook_name, handler_id);
+}
+function emitPluginHook(hook_name, data_json) {
+  const native = getNativeBridge();
+  if (!native?.emit_plugin_hook) throw new Error("emit_plugin_hook not available");
+  return native.emit_plugin_hook(hook_name, data_json);
+}
+function getCompilationMetrics() {
+  const native = getNativeBridge();
+  if (!native?.get_compilation_metrics) throw new Error("get_compilation_metrics not available");
+  return native.get_compilation_metrics();
+}
+function resetCompilationMetrics() {
+  const native = getNativeBridge();
+  if (!native?.reset_compilation_metrics) throw new Error("reset_compilation_metrics not available");
+  return native.reset_compilation_metrics();
+}
+function validateCssOutput(css) {
+  const native = getNativeBridge();
+  if (!native?.validate_css_output) throw new Error("validate_css_output not available");
+  return native.validate_css_output(css);
+}
+function getCompilerDiagnostics() {
+  const native = getNativeBridge();
+  if (!native?.get_compiler_diagnostics) throw new Error("get_compiler_diagnostics not available");
+  return native.get_compiler_diagnostics();
+}
+var init_watchSystemNative = __esm({
+  "packages/domain/compiler/src/watch/watchSystemNative.ts"() {
+    init_nativeBridge();
+  }
+});
+
+// packages/domain/compiler/src/watch/index.ts
+var init_watch = __esm({
+  "packages/domain/compiler/src/watch/index.ts"() {
+    init_watchSystemNative();
+  }
+});
+function _layoutClassesToCss(classes) {
+  const native = getNativeBridge();
+  if (!native?.layoutClassesToCss) {
+    throw new Error("FATAL: Native binding 'layoutClassesToCss' is required but not available.");
+  }
+  return native.layoutClassesToCss(classes);
+}
+function _hashContainer(tag, containerJson, name) {
+  const sortedKey = tag + (name ?? "") + containerJson;
+  const native = getNativeBridge();
+  if (!native?.hashContent) {
+    throw new Error("FATAL: Native binding 'hashContent' is required but not available.");
+  }
+  return `tw-cq-${native.hashContent(sortedKey, "fnv", 6)}`;
+}
+function extractContainerCssFromSource(source) {
+  const native = getNativeBridge();
+  if (!native?.extractTwContainerConfigs) {
+    throw new Error("FATAL: Native binding 'extractTwContainerConfigs' is required but not available.");
+  }
+  const configs = native.extractTwContainerConfigs(source);
+  const rules = [];
+  for (const cfg of configs) {
+    const id = _hashContainer(cfg.tag, cfg.containerJson, cfg.containerName);
+    for (const { key, classes } of cfg.breakpoints) {
+      const minWidth = _CONTAINER_BREAKPOINTS[key] ?? key;
+      const css = _layoutClassesToCss(classes);
+      if (!css) continue;
+      const query = cfg.containerName ? `@container ${cfg.containerName} (min-width: ${minWidth})` : `@container (min-width: ${minWidth})`;
+      rules.push(`${query}{.${id}{${css}}}`);
+    }
+  }
+  return rules.join("\n");
+}
+var 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"() {
+    init_nativeBridge();
+    init_compiler();
+    init_parser();
+    init_analyzer();
+    init_cache();
+    init_redis();
+    init_watch();
+    transformSource = (source, opts) => {
+      const native = getNativeBridge();
+      if (!native?.transformSource) {
+        throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+      }
+      const result = native.transformSource(source, opts);
+      if (!result) {
+        throw new Error("FATAL: transformSource returned null");
+      }
+      return result;
+    };
+    hasTwUsage = (source) => {
+      const native = getNativeBridge();
+      if (!native?.hasTwUsage) {
+        throw new Error("FATAL: Native binding 'hasTwUsage' is required but not available.");
+      }
+      return native.hasTwUsage(source);
+    };
+    isAlreadyTransformed = (source) => {
+      const native = getNativeBridge();
+      if (!native?.isAlreadyTransformed) {
+        throw new Error("FATAL: Native binding 'isAlreadyTransformed' is required but not available.");
+      }
+      return native.isAlreadyTransformed(source);
+    };
+    shouldProcess = (source) => {
+      return hasTwUsage(source) && !isAlreadyTransformed(source);
+    };
+    compileCssFromClasses = (classes, prefix) => {
+      const native = getNativeBridge();
+      if (!native?.transformSource) {
+        throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+      }
+      const result = native.transformSource(classes.join(" "), { prefix: prefix ?? "" });
+      if (!result) {
+        throw new Error("FATAL: transformSource returned null");
+      }
+      return result;
+    };
+    buildStyleTag = (classes) => {
+      const result = compileCssFromClasses(classes);
+      return result?.code ? `<style data-tailwind-styled>${result.code}</style>` : "";
+    };
+    generateCssForClasses = async (classes, _tailwindConfig, root, cssEntryContent, minify = false) => {
+      try {
+        const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
+        const result = await runCssPipeline2(classes, cssEntryContent, root, minify);
+        return result.css;
+      } catch {
+        const native = getNativeBridge();
+        if (!native?.transformSource) {
+          throw new Error("FATAL: Native binding 'transformSource' is required but not available.");
+        }
+        const result = native.transformSource(classes.join(" "), {});
+        return result?.code || "";
+      }
+    };
+    eliminateDeadCss = (css, deadClasses) => {
+      const native = getNativeBridge();
+      if (!native?.eliminateDeadCss) {
+        throw new Error("FATAL: Native binding 'eliminateDeadCss' is required but not available.");
+      }
+      return native.eliminateDeadCss(css, Array.from(deadClasses));
+    };
+    findDeadVariants = (variantConfig, usage) => {
+      const unused = [];
+      const configs = Array.isArray(variantConfig) ? variantConfig : [{ name: "__root__", variants: variantConfig }];
+      for (const component of configs) {
+        const componentUsage = usage[component.name] ?? /* @__PURE__ */ new Set();
+        const variants = component.variants;
+        for (const [key, values] of Object.entries(variants)) {
+          for (const [value] of Object.entries(values)) {
+            if (!componentUsage.has(`${key}:${value}`)) {
+              unused.push(`${component.name !== "__root__" ? `${component.name}/` : ""}${key}:${value}`);
+            }
+          }
+        }
+      }
+      return { unusedCount: unused.length, unused };
+    };
+    runElimination = (css, scanResult) => {
+      const native = getNativeBridge();
+      if (!native?.detectDeadCode) {
+        throw new Error("FATAL: Native binding 'detectDeadCode' is required but not available.");
+      }
+      const dead = native.detectDeadCode(JSON.stringify(scanResult), css);
+      return eliminateDeadCss(css, new Set(dead.deadInCss ?? []));
+    };
+    scanProjectUsage = (dirs, cwd) => {
+      const { batchExtractClasses: batchExtractClasses2 } = (init_parser(), __toCommonJS(parser_exports));
+      const files = dirs.map((dir) => path__namespace.default.resolve(cwd, dir));
+      const results = batchExtractClasses2(files) || [];
+      const combined = {};
+      for (const result of results) {
+        if (result.ok && result.classes) {
+          for (const cls of result.classes) {
+            if (!combined[cls]) combined[cls] = {};
+            combined[cls][result.file] = /* @__PURE__ */ new Set([cls]);
+          }
+        }
+      }
+      return combined;
+    };
+    generateSafelist = (scanDirs, outputPath, cwd) => {
+      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));
+      }
+      return allClasses;
+    };
+    loadSafelist = (safelistPath) => {
+      try {
+        const content = fs3__namespace.default.readFileSync(safelistPath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+        return [];
+      }
+    };
+    loadTailwindConfig = (cwd = process.cwd()) => {
+      const configFiles = [
+        "tailwind.config.ts",
+        "tailwind.config.js",
+        "tailwind.config.mjs",
+        "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);
+          return mod.default || mod;
+        }
+      }
+      return {};
+    };
+    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}")
+        ]
+      };
+    };
+    _CONTAINER_BREAKPOINTS = {
+      xs: "240px",
+      sm: "320px",
+      md: "640px",
+      lg: "1024px",
+      xl: "1280px",
+      "2xl": "1536px"
+    };
+    runLoaderTransform = (ctx) => {
+      const { filepath, source, options } = ctx;
+      const result = transformSource(source, { filename: filepath, ...options });
+      let staticCss;
+      try {
+        const cssChunks = [];
+        const stateRules = extractAndGenerateStateCss(source, filepath);
+        if (stateRules.length > 0) {
+          cssChunks.push(stateRules.map((r) => r.cssRule).join("\n"));
+        }
+        const containerCss = extractContainerCssFromSource(source);
+        if (containerCss) cssChunks.push(containerCss);
+        const combined = cssChunks.join("\n").trim();
+        if (combined) staticCss = combined;
+      } catch (err) {
+        console.debug("Static CSS extraction warning:", err);
+      }
+      return {
+        code: result?.code || "",
+        changed: result?.changed || false,
+        classes: result?.classes || [],
+        staticCss
+      };
+    };
+    shouldSkipFile = (filepath) => {
+      const SKIP_PATHS = ["node_modules", ".next", ".rspack-dist", ".turbo", "dist/", "out/"];
+      const skipExtensions = [".css", ".json", ".md", ".txt", ".yaml", ".yml"];
+      for (const p of SKIP_PATHS) {
+        if (filepath.includes(p)) return true;
+      }
+      for (const ext of skipExtensions) {
+        if (filepath.endsWith(ext)) return true;
+      }
+      return false;
+    };
+    fileToRoute = (filepath) => {
+      const normalized = filepath.replace(/\\/g, "/");
+      if (normalized.includes("/layout.") || normalized.includes("/loading.") || normalized.includes("/error.")) {
+        return "__global";
+      }
+      const pageMatch = normalized.match(/\/app\/(.+?)\/page\.[tj]sx?$/);
+      if (pageMatch) return `/${pageMatch[1]}`;
+      const rootPage = normalized.match(/\/app\/page\.[tj]sx?$/);
+      if (rootPage) return "/";
+      return null;
+    };
+    getAllRoutes = () => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return ["/", "__global"];
+    };
+    getRouteClasses = (_route) => /* @__PURE__ */ new Set();
+    registerFileClasses = (_filepath, _classes) => {
+    };
+    registerGlobalClasses = (_classes) => {
+    };
+    _incrementalEngineInstance = null;
+    getIncrementalEngine = () => {
+      if (!_incrementalEngineInstance) {
+        _incrementalEngineInstance = new IncrementalEngine();
+      }
+      return _incrementalEngineInstance;
+    };
+    resetIncrementalEngine = () => {
+      _incrementalEngineInstance = null;
+    };
+    IncrementalEngine = class {
+      compile(source) {
+        return transformSource(source);
+      }
+    };
+    getBucketEngine = () => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return {
+        add: (className) => className,
+        get: (_bucket) => []
+      };
+    };
+    resetBucketEngine = () => {
+    };
+    classifyNode = (_node) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return "unknown";
+    };
+    detectConflicts = (_classes) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClassUsage) {
+        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+      }
+      return [];
+    };
+    bucketSort = (classes) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      const sorted = native.classifyAndSortClasses(classes);
+      return sorted.map((c) => c.raw ?? c);
+    };
+    analyzeFile = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeRsc) {
+        throw new Error("FATAL: Native binding 'analyzeRsc' is required but not available.");
+      }
+      const rsc = native.analyzeRsc(source, filename);
+      return {
+        isServer: rsc?.isServer ?? true,
+        needsClientDirective: rsc?.needsClientDirective ?? false,
+        clientReasons: rsc?.clientReasons ?? [],
+        interactiveClasses: [],
+        canStaticResolveVariants: true
+      };
+    };
+    analyzeVariantUsage = (_source, _componentName, _variantKeys) => {
+      return { resolved: {}, dynamic: [] };
+    };
+    injectClientDirective = (source) => {
+      if (!source.includes('"use client"') && !source.includes("'use client'")) {
+        return '"use client";\n' + source;
+      }
+      return source;
+    };
+    injectServerOnlyComment = (source) => {
+      return `/* @server-only */
+${source}`;
+    };
+    analyzeClasses = (filesJson, cwd, flags) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClasses) {
+        throw new Error("FATAL: Native binding 'analyzeClasses' is required but not available.");
+      }
+      return native.analyzeClasses(filesJson, cwd, flags);
+    };
+    extractTwStateConfigs = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.extractTwStateConfigs) {
+        throw new Error("FATAL: Native binding 'extractTwStateConfigs' is required but not available.");
+      }
+      return native.extractTwStateConfigs(source, filename);
+    };
+    generateStaticStateCss = (entries, _themeConfig) => {
+      const rules = [];
+      for (const entry of entries) {
+        const stateConfig = JSON.parse(entry.statesJson);
+        for (const [stateName, classes] of Object.entries(stateConfig)) {
+          rules.push({
+            selector: `.${entry.componentName}[data-state="${stateName}"]`,
+            declarations: classes,
+            cssRule: `.${entry.componentName}[data-state="${stateName}"]{${classes}}`,
+            componentName: entry.componentName,
+            stateName
+          });
+        }
+      }
+      return rules;
+    };
+    extractAndGenerateStateCss = (source, filename) => {
+      const entries = extractTwStateConfigs(source, filename);
+      return generateStaticStateCss(entries);
+    };
+  }
+});
+
+// packages/domain/compiler/src/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  adaptNativeResult: () => adaptNativeResult,
+  analyzeClassUsageNative: () => analyzeClassUsageNative,
+  analyzeClasses: () => analyzeClasses,
+  analyzeClassesNative: () => analyzeClassesNative,
+  analyzeFile: () => analyzeFile,
+  analyzeRscNative: () => analyzeRscNative,
+  analyzeVariantUsage: () => analyzeVariantUsage,
+  astExtractClasses: () => astExtractClasses,
+  atomicRegistrySize: () => atomicRegistrySize,
+  batchExtractClasses: () => batchExtractClasses,
+  batchExtractClassesNative: () => batchExtractClassesNative,
+  bucketSort: () => bucketSort,
+  buildStyleTag: () => buildStyleTag,
+  cachePriority: () => cachePriority,
+  cacheRead: () => cacheRead,
+  cacheWrite: () => cacheWrite,
+  checkAgainstSafelist: () => checkAgainstSafelist,
+  checkAgainstSafelistNative: () => checkAgainstSafelistNative,
+  classifyAndSortClassesNative: () => classifyAndSortClassesNative,
+  classifyNode: () => classifyNode,
+  clearAllCaches: () => clearAllCaches,
+  clearAtomicRegistry: () => clearAtomicRegistry,
+  clearCache: () => clearCache,
+  clearCompileCache: () => clearCompileCache,
+  clearCssGenCache: () => clearCssGenCache,
+  clearParseCache: () => clearParseCache,
+  clearResolveCache: () => clearResolveCache,
+  clearThemeCache: () => clearThemeCache,
+  collectFiles: () => collectFiles,
+  compileAnimation: () => compileAnimation,
+  compileClass: () => compileClass,
+  compileClasses: () => compileClasses,
+  compileCssFromClasses: () => compileCssFromClasses,
+  compileCssLightning: () => compileCssLightning,
+  compileCssNative2: () => compileCssNative2,
+  compileKeyframes: () => compileKeyframes,
+  compileTheme: () => compileTheme,
+  compileToCss: () => compileToCss,
+  compileToCssBatch: () => compileToCssBatch,
+  compileVariantTableNative: () => compileVariantTableNative,
+  computeIncrementalDiff: () => computeIncrementalDiff,
+  createFingerprint: () => createFingerprint,
+  detectConflicts: () => detectConflicts,
+  detectDeadCode: () => detectDeadCode,
+  diffClassLists: () => diffClassLists,
+  eliminateDeadCss: () => eliminateDeadCss,
+  eliminateDeadCssNative: () => eliminateDeadCssNative,
+  emitPluginHook: () => emitPluginHook,
+  estimateOptimalCacheConfig: () => estimateOptimalCacheConfig,
+  extractAllClasses: () => extractAllClasses,
+  extractAndGenerateStateCss: () => extractAndGenerateStateCss,
+  extractAndGenerateStateCssNative: () => extractAndGenerateStateCssNative,
+  extractClassesFromSource: () => extractClassesFromSource,
+  extractClassesFromSourceNative: () => extractClassesFromSourceNative,
+  extractComponentUsage: () => extractComponentUsage,
+  extractContainerCssFromSource: () => extractContainerCssFromSource,
+  extractTwContainerConfigs: () => extractTwContainerConfigs,
+  extractTwStateConfigs: () => extractTwStateConfigs,
+  extractTwStateConfigsNative: () => extractTwStateConfigsNative,
+  fileToRoute: () => fileToRoute,
+  findDeadVariants: () => findDeadVariants,
+  generateAtomicCss: () => generateAtomicCss,
+  generateCssForClasses: () => generateCssForClasses,
+  generateCssNative: () => generateCssNative,
+  generateSafelist: () => generateSafelist,
+  generateStaticStateCss: () => generateStaticStateCss,
+  generateStaticStateCssNative: () => generateStaticStateCssNative,
+  generateSubComponentTypes: () => generateSubComponentTypes,
+  getAllRoutes: () => getAllRoutes,
+  getBucketEngine: () => getBucketEngine,
+  getCacheOptimizationHints: () => getCacheOptimizationHints,
+  getCacheStatistics: () => getCacheStatistics,
+  getCacheStats: () => getCacheStats,
+  getCompilationMetrics: () => getCompilationMetrics,
+  getCompilerDiagnostics: () => getCompilerDiagnostics,
+  getContentPaths: () => getContentPaths,
+  getIncrementalEngine: () => getIncrementalEngine,
+  getNativeBridge: () => getNativeBridge,
+  getPluginHooks: () => getPluginHooks,
+  getRouteClasses: () => getRouteClasses,
+  getWatchStats: () => getWatchStats,
+  hasTwUsage: () => hasTwUsage,
+  hashContent: () => hashContent,
+  hoistComponentsNative: () => hoistComponentsNative,
+  idRegistryActiveCount: () => idRegistryActiveCount,
+  idRegistryCreate: () => idRegistryCreate,
+  idRegistryDestroy: () => idRegistryDestroy,
+  idRegistryExport: () => idRegistryExport,
+  idRegistryGenerate: () => idRegistryGenerate,
+  idRegistryImport: () => idRegistryImport,
+  idRegistryLookup: () => idRegistryLookup,
+  idRegistryNext: () => idRegistryNext,
+  idRegistryReset: () => idRegistryReset,
+  idRegistrySnapshot: () => idRegistrySnapshot,
+  injectClientDirective: () => injectClientDirective,
+  injectServerOnlyComment: () => injectServerOnlyComment,
+  injectStateHash: () => injectStateHash,
+  isAlreadyTransformed: () => isAlreadyTransformed,
+  isWatchRunning: () => isWatchRunning,
+  layoutClassesToCss: () => layoutClassesToCss,
+  loadSafelist: () => loadSafelist,
+  loadTailwindConfig: () => loadTailwindConfig,
+  mergeClassesStatic: () => mergeClassesStatic,
+  mergeCssDeclarationsNative: () => mergeCssDeclarationsNative,
+  minifyCss: () => minifyCss,
+  normalizeAndDedupClasses: () => normalizeAndDedupClasses,
+  normalizeClasses: () => normalizeClasses,
+  optimizeCssNative: () => optimizeCssNative,
+  parseAtomicClass: () => parseAtomicClass,
+  parseClasses: () => parseClasses,
+  pollWatchEvents: () => pollWatchEvents,
+  processFileChange: () => processFileChange,
+  processTailwindCssLightning: () => processTailwindCssLightning,
+  propertyIdToString: () => propertyIdToString,
+  pruneStaleCacheEntries: () => pruneStaleCacheEntries,
+  rebuildWorkspaceResult: () => rebuildWorkspaceResult,
+  redisCacheClear: () => redisCacheClear,
+  redisCacheHitRate: () => redisCacheHitRate,
+  redisCacheKeyCount: () => redisCacheKeyCount,
+  redisCacheSize: () => redisCacheSize,
+  redisCacheSync: () => redisCacheSync,
+  redisClusterStatus: () => redisClusterStatus,
+  redisDelete: () => redisDelete,
+  redisDiagnose: () => redisDiagnose,
+  redisDisableCacheWarming: () => redisDisableCacheWarming,
+  redisDisableCluster: () => redisDisableCluster,
+  redisDisablePersistence: () => redisDisablePersistence,
+  redisEnableCacheWarming: () => redisEnableCacheWarming,
+  redisEnableCluster: () => redisEnableCluster,
+  redisEnablePersistence: () => redisEnablePersistence,
+  redisExists: () => redisExists,
+  redisExpirationGet: () => redisExpirationGet,
+  redisExpirationSet: () => redisExpirationSet,
+  redisFlushAll: () => redisFlushAll,
+  redisFlushDb: () => redisFlushDb,
+  redisGet: () => redisGet,
+  redisGetEvictionPolicy: () => redisGetEvictionPolicy,
+  redisInfo: () => redisInfo,
+  redisMemoryStats: () => redisMemoryStats,
+  redisMget: () => redisMget,
+  redisMonitor: () => redisMonitor,
+  redisMset: () => redisMset,
+  redisOptimizeMemory: () => redisOptimizeMemory,
+  redisPing: () => redisPing,
+  redisPoolConnect: () => redisPoolConnect,
+  redisPoolReconnect: () => redisPoolReconnect,
+  redisPoolStats: () => redisPoolStats,
+  redisPublish: () => redisPublish,
+  redisReplicate: () => redisReplicate,
+  redisReplicationStatus: () => redisReplicationStatus,
+  redisSet: () => redisSet,
+  redisSetEvictionPolicy: () => redisSetEvictionPolicy,
+  redisSnapshot: () => redisSnapshot,
+  redisSubscribe: () => redisSubscribe,
+  registerFileClasses: () => registerFileClasses,
+  registerGlobalClasses: () => registerGlobalClasses,
+  registerPluginHook: () => registerPluginHook,
+  registerPropertyName: () => registerPropertyName,
+  registerValueName: () => registerValueName,
+  resetBucketEngine: () => resetBucketEngine,
+  resetCompilationMetrics: () => resetCompilationMetrics,
+  resetIncrementalEngine: () => resetIncrementalEngine,
+  resolveCascade: () => resolveCascade,
+  resolveClassNames: () => resolveClassNames,
+  resolveConflictGroup: () => resolveConflictGroup,
+  resolveSimpleVariants: () => resolveSimpleVariants,
+  resolveThemeValue: () => resolveThemeValue,
+  resolveVariants: () => resolveVariants,
+  reverseLookupProperty: () => reverseLookupProperty,
+  reverseLookupValue: () => reverseLookupValue,
+  runCssPipeline: () => runCssPipeline,
+  runCssPipelineSync: () => runCssPipelineSync,
+  runElimination: () => runElimination,
+  runLoaderTransform: () => runLoaderTransform,
+  scanCacheOptimizations: () => scanCacheOptimizations,
+  scanFile: () => scanFile,
+  scanFileNative: () => scanFileNative,
+  scanFilesBatchNative: () => scanFilesBatchNative,
+  scanProjectUsage: () => scanProjectUsage,
+  scanWorkspace: () => scanWorkspace,
+  shouldProcess: () => shouldProcess,
+  shouldSkipFile: () => shouldSkipFile,
+  startWatch: () => startWatch,
+  stopWatch: () => stopWatch,
+  toAtomicClasses: () => toAtomicClasses,
+  transformSource: () => transformSource,
+  twMerge: () => twMerge,
+  twMergeMany: () => twMergeMany,
+  twMergeManyWithSeparator: () => twMergeManyWithSeparator,
+  twMergeRaw: () => twMergeRaw,
+  twMergeWithSeparator: () => twMergeWithSeparator,
+  unregisterPluginHook: () => unregisterPluginHook,
+  validateCssOutput: () => validateCssOutput,
+  validateThemeConfig: () => validateThemeConfig,
+  valueIdToString: () => valueIdToString,
+  walkAndPrefilterSourceFiles: () => walkAndPrefilterSourceFiles,
+  watchAddPattern: () => watchAddPattern,
+  watchClearAll: () => watchClearAll,
+  watchEventTypeToString: () => watchEventTypeToString,
+  watchGetActiveHandles: () => watchGetActiveHandles,
+  watchPause: () => watchPause,
+  watchRemovePattern: () => watchRemovePattern,
+  watchResume: () => watchResume
+});
+var init_internal = __esm({
+  "packages/domain/compiler/src/internal.ts"() {
+    init_src();
+    init_tailwindEngine();
+    init_compiler();
+    init_parser();
+    init_analyzer();
+    init_cache();
+    init_redis();
+    init_watch();
+  }
+});
+function getNative() {
+  if (_native) return _native;
+  try {
+    const mod = (init_internal(), __toCommonJS(internal_exports));
+    if (typeof mod?.extractTwStateConfigs !== "function" || typeof mod?.generateStaticStateCss !== "function") {
+      return null;
+    }
+    _native = {
+      extractTwStateConfigs: mod.extractTwStateConfigs,
+      generateStaticStateCss: mod.generateStaticStateCss,
+      extractAndGenerateStateCss: mod.extractAndGenerateStateCss ?? // Fallback jika extractAndGenerateStateCss belum di-export
+      ((source, filename) => {
+        const configs = mod.extractTwStateConfigs(source, filename);
+        if (configs.length === 0) return [];
+        return mod.generateStaticStateCss(configs.map((c) => ({
+          tag: c.tag,
+          componentName: c.componentName,
+          statesJson: c.statesJson
+        })));
+      })
+    };
+    return _native;
+  } catch {
+    return null;
+  }
+}
+function* walkSourceFiles(dir) {
+  let entries;
+  try {
+    entries = fs3__namespace.default.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path__namespace.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);
+      if (SOURCE_EXTENSIONS.has(ext)) yield fullPath;
+    }
+  }
+}
+function buildCssHeader(result) {
+  return [
+    "/* \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    " * tw-state-static.css \u2014 Auto-generated by staticStateExtractor.ts",
+    " * DO NOT EDIT. Re-generated on each build.",
+    " *",
+    ` * Files scanned:      ${result.filesScanned}`,
+    ` * Files with states:  ${result.filesWithStates}`,
+    ` * Components found:   ${result.componentsFound}`,
+    ` * Rules generated:    ${result.rulesGenerated}`,
+    ` * Rules skipped:      ${result.rulesSkipped} (akan di-inject runtime sebagai fallback)`,
+    " *",
+    ' * Selector format: .tw-s-[hash][data-stateName="true"] { ... }',
+    " * Hash identik dengan yang dibuat oleh stateEngine.ts di runtime.",
+    " * \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500 */",
+    ""
+  ].join("\n");
+}
+function extractStaticStateCss(srcDir, options = {}) {
+  const { verbose = false, maxFiles = Infinity } = options;
+  const native = getNative();
+  if (!native) {
+    if (verbose) {
+      process.stderr.write(
+        "[tw:static-state] native module tidak tersedia \u2014 skip static CSS pre-generation\n"
+      );
+    }
+    return {
+      filesScanned: 0,
+      filesWithStates: 0,
+      componentsFound: 0,
+      rulesGenerated: 0,
+      rulesSkipped: 0,
+      generatedCss: "",
+      rules: []
+    };
+  }
+  const allConfigs = [];
+  let filesScanned = 0;
+  let filesWithStates = 0;
+  if (native.walkAndPrefilterSourceFiles) {
+    const prefiltered = native.walkAndPrefilterSourceFiles(
+      srcDir,
+      [".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"],
+      ["node_modules", ".next", "dist", "build", ".git", "coverage", "__tests__"],
+      // Required substrings — AND logic, identik dengan JS pre-filter di bawah
+      ["states:", "tw."],
+      maxFiles === Infinity ? null : maxFiles,
+      null
+      // sequential — parallel mode opsional untuk large monorepo
+    );
+    for (const { path: filePath, content: source } of prefiltered) {
+      filesScanned++;
+      const configs = native.extractTwStateConfigs(source, filePath);
+      if (configs.length > 0) {
+        filesWithStates++;
+        allConfigs.push(...configs);
+        if (verbose) {
+          process.stderr.write(
+            `[tw:static-state] ${path__namespace.default.relative(srcDir, filePath)}: ${configs.length} komponen
+`
+          );
+        }
+      }
+    }
+  } else {
+    for (const filePath of walkSourceFiles(srcDir)) {
+      if (filesScanned >= maxFiles) break;
+      let source;
+      try {
+        source = fs3__namespace.default.readFileSync(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      filesScanned++;
+      if (!source.includes("states:") && !source.includes("states :")) continue;
+      if (!source.includes("tw.") && !source.includes("tailwind-styled")) continue;
+      const configs = native.extractTwStateConfigs(source, filePath);
+      if (configs.length > 0) {
+        filesWithStates++;
+        allConfigs.push(...configs);
+        if (verbose) {
+          process.stderr.write(
+            `[tw:static-state] ${path__namespace.default.relative(srcDir, filePath)}: ${configs.length} komponen
+`
+          );
+        }
+      }
+    }
+  }
+  if (allConfigs.length === 0) {
+    return {
+      filesScanned,
+      filesWithStates: 0,
+      componentsFound: 0,
+      rulesGenerated: 0,
+      rulesSkipped: 0,
+      generatedCss: "",
+      rules: []
+    };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueConfigs = [];
+  for (const config of allConfigs) {
+    const key = `${config.tag}::${config.statesJson}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueConfigs.push({
+        tag: config.tag,
+        componentName: config.componentName,
+        statesJson: config.statesJson
+      });
+    }
+  }
+  const allRules = native.generateStaticStateCss(uniqueConfigs, options.resolvedCss ?? null);
+  const rulesSkipped = uniqueConfigs.reduce((total, cfg) => {
+    try {
+      const stateMap = JSON.parse(cfg.statesJson);
+      return total + Object.keys(stateMap).length;
+    } catch {
+      return total;
+    }
+  }, 0) - allRules.length;
+  const byComponent = /* @__PURE__ */ new Map();
+  for (const rule of allRules) {
+    const existing = byComponent.get(rule.componentName) ?? [];
+    existing.push(rule);
+    byComponent.set(rule.componentName, existing);
+  }
+  const cssBlocks = [];
+  for (const [componentName, rules] of byComponent) {
+    cssBlocks.push(`/* ${componentName} */`);
+    for (const rule of rules) {
+      cssBlocks.push(`/* state: ${rule.stateName} */`);
+      cssBlocks.push(rule.cssRule);
+    }
+    cssBlocks.push("");
+  }
+  const result = {
+    filesScanned,
+    filesWithStates,
+    componentsFound: allConfigs.length,
+    rulesGenerated: allRules.length,
+    rulesSkipped: Math.max(0, rulesSkipped),
+    generatedCss: cssBlocks.join("\n"),
+    rules: allRules
+  };
+  result.generatedCss = buildCssHeader(result) + result.generatedCss;
+  return result;
+}
+function appendStaticStateCssToSafelist(srcDir, safelistPath, options = {}) {
+  const result = extractStaticStateCss(srcDir, options);
+  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);
+  if (result.rulesGenerated === 0) {
+    try {
+      fs3__namespace.default.writeFileSync(
+        stateFilePath,
+        "/* tw-state-static.css \u2014 tidak ada state rules yang di-generate */\n",
+        "utf-8"
+      );
+    } catch {
+    }
+    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");
+    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}`
+    ].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 init_staticStateExtractor = __esm({
+  "packages/domain/shared/src/staticStateExtractor.ts"() {
+    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";
+  }
+});
+function getEnvLevel() {
+  const env = process.env.TWS_LOG_LEVEL?.toLowerCase();
+  if (env && env in LEVELS) return env;
+  return process.env.TWS_DEBUG_SCANNER === "1" ? "debug" : "info";
+}
+function setGlobalLogFile(filePath) {
+  _globalLogFile = filePath;
+  _logFileInitialized = false;
+  try {
+    fs3__namespace.default.mkdirSync(path__namespace.default.dirname(filePath), { recursive: true });
+    fs3__namespace.default.writeFileSync(
+      filePath,
+      `# tailwind-styled build log \u2014 ${(/* @__PURE__ */ new Date()).toISOString()}
+`,
+      "utf-8"
+    );
+    _logFileInitialized = true;
+  } catch {
+  }
+}
+function writeToFile(line) {
+  if (!_globalLogFile || !_logFileInitialized) return;
+  try {
+    fs3__namespace.default.appendFileSync(_globalLogFile, line);
+  } catch {
+  }
+}
+function createLogger(prefix, level) {
+  const loggerState = {
+    currentLevel: getEnvLevel(),
+    setLevel(l) {
+      this.currentLevel = l;
+    }
+  };
+  const log2 = (msgLevel, stream, args) => {
+    if (LEVELS[msgLevel] > LEVELS[loggerState.currentLevel]) return;
+    const line = `[${prefix}] ${args.map(String).join(" ")}
+`;
+    process[stream].write(line);
+    writeToFile(line);
+  };
+  return {
+    error: (...a) => log2("error", "stderr", a),
+    warn: (...a) => log2("warn", "stderr", a),
+    info: (...a) => log2("info", "stdout", a),
+    debug: (...a) => log2("debug", "stderr", a),
+    setLevel: loggerState.setLevel,
+    setLogFile: (filePath) => setGlobalLogFile(filePath)
+  };
+}
+var LEVELS, _globalLogFile, _logFileInitialized;
+var init_logger = __esm({
+  "packages/domain/shared/src/logger.ts"() {
+    LEVELS = { silent: 0, error: 1, warn: 2, info: 3, debug: 4 };
+    _globalLogFile = null;
+    _logFileInitialized = false;
+    createLogger("tailwind-styled");
+  }
+});
+function createLogger2(namespace) {
+  const prefix = `[${namespace}]`;
+  return {
+    warn(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    },
+    debug(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    },
+    error(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    },
+    log(...args) {
+      process.stderr.write(`${prefix} ${args.map((a) => typeof a === "string" ? a : String(a)).join(" ")}
+`);
+    }
+  };
+}
+function createDebugLogger(namespace, label) {
+  const prefix = label ? `[${namespace}:${label}]` : `[${namespace}]`;
+  return (msg) => {
+    if (process.env.DEBUG?.includes(namespace) || process.env.TW_DEBUG) {
+      console.debug(prefix, msg);
+    }
+  };
+}
+function formatIssuePath(path6) {
+  if (!path6 || path6.length === 0) return "(root)";
+  return path6.map(
+    (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
+  ).join(".");
+}
+function wrapUnknownError(domain, code, error) {
+  return exports.TwError.wrap(domain, code, error);
+}
+function isTwError(err) {
+  return err instanceof exports.TwError;
+}
+function loadNativeBinding(options) {
+  const { runtimeDir, candidates, isValid } = options;
+  const loadErrors = [];
+  for (const candidate of candidates) {
+    const candidatePath = path__namespace.default.resolve(runtimeDir, candidate);
+    try {
+      if (!fs3__namespace.default.existsSync(candidatePath) && !fs3__namespace.default.existsSync(candidatePath + ".node")) {
+        continue;
+      }
+      const mod = requireNativeModule(candidatePath);
+      if (mod && isValid(mod)) {
+        return { binding: mod, loadErrors, loadedPath: candidatePath };
+      }
+      loadErrors.push({ path: candidatePath, message: options.invalidExportMessage });
+    } catch (e) {
+      loadErrors.push({ path: candidatePath, message: e instanceof Error ? e.message : String(e) });
+    }
+  }
+  return { binding: null, loadErrors };
+}
+function requireNativeModule(p) {
+  return _require2(p);
+}
+function resolveNativeBindingCandidates(options) {
+  const {
+    envVarNames = ["TW_NATIVE_PATH", "TWS_NATIVE_PATH"],
+    includeDefaultCandidates = true,
+    enforceNodeExtensionForEnvPath = false
+  } = options;
+  const runtimeDir = options.runtimeDir || process.cwd();
+  const candidates = [];
+  for (const envVar of envVarNames) {
+    const envPath = process.env[envVar];
+    if (envPath) {
+      candidates.push(enforceNodeExtensionForEnvPath && !envPath.endsWith(".node") ? envPath + ".node" : envPath);
+    }
+  }
+  if (!includeDefaultCandidates) return candidates;
+  if (fs3__namespace.default.existsSync(runtimeDir)) {
+    try {
+      for (const entry of fs3__namespace.default.readdirSync(runtimeDir)) {
+        if (entry.endsWith(".node")) candidates.push(entry);
+      }
+    } catch {
+    }
+  }
+  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`));
+  }
+  return Array.from(new Set(candidates));
+}
+function resolveRuntimeDir(dir, importMetaUrl) {
+  if (dir) return path__namespace.default.resolve(dir);
+  try {
+    return path__namespace.default.dirname(url.fileURLToPath(importMetaUrl));
+  } catch {
+    return process.cwd();
+  }
+}
+function hashContent2(content, algorithm = "md5", length) {
+  const hash = 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 Error) return error.message;
+  return String(error);
+}
+exports.TwError = void 0; var _require2; exports.LRUCache = void 0;
+var init_src2 = __esm({
+  "packages/domain/shared/src/index.ts"() {
+    init_trace();
+    init_error_codes();
+    init_compatibility();
+    init_native_schemas();
+    init_esmHelpers();
+    init_telemetry();
+    init_configSchemas();
+    init_workerResolver();
+    init_codegen();
+    init_native_resolution();
+    init_observability();
+    init_staticStateExtractor();
+    init_logger();
+    exports.TwError = class _TwError extends Error {
+      /** @deprecated Gunakan source */
+      domain;
+      source;
+      code;
+      originalCause;
+      constructor(domainOrSource, code, message, cause) {
+        super(message);
+        this.name = "TwError";
+        this.domain = domainOrSource;
+        this.source = domainOrSource;
+        this.code = code;
+        this.originalCause = cause;
+        if (Error.captureStackTrace) Error.captureStackTrace(this, _TwError);
+      }
+      static fromIo(code, message) {
+        return new _TwError("io", code, message);
+      }
+      static fromCompile(code, message) {
+        return new _TwError("compile", code, message);
+      }
+      static fromRust(err) {
+        if (err instanceof _TwError) return err;
+        if (err instanceof Error) return new _TwError("rust", "RUST_ERROR", err.message, err);
+        if (err && typeof err === "object") {
+          const e = err;
+          return new _TwError("rust", e.code ?? "RUST_ERROR", e.message ?? String(err), err);
+        }
+        return new _TwError("rust", "RUST_ERROR", String(err), err);
+      }
+      /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
+      static fromZod(err) {
+        const first = err.issues?.[0] ?? err.errors?.[0];
+        const path6 = formatIssuePath(first?.path);
+        const message = first ? `${path6}: ${first.message}` : "Schema validation failed";
+        return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
+      }
+      static wrap(source, code, err) {
+        if (err instanceof _TwError) return err;
+        if (err instanceof Error) return new _TwError(source, code, err.message, err);
+        return new _TwError(source, code, String(err), err);
+      }
+      toString() {
+        return `TwError [${this.source}:${this.code}] ${this.message}`;
+      }
+      toJSON() {
+        return { name: this.name, source: this.source, code: this.code, message: this.message };
+      }
+      toCliMessage() {
+        return `[${this.source.toUpperCase()}:${this.code}] ${this.message}`;
+      }
+    };
+    _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)));
+    exports.LRUCache = class {
+      capacity;
+      cache;
+      constructor(capacity) {
+        this.capacity = capacity;
+        this.cache = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        if (!this.cache.has(key)) return void 0;
+        const value = this.cache.get(key);
+        this.cache.delete(key);
+        this.cache.set(key, value);
+        return value;
+      }
+      set(key, value) {
+        if (this.cache.has(key)) {
+          this.cache.delete(key);
+        } else if (this.cache.size >= this.capacity) {
+          const firstKey = this.cache.keys().next().value;
+          if (firstKey !== void 0) {
+            this.cache.delete(firstKey);
+          }
+        }
+        this.cache.set(key, value);
+      }
+      delete(key) {
+        return this.cache.delete(key);
+      }
+      has(key) {
+        return this.cache.has(key);
+      }
+      clear() {
+        this.cache.clear();
+      }
+      entries() {
+        return this.cache.entries();
+      }
+      get size() {
+        return this.cache.size;
+      }
+    };
+  }
+});
+
+// src/umbrella/shared.ts
+init_src2();
 
-exports.ERROR_CODES = ERROR_CODES;
-exports.LRUCache = LRUCache;
-exports.NativeAnalyzerReportSchema = NativeAnalyzerReportSchema;
-exports.NativeCacheEntrySchema = NativeCacheEntrySchema;
-exports.NativeCacheReadResultSchema = NativeCacheReadResultSchema;
-exports.NativeCssCompileResultSchema = NativeCssCompileResultSchema;
-exports.NativeScanFileSchema = NativeScanFileSchema;
-exports.NativeScanResultSchema = NativeScanResultSchema;
-exports.NativeTransformResultSchema = NativeTransformResultSchema;
-exports.NativeWatchResultSchema = NativeWatchResultSchema;
-exports.PackageJsonSchema = PackageJsonSchema;
-exports.RegistryFileSchema = RegistryFileSchema;
-exports.RegistryPluginEntrySchema = RegistryPluginEntrySchema;
-exports.ScanCacheClassEntrySchema = ScanCacheClassEntrySchema;
-exports.ScanCacheSchema = ScanCacheSchema;
-exports.TailwindConfigSchema = TailwindConfigSchema;
-exports.TelemetryCollector = TelemetryCollector;
-exports.TwError = TwError;
+exports.appendStaticStateCssToSafelist = appendStaticStateCssToSafelist;
 exports.assertTailwindV4 = assertTailwindV4;
 exports.calculateHealth = calculateHealth;
 exports.createBuildTimer = createBuildTimer;
 exports.createDebugLogger = createDebugLogger;
 exports.createEsmRequire = createEsmRequire;
-exports.createLogger = createLogger;
+exports.createLogger = createLogger2;
 exports.createObservabilityClient = createObservabilityClient;
 exports.createTraceSnapshot = createTraceSnapshot;
 exports.detectTailwind = detectTailwind;
+exports.extractStaticStateCss = extractStaticStateCss;
 exports.formatDuration = formatDuration;
 exports.formatErrorCode = formatErrorCode;
 exports.formatErrorMessage = formatErrorMessage;
@@ -1196,7 +3743,7 @@ exports.getModeColor = getModeColor;
 exports.getPipelinePercentages = getPipelinePercentages;
 exports.getSuggestion = getSuggestion;
 exports.getTailwindVersion = getTailwindVersion;
-exports.hashContent = hashContent;
+exports.hashContent = hashContent2;
 exports.isTailwindV4 = isTailwindV4;
 exports.isTwError = isTwError;
 exports.loadNativeBinding = loadNativeBinding;
@@ -1212,6 +3759,7 @@ 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