politty 0.0.1 → 0.1.1

package/dist/runner-DceWXOwD.js

@@ -0,0 +1,1372 @@
+import { n as getExtractedFields, t as extractFields } from "./schema-extractor-Dk5Z0Iei.js";
+import { a as emptyLogs, i as createLogCollector, n as resolveLazyCommand, o as mergeLogs, r as resolveSubcommand, t as listSubCommands } from "./subcommand-router-BiSvDXHg.js";
+import { z } from "zod";
+import { styleText } from "node:util";
+
+//#region src/executor/command-runner.ts
+/**
+* Execute a command lifecycle: setup → run → cleanup
+*
+* This is an internal function that executes the command's lifecycle hooks.
+* For running commands with argument parsing, use `runCommand` instead.
+*
+* @param command - The command to execute
+* @param args - Already validated arguments
+* @param options - Lifecycle options
+* @returns The result of command execution
+* @internal
+*/
+async function executeLifecycle(command, args, _options = {}) {
+	let error;
+	let result;
+	const collector = _options.captureLogs ?? false ? createLogCollector() : null;
+	collector?.start();
+	const setupContext = { args };
+	const cleanupContext = {
+		args,
+		error
+	};
+	let signalHandler;
+	if (_options.handleSignals) {
+		signalHandler = async (_signal) => {
+			if (signalHandler) {
+				process.off("SIGINT", signalHandler);
+				process.off("SIGTERM", signalHandler);
+			}
+			if (command.cleanup) try {
+				await command.cleanup(cleanupContext);
+			} catch (e) {
+				console.error("Error during signal cleanup:", e);
+			}
+			collector?.stop();
+			process.exit(1);
+		};
+		process.on("SIGINT", signalHandler);
+		process.on("SIGTERM", signalHandler);
+	}
+	try {
+		if (command.setup) await command.setup(setupContext);
+		if (command.run) result = await command.run(args);
+	} catch (e) {
+		error = e instanceof Error ? e : new Error(String(e));
+	} finally {
+		if (signalHandler) {
+			process.off("SIGINT", signalHandler);
+			process.off("SIGTERM", signalHandler);
+		}
+	}
+	if (command.cleanup) {
+		cleanupContext.error = error;
+		try {
+			await command.cleanup(cleanupContext);
+		} catch (cleanupError) {
+			if (!error) error = cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError));
+		}
+	}
+	collector?.stop();
+	const logs = mergeLogs(_options.existingLogs ?? emptyLogs(), collector?.getLogs() ?? emptyLogs());
+	if (error) return {
+		success: false,
+		error,
+		exitCode: 1,
+		logs
+	};
+	return {
+		success: true,
+		result,
+		exitCode: 0,
+		logs
+	};
+}
+
+//#endregion
+//#region src/output/logger.ts
+/**
+* Check if color output should be disabled
+*/
+function shouldDisableColor() {
+	if (process.env.NO_COLOR !== void 0) return true;
+	if (process.env.FORCE_COLOR === "0") return true;
+	if (process.env.FORCE_COLOR) return false;
+	if (process.env.CI) return true;
+	if (!process.stdout.isTTY) return true;
+	return false;
+}
+/**
+* Global flag to control color output
+*/
+let colorDisabled = shouldDisableColor();
+/**
+* Enable or disable color output programmatically
+*/
+function setColorEnabled(enabled) {
+	colorDisabled = !enabled;
+}
+/**
+* Check if color output is currently enabled
+*/
+function isColorEnabled() {
+	return !colorDisabled;
+}
+/**
+* Create a style function that applies the given styles
+*/
+function createStyleFn(...styleArgs) {
+	return (text) => {
+		if (colorDisabled) return text;
+		let result = text;
+		for (const style of styleArgs) result = styleText(style, result);
+		return result;
+	};
+}
+/**
+* Semantic style functions for inline text styling
+*/
+const styles = {
+	success: createStyleFn("green"),
+	error: createStyleFn("red"),
+	warning: createStyleFn("yellow"),
+	info: createStyleFn("cyan"),
+	bold: createStyleFn("bold"),
+	dim: createStyleFn("dim"),
+	italic: createStyleFn("italic"),
+	underline: createStyleFn("underline"),
+	red: createStyleFn("red"),
+	green: createStyleFn("green"),
+	yellow: createStyleFn("yellow"),
+	blue: createStyleFn("blue"),
+	magenta: createStyleFn("magenta"),
+	cyan: createStyleFn("cyan"),
+	white: createStyleFn("white"),
+	gray: createStyleFn("gray"),
+	command: createStyleFn("bold"),
+	commandName: createStyleFn("bold", "cyan"),
+	option: createStyleFn("cyan"),
+	optionName: createStyleFn("bold"),
+	placeholder: createStyleFn("dim"),
+	defaultValue: createStyleFn("dim"),
+	required: createStyleFn("yellow"),
+	description: (text) => text,
+	sectionHeader: createStyleFn("bold", "underline"),
+	version: createStyleFn("dim")
+};
+/**
+* Standardized symbols for CLI output
+*/
+const symbols = {
+	success: styles.green("✓"),
+	error: styles.red("✖"),
+	warning: styles.yellow("⚠"),
+	info: styles.cyan("ℹ"),
+	bullet: styles.gray("•"),
+	arrow: styles.gray("→")
+};
+/**
+* Logger for CLI output
+*/
+const logger = {
+	info(message) {
+		console.log(message);
+	},
+	success(message) {
+		console.log(`${symbols.success} ${styles.success(message)}`);
+	},
+	warn(message) {
+		console.warn(`${symbols.warning} ${styles.warning(message)}`);
+	},
+	error(message) {
+		console.error(`${symbols.error} ${styles.error(message)}`);
+	},
+	log(message) {
+		console.log(message);
+	},
+	newline() {
+		console.log("");
+	},
+	debug(message) {
+		console.log(styles.dim(message));
+	}
+};
+
+//#endregion
+//#region src/output/help-generator.ts
+/**
+* Default descriptions for built-in options
+*/
+const defaultBuiltinDescriptions = {
+	help: "Show help",
+	helpAll: "Show help with all subcommand options",
+	version: "Show version"
+};
+/**
+* Build full command name from context
+*/
+function buildFullCommandName(command, context) {
+	if (context?.rootName && context.commandPath && context.commandPath.length > 0) return context.commandPath.join(" ");
+	return command.name ?? "command";
+}
+/**
+* Build usage command name (includes root name for subcommands)
+*/
+function buildUsageCommandName(command, context) {
+	if (context?.rootName && context.commandPath && context.commandPath.length > 0) return `${context.rootName} ${context.commandPath.join(" ")}`;
+	return command.name ?? "command";
+}
+/**
+* Render the usage line for a command
+*/
+function renderUsageLine(command, context) {
+	const parts = [];
+	const name = buildUsageCommandName(command, context);
+	parts.push(styles.commandName(name));
+	const extracted = getExtractedFields(command);
+	if (extracted) {
+		const positionals = extracted.fields.filter((a) => a.positional);
+		if (extracted.fields.filter((a) => !a.positional).length > 0) parts.push(styles.placeholder("[options]"));
+		if (command.subCommands && Object.keys(command.subCommands).length > 0) parts.push(styles.placeholder("[command]"));
+		for (const arg of positionals) if (arg.required) parts.push(styles.option(`<${arg.name}>`));
+		else parts.push(styles.placeholder(`[${arg.name}]`));
+	} else if (command.subCommands && Object.keys(command.subCommands).length > 0) parts.push(styles.placeholder("[command]"));
+	return parts.join(" ");
+}
+/**
+* Render the options section
+*/
+function renderOptions(command, descriptions = {}, context) {
+	const lines = [];
+	const desc = {
+		help: descriptions.help ?? defaultBuiltinDescriptions.help,
+		helpAll: descriptions.helpAll ?? defaultBuiltinDescriptions.helpAll,
+		version: descriptions.version ?? defaultBuiltinDescriptions.version
+	};
+	const extracted = getExtractedFields(command);
+	const hasUserDefinedh = extracted?.fields.some((f) => f.alias === "h" && f.overrideBuiltinAlias === true) ?? false;
+	const hasUserDefinedH = extracted?.fields.some((f) => f.alias === "H" && f.overrideBuiltinAlias === true) ?? false;
+	if (hasUserDefinedh) lines.push(formatOption(styles.option("--help"), desc.help));
+	else lines.push(formatOption(`${styles.option("-h")}, ${styles.option("--help")}`, desc.help));
+	if (hasUserDefinedH) lines.push(formatOption(styles.option("--help-all"), desc.helpAll));
+	else lines.push(formatOption(`${styles.option("-H")}, ${styles.option("--help-all")}`, desc.helpAll));
+	if (context?.rootVersion) lines.push(formatOption(styles.option("--version"), desc.version));
+	if (!extracted) return lines.join("\n");
+	if (extracted.schemaType === "discriminatedUnion" && extracted.discriminator) return renderDiscriminatedUnionOptions(extracted, command, lines);
+	if (extracted.schemaType === "union" && extracted.unionOptions) return renderUnionOptions(extracted, command, lines);
+	if (extracted.schemaType === "xor" && extracted.unionOptions) return renderUnionOptions(extracted, command, lines);
+	const options = extracted.fields.filter((a) => !a.positional);
+	for (const opt of options) {
+		const flags = formatFlags(opt);
+		let desc$1 = opt.description ?? "";
+		if (opt.defaultValue !== void 0) desc$1 += ` ${styles.defaultValue(`(default: ${JSON.stringify(opt.defaultValue)})`)}`;
+		if (opt.required) desc$1 += ` ${styles.required("(required)")}`;
+		const envInfo = formatEnvInfo(opt.env);
+		if (envInfo) desc$1 += ` ${envInfo}`;
+		lines.push(formatOption(flags, desc$1));
+	}
+	return lines.join("\n");
+}
+/**
+* Render options for discriminated union with variants
+*/
+function renderDiscriminatedUnionOptions(extracted, _command, lines) {
+	const discriminator = extracted.discriminator;
+	const variants = extracted.variants ?? [];
+	const discriminatorField = extracted.fields.find((f) => f.name === discriminator);
+	if (discriminatorField) {
+		const variantValues = variants.map((v) => v.discriminatorValue).join("|");
+		const flags = `${styles.option(`--${discriminator}`)} ${styles.placeholder(`<${variantValues}>`)}`;
+		const description = extracted.description ?? discriminatorField.description ?? "Action to perform";
+		lines.push(formatOption(flags, description));
+	}
+	const commonFields = /* @__PURE__ */ new Set();
+	const allFieldNames = /* @__PURE__ */ new Set();
+	for (const variant of variants) for (const field of variant.fields) allFieldNames.add(field.name);
+	for (const fieldName of allFieldNames) {
+		if (fieldName === discriminator) continue;
+		if (variants.every((v) => v.fields.some((f) => f.name === fieldName))) commonFields.add(fieldName);
+	}
+	for (const fieldName of commonFields) {
+		const field = extracted.fields.find((f) => f.name === fieldName);
+		if (field && !field.positional) {
+			const flags = formatFlags(field);
+			let desc = field.description ?? "";
+			if (field.defaultValue !== void 0) desc += ` ${styles.defaultValue(`(default: ${JSON.stringify(field.defaultValue)})`)}`;
+			const envInfo = formatEnvInfo(field.env);
+			if (envInfo) desc += ` ${envInfo}`;
+			lines.push(formatOption(flags, desc));
+		}
+	}
+	for (const variant of variants) {
+		const variantFields = variant.fields.filter((f) => f.name !== discriminator && !commonFields.has(f.name) && !f.positional);
+		if (variantFields.length > 0) {
+			lines.push("");
+			const variantLabel = variant.description ? `${styles.dim("When")} ${styles.option(discriminator)}=${styles.bold(variant.discriminatorValue)}: ${variant.description}` : `${styles.dim("When")} ${styles.option(discriminator)}=${styles.bold(variant.discriminatorValue)}:`;
+			lines.push(variantLabel);
+			for (const field of variantFields) {
+				const flags = formatFlags(field);
+				let desc = field.description ?? "";
+				if (field.defaultValue !== void 0) desc += ` ${styles.defaultValue(`(default: ${JSON.stringify(field.defaultValue)})`)}`;
+				if (field.required) desc += ` ${styles.required("(required)")}`;
+				const envInfo = formatEnvInfo(field.env);
+				if (envInfo) desc += ` ${envInfo}`;
+				lines.push(formatOption(`  ${flags}`, desc));
+			}
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Render options for union with multiple options
+*/
+function renderUnionOptions(extracted, _command, lines) {
+	const unionOptions = extracted.unionOptions ?? [];
+	const commonFields = /* @__PURE__ */ new Set();
+	const allFieldNames = /* @__PURE__ */ new Set();
+	for (const option of unionOptions) for (const field of option.fields) allFieldNames.add(field.name);
+	for (const fieldName of allFieldNames) if (unionOptions.every((o) => o.fields.some((f) => f.name === fieldName))) commonFields.add(fieldName);
+	for (const fieldName of commonFields) {
+		const field = extracted.fields.find((f) => f.name === fieldName);
+		if (field && !field.positional) {
+			const flags = formatFlags(field);
+			let desc = field.description ?? "";
+			if (field.defaultValue !== void 0) desc += ` ${styles.defaultValue(`(default: ${JSON.stringify(field.defaultValue)})`)}`;
+			const envInfo = formatEnvInfo(field.env);
+			if (envInfo) desc += ` ${envInfo}`;
+			lines.push(formatOption(flags, desc));
+		}
+	}
+	for (let i = 0; i < unionOptions.length; i++) {
+		const option = unionOptions[i];
+		if (!option) continue;
+		const uniqueFields = option.fields.filter((f) => !commonFields.has(f.name) && !f.positional);
+		if (uniqueFields.length > 0) {
+			lines.push("");
+			const label = option.description ?? `Variant ${i + 1}`;
+			lines.push(`  ${styles.bold(`${label}:`)}`);
+			for (const field of uniqueFields) {
+				const flags = formatFlags(field);
+				let desc = field.description ?? "";
+				if (field.defaultValue !== void 0) desc += ` ${styles.defaultValue(`(default: ${JSON.stringify(field.defaultValue)})`)}`;
+				if (field.required) desc += ` ${styles.required("(required)")}`;
+				const envInfo = formatEnvInfo(field.env);
+				if (envInfo) desc += ` ${envInfo}`;
+				lines.push(formatOption(`  ${flags}`, desc));
+			}
+		}
+	}
+	return lines.join("\n");
+}
+/**
+* Format option flags (-v, --verbose <VALUE>)
+* Uses cliName (kebab-case) for display
+*/
+function formatFlags(opt) {
+	const parts = [];
+	if (opt.alias) parts.push(styles.option(`-${opt.alias}`));
+	let longFlag = styles.option(`--${opt.cliName}`);
+	if (opt.type !== "boolean") {
+		const placeholder = opt.placeholder ?? opt.cliName.toUpperCase();
+		longFlag += ` ${styles.placeholder(`<${placeholder}>`)}`;
+	}
+	parts.push(longFlag);
+	return parts.join(", ");
+}
+/**
+* Format environment variable info for help display
+*/
+function formatEnvInfo(env) {
+	if (!env) return "";
+	const envNames = Array.isArray(env) ? env : [env];
+	return styles.dim(`[env: ${envNames.join(", ")}]`);
+}
+/**
+* Strip ANSI escape codes from a string to get visual length
+*/
+function stripAnsi(str) {
+	return str.replace(/\x1B\[[0-9;]*m/g, "");
+}
+/**
+* Pad a string that may contain ANSI codes to a visual width
+*/
+function padEndVisual(str, width) {
+	const visualLength = stripAnsi(str).length;
+	const padding = Math.max(0, width - visualLength);
+	return str + " ".repeat(padding);
+}
+/**
+* Format a single option line
+* If flags exceed the column width, description is moved to the next line
+*/
+function formatOption(flags, description, indent = 0, extraDescPadding = 0) {
+	const flagWidth = 32;
+	const indentStr = "  ".repeat(indent);
+	const visualFlagLength = stripAnsi(flags).length;
+	const effectiveFlagWidth = flagWidth - indent * 2 + extraDescPadding;
+	if (visualFlagLength >= effectiveFlagWidth) return `${indentStr}  ${flags}\n${" ".repeat(effectiveFlagWidth + 2 + indent * 2)}${description}`;
+	return `${indentStr}  ${padEndVisual(flags, effectiveFlagWidth)}${description}`;
+}
+/**
+* Render options for a subcommand (used by showSubcommandOptions)
+*/
+function renderSubcommandOptionsCompact(command, indent) {
+	const lines = [];
+	const extracted = getExtractedFields(command);
+	if (extracted) {
+		const options = extracted.fields.filter((a) => !a.positional);
+		for (const opt of options) {
+			const flags = formatFlags(opt);
+			let desc = opt.description ?? "";
+			if (opt.defaultValue !== void 0) desc += ` ${styles.defaultValue(`(default: ${JSON.stringify(opt.defaultValue)})`)}`;
+			const envInfo = formatEnvInfo(opt.env);
+			if (envInfo) desc += ` ${envInfo}`;
+			lines.push(formatOption(flags, desc, indent, 2));
+		}
+	}
+	return lines;
+}
+/**
+* Render subcommands recursively with their options (flat style)
+*/
+function renderSubcommandsWithOptions(subCommands, parentPath, baseIndent) {
+	const lines = [];
+	for (const [name, subCmd] of Object.entries(subCommands)) {
+		const cmd = typeof subCmd === "function" ? null : subCmd;
+		const fullPath = parentPath ? `${parentPath} ${name}` : name;
+		const desc = cmd?.description ?? "";
+		lines.push(formatOption(styles.command(fullPath), desc, baseIndent));
+		if (cmd) {
+			const optionLines = renderSubcommandOptionsCompact(cmd, baseIndent + 1);
+			lines.push(...optionLines);
+			if (cmd.subCommands && Object.keys(cmd.subCommands).length > 0) {
+				const nestedLines = renderSubcommandsWithOptions(cmd.subCommands, fullPath, baseIndent);
+				lines.push(...nestedLines);
+			}
+		}
+	}
+	return lines;
+}
+/**
+* Generate help text for a command
+*
+* @param command - The command to generate help for
+* @param options - Help generation options
+* @returns Formatted help text
+*/
+function generateHelp(command, options) {
+	const sections = [];
+	const context = options.context;
+	const headerLines = [];
+	const displayName = buildFullCommandName(command, context);
+	if (displayName) {
+		let header = styles.commandName(displayName);
+		if (context?.rootName && context.commandPath && context.commandPath.length > 0) if (context.rootVersion) header += ` ${styles.version(`(${context.rootName} v${context.rootVersion})`)}`;
+		else header += ` ${styles.version(`(${context.rootName})`)}`;
+		else if (context?.rootVersion) header += ` ${styles.version(`v${context.rootVersion}`)}`;
+		headerLines.push(header);
+	}
+	if (command.description) headerLines.push(command.description);
+	if (headerLines.length > 0) sections.push(headerLines.join("\n"));
+	sections.push(`${styles.sectionHeader("Usage:")} ${renderUsageLine(command, context)}`);
+	const optionsText = renderOptions(command, options.descriptions, context);
+	if (optionsText) sections.push(`${styles.sectionHeader("Options:")}\n${optionsText}`);
+	if (options.showSubcommands !== false && command.subCommands && Object.keys(command.subCommands).length > 0) {
+		const currentPath = context?.commandPath?.join(" ") ?? "";
+		if (options.showSubcommandOptions) {
+			const subLines = renderSubcommandsWithOptions(command.subCommands, currentPath, 0);
+			sections.push(`${styles.sectionHeader("Commands:")}\n${subLines.join("\n")}`);
+		} else {
+			const subLines = [];
+			for (const [name, subCmd] of Object.entries(command.subCommands)) {
+				const desc = (typeof subCmd === "function" ? { description: void 0 } : subCmd).description ?? "";
+				const fullName = currentPath ? `${currentPath} ${name}` : name;
+				subLines.push(formatOption(styles.command(fullName), desc));
+			}
+			sections.push(`${styles.sectionHeader("Commands:")}\n${subLines.join("\n")}`);
+		}
+	}
+	if (command.examples && command.examples.length > 0) {
+		const exampleLines = renderExamplesForHelp(command.examples, context);
+		sections.push(`${styles.sectionHeader("Examples:")}\n${exampleLines}`);
+	}
+	if (command.notes) sections.push(`${styles.sectionHeader("Notes:")}\n${command.notes}`);
+	return sections.join("\n\n");
+}
+/**
+* Render examples for CLI help output
+*/
+function renderExamplesForHelp(examples, context) {
+	const lines = [];
+	const cmdPrefix = context?.rootName ? `${context.rootName} ` : "";
+	const cmdPath = context?.commandPath?.join(" ") ?? "";
+	const fullPrefix = cmdPath ? `${cmdPrefix}${cmdPath} ` : cmdPrefix;
+	for (const example of examples) {
+		lines.push(`  ${styles.dim(example.desc)}`);
+		lines.push(`    ${styles.dim("$")} ${fullPrefix}${example.cmd}`);
+		if (example.output) for (const line of example.output.split("\n")) lines.push(`    ${line}`);
+		lines.push("");
+	}
+	if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/validator/validation-errors.ts
+/**
+* Error thrown when positional argument configuration is invalid
+*/
+var PositionalConfigError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PositionalConfigError";
+	}
+};
+/**
+* Error thrown when a reserved alias is used
+*/
+var ReservedAliasError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ReservedAliasError";
+	}
+};
+/**
+* Error thrown when duplicate field names are detected
+*/
+var DuplicateFieldError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DuplicateFieldError";
+	}
+};
+/**
+* Error thrown when duplicate aliases are detected
+*/
+var DuplicateAliasError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DuplicateAliasError";
+	}
+};
+
+//#endregion
+//#region src/validator/command-validator.ts
+/**
+* Check for duplicate field names
+*/
+function checkDuplicateFields(extracted, commandPath) {
+	const errors = [];
+	const seenNames = /* @__PURE__ */ new Map();
+	for (const field of extracted.fields) {
+		if (seenNames.has(field.name)) errors.push({
+			commandPath,
+			type: "duplicate_field",
+			message: `Duplicate field name "${field.name}" detected.`,
+			field: field.name
+		});
+		seenNames.set(field.name, field.name);
+	}
+	return errors;
+}
+/**
+* Check for duplicate aliases and alias-field name conflicts
+*/
+function checkDuplicateAliases(extracted, commandPath) {
+	const errors = [];
+	const seenAliases = /* @__PURE__ */ new Map();
+	const fieldNames = new Set(extracted.fields.map((f) => f.name));
+	for (const field of extracted.fields) {
+		if (!field.alias) continue;
+		if (fieldNames.has(field.alias)) errors.push({
+			commandPath,
+			type: "duplicate_alias",
+			message: `Alias "${field.alias}" for field "${field.name}" conflicts with existing field name "${field.alias}".`,
+			field: field.name
+		});
+		const existingField = seenAliases.get(field.alias);
+		if (existingField) errors.push({
+			commandPath,
+			type: "duplicate_alias",
+			message: `Duplicate alias "${field.alias}" detected. Both "${existingField}" and "${field.name}" use the same alias.`,
+			field: field.name
+		});
+		seenAliases.set(field.alias, field.name);
+	}
+	return errors;
+}
+/**
+* Check positional argument configuration
+*/
+function checkPositionalConfig(extracted, commandPath) {
+	const errors = [];
+	const positionalFields = extracted.fields.filter((f) => f.positional);
+	let foundArrayPositional = null;
+	let foundOptionalPositional = null;
+	for (const field of positionalFields) {
+		if (foundArrayPositional !== null) errors.push({
+			commandPath,
+			type: "positional_config",
+			message: `Positional argument "${field.name}" cannot follow array positional argument "${foundArrayPositional}".`,
+			field: field.name
+		});
+		if (field.type === "array" && foundOptionalPositional !== null) errors.push({
+			commandPath,
+			type: "positional_config",
+			message: `Array positional "${field.name}" cannot be used with optional positional "${foundOptionalPositional}" (ambiguous parsing).`,
+			field: field.name
+		});
+		if (foundOptionalPositional !== null && field.required) errors.push({
+			commandPath,
+			type: "positional_config",
+			message: `Required positional "${field.name}" cannot follow optional positional "${foundOptionalPositional}".`,
+			field: field.name
+		});
+		if (field.type === "array") foundArrayPositional = field.name;
+		if (!field.required) foundOptionalPositional = field.name;
+	}
+	return errors;
+}
+/**
+* Check for reserved aliases used without override flag
+*/
+function checkReservedAliases(extracted, commandPath) {
+	const errors = [];
+	for (const field of extracted.fields) if ((field.alias === "h" || field.alias === "H") && field.overrideBuiltinAlias !== true) errors.push({
+		commandPath,
+		type: "reserved_alias",
+		message: `Alias "${field.alias}" is reserved for --${field.alias === "h" ? "help" : "help-all"}.`,
+		field: field.name
+	});
+	return errors;
+}
+/**
+* Validate that no duplicate field names exist
+*
+* @param extracted - Extracted fields from schema
+* @throws {DuplicateFieldError} If duplicate field names are found
+*/
+function validateDuplicateFields(extracted) {
+	const errors = checkDuplicateFields(extracted, []);
+	if (errors.length > 0) throw new DuplicateFieldError(`Duplicate field name "${errors[0]?.field ?? "unknown"}" detected. Each field must have a unique name.`);
+}
+/**
+* Validate that no duplicate aliases exist
+*
+* Also checks for conflicts between aliases and field names
+*
+* @param extracted - Extracted fields from schema
+* @throws {DuplicateAliasError} If duplicate aliases are found or alias conflicts with field name
+*/
+function validateDuplicateAliases(extracted) {
+	const errors = checkDuplicateAliases(extracted, []);
+	if (errors.length > 0) {
+		const err = errors[0];
+		throw new DuplicateAliasError(err.message);
+	}
+}
+/**
+* Validate positional argument configuration
+*
+* Rules:
+* - Array positional arguments must be the last positional
+* - No positional arguments can follow an array positional
+* - Required positional arguments cannot follow optional positional arguments
+* - Array positional and optional positional cannot be used together (ambiguous parsing)
+*
+* @param extracted - Extracted fields from schema
+* @throws {PositionalConfigError} If configuration is invalid
+*/
+function validatePositionalConfig(extracted) {
+	const errors = checkPositionalConfig(extracted, []);
+	if (errors.length > 0) {
+		const err = errors[0];
+		throw new PositionalConfigError(err.message);
+	}
+}
+/**
+* Validate that no reserved aliases are used without explicit override
+*
+* Reserved aliases:
+* - 'h' is reserved for --help
+* - 'H' is reserved for --help-all
+*
+* Users can override these by setting overrideBuiltinAlias: true
+*
+* @param extracted - Extracted fields from schema
+* @param _hasSubCommands - Whether the command has subcommands (reserved for future use)
+* @throws {ReservedAliasError} If a reserved alias is used without override flag
+*/
+function validateReservedAliases(extracted, _hasSubCommands) {
+	const errors = checkReservedAliases(extracted, []);
+	if (errors.length > 0) {
+		const field = errors[0].field ?? "unknown";
+		const alias = extracted.fields.find((f) => f.name === field)?.alias ?? "h";
+		throw new ReservedAliasError(`Alias "${alias}" is reserved for --${alias === "h" ? "help" : "help-all"}. To override this, set { alias: "${alias}", overrideBuiltinAlias: true } for "${field}".`);
+	}
+}
+/**
+* Collect validation errors for a single command's schema (non-throwing)
+*/
+function collectSchemaErrors(extracted, _hasSubCommands, commandPath) {
+	return [
+		...checkDuplicateFields(extracted, commandPath),
+		...checkDuplicateAliases(extracted, commandPath),
+		...checkPositionalConfig(extracted, commandPath),
+		...checkReservedAliases(extracted, commandPath)
+	];
+}
+/**
+* Validate a command and all its subcommands recursively
+*
+* This function collects all validation errors without throwing,
+* making it suitable for test assertions.
+*
+* @param command - The command to validate
+* @param options - Validation options
+* @returns Validation result with all errors collected
+*
+* @example
+* ```ts
+* const result = await validateCommand(myCommand);
+* if (!result.valid) {
+*   console.error(result.errors);
+* }
+* ```
+*/
+async function validateCommand(command, options = {}) {
+	const commandPath = options.commandPath ?? [command.name];
+	const errors = [];
+	const hasSubCommands = command.subCommands ? Object.keys(command.subCommands).length > 0 : false;
+	if (command.args) {
+		const extracted = extractFields(command.args);
+		errors.push(...collectSchemaErrors(extracted, hasSubCommands, commandPath));
+	}
+	if (command.subCommands) for (const [name, subCmd] of Object.entries(command.subCommands)) {
+		const subResult = await validateCommand(await resolveLazyCommand(subCmd), { commandPath: [...commandPath, name] });
+		if (!subResult.valid) errors.push(...subResult.errors);
+	}
+	if (errors.length === 0) return { valid: true };
+	return {
+		valid: false,
+		errors
+	};
+}
+/**
+* Format command validation errors for display
+*
+* @param errors - Array of validation errors
+* @returns Formatted error message
+*/
+function formatCommandValidationErrors(errors) {
+	if (errors.length === 0) return "";
+	const lines = ["Command definition errors:"];
+	for (const error of errors) {
+		const path = error.commandPath.join(" > ");
+		lines.push(`  - [${path}] ${error.message}`);
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/parser/argv-parser.ts
+/**
+* Parse argv into a flat record
+*
+* Supports:
+* - Long options: --flag, --flag=value, --flag value
+* - Short options: -f, -f=value, -f value
+* - Combined short options: -abc (treated as -a -b -c if all are boolean)
+* - Positional arguments
+* - -- to stop parsing options
+*
+* @param argv - Command line arguments
+* @param options - Parser options
+* @returns Parsed arguments
+*/
+function parseArgv(argv, options = {}) {
+	const { aliasMap = /* @__PURE__ */ new Map(), booleanFlags = /* @__PURE__ */ new Set(), arrayFlags = /* @__PURE__ */ new Set() } = options;
+	const result = {
+		options: {},
+		positionals: [],
+		rest: []
+	};
+	let i = 0;
+	let stopParsing = false;
+	const setOption = (name, value) => {
+		const resolvedName = aliasMap.get(name) ?? name;
+		if (arrayFlags.has(resolvedName)) {
+			const existing = result.options[resolvedName];
+			if (Array.isArray(existing)) existing.push(value);
+			else if (existing !== void 0) result.options[resolvedName] = [existing, value];
+			else result.options[resolvedName] = [value];
+		} else result.options[resolvedName] = value;
+	};
+	while (i < argv.length) {
+		const arg = argv[i];
+		if (stopParsing) {
+			result.rest.push(arg);
+			i++;
+			continue;
+		}
+		if (arg === "--") {
+			stopParsing = true;
+			i++;
+			continue;
+		}
+		if (arg.startsWith("--")) {
+			const withoutDashes = arg.slice(2);
+			if (withoutDashes.startsWith("no-")) {
+				const flagName = withoutDashes.slice(3);
+				const resolvedName = aliasMap.get(flagName) ?? flagName;
+				if (booleanFlags.has(resolvedName)) {
+					setOption(flagName, false);
+					i++;
+					continue;
+				}
+			}
+			const eqIndex = withoutDashes.indexOf("=");
+			if (eqIndex !== -1) {
+				setOption(withoutDashes.slice(0, eqIndex), withoutDashes.slice(eqIndex + 1));
+				i++;
+			} else {
+				const name = withoutDashes;
+				const resolvedName = aliasMap.get(name) ?? name;
+				if (booleanFlags.has(resolvedName)) {
+					setOption(name, true);
+					i++;
+				} else {
+					const nextArg = argv[i + 1];
+					if (nextArg !== void 0 && !nextArg.startsWith("-")) {
+						setOption(name, nextArg);
+						i += 2;
+					} else {
+						setOption(name, true);
+						i++;
+					}
+				}
+			}
+			continue;
+		}
+		if (arg.startsWith("-") && arg.length > 1 && !arg.startsWith("--")) {
+			const withoutDash = arg.slice(1);
+			const eqIndex = withoutDash.indexOf("=");
+			if (eqIndex !== -1) {
+				setOption(withoutDash.slice(0, eqIndex), withoutDash.slice(eqIndex + 1));
+				i++;
+			} else if (withoutDash.length === 1) {
+				const name = withoutDash;
+				const resolvedName = aliasMap.get(name) ?? name;
+				if (booleanFlags.has(resolvedName)) {
+					setOption(name, true);
+					i++;
+				} else {
+					const nextArg = argv[i + 1];
+					if (nextArg !== void 0 && !nextArg.startsWith("-")) {
+						setOption(name, nextArg);
+						i += 2;
+					} else {
+						setOption(name, true);
+						i++;
+					}
+				}
+			} else {
+				for (const char of withoutDash) setOption(char, true);
+				i++;
+			}
+			continue;
+		}
+		result.positionals.push(arg);
+		i++;
+	}
+	return result;
+}
+/**
+* Build parser options from extracted fields
+*/
+function buildParserOptions(extracted) {
+	const aliasMap = /* @__PURE__ */ new Map();
+	const booleanFlags = /* @__PURE__ */ new Set();
+	const arrayFlags = /* @__PURE__ */ new Set();
+	for (const field of extracted.fields) {
+		if (field.cliName !== field.name) aliasMap.set(field.cliName, field.name);
+		if (field.alias) aliasMap.set(field.alias, field.name);
+		if (field.type === "boolean") booleanFlags.add(field.name);
+		if (field.type === "array") arrayFlags.add(field.name);
+	}
+	return {
+		aliasMap,
+		booleanFlags,
+		arrayFlags
+	};
+}
+/**
+* Merge parsed argv with positional fields to create a flat record
+*/
+function mergeWithPositionals(parsed, extracted) {
+	const result = { ...parsed.options };
+	const positionalFields = extracted.fields.filter((f) => f.positional);
+	let positionalIndex = 0;
+	for (const field of positionalFields) {
+		if (positionalIndex >= parsed.positionals.length) break;
+		if (field.type === "array") {
+			result[field.name] = parsed.positionals.slice(positionalIndex);
+			break;
+		} else {
+			result[field.name] = parsed.positionals[positionalIndex];
+			positionalIndex++;
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/parser/arg-parser.ts
+/**
+* Parse CLI arguments for a command
+*
+* @param argv - Command line arguments
+* @param command - The command to parse for
+* @param options - Parse options
+* @returns Parse result
+*/
+function parseArgs(argv, command, options = {}) {
+	const subCommandNames = command.subCommands ? Object.keys(command.subCommands) : [];
+	const hasSubCommands = subCommandNames.length > 0;
+	if (hasSubCommands && argv.length > 0) {
+		const firstArg = argv[0];
+		if (firstArg && !firstArg.startsWith("-") && subCommandNames.includes(firstArg)) return {
+			helpRequested: false,
+			helpAllRequested: false,
+			versionRequested: false,
+			subCommand: firstArg,
+			remainingArgs: argv.slice(1),
+			rawArgs: {},
+			positionals: [],
+			unknownFlags: []
+		};
+	}
+	let extracted;
+	if (command.args) {
+		extracted = extractFields(command.args);
+		if (!options.skipValidation) {
+			validateDuplicateFields(extracted);
+			validateDuplicateAliases(extracted);
+			validatePositionalConfig(extracted);
+			validateReservedAliases(extracted, hasSubCommands);
+		}
+	}
+	const hasUserDefinedH = extracted?.fields.some((f) => f.alias === "H" && f.overrideBuiltinAlias === true) ?? false;
+	const hasUserDefinedh = extracted?.fields.some((f) => f.alias === "h" && f.overrideBuiltinAlias === true) ?? false;
+	const helpAllRequested = argv.includes("--help-all") || !hasUserDefinedH && argv.includes("-H");
+	const helpRequested = !helpAllRequested && (argv.includes("--help") || !hasUserDefinedh && argv.includes("-h"));
+	const versionRequested = argv.includes("--version");
+	if (helpRequested || helpAllRequested || versionRequested) return {
+		helpRequested,
+		helpAllRequested,
+		versionRequested,
+		subCommand: void 0,
+		remainingArgs: [],
+		rawArgs: {},
+		positionals: [],
+		unknownFlags: []
+	};
+	if (!extracted) return {
+		helpRequested: false,
+		helpAllRequested: false,
+		versionRequested: false,
+		subCommand: void 0,
+		remainingArgs: [],
+		rawArgs: {},
+		positionals: [],
+		unknownFlags: []
+	};
+	const parsed = parseArgv(argv, buildParserOptions(extracted));
+	const rawArgs = mergeWithPositionals(parsed, extracted);
+	for (const field of extracted.fields) if (field.env && rawArgs[field.name] === void 0) {
+		const envNames = Array.isArray(field.env) ? field.env : [field.env];
+		for (const envName of envNames) {
+			const envValue = process.env[envName];
+			if (envValue !== void 0) {
+				rawArgs[field.name] = envValue;
+				break;
+			}
+		}
+	}
+	const knownFlags = new Set(extracted.fields.map((f) => f.name));
+	const knownCliNames = new Set(extracted.fields.map((f) => f.cliName));
+	const knownAliases = new Set(extracted.fields.filter((f) => f.alias).map((f) => f.alias));
+	const unknownFlags = [];
+	for (const key of Object.keys(parsed.options)) if (!knownFlags.has(key) && !knownCliNames.has(key) && !knownAliases.has(key)) unknownFlags.push(key);
+	return {
+		helpRequested: false,
+		helpAllRequested: false,
+		versionRequested: false,
+		subCommand: void 0,
+		remainingArgs: [],
+		rawArgs,
+		positionals: parsed.positionals,
+		unknownFlags,
+		extractedFields: extracted
+	};
+}
+
+//#endregion
+//#region src/validator/error-formatter.ts
+/**
+* Calculate Levenshtein distance between two strings
+*/
+function levenshteinDistance(a, b) {
+	const matrix = [];
+	for (let i = 0; i <= b.length; i++) matrix[i] = [i];
+	for (let j = 0; j <= a.length; j++) matrix[0][j] = j;
+	for (let i = 1; i <= b.length; i++) for (let j = 1; j <= a.length; j++) if (b.charAt(i - 1) === a.charAt(j - 1)) matrix[i][j] = matrix[i - 1][j - 1];
+	else matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+	return matrix[b.length][a.length];
+}
+/**
+* Find similar strings from a list
+*/
+function findSimilar(target, candidates) {
+	const threshold = Math.max(2, Math.floor(target.length / 2));
+	return candidates.map((candidate) => ({
+		candidate,
+		distance: levenshteinDistance(target.toLowerCase(), candidate.toLowerCase())
+	})).filter(({ distance }) => distance <= threshold).sort((a, b) => a.distance - b.distance).map(({ candidate }) => candidate).slice(0, 3);
+}
+/**
+* Format validation errors into a human-readable message
+*
+* @param errors - Array of validation errors
+* @returns Formatted error message
+*/
+function formatValidationErrors$1(errors) {
+	if (errors.length === 0) return "";
+	const lines = [styles.error("Validation errors:")];
+	for (const error of errors) {
+		const path = error.path.join(".");
+		lines.push(`  ${symbols.bullet} ${styles.bold(path)}: ${error.message}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Format unknown flag error with suggestions
+*
+* @param flag - The unknown flag (e.g., "--verbos")
+* @param knownFlags - List of known flag names
+* @returns Formatted error message with suggestions
+*/
+function formatUnknownFlag(flag, knownFlags) {
+	const similar = findSimilar(flag.replace(/^-{1,2}/, ""), knownFlags);
+	let message = `${styles.error("Unknown option:")} ${styles.bold(flag)}`;
+	if (similar.length > 0) {
+		message += `\n\n${styles.info("Did you mean?")}`;
+		for (const suggestion of similar) message += `\n  ${symbols.arrow} ${styles.option(`--${suggestion}`)}`;
+	}
+	return message;
+}
+/**
+* Format unknown flag warning with suggestions (for strip mode)
+*
+* @param flag - The unknown flag (e.g., "--verbos")
+* @param knownFlags - List of known flag names
+* @returns Formatted warning message with suggestions
+*/
+function formatUnknownFlagWarning(flag, knownFlags) {
+	const similar = findSimilar(flag.replace(/^-{1,2}/, ""), knownFlags);
+	let message = `${styles.warning("Warning: Unknown option:")} ${styles.bold(flag)}`;
+	if (similar.length > 0) {
+		message += `\n\n${styles.info("Did you mean?")}`;
+		for (const suggestion of similar) message += `\n  ${symbols.arrow} ${styles.option(`--${suggestion}`)}`;
+	}
+	return message;
+}
+/**
+* Format runtime error
+*
+* @param error - The error that occurred
+* @param debug - Whether to include stack trace
+* @returns Formatted error message
+*/
+function formatRuntimeError(error, debug) {
+	if (debug && error.stack) return `${styles.error("Error:")} ${error.message}\n\n${styles.dim(error.stack)}`;
+	return `${styles.error("Error:")} ${error.message}`;
+}
+/**
+* Format unknown subcommand error with suggestions
+*
+* @param subcommand - The unknown subcommand name
+* @param knownSubcommands - List of known subcommand names
+* @returns Formatted error message with suggestions
+*/
+function formatUnknownSubcommand(subcommand, knownSubcommands) {
+	const similar = findSimilar(subcommand, knownSubcommands);
+	let message = `${styles.error("Unknown command:")} ${styles.bold(subcommand)}`;
+	if (similar.length > 0) {
+		message += `\n\n${styles.info("Did you mean?")}`;
+		for (const suggestion of similar) message += `\n  ${symbols.arrow} ${styles.command(suggestion)}`;
+	}
+	return message;
+}
+
+//#endregion
+//#region src/validator/zod-validator.ts
+/**
+* Convert ZodError to ValidationError array (zod v4 compatible)
+*/
+function formatZodErrors(error) {
+	return error.issues.map((issue) => ({
+		path: issue.path.map(String),
+		message: issue.message,
+		code: issue.code,
+		received: "received" in issue ? issue.received : void 0,
+		expected: "expected" in issue ? String(issue.expected) : void 0
+	}));
+}
+/**
+* Validate raw arguments against a schema
+*
+* @param rawArgs - Parsed but unvalidated arguments
+* @param schema - Zod schema (ZodObject, ZodDiscriminatedUnion, etc.)
+* @returns Validation result with typed data or errors
+*/
+function validateArgs(rawArgs, schema) {
+	const result = schema.safeParse(rawArgs);
+	if (result.success) return {
+		success: true,
+		data: result.data
+	};
+	return {
+		success: false,
+		errors: formatZodErrors(result.error)
+	};
+}
+/**
+* Format validation errors for display
+*/
+function formatValidationErrors(errors) {
+	return errors.map((e) => {
+		return `${e.path.length > 0 ? `${e.path.join(".")}: ` : ""}${e.message}`;
+	}).join("\n");
+}
+
+//#endregion
+//#region src/core/runner.ts
+/**
+* Default logger using console
+*/
+const defaultLogger = {
+	log: (message) => console.log(message),
+	error: (message) => console.error(message)
+};
+/**
+* Run a command with the given arguments (programmatic/test usage)
+*
+* This function parses arguments, validates them, routes to subcommands,
+* and executes the command. It does NOT call process.exit.
+*
+* @param command - The command to run
+* @param argv - Command line arguments to parse
+* @param options - Run options
+* @returns The result of command execution
+*
+* @example
+* ```ts
+* import { defineCommand, runCommand } from "politty";
+*
+* const command = defineCommand({
+*   name: "my-cli",
+*   args: z.object({ name: z.string() }),
+*   run: ({ name }) => console.log(`Hello, ${name}!`),
+* });
+*
+* // In tests
+* const result = await runCommand(command, ["--name", "World"]);
+* expect(result.exitCode).toBe(0);
+* ```
+*/
+async function runCommand(command, argv, options = {}) {
+	return runCommandInternal(command, argv, {
+		...options,
+		handleSignals: false,
+		skipValidation: options.skipValidation,
+		logger: options.logger
+	});
+}
+/**
+* Run a CLI command as the main entry point
+*
+* This function:
+* - Uses process.argv for arguments
+* - Handles SIGINT/SIGTERM signals
+* - Calls process.exit with the appropriate exit code
+*
+* @param command - The command to run
+* @param options - Main options (version, debug)
+*
+* @example
+* ```ts
+* import { defineCommand, runMain } from "politty";
+*
+* const command = defineCommand({
+*   name: "my-cli",
+*   run: () => console.log("Hello!"),
+* });
+*
+* runMain(command, { version: "1.0.0" });
+* ```
+*/
+async function runMain(command, options = {}) {
+	const result = await runCommandInternal(command, process.argv.slice(2), {
+		debug: options.debug,
+		captureLogs: options.captureLogs,
+		skipValidation: options.skipValidation,
+		handleSignals: true,
+		logger: options.logger,
+		_context: {
+			commandPath: [],
+			rootName: command.name,
+			rootVersion: options.version
+		}
+	});
+	process.exit(result.exitCode);
+}
+/**
+* Internal implementation of command running
+*/
+async function runCommandInternal(command, argv, options = {}) {
+	const logger$1 = options.logger ?? defaultLogger;
+	const context = options._context ?? {
+		commandPath: [],
+		rootName: command.name
+	};
+	const collector = options.captureLogs ?? false ? createLogCollector() : null;
+	collector?.start();
+	const getCurrentLogs = () => {
+		return mergeLogs(options._existingLogs ?? emptyLogs(), collector?.getLogs() ?? emptyLogs());
+	};
+	try {
+		const parseResult = parseArgs(argv, command, { skipValidation: options.skipValidation });
+		if (parseResult.helpRequested || parseResult.helpAllRequested) {
+			let hasUnknownSubcommand = false;
+			const subCmdNames = listSubCommands(command);
+			if (subCmdNames.length > 0) {
+				const potentialSubCmd = argv.find((arg) => !arg.startsWith("-"));
+				if (potentialSubCmd && !subCmdNames.includes(potentialSubCmd)) {
+					logger$1.error(formatUnknownSubcommand(potentialSubCmd, subCmdNames));
+					logger$1.error("");
+					hasUnknownSubcommand = true;
+				}
+			}
+			const help = generateHelp(command, {
+				showSubcommands: options.showSubcommands ?? true,
+				showSubcommandOptions: parseResult.helpAllRequested || options.showSubcommandOptions,
+				context
+			});
+			logger$1.log(help);
+			collector?.stop();
+			if (hasUnknownSubcommand) return {
+				success: false,
+				error: /* @__PURE__ */ new Error(`Unknown subcommand: ${argv.find((arg) => !arg.startsWith("-"))}`),
+				exitCode: 1,
+				logs: getCurrentLogs()
+			};
+			return {
+				success: true,
+				result: void 0,
+				exitCode: 0,
+				logs: getCurrentLogs()
+			};
+		}
+		if (parseResult.versionRequested) {
+			const version = context.rootVersion;
+			if (version) logger$1.log(version);
+			collector?.stop();
+			return {
+				success: true,
+				result: void 0,
+				exitCode: 0,
+				logs: getCurrentLogs()
+			};
+		}
+		if (parseResult.subCommand) {
+			const subCmd = await resolveSubcommand(command, parseResult.subCommand);
+			if (subCmd) {
+				const subContext = {
+					commandPath: [...context.commandPath ?? [], parseResult.subCommand],
+					rootName: context.rootName,
+					rootVersion: context.rootVersion
+				};
+				collector?.stop();
+				return runCommandInternal(subCmd, parseResult.remainingArgs, {
+					...options,
+					_context: subContext,
+					_existingLogs: getCurrentLogs()
+				});
+			}
+		}
+		if (listSubCommands(command).length > 0 && !parseResult.subCommand && !command.run) {
+			const help = generateHelp(command, {
+				showSubcommands: options.showSubcommands ?? true,
+				context
+			});
+			logger$1.log(help);
+			collector?.stop();
+			return {
+				success: true,
+				result: void 0,
+				exitCode: 0,
+				logs: getCurrentLogs()
+			};
+		}
+		if (parseResult.unknownFlags.length > 0) {
+			const unknownKeysMode = parseResult.extractedFields?.unknownKeysMode ?? "strip";
+			const knownFlags = parseResult.extractedFields?.fields.map((f) => f.name) ?? [];
+			if (unknownKeysMode === "strict") {
+				for (const flag of parseResult.unknownFlags) logger$1.error(formatUnknownFlag(flag, knownFlags));
+				collector?.stop();
+				return {
+					success: false,
+					error: /* @__PURE__ */ new Error(`Unknown flags: ${parseResult.unknownFlags.join(", ")}`),
+					exitCode: 1,
+					logs: getCurrentLogs()
+				};
+			} else if (unknownKeysMode === "strip") for (const flag of parseResult.unknownFlags) logger$1.error(formatUnknownFlagWarning(flag, knownFlags));
+		}
+		if (!command.args) {
+			collector?.stop();
+			return await executeLifecycle(command, {}, {
+				handleSignals: options.handleSignals,
+				captureLogs: options.captureLogs,
+				existingLogs: getCurrentLogs()
+			});
+		}
+		const validationResult = validateArgs(parseResult.rawArgs, command.args);
+		if (!validationResult.success) {
+			logger$1.error(formatValidationErrors$1(validationResult.errors));
+			collector?.stop();
+			return {
+				success: false,
+				error: new Error(formatValidationErrors$1(validationResult.errors)),
+				exitCode: 1,
+				logs: getCurrentLogs()
+			};
+		}
+		collector?.stop();
+		return await executeLifecycle(command, validationResult.data, {
+			handleSignals: options.handleSignals,
+			captureLogs: options.captureLogs,
+			existingLogs: getCurrentLogs()
+		});
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		logger$1.error(formatRuntimeError(err, options.debug ?? false));
+		collector?.stop();
+		return {
+			success: false,
+			error: err,
+			exitCode: 1,
+			logs: getCurrentLogs()
+		};
+	}
+}
+
+//#endregion
+export { logger as _, formatCommandValidationErrors as a, symbols as b, validateDuplicateFields as c, DuplicateAliasError as d, DuplicateFieldError as f, isColorEnabled as g, generateHelp as h, parseArgv as i, validatePositionalConfig as l, ReservedAliasError as m, runMain as n, validateCommand as o, PositionalConfigError as p, formatValidationErrors as r, validateDuplicateAliases as s, runCommand as t, validateReservedAliases as u, setColorEnabled as v, styles as y };
+//# sourceMappingURL=runner-DceWXOwD.js.map