politty 0.4.13 → 0.4.15

package/dist/{runner-DA48D-3K.cjs → runner-CriXJlm4.cjs}

@@ -1,8 +1,8 @@
-const require_subcommand_router = require('./subcommand-router-BnHpqyRk.cjs');
-const require_lazy = require('./lazy-qPy4cMnv.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.alias === "h" && f.overrideBuiltinAlias === true) ?? false;
-	const hasUserDefinedH = extracted?.fields.some((f) => f.alias === "H" && f.overrideBuiltinAlias === true) ?? 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));
@@ -738,13 +738,25 @@ function renderUnionOptions(extracted, _command, lines) {
 */
 function formatFlags(opt) {
 	const parts = [];
-	if (opt.alias) parts.push(styles.option(`-${opt.alias}`));
+	if (opt.alias) {
+		for (const alias of opt.alias) if (alias.length === 1) parts.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}>`)}`;
 	}
 	parts.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}>`)}`;
+			}
+			parts.push(longAlias);
+		}
+	}
 	return parts.join(", ");
 }
 /**
@@ -804,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) {
@@ -824,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);
@@ -858,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}`);
@@ -872,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")}`);
 		}
@@ -981,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,
@@ -1000,22 +1019,36 @@ function checkDuplicateAliases(extracted, commandPath) {
 	const errors = [];
 	const seenAliases = /* @__PURE__ */ new Map();
 	const fieldNames = new Set(extracted.fields.map((f) => f.name));
-	for (const field of extracted.fields) {
-		if (!field.alias) continue;
-		if (fieldNames.has(field.alias)) errors.push({
+	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 "${field.alias}" for field "${field.name}" conflicts with existing field name "${field.alias}".`,
-			field: field.name
-		});
-		const existingField = seenAliases.get(field.alias);
-		if (existingField) errors.push({
-			commandPath,
-			type: "duplicate_alias",
-			message: `Duplicate alias "${field.alias}" detected. Both "${existingField}" and "${field.name}" use the same alias.`,
-			field: field.name
+			message: `Alias "${alias}" for field "${fieldName}" conflicts with existing field name or CLI name "${alias}".`,
+			field: fieldName
 		});
-		seenAliases.set(field.alias, field.name);
+		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_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_subcommand_router.toCamelCase(alias);
+				if (camelVariant !== alias && !fieldNames.has(camelVariant)) registerAlias(camelVariant, field.name, true);
+			}
+		}
 	}
 	return errors;
 }
@@ -1056,12 +1089,15 @@ function checkPositionalConfig(extracted, commandPath) {
 */
 function checkReservedAliases(extracted, commandPath) {
 	const errors = [];
-	for (const field of extracted.fields) if ((field.alias === "h" || field.alias === "H") && field.overrideBuiltinAlias !== true) errors.push({
-		commandPath,
-		type: "reserved_alias",
-		message: `Alias "${field.alias}" is reserved for --${field.alias === "h" ? "help" : "help-all"}.`,
-		field: field.name
-	});
+	for (const field of extracted.fields) {
+		if (field.overrideBuiltinAlias === true) continue;
+		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"}.`,
+			field: field.name
+		});
+	}
 	return errors;
 }
 /**
@@ -1125,8 +1161,9 @@ function validateReservedAliases(extracted, _hasSubCommands) {
 	const errors = checkReservedAliases(extracted, []);
 	if (errors.length > 0) {
 		const field = errors[0].field ?? "unknown";
-		const alias = extracted.fields.find((f) => f.name === field)?.alias ?? "h";
-		throw new ReservedAliasError(`Alias "${alias}" is reserved for --${alias === "h" ? "help" : "help-all"}. To override this, set { alias: "${alias}", overrideBuiltinAlias: true } for "${field}".`);
+		const found = extracted.fields.find((f) => f.name === field);
+		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).`);
 	}
 }
 /**
@@ -1152,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.`);
 	}
@@ -1172,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,
@@ -1194,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);
@@ -1371,8 +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);
-		if (field.alias) aliasMap.set(field.alias, field.name);
-		const camelVariant = require_lazy.toCamelCase(field.name);
+		for (const alias of require_subcommand_router.getAllAliases(field)) {
+			aliasMap.set(alias, field.name);
+			if (alias.length > 1 && alias.includes("-")) {
+				const camelAlias = require_subcommand_router.toCamelCase(alias);
+				if (camelAlias !== alias && !definedNames.has(camelAlias) && !aliasMap.has(camelAlias)) aliasMap.set(camelAlias, 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);
@@ -1413,12 +1508,14 @@ 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_subcommand_router.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: new Set(globalExtracted.fields.filter((f) => f.alias).map((f) => f.alias))
+		aliases: shortAliases
 	};
 }
 /**
@@ -1561,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);
@@ -1581,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,
@@ -1594,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);
@@ -1604,8 +1702,8 @@ function parseArgs(argv, command, options = {}) {
 			if (options.globalExtracted) validateCrossSchemaCollisions(options.globalExtracted, extracted);
 		}
 	}
-	const hasUserDefinedH = extracted?.fields.some((f) => f.alias === "H" && f.overrideBuiltinAlias === true) ?? false;
-	const hasUserDefinedh = extracted?.fields.some((f) => f.alias === "h" && f.overrideBuiltinAlias === true) ?? false;
+	const 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");
@@ -1652,11 +1750,12 @@ 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 = new Set(extracted.fields.filter((f) => f.alias).map((f) => f.alias));
+	const knownAliases = /* @__PURE__ */ new Set();
+	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);
-		if (f.alias) knownAliases.add(f.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);
@@ -1694,8 +1793,9 @@ function parseGlobalArgs(tokens, globalExtracted) {
 */
 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 localAliases = new Set(localExtracted?.fields.filter((f) => f.alias).map((f) => f.alias) ?? []);
+	const localAliasMapKeys = localExtracted ? new Set(buildParserOptions(localExtracted).aliasMap?.keys() ?? []) : /* @__PURE__ */ new Set();
 	const globalTokens = [];
 	const commandTokens = [];
 	for (let i = 0; i < argv.length; i++) {
@@ -1707,7 +1807,7 @@ function separateGlobalArgs(argv, globalExtracted, localExtracted) {
 		if (arg.startsWith("--")) {
 			const { resolvedName, withoutDashes, isNegated, isGlobal } = resolveGlobalLongOption(arg, lookup);
 			const flagName = isNegated ? withoutDashes.slice(3) : withoutDashes;
-			const isLocalCollision = localCliNames.has(withoutDashes) || localCliNames.has(flagName);
+			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;
@@ -1716,7 +1816,7 @@ function separateGlobalArgs(argv, globalExtracted, localExtracted) {
 			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)) && !localAliases.has(withoutDash)) {
+				if ((lookup.aliases.has(withoutDash) || lookup.flagNames.has(resolvedName)) && !localAliasMapKeys.has(withoutDash)) {
 					i += collectGlobalFlag(argv, i, resolvedName, false, lookup.booleanFlags, globalTokens) - 1;
 					continue;
 				}
@@ -1847,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
 });
@@ -1887,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 {
@@ -1902,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();
@@ -1915,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 {
@@ -1928,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;
@@ -2013,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, {
@@ -2030,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,
@@ -2043,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,
@@ -2071,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(),
@@ -2205,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);
@@ -2380,4 +2482,4 @@ Object.defineProperty(exports, 'validateReservedAliases', {
     return validateReservedAliases;
   }
 });
-//# sourceMappingURL=runner-DA48D-3K.cjs.map
+//# sourceMappingURL=runner-CriXJlm4.cjs.map