tailwindcss-patch 8.7.2 → 8.7.4-alpha.0

package/dist/{chunk-PL4WB2UD.mjs → chunk-6ZDYMYHE.mjs}

@@ -1,3 +1,7 @@
+import {
+  __dirname
+} from "./chunk-A67ABH3M.mjs";
+
 // src/logger.ts
 import { createConsola } from "consola";
 var logger = createConsola();
@@ -16,7 +20,7 @@ import path from "pathe";
 // package.json
 var package_default = {
   name: "tailwindcss-patch",
-  version: "8.7.2",
+  version: "8.7.4-alpha.0",
   description: "patch tailwindcss for exposing context and extract classes",
   author: "ice breaker <1324318532@qq.com>",
   license: "MIT",
@@ -37,17 +41,17 @@ var package_default = {
   ],
   exports: {
     ".": {
-      types: "./src/index.ts",
-      import: "./src/index.ts",
-      require: "./src/index.ts"
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
     },
     "./migration-report.schema.json": "./schema/migration-report.schema.json",
     "./restore-result.schema.json": "./schema/restore-result.schema.json",
     "./validate-result.schema.json": "./schema/validate-result.schema.json"
   },
-  main: "./src/index.ts",
-  module: "./src/index.ts",
-  types: "./src/index.ts",
+  main: "./dist/index.js",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
   bin: {
     "tw-patch": "dev/bin.ts",
     "tailwindcss-patch": "dev/bin.ts"
@@ -62,6 +66,7 @@ var package_default = {
     build: "tsup",
     test: "vitest run",
     "test:dev": "vitest",
+    "bench:cold-start": "node --import tsx bench/cold-start.ts",
     patch: "tsx dev/bin.ts install",
     r0: "tsx dev/bin.ts extract",
     r1: "tsx dev/bin.ts extract --css index.css"
@@ -102,12 +107,12 @@ var package_default = {
     "@babel/types": "^7.29.0",
     "@tailwindcss-mangle/config": "workspace:*",
     "@tailwindcss/node": "^4.2.1",
-    cac: "^6.7.14",
+    cac: "^7.0.0",
     consola: "^3.4.2",
-    "fs-extra": "^11.3.3",
+    "fs-extra": "^11.3.4",
     "local-pkg": "^1.1.2",
     pathe: "^2.0.3",
-    postcss: "^8.5.6",
+    postcss: "^8.5.8",
     semver: "^7.7.4",
     "tailwindcss-config": "^1.1.4"
   },
@@ -1507,230 +1512,10 @@ ${Date.now()}`, { flag: "wx" });
   }
 };
 
-// src/extraction/candidate-extractor.ts
-import { promises as fs3 } from "fs";
+// src/options/normalize.ts
 import process3 from "process";
+import fs3 from "fs-extra";
 import path2 from "pathe";
-async function importNode() {
-  return import("@tailwindcss/node");
-}
-async function importOxide() {
-  return import("@tailwindcss/oxide");
-}
-async function loadDesignSystem(css, bases) {
-  const uniqueBases = Array.from(new Set(bases.filter(Boolean)));
-  if (uniqueBases.length === 0) {
-    throw new Error("No base directories provided for Tailwind CSS design system.");
-  }
-  const { __unstable__loadDesignSystem } = await importNode();
-  let lastError;
-  for (const base of uniqueBases) {
-    try {
-      return await __unstable__loadDesignSystem(css, { base });
-    } catch (error) {
-      lastError = error;
-    }
-  }
-  if (lastError instanceof Error) {
-    throw lastError;
-  }
-  throw new Error("Failed to load Tailwind CSS design system.");
-}
-async function extractRawCandidatesWithPositions(content, extension = "html") {
-  const { Scanner } = await importOxide();
-  const scanner = new Scanner({});
-  const result = scanner.getCandidatesWithPositions({ content, extension });
-  return result.map(({ candidate, position }) => ({
-    rawCandidate: candidate,
-    start: position,
-    end: position + candidate.length
-  }));
-}
-async function extractRawCandidates(sources) {
-  const { Scanner } = await importOxide();
-  const scanner = new Scanner(sources === void 0 ? {} : { sources });
-  return scanner.scan();
-}
-async function extractValidCandidates(options) {
-  const providedOptions = options ?? {};
-  const defaultCwd = providedOptions.cwd ?? process3.cwd();
-  const base = providedOptions.base ?? defaultCwd;
-  const baseFallbacks = providedOptions.baseFallbacks ?? [];
-  const css = providedOptions.css ?? '@import "tailwindcss";';
-  const sources = (providedOptions.sources ?? [
-    {
-      base: defaultCwd,
-      pattern: "**/*",
-      negated: false
-    }
-  ]).map((source) => ({
-    base: source.base ?? defaultCwd,
-    pattern: source.pattern,
-    negated: source.negated
-  }));
-  const designSystem = await loadDesignSystem(css, [base, ...baseFallbacks]);
-  const candidates = await extractRawCandidates(sources);
-  const parsedCandidates = candidates.filter(
-    (rawCandidate) => designSystem.parseCandidate(rawCandidate).length > 0
-  );
-  if (parsedCandidates.length === 0) {
-    return parsedCandidates;
-  }
-  const cssByCandidate = designSystem.candidatesToCss(parsedCandidates);
-  const validCandidates = [];
-  for (let index = 0; index < parsedCandidates.length; index++) {
-    const candidate = parsedCandidates[index];
-    if (candidate === void 0) {
-      continue;
-    }
-    const css2 = cssByCandidate[index];
-    if (typeof css2 === "string" && css2.trim().length > 0) {
-      validCandidates.push(candidate);
-    }
-  }
-  return validCandidates;
-}
-function normalizeSources(sources, cwd) {
-  const baseSources = sources?.length ? sources : [
-    {
-      base: cwd,
-      pattern: "**/*",
-      negated: false
-    }
-  ];
-  return baseSources.map((source) => ({
-    base: source.base ?? cwd,
-    pattern: source.pattern,
-    negated: source.negated
-  }));
-}
-function buildLineOffsets(content) {
-  const offsets = [0];
-  for (let i = 0; i < content.length; i++) {
-    if (content[i] === "\n") {
-      offsets.push(i + 1);
-    }
-  }
-  if (offsets[offsets.length - 1] !== content.length) {
-    offsets.push(content.length);
-  }
-  return offsets;
-}
-function resolveLineMeta(content, offsets, index) {
-  let low = 0;
-  let high = offsets.length - 1;
-  while (low <= high) {
-    const mid = Math.floor((low + high) / 2);
-    const start = offsets[mid];
-    if (start === void 0) {
-      break;
-    }
-    const nextStart = offsets[mid + 1] ?? content.length;
-    if (index < start) {
-      high = mid - 1;
-      continue;
-    }
-    if (index >= nextStart) {
-      low = mid + 1;
-      continue;
-    }
-    const line = mid + 1;
-    const column = index - start + 1;
-    const lineEnd = content.indexOf("\n", start);
-    const lineText = content.slice(start, lineEnd === -1 ? content.length : lineEnd);
-    return { line, column, lineText };
-  }
-  const lastStart = offsets[offsets.length - 2] ?? 0;
-  return {
-    line: offsets.length - 1,
-    column: index - lastStart + 1,
-    lineText: content.slice(lastStart)
-  };
-}
-function toExtension(filename) {
-  const ext = path2.extname(filename).replace(/^\./, "");
-  return ext || "txt";
-}
-function toRelativeFile(cwd, filename) {
-  const relative = path2.relative(cwd, filename);
-  return relative === "" ? path2.basename(filename) : relative;
-}
-async function extractProjectCandidatesWithPositions(options) {
-  const cwd = options?.cwd ? path2.resolve(options.cwd) : process3.cwd();
-  const normalizedSources = normalizeSources(options?.sources, cwd);
-  const { Scanner } = await importOxide();
-  const scanner = new Scanner({
-    sources: normalizedSources
-  });
-  const files = scanner.files ?? [];
-  const entries = [];
-  const skipped = [];
-  for (const file of files) {
-    let content;
-    try {
-      content = await fs3.readFile(file, "utf8");
-    } catch (error) {
-      skipped.push({
-        file,
-        reason: error instanceof Error ? error.message : "Unknown error"
-      });
-      continue;
-    }
-    const extension = toExtension(file);
-    const matches = scanner.getCandidatesWithPositions({
-      file,
-      content,
-      extension
-    });
-    if (!matches.length) {
-      continue;
-    }
-    const offsets = buildLineOffsets(content);
-    const relativeFile = toRelativeFile(cwd, file);
-    for (const match of matches) {
-      const info = resolveLineMeta(content, offsets, match.position);
-      entries.push({
-        rawCandidate: match.candidate,
-        file,
-        relativeFile,
-        extension,
-        start: match.position,
-        end: match.position + match.candidate.length,
-        length: match.candidate.length,
-        line: info.line,
-        column: info.column,
-        lineText: info.lineText
-      });
-    }
-  }
-  return {
-    entries,
-    filesScanned: files.length,
-    skippedFiles: skipped,
-    sources: normalizedSources
-  };
-}
-function groupTokensByFile(report, options) {
-  const key = options?.key ?? "relative";
-  const stripAbsolute = options?.stripAbsolutePaths ?? key !== "absolute";
-  return report.entries.reduce((acc, entry) => {
-    const bucketKey = key === "absolute" ? entry.file : entry.relativeFile;
-    if (!acc[bucketKey]) {
-      acc[bucketKey] = [];
-    }
-    const value = stripAbsolute ? {
-      ...entry,
-      file: entry.relativeFile
-    } : entry;
-    acc[bucketKey].push(value);
-    return acc;
-  }, {});
-}
-
-// src/options/normalize.ts
-import process4 from "process";
-import fs4 from "fs-extra";
-import path3 from "pathe";
 var hasWarnedDeprecatedOptions = false;
 var deprecatedOptionMapping = {
   cwd: "projectRoot",
@@ -1740,11 +1525,11 @@ var deprecatedOptionMapping = {
   output: "extract"
 };
 function resolveRealpathSafe(value) {
-  const resolved = path3.resolve(value);
+  const resolved = path2.resolve(value);
   try {
-    return path3.normalize(fs4.realpathSync(resolved));
+    return path2.normalize(fs3.realpathSync(resolved));
   } catch {
-    return path3.normalize(resolved);
+    return path2.normalize(resolved);
   }
 }
 function toPrettyValue(value) {
@@ -1765,7 +1550,7 @@ function normalizeCacheDriver(driver) {
 function normalizeCacheOptions(cache, projectRoot) {
   let enabled = false;
   let cwd = resolveRealpathSafe(projectRoot);
-  let dir = path3.resolve(cwd, "node_modules/.cache", pkgName);
+  let dir = path2.resolve(cwd, "node_modules/.cache", pkgName);
   let file = "class-cache.json";
   let strategy = "merge";
   let driver = "file";
@@ -1774,12 +1559,12 @@ function normalizeCacheOptions(cache, projectRoot) {
   } else if (typeof cache === "object" && cache) {
     enabled = cache.enabled ?? true;
     cwd = cache.cwd ? resolveRealpathSafe(cache.cwd) : cwd;
-    dir = cache.dir ? path3.resolve(cache.dir) : path3.resolve(cwd, "node_modules/.cache", pkgName);
+    dir = cache.dir ? path2.resolve(cache.dir) : path2.resolve(cwd, "node_modules/.cache", pkgName);
     file = cache.file ?? file;
     strategy = cache.strategy ?? strategy;
     driver = normalizeCacheDriver(cache.driver);
   }
-  const filename = path3.resolve(dir, file);
+  const filename = path2.resolve(dir, file);
   return {
     enabled,
     cwd,
@@ -1842,9 +1627,9 @@ function normalizeExtendLengthUnitsOptions(extend) {
   };
 }
 function normalizeTailwindV4Options(v4, fallbackBase) {
-  const configuredBase = v4?.base ? path3.resolve(v4.base) : void 0;
+  const configuredBase = v4?.base ? path2.resolve(v4.base) : void 0;
   const base = configuredBase ?? fallbackBase;
-  const cssEntries = Array.isArray(v4?.cssEntries) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => path3.resolve(entry)) : [];
+  const cssEntries = Array.isArray(v4?.cssEntries) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => path2.resolve(entry)) : [];
   const userSources = v4?.sources;
   const hasUserDefinedSources = Boolean(userSources?.length);
   const sources = hasUserDefinedSources ? userSources : [
@@ -1936,7 +1721,7 @@ function warnDeprecatedOptionsIfNeeded(options) {
 function normalizeOptions(options = {}) {
   warnDeprecatedOptionsIfNeeded(options);
   const resolved = resolveOptionSlices(options);
-  const projectRoot = resolveRealpathSafe(resolved.projectRoot ? path3.resolve(resolved.projectRoot) : process4.cwd());
+  const projectRoot = resolveRealpathSafe(resolved.projectRoot ? path2.resolve(resolved.projectRoot) : process3.cwd());
   const overwrite = resolved.overwrite ?? true;
   const output = normalizeOutputOptions(resolved.extract);
   const cache = normalizeCacheOptions(options.cache, projectRoot);
@@ -1966,49 +1751,745 @@ function normalizeOptions(options = {}) {
   };
 }
 
-// src/patching/status.ts
-import * as t4 from "@babel/types";
-import fs6 from "fs-extra";
-import path5 from "pathe";
-
-// src/babel/index.ts
-import _babelGenerate from "@babel/generator";
-import _babelTraverse from "@babel/traverse";
-import { parse, parseExpression } from "@babel/parser";
-function _interopDefaultCompat(e) {
-  return e && typeof e === "object" && "default" in e ? e.default : e;
-}
-var generate = _interopDefaultCompat(_babelGenerate);
-var traverse = _interopDefaultCompat(_babelTraverse);
-
-// src/patching/operations/export-context/postcss-v2.ts
-import * as t from "@babel/types";
-var IDENTIFIER_RE = /^[A-Z_$][\w$]*$/i;
-function toIdentifierName(property) {
-  if (!property) {
-    return "contextRef";
-  }
-  const sanitized = property.replace(/[^\w$]/gu, "_");
-  if (/^\d/.test(sanitized)) {
-    return `_${sanitized}`;
+// src/options/legacy.ts
+function normalizeLegacyFeatures(patch) {
+  const apply = patch?.applyPatches;
+  const extend = apply?.extendLengthUnits;
+  let extendOption = false;
+  if (extend && typeof extend === "object") {
+    extendOption = {
+      ...extend,
+      enabled: true
+    };
+  } else if (extend === true) {
+    extendOption = {
+      enabled: true,
+      units: ["rpx"],
+      ...patch?.overwrite === void 0 ? {} : { overwrite: patch.overwrite }
+    };
   }
-  return sanitized || "contextRef";
+  return {
+    exposeContext: apply?.exportContext ?? true,
+    extendLengthUnits: extendOption
+  };
 }
-function createExportsMember(property) {
-  if (IDENTIFIER_RE.test(property)) {
-    return t.memberExpression(t.identifier("exports"), t.identifier(property));
+function fromLegacyOptions(options) {
+  if (!options) {
+    return {};
   }
-  return t.memberExpression(t.identifier("exports"), t.stringLiteral(property), true);
-}
-function transformProcessTailwindFeaturesReturnContextV2(content) {
-  const ast = parse(content, {
-    sourceType: "unambiguous"
-  });
-  let hasPatched = false;
-  traverse(ast, {
-    FunctionDeclaration(path13) {
-      const node = path13.node;
-      if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
+  const patch = options.patch;
+  const features = normalizeLegacyFeatures(patch);
+  const output = patch?.output;
+  const tailwindConfig = patch?.tailwindcss;
+  const tailwindVersion = tailwindConfig?.version;
+  const tailwindV2 = tailwindConfig?.v2;
+  const tailwindV3 = tailwindConfig?.v3;
+  const tailwindV4 = tailwindConfig?.v4;
+  const tailwindConfigPath = tailwindV3?.config ?? tailwindV2?.config;
+  const tailwindCwd = tailwindV3?.cwd ?? tailwindV2?.cwd ?? patch?.cwd;
+  const normalizedExtract = output ? {
+    ...output.filename === void 0 ? {} : { file: output.filename },
+    pretty: output.loose ? 2 : false,
+    ...output.removeUniversalSelector === void 0 ? {} : { removeUniversalSelector: output.removeUniversalSelector }
+  } : void 0;
+  const normalizedTailwindcss = {
+    ...patch?.packageName === void 0 ? {} : { packageName: patch.packageName },
+    ...tailwindVersion === void 0 ? {} : { version: tailwindVersion },
+    ...patch?.resolve === void 0 ? {} : { resolve: patch.resolve },
+    ...tailwindConfigPath === void 0 ? {} : { config: tailwindConfigPath },
+    ...tailwindCwd === void 0 ? {} : { cwd: tailwindCwd },
+    ...tailwindV2 === void 0 ? {} : { v2: tailwindV2 },
+    ...tailwindV3 === void 0 ? {} : { v3: tailwindV3 },
+    ...tailwindV4 === void 0 ? {} : { v4: tailwindV4 }
+  };
+  const normalizedCache = typeof options.cache === "boolean" ? options.cache : options.cache ? {
+    ...options.cache,
+    enabled: options.cache.enabled ?? true
+  } : void 0;
+  const normalizedApply = {
+    ...patch?.overwrite === void 0 ? {} : { overwrite: patch.overwrite },
+    exposeContext: features.exposeContext,
+    extendLengthUnits: features.extendLengthUnits
+  };
+  return {
+    ...patch?.cwd === void 0 ? {} : { projectRoot: patch.cwd },
+    ...patch?.filter === void 0 ? {} : { filter: patch.filter },
+    ...normalizedCache === void 0 ? {} : { cache: normalizedCache },
+    ...normalizedExtract === void 0 ? {} : { extract: normalizedExtract },
+    ...Object.keys(normalizedTailwindcss).length === 0 ? {} : { tailwindcss: normalizedTailwindcss },
+    apply: normalizedApply
+  };
+}
+function fromUnifiedConfig(registry) {
+  if (!registry) {
+    return {};
+  }
+  const tailwind = registry.tailwindcss ?? registry.tailwind;
+  const modernExtract = registry.extract;
+  const legacyOutput = registry.output;
+  const pretty = (() => {
+    const value = modernExtract?.pretty ?? legacyOutput?.pretty;
+    if (value === void 0) {
+      return void 0;
+    }
+    if (typeof value === "boolean") {
+      return value ? 2 : false;
+    }
+    return value;
+  })();
+  const removeUniversalSelector = modernExtract?.removeUniversalSelector ?? legacyOutput?.stripUniversalSelector;
+  const outputFile = modernExtract?.file ?? legacyOutput?.file;
+  const normalizedExtract = modernExtract || legacyOutput ? {
+    ...modernExtract?.write === void 0 ? {} : { write: modernExtract.write },
+    ...outputFile === void 0 ? {} : { file: outputFile },
+    ...pretty === void 0 ? {} : { pretty },
+    ...removeUniversalSelector === void 0 ? {} : { removeUniversalSelector },
+    ...modernExtract?.format === void 0 ? {} : { format: modernExtract.format }
+  } : void 0;
+  const normalizedTailwindcss = tailwind ? {
+    ...tailwind.version === void 0 ? {} : { version: tailwind.version },
+    ...tailwind.packageName === void 0 ? tailwind.package === void 0 ? {} : { packageName: tailwind.package } : { packageName: tailwind.packageName },
+    ...tailwind.resolve === void 0 ? {} : { resolve: tailwind.resolve },
+    ...tailwind.config === void 0 ? {} : { config: tailwind.config },
+    ...tailwind.cwd === void 0 ? {} : { cwd: tailwind.cwd },
+    ...tailwind.v2 === void 0 ? tailwind.legacy === void 0 ? {} : { v2: tailwind.legacy } : { v2: tailwind.v2 },
+    ...tailwind.v3 === void 0 ? tailwind.classic === void 0 ? {} : { v3: tailwind.classic } : { v3: tailwind.v3 },
+    ...tailwind.v4 === void 0 ? tailwind.next === void 0 ? {} : { v4: tailwind.next } : { v4: tailwind.v4 }
+  } : void 0;
+  const normalizedApply = registry.apply ? {
+    ...registry.apply.overwrite === void 0 ? {} : { overwrite: registry.apply.overwrite },
+    ...registry.apply.exposeContext === void 0 ? {} : { exposeContext: registry.apply.exposeContext },
+    ...registry.apply.extendLengthUnits === void 0 ? {} : { extendLengthUnits: registry.apply.extendLengthUnits }
+  } : void 0;
+  return {
+    ...registry.projectRoot === void 0 ? {} : { projectRoot: registry.projectRoot },
+    ...normalizedApply === void 0 ? {} : { apply: normalizedApply },
+    ...registry.cache === void 0 ? {} : { cache: registry.cache },
+    ...registry.filter === void 0 ? {} : { filter: registry.filter },
+    ...normalizedExtract === void 0 ? {} : { extract: normalizedExtract },
+    ...normalizedTailwindcss === void 0 ? {} : { tailwindcss: normalizedTailwindcss }
+  };
+}
+
+// src/config/workspace.ts
+import { pathToFileURL } from "url";
+import path3 from "pathe";
+var configModulePromise;
+var defuPromise;
+function isNodeError(error) {
+  return !!error && typeof error === "object" && ("code" in error || "message" in error);
+}
+function isMissingConfigModuleError(error) {
+  if (!isNodeError(error) || error.code !== "MODULE_NOT_FOUND") {
+    return false;
+  }
+  const message = error.message ?? "";
+  return message.includes("@tailwindcss-mangle/config");
+}
+function isMissingSharedModuleError(error) {
+  if (!isNodeError(error) || error.code !== "MODULE_NOT_FOUND") {
+    return false;
+  }
+  const message = error.message ?? "";
+  return message.includes("@tailwindcss-mangle/shared");
+}
+async function loadWorkspaceConfigModule() {
+  if (!configModulePromise) {
+    configModulePromise = import("@tailwindcss-mangle/config").catch(async (error) => {
+      if (!isMissingConfigModuleError(error)) {
+        throw error;
+      }
+      const fallback = path3.resolve(__dirname, "../../../config/src/index.ts");
+      return import(pathToFileURL(fallback).href);
+    });
+  }
+  return configModulePromise;
+}
+async function loadWorkspaceDefu() {
+  if (!defuPromise) {
+    defuPromise = import("./dist-7UDSGIWH.mjs").then((mod) => mod.defu).catch(async (error) => {
+      if (!isMissingSharedModuleError(error)) {
+        throw error;
+      }
+      const fallback = path3.resolve(__dirname, "../../../shared/src/utils.ts");
+      const mod = await import(pathToFileURL(fallback).href);
+      return mod.defu;
+    });
+  }
+  return defuPromise;
+}
+async function loadPatchOptionsForWorkspace(cwd, overrides) {
+  const merge = await loadWorkspaceDefu();
+  const configModule = await loadWorkspaceConfigModule();
+  const { config } = await configModule.getConfig(cwd);
+  const legacyConfig = config;
+  const base = config?.registry ? fromUnifiedConfig(config.registry) : legacyConfig?.patch ? fromLegacyOptions({ patch: legacyConfig.patch }) : {};
+  const merged = merge(overrides ?? {}, base);
+  return merged;
+}
+
+// src/extraction/candidate-extractor.ts
+import { promises as fs4 } from "fs";
+import process4 from "process";
+import path4 from "pathe";
+var nodeImportPromise;
+var oxideImportPromise;
+var designSystemPromiseCache = /* @__PURE__ */ new Map();
+var designSystemCandidateCache = /* @__PURE__ */ new Map();
+async function importNode() {
+  return import("@tailwindcss/node");
+}
+async function importOxide() {
+  return import("@tailwindcss/oxide");
+}
+function getNodeModule() {
+  nodeImportPromise ??= importNode();
+  return nodeImportPromise;
+}
+function getOxideModule() {
+  oxideImportPromise ??= importOxide();
+  return oxideImportPromise;
+}
+function createDesignSystemCacheKey(css, bases) {
+  return JSON.stringify({
+    css,
+    bases: Array.from(new Set(bases.filter(Boolean)))
+  });
+}
+async function loadDesignSystem(css, bases) {
+  const uniqueBases = Array.from(new Set(bases.filter(Boolean)));
+  if (uniqueBases.length === 0) {
+    throw new Error("No base directories provided for Tailwind CSS design system.");
+  }
+  const cacheKey = createDesignSystemCacheKey(css, uniqueBases);
+  const cached = designSystemPromiseCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const promise = (async () => {
+    const { __unstable__loadDesignSystem } = await getNodeModule();
+    let lastError;
+    for (const base of uniqueBases) {
+      try {
+        return await __unstable__loadDesignSystem(css, { base });
+      } catch (error) {
+        lastError = error;
+      }
+    }
+    if (lastError instanceof Error) {
+      throw lastError;
+    }
+    throw new Error("Failed to load Tailwind CSS design system.");
+  })();
+  designSystemPromiseCache.set(cacheKey, promise);
+  promise.catch(() => {
+    if (designSystemPromiseCache.get(cacheKey) === promise) {
+      designSystemPromiseCache.delete(cacheKey);
+      designSystemCandidateCache.delete(cacheKey);
+    }
+  });
+  return promise;
+}
+async function extractRawCandidatesWithPositions(content, extension = "html") {
+  const { Scanner } = await getOxideModule();
+  const scanner = new Scanner({});
+  const result = scanner.getCandidatesWithPositions({ content, extension });
+  return result.map(({ candidate, position }) => ({
+    rawCandidate: candidate,
+    start: position,
+    end: position + candidate.length
+  }));
+}
+async function extractRawCandidates(sources) {
+  const { Scanner } = await getOxideModule();
+  const scanner = new Scanner(sources === void 0 ? {} : { sources });
+  return scanner.scan();
+}
+async function extractValidCandidates(options) {
+  const providedOptions = options ?? {};
+  const defaultCwd = providedOptions.cwd ?? process4.cwd();
+  const base = providedOptions.base ?? defaultCwd;
+  const baseFallbacks = providedOptions.baseFallbacks ?? [];
+  const css = providedOptions.css ?? '@import "tailwindcss";';
+  const sources = (providedOptions.sources ?? [
+    {
+      base: defaultCwd,
+      pattern: "**/*",
+      negated: false
+    }
+  ]).map((source) => ({
+    base: source.base ?? defaultCwd,
+    pattern: source.pattern,
+    negated: source.negated
+  }));
+  const designSystemKey = createDesignSystemCacheKey(css, [base, ...baseFallbacks]);
+  const designSystem = await loadDesignSystem(css, [base, ...baseFallbacks]);
+  const candidateCache = designSystemCandidateCache.get(designSystemKey) ?? /* @__PURE__ */ new Map();
+  designSystemCandidateCache.set(designSystemKey, candidateCache);
+  const candidates = await extractRawCandidates(sources);
+  const validCandidates = [];
+  const uncachedCandidates = [];
+  for (const rawCandidate of candidates) {
+    const cached = candidateCache.get(rawCandidate);
+    if (cached === true) {
+      validCandidates.push(rawCandidate);
+      continue;
+    }
+    if (cached === false) {
+      continue;
+    }
+    if (designSystem.parseCandidate(rawCandidate).length > 0) {
+      uncachedCandidates.push(rawCandidate);
+      continue;
+    }
+    candidateCache.set(rawCandidate, false);
+  }
+  if (uncachedCandidates.length === 0) {
+    return validCandidates;
+  }
+  const cssByCandidate = designSystem.candidatesToCss(uncachedCandidates);
+  for (let index = 0; index < uncachedCandidates.length; index++) {
+    const candidate = uncachedCandidates[index];
+    if (candidate === void 0) {
+      continue;
+    }
+    const candidateCss = cssByCandidate[index];
+    const isValid = typeof candidateCss === "string" && candidateCss.trim().length > 0;
+    candidateCache.set(candidate, isValid);
+    if (!isValid) {
+      continue;
+    }
+    validCandidates.push(candidate);
+  }
+  return validCandidates;
+}
+function normalizeSources(sources, cwd) {
+  const baseSources = sources?.length ? sources : [
+    {
+      base: cwd,
+      pattern: "**/*",
+      negated: false
+    }
+  ];
+  return baseSources.map((source) => ({
+    base: source.base ?? cwd,
+    pattern: source.pattern,
+    negated: source.negated
+  }));
+}
+function buildLineOffsets(content) {
+  const offsets = [0];
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "\n") {
+      offsets.push(i + 1);
+    }
+  }
+  if (offsets[offsets.length - 1] !== content.length) {
+    offsets.push(content.length);
+  }
+  return offsets;
+}
+function resolveLineMeta(content, offsets, index) {
+  let low = 0;
+  let high = offsets.length - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const start = offsets[mid];
+    if (start === void 0) {
+      break;
+    }
+    const nextStart = offsets[mid + 1] ?? content.length;
+    if (index < start) {
+      high = mid - 1;
+      continue;
+    }
+    if (index >= nextStart) {
+      low = mid + 1;
+      continue;
+    }
+    const line = mid + 1;
+    const column = index - start + 1;
+    const lineEnd = content.indexOf("\n", start);
+    const lineText = content.slice(start, lineEnd === -1 ? content.length : lineEnd);
+    return { line, column, lineText };
+  }
+  const lastStart = offsets[offsets.length - 2] ?? 0;
+  return {
+    line: offsets.length - 1,
+    column: index - lastStart + 1,
+    lineText: content.slice(lastStart)
+  };
+}
+function toExtension(filename) {
+  const ext = path4.extname(filename).replace(/^\./, "");
+  return ext || "txt";
+}
+function toRelativeFile(cwd, filename) {
+  const relative = path4.relative(cwd, filename);
+  return relative === "" ? path4.basename(filename) : relative;
+}
+async function extractProjectCandidatesWithPositions(options) {
+  const cwd = options?.cwd ? path4.resolve(options.cwd) : process4.cwd();
+  const normalizedSources = normalizeSources(options?.sources, cwd);
+  const { Scanner } = await getOxideModule();
+  const scanner = new Scanner({
+    sources: normalizedSources
+  });
+  const files = scanner.files ?? [];
+  const entries = [];
+  const skipped = [];
+  for (const file of files) {
+    let content;
+    try {
+      content = await fs4.readFile(file, "utf8");
+    } catch (error) {
+      skipped.push({
+        file,
+        reason: error instanceof Error ? error.message : "Unknown error"
+      });
+      continue;
+    }
+    const extension = toExtension(file);
+    const matches = scanner.getCandidatesWithPositions({
+      file,
+      content,
+      extension
+    });
+    if (!matches.length) {
+      continue;
+    }
+    const offsets = buildLineOffsets(content);
+    const relativeFile = toRelativeFile(cwd, file);
+    for (const match of matches) {
+      const info = resolveLineMeta(content, offsets, match.position);
+      entries.push({
+        rawCandidate: match.candidate,
+        file,
+        relativeFile,
+        extension,
+        start: match.position,
+        end: match.position + match.candidate.length,
+        length: match.candidate.length,
+        line: info.line,
+        column: info.column,
+        lineText: info.lineText
+      });
+    }
+  }
+  return {
+    entries,
+    filesScanned: files.length,
+    skippedFiles: skipped,
+    sources: normalizedSources
+  };
+}
+function groupTokensByFile(report, options) {
+  const key = options?.key ?? "relative";
+  const stripAbsolute = options?.stripAbsolutePaths ?? key !== "absolute";
+  return report.entries.reduce((acc, entry) => {
+    const bucketKey = key === "absolute" ? entry.file : entry.relativeFile;
+    if (!acc[bucketKey]) {
+      acc[bucketKey] = [];
+    }
+    const value = stripAbsolute ? {
+      ...entry,
+      file: entry.relativeFile
+    } : entry;
+    acc[bucketKey].push(value);
+    return acc;
+  }, {});
+}
+
+// src/runtime/class-collector.ts
+import process5 from "process";
+import fs5 from "fs-extra";
+import path5 from "pathe";
+
+// src/utils.ts
+function isObject(val) {
+  return val !== null && typeof val === "object" && Array.isArray(val) === false;
+}
+function spliceChangesIntoString(str, changes) {
+  if (!changes[0]) {
+    return str;
+  }
+  changes.sort((a, b) => {
+    return a.end - b.end || a.start - b.start;
+  });
+  let result = "";
+  let previous = changes[0];
+  result += str.slice(0, previous.start);
+  result += previous.replacement;
+  for (let i = 1; i < changes.length; ++i) {
+    const change = changes[i];
+    result += str.slice(previous.end, change.start);
+    result += change.replacement;
+    previous = change;
+  }
+  result += str.slice(previous.end);
+  return result;
+}
+
+// src/runtime/class-collector.ts
+function collectClassesFromContexts(contexts, filter) {
+  const set = /* @__PURE__ */ new Set();
+  for (const context of contexts) {
+    if (!isObject(context) || !context.classCache) {
+      continue;
+    }
+    for (const key of context.classCache.keys()) {
+      const className = key.toString();
+      if (filter(className)) {
+        set.add(className);
+      }
+    }
+  }
+  return set;
+}
+async function collectClassesFromTailwindV4(options) {
+  const set = /* @__PURE__ */ new Set();
+  const v4Options = options.tailwind.v4;
+  if (!v4Options) {
+    return set;
+  }
+  const toAbsolute = (value) => {
+    if (!value) {
+      return void 0;
+    }
+    return path5.isAbsolute(value) ? value : path5.resolve(options.projectRoot, value);
+  };
+  const resolvedConfiguredBase = toAbsolute(v4Options.configuredBase);
+  const resolvedDefaultBase = toAbsolute(v4Options.base) ?? process5.cwd();
+  const resolveSources = (base) => {
+    if (!v4Options.sources?.length) {
+      return void 0;
+    }
+    return v4Options.sources.map((source) => ({
+      base: source.base ?? base,
+      pattern: source.pattern,
+      negated: source.negated
+    }));
+  };
+  if (v4Options.cssEntries.length > 0) {
+    for (const entry of v4Options.cssEntries) {
+      const filePath = path5.isAbsolute(entry) ? entry : path5.resolve(options.projectRoot, entry);
+      if (!await fs5.pathExists(filePath)) {
+        continue;
+      }
+      const css = await fs5.readFile(filePath, "utf8");
+      const entryDir = path5.dirname(filePath);
+      const designSystemBases = resolvedConfiguredBase && resolvedConfiguredBase !== entryDir ? [entryDir, resolvedConfiguredBase] : [entryDir];
+      const sourcesBase = resolvedConfiguredBase ?? entryDir;
+      const sources = resolveSources(sourcesBase);
+      const firstBase = designSystemBases[0] ?? entryDir;
+      const extractOptions = {
+        cwd: options.projectRoot,
+        base: firstBase,
+        baseFallbacks: designSystemBases.slice(1),
+        css,
+        ...sources === void 0 ? {} : { sources }
+      };
+      const candidates = await extractValidCandidates(extractOptions);
+      for (const candidate of candidates) {
+        if (options.filter(candidate)) {
+          set.add(candidate);
+        }
+      }
+    }
+  } else {
+    const baseForCss = resolvedConfiguredBase ?? resolvedDefaultBase;
+    const sources = resolveSources(baseForCss);
+    const extractOptions = {
+      cwd: options.projectRoot,
+      base: baseForCss,
+      ...v4Options.css === void 0 ? {} : { css: v4Options.css },
+      ...sources === void 0 ? {} : { sources }
+    };
+    const candidates = await extractValidCandidates(extractOptions);
+    for (const candidate of candidates) {
+      if (options.filter(candidate)) {
+        set.add(candidate);
+      }
+    }
+  }
+  return set;
+}
+
+// src/runtime/context-registry.ts
+import { createRequire } from "module";
+import fs6 from "fs-extra";
+import path6 from "pathe";
+var require2 = createRequire(import.meta.url);
+function resolveRuntimeEntry(packageInfo, majorVersion) {
+  const root = packageInfo.rootPath;
+  if (majorVersion === 2) {
+    const jitIndex = path6.join(root, "lib/jit/index.js");
+    if (fs6.existsSync(jitIndex)) {
+      return jitIndex;
+    }
+  } else if (majorVersion === 3) {
+    const plugin = path6.join(root, "lib/plugin.js");
+    const index = path6.join(root, "lib/index.js");
+    if (fs6.existsSync(plugin)) {
+      return plugin;
+    }
+    if (fs6.existsSync(index)) {
+      return index;
+    }
+  }
+  return void 0;
+}
+function loadRuntimeContexts(packageInfo, majorVersion, refProperty) {
+  if (majorVersion === 4) {
+    return [];
+  }
+  const entry = resolveRuntimeEntry(packageInfo, majorVersion);
+  if (!entry) {
+    return [];
+  }
+  const moduleExports = require2(entry);
+  if (!moduleExports) {
+    return [];
+  }
+  const ref = moduleExports[refProperty];
+  if (!ref) {
+    return [];
+  }
+  if (Array.isArray(ref)) {
+    return ref;
+  }
+  if (typeof ref === "object" && Array.isArray(ref.value)) {
+    return ref.value;
+  }
+  return [];
+}
+
+// src/runtime/process-tailwindcss.ts
+import { createRequire as createRequire2 } from "module";
+import fs7 from "fs-extra";
+import path7 from "pathe";
+import postcss from "postcss";
+import { loadConfig } from "tailwindcss-config";
+var require3 = createRequire2(import.meta.url);
+function resolveModuleEntry(id) {
+  return path7.isAbsolute(id) ? id : require3.resolve(id);
+}
+function resolvePackageRootFromEntry(entry) {
+  let current = path7.dirname(entry);
+  while (current && current !== path7.dirname(current)) {
+    const packageJsonPath = path7.join(current, "package.json");
+    if (fs7.pathExistsSync(packageJsonPath)) {
+      return current;
+    }
+    current = path7.dirname(current);
+  }
+  return void 0;
+}
+function clearTailwindV3RuntimeState(pluginName) {
+  try {
+    const entry = resolveModuleEntry(pluginName);
+    const root = resolvePackageRootFromEntry(entry);
+    if (!root) {
+      return;
+    }
+    const sharedStatePath = path7.join(root, "lib/lib/sharedState.js");
+    if (!fs7.pathExistsSync(sharedStatePath)) {
+      return;
+    }
+    const sharedState = require3.cache[sharedStatePath]?.exports;
+    sharedState?.contextMap?.clear();
+    sharedState?.configContextMap?.clear();
+    sharedState?.contextSourcesMap?.clear();
+    sharedState?.sourceHashMap?.clear();
+    for (const candidate of ["lib/plugin.js", "lib/index.js"]) {
+      const runtimeEntry = path7.join(root, candidate);
+      if (!fs7.pathExistsSync(runtimeEntry)) {
+        continue;
+      }
+      const runtimeModule = require3.cache[runtimeEntry]?.exports;
+      runtimeModule?.contextRef?.value?.splice(0, runtimeModule.contextRef.value.length);
+      break;
+    }
+  } catch {
+  }
+}
+async function resolveConfigPath(options) {
+  if (options.config && path7.isAbsolute(options.config)) {
+    return options.config;
+  }
+  const result = await loadConfig({ cwd: options.cwd });
+  if (!result) {
+    throw new Error(`Unable to locate Tailwind CSS config from ${options.cwd}`);
+  }
+  return result.filepath;
+}
+async function runTailwindBuild(options) {
+  const configPath = await resolveConfigPath(options);
+  const pluginName = options.postcssPlugin ?? (options.majorVersion === 4 ? "@tailwindcss/postcss" : "tailwindcss");
+  if (options.majorVersion === 3) {
+    clearTailwindV3RuntimeState(pluginName);
+  }
+  if (options.majorVersion === 4) {
+    return postcss([
+      require3(pluginName)({
+        config: configPath
+      })
+    ]).process("@import 'tailwindcss';", {
+      from: void 0
+    });
+  }
+  return postcss([
+    require3(pluginName)({
+      config: configPath
+    })
+  ]).process("@tailwind base;@tailwind components;@tailwind utilities;", {
+    from: void 0
+  });
+}
+
+// src/patching/status.ts
+import * as t4 from "@babel/types";
+import fs9 from "fs-extra";
+import path9 from "pathe";
+
+// src/babel/index.ts
+import _babelGenerate from "@babel/generator";
+import _babelTraverse from "@babel/traverse";
+import { parse, parseExpression } from "@babel/parser";
+function _interopDefaultCompat(e) {
+  return e && typeof e === "object" && "default" in e ? e.default : e;
+}
+var generate = _interopDefaultCompat(_babelGenerate);
+var traverse = _interopDefaultCompat(_babelTraverse);
+
+// src/patching/operations/export-context/postcss-v2.ts
+import * as t from "@babel/types";
+var IDENTIFIER_RE = /^[A-Z_$][\w$]*$/i;
+function toIdentifierName(property) {
+  if (!property) {
+    return "contextRef";
+  }
+  const sanitized = property.replace(/[^\w$]/gu, "_");
+  if (/^\d/.test(sanitized)) {
+    return `_${sanitized}`;
+  }
+  return sanitized || "contextRef";
+}
+function createExportsMember(property) {
+  if (IDENTIFIER_RE.test(property)) {
+    return t.memberExpression(t.identifier("exports"), t.identifier(property));
+  }
+  return t.memberExpression(t.identifier("exports"), t.stringLiteral(property), true);
+}
+function transformProcessTailwindFeaturesReturnContextV2(content) {
+  const ast = parse(content, {
+    sourceType: "unambiguous"
+  });
+  let hasPatched = false;
+  traverse(ast, {
+    FunctionDeclaration(path18) {
+      const node = path18.node;
+      if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
         return;
       }
       const returnStatement3 = node.body.body[0];
@@ -2038,8 +2519,8 @@ function transformPostcssPluginV2(content, options) {
   const ast = parse(content);
   let hasPatched = false;
   traverse(ast, {
-    Program(path13) {
-      const program = path13.node;
+    Program(path18) {
+      const program = path18.node;
       const index = program.body.findIndex((statement) => {
         return t.isFunctionDeclaration(statement) && statement.id?.name === "_default";
       });
@@ -2073,11 +2554,11 @@ function transformPostcssPluginV2(content, options) {
         );
       }
     },
-    FunctionDeclaration(path13) {
+    FunctionDeclaration(path18) {
       if (hasPatched) {
         return;
       }
-      const fn = path13.node;
+      const fn = path18.node;
       if (fn.id?.name !== "_default") {
         return;
       }
@@ -2166,8 +2647,8 @@ function transformProcessTailwindFeaturesReturnContext(content) {
   const ast = parse(content);
   let hasPatched = false;
   traverse(ast, {
-    FunctionDeclaration(path13) {
-      const node = path13.node;
+    FunctionDeclaration(path18) {
+      const node = path18.node;
       if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1) {
         return;
       }
@@ -2199,8 +2680,8 @@ function transformPostcssPlugin(content, { refProperty }) {
   const valueMember = t2.memberExpression(refIdentifier, t2.identifier("value"));
   let hasPatched = false;
   traverse(ast, {
-    Program(path13) {
-      const program = path13.node;
+    Program(path18) {
+      const program = path18.node;
       const index = program.body.findIndex((statement) => {
         return t2.isExpressionStatement(statement) && t2.isAssignmentExpression(statement.expression) && t2.isMemberExpression(statement.expression.left) && t2.isFunctionExpression(statement.expression.right) && statement.expression.right.id?.name === "tailwindcss";
       });
@@ -2238,11 +2719,11 @@ function transformPostcssPlugin(content, { refProperty }) {
         );
       }
     },
-    FunctionExpression(path13) {
+    FunctionExpression(path18) {
       if (hasPatched) {
         return;
       }
-      const fn = path13.node;
+      const fn = path18.node;
       if (fn.id?.name !== "tailwindcss" || fn.body.body.length !== 1) {
         return;
       }
@@ -2313,56 +2794,29 @@ function transformPostcssPlugin(content, { refProperty }) {
 
 // src/patching/operations/extend-length-units.ts
 import * as t3 from "@babel/types";
-import fs5 from "fs-extra";
-import path4 from "pathe";
-
-// src/utils.ts
-function isObject(val) {
-  return val !== null && typeof val === "object" && Array.isArray(val) === false;
-}
-function spliceChangesIntoString(str, changes) {
-  if (!changes[0]) {
-    return str;
-  }
-  changes.sort((a, b) => {
-    return a.end - b.end || a.start - b.start;
-  });
-  let result = "";
-  let previous = changes[0];
-  result += str.slice(0, previous.start);
-  result += previous.replacement;
-  for (let i = 1; i < changes.length; ++i) {
-    const change = changes[i];
-    result += str.slice(previous.end, change.start);
-    result += change.replacement;
-    previous = change;
-  }
-  result += str.slice(previous.end);
-  return result;
-}
-
-// src/patching/operations/extend-length-units.ts
+import fs8 from "fs-extra";
+import path8 from "pathe";
 function updateLengthUnitsArray(content, options) {
   const { variableName = "lengthUnits", units } = options;
   const ast = parse(content);
   let arrayRef;
   let changed = false;
   traverse(ast, {
-    Identifier(path13) {
-      if (path13.node.name === variableName && t3.isVariableDeclarator(path13.parent) && t3.isArrayExpression(path13.parent.init)) {
-        arrayRef = path13.parent.init;
+    Identifier(path18) {
+      if (path18.node.name === variableName && t3.isVariableDeclarator(path18.parent) && t3.isArrayExpression(path18.parent.init)) {
+        arrayRef = path18.parent.init;
         const existing = new Set(
-          path13.parent.init.elements.map((element) => t3.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
+          path18.parent.init.elements.map((element) => t3.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
         );
         for (const unit of units) {
           if (!existing.has(unit)) {
-            path13.parent.init.elements = path13.parent.init.elements.map((element) => {
+            path18.parent.init.elements = path18.parent.init.elements.map((element) => {
               if (t3.isStringLiteral(element)) {
                 return t3.stringLiteral(element.value);
               }
               return element;
             });
-            path13.parent.init.elements.push(t3.stringLiteral(unit));
+            path18.parent.init.elements.push(t3.stringLiteral(unit));
             changed = true;
           }
         }
@@ -2383,12 +2837,12 @@ function applyExtendLengthUnitsPatchV3(rootDir, options) {
     lengthUnitsFilePath: options.lengthUnitsFilePath ?? "lib/util/dataTypes.js",
     variableName: options.variableName ?? "lengthUnits"
   };
-  const dataTypesFilePath = path4.resolve(rootDir, opts.lengthUnitsFilePath);
-  const exists = fs5.existsSync(dataTypesFilePath);
+  const dataTypesFilePath = path8.resolve(rootDir, opts.lengthUnitsFilePath);
+  const exists = fs8.existsSync(dataTypesFilePath);
   if (!exists) {
     return { changed: false, code: void 0 };
   }
-  const content = fs5.readFileSync(dataTypesFilePath, "utf8");
+  const content = fs8.readFileSync(dataTypesFilePath, "utf8");
   const { arrayRef, changed } = updateLengthUnitsArray(content, opts);
   if (!arrayRef || !changed) {
     return { changed: false, code: void 0 };
@@ -2399,8 +2853,8 @@ function applyExtendLengthUnitsPatchV3(rootDir, options) {
   if (arrayRef.start != null && arrayRef.end != null) {
     const nextCode = `${content.slice(0, arrayRef.start)}${code}${content.slice(arrayRef.end)}`;
     if (opts.overwrite) {
-      const target = opts.destPath ? path4.resolve(opts.destPath) : dataTypesFilePath;
-      fs5.writeFileSync(target, nextCode, "utf8");
+      const target = opts.destPath ? path8.resolve(opts.destPath) : dataTypesFilePath;
+      fs8.writeFileSync(target, nextCode, "utf8");
       logger_default.success("Patched Tailwind CSS length unit list (v3).");
     }
     return {
@@ -2418,16 +2872,16 @@ function applyExtendLengthUnitsPatchV4(rootDir, options) {
     return { files: [], changed: false };
   }
   const opts = { ...options };
-  const distDir = path4.resolve(rootDir, "dist");
-  if (!fs5.existsSync(distDir)) {
+  const distDir = path8.resolve(rootDir, "dist");
+  if (!fs8.existsSync(distDir)) {
     return { files: [], changed: false };
   }
-  const entries = fs5.readdirSync(distDir);
+  const entries = fs8.readdirSync(distDir);
   const chunkNames = entries.filter((entry) => entry.endsWith(".js") || entry.endsWith(".mjs"));
   const pattern = /\[\s*["']cm["'],\s*["']mm["'],[\w,"']+\]/;
   const candidates = chunkNames.map((chunkName) => {
-    const file = path4.join(distDir, chunkName);
-    const code = fs5.readFileSync(file, "utf8");
+    const file = path8.join(distDir, chunkName);
+    const code = fs8.readFileSync(file, "utf8");
     const match = pattern.exec(code);
     if (!match) {
       return null;
@@ -2443,13 +2897,13 @@ function applyExtendLengthUnitsPatchV4(rootDir, options) {
     const { code, file, match } = item;
     const ast = parse(match[0], { sourceType: "unambiguous" });
     traverse(ast, {
-      ArrayExpression(path13) {
+      ArrayExpression(path18) {
         for (const unit of opts.units) {
-          if (path13.node.elements.some((element) => t3.isStringLiteral(element) && element.value === unit)) {
+          if (path18.node.elements.some((element) => t3.isStringLiteral(element) && element.value === unit)) {
             item.hasPatched = true;
             return;
           }
-          path13.node.elements.push(t3.stringLiteral(unit));
+          path18.node.elements.push(t3.stringLiteral(unit));
         }
       }
     });
@@ -2467,7 +2921,7 @@ function applyExtendLengthUnitsPatchV4(rootDir, options) {
       }
     ]);
     if (opts.overwrite) {
-      fs5.writeFileSync(file, item.code, "utf8");
+      fs8.writeFileSync(file, item.code, "utf8");
     }
   }
   if (candidates.some((file) => !file.hasPatched)) {
@@ -2485,509 +2939,215 @@ function inspectLengthUnitsArray(content, variableName, units) {
   let found = false;
   let missingUnits = [];
   traverse(ast, {
-    Identifier(path13) {
-      if (path13.node.name === variableName && t4.isVariableDeclarator(path13.parent) && t4.isArrayExpression(path13.parent.init)) {
+    Identifier(path18) {
+      if (path18.node.name === variableName && t4.isVariableDeclarator(path18.parent) && t4.isArrayExpression(path18.parent.init)) {
         found = true;
         const existing = new Set(
-          path13.parent.init.elements.map((element) => t4.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
-        );
-        missingUnits = units.filter((unit) => !existing.has(unit));
-        path13.stop();
-      }
-    }
-  });
-  return {
-    found,
-    missingUnits
-  };
-}
-function checkExposeContextPatch(context) {
-  const { packageInfo, options, majorVersion } = context;
-  const refProperty = options.features.exposeContext.refProperty;
-  if (!options.features.exposeContext.enabled) {
-    return {
-      name: "exposeContext",
-      status: "skipped",
-      reason: "exposeContext feature disabled",
-      files: []
-    };
-  }
-  if (majorVersion === 4) {
-    return {
-      name: "exposeContext",
-      status: "unsupported",
-      reason: "Context export patch is only required for Tailwind v2/v3",
-      files: []
-    };
-  }
-  const checks = [];
-  function inspectFile(relative, transform) {
-    const filePath = path5.resolve(packageInfo.rootPath, relative);
-    if (!fs6.existsSync(filePath)) {
-      checks.push({ relative, exists: false, patched: false });
-      return;
-    }
-    const content = fs6.readFileSync(filePath, "utf8");
-    const { hasPatched } = transform(content);
-    checks.push({
-      relative,
-      exists: true,
-      patched: hasPatched
-    });
-  }
-  if (majorVersion === 3) {
-    inspectFile("lib/processTailwindFeatures.js", transformProcessTailwindFeaturesReturnContext);
-    const pluginCandidates = ["lib/plugin.js", "lib/index.js"];
-    const pluginRelative = pluginCandidates.find((candidate) => fs6.existsSync(path5.resolve(packageInfo.rootPath, candidate)));
-    if (pluginRelative) {
-      inspectFile(pluginRelative, (content) => transformPostcssPlugin(content, { refProperty }));
-    } else {
-      checks.push({ relative: "lib/plugin.js", exists: false, patched: false });
-    }
-  } else {
-    inspectFile("lib/jit/processTailwindFeatures.js", transformProcessTailwindFeaturesReturnContextV2);
-    inspectFile("lib/jit/index.js", (content) => transformPostcssPluginV2(content, { refProperty }));
-  }
-  const files = checks.filter((check) => check.exists).map((check) => check.relative);
-  const missingFiles = checks.filter((check) => !check.exists);
-  const unpatchedFiles = checks.filter((check) => check.exists && !check.patched);
-  const reasons = [];
-  if (missingFiles.length) {
-    reasons.push(`missing files: ${missingFiles.map((item) => item.relative).join(", ")}`);
-  }
-  if (unpatchedFiles.length) {
-    reasons.push(`unpatched files: ${unpatchedFiles.map((item) => item.relative).join(", ")}`);
-  }
-  return {
-    name: "exposeContext",
-    status: reasons.length ? "not-applied" : "applied",
-    ...reasons.length ? { reason: reasons.join("; ") } : {},
-    files
-  };
-}
-function checkExtendLengthUnitsV3(rootDir, options) {
-  const lengthUnitsFilePath = options.lengthUnitsFilePath ?? "lib/util/dataTypes.js";
-  const variableName = options.variableName ?? "lengthUnits";
-  const target = path5.resolve(rootDir, lengthUnitsFilePath);
-  const files = fs6.existsSync(target) ? [path5.relative(rootDir, target)] : [];
-  if (!fs6.existsSync(target)) {
-    return {
-      name: "extendLengthUnits",
-      status: "not-applied",
-      reason: `missing ${lengthUnitsFilePath}`,
-      files
-    };
-  }
-  const content = fs6.readFileSync(target, "utf8");
-  const { found, missingUnits } = inspectLengthUnitsArray(content, variableName, options.units);
-  if (!found) {
-    return {
-      name: "extendLengthUnits",
-      status: "not-applied",
-      reason: `could not locate ${variableName} array in ${lengthUnitsFilePath}`,
-      files
-    };
-  }
-  if (missingUnits.length) {
-    return {
-      name: "extendLengthUnits",
-      status: "not-applied",
-      reason: `missing units: ${missingUnits.join(", ")}`,
-      files
-    };
-  }
-  return {
-    name: "extendLengthUnits",
-    status: "applied",
-    files
-  };
-}
-function checkExtendLengthUnitsV4(rootDir, options) {
-  const distDir = path5.resolve(rootDir, "dist");
-  if (!fs6.existsSync(distDir)) {
-    return {
-      name: "extendLengthUnits",
-      status: "not-applied",
-      reason: "dist directory not found for Tailwind v4 package",
-      files: []
-    };
-  }
-  const result = applyExtendLengthUnitsPatchV4(rootDir, {
-    ...options,
-    enabled: true,
-    overwrite: false
-  });
-  if (result.files.length === 0) {
-    return {
-      name: "extendLengthUnits",
-      status: "not-applied",
-      reason: "no bundle chunks matched the length unit pattern",
-      files: []
-    };
-  }
-  const files = result.files.map((file) => path5.relative(rootDir, file.file));
-  const pending = result.files.filter((file) => !file.hasPatched);
-  if (pending.length) {
-    return {
-      name: "extendLengthUnits",
-      status: "not-applied",
-      reason: `missing units in ${pending.length} bundle${pending.length > 1 ? "s" : ""}`,
-      files: pending.map((file) => path5.relative(rootDir, file.file))
-    };
-  }
+          path18.parent.init.elements.map((element) => t4.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
+        );
+        missingUnits = units.filter((unit) => !existing.has(unit));
+        path18.stop();
+      }
+    }
+  });
   return {
-    name: "extendLengthUnits",
-    status: "applied",
-    files
+    found,
+    missingUnits
   };
 }
-function checkExtendLengthUnitsPatch(context) {
+function checkExposeContextPatch(context) {
   const { packageInfo, options, majorVersion } = context;
-  if (!options.features.extendLengthUnits) {
+  const refProperty = options.features.exposeContext.refProperty;
+  if (!options.features.exposeContext.enabled) {
     return {
-      name: "extendLengthUnits",
+      name: "exposeContext",
       status: "skipped",
-      reason: "extendLengthUnits feature disabled",
+      reason: "exposeContext feature disabled",
       files: []
     };
   }
-  if (majorVersion === 2) {
+  if (majorVersion === 4) {
     return {
-      name: "extendLengthUnits",
+      name: "exposeContext",
       status: "unsupported",
-      reason: "length unit extension is only applied for Tailwind v3/v4",
+      reason: "Context export patch is only required for Tailwind v2/v3",
       files: []
     };
   }
-  if (majorVersion === 3) {
-    return checkExtendLengthUnitsV3(packageInfo.rootPath, options.features.extendLengthUnits);
-  }
-  return checkExtendLengthUnitsV4(packageInfo.rootPath, options.features.extendLengthUnits);
-}
-function getPatchStatusReport(context) {
-  return {
-    package: {
-      name: context.packageInfo.name ?? context.packageInfo.packageJson?.name,
-      version: context.packageInfo.version,
-      root: context.packageInfo.rootPath
-    },
-    majorVersion: context.majorVersion,
-    entries: [
-      checkExposeContextPatch(context),
-      checkExtendLengthUnitsPatch(context)
-    ]
-  };
-}
-
-// src/runtime/class-collector.ts
-import process5 from "process";
-import fs7 from "fs-extra";
-import path6 from "pathe";
-function collectClassesFromContexts(contexts, filter) {
-  const set = /* @__PURE__ */ new Set();
-  for (const context of contexts) {
-    if (!isObject(context) || !context.classCache) {
-      continue;
-    }
-    for (const key of context.classCache.keys()) {
-      const className = key.toString();
-      if (filter(className)) {
-        set.add(className);
-      }
+  const checks = [];
+  function inspectFile(relative, transform) {
+    const filePath = path9.resolve(packageInfo.rootPath, relative);
+    if (!fs9.existsSync(filePath)) {
+      checks.push({ relative, exists: false, patched: false });
+      return;
     }
+    const content = fs9.readFileSync(filePath, "utf8");
+    const { hasPatched } = transform(content);
+    checks.push({
+      relative,
+      exists: true,
+      patched: hasPatched
+    });
   }
-  return set;
-}
-async function collectClassesFromTailwindV4(options) {
-  const set = /* @__PURE__ */ new Set();
-  const v4Options = options.tailwind.v4;
-  if (!v4Options) {
-    return set;
-  }
-  const toAbsolute = (value) => {
-    if (!value) {
-      return void 0;
-    }
-    return path6.isAbsolute(value) ? value : path6.resolve(options.projectRoot, value);
-  };
-  const resolvedConfiguredBase = toAbsolute(v4Options.configuredBase);
-  const resolvedDefaultBase = toAbsolute(v4Options.base) ?? process5.cwd();
-  const resolveSources = (base) => {
-    if (!v4Options.sources?.length) {
-      return void 0;
-    }
-    return v4Options.sources.map((source) => ({
-      base: source.base ?? base,
-      pattern: source.pattern,
-      negated: source.negated
-    }));
-  };
-  if (v4Options.cssEntries.length > 0) {
-    for (const entry of v4Options.cssEntries) {
-      const filePath = path6.isAbsolute(entry) ? entry : path6.resolve(options.projectRoot, entry);
-      if (!await fs7.pathExists(filePath)) {
-        continue;
-      }
-      const css = await fs7.readFile(filePath, "utf8");
-      const entryDir = path6.dirname(filePath);
-      const designSystemBases = resolvedConfiguredBase && resolvedConfiguredBase !== entryDir ? [entryDir, resolvedConfiguredBase] : [entryDir];
-      const sourcesBase = resolvedConfiguredBase ?? entryDir;
-      const sources = resolveSources(sourcesBase);
-      const firstBase = designSystemBases[0] ?? entryDir;
-      const extractOptions = {
-        cwd: options.projectRoot,
-        base: firstBase,
-        baseFallbacks: designSystemBases.slice(1),
-        css,
-        ...sources === void 0 ? {} : { sources }
-      };
-      const candidates = await extractValidCandidates(extractOptions);
-      for (const candidate of candidates) {
-        if (options.filter(candidate)) {
-          set.add(candidate);
-        }
-      }
+  if (majorVersion === 3) {
+    inspectFile("lib/processTailwindFeatures.js", transformProcessTailwindFeaturesReturnContext);
+    const pluginCandidates = ["lib/plugin.js", "lib/index.js"];
+    const pluginRelative = pluginCandidates.find((candidate) => fs9.existsSync(path9.resolve(packageInfo.rootPath, candidate)));
+    if (pluginRelative) {
+      inspectFile(pluginRelative, (content) => transformPostcssPlugin(content, { refProperty }));
+    } else {
+      checks.push({ relative: "lib/plugin.js", exists: false, patched: false });
     }
   } else {
-    const baseForCss = resolvedConfiguredBase ?? resolvedDefaultBase;
-    const sources = resolveSources(baseForCss);
-    const extractOptions = {
-      cwd: options.projectRoot,
-      base: baseForCss,
-      ...v4Options.css === void 0 ? {} : { css: v4Options.css },
-      ...sources === void 0 ? {} : { sources }
-    };
-    const candidates = await extractValidCandidates(extractOptions);
-    for (const candidate of candidates) {
-      if (options.filter(candidate)) {
-        set.add(candidate);
-      }
-    }
-  }
-  return set;
-}
-
-// src/runtime/context-registry.ts
-import { createRequire } from "module";
-import fs8 from "fs-extra";
-import path7 from "pathe";
-var require2 = createRequire(import.meta.url);
-function resolveRuntimeEntry(packageInfo, majorVersion) {
-  const root = packageInfo.rootPath;
-  if (majorVersion === 2) {
-    const jitIndex = path7.join(root, "lib/jit/index.js");
-    if (fs8.existsSync(jitIndex)) {
-      return jitIndex;
-    }
-  } else if (majorVersion === 3) {
-    const plugin = path7.join(root, "lib/plugin.js");
-    const index = path7.join(root, "lib/index.js");
-    if (fs8.existsSync(plugin)) {
-      return plugin;
-    }
-    if (fs8.existsSync(index)) {
-      return index;
-    }
-  }
-  return void 0;
-}
-function loadRuntimeContexts(packageInfo, majorVersion, refProperty) {
-  if (majorVersion === 4) {
-    return [];
-  }
-  const entry = resolveRuntimeEntry(packageInfo, majorVersion);
-  if (!entry) {
-    return [];
-  }
-  const moduleExports = require2(entry);
-  if (!moduleExports) {
-    return [];
-  }
-  const ref = moduleExports[refProperty];
-  if (!ref) {
-    return [];
-  }
-  if (Array.isArray(ref)) {
-    return ref;
-  }
-  if (typeof ref === "object" && Array.isArray(ref.value)) {
-    return ref.value;
+    inspectFile("lib/jit/processTailwindFeatures.js", transformProcessTailwindFeaturesReturnContextV2);
+    inspectFile("lib/jit/index.js", (content) => transformPostcssPluginV2(content, { refProperty }));
   }
-  return [];
-}
-
-// src/runtime/process-tailwindcss.ts
-import { createRequire as createRequire2 } from "module";
-import path8 from "pathe";
-import postcss from "postcss";
-import { loadConfig } from "tailwindcss-config";
-var require3 = createRequire2(import.meta.url);
-async function resolveConfigPath(options) {
-  if (options.config && path8.isAbsolute(options.config)) {
-    return options.config;
+  const files = checks.filter((check) => check.exists).map((check) => check.relative);
+  const missingFiles = checks.filter((check) => !check.exists);
+  const unpatchedFiles = checks.filter((check) => check.exists && !check.patched);
+  const reasons = [];
+  if (missingFiles.length) {
+    reasons.push(`missing files: ${missingFiles.map((item) => item.relative).join(", ")}`);
   }
-  const result = await loadConfig({ cwd: options.cwd });
-  if (!result) {
-    throw new Error(`Unable to locate Tailwind CSS config from ${options.cwd}`);
+  if (unpatchedFiles.length) {
+    reasons.push(`unpatched files: ${unpatchedFiles.map((item) => item.relative).join(", ")}`);
   }
-  return result.filepath;
+  return {
+    name: "exposeContext",
+    status: reasons.length ? "not-applied" : "applied",
+    ...reasons.length ? { reason: reasons.join("; ") } : {},
+    files
+  };
 }
-async function runTailwindBuild(options) {
-  const configPath = await resolveConfigPath(options);
-  const pluginName = options.postcssPlugin ?? (options.majorVersion === 4 ? "@tailwindcss/postcss" : "tailwindcss");
-  if (options.majorVersion === 4) {
-    return postcss([
-      require3(pluginName)({
-        config: configPath
-      })
-    ]).process("@import 'tailwindcss';", {
-      from: void 0
-    });
+function checkExtendLengthUnitsV3(rootDir, options) {
+  const lengthUnitsFilePath = options.lengthUnitsFilePath ?? "lib/util/dataTypes.js";
+  const variableName = options.variableName ?? "lengthUnits";
+  const target = path9.resolve(rootDir, lengthUnitsFilePath);
+  const files = fs9.existsSync(target) ? [path9.relative(rootDir, target)] : [];
+  if (!fs9.existsSync(target)) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: `missing ${lengthUnitsFilePath}`,
+      files
+    };
   }
-  return postcss([
-    require3(pluginName)({
-      config: configPath
-    })
-  ]).process("@tailwind base;@tailwind components;@tailwind utilities;", {
-    from: void 0
-  });
-}
-
-// src/api/tailwindcss-patcher.ts
-import process6 from "process";
-import fs10 from "fs-extra";
-import { getPackageInfoSync } from "local-pkg";
-import path10 from "pathe";
-import { coerce } from "semver";
-
-// src/options/legacy.ts
-function normalizeLegacyFeatures(patch) {
-  const apply = patch?.applyPatches;
-  const extend = apply?.extendLengthUnits;
-  let extendOption = false;
-  if (extend && typeof extend === "object") {
-    extendOption = {
-      ...extend,
-      enabled: true
+  const content = fs9.readFileSync(target, "utf8");
+  const { found, missingUnits } = inspectLengthUnitsArray(content, variableName, options.units);
+  if (!found) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: `could not locate ${variableName} array in ${lengthUnitsFilePath}`,
+      files
     };
-  } else if (extend === true) {
-    extendOption = {
-      enabled: true,
-      units: ["rpx"],
-      ...patch?.overwrite === void 0 ? {} : { overwrite: patch.overwrite }
+  }
+  if (missingUnits.length) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: `missing units: ${missingUnits.join(", ")}`,
+      files
     };
   }
   return {
-    exposeContext: apply?.exportContext ?? true,
-    extendLengthUnits: extendOption
+    name: "extendLengthUnits",
+    status: "applied",
+    files
   };
 }
-function fromLegacyOptions(options) {
-  if (!options) {
-    return {};
+function checkExtendLengthUnitsV4(rootDir, options) {
+  const distDir = path9.resolve(rootDir, "dist");
+  if (!fs9.existsSync(distDir)) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: "dist directory not found for Tailwind v4 package",
+      files: []
+    };
+  }
+  const result = applyExtendLengthUnitsPatchV4(rootDir, {
+    ...options,
+    enabled: true,
+    overwrite: false
+  });
+  if (result.files.length === 0) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: "no bundle chunks matched the length unit pattern",
+      files: []
+    };
+  }
+  const files = result.files.map((file) => path9.relative(rootDir, file.file));
+  const pending = result.files.filter((file) => !file.hasPatched);
+  if (pending.length) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: `missing units in ${pending.length} bundle${pending.length > 1 ? "s" : ""}`,
+      files: pending.map((file) => path9.relative(rootDir, file.file))
+    };
   }
-  const patch = options.patch;
-  const features = normalizeLegacyFeatures(patch);
-  const output = patch?.output;
-  const tailwindConfig = patch?.tailwindcss;
-  const tailwindVersion = tailwindConfig?.version;
-  const tailwindV2 = tailwindConfig?.v2;
-  const tailwindV3 = tailwindConfig?.v3;
-  const tailwindV4 = tailwindConfig?.v4;
-  const tailwindConfigPath = tailwindV3?.config ?? tailwindV2?.config;
-  const tailwindCwd = tailwindV3?.cwd ?? tailwindV2?.cwd ?? patch?.cwd;
-  const normalizedExtract = output ? {
-    ...output.filename === void 0 ? {} : { file: output.filename },
-    pretty: output.loose ? 2 : false,
-    ...output.removeUniversalSelector === void 0 ? {} : { removeUniversalSelector: output.removeUniversalSelector }
-  } : void 0;
-  const normalizedTailwindcss = {
-    ...patch?.packageName === void 0 ? {} : { packageName: patch.packageName },
-    ...tailwindVersion === void 0 ? {} : { version: tailwindVersion },
-    ...patch?.resolve === void 0 ? {} : { resolve: patch.resolve },
-    ...tailwindConfigPath === void 0 ? {} : { config: tailwindConfigPath },
-    ...tailwindCwd === void 0 ? {} : { cwd: tailwindCwd },
-    ...tailwindV2 === void 0 ? {} : { v2: tailwindV2 },
-    ...tailwindV3 === void 0 ? {} : { v3: tailwindV3 },
-    ...tailwindV4 === void 0 ? {} : { v4: tailwindV4 }
-  };
-  const normalizedCache = typeof options.cache === "boolean" ? options.cache : options.cache ? {
-    ...options.cache,
-    enabled: options.cache.enabled ?? true
-  } : void 0;
-  const normalizedApply = {
-    ...patch?.overwrite === void 0 ? {} : { overwrite: patch.overwrite },
-    exposeContext: features.exposeContext,
-    extendLengthUnits: features.extendLengthUnits
-  };
   return {
-    ...patch?.cwd === void 0 ? {} : { projectRoot: patch.cwd },
-    ...patch?.filter === void 0 ? {} : { filter: patch.filter },
-    ...normalizedCache === void 0 ? {} : { cache: normalizedCache },
-    ...normalizedExtract === void 0 ? {} : { extract: normalizedExtract },
-    ...Object.keys(normalizedTailwindcss).length === 0 ? {} : { tailwindcss: normalizedTailwindcss },
-    apply: normalizedApply
+    name: "extendLengthUnits",
+    status: "applied",
+    files
   };
 }
-function fromUnifiedConfig(registry) {
-  if (!registry) {
-    return {};
+function checkExtendLengthUnitsPatch(context) {
+  const { packageInfo, options, majorVersion } = context;
+  if (!options.features.extendLengthUnits) {
+    return {
+      name: "extendLengthUnits",
+      status: "skipped",
+      reason: "extendLengthUnits feature disabled",
+      files: []
+    };
   }
-  const tailwind = registry.tailwindcss ?? registry.tailwind;
-  const modernExtract = registry.extract;
-  const legacyOutput = registry.output;
-  const pretty = (() => {
-    const value = modernExtract?.pretty ?? legacyOutput?.pretty;
-    if (value === void 0) {
-      return void 0;
-    }
-    if (typeof value === "boolean") {
-      return value ? 2 : false;
-    }
-    return value;
-  })();
-  const removeUniversalSelector = modernExtract?.removeUniversalSelector ?? legacyOutput?.stripUniversalSelector;
-  const outputFile = modernExtract?.file ?? legacyOutput?.file;
-  const normalizedExtract = modernExtract || legacyOutput ? {
-    ...modernExtract?.write === void 0 ? {} : { write: modernExtract.write },
-    ...outputFile === void 0 ? {} : { file: outputFile },
-    ...pretty === void 0 ? {} : { pretty },
-    ...removeUniversalSelector === void 0 ? {} : { removeUniversalSelector },
-    ...modernExtract?.format === void 0 ? {} : { format: modernExtract.format }
-  } : void 0;
-  const normalizedTailwindcss = tailwind ? {
-    ...tailwind.version === void 0 ? {} : { version: tailwind.version },
-    ...tailwind.packageName === void 0 ? tailwind.package === void 0 ? {} : { packageName: tailwind.package } : { packageName: tailwind.packageName },
-    ...tailwind.resolve === void 0 ? {} : { resolve: tailwind.resolve },
-    ...tailwind.config === void 0 ? {} : { config: tailwind.config },
-    ...tailwind.cwd === void 0 ? {} : { cwd: tailwind.cwd },
-    ...tailwind.v2 === void 0 ? tailwind.legacy === void 0 ? {} : { v2: tailwind.legacy } : { v2: tailwind.v2 },
-    ...tailwind.v3 === void 0 ? tailwind.classic === void 0 ? {} : { v3: tailwind.classic } : { v3: tailwind.v3 },
-    ...tailwind.v4 === void 0 ? tailwind.next === void 0 ? {} : { v4: tailwind.next } : { v4: tailwind.v4 }
-  } : void 0;
-  const normalizedApply = registry.apply ? {
-    ...registry.apply.overwrite === void 0 ? {} : { overwrite: registry.apply.overwrite },
-    ...registry.apply.exposeContext === void 0 ? {} : { exposeContext: registry.apply.exposeContext },
-    ...registry.apply.extendLengthUnits === void 0 ? {} : { extendLengthUnits: registry.apply.extendLengthUnits }
-  } : void 0;
+  if (majorVersion === 2) {
+    return {
+      name: "extendLengthUnits",
+      status: "unsupported",
+      reason: "length unit extension is only applied for Tailwind v3/v4",
+      files: []
+    };
+  }
+  if (majorVersion === 3) {
+    return checkExtendLengthUnitsV3(packageInfo.rootPath, options.features.extendLengthUnits);
+  }
+  return checkExtendLengthUnitsV4(packageInfo.rootPath, options.features.extendLengthUnits);
+}
+function getPatchStatusReport(context) {
   return {
-    ...registry.projectRoot === void 0 ? {} : { projectRoot: registry.projectRoot },
-    ...normalizedApply === void 0 ? {} : { apply: normalizedApply },
-    ...registry.cache === void 0 ? {} : { cache: registry.cache },
-    ...registry.filter === void 0 ? {} : { filter: registry.filter },
-    ...normalizedExtract === void 0 ? {} : { extract: normalizedExtract },
-    ...normalizedTailwindcss === void 0 ? {} : { tailwindcss: normalizedTailwindcss }
+    package: {
+      name: context.packageInfo.name ?? context.packageInfo.packageJson?.name,
+      version: context.packageInfo.version,
+      root: context.packageInfo.rootPath
+    },
+    majorVersion: context.majorVersion,
+    entries: [
+      checkExposeContextPatch(context),
+      checkExtendLengthUnitsPatch(context)
+    ]
   };
 }
 
+// src/api/tailwindcss-patcher.ts
+import process6 from "process";
+import fs11 from "fs-extra";
+import { getPackageInfoSync } from "local-pkg";
+import path11 from "pathe";
+import { coerce } from "semver";
+
 // src/patching/operations/export-context/index.ts
-import fs9 from "fs-extra";
-import path9 from "pathe";
+import fs10 from "fs-extra";
+import path10 from "pathe";
 function writeFileIfRequired(filePath, code, overwrite, successMessage) {
   if (!overwrite) {
     return;
   }
-  fs9.writeFileSync(filePath, code, {
+  fs10.writeFileSync(filePath, code, {
     encoding: "utf8"
   });
   logger_default.success(successMessage);
@@ -3000,9 +3160,9 @@ function applyExposeContextPatch(params) {
   };
   if (majorVersion === 3) {
     const processFileRelative = "lib/processTailwindFeatures.js";
-    const processFilePath = path9.resolve(rootDir, processFileRelative);
-    if (fs9.existsSync(processFilePath)) {
-      const content = fs9.readFileSync(processFilePath, "utf8");
+    const processFilePath = path10.resolve(rootDir, processFileRelative);
+    if (fs10.existsSync(processFilePath)) {
+      const content = fs10.readFileSync(processFilePath, "utf8");
       const { code, hasPatched } = transformProcessTailwindFeaturesReturnContext(content);
       result.files[processFileRelative] = code;
       if (!hasPatched) {
@@ -3016,10 +3176,10 @@ function applyExposeContextPatch(params) {
       }
     }
     const pluginCandidates = ["lib/plugin.js", "lib/index.js"];
-    const pluginRelative = pluginCandidates.find((candidate) => fs9.existsSync(path9.resolve(rootDir, candidate)));
+    const pluginRelative = pluginCandidates.find((candidate) => fs10.existsSync(path10.resolve(rootDir, candidate)));
     if (pluginRelative) {
-      const pluginPath = path9.resolve(rootDir, pluginRelative);
-      const content = fs9.readFileSync(pluginPath, "utf8");
+      const pluginPath = path10.resolve(rootDir, pluginRelative);
+      const content = fs10.readFileSync(pluginPath, "utf8");
       const { code, hasPatched } = transformPostcssPlugin(content, { refProperty });
       result.files[pluginRelative] = code;
       if (!hasPatched) {
@@ -3034,9 +3194,9 @@ function applyExposeContextPatch(params) {
     }
   } else if (majorVersion === 2) {
     const processFileRelative = "lib/jit/processTailwindFeatures.js";
-    const processFilePath = path9.resolve(rootDir, processFileRelative);
-    if (fs9.existsSync(processFilePath)) {
-      const content = fs9.readFileSync(processFilePath, "utf8");
+    const processFilePath = path10.resolve(rootDir, processFileRelative);
+    if (fs10.existsSync(processFilePath)) {
+      const content = fs10.readFileSync(processFilePath, "utf8");
       const { code, hasPatched } = transformProcessTailwindFeaturesReturnContextV2(content);
       result.files[processFileRelative] = code;
       if (!hasPatched) {
@@ -3050,9 +3210,9 @@ function applyExposeContextPatch(params) {
       }
     }
     const pluginRelative = "lib/jit/index.js";
-    const pluginPath = path9.resolve(rootDir, pluginRelative);
-    if (fs9.existsSync(pluginPath)) {
-      const content = fs9.readFileSync(pluginPath, "utf8");
+    const pluginPath = path10.resolve(rootDir, pluginRelative);
+    if (fs10.existsSync(pluginPath)) {
+      const content = fs10.readFileSync(pluginPath, "utf8");
       const { code, hasPatched } = transformPostcssPluginV2(content, { refProperty });
       result.files[pluginRelative] = code;
       if (!hasPatched) {
@@ -3144,6 +3304,8 @@ var TailwindcssPatcher = class {
   majorVersion;
   cacheContext;
   cacheStore;
+  patchMemo;
+  inFlightBuild;
   constructor(options = {}) {
     const resolvedOptions = options && typeof options === "object" && "patch" in options ? fromLegacyOptions(options) : options;
     this.options = normalizeOptions(resolvedOptions);
@@ -3167,11 +3329,20 @@ var TailwindcssPatcher = class {
     this.cacheStore = new CacheStore(this.options.cache, this.cacheContext);
   }
   async patch() {
-    return applyTailwindPatches({
+    const snapshot = this.createPatchSnapshot();
+    if (this.patchMemo && this.patchMemo.snapshot === snapshot) {
+      return this.patchMemo.result;
+    }
+    const result = applyTailwindPatches({
       packageInfo: this.packageInfo,
       options: this.options,
       majorVersion: this.majorVersion
     });
+    this.patchMemo = {
+      result,
+      snapshot: this.createPatchSnapshot()
+    };
+    return result;
   }
   async getPatchStatus() {
     return getPatchStatusReport({
@@ -3189,6 +3360,9 @@ var TailwindcssPatcher = class {
   }
   async runTailwindBuildIfNeeded() {
     if (this.majorVersion === 2 || this.majorVersion === 3) {
+      if (this.inFlightBuild) {
+        return this.inFlightBuild;
+      }
       const executionOptions = resolveTailwindExecutionOptions(this.options, this.majorVersion);
       const buildOptions = {
         cwd: executionOptions.cwd,
@@ -3196,8 +3370,53 @@ var TailwindcssPatcher = class {
         ...executionOptions.config === void 0 ? {} : { config: executionOptions.config },
         ...executionOptions.postcssPlugin === void 0 ? {} : { postcssPlugin: executionOptions.postcssPlugin }
       };
-      await runTailwindBuild(buildOptions);
+      this.inFlightBuild = runTailwindBuild(buildOptions).then(() => void 0);
+      try {
+        await this.inFlightBuild;
+      } finally {
+        this.inFlightBuild = void 0;
+      }
+    }
+  }
+  createPatchSnapshot() {
+    const entries = [];
+    const pushSnapshot = (filePath) => {
+      if (!fs11.pathExistsSync(filePath)) {
+        entries.push(`${filePath}:missing`);
+        return;
+      }
+      const stat = fs11.statSync(filePath);
+      entries.push(`${filePath}:${stat.size}:${Math.trunc(stat.mtimeMs)}`);
+    };
+    if (this.options.features.exposeContext.enabled && (this.majorVersion === 2 || this.majorVersion === 3)) {
+      if (this.majorVersion === 2) {
+        pushSnapshot(path11.resolve(this.packageInfo.rootPath, "lib/jit/processTailwindFeatures.js"));
+        pushSnapshot(path11.resolve(this.packageInfo.rootPath, "lib/jit/index.js"));
+      } else {
+        pushSnapshot(path11.resolve(this.packageInfo.rootPath, "lib/processTailwindFeatures.js"));
+        const pluginPath = ["lib/plugin.js", "lib/index.js"].map((file) => path11.resolve(this.packageInfo.rootPath, file)).find((file) => fs11.pathExistsSync(file));
+        if (pluginPath) {
+          pushSnapshot(pluginPath);
+        }
+      }
+    }
+    if (this.options.features.extendLengthUnits?.enabled) {
+      if (this.majorVersion === 3) {
+        const target = this.options.features.extendLengthUnits.lengthUnitsFilePath ?? "lib/util/dataTypes.js";
+        pushSnapshot(path11.resolve(this.packageInfo.rootPath, target));
+      } else if (this.majorVersion === 4) {
+        const distDir = path11.resolve(this.packageInfo.rootPath, "dist");
+        if (fs11.pathExistsSync(distDir)) {
+          const chunkNames = fs11.readdirSync(distDir).filter((entry) => entry.endsWith(".js") || entry.endsWith(".mjs")).sort();
+          for (const chunkName of chunkNames) {
+            pushSnapshot(path11.join(distDir, chunkName));
+          }
+        } else {
+          entries.push(`${distDir}:missing`);
+        }
+      }
     }
+    return entries.join("|");
   }
   async collectClassSet() {
     if (this.majorVersion === 4) {
@@ -3227,13 +3446,13 @@ var TailwindcssPatcher = class {
       for (const value of existing) {
         set.add(value);
       }
-      const writeTarget = await this.cacheStore.write(set);
+      const writeTarget = this.areSetsEqual(existing, set) ? void 0 : await this.cacheStore.write(set);
       if (writeTarget) {
         logger_default.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
       }
     } else {
       if (set.size > 0) {
-        const writeTarget = await this.cacheStore.write(set);
+        const writeTarget = this.areSetsEqual(existing, set) ? void 0 : await this.cacheStore.write(set);
         if (writeTarget) {
           logger_default.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
         }
@@ -3253,13 +3472,13 @@ var TailwindcssPatcher = class {
       for (const value of existing) {
         set.add(value);
       }
-      const writeTarget = this.cacheStore.writeSync(set);
+      const writeTarget = this.areSetsEqual(existing, set) ? void 0 : this.cacheStore.writeSync(set);
       if (writeTarget) {
         logger_default.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
       }
     } else {
       if (set.size > 0) {
-        const writeTarget = this.cacheStore.writeSync(set);
+        const writeTarget = this.areSetsEqual(existing, set) ? void 0 : this.cacheStore.writeSync(set);
         if (writeTarget) {
           logger_default.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
         }
@@ -3269,6 +3488,17 @@ var TailwindcssPatcher = class {
     }
     return set;
   }
+  areSetsEqual(a, b) {
+    if (a.size !== b.size) {
+      return false;
+    }
+    for (const value of a) {
+      if (!b.has(value)) {
+        return false;
+      }
+    }
+    return true;
+  }
   async getClassSet() {
     await this.runTailwindBuildIfNeeded();
     const set = await this.collectClassSet();
@@ -3297,13 +3527,13 @@ var TailwindcssPatcher = class {
     if (!shouldWrite || !this.options.output.file) {
       return result;
     }
-    const target = path10.resolve(this.options.output.file);
-    await fs10.ensureDir(path10.dirname(target));
+    const target = path11.resolve(this.options.output.file);
+    await fs11.ensureDir(path11.dirname(target));
     if (this.options.output.format === "json") {
       const spaces = typeof this.options.output.pretty === "number" ? this.options.output.pretty : void 0;
-      await fs10.writeJSON(target, classList, { spaces });
+      await fs11.writeJSON(target, classList, { spaces });
     } else {
-      await fs10.writeFile(target, `${classList.join("\n")}
+      await fs11.writeFile(target, `${classList.join("\n")}
 `, "utf8");
     }
     logger_default.success(`Tailwind CSS class list saved to ${target.replace(process6.cwd(), ".")}`);
@@ -3341,37 +3571,94 @@ var TailwindcssPatcher = class {
   }
 };
 
-// src/cli/migrate-config.ts
-import generate2 from "@babel/generator";
-import { parse as parse2 } from "@babel/parser";
-import * as t5 from "@babel/types";
-import fs11 from "fs-extra";
-import path11 from "pathe";
-var DEFAULT_CONFIG_FILENAMES = [
-  "tailwindcss-patch.config.ts",
-  "tailwindcss-patch.config.js",
-  "tailwindcss-patch.config.mjs",
-  "tailwindcss-patch.config.cjs",
-  "tailwindcss-mangle.config.ts",
-  "tailwindcss-mangle.config.js",
-  "tailwindcss-mangle.config.mjs",
-  "tailwindcss-mangle.config.cjs"
-];
-var DEFAULT_CONFIG_FILENAME_SET = new Set(DEFAULT_CONFIG_FILENAMES);
-var DEFAULT_WORKSPACE_IGNORED_DIRS = /* @__PURE__ */ new Set([
-  ".git",
-  ".idea",
-  ".turbo",
-  ".vscode",
-  ".yarn",
-  "coverage",
-  "dist",
-  "node_modules",
-  "tmp"
-]);
-var DEFAULT_WORKSPACE_MAX_DEPTH = 6;
+// src/commands/migration-report.ts
 var MIGRATION_REPORT_KIND = "tw-patch-migrate-report";
 var MIGRATION_REPORT_SCHEMA_VERSION = 1;
+function assertMigrationReportCompatibility(report, reportFile) {
+  if (report.reportKind !== void 0 && report.reportKind !== MIGRATION_REPORT_KIND) {
+    throw new Error(`Unsupported report kind "${report.reportKind}" in ${reportFile}.`);
+  }
+  if (report.schemaVersion !== void 0 && (!Number.isInteger(report.schemaVersion) || report.schemaVersion > MIGRATION_REPORT_SCHEMA_VERSION)) {
+    throw new Error(
+      `Unsupported report schema version "${String(report.schemaVersion)}" in ${reportFile}. Current supported version is ${MIGRATION_REPORT_SCHEMA_VERSION}.`
+    );
+  }
+}
+
+// src/commands/migrate-config.ts
+import path14 from "pathe";
+
+// src/commands/migration-aggregation.ts
+function createMigrationAggregationState() {
+  return {
+    scannedFiles: 0,
+    changedFiles: 0,
+    writtenFiles: 0,
+    backupsWritten: 0,
+    unchangedFiles: 0,
+    missingFiles: 0,
+    entries: []
+  };
+}
+function collectMigrationExecutionResult(state, result) {
+  if (result.missing) {
+    state.missingFiles += 1;
+    return;
+  }
+  state.scannedFiles += 1;
+  state.entries.push(result.entry);
+  if (result.changed) {
+    state.changedFiles += 1;
+    if (result.wrote) {
+      state.writtenFiles += 1;
+    }
+    if (result.backupWritten) {
+      state.backupsWritten += 1;
+    }
+  } else {
+    state.unchangedFiles += 1;
+  }
+}
+function buildMigrationReport(state, context) {
+  const {
+    cwd,
+    dryRun,
+    rollbackOnError,
+    backupDirectory,
+    toolName,
+    toolVersion,
+    generatedAt = (/* @__PURE__ */ new Date()).toISOString()
+  } = context;
+  return {
+    reportKind: MIGRATION_REPORT_KIND,
+    schemaVersion: MIGRATION_REPORT_SCHEMA_VERSION,
+    generatedAt,
+    tool: {
+      name: toolName,
+      version: toolVersion
+    },
+    cwd,
+    dryRun,
+    rollbackOnError,
+    ...backupDirectory ? { backupDirectory } : {},
+    scannedFiles: state.scannedFiles,
+    changedFiles: state.changedFiles,
+    writtenFiles: state.writtenFiles,
+    backupsWritten: state.backupsWritten,
+    unchangedFiles: state.unchangedFiles,
+    missingFiles: state.missingFiles,
+    entries: state.entries
+  };
+}
+
+// src/commands/migration-file-executor.ts
+import fs13 from "fs-extra";
+import path13 from "pathe";
+
+// src/commands/migration-source.ts
+import generate2 from "@babel/generator";
+import { parse as parse2 } from "@babel/parser";
+import * as t5 from "@babel/types";
 var ROOT_LEGACY_KEYS = ["cwd", "overwrite", "tailwind", "features", "output", "applyPatches"];
 function getPropertyKeyName(property) {
   if (!property.computed && t5.isIdentifier(property.key)) {
@@ -3632,11 +3919,38 @@ function migrateConfigSource(source) {
     changes: [...changes]
   };
 }
+
+// src/commands/migration-target-files.ts
+import fs12 from "fs-extra";
+import path12 from "pathe";
+var DEFAULT_CONFIG_FILENAMES = [
+  "tailwindcss-patch.config.ts",
+  "tailwindcss-patch.config.js",
+  "tailwindcss-patch.config.mjs",
+  "tailwindcss-patch.config.cjs",
+  "tailwindcss-mangle.config.ts",
+  "tailwindcss-mangle.config.js",
+  "tailwindcss-mangle.config.mjs",
+  "tailwindcss-mangle.config.cjs"
+];
+var DEFAULT_CONFIG_FILENAME_SET = new Set(DEFAULT_CONFIG_FILENAMES);
+var DEFAULT_WORKSPACE_IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".idea",
+  ".turbo",
+  ".vscode",
+  ".yarn",
+  "coverage",
+  "dist",
+  "node_modules",
+  "tmp"
+]);
+var DEFAULT_WORKSPACE_MAX_DEPTH = 6;
 function resolveTargetFiles(cwd, files) {
   const candidates = files && files.length > 0 ? files : [...DEFAULT_CONFIG_FILENAMES];
   const resolved = /* @__PURE__ */ new Set();
   for (const file of candidates) {
-    resolved.add(path11.resolve(cwd, file));
+    resolved.add(path12.resolve(cwd, file));
   }
   return [...resolved];
 }
@@ -3651,12 +3965,12 @@ async function collectWorkspaceConfigFiles(cwd, maxDepth) {
     const { dir, depth } = current;
     let entries;
     try {
-      entries = await fs11.readdir(dir, { withFileTypes: true });
+      entries = await fs12.readdir(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const entry of entries) {
-      const absolutePath = path11.resolve(dir, entry.name);
+      const absolutePath = path12.resolve(dir, entry.name);
       if (entry.isFile() && DEFAULT_CONFIG_FILENAME_SET.has(entry.name)) {
         files.add(absolutePath);
         continue;
@@ -3676,11 +3990,11 @@ async function collectWorkspaceConfigFiles(cwd, maxDepth) {
   return [...files].sort((a, b) => a.localeCompare(b));
 }
 function resolveBackupRelativePath(cwd, file) {
-  const relative = path11.relative(cwd, file);
-  const isExternal = relative.startsWith("..") || path11.isAbsolute(relative);
+  const relative = path12.relative(cwd, file);
+  const isExternal = relative.startsWith("..") || path12.isAbsolute(relative);
   if (isExternal) {
     const sanitized = file.replace(/[:/\\]+/g, "_");
-    return path11.join("__external__", `${sanitized}.bak`);
+    return path12.join("__external__", `${sanitized}.bak`);
   }
   return `${relative}.bak`;
 }
@@ -3720,8 +4034,8 @@ function toPatternList(patterns) {
   return patterns.map((pattern) => pattern.trim()).filter(Boolean).map(globToRegExp);
 }
 function normalizeFileForPattern(file, cwd) {
-  const relative = path11.relative(cwd, file);
-  if (!relative.startsWith("..") && !path11.isAbsolute(relative)) {
+  const relative = path12.relative(cwd, file);
+  if (!relative.startsWith("..") && !path12.isAbsolute(relative)) {
     return relative.replace(/\\/g, "/");
   }
   return file.replace(/\\/g, "/");
@@ -3742,114 +4056,85 @@ function filterTargetFiles(targetFiles, cwd, include, exclude) {
     return !inExclude;
   });
 }
-async function migrateConfigFiles(options) {
-  const cwd = path11.resolve(options.cwd);
-  const dryRun = options.dryRun ?? false;
-  const rollbackOnError = options.rollbackOnError ?? true;
-  const backupDirectory = options.backupDir ? path11.resolve(cwd, options.backupDir) : void 0;
-  const maxDepth = options.maxDepth ?? DEFAULT_WORKSPACE_MAX_DEPTH;
-  const discoveredTargetFiles = options.files && options.files.length > 0 ? resolveTargetFiles(cwd, options.files) : options.workspace ? await collectWorkspaceConfigFiles(cwd, maxDepth) : resolveTargetFiles(cwd);
-  const targetFiles = filterTargetFiles(discoveredTargetFiles, cwd, options.include, options.exclude);
-  const entries = [];
-  let scannedFiles = 0;
-  let changedFiles = 0;
-  let writtenFiles = 0;
-  let backupsWritten = 0;
-  let unchangedFiles = 0;
-  let missingFiles = 0;
-  const wroteEntries = [];
-  for (const file of targetFiles) {
-    const exists = await fs11.pathExists(file);
-    if (!exists) {
-      missingFiles += 1;
-      continue;
-    }
-    scannedFiles += 1;
-    const source = await fs11.readFile(file, "utf8");
-    const migrated = migrateConfigSource(source);
-    const entry = {
-      file,
-      changed: migrated.changed,
-      written: false,
-      rolledBack: false,
-      changes: migrated.changes
-    };
-    entries.push(entry);
-    if (migrated.changed) {
-      changedFiles += 1;
-      if (!dryRun) {
-        try {
-          if (backupDirectory) {
-            const backupRelativePath = resolveBackupRelativePath(cwd, file);
-            const backupFile = path11.resolve(backupDirectory, backupRelativePath);
-            await fs11.ensureDir(path11.dirname(backupFile));
-            await fs11.writeFile(backupFile, source, "utf8");
-            entry.backupFile = backupFile;
-            backupsWritten += 1;
-          }
-          await fs11.writeFile(file, migrated.code, "utf8");
-          entry.written = true;
-          wroteEntries.push({ file, source, entry });
-          writtenFiles += 1;
-        } catch (error) {
-          let rollbackCount = 0;
-          if (rollbackOnError && wroteEntries.length > 0) {
-            for (const written of [...wroteEntries].reverse()) {
-              try {
-                await fs11.writeFile(written.file, written.source, "utf8");
-                written.entry.written = false;
-                written.entry.rolledBack = true;
-                rollbackCount += 1;
-              } catch {
-              }
-            }
-            writtenFiles = Math.max(0, writtenFiles - rollbackCount);
-          }
-          const reason = error instanceof Error ? error.message : String(error);
-          const rollbackHint = rollbackOnError && rollbackCount > 0 ? ` Rolled back ${rollbackCount} previously written file(s).` : "";
-          throw new Error(`Failed to write migrated config "${file}": ${reason}.${rollbackHint}`);
-        }
-      }
-    } else {
-      unchangedFiles += 1;
+
+// src/commands/migration-file-executor.ts
+async function rollbackWrittenEntries(wroteEntries) {
+  let rollbackCount = 0;
+  for (const written of [...wroteEntries].reverse()) {
+    try {
+      await fs13.writeFile(written.file, written.source, "utf8");
+      written.entry.written = false;
+      written.entry.rolledBack = true;
+      rollbackCount += 1;
+    } catch {
     }
   }
-  return {
-    reportKind: MIGRATION_REPORT_KIND,
-    schemaVersion: MIGRATION_REPORT_SCHEMA_VERSION,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    tool: {
-      name: pkgName,
-      version: pkgVersion
-    },
+  return rollbackCount;
+}
+async function executeMigrationFile(options) {
+  const {
     cwd,
+    file,
     dryRun,
     rollbackOnError,
-    ...backupDirectory ? { backupDirectory } : {},
-    scannedFiles,
-    changedFiles,
-    writtenFiles,
-    backupsWritten,
-    unchangedFiles,
-    missingFiles,
-    entries
+    backupDirectory,
+    wroteEntries
+  } = options;
+  const exists = await fs13.pathExists(file);
+  if (!exists) {
+    return {
+      missing: true,
+      changed: false,
+      wrote: false,
+      backupWritten: false
+    };
+  }
+  const source = await fs13.readFile(file, "utf8");
+  const migrated = migrateConfigSource(source);
+  const entry = {
+    file,
+    changed: migrated.changed,
+    written: false,
+    rolledBack: false,
+    changes: migrated.changes
   };
-}
-async function restoreConfigFiles(options) {
-  const cwd = path11.resolve(options.cwd);
-  const dryRun = options.dryRun ?? false;
-  const strict = options.strict ?? false;
-  const reportFile = path11.resolve(cwd, options.reportFile);
-  const report = await fs11.readJSON(reportFile);
-  if (report.reportKind !== void 0 && report.reportKind !== MIGRATION_REPORT_KIND) {
-    throw new Error(`Unsupported report kind "${report.reportKind}" in ${reportFile}.`);
+  if (!migrated.changed || dryRun) {
+    return {
+      missing: false,
+      changed: migrated.changed,
+      wrote: false,
+      backupWritten: false,
+      entry
+    };
   }
-  if (report.schemaVersion !== void 0 && (!Number.isInteger(report.schemaVersion) || report.schemaVersion > MIGRATION_REPORT_SCHEMA_VERSION)) {
-    throw new Error(
-      `Unsupported report schema version "${String(report.schemaVersion)}" in ${reportFile}. Current supported version is ${MIGRATION_REPORT_SCHEMA_VERSION}.`
-    );
+  let backupWritten = false;
+  try {
+    if (backupDirectory) {
+      const backupRelativePath = resolveBackupRelativePath(cwd, file);
+      const backupFile = path13.resolve(backupDirectory, backupRelativePath);
+      await fs13.ensureDir(path13.dirname(backupFile));
+      await fs13.writeFile(backupFile, source, "utf8");
+      entry.backupFile = backupFile;
+      backupWritten = true;
+    }
+    await fs13.writeFile(file, migrated.code, "utf8");
+    entry.written = true;
+    wroteEntries.push({ file, source, entry });
+    return {
+      missing: false,
+      changed: true,
+      wrote: true,
+      backupWritten,
+      entry
+    };
+  } catch (error) {
+    const rollbackCount = rollbackOnError && wroteEntries.length > 0 ? await rollbackWrittenEntries(wroteEntries) : 0;
+    const reason = error instanceof Error ? error.message : String(error);
+    const rollbackHint = rollbackOnError && rollbackCount > 0 ? ` Rolled back ${rollbackCount} previously written file(s).` : "";
+    throw new Error(`Failed to write migrated config "${file}": ${reason}.${rollbackHint}`);
   }
-  const entries = Array.isArray(report.entries) ? report.entries : [];
+}
+async function restoreConfigEntries(entries, dryRun) {
   let scannedEntries = 0;
   let restorableEntries = 0;
   let restoredFiles = 0;
@@ -3858,26 +4143,113 @@ async function restoreConfigFiles(options) {
   const restored = [];
   for (const entry of entries) {
     scannedEntries += 1;
-    const targetFile = entry.file ? path11.resolve(entry.file) : void 0;
-    const backupFile = entry.backupFile ? path11.resolve(entry.backupFile) : void 0;
+    const targetFile = entry.file ? path13.resolve(entry.file) : void 0;
+    const backupFile = entry.backupFile ? path13.resolve(entry.backupFile) : void 0;
     if (!targetFile || !backupFile) {
       skippedEntries += 1;
       continue;
     }
     restorableEntries += 1;
-    const backupExists = await fs11.pathExists(backupFile);
+    const backupExists = await fs13.pathExists(backupFile);
     if (!backupExists) {
       missingBackups += 1;
       continue;
     }
     if (!dryRun) {
-      const backupContent = await fs11.readFile(backupFile, "utf8");
-      await fs11.ensureDir(path11.dirname(targetFile));
-      await fs11.writeFile(targetFile, backupContent, "utf8");
+      const backupContent = await fs13.readFile(backupFile, "utf8");
+      await fs13.ensureDir(path13.dirname(targetFile));
+      await fs13.writeFile(targetFile, backupContent, "utf8");
     }
     restoredFiles += 1;
     restored.push(targetFile);
   }
+  return {
+    scannedEntries,
+    restorableEntries,
+    restoredFiles,
+    missingBackups,
+    skippedEntries,
+    restored
+  };
+}
+
+// src/commands/migration-report-loader.ts
+import fs14 from "fs-extra";
+async function loadMigrationReportForRestore(reportFile) {
+  const report = await fs14.readJSON(reportFile);
+  assertMigrationReportCompatibility(report, reportFile);
+  return {
+    ...report.reportKind === void 0 ? {} : { reportKind: report.reportKind },
+    ...report.schemaVersion === void 0 ? {} : { schemaVersion: report.schemaVersion },
+    entries: Array.isArray(report.entries) ? report.entries : []
+  };
+}
+
+// src/commands/migration-target-resolver.ts
+async function resolveMigrationTargetFiles(options) {
+  const {
+    cwd,
+    files,
+    workspace,
+    maxDepth,
+    include,
+    exclude
+  } = options;
+  const resolvedMaxDepth = maxDepth ?? DEFAULT_WORKSPACE_MAX_DEPTH;
+  const discoveredTargetFiles = files && files.length > 0 ? resolveTargetFiles(cwd, files) : workspace ? await collectWorkspaceConfigFiles(cwd, resolvedMaxDepth) : resolveTargetFiles(cwd);
+  return filterTargetFiles(discoveredTargetFiles, cwd, include, exclude);
+}
+
+// src/commands/migrate-config.ts
+async function migrateConfigFiles(options) {
+  const cwd = path14.resolve(options.cwd);
+  const dryRun = options.dryRun ?? false;
+  const rollbackOnError = options.rollbackOnError ?? true;
+  const backupDirectory = options.backupDir ? path14.resolve(cwd, options.backupDir) : void 0;
+  const targetFiles = await resolveMigrationTargetFiles({
+    cwd,
+    files: options.files,
+    workspace: options.workspace,
+    maxDepth: options.maxDepth,
+    include: options.include,
+    exclude: options.exclude
+  });
+  const aggregation = createMigrationAggregationState();
+  const wroteEntries = [];
+  for (const file of targetFiles) {
+    const result = await executeMigrationFile({
+      cwd,
+      file,
+      dryRun,
+      rollbackOnError,
+      wroteEntries,
+      ...backupDirectory ? { backupDirectory } : {}
+    });
+    collectMigrationExecutionResult(aggregation, result);
+  }
+  return buildMigrationReport(aggregation, {
+    cwd,
+    dryRun,
+    rollbackOnError,
+    ...backupDirectory ? { backupDirectory } : {},
+    toolName: pkgName,
+    toolVersion: pkgVersion
+  });
+}
+async function restoreConfigFiles(options) {
+  const cwd = path14.resolve(options.cwd);
+  const dryRun = options.dryRun ?? false;
+  const strict = options.strict ?? false;
+  const reportFile = path14.resolve(cwd, options.reportFile);
+  const report = await loadMigrationReportForRestore(reportFile);
+  const {
+    scannedEntries,
+    restorableEntries,
+    restoredFiles,
+    missingBackups,
+    skippedEntries,
+    restored
+  } = await restoreConfigEntries(report.entries, dryRun);
   if (strict && missingBackups > 0) {
     throw new Error(`Restore failed: ${missingBackups} backup file(s) missing in report ${reportFile}.`);
   }
@@ -3897,105 +4269,7 @@ async function restoreConfigFiles(options) {
   };
 }
 
-// src/cli/commands.ts
-import process7 from "process";
-import { CONFIG_NAME, getConfig, initConfig } from "@tailwindcss-mangle/config";
-
-// ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
-function isPlainObject(value) {
-  if (value === null || typeof value !== "object") {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
-    return false;
-  }
-  if (Symbol.iterator in value) {
-    return false;
-  }
-  if (Symbol.toStringTag in value) {
-    return Object.prototype.toString.call(value) === "[object Module]";
-  }
-  return true;
-}
-function _defu(baseObject, defaults, namespace = ".", merger) {
-  if (!isPlainObject(defaults)) {
-    return _defu(baseObject, {}, namespace, merger);
-  }
-  const object = Object.assign({}, defaults);
-  for (const key in baseObject) {
-    if (key === "__proto__" || key === "constructor") {
-      continue;
-    }
-    const value = baseObject[key];
-    if (value === null || value === void 0) {
-      continue;
-    }
-    if (merger && merger(object, key, value, namespace)) {
-      continue;
-    }
-    if (Array.isArray(value) && Array.isArray(object[key])) {
-      object[key] = [...value, ...object[key]];
-    } else if (isPlainObject(value) && isPlainObject(object[key])) {
-      object[key] = _defu(
-        value,
-        object[key],
-        (namespace ? `${namespace}.` : "") + key.toString(),
-        merger
-      );
-    } else {
-      object[key] = value;
-    }
-  }
-  return object;
-}
-function createDefu(merger) {
-  return (...arguments_) => (
-    // eslint-disable-next-line unicorn/no-array-reduce
-    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
-  );
-}
-var defu = createDefu();
-var defuFn = createDefu((object, key, currentValue) => {
-  if (object[key] !== void 0 && typeof currentValue === "function") {
-    object[key] = currentValue(object[key]);
-    return true;
-  }
-});
-var defuArrayFn = createDefu((object, key, currentValue) => {
-  if (Array.isArray(object[key]) && typeof currentValue === "function") {
-    object[key] = currentValue(object[key]);
-    return true;
-  }
-});
-
-// ../shared/src/utils.ts
-var defuOverrideArray = createDefu((obj, key, value) => {
-  if (Array.isArray(obj[key]) && Array.isArray(value)) {
-    obj[key] = value;
-    return true;
-  }
-});
-var preserveClassNames = [
-  // https://tailwindcss.com/docs/transition-timing-function start
-  // https://github.com/sonofmagic/tailwindcss-mangle/issues/21
-  "ease-out",
-  "ease-linear",
-  "ease-in",
-  "ease-in-out"
-  // https://tailwindcss.com/docs/transition-timing-function end
-];
-var preserveClassNamesMap = preserveClassNames.reduce((acc, cur) => {
-  acc[cur] = true;
-  return acc;
-}, {});
-var acceptChars = [..."abcdefghijklmnopqrstuvwxyz"];
-
-// src/cli/commands.ts
-import cac from "cac";
-import fs12 from "fs-extra";
-import path12 from "pathe";
-var tailwindcssPatchCommands = ["install", "extract", "tokens", "init", "migrate", "restore", "validate", "status"];
+// src/commands/validate.ts
 var VALIDATE_EXIT_CODES = {
   OK: 0,
   REPORT_INCOMPATIBLE: 21,
@@ -4010,7 +4284,7 @@ var VALIDATE_FAILURE_REASONS = [
   "unknown-error"
 ];
 var IO_ERROR_CODES = /* @__PURE__ */ new Set(["ENOENT", "EACCES", "EPERM", "EISDIR", "ENOTDIR", "EMFILE", "ENFILE"]);
-function isNodeError(error) {
+function isNodeError2(error) {
   return !!error && typeof error === "object" && ("code" in error || "message" in error);
 }
 function classifyValidateError(error) {
@@ -4029,7 +4303,7 @@ function classifyValidateError(error) {
       message
     };
   }
-  if (isNodeError(error) && typeof error.code === "string" && IO_ERROR_CODES.has(error.code)) {
+  if (isNodeError2(error) && typeof error.code === "string" && IO_ERROR_CODES.has(error.code)) {
     return {
       reason: "io-error",
       exitCode: VALIDATE_EXIT_CODES.IO_ERROR,
@@ -4052,6 +4326,17 @@ var ValidateCommandError = class extends Error {
     this.exitCode = summary.exitCode;
   }
 };
+
+// src/commands/types.ts
+var tailwindcssPatchCommands = ["install", "extract", "tokens", "init", "migrate", "restore", "validate", "status"];
+
+// src/commands/cli.ts
+import cac from "cac";
+
+// src/commands/command-definitions.ts
+import process7 from "process";
+
+// src/commands/token-output.ts
 var TOKEN_FORMATS = ["json", "lines", "grouped-json"];
 var DEFAULT_TOKEN_REPORT = ".tw-patch/tw-token-report.json";
 function formatTokenLine(entry) {
@@ -4073,68 +4358,8 @@ function formatGroupedPreview(map, limit = 3) {
     moreFiles: Math.max(0, files.length - limit)
   };
 }
-function resolveCwd(rawCwd) {
-  if (!rawCwd) {
-    return process7.cwd();
-  }
-  return path12.resolve(rawCwd);
-}
-function createDefaultRunner(factory) {
-  let promise;
-  return () => {
-    if (!promise) {
-      promise = factory();
-    }
-    return promise;
-  };
-}
-async function loadPatchOptionsForCwd(cwd, overrides) {
-  const { config } = await getConfig(cwd);
-  const legacyConfig = config;
-  const base = config?.registry ? fromUnifiedConfig(config.registry) : legacyConfig?.patch ? fromLegacyOptions({ patch: legacyConfig.patch }) : {};
-  const merged = defu(overrides ?? {}, base);
-  return merged;
-}
-function createCommandContext(cli, command, commandName, args, cwd) {
-  let cachedOptions;
-  let cachedPatcher;
-  let cachedConfig;
-  const loadPatchOptionsForContext = (overrides) => {
-    if (overrides) {
-      return loadPatchOptionsForCwd(cwd, overrides);
-    }
-    if (!cachedOptions) {
-      cachedOptions = loadPatchOptionsForCwd(cwd);
-    }
-    return cachedOptions;
-  };
-  const createPatcherForContext = async (overrides) => {
-    if (overrides) {
-      const patchOptions = await loadPatchOptionsForCwd(cwd, overrides);
-      return new TailwindcssPatcher(patchOptions);
-    }
-    if (!cachedPatcher) {
-      cachedPatcher = loadPatchOptionsForContext().then((options) => new TailwindcssPatcher(options));
-    }
-    return cachedPatcher;
-  };
-  return {
-    cli,
-    command,
-    commandName,
-    args,
-    cwd,
-    logger: logger_default,
-    loadConfig: () => {
-      if (!cachedConfig) {
-        cachedConfig = getConfig(cwd);
-      }
-      return cachedConfig;
-    },
-    loadPatchOptions: loadPatchOptionsForContext,
-    createPatcher: createPatcherForContext
-  };
-}
+
+// src/commands/command-definitions.ts
 function createCwdOptionDefinition(description = "Working directory") {
   return {
     flags: "--cwd <dir>",
@@ -4224,6 +4449,8 @@ function buildDefaultCommandDefinitions() {
     }
   };
 }
+
+// src/commands/command-metadata.ts
 function addPrefixIfMissing(value, prefix) {
   if (!prefix || value.startsWith(prefix)) {
     return value;
@@ -4251,30 +4478,93 @@ function resolveOptionDefinitions(defaults, override) {
   }
   return [...defaults, ...customDefs];
 }
-function applyCommandOptions(command, optionDefs) {
-  for (const option of optionDefs) {
-    command.option(option.flags, option.description ?? "", option.config);
-  }
+function resolveCommandMetadata(command, mountOptions, prefix, defaults) {
+  const names = resolveCommandNames(command, mountOptions, prefix);
+  const definition = defaults[command];
+  const override = mountOptions.commandOptions?.[command];
+  const description = override?.description ?? definition.description;
+  const optionDefs = resolveOptionDefinitions(definition.optionDefs, override);
+  return { ...names, description, optionDefs };
+}
+function applyCommandOptions(command, optionDefs) {
+  for (const option of optionDefs) {
+    command.option(option.flags, option.description ?? "", option.config);
+  }
+}
+
+// src/commands/command-context.ts
+import process8 from "process";
+import path15 from "pathe";
+function resolveCommandCwd(rawCwd) {
+  if (!rawCwd) {
+    return process8.cwd();
+  }
+  return path15.resolve(rawCwd);
+}
+function createMemoizedPromiseRunner(factory) {
+  let promise;
+  return () => {
+    if (!promise) {
+      promise = factory();
+    }
+    return promise;
+  };
+}
+function createTailwindcssPatchCommandContext(cli, command, commandName, args, cwd) {
+  const loadCachedConfig = createMemoizedPromiseRunner(
+    () => loadWorkspaceConfigModule().then((mod) => mod.getConfig(cwd))
+  );
+  const loadCachedPatchOptions = createMemoizedPromiseRunner(
+    () => loadPatchOptionsForWorkspace(cwd)
+  );
+  const createCachedPatcher = createMemoizedPromiseRunner(async () => {
+    const patchOptions = await loadCachedPatchOptions();
+    return new TailwindcssPatcher(patchOptions);
+  });
+  const loadPatchOptionsForContext = (overrides) => {
+    if (overrides) {
+      return loadPatchOptionsForWorkspace(cwd, overrides);
+    }
+    return loadCachedPatchOptions();
+  };
+  const createPatcherForContext = async (overrides) => {
+    if (overrides) {
+      const patchOptions = await loadPatchOptionsForWorkspace(cwd, overrides);
+      return new TailwindcssPatcher(patchOptions);
+    }
+    return createCachedPatcher();
+  };
+  return {
+    cli,
+    command,
+    commandName,
+    args,
+    cwd,
+    logger: logger_default,
+    loadConfig: loadCachedConfig,
+    loadPatchOptions: loadPatchOptionsForContext,
+    createPatcher: createPatcherForContext
+  };
 }
+
+// src/commands/command-runtime.ts
 function runWithCommandHandler(cli, command, commandName, args, handler, defaultHandler) {
-  const cwd = resolveCwd(args.cwd);
-  const context = createCommandContext(cli, command, commandName, args, cwd);
-  const runDefault = createDefaultRunner(() => defaultHandler(context));
+  const cwd = resolveCommandCwd(args.cwd);
+  const context = createTailwindcssPatchCommandContext(cli, command, commandName, args, cwd);
+  const runDefault = createMemoizedPromiseRunner(() => defaultHandler(context));
   if (!handler) {
     return runDefault();
   }
   return handler(context, runDefault);
 }
-function resolveCommandMetadata(command, mountOptions, prefix, defaults) {
-  const names = resolveCommandNames(command, mountOptions, prefix);
-  const definition = defaults[command];
-  const override = mountOptions.commandOptions?.[command];
-  const description = override?.description ?? definition.description;
-  const optionDefs = resolveOptionDefinitions(definition.optionDefs, override);
-  return { ...names, description, optionDefs };
-}
-async function installCommandDefaultHandler(ctx) {
-  const patcher = await ctx.createPatcher();
+
+// src/commands/basic-handlers.ts
+import process9 from "process";
+import fs15 from "fs-extra";
+import path16 from "pathe";
+var DEFAULT_CONFIG_NAME = "tailwindcss-mangle";
+async function installCommandDefaultHandler(_ctx) {
+  const patcher = new TailwindcssPatcher();
   await patcher.patch();
   logger_default.success("Tailwind CSS runtime patched successfully.");
 }
@@ -4325,18 +4615,18 @@ async function tokensCommandDefaultHandler(ctx) {
   const grouped = format === "grouped-json" ? buildGrouped() : null;
   const resolveGrouped = () => grouped ?? buildGrouped();
   if (shouldWrite) {
-    const target = path12.resolve(targetFile);
-    await fs12.ensureDir(path12.dirname(target));
+    const target = path16.resolve(targetFile);
+    await fs15.ensureDir(path16.dirname(target));
     if (format === "json") {
-      await fs12.writeJSON(target, report, { spaces: 2 });
+      await fs15.writeJSON(target, report, { spaces: 2 });
     } else if (format === "grouped-json") {
-      await fs12.writeJSON(target, resolveGrouped(), { spaces: 2 });
+      await fs15.writeJSON(target, resolveGrouped(), { spaces: 2 });
     } else {
       const lines = report.entries.map(formatTokenLine);
-      await fs12.writeFile(target, `${lines.join("\n")}
+      await fs15.writeFile(target, `${lines.join("\n")}
 `, "utf8");
     }
-    logger_default.success(`Collected ${report.entries.length} tokens (${format}) \u2192 ${target.replace(process7.cwd(), ".")}`);
+    logger_default.success(`Collected ${report.entries.length} tokens (${format}) \u2192 ${target.replace(process9.cwd(), ".")}`);
   } else {
     logger_default.success(`Collected ${report.entries.length} tokens from ${report.filesScanned} files.`);
     if (format === "lines") {
@@ -4375,60 +4665,94 @@ async function tokensCommandDefaultHandler(ctx) {
   return report;
 }
 async function initCommandDefaultHandler(ctx) {
-  await initConfig(ctx.cwd);
-  logger_default.success(`\u2728 ${CONFIG_NAME}.config.ts initialized!`);
+  const configModule = await loadWorkspaceConfigModule();
+  await configModule.initConfig(ctx.cwd);
+  const configName = configModule.CONFIG_NAME || DEFAULT_CONFIG_NAME;
+  logger_default.success(`\u2728 ${configName}.config.ts initialized!`);
 }
-async function migrateCommandDefaultHandler(ctx) {
-  const { args } = ctx;
-  const normalizePatternArgs = (value) => {
-    if (!value) {
-      return void 0;
-    }
-    const raw = Array.isArray(value) ? value : [value];
-    const values = raw.flatMap((item) => item.split(",")).map((item) => item.trim()).filter(Boolean);
-    return values.length > 0 ? values : void 0;
+
+// src/commands/migration-args.ts
+function normalizePatternArgs(value) {
+  if (!value) {
+    return void 0;
+  }
+  const raw = Array.isArray(value) ? value : [value];
+  const values = raw.flatMap((item) => item.split(",")).map((item) => item.trim()).filter(Boolean);
+  return values.length > 0 ? values : void 0;
+}
+function parseMaxDepth(value) {
+  if (value === void 0) {
+    return {
+      maxDepth: void 0,
+      hasInvalidMaxDepth: false
+    };
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return {
+      maxDepth: void 0,
+      hasInvalidMaxDepth: true
+    };
+  }
+  return {
+    maxDepth: Math.floor(parsed),
+    hasInvalidMaxDepth: false
   };
+}
+function resolveMigrateCommandArgs(args) {
   const include = normalizePatternArgs(args.include);
   const exclude = normalizePatternArgs(args.exclude);
-  const parsedMaxDepth = args.maxDepth === void 0 ? void 0 : Number(args.maxDepth);
-  const maxDepth = parsedMaxDepth !== void 0 && Number.isFinite(parsedMaxDepth) && parsedMaxDepth >= 0 ? Math.floor(parsedMaxDepth) : void 0;
+  const { maxDepth, hasInvalidMaxDepth } = parseMaxDepth(args.maxDepth);
   const checkMode = args.check ?? false;
   const dryRun = args.dryRun ?? checkMode;
-  if (args.workspace && args.maxDepth !== void 0 && maxDepth === void 0) {
-    logger_default.warn(`Invalid --max-depth value "${String(args.maxDepth)}", fallback to default depth.`);
-  }
-  const report = await migrateConfigFiles({
-    cwd: ctx.cwd,
+  return {
+    include,
+    exclude,
+    maxDepth,
+    checkMode,
     dryRun,
-    ...args.config ? { files: [args.config] } : {},
-    ...args.workspace ? { workspace: true } : {},
-    ...args.workspace && maxDepth !== void 0 ? { maxDepth } : {},
-    ...args.backupDir ? { backupDir: args.backupDir } : {},
-    ...include ? { include } : {},
-    ...exclude ? { exclude } : {}
-  });
-  if (args.reportFile) {
-    const reportPath = path12.resolve(ctx.cwd, args.reportFile);
-    await fs12.ensureDir(path12.dirname(reportPath));
-    await fs12.writeJSON(reportPath, report, { spaces: 2 });
-    logger_default.info(`Migration report written: ${reportPath.replace(process7.cwd(), ".")}`);
-  }
-  if (args.json) {
-    logger_default.log(JSON.stringify(report, null, 2));
-    if (checkMode && report.changedFiles > 0) {
-      throw new Error(`Migration check failed: ${report.changedFiles} file(s) still need migration.`);
-    }
-    if (report.scannedFiles === 0) {
-      logger_default.warn("No config files found for migration.");
-    }
-    return report;
-  }
-  if (report.scannedFiles === 0) {
-    logger_default.warn("No config files found for migration.");
-    return report;
-  }
+    hasInvalidMaxDepth
+  };
+}
+function resolveRestoreCommandArgs(args) {
+  return {
+    reportFile: args.reportFile ?? ".tw-patch/migrate-report.json",
+    dryRun: args.dryRun ?? false,
+    strict: args.strict ?? false
+  };
+}
+function resolveValidateCommandArgs(args) {
+  return {
+    reportFile: args.reportFile ?? ".tw-patch/migrate-report.json",
+    strict: args.strict ?? false
+  };
+}
+
+// src/commands/migration-output.ts
+import process10 from "process";
+import fs16 from "fs-extra";
+import path17 from "pathe";
+function formatPathForLog(file) {
+  return file.replace(process10.cwd(), ".");
+}
+function createMigrationCheckFailureError(changedFiles) {
+  return new Error(`Migration check failed: ${changedFiles} file(s) still need migration.`);
+}
+async function writeMigrationReportFile(cwd, reportFile, report) {
+  const reportPath = path17.resolve(cwd, reportFile);
+  await fs16.ensureDir(path17.dirname(reportPath));
+  await fs16.writeJSON(reportPath, report, { spaces: 2 });
+  logger_default.info(`Migration report written: ${formatPathForLog(reportPath)}`);
+}
+function logMigrationReportAsJson(report) {
+  logger_default.log(JSON.stringify(report, null, 2));
+}
+function logNoMigrationConfigFilesWarning() {
+  logger_default.warn("No config files found for migration.");
+}
+function logMigrationEntries(report, dryRun) {
   for (const entry of report.entries) {
-    const fileLabel = entry.file.replace(process7.cwd(), ".");
+    const fileLabel = formatPathForLog(entry.file);
     if (!entry.changed) {
       logger_default.info(`No changes: ${fileLabel}`);
       continue;
@@ -4442,105 +4766,156 @@ async function migrateCommandDefaultHandler(ctx) {
       logger_default.info(`  - ${change}`);
     }
     if (entry.backupFile) {
-      logger_default.info(`  - backup: ${entry.backupFile.replace(process7.cwd(), ".")}`);
+      logger_default.info(`  - backup: ${formatPathForLog(entry.backupFile)}`);
     }
   }
+}
+function logMigrationSummary(report) {
   logger_default.info(
     `Migration summary: scanned=${report.scannedFiles}, changed=${report.changedFiles}, written=${report.writtenFiles}, backups=${report.backupsWritten}, missing=${report.missingFiles}, unchanged=${report.unchangedFiles}`
   );
-  if (checkMode && report.changedFiles > 0) {
-    throw new Error(`Migration check failed: ${report.changedFiles} file(s) still need migration.`);
-  }
-  return report;
 }
-async function restoreCommandDefaultHandler(ctx) {
-  const { args } = ctx;
-  const reportFile = args.reportFile ?? ".tw-patch/migrate-report.json";
-  const result = await restoreConfigFiles({
-    cwd: ctx.cwd,
-    reportFile,
-    dryRun: args.dryRun ?? false,
-    strict: args.strict ?? false
-  });
-  if (args.json) {
-    logger_default.log(JSON.stringify(result, null, 2));
-    return result;
-  }
+function logRestoreResultAsJson(result) {
+  logger_default.log(JSON.stringify(result, null, 2));
+}
+function logRestoreSummary(result) {
   logger_default.info(
     `Restore summary: scanned=${result.scannedEntries}, restorable=${result.restorableEntries}, restored=${result.restoredFiles}, missingBackups=${result.missingBackups}, skipped=${result.skippedEntries}`
   );
   if (result.restored.length > 0) {
     const preview = result.restored.slice(0, 5);
     for (const file of preview) {
-      logger_default.info(`  - ${file.replace(process7.cwd(), ".")}`);
+      logger_default.info(`  - ${formatPathForLog(file)}`);
     }
     if (result.restored.length > preview.length) {
       logger_default.info(`  ...and ${result.restored.length - preview.length} more`);
     }
   }
-  return result;
 }
-async function validateCommandDefaultHandler(ctx) {
+function logValidateSuccessAsJson(result) {
+  const payload = {
+    ok: true,
+    ...result
+  };
+  logger_default.log(JSON.stringify(payload, null, 2));
+}
+function logValidateSuccessSummary(result) {
+  logger_default.success(
+    `Migration report validated: scanned=${result.scannedEntries}, restorable=${result.restorableEntries}, missingBackups=${result.missingBackups}, skipped=${result.skippedEntries}`
+  );
+  if (result.reportKind || result.reportSchemaVersion !== void 0) {
+    const kind = result.reportKind ?? "unknown";
+    const schema = result.reportSchemaVersion === void 0 ? "unknown" : String(result.reportSchemaVersion);
+    logger_default.info(`  metadata: kind=${kind}, schema=${schema}`);
+  }
+}
+function logValidateFailureAsJson(summary) {
+  const payload = {
+    ok: false,
+    reason: summary.reason,
+    exitCode: summary.exitCode,
+    message: summary.message
+  };
+  logger_default.log(JSON.stringify(payload, null, 2));
+}
+function logValidateFailureSummary(summary) {
+  logger_default.error(`Validation failed [${summary.reason}] (exit ${summary.exitCode}): ${summary.message}`);
+}
+
+// src/commands/migrate-handler.ts
+async function migrateCommandDefaultHandler(ctx) {
   const { args } = ctx;
-  const reportFile = args.reportFile ?? ".tw-patch/migrate-report.json";
-  try {
-    const result = await restoreConfigFiles({
-      cwd: ctx.cwd,
-      reportFile,
-      dryRun: true,
-      strict: args.strict ?? false
-    });
-    if (args.json) {
-      const payload = {
-        ok: true,
-        ...result
-      };
-      logger_default.log(JSON.stringify(payload, null, 2));
-      return result;
+  const {
+    include,
+    exclude,
+    maxDepth,
+    checkMode,
+    dryRun,
+    hasInvalidMaxDepth
+  } = resolveMigrateCommandArgs(args);
+  if (args.workspace && hasInvalidMaxDepth) {
+    logger_default.warn(`Invalid --max-depth value "${String(args.maxDepth)}", fallback to default depth.`);
+  }
+  const report = await migrateConfigFiles({
+    cwd: ctx.cwd,
+    dryRun,
+    ...args.config ? { files: [args.config] } : {},
+    ...args.workspace ? { workspace: true } : {},
+    ...args.workspace && maxDepth !== void 0 ? { maxDepth } : {},
+    ...args.backupDir ? { backupDir: args.backupDir } : {},
+    ...include ? { include } : {},
+    ...exclude ? { exclude } : {}
+  });
+  if (args.reportFile) {
+    await writeMigrationReportFile(ctx.cwd, args.reportFile, report);
+  }
+  if (args.json) {
+    logMigrationReportAsJson(report);
+    if (checkMode && report.changedFiles > 0) {
+      throw createMigrationCheckFailureError(report.changedFiles);
     }
-    logger_default.success(
-      `Migration report validated: scanned=${result.scannedEntries}, restorable=${result.restorableEntries}, missingBackups=${result.missingBackups}, skipped=${result.skippedEntries}`
-    );
-    if (result.reportKind || result.reportSchemaVersion !== void 0) {
-      const kind = result.reportKind ?? "unknown";
-      const schema = result.reportSchemaVersion === void 0 ? "unknown" : String(result.reportSchemaVersion);
-      logger_default.info(`  metadata: kind=${kind}, schema=${schema}`);
+    if (report.scannedFiles === 0) {
+      logNoMigrationConfigFilesWarning();
     }
+    return report;
+  }
+  if (report.scannedFiles === 0) {
+    logNoMigrationConfigFilesWarning();
+    return report;
+  }
+  logMigrationEntries(report, dryRun);
+  logMigrationSummary(report);
+  if (checkMode && report.changedFiles > 0) {
+    throw createMigrationCheckFailureError(report.changedFiles);
+  }
+  return report;
+}
+
+// src/commands/restore-handler.ts
+async function restoreCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const restoreArgs = resolveRestoreCommandArgs(args);
+  const result = await restoreConfigFiles({
+    cwd: ctx.cwd,
+    reportFile: restoreArgs.reportFile,
+    dryRun: restoreArgs.dryRun,
+    strict: restoreArgs.strict
+  });
+  if (args.json) {
+    logRestoreResultAsJson(result);
     return result;
-  } catch (error) {
-    const summary = classifyValidateError(error);
-    if (args.json) {
-      const payload = {
-        ok: false,
-        reason: summary.reason,
-        exitCode: summary.exitCode,
-        message: summary.message
-      };
-      logger_default.log(JSON.stringify(payload, null, 2));
-    } else {
-      logger_default.error(`Validation failed [${summary.reason}] (exit ${summary.exitCode}): ${summary.message}`);
-    }
-    throw new ValidateCommandError(summary, { cause: error });
   }
+  logRestoreSummary(result);
+  return result;
 }
+
+// src/commands/status-output.ts
 function formatFilesHint(entry) {
   if (!entry.files.length) {
     return "";
   }
   return ` (${entry.files.join(", ")})`;
 }
-async function statusCommandDefaultHandler(ctx) {
-  const patcher = await ctx.createPatcher();
-  const report = await patcher.getPatchStatus();
-  if (ctx.args.json) {
-    logger_default.log(JSON.stringify(report, null, 2));
-    return report;
-  }
-  const applied = report.entries.filter((entry) => entry.status === "applied");
-  const pending = report.entries.filter((entry) => entry.status === "not-applied");
-  const skipped = report.entries.filter((entry) => entry.status === "skipped" || entry.status === "unsupported");
-  const packageLabel = `${report.package.name ?? "tailwindcss"}@${report.package.version ?? "unknown"}`;
-  logger_default.info(`Patch status for ${packageLabel} (v${report.majorVersion})`);
+function formatPackageLabel(report) {
+  return `${report.package.name ?? "tailwindcss"}@${report.package.version ?? "unknown"}`;
+}
+function partitionStatusEntries(report) {
+  return {
+    applied: report.entries.filter((entry) => entry.status === "applied"),
+    pending: report.entries.filter((entry) => entry.status === "not-applied"),
+    skipped: report.entries.filter((entry) => entry.status === "skipped" || entry.status === "unsupported")
+  };
+}
+function logStatusReportAsJson(report) {
+  logger_default.log(JSON.stringify(report, null, 2));
+}
+function logStatusReportSummary(report) {
+  const {
+    applied,
+    pending,
+    skipped
+  } = partitionStatusEntries(report);
+  logger_default.info(`Patch status for ${formatPackageLabel(report)} (v${report.majorVersion})`);
   if (applied.length) {
     logger_default.success("Applied:");
     applied.forEach((entry) => logger_default.success(`  \u2022 ${entry.name}${formatFilesHint(entry)}`));
@@ -4548,7 +4923,7 @@ async function statusCommandDefaultHandler(ctx) {
   if (pending.length) {
     logger_default.warn("Needs attention:");
     pending.forEach((entry) => {
-      const details = entry.reason ? ` \u2013 ${entry.reason}` : "";
+      const details = entry.reason ? ` - ${entry.reason}` : "";
       logger_default.warn(`  \u2022 ${entry.name}${formatFilesHint(entry)}${details}`);
     });
   } else {
@@ -4557,151 +4932,89 @@ async function statusCommandDefaultHandler(ctx) {
   if (skipped.length) {
     logger_default.info("Skipped:");
     skipped.forEach((entry) => {
-      const details = entry.reason ? ` \u2013 ${entry.reason}` : "";
+      const details = entry.reason ? ` - ${entry.reason}` : "";
       logger_default.info(`  \u2022 ${entry.name}${details}`);
     });
   }
+}
+
+// src/commands/status-handler.ts
+async function statusCommandDefaultHandler(ctx) {
+  const patcher = await ctx.createPatcher();
+  const report = await patcher.getPatchStatus();
+  if (ctx.args.json) {
+    logStatusReportAsJson(report);
+    return report;
+  }
+  logStatusReportSummary(report);
   return report;
 }
+
+// src/commands/validate-handler.ts
+async function validateCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const validateArgs = resolveValidateCommandArgs(args);
+  try {
+    const result = await restoreConfigFiles({
+      cwd: ctx.cwd,
+      reportFile: validateArgs.reportFile,
+      dryRun: true,
+      strict: validateArgs.strict
+    });
+    if (args.json) {
+      logValidateSuccessAsJson(result);
+      return result;
+    }
+    logValidateSuccessSummary(result);
+    return result;
+  } catch (error) {
+    const summary = classifyValidateError(error);
+    if (args.json) {
+      logValidateFailureAsJson(summary);
+    } else {
+      logValidateFailureSummary(summary);
+    }
+    throw new ValidateCommandError(summary, { cause: error });
+  }
+}
+
+// src/commands/default-handler-map.ts
+var defaultCommandHandlers = {
+  install: installCommandDefaultHandler,
+  extract: extractCommandDefaultHandler,
+  tokens: tokensCommandDefaultHandler,
+  init: initCommandDefaultHandler,
+  migrate: migrateCommandDefaultHandler,
+  restore: restoreCommandDefaultHandler,
+  validate: validateCommandDefaultHandler,
+  status: statusCommandDefaultHandler
+};
+
+// src/commands/command-registrar.ts
+function registerTailwindcssPatchCommand(cli, commandName, options, prefix, defaultDefinitions) {
+  const metadata = resolveCommandMetadata(commandName, options, prefix, defaultDefinitions);
+  const command = cli.command(metadata.name, metadata.description);
+  applyCommandOptions(command, metadata.optionDefs);
+  command.action(async (args) => {
+    return runWithCommandHandler(
+      cli,
+      command,
+      commandName,
+      args,
+      options.commandHandlers?.[commandName],
+      defaultCommandHandlers[commandName]
+    );
+  });
+  metadata.aliases.forEach((alias) => command.alias(alias));
+}
+
+// src/commands/cli.ts
 function mountTailwindcssPatchCommands(cli, options = {}) {
   const prefix = options.commandPrefix ?? "";
   const selectedCommands = options.commands ?? tailwindcssPatchCommands;
   const defaultDefinitions = buildDefaultCommandDefinitions();
-  const registrars = {
-    install: () => {
-      const metadata = resolveCommandMetadata("install", options, prefix, defaultDefinitions);
-      const command = cli.command(metadata.name, metadata.description);
-      applyCommandOptions(command, metadata.optionDefs);
-      command.action(async (args) => {
-        return runWithCommandHandler(
-          cli,
-          command,
-          "install",
-          args,
-          options.commandHandlers?.install,
-          installCommandDefaultHandler
-        );
-      });
-      metadata.aliases.forEach((alias) => command.alias(alias));
-    },
-    extract: () => {
-      const metadata = resolveCommandMetadata("extract", options, prefix, defaultDefinitions);
-      const command = cli.command(metadata.name, metadata.description);
-      applyCommandOptions(command, metadata.optionDefs);
-      command.action(async (args) => {
-        return runWithCommandHandler(
-          cli,
-          command,
-          "extract",
-          args,
-          options.commandHandlers?.extract,
-          extractCommandDefaultHandler
-        );
-      });
-      metadata.aliases.forEach((alias) => command.alias(alias));
-    },
-    tokens: () => {
-      const metadata = resolveCommandMetadata("tokens", options, prefix, defaultDefinitions);
-      const command = cli.command(metadata.name, metadata.description);
-      applyCommandOptions(command, metadata.optionDefs);
-      command.action(async (args) => {
-        return runWithCommandHandler(
-          cli,
-          command,
-          "tokens",
-          args,
-          options.commandHandlers?.tokens,
-          tokensCommandDefaultHandler
-        );
-      });
-      metadata.aliases.forEach((alias) => command.alias(alias));
-    },
-    init: () => {
-      const metadata = resolveCommandMetadata("init", options, prefix, defaultDefinitions);
-      const command = cli.command(metadata.name, metadata.description);
-      applyCommandOptions(command, metadata.optionDefs);
-      command.action(async (args) => {
-        return runWithCommandHandler(
-          cli,
-          command,
-          "init",
-          args,
-          options.commandHandlers?.init,
-          initCommandDefaultHandler
-        );
-      });
-      metadata.aliases.forEach((alias) => command.alias(alias));
-    },
-    migrate: () => {
-      const metadata = resolveCommandMetadata("migrate", options, prefix, defaultDefinitions);
-      const command = cli.command(metadata.name, metadata.description);
-      applyCommandOptions(command, metadata.optionDefs);
-      command.action(async (args) => {
-        return runWithCommandHandler(
-          cli,
-          command,
-          "migrate",
-          args,
-          options.commandHandlers?.migrate,
-          migrateCommandDefaultHandler
-        );
-      });
-      metadata.aliases.forEach((alias) => command.alias(alias));
-    },
-    restore: () => {
-      const metadata = resolveCommandMetadata("restore", options, prefix, defaultDefinitions);
-      const command = cli.command(metadata.name, metadata.description);
-      applyCommandOptions(command, metadata.optionDefs);
-      command.action(async (args) => {
-        return runWithCommandHandler(
-          cli,
-          command,
-          "restore",
-          args,
-          options.commandHandlers?.restore,
-          restoreCommandDefaultHandler
-        );
-      });
-      metadata.aliases.forEach((alias) => command.alias(alias));
-    },
-    validate: () => {
-      const metadata = resolveCommandMetadata("validate", options, prefix, defaultDefinitions);
-      const command = cli.command(metadata.name, metadata.description);
-      applyCommandOptions(command, metadata.optionDefs);
-      command.action(async (args) => {
-        return runWithCommandHandler(
-          cli,
-          command,
-          "validate",
-          args,
-          options.commandHandlers?.validate,
-          validateCommandDefaultHandler
-        );
-      });
-      metadata.aliases.forEach((alias) => command.alias(alias));
-    },
-    status: () => {
-      const metadata = resolveCommandMetadata("status", options, prefix, defaultDefinitions);
-      const command = cli.command(metadata.name, metadata.description);
-      applyCommandOptions(command, metadata.optionDefs);
-      command.action(async (args) => {
-        return runWithCommandHandler(
-          cli,
-          command,
-          "status",
-          args,
-          options.commandHandlers?.status,
-          statusCommandDefaultHandler
-        );
-      });
-      metadata.aliases.forEach((alias) => command.alias(alias));
-    }
-  };
   for (const name of selectedCommands) {
-    const register = registrars[name];
-    if (register) {
-      register();
-    }
+    registerTailwindcssPatchCommand(cli, name, options, prefix, defaultDefinitions);
   }
   return cli;
 }
@@ -4714,26 +5027,26 @@ function createTailwindcssPatchCli(options = {}) {
 export {
   logger_default,
   CacheStore,
+  normalizeOptions,
   extractRawCandidatesWithPositions,
   extractRawCandidates,
   extractValidCandidates,
   extractProjectCandidatesWithPositions,
   groupTokensByFile,
-  normalizeOptions,
-  getPatchStatusReport,
   collectClassesFromContexts,
   collectClassesFromTailwindV4,
   loadRuntimeContexts,
   runTailwindBuild,
+  getPatchStatusReport,
   TailwindcssPatcher,
   MIGRATION_REPORT_KIND,
   MIGRATION_REPORT_SCHEMA_VERSION,
   migrateConfigFiles,
   restoreConfigFiles,
-  tailwindcssPatchCommands,
   VALIDATE_EXIT_CODES,
   VALIDATE_FAILURE_REASONS,
   ValidateCommandError,
+  tailwindcssPatchCommands,
   mountTailwindcssPatchCommands,
   createTailwindcssPatchCli
 };