politty 0.0.1 → 0.1.1

package/dist/runner-BZuYiRhi.cjs

@@ -0,0 +1,1492 @@
+const require_schema_extractor = require('./schema-extractor-B9D3Rf22.cjs');
+const require_subcommand_router = require('./subcommand-router-Vf-0w9P4.cjs');
+const require_docs_index = require('./docs/index.cjs');
+let zod = require("zod");
+let node_util = require("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 ? require_subcommand_router.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 = require_subcommand_router.mergeLogs(_options.existingLogs ?? require_subcommand_router.emptyLogs(), collector?.getLogs() ?? require_subcommand_router.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 = (0, node_util.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 = require_schema_extractor.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 = require_schema_extractor.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 = require_schema_extractor.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 = require_schema_extractor.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 require_subcommand_router.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 = require_schema_extractor.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 ? require_subcommand_router.createLogCollector() : null;
+	collector?.start();
+	const getCurrentLogs = () => {
+		return require_subcommand_router.mergeLogs(options._existingLogs ?? require_subcommand_router.emptyLogs(), collector?.getLogs() ?? require_subcommand_router.emptyLogs());
+	};
+	try {
+		const parseResult = parseArgs(argv, command, { skipValidation: options.skipValidation });
+		if (parseResult.helpRequested || parseResult.helpAllRequested) {
+			let hasUnknownSubcommand = false;
+			const subCmdNames = require_subcommand_router.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 require_subcommand_router.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 (require_subcommand_router.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
+Object.defineProperty(exports, 'DuplicateAliasError', {
+  enumerable: true,
+  get: function () {
+    return DuplicateAliasError;
+  }
+});
+Object.defineProperty(exports, 'DuplicateFieldError', {
+  enumerable: true,
+  get: function () {
+    return DuplicateFieldError;
+  }
+});
+Object.defineProperty(exports, 'PositionalConfigError', {
+  enumerable: true,
+  get: function () {
+    return PositionalConfigError;
+  }
+});
+Object.defineProperty(exports, 'ReservedAliasError', {
+  enumerable: true,
+  get: function () {
+    return ReservedAliasError;
+  }
+});
+Object.defineProperty(exports, 'formatCommandValidationErrors', {
+  enumerable: true,
+  get: function () {
+    return formatCommandValidationErrors;
+  }
+});
+Object.defineProperty(exports, 'formatValidationErrors', {
+  enumerable: true,
+  get: function () {
+    return formatValidationErrors;
+  }
+});
+Object.defineProperty(exports, 'generateHelp', {
+  enumerable: true,
+  get: function () {
+    return generateHelp;
+  }
+});
+Object.defineProperty(exports, 'isColorEnabled', {
+  enumerable: true,
+  get: function () {
+    return isColorEnabled;
+  }
+});
+Object.defineProperty(exports, 'logger', {
+  enumerable: true,
+  get: function () {
+    return logger;
+  }
+});
+Object.defineProperty(exports, 'parseArgv', {
+  enumerable: true,
+  get: function () {
+    return parseArgv;
+  }
+});
+Object.defineProperty(exports, 'runCommand', {
+  enumerable: true,
+  get: function () {
+    return runCommand;
+  }
+});
+Object.defineProperty(exports, 'runMain', {
+  enumerable: true,
+  get: function () {
+    return runMain;
+  }
+});
+Object.defineProperty(exports, 'setColorEnabled', {
+  enumerable: true,
+  get: function () {
+    return setColorEnabled;
+  }
+});
+Object.defineProperty(exports, 'styles', {
+  enumerable: true,
+  get: function () {
+    return styles;
+  }
+});
+Object.defineProperty(exports, 'symbols', {
+  enumerable: true,
+  get: function () {
+    return symbols;
+  }
+});
+Object.defineProperty(exports, 'validateCommand', {
+  enumerable: true,
+  get: function () {
+    return validateCommand;
+  }
+});
+Object.defineProperty(exports, 'validateDuplicateAliases', {
+  enumerable: true,
+  get: function () {
+    return validateDuplicateAliases;
+  }
+});
+Object.defineProperty(exports, 'validateDuplicateFields', {
+  enumerable: true,
+  get: function () {
+    return validateDuplicateFields;
+  }
+});
+Object.defineProperty(exports, 'validatePositionalConfig', {
+  enumerable: true,
+  get: function () {
+    return validatePositionalConfig;
+  }
+});
+Object.defineProperty(exports, 'validateReservedAliases', {
+  enumerable: true,
+  get: function () {
+    return validateReservedAliases;
+  }
+});
+//# sourceMappingURL=runner-BZuYiRhi.cjs.map