@silvery/commander 0.19.2 → 0.23.0

package/README.md

@@ -71,6 +71,12 @@ Options with [Zod](https://github.com/colinhacks/zod) schemas or built-in types
   - Any [Standard Schema](https://github.com/standard-schema/standard-schema) library — [Valibot](https://github.com/fabian-hiller/valibot), [ArkType](https://github.com/arktypeio/arktype)
   - All types usable standalone via `.parse()`/`.safeParse()`
 
+## Help composition and silent aliases
+
+Enhanced `Command.configureHelp({...})` shallow-merges with the current help configuration, so partial customizations preserve Silvery's installed color hooks; supplied keys win. `@silvery/commander/plain` keeps Commander's replacement behavior.
+
+Use `.silentAlias("queues")` for a compatibility spelling that should parse without appearing in help, usage, or typo suggestions. Ordinary `.alias()` and `.aliases()` remain visible and otherwise keep Commander semantics.
+
 ## Docs
 
 Full reference, type table, and API details at **[silvery.dev/reference/commander](https://silvery.dev/reference/commander)**.

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { a as date, c as int, d as path, f as port, h as url, i as csv, l as intRange, m as uint, n as StandardSchemaV1, o as email, p as regex, r as bool, s as float, t as CLIType, u as json } from "./presets-DTzPdB8a.mjs";
-import { Argument, Command as Command$1, CommanderError, Help, InvalidArgumentError, Option, OptionValues } from "commander";
+import { Argument, Command as Command$1, CommandOptions, CommanderError, Help, HelpConfiguration, InvalidArgumentError, Option, OptionValues } from "commander";
 import * as zod from "zod";
 
 //#region src/command.d.ts
@@ -145,6 +145,23 @@ declare class _CommandBase extends Command$1 {
   /** Argument names registered via typed .argument() — used by .action() to merge into opts. */
   _typedArgNames: string[];
   constructor(name?: string);
+  /** Compose help customizations while preserving the enhanced command's installed hooks. */
+  configureHelp(configuration: HelpConfiguration): this;
+  configureHelp(): HelpConfiguration;
+  /** Return every spelling accepted for a command, including parse-only aliases. */
+  private _commandIdentities;
+  private _silentAliasesFor;
+  private _addSilentAlias;
+  /** Match the executable-child forwarding used by Commander's alias(). */
+  private _aliasTarget;
+  /** Parent lookup used by Commander parsing; silent aliases never enter normal alias metadata. */
+  _findCommand(name?: string): Command$1 | undefined;
+  private _assertAliasAvailable;
+  alias(alias: string): this;
+  alias(): string;
+  /** Add an accepted command spelling which is omitted from help, usage, and suggestions. */
+  silentAlias(alias: string): this;
+  addCommand(command: Command$1, opts?: CommandOptions): this;
   /**
    * Add an option with smart third-argument detection.
    *
@@ -246,8 +263,8 @@ declare class _CommandBase extends Command$1 {
 interface Command<Opts extends Record<string, unknown> = {}, Args extends any[] = [], ArgsRecord extends Record<string, unknown> = {}> extends _CommandBase {
   /** Return option values with full type inference. */
   opts(): Opts;
-  /** Accept any `Command<...>` variant as a subcommand. */
-  addCommand(cmd: Command<any, any, any>, opts?: {
+  /** Accept raw Commander commands and any enhanced `Command<...>` variant. */
+  addCommand(cmd: Command$1 | Command<any, any, any>, opts?: {
     isDefault?: boolean;
     hidden?: boolean;
     noHelp?: boolean;
@@ -262,6 +279,8 @@ interface Command<Opts extends Record<string, unknown> = {}, Args extends any[]
   alias(alias: string): this;
   /** Get command alias. */
   alias(): string;
+  /** Add a parse-only alias omitted from help, usage, and suggestions. */
+  silentAlias(alias: string): this;
   /** Set command version (preserves typed chain). */
   version(str: string, flags?: string, description?: string): this;
   /** Add a choices option: `--env <e>`, `["dev", "staging", "prod"]` */
@@ -509,11 +528,11 @@ declare const z: {
   array<T extends zod.z.core.SomeType>(element: T, params?: string | zod.z.core.$ZodArrayParams): zod.ZodArray<T>;
   keyof<T extends zod.ZodObject>(schema: T): zod.ZodEnum<zod.z.core.util.KeysEnum<T["_zod"]["output"]>>;
   object<T extends zod.z.core.$ZodLooseShape = Partial<Record<never, zod.z.core.SomeType>>>(shape?: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<zod.z.core.util.Writeable<T>, zod.z.core.$strip>;
-  strictObject<T extends zod.z.core.$ZodLooseShape>(shape: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<T, zod.z.core.$strict>;
-  looseObject<T extends zod.z.core.$ZodLooseShape>(shape: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<T, zod.z.core.$loose>;
+  strictObject<T extends zod.z.core.$ZodLooseShape>(shape: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<zod.z.core.util.Writeable<T>, zod.z.core.$strict>;
+  looseObject<T extends zod.z.core.$ZodLooseShape>(shape: T, params?: string | zod.z.core.$ZodObjectParams): zod.ZodObject<zod.z.core.util.Writeable<T>, zod.z.core.$loose>;
   union<const T extends readonly zod.z.core.SomeType[]>(options: T, params?: string | zod.z.core.$ZodUnionParams): zod.ZodUnion<T>;
   xor<const T extends readonly zod.z.core.SomeType[]>(options: T, params?: string | zod.z.core.$ZodXorParams): zod.ZodXor<T>;
-  discriminatedUnion<Types extends readonly [zod.z.core.$ZodTypeDiscriminable, ...zod.z.core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | zod.z.core.$ZodDiscriminatedUnionParams): zod.ZodDiscriminatedUnion<Types, Disc>;
+  discriminatedUnion<Types extends readonly [zod.z.core.$ZodTypeDiscriminable<Disc>, ...zod.z.core.$ZodTypeDiscriminable<Disc>[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | zod.z.core.$ZodDiscriminatedUnionParams): zod.ZodDiscriminatedUnion<Types, Disc>;
   intersection<T extends zod.z.core.SomeType, U extends zod.z.core.SomeType>(left: T, right: U): zod.ZodIntersection<T, U>;
   tuple<T extends readonly [zod.z.core.SomeType, ...zod.z.core.SomeType[]]>(items: T, params?: string | zod.z.core.$ZodTupleParams): zod.ZodTuple<T, null>;
   tuple<T extends readonly [zod.z.core.SomeType, ...zod.z.core.SomeType[]], Rest extends zod.z.core.SomeType>(items: T, rest: Rest, params?: string | zod.z.core.$ZodTupleParams): zod.ZodTuple<T, Rest>;
@@ -527,7 +546,7 @@ declare const z: {
   literal<const T extends ReadonlyArray<zod.z.core.util.Literal>>(value: T, params?: string | zod.z.core.$ZodLiteralParams): zod.ZodLiteral<T[number]>;
   literal<const T extends zod.z.core.util.Literal>(value: T, params?: string | zod.z.core.$ZodLiteralParams): zod.ZodLiteral<T>;
   file(params?: string | zod.z.core.$ZodFileParams): zod.ZodFile;
-  transform<I = unknown, O = I>(fn: (input: I, ctx: zod.z.core.ParsePayload) => O): zod.ZodTransform<Awaited<O>, I>;
+  transform<I = unknown, O = I>(fn: (input: I, ctx: zod.z.core.$RefinementCtx) => O): zod.ZodTransform<Awaited<O>, I>;
   optional<T extends zod.z.core.SomeType>(innerType: T): zod.ZodOptional<T>;
   exactOptional<T extends zod.z.core.SomeType>(innerType: T): zod.ZodExactOptional<T>;
   nullable<T extends zod.z.core.SomeType>(innerType: T): zod.ZodNullable<T>;
@@ -542,6 +561,7 @@ declare const z: {
     decode: (value: zod.z.core.output<A>, payload: zod.z.core.ParsePayload<zod.z.core.output<A>>) => zod.z.core.util.MaybeAsync<zod.z.core.input<B>>;
     encode: (value: zod.z.core.input<B>, payload: zod.z.core.ParsePayload<zod.z.core.input<B>>) => zod.z.core.util.MaybeAsync<zod.z.core.output<A>>;
   }): zod.ZodCodec<A, B>;
+  invertCodec<A extends zod.z.core.SomeType, B extends zod.z.core.SomeType>(codec: zod.ZodCodec<A, B>): zod.ZodCodec<B, A>;
   readonly<T extends zod.z.core.SomeType>(innerType: T): zod.ZodReadonly<T>;
   templateLiteral<const Parts extends zod.z.core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | zod.z.core.$ZodTemplateLiteralParams): zod.ZodTemplateLiteral<zod.z.core.$PartsToTemplateLiteral<Parts>>;
   lazy<T extends zod.z.core.SomeType>(getter: () => T): zod.ZodLazy<T>;
@@ -567,8 +587,8 @@ declare const z: {
   check<O = unknown>(fn: zod.z.core.CheckFn<O>): zod.z.core.$ZodCheck<O>;
   custom<O>(fn?: (data: unknown) => unknown, _params?: string | zod.z.core.$ZodCustomParams | undefined): zod.ZodCustom<O, O>;
   refine<T>(fn: (arg: NoInfer<T>) => zod.z.core.util.MaybeAsync<unknown>, _params?: string | zod.z.core.$ZodCustomParams): zod.z.core.$ZodCheck<T>;
-  superRefine<T>(fn: (arg: T, payload: zod.z.core.$RefinementCtx<T>) => void | Promise<void>): zod.z.core.$ZodCheck<T>;
-  preprocess<A, U extends zod.z.core.SomeType, B = unknown>(fn: (arg: B, ctx: zod.z.core.$RefinementCtx) => A, schema: U): zod.ZodPipe<zod.ZodTransform<A, B>, U>;
+  superRefine<T>(fn: (arg: T, payload: zod.z.core.$RefinementCtx<T>) => void | Promise<void>, params?: zod.z.core.$ZodSuperRefineParams): zod.z.core.$ZodCheck<T>;
+  preprocess<A, U extends zod.z.core.SomeType, B = unknown>(fn: (arg: B, ctx: zod.z.core.$RefinementCtx) => A, schema: U): zod.ZodPreprocess<U>;
   ZodType: zod.z.core.$constructor<zod.ZodType>;
   _ZodString: zod.z.core.$constructor<zod._ZodString>;
   ZodString: zod.z.core.$constructor<zod.ZodString>;
@@ -637,6 +657,7 @@ declare const z: {
   ZodNaN: zod.z.core.$constructor<zod.ZodNaN>;
   ZodPipe: zod.z.core.$constructor<zod.ZodPipe>;
   ZodCodec: zod.z.core.$constructor<zod.ZodCodec>;
+  ZodPreprocess: zod.z.core.$constructor<zod.ZodPreprocess>;
   ZodReadonly: zod.z.core.$constructor<zod.ZodReadonly>;
   ZodTemplateLiteral: zod.z.core.$constructor<zod.ZodTemplateLiteral>;
   ZodLazy: zod.z.core.$constructor<zod.ZodLazy>;

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/command.ts","../src/colorize.ts","../src/z.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/command.ts","../src/colorize.ts","../src/z.ts"],"mappings":"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"}

package/dist/index.mjs

@@ -19,7 +19,7 @@ import * as zod from "zod";
 * ```
 */
 const autoStyle = createStyle();
-const s = createStyle({ level: "basic" });
+const s = createStyle({ level: "ansi16" });
 /**
 * Check if color output should be enabled.
 * Delegates to @silvery/ansi's auto-detection (NO_COLOR, FORCE_COLOR, TERM).
@@ -42,7 +42,7 @@ function colorizeHelp(program, options) {
 	const desc = options?.description ?? ((t) => t);
 	const heading = options?.heading ?? ((t) => s.bold(t));
 	const brackets = options?.brackets ?? ((t) => s.accent(t));
-	program.configureHelp({
+	const helpConfig = {
 		styleTitle: (str) => heading(str),
 		styleCommandText: (str) => cmds(str),
 		styleOptionText: (str) => flags(str),
@@ -50,6 +50,11 @@ function colorizeHelp(program, options) {
 		styleArgumentText: (str) => brackets(str),
 		styleDescriptionText: (str) => desc(str),
 		styleCommandDescription: (str) => s.bold.primary(str)
+	};
+	const existingHelp = program.configureHelp();
+	program.configureHelp({
+		...existingHelp,
+		...helpConfig
 	});
 	program.configureOutput({
 		getOutHasColors: () => true,
@@ -289,6 +294,7 @@ function maxLineWidth(term) {
 	for (const line of term.split("\n")) if (line.length > max) max = line.length;
 	return max;
 }
+const silentAliasesSymbol = Symbol("silvery.commander.silentAliases");
 /**
 * Type-safe Commander Command with auto-colorized help, Standard Schema support,
 * array-as-choices detection, and inferred option types.
@@ -313,9 +319,81 @@ const Command = class _CommandBase extends Command$1 {
 	_typedArgNames = [];
 	constructor(name) {
 		super(name);
-		colorizeHelp(this);
+		if (shouldColorize()) colorizeHelp(this);
 		this._capitalizeBuiltinDescriptions();
 	}
+	configureHelp(configuration) {
+		if (configuration === void 0) return super.configureHelp();
+		return super.configureHelp({
+			...super.configureHelp(),
+			...configuration
+		});
+	}
+	/** Return every spelling accepted for a command, including parse-only aliases. */
+	_commandIdentities(command) {
+		return [
+			command.name(),
+			...command.aliases(),
+			...this._silentAliasesFor(command)
+		];
+	}
+	_silentAliasesFor(command) {
+		return command[silentAliasesSymbol] ?? [];
+	}
+	_addSilentAlias(command, alias) {
+		const target = command;
+		const aliases = target[silentAliasesSymbol];
+		if (aliases) {
+			aliases.push(alias);
+			return;
+		}
+		Object.defineProperty(target, silentAliasesSymbol, { value: [alias] });
+	}
+	/** Match the executable-child forwarding used by Commander's alias(). */
+	_aliasTarget() {
+		const lastCommand = this.commands[this.commands.length - 1];
+		return lastCommand?._executableHandler ? lastCommand : this;
+	}
+	/** Parent lookup used by Commander parsing; silent aliases never enter normal alias metadata. */
+	_findCommand(name) {
+		if (!name) return void 0;
+		return this.commands.find((command) => this._commandIdentities(command).includes(name));
+	}
+	_assertAliasAvailable(command, alias) {
+		if (alias === command.name()) throw new Error("Command alias can't be the same as its name");
+		const matchingCommand = [...command.aliases(), ...this._silentAliasesFor(command)].includes(alias) ? command : command.parent?.commands.find((candidate) => this._commandIdentities(candidate).includes(alias));
+		if (matchingCommand) {
+			const existingCommand = this._commandIdentities(matchingCommand).join("|");
+			throw new Error(`cannot add alias '${alias}' to command '${command.name()}' as already have command '${existingCommand}'`);
+		}
+	}
+	alias(alias) {
+		if (alias === void 0) return super.alias();
+		this._assertAliasAvailable(this._aliasTarget(), alias);
+		return super.alias(alias);
+	}
+	/** Add an accepted command spelling which is omitted from help, usage, and suggestions. */
+	silentAlias(alias) {
+		const command = this._aliasTarget();
+		this._assertAliasAvailable(command, alias);
+		this._addSilentAlias(command, alias);
+		return this;
+	}
+	addCommand(command, opts) {
+		if (!command.name()) return super.addCommand(command, opts);
+		const identities = this._commandIdentities(command);
+		const seen = /* @__PURE__ */ new Set();
+		for (const identity of identities) {
+			const matchingCommand = seen.has(identity) ? command : this._findCommand(identity);
+			if (matchingCommand) {
+				const existingCommand = this._commandIdentities(matchingCommand).join("|");
+				const newCommand = identities.join("|");
+				throw new Error(`cannot add command '${newCommand}' as already have command '${existingCommand}'`);
+			}
+			seen.add(identity);
+		}
+		return super.addCommand(command, opts);
+	}
 	/**
 	* Add an option with smart third-argument detection.
 	*
@@ -345,7 +423,7 @@ const Command = class _CommandBase extends Command$1 {
 	* Tracks argument names for `.action()` merging.
 	*/
 	argument(flags, description, parseArgOrDefault, defaultValue) {
-		const camelName = flags.replace(/[<\[\]>.]/g, "").trim().replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+		const camelName = flags.replace(/[<[\]>.]/g, "").trim().replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 		this._typedArgNames.push(camelName);
 		if (Array.isArray(parseArgOrDefault)) {
 			const arg = this.createArgument(flags, description ?? "");

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["BaseCommand","Option","Help"],"sources":["../src/colorize.ts","../src/tokenize.ts","../src/command.ts","../src/z.ts"],"sourcesContent":["/**\n * Commander.js help colorization using @silvery/ansi.\n *\n * Uses Commander's built-in style hooks (styleTitle, styleOptionText, etc.)\n * rather than regex post-processing.\n *\n * @example\n * ```ts\n * import { Command } from \"@silvery/commander\"\n * // Command auto-colorizes in its constructor — no manual call needed.\n * // For plain Commander:\n * import { colorizeHelp } from \"@silvery/commander\"\n * colorizeHelp(program)\n * ```\n */\n\nimport { createStyle } from \"@silvery/ansi\"\n\n// Auto-detect terminal color level for shouldColorize() checks.\nconst autoStyle = createStyle()\n\n// Forced basic-color style for explicit colorizeHelp() calls.\n// When a user explicitly calls colorizeHelp(), they want color regardless\n// of terminal detection. The function name means \"add color\" — if you\n// don't want color, don't call it.\nconst s = createStyle({ level: \"basic\" })\n\n/**\n * Check if color output should be enabled.\n * Delegates to @silvery/ansi's auto-detection (NO_COLOR, FORCE_COLOR, TERM).\n */\nexport function shouldColorize(): boolean {\n  return autoStyle.level > 0\n}\n\n/**\n * Minimal interface for Commander's Command — avoids requiring Commander\n * as a direct dependency. Works with both `commander` and\n * `@silvery/commander`.\n */\nexport interface CommandLike {\n  // biome-ignore lint: permissive to match Commander's overloaded signatures\n  configureHelp(...args: any[]): any\n  // biome-ignore lint: permissive to match Commander's overloaded signatures\n  configureOutput(...args: any[]): any\n  // biome-ignore lint: permissive to match Commander's Command[] structurally\n  readonly commands: readonly any[]\n}\n\n/** Color scheme for help output. Each value is a styling function (text → styled text). */\nexport interface ColorizeHelpOptions {\n  /** Style for command/subcommand names. Default: primary (yellow without theme) */\n  commands?: (text: string) => string\n  /** Style for --flags and -short options. Default: secondary (cyan without theme) */\n  flags?: (text: string) => string\n  /** Style for description text. Default: unstyled (normal foreground) */\n  description?: (text: string) => string\n  /** Style for section headings (Usage:, Options:, etc.). Default: bold */\n  heading?: (text: string) => string\n  /** Style for <required> and [optional] argument brackets. Default: accent (magenta without theme) */\n  brackets?: (text: string) => string\n}\n\n/**\n * Apply colorized help output to a Commander.js program and all its subcommands.\n *\n * Uses Commander's built-in `configureHelp()` style hooks rather than\n * post-processing the formatted string.\n *\n * @param program - A Commander Command instance (or compatible object)\n * @param options - Override default style functions for each element\n */\nexport function colorizeHelp(program: CommandLike, options?: ColorizeHelpOptions): void {\n  // Semantic token fallback: theme token → named color\n  const cmds = options?.commands ?? ((t: string) => s.primary(t))\n  const flags = options?.flags ?? ((t: string) => s.secondary(t))\n  const desc = options?.description ?? ((t: string) => t)\n  const heading = options?.heading ?? ((t: string) => s.bold(t))\n  const brackets = options?.brackets ?? ((t: string) => s.accent(t))\n\n  const helpConfig: Record<string, unknown> = {\n    styleTitle: (str: string) => heading(str),\n    styleCommandText: (str: string) => cmds(str),\n    styleOptionText: (str: string) => flags(str),\n    styleSubcommandText: (str: string) => cmds(str),\n    styleArgumentText: (str: string) => brackets(str),\n    styleDescriptionText: (str: string) => desc(str),\n    styleCommandDescription: (str: string) => s.bold.primary(str),\n  }\n\n  program.configureHelp(helpConfig)\n\n  // Tell Commander that color output is supported, even when stdout is not\n  // a TTY. Without this, Commander strips ANSI codes from helpInformation().\n  program.configureOutput({\n    getOutHasColors: () => true,\n    getErrHasColors: () => true,\n  })\n\n  // Apply recursively to all existing subcommands\n  for (const sub of program.commands) {\n    colorizeHelp(sub, options)\n  }\n}\n","/**\n * Shell command-line tokenizer for help-section term styling.\n *\n * Walks a single line of shell-like text and classifies each token so the\n * default text help renderer can style it without re-running the regex\n * machinery on every render. Pure function — no ANSI, no styling.\n *\n * Internal: not exported from index.ts. Used only by command.ts's\n * styleSectionTerm() / _renderSections().\n *\n * Example:\n *   tokenizeCmdline(\"$ termless play -o demo.gif demo.tape\")\n *   →\n *   [\n *     { kind: \"prompt\",     text: \"$ \" },\n *     { kind: \"program\",    text: \"termless\" },\n *     { kind: \"whitespace\", text: \" \" },\n *     { kind: \"subcommand\", text: \"play\" },\n *     { kind: \"whitespace\", text: \" \" },\n *     { kind: \"flag\",       text: \"-o\" },\n *     { kind: \"whitespace\", text: \" \" },\n *     { kind: \"value\",      text: \"demo.gif\" },\n *     { kind: \"whitespace\", text: \" \" },\n *     { kind: \"value\",      text: \"demo.tape\" },\n *   ]\n */\n\nexport type CmdlineToken =\n  | { kind: \"prompt\"; text: string }\n  | { kind: \"program\"; text: string }\n  | { kind: \"subcommand\"; text: string }\n  | { kind: \"flag\"; text: string }\n  | { kind: \"arg-bracket\"; text: string }\n  | { kind: \"quoted\"; text: string }\n  | { kind: \"value\"; text: string }\n  | { kind: \"whitespace\"; text: string }\n\n/** Detect a shell prompt at the start of a line. Supports `$ `, `# `, `> `, `❯ `. */\nconst PROMPT_RE = /^([$#>❯]\\s+)/\n\n/** Match one of: long/short flag, bracket arg, quoted string, bare token, whitespace. */\nconst TOKEN_RE = /(--?\\S+)|(<[^>]+>|\\[[^\\]]+\\])|('[^']*'|\"[^\"]*\")|(\\S+)|(\\s+)/g\n\n/** Bare command-word pattern (letters/digits/dash, no dots or slashes). */\nconst BARE_WORD_RE = /^[a-z][\\w-]*$/i\n\n/**\n * Tokenize a single line of shell-like text.\n *\n * Classification (matches the original styleSectionTerm contract):\n * - First non-whitespace bare word after the prompt is `program`.\n * - The IMMEDIATELY-FOLLOWING bare word (the second bare word) is `subcommand`,\n *   IF it looks like a command word (lowercase letter start, no dots/slashes).\n * - All subsequent bare words are `value`s (filenames, package names, etc.).\n * - Flags (`--foo`, `-f`), bracket args (`<x>`, `[y]`), and quoted strings end\n *   the \"command portion\" — anything after them is a value.\n *\n * The \"max 1 subcommand\" rule keeps `$ npm install foo` correctly classified\n * as program/subcommand/value (not program/subcommand/subcommand). For nested\n * commands (`$ git remote add ...`), only the first subcommand level is styled.\n *\n * If the line has no shell prompt, the same classification still applies —\n * the leading word is `program`, etc.\n */\nexport function tokenizeCmdline(line: string): CmdlineToken[] {\n  const tokens: CmdlineToken[] = []\n\n  // Detect and emit the prompt as a separate token\n  const promptMatch = line.match(PROMPT_RE)\n  let body = line\n  if (promptMatch) {\n    tokens.push({ kind: \"prompt\", text: promptMatch[1]! })\n    body = line.slice(promptMatch[1]!.length)\n  }\n\n  // Tokenize the rest with contextual classification\n  const matches = body.match(TOKEN_RE) ?? []\n  let commandWords = 0\n  let doneWithCommand = false\n\n  for (const token of matches) {\n    if (/^\\s+$/.test(token)) {\n      tokens.push({ kind: \"whitespace\", text: token })\n      continue\n    }\n    if (/^--?\\S/.test(token)) {\n      doneWithCommand = true\n      tokens.push({ kind: \"flag\", text: token })\n      continue\n    }\n    if (/^[<[]/.test(token)) {\n      doneWithCommand = true\n      tokens.push({ kind: \"arg-bracket\", text: token })\n      continue\n    }\n    if (/^[\"']/.test(token)) {\n      doneWithCommand = true\n      tokens.push({ kind: \"quoted\", text: token })\n      continue\n    }\n    // Bare word: the first becomes `program`, the second (if it looks like a\n    // command word — bare lowercase word, no dots/slashes) becomes `subcommand`,\n    // and everything else becomes `value`.\n    if (!doneWithCommand && commandWords === 0) {\n      commandWords++\n      tokens.push({ kind: \"program\", text: token })\n      continue\n    }\n    if (!doneWithCommand && commandWords === 1 && BARE_WORD_RE.test(token)) {\n      commandWords++\n      tokens.push({ kind: \"subcommand\", text: token })\n      continue\n    }\n    // Plain values (filenames, version strings, package names, anything else)\n    doneWithCommand = true\n    tokens.push({ kind: \"value\", text: token })\n  }\n\n  return tokens\n}\n\n/** Returns true if the line starts with a recognized shell prompt. */\nexport function isShellLine(line: string): boolean {\n  return PROMPT_RE.test(line)\n}\n","/**\n * Enhanced Commander Command with auto-colorized help, Standard Schema support,\n * array-as-choices detection, and **type-safe option + argument inference**.\n *\n * Subclasses Commander's Command so `new Command(\"app\")` just works --\n * it's Commander with auto-colorized help, automatic Standard Schema /\n * legacy Zod detection, and array choices in `.option()` and `.argument()`.\n *\n * Each `.option()` call narrows the return type so that `.action()`, `.opts()`,\n * and `.actionMerged()` know exactly which options exist and what types they have.\n * Each `.argument()` call appends to both a positional tuple (for `.action()`)\n * and a named record (for `.actionMerged()`).\n *\n * `.action(fn)` is Commander-native: positional args, then options, then command.\n * `.actionMerged(fn)` is an opt-in helper that merges args and options into a\n * single named object — nicer for commands with many positional arguments.\n *\n * @example\n * ```ts\n * import { Command, port, csv } from \"@silvery/commander\"\n *\n * // Commander-native: positional args, then options\n * new Command(\"deploy\")\n *   .argument(\"<service>\", \"Service to deploy\")\n *   .argument(\"[env]\", \"Environment\", [\"dev\", \"staging\", \"prod\"])\n *   .option(\"-p, --port <n>\", \"Port\", port)\n *   .option(\"--verbose\", \"Verbose output\")\n *   .action((service, env, opts) => {\n *     service       // string\n *     env           // \"dev\" | \"staging\" | \"prod\" | undefined\n *     opts.port     // number | undefined\n *     opts.verbose  // boolean | undefined\n *   })\n *\n * // Merged form: flat named object with args and options merged\n * new Command(\"deploy\")\n *   .argument(\"<service>\")\n *   .argument(\"[env]\", [\"dev\", \"staging\", \"prod\"] as const)\n *   .option(\"-p, --port <n>\", \"Port\", port)\n *   .actionMerged(({ service, env, port }) => { ... })\n *\n * program.parse()\n * ```\n */\n\nimport { Command as BaseCommand, Help, Option } from \"commander\"\nimport { colorizeHelp, shouldColorize } from \"./colorize.ts\"\nimport type { CLIType, StandardSchemaV1 } from \"./presets.ts\"\nimport { tokenizeCmdline, isShellLine, type CmdlineToken } from \"./tokenize.ts\"\n\n/**\n * Broad structural type for schema objects that have a `~standard` property.\n * Matches both our `StandardSchemaV1<T>`, Zod v4's async-capable Standard Schema,\n * and any other library implementing Standard Schema v1.\n *\n * Type extraction works via the `types` property (Standard Schema v1 convention).\n */\ninterface AnyStandardSchema {\n  readonly \"~standard\": {\n    readonly version: 1\n    readonly vendor: string\n    readonly validate: (value: unknown, ...args: any[]) => any\n    readonly types?: { readonly output: unknown } | undefined\n  }\n}\n\n/** Extract the output type from a Standard Schema v1 object. */\ntype SchemaOutput<S extends AnyStandardSchema> = NonNullable<S[\"~standard\"][\"types\"]>[\"output\"]\n\n// ────────────────────────────────────────────────────────────────\n// Type-level flag parsing utilities\n// ────────────────────────────────────────────────────────────────\n\n/**\n * Extract the long option name from a flags string.\n *\n * Examples:\n *   \"-v, --verbose\"        → \"verbose\"\n *   \"--port <n>\"           → \"port\"\n *   \"--dry-run\"            → \"dry-run\"\n *   \"--no-color\"           → \"no-color\"\n *   \"-o, --output [path]\"  → \"output\"\n */\ntype ExtractLongName<S extends string> = S extends `${string}--${infer Rest}`\n  ? Rest extends `${infer Name} ${string}`\n    ? Name\n    : Rest\n  : S extends `-${infer C}, ${infer Rest}`\n    ? Rest extends `${infer Name} ${string}`\n      ? Name\n      : Rest\n    : S extends `-${infer C}`\n      ? C\n      : never\n\n/**\n * Convert kebab-case to camelCase (matching Commander's attributeName()).\n *\n * \"dry-run\"        → \"dryRun\"\n * \"terminal-name\"  → \"terminalName\"\n * \"verbose\"        → \"verbose\"\n */\ntype CamelCase<S extends string> = S extends `${infer A}-${infer B}${infer Rest}`\n  ? `${A}${Uppercase<B>}${CamelCase<Rest>}`\n  : S\n\n// ────────────────────────────────────────────────────────────────\n// Type-level argument parsing utilities\n// ────────────────────────────────────────────────────────────────\n\n/**\n * Extract the argument name from a flags string.\n *\n * Examples:\n *   \"<service>\"       → \"service\"\n *   \"[env]\"           → \"env\"\n *   \"<files...>\"      → \"files\"\n *   \"<service-name>\"  → \"service-name\"\n */\ntype ExtractArgName<S extends string> = S extends `<${infer Name}...>`\n  ? Name\n  : S extends `<${infer Name}>`\n    ? Name\n    : S extends `[${infer Name}...]`\n      ? Name\n      : S extends `[${infer Name}]`\n        ? Name\n        : never\n\n/** Is the argument required (wrapped in `<...>`)? */\ntype IsArgRequired<S extends string> = S extends `<${string}>` ? true : false\n\n/** Is the argument variadic (ends with `...>` or `...]`)? */\ntype IsArgVariadic<S extends string> = S extends `${string}...${string}` ? true : false\n\n/**\n * Derive the property key from an argument flags string.\n * Applies: extract name → camelCase.\n */\ntype ArgKey<S extends string> = CamelCase<ExtractArgName<S>>\n\n/**\n * Parse positional arguments embedded in a command name string.\n *\n * Commander.js accepts argument syntax inline with command names:\n *   `\"deploy <service>\"`            → 1 required arg\n *   `\"deploy <service> [env]\"`      → 1 required + 1 optional\n *   `\"deploy <files...>\"`           → 1 required variadic\n *\n * `ParseCommandString<S>` returns `[Args tuple, ArgsRecord]` so the typed\n * `command<S>()` overload can produce a `Command<{}, Args, ArgsRecord>` with\n * the same type information you'd get from chaining `.argument()` calls.\n *\n * Limitations: only plain string types — `<svc>` is `string`, `[env]` is\n * `string | undefined`, `<files...>` is `string[]`. Parsers, schemas, and\n * choices still require `.argument()` because the inline string syntax can't\n * express them. Mixing inline args with `.argument()` calls is allowed:\n * the inline ones come first in the tuple, the `.argument()` ones append.\n */\n\n/** Split a command name string at the first space. `\"deploy <service>\"` → `[\"deploy\", \"<service>\"]` */\ntype SplitCommandHead<S extends string> = S extends `${infer Name} ${infer Rest}`\n  ? [Name, Rest]\n  : [S, \"\"]\n\n/** Walk the tail tokens after the command name and build [Args tuple, ArgsRecord]. */\ntype ParseInlineArgs<S extends string, Tuple extends any[] = [], Rec = {}> = S extends \"\"\n  ? [Tuple, Rec]\n  : S extends `${infer Tok} ${infer Rest}`\n    ? Tok extends `<${infer Name}...>`\n      ? ParseInlineArgs<Rest, [...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>>\n      : Tok extends `<${infer Name}>`\n        ? ParseInlineArgs<Rest, [...Tuple, string], Rec & Record<CamelCase<Name>, string>>\n        : Tok extends `[${infer Name}...]`\n          ? ParseInlineArgs<Rest, [...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>>\n          : Tok extends `[${infer Name}]`\n            ? ParseInlineArgs<\n                Rest,\n                [...Tuple, string | undefined],\n                Rec & Record<CamelCase<Name>, string | undefined>\n              >\n            : ParseInlineArgs<Rest, Tuple, Rec> // skip non-arg tokens\n    : // Last token (no trailing space)\n      S extends `<${infer Name}...>`\n      ? [[...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>]\n      : S extends `<${infer Name}>`\n        ? [[...Tuple, string], Rec & Record<CamelCase<Name>, string>]\n        : S extends `[${infer Name}...]`\n          ? [[...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>]\n          : S extends `[${infer Name}]`\n            ? [[...Tuple, string | undefined], Rec & Record<CamelCase<Name>, string | undefined>]\n            : [Tuple, Rec]\n\n/** Top-level: parse a `command(name)` string into [Args tuple, ArgsRecord]. */\ntype ParseCommandString<S extends string> =\n  SplitCommandHead<S> extends [infer _Name, infer Tail extends string]\n    ? Tail extends \"\"\n      ? [[], {}]\n      : ParseInlineArgs<Tail>\n    : [[], {}]\n\n/**\n * Infer the value type for an argument based on its flags string and\n * the optional parser/choices/schema.\n *\n * Rules:\n *   <required>            → string\n *   [optional]            → string | undefined\n *   <variadic...>         → string[]\n *   [variadic...]         → string[]\n *   with parser fn        → ReturnType<parser> (+ | undefined if optional)\n *   with CLIType<T>       → T (+ | undefined if optional)\n *   with StandardSchema   → T (+ | undefined if optional)\n *   with choices[]        → choices[number] (+ | undefined if optional)\n */\ntype InferArgType<Flags extends string, ParseArg = undefined> =\n  IsArgVariadic<Flags> extends true\n    ? ParseArg extends readonly (infer C)[]\n      ? C[]\n      : ParseArg extends CLIType<infer T>\n        ? T[]\n        : ParseArg extends StandardSchemaV1<infer T>\n          ? T[]\n          : ParseArg extends (value: string, ...args: any[]) => infer R\n            ? R[]\n            : string[]\n    : IsArgRequired<Flags> extends true\n      ? ParseArg extends readonly (infer C)[]\n        ? C\n        : ParseArg extends CLIType<infer T>\n          ? T\n          : ParseArg extends StandardSchemaV1<infer T>\n            ? T\n            : ParseArg extends (value: string, ...args: any[]) => infer R\n              ? R\n              : string\n      : ParseArg extends readonly (infer C)[]\n        ? C | undefined\n        : ParseArg extends CLIType<infer T>\n          ? T | undefined\n          : ParseArg extends StandardSchemaV1<infer T>\n            ? T | undefined\n            : ParseArg extends (value: string, ...args: any[]) => infer R\n              ? R | undefined\n              : string | undefined\n\n/**\n * Strip \"no-\" prefix from negated flags.\n * \"--no-color\" → long name \"no-color\" → stripped to \"color\"\n */\ntype StripNo<S extends string> = S extends `no-${infer Rest}` ? Rest : S\n\n/**\n * Derive the property key from a flags string.\n * Applies: extract long name → strip \"no-\" → camelCase.\n */\ntype FlagKey<S extends string> = CamelCase<StripNo<ExtractLongName<S>>>\n\n/**\n * Does the flags string contain a required value argument `<...>`?\n */\ntype HasRequiredArg<S extends string> = S extends `${string}<${string}>${string}` ? true : false\n\n/**\n * Does the flags string contain an optional value argument `[...]`?\n */\ntype HasOptionalArg<S extends string> = S extends `${string}[${string}]${string}` ? true : false\n\n/**\n * Does the flags string start with `--no-`?\n */\ntype IsNegated<S extends string> = ExtractLongName<S> extends `no-${string}` ? true : false\n\n/**\n * Infer the value type for a flag based on the flags string and the\n * optional third argument (parser function, Standard Schema, choices array).\n *\n * Rules (mirroring Commander runtime behavior):\n *   --flag                    → boolean | undefined\n *   --no-flag                 → boolean\n *   --flag <value>            → string | undefined  (or parser return type)\n *   --flag [value]            → string | boolean | undefined (or parser return type | boolean)\n *   --flag <value>, parser fn → ReturnType<parser> | undefined\n *   --flag <value>, CLIType<T> / StandardSchemaV1<T> → T | undefined\n *   --flag <value>, choices[] → choices[number] | undefined\n */\ntype InferOptionType<Flags extends string, ParseArg = undefined> =\n  IsNegated<Flags> extends true\n    ? boolean\n    : HasRequiredArg<Flags> extends true\n      ? ParseArg extends readonly (infer C)[]\n        ? C | undefined\n        : ParseArg extends CLIType<infer T>\n          ? T | undefined\n          : ParseArg extends StandardSchemaV1<infer T>\n            ? T | undefined\n            : ParseArg extends (value: string, ...args: any[]) => infer R\n              ? R | undefined\n              : string | undefined\n      : HasOptionalArg<Flags> extends true\n        ? ParseArg extends readonly (infer C)[]\n          ? C | boolean | undefined\n          : ParseArg extends CLIType<infer T>\n            ? T | boolean | undefined\n            : ParseArg extends StandardSchemaV1<infer T>\n              ? T | boolean | undefined\n              : ParseArg extends (value: string, ...args: any[]) => infer R\n                ? R | boolean | undefined\n                : string | boolean | undefined\n        : boolean | undefined\n\n// --- Standard Schema support ---\n\n/** Runtime check: is this value a Standard Schema v1 object? */\nfunction isStandardSchema(value: unknown): value is StandardSchemaV1 {\n  return typeof value === \"object\" && value !== null && \"~standard\" in (value as any)\n}\n\n/** Wrap a Standard Schema as a Commander parser function */\nfunction standardSchemaParser<T>(schema: StandardSchemaV1<T>): (value: string) => T {\n  return (value: string) => {\n    const result = schema[\"~standard\"].validate(value)\n    if (\"issues\" in result) {\n      const msg = result.issues.map((i) => i.message).join(\", \")\n      throw new Error(msg)\n    }\n    return result.value\n  }\n}\n\n// --- Legacy Zod support (pre-3.24, no ~standard) ---\n\ninterface ZodLike<T = any> {\n  parse(value: unknown): T\n  _def: unknown\n}\n\nfunction isLegacyZodSchema(value: unknown): value is ZodLike {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as any).parse === \"function\" &&\n    \"_def\" in (value as any) &&\n    !(\"~standard\" in (value as any))\n  )\n}\n\nfunction legacyZodParser<T>(schema: ZodLike<T>): (value: string) => T {\n  return (value: string) => {\n    try {\n      return schema.parse(value)\n    } catch (err: any) {\n      if (err?.issues) {\n        const messages = err.issues.map((i: any) => i.message).join(\", \")\n        throw new Error(messages)\n      }\n      throw err\n    }\n  }\n}\n\n// --- Help Section Types ---\n\n/** Position for help sections — mirrors Commander's addHelpText positions. */\nexport type HelpSectionPosition = \"beforeAll\" | \"before\" | \"after\" | \"afterAll\"\n\n/** Content for a help section: rows of [term, description] pairs, or free-form text. */\nexport type HelpSectionContent = [string, string][] | string\n\n// Internal storage\ninterface StoredSection {\n  position: HelpSectionPosition\n  title: string\n  content: HelpSectionContent\n}\n\n/**\n * Style a SINGLE-LINE section term using Commander's style hooks.\n *\n * Three modes:\n * - Shell command line (`$ termless play demo.tape`): tokenize via tokenizeCmdline()\n *   and style each token by kind (dim prompt, primary program/subcommand,\n *   secondary flags, accent brackets, dim quoted strings, plain values)\n * - Option-like (`-f, --flag`): entire term styled as option\n * - Plain text: command words + argument brackets\n *\n * For multi-line terms, callers split on \\n and call this per line — see\n * _renderSections().\n */\nfunction styleSectionTerm(term: string, helper: any): string {\n  // Shell command terms (start with \"$ \", \"# \", \"> \", \"❯ \")\n  if (isShellLine(term)) {\n    return styleCmdlineTokens(tokenizeCmdline(term), helper)\n  }\n\n  // Option-like terms: entire term styled as option\n  if (/^\\s*-/.test(term)) return helper.styleOptionText(term)\n\n  // Command-like terms: style command words with primary, <brackets> with accent\n  // Split into bracket groups and non-bracket parts\n  const parts = term.split(/(<[^>]+>|\\[[^\\]]+\\])/g)\n  if (parts.length === 1) {\n    // No brackets — style entire term as command\n    return helper.styleCommandText(term)\n  }\n  // Mix of command text and brackets\n  return parts\n    .map((part) => {\n      if (/^[<[]/.test(part)) return helper.styleArgumentText(part)\n      if (part) return helper.styleCommandText(part)\n      return part\n    })\n    .join(\"\")\n}\n\n/**\n * Apply style hooks to a stream of CmdlineTokens.\n *\n * Each token kind maps to one of Commander's style hooks (or a manual ANSI\n * dim escape for prompts/quoted strings, since Commander's style hook set\n * doesn't have a \"dim\" entry).\n */\nfunction styleCmdlineTokens(tokens: CmdlineToken[], helper: any): string {\n  const dim = (text: string) => (shouldColorize() ? `\\x1b[2m${text}\\x1b[22m` : text)\n  return tokens\n    .map((t) => {\n      switch (t.kind) {\n        case \"prompt\":\n          return dim(t.text)\n        case \"program\":\n        case \"subcommand\":\n          return helper.styleCommandText(t.text)\n        case \"flag\":\n          return helper.styleOptionText(t.text)\n        case \"arg-bracket\":\n          return helper.styleArgumentText(t.text)\n        case \"quoted\":\n          return dim(t.text)\n        case \"value\":\n        case \"whitespace\":\n          return t.text\n      }\n    })\n    .join(\"\")\n}\n\n/**\n * Compute the longest visual width of any line within a (possibly multi-line) term.\n * Used for column alignment when terms span multiple lines.\n */\nfunction maxLineWidth(term: string): number {\n  let max = 0\n  for (const line of term.split(\"\\n\")) {\n    if (line.length > max) max = line.length\n  }\n  return max\n}\n\n// ────────────────────────────────────────────────────────────────\n// Command class — runtime implementation (non-generic)\n//\n// The class itself is NOT generic. Type-safe option inference is\n// layered on via interface merging below (see `TypedOptionOverloads`).\n// This keeps the class fully compatible with Commander's base Command\n// (no `noImplicitOverride` or structural assignability issues).\n// ────────────────────────────────────────────────────────────────\n\nclass _CommandBase extends BaseCommand {\n  private _helpSectionList: StoredSection[] = []\n  private _helpSectionsInstalled = false\n\n  /** Argument names registered via typed .argument() — used by .action() to merge into opts. */\n  _typedArgNames: string[] = []\n\n  constructor(name?: string) {\n    super(name)\n    colorizeHelp(this as any)\n    this._capitalizeBuiltinDescriptions()\n  }\n\n  /**\n   * Add an option with smart third-argument detection.\n   *\n   * The third argument is detected in order:\n   * 1. **Array** -- treated as choices (Commander `.choices()`)\n   * 2. **Standard Schema v1** -- wrapped as a parser function\n   * 3. **Legacy Zod** (pre-3.24, has `_def` + `parse`) -- wrapped as a parser\n   * 4. **Function** -- passed through as Commander's parser function\n   * 5. **Anything else** -- passed through as a default value\n   */\n  override option(\n    flags: string,\n    description?: string,\n    parseArgOrDefault?: any,\n    defaultValue?: any,\n  ): this {\n    if (Array.isArray(parseArgOrDefault)) {\n      const opt = new Option(flags, description ?? \"\").choices(parseArgOrDefault as string[])\n      this.addOption(opt)\n      return this\n    }\n    if (isStandardSchema(parseArgOrDefault)) {\n      return super.option(\n        flags,\n        description ?? \"\",\n        standardSchemaParser(parseArgOrDefault),\n        defaultValue,\n      )\n    }\n    if (isLegacyZodSchema(parseArgOrDefault)) {\n      return super.option(\n        flags,\n        description ?? \"\",\n        legacyZodParser(parseArgOrDefault),\n        defaultValue,\n      )\n    }\n    if (typeof parseArgOrDefault === \"function\") {\n      return super.option(flags, description ?? \"\", parseArgOrDefault, defaultValue)\n    }\n    return super.option(flags, description ?? \"\", parseArgOrDefault)\n  }\n\n  /**\n   * Add an argument with smart third-argument detection.\n   *\n   * Same detection as `.option()`: array → choices, Standard Schema → parser,\n   * legacy Zod → parser, function → parser, anything else → default value.\n   * Tracks argument names for `.action()` merging.\n   */\n  override argument(\n    flags: string,\n    description?: string,\n    parseArgOrDefault?: any,\n    defaultValue?: any,\n  ): this {\n    // Extract the camelCase name from the flags string for action() merging\n    const rawName = flags.replace(/[<\\[\\]>.]/g, \"\").trim()\n    const camelName = rawName.replace(/-([a-z])/g, (_: string, c: string) => c.toUpperCase())\n    this._typedArgNames.push(camelName)\n\n    if (Array.isArray(parseArgOrDefault)) {\n      const arg = this.createArgument(flags, description ?? \"\")\n      arg.choices(parseArgOrDefault as string[])\n      this.addArgument(arg)\n      return this\n    }\n    if (isStandardSchema(parseArgOrDefault)) {\n      return super.argument(\n        flags,\n        description ?? \"\",\n        standardSchemaParser(parseArgOrDefault),\n        defaultValue,\n      )\n    }\n    if (isLegacyZodSchema(parseArgOrDefault)) {\n      return super.argument(\n        flags,\n        description ?? \"\",\n        legacyZodParser(parseArgOrDefault),\n        defaultValue,\n      )\n    }\n    if (typeof parseArgOrDefault === \"function\") {\n      return super.argument(flags, description ?? \"\", parseArgOrDefault, defaultValue)\n    }\n    return super.argument(flags, description ?? \"\", parseArgOrDefault)\n  }\n\n  /**\n   * Register an action callback with a named-parameter object instead of positional args.\n   *\n   * The handler receives a single object containing all positional arguments\n   * (merged by name) and all options, plus the Command instance as a second arg.\n   * Argument names come from the typed `.argument()` calls, camelCased.\n   *\n   * This is a convenience wrapper over `.action()` — `.action()` itself remains\n   * Commander-native `(...args, opts, command) => ...`. Prefer `.action()` for\n   * single-arg commands (where positional is more ergonomic) and `.actionMerged()`\n   * for multi-arg commands (where a flat named object is nicer).\n   *\n   * @example\n   * ```ts\n   * new Command(\"deploy\")\n   *   .argument(\"<service>\")\n   *   .argument(\"[env]\")\n   *   .option(\"-p, --port <n>\", port)\n   *   .actionMerged(({ service, env, port }, cmd) => {\n   *     // service, env, port are all typed\n   *     // cmd is the Command instance\n   *   })\n   * ```\n   */\n  actionMerged(fn: (params: any, cmd: any) => any): this {\n    const argNames = this._typedArgNames\n    return super.action((...args: any[]) => {\n      // Commander passes: (arg1, arg2, ..., opts, command)\n      const cmd = args[args.length - 1]\n      const opts = args[args.length - 2] ?? {}\n      const merged: Record<string, unknown> = { ...opts }\n      for (let i = 0; i < argNames.length; i++) {\n        merged[argNames[i]!] = args[i]\n      }\n      return fn(merged, cmd)\n    })\n  }\n\n  /**\n   * Add a styled help section — like Commander's `addHelpText` but with\n   * structured content that participates in global column alignment.\n   *\n   * @example\n   * ```ts\n   * // Rows with aligned descriptions (default position: \"after\")\n   * program.addHelpSection(\"Getting Started:\", [\n   *   [\"myapp init\", \"Initialize a new project\"],\n   *   [\"myapp serve\", \"Start the dev server\"],\n   * ])\n   *\n   * // Free-form text\n   * program.addHelpSection(\"Note:\", \"Requires Node.js 23+\")\n   *\n   * // Explicit position\n   * program.addHelpSection(\"before\", \"Prerequisites:\", [\n   *   [\"node >= 23\", \"Required runtime\"],\n   * ])\n   * ```\n   */\n  addHelpSection(title: string, content: HelpSectionContent): this\n  addHelpSection(position: HelpSectionPosition, title: string, content: HelpSectionContent): this\n  addHelpSection(\n    positionOrTitle: HelpSectionPosition | string,\n    titleOrContent: string | HelpSectionContent,\n    content?: HelpSectionContent,\n  ): this {\n    let position: HelpSectionPosition\n    let title: string\n    let body: HelpSectionContent\n\n    if (content !== undefined) {\n      // 3-arg: addHelpSection(position, title, content)\n      position = positionOrTitle as HelpSectionPosition\n      title = titleOrContent as string\n      body = content\n    } else {\n      // 2-arg: addHelpSection(title, content) — defaults to \"after\"\n      position = \"after\"\n      title = positionOrTitle\n      body = titleOrContent as HelpSectionContent\n    }\n\n    this._helpSectionList.push({ position, title, content: body })\n    this._installHelpSectionHooks()\n    return this\n  }\n\n  // Subcommands also get colorized help, Standard Schema, and array choices\n  override createCommand(name?: string): _CommandBase {\n    return new _CommandBase(name)\n  }\n\n  /**\n   * Override Commander's `command()` to mirror inline-arg names (from\n   * `command(\"deploy <service>\")`) into our `_typedArgNames`. This keeps\n   * `.actionMerged()` working on subcommands declared with the inline form,\n   * since the merged dispatch reads from `_typedArgNames` to know which\n   * positional indices map to which key.\n   *\n   * Both forms now coexist:\n   *   .command(\"deploy <service>\")               // inline — names from string\n   *   .command(\"deploy\").argument(\"<service>\")   // explicit — names from .argument()\n   * Both produce equivalent runtime + type behavior.\n   */\n  override command(...args: any[]): any {\n    // biome-ignore lint: variadic forwarding\n    const result = (super.command as any).apply(this, args)\n    // The newly-created subcommand is always the last entry in this.commands\n    // (Commander appends after createCommand). Its _args field has been populated\n    // by Commander's own parsing of the name string.\n    const sub = this.commands[this.commands.length - 1] as _CommandBase | undefined\n    if (sub && Array.isArray((sub as any)._args)) {\n      for (const arg of (sub as any)._args as Array<{ name(): string }>) {\n        const argName = arg.name()\n        const camel = argName.replace(/-([a-z])/g, (_: string, c: string) => c.toUpperCase())\n        if (!sub._typedArgNames.includes(camel)) {\n          sub._typedArgNames.push(camel)\n        }\n      }\n    }\n    return result\n  }\n\n  /**\n   * Auto-detect capitalization from user-provided descriptions and match it\n   * for built-in options (-V/--version, -h/--help).\n   */\n  private _capitalizeBuiltinDescriptions(): void {\n    const origHelp = this.helpInformation.bind(this)\n    this.helpInformation = () => {\n      const builtinFlags = new Set([\"-V, --version\", \"-h, --help\"])\n      const userDescs = this.options\n        .filter(\n          (opt) =>\n            !builtinFlags.has(opt.flags) && opt.description && /^[a-zA-Z]/.test(opt.description),\n        )\n        .map((opt) => opt.description!)\n      for (const cmd of this.commands) {\n        if (cmd.description() && /^[a-zA-Z]/.test(cmd.description())) {\n          userDescs.push(cmd.description())\n        }\n      }\n      if (userDescs.length > 0) {\n        const capitalCount = userDescs.filter((d) => /^[A-Z]/.test(d)).length\n        if (capitalCount > userDescs.length / 2) {\n          for (const opt of this.options) {\n            if (builtinFlags.has(opt.flags) && opt.description && /^[a-z]/.test(opt.description)) {\n              opt.description = opt.description[0]!.toUpperCase() + opt.description.slice(1)\n            }\n          }\n          const helpOpt = (this as any)._helpOption\n          if (helpOpt?.description && /^[a-z]/.test(helpOpt.description)) {\n            helpOpt.description =\n              helpOpt.description[0]!.toUpperCase() + helpOpt.description.slice(1)\n          }\n        }\n      }\n      return origHelp()\n    }\n  }\n\n  /**\n   * Render sections for a given position using the help formatter.\n   *\n   * Handles multi-line term entries (terms containing `\\n`) by emitting one\n   * row per line. The description column is **top-aligned**: it appears only\n   * on the first line of a multi-line term, with subsequent lines holding\n   * just the styled term and an empty description column.\n   */\n  private _renderSections(position: HelpSectionPosition, helper: any, termWidth: number): string {\n    const sections = this._helpSectionList.filter((s) => s.position === position)\n    if (sections.length === 0) return \"\"\n\n    const lines: string[] = []\n    for (const section of sections) {\n      lines.push(\"\")\n      lines.push(helper.styleTitle(section.title))\n      if (typeof section.content === \"string\") {\n        for (const line of section.content.split(\"\\n\")) {\n          lines.push(`  ${line}`)\n        }\n      } else {\n        for (const [term, desc] of section.content) {\n          // Multi-line term support: split on \\n, emit one row per line.\n          // First line carries the description; subsequent lines have empty desc.\n          const termLines = term.split(\"\\n\")\n          for (let i = 0; i < termLines.length; i++) {\n            const lineText = termLines[i]!\n            const styledTerm = styleSectionTerm(lineText, helper)\n            const lineDesc = i === 0 ? helper.styleDescriptionText(desc) : \"\"\n            lines.push(helper.formatItem(styledTerm, termWidth, lineDesc, helper))\n          }\n        }\n      }\n    }\n    lines.push(\"\")\n    return lines.join(\"\\n\")\n  }\n\n  /** Install hooks once — merges with existing configureHelp, adds addHelpText for before/afterAll. */\n  private _installHelpSectionHooks(): void {\n    if (this._helpSectionsInstalled) return\n    this._helpSectionsInstalled = true\n\n    const self = this\n    const existing = (this as any)._helpConfiguration ?? {}\n    const origPadWidth = existing.padWidth\n    const origFormatHelp = existing.formatHelp\n    const protoFormatHelp = Help.prototype.formatHelp\n\n    this.configureHelp({\n      ...existing,\n      // Include section term widths in global column alignment\n      padWidth(cmd: any, helper: any) {\n        const base = origPadWidth\n          ? origPadWidth(cmd, helper)\n          : Math.max(\n              helper.longestOptionTermLength(cmd, helper),\n              helper.longestGlobalOptionTermLength?.(cmd, helper) ?? 0,\n              helper.longestSubcommandTermLength(cmd, helper),\n              helper.longestArgumentTermLength(cmd, helper),\n            )\n        if (cmd !== self) return base\n        let sectionMax = 0\n        for (const section of self._helpSectionList) {\n          if (typeof section.content !== \"string\") {\n            for (const [term] of section.content) {\n              // For multi-line terms, use the LONGEST line, not the total length.\n              const w = maxLineWidth(term)\n              if (w > sectionMax) sectionMax = w\n            }\n          }\n        }\n        return Math.max(base, sectionMax)\n      },\n      // Render \"before\" and \"after\" sections inside formatHelp\n      formatHelp(cmd: any, helper: any) {\n        const baseHelp = origFormatHelp\n          ? origFormatHelp(cmd, helper)\n          : protoFormatHelp.call(helper, cmd, helper)\n        // Only render THIS command's sections. configureHelp is inherited by\n        // subcommands, so without this guard parent sections leak into subcommand help.\n        // Subcommands with their own sections install their own hooks.\n        if (cmd !== self) return baseHelp\n        const termWidth = helper.padWidth(cmd, helper)\n        const before = self._renderSections(\"before\", helper, termWidth)\n        const after = self._renderSections(\"after\", helper, termWidth)\n\n        // \"before\" goes after the Usage+Description but before Options.\n        // Since we can't inject mid-formatHelp easily, prepend before baseHelp.\n        // \"after\" appends at the end.\n        return (before ? before + \"\\n\" : \"\") + baseHelp + after\n      },\n    })\n\n    // \"beforeAll\" and \"afterAll\" use Commander's addHelpText (propagates to subcommands)\n    this.addHelpText(\"beforeAll\", () => {\n      const helper = this.createHelp()\n      const termWidth = helper.padWidth(this, helper)\n      return this._renderSections(\"beforeAll\", helper, termWidth)\n    })\n    this.addHelpText(\"afterAll\", () => {\n      const helper = this.createHelp()\n      const termWidth = helper.padWidth(this, helper)\n      return this._renderSections(\"afterAll\", helper, termWidth)\n    })\n  }\n}\n\n// ────────────────────────────────────────────────────────────────\n// Type-safe option inference layer\n//\n// The `Command` type wraps `_CommandBase` with three generic parameters:\n//   - `Opts`       — accumulated options (from `.option()`)\n//   - `Args`       — tuple of positional arg types (from `.argument()`)\n//   - `ArgsRecord` — record mapping arg names to types (for merged form)\n//\n// Each `.option()` overload narrows `Opts`.\n// Each `.argument()` overload appends to both `Args` and `ArgsRecord`.\n// The runtime class is `_CommandBase` — `Command` is just a type alias\n// with a constructor wrapper.\n// ────────────────────────────────────────────────────────────────\n\n// ────────────────────────────────────────────────────────────────\n// Public type: Command<Opts, Args, ArgsRecord>\n//\n// Interface merging adds typed `.option()`, `.argument()`, `.opts()`,\n// and `.action()` overloads on top of `_CommandBase`. The `@ts-expect-error`\n// suppresses the `opts()` return type conflict (we intentionally narrow it\n// from Commander's generic `<T>() => T` to a concrete `() => Opts`).\n// ────────────────────────────────────────────────────────────────\n\n// @ts-expect-error — opts() intentionally narrows from base <T>() => T to () => Opts\nexport interface Command<\n  Opts extends Record<string, unknown> = {},\n  Args extends any[] = [],\n  ArgsRecord extends Record<string, unknown> = {},\n> extends _CommandBase {\n  /** Return option values with full type inference. */\n  opts(): Opts\n\n  /** Accept any `Command<...>` variant as a subcommand. */\n  addCommand(\n    cmd: Command<any, any, any>,\n    opts?: { isDefault?: boolean; hidden?: boolean; noHelp?: boolean },\n  ): this\n\n  /** Factory for subcommands — returns a fresh `Command<{}>`. */\n  createCommand(name?: string): Command<{}, [], {}>\n\n  // -- Chain-preserving overrides for inherited Commander methods --\n  // Without these, calling .description(), .alias(), or .version() loses the\n  // generic type parameters (falls back to base Commander's `this`).\n\n  /** Set command description (preserves typed chain). */\n  description(str: string): this\n  /** Get command description. */\n  description(): string\n\n  /** Set command alias (preserves typed chain). */\n  alias(alias: string): this\n  /** Get command alias. */\n  alias(): string\n\n  /** Set command version (preserves typed chain). */\n  version(str: string, flags?: string, description?: string): this\n\n  // -- Typed option overloads --\n\n  /** Add a choices option: `--env <e>`, `[\"dev\", \"staging\", \"prod\"]` */\n  option<F extends string, const C extends readonly string[]>(\n    flags: F,\n    description: string,\n    choices: C,\n  ): Command<Opts & Record<FlagKey<F>, C[number] | undefined>, Args, ArgsRecord>\n\n  /** Add an option with a CLIType preset (port, csv, uint, etc.) */\n  option<F extends string, T>(\n    flags: F,\n    description: string,\n    schema: CLIType<T>,\n    defaultValue?: T,\n  ): Command<Opts & Record<FlagKey<F>, T | undefined>, Args, ArgsRecord>\n\n  /** Add an option with a Standard Schema v1 validator (Zod, Valibot, ArkType) */\n  option<F extends string, S extends AnyStandardSchema>(\n    flags: F,\n    description: string,\n    schema: S,\n    defaultValue?: SchemaOutput<S>,\n  ): Command<Opts & Record<FlagKey<F>, SchemaOutput<S> | undefined>, Args, ArgsRecord>\n\n  /** Add an option with a parser function */\n  option<F extends string, T>(\n    flags: F,\n    description: string,\n    parseArg: (value: string, previous: T) => T,\n    defaultValue?: T,\n  ): Command<Opts & Record<FlagKey<F>, T | undefined>, Args, ArgsRecord>\n\n  /** Add a boolean flag or string-value option (no parser) */\n  option<F extends string>(\n    flags: F,\n    description?: string,\n    defaultValue?: string | boolean,\n  ): Command<Opts & Record<FlagKey<F>, InferOptionType<F>>, Args, ArgsRecord>\n\n  /**\n   * Fallback: accepts any third argument (legacy Zod, unknown schemas, etc.)\n   * that doesn't match the more specific overloads above.\n   */\n  option<F extends string>(\n    flags: F,\n    description: string,\n    parseArgOrDefault: any,\n    defaultValue?: any,\n  ): Command<Opts, Args, ArgsRecord>\n\n  // -- Typed argument overloads --\n  // Arguments append to the Args tuple (for native .action()) AND to ArgsRecord\n  // (for .actionMerged()). They do NOT merge into Opts — Opts is strictly options-only.\n\n  /** Add a choices argument: `<env>`, `[\"dev\", \"staging\", \"prod\"]` */\n  argument<F extends string, const C extends readonly string[]>(\n    flags: F,\n    description: string,\n    choices: C,\n  ): Command<\n    Opts,\n    [\n      ...Args,\n      IsArgVariadic<F> extends true\n        ? C[number][]\n        : IsArgRequired<F> extends true\n          ? C[number]\n          : C[number] | undefined,\n    ],\n    ArgsRecord &\n      Record<\n        ArgKey<F>,\n        IsArgVariadic<F> extends true\n          ? C[number][]\n          : IsArgRequired<F> extends true\n            ? C[number]\n            : C[number] | undefined\n      >\n  >\n\n  /** Add an argument with a CLIType preset (port, csv, uint, etc.) */\n  argument<F extends string, T>(\n    flags: F,\n    description: string,\n    schema: CLIType<T>,\n    defaultValue?: T,\n  ): Command<\n    Opts,\n    [...Args, InferArgType<F, CLIType<T>>],\n    ArgsRecord & Record<ArgKey<F>, InferArgType<F, CLIType<T>>>\n  >\n\n  /** Add an argument with a Standard Schema v1 validator (Zod, Valibot, ArkType) */\n  argument<F extends string, S extends AnyStandardSchema>(\n    flags: F,\n    description: string,\n    schema: S,\n    defaultValue?: SchemaOutput<S>,\n  ): Command<\n    Opts,\n    [...Args, InferArgType<F, StandardSchemaV1<SchemaOutput<S>>>],\n    ArgsRecord & Record<ArgKey<F>, InferArgType<F, StandardSchemaV1<SchemaOutput<S>>>>\n  >\n\n  /** Add an argument with a parser function */\n  argument<F extends string, T>(\n    flags: F,\n    description: string,\n    parseArg: (value: string, previous: T) => T,\n    defaultValue?: T,\n  ): Command<\n    Opts,\n    [...Args, InferArgType<F, (value: string, previous: T) => T>],\n    ArgsRecord & Record<ArgKey<F>, InferArgType<F, (value: string, previous: T) => T>>\n  >\n\n  /** Add a string argument (no parser) — required, optional, or variadic */\n  argument<F extends string>(\n    flags: F,\n    description?: string,\n    defaultValue?: string,\n  ): Command<Opts, [...Args, InferArgType<F>], ArgsRecord & Record<ArgKey<F>, InferArgType<F>>>\n\n  /** Fallback: accepts any third argument */\n  argument<F extends string>(\n    flags: F,\n    description: string,\n    parseArgOrDefault: any,\n    defaultValue?: any,\n  ): Command<Opts, Args, ArgsRecord>\n\n  // -- Typed action overloads --\n\n  /**\n   * Register an action handler — Commander-native positional form.\n   * Receives `(...positionalArgs, opts, command)`. The command instance is\n   * appended last so it can be safely ignored by handlers that don't need it.\n   */\n  action(\n    fn: (...args: [...Args, Opts, Command<Opts, Args, ArgsRecord>]) => void | Promise<void>,\n  ): this\n\n  /**\n   * Register an action handler — merged named-object form.\n   * Receives `(params, command)` where `params` is a flat object of\n   * args merged with options, keyed by argument/option name.\n   *\n   * Use this when you prefer a single destructured object to multiple positional\n   * parameters — especially for commands with 2+ arguments.\n   */\n  actionMerged(\n    fn: (params: Opts & ArgsRecord, cmd: Command<Opts, Args, ArgsRecord>) => void | Promise<void>,\n  ): this\n\n  // -- Typed command overload --\n\n  /**\n   * Create a subcommand. Returns a fresh `Command<{}, ParsedArgs, ParsedArgsRecord>`.\n   *\n   * Positional arguments embedded in the command name string (`\"deploy <service>\"`)\n   * are parsed at the type level and contribute to the returned `Args` tuple and\n   * `ArgsRecord`. The same shape as if you'd chained `.argument(\"<service>\")`.\n   *\n   * For typed parsers, schemas, or choices, use `.argument()` on the returned\n   * command — the inline string syntax can only express plain string args.\n   * Mixing both forms is allowed: inline args come first in the tuple, then\n   * `.argument()` calls append.\n   */\n  command<S extends string>(\n    nameAndArgs: S,\n    opts?: { isDefault?: boolean; hidden?: boolean; noHelp?: boolean },\n  ): ParseCommandString<S> extends [infer A extends any[], infer R extends Record<string, unknown>]\n    ? Command<{}, A, R>\n    : Command<{}, [], {}>\n\n  /** Overload for command with description (attached-action subcommand, returns parent). */\n  command<S extends string>(\n    nameAndArgs: S,\n    description: string,\n    opts?: { isDefault?: boolean; hidden?: boolean; noHelp?: boolean; executableFile?: string },\n  ): this\n}\n\n/**\n * Type-safe Commander Command with auto-colorized help, Standard Schema support,\n * array-as-choices detection, and inferred option types.\n *\n * Use `.action()` for Commander-native positional form — `(arg1, arg2, opts, cmd) => ...`.\n * Use `.actionMerged()` for a flat destructured form — `({ arg1, arg2, opt1 }, cmd) => ...`.\n *\n * @example\n * ```ts\n * new Command(\"deploy\")\n *   .argument(\"<service>\", \"Service to deploy\")\n *   .argument(\"[env]\", \"Environment\", [\"dev\", \"staging\", \"prod\"] as const)\n *   .option(\"--verbose\", \"Verbose output\")\n *   .action((service, env, opts) => { ... })\n *   // or: .actionMerged(({ service, env, verbose }) => { ... })\n * ```\n */\nexport const Command = _CommandBase as unknown as {\n  new (name?: string): Command<{}, [], {}>\n}\n","/**\n * Extended Zod object with CLI types.\n *\n * Spreads all of Zod's exports and adds CLI-specific schemas.\n * Tree-shakeable -- only evaluated if user imports `z`.\n *\n * @example\n * ```ts\n * import { z, Command } from \"@silvery/commander\"\n *\n * new Command(\"deploy\")\n *   .option(\"-p, --port <n>\", \"Port\", z.port)\n *   .option(\"--tags <t>\", \"Tags\", z.csv)\n *   .option(\"-e, --env <e>\", \"Env\", [\"dev\", \"staging\", \"prod\"])\n *\n * program.parse()\n * ```\n */\n\nimport * as zod from \"zod\"\n\nexport const z = {\n  ...zod,\n  // CLI types (built on Zod schemas)\n  port: zod.coerce.number().int().min(1).max(65535),\n  int: zod.coerce.number().int(),\n  uint: zod.coerce.number().int().min(0),\n  float: zod.coerce.number(),\n  csv: zod.string().transform((v: string) =>\n    v\n      .split(\",\")\n      .map((s: string) => s.trim())\n      .filter(Boolean),\n  ),\n  url: zod.string().url(),\n  path: zod.string().min(1),\n  email: zod.string().email(),\n  date: zod.coerce.date(),\n  json: zod.string().transform((v: string) => JSON.parse(v)),\n  bool: zod\n    .enum([\"true\", \"false\", \"1\", \"0\", \"yes\", \"no\", \"y\", \"n\"] as const)\n    .transform((v: string) => [\"true\", \"1\", \"yes\", \"y\"].includes(v)),\n  intRange: (min: number, max: number) => zod.coerce.number().int().min(min).max(max),\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":["BaseCommand","Option","Help"],"sources":["../src/colorize.ts","../src/tokenize.ts","../src/command.ts","../src/z.ts"],"sourcesContent":["/**\n * Commander.js help colorization using @silvery/ansi.\n *\n * Uses Commander's built-in style hooks (styleTitle, styleOptionText, etc.)\n * rather than regex post-processing.\n *\n * @example\n * ```ts\n * import { Command } from \"@silvery/commander\"\n * // Command auto-colorizes in its constructor — no manual call needed.\n * // For plain Commander:\n * import { colorizeHelp } from \"@silvery/commander\"\n * colorizeHelp(program)\n * ```\n */\n\nimport { createStyle } from \"@silvery/ansi\"\n\n// Auto-detect terminal color level for shouldColorize() checks.\nconst autoStyle = createStyle()\n\n// Forced basic-color style for explicit colorizeHelp() calls.\n// When a user explicitly calls colorizeHelp(), they want color regardless\n// of terminal detection. The function name means \"add color\" — if you\n// don't want color, don't call it.\nconst s = createStyle({ level: \"ansi16\" })\n\n/**\n * Check if color output should be enabled.\n * Delegates to @silvery/ansi's auto-detection (NO_COLOR, FORCE_COLOR, TERM).\n */\nexport function shouldColorize(): boolean {\n  return autoStyle.level > 0\n}\n\n/**\n * Minimal interface for Commander's Command — avoids requiring Commander\n * as a direct dependency. Works with both `commander` and\n * `@silvery/commander`.\n */\nexport interface CommandLike {\n  // biome-ignore lint: permissive to match Commander's overloaded signatures\n  configureHelp(...args: any[]): any\n  // biome-ignore lint: permissive to match Commander's overloaded signatures\n  configureOutput(...args: any[]): any\n  // biome-ignore lint: permissive to match Commander's Command[] structurally\n  readonly commands: readonly any[]\n}\n\n/** Color scheme for help output. Each value is a styling function (text → styled text). */\nexport interface ColorizeHelpOptions {\n  /** Style for command/subcommand names. Default: primary (yellow without theme) */\n  commands?: (text: string) => string\n  /** Style for --flags and -short options. Default: secondary (cyan without theme) */\n  flags?: (text: string) => string\n  /** Style for description text. Default: unstyled (normal foreground) */\n  description?: (text: string) => string\n  /** Style for section headings (Usage:, Options:, etc.). Default: bold */\n  heading?: (text: string) => string\n  /** Style for <required> and [optional] argument brackets. Default: accent (magenta without theme) */\n  brackets?: (text: string) => string\n}\n\n/**\n * Apply colorized help output to a Commander.js program and all its subcommands.\n *\n * Uses Commander's built-in `configureHelp()` style hooks rather than\n * post-processing the formatted string.\n *\n * @param program - A Commander Command instance (or compatible object)\n * @param options - Override default style functions for each element\n */\nexport function colorizeHelp(program: CommandLike, options?: ColorizeHelpOptions): void {\n  // Semantic token fallback: theme token → named color\n  const cmds = options?.commands ?? ((t: string) => s.primary(t))\n  const flags = options?.flags ?? ((t: string) => s.secondary(t))\n  const desc = options?.description ?? ((t: string) => t)\n  const heading = options?.heading ?? ((t: string) => s.bold(t))\n  const brackets = options?.brackets ?? ((t: string) => s.accent(t))\n\n  const helpConfig: Record<string, unknown> = {\n    styleTitle: (str: string) => heading(str),\n    styleCommandText: (str: string) => cmds(str),\n    styleOptionText: (str: string) => flags(str),\n    styleSubcommandText: (str: string) => cmds(str),\n    styleArgumentText: (str: string) => brackets(str),\n    styleDescriptionText: (str: string) => desc(str),\n    styleCommandDescription: (str: string) => s.bold.primary(str),\n  }\n\n  const existingHelp = program.configureHelp()\n  program.configureHelp({ ...existingHelp, ...helpConfig })\n\n  // Tell Commander that color output is supported, even when stdout is not\n  // a TTY. Without this, Commander strips ANSI codes from helpInformation().\n  program.configureOutput({\n    getOutHasColors: () => true,\n    getErrHasColors: () => true,\n  })\n\n  // Apply recursively to all existing subcommands\n  for (const sub of program.commands) {\n    colorizeHelp(sub, options)\n  }\n}\n","/**\n * Shell command-line tokenizer for help-section term styling.\n *\n * Walks a single line of shell-like text and classifies each token so the\n * default text help renderer can style it without re-running the regex\n * machinery on every render. Pure function — no ANSI, no styling.\n *\n * Internal: not exported from index.ts. Used only by command.ts's\n * styleSectionTerm() / _renderSections().\n *\n * Example:\n *   tokenizeCmdline(\"$ termless play -o demo.gif demo.tape\")\n *   →\n *   [\n *     { kind: \"prompt\",     text: \"$ \" },\n *     { kind: \"program\",    text: \"termless\" },\n *     { kind: \"whitespace\", text: \" \" },\n *     { kind: \"subcommand\", text: \"play\" },\n *     { kind: \"whitespace\", text: \" \" },\n *     { kind: \"flag\",       text: \"-o\" },\n *     { kind: \"whitespace\", text: \" \" },\n *     { kind: \"value\",      text: \"demo.gif\" },\n *     { kind: \"whitespace\", text: \" \" },\n *     { kind: \"value\",      text: \"demo.tape\" },\n *   ]\n */\n\nexport type CmdlineToken =\n  | { kind: \"prompt\"; text: string }\n  | { kind: \"program\"; text: string }\n  | { kind: \"subcommand\"; text: string }\n  | { kind: \"flag\"; text: string }\n  | { kind: \"arg-bracket\"; text: string }\n  | { kind: \"quoted\"; text: string }\n  | { kind: \"value\"; text: string }\n  | { kind: \"whitespace\"; text: string }\n\n/** Detect a shell prompt at the start of a line. Supports `$ `, `# `, `> `, `❯ `. */\nconst PROMPT_RE = /^([$#>❯]\\s+)/\n\n/** Match one of: long/short flag, bracket arg, quoted string, bare token, whitespace. */\nconst TOKEN_RE = /(--?\\S+)|(<[^>]+>|\\[[^\\]]+\\])|('[^']*'|\"[^\"]*\")|(\\S+)|(\\s+)/g\n\n/** Bare command-word pattern (letters/digits/dash, no dots or slashes). */\nconst BARE_WORD_RE = /^[a-z][\\w-]*$/i\n\n/**\n * Tokenize a single line of shell-like text.\n *\n * Classification (matches the original styleSectionTerm contract):\n * - First non-whitespace bare word after the prompt is `program`.\n * - The IMMEDIATELY-FOLLOWING bare word (the second bare word) is `subcommand`,\n *   IF it looks like a command word (lowercase letter start, no dots/slashes).\n * - All subsequent bare words are `value`s (filenames, package names, etc.).\n * - Flags (`--foo`, `-f`), bracket args (`<x>`, `[y]`), and quoted strings end\n *   the \"command portion\" — anything after them is a value.\n *\n * The \"max 1 subcommand\" rule keeps `$ npm install foo` correctly classified\n * as program/subcommand/value (not program/subcommand/subcommand). For nested\n * commands (`$ git remote add ...`), only the first subcommand level is styled.\n *\n * If the line has no shell prompt, the same classification still applies —\n * the leading word is `program`, etc.\n */\nexport function tokenizeCmdline(line: string): CmdlineToken[] {\n  const tokens: CmdlineToken[] = []\n\n  // Detect and emit the prompt as a separate token\n  const promptMatch = line.match(PROMPT_RE)\n  let body = line\n  if (promptMatch) {\n    tokens.push({ kind: \"prompt\", text: promptMatch[1]! })\n    body = line.slice(promptMatch[1]!.length)\n  }\n\n  // Tokenize the rest with contextual classification\n  const matches = body.match(TOKEN_RE) ?? []\n  let commandWords = 0\n  let doneWithCommand = false\n\n  for (const token of matches) {\n    if (/^\\s+$/.test(token)) {\n      tokens.push({ kind: \"whitespace\", text: token })\n      continue\n    }\n    if (/^--?\\S/.test(token)) {\n      doneWithCommand = true\n      tokens.push({ kind: \"flag\", text: token })\n      continue\n    }\n    if (/^[<[]/.test(token)) {\n      doneWithCommand = true\n      tokens.push({ kind: \"arg-bracket\", text: token })\n      continue\n    }\n    if (/^[\"']/.test(token)) {\n      doneWithCommand = true\n      tokens.push({ kind: \"quoted\", text: token })\n      continue\n    }\n    // Bare word: the first becomes `program`, the second (if it looks like a\n    // command word — bare lowercase word, no dots/slashes) becomes `subcommand`,\n    // and everything else becomes `value`.\n    if (!doneWithCommand && commandWords === 0) {\n      commandWords++\n      tokens.push({ kind: \"program\", text: token })\n      continue\n    }\n    if (!doneWithCommand && commandWords === 1 && BARE_WORD_RE.test(token)) {\n      commandWords++\n      tokens.push({ kind: \"subcommand\", text: token })\n      continue\n    }\n    // Plain values (filenames, version strings, package names, anything else)\n    doneWithCommand = true\n    tokens.push({ kind: \"value\", text: token })\n  }\n\n  return tokens\n}\n\n/** Returns true if the line starts with a recognized shell prompt. */\nexport function isShellLine(line: string): boolean {\n  return PROMPT_RE.test(line)\n}\n","/**\n * Enhanced Commander Command with auto-colorized help, Standard Schema support,\n * array-as-choices detection, and **type-safe option + argument inference**.\n *\n * Subclasses Commander's Command so `new Command(\"app\")` just works --\n * it's Commander with auto-colorized help, automatic Standard Schema /\n * legacy Zod detection, and array choices in `.option()` and `.argument()`.\n *\n * Each `.option()` call narrows the return type so that `.action()`, `.opts()`,\n * and `.actionMerged()` know exactly which options exist and what types they have.\n * Each `.argument()` call appends to both a positional tuple (for `.action()`)\n * and a named record (for `.actionMerged()`).\n *\n * `.action(fn)` is Commander-native: positional args, then options, then command.\n * `.actionMerged(fn)` is an opt-in helper that merges args and options into a\n * single named object — nicer for commands with many positional arguments.\n *\n * @example\n * ```ts\n * import { Command, port, csv } from \"@silvery/commander\"\n *\n * // Commander-native: positional args, then options\n * new Command(\"deploy\")\n *   .argument(\"<service>\", \"Service to deploy\")\n *   .argument(\"[env]\", \"Environment\", [\"dev\", \"staging\", \"prod\"])\n *   .option(\"-p, --port <n>\", \"Port\", port)\n *   .option(\"--verbose\", \"Verbose output\")\n *   .action((service, env, opts) => {\n *     service       // string\n *     env           // \"dev\" | \"staging\" | \"prod\" | undefined\n *     opts.port     // number | undefined\n *     opts.verbose  // boolean | undefined\n *   })\n *\n * // Merged form: flat named object with args and options merged\n * new Command(\"deploy\")\n *   .argument(\"<service>\")\n *   .argument(\"[env]\", [\"dev\", \"staging\", \"prod\"] as const)\n *   .option(\"-p, --port <n>\", \"Port\", port)\n *   .actionMerged(({ service, env, port }) => { ... })\n *\n * program.parse()\n * ```\n */\n\nimport {\n  Command as BaseCommand,\n  Help,\n  Option,\n  type CommandOptions,\n  type HelpConfiguration,\n} from \"commander\"\nimport { colorizeHelp, shouldColorize } from \"./colorize.ts\"\nimport type { CLIType, StandardSchemaV1 } from \"./presets.ts\"\nimport { tokenizeCmdline, isShellLine, type CmdlineToken } from \"./tokenize.ts\"\n\n/**\n * Broad structural type for schema objects that have a `~standard` property.\n * Matches both our `StandardSchemaV1<T>`, Zod v4's async-capable Standard Schema,\n * and any other library implementing Standard Schema v1.\n *\n * Type extraction works via the `types` property (Standard Schema v1 convention).\n */\ninterface AnyStandardSchema {\n  readonly \"~standard\": {\n    readonly version: 1\n    readonly vendor: string\n    readonly validate: (value: unknown, ...args: any[]) => any\n    readonly types?: { readonly output: unknown } | undefined\n  }\n}\n\n/** Extract the output type from a Standard Schema v1 object. */\ntype SchemaOutput<S extends AnyStandardSchema> = NonNullable<S[\"~standard\"][\"types\"]>[\"output\"]\n\n// ────────────────────────────────────────────────────────────────\n// Type-level flag parsing utilities\n// ────────────────────────────────────────────────────────────────\n\n/**\n * Extract the long option name from a flags string.\n *\n * Examples:\n *   \"-v, --verbose\"        → \"verbose\"\n *   \"--port <n>\"           → \"port\"\n *   \"--dry-run\"            → \"dry-run\"\n *   \"--no-color\"           → \"no-color\"\n *   \"-o, --output [path]\"  → \"output\"\n */\ntype ExtractLongName<S extends string> = S extends `${string}--${infer Rest}`\n  ? Rest extends `${infer Name} ${string}`\n    ? Name\n    : Rest\n  : S extends `-${infer C}, ${infer Rest}`\n    ? Rest extends `${infer Name} ${string}`\n      ? Name\n      : Rest\n    : S extends `-${infer C}`\n      ? C\n      : never\n\n/**\n * Convert kebab-case to camelCase (matching Commander's attributeName()).\n *\n * \"dry-run\"        → \"dryRun\"\n * \"terminal-name\"  → \"terminalName\"\n * \"verbose\"        → \"verbose\"\n */\ntype CamelCase<S extends string> = S extends `${infer A}-${infer B}${infer Rest}`\n  ? `${A}${Uppercase<B>}${CamelCase<Rest>}`\n  : S\n\n// ────────────────────────────────────────────────────────────────\n// Type-level argument parsing utilities\n// ────────────────────────────────────────────────────────────────\n\n/**\n * Extract the argument name from a flags string.\n *\n * Examples:\n *   \"<service>\"       → \"service\"\n *   \"[env]\"           → \"env\"\n *   \"<files...>\"      → \"files\"\n *   \"<service-name>\"  → \"service-name\"\n */\ntype ExtractArgName<S extends string> = S extends `<${infer Name}...>`\n  ? Name\n  : S extends `<${infer Name}>`\n    ? Name\n    : S extends `[${infer Name}...]`\n      ? Name\n      : S extends `[${infer Name}]`\n        ? Name\n        : never\n\n/** Is the argument required (wrapped in `<...>`)? */\ntype IsArgRequired<S extends string> = S extends `<${string}>` ? true : false\n\n/** Is the argument variadic (ends with `...>` or `...]`)? */\ntype IsArgVariadic<S extends string> = S extends `${string}...${string}` ? true : false\n\n/**\n * Derive the property key from an argument flags string.\n * Applies: extract name → camelCase.\n */\ntype ArgKey<S extends string> = CamelCase<ExtractArgName<S>>\n\n/**\n * Parse positional arguments embedded in a command name string.\n *\n * Commander.js accepts argument syntax inline with command names:\n *   `\"deploy <service>\"`            → 1 required arg\n *   `\"deploy <service> [env]\"`      → 1 required + 1 optional\n *   `\"deploy <files...>\"`           → 1 required variadic\n *\n * `ParseCommandString<S>` returns `[Args tuple, ArgsRecord]` so the typed\n * `command<S>()` overload can produce a `Command<{}, Args, ArgsRecord>` with\n * the same type information you'd get from chaining `.argument()` calls.\n *\n * Limitations: only plain string types — `<svc>` is `string`, `[env]` is\n * `string | undefined`, `<files...>` is `string[]`. Parsers, schemas, and\n * choices still require `.argument()` because the inline string syntax can't\n * express them. Mixing inline args with `.argument()` calls is allowed:\n * the inline ones come first in the tuple, the `.argument()` ones append.\n */\n\n/** Split a command name string at the first space. `\"deploy <service>\"` → `[\"deploy\", \"<service>\"]` */\ntype SplitCommandHead<S extends string> = S extends `${infer Name} ${infer Rest}`\n  ? [Name, Rest]\n  : [S, \"\"]\n\n/** Walk the tail tokens after the command name and build [Args tuple, ArgsRecord]. */\ntype ParseInlineArgs<S extends string, Tuple extends any[] = [], Rec = {}> = S extends \"\"\n  ? [Tuple, Rec]\n  : S extends `${infer Tok} ${infer Rest}`\n    ? Tok extends `<${infer Name}...>`\n      ? ParseInlineArgs<Rest, [...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>>\n      : Tok extends `<${infer Name}>`\n        ? ParseInlineArgs<Rest, [...Tuple, string], Rec & Record<CamelCase<Name>, string>>\n        : Tok extends `[${infer Name}...]`\n          ? ParseInlineArgs<Rest, [...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>>\n          : Tok extends `[${infer Name}]`\n            ? ParseInlineArgs<\n                Rest,\n                [...Tuple, string | undefined],\n                Rec & Record<CamelCase<Name>, string | undefined>\n              >\n            : ParseInlineArgs<Rest, Tuple, Rec> // skip non-arg tokens\n    : // Last token (no trailing space)\n      S extends `<${infer Name}...>`\n      ? [[...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>]\n      : S extends `<${infer Name}>`\n        ? [[...Tuple, string], Rec & Record<CamelCase<Name>, string>]\n        : S extends `[${infer Name}...]`\n          ? [[...Tuple, string[]], Rec & Record<CamelCase<Name>, string[]>]\n          : S extends `[${infer Name}]`\n            ? [[...Tuple, string | undefined], Rec & Record<CamelCase<Name>, string | undefined>]\n            : [Tuple, Rec]\n\n/** Top-level: parse a `command(name)` string into [Args tuple, ArgsRecord]. */\ntype ParseCommandString<S extends string> =\n  SplitCommandHead<S> extends [infer _Name, infer Tail extends string]\n    ? Tail extends \"\"\n      ? [[], {}]\n      : ParseInlineArgs<Tail>\n    : [[], {}]\n\n/**\n * Infer the value type for an argument based on its flags string and\n * the optional parser/choices/schema.\n *\n * Rules:\n *   <required>            → string\n *   [optional]            → string | undefined\n *   <variadic...>         → string[]\n *   [variadic...]         → string[]\n *   with parser fn        → ReturnType<parser> (+ | undefined if optional)\n *   with CLIType<T>       → T (+ | undefined if optional)\n *   with StandardSchema   → T (+ | undefined if optional)\n *   with choices[]        → choices[number] (+ | undefined if optional)\n */\ntype InferArgType<Flags extends string, ParseArg = undefined> =\n  IsArgVariadic<Flags> extends true\n    ? ParseArg extends readonly (infer C)[]\n      ? C[]\n      : ParseArg extends CLIType<infer T>\n        ? T[]\n        : ParseArg extends StandardSchemaV1<infer T>\n          ? T[]\n          : ParseArg extends (value: string, ...args: any[]) => infer R\n            ? R[]\n            : string[]\n    : IsArgRequired<Flags> extends true\n      ? ParseArg extends readonly (infer C)[]\n        ? C\n        : ParseArg extends CLIType<infer T>\n          ? T\n          : ParseArg extends StandardSchemaV1<infer T>\n            ? T\n            : ParseArg extends (value: string, ...args: any[]) => infer R\n              ? R\n              : string\n      : ParseArg extends readonly (infer C)[]\n        ? C | undefined\n        : ParseArg extends CLIType<infer T>\n          ? T | undefined\n          : ParseArg extends StandardSchemaV1<infer T>\n            ? T | undefined\n            : ParseArg extends (value: string, ...args: any[]) => infer R\n              ? R | undefined\n              : string | undefined\n\n/**\n * Strip \"no-\" prefix from negated flags.\n * \"--no-color\" → long name \"no-color\" → stripped to \"color\"\n */\ntype StripNo<S extends string> = S extends `no-${infer Rest}` ? Rest : S\n\n/**\n * Derive the property key from a flags string.\n * Applies: extract long name → strip \"no-\" → camelCase.\n */\ntype FlagKey<S extends string> = CamelCase<StripNo<ExtractLongName<S>>>\n\n/**\n * Does the flags string contain a required value argument `<...>`?\n */\ntype HasRequiredArg<S extends string> = S extends `${string}<${string}>${string}` ? true : false\n\n/**\n * Does the flags string contain an optional value argument `[...]`?\n */\ntype HasOptionalArg<S extends string> = S extends `${string}[${string}]${string}` ? true : false\n\n/**\n * Does the flags string start with `--no-`?\n */\ntype IsNegated<S extends string> = ExtractLongName<S> extends `no-${string}` ? true : false\n\n/**\n * Infer the value type for a flag based on the flags string and the\n * optional third argument (parser function, Standard Schema, choices array).\n *\n * Rules (mirroring Commander runtime behavior):\n *   --flag                    → boolean | undefined\n *   --no-flag                 → boolean\n *   --flag <value>            → string | undefined  (or parser return type)\n *   --flag [value]            → string | boolean | undefined (or parser return type | boolean)\n *   --flag <value>, parser fn → ReturnType<parser> | undefined\n *   --flag <value>, CLIType<T> / StandardSchemaV1<T> → T | undefined\n *   --flag <value>, choices[] → choices[number] | undefined\n */\ntype InferOptionType<Flags extends string, ParseArg = undefined> =\n  IsNegated<Flags> extends true\n    ? boolean\n    : HasRequiredArg<Flags> extends true\n      ? ParseArg extends readonly (infer C)[]\n        ? C | undefined\n        : ParseArg extends CLIType<infer T>\n          ? T | undefined\n          : ParseArg extends StandardSchemaV1<infer T>\n            ? T | undefined\n            : ParseArg extends (value: string, ...args: any[]) => infer R\n              ? R | undefined\n              : string | undefined\n      : HasOptionalArg<Flags> extends true\n        ? ParseArg extends readonly (infer C)[]\n          ? C | boolean | undefined\n          : ParseArg extends CLIType<infer T>\n            ? T | boolean | undefined\n            : ParseArg extends StandardSchemaV1<infer T>\n              ? T | boolean | undefined\n              : ParseArg extends (value: string, ...args: any[]) => infer R\n                ? R | boolean | undefined\n                : string | boolean | undefined\n        : boolean | undefined\n\n// --- Standard Schema support ---\n\n/** Runtime check: is this value a Standard Schema v1 object? */\nfunction isStandardSchema(value: unknown): value is StandardSchemaV1 {\n  return typeof value === \"object\" && value !== null && \"~standard\" in (value as any)\n}\n\n/** Wrap a Standard Schema as a Commander parser function */\nfunction standardSchemaParser<T>(schema: StandardSchemaV1<T>): (value: string) => T {\n  return (value: string) => {\n    const result = schema[\"~standard\"].validate(value)\n    if (\"issues\" in result) {\n      const msg = result.issues.map((i) => i.message).join(\", \")\n      throw new Error(msg)\n    }\n    return result.value\n  }\n}\n\n// --- Legacy Zod support (pre-3.24, no ~standard) ---\n\ninterface ZodLike<T = any> {\n  parse(value: unknown): T\n  _def: unknown\n}\n\nfunction isLegacyZodSchema(value: unknown): value is ZodLike {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as any).parse === \"function\" &&\n    \"_def\" in (value as any) &&\n    !(\"~standard\" in (value as any))\n  )\n}\n\nfunction legacyZodParser<T>(schema: ZodLike<T>): (value: string) => T {\n  return (value: string) => {\n    try {\n      return schema.parse(value)\n    } catch (err: any) {\n      if (err?.issues) {\n        const messages = err.issues.map((i: any) => i.message).join(\", \")\n        throw new Error(messages)\n      }\n      throw err\n    }\n  }\n}\n\n// --- Help Section Types ---\n\n/** Position for help sections — mirrors Commander's addHelpText positions. */\nexport type HelpSectionPosition = \"beforeAll\" | \"before\" | \"after\" | \"afterAll\"\n\n/** Content for a help section: rows of [term, description] pairs, or free-form text. */\nexport type HelpSectionContent = [string, string][] | string\n\n// Internal storage\ninterface StoredSection {\n  position: HelpSectionPosition\n  title: string\n  content: HelpSectionContent\n}\n\n/**\n * Style a SINGLE-LINE section term using Commander's style hooks.\n *\n * Three modes:\n * - Shell command line (`$ termless play demo.tape`): tokenize via tokenizeCmdline()\n *   and style each token by kind (dim prompt, primary program/subcommand,\n *   secondary flags, accent brackets, dim quoted strings, plain values)\n * - Option-like (`-f, --flag`): entire term styled as option\n * - Plain text: command words + argument brackets\n *\n * For multi-line terms, callers split on \\n and call this per line — see\n * _renderSections().\n */\nfunction styleSectionTerm(term: string, helper: any): string {\n  // Shell command terms (start with \"$ \", \"# \", \"> \", \"❯ \")\n  if (isShellLine(term)) {\n    return styleCmdlineTokens(tokenizeCmdline(term), helper)\n  }\n\n  // Option-like terms: entire term styled as option\n  if (/^\\s*-/.test(term)) return helper.styleOptionText(term)\n\n  // Command-like terms: style command words with primary, <brackets> with accent\n  // Split into bracket groups and non-bracket parts\n  const parts = term.split(/(<[^>]+>|\\[[^\\]]+\\])/g)\n  if (parts.length === 1) {\n    // No brackets — style entire term as command\n    return helper.styleCommandText(term)\n  }\n  // Mix of command text and brackets\n  return parts\n    .map((part) => {\n      if (/^[<[]/.test(part)) return helper.styleArgumentText(part)\n      if (part) return helper.styleCommandText(part)\n      return part\n    })\n    .join(\"\")\n}\n\n/**\n * Apply style hooks to a stream of CmdlineTokens.\n *\n * Each token kind maps to one of Commander's style hooks (or a manual ANSI\n * dim escape for prompts/quoted strings, since Commander's style hook set\n * doesn't have a \"dim\" entry).\n */\nfunction styleCmdlineTokens(tokens: CmdlineToken[], helper: any): string {\n  const dim = (text: string) => (shouldColorize() ? `\\x1b[2m${text}\\x1b[22m` : text)\n  return tokens\n    .map((t) => {\n      switch (t.kind) {\n        case \"prompt\":\n          return dim(t.text)\n        case \"program\":\n        case \"subcommand\":\n          return helper.styleCommandText(t.text)\n        case \"flag\":\n          return helper.styleOptionText(t.text)\n        case \"arg-bracket\":\n          return helper.styleArgumentText(t.text)\n        case \"quoted\":\n          return dim(t.text)\n        case \"value\":\n        case \"whitespace\":\n          return t.text\n      }\n    })\n    .join(\"\")\n}\n\n/**\n * Compute the longest visual width of any line within a (possibly multi-line) term.\n * Used for column alignment when terms span multiple lines.\n */\nfunction maxLineWidth(term: string): number {\n  let max = 0\n  for (const line of term.split(\"\\n\")) {\n    if (line.length > max) max = line.length\n  }\n  return max\n}\n\n// ────────────────────────────────────────────────────────────────\n// Command class — runtime implementation (non-generic)\n//\n// The class itself is NOT generic. Type-safe option inference is\n// layered on via interface merging below (see `TypedOptionOverloads`).\n// This keeps the class fully compatible with Commander's base Command\n// (no `noImplicitOverride` or structural assignability issues).\n// ────────────────────────────────────────────────────────────────\n\nconst silentAliasesSymbol = Symbol(\"silvery.commander.silentAliases\")\ntype CommandWithSilentAliases = BaseCommand & { [silentAliasesSymbol]?: string[] }\n\nclass _CommandBase extends BaseCommand {\n  private _helpSectionList: StoredSection[] = []\n  private _helpSectionsInstalled = false\n\n  /** Argument names registered via typed .argument() — used by .action() to merge into opts. */\n  _typedArgNames: string[] = []\n\n  constructor(name?: string) {\n    super(name)\n    // Auto-colorize only when color detection says the output supports it.\n    // Unconditional colorization here shipped ANSI codes to pipes and ignored\n    // NO_COLOR (found by gitbay's CLI tests, 2026-07-07): colorizeHelp() is\n    // the explicit \"force color\" path, so the AUTO path must gate on the same\n    // detection shouldColorize() already exposes.\n    if (shouldColorize()) colorizeHelp(this as any)\n    this._capitalizeBuiltinDescriptions()\n  }\n\n  /** Compose help customizations while preserving the enhanced command's installed hooks. */\n  override configureHelp(configuration: HelpConfiguration): this\n  override configureHelp(): HelpConfiguration\n  override configureHelp(configuration?: HelpConfiguration): this | HelpConfiguration {\n    if (configuration === undefined) return super.configureHelp()\n    return super.configureHelp({ ...super.configureHelp(), ...configuration })\n  }\n\n  /** Return every spelling accepted for a command, including parse-only aliases. */\n  private _commandIdentities(command: BaseCommand): string[] {\n    return [command.name(), ...command.aliases(), ...this._silentAliasesFor(command)]\n  }\n\n  private _silentAliasesFor(command: BaseCommand): string[] {\n    return (command as CommandWithSilentAliases)[silentAliasesSymbol] ?? []\n  }\n\n  private _addSilentAlias(command: BaseCommand, alias: string): void {\n    const target = command as CommandWithSilentAliases\n    const aliases = target[silentAliasesSymbol]\n    if (aliases) {\n      aliases.push(alias)\n      return\n    }\n    Object.defineProperty(target, silentAliasesSymbol, { value: [alias] })\n  }\n\n  /** Match the executable-child forwarding used by Commander's alias(). */\n  private _aliasTarget(): BaseCommand {\n    const lastCommand = this.commands[this.commands.length - 1] as\n      | (BaseCommand & { _executableHandler?: boolean })\n      | undefined\n    return lastCommand?._executableHandler ? lastCommand : this\n  }\n\n  /** Parent lookup used by Commander parsing; silent aliases never enter normal alias metadata. */\n  _findCommand(name?: string): BaseCommand | undefined {\n    if (!name) return undefined\n    return this.commands.find((command) => this._commandIdentities(command).includes(name))\n  }\n\n  private _assertAliasAvailable(command: BaseCommand, alias: string): void {\n    if (alias === command.name()) {\n      throw new Error(\"Command alias can't be the same as its name\")\n    }\n\n    const ownAliases = [...command.aliases(), ...this._silentAliasesFor(command)]\n    const matchingCommand = ownAliases.includes(alias)\n      ? command\n      : command.parent?.commands.find((candidate) =>\n          this._commandIdentities(candidate).includes(alias),\n        )\n    if (matchingCommand) {\n      const existingCommand = this._commandIdentities(matchingCommand).join(\"|\")\n      throw new Error(\n        `cannot add alias '${alias}' to command '${command.name()}' as already have command '${existingCommand}'`,\n      )\n    }\n  }\n\n  override alias(alias: string): this\n  override alias(): string\n  override alias(alias?: string): this | string {\n    if (alias === undefined) return super.alias()\n    this._assertAliasAvailable(this._aliasTarget(), alias)\n    return super.alias(alias)\n  }\n\n  /** Add an accepted command spelling which is omitted from help, usage, and suggestions. */\n  silentAlias(alias: string): this {\n    const command = this._aliasTarget()\n    this._assertAliasAvailable(command, alias)\n    this._addSilentAlias(command, alias)\n    return this\n  }\n\n  override addCommand(command: BaseCommand, opts?: CommandOptions): this {\n    if (!command.name()) return super.addCommand(command, opts)\n\n    const identities = this._commandIdentities(command)\n    const seen = new Set<string>()\n    for (const identity of identities) {\n      const matchingCommand = seen.has(identity) ? command : this._findCommand(identity)\n      if (matchingCommand) {\n        const existingCommand = this._commandIdentities(matchingCommand).join(\"|\")\n        const newCommand = identities.join(\"|\")\n        throw new Error(\n          `cannot add command '${newCommand}' as already have command '${existingCommand}'`,\n        )\n      }\n      seen.add(identity)\n    }\n\n    return super.addCommand(command, opts)\n  }\n\n  /**\n   * Add an option with smart third-argument detection.\n   *\n   * The third argument is detected in order:\n   * 1. **Array** -- treated as choices (Commander `.choices()`)\n   * 2. **Standard Schema v1** -- wrapped as a parser function\n   * 3. **Legacy Zod** (pre-3.24, has `_def` + `parse`) -- wrapped as a parser\n   * 4. **Function** -- passed through as Commander's parser function\n   * 5. **Anything else** -- passed through as a default value\n   */\n  override option(\n    flags: string,\n    description?: string,\n    parseArgOrDefault?: any,\n    defaultValue?: any,\n  ): this {\n    if (Array.isArray(parseArgOrDefault)) {\n      const opt = new Option(flags, description ?? \"\").choices(parseArgOrDefault as string[])\n      this.addOption(opt)\n      return this\n    }\n    if (isStandardSchema(parseArgOrDefault)) {\n      return super.option(\n        flags,\n        description ?? \"\",\n        standardSchemaParser(parseArgOrDefault),\n        defaultValue,\n      )\n    }\n    if (isLegacyZodSchema(parseArgOrDefault)) {\n      return super.option(\n        flags,\n        description ?? \"\",\n        legacyZodParser(parseArgOrDefault),\n        defaultValue,\n      )\n    }\n    if (typeof parseArgOrDefault === \"function\") {\n      return super.option(flags, description ?? \"\", parseArgOrDefault, defaultValue)\n    }\n    return super.option(flags, description ?? \"\", parseArgOrDefault)\n  }\n\n  /**\n   * Add an argument with smart third-argument detection.\n   *\n   * Same detection as `.option()`: array → choices, Standard Schema → parser,\n   * legacy Zod → parser, function → parser, anything else → default value.\n   * Tracks argument names for `.action()` merging.\n   */\n  override argument(\n    flags: string,\n    description?: string,\n    parseArgOrDefault?: any,\n    defaultValue?: any,\n  ): this {\n    // Extract the camelCase name from the flags string for action() merging\n    const rawName = flags.replace(/[<[\\]>.]/g, \"\").trim()\n    const camelName = rawName.replace(/-([a-z])/g, (_: string, c: string) => c.toUpperCase())\n    this._typedArgNames.push(camelName)\n\n    if (Array.isArray(parseArgOrDefault)) {\n      const arg = this.createArgument(flags, description ?? \"\")\n      arg.choices(parseArgOrDefault as string[])\n      this.addArgument(arg)\n      return this\n    }\n    if (isStandardSchema(parseArgOrDefault)) {\n      return super.argument(\n        flags,\n        description ?? \"\",\n        standardSchemaParser(parseArgOrDefault),\n        defaultValue,\n      )\n    }\n    if (isLegacyZodSchema(parseArgOrDefault)) {\n      return super.argument(\n        flags,\n        description ?? \"\",\n        legacyZodParser(parseArgOrDefault),\n        defaultValue,\n      )\n    }\n    if (typeof parseArgOrDefault === \"function\") {\n      return super.argument(flags, description ?? \"\", parseArgOrDefault, defaultValue)\n    }\n    return super.argument(flags, description ?? \"\", parseArgOrDefault)\n  }\n\n  /**\n   * Register an action callback with a named-parameter object instead of positional args.\n   *\n   * The handler receives a single object containing all positional arguments\n   * (merged by name) and all options, plus the Command instance as a second arg.\n   * Argument names come from the typed `.argument()` calls, camelCased.\n   *\n   * This is a convenience wrapper over `.action()` — `.action()` itself remains\n   * Commander-native `(...args, opts, command) => ...`. Prefer `.action()` for\n   * single-arg commands (where positional is more ergonomic) and `.actionMerged()`\n   * for multi-arg commands (where a flat named object is nicer).\n   *\n   * @example\n   * ```ts\n   * new Command(\"deploy\")\n   *   .argument(\"<service>\")\n   *   .argument(\"[env]\")\n   *   .option(\"-p, --port <n>\", port)\n   *   .actionMerged(({ service, env, port }, cmd) => {\n   *     // service, env, port are all typed\n   *     // cmd is the Command instance\n   *   })\n   * ```\n   */\n  actionMerged(fn: (params: any, cmd: any) => any): this {\n    const argNames = this._typedArgNames\n    return super.action((...args: any[]) => {\n      // Commander passes: (arg1, arg2, ..., opts, command)\n      const cmd = args[args.length - 1]\n      const opts = args[args.length - 2] ?? {}\n      const merged: Record<string, unknown> = { ...opts }\n      for (let i = 0; i < argNames.length; i++) {\n        merged[argNames[i]!] = args[i]\n      }\n      return fn(merged, cmd)\n    })\n  }\n\n  /**\n   * Add a styled help section — like Commander's `addHelpText` but with\n   * structured content that participates in global column alignment.\n   *\n   * @example\n   * ```ts\n   * // Rows with aligned descriptions (default position: \"after\")\n   * program.addHelpSection(\"Getting Started:\", [\n   *   [\"myapp init\", \"Initialize a new project\"],\n   *   [\"myapp serve\", \"Start the dev server\"],\n   * ])\n   *\n   * // Free-form text\n   * program.addHelpSection(\"Note:\", \"Requires Node.js 23+\")\n   *\n   * // Explicit position\n   * program.addHelpSection(\"before\", \"Prerequisites:\", [\n   *   [\"node >= 23\", \"Required runtime\"],\n   * ])\n   * ```\n   */\n  addHelpSection(title: string, content: HelpSectionContent): this\n  addHelpSection(position: HelpSectionPosition, title: string, content: HelpSectionContent): this\n  addHelpSection(\n    positionOrTitle: HelpSectionPosition | string,\n    titleOrContent: string | HelpSectionContent,\n    content?: HelpSectionContent,\n  ): this {\n    let position: HelpSectionPosition\n    let title: string\n    let body: HelpSectionContent\n\n    if (content !== undefined) {\n      // 3-arg: addHelpSection(position, title, content)\n      position = positionOrTitle as HelpSectionPosition\n      title = titleOrContent as string\n      body = content\n    } else {\n      // 2-arg: addHelpSection(title, content) — defaults to \"after\"\n      position = \"after\"\n      title = positionOrTitle\n      body = titleOrContent as HelpSectionContent\n    }\n\n    this._helpSectionList.push({ position, title, content: body })\n    this._installHelpSectionHooks()\n    return this\n  }\n\n  // Subcommands also get colorized help, Standard Schema, and array choices\n  override createCommand(name?: string): _CommandBase {\n    return new _CommandBase(name)\n  }\n\n  /**\n   * Override Commander's `command()` to mirror inline-arg names (from\n   * `command(\"deploy <service>\")`) into our `_typedArgNames`. This keeps\n   * `.actionMerged()` working on subcommands declared with the inline form,\n   * since the merged dispatch reads from `_typedArgNames` to know which\n   * positional indices map to which key.\n   *\n   * Both forms now coexist:\n   *   .command(\"deploy <service>\")               // inline — names from string\n   *   .command(\"deploy\").argument(\"<service>\")   // explicit — names from .argument()\n   * Both produce equivalent runtime + type behavior.\n   */\n  override command(...args: any[]): any {\n    // biome-ignore lint: variadic forwarding\n    const result = (super.command as any).apply(this, args)\n    // The newly-created subcommand is always the last entry in this.commands\n    // (Commander appends after createCommand). Its _args field has been populated\n    // by Commander's own parsing of the name string.\n    const sub = this.commands[this.commands.length - 1] as _CommandBase | undefined\n    if (sub && Array.isArray((sub as any)._args)) {\n      for (const arg of (sub as any)._args as Array<{ name(): string }>) {\n        const argName = arg.name()\n        const camel = argName.replace(/-([a-z])/g, (_: string, c: string) => c.toUpperCase())\n        if (!sub._typedArgNames.includes(camel)) {\n          sub._typedArgNames.push(camel)\n        }\n      }\n    }\n    return result\n  }\n\n  /**\n   * Auto-detect capitalization from user-provided descriptions and match it\n   * for built-in options (-V/--version, -h/--help).\n   */\n  private _capitalizeBuiltinDescriptions(): void {\n    const origHelp = this.helpInformation.bind(this)\n    this.helpInformation = () => {\n      const builtinFlags = new Set([\"-V, --version\", \"-h, --help\"])\n      const userDescs = this.options\n        .filter(\n          (opt) =>\n            !builtinFlags.has(opt.flags) && opt.description && /^[a-zA-Z]/.test(opt.description),\n        )\n        .map((opt) => opt.description!)\n      for (const cmd of this.commands) {\n        if (cmd.description() && /^[a-zA-Z]/.test(cmd.description())) {\n          userDescs.push(cmd.description())\n        }\n      }\n      if (userDescs.length > 0) {\n        const capitalCount = userDescs.filter((d) => /^[A-Z]/.test(d)).length\n        if (capitalCount > userDescs.length / 2) {\n          for (const opt of this.options) {\n            if (builtinFlags.has(opt.flags) && opt.description && /^[a-z]/.test(opt.description)) {\n              opt.description = opt.description[0]!.toUpperCase() + opt.description.slice(1)\n            }\n          }\n          const helpOpt = (this as any)._helpOption\n          if (helpOpt?.description && /^[a-z]/.test(helpOpt.description)) {\n            helpOpt.description =\n              helpOpt.description[0]!.toUpperCase() + helpOpt.description.slice(1)\n          }\n        }\n      }\n      return origHelp()\n    }\n  }\n\n  /**\n   * Render sections for a given position using the help formatter.\n   *\n   * Handles multi-line term entries (terms containing `\\n`) by emitting one\n   * row per line. The description column is **top-aligned**: it appears only\n   * on the first line of a multi-line term, with subsequent lines holding\n   * just the styled term and an empty description column.\n   */\n  private _renderSections(position: HelpSectionPosition, helper: any, termWidth: number): string {\n    const sections = this._helpSectionList.filter((s) => s.position === position)\n    if (sections.length === 0) return \"\"\n\n    const lines: string[] = []\n    for (const section of sections) {\n      lines.push(\"\")\n      lines.push(helper.styleTitle(section.title))\n      if (typeof section.content === \"string\") {\n        for (const line of section.content.split(\"\\n\")) {\n          lines.push(`  ${line}`)\n        }\n      } else {\n        for (const [term, desc] of section.content) {\n          // Multi-line term support: split on \\n, emit one row per line.\n          // First line carries the description; subsequent lines have empty desc.\n          const termLines = term.split(\"\\n\")\n          for (let i = 0; i < termLines.length; i++) {\n            const lineText = termLines[i]!\n            const styledTerm = styleSectionTerm(lineText, helper)\n            const lineDesc = i === 0 ? helper.styleDescriptionText(desc) : \"\"\n            lines.push(helper.formatItem(styledTerm, termWidth, lineDesc, helper))\n          }\n        }\n      }\n    }\n    lines.push(\"\")\n    return lines.join(\"\\n\")\n  }\n\n  /** Install hooks once — merges with existing configureHelp, adds addHelpText for before/afterAll. */\n  private _installHelpSectionHooks(): void {\n    if (this._helpSectionsInstalled) return\n    this._helpSectionsInstalled = true\n\n    const self = this\n    const existing = (this as any)._helpConfiguration ?? {}\n    const origPadWidth = existing.padWidth\n    const origFormatHelp = existing.formatHelp\n    const protoFormatHelp = Help.prototype.formatHelp\n\n    this.configureHelp({\n      ...existing,\n      // Include section term widths in global column alignment\n      padWidth(cmd: any, helper: any) {\n        const base = origPadWidth\n          ? origPadWidth(cmd, helper)\n          : Math.max(\n              helper.longestOptionTermLength(cmd, helper),\n              helper.longestGlobalOptionTermLength?.(cmd, helper) ?? 0,\n              helper.longestSubcommandTermLength(cmd, helper),\n              helper.longestArgumentTermLength(cmd, helper),\n            )\n        if (cmd !== self) return base\n        let sectionMax = 0\n        for (const section of self._helpSectionList) {\n          if (typeof section.content !== \"string\") {\n            for (const [term] of section.content) {\n              // For multi-line terms, use the LONGEST line, not the total length.\n              const w = maxLineWidth(term)\n              if (w > sectionMax) sectionMax = w\n            }\n          }\n        }\n        return Math.max(base, sectionMax)\n      },\n      // Render \"before\" and \"after\" sections inside formatHelp\n      formatHelp(cmd: any, helper: any) {\n        const baseHelp = origFormatHelp\n          ? origFormatHelp(cmd, helper)\n          : protoFormatHelp.call(helper, cmd, helper)\n        // Only render THIS command's sections. configureHelp is inherited by\n        // subcommands, so without this guard parent sections leak into subcommand help.\n        // Subcommands with their own sections install their own hooks.\n        if (cmd !== self) return baseHelp\n        const termWidth = helper.padWidth(cmd, helper)\n        const before = self._renderSections(\"before\", helper, termWidth)\n        const after = self._renderSections(\"after\", helper, termWidth)\n\n        // \"before\" goes after the Usage+Description but before Options.\n        // Since we can't inject mid-formatHelp easily, prepend before baseHelp.\n        // \"after\" appends at the end.\n        return (before ? before + \"\\n\" : \"\") + baseHelp + after\n      },\n    })\n\n    // \"beforeAll\" and \"afterAll\" use Commander's addHelpText (propagates to subcommands)\n    this.addHelpText(\"beforeAll\", () => {\n      const helper = this.createHelp()\n      const termWidth = helper.padWidth(this, helper)\n      return this._renderSections(\"beforeAll\", helper, termWidth)\n    })\n    this.addHelpText(\"afterAll\", () => {\n      const helper = this.createHelp()\n      const termWidth = helper.padWidth(this, helper)\n      return this._renderSections(\"afterAll\", helper, termWidth)\n    })\n  }\n}\n\n// ────────────────────────────────────────────────────────────────\n// Type-safe option inference layer\n//\n// The `Command` type wraps `_CommandBase` with three generic parameters:\n//   - `Opts`       — accumulated options (from `.option()`)\n//   - `Args`       — tuple of positional arg types (from `.argument()`)\n//   - `ArgsRecord` — record mapping arg names to types (for merged form)\n//\n// Each `.option()` overload narrows `Opts`.\n// Each `.argument()` overload appends to both `Args` and `ArgsRecord`.\n// The runtime class is `_CommandBase` — `Command` is just a type alias\n// with a constructor wrapper.\n// ────────────────────────────────────────────────────────────────\n\n// ────────────────────────────────────────────────────────────────\n// Public type: Command<Opts, Args, ArgsRecord>\n//\n// Interface merging adds typed `.option()`, `.argument()`, `.opts()`,\n// and `.action()` overloads on top of `_CommandBase`. The `@ts-expect-error`\n// suppresses the `opts()` return type conflict (we intentionally narrow it\n// from Commander's generic `<T>() => T` to a concrete `() => Opts`).\n// ────────────────────────────────────────────────────────────────\n\n// @ts-expect-error — opts() intentionally narrows from base <T>() => T to () => Opts\nexport interface Command<\n  Opts extends Record<string, unknown> = {},\n  Args extends any[] = [],\n  ArgsRecord extends Record<string, unknown> = {},\n> extends _CommandBase {\n  /** Return option values with full type inference. */\n  opts(): Opts\n\n  /** Accept raw Commander commands and any enhanced `Command<...>` variant. */\n  addCommand(\n    cmd: BaseCommand | Command<any, any, any>,\n    opts?: { isDefault?: boolean; hidden?: boolean; noHelp?: boolean },\n  ): this\n\n  /** Factory for subcommands — returns a fresh `Command<{}>`. */\n  createCommand(name?: string): Command<{}, [], {}>\n\n  // -- Chain-preserving overrides for inherited Commander methods --\n  // Without these, calling .description(), .alias(), or .version() loses the\n  // generic type parameters (falls back to base Commander's `this`).\n\n  /** Set command description (preserves typed chain). */\n  description(str: string): this\n  /** Get command description. */\n  description(): string\n\n  /** Set command alias (preserves typed chain). */\n  alias(alias: string): this\n  /** Get command alias. */\n  alias(): string\n\n  /** Add a parse-only alias omitted from help, usage, and suggestions. */\n  silentAlias(alias: string): this\n\n  /** Set command version (preserves typed chain). */\n  version(str: string, flags?: string, description?: string): this\n\n  // -- Typed option overloads --\n\n  /** Add a choices option: `--env <e>`, `[\"dev\", \"staging\", \"prod\"]` */\n  option<F extends string, const C extends readonly string[]>(\n    flags: F,\n    description: string,\n    choices: C,\n  ): Command<Opts & Record<FlagKey<F>, C[number] | undefined>, Args, ArgsRecord>\n\n  /** Add an option with a CLIType preset (port, csv, uint, etc.) */\n  option<F extends string, T>(\n    flags: F,\n    description: string,\n    schema: CLIType<T>,\n    defaultValue?: T,\n  ): Command<Opts & Record<FlagKey<F>, T | undefined>, Args, ArgsRecord>\n\n  /** Add an option with a Standard Schema v1 validator (Zod, Valibot, ArkType) */\n  option<F extends string, S extends AnyStandardSchema>(\n    flags: F,\n    description: string,\n    schema: S,\n    defaultValue?: SchemaOutput<S>,\n  ): Command<Opts & Record<FlagKey<F>, SchemaOutput<S> | undefined>, Args, ArgsRecord>\n\n  /** Add an option with a parser function */\n  option<F extends string, T>(\n    flags: F,\n    description: string,\n    parseArg: (value: string, previous: T) => T,\n    defaultValue?: T,\n  ): Command<Opts & Record<FlagKey<F>, T | undefined>, Args, ArgsRecord>\n\n  /** Add a boolean flag or string-value option (no parser) */\n  option<F extends string>(\n    flags: F,\n    description?: string,\n    defaultValue?: string | boolean,\n  ): Command<Opts & Record<FlagKey<F>, InferOptionType<F>>, Args, ArgsRecord>\n\n  /**\n   * Fallback: accepts any third argument (legacy Zod, unknown schemas, etc.)\n   * that doesn't match the more specific overloads above.\n   */\n  option<F extends string>(\n    flags: F,\n    description: string,\n    parseArgOrDefault: any,\n    defaultValue?: any,\n  ): Command<Opts, Args, ArgsRecord>\n\n  // -- Typed argument overloads --\n  // Arguments append to the Args tuple (for native .action()) AND to ArgsRecord\n  // (for .actionMerged()). They do NOT merge into Opts — Opts is strictly options-only.\n\n  /** Add a choices argument: `<env>`, `[\"dev\", \"staging\", \"prod\"]` */\n  argument<F extends string, const C extends readonly string[]>(\n    flags: F,\n    description: string,\n    choices: C,\n  ): Command<\n    Opts,\n    [\n      ...Args,\n      IsArgVariadic<F> extends true\n        ? C[number][]\n        : IsArgRequired<F> extends true\n          ? C[number]\n          : C[number] | undefined,\n    ],\n    ArgsRecord &\n      Record<\n        ArgKey<F>,\n        IsArgVariadic<F> extends true\n          ? C[number][]\n          : IsArgRequired<F> extends true\n            ? C[number]\n            : C[number] | undefined\n      >\n  >\n\n  /** Add an argument with a CLIType preset (port, csv, uint, etc.) */\n  argument<F extends string, T>(\n    flags: F,\n    description: string,\n    schema: CLIType<T>,\n    defaultValue?: T,\n  ): Command<\n    Opts,\n    [...Args, InferArgType<F, CLIType<T>>],\n    ArgsRecord & Record<ArgKey<F>, InferArgType<F, CLIType<T>>>\n  >\n\n  /** Add an argument with a Standard Schema v1 validator (Zod, Valibot, ArkType) */\n  argument<F extends string, S extends AnyStandardSchema>(\n    flags: F,\n    description: string,\n    schema: S,\n    defaultValue?: SchemaOutput<S>,\n  ): Command<\n    Opts,\n    [...Args, InferArgType<F, StandardSchemaV1<SchemaOutput<S>>>],\n    ArgsRecord & Record<ArgKey<F>, InferArgType<F, StandardSchemaV1<SchemaOutput<S>>>>\n  >\n\n  /** Add an argument with a parser function */\n  argument<F extends string, T>(\n    flags: F,\n    description: string,\n    parseArg: (value: string, previous: T) => T,\n    defaultValue?: T,\n  ): Command<\n    Opts,\n    [...Args, InferArgType<F, (value: string, previous: T) => T>],\n    ArgsRecord & Record<ArgKey<F>, InferArgType<F, (value: string, previous: T) => T>>\n  >\n\n  /** Add a string argument (no parser) — required, optional, or variadic */\n  argument<F extends string>(\n    flags: F,\n    description?: string,\n    defaultValue?: string,\n  ): Command<Opts, [...Args, InferArgType<F>], ArgsRecord & Record<ArgKey<F>, InferArgType<F>>>\n\n  /** Fallback: accepts any third argument */\n  argument<F extends string>(\n    flags: F,\n    description: string,\n    parseArgOrDefault: any,\n    defaultValue?: any,\n  ): Command<Opts, Args, ArgsRecord>\n\n  // -- Typed action overloads --\n\n  /**\n   * Register an action handler — Commander-native positional form.\n   * Receives `(...positionalArgs, opts, command)`. The command instance is\n   * appended last so it can be safely ignored by handlers that don't need it.\n   */\n  action(\n    fn: (...args: [...Args, Opts, Command<Opts, Args, ArgsRecord>]) => void | Promise<void>,\n  ): this\n\n  /**\n   * Register an action handler — merged named-object form.\n   * Receives `(params, command)` where `params` is a flat object of\n   * args merged with options, keyed by argument/option name.\n   *\n   * Use this when you prefer a single destructured object to multiple positional\n   * parameters — especially for commands with 2+ arguments.\n   */\n  actionMerged(\n    fn: (params: Opts & ArgsRecord, cmd: Command<Opts, Args, ArgsRecord>) => void | Promise<void>,\n  ): this\n\n  // -- Typed command overload --\n\n  /**\n   * Create a subcommand. Returns a fresh `Command<{}, ParsedArgs, ParsedArgsRecord>`.\n   *\n   * Positional arguments embedded in the command name string (`\"deploy <service>\"`)\n   * are parsed at the type level and contribute to the returned `Args` tuple and\n   * `ArgsRecord`. The same shape as if you'd chained `.argument(\"<service>\")`.\n   *\n   * For typed parsers, schemas, or choices, use `.argument()` on the returned\n   * command — the inline string syntax can only express plain string args.\n   * Mixing both forms is allowed: inline args come first in the tuple, then\n   * `.argument()` calls append.\n   */\n  command<S extends string>(\n    nameAndArgs: S,\n    opts?: { isDefault?: boolean; hidden?: boolean; noHelp?: boolean },\n  ): ParseCommandString<S> extends [infer A extends any[], infer R extends Record<string, unknown>]\n    ? Command<{}, A, R>\n    : Command<{}, [], {}>\n\n  /** Overload for command with description (attached-action subcommand, returns parent). */\n  command<S extends string>(\n    nameAndArgs: S,\n    description: string,\n    opts?: { isDefault?: boolean; hidden?: boolean; noHelp?: boolean; executableFile?: string },\n  ): this\n}\n\n/**\n * Type-safe Commander Command with auto-colorized help, Standard Schema support,\n * array-as-choices detection, and inferred option types.\n *\n * Use `.action()` for Commander-native positional form — `(arg1, arg2, opts, cmd) => ...`.\n * Use `.actionMerged()` for a flat destructured form — `({ arg1, arg2, opt1 }, cmd) => ...`.\n *\n * @example\n * ```ts\n * new Command(\"deploy\")\n *   .argument(\"<service>\", \"Service to deploy\")\n *   .argument(\"[env]\", \"Environment\", [\"dev\", \"staging\", \"prod\"] as const)\n *   .option(\"--verbose\", \"Verbose output\")\n *   .action((service, env, opts) => { ... })\n *   // or: .actionMerged(({ service, env, verbose }) => { ... })\n * ```\n */\nexport const Command = _CommandBase as unknown as {\n  new (name?: string): Command<{}, [], {}>\n}\n","/**\n * Extended Zod object with CLI types.\n *\n * Spreads all of Zod's exports and adds CLI-specific schemas.\n * Tree-shakeable -- only evaluated if user imports `z`.\n *\n * @example\n * ```ts\n * import { z, Command } from \"@silvery/commander\"\n *\n * new Command(\"deploy\")\n *   .option(\"-p, --port <n>\", \"Port\", z.port)\n *   .option(\"--tags <t>\", \"Tags\", z.csv)\n *   .option(\"-e, --env <e>\", \"Env\", [\"dev\", \"staging\", \"prod\"])\n *\n * program.parse()\n * ```\n */\n\nimport * as zod from \"zod\"\n\nexport const z = {\n  ...zod,\n  // CLI types (built on Zod schemas)\n  port: zod.coerce.number().int().min(1).max(65535),\n  int: zod.coerce.number().int(),\n  uint: zod.coerce.number().int().min(0),\n  float: zod.coerce.number(),\n  csv: zod.string().transform((v: string) =>\n    v\n      .split(\",\")\n      .map((s: string) => s.trim())\n      .filter(Boolean),\n  ),\n  url: zod.string().url(),\n  path: zod.string().min(1),\n  email: zod.string().email(),\n  date: zod.coerce.date(),\n  json: zod.string().transform((v: string) => JSON.parse(v)),\n  bool: zod\n    .enum([\"true\", \"false\", \"1\", \"0\", \"yes\", \"no\", \"y\", \"n\"] as const)\n    .transform((v: string) => [\"true\", \"1\", \"yes\", \"y\"].includes(v)),\n  intRange: (min: number, max: number) => zod.coerce.number().int().min(min).max(max),\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silvery/commander",
-  "version": "0.19.2",
+  "version": "0.23.0",
   "description": "Colorized Commander.js help output using ANSI escape codes",
   "keywords": [
     "ansi",
@@ -35,8 +35,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@silvery/ansi": "0.19.2",
-    "commander": ">=13.0.0",
+    "@silvery/ansi": "0.23.0",
+    "commander": ">=15.0.0",
     "zod": ">=3.0.0"
   },
   "tsdown": {
@@ -54,7 +54,7 @@
     "format": "esm"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=24.0.0"
   },
   "scripts": {
     "build": "tsdown"