@csszyx/cli 0.8.0 → 0.9.1

package/README.md

@@ -61,6 +61,9 @@ npx csszyx generate-types --output ./src/csszyx.d.ts
 ### `migrate`
 
 Convert Tailwind `className="..."` to CSSzyx `sz={...}` props. Phase 1 supports static string classNames.
+Display utilities migrate to canonical `display` props (`flex` →
+`{ display: 'flex' }`) instead of boolean sugar, and conflicting display
+utilities in the same variant scope stay unresolved for manual review.
 
 ```bash
 npx csszyx migrate src/

package/dist/index.mjs

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import cac from 'cac';
-import path, { resolve, dirname } from 'node:path';
+import * as path from 'node:path';
+import path__default, { resolve, dirname } from 'node:path';
 import fs from 'fs-extra';
 import ora from 'ora';
 import pc from 'picocolors';
@@ -13,8 +14,11 @@ import prompts from 'prompts';
 import readline from 'node:readline';
 import fg from 'fast-glob';
 import { parse } from '@babel/parser';
-import _traverse from '@babel/traverse';
 import * as t from '@babel/types';
+import { runNextPrebuild } from '@csszyx/unplugin/next-prebuild';
+import { NextSafelistWatcher } from '@csszyx/unplugin/next-watcher';
+import { watch } from 'chokidar';
+import { Minimatch } from 'minimatch';
 
 const colors = {
   success: pc.green,
@@ -141,19 +145,19 @@ async function collectStats(cwd) {
       mangledCSS: 0
     }
   };
-  const distDir = path.join(cwd, "dist");
+  const distDir = path__default.join(cwd, "dist");
   if (!fs.existsSync(distDir)) {
     return stats;
   }
   const htmlFiles = fs.readdirSync(distDir, { recursive: true }).filter((f) => String(f).endsWith(".html"));
   const cssFiles = fs.readdirSync(distDir, { recursive: true }).filter((f) => String(f).endsWith(".css"));
   if (htmlFiles.length > 0) {
-    const htmlContent = fs.readFileSync(path.join(distDir, String(htmlFiles[0])), "utf-8");
+    const htmlContent = fs.readFileSync(path__default.join(distDir, String(htmlFiles[0])), "utf-8");
     stats.bundleSavings.mangledHTML = Buffer.byteLength(htmlContent);
     stats.bundleSavings.originalHTML = Math.round(stats.bundleSavings.mangledHTML * 1.67);
   }
   if (cssFiles.length > 0) {
-    const cssContent = fs.readFileSync(path.join(distDir, String(cssFiles[0])), "utf-8");
+    const cssContent = fs.readFileSync(path__default.join(distDir, String(cssFiles[0])), "utf-8");
     stats.bundleSavings.mangledCSS = Buffer.byteLength(cssContent);
     stats.bundleSavings.originalCSS = Math.round(stats.bundleSavings.mangledCSS * 1.71);
   }
@@ -174,14 +178,14 @@ function formatBytes(bytes) {
 
 function detectFramework(cwd) {
   try {
-    const pkgPath = path.join(cwd, "package.json");
+    const pkgPath = path__default.join(cwd, "package.json");
     if (!fs.existsSync(pkgPath)) {
       return "unknown";
     }
     const pkg = fs.readJSONSync(pkgPath);
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     if (deps.next) {
-      const hasAppDir = fs.existsSync(path.join(cwd, "app"));
+      const hasAppDir = fs.existsSync(path__default.join(cwd, "app"));
       return hasAppDir ? "nextjs-app" : "nextjs-pages";
     }
     if (deps.nuxt) {
@@ -210,20 +214,20 @@ function detectFramework(cwd) {
   }
 }
 function detectPackageManager(cwd) {
-  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs.existsSync(path__default.join(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (fs.existsSync(path.join(cwd, "yarn.lock"))) {
+  if (fs.existsSync(path__default.join(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if (fs.existsSync(path.join(cwd, "bun.lockb"))) {
+  if (fs.existsSync(path__default.join(cwd, "bun.lockb"))) {
     return "bun";
   }
   return "npm";
 }
 function hasTailwindInstalled(cwd) {
   try {
-    const pkgPath = path.join(cwd, "package.json");
+    const pkgPath = path__default.join(cwd, "package.json");
     if (!fs.existsSync(pkgPath)) {
       return false;
     }
@@ -235,7 +239,7 @@ function hasTailwindInstalled(cwd) {
   }
 }
 function hasTypeScript(cwd) {
-  return fs.existsSync(path.join(cwd, "tsconfig.json")) || fs.existsSync(path.join(cwd, "jsconfig.json"));
+  return fs.existsSync(path__default.join(cwd, "tsconfig.json")) || fs.existsSync(path__default.join(cwd, "jsconfig.json"));
 }
 function getProjectInfo(cwd = process.cwd()) {
   return {
@@ -267,7 +271,7 @@ async function doctor(options = {}) {
   printHeader("csszyx Doctor");
   let issueCount = 0;
   printSection("\u{1F4CB} Configuration Health");
-  const hasConfig = fs.existsSync(path.join(cwd, "csszyx.config.ts")) || fs.existsSync(path.join(cwd, "csszyx.config.js"));
+  const hasConfig = fs.existsSync(path__default.join(cwd, "csszyx.config.ts")) || fs.existsSync(path__default.join(cwd, "csszyx.config.js"));
   if (hasConfig) {
     printSuccess("csszyx configuration found");
   } else {
@@ -284,7 +288,7 @@ async function doctor(options = {}) {
   }
   printSection("\u{1F4E6} Package Versions");
   try {
-    const pkgPath = path.join(cwd, "package.json");
+    const pkgPath = path__default.join(cwd, "package.json");
     const pkg = fs.readJSONSync(pkgPath);
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     if (deps.csszyx) {
@@ -298,12 +302,12 @@ async function doctor(options = {}) {
     issueCount++;
   }
   printSection("\u{1F528} Build Output");
-  const distDir = path.join(cwd, "dist");
+  const distDir = path__default.join(cwd, "dist");
   if (fs.existsSync(distDir)) {
     const htmlFiles = fs.readdirSync(distDir, { recursive: true }).filter((f) => String(f).endsWith(".html"));
     if (htmlFiles.length > 0) {
       printSuccess(`Found ${htmlFiles.length} HTML file(s)`);
-      const htmlContent = fs.readFileSync(path.join(distDir, String(htmlFiles[0])), "utf-8");
+      const htmlContent = fs.readFileSync(path__default.join(distDir, String(htmlFiles[0])), "utf-8");
       if (htmlContent.includes("data-sz-checksum")) {
         printSuccess("Checksum injection working");
       } else {
@@ -1196,6 +1200,16 @@ async function generateTypes(options = {}) {
 }
 
 const VITE_FRAMEWORKS = /* @__PURE__ */ new Set(["vite-react", "vite-vue", "vite-svelte"]);
+async function readFileOrNull(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf8");
+  } catch (err) {
+    if (err?.code === "ENOENT") {
+      return null;
+    }
+    throw err;
+  }
+}
 const NEXTJS_FRAMEWORKS = /* @__PURE__ */ new Set(["nextjs-app", "nextjs-pages"]);
 const CSS_ENTRY_CANDIDATES = [
   "src/index.css",
@@ -1273,7 +1287,7 @@ async function init(options = {}) {
   const spin2 = spinner.start("Creating config files...");
   try {
     const configContent = generateConfigFile(config);
-    const configPath = path.join(
+    const configPath = path__default.join(
       cwd,
       projectInfo.hasTypeScript ? "csszyx.config.ts" : "csszyx.config.js"
     );
@@ -1283,11 +1297,11 @@ async function init(options = {}) {
     }
     await injectPlugin(cwd, projectInfo.framework);
     if (config.setupGitignore) {
-      const gitignorePath = path.join(cwd, ".gitignore");
+      const gitignorePath = path__default.join(cwd, ".gitignore");
       const ignoreEntry = "\n# csszyx generated theme types\n.csszyx\n";
-      if (fs.existsSync(gitignorePath)) {
-        const content = await fs.readFile(gitignorePath, "utf8");
-        if (!content.includes(".csszyx")) {
+      const existing = await readFileOrNull(gitignorePath);
+      if (existing !== null) {
+        if (!existing.includes(".csszyx")) {
           await fs.appendFile(gitignorePath, ignoreEntry);
         }
       } else {
@@ -1312,32 +1326,35 @@ async function init(options = {}) {
 }
 async function setupTailwindCss(cwd, framework) {
   let cssPath;
+  let content = null;
   for (const candidate of CSS_ENTRY_CANDIDATES) {
-    const full = path.join(cwd, candidate);
-    if (fs.existsSync(full)) {
+    const full = path__default.join(cwd, candidate);
+    const existing = await readFileOrNull(full);
+    if (existing !== null) {
       cssPath = full;
+      content = existing;
       break;
     }
   }
-  if (!cssPath) {
-    cssPath = path.join(cwd, "src/index.css");
-    await fs.ensureDir(path.dirname(cssPath));
+  if (!cssPath || content === null) {
+    cssPath = path__default.join(cwd, "src/index.css");
+    await fs.ensureDir(path__default.dirname(cssPath));
     await fs.writeFile(cssPath, '@import "tailwindcss";\n');
-    printInfo(`Created ${path.relative(cwd, cssPath)} with Tailwind v4 import`);
+    printInfo(`Created ${path__default.relative(cwd, cssPath)} with Tailwind v4 import`);
     return;
   }
-  const content = await fs.readFile(cssPath, "utf8");
   if (!content.includes('@import "tailwindcss"') && !content.includes("@import 'tailwindcss'")) {
     await fs.writeFile(cssPath, `@import "tailwindcss";
 
 ${content}`);
-    printInfo(`Added Tailwind v4 import to ${path.relative(cwd, cssPath)}`);
+    printInfo(`Added Tailwind v4 import to ${path__default.relative(cwd, cssPath)}`);
   }
   if (NEXTJS_FRAMEWORKS.has(framework)) {
-    const postcssMjs = path.join(cwd, "postcss.config.mjs");
-    const postcssJs = path.join(cwd, "postcss.config.js");
-    const postcssTs = path.join(cwd, "postcss.config.ts");
-    if (!fs.existsSync(postcssMjs) && !fs.existsSync(postcssJs) && !fs.existsSync(postcssTs)) {
+    const postcssMjs = path__default.join(cwd, "postcss.config.mjs");
+    const postcssJs = path__default.join(cwd, "postcss.config.js");
+    const postcssTs = path__default.join(cwd, "postcss.config.ts");
+    const hasExisting = await readFileOrNull(postcssMjs) !== null || await readFileOrNull(postcssJs) !== null || await readFileOrNull(postcssTs) !== null;
+    if (!hasExisting) {
       await fs.writeFile(postcssMjs, generatePostcssConfig());
       printInfo("Created postcss.config.mjs for Tailwind v4");
     }
@@ -1363,22 +1380,24 @@ async function injectPlugin(cwd, framework) {
 }
 async function injectVitePlugin(cwd) {
   const candidates = [
-    path.join(cwd, "vite.config.ts"),
-    path.join(cwd, "vite.config.js"),
-    path.join(cwd, "vite.config.mts"),
-    path.join(cwd, "vite.config.mjs")
+    path__default.join(cwd, "vite.config.ts"),
+    path__default.join(cwd, "vite.config.js"),
+    path__default.join(cwd, "vite.config.mts"),
+    path__default.join(cwd, "vite.config.mjs")
   ];
   let configPath;
+  let content = null;
   for (const c of candidates) {
-    if (fs.existsSync(c)) {
+    const existing = await readFileOrNull(c);
+    if (existing !== null) {
       configPath = c;
+      content = existing;
       break;
     }
   }
-  if (!configPath) {
+  if (!configPath || content === null) {
     return false;
   }
-  let content = await fs.readFile(configPath, "utf8");
   if (content.includes("csszyx")) {
     return true;
   }
@@ -1402,46 +1421,48 @@ ${importBlock}${content.slice(insertAt)}`;
   content = content.slice(0, pluginsInsertAt) + `
     ...csszyx(),      // csszyx MUST come before tailwindcss${twEntry}` + content.slice(pluginsInsertAt);
   await fs.writeFile(configPath, content);
-  printInfo(`Injected csszyx plugin into ${path.basename(configPath)}`);
+  printInfo(`Injected csszyx plugin into ${path__default.basename(configPath)}`);
   return true;
 }
 async function injectNextPlugin(cwd) {
   const candidates = [
-    path.join(cwd, "next.config.ts"),
-    path.join(cwd, "next.config.mjs"),
-    path.join(cwd, "next.config.js")
+    path__default.join(cwd, "next.config.ts"),
+    path__default.join(cwd, "next.config.mjs"),
+    path__default.join(cwd, "next.config.js")
   ];
   let configPath;
+  let content = null;
   for (const c of candidates) {
-    if (fs.existsSync(c)) {
+    const existing = await readFileOrNull(c);
+    if (existing !== null) {
       configPath = c;
+      content = existing;
       break;
     }
   }
   if (!configPath) {
-    configPath = path.join(cwd, "next.config.js");
+    configPath = path__default.join(cwd, "next.config.js");
     await fs.writeFile(configPath, generateNextConfig());
     printInfo("Created next.config.js with csszyx plugin");
     return true;
   }
-  const content = await fs.readFile(configPath, "utf8");
-  if (content.includes("csszyx")) {
+  if (content?.includes("csszyx")) {
     return true;
   }
   return false;
 }
 async function setupTsconfig(cwd) {
-  let tsconfigPath = path.join(cwd, "tsconfig.json");
-  if (!fs.existsSync(tsconfigPath)) {
-    const viteTsConfig = path.join(cwd, "tsconfig.app.json");
-    if (fs.existsSync(viteTsConfig)) {
-      tsconfigPath = viteTsConfig;
-    }
-  }
-  if (!fs.existsSync(tsconfigPath)) {
+  const primary = path__default.join(cwd, "tsconfig.json");
+  const viteTsConfig = path__default.join(cwd, "tsconfig.app.json");
+  let tsconfigPath = primary;
+  let content = await readFileOrNull(tsconfigPath);
+  if (content === null) {
+    tsconfigPath = viteTsConfig;
+    content = await readFileOrNull(tsconfigPath);
+  }
+  if (content === null) {
     return;
   }
-  let content = await fs.readFile(tsconfigPath, "utf8");
   if (content.includes(".csszyx")) {
     return;
   }
@@ -1565,7 +1586,7 @@ function isGradientObj(v) {
   return typeof v === "object" && v !== null && "gradient" in v;
 }
 function formatKey(key) {
-  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+  if (/^[a-z_$][\w$]*$/i.test(key)) {
     return key;
   }
   return `'${key}'`;
@@ -1590,7 +1611,7 @@ function formatValue(value, indent) {
     const items = value.map((v) => formatValue(v, indent));
     return `[${items.join(", ")}]`;
   }
-  if (typeof value === "object" && value !== null) {
+  if (typeof value === "object") {
     if (isColorOpacityObj(value)) {
       const parts = [`color: '${escapeString(String(value.color))}'`];
       if (typeof value.op === "number") {
@@ -2351,7 +2372,7 @@ const KNOWN_SIMPLE_VARIANTS = /* @__PURE__ */ new Set([
   "pointer-none"
 ]);
 
-function parseClass(cls) {
+function parseClass(cls, options = {}) {
   let important = false;
   let input = cls;
   if (input.endsWith("!")) {
@@ -2364,7 +2385,7 @@ function parseClass(cls) {
     negative = true;
     negInput = input.slice(1);
   }
-  const boolResult = tryBooleanMatch(input);
+  const boolResult = tryBooleanMatch(input, options);
   if (boolResult) {
     return applyImportant(boolResult, important);
   }
@@ -2380,10 +2401,7 @@ function parseClass(cls) {
         continue;
       }
       if (REVERSE_BOOLEAN_MAP[source]) {
-        return applyImportant(
-          { prop: REVERSE_BOOLEAN_MAP[source], value: true },
-          important
-        );
+        return applyImportant(booleanClassToParsed(source, options), important);
       }
       if (prefix === "divide-x" || prefix === "divide-y") {
         return applyImportant({ prop, value: true }, important);
@@ -2422,7 +2440,7 @@ function parseClass(cls) {
       }
     }
   }
-  const displayResult = tryDisplay(input);
+  const displayResult = tryDisplay(input, options);
   if (displayResult) {
     return applyImportant(displayResult, important);
   }
@@ -2456,17 +2474,17 @@ function applyImportant(result, important) {
   }
   return result;
 }
-function tryBooleanMatch(cls) {
+function tryBooleanMatch(cls, options) {
   if (BOOLEAN_VALUE_MAP[cls]) {
     const { prop, value } = BOOLEAN_VALUE_MAP[cls];
     return { prop, value };
   }
   if (REVERSE_BOOLEAN_MAP[cls]) {
-    return { prop: REVERSE_BOOLEAN_MAP[cls], value: true };
+    return booleanClassToParsed(cls, options);
   }
   return null;
 }
-function tryDisplay(cls) {
+function tryDisplay(cls, options) {
   const displayValues = /* @__PURE__ */ new Set([
     "block",
     "inline",
@@ -2484,10 +2502,33 @@ function tryDisplay(cls) {
     "list-item"
   ]);
   if (displayValues.has(cls)) {
-    return REVERSE_BOOLEAN_MAP[cls] ? { prop: REVERSE_BOOLEAN_MAP[cls], value: true } : null;
+    return REVERSE_BOOLEAN_MAP[cls] ? booleanClassToParsed(cls, options) : null;
   }
   return null;
 }
+function booleanClassToParsed(cls, options) {
+  const displayValue = DISPLAY_CLASS_VALUES[cls];
+  if (options.display === "canonical" && displayValue) {
+    return { prop: "display", value: displayValue, cssProperty: "display" };
+  }
+  return { prop: REVERSE_BOOLEAN_MAP[cls], value: true };
+}
+const DISPLAY_CLASS_VALUES = {
+  block: "block",
+  inline: "inline",
+  "inline-block": "inline-block",
+  flex: "flex",
+  "inline-flex": "inline-flex",
+  grid: "grid",
+  "inline-grid": "inline-grid",
+  hidden: "none",
+  contents: "contents",
+  table: "table",
+  "table-row": "table-row",
+  "table-cell": "table-cell",
+  "flow-root": "flow-root",
+  "list-item": "list-item"
+};
 function tryGradient(cls, negative) {
   let input = cls;
   let type = null;
@@ -3133,6 +3174,8 @@ function normalizeVariantKey(variant) {
 const TODO_KEEP = "sz:keep";
 const TODO_REMOVE = "sz:remove";
 const TODO_PENDING = "sz:todo";
+const MAX_TOKEN_CACHE_SIZE = 4096;
+const parsedTokenCache = /* @__PURE__ */ new Map();
 function resolveCustomMapEntry(token, customMap, resolveString) {
   if (!(token in customMap)) {
     return null;
@@ -3164,6 +3207,8 @@ function classNameToSzObject(className, customMap) {
   const szObject = {};
   const unrecognized = [];
   const keepInClassName = [];
+  const seenCssPropertiesByPath = /* @__PURE__ */ new Map();
+  const conflictedCssPropertiesByPath = /* @__PURE__ */ new Map();
   for (const token of tokens) {
     if (customMap && token in customMap) {
       const entry = resolveCustomMapEntry(
@@ -3201,21 +3246,79 @@ function classNameToSzObject(className, customMap) {
         }
       }
     }
-    const { variantParts, baseClass } = extractVariants(token);
-    const parsed = parseClass(baseClass);
-    if (!parsed) {
+    const parsedToken = parseClassTokenCached(token);
+    if (!parsedToken) {
+      unrecognized.push(token);
+      continue;
+    }
+    if (isCssPropertyConflicted(conflictedCssPropertiesByPath, parsedToken)) {
       unrecognized.push(token);
       continue;
     }
-    const variantKeys = variantParts.map((v) => mapVariant(v));
-    const keyPath = [];
-    for (const vk of variantKeys) {
-      keyPath.push(...vk);
+    const conflict = findCssPropertyConflict(seenCssPropertiesByPath, parsedToken, token);
+    if (conflict) {
+      rememberCssPropertyConflict(conflictedCssPropertiesByPath, parsedToken);
+      unrecognized.push(conflict, token);
+      removeNestedValue(szObject, parsedToken.keyPath, parsedToken.prop);
+      continue;
     }
-    setNestedValue(szObject, keyPath, parsed.prop, parsed.value);
+    rememberCssProperty(seenCssPropertiesByPath, parsedToken, token);
+    setNestedValue(
+      szObject,
+      parsedToken.keyPath,
+      parsedToken.prop,
+      cloneParsedValue(parsedToken.value)
+    );
   }
   return { szObject, unrecognized, keepInClassName };
 }
+function parseClassTokenCached(token) {
+  if (parsedTokenCache.has(token)) {
+    return parsedTokenCache.get(token) ?? null;
+  }
+  const parsed = parseClassToken(token);
+  rememberParsedToken(token, parsed);
+  return parsed;
+}
+function parseClassToken(token) {
+  const { variantParts, baseClass } = extractVariants(token);
+  const parsed = parseClass(baseClass, { display: "canonical" });
+  if (!parsed) {
+    return null;
+  }
+  const keyPath = [];
+  for (const variant of variantParts) {
+    keyPath.push(...mapVariant(variant));
+  }
+  return {
+    keyPath,
+    prop: parsed.prop,
+    value: parsed.value,
+    cssProperty: parsed.cssProperty
+  };
+}
+function rememberParsedToken(token, parsed) {
+  if (parsedTokenCache.size >= MAX_TOKEN_CACHE_SIZE) {
+    const oldest = parsedTokenCache.keys().next().value;
+    if (oldest !== void 0) {
+      parsedTokenCache.delete(oldest);
+    }
+  }
+  parsedTokenCache.set(token, parsed);
+}
+function cloneParsedValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(cloneParsedValue);
+  }
+  if (value && typeof value === "object") {
+    const clone = {};
+    for (const [key, nested] of Object.entries(value)) {
+      clone[key] = cloneParsedValue(nested);
+    }
+    return clone;
+  }
+  return value;
+}
 function setNestedValue(obj, keyPath, prop, value) {
   let current = obj;
   for (const key of keyPath) {
@@ -3226,6 +3329,64 @@ function setNestedValue(obj, keyPath, prop, value) {
   }
   current[prop] = value;
 }
+function findCssPropertyConflict(seen, parsed, token) {
+  if (!parsed.cssProperty) {
+    return null;
+  }
+  const scope = parsed.keyPath.join("\0");
+  const previous = seen.get(scope)?.get(parsed.cssProperty);
+  return previous && previous !== token ? previous : null;
+}
+function isCssPropertyConflicted(conflicted, parsed) {
+  if (!parsed.cssProperty) {
+    return false;
+  }
+  return conflicted.get(parsed.keyPath.join("\0"))?.has(parsed.cssProperty) === true;
+}
+function rememberCssPropertyConflict(conflicted, parsed) {
+  if (!parsed.cssProperty) {
+    return;
+  }
+  const scope = parsed.keyPath.join("\0");
+  let properties = conflicted.get(scope);
+  if (!properties) {
+    properties = /* @__PURE__ */ new Set();
+    conflicted.set(scope, properties);
+  }
+  properties.add(parsed.cssProperty);
+}
+function rememberCssProperty(seen, parsed, token) {
+  if (!parsed.cssProperty) {
+    return;
+  }
+  const scope = parsed.keyPath.join("\0");
+  let properties = seen.get(scope);
+  if (!properties) {
+    properties = /* @__PURE__ */ new Map();
+    seen.set(scope, properties);
+  }
+  properties.set(parsed.cssProperty, token);
+}
+function removeNestedValue(obj, keyPath, prop) {
+  let current = obj;
+  const parents = [];
+  for (const key of keyPath) {
+    const next = current[key];
+    if (!next || typeof next !== "object" || Array.isArray(next)) {
+      return;
+    }
+    parents.push([current, key]);
+    current = next;
+  }
+  delete current[prop];
+  for (let index = parents.length - 1; index >= 0; index--) {
+    const [parent, key] = parents[index];
+    const child = parent[key];
+    if (child && typeof child === "object" && Object.keys(child).length === 0) {
+      delete parent[key];
+    }
+  }
+}
 
 const CLSX_LIKE_NAMES = /* @__PURE__ */ new Set(["clsx", "cn", "cx", "twMerge", "classNames", "classnames"]);
 function isClsxLikeName(name) {
@@ -3532,7 +3693,7 @@ function isExpression(node, t) {
   return t.isExpression(node);
 }
 
-const traverse = typeof _traverse === "function" ? _traverse : _traverse.default;
+const VISITOR_KEYS = t.VISITOR_KEYS;
 function injectTodoComment(unrecognized, parent, options, replacements) {
   if (!options.injectTodos || unrecognized.length === 0) {
     return;
@@ -3548,6 +3709,39 @@ function injectTodoComment(unrecognized, parent, options, replacements) {
 `
   });
 }
+function walkAst(node, visitors, ancestors = []) {
+  if (t.isImportDeclaration(node)) {
+    visitors.ImportDeclaration?.(node);
+  } else if (t.isCallExpression(node)) {
+    visitors.CallExpression?.(node, ancestors);
+  } else if (t.isJSXAttribute(node)) {
+    visitors.JSXAttribute?.(node, ancestors[ancestors.length - 1] ?? null);
+  }
+  const keys = VISITOR_KEYS[node.type];
+  if (!keys) {
+    return;
+  }
+  ancestors.push(node);
+  for (const key of keys) {
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        if (isAstNode(item)) {
+          walkAst(item, visitors, ancestors);
+        }
+      }
+    } else if (isAstNode(child)) {
+      walkAst(child, visitors, ancestors);
+    }
+  }
+  ancestors.pop();
+}
+function isAstNode(value) {
+  return Boolean(value && typeof value === "object" && "type" in value);
+}
+function isClassNameJsxAttribute(node) {
+  return t.isJSXAttribute(node) && t.isJSXIdentifier(node.name) && node.name.name === "className";
+}
 function transformSource(source, filePath, options = {}) {
   const warnings = [];
   let classNamesTransformed = 0;
@@ -3558,6 +3752,15 @@ function transformSource(source, filePath, options = {}) {
   let clsxUsedOutsideClassName = false;
   const clsxCallsitesMigrated = /* @__PURE__ */ new Set();
   let hasCvaImport = false;
+  if (source.indexOf("className") === -1 && source.indexOf("cva") === -1) {
+    return {
+      code: source,
+      changed: false,
+      warnings: [],
+      stats: { classNamesTransformed: 0, classNamesSkipped: 0, classesUnrecognized: [] },
+      potentiallyUnusedImports: []
+    };
+  }
   let ast;
   try {
     ast = parse(source, {
@@ -3575,41 +3778,35 @@ function transformSource(source, filePath, options = {}) {
       potentiallyUnusedImports: []
     };
   }
-  traverse(ast, {
-    // Track clsx-like and CVA imports
-    ImportDeclaration(path) {
-      const src = path.node.source.value;
+  walkAst(ast, {
+    ImportDeclaration(node) {
+      const src = node.source.value;
       const clsxPackages = ["clsx", "clsx/lite", "classnames", "tailwind-merge"];
       const isClsxPkg = clsxPackages.some((p) => src === p || src.startsWith(`${p}/`));
       const cvaPkgs = ["cva", "class-variance-authority"];
       if (cvaPkgs.some((p) => src === p || src.startsWith(`${p}/`))) {
         hasCvaImport = true;
       }
-      for (const spec of path.node.specifiers) {
+      for (const spec of node.specifiers) {
         const localName = spec.local.name;
         if (isClsxPkg || isClsxLikeName(localName)) {
           clsxImportNames.add(localName);
         }
       }
     },
-    // Track clsx usage outside className
-    CallExpression(path) {
-      if (t.isIdentifier(path.node.callee) && clsxImportNames.has(path.node.callee.name)) {
-        const inClassName = path.findParent(
-          (p) => t.isJSXAttribute(p.node) && t.isJSXIdentifier(p.node.name) && p.node.name.name === "className"
-        );
+    CallExpression(node, ancestors) {
+      if (t.isIdentifier(node.callee) && clsxImportNames.has(node.callee.name)) {
+        const inClassName = ancestors.some(isClassNameJsxAttribute);
         if (!inClassName) {
           clsxUsedOutsideClassName = true;
         }
       }
     },
-    // Main transformation: className → sz
-    JSXAttribute(path) {
-      const attrName = path.node.name;
+    JSXAttribute(node, parent) {
+      const attrName = node.name;
       if (!t.isJSXIdentifier(attrName) || attrName.name !== "className") {
         return;
       }
-      const parent = path.parent;
       if (t.isJSXOpeningElement(parent)) {
         const elementName = parent.name;
         const isCapitalized = t.isJSXIdentifier(elementName) && /^[A-Z]/.test(elementName.name) || t.isJSXMemberExpression(elementName);
@@ -3627,9 +3824,9 @@ function transformSource(source, filePath, options = {}) {
           return;
         }
       }
-      const value = path.node.value;
-      const attrStart = path.node.start;
-      const attrEnd = path.node.end;
+      const value = node.value;
+      const attrStart = node.start;
+      const attrEnd = node.end;
       if (attrStart === null || attrStart === void 0 || attrEnd === null || attrEnd === void 0) {
         return;
       }
@@ -3639,7 +3836,7 @@ function transformSource(source, filePath, options = {}) {
           replacements.push({ start: attrStart, end: attrEnd, text: result.replacement });
           classNamesTransformed++;
           classesUnrecognized.push(...result.unrecognized);
-          injectTodoComment(result.unrecognized, path.parent, options, replacements);
+          injectTodoComment(result.unrecognized, parent, options, replacements);
         } else {
           classNamesSkipped++;
         }
@@ -3657,7 +3854,7 @@ function transformSource(source, filePath, options = {}) {
             });
             classNamesTransformed++;
             classesUnrecognized.push(...result.unrecognized);
-            injectTodoComment(result.unrecognized, path.parent, options, replacements);
+            injectTodoComment(result.unrecognized, parent, options, replacements);
           } else {
             classNamesSkipped++;
           }
@@ -3677,7 +3874,7 @@ function transformSource(source, filePath, options = {}) {
             classNamesSkipped++;
             warnings.push(...result.warnings.map((w) => `[${filePath}] ${w}`));
           }
-          injectTodoComment(result.unrecognized, path.parent, options, replacements);
+          injectTodoComment(result.unrecognized, parent, options, replacements);
           return;
         }
         if (t.isCallExpression(expr) && t.isIdentifier(expr.callee) && isClsxLikeName(expr.callee.name)) {
@@ -3697,7 +3894,7 @@ function transformSource(source, filePath, options = {}) {
             classNamesSkipped++;
             warnings.push(...result.warnings.map((w) => `[${filePath}] ${w}`));
           }
-          injectTodoComment(result.unrecognized, path.parent, options, replacements);
+          injectTodoComment(result.unrecognized, parent, options, replacements);
           return;
         }
         if (t.isConditionalExpression(expr)) {
@@ -3714,7 +3911,7 @@ function transformSource(source, filePath, options = {}) {
             classNamesSkipped++;
             warnings.push(...result.warnings.map((w) => `[${filePath}] ${w}`));
           }
-          injectTodoComment(result.unrecognized, path.parent, options, replacements);
+          injectTodoComment(result.unrecognized, parent, options, replacements);
           return;
         }
         if (t.isLogicalExpression(expr) && expr.operator === "&&") {
@@ -3731,7 +3928,7 @@ function transformSource(source, filePath, options = {}) {
             classNamesSkipped++;
             warnings.push(...result.warnings.map((w) => `[${filePath}] ${w}`));
           }
-          injectTodoComment(result.unrecognized, path.parent, options, replacements);
+          injectTodoComment(result.unrecognized, parent, options, replacements);
           return;
         }
         classNamesSkipped++;
@@ -3860,9 +4057,9 @@ function transformHtmlSourceSimple(source, filePath, options = {}) {
 function createLogFile(cwd) {
   const now = /* @__PURE__ */ new Date();
   const ts = now.toISOString().slice(0, 19).replace("T", "_").replace(/:/g, "-");
-  const logDir = path.join(cwd, ".csszyx", "logs");
+  const logDir = path__default.join(cwd, ".csszyx", "logs");
   fs$1.mkdirSync(logDir, { recursive: true });
-  const filePath = path.join(logDir, `migrate-${ts}.log`);
+  const filePath = path__default.join(logDir, `migrate-${ts}.log`);
   const lines = [`csszyx migrate \u2014 ${now.toISOString()}`, ""];
   return {
     filePath,
@@ -3873,7 +4070,7 @@ function createLogFile(cwd) {
 }
 function isGitignored(cwd, pattern) {
   try {
-    const content = fs$1.readFileSync(path.join(cwd, ".gitignore"), "utf-8");
+    const content = fs$1.readFileSync(path__default.join(cwd, ".gitignore"), "utf-8");
     return content.split("\n").some((l) => {
       const t = l.trim();
       return t === pattern || t === `${pattern}/` || t === `/${pattern}`;
@@ -3916,7 +4113,7 @@ async function migrate(options = {}) {
   }
   if (resolveTodosPath) {
     try {
-      const absolutePath = path.resolve(cwd, resolveTodosPath);
+      const absolutePath = path__default.resolve(cwd, resolveTodosPath);
       const content = fs$1.readFileSync(absolutePath, "utf-8");
       customMap = JSON.parse(content);
       printInfo(`Loaded resolution map from ${resolveTodosPath}`);
@@ -3986,7 +4183,10 @@ async function migrate(options = {}) {
     }
     let processSource = source;
     if (resolveTodosPath && !isHtml) {
-      processSource = processSource.replace(/\{\/\*\s*@sz-todo:\s*(.*?)\s*\*\/\}\n?/g, "");
+      processSource = processSource.replace(
+        /\{\/\*\s*@sz-todo:\s*(\S(?:.*\S)?)\s*\*\/\}\n?/g,
+        ""
+      );
     }
     const result = isHtml ? transformHtmlSourceSimple(processSource, filePath, {
       braces: options.braces,
@@ -4002,14 +4202,14 @@ async function migrate(options = {}) {
       totalSkipped += result.stats.classNamesSkipped;
       allUnrecognized.push(...result.stats.classesUnrecognized);
       if (result.potentiallyUnusedImports.length > 0) {
-        const rel2 = path.relative(cwd, filePath);
+        const rel2 = path__default.relative(cwd, filePath);
         unusedImportFiles.push({ file: rel2, imports: result.potentiallyUnusedImports });
       }
       if (!dryRun) {
         try {
           fs$1.writeFileSync(filePath, result.code, "utf-8");
         } catch (err) {
-          const rel2 = path.relative(cwd, filePath);
+          const rel2 = path__default.relative(cwd, filePath);
           printWarn(
             `Could not write ${rel2}: ${err instanceof Error ? err.message : String(err)}`
           );
@@ -4017,7 +4217,7 @@ async function migrate(options = {}) {
           continue;
         }
       }
-      const rel = path.relative(cwd, filePath);
+      const rel = path__default.relative(cwd, filePath);
       if (dryRun) {
         printInfo(`  ${rel}: ${result.stats.classNamesTransformed} className(s) \u2192 sz`);
         log.writeLine(`  ${rel}: ${result.stats.classNamesTransformed} className(s) \u2192 sz`);
@@ -4058,7 +4258,7 @@ async function migrate(options = {}) {
     }
   }
   if (audit) {
-    const todoPath = path.join(cwd, ".csszyx-todo.json");
+    const todoPath = path__default.join(cwd, ".csszyx-todo.json");
     const unique = [...new Set(allUnrecognized)];
     console.info();
     if (unique.length === 0) {
@@ -4075,19 +4275,19 @@ async function migrate(options = {}) {
         fs$1.writeFileSync(todoPath, JSON.stringify(todoObj, null, 2));
       } catch (err) {
         printWarn(
-          `Could not write ${path.relative(cwd, todoPath)}: ${err instanceof Error ? err.message : String(err)}`
+          `Could not write ${path__default.relative(cwd, todoPath)}: ${err instanceof Error ? err.message : String(err)}`
         );
         log.flush();
         return;
       }
       printSuccess(
-        `Audit complete. Exported ${unique.length} unrecognized classes to ${path.relative(cwd, todoPath)}.`
+        `Audit complete. Exported ${unique.length} unrecognized classes to ${path__default.relative(cwd, todoPath)}.`
       );
       printInfo(
         "Edit this file to map custom classes, then run: npx @csszyx/cli migrate --resolve-todos .csszyx-todo.json"
       );
       log.writeLine(
-        `Audit: ${unique.length} unrecognized classes written to ${path.relative(cwd, todoPath)}`
+        `Audit: ${unique.length} unrecognized classes written to ${path__default.relative(cwd, todoPath)}`
       );
     }
   }
@@ -4112,13 +4312,353 @@ async function migrate(options = {}) {
   }
   try {
     log.flush();
-    printInfo(`Migration log saved to ${path.relative(cwd, log.filePath)}`);
+    printInfo(`Migration log saved to ${path__default.relative(cwd, log.filePath)}`);
   } catch {
   }
 }
 
+const DEFAULT_NEXT_SOURCE_PATTERN = "{app,pages,src}/**/*.{ts,tsx,js,jsx,mjs,cjs}";
+const DEFAULT_NEXT_SOURCE_IGNORE = [
+  "node_modules/**",
+  ".git/**",
+  ".next/**",
+  ".next-turbo-*/**",
+  ".csszyx/**",
+  "dist/**",
+  "build/**"
+];
+
+async function nextPrebuild(options = {}) {
+  const cwd = path__default.resolve(options.cwd ?? process.cwd());
+  const root = path__default.resolve(options.root ?? cwd);
+  const pattern = options.pattern ?? DEFAULT_NEXT_SOURCE_PATTERN;
+  try {
+    const mode = normalizeMode(options.mode);
+    const parserMode = normalizeParserMode$1(options.parserMode);
+    const matches = await fg(pattern, {
+      cwd: root,
+      absolute: true,
+      ignore: [...DEFAULT_NEXT_SOURCE_IGNORE, ...options.extraIgnore ?? []],
+      dot: false,
+      onlyFiles: true
+    });
+    if (matches.length === 0) {
+      const message = `No source files matched pattern \`${pattern}\` under ${root}.`;
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            { ok: false, reason: "no-files-matched", root, pattern, mode },
+            null,
+            2
+          )
+        );
+      } else {
+        console.error(`${colors.error(icons.error)} ${message}`);
+      }
+      return 1;
+    }
+    const result = runNextPrebuild({
+      files: matches,
+      explicitRoot: root,
+      cwd,
+      mode,
+      parserMode,
+      safelistOutputFile: options.outputFile,
+      cacheDir: options.cacheDir,
+      config: { mangleVars: false }
+      // Versions intentionally omitted: runNextPrebuild's package.json
+      // fallback reads the real installed @csszyx/unplugin and
+      // @csszyx/compiler versions so the manifest's generation identity
+      // tracks the engine that actually runs the transform.
+    });
+    if (options.json) {
+      console.log(
+        JSON.stringify(
+          {
+            ok: true,
+            root,
+            mode,
+            scannedCount: result.scannedCount,
+            transformedCount: result.transformedCount,
+            skippedMissingCount: result.skippedMissingCount,
+            sourceCount: result.sourceCount,
+            classCount: result.classCount,
+            manifestPath: result.manifestPath,
+            safelistOutputPath: result.safelistOutputPath
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(`${colors.success(icons.success)} csszyx next prebuild done`);
+      console.log(`  root:        ${root}`);
+      console.log(`  mode:        ${mode}`);
+      console.log(`  scanned:     ${result.scannedCount}`);
+      console.log(`  transformed: ${result.transformedCount}`);
+      console.log(`  skipped:     ${result.skippedMissingCount}`);
+      console.log(`  sources:     ${result.sourceCount}`);
+      console.log(`  classes:     ${result.classCount}`);
+      console.log(`  safelist:    ${result.safelistOutputPath}`);
+      console.log(`  manifest:    ${result.manifestPath}`);
+    }
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (options.json) {
+      console.log(JSON.stringify({ ok: false, reason: message }, null, 2));
+    } else {
+      console.error(`${colors.error(icons.error)} ${message}`);
+    }
+    return 1;
+  }
+}
+function normalizeMode(mode) {
+  if (mode === void 0) {
+    return "production";
+  }
+  if (mode === "development" || mode === "production") {
+    return mode;
+  }
+  throw new Error(`Invalid --mode "${mode}". Expected "development" or "production".`);
+}
+function normalizeParserMode$1(parserMode) {
+  if (parserMode === void 0) {
+    return void 0;
+  }
+  if (parserMode === "rust" || parserMode === "oxc" || parserMode === "babel") {
+    return parserMode;
+  }
+  throw new Error(`Invalid --parser-mode "${parserMode}". Expected "rust", "oxc", or "babel".`);
+}
+
+const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/i;
+async function startNextWatch(options = {}, dependencies = {}) {
+  const cwd = path.resolve(options.cwd ?? process.cwd());
+  const root = path.resolve(options.root ?? cwd);
+  const pattern = options.pattern ?? DEFAULT_NEXT_SOURCE_PATTERN;
+  const ignore = [...DEFAULT_NEXT_SOURCE_IGNORE, ...options.extraIgnore ?? []];
+  const parserMode = normalizeParserMode(options.parserMode);
+  const debounceMs = normalizeDebounceMs(options.debounceMs);
+  const files = await fg(pattern, {
+    cwd: root,
+    absolute: true,
+    ignore,
+    dot: false,
+    onlyFiles: true
+  });
+  if (files.length === 0) {
+    throw new Error(`No source files matched pattern \`${pattern}\` under ${root}.`);
+  }
+  const prebuild = runNextPrebuild({
+    files,
+    explicitRoot: root,
+    cwd,
+    mode: "development",
+    parserMode,
+    safelistOutputFile: options.outputFile,
+    cacheDir: options.cacheDir,
+    config: { mangleVars: false }
+  });
+  let resolveFailure = () => {
+  };
+  let failed = false;
+  const failure = new Promise((resolve) => {
+    resolveFailure = resolve;
+  });
+  const reportFailure = (error) => {
+    if (failed) {
+      return;
+    }
+    failed = true;
+    resolveFailure(error instanceof Error ? error : new Error(String(error)));
+  };
+  const controller = new NextSafelistWatcher({
+    context: prebuild.context,
+    debounceMs,
+    onError: reportFailure
+  });
+  const watchFactory = dependencies.watch ?? watch;
+  const fsWatcher = watchFactory(root, {
+    ignoreInitial: true,
+    persistent: true,
+    atomic: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 25,
+      pollInterval: 10
+    },
+    ignored: createIgnoredMatcher(root, prebuild.context.safelist.shardsDir, ignore)
+  });
+  fsWatcher.on("all", (event, filePath) => {
+    const absolutePath = path.resolve(filePath);
+    if (event === "add" || event === "change" || event === "unlink") {
+      if (controller.notify(event, absolutePath) || event !== "unlink" || !SOURCE_EXTENSION.test(absolutePath)) {
+        return;
+      }
+      controller.notifySourceRemoval(absolutePath);
+    }
+  });
+  fsWatcher.on("error", reportFailure);
+  try {
+    await waitForWatcherReady(fsWatcher);
+    controller.start();
+  } catch (error) {
+    await fsWatcher.close();
+    controller.close();
+    throw error;
+  }
+  let closed = false;
+  return {
+    root,
+    sourcePattern: pattern,
+    safelistOutputPath: prebuild.safelistOutputPath,
+    manifestPath: prebuild.manifestPath,
+    failure,
+    close: async () => {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      await fsWatcher.close();
+      controller.close();
+    }
+  };
+}
+async function nextWatch(options = {}) {
+  let session;
+  let exitCode = 0;
+  try {
+    session = await startNextWatch(options);
+    if (!options.silent) {
+      console.log(`${colors.success(icons.success)} csszyx next watch ready`);
+      console.log(`  root:     ${session.root}`);
+      console.log(`  pattern:  ${session.sourcePattern}`);
+      console.log(`  safelist: ${session.safelistOutputPath}`);
+      console.log(`  manifest: ${session.manifestPath}`);
+    }
+    const outcome = await waitForShutdown(session.failure);
+    if (outcome) {
+      console.error(`${colors.error(icons.error)} ${outcome.message}`);
+      exitCode = 1;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${colors.error(icons.error)} ${message}`);
+    exitCode = 1;
+  }
+  try {
+    await session?.close();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${colors.error(icons.error)} Failed to close Next watcher: ${message}`);
+    exitCode = 1;
+  }
+  return exitCode;
+}
+function waitForWatcherReady(watcher) {
+  return new Promise((resolve, reject) => {
+    const onReady = () => {
+      watcher.off("error", onStartupError);
+      resolve();
+    };
+    const onStartupError = (error) => {
+      watcher.off("ready", onReady);
+      reject(error);
+    };
+    watcher.once("ready", onReady);
+    watcher.once("error", onStartupError);
+  });
+}
+function waitForShutdown(failure) {
+  return new Promise((resolve) => {
+    const cleanup = () => {
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+    };
+    const onSignal = () => {
+      cleanup();
+      resolve(void 0);
+    };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+    failure.then((error) => {
+      cleanup();
+      resolve(error);
+    });
+  });
+}
+function createIgnoredMatcher(root, shardsDir, ignore) {
+  const normalizedShardsDir = path.resolve(shardsDir);
+  const matchers = ignore.flatMap((pattern) => {
+    const normalized = pattern.replace(/\\/g, "/");
+    const variants = normalized.endsWith("/**") ? [normalized, normalized.slice(0, -3)] : [normalized];
+    return variants.map((variant) => new Minimatch(variant, { dot: true }));
+  });
+  return (candidate) => {
+    const absolute = path.resolve(candidate);
+    const relativeToShards = path.relative(absolute, normalizedShardsDir);
+    if (absolute === normalizedShardsDir || absolute.startsWith(`${normalizedShardsDir}${path.sep}`) || relativeToShards !== ".." && !relativeToShards.startsWith(`..${path.sep}`) && !path.isAbsolute(relativeToShards)) {
+      return false;
+    }
+    const relative = path.relative(root, absolute).replace(/\\/g, "/");
+    if (!relative || relative.startsWith("../") || path.isAbsolute(relative)) {
+      return false;
+    }
+    return matchers.some((matcher) => matcher.match(relative));
+  };
+}
+function normalizeParserMode(parserMode) {
+  if (parserMode === void 0) {
+    return void 0;
+  }
+  if (parserMode === "rust" || parserMode === "oxc" || parserMode === "babel") {
+    return parserMode;
+  }
+  throw new Error(`Invalid --parser-mode "${parserMode}". Expected "rust", "oxc", or "babel".`);
+}
+function normalizeDebounceMs(debounceMs) {
+  if (debounceMs === void 0) {
+    return void 0;
+  }
+  const parsed = typeof debounceMs === "number" ? debounceMs : Number(debounceMs);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 6e4) {
+    throw new Error("Invalid --debounce-ms. Expected an integer between 0 and 60000.");
+  }
+  return parsed;
+}
+
 const cli = cac("csszyx");
+normalizeNextCommandAlias(process.argv);
 const VERSION = "0.0.0";
+async function runNextPrebuildCommand(pattern, options) {
+  const code = await nextPrebuild({
+    cwd: options.cwd,
+    root: options.root,
+    mode: options.mode,
+    parserMode: options.parserMode,
+    outputFile: options.outputFile,
+    cacheDir: options.cacheDir,
+    pattern,
+    extraIgnore: options.ignore ? String(options.ignore).split(",") : void 0,
+    json: options.json
+  });
+  if (code !== 0) {
+    process.exit(code);
+  }
+}
+async function runNextWatchCommand(pattern, options) {
+  const code = await nextWatch({
+    cwd: options.cwd,
+    root: options.root,
+    parserMode: options.parserMode,
+    outputFile: options.outputFile,
+    cacheDir: options.cacheDir,
+    pattern,
+    extraIgnore: options.ignore ? String(options.ignore).split(",") : void 0,
+    debounceMs: options.debounceMs
+  });
+  process.exitCode = code;
+}
 cli.command("init", "Setup csszyx in your project").option("--framework <name>", "Specify framework").option("--yes", "Skip prompts (use defaults)").option("--cwd <dir>", "Current working directory").action(async (options) => {
   await init({
     framework: options.framework,
@@ -4167,11 +4707,27 @@ cli.command("migrate [dir]", "Convert Tailwind className to sz prop").option("--
     resolveTodos: options.resolveTodos
   });
 });
+cli.command(
+  "next-prebuild [pattern]",
+  "Seed the Next.js Turbopack csszyx safelist and generation manifest"
+).option("--root <dir>", "Next app root (defaults to cwd)").option("--cwd <dir>", "Current working directory").option("--mode <mode>", "development | production (default: production)").option("--parser-mode <mode>", "rust | oxc | babel (default: rust)").option(
+  "--output-file <path>",
+  "Tailwind @source safelist output (default: csszyx-classes.html)"
+).option("--cache-dir <dir>", "Cache directory relative to root (default: .csszyx/cache)").option("--ignore <patterns>", "Extra glob patterns to ignore (comma-separated)").option("--json", "Emit a single JSON result instead of formatted text").action(runNextPrebuildCommand);
+cli.command("next-watch [pattern]", "Maintain the Next.js Turbopack csszyx safelist").option("--root <dir>", "Next app root (defaults to cwd)").option("--cwd <dir>", "Current working directory").option("--parser-mode <mode>", "rust | oxc | babel (default: rust)").option(
+  "--output-file <path>",
+  "Tailwind @source safelist output (default: csszyx-classes.html)"
+).option("--cache-dir <dir>", "Cache directory relative to root (default: .csszyx/cache)").option("--ignore <patterns>", "Extra glob patterns to ignore (comma-separated)").option("--debounce-ms <ms>", "Safelist materialization debounce (default: 50)").action(runNextWatchCommand);
 cli.command("").action(() => {
   cli.outputHelp();
 });
 cli.help();
 cli.version(VERSION);
 cli.parse();
+function normalizeNextCommandAlias(argv) {
+  if (argv[2] === "next" && (argv[3] === "prebuild" || argv[3] === "watch")) {
+    argv.splice(2, 2, `next-${argv[3]}`);
+  }
+}
 
 export { classNameToSzObject, extractScreenKeys, extractSpacingKeys, findConfigFile, flattenColors, generateAndWriteTypes, generateTypeDeclarations, generateTypes, transformSource as migrateSource, scanTailwindConfig, writeDeclarationFile };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@csszyx/cli",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Command-line tools for csszyx",
   "keywords": [
     "csszyx",
@@ -27,8 +27,10 @@
   "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.mts",
-      "import": "./dist/index.mjs"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
     }
   },
   "files": [
@@ -36,28 +38,27 @@
   ],
   "dependencies": {
     "@babel/parser": "^7.23.0",
-    "@babel/traverse": "^7.23.0",
-    "@babel/generator": "^7.23.0",
     "@babel/types": "^7.23.0",
     "cac": "^6.7.14",
-    "fast-glob": "^3.3.2",
-    "tailwindcss": "^3.4.1",
-    "prompts": "^2.4.2",
-    "picocolors": "^1.0.0",
-    "ora": "^8.0.1",
+    "chokidar": "^5.0.0",
     "execa": "^8.0.1",
+    "fast-glob": "^3.3.2",
     "fs-extra": "^11.2.0",
-    "@csszyx/types": "0.8.0"
+    "minimatch": "^10.2.4",
+    "ora": "^8.0.1",
+    "picocolors": "^1.0.0",
+    "prompts": "^2.4.2",
+    "tailwindcss": "^3.4.1",
+    "@csszyx/types": "0.9.1",
+    "@csszyx/unplugin": "0.9.1"
   },
   "devDependencies": {
-    "@types/babel__generator": "^7.6.8",
-    "@types/babel__traverse": "^7.20.5",
+    "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.11.5",
     "@types/prompts": "^2.4.9",
-    "@types/fs-extra": "^11.0.4",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.6",
-    "unbuild": "^3.6.1"
+    "unbuild": "^3.6.1",
+    "vitest": "^4.1.6"
   },
   "sideEffects": false,
   "engines": {