politty 0.4.14 → 0.4.15

package/dist/{runner-CY5fOsSh.cjs → runner-CriXJlm4.cjs}

@@ -1,8 +1,8 @@
-const require_subcommand_router = require('./subcommand-router-C9ONv6Nq.cjs');
-const require_lazy = require('./lazy-AGV9Pkt5.cjs');
+const require_log_collector = require('./log-collector-Cd2_mv87.cjs');
+const require_subcommand_router = require('./subcommand-router-CqZX3orq.cjs');
 let node_util = require("node:util");
 let string_width = require("string-width");
-string_width = require_subcommand_router.__toESM(string_width);
+string_width = require_log_collector.__toESM(string_width, 1);
 
 //#region src/core/case-proxy.ts
 /**
@@ -19,9 +19,9 @@ function createDualCaseProxy(obj) {
 		get(target, prop, receiver) {
 			if (typeof prop === "string") {
 				if (prop in target) return Reflect.get(target, prop, receiver);
-				const camel = require_lazy.toCamelCase(prop);
+				const camel = require_subcommand_router.toCamelCase(prop);
 				if (camel !== prop && camel in target) return Reflect.get(target, camel, receiver);
-				const kebab = require_lazy.toKebabCase(prop);
+				const kebab = require_subcommand_router.toKebabCase(prop);
 				if (kebab !== prop && kebab in target) return Reflect.get(target, kebab, receiver);
 			}
 			return Reflect.get(target, prop, receiver);
@@ -29,9 +29,9 @@ function createDualCaseProxy(obj) {
 		has(target, prop) {
 			if (typeof prop === "string") {
 				if (prop in target) return true;
-				const camel = require_lazy.toCamelCase(prop);
+				const camel = require_subcommand_router.toCamelCase(prop);
 				if (camel !== prop && camel in target) return true;
-				const kebab = require_lazy.toKebabCase(prop);
+				const kebab = require_subcommand_router.toKebabCase(prop);
 				if (kebab !== prop && kebab in target) return true;
 			}
 			return Reflect.has(target, prop);
@@ -56,7 +56,7 @@ function createDualCaseProxy(obj) {
 async function executeLifecycle(command, args, _options = {}) {
 	let error;
 	let result;
-	const collector = _options.captureLogs ?? false ? require_subcommand_router.createLogCollector() : null;
+	const collector = _options.captureLogs ?? false ? require_log_collector.createLogCollector() : null;
 	collector?.start();
 	const setupContext = { args };
 	const cleanupContext = {
@@ -119,7 +119,7 @@ async function executeLifecycle(command, args, _options = {}) {
 		}
 	}
 	collector?.stop();
-	const logs = require_subcommand_router.mergeLogs(_options.existingLogs ?? require_subcommand_router.emptyLogs(), collector?.getLogs() ?? require_subcommand_router.emptyLogs());
+	const logs = require_log_collector.mergeLogs(_options.existingLogs ?? require_log_collector.emptyLogs(), collector?.getLogs() ?? require_log_collector.emptyLogs());
 	if (error) return {
 		success: false,
 		error,
@@ -593,7 +593,7 @@ function renderUsageLine(command, context) {
 	const name = buildUsageCommandName(command, context);
 	parts.push(styles.commandName(name));
 	if (context?.globalExtracted?.fields.length) parts.push(styles.placeholder("[global options]"));
-	const extracted = require_lazy.getExtractedFields(command);
+	const extracted = require_subcommand_router.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]"));
@@ -613,9 +613,9 @@ function renderOptions(command, descriptions = {}, context) {
 		helpAll: descriptions.helpAll ?? defaultBuiltinDescriptions.helpAll,
 		version: descriptions.version ?? defaultBuiltinDescriptions.version
 	};
-	const extracted = require_lazy.getExtractedFields(command);
-	const hasUserDefinedh = extracted?.fields.some((f) => f.overrideBuiltinAlias === true && require_lazy.getAllAliases(f).includes("h")) ?? false;
-	const hasUserDefinedH = extracted?.fields.some((f) => f.overrideBuiltinAlias === true && require_lazy.getAllAliases(f).includes("H")) ?? false;
+	const extracted = require_subcommand_router.getExtractedFields(command);
+	const hasUserDefinedh = extracted?.fields.some((f) => f.overrideBuiltinAlias === true && require_subcommand_router.getAllAliases(f).includes("h")) ?? false;
+	const hasUserDefinedH = extracted?.fields.some((f) => f.overrideBuiltinAlias === true && require_subcommand_router.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));
@@ -816,7 +816,7 @@ function renderGlobalOptions(globalExtracted) {
 */
 function renderSubcommandOptionsCompact(command, indent) {
 	const lines = [];
-	const extracted = require_lazy.getExtractedFields(command);
+	const extracted = require_subcommand_router.getExtractedFields(command);
 	if (extracted) {
 		const options = extracted.fields.filter((a) => !a.positional);
 		for (const opt of options) {
@@ -836,10 +836,12 @@ function renderSubcommandOptionsCompact(command, indent) {
 function renderSubcommandsWithOptions(subCommands, parentPath, baseIndent) {
 	const lines = [];
 	for (const [name, subCmd] of getVisibleSubcommandEntries(subCommands)) {
-		const cmd = require_lazy.resolveSubCommandMeta(subCmd);
+		const cmd = require_subcommand_router.resolveSubCommandMeta(subCmd);
 		const fullPath = parentPath ? `${parentPath} ${name}` : name;
 		const desc = cmd?.description ?? "";
-		lines.push(formatOption(styles.command(fullPath), desc, baseIndent));
+		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);
@@ -870,7 +872,9 @@ function generateHelp(command, options) {
 		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}`);
@@ -884,9 +888,12 @@ function generateHelp(command, options) {
 		} else {
 			const subLines = [];
 			for (const [name, subCmd] of Object.entries(visibleSubCommands)) {
-				const desc = require_lazy.resolveSubCommandMeta(subCmd)?.description ?? "";
+				const cmd = require_subcommand_router.resolveSubCommandMeta(subCmd);
+				const desc = cmd?.description ?? "";
 				const fullName = currentPath ? `${currentPath} ${name}` : name;
-				subLines.push(formatOption(styles.command(fullName), desc));
+				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")}`);
 		}
@@ -993,7 +1000,7 @@ function checkCaseVariantCollisions(extracted, commandPath) {
 	const errors = [];
 	const canonicalMap = /* @__PURE__ */ new Map();
 	for (const field of extracted.fields) {
-		const camel = require_lazy.toCamelCase(field.name);
+		const camel = require_subcommand_router.toCamelCase(field.name);
 		const existing = canonicalMap.get(camel);
 		if (existing && existing !== field.name) errors.push({
 			commandPath,
@@ -1033,12 +1040,12 @@ function checkDuplicateAliases(extracted, commandPath) {
 		seenAliases.set(alias, fieldName);
 	};
 	for (const field of extracted.fields) {
-		const allAliases = require_lazy.getAllAliases(field);
+		const allAliases = require_subcommand_router.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_lazy.toCamelCase(alias);
+				const camelVariant = require_subcommand_router.toCamelCase(alias);
 				if (camelVariant !== alias && !fieldNames.has(camelVariant)) registerAlias(camelVariant, field.name, true);
 			}
 		}
@@ -1084,7 +1091,7 @@ function checkReservedAliases(extracted, commandPath) {
 	const errors = [];
 	for (const field of extracted.fields) {
 		if (field.overrideBuiltinAlias === true) continue;
-		for (const alias of require_lazy.getAllAliases(field)) if (alias === "h" || alias === "H") errors.push({
+		for (const alias of require_subcommand_router.getAllAliases(field)) if (alias === "h" || alias === "H") errors.push({
 			commandPath,
 			type: "reserved_alias",
 			message: `Alias "${alias}" is reserved for --${alias === "h" ? "help" : "help-all"}.`,
@@ -1155,7 +1162,7 @@ function validateReservedAliases(extracted, _hasSubCommands) {
 	if (errors.length > 0) {
 		const field = errors[0].field ?? "unknown";
 		const found = extracted.fields.find((f) => f.name === field);
-		const alias = (found ? require_lazy.getAllAliases(found) : []).find((a) => a === "h" || a === "H") ?? "h";
+		const alias = (found ? require_subcommand_router.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).`);
 	}
 }
@@ -1182,9 +1189,9 @@ function validateCaseVariantCollisions(extracted) {
 */
 function validateCrossSchemaCollisions(extractedA, extractedB) {
 	const canonicalMap = /* @__PURE__ */ new Map();
-	for (const field of extractedA.fields) canonicalMap.set(require_lazy.toCamelCase(field.name), field.name);
+	for (const field of extractedA.fields) canonicalMap.set(require_subcommand_router.toCamelCase(field.name), field.name);
 	for (const field of extractedB.fields) {
-		const camel = require_lazy.toCamelCase(field.name);
+		const camel = require_subcommand_router.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.`);
 	}
@@ -1202,6 +1209,57 @@ function collectSchemaErrors(extracted, _hasSubCommands, 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_subcommand_router.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,
@@ -1224,9 +1282,10 @@ async function validateCommand(command, options = {}) {
 	const errors = [];
 	const hasSubCommands = command.subCommands ? Object.keys(command.subCommands).length > 0 : false;
 	if (command.args) {
-		const extracted = require_lazy.extractFields(command.args);
+		const extracted = require_subcommand_router.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_subcommand_router.resolveLazyCommand(subCmd), { commandPath: [...commandPath, name] });
 		if (!subResult.valid) errors.push(...subResult.errors);
@@ -1401,14 +1460,14 @@ function buildParserOptions(extracted) {
 	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_lazy.getAllAliases(field)) {
+		for (const alias of require_subcommand_router.getAllAliases(field)) {
 			aliasMap.set(alias, field.name);
 			if (alias.length > 1 && alias.includes("-")) {
-				const camelAlias = require_lazy.toCamelCase(alias);
+				const camelAlias = require_subcommand_router.toCamelCase(alias);
 				if (camelAlias !== alias && !definedNames.has(camelAlias) && !aliasMap.has(camelAlias)) aliasMap.set(camelAlias, field.name);
 			}
 		}
-		const camelVariant = require_lazy.toCamelCase(field.name);
+		const camelVariant = require_subcommand_router.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);
@@ -1450,7 +1509,7 @@ function mergeWithPositionals(parsed, extracted) {
 function buildGlobalFlagLookup(globalExtracted) {
 	const { aliasMap = /* @__PURE__ */ new Map(), booleanFlags = /* @__PURE__ */ new Set() } = buildParserOptions(globalExtracted);
 	const shortAliases = /* @__PURE__ */ new Set();
-	for (const field of globalExtracted.fields) for (const alias of require_lazy.getAllAliases(field)) if (alias.length === 1) shortAliases.add(alias);
+	for (const field of globalExtracted.fields) for (const alias of require_subcommand_router.getAllAliases(field)) if (alias.length === 1) shortAliases.add(alias);
 	return {
 		aliasMap,
 		booleanFlags,
@@ -1599,7 +1658,8 @@ function findFirstPositional(argv, globalExtracted) {
 * @returns Parse result
 */
 function parseArgs(argv, command, options = {}) {
-	const subCommandNames = command.subCommands ? Object.keys(command.subCommands) : [];
+	const subCommandNameSet = require_subcommand_router.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);
@@ -1619,7 +1679,7 @@ function parseArgs(argv, command, options = {}) {
 		}
 	} else {
 		const firstArg = argv[0];
-		if (firstArg && !firstArg.startsWith("-") && subCommandNames.includes(firstArg)) return {
+		if (firstArg && !firstArg.startsWith("-") && subCommandNameSet.has(firstArg)) return {
 			helpRequested: false,
 			helpAllRequested: false,
 			versionRequested: false,
@@ -1632,7 +1692,7 @@ function parseArgs(argv, command, options = {}) {
 	}
 	let extracted;
 	if (command.args) {
-		extracted = require_lazy.extractFields(command.args);
+		extracted = require_subcommand_router.extractFields(command.args);
 		if (!options.skipValidation) {
 			validateDuplicateFields(extracted);
 			validateCaseVariantCollisions(extracted);
@@ -1642,8 +1702,8 @@ function parseArgs(argv, command, options = {}) {
 			if (options.globalExtracted) validateCrossSchemaCollisions(options.globalExtracted, extracted);
 		}
 	}
-	const hasUserDefinedH = extracted?.fields.some((f) => f.overrideBuiltinAlias === true && require_lazy.getAllAliases(f).includes("H")) ?? false;
-	const hasUserDefinedh = extracted?.fields.some((f) => f.overrideBuiltinAlias === true && require_lazy.getAllAliases(f).includes("h")) ?? false;
+	const hasUserDefinedH = extracted?.fields.some((f) => f.overrideBuiltinAlias === true && require_subcommand_router.getAllAliases(f).includes("H")) ?? false;
+	const hasUserDefinedh = extracted?.fields.some((f) => f.overrideBuiltinAlias === true && require_subcommand_router.getAllAliases(f).includes("h")) ?? false;
 	const helpAllRequested = argv.includes("--help-all") || !hasUserDefinedH && argv.includes("-H");
 	const helpRequested = !helpAllRequested && (argv.includes("--help") || !hasUserDefinedh && argv.includes("-h"));
 	const versionRequested = argv.includes("--version");
@@ -1691,11 +1751,11 @@ function parseArgs(argv, command, options = {}) {
 	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_lazy.getAllAliases(f)) knownAliases.add(alias);
+	for (const f of extracted.fields) for (const alias of require_subcommand_router.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_lazy.getAllAliases(f)) knownAliases.add(alias);
+		for (const alias of require_subcommand_router.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);
@@ -1887,7 +1947,7 @@ async function runEffects(validatedArgs, extracted, globalArgs) {
 
 //#endregion
 //#region src/core/runner.ts
-var runner_exports = /* @__PURE__ */ require_subcommand_router.__exportAll({
+var runner_exports = /* @__PURE__ */ require_log_collector.__exportAll({
 	runCommand: () => runCommand,
 	runMain: () => runMain
 });
@@ -1927,7 +1987,7 @@ const defaultLogger = {
 async function runCommand(command, argv, options = {}) {
 	const globalExtracted = extractAndValidateGlobal(options);
 	const shouldCaptureLogs = options.captureLogs ?? false;
-	const globalCollector = shouldCaptureLogs ? require_subcommand_router.createLogCollector() : null;
+	const globalCollector = shouldCaptureLogs ? require_log_collector.createLogCollector() : null;
 	if (options.setup) {
 		globalCollector?.start();
 		try {
@@ -1942,7 +2002,7 @@ async function runCommand(command, argv, options = {}) {
 				success: false,
 				error,
 				exitCode: 1,
-				logs: globalCollector?.getLogs() ?? require_subcommand_router.emptyLogs()
+				logs: globalCollector?.getLogs() ?? require_log_collector.emptyLogs()
 			};
 		}
 		globalCollector?.stop();
@@ -1955,7 +2015,7 @@ async function runCommand(command, argv, options = {}) {
 		_existingLogs: globalCollector?.getLogs()
 	});
 	if (options.cleanup) {
-		const cleanupCollector = shouldCaptureLogs ? require_subcommand_router.createLogCollector() : null;
+		const cleanupCollector = shouldCaptureLogs ? require_log_collector.createLogCollector() : null;
 		cleanupCollector?.start();
 		const cleanupCtx = { error: !result.success ? result.error : void 0 };
 		try {
@@ -1968,15 +2028,15 @@ async function runCommand(command, argv, options = {}) {
 					success: false,
 					error,
 					exitCode: 1,
-					logs: require_subcommand_router.mergeLogs(result.logs, cleanupCollector?.getLogs() ?? require_subcommand_router.emptyLogs())
+					logs: require_log_collector.mergeLogs(result.logs, cleanupCollector?.getLogs() ?? require_log_collector.emptyLogs())
 				};
 			}
 		}
 		cleanupCollector?.stop();
-		const cleanupLogs = cleanupCollector?.getLogs() ?? require_subcommand_router.emptyLogs();
+		const cleanupLogs = cleanupCollector?.getLogs() ?? require_log_collector.emptyLogs();
 		if (cleanupLogs.entries.length > 0) return {
 			...result,
-			logs: require_subcommand_router.mergeLogs(result.logs, cleanupLogs)
+			logs: require_log_collector.mergeLogs(result.logs, cleanupLogs)
 		};
 	}
 	return result;
@@ -2053,10 +2113,10 @@ async function runCommandInternal(command, argv, options = {}) {
 		rootName: command.name,
 		globalExtracted: options._globalExtracted
 	};
-	const collector = options.captureLogs ?? false ? require_subcommand_router.createLogCollector() : null;
+	const collector = options.captureLogs ?? false ? require_log_collector.createLogCollector() : null;
 	collector?.start();
 	const getCurrentLogs = () => {
-		return require_subcommand_router.mergeLogs(options._existingLogs ?? require_subcommand_router.emptyLogs(), collector?.getLogs() ?? require_subcommand_router.emptyLogs());
+		return require_log_collector.mergeLogs(options._existingLogs ?? require_log_collector.emptyLogs(), collector?.getLogs() ?? require_log_collector.emptyLogs());
 	};
 	try {
 		const parseResult = parseArgs(argv, command, {
@@ -2070,9 +2130,10 @@ async function runCommandInternal(command, argv, options = {}) {
 		if (parseResult.helpRequested || parseResult.helpAllRequested) {
 			let hasUnknownSubcommand = false;
 			const subCmdNames = require_subcommand_router.listSubCommands(command);
+			const allSubCmdNameSet = require_subcommand_router.listSubCommandNamesWithAliases(command);
 			if (subCmdNames.length > 0) {
 				const potentialSubCmd = findFirstPositional(argv, context.globalExtracted);
-				if (potentialSubCmd && !subCmdNames.includes(potentialSubCmd)) hasUnknownSubcommand = true;
+				if (potentialSubCmd && !allSubCmdNameSet.has(potentialSubCmd)) hasUnknownSubcommand = true;
 			}
 			const help = generateHelp(command, {
 				showSubcommands: options.showSubcommands ?? true,
@@ -2083,7 +2144,7 @@ async function runCommandInternal(command, argv, options = {}) {
 			collector?.stop();
 			if (hasUnknownSubcommand) {
 				const unknownCmd = findFirstPositional(argv, context.globalExtracted) ?? "";
-				const similar = findSimilar(unknownCmd, subCmdNames);
+				const similar = findSimilar(unknownCmd, [...allSubCmdNameSet]);
 				const suggestion = similar.length > 0 ? ` Did you mean: ${similar.join(", ")}?` : "";
 				return {
 					success: false,
@@ -2111,16 +2172,17 @@ async function runCommandInternal(command, argv, options = {}) {
 			};
 		}
 		if (parseResult.subCommand) {
-			const subCmd = await require_subcommand_router.resolveSubcommand(command, parseResult.subCommand);
-			if (subCmd) {
+			const resolved = await require_subcommand_router.resolveSubcommandWithAlias(command, parseResult.subCommand);
+			if (resolved) {
 				const subContext = {
 					commandPath: [...context.commandPath ?? [], parseResult.subCommand],
 					rootName: context.rootName,
 					rootVersion: context.rootVersion,
-					globalExtracted: context.globalExtracted
+					globalExtracted: context.globalExtracted,
+					aliasFor: resolved.aliasFor
 				};
 				collector?.stop();
-				return runCommandInternal(subCmd, parseResult.remainingArgs, {
+				return runCommandInternal(resolved.command, parseResult.remainingArgs, {
 					...options,
 					_context: subContext,
 					_existingLogs: getCurrentLogs(),
@@ -2245,7 +2307,7 @@ async function runCommandInternal(command, argv, options = {}) {
 */
 function extractAndValidateGlobal(options) {
 	if (!options.globalArgs) return void 0;
-	const extracted = require_lazy.extractFields(options.globalArgs);
+	const extracted = require_subcommand_router.extractFields(options.globalArgs);
 	if (!options.skipValidation) {
 		validateDuplicateFields(extracted);
 		validateCaseVariantCollisions(extracted);
@@ -2420,4 +2482,4 @@ Object.defineProperty(exports, 'validateReservedAliases', {
     return validateReservedAliases;
   }
 });
-//# sourceMappingURL=runner-CY5fOsSh.cjs.map
+//# sourceMappingURL=runner-CriXJlm4.cjs.map