tailwind-styled-v4 5.0.11 → 5.0.12

package/dist/shared.mjs

@@ -1,19 +1,39 @@
-import { createHash } from 'crypto';
-import * as fs from 'fs';
-import fs__default from 'fs';
+import { z } from 'zod';
+import { createRequire } from 'module';
+import * as fs3 from 'fs';
+import fs3__default from 'fs';
 import * as path from 'path';
 import path__default from 'path';
+import { createHash } from 'crypto';
 import { fileURLToPath } from 'url';
-import { createRequire } from 'module';
-import { z } from 'zod';
 
 /* 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) {
@@ -105,43 +125,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];
 }
@@ -149,6 +138,46 @@ function formatErrorCode(code) {
   const prefix = code.startsWith("E") ? "Error" : code.startsWith("W") ? "Warning" : "Code";
   return `[${prefix} ${code}]`;
 }
+var ERROR_CODES, ERROR_SUGGESTIONS;
+var init_error_codes = __esm({
+  "packages/domain/shared/src/error-codes.ts"() {
+    ERROR_CODES = {
+      // E0xx — Native binding
+      NATIVE_NOT_FOUND: "E001",
+      NATIVE_LOAD_FAILED: "E002",
+      NATIVE_VERSION_MISMATCH: "E003",
+      SCANNER_NATIVE_NOT_FOUND: "E004",
+      SCANNER_HASH_FAILED: "E005",
+      NATIVE_TRANSFORM_UNAVAILABLE: "E006",
+      // E2xx — Compilation
+      MISSING_REACT_IMPORT: "E201",
+      UNSUPPORTED_PATTERN: "E202",
+      TEMPLATE_PARSE_ERROR: "E203",
+      COMPILE_TIMEOUT: "E204",
+      // E3xx — Compatibility
+      TAILWIND_VERSION_UNSUPPORTED: "E301",
+      NODE_VERSION_UNSUPPORTED: "E302",
+      // E4xx — Cache
+      CACHE_READ_FAILED: "E401",
+      CACHE_WRITE_FAILED: "E402",
+      CACHE_CORRUPTED: "E403",
+      // E5xx — RSC
+      RSC_BOUNDARY_CONFLICT: "E501",
+      // W1xx — Warnings
+      DYNAMIC_CONTENT: "W101",
+      INVALID_VARIANT_VALUE: "W201",
+      DEPRECATED_MODE: "W301"
+    };
+    ERROR_SUGGESTIONS = {
+      E001: "Run: npm install @tailwind-styled/native-{platform} or build from source",
+      E002: "Try: npm rebuild or reinstall the package",
+      E003: "Run: npm install tailwind-styled-v4@latest to sync versions",
+      E004: "Run: npm install @tailwind-styled/scanner",
+      E006: "Run: npm install @tailwind-styled/compiler",
+      E301: "Upgrade: npm install tailwindcss@^4"
+    };
+  }
+});
 
 // packages/domain/shared/src/compatibility.ts
 function detectTailwind() {
@@ -176,64 +205,9 @@ function getTailwindVersion() {
 function isTailwindV4() {
   return detectTailwind().supported;
 }
-var NativeScanFileSchema = z.object({
-  file: z.string().min(1, "file path cannot be empty"),
-  classes: z.array(z.string()),
-  hash: z.string().optional()
-});
-var NativeScanResultSchema = z.object({
-  files: z.array(NativeScanFileSchema),
-  totalFiles: z.number().int().nonnegative(),
-  uniqueClasses: z.array(z.string())
-});
-var NativeClassUsageSchema = z.object({
-  name: z.string(),
-  count: z.number().int().nonnegative(),
-  files: z.array(z.string()).optional()
-});
-var NativeAnalyzerReportSchema = z.object({
-  root: z.string(),
-  topClasses: z.array(NativeClassUsageSchema).optional(),
-  safelist: z.array(z.string()).optional(),
-  css: z.string().optional(),
-  conflicts: z.array(z.unknown()).optional(),
-  unusedClasses: z.array(z.string()).optional(),
-  durationMs: z.number().nonnegative().optional()
-});
-var NativeTransformResultSchema = z.object({
-  code: z.string(),
-  classes: z.array(z.string()),
-  changed: z.boolean(),
-  rsc: z.object({
-    isServer: z.boolean(),
-    needsClientDirective: z.boolean(),
-    clientReasons: z.array(z.string())
-  }).optional()
-});
-var NativeCssCompileResultSchema = z.object({
-  css: z.string(),
-  resolvedClasses: z.array(z.string()),
-  unresolvedClasses: z.array(z.string()).optional()
-});
-z.object({
-  type: z.enum(["change", "unlink", "create"]),
-  path: z.string()
-});
-var NativeWatchResultSchema = z.object({
-  status: z.enum(["ok", "error"]),
-  handleId: z.string().optional(),
-  error: z.string().optional()
-});
-var NativeCacheEntrySchema = z.object({
-  file: z.string(),
-  hash: z.string(),
-  classes: z.array(z.string()),
-  timestamp: z.number(),
-  size: z.number().optional()
-});
-var NativeCacheReadResultSchema = z.object({
-  entries: z.array(NativeCacheEntrySchema),
-  version: z.string().optional()
+var init_compatibility = __esm({
+  "packages/domain/shared/src/compatibility.ts"() {
+  }
 });
 function safeParseNative(schema, data, fallback) {
   const result = schema.safeParse(data);
@@ -243,17 +217,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;
 }
+var NativeScanFileSchema, NativeScanResultSchema, NativeClassUsageSchema, NativeAnalyzerReportSchema, NativeTransformResultSchema, NativeCssCompileResultSchema, NativeWatchResultSchema, NativeCacheEntrySchema, NativeCacheReadResultSchema;
+var init_native_schemas = __esm({
+  "packages/domain/shared/src/native-schemas.ts"() {
+    NativeScanFileSchema = z.object({
+      file: z.string().min(1, "file path cannot be empty"),
+      classes: z.array(z.string()),
+      hash: z.string().optional()
+    });
+    NativeScanResultSchema = z.object({
+      files: z.array(NativeScanFileSchema),
+      totalFiles: z.number().int().nonnegative(),
+      uniqueClasses: z.array(z.string())
+    });
+    NativeClassUsageSchema = z.object({
+      name: z.string(),
+      count: z.number().int().nonnegative(),
+      files: z.array(z.string()).optional()
+    });
+    NativeAnalyzerReportSchema = z.object({
+      root: z.string(),
+      topClasses: z.array(NativeClassUsageSchema).optional(),
+      safelist: z.array(z.string()).optional(),
+      css: z.string().optional(),
+      conflicts: z.array(z.unknown()).optional(),
+      unusedClasses: z.array(z.string()).optional(),
+      durationMs: z.number().nonnegative().optional()
+    });
+    NativeTransformResultSchema = z.object({
+      code: z.string(),
+      classes: z.array(z.string()),
+      changed: z.boolean(),
+      rsc: z.object({
+        isServer: z.boolean(),
+        needsClientDirective: z.boolean(),
+        clientReasons: z.array(z.string())
+      }).optional()
+    });
+    NativeCssCompileResultSchema = z.object({
+      css: z.string(),
+      resolvedClasses: z.array(z.string()),
+      unresolvedClasses: z.array(z.string()).optional()
+    });
+    z.object({
+      type: z.enum(["change", "unlink", "create"]),
+      path: z.string()
+    });
+    NativeWatchResultSchema = z.object({
+      status: z.enum(["ok", "error"]),
+      handleId: z.string().optional(),
+      error: z.string().optional()
+    });
+    NativeCacheEntrySchema = z.object({
+      file: z.string(),
+      hash: z.string(),
+      classes: z.array(z.string()),
+      timestamp: z.number(),
+      size: z.number().optional()
+    });
+    NativeCacheReadResultSchema = z.object({
+      entries: z.array(NativeCacheEntrySchema),
+      version: z.string().optional()
+    });
+  }
+});
 
 // packages/domain/shared/src/esmHelpers.ts
-var isBrowser = typeof window !== "undefined" || typeof document !== "undefined";
-var nodeModuleRef = null;
 function getNodeModuleRef() {
   if (isBrowser) return null;
   if (nodeModuleRef !== null) return nodeModuleRef;
@@ -266,9 +302,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();
@@ -336,72 +369,18 @@ 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();
@@ -440,68 +419,75 @@ function createBuildTimer() {
     }
   };
 }
-var ScanCacheClassEntrySchema = z.object({
-  name: z.string().min(1),
-  usedIn: z.array(z.string()),
-  risk: z.enum(["low", "medium", "high"]).default("low"),
-  bundleContribution: z.number().nonnegative().default(0),
-  variants: z.array(z.string()).default([])
-});
-var ScanCacheSchema = z.object({
-  version: z.string().default("1"),
-  generatedAt: z.string(),
-  root: z.string(),
-  classNames: z.array(ScanCacheClassEntrySchema),
-  totalFiles: z.number().int().nonnegative(),
-  uniqueCount: z.number().int().nonnegative()
-});
-var TailwindContentItemSchema = z.union([
-  z.string(),
-  z.object({
-    raw: z.string(),
-    extension: z.string().optional()
-  }),
-  z.object({
-    files: z.array(z.string()),
-    transform: z.record(z.string(), z.unknown()).optional()
-  })
-]);
-var TailwindConfigSchema = z.object({
-  content: z.array(TailwindContentItemSchema).optional(),
-  theme: z.record(z.string(), z.unknown()).optional(),
-  plugins: z.array(z.unknown()).optional(),
-  darkMode: z.union([z.literal("class"), z.literal("media"), z.literal(false)]).optional(),
-  prefix: z.string().optional(),
-  safelist: z.array(z.union([z.string(), z.object({ pattern: z.instanceof(RegExp) })])).optional(),
-  blocklist: z.array(z.string()).optional()
-}).passthrough();
-var RegistryPluginEntrySchema = z.object({
-  name: z.string().min(1),
-  description: z.string(),
-  version: z.string(),
-  tags: z.array(z.string()).default([]),
-  official: z.boolean().default(false),
-  docs: z.string().url().optional(),
-  install: z.string().optional(),
-  integrity: z.string().optional()
-});
-var RegistryFileSchema = z.object({
-  version: z.string(),
-  official: z.array(RegistryPluginEntrySchema).default([]),
-  community: z.array(RegistryPluginEntrySchema).default([])
+var RING_BUFFER_SIZE, TelemetryCollector, _globalCollector;
+var init_telemetry = __esm({
+  "packages/domain/shared/src/telemetry.ts"() {
+    RING_BUFFER_SIZE = 100;
+    TelemetryCollector = class {
+      data = [];
+      enabled;
+      constructor(enabled) {
+        this.enabled = enabled ?? (process.env.TWS_TELEMETRY === "1" || process.env.TWS_TELEMETRY === "true");
+      }
+      record(build) {
+        if (!this.enabled) return;
+        if (this.data.length >= RING_BUFFER_SIZE) {
+          this.data.shift();
+        }
+        this.data.push(build);
+      }
+      snapshot() {
+        return [...this.data];
+      }
+      summary() {
+        if (this.data.length === 0) return null;
+        const durations = this.data.map((d) => d.durationMs).sort((a, b) => a - b);
+        const p95Idx = Math.floor(durations.length * 0.95);
+        const avg = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
+        return {
+          totalBuilds: this.data.length,
+          avgDurationMs: avg(durations),
+          p95DurationMs: durations[p95Idx] ?? durations[durations.length - 1] ?? 0,
+          avgCacheHitRate: avg(this.data.map((d) => d.cacheHitRate)),
+          avgFilesScanned: avg(this.data.map((d) => d.filesScanned)),
+          avgClassesExtracted: avg(this.data.map((d) => d.classesExtracted)),
+          phaseAvgs: {
+            scan: avg(this.data.map((d) => d.phases.scan)),
+            compile: avg(this.data.map((d) => d.phases.compile)),
+            engine: avg(this.data.map((d) => d.phases.engine)),
+            output: avg(this.data.map((d) => d.phases.output))
+          },
+          slowestBuildMs: durations[durations.length - 1] ?? 0,
+          fastestBuildMs: durations[0] ?? 0
+        };
+      }
+      reset() {
+        this.data = [];
+      }
+      /** Format ringkas untuk CLI output */
+      formatCli() {
+        const s = this.summary();
+        if (!s) return "[telemetry] no data";
+        return [
+          `[telemetry] ${s.totalBuilds} builds`,
+          `avg ${s.avgDurationMs.toFixed(0)}ms`,
+          `p95 ${s.p95DurationMs.toFixed(0)}ms`,
+          `cache hit ${(s.avgCacheHitRate * 100).toFixed(0)}%`,
+          `${s.avgFilesScanned.toFixed(0)} files`
+        ].join(" \xB7 ");
+      }
+      /** Export sebagai JSON untuk dashboard/prometheus */
+      toJSON() {
+        return {
+          summary: this.summary(),
+          history: this.data.slice(-20)
+          // last 20 builds
+        };
+      }
+    };
+    _globalCollector = null;
+  }
 });
-var PackageJsonSchema = z.object({
-  name: z.string(),
-  version: z.string(),
-  scripts: z.record(z.string(), z.string()).optional(),
-  dependencies: z.record(z.string(), z.string()).optional(),
-  devDependencies: z.record(z.string(), z.string()).optional(),
-  peerDependencies: z.record(z.string(), z.string()).optional(),
-  main: z.string().optional(),
-  module: z.string().optional(),
-  exports: z.unknown().optional(),
-  type: z.enum(["module", "commonjs"]).optional()
-}).passthrough();
 function parseJsonWithSchema(jsonString, schema, sourceName) {
   let parsed;
   try {
@@ -532,12 +518,75 @@ function parseJsonFileWithSchema(filePath, schema) {
   }
   return parseJsonWithSchema(content, schema, basename(filePath));
 }
+var ScanCacheClassEntrySchema, ScanCacheSchema, TailwindContentItemSchema, TailwindConfigSchema, RegistryPluginEntrySchema, RegistryFileSchema, PackageJsonSchema;
+var init_configSchemas = __esm({
+  "packages/domain/shared/src/configSchemas.ts"() {
+    ScanCacheClassEntrySchema = z.object({
+      name: z.string().min(1),
+      usedIn: z.array(z.string()),
+      risk: z.enum(["low", "medium", "high"]).default("low"),
+      bundleContribution: z.number().nonnegative().default(0),
+      variants: z.array(z.string()).default([])
+    });
+    ScanCacheSchema = z.object({
+      version: z.string().default("1"),
+      generatedAt: z.string(),
+      root: z.string(),
+      classNames: z.array(ScanCacheClassEntrySchema),
+      totalFiles: z.number().int().nonnegative(),
+      uniqueCount: z.number().int().nonnegative()
+    });
+    TailwindContentItemSchema = z.union([
+      z.string(),
+      z.object({
+        raw: z.string(),
+        extension: z.string().optional()
+      }),
+      z.object({
+        files: z.array(z.string()),
+        transform: z.record(z.string(), z.unknown()).optional()
+      })
+    ]);
+    TailwindConfigSchema = z.object({
+      content: z.array(TailwindContentItemSchema).optional(),
+      theme: z.record(z.string(), z.unknown()).optional(),
+      plugins: z.array(z.unknown()).optional(),
+      darkMode: z.union([z.literal("class"), z.literal("media"), z.literal(false)]).optional(),
+      prefix: z.string().optional(),
+      safelist: z.array(z.union([z.string(), z.object({ pattern: z.instanceof(RegExp) })])).optional(),
+      blocklist: z.array(z.string()).optional()
+    }).passthrough();
+    RegistryPluginEntrySchema = z.object({
+      name: z.string().min(1),
+      description: z.string(),
+      version: z.string(),
+      tags: z.array(z.string()).default([]),
+      official: z.boolean().default(false),
+      docs: z.string().url().optional(),
+      install: z.string().optional(),
+      integrity: z.string().optional()
+    });
+    RegistryFileSchema = z.object({
+      version: z.string(),
+      official: z.array(RegistryPluginEntrySchema).default([]),
+      community: z.array(RegistryPluginEntrySchema).default([])
+    });
+    PackageJsonSchema = z.object({
+      name: z.string(),
+      version: z.string(),
+      scripts: z.record(z.string(), z.string()).optional(),
+      dependencies: z.record(z.string(), z.string()).optional(),
+      devDependencies: z.record(z.string(), z.string()).optional(),
+      peerDependencies: z.record(z.string(), z.string()).optional(),
+      main: z.string().optional(),
+      module: z.string().optional(),
+      exports: z.unknown().optional(),
+      type: z.enum(["module", "commonjs"]).optional()
+    }).passthrough();
+  }
+});
 
 // packages/domain/shared/src/workerResolver.ts
-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 "";
@@ -563,11 +612,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;
   }
@@ -617,6 +666,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) {
@@ -774,16 +832,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 : createRequire(import.meta.url);
-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}`;
@@ -794,12 +846,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.existsSync(envPath)) {
+    if (fs3.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
@@ -808,7 +860,7 @@ function resolveNativeBinary(runtimeDir) {
   for (const pkg of prebuiltPkgs) {
     try {
       const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs.existsSync(candidate)) {
+      if (fs3.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -825,7 +877,7 @@ function resolveNativeBinary(runtimeDir) {
         for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
           const candidate = path.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
           tried.push(`self-bundled:${candidate}`);
-          if (fs.existsSync(candidate)) {
+          if (fs3.existsSync(candidate)) {
             return { path: candidate, source: "prebuilt", platform, tried };
           }
         }
@@ -859,7 +911,7 @@ function resolveNativeBinary(runtimeDir) {
   }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs.existsSync(candidate)) {
+    if (fs3.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
@@ -879,13 +931,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 : createRequire(import.meta.url);
+    PLATFORM_MAP = {
+      "linux-x64": ["@tailwind-styled/native-linux-x64-gnu", "@tailwind-styled/native-linux-x64"],
+      "linux-arm64": ["@tailwind-styled/native-linux-arm64-gnu", "@tailwind-styled/native-linux-arm64"],
+      "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;
@@ -912,9 +979,1187 @@ function createObservabilityClient(opts = {}) {
     }
   };
 }
+var init_observability = __esm({
+  "packages/domain/shared/src/observability.ts"() {
+  }
+});
+
+// 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, import.meta.url);
+        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 {
+      }
+    }
+  }
+});
+
+// packages/domain/compiler/src/tailwindEngine.ts
+var tailwindEngine_exports = {};
+__export(tailwindEngine_exports, {
+  clearCache: () => clearCache,
+  generateRawCss: () => generateRawCss,
+  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 loadTailwindEngine() {
+  if (_twEngine) return _twEngine;
+  if (_twEngineError) throw _twEngineError;
+  try {
+    const tw = require2("tailwindcss");
+    if (typeof tw.compile !== "function") {
+      throw new Error("tailwindcss v4 not found \u2014 compile() API missing. Check tailwindcss version >= 4.");
+    }
+    _twEngine = tw;
+    return _twEngine;
+  } catch (e) {
+    _twEngineError = e instanceof Error ? e : new Error(String(e));
+    throw _twEngineError;
+  }
+}
+async function generateRawCss(classes, cssEntryContent, root) {
+  if (classes.length === 0) return "";
+  const tw = loadTailwindEngine();
+  const input = cssEntryContent ?? "@import 'tailwindcss';";
+  const { readFileSync, existsSync: existsSync3 } = await import('fs');
+  const { dirname, resolve: resolve2 } = await import('path');
+  const projectRoot = root ?? process.cwd();
+  const req = createRequire(resolve2(projectRoot, "package.json"));
+  const loadStylesheet = async (id, base) => {
+    try {
+      const cssId = id === "tailwindcss" ? "tailwindcss/index.css" : id === "tailwindcss/preflight" ? "tailwindcss/preflight.css" : id === "tailwindcss/utilities" ? "tailwindcss/utilities.css" : id === "tailwindcss/theme" ? "tailwindcss/theme.css" : id;
+      const pkgPath = req.resolve(cssId);
+      return { content: readFileSync(pkgPath, "utf-8"), base: dirname(pkgPath) };
+    } catch {
+      try {
+        const absPath = resolve2(base, id);
+        if (existsSync3(absPath)) {
+          return { content: readFileSync(absPath, "utf-8"), base: dirname(absPath) };
+        }
+      } catch {
+      }
+      return { content: "", base };
+    }
+  };
+  const compiler = await Promise.resolve(tw.compile(input, { loadStylesheet }));
+  return compiler.build(classes);
+}
+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;
+  try {
+    const theme = getThemeConfig();
+    rawCss = await generateCssNative(unique, {
+      theme,
+      fallbackToJs: true,
+      logFallback: process.env.DEBUG?.includes("compiler") === true
+    });
+    usedRustCompiler = true;
+  } catch (error) {
+    if (process.env.DEBUG?.includes("compiler")) {
+      console.warn("[Compiler] Rust compiler failed, using JavaScript Tailwind:", error);
+    }
+    rawCss = await generateRawCss(unique, cssEntryContent, root);
+  }
+  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 require2, _cssCache, _cacheHits, _cacheMisses, MAX_CACHE_SIZE, _twEngine, _twEngineError;
+var init_tailwindEngine = __esm({
+  "packages/domain/compiler/src/tailwindEngine.ts"() {
+    init_nativeBridge();
+    init_cssGeneratorNative();
+    require2 = createRequire(import.meta.url);
+    _cssCache = /* @__PURE__ */ new Map();
+    _cacheHits = 0;
+    _cacheMisses = 0;
+    MAX_CACHE_SIZE = 100;
+    _twEngine = null;
+    _twEngineError = null;
+  }
+});
+
+// packages/domain/compiler/src/cssGeneratorNative.ts
+async function generateCssNative(classes, options) {
+  const {
+    theme,
+    fallbackToJs = true,
+    logFallback = false
+  } = options;
+  try {
+    const native = getNativeBridge();
+    if (!native?.generateCssNative) {
+      throw new Error("generateCssNative not available in native binding");
+    }
+    const themeJson = JSON.stringify(theme);
+    const css = native.generateCssNative(classes, themeJson);
+    return css;
+  } catch (error) {
+    if (!fallbackToJs) {
+      throw error;
+    }
+    if (logFallback) {
+      console.warn(
+        "[CSS Compiler] Rust CSS generator unavailable, falling back to JavaScript Tailwind",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    return generateRawCss(classes);
+  }
+}
+var init_cssGeneratorNative = __esm({
+  "packages/domain/compiler/src/cssGeneratorNative.ts"() {
+    init_nativeBridge();
+    init_tailwindEngine();
+  }
+});
+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, compileCssNative, generateCssForClasses, extractAllClasses, extractClassesFromSource, astExtractClasses, parseClasses, normalizeClasses, mergeClassesStatic, normalizeAndDedupClasses, eliminateDeadCss, findDeadVariants, runElimination, optimizeCss, scanProjectUsage, extractComponentUsage, diffClassLists, batchExtractClasses, checkAgainstSafelist, hoistComponents, compileVariantTable, compileVariants, classifyAndSortClasses, mergeCssDeclarations, analyzeClassUsage, analyzeRsc, analyzeFile, analyzeVariantUsage, injectClientDirective, injectServerOnlyComment, analyzeClasses, generateSafelist, loadSafelist, loadTailwindConfig, getContentPaths, _CONTAINER_BREAKPOINTS, runLoaderTransform, shouldSkipFile, fileToRoute, getAllRoutes, getRouteClasses, registerFileClasses, registerGlobalClasses, _incrementalEngineInstance, getIncrementalEngine, resetIncrementalEngine, IncrementalEngine, getBucketEngine, resetBucketEngine, classifyNode, detectConflicts, bucketSort, extractTwStateConfigs, generateStaticStateCss, extractAndGenerateStateCss;
+var init_src = __esm({
+  "packages/domain/compiler/src/index.ts"() {
+    init_nativeBridge();
+    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>` : "";
+    };
+    compileCssNative = (classes, prefix = null) => {
+      return compileCssFromClasses(classes, prefix);
+    };
+    generateCssForClasses = async (classes, _tailwindConfig, root, cssEntryContent, minify = false) => {
+      const { runCssPipeline: runCssPipeline2 } = await Promise.resolve().then(() => (init_tailwindEngine(), tailwindEngine_exports));
+      const result = await runCssPipeline2(classes, cssEntryContent, root, minify);
+      return result.css;
+    };
+    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) || [];
+    };
+    parseClasses = (raw) => {
+      const native = getNativeBridge();
+      if (!native?.parseClasses) {
+        throw new Error("FATAL: Native binding 'parseClasses' is required but not available.");
+      }
+      return native.parseClasses(raw) || [];
+    };
+    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 };
+    };
+    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 ?? []));
+    };
+    optimizeCss = (css) => {
+      const native = getNativeBridge();
+      if (!native?.optimizeCss) {
+        throw new Error("FATAL: Native binding 'optimizeCss' is required but not available.");
+      }
+      return native.optimizeCss(css);
+    };
+    scanProjectUsage = (dirs, cwd) => {
+      const files = dirs.map((dir) => path__default.resolve(cwd, dir));
+      const results = batchExtractClasses(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;
+    };
+    extractComponentUsage = (source) => {
+      const native = getNativeBridge();
+      if (!native?.extractComponentUsage) {
+        throw new Error("FATAL: Native binding 'extractComponentUsage' is required but not available.");
+      }
+      return native.extractComponentUsage(source) || [];
+    };
+    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 };
+    };
+    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 };
+    };
+    hoistComponents = (source) => {
+      const native = getNativeBridge();
+      if (!native?.hoistComponents) {
+        throw new Error("FATAL: Native binding 'hoistComponents' is required but not available.");
+      }
+      return native.hoistComponents(source) || { code: source, hoisted: [], warnings: [] };
+    };
+    compileVariantTable = (configJson) => {
+      const native = getNativeBridge();
+      if (!native?.compileVariantTable) {
+        throw new Error("FATAL: Native binding 'compileVariantTable' is required but not available.");
+      }
+      return native.compileVariantTable(configJson) || { id: "", tableJson: "{}", keys: [], defaultKey: "", combinations: 0 };
+    };
+    compileVariants = (componentId, config) => {
+      return compileVariantTable(JSON.stringify({ componentId, ...config }));
+    };
+    classifyAndSortClasses = (classes) => {
+      const native = getNativeBridge();
+      if (!native?.classifyAndSortClasses) {
+        throw new Error("FATAL: Native binding 'classifyAndSortClasses' is required but not available.");
+      }
+      return native.classifyAndSortClasses(classes) || [];
+    };
+    mergeCssDeclarations = (cssChunks) => {
+      const native = getNativeBridge();
+      if (!native?.mergeCssDeclarations) {
+        throw new Error("FATAL: Native binding 'mergeCssDeclarations' is required but not available.");
+      }
+      return native.mergeCssDeclarations(cssChunks) || { declarationsJson: "{}", declarationString: "", count: 0 };
+    };
+    analyzeClassUsage = (classes, scanResultJson, css) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeClassUsage) {
+        throw new Error("FATAL: Native binding 'analyzeClassUsage' is required but not available.");
+      }
+      return native.analyzeClassUsage(classes, scanResultJson, css) || [];
+    };
+    analyzeRsc = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.analyzeRsc) {
+        throw new Error("FATAL: Native binding 'analyzeRsc' is required but not available.");
+      }
+      return native.analyzeRsc(source, filename) || { isServer: true, needsClientDirective: false, clientReasons: [] };
+    };
+    analyzeFile = (source, filename) => {
+      const rsc = 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);
+    };
+    generateSafelist = (scanDirs, outputPath, cwd) => {
+      const classes = scanProjectUsage(scanDirs, cwd || process.cwd());
+      const allClasses = Object.keys(classes).sort();
+      if (outputPath) {
+        fs3__default.writeFileSync(outputPath, JSON.stringify(allClasses, null, 2));
+      }
+      return allClasses;
+    };
+    loadSafelist = (safelistPath) => {
+      try {
+        const content = fs3__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__default.join(cwd, file);
+        if (fs3__default.existsSync(fullPath)) {
+          const mod = __require(fullPath);
+          return mod.default || mod;
+        }
+      }
+      return {};
+    };
+    getContentPaths = (cwd = process.cwd()) => {
+      return {
+        content: [
+          path__default.join(cwd, "src/**/*.{js,ts,jsx,tsx}"),
+          path__default.join(cwd, "app/**/*.{js,ts,jsx,tsx}"),
+          path__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 {
+      }
+      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) => {
+      return classifyAndSortClasses(classes).map((c) => c.raw ?? c);
+    };
+    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 = (inputs, resolvedCss = null) => {
+      const native = getNativeBridge();
+      if (!native?.generateStaticStateCss) {
+        throw new Error("FATAL: Native binding 'generateStaticStateCss' is required but not available.");
+      }
+      return native.generateStaticStateCss(inputs, resolvedCss);
+    };
+    extractAndGenerateStateCss = (source, filename) => {
+      const native = getNativeBridge();
+      if (!native?.extractAndGenerateStateCss) {
+        const configs = extractTwStateConfigs(source, filename);
+        if (configs.length === 0) return [];
+        return generateStaticStateCss(
+          configs.map((c) => ({ tag: c.tag, componentName: c.componentName, statesJson: c.statesJson }))
+        );
+      }
+      return native.extractAndGenerateStateCss(source, filename);
+    };
+  }
+});
 
-// packages/domain/shared/src/index.ts
-function createLogger(namespace) {
+// packages/domain/compiler/src/internal.ts
+var internal_exports = {};
+__export(internal_exports, {
+  adaptNativeResult: () => adaptNativeResult,
+  analyzeClassUsage: () => analyzeClassUsage,
+  analyzeClasses: () => analyzeClasses,
+  analyzeFile: () => analyzeFile,
+  analyzeRsc: () => analyzeRsc,
+  analyzeVariantUsage: () => analyzeVariantUsage,
+  astExtractClasses: () => astExtractClasses,
+  batchExtractClasses: () => batchExtractClasses,
+  bucketSort: () => bucketSort,
+  buildStyleTag: () => buildStyleTag,
+  checkAgainstSafelist: () => checkAgainstSafelist,
+  classifyAndSortClasses: () => classifyAndSortClasses,
+  classifyNode: () => classifyNode,
+  clearCache: () => clearCache,
+  compileCssFromClasses: () => compileCssFromClasses,
+  compileCssNative: () => compileCssNative,
+  compileVariantTable: () => compileVariantTable,
+  compileVariants: () => compileVariants,
+  detectConflicts: () => detectConflicts,
+  diffClassLists: () => diffClassLists,
+  eliminateDeadCss: () => eliminateDeadCss,
+  extractAllClasses: () => extractAllClasses,
+  extractAndGenerateStateCss: () => extractAndGenerateStateCss,
+  extractClassesFromSource: () => extractClassesFromSource,
+  extractComponentUsage: () => extractComponentUsage,
+  extractContainerCssFromSource: () => extractContainerCssFromSource,
+  extractTwStateConfigs: () => extractTwStateConfigs,
+  fileToRoute: () => fileToRoute,
+  findDeadVariants: () => findDeadVariants,
+  generateCssForClasses: () => generateCssForClasses,
+  generateRawCss: () => generateRawCss,
+  generateSafelist: () => generateSafelist,
+  generateStaticStateCss: () => generateStaticStateCss,
+  getAllRoutes: () => getAllRoutes,
+  getBucketEngine: () => getBucketEngine,
+  getCacheStats: () => getCacheStats,
+  getContentPaths: () => getContentPaths,
+  getIncrementalEngine: () => getIncrementalEngine,
+  getNativeBridge: () => getNativeBridge,
+  getRouteClasses: () => getRouteClasses,
+  hasTwUsage: () => hasTwUsage,
+  hoistComponents: () => hoistComponents,
+  injectClientDirective: () => injectClientDirective,
+  injectServerOnlyComment: () => injectServerOnlyComment,
+  isAlreadyTransformed: () => isAlreadyTransformed,
+  loadSafelist: () => loadSafelist,
+  loadTailwindConfig: () => loadTailwindConfig,
+  mergeClassesStatic: () => mergeClassesStatic,
+  mergeCssDeclarations: () => mergeCssDeclarations,
+  normalizeAndDedupClasses: () => normalizeAndDedupClasses,
+  normalizeClasses: () => normalizeClasses,
+  optimizeCss: () => optimizeCss,
+  parseClasses: () => parseClasses,
+  registerFileClasses: () => registerFileClasses,
+  registerGlobalClasses: () => registerGlobalClasses,
+  resetBucketEngine: () => resetBucketEngine,
+  resetIncrementalEngine: () => resetIncrementalEngine,
+  runCssPipeline: () => runCssPipeline,
+  runCssPipelineSync: () => runCssPipelineSync,
+  runElimination: () => runElimination,
+  runLoaderTransform: () => runLoaderTransform,
+  scanProjectUsage: () => scanProjectUsage,
+  shouldProcess: () => shouldProcess,
+  shouldSkipFile: () => shouldSkipFile,
+  transformSource: () => transformSource
+});
+var init_internal = __esm({
+  "packages/domain/compiler/src/internal.ts"() {
+    init_src();
+    init_tailwindEngine();
+  }
+});
+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__default.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = path__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__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__default.relative(srcDir, filePath)}: ${configs.length} komponen
+`
+          );
+        }
+      }
+    }
+  } else {
+    for (const filePath of walkSourceFiles(srcDir)) {
+      if (filesScanned >= maxFiles) break;
+      let source;
+      try {
+        source = fs3__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__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__default.join(path__default.dirname(safelistPath), "tw-classes");
+  fs3__default.mkdirSync(twClassesDir, { recursive: true });
+  const stateFilePath = path__default.join(twClassesDir, TW_STATE_STATIC_FILENAME);
+  if (result.rulesGenerated === 0) {
+    try {
+      fs3__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__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/${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, TW_STATE_STATIC_FILENAME;
+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;
+    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__default.mkdirSync(path__default.dirname(filePath), { recursive: true });
+    fs3__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__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) {
@@ -943,64 +2188,12 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path3) {
-  if (!path3 || path3.length === 0) return "(root)";
-  return path3.map(
+function formatIssuePath(path6) {
+  if (!path6 || path6.length === 0) return "(root)";
+  return path6.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
-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);
-    }
-    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}`;
-  }
-  toJSON() {
-    return { name: this.name, source: this.source, code: this.code, message: this.message };
-  }
-  toCliMessage() {
-    return `[${this.source.toUpperCase()}:${this.code}] ${this.message}`;
-  }
-};
 function wrapUnknownError(domain, code, error) {
   return TwError.wrap(domain, code, error);
 }
@@ -1013,7 +2206,7 @@ function loadNativeBinding(options) {
   for (const candidate of candidates) {
     const candidatePath = path__default.resolve(runtimeDir, candidate);
     try {
-      if (!fs__default.existsSync(candidatePath) && !fs__default.existsSync(candidatePath + ".node")) {
+      if (!fs3__default.existsSync(candidatePath) && !fs3__default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -1027,7 +2220,6 @@ function loadNativeBinding(options) {
   }
   return { binding: null, loadErrors };
 }
-var _require2 = createRequire(import.meta.url);
 function requireNativeModule(p) {
   return _require2(p);
 }
@@ -1046,9 +2238,9 @@ function resolveNativeBindingCandidates(options) {
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs__default.existsSync(runtimeDir)) {
+  if (fs3__default.existsSync(runtimeDir)) {
     try {
-      for (const entry of fs__default.readdirSync(runtimeDir)) {
+      for (const entry of fs3__default.readdirSync(runtimeDir)) {
         if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
@@ -1086,48 +2278,122 @@ function formatErrorMessage(error) {
   if (error instanceof Error) return error.message;
   return String(error);
 }
-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);
+var TwError, _require2, LRUCache;
+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();
+    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);
       }
-    }
-    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;
+      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 = createRequire(import.meta.url);
+    LRUCache = class {
+      capacity;
+      cache;
+      constructor(capacity) {
+        this.capacity = capacity;
+        this.cache = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        if (!this.cache.has(key)) return void 0;
+        const value = this.cache.get(key);
+        this.cache.delete(key);
+        this.cache.set(key, value);
+        return value;
+      }
+      set(key, value) {
+        if (this.cache.has(key)) {
+          this.cache.delete(key);
+        } else if (this.cache.size >= this.capacity) {
+          const firstKey = this.cache.keys().next().value;
+          if (firstKey !== void 0) {
+            this.cache.delete(firstKey);
+          }
+        }
+        this.cache.set(key, value);
+      }
+      delete(key) {
+        return this.cache.delete(key);
+      }
+      has(key) {
+        return this.cache.has(key);
+      }
+      clear() {
+        this.cache.clear();
+      }
+      entries() {
+        return this.cache.entries();
+      }
+      get size() {
+        return this.cache.size;
+      }
+    };
   }
-};
+});
+
+// src/umbrella/shared.ts
+init_src2();
 
-export { ERROR_CODES, LRUCache, NativeAnalyzerReportSchema, NativeCacheEntrySchema, NativeCacheReadResultSchema, NativeCssCompileResultSchema, NativeScanFileSchema, NativeScanResultSchema, NativeTransformResultSchema, NativeWatchResultSchema, PackageJsonSchema, RegistryFileSchema, RegistryPluginEntrySchema, ScanCacheClassEntrySchema, ScanCacheSchema, TailwindConfigSchema, TelemetryCollector, TwError, assertTailwindV4, calculateHealth, createBuildTimer, createDebugLogger, createEsmRequire, createLogger, createObservabilityClient, createTraceSnapshot, detectTailwind, formatDuration, formatErrorCode, formatErrorMessage, formatMemory, formatNativeNotFoundError, generateBarrelFile, generateClassRenameCodemod, generateComponentCode, generateStorybookStory, getBuildTimeColor, getDirname, getFilename, getGlobalTelemetry, getHealthColor, getMemoryColor, getModeColor, getPipelinePercentages, getSuggestion, getTailwindVersion, hashContent, isTailwindV4, isTwError, loadNativeBinding, parseJsonFileWithSchema, parseJsonWithSchema, parseNative, resetGlobalTelemetry, resolveFromRoot, resolveLoaderPath, resolveNativeBinary, resolveNativeBindingCandidates, resolveNativeNodePath, resolveRuntimeDir, resolveWorkerPath, safeParseNative, tryRequire, wrapUnknownError };
+export { ERROR_CODES, LRUCache, NativeAnalyzerReportSchema, NativeCacheEntrySchema, NativeCacheReadResultSchema, NativeCssCompileResultSchema, NativeScanFileSchema, NativeScanResultSchema, NativeTransformResultSchema, NativeWatchResultSchema, PackageJsonSchema, RegistryFileSchema, RegistryPluginEntrySchema, ScanCacheClassEntrySchema, ScanCacheSchema, TW_STATE_STATIC_FILENAME, TailwindConfigSchema, TelemetryCollector, TwError, appendStaticStateCssToSafelist, assertTailwindV4, calculateHealth, createBuildTimer, createDebugLogger, createEsmRequire, createLogger2 as createLogger, createObservabilityClient, createTraceSnapshot, detectTailwind, extractStaticStateCss, formatDuration, formatErrorCode, formatErrorMessage, formatMemory, formatNativeNotFoundError, generateBarrelFile, generateClassRenameCodemod, generateComponentCode, generateStorybookStory, getBuildTimeColor, getDirname, getFilename, getGlobalTelemetry, getHealthColor, getMemoryColor, getModeColor, getPipelinePercentages, getSuggestion, getTailwindVersion, hashContent, isTailwindV4, isTwError, loadNativeBinding, parseJsonFileWithSchema, parseJsonWithSchema, parseNative, resetGlobalTelemetry, resolveFromRoot, resolveLoaderPath, resolveNativeBinary, resolveNativeBindingCandidates, resolveNativeNodePath, resolveRuntimeDir, resolveWorkerPath, safeParseNative, setGlobalLogFile, tryRequire, wrapUnknownError };
 //# sourceMappingURL=shared.mjs.map
 //# sourceMappingURL=shared.mjs.map