tailwind-styled-v4 5.0.10 → 5.0.11

package/dist/cli.js

@@ -1,14 +1,14 @@
 'use strict';
 
 var module$1 = require('module');
-var fs11 = require('fs');
+var fs12 = 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 fs7 = require('fs/promises');
+var fs8 = 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 fs11__namespace = /*#__PURE__*/_interopNamespace(fs11);
+var fs12__namespace = /*#__PURE__*/_interopNamespace(fs12);
 var path6__namespace = /*#__PURE__*/_interopNamespace(path6);
-var fs7__default = /*#__PURE__*/_interopDefault(fs7);
+var fs8__default = /*#__PURE__*/_interopDefault(fs8);
 
 /* tailwind-styled-v4 v5.0.4 | MIT | https://github.com/dictionar32/tailwind-styled-v4 */
 var __create = Object.create;
@@ -1013,7 +1013,7 @@ var require_command = __commonJS({
     var EventEmitter = __require("events").EventEmitter;
     var childProcess = __require("child_process");
     var path29 = __require("path");
-    var fs15 = __require("fs");
+    var fs16 = __require("fs");
     var process2 = __require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1945,10 +1945,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path29.resolve(baseDir, baseName);
-          if (fs15.existsSync(localBin)) return localBin;
+          if (fs16.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path29.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs15.existsSync(`${localBin}${ext}`)
+            (ext) => fs16.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1960,7 +1960,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs15.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs16.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -3196,7 +3196,7 @@ function resolveNativeBinary(runtimeDir) {
   }
   const envPath = process.env.TW_NATIVE_PATH?.trim();
   if (envPath) {
-    if (fs11__namespace.existsSync(envPath)) {
+    if (fs12__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 (fs11__namespace.existsSync(candidate)) {
+      if (fs12__namespace.existsSync(candidate)) {
         return { path: candidate, source: "prebuilt", platform, tried };
       }
       tried.push(`prebuilt:${pkg} (resolved but missing)`);
@@ -3213,9 +3213,24 @@ function resolveNativeBinary(runtimeDir) {
       tried.push(`prebuilt:${pkg} (not installed)`);
     }
   }
+  const napiPlatform = platform === "linux-x64" ? "linux-x64-gnu" : platform === "linux-arm64" ? "linux-arm64-gnu" : platform;
+  const BINARY_NAMES_SELF = ["tailwind-styled-native", "tailwind_styled_parser"];
+  if (runtimeDir) {
+    for (const depth of ["..", path6__namespace.join("..", ".."), path6__namespace.join("..", "..", "..")]) {
+      const pkgRoot = path6__namespace.resolve(runtimeDir, depth);
+      for (const bin of BINARY_NAMES_SELF) {
+        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)) {
+            return { path: candidate, source: "prebuilt", platform, tried };
+          }
+        }
+      }
+    }
+  }
   const cwd2 = process.cwd();
   const base = runtimeDir ?? cwd2;
-  const napiPlatform = platform === "linux-x64" ? "linux-x64-gnu" : platform === "linux-arm64" ? "linux-arm64-gnu" : platform;
   const BINARY_NAMES = ["tailwind-styled-native", "tailwind_styled_parser"];
   const localCandidates = [];
   for (const bin of BINARY_NAMES) {
@@ -3241,7 +3256,7 @@ function resolveNativeBinary(runtimeDir) {
   }
   for (const candidate of localCandidates) {
     tried.push(`local:${candidate}`);
-    if (fs11__namespace.existsSync(candidate)) {
+    if (fs12__namespace.existsSync(candidate)) {
       return { path: candidate, source: "local", platform, tried };
     }
   }
@@ -3253,12 +3268,12 @@ var init_native_resolution = __esm({
     isBrowser2 = typeof window !== "undefined" || typeof document !== "undefined";
     _require = typeof __require !== "undefined" ? __require : module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href)));
     PLATFORM_MAP = {
-      "linux-x64": ["@tailwind-styled/native-linux-x64"],
-      "linux-arm64": ["@tailwind-styled/native-linux-arm64"],
+      "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"],
-      "win32-arm64": ["@tailwind-styled/native-win32-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"]
     };
   }
 });
@@ -3306,7 +3321,7 @@ function loadNativeBinding(options) {
   for (const candidate of candidates) {
     const candidatePath = path6__namespace.default.resolve(runtimeDir, candidate);
     try {
-      if (!fs11__namespace.default.existsSync(candidatePath) && !fs11__namespace.default.existsSync(candidatePath + ".node")) {
+      if (!fs12__namespace.default.existsSync(candidatePath) && !fs12__namespace.default.existsSync(candidatePath + ".node")) {
         continue;
       }
       const mod = requireNativeModule(candidatePath);
@@ -3338,9 +3353,9 @@ function resolveNativeBindingCandidates(options) {
     }
   }
   if (!includeDefaultCandidates) return candidates;
-  if (fs11__namespace.default.existsSync(runtimeDir)) {
+  if (fs12__namespace.default.existsSync(runtimeDir)) {
     try {
-      for (const entry of fs11__namespace.default.readdirSync(runtimeDir)) {
+      for (const entry of fs12__namespace.default.readdirSync(runtimeDir)) {
         if (entry.endsWith(".node")) candidates.push(entry);
       }
     } catch {
@@ -3351,11 +3366,13 @@ function resolveNativeBindingCandidates(options) {
   for (const bin of BINARY_NAMES) {
     candidates.push(path6__namespace.default.resolve(runtimeDir, `${bin}.node`));
     candidates.push(path6__namespace.default.resolve(runtimeDir, `${bin}.${napiPlatform}.node`));
+    candidates.push(path6__namespace.default.resolve(runtimeDir, "..", "native", `${bin}.node`));
+    candidates.push(path6__namespace.default.resolve(runtimeDir, "..", "native", `${bin}.${napiPlatform}.node`));
+    candidates.push(path6__namespace.default.resolve(process.cwd(), "native", `${bin}.node`));
+    candidates.push(path6__namespace.default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
     candidates.push(path6__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.node`));
     candidates.push(path6__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `${bin}.${napiPlatform}.node`));
     candidates.push(path6__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", `${bin}.node`));
-    candidates.push(path6__namespace.default.resolve(process.cwd(), "native", `${bin}.node`));
-    candidates.push(path6__namespace.default.resolve(process.cwd(), "native", `${bin}.${napiPlatform}.node`));
   }
   return Array.from(new Set(candidates));
 }
@@ -3440,8 +3457,10 @@ __export(native_bridge_exports, {
   extractClassesNative: () => extractClassesNative,
   generateSubComponentTypesNative: () => generateSubComponentTypesNative,
   hasNativeScannerBinding: () => hasNativeScannerBinding,
+  hasNativeWatchBinding: () => hasNativeWatchBinding,
   hashContentNative: () => hashContentNative,
   isRustCacheAvailable: () => isRustCacheAvailable,
+  pollWatchEventsNative: () => pollWatchEventsNative,
   pruneStaleEntriesNative: () => pruneStaleEntriesNative,
   rebuildWorkspaceResultNative: () => rebuildWorkspaceResultNative,
   resetScannerBridgeCache: () => resetScannerBridgeCache,
@@ -3451,7 +3470,9 @@ __export(native_bridge_exports, {
   scanCacheStats: () => scanCacheStats,
   scanFileNative: () => scanFileNative,
   scanFilesBatchNative: () => scanFilesBatchNative,
-  scanWorkspaceNative: () => scanWorkspaceNative
+  scanWorkspaceNative: () => scanWorkspaceNative,
+  startWatchNative: () => startWatchNative,
+  stopWatchNative: () => stopWatchNative
 });
 function getDirname2() {
   if (typeof __dirname !== "undefined") {
@@ -3628,6 +3649,41 @@ function computeCacheStatsNative(filesClasses, sizes, top) {
   if (!binding.computeCacheStats) return null;
   return binding.computeCacheStats(filesClasses, sizes, top ?? null);
 }
+function startWatchNative(rootDir) {
+  try {
+    const binding = scannerGetBinding();
+    if (!binding.startWatch) return null;
+    return binding.startWatch(rootDir);
+  } catch {
+    return null;
+  }
+}
+function pollWatchEventsNative(handleId) {
+  try {
+    const binding = scannerGetBinding();
+    if (!binding.pollWatchEvents) return [];
+    return binding.pollWatchEvents(handleId);
+  } catch {
+    return [];
+  }
+}
+function stopWatchNative(handleId) {
+  try {
+    const binding = scannerGetBinding();
+    if (!binding.stopWatch) return false;
+    return binding.stopWatch(handleId);
+  } catch {
+    return false;
+  }
+}
+function hasNativeWatchBinding() {
+  try {
+    const binding = scannerGetBinding();
+    return !!(binding.startWatch && binding.pollWatchEvents && binding.stopWatch);
+  } catch {
+    return false;
+  }
+}
 var log, isValidScannerBinding, createScannerBridgeLoader, scannerBridgeLoader, scannerGetBinding, resetScannerBridgeCache;
 var init_native_bridge = __esm({
   "packages/domain/scanner/src/native-bridge.ts"() {
@@ -3717,6 +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 });
   const result = cacheReadNative(cachePath);
   if (!result) return [];
   return result.entries.map((e) => ({
@@ -3731,6 +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 });
   const success = cacheWriteNative(cachePath, entries);
   if (!success) {
     throw new Error(
@@ -3761,7 +3819,7 @@ function collectFiles(rootDir, extensions, ignoreDirs) {
   function walk(dir) {
     let entries;
     try {
-      entries = fs11__namespace.default.readdirSync(dir, { withFileTypes: true });
+      entries = fs12__namespace.default.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -3961,7 +4019,7 @@ function resolveScannerWorkerModulePath() {
     path6__namespace.default.resolve(runtimeDir, "worker.ts")
   ];
   for (const candidate of candidates) {
-    if (fs11__namespace.default.existsSync(candidate)) return candidate;
+    if (fs12__namespace.default.existsSync(candidate)) return candidate;
   }
   return null;
 }
@@ -4018,7 +4076,7 @@ function collectCandidates(rootDir, ignoreDirectories, extensionSet) {
     if (!currentDir) continue;
     const entries = (() => {
       try {
-        return fs11__namespace.default.readdirSync(currentDir, { withFileTypes: true });
+        return fs12__namespace.default.readdirSync(currentDir, { withFileTypes: true });
       } catch {
         return [];
       }
@@ -4117,7 +4175,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const filePath of candidates) {
       const stat = (() => {
         try {
-          return fs11__namespace.default.statSync(filePath);
+          return fs12__namespace.default.statSync(filePath);
         } catch {
           return null;
         }
@@ -4143,7 +4201,7 @@ function scanWorkspace(rootDir, options = {}) {
     for (const { filePath, stat, size, cached } of ranked) {
       const content = (() => {
         try {
-          return fs11__namespace.default.readFileSync(filePath, "utf8");
+          return fs12__namespace.default.readFileSync(filePath, "utf8");
         } catch {
           return null;
         }
@@ -4248,21 +4306,31 @@ var init_src2 = __esm({
         if (_state.binding !== void 0) return _state.binding;
         const runtimeDir = getRuntimeDir();
         const req = module$1.createRequire(path6__namespace.default.join(runtimeDir, "noop.cjs"));
+        const _platform = process.platform;
+        const _arch = process.arch;
+        const _platformArch = `${_platform}-${_arch}`;
+        const _platformArchGnu = _platformArch === "linux-x64" ? "linux-x64-gnu" : _platformArch === "linux-arm64" ? "linux-arm64-gnu" : _platformArch;
         const candidates = [
           // ── binaryName baru: tailwind-styled-native (napi-rs naming) ──
           // cwd = repo root saat run dari root, atau package dir saat workspaces
           path6__namespace.default.resolve(process.cwd(), "native", "tailwind-styled-native.node"),
-          path6__namespace.default.resolve(process.cwd(), "native", `tailwind-styled-native.${process.platform}-${process.arch}.node`),
-          path6__namespace.default.resolve(process.cwd(), "native", `tailwind-styled-native.${process.platform}-${process.arch}-gnu.node`),
-          // runtimeDir = dist/ → naik 4 level ke repo root
+          path6__namespace.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArch}.node`),
+          path6__namespace.default.resolve(process.cwd(), "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          // runtimeDir = dist/ → naik 1 level ke package root (npm install case)
+          // e.g. node_modules/tailwind-styled-v4/dist/ → node_modules/tailwind-styled-v4/native/
+          path6__namespace.default.resolve(runtimeDir, "..", "native", "tailwind-styled-native.node"),
+          path6__namespace.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArch}.node`),
+          path6__namespace.default.resolve(runtimeDir, "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
+          // runtimeDir = dist/ → naik 4 level ke repo root (monorepo dev case)
           path6__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind-styled-native.node"),
-          path6__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${process.platform}-${process.arch}-gnu.node`),
+          path6__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // 3 level fallback (jika package di-nest lebih dangkal)
           path6__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind-styled-native.node"),
-          path6__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${process.platform}-${process.arch}-gnu.node`),
+          path6__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", `tailwind-styled-native.${_platformArchGnu}.node`),
           // ── binaryName lama: tailwind_styled_parser (backward compat) ──
           path6__namespace.default.resolve(process.cwd(), "native/tailwind_styled_parser.node"),
           path6__namespace.default.resolve(process.cwd(), "native/build/Release/tailwind_styled_parser.node"),
+          path6__namespace.default.resolve(runtimeDir, "..", "native", "tailwind_styled_parser.node"),
           path6__namespace.default.resolve(runtimeDir, "..", "..", "..", "..", "native", "tailwind_styled_parser.node"),
           path6__namespace.default.resolve(runtimeDir, "..", "..", "..", "native", "tailwind_styled_parser.node"),
           path6__namespace.default.resolve(
@@ -4277,7 +4345,7 @@ var init_src2 = __esm({
           )
         ];
         for (const fullPath of candidates) {
-          if (!fs11__namespace.default.existsSync(fullPath)) continue;
+          if (!fs12__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")) {
@@ -4319,7 +4387,7 @@ function isRecord(value) {
 }
 async function pathExists(filePath) {
   try {
-    await fs11__namespace.default.promises.access(filePath, fs11__namespace.default.constants.F_OK);
+    await fs12__namespace.default.promises.access(filePath, fs12__namespace.default.constants.F_OK);
     return true;
   } catch {
     return false;
@@ -4667,7 +4735,7 @@ var init_semantic = __esm({
       return out;
     };
     collectSafelistFromSource = async (configPath) => {
-      const source = await fs11__namespace.default.promises.readFile(configPath, "utf8");
+      const source = await fs12__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");
@@ -4694,7 +4762,7 @@ var init_semantic = __esm({
           customUtilities: /* @__PURE__ */ new Set()
         };
       }
-      const configStat = await fs11__namespace.default.promises.stat(configPath).catch(() => null);
+      const configStat = await fs12__namespace.default.promises.stat(configPath).catch(() => null);
       if (configStat) {
         const cached = tailwindConfigCache.get(configPath);
         if (cached && cached.mtimeMs === configStat.mtimeMs && cached.size === configStat.size) {
@@ -5127,7 +5195,7 @@ var init_src3 = __esm({
 });
 async function pathExists2(filePath) {
   try {
-    await fs7__default.default.access(filePath);
+    await fs8__default.default.access(filePath);
     return true;
   } catch {
     return false;
@@ -5135,7 +5203,7 @@ async function pathExists2(filePath) {
 }
 async function readFileSafe(filePath) {
   try {
-    return await fs7__default.default.readFile(filePath, "utf8");
+    return await fs8__default.default.readFile(filePath, "utf8");
   } catch {
     return null;
   }
@@ -5154,8 +5222,8 @@ async function writeFileSafe(filePath, content, options = {}) {
     options.onDryRun?.(`write ${filePath}`);
     return;
   }
-  await fs7__default.default.mkdir(path6__namespace.default.dirname(filePath), { recursive: true });
-  await fs7__default.default.writeFile(filePath, content, "utf8");
+  await fs8__default.default.mkdir(path6__namespace.default.dirname(filePath), { recursive: true });
+  await fs8__default.default.writeFile(filePath, content, "utf8");
 }
 async function ensureFileSafe(filePath, content, options = {}) {
   if (await pathExists2(filePath)) return "skipped";
@@ -6301,7 +6369,8 @@ async function runInitCli(rawArgs) {
     `${JSON.stringify(
       {
         version: 1,
-        cssEntry: "src/tailwind.css"
+        compiler: { engine: "rust" },
+        css: { entry: "src/tailwind.css" }
       },
       null,
       2
@@ -6382,7 +6451,7 @@ async function findSourceFiles(dir) {
   const out = [];
   async function walk(currentDir) {
     if (!await pathExists2(currentDir)) return;
-    const entries = await fs7__default.default.readdir(currentDir, { withFileTypes: true });
+    const entries = await fs8__default.default.readdir(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path6__namespace.default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
@@ -6448,12 +6517,12 @@ async function runMigrateCli(rawArgs) {
     report.configWrites += await migrateConfig(root, dryRun);
   }
   for (const filePath of files) {
-    const source = await fs7__default.default.readFile(filePath, "utf8");
+    const source = await fs8__default.default.readFile(filePath, "utf8");
     const migrated = migrateSource(source, { includeImports, includeClasses });
     if (migrated.output !== source) {
       report.updatedFiles++;
       if (!dryRun) {
-        await fs7__default.default.writeFile(filePath, migrated.output, "utf8");
+        await fs8__default.default.writeFile(filePath, migrated.output, "utf8");
       }
     }
     report.classRenames += migrated.classRenames;
@@ -6519,8 +6588,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");
-  fs11__namespace.default.mkdirSync(cacheDir, { recursive: true });
-  fs11__namespace.default.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2), "utf-8");
+  fs12__namespace.default.mkdirSync(cacheDir, { recursive: true });
+  fs12__namespace.default.writeFileSync(cachePath, JSON.stringify(cacheData, null, 2), "utf-8");
   return cachePath;
 }
 async function runScanCli(rawArgs) {
@@ -6990,6 +7059,14 @@ async function findExisting(cwd2, names) {
   }
   return null;
 }
+async function writeFileWithDryRun(cwd2, filePath, content, label, flags, logger) {
+  if (flags.isDryRun) {
+    logger.dry(`create ${label}`);
+    return;
+  }
+  await writeFileSafe(filePath, content);
+  logger.ok(path6__namespace.default.relative(cwd2, filePath) || label);
+}
 async function patchFileWithDryRun(filePath, patcher, label, flags, logger) {
   const source = await readFileSafe(filePath);
   if (!source) return false;
@@ -7175,6 +7252,21 @@ var runSetupCli = async (rawArgs) => {
       setupFlags,
       logger
     );
+    const detectedCssEntry = path6__namespace.default.relative(cwd, cssFile).replace(/\\/g, "/");
+    const twConfigPath = path6__namespace.default.join(cwd, "tailwind-styled.config.json");
+    const twConfig = {
+      version: 1,
+      compiler: { engine: "rust" },
+      css: { entry: detectedCssEntry }
+    };
+    await writeFileWithDryRun(
+      cwd,
+      twConfigPath,
+      JSON.stringify(twConfig, null, 2) + "\n",
+      "tailwind-styled.config.json",
+      setupFlags,
+      logger
+    );
   } else {
     logger.warn('CSS entry tidak ditemukan \u2014 tambahkan @import "tailwindcss" manual ke globals.css');
   }
@@ -7186,6 +7278,21 @@ var runSetupCli = async (rawArgs) => {
   } else {
     logger.skip("tsconfig.json tidak ditemukan \u2014 skip");
   }
+  output.writeText("\n" + import_picocolors3.default.bold("  [+]") + import_picocolors3.default.cyan("  pre-warming scanner cache"));
+  if (!setupFlags.isDryRun) {
+    try {
+      const { scanWorkspaceAsync: scanWorkspaceAsync2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+      const scanSpinner = output.spinner();
+      scanSpinner.start("Scanning workspace...");
+      const scanned = await scanWorkspaceAsync2(cwd, { useCache: true });
+      scanSpinner.stop(`Scanned ${scanned.totalFiles} file(s), ${scanned.uniqueClasses.length} unique classes`);
+      logger.ok(".cache/tailwind-styled/scanner-cache.json");
+    } catch {
+      logger.warn("Pre-warm cache gagal \u2014 tidak masalah, cache akan dibangun saat npm run dev");
+    }
+  } else {
+    logger.dry("pre-warm scanner cache");
+  }
   output.writeText("");
   output.writeText(import_picocolors3.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"));
   output.writeText(import_picocolors3.default.bold(import_picocolors3.default.green("  \u2713 setup selesai")));
@@ -7299,7 +7406,7 @@ async function runStatsCli(args) {
 init_runtime();
 function collectTsFiles(dir, extensions) {
   const files = [];
-  const entries = fs11.readdirSync(dir, { withFileTypes: true });
+  const entries = fs12.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     const full = path6.join(dir, entry.name);
     if (entry.isDirectory()) {
@@ -7382,7 +7489,7 @@ async function runBoundaryCli(args, context) {
   for (const file of files) {
     let source;
     try {
-      source = fs11.readFileSync(file, "utf8");
+      source = fs12.readFileSync(file, "utf8");
     } catch {
       continue;
     }
@@ -7477,7 +7584,7 @@ async function loadRegistry(context) {
   if (!registryPath) {
     throw new CliUsageError("Plugin registry file not found.");
   }
-  const raw = await fs7__default.default.readFile(registryPath, "utf8");
+  const raw = await fs8__default.default.readFile(registryPath, "utf8");
   const data = JSON.parse(raw);
   return [
     ...data.official.map((item) => ({ ...item, official: true })),
@@ -7612,8 +7719,8 @@ var deployCommand = {
       return;
     }
     const cacheDir = path6__namespace.default.join(process.cwd(), ".tw-cache");
-    await fs7__default.default.mkdir(cacheDir, { recursive: true });
-    await fs7__default.default.writeFile(
+    await fs8__default.default.mkdir(cacheDir, { recursive: true });
+    await fs8__default.default.writeFile(
       path6__namespace.default.join(cacheDir, "deploy-manifest.json"),
       JSON.stringify(manifest, null, 2)
     );
@@ -7714,22 +7821,22 @@ function addIssue(issues, severity, type, message, suggestion, location) {
   issues.push({ severity, type, message, suggestion, location });
 }
 function readJsonFile(filePath) {
-  if (!fs11__namespace.default.existsSync(filePath)) return null;
+  if (!fs12__namespace.default.existsSync(filePath)) return null;
   try {
-    return JSON.parse(fs11__namespace.default.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs12__namespace.default.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
 }
 function findWorkspacePackageJsonFiles(root) {
   const packagesDir = path6__namespace.default.join(root, "packages");
-  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));
+  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));
 }
 function findFiles(dir, ext) {
   const files = [];
   try {
-    const entries = fs11__namespace.default.readdirSync(dir, { withFileTypes: true });
+    const entries = fs12__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") {
@@ -7891,7 +7998,7 @@ function runTailwindProjectDiagnostics(root, issues, checks) {
   const cssFiles = findFiles(root, ".css");
   const hasTailwindImport = cssFiles.slice(0, 10).some((filePath) => {
     try {
-      const content = fs11__namespace.default.readFileSync(filePath, "utf8");
+      const content = fs12__namespace.default.readFileSync(filePath, "utf8");
       return content.includes("@tailwind") || content.includes('@import "tailwindcss"');
     } catch {
       return false;
@@ -7915,7 +8022,7 @@ function runTailwindProjectDiagnostics(root, issues, checks) {
     );
   }
   const configFiles = ["tailwind.config.js", "tailwind.config.ts", "tailwind.config.mjs"];
-  const hasConfig = configFiles.some((name) => fs11__namespace.default.existsSync(path6__namespace.default.join(root, name)));
+  const hasConfig = configFiles.some((name) => fs12__namespace.default.existsSync(path6__namespace.default.join(root, name)));
   addCheck(
     checks,
     "tailwind",
@@ -10310,7 +10417,7 @@ function tryCompileClasses(classes) {
   }
 }
 function traceSingleFile(filePath, root) {
-  const source = fs11__namespace.default.readFileSync(filePath, "utf8");
+  const source = fs12__namespace.default.readFileSync(filePath, "utf8");
   const classes = uniqueSorted(scanSource(source));
   const imports = extractImports(source);
   const compiled = tryCompileClasses(classes);
@@ -10341,7 +10448,7 @@ 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 = fs11__namespace.default.readFileSync(entry.file, "utf8");
+    const source = fs12__namespace.default.readFileSync(entry.file, "utf8");
     const fileImports = extractImports(source);
     for (const fileImport of fileImports) {
       const key = `${fileImport.kind}:${fileImport.source}`;
@@ -10374,10 +10481,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 (!fs11__namespace.default.existsSync(resolvedTarget)) {
+  if (!fs12__namespace.default.existsSync(resolvedTarget)) {
     throw new Error(`Trace target not found: ${resolvedTarget}`);
   }
-  const stat = fs11__namespace.default.statSync(resolvedTarget);
+  const stat = fs12__namespace.default.statSync(resolvedTarget);
   if (stat.isDirectory()) {
     return traceDirectory(resolvedTarget, root);
   }
@@ -10583,10 +10690,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 (!fs11__namespace.default.existsSync(outDir)) {
-    fs11__namespace.default.mkdirSync(outDir, { recursive: true });
+  if (!fs12__namespace.default.existsSync(outDir)) {
+    fs12__namespace.default.mkdirSync(outDir, { recursive: true });
   }
-  fs11__namespace.default.writeFileSync(outPath, result.dtsContent, "utf-8");
+  fs12__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"));
@@ -10602,7 +10709,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 (fs11__namespace.default.existsSync(candidate)) {
+    if (fs12__namespace.default.existsSync(candidate)) {
       try {
         return __require(candidate);
       } catch {
@@ -10661,7 +10768,7 @@ async function whyClass(className, options) {
   for (const file of scanResult.files) {
     const source = (() => {
       try {
-        return fs11__namespace.default.readFileSync(file.file, "utf8");
+        return fs12__namespace.default.readFileSync(file.file, "utf8");
       } catch {
         return "";
       }