tailwind-styled-v4 5.0.11 → 5.0.13

package/dist/cli.js

@@ -1,14 +1,14 @@
 'use strict';
 
 var module$1 = require('module');
-var fs12 = require('fs');
+var fs11 = require('fs');
 var path6 = require('path');
 require('crypto');
 var url = require('url');
 var worker_threads = require('worker_threads');
 var os = require('os');
 var zod = require('zod');
-var fs8 = require('fs/promises');
+var fs7 = require('fs/promises');
 var prompts = require('@clack/prompts');
 var util = require('util');
 var child_process = require('child_process');
@@ -34,9 +34,9 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs12__namespace = /*#__PURE__*/_interopNamespace(fs12);
+var fs11__namespace = /*#__PURE__*/_interopNamespace(fs11);
 var path6__namespace = /*#__PURE__*/_interopNamespace(path6);
-var fs8__default = /*#__PURE__*/_interopDefault(fs8);
+var fs7__default = /*#__PURE__*/_interopDefault(fs7);
 
 /* tailwind-styled-v4 v5.0.4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
 var __create = Object.create;
@@ -1012,7 +1012,7 @@ var require_command = __commonJS({
   "packages/infrastructure/cli/node_modules/commander/lib/command.js"(exports$1) {
     var EventEmitter = __require("events").EventEmitter;
     var childProcess = __require("child_process");
-    var path29 = __require("path");
+    var path30 = __require("path");
     var fs16 = __require("fs");
     var process2 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -1944,9 +1944,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path29.resolve(baseDir, baseName);
+          const localBin = path30.resolve(baseDir, baseName);
           if (fs16.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path29.extname(baseName))) return void 0;
+          if (sourceExt.includes(path30.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs16.existsSync(`${localBin}${ext}`)
           );
@@ -1964,17 +1964,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path29.resolve(
-            path29.dirname(resolvedScriptPath),
+          executableDir = path30.resolve(
+            path30.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path29.basename(
+            const legacyName = path30.basename(
               this._scriptPath,
-              path29.extname(this._scriptPath)
+              path30.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -1985,7 +1985,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path29.extname(executableFile));
+        launchWithNode = sourceExt.includes(path30.extname(executableFile));
         let proc;
         if (process2.platform !== "win32") {
           if (launchWithNode) {
@@ -2825,7 +2825,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path29.basename(filename, path29.extname(filename));
+        this._name = path30.basename(filename, path30.extname(filename));
         return this;
       }
       /**
@@ -2839,9 +2839,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path30) {
-        if (path30 === void 0) return this._executableDir;
-        this._executableDir = path30;
+      executableDir(path31) {
+        if (path31 === void 0) return this._executableDir;
+        this._executableDir = path31;
         return this;
       }
       /**
@@ -3191,12 +3191,12 @@ function resolveNativeBinary(runtimeDir) {
   if (isBrowser2) {
     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 (fs12__namespace.existsSync(envPath)) {
+    if (fs11__namespace.existsSync(envPath)) {
       return { path: envPath, source: "env", platform, tried };
     }
     tried.push(`env:${envPath} (not found)`);
@@ -3205,7 +3205,7 @@ function resolveNativeBinary(runtimeDir) {
   for (const pkg of prebuiltPkgs) {
     try {
       const candidate = _require.resolve(`${pkg}/tailwind_styled_parser.node`);
-      if (fs12__namespace.existsSync(candidate)) {
+      if (fs11__namespace.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -3222,7 +3222,7 @@ function resolveNativeBinary(runtimeDir) {
         for (const suffix of ["", `.${platform}`, `.${napiPlatform}`]) {
           const candidate = path6__namespace.resolve(pkgRoot, "native", `${bin}${suffix}.node`);
           tried.push(`self-bundled:${candidate}`);
-          if (fs12__namespace.existsSync(candidate)) {
+          if (fs11__namespace.existsSync(candidate)) {
             return { path: candidate, source: "prebuilt", platform, tried };
           }
         }
@@ -3256,7 +3256,7 @@ function resolveNativeBinary(runtimeDir) {
   }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs12__namespace.existsSync(candidate)) {
+    if (fs11__namespace.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
@@ -3306,9 +3306,9 @@ function createDebugLogger(namespace, label) {
     }
   };
 }
-function formatIssuePath(path29) {
-  if (!path29 || path29.length === 0) return "(root)";
-  return path29.map(
+function formatIssuePath(path30) {
+  if (!path30 || path30.length === 0) return "(root)";
+  return path30.map(
     (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
   ).join(".");
 }
@@ -3321,7 +3321,7 @@ function loadNativeBinding(options) {
   for (const candidate of candidates) {
     const candidatePath = path6__namespace.default.resolve(runtimeDir, candidate);
     try {
-      if (!fs12__namespace.default.existsSync(candidatePath) && !fs12__namespace.default.existsSync(candidatePath + ".node")) {
+      if (!fs11__namespace.default.existsSync(candidatePath) && !fs11__namespace.default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -3353,9 +3353,9 @@ function resolveNativeBindingCandidates(options) {
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs12__namespace.default.existsSync(runtimeDir)) {
+  if (fs11__namespace.default.existsSync(runtimeDir)) {
     try {
-      for (const entry of fs12__namespace.default.readdirSync(runtimeDir)) {
+      for (const entry of fs11__namespace.default.readdirSync(runtimeDir)) {
         if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
@@ -3422,8 +3422,8 @@ var init_src = __esm({
       /** Buat TwError dari ZodError — dukung shape Zod v3 (`errors`) dan v4 (`issues`). */
       static fromZod(err) {
         const first = err.issues?.[0] ?? err.errors?.[0];
-        const path29 = formatIssuePath(first?.path);
-        const message = first ? `${path29}: ${first.message}` : "Schema validation failed";
+        const path30 = formatIssuePath(first?.path);
+        const message = first ? `${path30}: ${first.message}` : "Schema validation failed";
         return new _TwError("validation", "SCHEMA_VALIDATION_FAILED", message, err);
       }
       static wrap(source, code, err) {
@@ -3773,7 +3773,7 @@ function defaultCachePath(rootDir, cacheDir) {
 }
 function readCache(rootDir, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs12__namespace.default.mkdirSync(path6__namespace.default.dirname(cachePath), { recursive: true });
+  fs11__namespace.default.mkdirSync(path6__namespace.default.dirname(cachePath), { recursive: true });
   const result = cacheReadNative(cachePath);
   if (!result) return [];
   return result.entries.map((e) => ({
@@ -3788,7 +3788,7 @@ function readCache(rootDir, cacheDir) {
 }
 function writeCache(rootDir, entries, cacheDir) {
   const cachePath = defaultCachePath(rootDir, cacheDir);
-  fs12__namespace.default.mkdirSync(path6__namespace.default.dirname(cachePath), { recursive: true });
+  fs11__namespace.default.mkdirSync(path6__namespace.default.dirname(cachePath), { recursive: true });
   const success = cacheWriteNative(cachePath, entries);
   if (!success) {
     throw new Error(
@@ -3815,27 +3815,7 @@ var init_cache_native = __esm({
 function collectFiles(rootDir, extensions, ignoreDirs) {
   const native = collectFilesNative(rootDir, extensions, ignoreDirs);
   if (native !== null) return native;
-  const files = [];
-  function walk(dir) {
-    let entries;
-    try {
-      entries = fs12__namespace.default.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const fullPath = path6__namespace.default.join(dir, entry.name);
-      const rel = path6__namespace.default.relative(rootDir, fullPath);
-      if (entry.isDirectory()) {
-        const ignored = ignoreDirs.some((d) => entry.name === d || rel.startsWith(d + path6__namespace.default.sep));
-        if (!ignored) walk(fullPath);
-      } else if (isScannableFile(entry.name, extensions)) {
-        files.push(fullPath);
-      }
-    }
-  }
-  walk(rootDir);
-  return files;
+  throw new Error("FATAL: Native binding 'collectFiles' is required but not available.");
 }
 function mergeResults(batchResults) {
   const files = batchResults.map((r) => ({
@@ -3845,8 +3825,7 @@ function mergeResults(batchResults) {
   }));
   const native = rebuildWorkspaceResultNative(files);
   if (native) return native;
-  const unique = new Set(files.flatMap((f) => f.classes));
-  return { files, totalFiles: files.length, uniqueClasses: Array.from(unique).sort() };
+  throw new Error("FATAL: Native binding 'rebuildWorkspaceResult' is required but not available.");
 }
 function runChunkInWorker(filePaths) {
   return new Promise((resolve2, reject) => {
@@ -3917,12 +3896,12 @@ var formatIssuePath2, formatIssues, parseWithSchema, NonNegativeIntegerSchema, S
 var init_schemas = __esm({
   "packages/domain/scanner/src/schemas.ts"() {
     init_src();
-    formatIssuePath2 = (path29) => path29.length > 0 ? path29.map(
+    formatIssuePath2 = (path30) => path30.length > 0 ? path30.map(
       (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
     ).join(".") : "<root>";
     formatIssues = (error) => error.issues.map((issue) => {
-      const path29 = formatIssuePath2(issue.path);
-      return `${path29}: ${issue.message}`;
+      const path30 = formatIssuePath2(issue.path);
+      return `${path30}: ${issue.message}`;
     }).join("; ");
     parseWithSchema = (schema, data, label) => {
       const parsed = schema.safeParse(data);
@@ -3985,7 +3964,7 @@ __export(src_exports, {
   DEFAULT_IGNORES: () => DEFAULT_IGNORES,
   batchExtractClassesNative: () => batchExtractClassesNative,
   extractClassesNative: () => extractClassesNative,
-  isScannableFile: () => isScannableFile,
+  isScannableFile: () => isScannableFile2,
   parseScanWorkspaceOptions: () => parseScanWorkspaceOptions,
   parseScanWorkspaceResult: () => parseScanWorkspaceResult,
   parseScannerWorkerMessage: () => parseScannerWorkerMessage,
@@ -4019,7 +3998,7 @@ function resolveScannerWorkerModulePath() {
     path6__namespace.default.resolve(runtimeDir, "worker.ts")
   ];
   for (const candidate of candidates) {
-    if (fs12__namespace.default.existsSync(candidate)) return candidate;
+    if (fs11__namespace.default.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -4076,7 +4055,7 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs12__namespace.default.readdirSync(currentDir, { withFileTypes: true });
+        return fs11__namespace.default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
@@ -4114,7 +4093,7 @@ function scanSource(source) {
     "FATAL: Native parser binding is required but not available.\nThis package requires native Rust bindings.\n\nResolution steps:\n1. Build the native Rust module: npm run build:rust"
   );
 }
-function isScannableFile(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
+function isScannableFile2(filePath, includeExtensions = DEFAULT_EXTENSIONS) {
   return includeExtensions.includes(path6__namespace.default.extname(filePath));
 }
 function scanFile(filePath) {
@@ -4175,7 +4154,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs12__namespace.default.statSync(filePath);
+          return fs11__namespace.default.statSync(filePath);
         } catch {
           return null;
         }
@@ -4201,7 +4180,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs12__namespace.default.readFileSync(filePath, "utf8");
+          return fs11__namespace.default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -4345,7 +4324,7 @@ var init_src2 = __esm({
           )
         ];
         for (const fullPath of candidates) {
-          if (!fs12__namespace.default.existsSync(fullPath)) continue;
+          if (!fs11__namespace.default.existsSync(fullPath)) continue;
           try {
             const required = req(fullPath);
             if (required && (typeof required.extractClassesFromSource === "function" || typeof required.parseClasses === "function" || typeof required.parse_classes === "function")) {
@@ -4387,7 +4366,7 @@ function isRecord(value) {
 }
 async function pathExists(filePath) {
   try {
-    await fs12__namespace.default.promises.access(filePath, fs12__namespace.default.constants.F_OK);
+    await fs11__namespace.default.promises.access(filePath, fs11__namespace.default.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -4508,7 +4487,7 @@ var formatIssuePath3, isPlainObject, formatIssues2, parseWithSchema2, CountSchem
 var init_schemas2 = __esm({
   "packages/domain/analyzer/src/schemas.ts"() {
     init_src();
-    formatIssuePath3 = (path29) => path29.length > 0 ? path29.map(
+    formatIssuePath3 = (path30) => path30.length > 0 ? path30.map(
       (segment) => typeof segment === "symbol" ? segment.description ?? segment.toString() : String(segment)
     ).join(".") : "<root>";
     isPlainObject = (value) => {
@@ -4517,8 +4496,8 @@ var init_schemas2 = __esm({
       return proto === Object.prototype || proto === null;
     };
     formatIssues2 = (error) => error.issues.map((issue) => {
-      const path29 = formatIssuePath3(issue.path);
-      return `${path29}: ${issue.message}`;
+      const path30 = formatIssuePath3(issue.path);
+      return `${path30}: ${issue.message}`;
     }).join("; ");
     parseWithSchema2 = (schema, data, label) => {
       const parsed = schema.safeParse(data);
@@ -4614,7 +4593,7 @@ var init_schemas2 = __esm({
     parseClassToCssOptions = (options) => parseWithSchema2(ClassToCssOptionsSchema, options ?? {}, "classToCss options are invalid");
   }
 });
-var SUPPORTED_TAILWIND_CONFIG_EXTENSIONS, tailwindConfigCache, splitVariantAndBase, isArbitraryUtility, resolveConflictGroup, detectConflicts, isSupportedTailwindConfigPath, resolveTailwindConfigPath, collectSafelistFromConfig, collectCustomUtilities, collectSafelistFromSource, loadTailwindConfig, utilityPrefix, buildSemanticReport;
+var SUPPORTED_TAILWIND_CONFIG_EXTENSIONS, tailwindConfigCache, splitVariantAndBase, resolveConflictGroup, detectConflicts, isSupportedTailwindConfigPath, resolveTailwindConfigPath, collectSafelistFromConfig, collectCustomUtilities, collectSafelistFromSource, loadTailwindConfig, utilityPrefix, buildSemanticReport;
 var init_semantic = __esm({
   "packages/domain/analyzer/src/semantic.ts"() {
     init_binding();
@@ -4627,27 +4606,13 @@ var init_semantic = __esm({
       const base = parts.pop() ?? className;
       return { variantKey: parts.join(":"), base };
     };
-    isArbitraryUtility = (baseClass) => {
-      return baseClass.includes("[") && baseClass.includes("]");
-    };
-    resolveConflictGroup = (base) => {
-      if (isArbitraryUtility(base)) return null;
-      if (["block", "inline", "inline-block", "inline-flex", "flex", "grid", "hidden"].includes(base))
-        return "display";
-      if (base.startsWith("bg-")) return "bg";
-      if (base.startsWith("text-")) return "text";
-      if (base.startsWith("font-")) return "font";
-      if (base.startsWith("rounded")) return "rounded";
-      if (base.startsWith("shadow")) return "shadow";
-      if (base.startsWith("border-")) return "border";
-      if (base.startsWith("opacity-")) return "opacity";
-      if (base.startsWith("w-") || base.startsWith("min-w-") || base.startsWith("max-w-"))
-        return "width";
-      if (base.startsWith("h-") || base.startsWith("min-h-") || base.startsWith("max-h-"))
-        return "height";
-      if (base.startsWith("p-") || base.startsWith("px-") || base.startsWith("py-")) return "padding";
-      if (base.startsWith("m-") || base.startsWith("mx-") || base.startsWith("my-")) return "margin";
-      return null;
+    resolveConflictGroup = async (base) => {
+      const native = await getNativeBinding();
+      if (!native?.resolveConflictGroup) {
+        throw new Error("Native binding 'resolveConflictGroup' is required but not available.");
+      }
+      const result = native.resolveConflictGroup(base);
+      return result.length > 0 ? result : null;
     };
     detectConflicts = async (usages) => {
       const native = await getNativeBinding();
@@ -4735,7 +4700,7 @@ var init_semantic = __esm({
       return out;
     };
     collectSafelistFromSource = async (configPath) => {
-      const source = await fs12__namespace.default.promises.readFile(configPath, "utf8");
+      const source = await fs11__namespace.default.promises.readFile(configPath, "utf8");
       const { extractClassesNative: extractClassesNative2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
       const allTokens = extractClassesNative2(source);
       const hasSafelist = source.includes("safelist");
@@ -4762,7 +4727,7 @@ var init_semantic = __esm({
           customUtilities: /* @__PURE__ */ new Set()
         };
       }
-      const configStat = await fs12__namespace.default.promises.stat(configPath).catch(() => null);
+      const configStat = await fs11__namespace.default.promises.stat(configPath).catch(() => null);
       if (configStat) {
         const cached = tailwindConfigCache.get(configPath);
         if (cached && cached.mtimeMs === configStat.mtimeMs && cached.size === configStat.size) {
@@ -5058,12 +5023,12 @@ var init_classToCss = __esm({
     init_binding();
     init_schemas2();
     init_utils();
-    normalizeClassInput = (input, _binding) => {
+    normalizeClassInput = (input, binding) => {
       if (typeof input === "string") {
-        if (_binding?.normalizeClassInput) {
-          return _binding.normalizeClassInput(input);
+        if (!binding.normalizeClassInput) {
+          throw new Error("FATAL: Native binding 'normalizeClassInput' is required but not available.");
         }
-        return input.split(/\s+/).map((item) => item.trim()).filter((item) => item.length > 0);
+        return binding.normalizeClassInput(input);
       }
       if (!Array.isArray(input)) {
         throw new TypeError("classToCss input must be a string or an array of strings.");
@@ -5095,11 +5060,11 @@ var init_classToCss = __esm({
       }
     };
     declarationMapToString = (declarationMap, binding) => {
-      const entries = Array.from(declarationMap.entries()).map(([property, value]) => ({ property, value }));
-      if (binding?.declarationMapToString) {
-        return binding.declarationMapToString(entries);
+      if (!binding.declarationMapToString) {
+        throw new Error("FATAL: Native binding 'declarationMapToString' is required but not available.");
       }
-      return entries.map(({ property, value }) => `${property}: ${value}`).join("; ");
+      const entries = Array.from(declarationMap.entries()).map(([property, value]) => ({ property, value }));
+      return binding.declarationMapToString(entries);
     };
     classToCss = async (input, options = {}) => {
       const binding = await requireNativeCssCompiler();
@@ -5195,7 +5160,7 @@ var init_src3 = __esm({
 });
 async function pathExists2(filePath) {
   try {
-    await fs8__default.default.access(filePath);
+    await fs7__default.default.access(filePath);
     return true;
   } catch {
     return false;
@@ -5203,7 +5168,7 @@ async function pathExists2(filePath) {
 }
 async function readFileSafe(filePath) {
   try {
-    return await fs8__default.default.readFile(filePath, "utf8");
+    return await fs7__default.default.readFile(filePath, "utf8");
   } catch {
     return null;
   }
@@ -5222,8 +5187,8 @@ async function writeFileSafe(filePath, content, options = {}) {
     options.onDryRun?.(`write ${filePath}`);
     return;
   }
-  await fs8__default.default.mkdir(path6__namespace.default.dirname(filePath), { recursive: true });
-  await fs8__default.default.writeFile(filePath, content, "utf8");
+  await fs7__default.default.mkdir(path6__namespace.default.dirname(filePath), { recursive: true });
+  await fs7__default.default.writeFile(filePath, content, "utf8");
 }
 async function ensureFileSafe(filePath, content, options = {}) {
   if (await pathExists2(filePath)) return "skipped";
@@ -6096,7 +6061,7 @@ var _loadNative, log3, NATIVE_UNAVAILABLE_MESSAGE, nativeBridge, bridgeLoadAttem
 var init_nativeBridge = __esm({
   "packages/domain/compiler/src/nativeBridge.ts"() {
     init_src();
-    _loadNative = (path29) => __require(path29);
+    _loadNative = (path30) => __require(path30);
     log3 = (...args) => {
       if (process.env.DEBUG?.includes("compiler:native")) {
         console.log("[compiler:native]", ...args);
@@ -6154,6 +6119,78 @@ Tried paths: ${result.tried.join("\n")}`);
   }
 });
 
+// packages/domain/compiler/src/compiler/index.ts
+var init_compiler = __esm({
+  "packages/domain/compiler/src/compiler/index.ts"() {
+  }
+});
+
+// packages/domain/compiler/src/parser/index.ts
+var init_parser = __esm({
+  "packages/domain/compiler/src/parser/index.ts"() {
+  }
+});
+
+// packages/domain/compiler/src/analyzer/index.ts
+var init_analyzer = __esm({
+  "packages/domain/compiler/src/analyzer/index.ts"() {
+  }
+});
+
+// packages/domain/compiler/src/cache/index.ts
+var init_cache = __esm({
+  "packages/domain/compiler/src/cache/index.ts"() {
+  }
+});
+
+// packages/domain/compiler/src/redis/index.ts
+var init_redis = __esm({
+  "packages/domain/compiler/src/redis/index.ts"() {
+  }
+});
+
+// packages/domain/compiler/src/watch/index.ts
+var init_watch = __esm({
+  "packages/domain/compiler/src/watch/index.ts"() {
+  }
+});
+var compileCssFromClasses;
+var init_src4 = __esm({
+  "packages/domain/compiler/src/index.ts"() {
+    init_nativeBridge();
+    init_compiler();
+    init_parser();
+    init_analyzer();
+    init_cache();
+    init_redis();
+    init_watch();
+    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;
+    };
+  }
+});
+
+// packages/domain/compiler/src/internal.ts
+var init_internal = __esm({
+  "packages/domain/compiler/src/internal.ts"() {
+    init_src4();
+    init_compiler();
+    init_parser();
+    init_analyzer();
+    init_cache();
+    init_redis();
+    init_watch();
+  }
+});
+
 // packages/infrastructure/cli/src/commands/program.ts
 init_esm();
 
@@ -6451,7 +6488,7 @@ async function findSourceFiles(dir) {
   const out = [];
   async function walk(currentDir) {
     if (!await pathExists2(currentDir)) return;
-    const entries = await fs8__default.default.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs7__default.default.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path6__namespace.default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
@@ -6517,12 +6554,12 @@ async function runMigrateCli(rawArgs) {
     report.configWrites += await migrateConfig(root, dryRun);
   }
   for (const filePath of files) {
-    const source = await fs8__default.default.readFile(filePath, "utf8");
+    const source = await fs7__default.default.readFile(filePath, "utf8");
     const migrated = migrateSource(source, { includeImports, includeClasses });
     if (migrated.output !== source) {
       report.updatedFiles++;
       if (!dryRun) {
-        await fs8__default.default.writeFile(filePath, migrated.output, "utf8");
+        await fs7__default.default.writeFile(filePath, migrated.output, "utf8");
       }
     }
     report.classRenames += migrated.classRenames;
@@ -6588,8 +6625,8 @@ function buildClassNames(files, uniqueClasses) {
 function writeScanCache(root, cacheData) {
   const cacheDir = path6__namespace.default.join(root, ".tailwind-styled");
   const cachePath = path6__namespace.default.join(cacheDir, "scan-cache.json");
-  fs12__namespace.default.mkdirSync(cacheDir, { recursive: true });
-  fs12__namespace.default.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2), "utf-8");
+  fs11__namespace.default.mkdirSync(cacheDir, { recursive: true });
+  fs11__namespace.default.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2), "utf-8");
   return cachePath;
 }
 async function runScanCli(rawArgs) {
@@ -6763,26 +6800,62 @@ function computeSafelistSourcePath(cssFilePath, cwd2) {
     return `${ups}/.next/tw-classes/**`;
   }
 }
+function computeStateStaticImportPath(cssFilePath, cwd2) {
+  try {
+    const nodePath = __require("path");
+    const cssAbs = nodePath.resolve(cwd2, cssFilePath);
+    const cssDir = nodePath.dirname(cssAbs);
+    const stateStaticAbs = nodePath.resolve(cwd2, ".next", "_tw-state-static.css");
+    const rel = nodePath.relative(cssDir, stateStaticAbs).replace(/\\/g, "/");
+    return rel.startsWith(".") ? rel : `./${rel}`;
+  } catch {
+    const depth = cssFilePath.split("/").length - 1;
+    const ups = Array(depth).fill("..").join("/");
+    return `${ups}/.next/_tw-state-static.css`;
+  }
+}
 function patchTailwindCssImpl(src, bundler, cssFilePath, cwd2) {
   const hasTailwindImport = src.includes('@import "tailwindcss"') || src.includes("@import 'tailwindcss'");
-  const hasSafelistSource2 = src.includes("tailwind-styled-safelist.css");
+  const hasSafelistSource2 = src.includes("tw-classes");
+  const hasStateImport = src.includes("_tw-state-static.css");
   const needsSafelistSource = bundler === "next" && !hasSafelistSource2;
-  const safelistRelPath = needsSafelistSource && cssFilePath && cwd2 ? computeSafelistSourcePath(cssFilePath, cwd2) : "../.next/tailwind-styled-safelist.css";
+  const needsStateImport = bundler === "next" && !hasStateImport;
+  const safelistRelPath = needsSafelistSource && cssFilePath && cwd2 ? computeSafelistSourcePath(cssFilePath, cwd2) : "../.next/tw-classes/**";
+  const stateImportRelPath = needsStateImport && cssFilePath && cwd2 ? computeStateStaticImportPath(cssFilePath, cwd2) : "../.next/_tw-state-static.css";
   const safelistSource = `@source "${safelistRelPath}";`;
+  const stateImport = `@import "${stateImportRelPath}";`;
   if (hasTailwindImport) {
-    if (!needsSafelistSource) return null;
-    const patched = src.replace(
-      /(@import\s+['"]tailwindcss['"];?)/,
-      `$1
+    if (!needsSafelistSource && !needsStateImport) return null;
+    let patched = src;
+    if (needsSafelistSource) {
+      patched = patched.replace(
+        /(@import\s+['"]tailwindcss['"];?)/,
+        `$1
 ${safelistSource}`
-    );
+      );
+    }
+    if (needsStateImport) {
+      if (patched.includes("tw-classes")) {
+        patched = patched.replace(
+          /(@source\s+["'][^"']+["'];?)/,
+          `$1
+${stateImport}`
+        );
+      } else {
+        patched = patched.replace(
+          /(@import\s+['"]tailwindcss['"];?)/,
+          `$1
+${stateImport}`
+        );
+      }
+    }
     return patched === src ? null : patched;
   }
-  const base = `@import "tailwindcss";
-${needsSafelistSource ? `${safelistSource}
-` : ""}
-${src}`;
-  return base;
+  const lines = [`@import "tailwindcss";`];
+  if (needsSafelistSource) lines.push(safelistSource);
+  if (needsStateImport) lines.push(stateImport);
+  lines.push("", src);
+  return lines.join("\n");
 }
 function patchTsConfigImpl(src) {
   try {
@@ -7406,7 +7479,7 @@ async function runStatsCli(args) {
 init_runtime();
 function collectTsFiles(dir, extensions) {
   const files = [];
-  const entries = fs12.readdirSync(dir, { withFileTypes: true });
+  const entries = fs11.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     const full = path6.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -7489,7 +7562,7 @@ async function runBoundaryCli(args, context) {
   for (const file of files) {
     let source;
     try {
-      source = fs12.readFileSync(file, "utf8");
+      source = fs11.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -7584,7 +7657,7 @@ async function loadRegistry(context) {
   if (!registryPath) {
     throw new CliUsageError("Plugin registry file not found.");
   }
-  const raw = await fs8__default.default.readFile(registryPath, "utf8");
+  const raw = await fs7__default.default.readFile(registryPath, "utf8");
   const data = JSON.parse(raw);
   return [
     ...data.official.map((item) => ({ ...item, official: true })),
@@ -7719,8 +7792,8 @@ var deployCommand = {
       return;
     }
     const cacheDir = path6__namespace.default.join(process.cwd(), ".tw-cache");
-    await fs8__default.default.mkdir(cacheDir, { recursive: true });
-    await fs8__default.default.writeFile(
+    await fs7__default.default.mkdir(cacheDir, { recursive: true });
+    await fs7__default.default.writeFile(
       path6__namespace.default.join(cacheDir, "deploy-manifest.json"),
       JSON.stringify(manifest, null, 2)
     );
@@ -7821,22 +7894,27 @@ function addIssue(issues, severity, type, message, suggestion, location) {
   issues.push({ severity, type, message, suggestion, location });
 }
 function readJsonFile(filePath) {
-  if (!fs12__namespace.default.existsSync(filePath)) return null;
+  if (!fs11__namespace.default.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs12__namespace.default.readFileSync(filePath, "utf8"));
-  } catch {
+    return JSON.parse(fs11__namespace.default.readFileSync(filePath, "utf8"));
+  } catch (parseErr) {
+    if (process.env.TWS_DEBUG === "1") {
+      const msg = parseErr instanceof Error ? parseErr.message : String(parseErr);
+      process.stderr.write(`[tw:doctor] malformed JSON: ${filePath} \u2014 ${msg}
+`);
+    }
     return null;
   }
 }
 function findWorkspacePackageJsonFiles(root) {
   const packagesDir = path6__namespace.default.join(root, "packages");
-  if (!fs12__namespace.default.existsSync(packagesDir)) return [];
-  return fs12__namespace.default.readdirSync(packagesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path6__namespace.default.join(packagesDir, entry.name, "package.json")).filter((filePath) => fs12__namespace.default.existsSync(filePath));
+  if (!fs11__namespace.default.existsSync(packagesDir)) return [];
+  return fs11__namespace.default.readdirSync(packagesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path6__namespace.default.join(packagesDir, entry.name, "package.json")).filter((filePath) => fs11__namespace.default.existsSync(filePath));
 }
 function findFiles(dir, ext) {
   const files = [];
   try {
-    const entries = fs12__namespace.default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs11__namespace.default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path6__namespace.default.join(dir, entry.name);
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
@@ -7845,7 +7923,12 @@ function findFiles(dir, ext) {
         files.push(fullPath);
       }
     }
-  } catch {
+  } catch (dirErr) {
+    if (process.env.TWS_DEBUG === "1") {
+      const msg = dirErr instanceof Error ? dirErr.message : String(dirErr);
+      process.stderr.write(`[tw:doctor] findFiles error in ${dir}: ${msg}
+`);
+    }
     return files;
   }
   return files;
@@ -7998,7 +8081,7 @@ function runTailwindProjectDiagnostics(root, issues, checks) {
   const cssFiles = findFiles(root, ".css");
   const hasTailwindImport = cssFiles.slice(0, 10).some((filePath) => {
     try {
-      const content = fs12__namespace.default.readFileSync(filePath, "utf8");
+      const content = fs11__namespace.default.readFileSync(filePath, "utf8");
       return content.includes("@tailwind") || content.includes('@import "tailwindcss"');
     } catch {
       return false;
@@ -8022,7 +8105,7 @@ function runTailwindProjectDiagnostics(root, issues, checks) {
     );
   }
   const configFiles = ["tailwind.config.js", "tailwind.config.ts", "tailwind.config.mjs"];
-  const hasConfig = configFiles.some((name) => fs12__namespace.default.existsSync(path6__namespace.default.join(root, name)));
+  const hasConfig = configFiles.some((name) => fs11__namespace.default.existsSync(path6__namespace.default.join(root, name)));
   addCheck(
     checks,
     "tailwind",
@@ -8682,6 +8765,7 @@ init_args();
 init_errors();
 init_fs();
 init_json();
+init_src4();
 var DEFAULT_TAILWIND_CSS2 = '@import "tailwindcss";\n';
 var DEFAULT_TW_CONFIG = `${JSON.stringify(
   {
@@ -8696,6 +8780,89 @@ var DEFAULT_TW_CONFIG = `${JSON.stringify(
 function pkgHasDep(pkg, name) {
   return Boolean(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
 }
+async function validateThemeConfig(cwd2) {
+  const results = [];
+  try {
+    const native = getNativeBridge();
+    if (!native) {
+      results.push({ type: "theme", valid: false, message: "Native binding not available" });
+      return results;
+    }
+    const twConfigFiles = ["tailwind.config.ts", "tailwind.config.js", "tailwind.config.mjs"];
+    let configPath = null;
+    for (const file of twConfigFiles) {
+      if (await pathExists2(path6__namespace.default.join(cwd2, file))) {
+        configPath = path6__namespace.default.join(cwd2, file);
+        break;
+      }
+    }
+    if (!configPath) {
+      results.push({ type: "theme-config-missing", valid: false, message: "No tailwind.config found" });
+      return results;
+    }
+    try {
+      const configUrl = url.pathToFileURL(configPath);
+      const configModule = await import(configUrl.href);
+      const config = configModule.default || configModule;
+      const theme = config.theme || {};
+      if (theme.colors && native.validateColorsNapi) {
+        try {
+          const colorsJson = JSON.stringify(theme.colors);
+          const isValid = native.validateColorsNapi(colorsJson);
+          results.push({
+            type: "theme-colors",
+            valid: isValid,
+            message: isValid ? "Colors theme validated OK" : "Invalid colors in theme"
+          });
+        } catch (err) {
+          results.push({
+            type: "theme-colors",
+            valid: false,
+            message: `Color validation error: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
+      }
+      if (theme.screens && native.validateBreakpointsNapi) {
+        try {
+          const screensJson = JSON.stringify(theme.screens);
+          const isValid = native.validateBreakpointsNapi(screensJson);
+          results.push({
+            type: "theme-breakpoints",
+            valid: isValid,
+            message: isValid ? "Breakpoints validated OK" : "Invalid breakpoints in theme"
+          });
+        } catch (err) {
+          results.push({
+            type: "theme-breakpoints",
+            valid: false,
+            message: `Breakpoints validation error: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
+      }
+      if (native.runHealthCheck) {
+        try {
+          native.runHealthCheck();
+          results.push({ type: "theme-integrity", valid: true, message: "Theme integrity check passed" });
+        } catch {
+          results.push({ type: "theme-integrity", valid: false, message: "Theme integrity check failed" });
+        }
+      }
+    } catch (err) {
+      results.push({
+        type: "theme-load",
+        valid: false,
+        message: `Failed to load theme config: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  } catch (err) {
+    results.push({
+      type: "theme-validation",
+      valid: false,
+      message: `Theme validation failed: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  return results;
+}
 function nodeVersion() {
   const full = process.version.replace("v", "");
   const major = parseInt(full.split(".")[0], 10);
@@ -8820,6 +8987,16 @@ async function runPreflightCli(rawArgs) {
       "Run: tw migrate --dry-run to see migration steps"
     );
   }
+  const themeValidation = await validateThemeConfig(cwd2);
+  for (const validation of themeValidation) {
+    check(
+      results,
+      `theme-${validation.type}`,
+      `Theme ${validation.type}`,
+      validation.valid,
+      validation.message
+    );
+  }
   const hasTsConfig = await pathExists2(path6__namespace.default.join(cwd2, "tsconfig.json"));
   check(
     results,
@@ -9307,19 +9484,8 @@ var syncCommand = {
 var import_picocolors5 = __toESM(require_picocolors());
 init_errors();
 
-// packages/domain/compiler/src/index.ts
-init_nativeBridge();
-var 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;
-};
+// packages/infrastructure/cli/src/utils/traceService.ts
+init_internal();
 
 // packages/domain/engine/src/native-bridge.ts
 init_src();
@@ -9770,37 +9936,33 @@ var CascadeResolutionId = class {
     return `R${this.value}`;
   }
 };
-var _propertyNamesFallback = /* @__PURE__ */ new Map();
-var _valueNamesFallback = /* @__PURE__ */ new Map();
 function registerPropertyName(id, name) {
   const native = getNativeEngineBinding();
-  if (native?.registerPropertyName) {
-    native.registerPropertyName(id.value, name);
-    return;
+  if (!native?.registerPropertyName) {
+    throw new Error("FATAL: Native binding 'registerPropertyName' is required but not available.");
   }
-  _propertyNamesFallback.set(id.value, name);
+  native.registerPropertyName(id.value, name);
 }
 function registerValueName(id, name) {
   const native = getNativeEngineBinding();
-  if (native?.registerValueName) {
-    native.registerValueName(id.value, name);
-    return;
+  if (!native?.registerValueName) {
+    throw new Error("FATAL: Native binding 'registerValueName' is required but not available.");
   }
-  _valueNamesFallback.set(id.value, name);
+  native.registerValueName(id.value, name);
 }
 function propertyIdToString(id) {
   const native = getNativeEngineBinding();
-  if (native?.propertyIdToString) {
-    return native.propertyIdToString(id.value);
+  if (!native?.propertyIdToString) {
+    throw new Error("FATAL: Native binding 'propertyIdToString' is required but not available.");
   }
-  return _propertyNamesFallback.get(id.value) ?? `P${id.value}`;
+  return native.propertyIdToString(id.value);
 }
 function valueIdToString(id) {
   const native = getNativeEngineBinding();
-  if (native?.valueIdToString) {
-    return native.valueIdToString(id.value);
+  if (!native?.valueIdToString) {
+    throw new Error("FATAL: Native binding 'valueIdToString' is required but not available.");
   }
-  return _valueNamesFallback.get(id.value) ?? `V${id.value}`;
+  return native.valueIdToString(id.value);
 }
 var CascadeStage = /* @__PURE__ */ ((CascadeStage2) => {
   CascadeStage2[CascadeStage2["Origin"] = 0] = "Origin";
@@ -9810,19 +9972,12 @@ var CascadeStage = /* @__PURE__ */ ((CascadeStage2) => {
   CascadeStage2[CascadeStage2["Order"] = 4] = "Order";
   return CascadeStage2;
 })(CascadeStage || {});
-function createFingerprintFallback(parts) {
-  const hash = parts.reduce(
-    (acc, part) => part.split("").reduce((h, char) => (h << 5) - h + char.charCodeAt(0) & h, acc),
-    0
-  );
-  return Math.abs(hash).toString(36);
-}
 function createFingerprint(parts) {
   const native = getNativeEngineBinding();
-  if (native?.createFingerprint) {
-    return native.createFingerprint(parts);
+  if (!native?.createFingerprint) {
+    throw new Error("FATAL: Native binding 'createFingerprint' is required but not available.");
   }
-  return createFingerprintFallback(parts);
+  return native.createFingerprint(parts);
 }
 
 // packages/domain/engine/src/reverseLookup.ts
@@ -10084,14 +10239,68 @@ function detectLayerFromClassName(className) {
   return null;
 }
 function parseCssToIr(css, options = {}) {
-  resetIdGenerator();
+  const native = getNativeEngineBinding();
+  const prefix = options.prefix ?? "";
+  if (native?.assembleCssIr) {
+    return _parseCssToIrFast(native.assembleCssIr(css, prefix || null));
+  }
+  return _parseCssToIrFallback(css, prefix, native);
+}
+function _parseCssToIrFast(assembled) {
+  const native = getNativeEngineBinding();
   layerMap.clear();
   layerOrderMap.clear();
-  const native = getNativeEngineBinding();
+  for (const le of assembled.layers) {
+    const lid = new LayerId(le.layerId);
+    layerMap.set(le.name, lid);
+    layerOrderMap.set(le.name, le.order);
+  }
+  const rules = assembled.rules.map((r) => {
+    const propertyId = new PropertyId(r.propertyId);
+    const valueId = new ValueId(r.valueId);
+    if (native?.registerPropertyName) {
+      native.registerPropertyName(r.propertyId, r.propertyName);
+    } else {
+      registerPropertyName(propertyId, r.propertyName);
+    }
+    if (native?.registerValueName) {
+      native.registerValueName(r.valueId, r.valueName);
+    } else {
+      registerValueName(valueId, r.valueName);
+    }
+    return {
+      id: new RuleId(r.ruleId),
+      selector: new SelectorId(r.selectorId),
+      variantChain: new VariantChainId(0),
+      property: propertyId,
+      value: valueId,
+      origin: r.origin,
+      importance: r.importance,
+      layer: r.layerId >= 0 ? new LayerId(r.layerId) : null,
+      layerOrder: r.layerOrder,
+      specificity: r.specificity,
+      condition: r.conditionId >= 0 ? new ConditionId(r.conditionId) : null,
+      conditionResult: r.conditionResult,
+      insertionOrder: r.insertionOrder,
+      fingerprint: r.fingerprint,
+      source: { file: "", line: 1, column: 1 }
+    };
+  });
+  const classToRuleIds = new Map(
+    assembled.classToRuleIds.map((m) => [
+      m.className,
+      m.ruleIds.map((id) => new RuleId(id))
+    ])
+  );
+  return { rules, classToRuleIds };
+}
+function _parseCssToIrFallback(css, prefix, native) {
   if (!native?.parseCssRules) {
     throw new Error("FATAL: Native binding 'parseCssRules' is required but not available.");
   }
-  const prefix = options.prefix ?? "";
+  resetIdGenerator();
+  layerMap.clear();
+  layerOrderMap.clear();
   const rules = [];
   const classToRuleIds = /* @__PURE__ */ new Map();
   const parsed = native.parseCssRules(css);
@@ -10106,7 +10315,7 @@ function parseCssToIr(css, options = {}) {
     const valueId = generateValueId(r.value);
     const hasMedia = r.variants.some((v) => v.startsWith("@") || v === "dark" || v === "print");
     const conditionId = hasMedia ? generateConditionId() : null;
-    const conditionResult = hasMedia ? 2 /* Unknown */ : 2 /* Unknown */;
+    const conditionResult = 2 /* Unknown */;
     const ruleId = generateRuleId();
     const fingerprint = createFingerprint([className, r.property, r.value]);
     const rule = {
@@ -10120,7 +10329,6 @@ function parseCssToIr(css, options = {}) {
       layer,
       layerOrder,
       specificity: r.specificity,
-      // from native — no JS recalculation
       condition: conditionId,
       conditionResult,
       insertionOrder: getNextInsertionOrder(),
@@ -10346,6 +10554,9 @@ async function traceClass(className, options) {
   };
   return result;
 }
+
+// packages/infrastructure/cli/src/utils/traceTargetService.ts
+init_internal();
 init_src2();
 function toRelativePath(root, value) {
   const relative = path6__namespace.default.relative(root, value);
@@ -10417,7 +10628,7 @@ function tryCompileClasses(classes) {
   }
 }
 function traceSingleFile(filePath, root) {
-  const source = fs12__namespace.default.readFileSync(filePath, "utf8");
+  const source = fs11__namespace.default.readFileSync(filePath, "utf8");
   const classes = uniqueSorted(scanSource(source));
   const imports = extractImports(source);
   const compiled = tryCompileClasses(classes);
@@ -10447,8 +10658,8 @@ function traceDirectory(targetDir, root) {
   });
   const imports = [];
   const importKeys = /* @__PURE__ */ new Set();
-  const files = scanResult.files.filter((entry) => isScannableFile(entry.file, DEFAULT_EXTENSIONS)).map((entry) => {
-    const source = fs12__namespace.default.readFileSync(entry.file, "utf8");
+  const files = scanResult.files.filter((entry) => isScannableFile2(entry.file, DEFAULT_EXTENSIONS)).map((entry) => {
+    const source = fs11__namespace.default.readFileSync(entry.file, "utf8");
     const fileImports = extractImports(source);
     for (const fileImport of fileImports) {
       const key = `${fileImport.kind}:${fileImport.source}`;
@@ -10481,10 +10692,10 @@ function traceDirectory(targetDir, root) {
 async function traceTarget(target, options = {}) {
   const root = path6__namespace.default.resolve(options.root ?? process.cwd());
   const resolvedTarget = path6__namespace.default.resolve(root, target);
-  if (!fs12__namespace.default.existsSync(resolvedTarget)) {
+  if (!fs11__namespace.default.existsSync(resolvedTarget)) {
     throw new Error(`Trace target not found: ${resolvedTarget}`);
   }
-  const stat = fs12__namespace.default.statSync(resolvedTarget);
+  const stat = fs11__namespace.default.statSync(resolvedTarget);
   if (stat.isDirectory()) {
     return traceDirectory(resolvedTarget, root);
   }
@@ -10690,10 +10901,10 @@ async function runGenerateTypesCli(rawArgs) {
   output.writeText("");
   output.writeText(import_picocolors6.default.bold("  [2/2]") + import_picocolors6.default.cyan("  generate .d.ts"));
   const outDir = path6__namespace.default.dirname(outPath);
-  if (!fs12__namespace.default.existsSync(outDir)) {
-    fs12__namespace.default.mkdirSync(outDir, { recursive: true });
+  if (!fs11__namespace.default.existsSync(outDir)) {
+    fs11__namespace.default.mkdirSync(outDir, { recursive: true });
   }
-  fs12__namespace.default.writeFileSync(outPath, result.dtsContent, "utf-8");
+  fs11__namespace.default.writeFileSync(outPath, result.dtsContent, "utf-8");
   logger.ok(path6__namespace.default.relative(cwd2, outPath));
   output.writeText("");
   output.writeText(import_picocolors6.default.dim("  \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"));
@@ -10709,7 +10920,7 @@ async function loadNativeBinding2(cwd2) {
     path6__namespace.default.join(cwd2, "node_modules", "tailwind-styled-v4", "native", "tailwind-styled-native.node")
   ];
   for (const candidate of candidates) {
-    if (fs12__namespace.default.existsSync(candidate)) {
+    if (fs11__namespace.default.existsSync(candidate)) {
       try {
         return __require(candidate);
       } catch {
@@ -10721,6 +10932,9 @@ async function loadNativeBinding2(cwd2) {
 
 // packages/infrastructure/cli/src/commands/why.ts
 init_errors();
+
+// packages/infrastructure/cli/src/utils/whyService.ts
+init_internal();
 init_src2();
 function extractVariantChain(usage) {
   const segments = normalizeScannedClass(usage).split(":").filter(Boolean);
@@ -10768,7 +10982,7 @@ async function whyClass(className, options) {
   for (const file of scanResult.files) {
     const source = (() => {
       try {
-        return fs12__namespace.default.readFileSync(file.file, "utf8");
+        return fs11__namespace.default.readFileSync(file.file, "utf8");
       } catch {
         return "";
       }