tailwindcss-patch 8.7.3 → 9.0.0-alpha.1

package/dist/{chunk-3T6WSV7F.mjs → chunk-SWLOK2S6.mjs}

@@ -1,6 +1,6 @@
 import {
   __dirname
-} from "./chunk-JHEI2MLC.mjs";
+} from "./chunk-A67ABH3M.mjs";
 
 // src/logger.ts
 import { createConsola } from "consola";
@@ -20,7 +20,7 @@ import path from "pathe";
 // package.json
 var package_default = {
   name: "tailwindcss-patch",
-  version: "8.7.3",
+  version: "9.0.0-alpha.1",
   description: "patch tailwindcss for exposing context and extract classes",
   author: "ice breaker <1324318532@qq.com>",
   license: "MIT",
@@ -41,17 +41,17 @@ var package_default = {
   ],
   exports: {
     ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.mjs",
-      require: "./dist/index.js"
+      types: "./src/index.ts",
+      import: "./src/index.ts",
+      require: "./src/index.ts"
     },
     "./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: "./dist/index.js",
-  module: "./dist/index.mjs",
-  types: "./dist/index.d.ts",
+  main: "./src/index.ts",
+  module: "./src/index.ts",
+  types: "./src/index.ts",
   bin: {
     "tw-patch": "dev/bin.ts",
     "tailwindcss-patch": "dev/bin.ts"
@@ -66,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"
@@ -106,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"
   },
@@ -1515,14 +1516,6 @@ ${Date.now()}`, { flag: "wx" });
 import process3 from "process";
 import fs3 from "fs-extra";
 import path2 from "pathe";
-var hasWarnedDeprecatedOptions = false;
-var deprecatedOptionMapping = {
-  cwd: "projectRoot",
-  overwrite: "apply.overwrite",
-  tailwind: "tailwindcss",
-  features: "apply",
-  output: "extract"
-};
 function resolveRealpathSafe(value) {
   const resolved = path2.resolve(value);
   try {
@@ -1667,66 +1660,32 @@ function normalizeTailwindOptions(tailwind, projectRoot) {
     v4
   };
 }
-function resolveOptionSlices(options) {
-  const projectRoot = options.projectRoot ?? options.cwd;
-  const overwrite = options.apply?.overwrite ?? options.overwrite;
-  const tailwind = options.tailwindcss ?? options.tailwind;
-  const exposeContext = options.apply?.exposeContext !== void 0 ? options.apply.exposeContext : options.features?.exposeContext;
-  const extendLengthUnits = options.apply?.extendLengthUnits !== void 0 ? options.apply.extendLengthUnits : options.features?.extendLengthUnits;
-  const write = options.extract?.write ?? options.output?.enabled;
-  const file = options.extract?.file ?? options.output?.file;
-  const format = options.extract?.format ?? options.output?.format;
-  const pretty = options.extract?.pretty ?? options.output?.pretty;
-  const removeUniversalSelector = options.extract?.removeUniversalSelector ?? options.output?.removeUniversalSelector;
-  const extract = {
-    ...write === void 0 ? {} : { write },
-    ...file === void 0 ? {} : { file },
-    ...format === void 0 ? {} : { format },
-    ...pretty === void 0 ? {} : { pretty },
-    ...removeUniversalSelector === void 0 ? {} : { removeUniversalSelector }
-  };
-  return {
-    ...projectRoot === void 0 ? {} : { projectRoot },
-    ...overwrite === void 0 ? {} : { overwrite },
-    ...tailwind === void 0 ? {} : { tailwind },
-    ...Object.keys(extract).length === 0 ? {} : { extract },
-    ...exposeContext === void 0 ? {} : { exposeContext },
-    ...extendLengthUnits === void 0 ? {} : { extendLengthUnits }
-  };
-}
-function findUsedDeprecatedOptions(options) {
-  const result = [];
-  for (const key of Object.keys(deprecatedOptionMapping)) {
-    if (options[key] !== void 0) {
-      result.push(key);
-    }
-  }
-  return result;
-}
-function warnDeprecatedOptionsIfNeeded(options) {
-  if (hasWarnedDeprecatedOptions) {
-    return;
-  }
-  const used = findUsedDeprecatedOptions(options);
+var deprecatedOptionMapping = {
+  cwd: "projectRoot",
+  overwrite: "apply.overwrite",
+  tailwind: "tailwindcss",
+  features: "apply",
+  output: "extract"
+};
+function assertNoDeprecatedOptions(options) {
+  const used = Object.keys(deprecatedOptionMapping).filter((key) => Object.prototype.hasOwnProperty.call(options, key));
   if (used.length === 0) {
     return;
   }
-  hasWarnedDeprecatedOptions = true;
   const mapping = used.map((key) => `${key} -> ${deprecatedOptionMapping[key]}`).join(", ");
-  logger_default.warn(
-    `[deprecated] TailwindcssPatcher options (${used.join(", ")}) are deprecated and will be removed in the next major version. Please migrate to: ${mapping}.`
+  throw new Error(
+    `Legacy TailwindcssPatcher options are no longer supported: ${used.join(", ")}. Use the modern fields instead: ${mapping}.`
   );
 }
 function normalizeOptions(options = {}) {
-  warnDeprecatedOptionsIfNeeded(options);
-  const resolved = resolveOptionSlices(options);
-  const projectRoot = resolveRealpathSafe(resolved.projectRoot ? path2.resolve(resolved.projectRoot) : process3.cwd());
-  const overwrite = resolved.overwrite ?? true;
-  const output = normalizeOutputOptions(resolved.extract);
+  assertNoDeprecatedOptions(options);
+  const projectRoot = resolveRealpathSafe(options.projectRoot ? path2.resolve(options.projectRoot) : process3.cwd());
+  const overwrite = options.apply?.overwrite ?? true;
+  const output = normalizeOutputOptions(options.extract);
   const cache = normalizeCacheOptions(options.cache, projectRoot);
-  const tailwind = normalizeTailwindOptions(resolved.tailwind, projectRoot);
-  const exposeContext = normalizeExposeContextOptions(resolved.exposeContext);
-  const extendLengthUnits = normalizeExtendLengthUnitsOptions(resolved.extendLengthUnits);
+  const tailwind = normalizeTailwindOptions(options.tailwindcss, projectRoot);
+  const exposeContext = normalizeExposeContextOptions(options.apply?.exposeContext);
+  const extendLengthUnits = normalizeExtendLengthUnitsOptions(options.apply?.extendLengthUnits);
   const filter = (className) => {
     if (output.removeUniversalSelector && className === "*") {
       return false;
@@ -1751,122 +1710,70 @@ function normalizeOptions(options = {}) {
 }
 
 // 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 }
-    };
+var deprecatedRegistryMapping = {
+  output: "extract",
+  tailwind: "tailwindcss"
+};
+var deprecatedTailwindMapping = {
+  package: "packageName",
+  legacy: "v2",
+  classic: "v3",
+  next: "v4"
+};
+function assertNoDeprecatedRegistryOptions(registry) {
+  const usedRegistryKeys = Object.keys(deprecatedRegistryMapping).filter((key) => Object.prototype.hasOwnProperty.call(registry, key));
+  if (usedRegistryKeys.length > 0) {
+    const mapping = usedRegistryKeys.map((key) => `${key} -> ${deprecatedRegistryMapping[key]}`).join(", ");
+    throw new Error(
+      `Legacy registry fields are no longer supported: ${usedRegistryKeys.join(", ")}. Use the modern fields instead: ${mapping}.`
+    );
   }
-  return {
-    exposeContext: apply?.exportContext ?? true,
-    extendLengthUnits: extendOption
-  };
-}
-function fromLegacyOptions(options) {
-  if (!options) {
-    return {};
+  const tailwind = registry.tailwindcss;
+  if (!tailwind) {
+    return;
+  }
+  const usedTailwindKeys = Object.keys(deprecatedTailwindMapping).filter((key) => Object.prototype.hasOwnProperty.call(tailwind, key));
+  if (usedTailwindKeys.length > 0) {
+    const mapping = usedTailwindKeys.map((key) => `${key} -> tailwindcss.${deprecatedTailwindMapping[key]}`).join(", ");
+    throw new Error(
+      `Legacy "registry.tailwindcss" fields are no longer supported: ${usedTailwindKeys.join(", ")}. Use the modern fields instead: ${mapping}.`
+    );
   }
-  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 }
+  assertNoDeprecatedRegistryOptions(registry);
+  const extract = registry.extract ? {
+    ...registry.extract.write === void 0 ? {} : { write: registry.extract.write },
+    ...registry.extract.file === void 0 ? {} : { file: registry.extract.file },
+    ...registry.extract.format === void 0 ? {} : { format: registry.extract.format },
+    ...registry.extract.pretty === void 0 ? {} : { pretty: registry.extract.pretty },
+    ...registry.extract.removeUniversalSelector === void 0 ? {} : { removeUniversalSelector: registry.extract.removeUniversalSelector }
   } : 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 }
+  const tailwindcss = registry.tailwindcss ? {
+    ...registry.tailwindcss.version === void 0 ? {} : { version: registry.tailwindcss.version },
+    ...registry.tailwindcss.packageName === void 0 ? {} : { packageName: registry.tailwindcss.packageName },
+    ...registry.tailwindcss.resolve === void 0 ? {} : { resolve: registry.tailwindcss.resolve },
+    ...registry.tailwindcss.config === void 0 ? {} : { config: registry.tailwindcss.config },
+    ...registry.tailwindcss.cwd === void 0 ? {} : { cwd: registry.tailwindcss.cwd },
+    ...registry.tailwindcss.v2 === void 0 ? {} : { v2: registry.tailwindcss.v2 },
+    ...registry.tailwindcss.v3 === void 0 ? {} : { v3: registry.tailwindcss.v3 },
+    ...registry.tailwindcss.v4 === void 0 ? {} : { v4: registry.tailwindcss.v4 }
   } : void 0;
-  const normalizedApply = registry.apply ? {
+  const apply = 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 },
+    ...apply === void 0 ? {} : { apply },
     ...registry.cache === void 0 ? {} : { cache: registry.cache },
     ...registry.filter === void 0 ? {} : { filter: registry.filter },
-    ...normalizedExtract === void 0 ? {} : { extract: normalizedExtract },
-    ...normalizedTailwindcss === void 0 ? {} : { tailwindcss: normalizedTailwindcss }
+    ...extract === void 0 ? {} : { extract },
+    ...tailwindcss === void 0 ? {} : { tailwindcss }
   };
 }
 
@@ -1878,19 +1785,22 @@ 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") {
+function isMissingModuleError(error, pkgName2) {
+  if (!isNodeError(error)) {
     return false;
   }
-  const message = error.message ?? "";
-  return message.includes("@tailwindcss-mangle/config");
-}
-function isMissingSharedModuleError(error) {
-  if (!isNodeError(error) || error.code !== "MODULE_NOT_FOUND") {
+  const code = error.code;
+  if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND") {
     return false;
   }
   const message = error.message ?? "";
-  return message.includes("@tailwindcss-mangle/shared");
+  return message.includes(pkgName2) || message.includes(`${pkgName2}/dist/`);
+}
+function isMissingConfigModuleError(error) {
+  return isMissingModuleError(error, "@tailwindcss-mangle/config");
+}
+function isMissingSharedModuleError(error) {
+  return isMissingModuleError(error, "@tailwindcss-mangle/shared");
 }
 async function loadWorkspaceConfigModule() {
   if (!configModulePromise) {
@@ -1906,7 +1816,7 @@ async function loadWorkspaceConfigModule() {
 }
 async function loadWorkspaceDefu() {
   if (!defuPromise) {
-    defuPromise = import("./dist-EMUBVNNO.mjs").then((mod) => mod.defu).catch(async (error) => {
+    defuPromise = import("./dist-7UDSGIWH.mjs").then((mod) => mod.defu).catch(async (error) => {
       if (!isMissingSharedModuleError(error)) {
         throw error;
       }
@@ -1921,8 +1831,10 @@ 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 }) : {};
+  if (config && typeof config === "object" && "patch" in config && config.patch !== void 0) {
+    throw new Error('Legacy workspace config field "patch" is no longer supported. Move patcher options under "registry".');
+  }
+  const base = config?.registry ? fromUnifiedConfig(config.registry) : {};
   const merged = merge(overrides ?? {}, base);
   return merged;
 }
@@ -1931,33 +1843,66 @@ async function loadPatchOptionsForWorkspace(cwd, overrides) {
 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 { __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;
+  const cacheKey = createDesignSystemCacheKey(css, uniqueBases);
+  const cached = designSystemPromiseCache.get(cacheKey);
+  if (cached) {
+    return cached;
   }
-  throw new Error("Failed to load Tailwind CSS design system.");
+  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 importOxide();
+  const { Scanner } = await getOxideModule();
   const scanner = new Scanner({});
   const result = scanner.getCandidatesWithPositions({ content, extension });
   return result.map(({ candidate, position }) => ({
@@ -1967,7 +1912,7 @@ async function extractRawCandidatesWithPositions(content, extension = "html") {
   }));
 }
 async function extractRawCandidates(sources) {
-  const { Scanner } = await importOxide();
+  const { Scanner } = await getOxideModule();
   const scanner = new Scanner(sources === void 0 ? {} : { sources });
   return scanner.scan();
 }
@@ -1988,25 +1933,44 @@ async function extractValidCandidates(options) {
     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 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];
+  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 css2 = cssByCandidate[index];
-    if (typeof css2 === "string" && css2.trim().length > 0) {
-      validCandidates.push(candidate);
+    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;
 }
@@ -2078,7 +2042,7 @@ function toRelativeFile(cwd, filename) {
 async function extractProjectCandidatesWithPositions(options) {
   const cwd = options?.cwd ? path4.resolve(options.cwd) : process4.cwd();
   const normalizedSources = normalizeSources(options?.sources, cwd);
-  const { Scanner } = await importOxide();
+  const { Scanner } = await getOxideModule();
   const scanner = new Scanner({
     sources: normalizedSources
   });
@@ -2313,10 +2277,53 @@ function loadRuntimeContexts(packageInfo, majorVersion, refProperty) {
 
 // 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;
@@ -2330,6 +2337,9 @@ async function resolveConfigPath(options) {
 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)({
@@ -2350,7 +2360,7 @@ async function runTailwindBuild(options) {
 
 // src/patching/status.ts
 import * as t4 from "@babel/types";
-import fs8 from "fs-extra";
+import fs9 from "fs-extra";
 import path9 from "pathe";
 
 // src/babel/index.ts
@@ -2695,7 +2705,7 @@ function transformPostcssPlugin(content, { refProperty }) {
 
 // src/patching/operations/extend-length-units.ts
 import * as t3 from "@babel/types";
-import fs7 from "fs-extra";
+import fs8 from "fs-extra";
 import path8 from "pathe";
 function updateLengthUnitsArray(content, options) {
   const { variableName = "lengthUnits", units } = options;
@@ -2739,11 +2749,11 @@ function applyExtendLengthUnitsPatchV3(rootDir, options) {
     variableName: options.variableName ?? "lengthUnits"
   };
   const dataTypesFilePath = path8.resolve(rootDir, opts.lengthUnitsFilePath);
-  const exists = fs7.existsSync(dataTypesFilePath);
+  const exists = fs8.existsSync(dataTypesFilePath);
   if (!exists) {
     return { changed: false, code: void 0 };
   }
-  const content = fs7.readFileSync(dataTypesFilePath, "utf8");
+  const content = fs8.readFileSync(dataTypesFilePath, "utf8");
   const { arrayRef, changed } = updateLengthUnitsArray(content, opts);
   if (!arrayRef || !changed) {
     return { changed: false, code: void 0 };
@@ -2755,7 +2765,7 @@ function applyExtendLengthUnitsPatchV3(rootDir, options) {
     const nextCode = `${content.slice(0, arrayRef.start)}${code}${content.slice(arrayRef.end)}`;
     if (opts.overwrite) {
       const target = opts.destPath ? path8.resolve(opts.destPath) : dataTypesFilePath;
-      fs7.writeFileSync(target, nextCode, "utf8");
+      fs8.writeFileSync(target, nextCode, "utf8");
       logger_default.success("Patched Tailwind CSS length unit list (v3).");
     }
     return {
@@ -2774,15 +2784,15 @@ function applyExtendLengthUnitsPatchV4(rootDir, options) {
   }
   const opts = { ...options };
   const distDir = path8.resolve(rootDir, "dist");
-  if (!fs7.existsSync(distDir)) {
+  if (!fs8.existsSync(distDir)) {
     return { files: [], changed: false };
   }
-  const entries = fs7.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 = path8.join(distDir, chunkName);
-    const code = fs7.readFileSync(file, "utf8");
+    const code = fs8.readFileSync(file, "utf8");
     const match = pattern.exec(code);
     if (!match) {
       return null;
@@ -2822,7 +2832,7 @@ function applyExtendLengthUnitsPatchV4(rootDir, options) {
       }
     ]);
     if (opts.overwrite) {
-      fs7.writeFileSync(file, item.code, "utf8");
+      fs8.writeFileSync(file, item.code, "utf8");
     }
   }
   if (candidates.some((file) => !file.hasPatched)) {
@@ -2878,11 +2888,11 @@ function checkExposeContextPatch(context) {
   const checks = [];
   function inspectFile(relative, transform) {
     const filePath = path9.resolve(packageInfo.rootPath, relative);
-    if (!fs8.existsSync(filePath)) {
+    if (!fs9.existsSync(filePath)) {
       checks.push({ relative, exists: false, patched: false });
       return;
     }
-    const content = fs8.readFileSync(filePath, "utf8");
+    const content = fs9.readFileSync(filePath, "utf8");
     const { hasPatched } = transform(content);
     checks.push({
       relative,
@@ -2893,7 +2903,7 @@ function checkExposeContextPatch(context) {
   if (majorVersion === 3) {
     inspectFile("lib/processTailwindFeatures.js", transformProcessTailwindFeaturesReturnContext);
     const pluginCandidates = ["lib/plugin.js", "lib/index.js"];
-    const pluginRelative = pluginCandidates.find((candidate) => fs8.existsSync(path9.resolve(packageInfo.rootPath, candidate)));
+    const pluginRelative = pluginCandidates.find((candidate) => fs9.existsSync(path9.resolve(packageInfo.rootPath, candidate)));
     if (pluginRelative) {
       inspectFile(pluginRelative, (content) => transformPostcssPlugin(content, { refProperty }));
     } else {
@@ -2924,8 +2934,8 @@ 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 = fs8.existsSync(target) ? [path9.relative(rootDir, target)] : [];
-  if (!fs8.existsSync(target)) {
+  const files = fs9.existsSync(target) ? [path9.relative(rootDir, target)] : [];
+  if (!fs9.existsSync(target)) {
     return {
       name: "extendLengthUnits",
       status: "not-applied",
@@ -2933,7 +2943,7 @@ function checkExtendLengthUnitsV3(rootDir, options) {
       files
     };
   }
-  const content = fs8.readFileSync(target, "utf8");
+  const content = fs9.readFileSync(target, "utf8");
   const { found, missingUnits } = inspectLengthUnitsArray(content, variableName, options.units);
   if (!found) {
     return {
@@ -2959,7 +2969,7 @@ function checkExtendLengthUnitsV3(rootDir, options) {
 }
 function checkExtendLengthUnitsV4(rootDir, options) {
   const distDir = path9.resolve(rootDir, "dist");
-  if (!fs8.existsSync(distDir)) {
+  if (!fs9.existsSync(distDir)) {
     return {
       name: "extendLengthUnits",
       status: "not-applied",
@@ -3036,19 +3046,19 @@ function getPatchStatusReport(context) {
 
 // src/api/tailwindcss-patcher.ts
 import process6 from "process";
-import fs10 from "fs-extra";
+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 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);
@@ -3062,8 +3072,8 @@ function applyExposeContextPatch(params) {
   if (majorVersion === 3) {
     const processFileRelative = "lib/processTailwindFeatures.js";
     const processFilePath = path10.resolve(rootDir, processFileRelative);
-    if (fs9.existsSync(processFilePath)) {
-      const content = fs9.readFileSync(processFilePath, "utf8");
+    if (fs10.existsSync(processFilePath)) {
+      const content = fs10.readFileSync(processFilePath, "utf8");
       const { code, hasPatched } = transformProcessTailwindFeaturesReturnContext(content);
       result.files[processFileRelative] = code;
       if (!hasPatched) {
@@ -3077,10 +3087,10 @@ function applyExposeContextPatch(params) {
       }
     }
     const pluginCandidates = ["lib/plugin.js", "lib/index.js"];
-    const pluginRelative = pluginCandidates.find((candidate) => fs9.existsSync(path10.resolve(rootDir, candidate)));
+    const pluginRelative = pluginCandidates.find((candidate) => fs10.existsSync(path10.resolve(rootDir, candidate)));
     if (pluginRelative) {
       const pluginPath = path10.resolve(rootDir, pluginRelative);
-      const content = fs9.readFileSync(pluginPath, "utf8");
+      const content = fs10.readFileSync(pluginPath, "utf8");
       const { code, hasPatched } = transformPostcssPlugin(content, { refProperty });
       result.files[pluginRelative] = code;
       if (!hasPatched) {
@@ -3096,8 +3106,8 @@ function applyExposeContextPatch(params) {
   } else if (majorVersion === 2) {
     const processFileRelative = "lib/jit/processTailwindFeatures.js";
     const processFilePath = path10.resolve(rootDir, processFileRelative);
-    if (fs9.existsSync(processFilePath)) {
-      const content = fs9.readFileSync(processFilePath, "utf8");
+    if (fs10.existsSync(processFilePath)) {
+      const content = fs10.readFileSync(processFilePath, "utf8");
       const { code, hasPatched } = transformProcessTailwindFeaturesReturnContextV2(content);
       result.files[processFileRelative] = code;
       if (!hasPatched) {
@@ -3112,8 +3122,8 @@ function applyExposeContextPatch(params) {
     }
     const pluginRelative = "lib/jit/index.js";
     const pluginPath = path10.resolve(rootDir, pluginRelative);
-    if (fs9.existsSync(pluginPath)) {
-      const content = fs9.readFileSync(pluginPath, "utf8");
+    if (fs10.existsSync(pluginPath)) {
+      const content = fs10.readFileSync(pluginPath, "utf8");
       const { code, hasPatched } = transformPostcssPluginV2(content, { refProperty });
       result.files[pluginRelative] = code;
       if (!hasPatched) {
@@ -3158,25 +3168,7 @@ function applyTailwindPatches(context) {
   return results;
 }
 
-// src/api/tailwindcss-patcher.ts
-function resolveMajorVersion(version, hint) {
-  if (hint && [2, 3, 4].includes(hint)) {
-    return hint;
-  }
-  if (version) {
-    const coerced = coerce(version);
-    if (coerced) {
-      const major = coerced.major;
-      if (major === 2 || major === 3 || major === 4) {
-        return major;
-      }
-      if (major >= 4) {
-        return 4;
-      }
-    }
-  }
-  return 3;
-}
+// src/runtime/collector.ts
 function resolveTailwindExecutionOptions(normalized, majorVersion) {
   const base = normalized.tailwind;
   if (majorVersion === 2 && base.v2) {
@@ -3199,15 +3191,138 @@ function resolveTailwindExecutionOptions(normalized, majorVersion) {
     postcssPlugin: base.postcssPlugin
   };
 }
+var BaseCollector = class {
+  constructor(packageInfo, options, majorVersion) {
+    this.packageInfo = packageInfo;
+    this.options = options;
+    this.majorVersion = majorVersion;
+  }
+  async patch() {
+    return applyTailwindPatches({
+      packageInfo: this.packageInfo,
+      options: this.options,
+      majorVersion: this.majorVersion
+    });
+  }
+  async getPatchStatus() {
+    return getPatchStatusReport({
+      packageInfo: this.packageInfo,
+      options: this.options,
+      majorVersion: this.majorVersion
+    });
+  }
+  getContexts() {
+    return loadRuntimeContexts(
+      this.packageInfo,
+      this.majorVersion,
+      this.options.features.exposeContext.refProperty
+    );
+  }
+};
+var RuntimeCollector = class extends BaseCollector {
+  constructor(packageInfo, options, majorVersion, snapshotFactory) {
+    super(packageInfo, options, majorVersion);
+    this.snapshotFactory = snapshotFactory;
+  }
+  inFlightBuild;
+  async collectClassSet() {
+    const contexts = this.getContexts();
+    return collectClassesFromContexts(contexts, this.options.filter);
+  }
+  getPatchSnapshot() {
+    return this.snapshotFactory();
+  }
+  async runTailwindBuildIfNeeded() {
+    if (this.inFlightBuild) {
+      return this.inFlightBuild;
+    }
+    const executionOptions = resolveTailwindExecutionOptions(this.options, this.majorVersion);
+    const buildOptions = {
+      cwd: executionOptions.cwd,
+      majorVersion: this.majorVersion,
+      ...executionOptions.config === void 0 ? {} : { config: executionOptions.config },
+      ...executionOptions.postcssPlugin === void 0 ? {} : { postcssPlugin: executionOptions.postcssPlugin }
+    };
+    this.inFlightBuild = runTailwindBuild(buildOptions).then(() => void 0);
+    try {
+      await this.inFlightBuild;
+    } finally {
+      this.inFlightBuild = void 0;
+    }
+  }
+};
+var TailwindV4Collector = class extends BaseCollector {
+  constructor(packageInfo, options, snapshotFactory) {
+    super(packageInfo, options, 4);
+    this.snapshotFactory = snapshotFactory;
+  }
+  snapshotFactory;
+  async collectClassSet() {
+    return collectClassesFromTailwindV4(this.options);
+  }
+  getPatchSnapshot() {
+    return this.snapshotFactory();
+  }
+};
+
+// src/api/tailwindcss-patcher.ts
+function resolveInstalledMajorVersion(version) {
+  if (!version) {
+    return void 0;
+  }
+  const coerced = coerce(version);
+  if (!coerced) {
+    return void 0;
+  }
+  const major = coerced.major;
+  if (major === 2 || major === 3 || major === 4) {
+    return major;
+  }
+  if (major >= 4) {
+    return 4;
+  }
+  return void 0;
+}
+function validateInstalledVersion(packageVersion, expectedMajor, packageName) {
+  const installedMajor = resolveInstalledMajorVersion(packageVersion);
+  if (installedMajor === void 0) {
+    return;
+  }
+  if (installedMajor !== expectedMajor) {
+    throw new Error(
+      `Configured tailwindcss.version=${expectedMajor}, but resolved package "${packageName}" is version ${packageVersion}. Update the configuration or resolve the correct package.`
+    );
+  }
+}
+function resolveMajorVersionOrThrow(configuredMajor, packageVersion, packageName) {
+  if (configuredMajor !== void 0) {
+    validateInstalledVersion(packageVersion, configuredMajor, packageName);
+    return configuredMajor;
+  }
+  const installedMajor = resolveInstalledMajorVersion(packageVersion);
+  if (installedMajor !== void 0) {
+    return installedMajor;
+  }
+  throw new Error(
+    `Unable to infer Tailwind CSS major version from resolved package "${packageName}" (${packageVersion ?? "unknown"}). Set "tailwindcss.version" to 2, 3, or 4 explicitly.`
+  );
+}
+function createCollector(packageInfo, options, majorVersion, snapshotFactory) {
+  if (majorVersion === 4) {
+    return new TailwindV4Collector(packageInfo, options, snapshotFactory);
+  }
+  return new RuntimeCollector(packageInfo, options, majorVersion, snapshotFactory);
+}
 var TailwindcssPatcher = class {
   options;
   packageInfo;
   majorVersion;
   cacheContext;
   cacheStore;
+  collector;
+  patchMemo;
   constructor(options = {}) {
-    const resolvedOptions = options && typeof options === "object" && "patch" in options ? fromLegacyOptions(options) : options;
-    this.options = normalizeOptions(resolvedOptions);
+    this.options = normalizeOptions(options);
     const packageInfo = getPackageInfoSync(
       this.options.tailwind.packageName,
       this.options.tailwind.resolve
@@ -3216,9 +3331,10 @@ var TailwindcssPatcher = class {
       throw new Error(`Unable to locate Tailwind CSS package "${this.options.tailwind.packageName}".`);
     }
     this.packageInfo = packageInfo;
-    this.majorVersion = resolveMajorVersion(
+    this.majorVersion = resolveMajorVersionOrThrow(
+      this.options.tailwind.versionHint,
       this.packageInfo.version,
-      this.options.tailwind.versionHint
+      this.options.tailwind.packageName
     );
     this.cacheContext = createCacheContextDescriptor(
       this.options,
@@ -3226,47 +3342,81 @@ var TailwindcssPatcher = class {
       this.majorVersion
     );
     this.cacheStore = new CacheStore(this.options.cache, this.cacheContext);
+    this.collector = createCollector(
+      this.packageInfo,
+      this.options,
+      this.majorVersion,
+      () => this.createPatchSnapshot()
+    );
   }
   async patch() {
-    return applyTailwindPatches({
-      packageInfo: this.packageInfo,
-      options: this.options,
-      majorVersion: this.majorVersion
-    });
+    const snapshot = this.collector.getPatchSnapshot();
+    if (this.patchMemo && this.patchMemo.snapshot === snapshot) {
+      return this.patchMemo.result;
+    }
+    const result = await this.collector.patch();
+    this.patchMemo = {
+      result,
+      snapshot: this.collector.getPatchSnapshot()
+    };
+    return result;
   }
   async getPatchStatus() {
-    return getPatchStatusReport({
-      packageInfo: this.packageInfo,
-      options: this.options,
-      majorVersion: this.majorVersion
-    });
+    return this.collector.getPatchStatus();
   }
   getContexts() {
-    return loadRuntimeContexts(
-      this.packageInfo,
-      this.majorVersion,
-      this.options.features.exposeContext.refProperty
-    );
+    return this.collector.getContexts();
   }
-  async runTailwindBuildIfNeeded() {
-    if (this.majorVersion === 2 || this.majorVersion === 3) {
-      const executionOptions = resolveTailwindExecutionOptions(this.options, this.majorVersion);
-      const buildOptions = {
-        cwd: executionOptions.cwd,
-        majorVersion: this.majorVersion,
-        ...executionOptions.config === void 0 ? {} : { config: executionOptions.config },
-        ...executionOptions.postcssPlugin === void 0 ? {} : { postcssPlugin: executionOptions.postcssPlugin }
-      };
-      await runTailwindBuild(buildOptions);
+  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) {
-      return collectClassesFromTailwindV4(this.options);
+      return this.collector.collectClassSet();
     }
     const contexts = this.getContexts();
     return collectClassesFromContexts(contexts, this.options.filter);
   }
+  async runTailwindBuildIfNeeded() {
+    await this.collector.runTailwindBuildIfNeeded?.();
+  }
   debugCacheRead(meta) {
     if (meta.hit) {
       logger_default.debug(
@@ -3288,13 +3438,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}`);
         }
@@ -3314,13 +3464,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}`);
         }
@@ -3330,6 +3480,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();
@@ -3359,12 +3520,12 @@ var TailwindcssPatcher = class {
       return result;
     }
     const target = path11.resolve(this.options.output.file);
-    await fs10.ensureDir(path11.dirname(target));
+    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(), ".")}`);
@@ -3483,7 +3644,7 @@ function buildMigrationReport(state, context) {
 }
 
 // src/commands/migration-file-executor.ts
-import fs12 from "fs-extra";
+import fs13 from "fs-extra";
 import path13 from "pathe";
 
 // src/commands/migration-source.ts
@@ -3752,7 +3913,7 @@ function migrateConfigSource(source) {
 }
 
 // src/commands/migration-target-files.ts
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 import path12 from "pathe";
 var DEFAULT_CONFIG_FILENAMES = [
   "tailwindcss-patch.config.ts",
@@ -3796,7 +3957,7 @@ 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;
     }
@@ -3893,7 +4054,7 @@ async function rollbackWrittenEntries(wroteEntries) {
   let rollbackCount = 0;
   for (const written of [...wroteEntries].reverse()) {
     try {
-      await fs12.writeFile(written.file, written.source, "utf8");
+      await fs13.writeFile(written.file, written.source, "utf8");
       written.entry.written = false;
       written.entry.rolledBack = true;
       rollbackCount += 1;
@@ -3911,7 +4072,7 @@ async function executeMigrationFile(options) {
     backupDirectory,
     wroteEntries
   } = options;
-  const exists = await fs12.pathExists(file);
+  const exists = await fs13.pathExists(file);
   if (!exists) {
     return {
       missing: true,
@@ -3920,7 +4081,7 @@ async function executeMigrationFile(options) {
       backupWritten: false
     };
   }
-  const source = await fs12.readFile(file, "utf8");
+  const source = await fs13.readFile(file, "utf8");
   const migrated = migrateConfigSource(source);
   const entry = {
     file,
@@ -3943,12 +4104,12 @@ async function executeMigrationFile(options) {
     if (backupDirectory) {
       const backupRelativePath = resolveBackupRelativePath(cwd, file);
       const backupFile = path13.resolve(backupDirectory, backupRelativePath);
-      await fs12.ensureDir(path13.dirname(backupFile));
-      await fs12.writeFile(backupFile, source, "utf8");
+      await fs13.ensureDir(path13.dirname(backupFile));
+      await fs13.writeFile(backupFile, source, "utf8");
       entry.backupFile = backupFile;
       backupWritten = true;
     }
-    await fs12.writeFile(file, migrated.code, "utf8");
+    await fs13.writeFile(file, migrated.code, "utf8");
     entry.written = true;
     wroteEntries.push({ file, source, entry });
     return {
@@ -3981,15 +4142,15 @@ async function restoreConfigEntries(entries, dryRun) {
       continue;
     }
     restorableEntries += 1;
-    const backupExists = await fs12.pathExists(backupFile);
+    const backupExists = await fs13.pathExists(backupFile);
     if (!backupExists) {
       missingBackups += 1;
       continue;
     }
     if (!dryRun) {
-      const backupContent = await fs12.readFile(backupFile, "utf8");
-      await fs12.ensureDir(path13.dirname(targetFile));
-      await fs12.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);
@@ -4005,9 +4166,9 @@ async function restoreConfigEntries(entries, dryRun) {
 }
 
 // src/commands/migration-report-loader.ts
-import fs13 from "fs-extra";
+import fs14 from "fs-extra";
 async function loadMigrationReportForRestore(reportFile) {
-  const report = await fs13.readJSON(reportFile);
+  const report = await fs14.readJSON(reportFile);
   assertMigrationReportCompatibility(report, reportFile);
   return {
     ...report.reportKind === void 0 ? {} : { reportKind: report.reportKind },
@@ -4391,11 +4552,11 @@ function runWithCommandHandler(cli, command, commandName, args, handler, default
 
 // src/commands/basic-handlers.ts
 import process9 from "process";
-import fs14 from "fs-extra";
+import fs15 from "fs-extra";
 import path16 from "pathe";
 var DEFAULT_CONFIG_NAME = "tailwindcss-mangle";
 async function installCommandDefaultHandler(_ctx) {
-  const patcher = new TailwindcssPatcher();
+  const patcher = await _ctx.createPatcher();
   await patcher.patch();
   logger_default.success("Tailwind CSS runtime patched successfully.");
 }
@@ -4447,14 +4608,14 @@ async function tokensCommandDefaultHandler(ctx) {
   const resolveGrouped = () => grouped ?? buildGrouped();
   if (shouldWrite) {
     const target = path16.resolve(targetFile);
-    await fs14.ensureDir(path16.dirname(target));
+    await fs15.ensureDir(path16.dirname(target));
     if (format === "json") {
-      await fs14.writeJSON(target, report, { spaces: 2 });
+      await fs15.writeJSON(target, report, { spaces: 2 });
     } else if (format === "grouped-json") {
-      await fs14.writeJSON(target, resolveGrouped(), { spaces: 2 });
+      await fs15.writeJSON(target, resolveGrouped(), { spaces: 2 });
     } else {
       const lines = report.entries.map(formatTokenLine);
-      await fs14.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(process9.cwd(), ".")}`);
@@ -4561,7 +4722,7 @@ function resolveValidateCommandArgs(args) {
 
 // src/commands/migration-output.ts
 import process10 from "process";
-import fs15 from "fs-extra";
+import fs16 from "fs-extra";
 import path17 from "pathe";
 function formatPathForLog(file) {
   return file.replace(process10.cwd(), ".");
@@ -4571,8 +4732,8 @@ function createMigrationCheckFailureError(changedFiles) {
 }
 async function writeMigrationReportFile(cwd, reportFile, report) {
   const reportPath = path17.resolve(cwd, reportFile);
-  await fs15.ensureDir(path17.dirname(reportPath));
-  await fs15.writeJSON(reportPath, report, { spaces: 2 });
+  await fs16.ensureDir(path17.dirname(reportPath));
+  await fs16.writeJSON(reportPath, report, { spaces: 2 });
   logger_default.info(`Migration report written: ${formatPathForLog(reportPath)}`);
 }
 function logMigrationReportAsJson(report) {