@silvery/commander 0.8.0 → 0.8.2

package/dist/index.mjs

@@ -0,0 +1,719 @@
+import { Argument, Command as Command$1, CommanderError, Help, Help as Help$1, InvalidArgumentError, Option, Option as Option$1 } from "commander";
+import { createStyle } from "@silvery/ansi";
+import * as zod from "zod";
+//#region src/colorize.ts
+/**
+* Commander.js help colorization using @silvery/ansi.
+*
+* Uses Commander's built-in style hooks (styleTitle, styleOptionText, etc.)
+* rather than regex post-processing.
+*
+* @example
+* ```ts
+* import { Command } from "@silvery/commander"
+* // Command auto-colorizes in its constructor — no manual call needed.
+* // For plain Commander:
+* import { colorizeHelp } from "@silvery/commander"
+* colorizeHelp(program)
+* ```
+*/
+const autoStyle = createStyle();
+const s = createStyle({ level: "basic" });
+/**
+* Check if color output should be enabled.
+* Delegates to @silvery/ansi's auto-detection (NO_COLOR, FORCE_COLOR, TERM).
+*/
+function shouldColorize() {
+	return autoStyle.level > 0;
+}
+/**
+* Apply colorized help output to a Commander.js program and all its subcommands.
+*
+* Uses Commander's built-in `configureHelp()` style hooks rather than
+* post-processing the formatted string.
+*
+* @param program - A Commander Command instance (or compatible object)
+* @param options - Override default style functions for each element
+*/
+function colorizeHelp(program, options) {
+	const cmds = options?.commands ?? ((t) => s.primary(t));
+	const flags = options?.flags ?? ((t) => s.secondary(t));
+	const desc = options?.description ?? ((t) => t);
+	const heading = options?.heading ?? ((t) => s.bold(t));
+	const brackets = options?.brackets ?? ((t) => s.accent(t));
+	program.configureHelp({
+		styleTitle: (str) => heading(str),
+		styleCommandText: (str) => cmds(str),
+		styleOptionText: (str) => flags(str),
+		styleSubcommandText: (str) => cmds(str),
+		styleArgumentText: (str) => brackets(str),
+		styleDescriptionText: (str) => desc(str),
+		styleCommandDescription: (str) => s.bold.primary(str)
+	});
+	program.configureOutput({
+		getOutHasColors: () => true,
+		getErrHasColors: () => true
+	});
+	for (const sub of program.commands) colorizeHelp(sub, options);
+}
+//#endregion
+//#region src/tokenize.ts
+/** Detect a shell prompt at the start of a line. Supports `$ `, `# `, `> `, `❯ `. */
+const PROMPT_RE = /^([$#>❯]\s+)/;
+/** Match one of: long/short flag, bracket arg, quoted string, bare token, whitespace. */
+const TOKEN_RE = /(--?\S+)|(<[^>]+>|\[[^\]]+\])|('[^']*'|"[^"]*")|(\S+)|(\s+)/g;
+/** Bare command-word pattern (letters/digits/dash, no dots or slashes). */
+const BARE_WORD_RE = /^[a-z][\w-]*$/i;
+/**
+* Tokenize a single line of shell-like text.
+*
+* Classification (matches the original styleSectionTerm contract):
+* - First non-whitespace bare word after the prompt is `program`.
+* - The IMMEDIATELY-FOLLOWING bare word (the second bare word) is `subcommand`,
+*   IF it looks like a command word (lowercase letter start, no dots/slashes).
+* - All subsequent bare words are `value`s (filenames, package names, etc.).
+* - Flags (`--foo`, `-f`), bracket args (`<x>`, `[y]`), and quoted strings end
+*   the "command portion" — anything after them is a value.
+*
+* The "max 1 subcommand" rule keeps `$ npm install foo` correctly classified
+* as program/subcommand/value (not program/subcommand/subcommand). For nested
+* commands (`$ git remote add ...`), only the first subcommand level is styled.
+*
+* If the line has no shell prompt, the same classification still applies —
+* the leading word is `program`, etc.
+*/
+function tokenizeCmdline(line) {
+	const tokens = [];
+	const promptMatch = line.match(PROMPT_RE);
+	let body = line;
+	if (promptMatch) {
+		tokens.push({
+			kind: "prompt",
+			text: promptMatch[1]
+		});
+		body = line.slice(promptMatch[1].length);
+	}
+	const matches = body.match(TOKEN_RE) ?? [];
+	let commandWords = 0;
+	let doneWithCommand = false;
+	for (const token of matches) {
+		if (/^\s+$/.test(token)) {
+			tokens.push({
+				kind: "whitespace",
+				text: token
+			});
+			continue;
+		}
+		if (/^--?\S/.test(token)) {
+			doneWithCommand = true;
+			tokens.push({
+				kind: "flag",
+				text: token
+			});
+			continue;
+		}
+		if (/^[<[]/.test(token)) {
+			doneWithCommand = true;
+			tokens.push({
+				kind: "arg-bracket",
+				text: token
+			});
+			continue;
+		}
+		if (/^["']/.test(token)) {
+			doneWithCommand = true;
+			tokens.push({
+				kind: "quoted",
+				text: token
+			});
+			continue;
+		}
+		if (!doneWithCommand && commandWords === 0) {
+			commandWords++;
+			tokens.push({
+				kind: "program",
+				text: token
+			});
+			continue;
+		}
+		if (!doneWithCommand && commandWords === 1 && BARE_WORD_RE.test(token)) {
+			commandWords++;
+			tokens.push({
+				kind: "subcommand",
+				text: token
+			});
+			continue;
+		}
+		doneWithCommand = true;
+		tokens.push({
+			kind: "value",
+			text: token
+		});
+	}
+	return tokens;
+}
+/** Returns true if the line starts with a recognized shell prompt. */
+function isShellLine(line) {
+	return PROMPT_RE.test(line);
+}
+//#endregion
+//#region src/command.ts
+/**
+* Enhanced Commander Command with auto-colorized help, Standard Schema support,
+* array-as-choices detection, and **type-safe option + argument inference**.
+*
+* Subclasses Commander's Command so `new Command("app")` just works --
+* it's Commander with auto-colorized help, automatic Standard Schema /
+* legacy Zod detection, and array choices in `.option()` and `.argument()`.
+*
+* Each `.option()` call narrows the return type so that `.action()`, `.opts()`,
+* and `.actionMerged()` know exactly which options exist and what types they have.
+* Each `.argument()` call appends to both a positional tuple (for `.action()`)
+* and a named record (for `.actionMerged()`).
+*
+* `.action(fn)` is Commander-native: positional args, then options, then command.
+* `.actionMerged(fn)` is an opt-in helper that merges args and options into a
+* single named object — nicer for commands with many positional arguments.
+*
+* @example
+* ```ts
+* import { Command, port, csv } from "@silvery/commander"
+*
+* // Commander-native: positional args, then options
+* new Command("deploy")
+*   .argument("<service>", "Service to deploy")
+*   .argument("[env]", "Environment", ["dev", "staging", "prod"])
+*   .option("-p, --port <n>", "Port", port)
+*   .option("--verbose", "Verbose output")
+*   .action((service, env, opts) => {
+*     service       // string
+*     env           // "dev" | "staging" | "prod" | undefined
+*     opts.port     // number | undefined
+*     opts.verbose  // boolean | undefined
+*   })
+*
+* // Merged form: flat named object with args and options merged
+* new Command("deploy")
+*   .argument("<service>")
+*   .argument("[env]", ["dev", "staging", "prod"] as const)
+*   .option("-p, --port <n>", "Port", port)
+*   .actionMerged(({ service, env, port }) => { ... })
+*
+* program.parse()
+* ```
+*/
+/** Runtime check: is this value a Standard Schema v1 object? */
+function isStandardSchema(value) {
+	return typeof value === "object" && value !== null && "~standard" in value;
+}
+/** Wrap a Standard Schema as a Commander parser function */
+function standardSchemaParser(schema) {
+	return (value) => {
+		const result = schema["~standard"].validate(value);
+		if ("issues" in result) {
+			const msg = result.issues.map((i) => i.message).join(", ");
+			throw new Error(msg);
+		}
+		return result.value;
+	};
+}
+function isLegacyZodSchema(value) {
+	return typeof value === "object" && value !== null && typeof value.parse === "function" && "_def" in value && !("~standard" in value);
+}
+function legacyZodParser(schema) {
+	return (value) => {
+		try {
+			return schema.parse(value);
+		} catch (err) {
+			if (err?.issues) {
+				const messages = err.issues.map((i) => i.message).join(", ");
+				throw new Error(messages);
+			}
+			throw err;
+		}
+	};
+}
+/**
+* Style a SINGLE-LINE section term using Commander's style hooks.
+*
+* Three modes:
+* - Shell command line (`$ termless play demo.tape`): tokenize via tokenizeCmdline()
+*   and style each token by kind (dim prompt, primary program/subcommand,
+*   secondary flags, accent brackets, dim quoted strings, plain values)
+* - Option-like (`-f, --flag`): entire term styled as option
+* - Plain text: command words + argument brackets
+*
+* For multi-line terms, callers split on \n and call this per line — see
+* _renderSections().
+*/
+function styleSectionTerm(term, helper) {
+	if (isShellLine(term)) return styleCmdlineTokens(tokenizeCmdline(term), helper);
+	if (/^\s*-/.test(term)) return helper.styleOptionText(term);
+	const parts = term.split(/(<[^>]+>|\[[^\]]+\])/g);
+	if (parts.length === 1) return helper.styleCommandText(term);
+	return parts.map((part) => {
+		if (/^[<[]/.test(part)) return helper.styleArgumentText(part);
+		if (part) return helper.styleCommandText(part);
+		return part;
+	}).join("");
+}
+/**
+* Apply style hooks to a stream of CmdlineTokens.
+*
+* Each token kind maps to one of Commander's style hooks (or a manual ANSI
+* dim escape for prompts/quoted strings, since Commander's style hook set
+* doesn't have a "dim" entry).
+*/
+function styleCmdlineTokens(tokens, helper) {
+	const dim = (text) => shouldColorize() ? `\x1b[2m${text}\x1b[22m` : text;
+	return tokens.map((t) => {
+		switch (t.kind) {
+			case "prompt": return dim(t.text);
+			case "program":
+			case "subcommand": return helper.styleCommandText(t.text);
+			case "flag": return helper.styleOptionText(t.text);
+			case "arg-bracket": return helper.styleArgumentText(t.text);
+			case "quoted": return dim(t.text);
+			case "value":
+			case "whitespace": return t.text;
+		}
+	}).join("");
+}
+/**
+* Compute the longest visual width of any line within a (possibly multi-line) term.
+* Used for column alignment when terms span multiple lines.
+*/
+function maxLineWidth(term) {
+	let max = 0;
+	for (const line of term.split("\n")) if (line.length > max) max = line.length;
+	return max;
+}
+/**
+* Type-safe Commander Command with auto-colorized help, Standard Schema support,
+* array-as-choices detection, and inferred option types.
+*
+* Use `.action()` for Commander-native positional form — `(arg1, arg2, opts, cmd) => ...`.
+* Use `.actionMerged()` for a flat destructured form — `({ arg1, arg2, opt1 }, cmd) => ...`.
+*
+* @example
+* ```ts
+* new Command("deploy")
+*   .argument("<service>", "Service to deploy")
+*   .argument("[env]", "Environment", ["dev", "staging", "prod"] as const)
+*   .option("--verbose", "Verbose output")
+*   .action((service, env, opts) => { ... })
+*   // or: .actionMerged(({ service, env, verbose }) => { ... })
+* ```
+*/
+const Command = class _CommandBase extends Command$1 {
+	_helpSectionList = [];
+	_helpSectionsInstalled = false;
+	/** Argument names registered via typed .argument() — used by .action() to merge into opts. */
+	_typedArgNames = [];
+	constructor(name) {
+		super(name);
+		colorizeHelp(this);
+		this._capitalizeBuiltinDescriptions();
+	}
+	/**
+	* Add an option with smart third-argument detection.
+	*
+	* The third argument is detected in order:
+	* 1. **Array** -- treated as choices (Commander `.choices()`)
+	* 2. **Standard Schema v1** -- wrapped as a parser function
+	* 3. **Legacy Zod** (pre-3.24, has `_def` + `parse`) -- wrapped as a parser
+	* 4. **Function** -- passed through as Commander's parser function
+	* 5. **Anything else** -- passed through as a default value
+	*/
+	option(flags, description, parseArgOrDefault, defaultValue) {
+		if (Array.isArray(parseArgOrDefault)) {
+			const opt = new Option$1(flags, description ?? "").choices(parseArgOrDefault);
+			this.addOption(opt);
+			return this;
+		}
+		if (isStandardSchema(parseArgOrDefault)) return super.option(flags, description ?? "", standardSchemaParser(parseArgOrDefault), defaultValue);
+		if (isLegacyZodSchema(parseArgOrDefault)) return super.option(flags, description ?? "", legacyZodParser(parseArgOrDefault), defaultValue);
+		if (typeof parseArgOrDefault === "function") return super.option(flags, description ?? "", parseArgOrDefault, defaultValue);
+		return super.option(flags, description ?? "", parseArgOrDefault);
+	}
+	/**
+	* Add an argument with smart third-argument detection.
+	*
+	* Same detection as `.option()`: array → choices, Standard Schema → parser,
+	* legacy Zod → parser, function → parser, anything else → default value.
+	* Tracks argument names for `.action()` merging.
+	*/
+	argument(flags, description, parseArgOrDefault, defaultValue) {
+		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 ?? "");
+			arg.choices(parseArgOrDefault);
+			this.addArgument(arg);
+			return this;
+		}
+		if (isStandardSchema(parseArgOrDefault)) return super.argument(flags, description ?? "", standardSchemaParser(parseArgOrDefault), defaultValue);
+		if (isLegacyZodSchema(parseArgOrDefault)) return super.argument(flags, description ?? "", legacyZodParser(parseArgOrDefault), defaultValue);
+		if (typeof parseArgOrDefault === "function") return super.argument(flags, description ?? "", parseArgOrDefault, defaultValue);
+		return super.argument(flags, description ?? "", parseArgOrDefault);
+	}
+	/**
+	* Register an action callback with a named-parameter object instead of positional args.
+	*
+	* The handler receives a single object containing all positional arguments
+	* (merged by name) and all options, plus the Command instance as a second arg.
+	* Argument names come from the typed `.argument()` calls, camelCased.
+	*
+	* This is a convenience wrapper over `.action()` — `.action()` itself remains
+	* Commander-native `(...args, opts, command) => ...`. Prefer `.action()` for
+	* single-arg commands (where positional is more ergonomic) and `.actionMerged()`
+	* for multi-arg commands (where a flat named object is nicer).
+	*
+	* @example
+	* ```ts
+	* new Command("deploy")
+	*   .argument("<service>")
+	*   .argument("[env]")
+	*   .option("-p, --port <n>", port)
+	*   .actionMerged(({ service, env, port }, cmd) => {
+	*     // service, env, port are all typed
+	*     // cmd is the Command instance
+	*   })
+	* ```
+	*/
+	actionMerged(fn) {
+		const argNames = this._typedArgNames;
+		return super.action((...args) => {
+			const cmd = args[args.length - 1];
+			const merged = { ...args[args.length - 2] ?? {} };
+			for (let i = 0; i < argNames.length; i++) merged[argNames[i]] = args[i];
+			return fn(merged, cmd);
+		});
+	}
+	addHelpSection(positionOrTitle, titleOrContent, content) {
+		let position;
+		let title;
+		let body;
+		if (content !== void 0) {
+			position = positionOrTitle;
+			title = titleOrContent;
+			body = content;
+		} else {
+			position = "after";
+			title = positionOrTitle;
+			body = titleOrContent;
+		}
+		this._helpSectionList.push({
+			position,
+			title,
+			content: body
+		});
+		this._installHelpSectionHooks();
+		return this;
+	}
+	createCommand(name) {
+		return new _CommandBase(name);
+	}
+	/**
+	* Override Commander's `command()` to mirror inline-arg names (from
+	* `command("deploy <service>")`) into our `_typedArgNames`. This keeps
+	* `.actionMerged()` working on subcommands declared with the inline form,
+	* since the merged dispatch reads from `_typedArgNames` to know which
+	* positional indices map to which key.
+	*
+	* Both forms now coexist:
+	*   .command("deploy <service>")               // inline — names from string
+	*   .command("deploy").argument("<service>")   // explicit — names from .argument()
+	* Both produce equivalent runtime + type behavior.
+	*/
+	command(...args) {
+		const result = super.command.apply(this, args);
+		const sub = this.commands[this.commands.length - 1];
+		if (sub && Array.isArray(sub._args)) for (const arg of sub._args) {
+			const camel = arg.name().replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+			if (!sub._typedArgNames.includes(camel)) sub._typedArgNames.push(camel);
+		}
+		return result;
+	}
+	/**
+	* Auto-detect capitalization from user-provided descriptions and match it
+	* for built-in options (-V/--version, -h/--help).
+	*/
+	_capitalizeBuiltinDescriptions() {
+		const origHelp = this.helpInformation.bind(this);
+		this.helpInformation = () => {
+			const builtinFlags = new Set(["-V, --version", "-h, --help"]);
+			const userDescs = this.options.filter((opt) => !builtinFlags.has(opt.flags) && opt.description && /^[a-zA-Z]/.test(opt.description)).map((opt) => opt.description);
+			for (const cmd of this.commands) if (cmd.description() && /^[a-zA-Z]/.test(cmd.description())) userDescs.push(cmd.description());
+			if (userDescs.length > 0) {
+				if (userDescs.filter((d) => /^[A-Z]/.test(d)).length > userDescs.length / 2) {
+					for (const opt of this.options) if (builtinFlags.has(opt.flags) && opt.description && /^[a-z]/.test(opt.description)) opt.description = opt.description[0].toUpperCase() + opt.description.slice(1);
+					const helpOpt = this._helpOption;
+					if (helpOpt?.description && /^[a-z]/.test(helpOpt.description)) helpOpt.description = helpOpt.description[0].toUpperCase() + helpOpt.description.slice(1);
+				}
+			}
+			return origHelp();
+		};
+	}
+	/**
+	* Render sections for a given position using the help formatter.
+	*
+	* Handles multi-line term entries (terms containing `\n`) by emitting one
+	* row per line. The description column is **top-aligned**: it appears only
+	* on the first line of a multi-line term, with subsequent lines holding
+	* just the styled term and an empty description column.
+	*/
+	_renderSections(position, helper, termWidth) {
+		const sections = this._helpSectionList.filter((s) => s.position === position);
+		if (sections.length === 0) return "";
+		const lines = [];
+		for (const section of sections) {
+			lines.push("");
+			lines.push(helper.styleTitle(section.title));
+			if (typeof section.content === "string") for (const line of section.content.split("\n")) lines.push(`  ${line}`);
+			else for (const [term, desc] of section.content) {
+				const termLines = term.split("\n");
+				for (let i = 0; i < termLines.length; i++) {
+					const lineText = termLines[i];
+					const styledTerm = styleSectionTerm(lineText, helper);
+					const lineDesc = i === 0 ? helper.styleDescriptionText(desc) : "";
+					lines.push(helper.formatItem(styledTerm, termWidth, lineDesc, helper));
+				}
+			}
+		}
+		lines.push("");
+		return lines.join("\n");
+	}
+	/** Install hooks once — merges with existing configureHelp, adds addHelpText for before/afterAll. */
+	_installHelpSectionHooks() {
+		if (this._helpSectionsInstalled) return;
+		this._helpSectionsInstalled = true;
+		const self = this;
+		const existing = this._helpConfiguration ?? {};
+		const origPadWidth = existing.padWidth;
+		const origFormatHelp = existing.formatHelp;
+		const protoFormatHelp = Help$1.prototype.formatHelp;
+		this.configureHelp({
+			...existing,
+			padWidth(cmd, helper) {
+				const base = origPadWidth ? origPadWidth(cmd, helper) : Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength?.(cmd, helper) ?? 0, helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
+				if (cmd !== self) return base;
+				let sectionMax = 0;
+				for (const section of self._helpSectionList) if (typeof section.content !== "string") for (const [term] of section.content) {
+					const w = maxLineWidth(term);
+					if (w > sectionMax) sectionMax = w;
+				}
+				return Math.max(base, sectionMax);
+			},
+			formatHelp(cmd, helper) {
+				const baseHelp = origFormatHelp ? origFormatHelp(cmd, helper) : protoFormatHelp.call(helper, cmd, helper);
+				if (cmd !== self) return baseHelp;
+				const termWidth = helper.padWidth(cmd, helper);
+				const before = self._renderSections("before", helper, termWidth);
+				const after = self._renderSections("after", helper, termWidth);
+				return (before ? before + "\n" : "") + baseHelp + after;
+			}
+		});
+		this.addHelpText("beforeAll", () => {
+			const helper = this.createHelp();
+			const termWidth = helper.padWidth(this, helper);
+			return this._renderSections("beforeAll", helper, termWidth);
+		});
+		this.addHelpText("afterAll", () => {
+			const helper = this.createHelp();
+			const termWidth = helper.padWidth(this, helper);
+			return this._renderSections("afterAll", helper, termWidth);
+		});
+	}
+};
+//#endregion
+//#region src/presets.ts
+function createType(vendor, validate) {
+	const schema = {
+		"~standard": {
+			version: 1,
+			vendor,
+			validate: (value) => {
+				try {
+					return { value: validate(value) };
+				} catch (e) {
+					return { issues: [{ message: e.message }] };
+				}
+			}
+		},
+		parse(value) {
+			const result = schema["~standard"].validate(value);
+			if ("issues" in result) throw new Error(result.issues[0]?.message ?? "Validation failed");
+			return result.value;
+		},
+		safeParse(value) {
+			const result = schema["~standard"].validate(value);
+			if ("issues" in result) return {
+				success: false,
+				issues: [...result.issues]
+			};
+			return {
+				success: true,
+				value: result.value
+			};
+		}
+	};
+	return schema;
+}
+const VENDOR = "@silvery/commander";
+/** Integer (coerced from string). */
+const int = createType(VENDOR, (v) => {
+	const s = String(v).trim();
+	if (s === "") throw new Error(`Expected integer, got "${v}"`);
+	const n = Number(s);
+	if (!Number.isInteger(n)) throw new Error(`Expected integer, got "${v}"`);
+	return n;
+});
+/** Unsigned integer (>= 0, coerced from string). */
+const uint = createType(VENDOR, (v) => {
+	const s = String(v).trim();
+	if (s === "") throw new Error(`Expected unsigned integer (>= 0), got "${v}"`);
+	const n = Number(s);
+	if (!Number.isInteger(n) || n < 0) throw new Error(`Expected unsigned integer (>= 0), got "${v}"`);
+	return n;
+});
+/** Float (coerced from string). */
+const float = createType(VENDOR, (v) => {
+	const s = String(v).trim();
+	if (s === "" || s === "NaN") throw new Error(`Expected number, got "${v}"`);
+	const n = Number(s);
+	if (Number.isNaN(n)) throw new Error(`Expected number, got "${v}"`);
+	return n;
+});
+/** Port number (1-65535). */
+const port = createType(VENDOR, (v) => {
+	const n = Number(v);
+	if (!Number.isInteger(n) || n < 1 || n > 65535) throw new Error(`Expected port (1-65535), got "${v}"`);
+	return n;
+});
+/** URL (validated via URL constructor). */
+const url = createType(VENDOR, (v) => {
+	const s = String(v);
+	try {
+		new URL(s);
+		return s;
+	} catch {
+		throw new Error(`Expected valid URL, got "${v}"`);
+	}
+});
+/** File path (non-empty string). */
+const path = createType(VENDOR, (v) => {
+	const s = String(v);
+	if (!s) throw new Error("Expected non-empty path");
+	return s;
+});
+/** Comma-separated values to string[]. */
+const csv = createType(VENDOR, (v) => {
+	return String(v).split(",").map((s) => s.trim()).filter(Boolean);
+});
+/** JSON string to parsed value. */
+const json = createType(VENDOR, (v) => {
+	try {
+		return JSON.parse(String(v));
+	} catch {
+		throw new Error(`Expected valid JSON, got "${v}"`);
+	}
+});
+/** Boolean string ("true"/"false"/"1"/"0"/"yes"/"no"). */
+const bool = createType(VENDOR, (v) => {
+	const s = String(v).toLowerCase();
+	if ([
+		"true",
+		"1",
+		"yes",
+		"y"
+	].includes(s)) return true;
+	if ([
+		"false",
+		"0",
+		"no",
+		"n"
+	].includes(s)) return false;
+	throw new Error(`Expected boolean (true/false/yes/no/1/0), got "${v}"`);
+});
+/** Date string to Date object. */
+const date = createType(VENDOR, (v) => {
+	const d = new Date(String(v));
+	if (isNaN(d.getTime())) throw new Error(`Expected valid date, got "${v}"`);
+	return d;
+});
+/** Email address (basic validation). */
+const email = createType(VENDOR, (v) => {
+	const s = String(v);
+	if (!s.includes("@") || !s.includes(".")) throw new Error(`Expected email address, got "${v}"`);
+	return s;
+});
+/** Regex pattern string to RegExp. */
+const regex = createType(VENDOR, (v) => {
+	try {
+		return new RegExp(String(v));
+	} catch {
+		throw new Error(`Expected valid regex, got "${v}"`);
+	}
+});
+/** Integer with min/max bounds (factory). */
+function intRange(min, max) {
+	return createType(VENDOR, (v) => {
+		const n = Number(v);
+		if (!Number.isInteger(n) || n < min || n > max) throw new Error(`Expected integer ${min}-${max}, got "${v}"`);
+		return n;
+	});
+}
+//#endregion
+//#region src/z.ts
+/**
+* Extended Zod object with CLI types.
+*
+* Spreads all of Zod's exports and adds CLI-specific schemas.
+* Tree-shakeable -- only evaluated if user imports `z`.
+*
+* @example
+* ```ts
+* import { z, Command } from "@silvery/commander"
+*
+* new Command("deploy")
+*   .option("-p, --port <n>", "Port", z.port)
+*   .option("--tags <t>", "Tags", z.csv)
+*   .option("-e, --env <e>", "Env", ["dev", "staging", "prod"])
+*
+* program.parse()
+* ```
+*/
+const z = {
+	...zod,
+	port: zod.coerce.number().int().min(1).max(65535),
+	int: zod.coerce.number().int(),
+	uint: zod.coerce.number().int().min(0),
+	float: zod.coerce.number(),
+	csv: zod.string().transform((v) => v.split(",").map((s) => s.trim()).filter(Boolean)),
+	url: zod.string().url(),
+	path: zod.string().min(1),
+	email: zod.string().email(),
+	date: zod.coerce.date(),
+	json: zod.string().transform((v) => JSON.parse(v)),
+	bool: zod.enum([
+		"true",
+		"false",
+		"1",
+		"0",
+		"yes",
+		"no",
+		"y",
+		"n"
+	]).transform((v) => [
+		"true",
+		"1",
+		"yes",
+		"y"
+	].includes(v)),
+	intRange: (min, max) => zod.coerce.number().int().min(min).max(max)
+};
+//#endregion
+export { Argument, Command, CommanderError, Help, InvalidArgumentError, Option, bool, colorizeHelp, csv, date, email, float, int, intRange, json, path, port, regex, shouldColorize, uint, url, z };
+
+//# sourceMappingURL=index.mjs.map