politty 0.7.0 → 0.9.0

package/dist/runner-DvFvokV6.cjs

@@ -1,2865 +0,0 @@
-const require_log_collector = require('./log-collector-DUqC427m.cjs');
-const require_schema_extractor = require('./schema-extractor-BxSRwLrx.cjs');
-let node_util = require("node:util");
-let string_width = require("string-width");
-string_width = require_log_collector.__toESM(string_width, 1);
-
-//#region src/core/case-proxy.ts
-/**
-* Wrap an args object with a Proxy that allows dual-case access.
-*
-* Given `{ "my-option": "value" }`, both `obj["my-option"]` and `obj.myOption`
-* will return `"value"`.
-*
-* - `Object.keys()`, `JSON.stringify()`, and spread return only the original keys.
-* - The `in` operator detects both case variants.
-*/
-function createDualCaseProxy(obj) {
-	return new Proxy(obj, {
-		get(target, prop, receiver) {
-			if (typeof prop === "string") {
-				if (prop in target) return Reflect.get(target, prop, receiver);
-				const camel = require_schema_extractor.toCamelCase(prop);
-				if (camel !== prop && camel in target) return Reflect.get(target, camel, receiver);
-				const kebab = require_schema_extractor.toKebabCase(prop);
-				if (kebab !== prop && kebab in target) return Reflect.get(target, kebab, receiver);
-			}
-			return Reflect.get(target, prop, receiver);
-		},
-		has(target, prop) {
-			if (typeof prop === "string") {
-				if (prop in target) return true;
-				const camel = require_schema_extractor.toCamelCase(prop);
-				if (camel !== prop && camel in target) return true;
-				const kebab = require_schema_extractor.toKebabCase(prop);
-				if (kebab !== prop && kebab in target) return true;
-			}
-			return Reflect.has(target, prop);
-		}
-	});
-}
-
-//#endregion
-//#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_log_collector.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);
-			}
-			const signalError = /* @__PURE__ */ new Error("Process interrupted");
-			cleanupContext.error = signalError;
-			if (command.cleanup) try {
-				await command.cleanup(cleanupContext);
-			} catch (e) {
-				console.error("Error during signal cleanup:", e);
-			}
-			if (_options.globalCleanup) try {
-				await _options.globalCleanup({ error: signalError });
-			} catch (e) {
-				console.error("Error during global signal cleanup:", e);
-			}
-			collector?.stop();
-			if (process.stdout.writableNeedDrain) await new Promise((resolve) => {
-				const timeout = setTimeout(() => {
-					process.stdout.off("drain", onDrain);
-					resolve();
-				}, 200);
-				const onDrain = () => {
-					clearTimeout(timeout);
-					resolve();
-				};
-				process.stdout.once("drain", onDrain);
-			});
-			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_log_collector.mergeLogs(_options.existingLogs ?? require_log_collector.emptyLogs(), collector?.getLogs() ?? require_log_collector.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", "underline", "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 = {
-	/**
-	* Log informational message
-	*/
-	info(message) {
-		console.log(message);
-	},
-	/**
-	* Log success message
-	*/
-	success(message) {
-		console.log(`${symbols.success} ${styles.success(message)}`);
-	},
-	/**
-	* Log warning message
-	*/
-	warn(message) {
-		console.warn(`${symbols.warning} ${styles.warning(message)}`);
-	},
-	/**
-	* Log error message
-	*/
-	error(message) {
-		console.error(`${symbols.error} ${styles.error(message)}`);
-	},
-	/**
-	* Log raw message without prefix
-	*/
-	log(message) {
-		console.log(message);
-	},
-	/**
-	* Log empty line
-	*/
-	newline() {
-		console.log("");
-	},
-	/**
-	* Log debug message with dim color
-	*/
-	debug(message) {
-		console.log(styles.dim(message));
-	}
-};
-
-//#endregion
-//#region src/output/markdown-renderer.ts
-/**
-* Lightweight Markdown-to-terminal renderer.
-*
-* Supports a subset of Markdown tailored for CLI help notes:
-* - Inline: bold, italic, inline code, links
-* - Block: paragraphs, unordered/ordered lists, blockquotes, headings,
-*          horizontal rules, fenced code blocks
-*/
-/**
-* Apply inline Markdown formatting to a string.
-*
-* Processing order matters to avoid conflicts:
-*   1. Inline code (backticks) — content inside is literal, no further processing
-*   2. Bold (**text**)
-*   3. Italic (*text* or _text_)
-*   4. Links [text](url)
-*/
-function renderInline(text) {
-	const codeSpans = [];
-	let result = text.replace(/`([^`]+)`/g, (_match, code) => {
-		const index = codeSpans.length;
-		codeSpans.push(styles.cyan(code));
-		return `\x00CODE${index}\x00`;
-	});
-	result = result.replace(/\*\*(.+?)\*\*/g, (_match, content) => styles.bold(content));
-	result = result.replace(/__(.+?)__/g, (_match, content) => styles.bold(content));
-	result = result.replace(/\*(.+?)\*/g, (_match, content) => styles.italic(content));
-	result = result.replace(/(?<!\w)_(.+?)_(?!\w)/g, (_match, content) => styles.italic(content));
-	result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, linkText, url) => `${styles.underline(linkText)} ${styles.dim(`(${url})`)}`);
-	result = result.replace(/\x00CODE(\d+)\x00/g, (_match, index) => codeSpans[Number(index)]);
-	return result;
-}
-/**
-* Render a Markdown string to styled terminal output.
-*
-* Block-level processing:
-*   - Splits input into blocks separated by blank lines
-*   - Detects headings, horizontal rules, blockquotes, lists, code blocks, and paragraphs
-*   - Applies inline formatting within each block
-*/
-function renderMarkdown(markdown) {
-	return splitIntoBlocks(markdown.split("\n")).map(renderBlock).join("\n\n");
-}
-const HEADING_RE = /^(#{1,6})\s+(.+)$/;
-const HR_RE = /^(?:---+|\*\*\*+|___+)\s*$/;
-const BLOCKQUOTE_RE = /^>\s?(.*)$/;
-const UL_RE = /^-\s+(.+)$/;
-const OL_RE = /^(\d+)[.)]\s+(.+)$/;
-const FENCE_OPEN_RE = /^(`{3,}|~{3,})(\S*)\s*$/;
-const ALERT_RE = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*$/;
-const TABLE_ROW_RE = /^\|(.+)\|$/;
-const TABLE_SEP_RE = /^\|(\s*:?-+:?\s*\|)+$/;
-/**
-* Split lines into logical blocks separated by blank lines.
-* Consecutive lines of the same block type are grouped together.
-*/
-function splitIntoBlocks(lines) {
-	const blocks = [];
-	let i = 0;
-	while (i < lines.length) {
-		const line = lines[i];
-		if (line.trim() === "") {
-			i++;
-			continue;
-		}
-		const fenceMatch = line.match(FENCE_OPEN_RE);
-		if (fenceMatch) {
-			const fence = fenceMatch[1];
-			const lang = fenceMatch[2] ?? "";
-			const codeLines = [];
-			i++;
-			while (i < lines.length) {
-				if (lines[i].startsWith(fence.charAt(0).repeat(fence.length)) && lines[i].trim() === fence.charAt(0).repeat(Math.max(fence.length, lines[i].trim().length))) {
-					i++;
-					break;
-				}
-				codeLines.push(lines[i]);
-				i++;
-			}
-			blocks.push({
-				type: "code",
-				lang,
-				lines: codeLines
-			});
-			continue;
-		}
-		const headingMatch = line.match(HEADING_RE);
-		if (headingMatch) {
-			blocks.push({
-				type: "heading",
-				level: headingMatch[1].length,
-				content: headingMatch[2]
-			});
-			i++;
-			continue;
-		}
-		if (HR_RE.test(line)) {
-			blocks.push({ type: "hr" });
-			i++;
-			continue;
-		}
-		if (BLOCKQUOTE_RE.test(line)) {
-			const bqLines = [];
-			while (i < lines.length) {
-				const bqMatch = lines[i].match(BLOCKQUOTE_RE);
-				if (bqMatch) {
-					bqLines.push(bqMatch[1]);
-					i++;
-				} else break;
-			}
-			if (bqLines.length > 0) {
-				const alertMatch = bqLines[0].match(ALERT_RE);
-				if (alertMatch) {
-					const contentLines = bqLines.slice(1).filter((l) => l !== "");
-					blocks.push({
-						type: "alert",
-						alertType: alertMatch[1],
-						lines: contentLines
-					});
-					continue;
-				}
-			}
-			blocks.push({
-				type: "blockquote",
-				lines: bqLines
-			});
-			continue;
-		}
-		if (UL_RE.test(line)) {
-			const items = [];
-			while (i < lines.length) {
-				const ulMatch = lines[i].match(UL_RE);
-				if (ulMatch) {
-					items.push(ulMatch[1]);
-					i++;
-				} else break;
-			}
-			blocks.push({
-				type: "ul",
-				items
-			});
-			continue;
-		}
-		const olMatch = line.match(OL_RE);
-		if (olMatch) {
-			const start = Number(olMatch[1]);
-			const items = [];
-			while (i < lines.length) {
-				const match = lines[i].match(OL_RE);
-				if (match) {
-					items.push(match[2]);
-					i++;
-				} else break;
-			}
-			blocks.push({
-				type: "ol",
-				items,
-				start
-			});
-			continue;
-		}
-		if (TABLE_ROW_RE.test(line) && i + 1 < lines.length && TABLE_SEP_RE.test(lines[i + 1])) {
-			const headers = parseCells(line);
-			const alignments = parseAlignments(lines[i + 1]);
-			i += 2;
-			const rows = [];
-			while (i < lines.length && TABLE_ROW_RE.test(lines[i])) {
-				rows.push(parseCells(lines[i]));
-				i++;
-			}
-			blocks.push({
-				type: "table",
-				headers,
-				alignments,
-				rows
-			});
-			continue;
-		}
-		const paraLines = [];
-		while (i < lines.length) {
-			const l = lines[i];
-			if (l.trim() === "" || HEADING_RE.test(l) || HR_RE.test(l) || BLOCKQUOTE_RE.test(l) || UL_RE.test(l) || OL_RE.test(l) || FENCE_OPEN_RE.test(l) || TABLE_ROW_RE.test(l) && i + 1 < lines.length && TABLE_SEP_RE.test(lines[i + 1])) break;
-			paraLines.push(l);
-			i++;
-		}
-		if (paraLines.length > 0) blocks.push({
-			type: "paragraph",
-			lines: paraLines
-		});
-	}
-	return blocks;
-}
-/**
-* Parse cells from a table row: `| a | b | c |` → `["a", "b", "c"]`
-*/
-function parseCells(row) {
-	return row.slice(1, -1).split("|").map((cell) => cell.trim());
-}
-/**
-* Parse alignment from separator row: `|:---|:---:|---:|` → `["left", "center", "right"]`
-*/
-function parseAlignments(sepRow) {
-	return sepRow.slice(1, -1).split("|").map((cell) => {
-		const trimmed = cell.trim();
-		if (trimmed.startsWith(":") && trimmed.endsWith(":")) return "center";
-		if (trimmed.endsWith(":")) return "right";
-		return "left";
-	});
-}
-/**
-* Pad a string to a given width with the specified alignment.
-*/
-function alignText(text, width, alignment) {
-	const visualWidth = (0, string_width.default)(text);
-	const total = Math.max(0, width - visualWidth);
-	if (alignment === "right") return " ".repeat(total) + text;
-	if (alignment === "center") {
-		const left = Math.floor(total / 2);
-		return " ".repeat(left) + text + " ".repeat(total - left);
-	}
-	return text + " ".repeat(total);
-}
-/**
-* Style configuration for GitHub-style alert blocks.
-*/
-const alertStyles = {
-	NOTE: {
-		icon: "ℹ",
-		label: "Note",
-		styleFn: styles.cyan
-	},
-	TIP: {
-		icon: "💡",
-		label: "Tip",
-		styleFn: styles.green
-	},
-	IMPORTANT: {
-		icon: "❗",
-		label: "Important",
-		styleFn: styles.magenta
-	},
-	WARNING: {
-		icon: "⚠",
-		label: "Warning",
-		styleFn: styles.yellow
-	},
-	CAUTION: {
-		icon: "🔴",
-		label: "Caution",
-		styleFn: styles.red
-	}
-};
-/**
-* Render a single block to styled terminal output.
-*/
-function renderBlock(block) {
-	switch (block.type) {
-		case "heading": return styles.green(styles.bold(renderInline(block.content)));
-		case "hr": return styles.dim("─".repeat(40));
-		case "blockquote": {
-			const prefix = styles.dim("│ ");
-			return block.lines.map((line) => `${prefix}${renderInline(line)}`).join("\n");
-		}
-		case "alert": {
-			const { icon, label, styleFn } = alertStyles[block.alertType];
-			const prefix = styleFn(styles.bold("│")) + " ";
-			const header = `${prefix}${styleFn(icon)} ${styleFn(label)}`;
-			if (block.lines.length === 0) return header;
-			return `${header}\n${block.lines.map((line) => `${prefix}${renderInline(line)}`).join("\n")}`;
-		}
-		case "ul": return block.items.map((item) => `${styles.dim("•")} ${renderInline(item)}`).join("\n");
-		case "ol": {
-			const maxNum = block.start + block.items.length - 1;
-			const width = String(maxNum).length;
-			return block.items.map((item, i) => {
-				const num = String(block.start + i).padStart(width, " ");
-				return `${styles.dim(`${num}.`)} ${renderInline(item)}`;
-			}).join("\n");
-		}
-		case "table": {
-			const colCount = block.headers.length;
-			const renderedHeaders = block.headers.map((h) => renderInline(h));
-			const renderedRows = block.rows.map((row) => Array.from({ length: colCount }, (_, i) => renderInline(row[i] ?? "")));
-			const colWidths = renderedHeaders.map((h, i) => {
-				const headerWidth = (0, string_width.default)(h);
-				const cellWidths = renderedRows.map((row) => (0, string_width.default)(row[i]));
-				return Math.max(headerWidth, ...cellWidths);
-			});
-			const pipe = styles.dim("│");
-			const topBorder = styles.dim(`┌─${colWidths.map((w) => "─".repeat(w)).join("─┬─")}─┐`);
-			const midBorder = styles.dim(`├─${colWidths.map((w) => "─".repeat(w)).join("─┼─")}─┤`);
-			const botBorder = styles.dim(`└─${colWidths.map((w) => "─".repeat(w)).join("─┴─")}─┘`);
-			return [
-				topBorder,
-				`${pipe} ${renderedHeaders.map((h, i) => styles.bold(alignText(h, colWidths[i], block.alignments[i] ?? "left"))).join(` ${pipe} `)} ${pipe}`,
-				midBorder,
-				...renderedRows.map((row) => {
-					return `${pipe} ${row.map((cell, i) => alignText(cell, colWidths[i], block.alignments[i] ?? "left")).join(` ${pipe} `)} ${pipe}`;
-				}),
-				botBorder
-			].join("\n");
-		}
-		case "code": return block.lines.map((line) => `  ${styles.yellow(line)}`).join("\n");
-		case "paragraph": return renderInline(block.lines.join(" "));
-	}
-}
-
-//#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"
-};
-/**
-* Internal subcommands are reserved for framework internals and hidden from help output.
-*/
-function isVisibleSubcommand(name) {
-	return !name.startsWith("__");
-}
-function getVisibleSubcommandEntries(subCommands) {
-	return Object.entries(subCommands).filter(([name]) => isVisibleSubcommand(name));
-}
-/**
-* 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));
-	if (context?.globalExtracted?.fields.length) parts.push(styles.placeholder("[global options]"));
-	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 && getVisibleSubcommandEntries(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 && getVisibleSubcommandEntries(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.overrideBuiltinAlias === true && require_schema_extractor.getAllAliases(f).includes("h")) ?? false;
-	const hasUserDefinedH = extracted?.fields.some((f) => f.overrideBuiltinAlias === true && require_schema_extractor.getAllAliases(f).includes("H")) ?? 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 = opt.description ?? "";
-		if (opt.defaultValue !== void 0) desc += ` ${styles.defaultValue(`(default: ${JSON.stringify(opt.defaultValue)})`)}`;
-		if (opt.required) desc += ` ${styles.required("(required)")}`;
-		const envInfo = formatEnvInfo(opt.env);
-		if (envInfo) desc += ` ${envInfo}`;
-		lines.push(formatOption(flags, desc));
-		const negationLine = formatNegationLine(opt);
-		if (negationLine) lines.push(negationLine);
-	}
-	return lines.join("\n");
-}
-/**
-* Render a separate line for the custom negation option when a
-* `negationDescription` is provided. When no description is given, the
-* negation is shown inline by `formatFlags`.
-*/
-function formatNegationLine(opt, indent = 0, extraDescPadding = 0) {
-	if (!opt.negationDisplay || !opt.negationDescription) return null;
-	return formatOption(styles.option(`--${opt.negationDisplay}`), `${opt.negationDescription} ${styles.dim(`(↔ --${opt.cliName})`)}`, indent, extraDescPadding);
-}
-/**
-* 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));
-			const negationLine = formatNegationLine(field);
-			if (negationLine) lines.push(negationLine);
-		}
-	}
-	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, 1));
-				const negationLine = formatNegationLine(field, 1);
-				if (negationLine) lines.push(negationLine);
-			}
-		}
-	}
-	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));
-			const negationLine = formatNegationLine(field);
-			if (negationLine) lines.push(negationLine);
-		}
-	}
-	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);
-		const label = option.description ?? `Variant ${i + 1}`;
-		if (uniqueFields.length > 0) {
-			lines.push("");
-			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, 1));
-				const negationLine = formatNegationLine(field, 1);
-				if (negationLine) lines.push(negationLine);
-			}
-		} else {
-			lines.push("");
-			lines.push(`  ${styles.bold(`${label}:`)}`);
-			lines.push(`    ${styles.dim(styles.italic("no options"))}`);
-		}
-	}
-	return lines.join("\n");
-}
-/**
-* Format option flags (-v, --verbose <VALUE>)
-* Uses cliName (kebab-case) for display
-*/
-function formatFlags(opt) {
-	const aliasParts = [];
-	if (opt.alias) {
-		for (const alias of opt.alias) if (alias.length === 1) aliasParts.push(styles.option(`-${alias}`));
-	}
-	let longFlag = styles.option(`--${opt.cliName}`);
-	if (opt.type !== "boolean") {
-		const placeholder = opt.placeholder ?? opt.cliName.toUpperCase();
-		longFlag += ` ${styles.placeholder(`<${placeholder}>`)}`;
-	}
-	aliasParts.push(longFlag);
-	if (opt.alias) {
-		for (const alias of opt.alias) if (alias.length > 1) {
-			let longAlias = styles.option(`--${alias}`);
-			if (opt.type !== "boolean") {
-				const placeholder = opt.placeholder ?? opt.cliName.toUpperCase();
-				longAlias += ` ${styles.placeholder(`<${placeholder}>`)}`;
-			}
-			aliasParts.push(longAlias);
-		}
-	}
-	const aliasStr = aliasParts.join(", ");
-	if (opt.type === "boolean" && opt.negationDisplay && !opt.negationDescription) return `${aliasStr} / ${styles.option(`--${opt.negationDisplay}`)}`;
-	return aliasStr;
-}
-/**
-* 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}`;
-}
-/**
-* Format a single option field as a help line
-*/
-function formatFieldLine(opt, indent = 0, extraDescPadding = 0) {
-	const flags = formatFlags(opt);
-	let desc = opt.description ?? "";
-	if (opt.defaultValue !== void 0) desc += ` ${styles.defaultValue(`(default: ${JSON.stringify(opt.defaultValue)})`)}`;
-	if (opt.required) desc += ` ${styles.required("(required)")}`;
-	const envInfo = formatEnvInfo(opt.env);
-	if (envInfo) desc += ` ${envInfo}`;
-	return formatOption(flags, desc, indent, extraDescPadding);
-}
-/**
-* Render global options section
-*/
-function renderGlobalOptions(globalExtracted) {
-	const lines = [];
-	for (const opt of globalExtracted.fields) {
-		if (opt.positional) continue;
-		lines.push(formatFieldLine(opt));
-		const negationLine = formatNegationLine(opt);
-		if (negationLine) lines.push(negationLine);
-	}
-	return lines.join("\n");
-}
-/**
-* 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));
-			const negationLine = formatNegationLine(opt, indent, 2);
-			if (negationLine) lines.push(negationLine);
-		}
-	}
-	return lines;
-}
-/**
-* Render subcommands recursively with their options (flat style)
-*/
-function renderSubcommandsWithOptions(subCommands, parentPath, baseIndent) {
-	const lines = [];
-	for (const [name, subCmd] of getVisibleSubcommandEntries(subCommands)) {
-		const cmd = require_schema_extractor.resolveSubCommandMeta(subCmd);
-		const fullPath = parentPath ? `${parentPath} ${name}` : name;
-		const desc = cmd?.description ?? "";
-		const aliases = cmd?.aliases;
-		const displayName = aliases && aliases.length > 0 ? `${fullPath}, ${aliases.join(", ")}` : fullPath;
-		lines.push(formatOption(styles.command(displayName), desc, baseIndent));
-		if (cmd) {
-			const optionLines = renderSubcommandOptionsCompact(cmd, baseIndent + 1);
-			lines.push(...optionLines);
-			const visibleNestedSubCommands = cmd.subCommands ? Object.fromEntries(getVisibleSubcommandEntries(cmd.subCommands)) : void 0;
-			if (visibleNestedSubCommands && Object.keys(visibleNestedSubCommands).length > 0) {
-				const nestedLines = renderSubcommandsWithOptions(visibleNestedSubCommands, 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 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}`)}`;
-		sections.push(header);
-	}
-	if (context?.aliasFor) sections.push(styles.dim(`Alias for ${styles.commandName(context.aliasFor)}`));
-	if (command.description) sections.push(command.description);
-	if (!context?.aliasFor && command.aliases && command.aliases.length > 0) sections.push(`${styles.sectionHeader("Aliases:")} ${command.aliases.map((a) => styles.command(a)).join(", ")}`);
-	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 (context?.globalExtracted?.fields.length) sections.push(`${styles.sectionHeader("Global Options:")}\n${renderGlobalOptions(context.globalExtracted)}`);
-	if (options.showSubcommands !== false && command.subCommands && getVisibleSubcommandEntries(command.subCommands).length > 0) {
-		const currentPath = context?.commandPath?.join(" ") ?? "";
-		const visibleSubCommands = Object.fromEntries(getVisibleSubcommandEntries(command.subCommands));
-		if (options.showSubcommandOptions) {
-			const subLines = renderSubcommandsWithOptions(visibleSubCommands, currentPath, 0);
-			sections.push(`${styles.sectionHeader("Commands:")}\n${subLines.join("\n")}`);
-		} else {
-			const subLines = [];
-			for (const [name, subCmd] of Object.entries(visibleSubCommands)) {
-				const cmd = require_schema_extractor.resolveSubCommandMeta(subCmd);
-				const desc = cmd?.description ?? "";
-				const fullName = currentPath ? `${currentPath} ${name}` : name;
-				const aliases = cmd?.aliases;
-				const displayName = aliases && aliases.length > 0 ? `${fullName}, ${aliases.join(", ")}` : fullName;
-				subLines.push(formatOption(styles.command(displayName), 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) {
-		const indented = renderMarkdown(command.notes).split("\n").map((line) => line === "" ? "" : `  ${line}`).join("\n");
-		sections.push(`${styles.sectionHeader("Notes:")}\n${indented}`);
-	}
-	return `\n${sections.join("\n\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";
-	}
-};
-/**
-* Error thrown when fields are case variants of each other (e.g. "my-option" and "myOption")
-*/
-var CaseVariantCollisionError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "CaseVariantCollisionError";
-	}
-};
-/**
-* Error thrown when a custom boolean negation name collides with another
-* field's name, cliName, alias, or another field's negation (including
-* derived camelCase variants).
-*/
-var DuplicateNegationError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "DuplicateNegationError";
-	}
-};
-
-//#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 case-variant collisions (e.g. "my-option" and "myOption" defined simultaneously)
-*/
-function checkCaseVariantCollisions(extracted, commandPath) {
-	const errors = [];
-	const canonicalMap = /* @__PURE__ */ new Map();
-	for (const field of extracted.fields) {
-		const camel = require_schema_extractor.toCamelCase(field.name);
-		const existing = canonicalMap.get(camel);
-		if (existing && existing !== field.name) errors.push({
-			commandPath,
-			type: "case_variant_collision",
-			message: `Fields "${existing}" and "${field.name}" are case variants of each other and would collide.`,
-			field: field.name
-		});
-		canonicalMap.set(camel, 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));
-	const cliNames = new Set(extracted.fields.map((f) => f.cliName));
-	const registerAlias = (alias, fieldName, isDerived) => {
-		if (fieldNames.has(alias) || cliNames.has(alias)) errors.push({
-			commandPath,
-			type: "duplicate_alias",
-			message: `Alias "${alias}" for field "${fieldName}" conflicts with existing field name or CLI name "${alias}".`,
-			field: fieldName
-		});
-		const existingField = seenAliases.get(alias);
-		if (existingField && existingField !== fieldName) {
-			const qualifier = isDerived ? " (derived camelCase variant)" : "";
-			errors.push({
-				commandPath,
-				type: "duplicate_alias",
-				message: `Duplicate alias "${alias}"${qualifier} detected. Both "${existingField}" and "${fieldName}" use the same alias.`,
-				field: fieldName
-			});
-		}
-		seenAliases.set(alias, fieldName);
-	};
-	for (const field of extracted.fields) {
-		const allAliases = require_schema_extractor.getAllAliases(field);
-		if (allAliases.length === 0) continue;
-		for (const alias of allAliases) {
-			registerAlias(alias, field.name, false);
-			if (alias.length > 1 && alias.includes("-")) {
-				const camelVariant = require_schema_extractor.toCamelCase(alias);
-				if (camelVariant !== alias && !fieldNames.has(camelVariant)) registerAlias(camelVariant, field.name, true);
-			}
-		}
-	}
-	return errors;
-}
-/**
-* Check for collisions involving custom boolean `negation` names
-*/
-function checkDuplicateNegations(extracted, commandPath) {
-	const errors = [];
-	const claimed = /* @__PURE__ */ new Map();
-	const claim = (name, fieldName, kind) => {
-		if (!claimed.has(name)) claimed.set(name, {
-			field: fieldName,
-			kind
-		});
-	};
-	for (const field of extracted.fields) {
-		claim(field.name, field.name, "field name");
-		if (field.name.includes("-")) {
-			const camelName = require_schema_extractor.toCamelCase(field.name);
-			if (camelName !== field.name) claim(camelName, field.name, "field name");
-		}
-		if (field.cliName !== field.name) claim(field.cliName, field.name, "CLI name");
-		if (field.cliName.includes("-")) {
-			const camelCli = require_schema_extractor.toCamelCase(field.cliName);
-			if (camelCli !== field.cliName) claim(camelCli, field.name, "CLI name");
-		}
-		for (const alias of require_schema_extractor.getAllAliases(field)) {
-			claim(alias, field.name, "alias");
-			if (alias.length > 1 && alias.includes("-")) {
-				const camelVariant = require_schema_extractor.toCamelCase(alias);
-				if (camelVariant !== alias) claim(camelVariant, field.name, "alias");
-			}
-		}
-		if (field.type === "boolean" && field.negation !== false && typeof field.negation !== "string") {
-			const defaultKebab = `no-${field.cliName}`;
-			claim(defaultKebab, field.name, "default negation");
-			const camelBase = require_schema_extractor.toCamelCase(field.cliName);
-			const defaultCamel = `no${camelBase[0]?.toUpperCase() ?? ""}${camelBase.slice(1)}`;
-			if (defaultCamel !== defaultKebab) claim(defaultCamel, field.name, "default negation");
-		}
-	}
-	const seenNegations = /* @__PURE__ */ new Map();
-	const register = (name, fieldName, isDerived) => {
-		const claim = claimed.get(name);
-		if (claim) {
-			const qualifier = isDerived ? " (derived camelCase variant)" : "";
-			const conflict = claim.field === fieldName ? `the same field's own ${claim.kind} "${name}"` : `${claim.kind} "${name}" of field "${claim.field}"`;
-			errors.push({
-				commandPath,
-				type: "duplicate_negation",
-				message: `Negation "${name}"${qualifier} for field "${fieldName}" conflicts with ${conflict}.`,
-				field: fieldName
-			});
-		}
-		const existing = seenNegations.get(name);
-		if (existing && existing !== fieldName) {
-			const qualifier = isDerived ? " (derived camelCase variant)" : "";
-			errors.push({
-				commandPath,
-				type: "duplicate_negation",
-				message: `Duplicate negation "${name}"${qualifier} detected. Both "${existing}" and "${fieldName}" use the same negation name.`,
-				field: fieldName
-			});
-		}
-		seenNegations.set(name, fieldName);
-	};
-	for (const field of extracted.fields) {
-		if (typeof field.negation !== "string") continue;
-		register(field.negation, field.name, false);
-		if (field.negation.includes("-")) {
-			const camelVariant = require_schema_extractor.toCamelCase(field.negation);
-			if (camelVariant !== field.negation) register(camelVariant, field.name, true);
-		}
-	}
-	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.overrideBuiltinAlias === true) continue;
-		for (const alias of require_schema_extractor.getAllAliases(field)) if (alias === "h" || alias === "H") errors.push({
-			commandPath,
-			type: "reserved_alias",
-			message: `Alias "${alias}" is reserved for --${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 found = extracted.fields.find((f) => f.name === field);
-		const alias = (found ? require_schema_extractor.getAllAliases(found) : []).find((a) => a === "h" || a === "H") ?? "h";
-		throw new ReservedAliasError(`Alias "${alias}" is reserved for --${alias === "h" ? "help" : "help-all"}. To override this, set { overrideBuiltinAlias: true } for "${field}" and keep the alias where it is currently defined (in alias or hiddenAlias).`);
-	}
-}
-/**
-* Validate that custom boolean negation names do not collide with anything
-*
-* @param extracted - Extracted fields from schema
-* @throws {DuplicateNegationError} If a colliding negation is found
-*/
-function validateDuplicateNegations(extracted) {
-	const errors = checkDuplicateNegations(extracted, []);
-	if (errors.length > 0) {
-		const err = errors[0];
-		throw new DuplicateNegationError(err.message);
-	}
-}
-/**
-* Validate that no case-variant collisions exist
-*
-* @param extracted - Extracted fields from schema
-* @throws {CaseVariantCollisionError} If case-variant collisions are found
-*/
-function validateCaseVariantCollisions(extracted) {
-	const errors = checkCaseVariantCollisions(extracted, []);
-	if (errors.length > 0) {
-		const err = errors[0];
-		throw new CaseVariantCollisionError(err.message);
-	}
-}
-/**
-* Validate that no case-variant collisions exist between two schemas
-* (e.g., global args and command args).
-*
-* @param extractedA - Extracted fields from first schema (e.g., global args)
-* @param extractedB - Extracted fields from second schema (e.g., command args)
-* @throws {CaseVariantCollisionError} If cross-schema case-variant collisions are found
-*/
-function validateCrossSchemaCollisions(extractedA, extractedB) {
-	const canonicalMap = /* @__PURE__ */ new Map();
-	for (const field of extractedA.fields) canonicalMap.set(require_schema_extractor.toCamelCase(field.name), field.name);
-	for (const field of extractedB.fields) {
-		const camel = require_schema_extractor.toCamelCase(field.name);
-		const existing = canonicalMap.get(camel);
-		if (existing && existing !== field.name) throw new CaseVariantCollisionError(`Global field "${existing}" and command field "${field.name}" are case variants of each other and would collide.`);
-	}
-}
-/**
-* Collect validation errors for a single command's schema (non-throwing)
-*/
-function collectSchemaErrors(extracted, _hasSubCommands, commandPath) {
-	return [
-		...checkDuplicateFields(extracted, commandPath),
-		...checkCaseVariantCollisions(extracted, commandPath),
-		...checkDuplicateAliases(extracted, commandPath),
-		...checkDuplicateNegations(extracted, commandPath),
-		...checkPositionalConfig(extracted, commandPath),
-		...checkReservedAliases(extracted, commandPath)
-	];
-}
-/**
-* Check for alias conflicts within subcommands
-* - Aliases must not conflict with subcommand names
-* - Aliases must not conflict with other aliases
-*/
-function checkSubCommandAliasConflicts(command, commandPath) {
-	const errors = [];
-	if (!command.subCommands) return errors;
-	const nameToOwner = /* @__PURE__ */ new Map();
-	for (const [name] of Object.entries(command.subCommands)) nameToOwner.set(name, name);
-	for (const [name, subCmdValue] of Object.entries(command.subCommands)) {
-		const resolved = require_schema_extractor.isLazyCommand(subCmdValue) ? subCmdValue.meta : typeof subCmdValue !== "function" ? subCmdValue : null;
-		if (!resolved?.aliases) continue;
-		const subCommandPath = [...commandPath, name];
-		for (const alias of resolved.aliases) {
-			if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(alias)) {
-				errors.push({
-					commandPath: subCommandPath,
-					type: "invalid_alias",
-					message: `Alias "${alias}" is invalid. Aliases must start with an alphanumeric character and contain only alphanumeric characters, hyphens, or underscores.`,
-					field: name
-				});
-				continue;
-			}
-			if (alias === name) {
-				errors.push({
-					commandPath: subCommandPath,
-					type: "duplicate_alias",
-					message: `Alias "${alias}" conflicts with its own name.`,
-					field: name
-				});
-				continue;
-			}
-			const existing = nameToOwner.get(alias);
-			if (existing) if (existing === name) errors.push({
-				commandPath: subCommandPath,
-				type: "duplicate_alias",
-				message: `Alias "${alias}" is duplicated within the alias list.`,
-				field: name
-			});
-			else errors.push({
-				commandPath: subCommandPath,
-				type: "duplicate_alias",
-				message: `Alias "${alias}" conflicts with existing subcommand or alias "${existing}".`,
-				field: name
-			});
-			else nameToOwner.set(alias, name);
-		}
-	}
-	return errors;
-}
-/**
-* 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));
-	}
-	errors.push(...checkSubCommandAliasConflicts(command, commandPath));
-	if (command.subCommands) for (const [name, subCmd] of Object.entries(command.subCommands)) {
-		const subResult = await validateCommand(await require_schema_extractor.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
-* - Boolean negation: --no-flag, --noFlag (requires `booleanFlags`)
-*
-* **Note:** When using negation detection (`--noFlag` / `--no-flag`),
-* supply `definedNames` so that options whose names happen to start with
-* "no" (e.g. `noDryRun`) are not mistaken for negation of another flag.
-* Without `definedNames`, all `--noX` forms matching a boolean flag will
-* be treated as negation.
-*
-* @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(), definedNames = /* @__PURE__ */ new Set(), negationMap = /* @__PURE__ */ new Map(), customNegatedFields = /* @__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.includes("=")) {
-				const negatedField = negationMap.get(withoutDashes);
-				if (negatedField && booleanFlags.has(negatedField)) {
-					setOption(negatedField, false);
-					i++;
-					continue;
-				}
-			}
-			if (withoutDashes.startsWith("no-")) {
-				const flagName = withoutDashes.slice(3);
-				if (flagName === flagName.toLowerCase()) {
-					const resolvedName = aliasMap.get(flagName) ?? flagName;
-					if (booleanFlags.has(resolvedName) && !customNegatedFields.has(resolvedName)) {
-						const asIsResolved = aliasMap.get(withoutDashes) ?? withoutDashes;
-						if (!definedNames.has(asIsResolved)) {
-							setOption(flagName, false);
-							i++;
-							continue;
-						}
-					}
-				}
-			}
-			if (withoutDashes.length > 2 && withoutDashes.startsWith("no") && /[A-Z]/.test(withoutDashes[2])) {
-				const camelFlagName = withoutDashes[2].toLowerCase() + withoutDashes.slice(3);
-				const resolvedName = aliasMap.get(camelFlagName) ?? camelFlagName;
-				if (booleanFlags.has(resolvedName) && !customNegatedFields.has(resolvedName)) {
-					const asIsResolved = aliasMap.get(withoutDashes) ?? withoutDashes;
-					if (!definedNames.has(asIsResolved)) {
-						setOption(camelFlagName, 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();
-	const definedNames = /* @__PURE__ */ new Set();
-	const negationMap = /* @__PURE__ */ new Map();
-	const customNegatedFields = /* @__PURE__ */ new Set();
-	for (const field of extracted.fields) definedNames.add(field.name);
-	for (const field of extracted.fields) {
-		if (field.cliName !== field.name) aliasMap.set(field.cliName, field.name);
-		for (const alias of require_schema_extractor.getAllAliases(field)) {
-			aliasMap.set(alias, field.name);
-			if (alias.length > 1 && alias.includes("-")) {
-				const camelAlias = require_schema_extractor.toCamelCase(alias);
-				if (camelAlias !== alias && !definedNames.has(camelAlias) && !aliasMap.has(camelAlias)) aliasMap.set(camelAlias, field.name);
-			}
-		}
-		const camelVariant = require_schema_extractor.toCamelCase(field.name);
-		if (camelVariant !== field.name && !definedNames.has(camelVariant) && !aliasMap.has(camelVariant)) aliasMap.set(camelVariant, field.name);
-		if (field.type === "boolean") booleanFlags.add(field.name);
-		if (field.type === "array") arrayFlags.add(field.name);
-		if (field.type === "boolean" && (typeof field.negation === "string" || field.negation === false)) {
-			customNegatedFields.add(field.name);
-			if (typeof field.negation === "string") {
-				negationMap.set(field.negation, field.name);
-				if (field.negation.includes("-")) {
-					const camelNegation = require_schema_extractor.toCamelCase(field.negation);
-					if (camelNegation !== field.negation) negationMap.set(camelNegation, field.name);
-				}
-			}
-		}
-	}
-	return {
-		aliasMap,
-		booleanFlags,
-		arrayFlags,
-		definedNames,
-		negationMap,
-		customNegatedFields
-	};
-}
-/**
-* 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);
-	const allPositionals = parsed.rest.length > 0 ? [...parsed.positionals, ...parsed.rest] : parsed.positionals;
-	let positionalIndex = 0;
-	for (const field of positionalFields) {
-		if (positionalIndex >= allPositionals.length) break;
-		if (field.type === "array") {
-			result[field.name] = allPositionals.slice(positionalIndex);
-			break;
-		} else {
-			result[field.name] = allPositionals[positionalIndex];
-			positionalIndex++;
-		}
-	}
-	return result;
-}
-
-//#endregion
-//#region src/parser/subcommand-scanner.ts
-/**
-* Build lookup tables from extracted global schema fields.
-* Shared by scanForSubcommand, separateGlobalArgs, and findFirstPositional.
-*/
-function buildGlobalFlagLookup(globalExtracted) {
-	const { aliasMap = /* @__PURE__ */ new Map(), booleanFlags = /* @__PURE__ */ new Set(), negationMap = /* @__PURE__ */ new Map(), customNegatedFields = /* @__PURE__ */ new Set() } = buildParserOptions(globalExtracted);
-	const shortAliases = /* @__PURE__ */ new Set();
-	for (const field of globalExtracted.fields) for (const alias of require_schema_extractor.getAllAliases(field)) if (alias.length === 1) shortAliases.add(alias);
-	return {
-		aliasMap,
-		booleanFlags,
-		flagNames: new Set(globalExtracted.fields.map((f) => f.name)),
-		cliNames: new Set(globalExtracted.fields.map((f) => f.cliName)),
-		aliases: shortAliases,
-		negationMap,
-		customNegatedFields
-	};
-}
-/**
-* Resolve a long option (--flag, --flag=value, --no-flag, --custom-negation)
-* against global flag lookup. Returns the resolved camelCase name and whether
-* it is a known global flag.
-*
-* `isSuppressedNegation` is true when the token matches a default `--no-X`
-* form that has been suppressed by a custom `negation` on the target field.
-* The caller may use this to keep argv scanning past such tokens (so a
-* trailing subcommand is still detected) even though they no longer negate.
-*/
-function resolveGlobalLongOption(arg, lookup) {
-	const withoutDashes = arg.includes("=") ? arg.slice(2, arg.indexOf("=")) : arg.slice(2);
-	const customNegated = !arg.includes("=") ? lookup.negationMap.get(withoutDashes) : void 0;
-	if (customNegated) return {
-		resolvedName: customNegated,
-		withoutDashes,
-		isNegated: true,
-		isGlobal: lookup.flagNames.has(customNegated),
-		isSuppressedNegation: false
-	};
-	const kebabNegated = withoutDashes.startsWith("no-");
-	const camelNegated = !kebabNegated && withoutDashes.length > 2 && withoutDashes.startsWith("no") && /[A-Z]/.test(withoutDashes[2]);
-	if (kebabNegated || camelNegated) {
-		const literalResolved = lookup.aliasMap.get(withoutDashes) ?? withoutDashes;
-		if (lookup.flagNames.has(literalResolved) || lookup.cliNames.has(withoutDashes)) return {
-			resolvedName: literalResolved,
-			withoutDashes,
-			isNegated: false,
-			isGlobal: true,
-			isSuppressedNegation: false
-		};
-	}
-	const defaultIsNegated = kebabNegated || camelNegated;
-	const flagName = kebabNegated ? withoutDashes.slice(3) : camelNegated ? withoutDashes[2].toLowerCase() + withoutDashes.slice(3) : withoutDashes;
-	const resolvedName = lookup.aliasMap.get(flagName) ?? flagName;
-	const suppressDefaultNegation = defaultIsNegated && lookup.customNegatedFields.has(resolvedName);
-	return {
-		resolvedName,
-		withoutDashes,
-		isNegated: defaultIsNegated && !suppressDefaultNegation,
-		isGlobal: !suppressDefaultNegation && (lookup.flagNames.has(resolvedName) || lookup.cliNames.has(withoutDashes) || lookup.cliNames.has(flagName)),
-		isSuppressedNegation: suppressDefaultNegation
-	};
-}
-/**
-* Check whether a non-boolean flag should consume the next argv token as its value.
-* Returns true when the next token exists, is not a flag, and the current flag
-* is not boolean / negated / using = syntax.
-*/
-function shouldConsumeValue(arg, resolvedName, isNegated, nextArg, booleanFlags) {
-	return !arg.includes("=") && !booleanFlags.has(resolvedName) && !isNegated && nextArg !== void 0 && !nextArg.startsWith("-");
-}
-/**
-* Collect a recognized global flag (and its value if applicable) into `dest`,
-* returning how many argv positions were consumed (1 or 2).
-*/
-function collectGlobalFlag(argv, i, resolvedName, isNegated, booleanFlags, dest) {
-	const arg = argv[i];
-	dest.push(arg);
-	if (shouldConsumeValue(arg, resolvedName, isNegated, argv[i + 1], booleanFlags)) {
-		dest.push(argv[i + 1]);
-		return 2;
-	}
-	return 1;
-}
-/**
-* Scan argv to find the subcommand position, skipping over global flags.
-*
-* Walks argv and recognizes global flags (long, short, --no-*) so that
-* `my-cli --verbose build --output dist` correctly identifies `build` as
-* the subcommand (index 1) rather than treating `--verbose` as the subcommand.
-*
-* Limitation: flags appearing before the subcommand name are matched only
-* against the global schema. If a flag is defined in both global and a
-* subcommand's local schema, the pre-subcommand occurrence is always treated
-* as global because the local schema is not available until the subcommand is
-* identified (lazy-loaded commands make eager checking infeasible). Place
-* colliding flags after the subcommand name so that `separateGlobalArgs` can
-* apply local-precedence logic.
-*
-* @param argv - Command line arguments
-* @param subCommandNames - Valid subcommand names
-* @param globalExtracted - Extracted fields from global args schema
-* @returns Scan result with subcommand position and token separation
-*/
-function scanForSubcommand(argv, subCommandNames, globalExtracted) {
-	const lookup = buildGlobalFlagLookup(globalExtracted);
-	const subCommandNameSet = new Set(subCommandNames);
-	const globalTokensBefore = [];
-	const suppressedTokens = [];
-	let i = 0;
-	while (i < argv.length) {
-		const arg = argv[i];
-		if (arg === "--" || BUILTIN_FLAGS.has(arg)) break;
-		if (!arg.startsWith("-") && subCommandNameSet.has(arg)) return {
-			subCommandIndex: i,
-			globalTokensBefore,
-			tokensAfterSubcommand: argv.slice(i + 1),
-			suppressedTokens
-		};
-		if (arg.startsWith("--")) {
-			const { resolvedName, isNegated, isGlobal, isSuppressedNegation } = resolveGlobalLongOption(arg, lookup);
-			if (isGlobal) {
-				i += collectGlobalFlag(argv, i, resolvedName, isNegated, lookup.booleanFlags, globalTokensBefore);
-				continue;
-			}
-			if (isSuppressedNegation) {
-				suppressedTokens.push(arg.includes("=") ? arg.slice(2, arg.indexOf("=")) : arg.slice(2));
-				i++;
-				continue;
-			}
-			break;
-		}
-		if (arg.startsWith("-") && arg.length > 1) {
-			const withoutDash = arg.includes("=") ? arg.slice(1, arg.indexOf("=")) : arg.slice(1);
-			if (withoutDash.length === 1) {
-				const resolvedName = lookup.aliasMap.get(withoutDash) ?? withoutDash;
-				if (lookup.aliases.has(withoutDash) || lookup.flagNames.has(resolvedName)) {
-					i += collectGlobalFlag(argv, i, resolvedName, false, lookup.booleanFlags, globalTokensBefore);
-					continue;
-				}
-			}
-			break;
-		}
-		break;
-	}
-	return {
-		subCommandIndex: -1,
-		globalTokensBefore,
-		tokensAfterSubcommand: [],
-		suppressedTokens
-	};
-}
-const BUILTIN_FLAGS = new Set([
-	"--help",
-	"-h",
-	"--help-all",
-	"-H",
-	"--version"
-]);
-/**
-* Find the index of the first positional argument in argv, properly skipping
-* global flag values. Returns -1 when no positional is present.
-*
-* Mirrors `scanForSubcommand`'s conservative stop conditions: the scan stops
-* (returning -1) on a `--` terminator, a builtin flag (`--help`/`--version`),
-* an unknown long flag, or an unknown/combined short flag. Past such tokens we
-* can't tell a flag *value* from a positional, so continuing would misclassify
-* e.g. `--help plugin` or `--unknown value` and wrongly trip plugin dispatch.
-*
-* Without globalExtracted, no flag is global, so any leading flag halts the
-* scan and a positional is only found when it precedes every flag.
-*/
-function findFirstPositionalIndex(argv, globalExtracted) {
-	const lookup = globalExtracted ? buildGlobalFlagLookup(globalExtracted) : {
-		aliasMap: /* @__PURE__ */ new Map(),
-		booleanFlags: /* @__PURE__ */ new Set(),
-		flagNames: /* @__PURE__ */ new Set(),
-		cliNames: /* @__PURE__ */ new Set(),
-		aliases: /* @__PURE__ */ new Set(),
-		negationMap: /* @__PURE__ */ new Map(),
-		customNegatedFields: /* @__PURE__ */ new Set()
-	};
-	for (let i = 0; i < argv.length; i++) {
-		const arg = argv[i];
-		if (!arg.startsWith("-")) return i;
-		if (arg === "--" || BUILTIN_FLAGS.has(arg)) return -1;
-		if (arg.startsWith("--")) {
-			const { resolvedName, isNegated, isGlobal, isSuppressedNegation } = resolveGlobalLongOption(arg, lookup);
-			if (isGlobal) {
-				if (shouldConsumeValue(arg, resolvedName, isNegated, argv[i + 1], lookup.booleanFlags)) i++;
-				continue;
-			}
-			if (isSuppressedNegation) continue;
-			return -1;
-		}
-		const withoutDash = arg.includes("=") ? arg.slice(1, arg.indexOf("=")) : arg.slice(1);
-		if (withoutDash.length === 1) {
-			const resolvedName = lookup.aliasMap.get(withoutDash) ?? withoutDash;
-			if (lookup.aliases.has(withoutDash) || lookup.flagNames.has(resolvedName)) {
-				if (shouldConsumeValue(arg, resolvedName, false, argv[i + 1], lookup.booleanFlags)) i++;
-				continue;
-			}
-		}
-		return -1;
-	}
-	return -1;
-}
-/**
-* Find the first positional argument in argv, properly skipping global flag
-* values. Thin wrapper over {@link findFirstPositionalIndex} — see that
-* function for the scan and stop conditions. Returns `undefined` when none.
-*/
-function findFirstPositional(argv, globalExtracted) {
-	const index = findFirstPositionalIndex(argv, globalExtracted);
-	return index >= 0 ? argv[index] : void 0;
-}
-
-//#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 subCommandNameSet = require_schema_extractor.listSubCommandNamesWithAliases(command);
-	const subCommandNames = [...subCommandNameSet];
-	const hasSubCommands = subCommandNames.length > 0;
-	if (hasSubCommands && argv.length > 0) if (options.globalExtracted) {
-		const scanResult = scanForSubcommand(argv, subCommandNames, options.globalExtracted);
-		if (scanResult.subCommandIndex >= 0) {
-			const rawGlobalArgs = parseGlobalArgs(scanResult.globalTokensBefore, options.globalExtracted);
-			return {
-				helpRequested: false,
-				helpAllRequested: false,
-				versionRequested: false,
-				subCommand: argv[scanResult.subCommandIndex],
-				remainingArgs: scanResult.tokensAfterSubcommand,
-				rawArgs: {},
-				positionals: [],
-				unknownFlags: scanResult.suppressedTokens,
-				rawGlobalArgs
-			};
-		}
-	} else {
-		const firstArg = argv[0];
-		if (firstArg && !firstArg.startsWith("-") && subCommandNameSet.has(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);
-			validateCaseVariantCollisions(extracted);
-			validateDuplicateAliases(extracted);
-			validateDuplicateNegations(extracted);
-			validatePositionalConfig(extracted);
-			validateReservedAliases(extracted, hasSubCommands);
-			if (options.globalExtracted) validateCrossSchemaCollisions(options.globalExtracted, extracted);
-		}
-	}
-	const ddIdx = argv.indexOf("--");
-	const flagScanArgv = ddIdx >= 0 ? argv.slice(0, ddIdx) : argv;
-	const hasUserDefinedH = extracted?.fields.some((f) => f.overrideBuiltinAlias === true && require_schema_extractor.getAllAliases(f).includes("H")) ?? false;
-	const hasUserDefinedh = extracted?.fields.some((f) => f.overrideBuiltinAlias === true && require_schema_extractor.getAllAliases(f).includes("h")) ?? false;
-	const helpAllRequested = flagScanArgv.includes("--help-all") || !hasUserDefinedH && flagScanArgv.includes("-H");
-	const helpRequested = !helpAllRequested && (flagScanArgv.includes("--help") || !hasUserDefinedh && flagScanArgv.includes("-h"));
-	const versionRequested = flagScanArgv.includes("--version");
-	if (helpRequested || helpAllRequested || versionRequested) return {
-		helpRequested,
-		helpAllRequested,
-		versionRequested,
-		subCommand: void 0,
-		remainingArgs: [],
-		rawArgs: {},
-		positionals: [],
-		unknownFlags: []
-	};
-	let commandArgv = argv;
-	let rawGlobalArgs;
-	if (options.globalExtracted) {
-		const { separated, globalParsed } = separateGlobalArgs(argv, options.globalExtracted, extracted);
-		commandArgv = separated;
-		rawGlobalArgs = globalParsed;
-	}
-	if (!extracted) return {
-		helpRequested: false,
-		helpAllRequested: false,
-		versionRequested: false,
-		subCommand: void 0,
-		remainingArgs: [],
-		rawArgs: {},
-		positionals: [],
-		unknownFlags: [],
-		rawGlobalArgs
-	};
-	const parserOptions = buildParserOptions(extracted);
-	const parsed = parseArgv(commandArgv, parserOptions);
-	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 = /* @__PURE__ */ new Set();
-	for (const f of extracted.fields) for (const alias of require_schema_extractor.getAllAliases(f)) knownAliases.add(alias);
-	if (options.globalExtracted) for (const f of options.globalExtracted.fields) {
-		knownFlags.add(f.name);
-		knownCliNames.add(f.cliName);
-		for (const alias of require_schema_extractor.getAllAliases(f)) knownAliases.add(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,
-		rawGlobalArgs
-	};
-}
-/**
-* Parse global args from a list of tokens (e.g., tokens before the subcommand).
-* Env fallbacks are applied later in the runner on the accumulated global args.
-*/
-function parseGlobalArgs(tokens, globalExtracted) {
-	if (tokens.length === 0) return {};
-	return mergeWithPositionals(parseArgv(tokens, buildParserOptions(globalExtracted)), globalExtracted);
-}
-/**
-* Separate global flags from command-local args in argv.
-* Global flags mixed with command args (e.g., `build --verbose --output dist`)
-* are extracted and returned separately.
-* When a flag is defined in both global and local schemas, the local definition
-* takes precedence (the flag stays in the command tokens).
-*
-* Note: Combined short flags (e.g., `-vq`) are not decomposed here; only
-* single-character short options are recognized as global. The underlying
-* `parseArgv` handles combined shorts for command-local parsing.
-*/
-function separateGlobalArgs(argv, globalExtracted, localExtracted) {
-	const lookup = buildGlobalFlagLookup(globalExtracted);
-	const localFieldNames = new Set(localExtracted?.fields.map((f) => f.name) ?? []);
-	const localCliNames = new Set(localExtracted?.fields.map((f) => f.cliName) ?? []);
-	const localAliasMapKeys = localExtracted ? new Set(buildParserOptions(localExtracted).aliasMap?.keys() ?? []) : /* @__PURE__ */ new Set();
-	const globalTokens = [];
-	const commandTokens = [];
-	for (let i = 0; i < argv.length; i++) {
-		const arg = argv[i];
-		if (arg === "--") {
-			commandTokens.push(...argv.slice(i));
-			break;
-		}
-		if (arg.startsWith("--")) {
-			const { resolvedName, withoutDashes, isNegated, isGlobal } = resolveGlobalLongOption(arg, lookup);
-			const flagName = resolvedName;
-			const isLocalCollision = localFieldNames.has(withoutDashes) || localFieldNames.has(flagName) || localCliNames.has(withoutDashes) || localCliNames.has(flagName) || localAliasMapKeys.has(withoutDashes) || localAliasMapKeys.has(flagName);
-			if (isGlobal && !isLocalCollision) {
-				i += collectGlobalFlag(argv, i, resolvedName, isNegated, lookup.booleanFlags, globalTokens) - 1;
-				continue;
-			}
-		} else if (arg.startsWith("-") && arg.length > 1) {
-			const withoutDash = arg.includes("=") ? arg.slice(1, arg.indexOf("=")) : arg.slice(1);
-			if (withoutDash.length === 1) {
-				const resolvedName = lookup.aliasMap.get(withoutDash) ?? withoutDash;
-				if ((lookup.aliases.has(withoutDash) || lookup.flagNames.has(resolvedName)) && !localAliasMapKeys.has(withoutDash)) {
-					i += collectGlobalFlag(argv, i, resolvedName, false, lookup.booleanFlags, globalTokens) - 1;
-					continue;
-				}
-			}
-		}
-		commandTokens.push(arg);
-	}
-	return {
-		separated: commandTokens,
-		globalParsed: parseGlobalArgs(globalTokens, globalExtracted)
-	};
-}
-
-//#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 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}`;
-}
-
-//#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/effect-runner.ts
-/**
-* Execute all registered effect callbacks for validated args.
-*
-* Effects run sequentially in field-definition order.
-* Only fires for fields that have an `effect` callback defined.
-*
-* @param validatedArgs - The validated (post-Zod) argument values
-* @param extracted - The extracted fields from the schema
-* @param globalArgs - The validated global args (passed to command arg effects)
-*/
-async function runEffects(validatedArgs, extracted, globalArgs) {
-	for (const field of extracted.fields) {
-		if (!field.effect) continue;
-		await field.effect(validatedArgs[field.name], {
-			name: field.name,
-			args: validatedArgs,
-			...globalArgs != null && { globalArgs }
-		});
-	}
-}
-
-//#endregion
-//#region src/core/runner.ts
-var runner_exports = /* @__PURE__ */ require_log_collector.__exportAll({
-	runCommand: () => runCommand,
-	runMain: () => runMain
-});
-/**
-* 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 = {}) {
-	const globalExtracted = extractAndValidateGlobal(options);
-	const shouldCaptureLogs = options.captureLogs ?? false;
-	const globalCollector = shouldCaptureLogs ? require_log_collector.createLogCollector() : null;
-	if (options.setup) {
-		globalCollector?.start();
-		try {
-			await options.setup({});
-		} catch (e) {
-			const error = e instanceof Error ? e : new Error(String(e));
-			if (options.cleanup) try {
-				await options.cleanup({ error });
-			} catch {}
-			globalCollector?.stop();
-			return {
-				success: false,
-				error,
-				exitCode: 1,
-				logs: globalCollector?.getLogs() ?? require_log_collector.emptyLogs()
-			};
-		}
-		globalCollector?.stop();
-	}
-	const result = await runCommandInternal(command, argv, {
-		...options,
-		handleSignals: false,
-		_globalExtracted: globalExtracted,
-		_globalCleanup: options.cleanup,
-		_existingLogs: globalCollector?.getLogs()
-	});
-	if (options.cleanup) {
-		const cleanupCollector = shouldCaptureLogs ? require_log_collector.createLogCollector() : null;
-		cleanupCollector?.start();
-		const cleanupCtx = { error: !result.success ? result.error : void 0 };
-		try {
-			await options.cleanup(cleanupCtx);
-		} catch (e) {
-			if (result.success) {
-				const error = e instanceof Error ? e : new Error(String(e));
-				cleanupCollector?.stop();
-				return {
-					success: false,
-					error,
-					exitCode: 1,
-					logs: require_log_collector.mergeLogs(result.logs, cleanupCollector?.getLogs() ?? require_log_collector.emptyLogs())
-				};
-			}
-		}
-		cleanupCollector?.stop();
-		const cleanupLogs = cleanupCollector?.getLogs() ?? require_log_collector.emptyLogs();
-		if (cleanupLogs.entries.length > 0) return {
-			...result,
-			logs: require_log_collector.mergeLogs(result.logs, cleanupLogs)
-		};
-	}
-	return result;
-}
-/**
-* Hidden internal subcommands (e.g. `__refresh-completion`) are spawned
-* by background hooks and must not run user-provided
-* `setup`/`cleanup`/`prompt` or required `globalArgs`. Those exist for
-* the foreground CLI run; replaying them in a detached child causes
-* duplicate side effects, stuck prompts, and validation failures the
-* user never opted into.
-*
-* We treat any registered subcommand whose name starts with `__` as
-* internal. We use `findFirstPositional` (schema-aware) instead of the
-* naive "first non-flag token" so an option *value* like
-* `--name __refresh-completion` doesn't trip the bypass — that would
-* silently skip lifecycle hooks for ordinary invocations.
-*/
-function isInternalSubcommandInvocation(command, argv, globalExtracted) {
-	const firstPositional = findFirstPositional(argv, globalExtracted);
-	if (!firstPositional || !firstPositional.startsWith("__")) return false;
-	return Boolean(command.subCommands?.[firstPositional]);
-}
-/**
-* 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
-* - Invokes `command.runMainHook` once before parsing if set, so plug-ins
-*   like `withCompletionCommand` can fire detached background work
-* - Bypasses user `setup`/`cleanup`/`prompt` and required `globalArgs`
-*   for registered hidden subcommands whose name starts with `__`
-*   (e.g. `__refresh-completion`)
-*
-* @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 = {}) {
-	if (command.runMainHook) try {
-		command.runMainHook(process.argv.slice(2));
-	} catch {}
-	const argv = process.argv.slice(2);
-	let globalExtractedForBypass;
-	if (options.globalArgs) try {
-		globalExtractedForBypass = require_schema_extractor.extractFields(options.globalArgs);
-	} catch {}
-	let effectiveOptions = options;
-	if (isInternalSubcommandInvocation(command, argv, globalExtractedForBypass)) {
-		const { setup: _s, cleanup: _c, prompt: _p, globalArgs: _g, ...rest } = options;
-		effectiveOptions = rest;
-	}
-	const globalExtracted = extractAndValidateGlobal(effectiveOptions);
-	if (effectiveOptions.onUnknownSubcommand && !isInternalSubcommandInvocation(command, argv, globalExtractedForBypass)) {
-		const knownSubCommands = require_schema_extractor.listSubCommandNamesWithAliases(command);
-		if (knownSubCommands.size > 0) {
-			const positionalIndex = findFirstPositionalIndex(argv, globalExtracted);
-			const name = positionalIndex >= 0 ? argv[positionalIndex] : void 0;
-			if (name && !knownSubCommands.has(name)) {
-				const forwardArgs = argv.slice(positionalIndex + 1);
-				const exitCode = await effectiveOptions.onUnknownSubcommand({
-					commandPath: [],
-					name,
-					args: forwardArgs
-				});
-				if (typeof exitCode === "number") {
-					await flushStandardStreams();
-					return process.exit(exitCode);
-				}
-			}
-		}
-	}
-	if (effectiveOptions.setup) try {
-		await effectiveOptions.setup({});
-	} catch (e) {
-		const error = e instanceof Error ? e : new Error(String(e));
-		if (effectiveOptions.cleanup) try {
-			await effectiveOptions.cleanup({ error });
-		} catch {}
-		process.exit(1);
-	}
-	const result = await runCommandInternal(command, argv, {
-		debug: effectiveOptions.debug,
-		captureLogs: effectiveOptions.captureLogs,
-		skipValidation: effectiveOptions.skipValidation,
-		handleSignals: true,
-		logger: effectiveOptions.logger,
-		globalArgs: effectiveOptions.globalArgs,
-		prompt: effectiveOptions.prompt,
-		onUnknownSubcommand: effectiveOptions.onUnknownSubcommand,
-		_globalExtracted: globalExtracted,
-		_globalCleanup: effectiveOptions.cleanup,
-		_context: {
-			commandPath: [],
-			rootName: command.name,
-			rootVersion: effectiveOptions.version,
-			globalExtracted
-		}
-	});
-	if ((effectiveOptions.displayErrors ?? true) && !result.success && result.error) (effectiveOptions.logger ?? defaultLogger).error(formatRuntimeError(result.error, effectiveOptions.debug ?? false));
-	if (effectiveOptions.cleanup) {
-		const cleanupCtx = { error: !result.success ? result.error : void 0 };
-		try {
-			await effectiveOptions.cleanup(cleanupCtx);
-		} catch {}
-	}
-	await flushStandardStreams();
-	process.exit(result.exitCode);
-}
-/**
-* Flush stdout/stderr before exit to prevent truncated output when piped
-* (pipe writes are buffered asynchronously, so exiting early loses data).
-*
-* We await a zero-byte write's callback rather than a `drain` event: `drain`
-* only fires after a `write()` returned `false` (backpressure), so buffered
-* writes that never tripped it would hang. The write callback is ordered after
-* all pending writes, so it resolves once the buffer is flushed.
-*/
-async function flushStandardStreams() {
-	await Promise.all([process.stdout, process.stderr].map((stream) => stream.writableLength > 0 ? new Promise((resolve) => stream.write("", () => resolve())) : Promise.resolve()));
-}
-/**
-* Internal implementation of command running
-*/
-async function runCommandInternal(command, argv, options = {}) {
-	const logger = options.logger ?? defaultLogger;
-	const context = options._context ?? {
-		commandPath: [],
-		rootName: command.name,
-		globalExtracted: options._globalExtracted
-	};
-	const collector = options.captureLogs ?? false ? require_log_collector.createLogCollector() : null;
-	collector?.start();
-	const getCurrentLogs = () => {
-		return require_log_collector.mergeLogs(options._existingLogs ?? require_log_collector.emptyLogs(), collector?.getLogs() ?? require_log_collector.emptyLogs());
-	};
-	try {
-		const parseResult = parseArgs(argv, command, {
-			skipValidation: options.skipValidation,
-			globalExtracted: options._globalExtracted
-		});
-		const accumulatedGlobalArgs = {
-			...options._parsedGlobalArgs,
-			...parseResult.rawGlobalArgs
-		};
-		const nestedCommandPath = context.commandPath ?? [];
-		if (options.onUnknownSubcommand && nestedCommandPath.length > 0) {
-			const knownSubCommands = require_schema_extractor.listSubCommandNamesWithAliases(command);
-			if (knownSubCommands.size > 0) {
-				const positionalIndex = findFirstPositionalIndex(argv, options._globalExtracted);
-				const name = positionalIndex >= 0 ? argv[positionalIndex] : void 0;
-				if (name && !knownSubCommands.has(name)) {
-					const forwardArgs = argv.slice(positionalIndex + 1);
-					const exitCode = await options.onUnknownSubcommand({
-						commandPath: nestedCommandPath,
-						name,
-						args: forwardArgs
-					});
-					if (typeof exitCode === "number") {
-						collector?.stop();
-						if (options.handleSignals) {
-							if (options._globalCleanup) try {
-								await options._globalCleanup({ error: void 0 });
-							} catch {}
-							await flushStandardStreams();
-							process.exit(exitCode);
-						}
-						return exitCode === 0 ? {
-							success: true,
-							result: void 0,
-							exitCode: 0,
-							logs: getCurrentLogs()
-						} : {
-							success: false,
-							error: /* @__PURE__ */ new Error(`Plugin "${[...nestedCommandPath, name].join(" ")}" exited with code ${exitCode}`),
-							exitCode,
-							logs: getCurrentLogs()
-						};
-					}
-				}
-			}
-		}
-		if (parseResult.helpRequested || parseResult.helpAllRequested) {
-			let hasUnknownSubcommand = false;
-			const subCmdNames = require_schema_extractor.listSubCommands(command);
-			const allSubCmdNameSet = require_schema_extractor.listSubCommandNamesWithAliases(command);
-			if (subCmdNames.length > 0) {
-				const potentialSubCmd = findFirstPositional(argv, context.globalExtracted);
-				if (potentialSubCmd && !allSubCmdNameSet.has(potentialSubCmd)) hasUnknownSubcommand = true;
-			}
-			const help = generateHelp(command, {
-				showSubcommands: options.showSubcommands ?? true,
-				showSubcommandOptions: parseResult.helpAllRequested || options.showSubcommandOptions,
-				context
-			});
-			logger.log(help);
-			collector?.stop();
-			if (hasUnknownSubcommand) {
-				const unknownCmd = findFirstPositional(argv, context.globalExtracted) ?? "";
-				const similar = findSimilar(unknownCmd, [...allSubCmdNameSet]);
-				const suggestion = similar.length > 0 ? ` Did you mean: ${similar.join(", ")}?` : "";
-				return {
-					success: false,
-					error: /* @__PURE__ */ new Error(`Unknown subcommand: ${unknownCmd}${suggestion ? `.${suggestion}` : ""}`),
-					exitCode: 1,
-					logs: getCurrentLogs()
-				};
-			}
-			return {
-				success: true,
-				result: void 0,
-				exitCode: 0,
-				logs: getCurrentLogs()
-			};
-		}
-		if (parseResult.versionRequested) {
-			const version = context.rootVersion;
-			if (version) logger.log(version);
-			collector?.stop();
-			return {
-				success: true,
-				result: void 0,
-				exitCode: 0,
-				logs: getCurrentLogs()
-			};
-		}
-		if (parseResult.subCommand) {
-			if (parseResult.unknownFlags.length > 0) {
-				const globalMode = context.globalExtracted?.unknownKeysMode ?? "strip";
-				if (globalMode === "strict") {
-					collector?.stop();
-					return {
-						success: false,
-						error: /* @__PURE__ */ new Error(`Unknown flags: ${parseResult.unknownFlags.join(", ")}`),
-						exitCode: 1,
-						logs: getCurrentLogs()
-					};
-				}
-				if (globalMode === "strip") {
-					const knownGlobalFlags = context.globalExtracted?.fields.map((f) => f.name) ?? [];
-					for (const flag of parseResult.unknownFlags) logger.error(formatUnknownFlagWarning(flag, knownGlobalFlags));
-				}
-			}
-			const resolved = await require_schema_extractor.resolveSubcommandWithAlias(command, parseResult.subCommand);
-			if (resolved) {
-				const subContext = {
-					commandPath: [...context.commandPath ?? [], parseResult.subCommand],
-					rootName: context.rootName,
-					rootVersion: context.rootVersion,
-					globalExtracted: context.globalExtracted,
-					aliasFor: resolved.aliasFor
-				};
-				collector?.stop();
-				return runCommandInternal(resolved.command, parseResult.remainingArgs, {
-					...options,
-					_context: subContext,
-					_existingLogs: getCurrentLogs(),
-					_parsedGlobalArgs: accumulatedGlobalArgs
-				});
-			}
-		}
-		if (require_schema_extractor.listSubCommands(command).length > 0 && !parseResult.subCommand && !command.run) {
-			const help = generateHelp(command, {
-				showSubcommands: options.showSubcommands ?? true,
-				context
-			});
-			logger.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") {
-				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.error(formatUnknownFlagWarning(flag, knownFlags));
-		}
-		let validatedGlobalArgs = {};
-		const isCompletionInvocation = command.name === "__complete";
-		if (options.globalArgs && options._globalExtracted && !isCompletionInvocation) {
-			for (const field of options._globalExtracted.fields) if (field.env && accumulatedGlobalArgs[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) {
-						accumulatedGlobalArgs[field.name] = envValue;
-						break;
-					}
-				}
-			}
-			if (options.prompt) {
-				const resolved = await options.prompt(accumulatedGlobalArgs, options._globalExtracted);
-				Object.assign(accumulatedGlobalArgs, resolved);
-			}
-			const globalValidation = validateArgs(accumulatedGlobalArgs, options.globalArgs);
-			if (!globalValidation.success) {
-				collector?.stop();
-				return {
-					success: false,
-					error: new Error(formatValidationErrors(globalValidation.errors)),
-					exitCode: 1,
-					logs: getCurrentLogs()
-				};
-			}
-			validatedGlobalArgs = globalValidation.data;
-		}
-		if (!command.args) {
-			const proxiedGlobalArgs = createDualCaseProxy(validatedGlobalArgs);
-			if (options._globalExtracted && !isCompletionInvocation) await runEffects(proxiedGlobalArgs, options._globalExtracted, proxiedGlobalArgs);
-			collector?.stop();
-			return await executeLifecycle(command, proxiedGlobalArgs, {
-				handleSignals: options.handleSignals,
-				captureLogs: options.captureLogs,
-				existingLogs: getCurrentLogs(),
-				globalCleanup: options._globalCleanup
-			});
-		}
-		let argsToValidate = parseResult.rawArgs;
-		if (options.prompt && parseResult.extractedFields) {
-			const resolved = await options.prompt(argsToValidate, parseResult.extractedFields);
-			argsToValidate = {
-				...argsToValidate,
-				...resolved
-			};
-		}
-		const validationResult = validateArgs(argsToValidate, command.args);
-		if (!validationResult.success) {
-			collector?.stop();
-			return {
-				success: false,
-				error: new Error(formatValidationErrors(validationResult.errors)),
-				exitCode: 1,
-				logs: getCurrentLogs()
-			};
-		}
-		const proxiedCommandArgs = createDualCaseProxy(validationResult.data);
-		const proxiedGlobalArgs = createDualCaseProxy(validatedGlobalArgs);
-		if (options._globalExtracted && !isCompletionInvocation) await runEffects(proxiedGlobalArgs, options._globalExtracted, proxiedGlobalArgs);
-		if (parseResult.extractedFields && !isCompletionInvocation) await runEffects(proxiedCommandArgs, parseResult.extractedFields, proxiedGlobalArgs);
-		const mergedArgs = createDualCaseProxy({
-			...proxiedGlobalArgs,
-			...proxiedCommandArgs
-		});
-		collector?.stop();
-		return await executeLifecycle(command, mergedArgs, {
-			handleSignals: options.handleSignals,
-			captureLogs: options.captureLogs,
-			existingLogs: getCurrentLogs(),
-			globalCleanup: options._globalCleanup
-		});
-	} catch (error) {
-		const err = error instanceof Error ? error : new Error(String(error));
-		collector?.stop();
-		return {
-			success: false,
-			error: err,
-			exitCode: 1,
-			logs: getCurrentLogs()
-		};
-	}
-}
-/**
-* Extract global fields from options.globalArgs and validate the schema upfront.
-* Rejects positional fields since global options must be flags.
-* Returns undefined when no globalArgs is provided.
-*/
-function extractAndValidateGlobal(options) {
-	if (!options.globalArgs) return void 0;
-	const extracted = require_schema_extractor.extractFields(options.globalArgs);
-	if (!options.skipValidation) {
-		validateDuplicateFields(extracted);
-		validateCaseVariantCollisions(extracted);
-		validateDuplicateAliases(extracted);
-		validateDuplicateNegations(extracted);
-		validateReservedAliases(extracted, true);
-		const positionalNames = extracted.fields.filter((f) => f.positional).map((f) => f.name);
-		if (positionalNames.length > 0) throw new Error(`Global options schema must not contain positional arguments. Found: ${positionalNames.join(", ")}`);
-	}
-	return extracted;
-}
-
-//#endregion
-Object.defineProperty(exports, 'CaseVariantCollisionError', {
-  enumerable: true,
-  get: function () {
-    return CaseVariantCollisionError;
-  }
-});
-Object.defineProperty(exports, 'DuplicateAliasError', {
-  enumerable: true,
-  get: function () {
-    return DuplicateAliasError;
-  }
-});
-Object.defineProperty(exports, 'DuplicateFieldError', {
-  enumerable: true,
-  get: function () {
-    return DuplicateFieldError;
-  }
-});
-Object.defineProperty(exports, 'DuplicateNegationError', {
-  enumerable: true,
-  get: function () {
-    return DuplicateNegationError;
-  }
-});
-Object.defineProperty(exports, 'PositionalConfigError', {
-  enumerable: true,
-  get: function () {
-    return PositionalConfigError;
-  }
-});
-Object.defineProperty(exports, 'ReservedAliasError', {
-  enumerable: true,
-  get: function () {
-    return ReservedAliasError;
-  }
-});
-Object.defineProperty(exports, 'createDualCaseProxy', {
-  enumerable: true,
-  get: function () {
-    return createDualCaseProxy;
-  }
-});
-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, 'renderInline', {
-  enumerable: true,
-  get: function () {
-    return renderInline;
-  }
-});
-Object.defineProperty(exports, 'renderMarkdown', {
-  enumerable: true,
-  get: function () {
-    return renderMarkdown;
-  }
-});
-Object.defineProperty(exports, 'runCommand', {
-  enumerable: true,
-  get: function () {
-    return runCommand;
-  }
-});
-Object.defineProperty(exports, 'runMain', {
-  enumerable: true,
-  get: function () {
-    return runMain;
-  }
-});
-Object.defineProperty(exports, 'runner_exports', {
-  enumerable: true,
-  get: function () {
-    return runner_exports;
-  }
-});
-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, 'validateCaseVariantCollisions', {
-  enumerable: true,
-  get: function () {
-    return validateCaseVariantCollisions;
-  }
-});
-Object.defineProperty(exports, 'validateCommand', {
-  enumerable: true,
-  get: function () {
-    return validateCommand;
-  }
-});
-Object.defineProperty(exports, 'validateCrossSchemaCollisions', {
-  enumerable: true,
-  get: function () {
-    return validateCrossSchemaCollisions;
-  }
-});
-Object.defineProperty(exports, 'validateDuplicateAliases', {
-  enumerable: true,
-  get: function () {
-    return validateDuplicateAliases;
-  }
-});
-Object.defineProperty(exports, 'validateDuplicateFields', {
-  enumerable: true,
-  get: function () {
-    return validateDuplicateFields;
-  }
-});
-Object.defineProperty(exports, 'validateDuplicateNegations', {
-  enumerable: true,
-  get: function () {
-    return validateDuplicateNegations;
-  }
-});
-Object.defineProperty(exports, 'validatePositionalConfig', {
-  enumerable: true,
-  get: function () {
-    return validatePositionalConfig;
-  }
-});
-Object.defineProperty(exports, 'validateReservedAliases', {
-  enumerable: true,
-  get: function () {
-    return validateReservedAliases;
-  }
-});
-//# sourceMappingURL=runner-DvFvokV6.cjs.map