auto-mode 1.0.1 → 2.0.1

package/dist/cli.js

@@ -1,11 +1,2570 @@
 #!/usr/bin/env node
-import { C as resolveXDGDir, D as string, E as strictObject, S as CLI_LIMITS, T as number, _ as findGitEntry, a as EMPTY_SESSION_SCOPE, b as readHostEnvironment, c as loadPolicy, d as writeActionDiagnostic, f as toRepositorySlug, g as findCheckout, h as isUnresolvedWord, i as loadSessionScope, l as resolveShippedPolicyDir, m as resolveShellPath, n as classifyAction, o as splitGitCommand, p as collectShellCommands, r as resolveSessionScopePath, s as M, t as parseActionRequest, u as loadCheckoutFacts, v as DEFAULT_SCOPE_SOURCES, w as updateJSONFile, x as runCapped, y as loadConfig } from "./parse-action-request-BfkmQxEC.js";
-import { randomUUID } from "node:crypto";
+import { C as pickJudgeLane, E as updateJSONFile, S as CLI_LIMITS, T as resolveXDGDir, _ as findCheckout, a as resolveSessionScopePath, b as loadConfig, c as splitGitCommand, d as loadCheckoutFacts, f as writeActionDiagnostic, g as isUnresolvedWord, h as resolveShellPath, i as classifyAction, l as loadPolicy, m as collectShellCommands, n as readRuntime, o as loadSessionScope, p as toRepositorySlug, s as EMPTY_SESSION_SCOPE, t as parseActionRequest, u as resolveShippedPolicyDir, v as findGitEntry, w as M, x as runCapped, y as DEFAULT_SCOPE_SOURCES } from "./parse-action-request-neI2tNwd.js";
+import { a as literal, d as string, i as discriminatedUnion, r as boolean, s as number, u as strictObject } from "./schemas-Dc2424NY.js";
+import { createHash, randomUUID } from "node:crypto";
 import { chmod, mkdir, open, readFile, realpath, stat } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
-import { constants, existsSync } from "node:fs";
+import { setTimeout } from "node:timers/promises";
+import { spawn } from "node:child_process";
+import { constants, existsSync, statSync } from "node:fs";
 import { text } from "node:stream/consumers";
-import { parseArgs } from "node:util";
+import { connect } from "node:net";
+//#region node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/utils-D-MmF6sM.js
+/**
+* Entry point of utils.
+*
+* Note that this entry point is used by gunshi to import utility functions.
+*
+* @module
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Convert a string to kebab-case.
+*
+* @param str - A string to convert
+* @returns Converted string into kebab-case.
+*/
+function kebabnize(str) {
+	return str.replace(/[A-Z]/g, (match, offset) => (offset > 0 ? "-" : "") + match.toLowerCase());
+}
+/**
+* Format allowed argument choices for validation error values and fallback messages.
+*
+* @param choices - Choice values to format
+* @returns JSON-quoted choices joined with `, `.
+*/
+function formatChoices(choices) {
+	return choices.map((value) => JSON.stringify(value)).join(", ");
+}
+//#endregion
+//#region node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/utils.js
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Check if the given command is a {@link LazyCommand}.
+*
+* @param cmd - A command to check
+* @returns `true` if the command is a {@link LazyCommand}, otherwise `false`
+*
+* A lazy command is identified by its `commandName` property. The property may be
+* `undefined` when the lazy command has no definition name.
+*/
+function isLazyCommand(cmd) {
+	return typeof cmd === "function" && "commandName" in cmd;
+}
+/**
+* Resolve a lazy command to a {@link Command}.
+*
+* If the loader returns a command, the properties of the loaded command take precedence,
+* and the properties that it does not define fall back to the definition that is given to `lazy`.
+*
+* @param cmd - A {@link Commandable} or {@link LazyCommand} to resolve
+* @param name - Optional name of the command, if not provided, it will use the name from the command itself.
+* @param needRunResolving - Whether to run the resolving function of the lazy command.
+* @returns A resolved {@link Command}
+*/
+async function resolveLazyCommand(cmd, name, needRunResolving = false) {
+	let command;
+	if (isLazyCommand(cmd)) {
+		const baseCommand = {
+			name: cmd.commandName,
+			description: cmd.description,
+			args: cmd.args,
+			examples: cmd.examples,
+			internal: cmd.internal,
+			entry: cmd.entry,
+			toKebab: cmd.toKebab,
+			rendering: cmd.rendering,
+			subCommands: cmd.subCommands
+		};
+		if ("resource" in cmd && cmd.resource) baseCommand.resource = cmd.resource;
+		command = Object.assign(create(), baseCommand);
+		if (needRunResolving) {
+			const loaded = await cmd();
+			if (typeof loaded === "function") command.run = loaded;
+			else if (typeof loaded === "object") {
+				if (loaded.run == null) throw new TypeError(`'run' is required in command: ${cmd.name || name}`);
+				/**
+				* NOTE(kazupon): the loaded command wins, and the definition that is given to `lazy` is the fallback
+				* for what the loaded command does not define. A loader that returns `{ run }` keeps the whole definition,
+				* like a loader that returns the runner itself.
+				*/
+				command.run = loaded.run;
+				command.name = loaded.name ?? cmd.commandName;
+				command.description = loaded.description ?? cmd.description;
+				command.args = loaded.args ?? cmd.args;
+				command.examples = loaded.examples ?? cmd.examples;
+				command.internal = loaded.internal ?? cmd.internal;
+				command.entry = loaded.entry ?? cmd.entry;
+				command.toKebab = loaded.toKebab ?? cmd.toKebab;
+				command.rendering = loaded.rendering ?? cmd.rendering;
+				command.subCommands = loaded.subCommands || cmd.subCommands;
+				if ("resource" in loaded && loaded.resource) command.resource = loaded.resource;
+			} else throw new TypeError(`Cannot resolve command: ${cmd.name || name}`);
+		}
+	} else command = Object.assign(create(), cmd);
+	if (command.name == null && name) command.name = name;
+	return deepFreeze(command);
+}
+/**
+* Create an object with the specified prototype. A shorthand for `Object.create`.
+*
+* @param obj - An object to use as the prototype for the new object. If `null`, it will create an object with no prototype.
+* @returns A new object with the specified prototype
+*/
+function create(obj = null) {
+	return Object.create(obj);
+}
+/**
+* Log a message to the console.
+*
+* @param args - Arguments to log
+*/
+function log(...args) {
+	console.log(...args);
+}
+/**
+* Get the sub-commands of a command as a normalized Map.
+*
+* @param cmd - A command or lazy command
+* @returns A Map of sub-commands, or undefined if the command has no sub-commands.
+*/
+function getCommandSubCommands(cmd) {
+	const subCommands = isLazyCommand(cmd) ? cmd.subCommands : typeof cmd === "object" ? cmd.subCommands : void 0;
+	if (!subCommands) return;
+	if (subCommands instanceof Map) return subCommands.size > 0 ? subCommands : void 0;
+	if (typeof subCommands === "object") {
+		const entries = Object.entries(subCommands);
+		if (entries.length === 0) return;
+		const map = /* @__PURE__ */ new Map();
+		for (const [name, cmd] of entries) map.set(name, cmd);
+		return map;
+	}
+}
+/**
+* Deep freeze an object, making it immutable.
+*
+* @param obj - The object to freeze
+* @param ignores - Properties to ignore during freezing
+* @returns A frozen object
+*/
+function deepFreeze(obj, ignores = []) {
+	if (obj === null || typeof obj !== "object") return obj;
+	for (const key of Object.keys(obj)) {
+		const value = obj[key];
+		if (ignores.includes(key)) continue;
+		if (typeof value === "object" && value !== null) deepFreeze(value, ignores);
+	}
+	return Object.freeze(obj);
+}
+//#endregion
+//#region node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/context-CSecf6R5.js
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const ANONYMOUS_COMMAND_NAME = "(anonymous)";
+/**
+* A no-operation function.
+*/
+const NOOP = () => {};
+const CLI_OPTIONS_DEFAULT = {
+	name: void 0,
+	description: void 0,
+	version: void 0,
+	cwd: void 0,
+	usageSilent: false,
+	subCommands: void 0,
+	leftMargin: 2,
+	middleMargin: 10,
+	usageOptionType: false,
+	usageOptionValue: true,
+	strict: false,
+	renderHeader: void 0,
+	renderUsage: void 0,
+	renderValidationErrors: void 0,
+	plugins: void 0,
+	fallbackToEntry: false
+};
+/**
+* The entry for gunshi context.
+* This module is exported for the purpose of testing the command.
+*
+* @example
+* ```js
+* import { createCommandContext } from 'gunshi/context'
+* ```
+*
+* @module
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Create a command context.
+*
+* @param param - A {@link CommandContextParams | parameters} to create a command context.
+* @returns A {@link CommandContext | command context}, which is readonly.
+*/
+async function createCommandContext({ args = {}, explicit = {}, values = {}, positionals = [], rest = [], argv = [], tokens = [], command = {}, extensions = {}, cliOptions = {}, callMode = "entry", commandPath = [], omitted = false, validationError }) {
+	/**
+	* normailize the options schema and values, to avoid prototype pollution
+	*/
+	const _args = Object.entries(args).reduce((acc, [key, value]) => {
+		acc[key] = Object.assign(create(), value);
+		return acc;
+	}, create());
+	/**
+	* setup the environment
+	*/
+	const env = Object.assign(create(), CLI_OPTIONS_DEFAULT, cliOptions);
+	/**
+	* apply Command definition's rendering option with highest priority
+	*/
+	if (command.rendering) {
+		const { header, usage, validationErrors } = command.rendering;
+		if (header !== void 0) env.renderHeader = header;
+		if (usage !== void 0) env.renderUsage = usage;
+		if (validationErrors !== void 0) env.renderValidationErrors = validationErrors;
+	}
+	/**
+	* create the command context
+	*/
+	const core = Object.assign(create(), {
+		name: getCommandName(command),
+		description: command.description,
+		omitted,
+		callMode,
+		commandPath,
+		env,
+		args: _args,
+		explicit,
+		values,
+		positionals,
+		rest,
+		_: argv,
+		tokens,
+		toKebab: command.toKebab,
+		log: cliOptions.usageSilent ? NOOP : log,
+		validationError
+	});
+	/**
+	* extend the command context with extensions
+	*/
+	if (Object.keys(extensions).length > 0) {
+		const ext = create(null);
+		Object.defineProperty(core, "extensions", {
+			value: ext,
+			writable: false,
+			enumerable: true,
+			configurable: true
+		});
+		for (const [key, extension] of Object.entries(extensions)) {
+			ext[key] = await extension.factory(core, command);
+			if (extension.onFactory) await extension.onFactory(core, command);
+		}
+	}
+	return deepFreeze(core, ["extensions", "entryCommand"]);
+}
+function getCommandName(cmd) {
+	if (isLazyCommand(cmd)) return cmd.commandName || cmd.name || "(anonymous)";
+	else if (typeof cmd === "object") return cmd.name || "(anonymous)";
+	else return ANONYMOUS_COMMAND_NAME;
+}
+//#endregion
+//#region node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/resolver-CAlgxe_R-3pz9PVFu.js
+/**
+* forked from `nodejs/node` (`pkgjs/parseargs`)
+* repository url: https://github.com/nodejs/node (https://github.com/pkgjs/parseargs)
+* code url: https://github.com/nodejs/node/blob/main/lib/internal/util/parse_args/parse_args.js
+*
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const HYPHEN_CHAR = "-";
+const HYPHEN_CODE = HYPHEN_CHAR.codePointAt(0);
+const EQUAL_CHAR = "=";
+const EQUAL_CODE = EQUAL_CHAR.codePointAt(0);
+const TERMINATOR = "--";
+const SHORT_OPTION_PREFIX = HYPHEN_CHAR;
+const LONG_OPTION_PREFIX = "--";
+/**
+* Parse command line arguments.
+*
+* @param args - command line arguments
+* @param options - parse options, about details see {@link ParserOptions}
+* @returns Argument tokens.
+*
+* @example
+* ```js
+* import { parseArgs } from 'args-tokens' // for Node.js and Bun
+* // import { parseArgs } from 'jsr:@kazupon/args-tokens' // for Deno
+*
+* const tokens = parseArgs(['--foo', 'bar', '-x', '--bar=baz'])
+* // do something with using tokens
+* // ...
+* console.log('tokens:', tokens)
+* ```
+*/
+function parseArgs(args, options = {}) {
+	const { allowCompatible = false } = options;
+	const tokens = [];
+	const remainings = [...args];
+	let index = -1;
+	let groupCount = 0;
+	let hasShortGroupValue = false;
+	let shortGroupValueInline = true;
+	while (remainings.length > 0) {
+		const arg = remainings.shift();
+		if (arg == void 0) break;
+		if (groupCount > 0) groupCount--;
+		else index++;
+		if (arg === TERMINATOR) {
+			tokens.push({
+				kind: "option-terminator",
+				index
+			});
+			const mapped = remainings.map((arg) => {
+				return {
+					kind: "positional",
+					index: ++index,
+					value: arg
+				};
+			});
+			tokens.push(...mapped);
+			break;
+		}
+		if (isShortOption(arg)) {
+			const shortOption = arg.charAt(1);
+			let value;
+			let inlineValue;
+			if (groupCount) {
+				tokens.push({
+					kind: "option",
+					name: shortOption,
+					rawName: arg,
+					index,
+					value,
+					inlineValue
+				});
+				if (groupCount === 1 && hasShortGroupValue) {
+					value = remainings.shift();
+					inlineValue = shortGroupValueInline;
+					hasShortGroupValue = false;
+					tokens.push({
+						kind: "option",
+						index,
+						value,
+						inlineValue
+					});
+				}
+			} else tokens.push({
+				kind: "option",
+				name: shortOption,
+				rawName: arg,
+				index,
+				value,
+				inlineValue
+			});
+			if (value != null) ++index;
+			continue;
+		}
+		if (isShortOptionGroup(arg)) {
+			const expanded = [];
+			let separated = false;
+			let dashed = false;
+			let shortValue = "";
+			for (let i = 1; i < arg.length; i++) {
+				const shortableOption = arg.charAt(i);
+				if (separated) shortValue += shortableOption;
+				else if (!allowCompatible && shortableOption.codePointAt(0) === EQUAL_CODE && expanded.length > 0) separated = true;
+				else if (!allowCompatible && shortableOption.codePointAt(0) === HYPHEN_CODE) {
+					separated = true;
+					dashed = true;
+					shortValue += shortableOption;
+				} else expanded.push(`${SHORT_OPTION_PREFIX}${shortableOption}`);
+			}
+			hasShortGroupValue = separated;
+			shortGroupValueInline = !dashed;
+			if (separated) expanded.push(shortValue);
+			remainings.unshift(...expanded);
+			groupCount = expanded.length;
+			continue;
+		}
+		if (isLongOption(arg)) {
+			const longOption = arg.slice(2);
+			tokens.push({
+				kind: "option",
+				name: longOption,
+				rawName: arg,
+				index,
+				value: void 0,
+				inlineValue: void 0
+			});
+			continue;
+		}
+		if (isLongOptionAndValue(arg)) {
+			const equalIndex = arg.indexOf(EQUAL_CHAR);
+			const longOption = arg.slice(2, equalIndex);
+			const value = arg.slice(equalIndex + 1);
+			tokens.push({
+				kind: "option",
+				name: longOption,
+				rawName: `${LONG_OPTION_PREFIX}${longOption}`,
+				index,
+				value,
+				inlineValue: true
+			});
+			continue;
+		}
+		tokens.push({
+			kind: "positional",
+			index,
+			value: arg
+		});
+	}
+	return tokens;
+}
+/**
+* Check if `arg` is a short option (e.g. `-f`).
+*
+* @param arg - An argument to check
+* @returns Whether `arg` is a short option.
+*/
+function isShortOption(arg) {
+	return arg.length === 2 && arg.codePointAt(0) === HYPHEN_CODE && arg.codePointAt(1) !== HYPHEN_CODE;
+}
+/**
+* Check if `arg` is a short option group (e.g. `-abc`).
+*
+* @param arg - An argument to check
+* @returns Whether `arg` is a short option group.
+*/
+function isShortOptionGroup(arg) {
+	if (arg.length <= 2) return false;
+	if (arg.codePointAt(0) !== HYPHEN_CODE) return false;
+	if (arg.codePointAt(1) === HYPHEN_CODE) return false;
+	return true;
+}
+/**
+* Check if `arg` is a long option (e.g. `--foo`).
+*
+* @param arg - An argument to check
+* @returns Whether `arg` is a long option.
+*/
+function isLongOption(arg) {
+	return hasLongOptionPrefix(arg) && !arg.includes(EQUAL_CHAR, 3);
+}
+/**
+* Check if `arg` is a long option with value (e.g. `--foo=bar`).
+*
+* @param arg - An argument to check
+* @returns Whether `arg` is a long option.
+*/
+function isLongOptionAndValue(arg) {
+	return hasLongOptionPrefix(arg) && arg.includes(EQUAL_CHAR, 3);
+}
+/**
+* Check if `arg` starts with the long option prefix `--` and has more after it, such as `--foo`.
+* The option terminator `--` alone does not.
+*
+* @param arg - An argument to check
+* @returns Whether `arg` has the long option prefix and more after it.
+*/
+function hasLongOptionPrefix(arg) {
+	return arg.startsWith(LONG_OPTION_PREFIX) && arg.length > 2;
+}
+/**
+* Internal definitions shared by the modules of `args-tokens`.
+*
+* This module is not an entry point: it is not in the `exports` of `package.json` and `jsr.json`,
+* so what it exports is not part of the public API.
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Brand of a `parse` function that has no side effects, set by `string()`, `number()`,
+* `integer()`, `float()`, `choice()` and `positional()` without a parser, so that the resolver may
+* call it with a value that the option was not given, to check the value before suggesting it.
+*
+* The brand is looked up in the global symbol registry with `Symbol.for`, so it stays identical
+* across bundled copies of `args-tokens`, where the resolver and the combinators may come from
+* different copies.
+*/
+const PURE_PARSE = Symbol.for("args-tokens.pureParse");
+/**
+* Entry point of argument options resolver.
+*
+* @module
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Machine-readable error codes for {@link ArgsValidationError}.
+*
+* Each code identifies a validation failure category and is also suitable as an
+* i18n resource key for localized rendering.
+*
+* {@link resolveArgs} and `parse()` do not report `unknownOption`. An option that is not in the
+* schema takes the argument after it as its value, unless that argument is an option, and the value
+* is dropped: with no `foo` in the schema, `--foo bar` gives no positional argument.
+*/
+const ArgsValidationErrorKeys = {
+	requiredOption: "err:arg:required-option",
+	requiredPositional: "err:arg:required-positional",
+	invalidType: "err:arg:invalid-type",
+	invalidChoice: "err:arg:invalid-choice",
+	customParse: "err:arg:custom-parse",
+	unknownOption: "err:arg:unknown-option",
+	unexpectedValue: "err:arg:unexpected-value",
+	missingValue: "err:arg:missing-value",
+	conflict: "err:arg:conflict",
+	invalidDefault: "err:arg:invalid-default"
+};
+/**
+* Brand that marks {@link ArgsValidationError} instances.
+*
+* The brand is looked up in the global symbol registry with `Symbol.for`, so it stays
+* identical across bundled copies of this module and across realms. It lets
+* {@link isArgsValidationError} recognize errors created by another copy of `args-tokens`,
+* where `instanceof` cannot match.
+*/
+const ARGS_VALIDATION_ERROR_BRAND = Symbol.for("args-tokens.ArgsValidationError");
+/**
+* An error that contains structured metadata for argument validation failures.
+*
+* The `message` remains the English fallback message. Renderers can use `code`
+* and `values` to localize the error, falling back to `message` when localization
+* is unavailable.
+*
+* Each instance carries a non-enumerable brand keyed by
+* `Symbol.for('args-tokens.ArgsValidationError')`, which {@link isArgsValidationError}
+* uses to recognize instances created by another bundled copy of `args-tokens`.
+*/
+var ArgsValidationError = class extends Error {
+	/**
+	* Machine-readable error code for this validation failure.
+	*
+	* This code can also be used as an i18n resource key.
+	*/
+	code;
+	/**
+	* Interpolation values for `code`.
+	*/
+	values;
+	/**
+	* Create an `ArgsValidationError` instance.
+	*
+	* @param message - fallback error message
+	* @param options - structured validation metadata
+	*/
+	constructor(message, options = {}) {
+		super(message, { cause: options.cause });
+		this.name = "ArgsValidationError";
+		this.code = options.code;
+		this.values = options.values ?? {};
+		Object.defineProperty(this, ARGS_VALIDATION_ERROR_BRAND, {
+			value: true,
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+	}
+};
+/**
+* Check whether the given value is an {@link ArgsValidationError}.
+*
+* This guard also recognizes errors created by another bundled copy of `args-tokens`
+* (0.29.0 or later), where `instanceof` does not match. Such an error must have an own brand
+* keyed by `Symbol.for('args-tokens.ArgsValidationError')` set to `true`, and a `values` object.
+* The guard does not rely on `error.name`, so subclasses such as {@link ArgResolveError} that
+* override `name` are still recognized.
+*
+* The guard narrows to `ArgsValidationError` only. Across bundled copies,
+* `instanceof ArgResolveError` still does not match.
+*
+* @param error - value to check
+* @returns `true` when the value is an `ArgsValidationError`
+*/
+function isArgsValidationError$1(error) {
+	if (error instanceof ArgsValidationError) return true;
+	if (typeof error !== "object" || error === null) return false;
+	if (!Object.hasOwn(error, ARGS_VALIDATION_ERROR_BRAND) || error[ARGS_VALIDATION_ERROR_BRAND] !== true) return false;
+	const values = error.values;
+	return typeof values === "object" && values !== null;
+}
+const SKIP_POSITIONAL_DEFAULT = -1;
+const ARG_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"boolean",
+	"number",
+	"enum",
+	"positional",
+	"custom"
+]);
+/**
+* Resolve command line arguments.
+*
+* @typeParam A - {@link Args | Arguments}, which is an object that defines the command line arguments.
+*
+* @param args - An arguments that contains {@link ArgSchema | arguments schema}.
+* @param tokens - An array of {@link ArgToken | tokens}.
+* @param resolveArgs - An arguments that contains {@link ResolveArgs | resolve arguments}.
+* @returns An object that contains the values of the arguments, positional arguments, rest arguments, {@link AggregateError | validation errors}, and explicit provision status.
+*
+* @example
+* ```typescript
+* // passed tokens: --port 3000
+*
+* const { values, explicit } = resolveArgs({
+*   port: {
+*     type: 'number',
+*     default: 8080
+*   },
+*   host: {
+*     type: 'string',
+*     default: 'localhost'
+*   }
+* }, parsedTokens)
+*
+* values.port // 3000
+* values.host // 'localhost'
+*
+* explicit.port // true (explicitly provided)
+* explicit.host // false (not provided, fallback to default)
+* ```
+*/
+function resolveArgs(args, tokens, { shortGrouping = false, skipPositional = SKIP_POSITIONAL_DEFAULT, toKebab = false } = {}) {
+	const skipPositionalIndex = typeof skipPositional === "number" ? Math.max(skipPositional, SKIP_POSITIONAL_DEFAULT) : SKIP_POSITIONAL_DEFAULT;
+	const rest = [];
+	const optionTokens = [];
+	const positionalTokens = [];
+	const argEntries = Object.entries(args);
+	let currentLongOption;
+	let currentShortOption;
+	const expandableShortOptions = [];
+	function getOptionName(rawArg, schema) {
+		return toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+	}
+	function checkLongTokenName(option, schema, token) {
+		if (token.rawName == void 0 || !hasLongOptionPrefix(token.rawName)) return false;
+		return token.name === option || isNegatedToken(token, option, schema);
+	}
+	function toShortValue() {
+		if (expandableShortOptions.length === 0) return;
+		else {
+			let value = "";
+			for (let i = 0; i < expandableShortOptions.length; i++) value += expandableShortOptions[i].name ?? "";
+			expandableShortOptions.length = 0;
+			return value;
+		}
+	}
+	function applyLongOptionValue(value) {
+		if (currentLongOption) {
+			currentLongOption.value = value;
+			optionTokens.push({ ...currentLongOption });
+			currentLongOption = void 0;
+		}
+	}
+	function applyShortOptionValue(value) {
+		if (currentShortOption) {
+			currentShortOption.value = value ?? toShortValue();
+			optionTokens.push({ ...currentShortOption });
+			currentShortOption = void 0;
+		}
+	}
+	/**
+	* analyze phase to resolve value
+	* separate tokens into positionals, long and short options, after that resolve values
+	*/
+	const schemas = Object.values(args);
+	const booleanLongOptionNames = /* @__PURE__ */ new Set();
+	for (let i = 0; i < argEntries.length; i++) {
+		const entry = argEntries[i];
+		const rawArg = entry[0];
+		const schema = entry[1];
+		if (typeof schema.parse !== "function") {
+			if (schema.type === "custom") throw new TypeError(`argument '${getOptionName(rawArg, schema)}' should have a 'parse' function`);
+			if (schema.type === "enum" && !Array.isArray(schema.choices)) throw new TypeError(`argument '${getOptionName(rawArg, schema)}' should have a 'choices' array`);
+			if (!ARG_TYPES.has(schema.type)) throw new Error(`Unsupported argument type '${schema.type}' for option '${getOptionName(rawArg, schema)}'`);
+		}
+		if (schema.type !== "boolean") continue;
+		const arg = toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+		booleanLongOptionNames.add(arg);
+		if (schema.negatable === true) booleanLongOptionNames.add(`no-${arg}`);
+	}
+	let terminated = false;
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i];
+		if (token.kind === "positional") {
+			if (terminated) {
+				rest.push(token.value);
+				continue;
+			}
+			if (currentShortOption) {
+				if (schemas.find((schema) => schema.short === currentShortOption.name && schema.type === "boolean") || expandableShortOptions.length > 0) {
+					positionalTokens.push({ ...token });
+					applyShortOptionValue();
+				} else applyShortOptionValue(token.value);
+			} else if (currentLongOption) {
+				if (booleanLongOptionNames.has(currentLongOption.name)) {
+					positionalTokens.push({ ...token });
+					applyLongOptionValue();
+				} else applyLongOptionValue(token.value);
+			} else positionalTokens.push({ ...token });
+		} else if (token.kind === "option") {
+			if (token.rawName) {
+				if (token.rawName.startsWith("--")) {
+					applyLongOptionValue();
+					applyShortOptionValue();
+					if (token.inlineValue) optionTokens.push({ ...token });
+					else currentLongOption = { ...token };
+				} else if (isShortOption(token.rawName)) {
+					if (currentShortOption) {
+						if (currentShortOption.index === token.index) {
+							if (shortGrouping) {
+								currentShortOption.value = token.value;
+								optionTokens.push({ ...currentShortOption });
+								currentShortOption = { ...token };
+							} else expandableShortOptions.push({ ...token });
+						} else {
+							currentShortOption.value = toShortValue();
+							optionTokens.push({ ...currentShortOption });
+							currentShortOption = { ...token };
+						}
+						applyLongOptionValue();
+					} else {
+						currentShortOption = { ...token };
+						applyLongOptionValue();
+					}
+				}
+			} else {
+				if (currentShortOption && currentShortOption.index == token.index) {
+					const letters = toShortValue();
+					currentShortOption.value = letters === void 0 ? token.value : `${letters}${token.inlineValue ? "=" : ""}${token.value ?? ""}`;
+					currentShortOption.inlineValue = token.inlineValue;
+					optionTokens.push({ ...currentShortOption });
+					currentShortOption = void 0;
+				}
+				applyLongOptionValue();
+			}
+		} else {
+			if (token.kind === "option-terminator") terminated = true;
+			applyLongOptionValue();
+			applyShortOptionValue();
+		}
+	}
+	/**
+	* check if the last long or short option is not resolved
+	*/
+	applyLongOptionValue();
+	applyShortOptionValue();
+	/**
+	* resolve values
+	*/
+	const values = Object.create(null);
+	const errors = [];
+	const explicit = Object.create(null);
+	const actualInputNames = /* @__PURE__ */ new Map();
+	let requiredPositionalsAfter;
+	const positionalItemCount = tokens.filter((token) => token.kind === "positional").length;
+	function getPositionalSkipIndex() {
+		return Math.min(skipPositionalIndex, positionalItemCount);
+	}
+	function getRequiredPositionalsAfter(rawArg) {
+		requiredPositionalsAfter ??= createRequiredPositionalsAfter(argEntries);
+		return requiredPositionalsAfter[rawArg] ?? 0;
+	}
+	let positionalsCount = 0;
+	for (let argIndex = 0; argIndex < argEntries.length; argIndex++) {
+		const entry = argEntries[argIndex];
+		const rawArg = entry[0];
+		const schema = entry[1];
+		const arg = getOptionName(rawArg, schema);
+		explicit[rawArg] = false;
+		if (schema.type === "positional") {
+			if (skipPositionalIndex > SKIP_POSITIONAL_DEFAULT) while (positionalsCount <= getPositionalSkipIndex()) positionalsCount++;
+			if (schema.multiple) {
+				const availablePositionals = Math.max(positionalTokens.length - positionalsCount, 0);
+				const positionalsToConsume = availablePositionals > 0 ? Math.max(availablePositionals - getRequiredPositionalsAfter(rawArg), 0) : 0;
+				if (positionalsToConsume > 0) {
+					const endPositionals = positionalsCount + positionalsToConsume;
+					if (typeof schema.parse === "function") {
+						const parsed = [];
+						for (let i = positionalsCount; i < endPositionals; i++) {
+							const p = positionalTokens[i];
+							const [parsedValue, error] = parseSchemaValue(p.value, rawArg, arg, schema);
+							if (error) errors.push(error);
+							else parsed.push(parsedValue);
+						}
+						values[rawArg] = parsed;
+					} else {
+						const valuesArray = [];
+						for (let i = positionalsCount; i < endPositionals; i++) valuesArray.push(positionalTokens[i].value);
+						values[rawArg] = valuesArray;
+					}
+					positionalsCount = endPositionals;
+					explicit[rawArg] = true;
+				} else if (schema.required) errors.push(createRequireError(rawArg, arg, schema));
+				else if (hasDefault(schema)) values[rawArg] = getDefaultValue(schema);
+			} else {
+				const positional = positionalTokens[positionalsCount];
+				if (shouldRequireMissingSinglePositional(schema)) {
+					if (positional != null) {
+						resolveSinglePositionalValue(values, errors, rawArg, arg, schema, positional);
+						explicit[rawArg] = true;
+						positionalsCount++;
+					} else errors.push(createRequireError(rawArg, arg, schema));
+					continue;
+				}
+				if (positional != null) {
+					const requiredPositionals = getRequiredPositionalsAfter(rawArg);
+					if (Math.max(positionalTokens.length - positionalsCount, 0) > requiredPositionals) {
+						resolveSinglePositionalValue(values, errors, rawArg, arg, schema, positional);
+						explicit[rawArg] = true;
+						positionalsCount++;
+						continue;
+					}
+				}
+				if (hasDefault(schema)) values[rawArg] = schema.default;
+			}
+			continue;
+		}
+		if (schema.required) {
+			if (!optionTokens.find((token) => {
+				return schema.short && token.name === schema.short && token.rawName != void 0 && isShortOption(token.rawName) || checkLongTokenName(arg, schema, token);
+			})) {
+				errors.push(createRequireError(rawArg, arg, schema));
+				continue;
+			}
+		}
+		let resolved = false;
+		for (let i = 0; i < optionTokens.length; i++) {
+			const token = optionTokens[i];
+			if (checkLongTokenName(arg, schema, token) || schema.short === token.name && token.rawName != void 0 && isShortOption(token.rawName)) {
+				explicit[rawArg] = true;
+				const rawName = token.rawName;
+				const actualInputName = isShortOption(rawName) ? `-${token.name}` : rawName;
+				actualInputNames.set(rawArg, actualInputName);
+				const missing = schema.type !== "boolean" && token.value === void 0;
+				if (!missing) {
+					const invalid = validateRequire(token, rawArg, arg, schema);
+					if (invalid) {
+						errors.push(invalid);
+						continue;
+					}
+				}
+				const [parsedValue, error] = missing ? [void 0, createMissingValueError(rawArg, arg, schema, findOptionLikeNextArgument(tokens, optionTokens, i, argEntries, toKebab))] : parse$1(token, rawArg, arg, schema);
+				if (error) errors.push(error);
+				else {
+					resolved = true;
+					if (schema.multiple) {
+						values[rawArg] ||= [];
+						values[rawArg].push(parsedValue);
+					} else values[rawArg] = parsedValue;
+				}
+			}
+		}
+		if (!resolved && schema.default != null) {
+			if (hasDefaultOutsideChoices(schema)) errors.push(createDefaultChoiceError(rawArg, arg, schema));
+			else values[rawArg] = getDefaultValue(schema);
+		}
+	}
+	const conflictErrors = checkConflicts(args, explicit, toKebab, actualInputNames);
+	errors.push(...conflictErrors);
+	return {
+		values,
+		positionals: positionalTokens.map((token) => token.value),
+		rest,
+		error: errors.length > 0 ? new AggregateError(errors) : void 0,
+		explicit
+	};
+}
+/**
+* Check whether an option token is the negated form (`--no-<option>`) of a negatable boolean option.
+*
+* The negated name is always `no-` followed by the full option name, so an option named
+* `no-cache` is negated only by `--no-no-cache`, and `--no-cache` is the option itself.
+*
+* @param token - The option token
+* @param option - The option name used on the command line (after `toKebab` conversion)
+* @param schema - The argument schema
+* @returns Whether the token negates the option.
+*/
+function isNegatedToken(token, option, schema) {
+	return schema.type === "boolean" && schema.negatable === true && token.name === `no-${option}`;
+}
+/**
+* Resolve the value of an option token that matches the schema.
+*
+* A token of a non-boolean option always has a value here: `resolveArgs()` reports an option
+* given without a value before calling this function.
+*
+* @param token - The option token
+* @param rawArg - The argument key in the schema
+* @param option - The option name used on the command line
+* @param schema - The argument schema
+* @returns The resolved value, or a validation error
+*/
+function parse$1(token, rawArg, option, schema) {
+	if (schema.type === "enum" && schema.choices && !schema.choices.includes(token.value)) return [void 0, createChoiceError(rawArg, option, schema, token.value)];
+	if (typeof schema.parse === "function") {
+		if (schema.type === "boolean") {
+			const [boolValue, error] = resolveBooleanValue(token, rawArg, option, schema);
+			if (error) return [void 0, error];
+			return parseSchemaValue(String(boolValue), rawArg, option, schema);
+		}
+		return parseSchemaValue(token.value, rawArg, option, schema);
+	}
+	switch (schema.type) {
+		case "string": return typeof token.value === "string" ? [token.value, void 0] : [void 0, createTypeError(rawArg, option, schema, token.value)];
+		case "boolean": return resolveBooleanValue(token, rawArg, option, schema);
+		case "number":
+			if (typeof token.value !== "string" || !isNumeric(token.value)) return [void 0, createTypeError(rawArg, option, schema, token.value)];
+			return [+token.value, void 0];
+		case "enum": return [token.value, void 0];
+		case "custom": throw new TypeError(`argument '${option}' should have a 'parse' function`);
+		default: throw new Error(`Unsupported argument type '${schema.type}' for option '${option}'`);
+	}
+}
+/**
+* Resolve the value of a boolean option token.
+*
+* `--flag` is `true` and `--no-flag` is `false`. An explicit inline value (`--flag=true`,
+* `--flag=false`, `-f=false`) is read instead; any other inline value is a type error.
+* The negated form does not take a value, so `--no-flag=<value>` is an error.
+*
+* @param token - The option token
+* @param rawArg - The argument key in the schema
+* @param option - The option name used on the command line
+* @param schema - The argument schema
+* @returns The resolved boolean, or a validation error
+*/
+function resolveBooleanValue(token, rawArg, option, schema) {
+	const negated = isNegatedToken(token, option, schema);
+	if (!token.inlineValue) return [!negated, void 0];
+	if (negated) return [void 0, createUnexpectedValueError(rawArg, option, schema, token)];
+	if (token.value !== "true" && token.value !== "false") return [void 0, createTypeError(rawArg, option, schema, token.value)];
+	return [token.value === "true", void 0];
+}
+function parseSchemaValue(value, rawArg, option, schema) {
+	try {
+		return [schema.parse(value), void 0];
+	} catch (error) {
+		return [void 0, createCustomParseError(error, rawArg, option, schema, value)];
+	}
+}
+function createRequireError(rawArg, option, schema) {
+	return new ArgResolveError(schema.type === "positional" ? `Positional argument '${option}' is required` : `Optional argument ${createOptionDisplayName(option, schema)} is required`, option, "required", schema, {
+		code: schema.type === "positional" ? ArgsValidationErrorKeys.requiredPositional : ArgsValidationErrorKeys.requiredOption,
+		values: schema.type === "positional" ? {
+			displayName: createArgumentDisplayName(option, schema),
+			name: rawArg
+		} : {
+			displayName: createOptionDisplayName(option, schema),
+			name: rawArg
+		}
+	});
+}
+function resolveSinglePositionalValue(values, errors, rawArg, option, schema, positional) {
+	if (typeof schema.parse === "function") {
+		const [parsedValue, error] = parseSchemaValue(positional.value, rawArg, option, schema);
+		if (error) errors.push(error);
+		else values[rawArg] = parsedValue;
+	} else values[rawArg] = positional.value;
+}
+function hasDefault(schema) {
+	return schema.default != null;
+}
+/**
+* Get the value that the default of an argument gives.
+*
+* The value of a `multiple` argument is an array, so its default becomes the only element of an
+* array. A default that is an array already, which only untyped code can give, is used as is.
+*
+* @param schema - The argument schema
+* @returns The value that the default gives
+*/
+function getDefaultValue(schema) {
+	const value = schema.default;
+	return schema.multiple && !Array.isArray(value) ? [value] : value;
+}
+/**
+* Check whether the default of an `enum` option is not one of its `choices`.
+*
+* The default does not go through `parse`, so with a `parse` function of your own, or a `map()`
+* transform, it is a value that the function returns, which need not be one of the choices, and it
+* is not checked. The `parse` function of `choice()` returns the value as is, so its default is
+* checked: among the schemas that the combinators make, it is the only `enum` schema whose `parse`
+* has the {@link PURE_PARSE} brand. An `enum` schema written by hand with another branded `parse`
+* would be checked too.
+*
+* Only a string, number or boolean default, as the type of `default` allows, is checked against an
+* array of choices. Anything else, which only untyped code can give, is used as before.
+*
+* @param schema - The argument schema
+* @returns Whether the default is not one of the choices
+*/
+function hasDefaultOutsideChoices(schema) {
+	const defaultType = typeof schema.default;
+	if (schema.type !== "enum" || !Array.isArray(schema.choices) || defaultType !== "string" && defaultType !== "number" && defaultType !== "boolean" || schema.choices.includes(schema.default)) return false;
+	const { parse } = schema;
+	if (typeof parse !== "function") return true;
+	try {
+		return hasPureParseBrand(parse);
+	} catch {
+		return false;
+	}
+}
+function shouldRequireMissingSinglePositional(schema) {
+	if (schema.required === true) return true;
+	if (schema.required === false) return false;
+	return !hasDefault(schema);
+}
+function getRequiredPositionalInputCount(schema) {
+	if (schema.type !== "positional") return 0;
+	if (schema.multiple) return schema.required === true ? 1 : 0;
+	return shouldRequireMissingSinglePositional(schema) ? 1 : 0;
+}
+function createRequiredPositionalsAfter(argEntries) {
+	const requiredPositionalsAfter = Object.create(null);
+	let minimumRequiredPositionals = 0;
+	for (let i = argEntries.length - 1; i >= 0; i--) {
+		const [rawArg, schema] = argEntries[i];
+		if (schema.type !== "positional") continue;
+		requiredPositionalsAfter[rawArg] = minimumRequiredPositionals;
+		minimumRequiredPositionals += getRequiredPositionalInputCount(schema);
+	}
+	return requiredPositionalsAfter;
+}
+/**
+* An error that occurs when resolving arguments.
+*
+* It is not thrown: when an argument is not valid, {@link resolveArgs} returns it in the `errors`
+* of the `AggregateError` in `error`, and so does `parse()`.
+*/
+var ArgResolveError = class extends ArgsValidationError {
+	/**
+	* The name of the argument on the command line, without the leading dashes: the schema key, in
+	* kebab-case with `toKebab`, such as `input-file` for `inputFile`, whether the option is given in
+	* the long form, as a short option or in the negated form. For a conflict, it is the name of the
+	* argument whose `conflicts` names the other one (the first in the schema when both name each
+	* other). `values.name` has the schema key.
+	*/
+	name;
+	schema;
+	type;
+	/**
+	* Create an `ArgResolveError` instance.
+	*
+	* @param message - the error message
+	* @param name - the name of the argument on the command line, in kebab-case with `toKebab`
+	* @param type - the type of the error: 'type', 'required', or 'conflict'
+	* @param schema - the argument schema that caused the error
+	* @param options - structured validation metadata
+	*/
+	constructor(message, name, type, schema, options = {}) {
+		super(message, options);
+		this.name = name;
+		this.type = type;
+		this.schema = schema;
+	}
+};
+function validateRequire(token, rawArg, option, schema) {
+	if (schema.required && schema.type !== "boolean" && !token.value) return createRequireError(rawArg, option, schema);
+}
+function isNumeric(str) {
+	return str.trim() !== "" && !isNaN(str);
+}
+function createTypeError(rawArg, option, schema, actual, expected = schema.type) {
+	return new ArgResolveError(`Optional argument ${createOptionDisplayName(option, schema)} should be '${expected}'`, option, "type", schema, {
+		code: ArgsValidationErrorKeys.invalidType,
+		values: {
+			displayName: createOptionDisplayName(option, schema),
+			name: rawArg,
+			expected,
+			...actual != null ? { actual } : {}
+		}
+	});
+}
+/**
+* Create the error for an option that is given without a value.
+*
+* `expected` names what the option takes: its type, or for a `custom` type its `metavar` (for
+* example `'integer'` for the `integer()` combinator). An `enum` also gets its choices. When the
+* argument after the option may be a value that starts with `-`, and the option may take it (see
+* `acceptsSuggestedValue()`), the error suggests the long form with `=`, which passes such a value in
+* every mode of the tokenizer.
+*
+* @param rawArg - The argument key in the schema
+* @param option - The option name used on the command line
+* @param schema - The argument schema
+* @param next - The argument after the option, when it may be a value that starts with `-`
+* @returns The validation error
+*/
+function createMissingValueError(rawArg, option, schema, next) {
+	const displayName = createOptionDisplayName(option, schema);
+	const suggestion = next === void 0 || !acceptsSuggestedValue(schema, next) ? void 0 : `--${option}=${next}`;
+	const hint = suggestion === void 0 ? "" : ` (to pass '${next}' as its value, write '${suggestion}')`;
+	const choices = schema.choices ?? [];
+	return new ArgResolveError(`Optional argument ${displayName} requires a value${hint}`, option, "type", schema, {
+		code: ArgsValidationErrorKeys.missingValue,
+		values: {
+			displayName,
+			name: rawArg,
+			expected: schema.type === "custom" ? schema.metavar ?? schema.type : schema.type,
+			...schema.type === "enum" ? {
+				choices: formatChoices(choices),
+				choiceValues: [...choices]
+			} : {},
+			...suggestion === void 0 ? {} : {
+				next,
+				suggestion
+			}
+		}
+	});
+}
+/**
+* Find the argument right after an option that is given without a value, when it may be a value
+* that starts with `-`.
+*
+* The option must end its own argument (with `shortGrouping`, `-pv` gives `-p` no value because of
+* `-v`), and the next argument must be read as options that are not all defined, such as `-5` or
+* `--foo`. Without `shortGrouping`, a group is read as its first option, which takes the other
+* letters as its value, so `-p5` is defined when `-p` is. The argument is rebuilt from its tokens.
+* Without `allowCompatible`, a short option written with a value, such as `-x=1`, `-x=` or `-x-1`,
+* has a value, and is not suggested.
+*
+* @param tokens - The tokens given to `resolveArgs()`
+* @param optionTokens - The option tokens that `resolveArgs()` resolves
+* @param position - The position of the option given without a value in `optionTokens`
+* @param argEntries - The argument schemas
+* @param toKebab - Whether every option name is converted to kebab-case
+* @returns The next argument rebuilt from its tokens, or `undefined` when there is nothing to
+* suggest
+*/
+function findOptionLikeNextArgument(tokens, optionTokens, position, argEntries, toKebab) {
+	const token = optionTokens[position];
+	for (let i = position + 1; i < optionTokens.length; i++) if (optionTokens[i].index === token.index) return;
+	const nextArg = tokens.filter((t) => t.index === token.index + 1);
+	if (nextArg.length === 0 || nextArg.some((t) => t.kind !== "option" || t.rawName == null)) return;
+	let text;
+	let known;
+	if (nextArg.length === 1 && nextArg[0].rawName.startsWith("--")) {
+		const [option] = nextArg;
+		text = option.inlineValue ? `${option.rawName}=${option.value}` : option.rawName;
+		known = createKnownOptionNames(argEntries, toKebab).long.has(option.name);
+	} else if (nextArg.every((t) => isShortOption(t.rawName) && t.value === void 0)) {
+		text = `-${nextArg.map((t) => t.name).join("")}`;
+		const { short } = createKnownOptionNames(argEntries, toKebab);
+		known = optionTokens.every((t) => t.index !== token.index + 1 || short.has(t.name));
+	} else return;
+	return known ? void 0 : text;
+}
+/**
+* Collect the names of the defined options: the long names, with the negated form of negatable
+* booleans, and the short names.
+*
+* @param argEntries - The argument schemas
+* @param toKebab - Whether every option name is converted to kebab-case
+* @returns The long and short option names
+*/
+function createKnownOptionNames(argEntries, toKebab) {
+	const long = /* @__PURE__ */ new Set();
+	const short = /* @__PURE__ */ new Set();
+	for (const [rawArg, schema] of argEntries) {
+		if (schema.type === "positional") continue;
+		const name = toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+		long.add(name);
+		if (schema.type === "boolean" && schema.negatable === true) long.add(`no-${name}`);
+		if (schema.short) short.add(schema.short);
+	}
+	return {
+		long,
+		short
+	};
+}
+/**
+* Check whether the argument after an option given without a value may be suggested as its value.
+*
+* The value of a `number` option must be numeric, as the error expects a number, and the value of
+* an `enum` option with `choices` must be one of them, which is checked before any `parse`
+* function. A `parse` function with its own {@link PURE_PARSE} brand is then called with the
+* value, which must not throw. Any other `parse` function may have side effects, so it is not
+* called: a `number` option or an `enum` option with `choices` is then checked only as above, and
+* any other option is not suggested.
+*
+* @param schema - The argument schema
+* @param value - The argument after the option
+* @returns Whether the value may be suggested
+*/
+function acceptsSuggestedValue(schema, value) {
+	if (schema.type === "number" && !isNumeric(value)) return false;
+	if (schema.type === "enum" && schema.choices && !schema.choices.includes(value)) return false;
+	const { parse } = schema;
+	if (typeof parse !== "function") return true;
+	try {
+		if (!hasPureParseBrand(parse)) return schema.type === "number" || schema.type === "enum" && schema.choices !== void 0;
+		parse(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Check whether a `parse` function has its own {@link PURE_PARSE} brand.
+*
+* Only an own brand counts, as for `isArgsValidationError()`. Reading it may throw, for example for
+* a revoked proxy, so call this function in `try`.
+*
+* @param parse - The `parse` function of a schema
+* @returns Whether the function has no side effects
+*/
+function hasPureParseBrand(parse) {
+	return Object.hasOwn(parse, PURE_PARSE) && parse[PURE_PARSE] === true;
+}
+function createUnexpectedValueError(rawArg, option, schema, token) {
+	const rawName = token.rawName;
+	const displayName = `'${rawName}'`;
+	return new ArgResolveError(`Optional argument ${displayName} does not take a value`, option, "type", schema, {
+		code: ArgsValidationErrorKeys.unexpectedValue,
+		values: {
+			displayName,
+			name: rawArg,
+			rawName,
+			...token.value != null ? { actual: token.value } : {}
+		}
+	});
+}
+function createChoiceError(rawArg, option, schema, actual) {
+	const choices = schema.choices ?? [];
+	return new ArgResolveError(`Optional argument ${createOptionDisplayName(option, schema)} should be chosen from '${schema.type}' [${formatChoices(choices)}] values`, option, "type", schema, {
+		code: ArgsValidationErrorKeys.invalidChoice,
+		values: {
+			displayName: createOptionDisplayName(option, schema),
+			name: rawArg,
+			expected: schema.type,
+			choices: formatChoices(choices),
+			choiceValues: [...choices],
+			...actual != null ? { actual } : {}
+		}
+	});
+}
+/**
+* Create the error for the default of an `enum` option that is not one of its `choices`.
+*
+* Its `values` have the same keys as those of `err:arg:invalid-choice`, with the default as
+* `actual`.
+*
+* @param rawArg - The argument key in the schema
+* @param option - The option name used on the command line
+* @param schema - The argument schema
+* @returns The error
+*/
+function createDefaultChoiceError(rawArg, option, schema) {
+	const choices = schema.choices ?? [];
+	const displayName = createOptionDisplayName(option, schema);
+	return new ArgResolveError(`Optional argument ${displayName} has the default ${typeof schema.default === "string" ? JSON.stringify(schema.default) : String(schema.default)}, which is not one of '${schema.type}' [${formatChoices(choices)}] values`, option, "type", schema, {
+		code: ArgsValidationErrorKeys.invalidDefault,
+		values: {
+			displayName,
+			name: rawArg,
+			expected: schema.type,
+			choices: formatChoices(choices),
+			choiceValues: [...choices],
+			actual: schema.default
+		}
+	});
+}
+function createCustomParseError(error, rawArg, option, schema, value) {
+	const reused = reuseValidationError(error, rawArg, option, schema, value);
+	if (reused) return reused;
+	const reason = getErrorReason(error);
+	return new ArgsValidationError(reason, {
+		code: ArgsValidationErrorKeys.customParse,
+		values: {
+			displayName: createArgumentDisplayName(option, schema),
+			name: rawArg,
+			reason
+		},
+		cause: error
+	});
+}
+/**
+* Reuse an {@link ArgsValidationError} thrown from a custom `parse` function, filling in missing values.
+*
+* @param error - The value thrown from `parse`
+* @param rawArg - The argument key in the schema
+* @param option - The option name used on the command line
+* @param schema - The argument schema
+* @param value - The raw input value
+* @returns The same error when it can be reused, otherwise `undefined` so the caller wraps it.
+* Inspecting or updating the thrown value can throw, for example when its `values` object is frozen
+* or an accessor throws; such values are not reused, so a custom `parse` cannot make `resolveArgs` throw this way.
+*/
+function reuseValidationError(error, rawArg, option, schema, value) {
+	try {
+		if (isArgsValidationError$1(error)) {
+			augmentValidationError(error, rawArg, option, schema, value);
+			return error;
+		}
+	} catch {}
+}
+function augmentValidationError(error, rawArg, option, schema, value) {
+	const values = error.values;
+	values.name ??= rawArg;
+	values.displayName ??= createArgumentDisplayName(option, schema);
+	if ((error.code === ArgsValidationErrorKeys.invalidType || error.code === ArgsValidationErrorKeys.invalidChoice) && values.actual == null) values.actual = value;
+}
+function getErrorReason(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function createArgumentDisplayName(option, schema) {
+	return schema.type === "positional" ? `'${option}'` : createOptionDisplayName(option, schema);
+}
+function createOptionDisplayName(option, schema) {
+	return `'--${option}'${schema.short ? ` or '-${schema.short}'` : ""}`;
+}
+/**
+* Create the error for two arguments that conflict.
+*
+* An option is shown as it was written, such as `'-p'` or `'--no-color'`, and a positional argument
+* by its name, such as `'file'`, as in the message. The message starts with "Positional argument"
+* when `schema` is a positional argument, and with "Optional argument" otherwise.
+*
+* @param rawArg - The argument key of the argument whose `conflicts` names the other one
+* @param option - The name of that argument used on the command line
+* @param schema - The argument schema of that argument
+* @param actualName - That option as it was written, or the name of that positional argument
+* @param conflictingArg - The argument key of the other argument
+* @param conflictingActualName - The other option as it was written, or the name of the other
+* positional argument
+* @returns The validation error
+*/
+function createConflictError(rawArg, option, schema, actualName, conflictingArg, conflictingActualName) {
+	const displayName = `'${actualName}'`;
+	const conflictDisplayName = `'${conflictingActualName}'`;
+	return new ArgResolveError(`${schema.type === "positional" ? "Positional" : "Optional"} argument ${displayName} conflicts with ${conflictDisplayName}`, option, "conflict", schema, {
+		code: ArgsValidationErrorKeys.conflict,
+		values: {
+			displayName,
+			name: rawArg,
+			conflictDisplayName,
+			conflictName: conflictingArg
+		}
+	});
+}
+function checkConflicts(args, explicit, toKebab, actualInputNames) {
+	for (const rawArg in args) {
+		const schema = args[rawArg];
+		if (!explicit[rawArg]) continue;
+		if (!schema.conflicts) continue;
+		const conflicts = Array.isArray(schema.conflicts) ? schema.conflicts : [schema.conflicts];
+		for (let i = 0; i < conflicts.length; i++) {
+			const conflictingArg = conflicts[i];
+			if (!explicit[conflictingArg]) continue;
+			const arg = toKebab || schema.toKebab ? kebabnize(rawArg) : rawArg;
+			const conflictingArgKebab = toKebab || args[conflictingArg]?.toKebab ? kebabnize(conflictingArg) : conflictingArg;
+			return [createConflictError(rawArg, arg, schema, schema.type === "positional" ? arg : actualInputNames.get(rawArg) || `--${arg}`, conflictingArg, args[conflictingArg]?.type === "positional" ? conflictingArgKebab : actualInputNames.get(conflictingArg) || `--${conflictingArgKebab}`)];
+		}
+	}
+	return [];
+}
+//#endregion
+//#region node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/error-pbHb3QAL.js
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Command not found error resource keys.
+*/
+const CommandNotFoundErrorKeys = { notFound: "err:cmd:not-found" };
+/**
+* Command resolution error resource keys.
+*
+* These errors describe an ambiguity or inconsistency while choosing a command from arguments.
+* They are kept separate from {@link CommandNotFoundError} so consumers can distinguish a typo
+* from an input whose command interpretation is not unique.
+*/
+const CommandResolutionErrorKeys = {
+	ambiguous: "err:cmd:ambiguous",
+	inconsistentOptions: "err:cmd:inconsistent-options",
+	lazySchemaMismatch: "err:cmd:lazy-schema-mismatch"
+};
+/**
+* Brand that marks {@link CommandNotFoundError} instances.
+*
+* The brand is looked up in the global symbol registry with `Symbol.for`, so it stays
+* identical across bundled copies of gunshi (`gunshi`, `@gunshi/plugin`, `@gunshi/bone`)
+* and across realms. It lets {@link isCommandNotFoundError} recognize errors created by
+* another copy, where `instanceof` cannot match.
+*/
+const COMMAND_NOT_FOUND_ERROR_BRAND = Symbol.for("gunshi.CommandNotFoundError");
+const COMMAND_RESOLUTION_ERROR_BRAND = Symbol.for("gunshi.CommandResolutionError");
+/**
+* Error raised when a command cannot be resolved.
+*
+* Each instance carries a non-enumerable brand keyed by
+* `Symbol.for('gunshi.CommandNotFoundError')`, so that {@link isCommandNotFoundError}
+* recognizes it even when it was created by another bundled copy of gunshi.
+*/
+var CommandNotFoundError = class extends Error {
+	code;
+	values;
+	commandName;
+	candidates;
+	commandPath;
+	/**
+	* Create a command-not-found error.
+	*
+	* @param message - Fallback error message
+	* @param options - Command-not-found metadata
+	*/
+	constructor(message, options) {
+		super(message, { cause: options.cause });
+		this.name = "CommandNotFoundError";
+		this.code = options.code;
+		this.values = options.values || {};
+		this.commandName = options.commandName;
+		this.candidates = options.candidates || [];
+		this.commandPath = options.commandPath || [];
+		Object.defineProperty(this, COMMAND_NOT_FOUND_ERROR_BRAND, {
+			value: true,
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+	}
+};
+/**
+* Error raised when command routing cannot produce one consistent command.
+*
+* The own registry brand is the cross-bundle contract. Unlike the legacy command-not-found
+* guard, the new guard deliberately has no name-based fallback because this error type is new and
+* must not classify arbitrary errors from older versions.
+*/
+var CommandResolutionError = class extends Error {
+	code;
+	values;
+	commandPath;
+	candidatePaths;
+	/**
+	* Create a command resolution error with structured routing metadata.
+	*
+	* @param message - Human-readable fallback message
+	* @param options - Error code and command-routing metadata
+	*/
+	constructor(message, options = {}) {
+		super(message, { cause: options.cause });
+		this.name = "CommandResolutionError";
+		this.code = options.code;
+		this.values = options.values || {};
+		this.commandPath = options.commandPath || [];
+		this.candidatePaths = options.candidatePaths || [];
+		Object.defineProperty(this, COMMAND_RESOLUTION_ERROR_BRAND, {
+			value: true,
+			enumerable: false,
+			writable: false,
+			configurable: false
+		});
+	}
+};
+/**
+* Check whether an error is a {@link CommandNotFoundError}.
+*
+* `instanceof` alone is not enough: `@gunshi/plugin` is bundled with its own copy of this
+* class (`noExternal: ['gunshi/plugin']`), so an error thrown by `gunshi` is never an instance
+* of the class a plugin imports. Errors from another copy are recognized through the
+* `Symbol.for('gunshi.CommandNotFoundError')` brand, which does not depend on `error.name`.
+*
+* @param error - An unknown error
+* @returns `true` if the error is a {@link CommandNotFoundError}
+*/
+function isCommandNotFoundError(error) {
+	if (error instanceof CommandNotFoundError) return true;
+	if (!isRecord(error) || !hasCommandNotFoundErrorShape(error)) return false;
+	if (Object.hasOwn(error, COMMAND_NOT_FOUND_ERROR_BRAND) && error[COMMAND_NOT_FOUND_ERROR_BRAND] === true) return true;
+	return error instanceof Error && error.name === "CommandNotFoundError";
+}
+/**
+* Check whether an error is a {@link CommandResolutionError}.
+*
+* @param error - An unknown error
+* @returns `true` when the error has the command-resolution brand and shape
+*/
+function isCommandResolutionError(error) {
+	if (error instanceof CommandResolutionError) return true;
+	if (!isRecord(error) || !hasCommandResolutionErrorShape(error)) return false;
+	return Object.hasOwn(error, COMMAND_RESOLUTION_ERROR_BRAND) && error[COMMAND_RESOLUTION_ERROR_BRAND] === true;
+}
+/**
+* Check whether an error is an {@link ArgsValidationError}.
+*
+* Prefer this over the `args-tokens` guard of the same name. Both recognize errors from another
+* bundled copy through the `Symbol.for('args-tokens.ArgsValidationError')` brand that
+* `args-tokens` 0.29.0 or later sets, including subclasses such as `ArgResolveError` that
+* override `name` with the argument name. This guard additionally:
+*
+* - recognizes direct `ArgsValidationError` instances from copies bundling `args-tokens`
+*   older than 0.29.0, which do not set the brand
+* - checks that `code` and `values` of an error from another copy have the expected types
+*
+* The guard narrows only to {@link ArgsValidationError}: across copies,
+* `instanceof ArgResolveError` still fails, so do not rely on `type` or `schema` for such errors.
+*
+* @param error - An unknown error
+* @returns `true` if the error is an {@link ArgsValidationError}
+*/
+function isArgsValidationError(error) {
+	if (error instanceof ArgsValidationError) return true;
+	if (!isRecord(error) || !hasArgsValidationErrorShape(error)) return false;
+	if (isArgsValidationError$1(error)) return true;
+	return error instanceof Error && error.name === "ArgsValidationError";
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+/**
+* Check whether `code` is an own or inherited property that is a string or `undefined`.
+*
+* Constructors always assign `code`, even when the option is omitted.
+*
+* @param error - An error from another copy
+* @returns `true` if `code` has the expected type
+*/
+function hasOptionalStringCode(error) {
+	return "code" in error && (error.code === void 0 || typeof error.code === "string");
+}
+function hasCommandNotFoundErrorShape(error) {
+	return hasOptionalStringCode(error) && isRecord(error.values) && typeof error.commandName === "string" && isStringArray(error.candidates) && isStringArray(error.commandPath);
+}
+function hasCommandResolutionErrorShape(error) {
+	return hasOptionalStringCode(error) && isRecord(error.values) && isStringArray(error.commandPath) && Array.isArray(error.candidatePaths) && error.candidatePaths.every((path) => isStringArray(path));
+}
+function hasArgsValidationErrorShape(error) {
+	return hasOptionalStringCode(error) && isRecord(error.values);
+}
+/**
+* Check whether validation errors should be handled before version, help, or command execution.
+*
+* @param error - An aggregate validation error
+* @returns `true` if the validation error must be handled with priority
+*/
+function hasPriorityValidationError(error) {
+	return error?.errors.some((error) => isCommandNotFoundError(error) || isCommandResolutionError(error) || isArgsValidationError(error) && error.code === ArgsValidationErrorKeys.unknownOption) ?? false;
+}
+//#endregion
+//#region node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/core-EDPnjwxe.js
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+const EMPTY_RENDERER = () => Promise.resolve("");
+/**
+* Factory function for creating a decorators manager.
+*
+* @returns A new decorators manager instance
+*/
+function createDecorators() {
+	/**
+	* private states
+	*/
+	const headerDecorators = [];
+	const usageDecorators = [];
+	const validationDecorators = [];
+	const commandDecorators = [];
+	/**
+	* helper function for building renderers
+	*/
+	function buildRenderer(decorators, defaultRenderer) {
+		if (decorators.length === 0) return defaultRenderer;
+		let renderer = defaultRenderer;
+		for (const decorator of decorators) {
+			const previousRenderer = renderer;
+			renderer = (ctx) => decorator(previousRenderer, ctx);
+		}
+		return renderer;
+	}
+	/**
+	* public interfaces
+	*/
+	return Object.freeze({
+		addHeaderDecorator(decorator) {
+			headerDecorators.push(decorator);
+		},
+		addUsageDecorator(decorator) {
+			usageDecorators.push(decorator);
+		},
+		addValidationErrorsDecorator(decorator) {
+			validationDecorators.push(decorator);
+		},
+		addCommandDecorator(decorator) {
+			commandDecorators.push(decorator);
+		},
+		get commandDecorators() {
+			return [...commandDecorators];
+		},
+		getHeaderRenderer() {
+			return buildRenderer(headerDecorators, EMPTY_RENDERER);
+		},
+		getUsageRenderer() {
+			return buildRenderer(usageDecorators, EMPTY_RENDERER);
+		},
+		getValidationErrorsRenderer() {
+			if (validationDecorators.length === 0) return EMPTY_RENDERER;
+			let renderer = EMPTY_RENDERER;
+			for (const decorator of validationDecorators) {
+				const previousRenderer = renderer;
+				renderer = (ctx, error) => decorator(previousRenderer, ctx, error);
+			}
+			return renderer;
+		}
+	});
+}
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Factory function for creating a plugin context.
+*
+* @typeParam G - A type extending {@linkcode GunshiParams} to specify the shape of command parameters.
+*
+* @param decorators - A {@linkcode Decorators} instance.
+* @param initialSubCommands - Initial sub commands map.
+* @returns A new {@linkcode PluginContext} instance.
+*/
+function createPluginContext(decorators, initialSubCommands) {
+	/**
+	* private states
+	*/
+	const globalOptions = /* @__PURE__ */ new Map();
+	const subCommands = new Map(initialSubCommands || []);
+	/**
+	* public interfaces
+	*/
+	return Object.freeze({
+		get globalOptions() {
+			return new Map(globalOptions);
+		},
+		addGlobalOption(name, schema) {
+			if (!name) throw new Error("Option name must be a non-empty string");
+			if (globalOptions.has(name)) throw new Error(`Global option '${name}' is already registered`);
+			/**
+			* NOTE(kazupon): a short name belongs to one option. The global options of a CLI come from
+			* plugins that know nothing of each other, so two of them may reach for the same letter, and
+			* the parser would then match both and give neither the value that was typed. The one that
+			* asked first keeps the letter, and the other keeps its long name — the same way a global
+			* option gives its short name up to an argument of the command that claims it.
+			*/
+			const taken = schema.short && findGlobalOptionByShort(globalOptions, schema.short);
+			if (taken) {
+				console.warn(`Short name '-${schema.short}' of the global option '${name}' is already used by '${taken}'. Global option '${name}' is registered without it.`);
+				globalOptions.set(name, {
+					...schema,
+					short: void 0
+				});
+				return;
+			}
+			globalOptions.set(name, schema);
+		},
+		get subCommands() {
+			return new Map(subCommands);
+		},
+		addCommand(name, command) {
+			if (!name) throw new Error("Command name must be a non-empty string");
+			if (subCommands.has(name)) throw new Error(`Command '${name}' is already registered`);
+			subCommands.set(name, command);
+		},
+		hasCommand(name) {
+			return subCommands.has(name);
+		},
+		decorateHeaderRenderer(decorator) {
+			decorators.addHeaderDecorator(decorator);
+		},
+		decorateUsageRenderer(decorator) {
+			decorators.addUsageDecorator(decorator);
+		},
+		decorateValidationErrorsRenderer(decorator) {
+			decorators.addValidationErrorsDecorator(decorator);
+		},
+		decorateCommand(decorator) {
+			decorators.addCommandDecorator(decorator);
+		}
+	});
+}
+/**
+* Find the global option that already uses a short name.
+*
+* @param globalOptions - The global options registered so far
+* @param short - A short name, without the leading dash
+* @returns The name of the global option that uses it, or `undefined`
+*/
+function findGlobalOptionByShort(globalOptions, short) {
+	for (const [name, schema] of globalOptions) if (schema.short === short) return name;
+}
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Resolve plugin dependencies using topological sort
+*
+* @param plugins - Array of plugins to resolve
+* @returns Array of plugins sorted by dependencies
+*/
+function resolveDependencies(plugins) {
+	const sorted = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visiting = /* @__PURE__ */ new Set();
+	const pluginMap = /* @__PURE__ */ new Map();
+	for (const plugin of plugins) {
+		if (typeof plugin.id !== "string" || plugin.id.length === 0) throw new Error("Plugin id must be a non-empty string");
+		if (pluginMap.has(plugin.id)) console.warn(`Duplicate plugin id detected: \`${plugin.id}\``);
+		pluginMap.set(plugin.id, plugin);
+	}
+	function visit(plugin) {
+		if (typeof plugin.id !== "string" || plugin.id.length === 0) throw new Error("Plugin id must be a non-empty string");
+		if (visited.has(plugin.id)) return;
+		if (visiting.has(plugin.id)) throw new Error(`Circular dependency detected: \`${[...visiting].join(` -> `) + " -> " + plugin.id}\``);
+		visiting.add(plugin.id);
+		const deps = plugin.dependencies || [];
+		for (const dep of deps) {
+			const depId = typeof dep === "string" ? dep : dep.id;
+			const isOptional = typeof dep === "string" ? false : dep.optional || false;
+			const depPlugin = pluginMap.get(depId);
+			if (!depPlugin && !isOptional) throw new Error(`Missing required dependency: \`${depId}\` on \`${plugin.id}\``);
+			if (depPlugin) visit(depPlugin);
+		}
+		visiting.delete(plugin.id);
+		visited.add(plugin.id);
+		sorted.push(plugin);
+	}
+	for (const plugin of plugins) visit(plugin);
+	return sorted;
+}
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Resolve the arguments of a command, the way gunshi parses and renders them.
+*
+* The global options belong to no command definition, so they are merged into the arguments of the
+* command that runs. An argument of the command shadows the global option of the same name, and it
+* shadows the same way by short name: a global option gives up its short name to an argument of the
+* command that claims the same letter, and keeps its long name.
+*
+* NOTE(kazupon): this is not exported from the entry points. `@gunshi/plugin-completion` completes
+* the arguments the same way with the copy in `@gunshi/shared`, and the tests of that copy pin it
+* to the results of this one, so a change here has to be made there too.
+*
+* @param globalOptions - The global options that plugins registered with `addGlobalOption`
+* @param args - The arguments that the command declares
+* @returns The merged arguments
+*/
+function resolveCommandArgs(globalOptions, args) {
+	return Object.assign(create(), resolveGlobalOptions(globalOptions, args), args);
+}
+function resolveGlobalOptions(globalOptions, args) {
+	if (!globalOptions) return;
+	const shortNames = /* @__PURE__ */ new Set();
+	for (const schema of Object.values(args || {})) if (schema.type !== "positional" && schema.short) shortNames.add(schema.short);
+	const resolved = create();
+	for (const [name, schema] of globalOptions)
+ /**
+	* NOTE(kazupon): a copy, because the schema is the one that the plugin registered, which every
+	* command of the CLI shares. Only this command gives up the short name.
+	*/
+	resolved[name] = schema.short && shortNames.has(schema.short) ? {
+		...schema,
+		short: void 0
+	} : schema;
+	return resolved;
+}
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Run the command.
+*
+* @typeParam G - A type extending {@linkcode GunshiParams} to specify the shape of command and cli options.
+*
+* @param argv - Command line arguments
+* @param entry - A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
+* @param options - A {@link CliOptions | CLI options}
+* @param plugins - An array of {@link Plugin | plugins} to be applied
+* @param usageOnly - Whether to render the usage of the command instead of running it, which is what `generate` of `gunshi/generator` asks for
+* @returns A rendered usage or undefined. if you will use {@link CliOptions.usageSilent} option, it will return rendered usage string.
+*/
+async function cliCore(argv, entry, options, plugins, usageOnly = false) {
+	const decorators = createDecorators();
+	/**
+	* NOTE(kazupon): the decorator goes on before any plugin, which makes it the outermost one, so
+	* that the usage is rendered whatever the command declares and the runner is never reached.
+	*/
+	if (usageOnly) decorators.addCommandDecorator(usageOnlyDecorator());
+	const entryCommand = createEntryCommand(entry);
+	const initialSubCommands = createInitialSubCommands(options, entryCommand);
+	const pluginContext = createPluginContext(decorators, initialSubCommands);
+	const resolvedPlugins = await applyPlugins(pluginContext, [...plugins, ...options.plugins || []]);
+	const cliOptions = normalizeCliOptions(options, decorators, pluginContext, entryCommand);
+	/**
+	* NOTE(kazupon): a CLI whose user declares no sub-commands has no command tree of its own,
+	* so a positional argument must not become a command name just because a plugin added a command.
+	* The user can still opt out with an explicit `fallbackToEntry: false`.
+	*/
+	if (initialSubCommands.size === 0 && cliOptions.subCommands.size > 0 && options.fallbackToEntry === void 0) cliOptions.fallbackToEntry = true;
+	const tokens = parseArgs(argv);
+	const selection = resolveCommandSelection(tokens, entry, cliOptions, pluginContext.globalOptions);
+	const resolved = selection.context;
+	const { commandName: name, command, callMode, commandPath, depth, levelSubCommands } = resolved;
+	let targetCommand = command;
+	let targetCommandName = name;
+	let targetCallMode = callMode;
+	let targetCommandPath = commandPath;
+	let targetDepth = depth;
+	let targetOmitted = resolved.omitted;
+	let targetLevelSubCommands = levelSubCommands;
+	const additionalValidationErrors = selection.error ? [selection.error] : [];
+	if (!targetCommand) {
+		if (!resolved.parentCommand || !resolved.unresolvedCommandName) throw new Error(`Command not found: ${name || ""}`);
+		targetCommand = resolved.parentCommand;
+		targetCommandName = resolved.parentCommandName;
+		targetCommandPath = resolved.parentCommandPath || [];
+		targetDepth = targetCommandPath.length;
+		targetCallMode = targetDepth > 0 ? "subCommand" : "entry";
+		targetOmitted = false;
+		targetLevelSubCommands = resolved.parentSubCommands;
+		additionalValidationErrors.push(createCommandNotFoundError(resolved));
+	}
+	const routingOptions = Object.assign(create(), cliOptions, { subCommands: new Map(cliOptions.subCommands) });
+	if (targetLevelSubCommands) cliOptions.subCommands = targetLevelSubCommands;
+	const resolvedCommand = isLazyCommand(targetCommand) ? await resolveLazyCommand(targetCommand, targetCommandName, true) : targetCommand;
+	if (selection.error == null && isLazyCommand(targetCommand)) {
+		const loaded = resolveCommandTreeFromPositionals(getRoutingPositionals(tokens, pluginContext.globalOptions, resolvedCommand), entry, routingOptions);
+		if (!sameCommandPath(loaded.commandPath, targetCommandPath)) additionalValidationErrors.push(createLazySchemaMismatchError(targetCommandPath, loaded.commandPath));
+	}
+	const commandArgs = getCommandArgs(resolvedCommand);
+	const args = resolveCommandArgs(pluginContext.globalOptions, commandArgs);
+	/**
+	* NOTE(kazupon): a plugin cannot tell on its own whether the global option it registered survived
+	* the merge, so the core says which ones are in effect for this command (#745).
+	*/
+	cliOptions.globalOptions = resolveEffectiveGlobalOptions(pluginContext.globalOptions, commandArgs, args);
+	const skipPositional = resolveSkipPositional(tokens, pluginContext.globalOptions, resolvedCommand, targetDepth);
+	const diagnostic = selection.diagnostic === true;
+	const { explicit, values, positionals, rest, error } = diagnostic ? {
+		explicit: create(),
+		values: create(),
+		positionals: [],
+		rest: [],
+		error: void 0
+	} : resolveArgs(args, tokens, {
+		shortGrouping: true,
+		toKebab: resolvedCommand.toKebab,
+		skipPositional
+	});
+	const validationError = mergeValidationErrors(error, [...additionalValidationErrors, ...cliOptions.strict && !diagnostic ? createUnknownOptionErrors(findUnknownOptions(args, tokens, { toKebab: resolvedCommand.toKebab })) : []]);
+	return await executeCommand(resolvedCommand, await createCommandContext({
+		args,
+		explicit,
+		values,
+		positionals,
+		rest,
+		argv,
+		tokens,
+		omitted: targetOmitted,
+		callMode: targetCallMode,
+		commandPath: targetCommandPath,
+		command: resolvedCommand,
+		extensions: getPluginExtensions(resolvedPlugins),
+		validationError,
+		cliOptions
+	}), decorators.commandDecorators);
+}
+/**
+* Create the decorator that renders the usage of the command instead of running it.
+*
+* NOTE(kazupon): `generate()` of `gunshi/generator` asks the core for a usage. It used to ask by
+* adding `-h` to the arguments, which made the answer depend on what the command calls its own
+* arguments: a command that declares one named `help` takes the schema of the global option, and
+* the usage was never rendered. A decorator is not an argument, so no command can take it away.
+*
+* @returns A {@linkcode CommandDecorator | command decorator} that renders the usage
+*/
+function usageOnlyDecorator() {
+	return () => async (ctx) => {
+		if (hasPriorityValidationError(ctx.validationError)) throw ctx.validationError;
+		const buf = [];
+		if (ctx.env.renderHeader != null) {
+			const header = await ctx.env.renderHeader(ctx);
+			if (header) buf.push(header);
+		}
+		if (ctx.env.renderUsage == null) return;
+		const usage = await ctx.env.renderUsage(ctx);
+		if (!usage) return;
+		buf.push(usage);
+		return buf.join("\n");
+	};
+}
+async function applyPlugins(pluginContext, plugins) {
+	const sortedPlugins = resolveDependencies(plugins);
+	for (const plugin of sortedPlugins) try {
+		/**
+		* NOTE(kazupon):
+		* strictly `Args` are not required for plugin installation.
+		* because the strictly `Args` required by each plugin are unknown,
+		* and the plugin side can not know what the user will specify.
+		*/
+		await plugin(pluginContext);
+	} catch (error) {
+		/**
+		* NOTE(kazupon): a plugin that cannot be installed leaves the CLI without the options, the
+		* commands and the decorators it was written to add, and the plugins behind it are not
+		* installed either, while their context extensions are handed to the command all the same.
+		* `resolveDependencies()` already ends the run for a circular or a missing dependency, so a
+		* `setup` that throws ends it too, naming the plugin rather than leaving the failure to
+		* surface somewhere else.
+		*/
+		throw new Error(`Failed to install the plugin \`${plugin.id}\``, { cause: error });
+	}
+	return sortedPlugins;
+}
+/**
+* Resolve the global options that are in effect for the command being executed.
+*
+* A global option is in effect unless the command declares an argument of its own under the same
+* name, which replaces it. The schema is taken from the merged arguments, so it is the one in effect.
+*
+* @param globalOptions - The global options that plugins registered with `addGlobalOption`
+* @param commandArgs - The arguments that the command declares
+* @param args - The merged arguments
+* @returns The global options in effect, keyed by name
+*/
+function resolveEffectiveGlobalOptions(globalOptions, commandArgs, args) {
+	const effective = /* @__PURE__ */ new Map();
+	for (const name of globalOptions.keys()) if (!Object.hasOwn(commandArgs, name)) effective.set(name, args[name]);
+	return effective;
+}
+function getCommandArgs(cmd) {
+	if (isLazyCommand(cmd)) return cmd.args || create();
+	else if (typeof cmd === "object") return cmd.args || create();
+	else return create();
+}
+const NEGATABLE_OPTION_PREFIX = "no-";
+function findUnknownOptions(args, tokens, options) {
+	const knownLongOptions = /* @__PURE__ */ new Set();
+	const knownShortOptions = /* @__PURE__ */ new Set();
+	const knownNegatableOptions = /* @__PURE__ */ new Set();
+	const knownLongOptionCandidates = /* @__PURE__ */ new Set();
+	const longOptionCandidates = [];
+	function addLongOptionCandidate(name) {
+		const candidate = `--${name}`;
+		if (knownLongOptionCandidates.has(candidate)) return;
+		knownLongOptionCandidates.add(candidate);
+		longOptionCandidates.push(candidate);
+	}
+	for (const [name, schema] of Object.entries(args)) {
+		if (schema.type === "positional") continue;
+		const optionName = resolveOptionName(name, schema, options);
+		knownLongOptions.add(optionName);
+		/**
+		* NOTE(kazupon): a hidden option is still accepted, so it stays a known option. It is left out
+		* of the candidates, which are what `@gunshi/plugin-suggestion` offers as "Did you mean".
+		*/
+		if (!schema.hidden) addLongOptionCandidate(optionName);
+		if (schema.short) knownShortOptions.add(schema.short);
+		if (schema.type === "boolean" && schema.negatable) {
+			const negatableOptionName = `${NEGATABLE_OPTION_PREFIX}${optionName}`;
+			knownNegatableOptions.add(negatableOptionName);
+			if (!schema.hidden) addLongOptionCandidate(negatableOptionName);
+		}
+	}
+	const unknownOptions = [];
+	for (const token of tokens) {
+		if (token.kind === "option-terminator") break;
+		if (token.kind !== "option" || !token.name || !token.rawName) continue;
+		const isLongOption = token.rawName.startsWith("--");
+		if (isLongOption) {
+			if (knownLongOptions.has(token.name) || knownNegatableOptions.has(token.name)) continue;
+		} else if (knownShortOptions.has(token.name)) continue;
+		unknownOptions.push({
+			rawName: token.rawName,
+			name: token.name,
+			candidates: isLongOption ? longOptionCandidates : []
+		});
+	}
+	return unknownOptions;
+}
+function resolveOptionName(name, schema, options) {
+	return options.toKebab || schema.toKebab ? kebabnize(name) : name;
+}
+function createUnknownOptionErrors(unknownOptions) {
+	return unknownOptions.map(({ rawName, name, candidates }) => {
+		return new ArgsValidationError(`Unknown option: ${rawName}`, {
+			code: ArgsValidationErrorKeys.unknownOption,
+			values: {
+				rawName,
+				name,
+				candidates
+			}
+		});
+	});
+}
+function mergeValidationErrors(error, additionalErrors) {
+	if (additionalErrors.length === 0) return error;
+	return new AggregateError(error ? [...error.errors, ...additionalErrors] : additionalErrors, error?.message || additionalErrors[0]?.message);
+}
+const isObject = (val) => val !== null && typeof val === "object";
+/**
+* Create the entry command that sub-commands and plugins can see.
+* The user-provided entry is copied, so that marking it with `entry: true` does not mutate it.
+*
+* @param entryCmd - The entry that is passed to `cli`
+* @returns The entry command marked with `entry: true`, or `undefined` if the entry is not a command
+*/
+function createEntryCommand(entryCmd) {
+	if (isLazyCommand(entryCmd)) return Object.assign((...args) => entryCmd(...args), entryCmd, { entry: true });
+	else if (typeof entryCmd === "object") return Object.assign(create(), entryCmd, { entry: true });
+	else if (typeof entryCmd === "function") return {
+		run: entryCmd,
+		name: entryCmd.name || "(anonymous)",
+		entry: true
+	};
+}
+function createInitialSubCommands(options, entryCommand) {
+	const hasSubCommands = options.subCommands ? options.subCommands instanceof Map ? options.subCommands.size > 0 : isObject(options.subCommands) && Object.keys(options.subCommands).length > 0 : false;
+	const subCommands = new Map(options.subCommands instanceof Map ? options.subCommands : []);
+	if (!(options.subCommands instanceof Map) && isObject(options.subCommands)) for (const [name, cmd] of Object.entries(options.subCommands)) subCommands.set(name, cmd);
+	if (hasSubCommands && entryCommand) subCommands.set(resolveEntryName(entryCommand), entryCommand);
+	return subCommands;
+}
+function normalizeCliOptions(options, decorators, pluginContext, entryCommand) {
+	const subCommands = new Map(pluginContext.subCommands);
+	/**
+	* NOTE(kazupon): the entry command is part of `subCommands` only when the user passes sub-commands,
+	* so it is exposed on its own for the plugins that add commands to a CLI without sub-commands.
+	*/
+	const resolvedOptions = Object.assign(create(), CLI_OPTIONS_DEFAULT, options, {
+		subCommands,
+		entryCommand
+	});
+	if (resolvedOptions.renderHeader === void 0) resolvedOptions.renderHeader = decorators.getHeaderRenderer();
+	if (resolvedOptions.renderUsage === void 0) resolvedOptions.renderUsage = decorators.getUsageRenderer();
+	if (resolvedOptions.renderValidationErrors === void 0) resolvedOptions.renderValidationErrors = decorators.getValidationErrorsRenderer();
+	return resolvedOptions;
+}
+function getPositionalTokens(tokens) {
+	const positionals = [];
+	for (const token of tokens) {
+		if (token.kind === "option-terminator") break;
+		if (token.kind === "positional" && token.value) positionals.push(token.value);
+	}
+	return positionals;
+}
+function resolveCommandTree(tokens, entry, options) {
+	return resolveCommandTreeFromPositionals(getPositionalTokens(tokens), entry, options);
+}
+function resolveCommandTreeFromPositionals(positionals, entry, options) {
+	function resolveAsEntry() {
+		if (typeof entry === "function") {
+			if (isLazyCommand(entry)) return {
+				commandName: resolveEntryName(entry),
+				command: entry,
+				callMode: "entry",
+				commandPath: [],
+				depth: 0,
+				omitted: options.subCommands.size > 0 && !positionals[0],
+				levelSubCommands: options.subCommands.size > 0 ? options.subCommands : void 0
+			};
+			else return {
+				command: {
+					run: entry,
+					entry: true
+				},
+				callMode: "entry",
+				commandPath: [],
+				depth: 0,
+				omitted: options.subCommands.size > 0 && !positionals[0],
+				levelSubCommands: options.subCommands.size > 0 ? options.subCommands : void 0
+			};
+		} else if (typeof entry === "object") return {
+			commandName: resolveEntryName(entry),
+			command: entry,
+			callMode: "entry",
+			commandPath: [],
+			depth: 0,
+			omitted: options.subCommands.size > 0 && !positionals[0],
+			levelSubCommands: options.subCommands.size > 0 ? options.subCommands : void 0
+		};
+		else return {
+			callMode: "unexpected",
+			commandPath: [],
+			depth: 0,
+			omitted: false,
+			levelSubCommands: void 0
+		};
+	}
+	if (positionals.length === 0 || options.subCommands.size === 0) return resolveAsEntry();
+	let currentSubCommands = options.subCommands;
+	let resolvedCommand;
+	let resolvedName;
+	const commandPath = [];
+	let depth = 0;
+	for (let i = 0; i < positionals.length; i++) {
+		const token = positionals[i];
+		const cmd = currentSubCommands.get(token);
+		if (cmd == null) {
+			if (depth === 0) {
+				if (options.fallbackToEntry) return resolveAsEntry();
+				const parent = resolveAsEntry();
+				return {
+					commandName: token,
+					callMode: "unexpected",
+					commandPath: [],
+					depth: 0,
+					omitted: false,
+					levelSubCommands: void 0,
+					unresolvedCommandName: token,
+					parentCommand: parent.command,
+					parentCommandName: parent.commandName,
+					parentCommandPath: [],
+					parentSubCommands: options.subCommands
+				};
+			}
+			return {
+				commandName: token,
+				callMode: "unexpected",
+				commandPath: [...commandPath],
+				depth,
+				omitted: false,
+				levelSubCommands: void 0,
+				unresolvedCommandName: token,
+				parentCommand: resolvedCommand,
+				parentCommandName: resolvedName,
+				parentCommandPath: [...commandPath],
+				parentSubCommands: currentSubCommands
+			};
+		}
+		let resolved = cmd;
+		if (typeof cmd === "function" && cmd.commandName == null) resolved = Object.assign((...args) => cmd(...args), cmd, { commandName: token });
+		else if (typeof cmd === "object" && cmd.name == null) resolved = Object.assign(create(), cmd, { name: token });
+		resolvedCommand = resolved;
+		resolvedName = token;
+		commandPath.push(token);
+		depth++;
+		const nestedSubCommands = getCommandSubCommands(cmd);
+		if (nestedSubCommands && nestedSubCommands.size > 0) currentSubCommands = nestedSubCommands;
+		else break;
+	}
+	if (!resolvedCommand) return resolveAsEntry();
+	const resolvedSubCommands = getCommandSubCommands(resolvedCommand);
+	const omitted = resolvedSubCommands != null && resolvedSubCommands.size > 0;
+	let levelSubCommands;
+	if (omitted && resolvedSubCommands) {
+		levelSubCommands = new Map(resolvedSubCommands);
+		let entryCopy;
+		if (typeof resolvedCommand === "function") entryCopy = Object.assign((...args) => resolvedCommand(...args), resolvedCommand, { entry: true });
+		else entryCopy = Object.assign(create(), resolvedCommand, { entry: true });
+		levelSubCommands.set(resolvedName || resolveEntryName(entryCopy), entryCopy);
+	}
+	return {
+		commandName: resolvedName,
+		command: resolvedCommand,
+		callMode: depth > 0 ? "subCommand" : "entry",
+		commandPath,
+		depth,
+		omitted,
+		levelSubCommands
+	};
+}
+/**
+* Select a command while accounting for option values that args-tokens removes during resolution.
+*
+* The routing pass deliberately projects each candidate's schemas down to the metadata needed to
+* classify tokens. It never copies `parse`, defaults, required checks, or other user code. A
+* candidate is accepted only when routing its own declaration reaches the same Map-key path in the
+* declaration tree.
+*
+* @param tokens - Tokenized command-line arguments
+* @param entry - Entry command definition or runner
+* @param options - Internal CLI options with the declared sub-command tree
+* @param globalOptions - Global option schemas used during candidate classification
+* @returns The selected command context or a diagnostic resolution error
+*/
+function resolveCommandSelection(tokens, entry, options, globalOptions) {
+	const rawPositionals = getPositionalTokens(tokens);
+	const legacy = resolveCommandTree(tokens, entry, options);
+	if (!tokens.some((token) => token.kind === "option")) return { context: legacy };
+	const candidates = collectRoutingCandidates(rawPositionals, options.subCommands);
+	const evaluations = candidates.map((candidate) => evaluateRoutingCandidate(candidate));
+	const validExplicit = evaluations.filter((evaluation) => evaluation.result.command != null && evaluation.result.unresolvedCommandName == null && sameCommandPath(evaluation.result.commandPath, evaluation.path) && evaluation.path.length > 0);
+	if (legacy.command != null && legacy.unresolvedCommandName == null && legacy.commandPath.length > 0) {
+		const legacyMatch = validExplicit.find((evaluation) => sameCommandPath(evaluation.path, legacy.commandPath));
+		if (legacyMatch) return { context: legacyMatch.result };
+	}
+	if (validExplicit.length === 1) return { context: validExplicit[0].result };
+	if (validExplicit.length > 1) return createCommandResolutionResult(options, entry, CommandResolutionErrorKeys.ambiguous, validExplicit.map((evaluation) => evaluation.path));
+	const entryEvaluation = evaluateRoutingCandidate({
+		path: [],
+		command: getEntryRoutingCommand(entry, options)
+	});
+	if (entryEvaluation.result.command != null && entryEvaluation.result.unresolvedCommandName == null && entryEvaluation.result.commandPath.length === 0) return { context: entryEvaluation.result };
+	const failures = evaluations.filter((evaluation) => {
+		const { result } = evaluation;
+		if (!result.unresolvedCommandName) return false;
+		const parentPath = result.parentCommandPath || [];
+		return isPathPrefix(evaluation.path, parentPath);
+	}).map((evaluation) => evaluation.result);
+	if (entryEvaluation.result.unresolvedCommandName) failures.push(entryEvaluation.result);
+	const deepestFailures = selectDeepestFailures(failures);
+	if (deepestFailures.length === 1) return { context: deepestFailures[0] };
+	if (deepestFailures.length > 1) {
+		const paths = deepestFailures.map((result) => result.parentCommandPath || []);
+		return createCommandResolutionResult(options, entry, CommandResolutionErrorKeys.ambiguous, paths);
+	}
+	return createCommandResolutionResult(options, entry, CommandResolutionErrorKeys.inconsistentOptions, candidates.map((candidate) => candidate.path));
+	function evaluateRoutingCandidate(candidate) {
+		const positionals = getRoutingPositionals(tokens, globalOptions, candidate.command);
+		return {
+			...candidate,
+			positionals,
+			result: resolveCommandTreeFromPositionals(positionals, entry, options)
+		};
+	}
+}
+function collectRoutingCandidates(rawPositionals, root) {
+	const candidates = [];
+	const seen = /* @__PURE__ */ new Set();
+	function collect(commands, offset, parentPath) {
+		for (let index = offset; index < rawPositionals.length; index++) {
+			const name = rawPositionals[index];
+			const command = commands.get(name);
+			if (command == null) continue;
+			const path = [...parentPath, name];
+			const key = JSON.stringify(path);
+			const normalized = normalizeCommandReference(command, name);
+			if (!seen.has(key)) {
+				seen.add(key);
+				candidates.push({
+					path,
+					command: normalized
+				});
+			}
+			const nested = getCommandSubCommands(normalized);
+			if (nested && nested.size > 0) collect(nested, index + 1, path);
+		}
+	}
+	collect(root, 0, []);
+	return candidates;
+}
+function normalizeCommandReference(command, name) {
+	if (typeof command === "function" && command.commandName == null) return Object.assign((...args) => command(...args), command, { commandName: name });
+	if (typeof command === "object" && command.name == null) return Object.assign(create(), command, { name });
+	return command;
+}
+function getEntryRoutingCommand(entry, options) {
+	if (options.entryCommand) return options.entryCommand;
+	if (typeof entry === "function" && !isLazyCommand(entry)) return {
+		run: entry,
+		entry: true
+	};
+	return entry;
+}
+function getRoutingPositionals(tokens, globalOptions, command) {
+	/**
+	* NOTE(kazupon): an empty argument is never a command name. `getPositionalTokens()` skips it when it
+	* collects the candidates, and the routing of each candidate must skip it too; otherwise the routing
+	* looks for a sub-command named `''`, and fails with `inconsistent-options` (#781).
+	*/
+	return readPositionals(tokens, globalOptions, command).filter((value) => value !== "");
+}
+/**
+* Read the positional arguments as `resolveArgs()` reads them for a command, empty ones included.
+*
+* The schemas are projected down to the metadata that classifies the tokens, so no code of the user,
+* such as `parse`, runs.
+*
+* @param tokens - Tokenized command-line arguments
+* @param globalOptions - Global option schemas
+* @param command - The command whose arguments classify the tokens
+* @returns The positional arguments, in the order that `skipPositional` of args-tokens counts them
+*/
+function readPositionals(tokens, globalOptions, command) {
+	const effective = resolveCommandArgs(globalOptions, getCommandArgs(command));
+	const routingArgs = create();
+	for (const [name, schema] of Object.entries(effective)) {
+		if (schema.type === "positional") continue;
+		routingArgs[name] = {
+			type: schema.type === "boolean" ? "boolean" : "string",
+			short: schema.short,
+			negatable: schema.negatable,
+			toKebab: schema.toKebab
+		};
+	}
+	return resolveArgs(routingArgs, tokens, {
+		shortGrouping: true,
+		toKebab: command.toKebab
+	}).positionals;
+}
+/**
+* Resolve `skipPositional` of args-tokens: the index of the last positional argument to skip.
+*
+* NOTE(kazupon): the command names are the first positional arguments that are not empty, and the
+* last one is at `depth - 1` only when no empty argument comes before it. `skipPositional` counts every
+* positional argument, the empty ones too, so `app '' build x` gave `build` to the first positional
+* argument of `build` (#793). The index is found in the reading of `resolveArgs()`, in which the values
+* of the options are already taken out, so that an empty value of an option is not counted.
+*
+* @param tokens - Tokenized command-line arguments
+* @param globalOptions - Global option schemas
+* @param command - The command whose arguments are resolved
+* @param depth - The number of command names
+* @returns The index of the last command name among the positional arguments, or `-1` for the entry
+*/
+function resolveSkipPositional(tokens, globalOptions, command, depth) {
+	if (depth === 0) return -1;
+	if (!tokens.some((token) => token.kind === "positional" && token.value === "")) return depth - 1;
+	let names = 0;
+	for (const [index, value] of readPositionals(tokens, globalOptions, command).entries()) {
+		if (value === "") continue;
+		names++;
+		if (names === depth) return index;
+	}
+	return depth - 1;
+}
+function sameCommandPath(left, right) {
+	return left.length === right.length && left.every((name, index) => name === right[index]);
+}
+function isPathPrefix(prefix, path) {
+	return prefix.length <= path.length && prefix.every((name, index) => name === path[index]);
+}
+function selectDeepestFailures(failures) {
+	const unique = /* @__PURE__ */ new Map();
+	for (const failure of failures) {
+		const path = failure.parentCommandPath || [];
+		const key = JSON.stringify(path);
+		unique.set(key, failure);
+	}
+	const deepest = Math.max(-1, ...[...unique.values()].map((failure) => (failure.parentCommandPath || []).length));
+	return [...unique.values()].filter((failure) => (failure.parentCommandPath || []).length === deepest);
+}
+function createCommandResolutionResult(options, entry, code, candidatePaths) {
+	const normalizedPaths = candidatePaths.map((path) => [...path]);
+	const commandPath = commonCommandPath(normalizedPaths);
+	const parent = resolveCommandTreeFromPositionals(commandPath, entry, options);
+	const command = createDiagnosticCommand(parent.command, commandPath.at(-1));
+	const context = {
+		...parent,
+		command,
+		commandPath,
+		depth: commandPath.length,
+		commandName: parent.commandName || commandPath.at(-1),
+		callMode: commandPath.length > 0 ? "subCommand" : "entry",
+		omitted: false
+	};
+	const formattedPaths = normalizedPaths.map((path) => path.join(" ")).join(", ");
+	const formattedPath = commandPath.join(" ");
+	const values = {
+		commandPath: formattedPath,
+		candidatePaths: formattedPaths,
+		candidates: formattedPaths
+	};
+	return {
+		context,
+		error: new CommandResolutionError(createCommandResolutionMessage(code, formattedPath, formattedPaths), {
+			code,
+			values,
+			commandPath,
+			candidatePaths: normalizedPaths
+		}),
+		diagnostic: true
+	};
+}
+function commonCommandPath(paths) {
+	if (paths.length === 0) return [];
+	const common = [...paths[0]];
+	for (const path of paths.slice(1)) {
+		let length = 0;
+		while (length < common.length && length < path.length && common[length] === path[length]) length++;
+		common.length = length;
+	}
+	return common;
+}
+function createDiagnosticCommand(command, name) {
+	if (typeof command === "function") return Object.assign(create(), command, {
+		name: command.commandName || name,
+		run: void 0
+	});
+	return Object.assign(create(), command || {}, {
+		name: command?.name || name,
+		run: void 0
+	});
+}
+function createCommandResolutionMessage(code, commandPath, candidatePaths) {
+	switch (code) {
+		case CommandResolutionErrorKeys.ambiguous: return `Ambiguous command resolution. Move options after the command name: ${candidatePaths}`;
+		case CommandResolutionErrorKeys.lazySchemaMismatch: return `Lazy command schema mismatch at ${commandPath}. Declare leading options in the lazy definition or move options after the command name.`;
+		default: return "The options do not identify a consistent command. Move options after the command name.";
+	}
+}
+function createLazySchemaMismatchError(commandPath, loadedPath) {
+	const expected = [...commandPath];
+	const actual = [...loadedPath];
+	return new CommandResolutionError(`Lazy command schema mismatch at ${expected.join(" ")}. Declare leading options in the lazy definition or move options after the command name.`, {
+		code: CommandResolutionErrorKeys.lazySchemaMismatch,
+		values: {
+			commandPath: expected.join(" "),
+			loadedCommandPath: actual.join(" ")
+		},
+		commandPath: expected,
+		candidatePaths: [expected, actual]
+	});
+}
+function createCommandNotFoundError(resolved) {
+	const commandName = resolved.unresolvedCommandName || resolved.commandName || "";
+	return new CommandNotFoundError(`Command not found: ${commandName}`, {
+		code: CommandNotFoundErrorKeys.notFound,
+		values: { commandName },
+		commandName,
+		candidates: [...resolved.parentSubCommands?.keys() || []],
+		commandPath: resolved.parentCommandPath || []
+	});
+}
+function resolveEntryName(entry) {
+	return isLazyCommand(entry) ? entry.commandName || "(anonymous)" : entry.name || "(anonymous)";
+}
+function getPluginExtensions(plugins) {
+	const extensions = create();
+	for (const plugin of plugins) if (plugin.extension) {
+		const key = plugin.id;
+		if (extensions[key]) console.warn(`Plugin "${key}" is already installed. Ignore it for command context extending.`);
+		else extensions[key] = plugin.extension;
+	}
+	return extensions;
+}
+async function executeCommand(cmd, ctx, decorators) {
+	const commandRunner = cmd.run || NOOP;
+	const baseRunner = (ctx) => {
+		if (hasPriorityValidationError(ctx.validationError)) throw ctx.validationError;
+		return commandRunner(ctx);
+	};
+	const decoratedRunner = decorators.reduceRight((runner, decorator) => decorator(runner), baseRunner);
+	try {
+		if (ctx.env.onBeforeCommand) await ctx.env.onBeforeCommand(ctx);
+		const result = await decoratedRunner(ctx);
+		if (ctx.env.onAfterCommand) await ctx.env.onAfterCommand(ctx, result);
+		return typeof result === "string" ? result : void 0;
+	} catch (error) {
+		if (ctx.env.onErrorCommand) try {
+			await ctx.env.onErrorCommand(ctx, error);
+		} catch (hookError) {
+			console.error("Error in onErrorCommand hook:", hookError);
+		}
+		throw error;
+	}
+}
+//#endregion
+//#region node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/bone.js
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Run the command.
+*
+* @typeParam G - A type extending {@linkcode GunshiParams} to specify the shape of command and cli options.
+*
+* @param args - Command line arguments
+* @param entry - A {@link Command | entry command}, an {@link CommandRunner | inline command runner}, or a {@link LazyCommand | lazily-loaded command}
+* @param options - A {@link CliOptions | CLI options}
+* @returns A rendered usage or undefined. if you will use {@linkcode CliOptions.usageSilent} option, it will return rendered usage string.
+*/
+async function cli(args, entry, options = {}) {
+	return cliCore(args, entry, options, []);
+}
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+//#endregion
+//#region node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/definition.js
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* Define a {@link Command | command}.
+*
+* @typeParam G - A {@link GunshiParamsConstraint} type
+*
+* @param definition - A {@link Command | command} definition
+* @returns A defined {@link Command | command}
+*/
+function define(definition) {
+	return definition;
+}
+/**
+* Define a {@link LazyCommand | lazy command} with or without definition.
+*
+* @param loader - A {@link CommandLoader | command loader} function that returns a command definition
+* @param definition - An optional {@link Command | command} definition. Its `name` may be omitted,
+*   including when the lazy command is used as the CLI entry command.
+* @returns A {@link LazyCommand | lazy command} that can be executed later
+*/
+function lazy(loader, definition) {
+	let lazyCommand = loader;
+	if ((definition != null || !("commandName" in lazyCommand)) && !Object.isExtensible(lazyCommand)) lazyCommand = Object.assign(() => loader(), loader);
+	if (definition == null && !("commandName" in lazyCommand)) lazyCommand.commandName = void 0;
+	if (definition != null) {
+		lazyCommand.commandName = definition.name;
+		lazyCommand.description = definition.description;
+		lazyCommand.args = definition.args;
+		lazyCommand.examples = definition.examples;
+		lazyCommand.internal = definition.internal;
+		lazyCommand.entry = definition.entry;
+		lazyCommand.toKebab = definition.toKebab;
+		lazyCommand.rendering = definition.rendering;
+		if (definition.subCommands) lazyCommand.subCommands = definition.subCommands;
+		if ("resource" in definition) lazyCommand.resource = definition.resource;
+	}
+	return lazyCommand;
+}
+//#endregion
+//#region node_modules/.bun/gunshi@1.0.0-rc.1/node_modules/gunshi/lib/plugin-Fea3gCnT.js
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+/**
+* @author kazuya kawaguchi (a.k.a. kazupon)
+* @license MIT
+*/
+//#endregion
 //#region src/capture/resolve-capture-dir.ts
 function resolveCaptureDir(capture, host) {
 	return capture.dir ?? join(resolveXDGDir(host, "state"), "captures");
@@ -73,7 +2632,6 @@ async function writeOwnerFile(path, text, flag) {
 //#endregion
 //#region src/config/build-jev-only-config.ts
 function buildJevOnlyConfig(config) {
-	if (config.provider.protocol !== "system-one") return null;
 	const judge = config.judge === void 0 || config.judge === null ? config.judge : {
 		...config.judge,
 		timeoutMs: Math.min(config.judge.timeoutMs, CLI_LIMITS.judgeMs)
@@ -95,6 +2653,117 @@ function resolveShippedModDir(startDir = import.meta.dirname) {
 	return modDir;
 }
 //#endregion
+//#region src/process/start-detached-process.ts
+function startDetachedProcess(file, args, env) {
+	const child = spawn(file, args, {
+		detached: true,
+		stdio: "ignore",
+		env
+	});
+	child.on("error", () => {});
+	child.unref();
+}
+//#endregion
+//#region src/judge/judge-server-response-schema.ts
+const judgeServerResponseSchema = discriminatedUnion("kind", [strictObject({
+	kind: literal("reply"),
+	text: string(),
+	model: string(),
+	safetyStops: number().nullable(),
+	fallback: boolean(),
+	warm: boolean().nullable()
+}), strictObject({
+	kind: literal("failure"),
+	aborted: boolean(),
+	message: string()
+})]);
+//#endregion
+//#region src/judge/make-judge-server-session.ts
+function makeJudgeServerSession(target) {
+	return {
+		review: async (model, request, signal) => {
+			const answer = await sendLine(await tryConnectOrStartServer(target, signal), `${JSON.stringify({
+				model,
+				timeoutMs: target.timeoutMs,
+				...request
+			})}\n`, signal);
+			const response = judgeServerResponseSchema.parse(JSON.parse(answer));
+			if (response.kind === "failure") throw response.aborted ? new DOMException(response.message, "AbortError") : new Error(response.message);
+			const { kind: _kind, ...reply } = response;
+			return reply;
+		},
+		stop: () => {}
+	};
+}
+const START_WAIT_MS = 1e4;
+const START_POLL_MS = 25;
+async function tryConnectOrStartServer(target, signal) {
+	const existing = await tryConnect(target.socketPath);
+	if (existing !== null) return existing;
+	const [file, ...args] = target.command;
+	startDetachedProcess(file, [
+		...args,
+		"judge-server",
+		target.socketPath
+	], target.env);
+	const deadline = Date.now() + START_WAIT_MS;
+	while (Date.now() < deadline) {
+		await setTimeout(START_POLL_MS, void 0, { signal });
+		const socket = await tryConnect(target.socketPath);
+		if (socket !== null) return socket;
+	}
+	throw new Error("the judge server did not start");
+}
+function tryConnect(socketPath) {
+	return new Promise((resolve) => {
+		const socket = connect(socketPath);
+		socket.once("connect", () => {
+			socket.off("error", onError);
+			resolve(socket);
+		});
+		const onError = () => {
+			resolve(null);
+		};
+		socket.once("error", onError);
+	});
+}
+function sendLine(socket, line, signal) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		const onAbort = () => {
+			socket.destroy();
+			reject(new DOMException("Judge review aborted", "AbortError"));
+		};
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+		socket.on("data", (chunk) => {
+			chunks.push(chunk);
+		});
+		socket.once("error", (error) => {
+			signal.removeEventListener("abort", onAbort);
+			reject(error);
+		});
+		socket.once("end", () => {
+			signal.removeEventListener("abort", onAbort);
+			socket.destroy();
+			resolve(Buffer.concat(chunks).toString("utf8").trim());
+		});
+		socket.write(line);
+	});
+}
+//#endregion
+//#region src/judge/resolve-judge-socket-path.ts
+function resolveJudgeSocketPath(host, sessionID, entry) {
+	const runtime = host.env["XDG_RUNTIME_DIR"];
+	const dir = runtime === void 0 || runtime === "" ? join(resolveXDGDir(host, "state"), "judge") : join(runtime, "auto-mode");
+	const build = statSync(entry, { throwIfNoEntry: false });
+	const name = createHash("sha256").update(`${sessionID}\0${entry}\0${String(build?.mtimeMs ?? 0)}`).digest("hex").slice(0, 24);
+	return join(dir, `judge-${name}.sock`);
+}
+//#endregion
 //#region src/scope/read-pull-request.ts
 const LOOKUP_TIMEOUT_MS = 5e3;
 const MAX_LOOKUP_OUTPUT_BYTES = 65536;
@@ -345,11 +3014,11 @@ async function isBranchCreatedSince(commonDir, branch, since) {
 }
 //#endregion
 //#region src/record-scope.ts
-async function recordScope(request, config, options = {}) {
-	const host = options.host ?? readHostEnvironment();
+async function recordScope(request, config, runtime) {
+	const host = runtime.host;
 	if (!Object.values(config.scopeSources ?? DEFAULT_SCOPE_SOURCES).some((source) => source.kind === "session")) return EMPTY_SESSION_SCOPE;
 	return await updateSessionScope(request, {
-		now: options.now ?? Date.now(),
+		now: runtime.now(),
 		stateDir: resolveXDGDir(host, "state"),
 		home: host.home,
 		env: host.env,
@@ -419,6 +3088,7 @@ Usage:
   auto-mode print-prompt     Print the system prompt the classifier receives
   auto-mode record           Read a finished Bash call on stdin, add what it created to the session's scope
   auto-mode mod-path         Print the directory of the Claude Code mod this package ships
+  auto-mode judge-server <socket>  Serve one agent session's judge reviews on a unix socket
 
 Options:
   --classifier <path>   Use this framework file instead of the shipped one
@@ -428,78 +3098,147 @@ Options:
   --jev-only            With run: require Jev and cap its API timeout at 5 seconds
   --evaluation-deadline <unix-ms>  With --jev-only: share the helper and API deadline
 `;
+const CLI_ARGS = {
+	classifier: { type: "string" },
+	rules: { type: "string" },
+	explain: { type: "boolean" },
+	"local-only": { type: "boolean" },
+	"jev-only": { type: "boolean" },
+	"evaluation-deadline": { type: "string" },
+	help: {
+		type: "boolean",
+		short: "h"
+	}
+};
+const COMMANDS = /* @__PURE__ */ new Map([
+	["run", (io, values) => runClassification(io, values)],
+	["print-prompt", (io, values) => printPrompt(io, values)],
+	["record", (io) => runRecord(io)],
+	["mod-path", (io) => printModPath(io)],
+	["judge-server", (io, _values, positionals) => runJudgeServer(io, positionals[0])]
+]);
 async function runCLI(argv, io) {
-	const args = tryParseCLIArgs(argv);
-	if (args instanceof Error) {
-		io.stderr.write(`auto-mode: ${args.message}\n\n${USAGE}`);
+	let exitCode = 0;
+	const subCommands = Object.fromEntries([...COMMANDS].map(([name, runCommand]) => [name, lazy(() => async (ctx) => {
+		exitCode = ctx.values.help === true ? printUsage(io.stdout) : await runCommand(io, ctx.values, [...ctx.positionals.slice(ctx.commandPath.length), ...ctx.rest]);
+	}, {
+		name,
+		args: CLI_ARGS
+	})]));
+	const entry = define({
+		name: "auto-mode",
+		args: CLI_ARGS,
+		run: async (ctx) => {
+			exitCode = await runCommandAfterTerminator(io, ctx.values, ctx.rest);
+		}
+	});
+	try {
+		await cli([...argv], entry, {
+			subCommands,
+			strict: true,
+			onBeforeCommand: requireValidCommandLine
+		});
+	} catch (error) {
+		if (!isUsageError(error)) throw error;
+		io.stderr.write(`auto-mode: ${formatUsageError(error)}\n\n${USAGE}`);
 		return 2;
 	}
-	const [command] = args.positionals;
-	if (args.values.help === true || command === void 0) {
-		io.stdout.write(USAGE);
-		return 0;
+	return exitCode;
+}
+function runCommandAfterTerminator(io, values, rest) {
+	const [command, ...positionals] = rest;
+	if (values.help === true || command === void 0) return Promise.resolve(printUsage(io.stdout));
+	const runCommand = COMMANDS.get(command);
+	if (runCommand === void 0) {
+		io.stderr.write(`auto-mode: unknown command '${command}'\n\n${USAGE}`);
+		return Promise.resolve(2);
 	}
-	if (command === "run") try {
-		return await run(io, args.values.explain === true, args.values["local-only"] === true, args.values["jev-only"] === true, args.values["evaluation-deadline"]);
+	return runCommand(io, values, positionals);
+}
+function printUsage(stdout) {
+	stdout.write(USAGE);
+	return 0;
+}
+async function runClassification(io, values) {
+	try {
+		return await run(io, {
+			explain: values.explain === true,
+			localOnly: values["local-only"] === true,
+			jevOnly: values["jev-only"] === true,
+			deadline: values["evaluation-deadline"]
+		});
 	} catch {
 		io.stderr.write("auto-mode: configuration unreadable; no verdict\n");
 		return 0;
 	}
-	if (command === "record") return runRecord(io);
-	if (command === "print-prompt") {
-		const config = await loadConfig(void 0, io.host);
-		printWarnings(io.stderr, config.warnings);
-		const framework = config.provider.protocol === "system-one" ? "decision.md" : "classifier.md";
-		const prompt = await loadPolicy({
-			classifierPath: args.values.classifier ?? config.classifierPath,
-			rulesPath: args.values.rules ?? config.rulesPath
-		}, framework);
-		io.stdout.write(`${prompt}\n`);
-		return 0;
-	}
-	if (command === "mod-path") try {
+}
+async function printPrompt(io, values) {
+	const config = await loadConfig(void 0, io.runtime.host);
+	printWarnings(io.stderr, config.warnings);
+	const prompt = await loadPolicy({
+		classifierPath: values.classifier ?? config.classifierPath,
+		rulesPath: values.rules ?? config.rulesPath
+	}, "decision.md");
+	io.stdout.write(`${prompt}\n`);
+	return 0;
+}
+function printModPath(io) {
+	try {
 		io.stdout.write(`${resolveShippedModDir()}\n`);
-		return 0;
+		return Promise.resolve(0);
 	} catch (error) {
 		io.stderr.write(`auto-mode: ${error instanceof Error ? error.message : String(error)}\n`);
-		return 1;
+		return Promise.resolve(1);
 	}
-	io.stderr.write(`auto-mode: unknown command '${command}'\n\n${USAGE}`);
-	return 2;
 }
-function tryParseCLIArgs(argv) {
-	try {
-		return parseArgs({
-			args: [...argv],
-			allowPositionals: true,
-			options: {
-				classifier: { type: "string" },
-				rules: { type: "string" },
-				explain: { type: "boolean" },
-				"local-only": { type: "boolean" },
-				"jev-only": { type: "boolean" },
-				"evaluation-deadline": { type: "string" },
-				help: {
-					type: "boolean",
-					short: "h"
-				}
-			}
-		});
-	} catch (error) {
-		return error instanceof Error ? error : new Error(String(error));
+function requireValidCommandLine(ctx) {
+	if (ctx.validationError !== void 0) throw ctx.validationError;
+}
+function isUsageError(error) {
+	return error instanceof AggregateError && error.errors.every((reason) => isArgsValidationError(reason) || isCommandNotFoundError(reason) || isCommandResolutionError(reason));
+}
+function formatUsageError(error) {
+	return error.errors.map((reason) => {
+		if (isCommandNotFoundError(reason)) return `unknown command '${reason.commandName}'`;
+		return reason instanceof Error ? reason.message : String(reason);
+	}).join("\n");
+}
+function buildJudgeServerSession(io, config, sessionID) {
+	const judge = config.judge ?? null;
+	if (io.judgeServerCommand === void 0 || judge === null || pickJudgeLane(judge).transport !== "agent-sdk") return;
+	const command = io.judgeServerCommand;
+	const entry = command[1] ?? command[0];
+	return makeJudgeServerSession({
+		socketPath: resolveJudgeSocketPath(io.runtime.host, sessionID, entry),
+		command: io.judgeServerCommand,
+		env: io.runtime.host.env,
+		timeoutMs: judge.timeoutMs
+	});
+}
+async function runJudgeServer(io, socketPath) {
+	if (socketPath === void 0) {
+		io.stderr.write(`auto-mode: judge-server needs a socket path\n\n${USAGE}`);
+		return 2;
 	}
+	await (await (await import("./start-judge-server-CCSZbTwM.js")).startJudgeServer({
+		socketPath,
+		env: io.runtime.host.env,
+		idleMs: JUDGE_IDLE_MS
+	}))?.closed;
+	return 0;
 }
-async function run(io, explain, localOnly, jevOnly, deadline) {
+const JUDGE_IDLE_MS = 9e5;
+async function run(io, options) {
 	const raw = await io.stdin();
 	let body;
 	try {
 		body = JSON.parse(raw);
 	} catch {
-		return printNote(io.stderr, explain, "stdin is not JSON, so no verdict");
+		return printNote(io.stderr, options.explain, "stdin is not JSON, so no verdict");
 	}
 	const request = parseActionRequest(body);
-	if (request === null) return printNote(io.stderr, explain, "not an action request this classifier judges, so no verdict");
-	const host = io.host;
+	if (request === null) return printNote(io.stderr, options.explain, "not an action request this classifier judges, so no verdict");
+	const host = io.runtime.host;
 	let loaded;
 	try {
 		loaded = await loadConfig(void 0, host);
@@ -508,29 +3247,26 @@ async function run(io, explain, localOnly, jevOnly, deadline) {
 		return printNote(io.stderr, true, "configuration unreadable; no verdict");
 	}
 	printWarnings(io.stderr, loaded.warnings);
-	const config = jevOnly ? buildJevOnlyConfig(loaded) : loaded;
-	if (config === null) {
-		await writeActionFailure(request, host, io.stderr);
-		return printNote(io.stderr, true, "Jev-only evaluation requires system-one; no verdict");
-	}
-	const deadlineAt = deadline === void 0 ? void 0 : Number(deadline);
-	if (deadlineAt !== void 0 && (!jevOnly || !Number.isSafeInteger(deadlineAt) || deadlineAt <= 0)) {
+	const config = options.jevOnly ? buildJevOnlyConfig(loaded) : loaded;
+	const deadlineAt = options.deadline === void 0 ? void 0 : Number(options.deadline);
+	if (deadlineAt !== void 0 && (!options.jevOnly || !Number.isSafeInteger(deadlineAt) || deadlineAt <= 0)) {
 		await writeActionFailure(request, host, io.stderr);
 		return printNote(io.stderr, true, "invalid Jev evaluation deadline; no verdict");
 	}
 	const controller = new AbortController();
-	const unsubscribe = jevOnly ? io.subscribeToStopSignals(() => {
+	const unsubscribe = options.jevOnly ? io.subscribeToStopSignals(() => {
 		controller.abort();
 	}) : null;
 	try {
 		const outcome = await classifyAction(request, config, {
-			localOnly,
+			localOnly: options.localOnly,
 			deadlineAt,
 			signal: controller.signal,
-			host,
+			runtime: io.runtime,
 			stderr: io.stderr,
 			budget: true,
-			actionLog: true
+			actionLog: true,
+			judgeSession: buildJudgeServerSession(io, config, request.sessionID)
 		});
 		if (outcome.verdict !== null) printVerdict(io.stdout, outcome.verdict);
 		if (config.capture?.enabled === true) {
@@ -544,7 +3280,7 @@ async function run(io, explain, localOnly, jevOnly, deadline) {
 			});
 			printCaptureNote(io.stderr, captured);
 		}
-		return printNote(io.stderr, explain || outcome.unavailable === true, outcome.note);
+		return printNote(io.stderr, options.explain || outcome.unavailable === true, outcome.note);
 	} finally {
 		unsubscribe?.();
 	}
@@ -574,7 +3310,7 @@ async function runRecord(io) {
 	const request = parseScopeRecordRequest(body);
 	if (request === null) return 0;
 	try {
-		await recordScope(request, await loadConfig(void 0, io.host), { host: io.host });
+		await recordScope(request, await loadConfig(void 0, io.runtime.host), io.runtime);
 	} catch {
 		io.stderr.write("auto-mode: session scope unavailable\n");
 	}
@@ -586,7 +3322,7 @@ process.exitCode = await runCLI(process.argv.slice(2), {
 	stdin: () => text(process.stdin),
 	stdout: process.stdout,
 	stderr: process.stderr,
-	host: readHostEnvironment(),
+	runtime: readRuntime(),
 	subscribeToStopSignals: (onStop) => {
 		process.on("SIGTERM", onStop);
 		process.on("SIGINT", onStop);
@@ -594,7 +3330,8 @@ process.exitCode = await runCLI(process.argv.slice(2), {
 			process.off("SIGTERM", onStop);
 			process.off("SIGINT", onStop);
 		};
-	}
+	},
+	judgeServerCommand: [process.execPath, import.meta.filename]
 });
 //#endregion
 export {};