tailwindcss-patch 8.3.0 → 8.4.0

package/dist/{chunk-SN7IO2IS.mjs → chunk-SHYTHM5B.mjs}

@@ -1656,156 +1656,143 @@ var acceptChars = [..."abcdefghijklmnopqrstuvwxyz"];
 import cac from "cac";
 import fs8 from "fs-extra";
 import path9 from "pathe";
-var tailwindcssPatchCommands = [
-  "install",
-  "extract",
-  "tokens",
-  "init"
-];
-function createTailwindcssPatchCli(options = {}) {
-  const cli = cac(options.name ?? "tw-patch");
-  mountTailwindcssPatchCommands(cli, options.mountOptions);
-  return cli;
+var tailwindcssPatchCommands = ["install", "extract", "tokens", "init"];
+var TOKEN_FORMATS = ["json", "lines", "grouped-json"];
+var DEFAULT_TOKEN_REPORT = ".tw-patch/tw-token-report.json";
+function formatTokenLine(entry) {
+  return `${entry.relativeFile}:${entry.line}:${entry.column} ${entry.rawCandidate} (${entry.start}-${entry.end})`;
 }
-function mountTailwindcssPatchCommands(cli, options = {}) {
-  const prefix = options.commandPrefix ?? "";
-  const selectedCommands = options.commands ?? tailwindcssPatchCommands;
-  const TOKEN_FORMATS = ["json", "lines", "grouped-json"];
-  const registrars = {
-    install() {
-      const { name, aliases } = resolveCommandNames("install", options, prefix);
-      const command = cli.command(name, "Apply Tailwind CSS runtime patches").option("--cwd <dir>", "Working directory", { default: process5.cwd() }).action(async (args) => {
-        const patchOptions = await loadPatchOptions(args.cwd);
-        const patcher = new TailwindcssPatcher(patchOptions);
-        await patcher.patch();
-        logger_default.success("Tailwind CSS runtime patched successfully.");
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    },
-    extract() {
-      const { name, aliases } = resolveCommandNames("extract", options, prefix);
-      const command = cli.command(name, "Collect generated class names into a cache file").option("--cwd <dir>", "Working directory", { default: process5.cwd() }).option("--output <file>", "Override output file path").option("--format <format>", "Output format (json|lines)").option("--css <file>", "Tailwind CSS entry CSS when using v4").option("--no-write", "Skip writing to disk").action(async (args) => {
-        const overrides = {};
-        if (args.output || args.format) {
-          overrides.output = {
-            file: args.output,
-            format: args.format
-          };
-        }
-        if (args.css) {
-          overrides.tailwind = {
-            v4: {
-              cssEntries: [args.css]
-            }
-          };
-        }
-        const patchOptions = await loadPatchOptions(args.cwd, overrides);
-        const patcher = new TailwindcssPatcher(patchOptions);
-        const result = await patcher.extract({ write: args.write });
-        if (result.filename) {
-          logger_default.success(`Collected ${result.classList.length} classes \u2192 ${result.filename}`);
-        } else {
-          logger_default.success(`Collected ${result.classList.length} classes.`);
-        }
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    },
-    tokens() {
-      const { name, aliases } = resolveCommandNames("tokens", options, prefix);
-      const command = cli.command(name, "Extract Tailwind tokens with file/position metadata").option("--cwd <dir>", "Working directory", { default: process5.cwd() }).option("--output <file>", "Override output file path", { default: ".tw-patch/tw-token-report.json" }).option("--format <format>", "Output format (json|lines|grouped-json)", { default: "json" }).option("--group-key <key>", "Grouping key for grouped-json output (relative|absolute)", { default: "relative" }).option("--no-write", "Skip writing to disk").action(async (args) => {
-        const patchOptions = await loadPatchOptions(args.cwd);
-        const patcher = new TailwindcssPatcher(patchOptions);
-        const report = await patcher.collectContentTokens();
-        const shouldWrite = args.write ?? true;
-        let format = args.format ?? "json";
-        if (!TOKEN_FORMATS.includes(format)) {
-          format = "json";
-        }
-        const targetFile = args.output ?? ".tw-patch/tw-token-report.json";
-        const groupKey = args.groupKey === "absolute" ? "absolute" : "relative";
-        const buildGrouped = () => groupTokensByFile(report, {
-          key: groupKey,
-          stripAbsolutePaths: groupKey !== "absolute"
-        });
-        const grouped = format === "grouped-json" ? buildGrouped() : null;
-        const resolveGrouped = () => grouped ?? buildGrouped();
-        if (shouldWrite) {
-          const target = path9.resolve(targetFile);
-          await fs8.ensureDir(path9.dirname(target));
-          if (format === "json") {
-            await fs8.writeJSON(target, report, { spaces: 2 });
-          } else if (format === "grouped-json") {
-            await fs8.writeJSON(target, resolveGrouped(), { spaces: 2 });
-          } else {
-            const lines = report.entries.map(formatTokenLine);
-            await fs8.writeFile(target, `${lines.join("\n")}
-`, "utf8");
-          }
-          logger_default.success(
-            `Collected ${report.entries.length} tokens (${format}) \u2192 ${target.replace(process5.cwd(), ".")}`
-          );
-        } else {
-          logger_default.success(`Collected ${report.entries.length} tokens from ${report.filesScanned} files.`);
-          if (format === "lines") {
-            const preview = report.entries.slice(0, 5).map(formatTokenLine).join("\n");
-            if (preview) {
-              logger_default.log("");
-              logger_default.info(preview);
-              if (report.entries.length > 5) {
-                logger_default.info(`\u2026and ${report.entries.length - 5} more.`);
-              }
-            }
-          } else if (format === "grouped-json") {
-            const map = resolveGrouped();
-            const { preview, moreFiles } = formatGroupedPreview(map);
-            if (preview) {
-              logger_default.log("");
-              logger_default.info(preview);
-              if (moreFiles > 0) {
-                logger_default.info(`\u2026and ${moreFiles} more files.`);
-              }
-            }
-          } else {
-            const previewEntries = report.entries.slice(0, 3);
-            if (previewEntries.length) {
-              logger_default.log("");
-              logger_default.info(JSON.stringify(previewEntries, null, 2));
-            }
-          }
-        }
-        if (report.skippedFiles.length) {
-          logger_default.warn("Skipped files:");
-          for (const skipped of report.skippedFiles) {
-            logger_default.warn(`  \u2022 ${skipped.file} (${skipped.reason})`);
-          }
-        }
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    },
-    init() {
-      const { name, aliases } = resolveCommandNames("init", options, prefix);
-      const command = cli.command(name, "Generate a tailwindcss-patch config file").option("--cwd <dir>", "Working directory", { default: process5.cwd() }).action(async (args) => {
-        await initConfig(args.cwd);
-        logger_default.success(`\u2728 ${CONFIG_NAME}.config.ts initialized!`);
-      });
-      aliases.forEach((alias) => command.alias(alias));
-    }
+function formatGroupedPreview(map, limit = 3) {
+  const files = Object.keys(map);
+  if (!files.length) {
+    return { preview: "", moreFiles: 0 };
+  }
+  const lines = files.slice(0, limit).map((file) => {
+    const tokens = map[file];
+    const sample = tokens.slice(0, 3).map((token) => token.rawCandidate).join(", ");
+    const suffix = tokens.length > 3 ? ", \u2026" : "";
+    return `${file}: ${tokens.length} tokens (${sample}${suffix})`;
+  });
+  return {
+    preview: lines.join("\n"),
+    moreFiles: Math.max(0, files.length - limit)
   };
-  for (const name of selectedCommands) {
-    const register = registrars[name];
-    if (register) {
-      register();
-    }
+}
+function resolveCwd(rawCwd) {
+  if (!rawCwd) {
+    return process5.cwd();
   }
-  return cli;
+  return path9.resolve(rawCwd);
 }
-async function loadPatchOptions(cwd, overrides) {
+function createDefaultRunner(factory) {
+  let promise;
+  return () => {
+    if (!promise) {
+      promise = factory();
+    }
+    return promise;
+  };
+}
+async function loadPatchOptionsForCwd(cwd, overrides) {
   const { config } = await getConfig(cwd);
   const legacyConfig = config;
   const base = config?.registry ? fromUnifiedConfig(config.registry) : legacyConfig?.patch ? fromLegacyOptions({ patch: legacyConfig.patch }) : {};
   const merged = defu(overrides ?? {}, base);
   return merged;
 }
+function createCommandContext(cli, command, commandName, args, cwd) {
+  let cachedOptions;
+  let cachedPatcher;
+  let cachedConfig;
+  const loadPatchOptionsForContext = (overrides) => {
+    if (overrides) {
+      return loadPatchOptionsForCwd(cwd, overrides);
+    }
+    if (!cachedOptions) {
+      cachedOptions = loadPatchOptionsForCwd(cwd);
+    }
+    return cachedOptions;
+  };
+  const createPatcherForContext = async (overrides) => {
+    if (overrides) {
+      const patchOptions = await loadPatchOptionsForCwd(cwd, overrides);
+      return new TailwindcssPatcher(patchOptions);
+    }
+    if (!cachedPatcher) {
+      cachedPatcher = loadPatchOptionsForContext().then((options) => new TailwindcssPatcher(options));
+    }
+    return cachedPatcher;
+  };
+  return {
+    cli,
+    command,
+    commandName,
+    args,
+    cwd,
+    logger: logger_default,
+    loadConfig: () => {
+      if (!cachedConfig) {
+        cachedConfig = getConfig(cwd);
+      }
+      return cachedConfig;
+    },
+    loadPatchOptions: loadPatchOptionsForContext,
+    createPatcher: createPatcherForContext
+  };
+}
+function createCwdOptionDefinition(description = "Working directory") {
+  return {
+    flags: "--cwd <dir>",
+    description,
+    config: { default: process5.cwd() }
+  };
+}
+function buildDefaultCommandDefinitions() {
+  return {
+    install: {
+      description: "Apply Tailwind CSS runtime patches",
+      optionDefs: [createCwdOptionDefinition()]
+    },
+    extract: {
+      description: "Collect generated class names into a cache file",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--output <file>", description: "Override output file path" },
+        { flags: "--format <format>", description: "Output format (json|lines)" },
+        { flags: "--css <file>", description: "Tailwind CSS entry CSS when using v4" },
+        { flags: "--no-write", description: "Skip writing to disk" }
+      ]
+    },
+    tokens: {
+      description: "Extract Tailwind tokens with file/position metadata",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--output <file>", description: "Override output file path", config: { default: DEFAULT_TOKEN_REPORT } },
+        {
+          flags: "--format <format>",
+          description: "Output format (json|lines|grouped-json)",
+          config: { default: "json" }
+        },
+        {
+          flags: "--group-key <key>",
+          description: "Grouping key for grouped-json output (relative|absolute)",
+          config: { default: "relative" }
+        },
+        { flags: "--no-write", description: "Skip writing to disk" }
+      ]
+    },
+    init: {
+      description: "Generate a tailwindcss-patch config file",
+      optionDefs: [createCwdOptionDefinition()]
+    }
+  };
+}
+function addPrefixIfMissing(value, prefix) {
+  if (!prefix || value.startsWith(prefix)) {
+    return value;
+  }
+  return `${prefix}${value}`;
+}
 function resolveCommandNames(command, mountOptions, prefix) {
   const override = mountOptions.commandOptions?.[command];
   const baseName = override?.name ?? command;
@@ -1813,30 +1800,228 @@ function resolveCommandNames(command, mountOptions, prefix) {
   const aliases = (override?.aliases ?? []).map((alias) => addPrefixIfMissing(alias, prefix));
   return { name, aliases };
 }
-function addPrefixIfMissing(value, prefix) {
-  if (!prefix || value.startsWith(prefix)) {
-    return value;
+function resolveOptionDefinitions(defaults, override) {
+  if (!override) {
+    return defaults;
   }
-  return `${prefix}${value}`;
+  const appendDefaults = override.appendDefaultOptions ?? true;
+  const customDefs = override.optionDefs ?? [];
+  if (!appendDefaults) {
+    return customDefs;
+  }
+  if (customDefs.length === 0) {
+    return defaults;
+  }
+  return [...defaults, ...customDefs];
 }
-function formatTokenLine(entry) {
-  return `${entry.relativeFile}:${entry.line}:${entry.column} ${entry.rawCandidate} (${entry.start}-${entry.end})`;
+function applyCommandOptions(command, optionDefs) {
+  for (const option of optionDefs) {
+    command.option(option.flags, option.description ?? "", option.config);
+  }
 }
-function formatGroupedPreview(map, limit = 3) {
-  const files = Object.keys(map);
-  if (!files.length) {
-    return { preview: "", moreFiles: 0 };
+function runWithCommandHandler(cli, command, commandName, args, handler, defaultHandler) {
+  const cwd = resolveCwd(args.cwd);
+  const context = createCommandContext(cli, command, commandName, args, cwd);
+  const runDefault = createDefaultRunner(() => defaultHandler(context));
+  if (!handler) {
+    return runDefault();
+  }
+  return handler(context, runDefault);
+}
+function resolveCommandMetadata(command, mountOptions, prefix, defaults) {
+  const names = resolveCommandNames(command, mountOptions, prefix);
+  const definition = defaults[command];
+  const override = mountOptions.commandOptions?.[command];
+  const description = override?.description ?? definition.description;
+  const optionDefs = resolveOptionDefinitions(definition.optionDefs, override);
+  return { ...names, description, optionDefs };
+}
+async function installCommandDefaultHandler(ctx) {
+  const patcher = await ctx.createPatcher();
+  await patcher.patch();
+  logger_default.success("Tailwind CSS runtime patched successfully.");
+}
+async function extractCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const overrides = {};
+  let hasOverrides = false;
+  if (args.output || args.format) {
+    overrides.output = {
+      file: args.output,
+      format: args.format
+    };
+    hasOverrides = true;
   }
-  const lines = files.slice(0, limit).map((file) => {
-    const tokens = map[file];
-    const sample = tokens.slice(0, 3).map((token) => token.rawCandidate).join(", ");
-    const suffix = tokens.length > 3 ? ", \u2026" : "";
-    return `${file}: ${tokens.length} tokens (${sample}${suffix})`;
+  if (args.css) {
+    overrides.tailwind = {
+      v4: {
+        cssEntries: [args.css]
+      }
+    };
+    hasOverrides = true;
+  }
+  const patcher = await ctx.createPatcher(hasOverrides ? overrides : void 0);
+  const result = await patcher.extract({ write: args.write });
+  if (result.filename) {
+    logger_default.success(`Collected ${result.classList.length} classes \u2192 ${result.filename}`);
+  } else {
+    logger_default.success(`Collected ${result.classList.length} classes.`);
+  }
+  return result;
+}
+async function tokensCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const patcher = await ctx.createPatcher();
+  const report = await patcher.collectContentTokens();
+  const shouldWrite = args.write ?? true;
+  let format = args.format ?? "json";
+  if (!TOKEN_FORMATS.includes(format)) {
+    format = "json";
+  }
+  const targetFile = args.output ?? DEFAULT_TOKEN_REPORT;
+  const groupKey = args.groupKey === "absolute" ? "absolute" : "relative";
+  const buildGrouped = () => groupTokensByFile(report, {
+    key: groupKey,
+    stripAbsolutePaths: groupKey !== "absolute"
   });
-  return {
-    preview: lines.join("\n"),
-    moreFiles: Math.max(0, files.length - limit)
+  const grouped = format === "grouped-json" ? buildGrouped() : null;
+  const resolveGrouped = () => grouped ?? buildGrouped();
+  if (shouldWrite) {
+    const target = path9.resolve(targetFile);
+    await fs8.ensureDir(path9.dirname(target));
+    if (format === "json") {
+      await fs8.writeJSON(target, report, { spaces: 2 });
+    } else if (format === "grouped-json") {
+      await fs8.writeJSON(target, resolveGrouped(), { spaces: 2 });
+    } else {
+      const lines = report.entries.map(formatTokenLine);
+      await fs8.writeFile(target, `${lines.join("\n")}
+`, "utf8");
+    }
+    logger_default.success(`Collected ${report.entries.length} tokens (${format}) \u2192 ${target.replace(process5.cwd(), ".")}`);
+  } else {
+    logger_default.success(`Collected ${report.entries.length} tokens from ${report.filesScanned} files.`);
+    if (format === "lines") {
+      const preview = report.entries.slice(0, 5).map(formatTokenLine).join("\n");
+      if (preview) {
+        logger_default.log("");
+        logger_default.info(preview);
+        if (report.entries.length > 5) {
+          logger_default.info(`\u2026and ${report.entries.length - 5} more.`);
+        }
+      }
+    } else if (format === "grouped-json") {
+      const map = resolveGrouped();
+      const { preview, moreFiles } = formatGroupedPreview(map);
+      if (preview) {
+        logger_default.log("");
+        logger_default.info(preview);
+        if (moreFiles > 0) {
+          logger_default.info(`\u2026and ${moreFiles} more files.`);
+        }
+      }
+    } else {
+      const previewEntries = report.entries.slice(0, 3);
+      if (previewEntries.length) {
+        logger_default.log("");
+        logger_default.info(JSON.stringify(previewEntries, null, 2));
+      }
+    }
+  }
+  if (report.skippedFiles.length) {
+    logger_default.warn("Skipped files:");
+    for (const skipped of report.skippedFiles) {
+      logger_default.warn(`  \u2022 ${skipped.file} (${skipped.reason})`);
+    }
+  }
+  return report;
+}
+async function initCommandDefaultHandler(ctx) {
+  await initConfig(ctx.cwd);
+  logger_default.success(`\u2728 ${CONFIG_NAME}.config.ts initialized!`);
+}
+function mountTailwindcssPatchCommands(cli, options = {}) {
+  const prefix = options.commandPrefix ?? "";
+  const selectedCommands = options.commands ?? tailwindcssPatchCommands;
+  const defaultDefinitions = buildDefaultCommandDefinitions();
+  const registrars = {
+    install: () => {
+      const metadata = resolveCommandMetadata("install", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "install",
+          args,
+          options.commandHandlers?.install,
+          installCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    extract: () => {
+      const metadata = resolveCommandMetadata("extract", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "extract",
+          args,
+          options.commandHandlers?.extract,
+          extractCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    tokens: () => {
+      const metadata = resolveCommandMetadata("tokens", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "tokens",
+          args,
+          options.commandHandlers?.tokens,
+          tokensCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    init: () => {
+      const metadata = resolveCommandMetadata("init", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "init",
+          args,
+          options.commandHandlers?.init,
+          initCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    }
   };
+  for (const name of selectedCommands) {
+    const register = registrars[name];
+    if (register) {
+      register();
+    }
+  }
+  return cli;
+}
+function createTailwindcssPatchCli(options = {}) {
+  const cli = cac(options.name ?? "tw-patch");
+  mountTailwindcssPatchCommands(cli, options.mountOptions);
+  return cli;
 }
 
 export {
@@ -1854,6 +2039,6 @@ export {
   runTailwindBuild,
   TailwindcssPatcher,
   tailwindcssPatchCommands,
-  createTailwindcssPatchCli,
-  mountTailwindcssPatchCommands
+  mountTailwindcssPatchCommands,
+  createTailwindcssPatchCli
 };

package/dist/cli.js

@@ -1,8 +1,8 @@
 "use strict";
 
-var _chunk7ZWFVW77js = require('./chunk-7ZWFVW77.js');
+var _chunkPF5ZTTYMjs = require('./chunk-PF5ZTTYM.js');
 
 // src/cli.ts
-var cli = _chunk7ZWFVW77js.createTailwindcssPatchCli.call(void 0, );
+var cli = _chunkPF5ZTTYMjs.createTailwindcssPatchCli.call(void 0, );
 cli.help();
 cli.parse();

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 import {
   createTailwindcssPatchCli
-} from "./chunk-SN7IO2IS.mjs";
+} from "./chunk-SHYTHM5B.mjs";
 
 // src/cli.ts
 var cli = createTailwindcssPatchCli();

package/dist/index.d.mts

@@ -2,9 +2,9 @@ import { SourceEntry } from '@tailwindcss/oxide';
 import postcss, { Node, Rule } from 'postcss';
 import { Config } from 'tailwindcss';
 import { PackageResolvingOptions, PackageInfo } from 'local-pkg';
-import { TailwindLocatorOptions, TailwindNextOptions } from '@tailwindcss-mangle/config';
+import { TailwindLocatorOptions, TailwindNextOptions, getConfig } from '@tailwindcss-mangle/config';
 export { defineConfig } from '@tailwindcss-mangle/config';
-import { CAC } from 'cac';
+import { Command, CAC } from 'cac';
 import * as consola from 'consola';
 
 type CacheStrategy = 'merge' | 'overwrite';
@@ -423,25 +423,83 @@ declare class CacheStore {
     readSync(): Set<string>;
 }
 
+declare const logger: consola.ConsolaInstance;
+
 type TailwindcssPatchCommand = 'install' | 'extract' | 'tokens' | 'init';
 declare const tailwindcssPatchCommands: TailwindcssPatchCommand[];
+type TokenOutputFormat = 'json' | 'lines' | 'grouped-json';
+type TokenGroupKey = 'relative' | 'absolute';
+type CacOptionConfig = Parameters<Command['option']>[2];
+interface TailwindcssPatchCommandOptionDefinition {
+    flags: string;
+    description?: string;
+    config?: CacOptionConfig;
+}
 interface TailwindcssPatchCommandOptions {
     name?: string;
     aliases?: string[];
+    description?: string;
+    optionDefs?: TailwindcssPatchCommandOptionDefinition[];
+    appendDefaultOptions?: boolean;
 }
+interface BaseCommandArgs {
+    cwd: string;
+}
+interface InstallCommandArgs extends BaseCommandArgs {
+}
+interface ExtractCommandArgs extends BaseCommandArgs {
+    output?: string;
+    format?: 'json' | 'lines';
+    css?: string;
+    write?: boolean;
+}
+interface TokensCommandArgs extends BaseCommandArgs {
+    output?: string;
+    format?: TokenOutputFormat;
+    groupKey?: TokenGroupKey;
+    write?: boolean;
+}
+interface InitCommandArgs extends BaseCommandArgs {
+}
+interface TailwindcssPatchCommandArgMap {
+    install: InstallCommandArgs;
+    extract: ExtractCommandArgs;
+    tokens: TokensCommandArgs;
+    init: InitCommandArgs;
+}
+interface TailwindcssPatchCommandResultMap {
+    install: void;
+    extract: ExtractResult;
+    tokens: TailwindTokenReport;
+    init: void;
+}
+interface TailwindcssPatchCommandContext<TCommand extends TailwindcssPatchCommand> {
+    cli: CAC;
+    command: Command;
+    commandName: TCommand;
+    args: TailwindcssPatchCommandArgMap[TCommand];
+    cwd: string;
+    logger: typeof logger;
+    loadConfig: () => ReturnType<typeof getConfig>;
+    loadPatchOptions: (overrides?: TailwindcssPatchOptions) => Promise<TailwindcssPatchOptions>;
+    createPatcher: (overrides?: TailwindcssPatchOptions) => Promise<TailwindcssPatcher>;
+}
+type TailwindcssPatchCommandHandler<TCommand extends TailwindcssPatchCommand> = (context: TailwindcssPatchCommandContext<TCommand>, next: () => Promise<TailwindcssPatchCommandResultMap[TCommand]>) => Promise<TailwindcssPatchCommandResultMap[TCommand]> | TailwindcssPatchCommandResultMap[TCommand];
+type TailwindcssPatchCommandHandlerMap = Partial<{
+    [K in TailwindcssPatchCommand]: TailwindcssPatchCommandHandler<K>;
+}>;
 interface TailwindcssPatchCliMountOptions {
     commandPrefix?: string;
     commands?: TailwindcssPatchCommand[];
     commandOptions?: Partial<Record<TailwindcssPatchCommand, TailwindcssPatchCommandOptions>>;
+    commandHandlers?: TailwindcssPatchCommandHandlerMap;
 }
 interface TailwindcssPatchCliOptions {
     name?: string;
     mountOptions?: TailwindcssPatchCliMountOptions;
 }
-declare function createTailwindcssPatchCli(options?: TailwindcssPatchCliOptions): CAC;
 declare function mountTailwindcssPatchCommands(cli: CAC, options?: TailwindcssPatchCliMountOptions): CAC;
-
-declare const logger: consola.ConsolaInstance;
+declare function createTailwindcssPatchCli(options?: TailwindcssPatchCliOptions): CAC;
 
 declare function normalizeOptions(options?: TailwindcssPatchOptions): NormalizedTailwindcssPatchOptions;
 
@@ -458,4 +516,4 @@ interface TailwindBuildOptions {
 }
 declare function runTailwindBuild(options: TailwindBuildOptions): Promise<postcss.Result<postcss.Root>>;
 
-export { CacheStore, type CacheStrategy, type ExtractResult, type ILengthUnitsPatchOptions, type NormalizedTailwindcssPatchOptions, type TailwindPatchRuntime, type TailwindTokenByFileMap, type TailwindTokenFileKey, type TailwindTokenLocation, type TailwindTokenReport, type TailwindcssClassCache, type TailwindcssPatchCliMountOptions, type TailwindcssPatchCliOptions, type TailwindcssPatchCommand, type TailwindcssPatchCommandOptions, type TailwindcssPatchOptions, TailwindcssPatcher, type TailwindcssRuntimeContext, collectClassesFromContexts, collectClassesFromTailwindV4, createTailwindcssPatchCli, extractProjectCandidatesWithPositions, extractRawCandidates, extractRawCandidatesWithPositions, extractValidCandidates, groupTokensByFile, loadRuntimeContexts, logger, mountTailwindcssPatchCommands, normalizeOptions, runTailwindBuild, tailwindcssPatchCommands };
+export { CacheStore, type CacheStrategy, type ExtractResult, type ILengthUnitsPatchOptions, type NormalizedTailwindcssPatchOptions, type TailwindPatchRuntime, type TailwindTokenByFileMap, type TailwindTokenFileKey, type TailwindTokenLocation, type TailwindTokenReport, type TailwindcssClassCache, type TailwindcssPatchCliMountOptions, type TailwindcssPatchCliOptions, type TailwindcssPatchCommand, type TailwindcssPatchCommandContext, type TailwindcssPatchCommandHandler, type TailwindcssPatchCommandHandlerMap, type TailwindcssPatchCommandOptionDefinition, type TailwindcssPatchCommandOptions, type TailwindcssPatchOptions, TailwindcssPatcher, type TailwindcssRuntimeContext, collectClassesFromContexts, collectClassesFromTailwindV4, createTailwindcssPatchCli, extractProjectCandidatesWithPositions, extractRawCandidates, extractRawCandidatesWithPositions, extractValidCandidates, groupTokensByFile, loadRuntimeContexts, logger, mountTailwindcssPatchCommands, normalizeOptions, runTailwindBuild, tailwindcssPatchCommands };