tailwindcss-patch 8.7.3 → 9.0.0-alpha.1

package/dist/{chunk-EFYAZO6C.js → chunk-Z6OMJZTU.js}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
 
-var _chunk7JAOSSROjs = require('./chunk-7JAOSSRO.js');
+var _chunk5CWNAWKPjs = require('./chunk-5CWNAWKP.js');
 
 // src/logger.ts
 var _consola = require('consola');
@@ -20,7 +20,7 @@ var _pathe = require('pathe'); var _pathe2 = _interopRequireDefault(_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" });
 
 
 
-var hasWarnedDeprecatedOptions = false;
-var deprecatedOptionMapping = {
-  cwd: "projectRoot",
-  overwrite: "apply.overwrite",
-  tailwind: "tailwindcss",
-  features: "apply",
-  output: "extract"
-};
 function resolveRealpathSafe(value) {
   const resolved = _pathe2.default.resolve(value);
   try {
@@ -1667,66 +1660,32 @@ function normalizeTailwindOptions(tailwind, projectRoot) {
     v4
   };
 }
-function resolveOptionSlices(options) {
-  const projectRoot = _nullishCoalesce(options.projectRoot, () => ( options.cwd));
-  const overwrite = _nullishCoalesce(_optionalChain([options, 'access', _42 => _42.apply, 'optionalAccess', _43 => _43.overwrite]), () => ( options.overwrite));
-  const tailwind = _nullishCoalesce(options.tailwindcss, () => ( options.tailwind));
-  const exposeContext = _optionalChain([options, 'access', _44 => _44.apply, 'optionalAccess', _45 => _45.exposeContext]) !== void 0 ? options.apply.exposeContext : _optionalChain([options, 'access', _46 => _46.features, 'optionalAccess', _47 => _47.exposeContext]);
-  const extendLengthUnits = _optionalChain([options, 'access', _48 => _48.apply, 'optionalAccess', _49 => _49.extendLengthUnits]) !== void 0 ? options.apply.extendLengthUnits : _optionalChain([options, 'access', _50 => _50.features, 'optionalAccess', _51 => _51.extendLengthUnits]);
-  const write = _nullishCoalesce(_optionalChain([options, 'access', _52 => _52.extract, 'optionalAccess', _53 => _53.write]), () => ( _optionalChain([options, 'access', _54 => _54.output, 'optionalAccess', _55 => _55.enabled])));
-  const file = _nullishCoalesce(_optionalChain([options, 'access', _56 => _56.extract, 'optionalAccess', _57 => _57.file]), () => ( _optionalChain([options, 'access', _58 => _58.output, 'optionalAccess', _59 => _59.file])));
-  const format = _nullishCoalesce(_optionalChain([options, 'access', _60 => _60.extract, 'optionalAccess', _61 => _61.format]), () => ( _optionalChain([options, 'access', _62 => _62.output, 'optionalAccess', _63 => _63.format])));
-  const pretty = _nullishCoalesce(_optionalChain([options, 'access', _64 => _64.extract, 'optionalAccess', _65 => _65.pretty]), () => ( _optionalChain([options, 'access', _66 => _66.output, 'optionalAccess', _67 => _67.pretty])));
-  const removeUniversalSelector = _nullishCoalesce(_optionalChain([options, 'access', _68 => _68.extract, 'optionalAccess', _69 => _69.removeUniversalSelector]), () => ( _optionalChain([options, 'access', _70 => _70.output, 'optionalAccess', _71 => _71.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 ? _pathe2.default.resolve(resolved.projectRoot) : _process2.default.cwd());
-  const overwrite = _nullishCoalesce(resolved.overwrite, () => ( true));
-  const output = normalizeOutputOptions(resolved.extract);
+  assertNoDeprecatedOptions(options);
+  const projectRoot = resolveRealpathSafe(options.projectRoot ? _pathe2.default.resolve(options.projectRoot) : _process2.default.cwd());
+  const overwrite = _nullishCoalesce(_optionalChain([options, 'access', _42 => _42.apply, 'optionalAccess', _43 => _43.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(_optionalChain([options, 'access', _44 => _44.apply, 'optionalAccess', _45 => _45.exposeContext]));
+  const extendLengthUnits = normalizeExtendLengthUnitsOptions(_optionalChain([options, 'access', _46 => _46.apply, 'optionalAccess', _47 => _47.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 = _optionalChain([patch, 'optionalAccess', _72 => _72.applyPatches]);
-  const extend = _optionalChain([apply, 'optionalAccess', _73 => _73.extendLengthUnits]);
-  let extendOption = false;
-  if (extend && typeof extend === "object") {
-    extendOption = {
-      ...extend,
-      enabled: true
-    };
-  } else if (extend === true) {
-    extendOption = {
-      enabled: true,
-      units: ["rpx"],
-      ..._optionalChain([patch, 'optionalAccess', _74 => _74.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: _nullishCoalesce(_optionalChain([apply, 'optionalAccess', _75 => _75.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 = _optionalChain([patch, 'optionalAccess', _76 => _76.output]);
-  const tailwindConfig = _optionalChain([patch, 'optionalAccess', _77 => _77.tailwindcss]);
-  const tailwindVersion = _optionalChain([tailwindConfig, 'optionalAccess', _78 => _78.version]);
-  const tailwindV2 = _optionalChain([tailwindConfig, 'optionalAccess', _79 => _79.v2]);
-  const tailwindV3 = _optionalChain([tailwindConfig, 'optionalAccess', _80 => _80.v3]);
-  const tailwindV4 = _optionalChain([tailwindConfig, 'optionalAccess', _81 => _81.v4]);
-  const tailwindConfigPath = _nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _82 => _82.config]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _83 => _83.config])));
-  const tailwindCwd = _nullishCoalesce(_nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _84 => _84.cwd]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _85 => _85.cwd]))), () => ( _optionalChain([patch, 'optionalAccess', _86 => _86.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 = {
-    ..._optionalChain([patch, 'optionalAccess', _87 => _87.packageName]) === void 0 ? {} : { packageName: patch.packageName },
-    ...tailwindVersion === void 0 ? {} : { version: tailwindVersion },
-    ..._optionalChain([patch, 'optionalAccess', _88 => _88.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: _nullishCoalesce(options.cache.enabled, () => ( true))
-  } : void 0;
-  const normalizedApply = {
-    ..._optionalChain([patch, 'optionalAccess', _89 => _89.overwrite]) === void 0 ? {} : { overwrite: patch.overwrite },
-    exposeContext: features.exposeContext,
-    extendLengthUnits: features.extendLengthUnits
-  };
-  return {
-    ..._optionalChain([patch, 'optionalAccess', _90 => _90.cwd]) === void 0 ? {} : { projectRoot: patch.cwd },
-    ..._optionalChain([patch, 'optionalAccess', _91 => _91.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 = _nullishCoalesce(registry.tailwindcss, () => ( registry.tailwind));
-  const modernExtract = registry.extract;
-  const legacyOutput = registry.output;
-  const pretty = (() => {
-    const value = _nullishCoalesce(_optionalChain([modernExtract, 'optionalAccess', _92 => _92.pretty]), () => ( _optionalChain([legacyOutput, 'optionalAccess', _93 => _93.pretty])));
-    if (value === void 0) {
-      return void 0;
-    }
-    if (typeof value === "boolean") {
-      return value ? 2 : false;
-    }
-    return value;
-  })();
-  const removeUniversalSelector = _nullishCoalesce(_optionalChain([modernExtract, 'optionalAccess', _94 => _94.removeUniversalSelector]), () => ( _optionalChain([legacyOutput, 'optionalAccess', _95 => _95.stripUniversalSelector])));
-  const outputFile = _nullishCoalesce(_optionalChain([modernExtract, 'optionalAccess', _96 => _96.file]), () => ( _optionalChain([legacyOutput, 'optionalAccess', _97 => _97.file])));
-  const normalizedExtract = modernExtract || legacyOutput ? {
-    ..._optionalChain([modernExtract, 'optionalAccess', _98 => _98.write]) === void 0 ? {} : { write: modernExtract.write },
-    ...outputFile === void 0 ? {} : { file: outputFile },
-    ...pretty === void 0 ? {} : { pretty },
-    ...removeUniversalSelector === void 0 ? {} : { removeUniversalSelector },
-    ..._optionalChain([modernExtract, 'optionalAccess', _99 => _99.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 = _nullishCoalesce(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 = _nullishCoalesce(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 = Promise.resolve().then(() => _interopRequireWildcard(require("./dist-NW65QXLC.js"))).then((mod) => mod.defu).catch(async (error) => {
+    defuPromise = Promise.resolve().then(() => _interopRequireWildcard(require("./dist-7O2232CU.js"))).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 = _optionalChain([config, 'optionalAccess', _100 => _100.registry]) ? fromUnifiedConfig(config.registry) : _optionalChain([legacyConfig, 'optionalAccess', _101 => _101.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 = _optionalChain([config, 'optionalAccess', _48 => _48.registry]) ? fromUnifiedConfig(config.registry) : {};
   const merged = merge(_nullishCoalesce(overrides, () => ( {})), base);
   return merged;
 }
@@ -1931,33 +1843,66 @@ async function loadPatchOptionsForWorkspace(cwd, overrides) {
 var _fs = require('fs');
 
 
+var nodeImportPromise;
+var oxideImportPromise;
+var designSystemPromiseCache = /* @__PURE__ */ new Map();
+var designSystemCandidateCache = /* @__PURE__ */ new Map();
 async function importNode() {
   return Promise.resolve().then(() => _interopRequireWildcard(require("@tailwindcss/node")));
 }
 async function importOxide() {
   return Promise.resolve().then(() => _interopRequireWildcard(require("@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,30 +1933,49 @@ 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 = _nullishCoalesce(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;
 }
 function normalizeSources(sources, cwd) {
-  const baseSources = _optionalChain([sources, 'optionalAccess', _102 => _102.length]) ? sources : [
+  const baseSources = _optionalChain([sources, 'optionalAccess', _49 => _49.length]) ? sources : [
     {
       base: cwd,
       pattern: "**/*",
@@ -2076,9 +2040,9 @@ function toRelativeFile(cwd, filename) {
   return relative === "" ? _pathe2.default.basename(filename) : relative;
 }
 async function extractProjectCandidatesWithPositions(options) {
-  const cwd = _optionalChain([options, 'optionalAccess', _103 => _103.cwd]) ? _pathe2.default.resolve(options.cwd) : _process2.default.cwd();
-  const normalizedSources = normalizeSources(_optionalChain([options, 'optionalAccess', _104 => _104.sources]), cwd);
-  const { Scanner } = await importOxide();
+  const cwd = _optionalChain([options, 'optionalAccess', _50 => _50.cwd]) ? _pathe2.default.resolve(options.cwd) : _process2.default.cwd();
+  const normalizedSources = normalizeSources(_optionalChain([options, 'optionalAccess', _51 => _51.sources]), cwd);
+  const { Scanner } = await getOxideModule();
   const scanner = new Scanner({
     sources: normalizedSources
   });
@@ -2131,8 +2095,8 @@ async function extractProjectCandidatesWithPositions(options) {
   };
 }
 function groupTokensByFile(report, options) {
-  const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _105 => _105.key]), () => ( "relative"));
-  const stripAbsolute = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _106 => _106.stripAbsolutePaths]), () => ( key !== "absolute"));
+  const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.key]), () => ( "relative"));
+  const stripAbsolute = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _53 => _53.stripAbsolutePaths]), () => ( key !== "absolute"));
   return report.entries.reduce((acc, entry) => {
     const bucketKey = key === "absolute" ? entry.file : entry.relativeFile;
     if (!acc[bucketKey]) {
@@ -2208,7 +2172,7 @@ async function collectClassesFromTailwindV4(options) {
   const resolvedConfiguredBase = toAbsolute(v4Options.configuredBase);
   const resolvedDefaultBase = _nullishCoalesce(toAbsolute(v4Options.base), () => ( _process2.default.cwd()));
   const resolveSources = (base) => {
-    if (!_optionalChain([v4Options, 'access', _107 => _107.sources, 'optionalAccess', _108 => _108.length])) {
+    if (!_optionalChain([v4Options, 'access', _54 => _54.sources, 'optionalAccess', _55 => _55.length])) {
       return void 0;
     }
     return v4Options.sources.map((source) => ({
@@ -2266,7 +2230,7 @@ async function collectClassesFromTailwindV4(options) {
 var _module = require('module');
 
 
-var require2 = _module.createRequire.call(void 0, _chunk7JAOSSROjs.importMetaUrl);
+var require2 = _module.createRequire.call(void 0, _chunk5CWNAWKPjs.importMetaUrl);
 function resolveRuntimeEntry(packageInfo, majorVersion) {
   const root = packageInfo.rootPath;
   if (majorVersion === 2) {
@@ -2314,9 +2278,52 @@ function loadRuntimeContexts(packageInfo, majorVersion, refProperty) {
 // src/runtime/process-tailwindcss.ts
 
 
+
 var _postcss = require('postcss'); var _postcss2 = _interopRequireDefault(_postcss);
 var _tailwindcssconfig = require('tailwindcss-config');
-var require3 = _module.createRequire.call(void 0, _chunk7JAOSSROjs.importMetaUrl);
+var require3 = _module.createRequire.call(void 0, _chunk5CWNAWKPjs.importMetaUrl);
+function resolveModuleEntry(id) {
+  return _pathe2.default.isAbsolute(id) ? id : require3.resolve(id);
+}
+function resolvePackageRootFromEntry(entry) {
+  let current = _pathe2.default.dirname(entry);
+  while (current && current !== _pathe2.default.dirname(current)) {
+    const packageJsonPath = _pathe2.default.join(current, "package.json");
+    if (_fsextra2.default.pathExistsSync(packageJsonPath)) {
+      return current;
+    }
+    current = _pathe2.default.dirname(current);
+  }
+  return void 0;
+}
+function clearTailwindV3RuntimeState(pluginName) {
+  try {
+    const entry = resolveModuleEntry(pluginName);
+    const root = resolvePackageRootFromEntry(entry);
+    if (!root) {
+      return;
+    }
+    const sharedStatePath = _pathe2.default.join(root, "lib/lib/sharedState.js");
+    if (!_fsextra2.default.pathExistsSync(sharedStatePath)) {
+      return;
+    }
+    const sharedState = _optionalChain([require3, 'access', _56 => _56.cache, 'access', _57 => _57[sharedStatePath], 'optionalAccess', _58 => _58.exports]);
+    _optionalChain([sharedState, 'optionalAccess', _59 => _59.contextMap, 'optionalAccess', _60 => _60.clear, 'call', _61 => _61()]);
+    _optionalChain([sharedState, 'optionalAccess', _62 => _62.configContextMap, 'optionalAccess', _63 => _63.clear, 'call', _64 => _64()]);
+    _optionalChain([sharedState, 'optionalAccess', _65 => _65.contextSourcesMap, 'optionalAccess', _66 => _66.clear, 'call', _67 => _67()]);
+    _optionalChain([sharedState, 'optionalAccess', _68 => _68.sourceHashMap, 'optionalAccess', _69 => _69.clear, 'call', _70 => _70()]);
+    for (const candidate of ["lib/plugin.js", "lib/index.js"]) {
+      const runtimeEntry = _pathe2.default.join(root, candidate);
+      if (!_fsextra2.default.pathExistsSync(runtimeEntry)) {
+        continue;
+      }
+      const runtimeModule = _optionalChain([require3, 'access', _71 => _71.cache, 'access', _72 => _72[runtimeEntry], 'optionalAccess', _73 => _73.exports]);
+      _optionalChain([runtimeModule, 'optionalAccess', _74 => _74.contextRef, 'optionalAccess', _75 => _75.value, 'optionalAccess', _76 => _76.splice, 'call', _77 => _77(0, runtimeModule.contextRef.value.length)]);
+      break;
+    }
+  } catch (e10) {
+  }
+}
 async function resolveConfigPath(options) {
   if (options.config && _pathe2.default.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 = _nullishCoalesce(options.postcssPlugin, () => ( (options.majorVersion === 4 ? "@tailwindcss/postcss" : "tailwindcss")));
+  if (options.majorVersion === 3) {
+    clearTailwindV3RuntimeState(pluginName);
+  }
   if (options.majorVersion === 4) {
     return _postcss2.default.call(void 0, [
       require3(pluginName)({
@@ -2390,7 +2400,7 @@ function transformProcessTailwindFeaturesReturnContextV2(content) {
   traverse(ast, {
     FunctionDeclaration(path18) {
       const node = path18.node;
-      if (_optionalChain([node, 'access', _109 => _109.id, 'optionalAccess', _110 => _110.name]) !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
+      if (_optionalChain([node, 'access', _78 => _78.id, 'optionalAccess', _79 => _79.name]) !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
         return;
       }
       const returnStatement3 = node.body.body[0];
@@ -2423,7 +2433,7 @@ function transformPostcssPluginV2(content, options) {
     Program(path18) {
       const program = path18.node;
       const index = program.body.findIndex((statement) => {
-        return t.isFunctionDeclaration(statement) && _optionalChain([statement, 'access', _111 => _111.id, 'optionalAccess', _112 => _112.name]) === "_default";
+        return t.isFunctionDeclaration(statement) && _optionalChain([statement, 'access', _80 => _80.id, 'optionalAccess', _81 => _81.name]) === "_default";
       });
       if (index === -1) {
         return;
@@ -2460,7 +2470,7 @@ function transformPostcssPluginV2(content, options) {
         return;
       }
       const fn = path18.node;
-      if (_optionalChain([fn, 'access', _113 => _113.id, 'optionalAccess', _114 => _114.name]) !== "_default") {
+      if (_optionalChain([fn, 'access', _82 => _82.id, 'optionalAccess', _83 => _83.name]) !== "_default") {
         return;
       }
       if (fn.body.body.length !== 1 || !t.isReturnStatement(fn.body.body[0])) {
@@ -2550,7 +2560,7 @@ function transformProcessTailwindFeaturesReturnContext(content) {
   traverse(ast, {
     FunctionDeclaration(path18) {
       const node = path18.node;
-      if (_optionalChain([node, 'access', _115 => _115.id, 'optionalAccess', _116 => _116.name]) !== "processTailwindFeatures" || node.body.body.length !== 1) {
+      if (_optionalChain([node, 'access', _84 => _84.id, 'optionalAccess', _85 => _85.name]) !== "processTailwindFeatures" || node.body.body.length !== 1) {
         return;
       }
       const [returnStatement3] = node.body.body;
@@ -2584,7 +2594,7 @@ function transformPostcssPlugin(content, { refProperty }) {
     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) && _optionalChain([statement, 'access', _117 => _117.expression, 'access', _118 => _118.right, 'access', _119 => _119.id, 'optionalAccess', _120 => _120.name]) === "tailwindcss";
+        return t2.isExpressionStatement(statement) && t2.isAssignmentExpression(statement.expression) && t2.isMemberExpression(statement.expression.left) && t2.isFunctionExpression(statement.expression.right) && _optionalChain([statement, 'access', _86 => _86.expression, 'access', _87 => _87.right, 'access', _88 => _88.id, 'optionalAccess', _89 => _89.name]) === "tailwindcss";
       });
       if (index === -1) {
         return;
@@ -2625,7 +2635,7 @@ function transformPostcssPlugin(content, { refProperty }) {
         return;
       }
       const fn = path18.node;
-      if (_optionalChain([fn, 'access', _121 => _121.id, 'optionalAccess', _122 => _122.name]) !== "tailwindcss" || fn.body.body.length !== 1) {
+      if (_optionalChain([fn, 'access', _90 => _90.id, 'optionalAccess', _91 => _91.name]) !== "tailwindcss" || fn.body.body.length !== 1) {
         return;
       }
       const [returnStatement3] = fn.body.body;
@@ -3022,7 +3032,7 @@ function checkExtendLengthUnitsPatch(context) {
 function getPatchStatusReport(context) {
   return {
     package: {
-      name: _nullishCoalesce(context.packageInfo.name, () => ( _optionalChain([context, 'access', _123 => _123.packageInfo, 'access', _124 => _124.packageJson, 'optionalAccess', _125 => _125.name]))),
+      name: _nullishCoalesce(context.packageInfo.name, () => ( _optionalChain([context, 'access', _92 => _92.packageInfo, 'access', _93 => _93.packageJson, 'optionalAccess', _94 => _94.name]))),
       version: context.packageInfo.version,
       root: context.packageInfo.rootPath
     },
@@ -3142,7 +3152,7 @@ function applyTailwindPatches(context) {
       majorVersion
     });
   }
-  if (_optionalChain([options, 'access', _126 => _126.features, 'access', _127 => _127.extendLengthUnits, 'optionalAccess', _128 => _128.enabled])) {
+  if (_optionalChain([options, 'access', _95 => _95.features, 'access', _96 => _96.extendLengthUnits, 'optionalAccess', _97 => _97.enabled])) {
     if (majorVersion === 3) {
       results.extendLengthUnits = applyExtendLengthUnitsPatchV3(
         packageInfo.rootPath,
@@ -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 = _semver.coerce.call(void 0, 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;
+  }
+  
+  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;
+  }
+  
+  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 = _semver.coerce.call(void 0, 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}" (${_nullishCoalesce(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 = (_class2 = class {
   
   
   
   
   
+  
+  
   constructor(options = {}) {;_class2.prototype.__init4.call(this);
-    const resolvedOptions = options && typeof options === "object" && "patch" in options ? fromLegacyOptions(options) : options;
-    this.options = normalizeOptions(resolvedOptions);
+    this.options = normalizeOptions(options);
     const packageInfo = _localpkg.getPackageInfoSync.call(void 0, 
       this.options.tailwind.packageName,
       this.options.tailwind.resolve
@@ -3216,9 +3331,10 @@ var TailwindcssPatcher = (_class2 = 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,56 +3342,90 @@ var TailwindcssPatcher = (_class2 = 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 (!_fsextra2.default.pathExistsSync(filePath)) {
+        entries.push(`${filePath}:missing`);
+        return;
+      }
+      const stat = _fsextra2.default.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(_pathe2.default.resolve(this.packageInfo.rootPath, "lib/jit/processTailwindFeatures.js"));
+        pushSnapshot(_pathe2.default.resolve(this.packageInfo.rootPath, "lib/jit/index.js"));
+      } else {
+        pushSnapshot(_pathe2.default.resolve(this.packageInfo.rootPath, "lib/processTailwindFeatures.js"));
+        const pluginPath = ["lib/plugin.js", "lib/index.js"].map((file) => _pathe2.default.resolve(this.packageInfo.rootPath, file)).find((file) => _fsextra2.default.pathExistsSync(file));
+        if (pluginPath) {
+          pushSnapshot(pluginPath);
+        }
+      }
     }
+    if (_optionalChain([this, 'access', _98 => _98.options, 'access', _99 => _99.features, 'access', _100 => _100.extendLengthUnits, 'optionalAccess', _101 => _101.enabled])) {
+      if (this.majorVersion === 3) {
+        const target = _nullishCoalesce(this.options.features.extendLengthUnits.lengthUnitsFilePath, () => ( "lib/util/dataTypes.js"));
+        pushSnapshot(_pathe2.default.resolve(this.packageInfo.rootPath, target));
+      } else if (this.majorVersion === 4) {
+        const distDir = _pathe2.default.resolve(this.packageInfo.rootPath, "dist");
+        if (_fsextra2.default.pathExistsSync(distDir)) {
+          const chunkNames = _fsextra2.default.readdirSync(distDir).filter((entry) => entry.endsWith(".js") || entry.endsWith(".mjs")).sort();
+          for (const chunkName of chunkNames) {
+            pushSnapshot(_pathe2.default.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 _optionalChain([this, 'access', _102 => _102.collector, 'access', _103 => _103.runTailwindBuildIfNeeded, 'optionalCall', _104 => _104()]);
+  }
   debugCacheRead(meta) {
     if (meta.hit) {
       logger_default.debug(
-        `[cache] hit fingerprint=${_nullishCoalesce(_optionalChain([meta, 'access', _129 => _129.fingerprint, 'optionalAccess', _130 => _130.slice, 'call', _131 => _131(0, 12)]), () => ( "n/a"))} schema=${_nullishCoalesce(meta.schemaVersion, () => ( "legacy"))} ${meta.details.join("; ")}`
+        `[cache] hit fingerprint=${_nullishCoalesce(_optionalChain([meta, 'access', _105 => _105.fingerprint, 'optionalAccess', _106 => _106.slice, 'call', _107 => _107(0, 12)]), () => ( "n/a"))} schema=${_nullishCoalesce(meta.schemaVersion, () => ( "legacy"))} ${meta.details.join("; ")}`
       );
       return;
     }
     logger_default.debug(
-      `[cache] miss reason=${meta.reason} fingerprint=${_nullishCoalesce(_optionalChain([meta, 'access', _132 => _132.fingerprint, 'optionalAccess', _133 => _133.slice, 'call', _134 => _134(0, 12)]), () => ( "n/a"))} schema=${_nullishCoalesce(meta.schemaVersion, () => ( "legacy"))} ${meta.details.join("; ")}`
+      `[cache] miss reason=${meta.reason} fingerprint=${_nullishCoalesce(_optionalChain([meta, 'access', _108 => _108.fingerprint, 'optionalAccess', _109 => _109.slice, 'call', _110 => _110(0, 12)]), () => ( "n/a"))} schema=${_nullishCoalesce(meta.schemaVersion, () => ( "legacy"))} ${meta.details.join("; ")}`
     );
   }
   async mergeWithCache(set) {
@@ -3288,13 +3438,13 @@ var TailwindcssPatcher = (_class2 = 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 = (_class2 = 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 = (_class2 = 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();
@@ -3348,7 +3509,7 @@ var TailwindcssPatcher = (_class2 = class {
     return merged;
   }
   async extract(options) {
-    const shouldWrite = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _135 => _135.write]), () => ( this.options.output.enabled));
+    const shouldWrite = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _111 => _111.write]), () => ( this.options.output.enabled));
     const classSet = await this.getClassSet();
     const classList = Array.from(classSet);
     const result = {
@@ -3384,19 +3545,19 @@ var TailwindcssPatcher = (_class2 = class {
   __init4() {this.extractValidCandidates = exports.extractValidCandidates = extractValidCandidates}
   async collectContentTokens(options) {
     return extractProjectCandidatesWithPositions({
-      cwd: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _136 => _136.cwd]), () => ( this.options.projectRoot)),
-      sources: _nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _137 => _137.sources]), () => ( _optionalChain([this, 'access', _138 => _138.options, 'access', _139 => _139.tailwind, 'access', _140 => _140.v4, 'optionalAccess', _141 => _141.sources]))), () => ( []))
+      cwd: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _112 => _112.cwd]), () => ( this.options.projectRoot)),
+      sources: _nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _113 => _113.sources]), () => ( _optionalChain([this, 'access', _114 => _114.options, 'access', _115 => _115.tailwind, 'access', _116 => _116.v4, 'optionalAccess', _117 => _117.sources]))), () => ( []))
     });
   }
   async collectContentTokensByFile(options) {
     const collectContentOptions = {
-      ..._optionalChain([options, 'optionalAccess', _142 => _142.cwd]) === void 0 ? {} : { cwd: options.cwd },
-      ..._optionalChain([options, 'optionalAccess', _143 => _143.sources]) === void 0 ? {} : { sources: options.sources }
+      ..._optionalChain([options, 'optionalAccess', _118 => _118.cwd]) === void 0 ? {} : { cwd: options.cwd },
+      ..._optionalChain([options, 'optionalAccess', _119 => _119.sources]) === void 0 ? {} : { sources: options.sources }
     };
     const report = await this.collectContentTokens(collectContentOptions);
     const groupOptions = {
-      ..._optionalChain([options, 'optionalAccess', _144 => _144.key]) === void 0 ? {} : { key: options.key },
-      ..._optionalChain([options, 'optionalAccess', _145 => _145.stripAbsolutePaths]) === void 0 ? {} : { stripAbsolutePaths: options.stripAbsolutePaths }
+      ..._optionalChain([options, 'optionalAccess', _120 => _120.key]) === void 0 ? {} : { key: options.key },
+      ..._optionalChain([options, 'optionalAccess', _121 => _121.stripAbsolutePaths]) === void 0 ? {} : { stripAbsolutePaths: options.stripAbsolutePaths }
     };
     return groupTokensByFile(report, groupOptions);
   }
@@ -3797,7 +3958,7 @@ async function collectWorkspaceConfigFiles(cwd, maxDepth) {
     let entries;
     try {
       entries = await _fsextra2.default.readdir(dir, { withFileTypes: true });
-    } catch (e10) {
+    } catch (e11) {
       continue;
     }
     for (const entry of entries) {
@@ -3897,7 +4058,7 @@ async function rollbackWrittenEntries(wroteEntries) {
       written.entry.written = false;
       written.entry.rolledBack = true;
       rollbackCount += 1;
-    } catch (e11) {
+    } catch (e12) {
     }
   }
   return rollbackCount;
@@ -4289,10 +4450,10 @@ function addPrefixIfMissing(value, prefix) {
   return `${prefix}${value}`;
 }
 function resolveCommandNames(command, mountOptions, prefix) {
-  const override = _optionalChain([mountOptions, 'access', _146 => _146.commandOptions, 'optionalAccess', _147 => _147[command]]);
-  const baseName = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _148 => _148.name]), () => ( command));
+  const override = _optionalChain([mountOptions, 'access', _122 => _122.commandOptions, 'optionalAccess', _123 => _123[command]]);
+  const baseName = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _124 => _124.name]), () => ( command));
   const name = addPrefixIfMissing(baseName, prefix);
-  const aliases = (_nullishCoalesce(_optionalChain([override, 'optionalAccess', _149 => _149.aliases]), () => ( []))).map((alias) => addPrefixIfMissing(alias, prefix));
+  const aliases = (_nullishCoalesce(_optionalChain([override, 'optionalAccess', _125 => _125.aliases]), () => ( []))).map((alias) => addPrefixIfMissing(alias, prefix));
   return { name, aliases };
 }
 function resolveOptionDefinitions(defaults, override) {
@@ -4312,8 +4473,8 @@ function resolveOptionDefinitions(defaults, override) {
 function resolveCommandMetadata(command, mountOptions, prefix, defaults) {
   const names = resolveCommandNames(command, mountOptions, prefix);
   const definition = defaults[command];
-  const override = _optionalChain([mountOptions, 'access', _150 => _150.commandOptions, 'optionalAccess', _151 => _151[command]]);
-  const description = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _152 => _152.description]), () => ( definition.description));
+  const override = _optionalChain([mountOptions, 'access', _126 => _126.commandOptions, 'optionalAccess', _127 => _127[command]]);
+  const description = _nullishCoalesce(_optionalChain([override, 'optionalAccess', _128 => _128.description]), () => ( definition.description));
   const optionDefs = resolveOptionDefinitions(definition.optionDefs, override);
   return { ...names, description, optionDefs };
 }
@@ -4395,7 +4556,7 @@ function runWithCommandHandler(cli, command, commandName, args, handler, default
 
 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.");
 }
@@ -4832,7 +4993,7 @@ function registerTailwindcssPatchCommand(cli, commandName, options, prefix, defa
       command,
       commandName,
       args,
-      _optionalChain([options, 'access', _153 => _153.commandHandlers, 'optionalAccess', _154 => _154[commandName]]),
+      _optionalChain([options, 'access', _129 => _129.commandHandlers, 'optionalAccess', _130 => _130[commandName]]),
       defaultCommandHandlers[commandName]
     );
   });