tailwindcss-patch 8.7.3 → 8.7.4-alpha.0

package/dist/{chunk-3T6WSV7F.mjs → chunk-6ZDYMYHE.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: "8.7.4-alpha.0",
   description: "patch tailwindcss for exposing context and extract classes",
   author: "ice breaker <1324318532@qq.com>",
   license: "MIT",
@@ -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"
   },
@@ -1906,7 +1907,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;
       }
@@ -1931,33 +1932,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 +2001,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 +2022,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 +2131,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 +2366,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 +2426,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 +2449,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 +2794,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 +2838,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 +2854,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 +2873,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 +2921,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 +2977,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 +2992,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 +3023,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 +3032,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 +3058,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 +3135,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 +3161,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 +3176,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 +3195,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 +3211,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) {
@@ -3205,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);
@@ -3228,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({
@@ -3250,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,
@@ -3257,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) {
@@ -3288,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}`);
         }
@@ -3314,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}`);
         }
@@ -3330,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();
@@ -3359,12 +3528,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 +3652,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 +3921,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 +3965,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 +4062,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 +4080,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 +4089,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 +4112,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 +4150,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 +4174,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,7 +4560,7 @@ 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) {
@@ -4447,14 +4616,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 +4730,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 +4740,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) {