tailwindcss-patch 8.4.3 → 8.5.0

package/dist/{chunk-LV6YDLJ7.mjs → chunk-V4NW4IGL.mjs}

@@ -520,372 +520,69 @@ function normalizeOptions(options = {}) {
   };
 }
 
-// src/runtime/class-collector.ts
-import process4 from "process";
-import fs3 from "fs-extra";
-import path3 from "pathe";
+// src/patching/status.ts
+import * as t4 from "@babel/types";
+import fs4 from "fs-extra";
+import path4 from "pathe";
 
-// src/utils.ts
-function isObject(val) {
-  return val !== null && typeof val === "object" && Array.isArray(val) === false;
+// src/babel/index.ts
+import _babelGenerate from "@babel/generator";
+import _babelTraverse from "@babel/traverse";
+import { parse, parseExpression } from "@babel/parser";
+function _interopDefaultCompat(e) {
+  return e && typeof e === "object" && "default" in e ? e.default : e;
 }
-function spliceChangesIntoString(str, changes) {
-  if (!changes[0]) {
-    return str;
+var generate = _interopDefaultCompat(_babelGenerate);
+var traverse = _interopDefaultCompat(_babelTraverse);
+
+// src/patching/operations/export-context/postcss-v2.ts
+import * as t from "@babel/types";
+var IDENTIFIER_RE = /^[A-Z_$][\w$]*$/i;
+function toIdentifierName(property) {
+  if (!property) {
+    return "contextRef";
   }
-  changes.sort((a, b) => {
-    return a.end - b.end || a.start - b.start;
-  });
-  let result = "";
-  let previous = changes[0];
-  result += str.slice(0, previous.start);
-  result += previous.replacement;
-  for (let i = 1; i < changes.length; ++i) {
-    const change = changes[i];
-    result += str.slice(previous.end, change.start);
-    result += change.replacement;
-    previous = change;
+  const sanitized = property.replace(/[^\w$]/gu, "_");
+  if (/^\d/.test(sanitized)) {
+    return `_${sanitized}`;
   }
-  result += str.slice(previous.end);
-  return result;
+  return sanitized || "contextRef";
 }
-
-// src/runtime/class-collector.ts
-function collectClassesFromContexts(contexts, filter) {
-  const set = /* @__PURE__ */ new Set();
-  for (const context of contexts) {
-    if (!isObject(context) || !context.classCache) {
-      continue;
-    }
-    for (const key of context.classCache.keys()) {
-      const className = key.toString();
-      if (filter(className)) {
-        set.add(className);
-      }
-    }
+function createExportsMember(property) {
+  if (IDENTIFIER_RE.test(property)) {
+    return t.memberExpression(t.identifier("exports"), t.identifier(property));
   }
-  return set;
+  return t.memberExpression(t.identifier("exports"), t.stringLiteral(property), true);
 }
-async function collectClassesFromTailwindV4(options) {
-  const set = /* @__PURE__ */ new Set();
-  const v4Options = options.tailwind.v4;
-  if (!v4Options) {
-    return set;
-  }
-  const toAbsolute = (value) => {
-    if (!value) {
-      return void 0;
-    }
-    return path3.isAbsolute(value) ? value : path3.resolve(options.projectRoot, value);
-  };
-  const resolvedConfiguredBase = toAbsolute(v4Options.configuredBase);
-  const resolvedDefaultBase = toAbsolute(v4Options.base) ?? process4.cwd();
-  const resolveSources = (base) => {
-    if (!v4Options.sources?.length) {
-      return void 0;
-    }
-    return v4Options.sources.map((source) => ({
-      base: source.base ?? base,
-      pattern: source.pattern,
-      negated: source.negated
-    }));
-  };
-  if (v4Options.cssEntries.length > 0) {
-    for (const entry of v4Options.cssEntries) {
-      const filePath = path3.isAbsolute(entry) ? entry : path3.resolve(options.projectRoot, entry);
-      if (!await fs3.pathExists(filePath)) {
-        continue;
+function transformProcessTailwindFeaturesReturnContextV2(content) {
+  const ast = parse(content, {
+    sourceType: "unambiguous"
+  });
+  let hasPatched = false;
+  traverse(ast, {
+    FunctionDeclaration(path11) {
+      const node = path11.node;
+      if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
+        return;
       }
-      const css = await fs3.readFile(filePath, "utf8");
-      const entryDir = path3.dirname(filePath);
-      const baseForEntry = resolvedConfiguredBase ?? entryDir;
-      const sources = resolveSources(baseForEntry);
-      const candidates = await extractValidCandidates({
-        cwd: options.projectRoot,
-        base: baseForEntry,
-        css,
-        sources
-      });
-      for (const candidate of candidates) {
-        if (options.filter(candidate)) {
-          set.add(candidate);
-        }
+      const returnStatement3 = node.body.body[0];
+      if (!t.isFunctionExpression(returnStatement3.argument)) {
+        return;
       }
-    }
-  } else {
-    const baseForCss = resolvedConfiguredBase ?? resolvedDefaultBase;
-    const sources = resolveSources(baseForCss);
-    const candidates = await extractValidCandidates({
-      cwd: options.projectRoot,
-      base: baseForCss,
-      css: v4Options.css,
-      sources
-    });
-    for (const candidate of candidates) {
-      if (options.filter(candidate)) {
-        set.add(candidate);
+      const body = returnStatement3.argument.body.body;
+      const lastStatement = body[body.length - 1];
+      const alreadyReturnsContext = Boolean(
+        t.isReturnStatement(lastStatement) && t.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context"
+      );
+      hasPatched = alreadyReturnsContext;
+      if (!alreadyReturnsContext) {
+        body.push(t.returnStatement(t.identifier("context")));
       }
     }
-  }
-  return set;
-}
-
-// src/runtime/context-registry.ts
-import { createRequire } from "module";
-import fs4 from "fs-extra";
-import path4 from "pathe";
-var require2 = createRequire(import.meta.url);
-function resolveRuntimeEntry(packageInfo, majorVersion) {
-  const root = packageInfo.rootPath;
-  if (majorVersion === 2) {
-    const jitIndex = path4.join(root, "lib/jit/index.js");
-    if (fs4.existsSync(jitIndex)) {
-      return jitIndex;
-    }
-  } else if (majorVersion === 3) {
-    const plugin = path4.join(root, "lib/plugin.js");
-    const index = path4.join(root, "lib/index.js");
-    if (fs4.existsSync(plugin)) {
-      return plugin;
-    }
-    if (fs4.existsSync(index)) {
-      return index;
-    }
-  }
-  return void 0;
-}
-function loadRuntimeContexts(packageInfo, majorVersion, refProperty) {
-  if (majorVersion === 4) {
-    return [];
-  }
-  const entry = resolveRuntimeEntry(packageInfo, majorVersion);
-  if (!entry) {
-    return [];
-  }
-  const moduleExports = require2(entry);
-  if (!moduleExports) {
-    return [];
-  }
-  const ref = moduleExports[refProperty];
-  if (!ref) {
-    return [];
-  }
-  if (Array.isArray(ref)) {
-    return ref;
-  }
-  if (typeof ref === "object" && Array.isArray(ref.value)) {
-    return ref.value;
-  }
-  return [];
-}
-
-// src/runtime/process-tailwindcss.ts
-import { createRequire as createRequire2 } from "module";
-import path5 from "pathe";
-import postcss from "postcss";
-import { loadConfig } from "tailwindcss-config";
-var require3 = createRequire2(import.meta.url);
-async function resolveConfigPath(options) {
-  if (options.config && path5.isAbsolute(options.config)) {
-    return options.config;
-  }
-  const result = await loadConfig({ cwd: options.cwd });
-  if (!result) {
-    throw new Error(`Unable to locate Tailwind CSS config from ${options.cwd}`);
-  }
-  return result.filepath;
-}
-async function runTailwindBuild(options) {
-  const configPath = await resolveConfigPath(options);
-  const pluginName = options.postcssPlugin ?? (options.majorVersion === 4 ? "@tailwindcss/postcss" : "tailwindcss");
-  if (options.majorVersion === 4) {
-    return postcss([
-      require3(pluginName)({
-        config: configPath
-      })
-    ]).process("@import 'tailwindcss';", {
-      from: void 0
-    });
-  }
-  return postcss([
-    require3(pluginName)({
-      config: configPath
-    })
-  ]).process("@tailwind base;@tailwind components;@tailwind utilities;", {
-    from: void 0
   });
-}
-
-// src/api/tailwindcss-patcher.ts
-import process5 from "process";
-import fs7 from "fs-extra";
-import { getPackageInfoSync } from "local-pkg";
-import path8 from "pathe";
-import { coerce } from "semver";
-
-// src/options/legacy.ts
-function normalizeLegacyFeatures(patch) {
-  const apply = patch?.applyPatches;
-  const extend = apply?.extendLengthUnits;
-  let extendOption = false;
-  if (extend && typeof extend === "object") {
-    extendOption = {
-      ...extend,
-      enabled: true
-    };
-  } else if (extend === true) {
-    extendOption = {
-      enabled: true,
-      units: ["rpx"],
-      overwrite: patch?.overwrite
-    };
-  }
   return {
-    exposeContext: apply?.exportContext ?? true,
-    extendLengthUnits: extendOption
-  };
-}
-function fromLegacyOptions(options) {
-  if (!options) {
-    return {};
-  }
-  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;
-  return {
-    cwd: patch?.cwd,
-    overwrite: patch?.overwrite,
-    filter: patch?.filter,
-    cache: typeof options.cache === "boolean" ? options.cache : options.cache ? {
-      ...options.cache,
-      enabled: options.cache.enabled ?? true
-    } : void 0,
-    output: output ? {
-      file: output.filename,
-      pretty: output.loose ? 2 : false,
-      removeUniversalSelector: output.removeUniversalSelector
-    } : void 0,
-    tailwind: {
-      packageName: patch?.packageName,
-      version: tailwindVersion,
-      resolve: patch?.resolve,
-      config: tailwindConfigPath,
-      cwd: tailwindCwd,
-      v2: tailwindV2,
-      v3: tailwindV3,
-      v4: tailwindV4
-    },
-    features: {
-      exposeContext: features.exposeContext,
-      extendLengthUnits: features.extendLengthUnits
-    }
-  };
-}
-function fromUnifiedConfig(registry) {
-  if (!registry) {
-    return {};
-  }
-  const tailwind = registry.tailwind;
-  const output = registry.output;
-  const pretty = (() => {
-    if (output?.pretty === void 0) {
-      return void 0;
-    }
-    if (typeof output.pretty === "boolean") {
-      return output.pretty ? 2 : false;
-    }
-    return output.pretty;
-  })();
-  return {
-    output: output ? {
-      file: output.file,
-      pretty,
-      removeUniversalSelector: output.stripUniversalSelector
-    } : void 0,
-    tailwind: tailwind ? {
-      version: tailwind.version,
-      packageName: tailwind.package,
-      resolve: tailwind.resolve,
-      config: tailwind.config,
-      cwd: tailwind.cwd,
-      v2: tailwind.legacy,
-      v3: tailwind.classic,
-      v4: tailwind.next
-    } : void 0
-  };
-}
-
-// src/patching/operations/export-context/index.ts
-import fs5 from "fs-extra";
-import path6 from "pathe";
-
-// src/patching/operations/export-context/postcss-v2.ts
-import * as t from "@babel/types";
-
-// src/babel/index.ts
-import _babelGenerate from "@babel/generator";
-import _babelTraverse from "@babel/traverse";
-import { parse, parseExpression } from "@babel/parser";
-function _interopDefaultCompat(e) {
-  return e && typeof e === "object" && "default" in e ? e.default : e;
-}
-var generate = _interopDefaultCompat(_babelGenerate);
-var traverse = _interopDefaultCompat(_babelTraverse);
-
-// src/patching/operations/export-context/postcss-v2.ts
-var IDENTIFIER_RE = /^[A-Z_$][\w$]*$/i;
-function toIdentifierName(property) {
-  if (!property) {
-    return "contextRef";
-  }
-  const sanitized = property.replace(/[^\w$]/gu, "_");
-  if (/^\d/.test(sanitized)) {
-    return `_${sanitized}`;
-  }
-  return sanitized || "contextRef";
-}
-function createExportsMember(property) {
-  if (IDENTIFIER_RE.test(property)) {
-    return t.memberExpression(t.identifier("exports"), t.identifier(property));
-  }
-  return t.memberExpression(t.identifier("exports"), t.stringLiteral(property), true);
-}
-function transformProcessTailwindFeaturesReturnContextV2(content) {
-  const ast = parse(content, {
-    sourceType: "unambiguous"
-  });
-  let hasPatched = false;
-  traverse(ast, {
-    FunctionDeclaration(path10) {
-      const node = path10.node;
-      if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
-        return;
-      }
-      const returnStatement3 = node.body.body[0];
-      if (!t.isFunctionExpression(returnStatement3.argument)) {
-        return;
-      }
-      const body = returnStatement3.argument.body.body;
-      const lastStatement = body[body.length - 1];
-      const alreadyReturnsContext = Boolean(
-        t.isReturnStatement(lastStatement) && t.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context"
-      );
-      hasPatched = alreadyReturnsContext;
-      if (!alreadyReturnsContext) {
-        body.push(t.returnStatement(t.identifier("context")));
-      }
-    }
-  });
-  return {
-    code: hasPatched ? content : generate(ast).code,
-    hasPatched
+    code: hasPatched ? content : generate(ast).code,
+    hasPatched
   };
 }
 function transformPostcssPluginV2(content, options) {
@@ -895,8 +592,8 @@ function transformPostcssPluginV2(content, options) {
   const ast = parse(content);
   let hasPatched = false;
   traverse(ast, {
-    Program(path10) {
-      const program = path10.node;
+    Program(path11) {
+      const program = path11.node;
       const index = program.body.findIndex((statement) => {
         return t.isFunctionDeclaration(statement) && statement.id?.name === "_default";
       });
@@ -930,11 +627,11 @@ function transformPostcssPluginV2(content, options) {
         );
       }
     },
-    FunctionDeclaration(path10) {
+    FunctionDeclaration(path11) {
       if (hasPatched) {
         return;
       }
-      const fn = path10.node;
+      const fn = path11.node;
       if (fn.id?.name !== "_default") {
         return;
       }
@@ -1023,8 +720,8 @@ function transformProcessTailwindFeaturesReturnContext(content) {
   const ast = parse(content);
   let hasPatched = false;
   traverse(ast, {
-    FunctionDeclaration(path10) {
-      const node = path10.node;
+    FunctionDeclaration(path11) {
+      const node = path11.node;
       if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1) {
         return;
       }
@@ -1056,8 +753,8 @@ function transformPostcssPlugin(content, { refProperty }) {
   const valueMember = t2.memberExpression(refIdentifier, t2.identifier("value"));
   let hasPatched = false;
   traverse(ast, {
-    Program(path10) {
-      const program = path10.node;
+    Program(path11) {
+      const program = path11.node;
       const index = program.body.findIndex((statement) => {
         return t2.isExpressionStatement(statement) && t2.isAssignmentExpression(statement.expression) && t2.isMemberExpression(statement.expression.left) && t2.isFunctionExpression(statement.expression.right) && statement.expression.right.id?.name === "tailwindcss";
       });
@@ -1095,11 +792,11 @@ function transformPostcssPlugin(content, { refProperty }) {
         );
       }
     },
-    FunctionExpression(path10) {
+    FunctionExpression(path11) {
       if (hasPatched) {
         return;
       }
-      const fn = path10.node;
+      const fn = path11.node;
       if (fn.id?.name !== "tailwindcss" || fn.body.body.length !== 1) {
         return;
       }
@@ -1161,19 +858,664 @@ function transformPostcssPlugin(content, { refProperty }) {
         )
       );
     }
-  });
+  });
+  return {
+    code: hasPatched ? content : generate(ast).code,
+    hasPatched
+  };
+}
+
+// src/patching/operations/extend-length-units.ts
+import * as t3 from "@babel/types";
+import fs3 from "fs-extra";
+import path3 from "pathe";
+
+// src/utils.ts
+function isObject(val) {
+  return val !== null && typeof val === "object" && Array.isArray(val) === false;
+}
+function spliceChangesIntoString(str, changes) {
+  if (!changes[0]) {
+    return str;
+  }
+  changes.sort((a, b) => {
+    return a.end - b.end || a.start - b.start;
+  });
+  let result = "";
+  let previous = changes[0];
+  result += str.slice(0, previous.start);
+  result += previous.replacement;
+  for (let i = 1; i < changes.length; ++i) {
+    const change = changes[i];
+    result += str.slice(previous.end, change.start);
+    result += change.replacement;
+    previous = change;
+  }
+  result += str.slice(previous.end);
+  return result;
+}
+
+// src/patching/operations/extend-length-units.ts
+function updateLengthUnitsArray(content, options) {
+  const { variableName = "lengthUnits", units } = options;
+  const ast = parse(content);
+  let arrayRef;
+  let changed = false;
+  traverse(ast, {
+    Identifier(path11) {
+      if (path11.node.name === variableName && t3.isVariableDeclarator(path11.parent) && t3.isArrayExpression(path11.parent.init)) {
+        arrayRef = path11.parent.init;
+        const existing = new Set(
+          path11.parent.init.elements.map((element) => t3.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
+        );
+        for (const unit of units) {
+          if (!existing.has(unit)) {
+            path11.parent.init.elements = path11.parent.init.elements.map((element) => {
+              if (t3.isStringLiteral(element)) {
+                return t3.stringLiteral(element.value);
+              }
+              return element;
+            });
+            path11.parent.init.elements.push(t3.stringLiteral(unit));
+            changed = true;
+          }
+        }
+      }
+    }
+  });
+  return {
+    arrayRef,
+    changed
+  };
+}
+function applyExtendLengthUnitsPatchV3(rootDir, options) {
+  if (!options.enabled) {
+    return { changed: false, code: void 0 };
+  }
+  const opts = {
+    ...options,
+    lengthUnitsFilePath: options.lengthUnitsFilePath ?? "lib/util/dataTypes.js",
+    variableName: options.variableName ?? "lengthUnits"
+  };
+  const dataTypesFilePath = path3.resolve(rootDir, opts.lengthUnitsFilePath);
+  const exists = fs3.existsSync(dataTypesFilePath);
+  if (!exists) {
+    return { changed: false, code: void 0 };
+  }
+  const content = fs3.readFileSync(dataTypesFilePath, "utf8");
+  const { arrayRef, changed } = updateLengthUnitsArray(content, opts);
+  if (!arrayRef || !changed) {
+    return { changed: false, code: void 0 };
+  }
+  const { code } = generate(arrayRef, {
+    jsescOption: { quotes: "single" }
+  });
+  if (arrayRef.start != null && arrayRef.end != null) {
+    const nextCode = `${content.slice(0, arrayRef.start)}${code}${content.slice(arrayRef.end)}`;
+    if (opts.overwrite) {
+      const target = opts.destPath ? path3.resolve(opts.destPath) : dataTypesFilePath;
+      fs3.writeFileSync(target, nextCode, "utf8");
+      logger_default.success("Patched Tailwind CSS length unit list (v3).");
+    }
+    return {
+      changed: true,
+      code: nextCode
+    };
+  }
+  return {
+    changed: false,
+    code: void 0
+  };
+}
+function applyExtendLengthUnitsPatchV4(rootDir, options) {
+  if (!options.enabled) {
+    return { files: [], changed: false };
+  }
+  const opts = { ...options };
+  const distDir = path3.resolve(rootDir, "dist");
+  if (!fs3.existsSync(distDir)) {
+    return { files: [], changed: false };
+  }
+  const entries = fs3.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 = path3.join(distDir, chunkName);
+    const code = fs3.readFileSync(file, "utf8");
+    const match = pattern.exec(code);
+    if (!match) {
+      return null;
+    }
+    return {
+      file,
+      code,
+      match,
+      hasPatched: false
+    };
+  }).filter((candidate) => candidate !== null);
+  for (const item of candidates) {
+    const { code, file, match } = item;
+    const ast = parse(match[0], { sourceType: "unambiguous" });
+    traverse(ast, {
+      ArrayExpression(path11) {
+        for (const unit of opts.units) {
+          if (path11.node.elements.some((element) => t3.isStringLiteral(element) && element.value === unit)) {
+            item.hasPatched = true;
+            return;
+          }
+          path11.node.elements.push(t3.stringLiteral(unit));
+        }
+      }
+    });
+    if (item.hasPatched) {
+      continue;
+    }
+    const { code: replacement } = generate(ast, { minified: true });
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    item.code = spliceChangesIntoString(code, [
+      {
+        start,
+        end,
+        replacement: replacement.endsWith(";") ? replacement.slice(0, -1) : replacement
+      }
+    ]);
+    if (opts.overwrite) {
+      fs3.writeFileSync(file, item.code, "utf8");
+    }
+  }
+  if (candidates.some((file) => !file.hasPatched)) {
+    logger_default.success("Patched Tailwind CSS length unit list (v4).");
+  }
+  return {
+    changed: candidates.some((file) => !file.hasPatched),
+    files: candidates
+  };
+}
+
+// src/patching/status.ts
+function inspectLengthUnitsArray(content, variableName, units) {
+  const ast = parse(content);
+  let found = false;
+  let missingUnits = [];
+  traverse(ast, {
+    Identifier(path11) {
+      if (path11.node.name === variableName && t4.isVariableDeclarator(path11.parent) && t4.isArrayExpression(path11.parent.init)) {
+        found = true;
+        const existing = new Set(
+          path11.parent.init.elements.map((element) => t4.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
+        );
+        missingUnits = units.filter((unit) => !existing.has(unit));
+        path11.stop();
+      }
+    }
+  });
+  return {
+    found,
+    missingUnits
+  };
+}
+function checkExposeContextPatch(context) {
+  const { packageInfo, options, majorVersion } = context;
+  const refProperty = options.features.exposeContext.refProperty;
+  if (!options.features.exposeContext.enabled) {
+    return {
+      name: "exposeContext",
+      status: "skipped",
+      reason: "exposeContext feature disabled",
+      files: []
+    };
+  }
+  if (majorVersion === 4) {
+    return {
+      name: "exposeContext",
+      status: "unsupported",
+      reason: "Context export patch is only required for Tailwind v2/v3",
+      files: []
+    };
+  }
+  const checks = [];
+  function inspectFile(relative, transform) {
+    const filePath = path4.resolve(packageInfo.rootPath, relative);
+    if (!fs4.existsSync(filePath)) {
+      checks.push({ relative, exists: false, patched: false });
+      return;
+    }
+    const content = fs4.readFileSync(filePath, "utf8");
+    const { hasPatched } = transform(content);
+    checks.push({
+      relative,
+      exists: true,
+      patched: hasPatched
+    });
+  }
+  if (majorVersion === 3) {
+    inspectFile("lib/processTailwindFeatures.js", transformProcessTailwindFeaturesReturnContext);
+    const pluginCandidates = ["lib/plugin.js", "lib/index.js"];
+    const pluginRelative = pluginCandidates.find((candidate) => fs4.existsSync(path4.resolve(packageInfo.rootPath, candidate)));
+    if (pluginRelative) {
+      inspectFile(pluginRelative, (content) => transformPostcssPlugin(content, { refProperty }));
+    } else {
+      checks.push({ relative: "lib/plugin.js", exists: false, patched: false });
+    }
+  } else {
+    inspectFile("lib/jit/processTailwindFeatures.js", transformProcessTailwindFeaturesReturnContextV2);
+    inspectFile("lib/jit/index.js", (content) => transformPostcssPluginV2(content, { refProperty }));
+  }
+  const files = checks.filter((check) => check.exists).map((check) => check.relative);
+  const missingFiles = checks.filter((check) => !check.exists);
+  const unpatchedFiles = checks.filter((check) => check.exists && !check.patched);
+  const reasons = [];
+  if (missingFiles.length) {
+    reasons.push(`missing files: ${missingFiles.map((item) => item.relative).join(", ")}`);
+  }
+  if (unpatchedFiles.length) {
+    reasons.push(`unpatched files: ${unpatchedFiles.map((item) => item.relative).join(", ")}`);
+  }
+  return {
+    name: "exposeContext",
+    status: reasons.length ? "not-applied" : "applied",
+    reason: reasons.length ? reasons.join("; ") : void 0,
+    files
+  };
+}
+function checkExtendLengthUnitsV3(rootDir, options) {
+  const lengthUnitsFilePath = options.lengthUnitsFilePath ?? "lib/util/dataTypes.js";
+  const variableName = options.variableName ?? "lengthUnits";
+  const target = path4.resolve(rootDir, lengthUnitsFilePath);
+  const files = fs4.existsSync(target) ? [path4.relative(rootDir, target)] : [];
+  if (!fs4.existsSync(target)) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: `missing ${lengthUnitsFilePath}`,
+      files
+    };
+  }
+  const content = fs4.readFileSync(target, "utf8");
+  const { found, missingUnits } = inspectLengthUnitsArray(content, variableName, options.units);
+  if (!found) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: `could not locate ${variableName} array in ${lengthUnitsFilePath}`,
+      files
+    };
+  }
+  if (missingUnits.length) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: `missing units: ${missingUnits.join(", ")}`,
+      files
+    };
+  }
+  return {
+    name: "extendLengthUnits",
+    status: "applied",
+    files
+  };
+}
+function checkExtendLengthUnitsV4(rootDir, options) {
+  const distDir = path4.resolve(rootDir, "dist");
+  if (!fs4.existsSync(distDir)) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: "dist directory not found for Tailwind v4 package",
+      files: []
+    };
+  }
+  const result = applyExtendLengthUnitsPatchV4(rootDir, {
+    ...options,
+    enabled: true,
+    overwrite: false
+  });
+  if (result.files.length === 0) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: "no bundle chunks matched the length unit pattern",
+      files: []
+    };
+  }
+  const files = result.files.map((file) => path4.relative(rootDir, file.file));
+  const pending = result.files.filter((file) => !file.hasPatched);
+  if (pending.length) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: `missing units in ${pending.length} bundle${pending.length > 1 ? "s" : ""}`,
+      files: pending.map((file) => path4.relative(rootDir, file.file))
+    };
+  }
+  return {
+    name: "extendLengthUnits",
+    status: "applied",
+    files
+  };
+}
+function checkExtendLengthUnitsPatch(context) {
+  const { packageInfo, options, majorVersion } = context;
+  if (!options.features.extendLengthUnits) {
+    return {
+      name: "extendLengthUnits",
+      status: "skipped",
+      reason: "extendLengthUnits feature disabled",
+      files: []
+    };
+  }
+  if (majorVersion === 2) {
+    return {
+      name: "extendLengthUnits",
+      status: "unsupported",
+      reason: "length unit extension is only applied for Tailwind v3/v4",
+      files: []
+    };
+  }
+  if (majorVersion === 3) {
+    return checkExtendLengthUnitsV3(packageInfo.rootPath, options.features.extendLengthUnits);
+  }
+  return checkExtendLengthUnitsV4(packageInfo.rootPath, options.features.extendLengthUnits);
+}
+function getPatchStatusReport(context) {
+  return {
+    package: {
+      name: context.packageInfo.name ?? context.packageInfo.packageJson?.name,
+      version: context.packageInfo.version,
+      root: context.packageInfo.rootPath
+    },
+    majorVersion: context.majorVersion,
+    entries: [
+      checkExposeContextPatch(context),
+      checkExtendLengthUnitsPatch(context)
+    ]
+  };
+}
+
+// src/runtime/class-collector.ts
+import process4 from "process";
+import fs5 from "fs-extra";
+import path5 from "pathe";
+function collectClassesFromContexts(contexts, filter) {
+  const set = /* @__PURE__ */ new Set();
+  for (const context of contexts) {
+    if (!isObject(context) || !context.classCache) {
+      continue;
+    }
+    for (const key of context.classCache.keys()) {
+      const className = key.toString();
+      if (filter(className)) {
+        set.add(className);
+      }
+    }
+  }
+  return set;
+}
+async function collectClassesFromTailwindV4(options) {
+  const set = /* @__PURE__ */ new Set();
+  const v4Options = options.tailwind.v4;
+  if (!v4Options) {
+    return set;
+  }
+  const toAbsolute = (value) => {
+    if (!value) {
+      return void 0;
+    }
+    return path5.isAbsolute(value) ? value : path5.resolve(options.projectRoot, value);
+  };
+  const resolvedConfiguredBase = toAbsolute(v4Options.configuredBase);
+  const resolvedDefaultBase = toAbsolute(v4Options.base) ?? process4.cwd();
+  const resolveSources = (base) => {
+    if (!v4Options.sources?.length) {
+      return void 0;
+    }
+    return v4Options.sources.map((source) => ({
+      base: source.base ?? base,
+      pattern: source.pattern,
+      negated: source.negated
+    }));
+  };
+  if (v4Options.cssEntries.length > 0) {
+    for (const entry of v4Options.cssEntries) {
+      const filePath = path5.isAbsolute(entry) ? entry : path5.resolve(options.projectRoot, entry);
+      if (!await fs5.pathExists(filePath)) {
+        continue;
+      }
+      const css = await fs5.readFile(filePath, "utf8");
+      const entryDir = path5.dirname(filePath);
+      const baseForEntry = resolvedConfiguredBase ?? entryDir;
+      const sources = resolveSources(baseForEntry);
+      const candidates = await extractValidCandidates({
+        cwd: options.projectRoot,
+        base: baseForEntry,
+        css,
+        sources
+      });
+      for (const candidate of candidates) {
+        if (options.filter(candidate)) {
+          set.add(candidate);
+        }
+      }
+    }
+  } else {
+    const baseForCss = resolvedConfiguredBase ?? resolvedDefaultBase;
+    const sources = resolveSources(baseForCss);
+    const candidates = await extractValidCandidates({
+      cwd: options.projectRoot,
+      base: baseForCss,
+      css: v4Options.css,
+      sources
+    });
+    for (const candidate of candidates) {
+      if (options.filter(candidate)) {
+        set.add(candidate);
+      }
+    }
+  }
+  return set;
+}
+
+// src/runtime/context-registry.ts
+import { createRequire } from "module";
+import fs6 from "fs-extra";
+import path6 from "pathe";
+var require2 = createRequire(import.meta.url);
+function resolveRuntimeEntry(packageInfo, majorVersion) {
+  const root = packageInfo.rootPath;
+  if (majorVersion === 2) {
+    const jitIndex = path6.join(root, "lib/jit/index.js");
+    if (fs6.existsSync(jitIndex)) {
+      return jitIndex;
+    }
+  } else if (majorVersion === 3) {
+    const plugin = path6.join(root, "lib/plugin.js");
+    const index = path6.join(root, "lib/index.js");
+    if (fs6.existsSync(plugin)) {
+      return plugin;
+    }
+    if (fs6.existsSync(index)) {
+      return index;
+    }
+  }
+  return void 0;
+}
+function loadRuntimeContexts(packageInfo, majorVersion, refProperty) {
+  if (majorVersion === 4) {
+    return [];
+  }
+  const entry = resolveRuntimeEntry(packageInfo, majorVersion);
+  if (!entry) {
+    return [];
+  }
+  const moduleExports = require2(entry);
+  if (!moduleExports) {
+    return [];
+  }
+  const ref = moduleExports[refProperty];
+  if (!ref) {
+    return [];
+  }
+  if (Array.isArray(ref)) {
+    return ref;
+  }
+  if (typeof ref === "object" && Array.isArray(ref.value)) {
+    return ref.value;
+  }
+  return [];
+}
+
+// src/runtime/process-tailwindcss.ts
+import { createRequire as createRequire2 } from "module";
+import path7 from "pathe";
+import postcss from "postcss";
+import { loadConfig } from "tailwindcss-config";
+var require3 = createRequire2(import.meta.url);
+async function resolveConfigPath(options) {
+  if (options.config && path7.isAbsolute(options.config)) {
+    return options.config;
+  }
+  const result = await loadConfig({ cwd: options.cwd });
+  if (!result) {
+    throw new Error(`Unable to locate Tailwind CSS config from ${options.cwd}`);
+  }
+  return result.filepath;
+}
+async function runTailwindBuild(options) {
+  const configPath = await resolveConfigPath(options);
+  const pluginName = options.postcssPlugin ?? (options.majorVersion === 4 ? "@tailwindcss/postcss" : "tailwindcss");
+  if (options.majorVersion === 4) {
+    return postcss([
+      require3(pluginName)({
+        config: configPath
+      })
+    ]).process("@import 'tailwindcss';", {
+      from: void 0
+    });
+  }
+  return postcss([
+    require3(pluginName)({
+      config: configPath
+    })
+  ]).process("@tailwind base;@tailwind components;@tailwind utilities;", {
+    from: void 0
+  });
+}
+
+// src/api/tailwindcss-patcher.ts
+import process5 from "process";
+import fs8 from "fs-extra";
+import { getPackageInfoSync } from "local-pkg";
+import path9 from "pathe";
+import { coerce } from "semver";
+
+// src/options/legacy.ts
+function normalizeLegacyFeatures(patch) {
+  const apply = patch?.applyPatches;
+  const extend = apply?.extendLengthUnits;
+  let extendOption = false;
+  if (extend && typeof extend === "object") {
+    extendOption = {
+      ...extend,
+      enabled: true
+    };
+  } else if (extend === true) {
+    extendOption = {
+      enabled: true,
+      units: ["rpx"],
+      overwrite: patch?.overwrite
+    };
+  }
+  return {
+    exposeContext: apply?.exportContext ?? true,
+    extendLengthUnits: extendOption
+  };
+}
+function fromLegacyOptions(options) {
+  if (!options) {
+    return {};
+  }
+  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;
+  return {
+    cwd: patch?.cwd,
+    overwrite: patch?.overwrite,
+    filter: patch?.filter,
+    cache: typeof options.cache === "boolean" ? options.cache : options.cache ? {
+      ...options.cache,
+      enabled: options.cache.enabled ?? true
+    } : void 0,
+    output: output ? {
+      file: output.filename,
+      pretty: output.loose ? 2 : false,
+      removeUniversalSelector: output.removeUniversalSelector
+    } : void 0,
+    tailwind: {
+      packageName: patch?.packageName,
+      version: tailwindVersion,
+      resolve: patch?.resolve,
+      config: tailwindConfigPath,
+      cwd: tailwindCwd,
+      v2: tailwindV2,
+      v3: tailwindV3,
+      v4: tailwindV4
+    },
+    features: {
+      exposeContext: features.exposeContext,
+      extendLengthUnits: features.extendLengthUnits
+    }
+  };
+}
+function fromUnifiedConfig(registry) {
+  if (!registry) {
+    return {};
+  }
+  const tailwind = registry.tailwind;
+  const output = registry.output;
+  const pretty = (() => {
+    if (output?.pretty === void 0) {
+      return void 0;
+    }
+    if (typeof output.pretty === "boolean") {
+      return output.pretty ? 2 : false;
+    }
+    return output.pretty;
+  })();
   return {
-    code: hasPatched ? content : generate(ast).code,
-    hasPatched
+    output: output ? {
+      file: output.file,
+      pretty,
+      removeUniversalSelector: output.stripUniversalSelector
+    } : void 0,
+    tailwind: tailwind ? {
+      version: tailwind.version,
+      packageName: tailwind.package,
+      resolve: tailwind.resolve,
+      config: tailwind.config,
+      cwd: tailwind.cwd,
+      v2: tailwind.legacy,
+      v3: tailwind.classic,
+      v4: tailwind.next
+    } : void 0
   };
 }
 
 // src/patching/operations/export-context/index.ts
+import fs7 from "fs-extra";
+import path8 from "pathe";
 function writeFileIfRequired(filePath, code, overwrite, successMessage) {
   if (!overwrite) {
     return;
   }
-  fs5.writeFileSync(filePath, code, {
+  fs7.writeFileSync(filePath, code, {
     encoding: "utf8"
   });
   logger_default.success(successMessage);
@@ -1186,9 +1528,9 @@ function applyExposeContextPatch(params) {
   };
   if (majorVersion === 3) {
     const processFileRelative = "lib/processTailwindFeatures.js";
-    const processFilePath = path6.resolve(rootDir, processFileRelative);
-    if (fs5.existsSync(processFilePath)) {
-      const content = fs5.readFileSync(processFilePath, "utf8");
+    const processFilePath = path8.resolve(rootDir, processFileRelative);
+    if (fs7.existsSync(processFilePath)) {
+      const content = fs7.readFileSync(processFilePath, "utf8");
       const { code, hasPatched } = transformProcessTailwindFeaturesReturnContext(content);
       result.files[processFileRelative] = code;
       if (!hasPatched) {
@@ -1202,10 +1544,10 @@ function applyExposeContextPatch(params) {
       }
     }
     const pluginCandidates = ["lib/plugin.js", "lib/index.js"];
-    const pluginRelative = pluginCandidates.find((candidate) => fs5.existsSync(path6.resolve(rootDir, candidate)));
+    const pluginRelative = pluginCandidates.find((candidate) => fs7.existsSync(path8.resolve(rootDir, candidate)));
     if (pluginRelative) {
-      const pluginPath = path6.resolve(rootDir, pluginRelative);
-      const content = fs5.readFileSync(pluginPath, "utf8");
+      const pluginPath = path8.resolve(rootDir, pluginRelative);
+      const content = fs7.readFileSync(pluginPath, "utf8");
       const { code, hasPatched } = transformPostcssPlugin(content, { refProperty });
       result.files[pluginRelative] = code;
       if (!hasPatched) {
@@ -1220,9 +1562,9 @@ function applyExposeContextPatch(params) {
     }
   } else if (majorVersion === 2) {
     const processFileRelative = "lib/jit/processTailwindFeatures.js";
-    const processFilePath = path6.resolve(rootDir, processFileRelative);
-    if (fs5.existsSync(processFilePath)) {
-      const content = fs5.readFileSync(processFilePath, "utf8");
+    const processFilePath = path8.resolve(rootDir, processFileRelative);
+    if (fs7.existsSync(processFilePath)) {
+      const content = fs7.readFileSync(processFilePath, "utf8");
       const { code, hasPatched } = transformProcessTailwindFeaturesReturnContextV2(content);
       result.files[processFileRelative] = code;
       if (!hasPatched) {
@@ -1236,9 +1578,9 @@ function applyExposeContextPatch(params) {
       }
     }
     const pluginRelative = "lib/jit/index.js";
-    const pluginPath = path6.resolve(rootDir, pluginRelative);
-    if (fs5.existsSync(pluginPath)) {
-      const content = fs5.readFileSync(pluginPath, "utf8");
+    const pluginPath = path8.resolve(rootDir, pluginRelative);
+    if (fs7.existsSync(pluginPath)) {
+      const content = fs7.readFileSync(pluginPath, "utf8");
       const { code, hasPatched } = transformPostcssPluginV2(content, { refProperty });
       result.files[pluginRelative] = code;
       if (!hasPatched) {
@@ -1255,147 +1597,6 @@ function applyExposeContextPatch(params) {
   return result;
 }
 
-// src/patching/operations/extend-length-units.ts
-import * as t3 from "@babel/types";
-import fs6 from "fs-extra";
-import path7 from "pathe";
-function updateLengthUnitsArray(content, options) {
-  const { variableName = "lengthUnits", units } = options;
-  const ast = parse(content);
-  let arrayRef;
-  let changed = false;
-  traverse(ast, {
-    Identifier(path10) {
-      if (path10.node.name === variableName && t3.isVariableDeclarator(path10.parent) && t3.isArrayExpression(path10.parent.init)) {
-        arrayRef = path10.parent.init;
-        const existing = new Set(
-          path10.parent.init.elements.map((element) => t3.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
-        );
-        for (const unit of units) {
-          if (!existing.has(unit)) {
-            path10.parent.init.elements = path10.parent.init.elements.map((element) => {
-              if (t3.isStringLiteral(element)) {
-                return t3.stringLiteral(element.value);
-              }
-              return element;
-            });
-            path10.parent.init.elements.push(t3.stringLiteral(unit));
-            changed = true;
-          }
-        }
-      }
-    }
-  });
-  return {
-    arrayRef,
-    changed
-  };
-}
-function applyExtendLengthUnitsPatchV3(rootDir, options) {
-  if (!options.enabled) {
-    return { changed: false, code: void 0 };
-  }
-  const opts = {
-    ...options,
-    lengthUnitsFilePath: options.lengthUnitsFilePath ?? "lib/util/dataTypes.js",
-    variableName: options.variableName ?? "lengthUnits"
-  };
-  const dataTypesFilePath = path7.resolve(rootDir, opts.lengthUnitsFilePath);
-  const exists = fs6.existsSync(dataTypesFilePath);
-  if (!exists) {
-    return { changed: false, code: void 0 };
-  }
-  const content = fs6.readFileSync(dataTypesFilePath, "utf8");
-  const { arrayRef, changed } = updateLengthUnitsArray(content, opts);
-  if (!arrayRef || !changed) {
-    return { changed: false, code: void 0 };
-  }
-  const { code } = generate(arrayRef, {
-    jsescOption: { quotes: "single" }
-  });
-  if (arrayRef.start != null && arrayRef.end != null) {
-    const nextCode = `${content.slice(0, arrayRef.start)}${code}${content.slice(arrayRef.end)}`;
-    if (opts.overwrite) {
-      const target = opts.destPath ? path7.resolve(opts.destPath) : dataTypesFilePath;
-      fs6.writeFileSync(target, nextCode, "utf8");
-      logger_default.success("Patched Tailwind CSS length unit list (v3).");
-    }
-    return {
-      changed: true,
-      code: nextCode
-    };
-  }
-  return {
-    changed: false,
-    code: void 0
-  };
-}
-function applyExtendLengthUnitsPatchV4(rootDir, options) {
-  if (!options.enabled) {
-    return { files: [], changed: false };
-  }
-  const opts = { ...options };
-  const distDir = path7.resolve(rootDir, "dist");
-  if (!fs6.existsSync(distDir)) {
-    return { files: [], changed: false };
-  }
-  const entries = fs6.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 = path7.join(distDir, chunkName);
-    const code = fs6.readFileSync(file, "utf8");
-    const match = pattern.exec(code);
-    if (!match) {
-      return null;
-    }
-    return {
-      file,
-      code,
-      match,
-      hasPatched: false
-    };
-  }).filter((candidate) => candidate !== null);
-  for (const item of candidates) {
-    const { code, file, match } = item;
-    const ast = parse(match[0], { sourceType: "unambiguous" });
-    traverse(ast, {
-      ArrayExpression(path10) {
-        for (const unit of opts.units) {
-          if (path10.node.elements.some((element) => t3.isStringLiteral(element) && element.value === unit)) {
-            item.hasPatched = true;
-            return;
-          }
-          path10.node.elements.push(t3.stringLiteral(unit));
-        }
-      }
-    });
-    if (item.hasPatched) {
-      continue;
-    }
-    const { code: replacement } = generate(ast, { minified: true });
-    const start = match.index ?? 0;
-    const end = start + match[0].length;
-    item.code = spliceChangesIntoString(code, [
-      {
-        start,
-        end,
-        replacement: replacement.endsWith(";") ? replacement.slice(0, -1) : replacement
-      }
-    ]);
-    if (opts.overwrite) {
-      fs6.writeFileSync(file, item.code, "utf8");
-    }
-  }
-  if (candidates.some((file) => !file.hasPatched)) {
-    logger_default.success("Patched Tailwind CSS length unit list (v4).");
-  }
-  return {
-    changed: candidates.some((file) => !file.hasPatched),
-    files: candidates
-  };
-}
-
 // src/patching/patch-runner.ts
 function applyTailwindPatches(context) {
   const { packageInfo, options, majorVersion } = context;
@@ -1494,6 +1695,13 @@ var TailwindcssPatcher = class {
       majorVersion: this.majorVersion
     });
   }
+  async getPatchStatus() {
+    return getPatchStatusReport({
+      packageInfo: this.packageInfo,
+      options: this.options,
+      majorVersion: this.majorVersion
+    });
+  }
   getContexts() {
     return loadRuntimeContexts(
       this.packageInfo,
@@ -1585,13 +1793,13 @@ var TailwindcssPatcher = class {
     if (!shouldWrite || !this.options.output.file) {
       return result;
     }
-    const target = path8.resolve(this.options.output.file);
-    await fs7.ensureDir(path8.dirname(target));
+    const target = path9.resolve(this.options.output.file);
+    await fs8.ensureDir(path9.dirname(target));
     if (this.options.output.format === "json") {
       const spaces = typeof this.options.output.pretty === "number" ? this.options.output.pretty : void 0;
-      await fs7.writeJSON(target, classList, { spaces });
+      await fs8.writeJSON(target, classList, { spaces });
     } else {
-      await fs7.writeFile(target, `${classList.join("\n")}
+      await fs8.writeFile(target, `${classList.join("\n")}
 `, "utf8");
     }
     logger_default.success(`Tailwind CSS class list saved to ${target.replace(process5.cwd(), ".")}`);
@@ -1716,9 +1924,9 @@ var acceptChars = [..."abcdefghijklmnopqrstuvwxyz"];
 
 // src/cli/commands.ts
 import cac from "cac";
-import fs8 from "fs-extra";
-import path9 from "pathe";
-var tailwindcssPatchCommands = ["install", "extract", "tokens", "init"];
+import fs9 from "fs-extra";
+import path10 from "pathe";
+var tailwindcssPatchCommands = ["install", "extract", "tokens", "init", "status"];
 var TOKEN_FORMATS = ["json", "lines", "grouped-json"];
 var DEFAULT_TOKEN_REPORT = ".tw-patch/tw-token-report.json";
 function formatTokenLine(entry) {
@@ -1744,7 +1952,7 @@ function resolveCwd(rawCwd) {
   if (!rawCwd) {
     return process6.cwd();
   }
-  return path9.resolve(rawCwd);
+  return path10.resolve(rawCwd);
 }
 function createDefaultRunner(factory) {
   let promise;
@@ -1846,6 +2054,13 @@ function buildDefaultCommandDefinitions() {
     init: {
       description: "Generate a tailwindcss-patch config file",
       optionDefs: [createCwdOptionDefinition()]
+    },
+    status: {
+      description: "Check which Tailwind patches are applied",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--json", description: "Print a JSON report of patch status" }
+      ]
     }
   };
 }
@@ -1949,15 +2164,15 @@ async function tokensCommandDefaultHandler(ctx) {
   const grouped = format === "grouped-json" ? buildGrouped() : null;
   const resolveGrouped = () => grouped ?? buildGrouped();
   if (shouldWrite) {
-    const target = path9.resolve(targetFile);
-    await fs8.ensureDir(path9.dirname(target));
+    const target = path10.resolve(targetFile);
+    await fs9.ensureDir(path10.dirname(target));
     if (format === "json") {
-      await fs8.writeJSON(target, report, { spaces: 2 });
+      await fs9.writeJSON(target, report, { spaces: 2 });
     } else if (format === "grouped-json") {
-      await fs8.writeJSON(target, resolveGrouped(), { spaces: 2 });
+      await fs9.writeJSON(target, resolveGrouped(), { spaces: 2 });
     } else {
       const lines = report.entries.map(formatTokenLine);
-      await fs8.writeFile(target, `${lines.join("\n")}
+      await fs9.writeFile(target, `${lines.join("\n")}
 `, "utf8");
     }
     logger_default.success(`Collected ${report.entries.length} tokens (${format}) \u2192 ${target.replace(process6.cwd(), ".")}`);
@@ -2002,6 +2217,46 @@ async function initCommandDefaultHandler(ctx) {
   await initConfig(ctx.cwd);
   logger_default.success(`\u2728 ${CONFIG_NAME}.config.ts initialized!`);
 }
+function formatFilesHint(entry) {
+  if (!entry.files.length) {
+    return "";
+  }
+  return ` (${entry.files.join(", ")})`;
+}
+async function statusCommandDefaultHandler(ctx) {
+  const patcher = await ctx.createPatcher();
+  const report = await patcher.getPatchStatus();
+  if (ctx.args.json) {
+    logger_default.log(JSON.stringify(report, null, 2));
+    return report;
+  }
+  const applied = report.entries.filter((entry) => entry.status === "applied");
+  const pending = report.entries.filter((entry) => entry.status === "not-applied");
+  const skipped = report.entries.filter((entry) => entry.status === "skipped" || entry.status === "unsupported");
+  const packageLabel = `${report.package.name ?? "tailwindcss"}@${report.package.version ?? "unknown"}`;
+  logger_default.info(`Patch status for ${packageLabel} (v${report.majorVersion})`);
+  if (applied.length) {
+    logger_default.success("Applied:");
+    applied.forEach((entry) => logger_default.success(`  \u2022 ${entry.name}${formatFilesHint(entry)}`));
+  }
+  if (pending.length) {
+    logger_default.warn("Needs attention:");
+    pending.forEach((entry) => {
+      const details = entry.reason ? ` \u2013 ${entry.reason}` : "";
+      logger_default.warn(`  \u2022 ${entry.name}${formatFilesHint(entry)}${details}`);
+    });
+  } else {
+    logger_default.success("All applicable patches are applied.");
+  }
+  if (skipped.length) {
+    logger_default.info("Skipped:");
+    skipped.forEach((entry) => {
+      const details = entry.reason ? ` \u2013 ${entry.reason}` : "";
+      logger_default.info(`  \u2022 ${entry.name}${details}`);
+    });
+  }
+  return report;
+}
 function mountTailwindcssPatchCommands(cli, options = {}) {
   const prefix = options.commandPrefix ?? "";
   const selectedCommands = options.commands ?? tailwindcssPatchCommands;
@@ -2070,6 +2325,22 @@ function mountTailwindcssPatchCommands(cli, options = {}) {
         );
       });
       metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    status: () => {
+      const metadata = resolveCommandMetadata("status", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "status",
+          args,
+          options.commandHandlers?.status,
+          statusCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
     }
   };
   for (const name of selectedCommands) {
@@ -2095,6 +2366,7 @@ export {
   extractProjectCandidatesWithPositions,
   groupTokensByFile,
   normalizeOptions,
+  getPatchStatusReport,
   collectClassesFromContexts,
   collectClassesFromTailwindV4,
   loadRuntimeContexts,