politty 0.4.15 → 0.5.0

package/dist/completion-Ca5ESJlG.js

@@ -1,1844 +0,0 @@
-import { c as resolveSubCommandMeta, h as arg, i as resolveSubCommandAlias, l as extractFields, p as toCamelCase } from "./subcommand-router-ENeCymvX.js";
-import { z } from "zod";
-import { execSync } from "node:child_process";
-
-//#region src/core/command.ts
-function defineCommand(config) {
-	return {
-		name: config.name,
-		description: config.description,
-		aliases: config.aliases,
-		args: config.args,
-		subCommands: config.subCommands,
-		setup: config.setup,
-		run: config.run,
-		cleanup: config.cleanup,
-		notes: config.notes,
-		examples: config.examples
-	};
-}
-/**
-* Create a typed defineCommand factory with pre-bound global args type.
-* This is the recommended pattern for type-safe global options.
-*
-* @example
-* ```ts
-* // global-args.ts
-* type GlobalArgsType = { verbose: boolean; config?: string };
-* export const defineAppCommand = createDefineCommand<GlobalArgsType>();
-*
-* // commands/build.ts
-* export const buildCommand = defineAppCommand({
-*   name: "build",
-*   args: z.object({ output: arg(z.string().default("dist")) }),
-*   run: (args) => {
-*     args.verbose; // typed via GlobalArgsType
-*     args.output;  // typed via local args
-*   },
-* });
-* ```
-*/
-function createDefineCommand() {
-	return defineCommand;
-}
-
-//#endregion
-//#region src/completion/value-completion-resolver.ts
-/**
-* Resolve value completion from field metadata
-*
-* Priority:
-* 1. Explicit custom completion (choices or shellCommand)
-* 2. Explicit completion type (file, directory, none)
-* 3. Auto-detected enum values from schema
-*/
-function resolveValueCompletion(field) {
-	const meta = field.completion;
-	if (meta?.custom) {
-		if (meta.custom.choices && meta.custom.choices.length > 0) return {
-			type: "choices",
-			choices: meta.custom.choices
-		};
-		if (meta.custom.shellCommand) return {
-			type: "command",
-			shellCommand: meta.custom.shellCommand
-		};
-	}
-	if (meta?.type) {
-		if (meta.type === "file") {
-			if (meta.matcher) return {
-				type: "file",
-				matcher: meta.matcher
-			};
-			if (meta.extensions) return {
-				type: "file",
-				extensions: meta.extensions
-			};
-			return { type: "file" };
-		}
-		if (meta.type === "directory") return { type: "directory" };
-		if (meta.type === "none") return { type: "none" };
-	}
-	if (field.enumValues && field.enumValues.length > 0) return {
-		type: "choices",
-		choices: field.enumValues
-	};
-}
-
-//#endregion
-//#region src/completion/extractor.ts
-/**
-* Extract completion data from commands
-*/
-/**
-* Sanitize a name for use as a shell function/variable identifier.
-* Replaces any character that is not alphanumeric or underscore with underscore.
-*
-* Note: This is not injective -- distinct names may produce the same output
-* (e.g., "foo-bar" and "foo_bar" both become "foo_bar"). When used for nested
-* path encoding (`path.map(sanitize).join("_")`), cross-level collisions are
-* theoretically possible (e.g., "foo-bar:baz" vs "foo:bar-baz") but extremely
-* unlikely in real CLI designs. If collision-safety is needed, sanitize must be
-* replaced with an injective encoding.
-*/
-function sanitize(name) {
-	return name.replace(/[^a-zA-Z0-9_]/g, "_");
-}
-/**
-* Filter subcommands to only visible (non-internal) ones.
-* Internal subcommands start with "__" and are hidden from completion/help.
-*/
-function getVisibleSubs(subs) {
-	return subs.filter((s) => !s.name.startsWith("__"));
-}
-/**
-* Get all completable subcommand names including aliases.
-* Returns an array of { name, description } for all visible subcommands
-* and their aliases.
-*/
-function getSubNamesWithAliases(subs) {
-	const result = [];
-	for (const sub of getVisibleSubs(subs)) {
-		result.push({
-			name: sub.name,
-			description: sub.description
-		});
-		if (sub.aliases) for (const alias of sub.aliases) result.push({
-			name: alias,
-			description: sub.description
-		});
-	}
-	return result;
-}
-/**
-* Convert a resolved field to a completable option
-*/
-function fieldToOption(field) {
-	return {
-		name: field.name,
-		cliName: field.cliName,
-		alias: field.alias,
-		description: field.description,
-		takesValue: field.type !== "boolean",
-		valueType: field.type,
-		required: field.required,
-		valueCompletion: resolveValueCompletion(field)
-	};
-}
-/**
-* Extract options from a command's args schema
-*/
-function extractOptions$1(command) {
-	if (!command.args) return [];
-	return extractFields(command.args).fields.filter((field) => !field.positional).map(fieldToOption);
-}
-/**
-* Extract positional arguments from a command
-*/
-function extractPositionals(command) {
-	if (!command.args) return [];
-	return extractFields(command.args).fields.filter((field) => field.positional);
-}
-/**
-* Extract completable positional arguments from a command
-*/
-function extractCompletablePositionals(command) {
-	if (!command.args) return [];
-	return extractFields(command.args).fields.filter((field) => field.positional).map((field, index) => ({
-		name: field.name,
-		cliName: field.cliName,
-		position: index,
-		description: field.description,
-		required: field.required,
-		variadic: field.type === "array",
-		valueCompletion: resolveValueCompletion(field)
-	}));
-}
-/**
-* Extract a completable subcommand from a command
-*/
-function extractSubcommand(name, command) {
-	const subcommands = [];
-	if (command.subCommands) for (const [subName, subCommand] of Object.entries(command.subCommands)) {
-		const resolved = resolveSubCommandMeta(subCommand);
-		if (resolved) subcommands.push(extractSubcommand(subName, resolved));
-		else subcommands.push({
-			name: subName,
-			description: "(lazy loaded)",
-			subcommands: [],
-			options: [],
-			positionals: []
-		});
-	}
-	return {
-		name,
-		description: command.description,
-		aliases: command.aliases,
-		subcommands,
-		options: extractOptions$1(command),
-		positionals: extractCompletablePositionals(command)
-	};
-}
-/** Join parent and child with a separator, omitting separator when parent is empty. */
-function joinPrefix(parent, child, sep) {
-	return parent ? `${parent}${sep}${child}` : child;
-}
-/**
-* Collect opt-takes-value case entries for a subcommand tree.
-* Used by bash and zsh generators (identical case syntax: `path:--opt) return 0 ;;`).
-* parentPath is a colon-delimited path (e.g., "" for root, "workspace:user" for nested).
-*/
-function optTakesValueEntries(sub, parentPath) {
-	const lines = [];
-	for (const opt of sub.options) if (opt.takesValue) {
-		const patterns = [`${parentPath}:--${opt.cliName}`];
-		if (opt.alias) for (const a of opt.alias) patterns.push(`${parentPath}:${a.length === 1 ? `-${a}` : `--${a}`}`);
-		lines.push(`        ${patterns.join("|")}) return 0 ;;`);
-	}
-	for (const child of getVisibleSubs(sub.subcommands)) {
-		lines.push(...optTakesValueEntries(child, joinPrefix(parentPath, child.name, ":")));
-		if (child.aliases) for (const alias of child.aliases) lines.push(...optTakesValueEntries(child, joinPrefix(parentPath, alias, ":")));
-	}
-	return lines;
-}
-/**
-* Recursively collect all subcommand route entries.
-* Returns entries used by all shell generators for both dispatch routing
-* and subcommand lookup (is_subcmd) tables.
-* Aliases are mapped to the same handler as the canonical name.
-*/
-function collectRouteEntries(sub, parentPath = "", parentFunc = "") {
-	const entries = [];
-	for (const child of getVisibleSubs(sub.subcommands)) {
-		const pathStr = joinPrefix(parentPath, child.name, ":");
-		const funcSuffix = joinPrefix(parentFunc, sanitize(child.name), "_");
-		entries.push(...collectRouteEntries(child, pathStr, funcSuffix));
-		entries.push({
-			pathStr,
-			funcSuffix,
-			lookupPattern: `${parentPath}:${child.name}`
-		});
-		if (child.aliases) for (const alias of child.aliases) {
-			const aliasPathStr = joinPrefix(parentPath, alias, ":");
-			entries.push(...collectRouteEntries(child, aliasPathStr, funcSuffix));
-			entries.push({
-				pathStr: aliasPathStr,
-				funcSuffix,
-				lookupPattern: `${parentPath}:${alias}`
-			});
-		}
-	}
-	return entries;
-}
-/**
-* Generate is_subcmd case/switch body lines (bash/zsh case syntax).
-* Returns lines for the case statement body only (caller wraps in function).
-*/
-function isSubcmdCaseLines(routeEntries) {
-	return routeEntries.map((r) => `        ${r.lookupPattern}) return 0 ;;`);
-}
-/**
-* Recursively merge global options into a subcommand and all its descendants.
-* Avoids duplicates by checking existing option names.
-*/
-function propagateGlobalOptions(sub, globalOptions) {
-	const existingNames = new Set(sub.options.map((o) => o.name));
-	const newOpts = globalOptions.filter((o) => !existingNames.has(o.name));
-	sub.options = [...sub.options, ...newOpts];
-	for (const child of sub.subcommands) propagateGlobalOptions(child, globalOptions);
-}
-/**
-* Extract completion data from a command tree
-*
-* @param command - The root command
-* @param programName - Program name for completion scripts
-* @param globalArgsSchema - Optional global args schema. When provided, global options
-*   are derived from this schema instead of the root command's options.
-*/
-function extractCompletionData(command, programName, globalArgsSchema) {
-	const rootSubcommand = extractSubcommand(programName, command);
-	let globalOptions;
-	if (globalArgsSchema) {
-		globalOptions = extractFields(globalArgsSchema).fields.filter((field) => !field.positional).map(fieldToOption);
-		propagateGlobalOptions(rootSubcommand, globalOptions);
-	} else globalOptions = rootSubcommand.options;
-	return {
-		command: rootSubcommand,
-		programName,
-		globalOptions
-	};
-}
-
-//#endregion
-//#region src/completion/bash.ts
-/** Escape a string for use inside bash double-quotes */
-function escapeBashDQ(s) {
-	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$").replace(/`/g, "\\`");
-}
-/**
-* Generate bash value completion code for a ValueCompletion spec.
-* Returns an array of bash lines.
-*/
-function bashValueLines(vc, inline) {
-	if (!vc) return [];
-	switch (vc.type) {
-		case "choices": {
-			const items = vc.choices.map((c) => `"${escapeBashDQ(c)}"`).join(" ");
-			if (inline) return [
-				`local -a _choices=(${items})`,
-				`COMPREPLY=()`,
-				`local _c; for _c in "\${_choices[@]}"; do [[ "$_c" == "$_cur"* ]] && COMPREPLY+=("\${_inline_prefix}\${_c}"); done`,
-				`compopt -o nospace`,
-				`compopt +o default 2>/dev/null`
-			];
-			return [
-				`local -a _choices=(${items})`,
-				`COMPREPLY=()`,
-				`local _c; for _c in "\${_choices[@]}"; do [[ "$_c" == "$_cur"* ]] && COMPREPLY+=("$_c"); done`,
-				`compopt +o default 2>/dev/null`
-			];
-		}
-		case "file":
-			if (vc.matcher?.length) return bashFileFilter(vc.matcher.map((p) => `[[ "\${_f##*/}" == ${p} ]]`).join(" || "), inline);
-			if (vc.extensions?.length) return bashFileFilter(vc.extensions.map((ext) => `[[ "$_f" == *".${ext}" ]]`).join(" || "), inline);
-			if (inline) return [
-				`local -a _entries=($(compgen -f -- "$_cur"))`,
-				`COMPREPLY=("\${_entries[@]/#/$_inline_prefix}")`,
-				`compopt -o filenames`
-			];
-			return [`COMPREPLY=($(compgen -f -- "$_cur"))`, `compopt -o filenames`];
-		case "directory":
-			if (inline) return [
-				`local -a _dirs=($(compgen -d -- "$_cur"))`,
-				`COMPREPLY=("\${_dirs[@]/#/$_inline_prefix}")`,
-				`compopt -o filenames`
-			];
-			return [`COMPREPLY=($(compgen -d -- "$_cur"))`, `compopt -o filenames`];
-		case "command": {
-			const cmd = vc.shellCommand;
-			if (inline) return [`COMPREPLY=($(compgen -P "$_inline_prefix" -W "$(${cmd})" -- "$_cur"))`];
-			return [`COMPREPLY=($(compgen -W "$(${cmd})" -- "$_cur"))`];
-		}
-		case "none": return [`compopt +o default 2>/dev/null`];
-	}
-}
-function bashFileFilter(checks, inline) {
-	const prefix = inline ? `"\${_inline_prefix}$_f"` : `"$_f"`;
-	return [
-		`local -a _all_entries=($(compgen -f -- "$_cur"))`,
-		`for _f in "\${_all_entries[@]}"; do`,
-		`    if [[ -d "$_f" ]]; then`,
-		`        COMPREPLY+=(${prefix})`,
-		`    elif ${checks}; then`,
-		`        COMPREPLY+=(${prefix})`,
-		`    fi`,
-		`done`,
-		`compopt -o filenames`,
-		`compopt +o default 2>/dev/null`
-	];
-}
-/** Collect value-taking option patterns for case matching */
-function optionValueCases$2(options, inline) {
-	const lines = [];
-	for (const opt of options) {
-		if (!opt.takesValue || !opt.valueCompletion) continue;
-		const valLines = bashValueLines(opt.valueCompletion, inline);
-		if (valLines.length === 0) continue;
-		const patterns = [`--${opt.cliName}`];
-		if (opt.alias) for (const a of opt.alias) patterns.push(a.length === 1 ? `-${a}` : `--${a}`);
-		const patternStr = patterns.join("|");
-		lines.push(`            ${patternStr})`);
-		for (const vl of valLines) lines.push(`                ${vl}`);
-		lines.push(`                return ;;`);
-	}
-	return lines;
-}
-/** Generate positional completion block */
-function positionalBlock$2(positionals) {
-	if (positionals.length === 0) return [];
-	const lines = [];
-	lines.push(`    case "$_pos_count" in`);
-	for (const pos of positionals) {
-		if (pos.variadic) lines.push(`        ${pos.position}|*)`);
-		else lines.push(`        ${pos.position})`);
-		for (const vl of bashValueLines(pos.valueCompletion, false)) lines.push(`            ${vl}`);
-		lines.push(`            ;;`);
-	}
-	lines.push(`    esac`);
-	return lines;
-}
-/** Generate prev/inline value completion blocks for options */
-function valueCompletionBlocks(options) {
-	if (!options.some((o) => o.takesValue && o.valueCompletion)) return [];
-	const lines = [];
-	const prevCases = optionValueCases$2(options, false);
-	if (prevCases.length > 0) {
-		lines.push(`    if [[ -z "$_inline_prefix" ]]; then`);
-		lines.push(`        case "$_prev" in`);
-		lines.push(...prevCases);
-		lines.push(`        esac`);
-		lines.push(`    fi`);
-	}
-	const inlineCases = optionValueCases$2(options, true);
-	if (inlineCases.length > 0) {
-		lines.push(`    if [[ -n "$_inline_prefix" ]]; then`);
-		lines.push(`        case "\${_inline_prefix%=}" in`);
-		lines.push(...inlineCases);
-		lines.push(`        esac`);
-		lines.push(`    fi`);
-	}
-	return lines;
-}
-/** Generate available-options list lines */
-function availableOptionLines$2(options, fn) {
-	const lines = [];
-	for (const opt of options) if (opt.valueType === "array") lines.push(`        _avail+=(--${opt.cliName})`);
-	else {
-		const patterns = [`"--${opt.cliName}"`];
-		if (opt.alias) for (const a of opt.alias) patterns.push(a.length === 1 ? `"-${a}"` : `"--${a}"`);
-		lines.push(`        __${fn}_not_used ${patterns.join(" ")} && _avail+=(--${opt.cliName})`);
-	}
-	lines.push(`        __${fn}_not_used "--help" && _avail+=(--help)`);
-	return lines;
-}
-/**
-* Generate a per-subcommand completion function.
-* Recursively generates functions for nested subcommands.
-*/
-function generateSubHandler$2(sub, fn, path) {
-	const fullPath = [...path, sub.name];
-	const funcName = `__${fn}_complete_${fullPath.map(sanitize).join("_")}`;
-	const visibleSubs = getVisibleSubs(sub.subcommands);
-	const lines = [];
-	for (const child of visibleSubs) lines.push(...generateSubHandler$2(child, fn, fullPath));
-	lines.push(`${funcName}() {`);
-	lines.push(...valueCompletionBlocks(sub.options));
-	const fullPathStr = fullPath.join(":");
-	lines.push(`    if [[ -z "$_inline_prefix" ]] && __${fn}_opt_takes_value "${fullPathStr}" "$_prev"; then return; fi`);
-	lines.push(`    if [[ -n "$_inline_prefix" ]] && __${fn}_opt_takes_value "${fullPathStr}" "\${_inline_prefix%=}"; then return; fi`);
-	if (sub.positionals.length > 0) {
-		lines.push(`    if (( _after_dd )); then`);
-		lines.push(...positionalBlock$2(sub.positionals).map((l) => `    ${l}`));
-		lines.push(`        return`);
-		lines.push(`    fi`);
-	} else lines.push(`    if (( _after_dd )); then return; fi`);
-	lines.push(`    if [[ "$_cur" == -* ]]; then`);
-	lines.push(`        local -a _avail=()`);
-	lines.push(...availableOptionLines$2(sub.options, fn));
-	lines.push(`        COMPREPLY=($(compgen -W "\${_avail[*]}" -- "$_cur"))`);
-	lines.push(`        compopt +o default 2>/dev/null`);
-	lines.push(`        return`);
-	lines.push(`    fi`);
-	if (visibleSubs.length > 0) {
-		const subNames = getSubNamesWithAliases(sub.subcommands).map((s) => s.name).join(" ");
-		lines.push(`    COMPREPLY=($(compgen -W "${subNames}" -- "$_cur"))`);
-		lines.push(`    compopt +o default 2>/dev/null`);
-	} else if (sub.positionals.length > 0) lines.push(...positionalBlock$2(sub.positionals));
-	lines.push(`}`);
-	lines.push(``);
-	return lines;
-}
-function generateBashCompletion(command, options) {
-	const { programName } = options;
-	const data = extractCompletionData(command, programName, options.globalArgsSchema);
-	const fn = sanitize(programName);
-	const root = data.command;
-	const visibleSubs = getVisibleSubs(root.subcommands);
-	const lines = [];
-	lines.push(`# Bash completion for ${programName}`);
-	lines.push(`# Generated by politty`);
-	lines.push(``);
-	lines.push(`__${fn}_not_used() {`);
-	lines.push(`    for _u in "\${_used_opts[@]}"; do`);
-	lines.push(`        for _chk in "$@"; do`);
-	lines.push(`            [[ "$_u" == "$_chk" ]] && return 1`);
-	lines.push(`        done`);
-	lines.push(`    done`);
-	lines.push(`    return 0`);
-	lines.push(`}`);
-	lines.push(``);
-	lines.push(`__${fn}_opt_takes_value() {`);
-	lines.push(`    case "$1:$2" in`);
-	lines.push(...optTakesValueEntries(root, ""));
-	lines.push(`    esac`);
-	lines.push(`    return 1`);
-	lines.push(`}`);
-	lines.push(``);
-	const routeEntries = collectRouteEntries(root);
-	if (routeEntries.length > 0) {
-		lines.push(`__${fn}_is_subcmd() {`);
-		lines.push(`    case "$1:$2" in`);
-		lines.push(...isSubcmdCaseLines(routeEntries));
-		lines.push(`    esac`);
-		lines.push(`    return 1`);
-		lines.push(`}`);
-		lines.push(``);
-	}
-	for (const sub of visibleSubs) lines.push(...generateSubHandler$2(sub, fn, []));
-	lines.push(`__${fn}_complete_root() {`);
-	lines.push(...valueCompletionBlocks(root.options));
-	lines.push(`    if [[ -z "$_inline_prefix" ]] && __${fn}_opt_takes_value "" "$_prev"; then return; fi`);
-	lines.push(`    if [[ -n "$_inline_prefix" ]] && __${fn}_opt_takes_value "" "\${_inline_prefix%=}"; then return; fi`);
-	if (root.positionals.length > 0) {
-		lines.push(`    if (( _after_dd )); then`);
-		lines.push(...positionalBlock$2(root.positionals).map((l) => `    ${l}`));
-		lines.push(`        return`);
-		lines.push(`    fi`);
-	} else lines.push(`    if (( _after_dd )); then return; fi`);
-	lines.push(`    if [[ "$_cur" == -* ]]; then`);
-	lines.push(`        local -a _avail=()`);
-	lines.push(...availableOptionLines$2(root.options, fn));
-	lines.push(`        COMPREPLY=($(compgen -W "\${_avail[*]}" -- "$_cur"))`);
-	lines.push(`        compopt +o default 2>/dev/null`);
-	if (visibleSubs.length > 0) {
-		lines.push(`    else`);
-		const subNames = getSubNamesWithAliases(root.subcommands).map((s) => s.name).join(" ");
-		lines.push(`        COMPREPLY=($(compgen -W "${subNames}" -- "$_cur"))`);
-		lines.push(`        compopt +o default 2>/dev/null`);
-	} else if (root.positionals.length > 0) {
-		lines.push(`    else`);
-		lines.push(...positionalBlock$2(root.positionals).map((l) => `    ${l}`));
-	}
-	lines.push(`    fi`);
-	lines.push(`}`);
-	lines.push(``);
-	const subRouting = routeEntries.map((r) => `        ${r.pathStr}) __${fn}_complete_${r.funcSuffix} ;;`).join("\n");
-	lines.push(`_${fn}_completions() {`);
-	lines.push(`    COMPREPLY=()`);
-	lines.push(``);
-	lines.push(`    # Rejoin words split by '=' in COMP_WORDBREAKS`);
-	lines.push(`    local -a _words=()`);
-	lines.push(`    local _i=1`);
-	lines.push(`    while (( _i <= COMP_CWORD )); do`);
-	lines.push(`        if [[ "\${COMP_WORDS[_i]}" == "=" && \${#_words[@]} -gt 0 ]]; then`);
-	lines.push(`            _words[\${#_words[@]}-1]+="=\${COMP_WORDS[_i+1]:-}"`);
-	lines.push(`            (( _i += 2 ))`);
-	lines.push(`        else`);
-	lines.push(`            _words+=("\${COMP_WORDS[_i]}")`);
-	lines.push(`            (( _i++ ))`);
-	lines.push(`        fi`);
-	lines.push(`    done`);
-	lines.push(``);
-	lines.push(`    local _cur=""`);
-	lines.push(`    (( \${#_words[@]} > 0 )) && _cur="\${_words[\${#_words[@]}-1]}"`);
-	lines.push(``);
-	lines.push(`    local _inline_prefix=""`);
-	lines.push(`    if [[ "$_cur" == --*=* ]]; then`);
-	lines.push(`        _inline_prefix="\${_cur%%=*}="`);
-	lines.push(`        _cur="\${_cur#*=}"`);
-	lines.push(`    fi`);
-	lines.push(``);
-	lines.push(`    local _prev=""`);
-	lines.push(`    (( \${#_words[@]} > 1 )) && _prev="\${_words[\${#_words[@]}-2]}"`);
-	lines.push(``);
-	lines.push(`    local _subcmd="" _after_dd=0 _pos_count=0 _skip_next=0`);
-	lines.push(`    local -a _used_opts=()`);
-	lines.push(``);
-	lines.push(`    local _j=0`);
-	lines.push(`    while (( _j < \${#_words[@]} - 1 )); do`);
-	lines.push(`        local _w="\${_words[_j]}"`);
-	lines.push(`        if (( _skip_next )); then _skip_next=0; (( _j++ )); continue; fi`);
-	lines.push(`        if [[ "$_w" == "--" ]]; then _after_dd=1; (( _j++ )); continue; fi`);
-	lines.push(`        if (( _after_dd )); then (( _pos_count++ )); (( _j++ )); continue; fi`);
-	lines.push(`        if [[ "$_w" == --*=* ]]; then _used_opts+=("\${_w%%=*}"); (( _j++ )); continue; fi`);
-	lines.push(`        if [[ "$_w" == -* ]]; then`);
-	lines.push(`            _used_opts+=("$_w")`);
-	lines.push(`            __${fn}_opt_takes_value "$_subcmd" "$_w" && _skip_next=1`);
-	lines.push(`            (( _j++ )); continue`);
-	lines.push(`        fi`);
-	if (routeEntries.length > 0) lines.push(`        if __${fn}_is_subcmd "$_subcmd" "$_w"; then _subcmd="\${_subcmd:+\${_subcmd}:}$_w"; _used_opts=(); _pos_count=0; else (( _pos_count++ )); fi`);
-	else lines.push(`        (( _pos_count++ ))`);
-	lines.push(`        (( _j++ ))`);
-	lines.push(`    done`);
-	lines.push(``);
-	lines.push(`    case "$_subcmd" in`);
-	lines.push(subRouting);
-	lines.push(`        *) __${fn}_complete_root ;;`);
-	lines.push(`    esac`);
-	lines.push(`}`);
-	lines.push(``);
-	lines.push(`complete -o default -F _${fn}_completions ${programName}`);
-	lines.push(``);
-	return {
-		script: lines.join("\n"),
-		shell: "bash",
-		installInstructions: `# To enable completions, add the following to your ~/.bashrc:
-
-# Option 1: Source directly
-eval "$(${programName} completion bash)"
-
-# Option 2: Save to a file
-${programName} completion bash > ~/.local/share/bash-completion/completions/${programName}
-
-# Then reload your shell or run:
-source ~/.bashrc`
-	};
-}
-
-//#endregion
-//#region src/completion/dynamic/candidate-generator.ts
-/**
-* Generate completion candidates based on context
-*/
-/**
-* Completion directive flags (bitwise)
-*/
-const CompletionDirective = {
-	Default: 0,
-	NoSpace: 1,
-	NoFileCompletion: 2,
-	FilterPrefix: 4,
-	KeepOrder: 8,
-	FileCompletion: 16,
-	DirectoryCompletion: 32,
-	Error: 64
-};
-/**
-* Generate completion candidates based on context
-*/
-function generateCandidates(context) {
-	const candidates = [];
-	let directive = CompletionDirective.Default;
-	switch (context.completionType) {
-		case "subcommand": return generateSubcommandCandidates(context);
-		case "option-name": return generateOptionNameCandidates(context);
-		case "option-value": return generateOptionValueCandidates(context);
-		case "positional": return generatePositionalCandidates(context);
-		default: return {
-			candidates,
-			directive
-		};
-	}
-}
-/**
-* Execute a shell command and return results as candidates
-*/
-function executeShellCommand(command) {
-	try {
-		return execSync(command, {
-			encoding: "utf-8",
-			timeout: 5e3
-		}).split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => ({
-			value: line,
-			type: "value"
-		}));
-	} catch {
-		return [];
-	}
-}
-/**
-* Resolve value completion, executing shell commands and file lookups in JS
-*/
-function resolveValueCandidates(vc, candidates, _currentWord, description) {
-	let directive = CompletionDirective.FilterPrefix;
-	let fileExtensions;
-	let fileMatchers;
-	switch (vc.type) {
-		case "choices":
-			if (vc.choices) for (const choice of vc.choices) candidates.push({
-				value: choice,
-				description,
-				type: "value"
-			});
-			directive |= CompletionDirective.NoFileCompletion;
-			break;
-		case "file":
-			if (vc.matcher && vc.matcher.length > 0) {
-				fileMatchers = vc.matcher.filter((m) => m.trim().length > 0);
-				if (fileMatchers.length === 0) {
-					fileMatchers = void 0;
-					directive |= CompletionDirective.FileCompletion;
-				}
-			} else if (vc.extensions && vc.extensions.length > 0) {
-				fileExtensions = Array.from(new Set(vc.extensions.map((ext) => ext.trim().replace(/^\./, "")).filter((ext) => ext.length > 0)));
-				if (fileExtensions.length === 0) {
-					fileExtensions = void 0;
-					directive |= CompletionDirective.FileCompletion;
-				}
-			} else directive |= CompletionDirective.FileCompletion;
-			break;
-		case "directory":
-			directive |= CompletionDirective.DirectoryCompletion;
-			break;
-		case "command":
-			if (vc.shellCommand) candidates.push(...executeShellCommand(vc.shellCommand));
-			directive |= CompletionDirective.NoFileCompletion;
-			break;
-		case "none":
-			directive |= CompletionDirective.NoFileCompletion;
-			break;
-	}
-	return {
-		directive,
-		fileExtensions,
-		fileMatchers
-	};
-}
-/**
-* Generate subcommand candidates
-*/
-function generateSubcommandCandidates(context) {
-	const candidates = [];
-	let directive = CompletionDirective.FilterPrefix;
-	for (const name of context.subcommands) {
-		let description;
-		const sub = context.currentCommand.subCommands?.[name];
-		if (sub) description = resolveSubCommandMeta(sub)?.description;
-		else {
-			const canonical = resolveSubCommandAlias(context.currentCommand, name);
-			if (canonical) {
-				const resolved = context.currentCommand.subCommands?.[canonical];
-				if (resolved) description = resolveSubCommandMeta(resolved)?.description;
-			}
-		}
-		candidates.push({
-			value: name,
-			description,
-			type: "subcommand"
-		});
-	}
-	if (candidates.length === 0 || context.currentWord.startsWith("-")) {
-		const optionResult = generateOptionNameCandidates(context);
-		candidates.push(...optionResult.candidates);
-	}
-	return {
-		candidates,
-		directive
-	};
-}
-/**
-* Generate option name candidates
-*/
-function generateOptionNameCandidates(context) {
-	const candidates = [];
-	const directive = CompletionDirective.FilterPrefix;
-	const availableOptions = context.options.filter((opt) => {
-		if (opt.valueType === "array") return true;
-		if (context.usedOptions.has(opt.cliName)) return false;
-		if (opt.alias && opt.alias.some((a) => context.usedOptions.has(a))) return false;
-		return true;
-	});
-	for (const opt of availableOptions) candidates.push({
-		value: `--${opt.cliName}`,
-		description: opt.description,
-		type: "option"
-	});
-	if (!context.usedOptions.has("help")) candidates.push({
-		value: "--help",
-		description: "Show help information",
-		type: "option"
-	});
-	return {
-		candidates,
-		directive
-	};
-}
-/**
-* Generate option value candidates
-*/
-function generateOptionValueCandidates(context) {
-	const candidates = [];
-	if (!context.targetOption) return {
-		candidates,
-		directive: CompletionDirective.FilterPrefix
-	};
-	const vc = context.targetOption.valueCompletion;
-	if (!vc) return {
-		candidates,
-		directive: CompletionDirective.FilterPrefix
-	};
-	return {
-		candidates,
-		...resolveValueCandidates(vc, candidates, context.currentWord)
-	};
-}
-/**
-* Generate positional argument candidates
-*/
-function generatePositionalCandidates(context) {
-	const candidates = [];
-	const positionalIndex = context.positionalIndex ?? 0;
-	const positional = context.positionals[positionalIndex] ?? (context.positionals.at(-1)?.variadic ? context.positionals.at(-1) : void 0);
-	if (!positional) return {
-		candidates,
-		directive: CompletionDirective.FilterPrefix
-	};
-	const vc = positional.valueCompletion;
-	if (!vc) return {
-		candidates,
-		directive: CompletionDirective.FilterPrefix
-	};
-	return {
-		candidates,
-		...resolveValueCandidates(vc, candidates, context.currentWord, positional.description)
-	};
-}
-
-//#endregion
-//#region src/completion/dynamic/context-parser.ts
-/**
-* Parse completion context from partial command line
-*/
-/**
-* Extract options from a command
-*/
-function extractOptions(command) {
-	if (!command.args) return [];
-	return extractFields(command.args).fields.filter((field) => !field.positional).map((field) => ({
-		name: field.name,
-		cliName: field.cliName,
-		alias: field.alias,
-		description: field.description,
-		takesValue: field.type !== "boolean",
-		valueType: field.type,
-		required: field.required,
-		valueCompletion: resolveValueCompletion(field)
-	}));
-}
-/**
-* Extract positionals from a command
-*/
-function extractPositionalsForContext(command) {
-	if (!command.args) return [];
-	return extractFields(command.args).fields.filter((field) => field.positional).map((field, index) => ({
-		name: field.name,
-		cliName: field.cliName,
-		position: index,
-		description: field.description,
-		required: field.required,
-		variadic: field.type === "array",
-		valueCompletion: resolveValueCompletion(field)
-	}));
-}
-/**
-* Get subcommand names from a command (including aliases)
-*/
-function getSubcommandNames(command) {
-	if (!command.subCommands) return [];
-	const names = [];
-	for (const [name, subCmd] of Object.entries(command.subCommands)) {
-		if (name.startsWith("__")) continue;
-		names.push(name);
-		const meta = resolveSubCommandMeta(subCmd);
-		if (meta?.aliases) names.push(...meta.aliases);
-	}
-	return names;
-}
-/**
-* Resolve subcommand by name (including alias lookup)
-*/
-function resolveSubcommand(command, name) {
-	if (!command.subCommands) return null;
-	const sub = command.subCommands[name];
-	if (sub) return resolveSubCommandMeta(sub);
-	const canonical = resolveSubCommandAlias(command, name);
-	if (canonical) return resolveSubCommandMeta(command.subCommands[canonical]);
-	return null;
-}
-/**
-* Check if a word is an option (starts with - or --)
-*/
-function isOption(word) {
-	return word.startsWith("-");
-}
-/**
-* Parse option name from word (e.g., "--foo=bar" -> "foo", "-v" -> "v")
-*/
-function parseOptionName(word) {
-	if (word.startsWith("--")) {
-		const withoutPrefix = word.slice(2);
-		const eqIndex = withoutPrefix.indexOf("=");
-		return eqIndex >= 0 ? withoutPrefix.slice(0, eqIndex) : withoutPrefix;
-	}
-	if (word.startsWith("-")) return word.slice(1, 2);
-	return word;
-}
-/**
-* Check if option has inline value (e.g., "--foo=bar")
-*/
-function hasInlineValue(word) {
-	return word.includes("=");
-}
-/**
-* Find option by name or alias
-*/
-function findOption(options, nameOrAlias) {
-	return options.find((opt) => {
-		if (opt.cliName === nameOrAlias) return true;
-		if (opt.alias?.includes(nameOrAlias)) return true;
-		if (nameOrAlias.length > 1) {
-			if (opt.cliName.includes("-") && toCamelCase(opt.cliName) === nameOrAlias) return true;
-			if (opt.alias?.some((a) => a.includes("-") && toCamelCase(a) === nameOrAlias)) return true;
-		}
-		return false;
-	});
-}
-/**
-* Parse completion context from command line arguments
-*
-* @param argv - Arguments after the program name (e.g., ["build", "--fo"])
-* @param rootCommand - The root command
-* @returns Completion context
-*/
-function parseCompletionContext(argv, rootCommand) {
-	let currentCommand = rootCommand;
-	const subcommandPath = [];
-	const usedOptions = /* @__PURE__ */ new Set();
-	let positionalCount = 0;
-	let i = 0;
-	let options = extractOptions(currentCommand);
-	let afterDoubleDash = false;
-	while (i < argv.length - 1) {
-		const word = argv[i];
-		if (!afterDoubleDash && word === "--") {
-			afterDoubleDash = true;
-			i++;
-			continue;
-		}
-		if (!afterDoubleDash && isOption(word)) {
-			const optName = parseOptionName(word);
-			const opt = findOption(options, optName);
-			if (opt) {
-				usedOptions.add(opt.cliName);
-				if (opt.alias) for (const a of opt.alias) usedOptions.add(a);
-				if (opt.takesValue && !hasInlineValue(word)) i++;
-			}
-			i++;
-			continue;
-		}
-		const subcommand = afterDoubleDash ? null : resolveSubcommand(currentCommand, word);
-		if (subcommand) {
-			subcommandPath.push(word);
-			currentCommand = subcommand;
-			options = extractOptions(currentCommand);
-			usedOptions.clear();
-			positionalCount = 0;
-			i++;
-			continue;
-		}
-		positionalCount++;
-		i++;
-	}
-	const currentWord = argv[argv.length - 1] ?? "";
-	const previousWord = argv[argv.length - 2] ?? "";
-	const positionals = extractPositionalsForContext(currentCommand);
-	const subcommands = getSubcommandNames(currentCommand);
-	let completionType;
-	let targetOption;
-	let positionalIndex;
-	if (!afterDoubleDash && previousWord && isOption(previousWord) && !hasInlineValue(previousWord)) {
-		const optName = parseOptionName(previousWord);
-		const opt = findOption(options, optName);
-		if (opt && opt.takesValue) {
-			completionType = "option-value";
-			targetOption = opt;
-		} else if (currentWord.startsWith("-")) completionType = "option-name";
-		else {
-			completionType = determineDefaultCompletionType(currentWord, subcommands, positionals, positionalCount);
-			if (completionType === "positional") positionalIndex = positionalCount;
-		}
-	} else if (!afterDoubleDash && currentWord.startsWith("--") && hasInlineValue(currentWord)) {
-		const optName = parseOptionName(currentWord);
-		const opt = findOption(options, optName);
-		if (opt && opt.takesValue) {
-			completionType = "option-value";
-			targetOption = opt;
-		} else completionType = "option-name";
-	} else if (!afterDoubleDash && currentWord.startsWith("-")) completionType = "option-name";
-	else {
-		completionType = determineDefaultCompletionType(currentWord, subcommands, positionals, positionalCount, afterDoubleDash);
-		if (completionType === "positional") positionalIndex = positionalCount;
-	}
-	return {
-		subcommandPath,
-		currentCommand,
-		currentWord,
-		previousWord,
-		completionType,
-		targetOption,
-		positionalIndex,
-		options,
-		subcommands,
-		positionals,
-		usedOptions,
-		providedPositionalCount: positionalCount
-	};
-}
-/**
-* Determine default completion type when not completing an option
-*/
-function determineDefaultCompletionType(currentWord, subcommands, positionals, positionalCount, afterDoubleDash) {
-	if (afterDoubleDash) return "positional";
-	if (subcommands.length > 0) {
-		if (subcommands.filter((s) => s.startsWith(currentWord)).length > 0 || currentWord === "") return "subcommand";
-	}
-	if (positionalCount < positionals.length) return "positional";
-	if (positionals.length > 0 && positionals[positionals.length - 1].variadic) return "positional";
-	return "subcommand";
-}
-
-//#endregion
-//#region src/completion/dynamic/shell-formatter.ts
-/**
-* Format completion candidates for the specified shell
-*
-* @returns Shell-ready output string (lines separated by newline, last line is :directive)
-*/
-function formatForShell(result, options) {
-	switch (options.shell) {
-		case "bash": return formatForBash(result, options);
-		case "zsh": return formatForZsh(result, options);
-		case "fish": return formatForFish(result, options);
-	}
-}
-/**
-* Check if the FilterPrefix directive is set
-*/
-function shouldFilterPrefix(directive) {
-	return (directive & CompletionDirective.FilterPrefix) !== 0;
-}
-/**
-* Filter candidates by prefix
-*/
-function filterByPrefix(candidates, prefix) {
-	if (!prefix) return candidates;
-	return candidates.filter((c) => c.value.startsWith(prefix));
-}
-/**
-* Append extension metadata and directive to output lines
-*/
-function appendMetadata(lines, result) {
-	if (result.fileExtensions && result.fileExtensions.length > 0) lines.push(`@ext:${result.fileExtensions.join(",")}`);
-	if (result.fileMatchers && result.fileMatchers.length > 0) lines.push(`@matcher:${result.fileMatchers.join(",")}`);
-	lines.push(`:${result.directive}`);
-}
-/**
-* Format for bash
-*
-* - Pre-filters candidates by currentWord prefix (replaces compgen -W)
-* - Handles --opt=value inline values by prepending prefix
-* - Outputs plain values only (no descriptions - bash COMPREPLY doesn't support them)
-* - Last line: :directive
-*/
-function formatForBash(result, options) {
-	let { candidates } = result;
-	if (shouldFilterPrefix(result.directive)) candidates = filterByPrefix(candidates, options.currentWord);
-	const lines = candidates.map((c) => {
-		if (options.inlinePrefix) return `${options.inlinePrefix}${c.value}`;
-		return c.value;
-	});
-	appendMetadata(lines, result);
-	return lines.join("\n");
-}
-/**
-* Format for zsh
-*
-* - Outputs value:description pairs for _describe
-* - Colons in values/descriptions are escaped with backslash
-* - Last line: :directive
-*/
-function formatForZsh(result, _options) {
-	const lines = result.candidates.map((c) => {
-		const escapedValue = c.value.replace(/:/g, "\\:");
-		if (c.description) return `${escapedValue}:${c.description.replace(/:/g, "\\:")}`;
-		return escapedValue;
-	});
-	appendMetadata(lines, result);
-	return lines.join("\n");
-}
-/**
-* Format for fish
-*
-* - Outputs value\tdescription pairs
-* - Last line: :directive
-*/
-function formatForFish(result, _options) {
-	const lines = result.candidates.map((c) => {
-		if (c.description) return `${c.value}\t${c.description}`;
-		return c.value;
-	});
-	appendMetadata(lines, result);
-	return lines.join("\n");
-}
-
-//#endregion
-//#region src/completion/dynamic/complete-command.ts
-/**
-* Dynamic completion command implementation
-*
-* This creates a hidden `__complete` command that outputs completion candidates
-* for shell scripts to consume. Usage:
-*
-*   mycli __complete --shell bash -- build --fo
-*   mycli __complete --shell zsh -- plugin add
-*
-* Output format depends on the target shell:
-*   bash: plain values (pre-filtered by prefix), last line :directive
-*   zsh:  value:description pairs, last line :directive
-*   fish: value\tdescription pairs, last line :directive
-*/
-/**
-* Detect inline option-value prefix (e.g., "--format=" from "--format=json")
-*/
-function detectInlinePrefix(currentWord) {
-	if (currentWord.startsWith("--") && currentWord.includes("=")) return currentWord.slice(0, currentWord.indexOf("=") + 1);
-}
-/**
-* Schema for the __complete command
-*/
-const completeArgsSchema = z.object({
-	shell: arg(z.enum([
-		"bash",
-		"zsh",
-		"fish"
-	]), { description: "Target shell for output formatting" }),
-	args: arg(z.array(z.string()).default([]), {
-		positional: true,
-		description: "Arguments to complete",
-		variadic: true
-	})
-});
-/**
-* Create the dynamic completion command
-*
-* @param rootCommand - The root command to generate completions for
-* @param programName - The program name (optional, defaults to rootCommand.name)
-* @returns A command that outputs completion candidates
-*/
-function createDynamicCompleteCommand(rootCommand, _programName) {
-	return defineCommand({
-		name: "__complete",
-		args: completeArgsSchema,
-		run(args) {
-			const context = parseCompletionContext(args.args, rootCommand);
-			const result = generateCandidates(context);
-			const inlinePrefix = detectInlinePrefix(context.currentWord);
-			const output = formatForShell(result, {
-				shell: args.shell,
-				currentWord: inlinePrefix ? context.currentWord.slice(inlinePrefix.length) : context.currentWord,
-				inlinePrefix
-			});
-			console.log(output);
-		}
-	});
-}
-/**
-* Check if a command tree contains the __complete command
-*/
-function hasCompleteCommand(command) {
-	return Boolean(command.subCommands?.["__complete"]);
-}
-
-//#endregion
-//#region src/completion/fish.ts
-/** Escape shell-special characters for fish double-quoted strings */
-function escapeDesc$1(s) {
-	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$");
-}
-/**
-* Generate fish value completion lines for a ValueCompletion spec.
-* Each line outputs candidates via echo (tab-separated value\tdescription).
-*/
-function fishValueLines(vc) {
-	if (!vc) return [];
-	switch (vc.type) {
-		case "choices": return vc.choices.map((c) => `echo "${escapeDesc$1(c)}"`);
-		case "file":
-			if (vc.matcher?.length) return fishMatcherLines(vc.matcher);
-			if (vc.extensions?.length) return fishExtensionLines(vc.extensions);
-			return [`__fish_complete_path "$_cur"`];
-		case "directory": return [`__fish_complete_directories "$_cur"`];
-		case "command": return [
-			`for _v in (${vc.shellCommand})`,
-			`    echo "$_v"`,
-			`end`
-		];
-		case "none": return [];
-	}
-}
-/** Generate fish matcher-filtered file completion */
-function fishMatcherLines(patterns) {
-	return [
-		`__fish_complete_directories "$_cur"`,
-		`set -l _dir ""`,
-		`if string match -q '*/*' "$_cur"`,
-		`    set _dir (string replace -r '[^/]*$' '' "$_cur")`,
-		`end`,
-		...patterns.flatMap((p) => [
-			`for _f in "$_dir"${p}`,
-			`    test -f "$_f"; and string match -q "$_cur*" "$_f"; and echo "$_f"`,
-			`end`
-		])
-	];
-}
-/** Generate fish extension-filtered file completion */
-function fishExtensionLines(extensions) {
-	const lines = [];
-	lines.push(`__fish_complete_directories "$_cur"`);
-	for (const ext of extensions) {
-		lines.push(`for _f in "$_cur"*.${ext}`);
-		lines.push(`    test -f "$_f"; and echo "$_f"`);
-		lines.push(`end`);
-	}
-	return lines;
-}
-/** Generate option-value switch cases for fish */
-function optionValueCases$1(options) {
-	const lines = [];
-	for (const opt of options) {
-		if (!opt.takesValue || !opt.valueCompletion) continue;
-		const valLines = fishValueLines(opt.valueCompletion);
-		if (valLines.length === 0) continue;
-		const conditions = [`test "$_prev" = "--${opt.cliName}"`];
-		if (opt.alias) for (const a of opt.alias) conditions.push(`test "$_prev" = "${a.length === 1 ? `-${a}` : `--${a}`}"`);
-		const cond = conditions.join("; or ");
-		lines.push(`    if ${cond}`);
-		for (const vl of valLines) lines.push(`        ${vl}`);
-		lines.push(`        return`);
-		lines.push(`    end`);
-	}
-	return lines;
-}
-/** Generate positional completion block for fish */
-function positionalBlock$1(positionals) {
-	if (positionals.length === 0) return [];
-	const lines = [];
-	for (const pos of positionals) {
-		const valLines = fishValueLines(pos.valueCompletion);
-		if (valLines.length === 0) continue;
-		if (pos.variadic) lines.push(`    if test $_pos_count -ge ${pos.position}`);
-		else lines.push(`    if test $_pos_count -eq ${pos.position}`);
-		for (const vl of valLines) lines.push(`        ${vl}`);
-		lines.push(`        return`);
-		lines.push(`    end`);
-	}
-	return lines;
-}
-/** Generate available-option echo lines for fish */
-function availableOptionLines$1(options, fn) {
-	const lines = [];
-	for (const opt of options) {
-		const desc = escapeDesc$1(opt.description ?? "");
-		if (opt.valueType === "array") lines.push(`        echo "--${opt.cliName}\t${desc}"`);
-		else {
-			const checks = [`"--${opt.cliName}"`];
-			if (opt.alias) for (const a of opt.alias) checks.push(a.length === 1 ? `"-${a}"` : `"--${a}"`);
-			lines.push(`        __${fn}_not_used ${checks.join(" ")}; and echo "--${opt.cliName}\t${desc}"`);
-		}
-	}
-	lines.push(`        __${fn}_not_used "--help"; and echo "--help\tShow help"`);
-	return lines;
-}
-/** Generate value-option completion block if any value-taking options exist */
-function valueCompletionBlock$1(options) {
-	if (!options.some((o) => o.takesValue && o.valueCompletion)) return [];
-	return optionValueCases$1(options);
-}
-/**
-* Generate a per-subcommand completion function for fish.
-* Recursively generates functions for nested subcommands.
-*/
-function generateSubHandler$1(sub, fn, path) {
-	const fullPath = [...path, sub.name];
-	const funcName = `__${fn}_complete_${fullPath.map(sanitize).join("_")}`;
-	const visibleSubs = getVisibleSubs(sub.subcommands);
-	const lines = [];
-	for (const child of visibleSubs) lines.push(...generateSubHandler$1(child, fn, fullPath));
-	lines.push(`function ${funcName} --no-scope-shadowing`);
-	lines.push(...valueCompletionBlock$1(sub.options));
-	const fullPathStr = fullPath.join(":");
-	lines.push(`    if __${fn}_opt_takes_value "${fullPathStr}" "$_prev"; return; end`);
-	if (sub.positionals.length > 0) {
-		lines.push(`    if test $_after_dd -eq 1`);
-		lines.push(...positionalBlock$1(sub.positionals).map((l) => `    ${l}`));
-		lines.push(`        return`);
-		lines.push(`    end`);
-	} else lines.push(`    if test $_after_dd -eq 1; return; end`);
-	lines.push(`    if string match -q -- '-*' "$_cur"`);
-	lines.push(...availableOptionLines$1(sub.options, fn));
-	lines.push(`        return`);
-	lines.push(`    end`);
-	if (visibleSubs.length > 0) for (const s of getSubNamesWithAliases(sub.subcommands)) {
-		const desc = escapeDesc$1(s.description ?? "");
-		lines.push(`    echo "${s.name}\t${desc}"`);
-	}
-	else if (sub.positionals.length > 0) lines.push(...positionalBlock$1(sub.positionals));
-	lines.push(`end`);
-	lines.push(``);
-	return lines;
-}
-/** Generate opt-takes-value entries for fish switch cases */
-function optTakesValueCases(sub, parentPath) {
-	const lines = [];
-	for (const opt of sub.options) if (opt.takesValue) {
-		const patterns = [`"${parentPath}:--${opt.cliName}"`];
-		if (opt.alias) for (const a of opt.alias) patterns.push(`"${parentPath}:${a.length === 1 ? `-${a}` : `--${a}`}"`);
-		lines.push(`        case ${patterns.join(" ")}`);
-		lines.push(`            return 0`);
-	}
-	for (const child of getVisibleSubs(sub.subcommands)) {
-		const childPath = parentPath ? `${parentPath}:${child.name}` : child.name;
-		lines.push(...optTakesValueCases(child, childPath));
-		if (child.aliases) for (const alias of child.aliases) {
-			const aliasPath = parentPath ? `${parentPath}:${alias}` : alias;
-			lines.push(...optTakesValueCases(child, aliasPath));
-		}
-	}
-	return lines;
-}
-function generateFishCompletion(command, options) {
-	const { programName } = options;
-	const data = extractCompletionData(command, programName, options.globalArgsSchema);
-	const fn = sanitize(programName);
-	const root = data.command;
-	const visibleSubs = getVisibleSubs(root.subcommands);
-	const lines = [];
-	lines.push(`# Fish completion for ${programName}`);
-	lines.push(`# Generated by politty`);
-	lines.push(``);
-	lines.push(`function __${fn}_not_used --no-scope-shadowing`);
-	lines.push(`    for _chk in $argv`);
-	lines.push(`        if contains -- "$_chk" $_used_opts`);
-	lines.push(`            return 1`);
-	lines.push(`        end`);
-	lines.push(`    end`);
-	lines.push(`    return 0`);
-	lines.push(`end`);
-	lines.push(``);
-	lines.push(`function __${fn}_opt_takes_value`);
-	lines.push(`    switch "$argv[1]:$argv[2]"`);
-	lines.push(...optTakesValueCases(root, ""));
-	lines.push(`    end`);
-	lines.push(`    return 1`);
-	lines.push(`end`);
-	lines.push(``);
-	const routeEntries = collectRouteEntries(root);
-	if (routeEntries.length > 0) {
-		lines.push(`function __${fn}_is_subcmd`);
-		lines.push(`    switch "$argv[1]:$argv[2]"`);
-		for (const r of routeEntries) {
-			lines.push(`        case "${r.lookupPattern}"`);
-			lines.push(`            return 0`);
-		}
-		lines.push(`    end`);
-		lines.push(`    return 1`);
-		lines.push(`end`);
-		lines.push(``);
-	}
-	for (const sub of visibleSubs) lines.push(...generateSubHandler$1(sub, fn, []));
-	lines.push(`function __${fn}_complete_root --no-scope-shadowing`);
-	lines.push(...valueCompletionBlock$1(root.options));
-	lines.push(`    if __${fn}_opt_takes_value "" "$_prev"; return; end`);
-	if (root.positionals.length > 0) {
-		lines.push(`    if test $_after_dd -eq 1`);
-		lines.push(...positionalBlock$1(root.positionals).map((l) => `    ${l}`));
-		lines.push(`        return`);
-		lines.push(`    end`);
-	} else lines.push(`    if test $_after_dd -eq 1; return; end`);
-	lines.push(`    if string match -q -- '-*' "$_cur"`);
-	lines.push(...availableOptionLines$1(root.options, fn));
-	if (visibleSubs.length > 0) {
-		lines.push(`    else`);
-		for (const s of getSubNamesWithAliases(root.subcommands)) {
-			const desc = escapeDesc$1(s.description ?? "");
-			lines.push(`        echo "${s.name}\t${desc}"`);
-		}
-	} else if (root.positionals.length > 0) {
-		lines.push(`    else`);
-		lines.push(...positionalBlock$1(root.positionals));
-	}
-	lines.push(`    end`);
-	lines.push(`end`);
-	lines.push(``);
-	lines.push(`function __fish_${fn}_complete`);
-	lines.push(`    set -l _args (commandline -opc)`);
-	lines.push(`    set -e _args[1]`);
-	lines.push(``);
-	lines.push(`    set -l _ct (commandline -ct)`);
-	lines.push(`    if test (count $_ct) -eq 0`);
-	lines.push(`        set -a _args ""`);
-	lines.push(`    else`);
-	lines.push(`        set -a _args $_ct`);
-	lines.push(`    end`);
-	lines.push(``);
-	lines.push(`    set -l _cur ""`);
-	lines.push(`    if test (count $_args) -gt 0`);
-	lines.push(`        set _cur "$_args[-1]"`);
-	lines.push(`    end`);
-	lines.push(``);
-	lines.push(`    set -l _prev ""`);
-	lines.push(`    if test (count $_args) -gt 1`);
-	lines.push(`        set _prev "$_args[-2]"`);
-	lines.push(`    end`);
-	lines.push(``);
-	lines.push(`    set -l _subcmd "" ; set -l _after_dd 0 ; set -l _pos_count 0 ; set -l _skip_next 0`);
-	lines.push(`    set -l _used_opts`);
-	lines.push(``);
-	lines.push(`    set -l _j 1`);
-	lines.push(`    set -l _limit (math (count $_args) - 1)`);
-	lines.push(`    while test $_j -le $_limit`);
-	lines.push(`        set -l _w "$_args[$_j]"`);
-	lines.push(`        if test $_skip_next -eq 1; set _skip_next 0; set _j (math $_j + 1); continue; end`);
-	lines.push(`        if test "$_w" = "--"; set _after_dd 1; set _j (math $_j + 1); continue; end`);
-	lines.push(`        if test $_after_dd -eq 1; set _pos_count (math $_pos_count + 1); set _j (math $_j + 1); continue; end`);
-	lines.push(`        if string match -q -- '--*=*' "$_w"; set -a _used_opts (string replace -r '=.*' '' -- "$_w"); set _j (math $_j + 1); continue; end`);
-	lines.push(`        if string match -q -- '-*' "$_w"`);
-	lines.push(`            set -a _used_opts "$_w"`);
-	lines.push(`            __${fn}_opt_takes_value "$_subcmd" "$_w"; and set _skip_next 1`);
-	lines.push(`            set _j (math $_j + 1); continue`);
-	lines.push(`        end`);
-	if (routeEntries.length > 0) lines.push(`        if __${fn}_is_subcmd "$_subcmd" "$_w"; test -n "$_subcmd"; and set _subcmd "$_subcmd:$_w"; or set _subcmd "$_w"; set _used_opts; set _pos_count 0; else; set _pos_count (math $_pos_count + 1); end`);
-	else lines.push(`        set _pos_count (math $_pos_count + 1)`);
-	lines.push(`        set _j (math $_j + 1)`);
-	lines.push(`    end`);
-	lines.push(``);
-	lines.push(`    switch "$_subcmd"`);
-	for (const r of routeEntries) lines.push(`        case "${r.pathStr}"; __${fn}_complete_${r.funcSuffix}`);
-	lines.push(`        case '*'; __${fn}_complete_root`);
-	lines.push(`    end`);
-	lines.push(`end`);
-	lines.push(``);
-	lines.push(`# Clear existing completions`);
-	lines.push(`complete -e -c ${programName}`);
-	lines.push(``);
-	lines.push(`# Register completion`);
-	lines.push(`complete -c ${programName} -f -a '(__fish_${fn}_complete)'`);
-	lines.push(``);
-	return {
-		script: lines.join("\n"),
-		shell: "fish",
-		installInstructions: `# To enable completions, run one of the following:
-
-# Option 1: Source directly
-${programName} completion fish | source
-
-# Option 2: Save to the fish completions directory
-${programName} completion fish > ~/.config/fish/completions/${programName}.fish
-
-# The completion will be available immediately in new shell sessions.
-# To use in the current session, run:
-source ~/.config/fish/completions/${programName}.fish`
-	};
-}
-
-//#endregion
-//#region src/completion/zsh.ts
-function escapeDesc(s) {
-	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$").replace(/`/g, "\\`").replace(/:/g, "\\:");
-}
-/**
-* Generate zsh value completion lines for a ValueCompletion spec.
-* Uses `_vals` array (must be declared in the calling function scope).
-*/
-function zshValueLines(vc, fn) {
-	if (!vc) return [];
-	switch (vc.type) {
-		case "choices": return [`_vals=(${vc.choices.map((c) => `"${escapeDesc(c)}"`).join(" ")})`, `__${fn}_cdescribe 'completions' _vals`];
-		case "file":
-			if (vc.matcher?.length) return vc.matcher.map((p) => `_files -g "${p}"`);
-			if (vc.extensions?.length) return vc.extensions.map((ext) => `_files -g "*.${ext}"`);
-			return [`_files`];
-		case "directory": return [`_files -/`];
-		case "command": return [`_vals=("\${(@f)$(${vc.shellCommand})}")`, `__${fn}_cdescribe 'completions' _vals`];
-		case "none": return [];
-	}
-}
-/** Generate option-value case branches */
-function optionValueCases(options, fn) {
-	const lines = [];
-	for (const opt of options) {
-		if (!opt.takesValue || !opt.valueCompletion) continue;
-		const valLines = zshValueLines(opt.valueCompletion, fn);
-		if (valLines.length === 0) continue;
-		const patterns = [`--${opt.cliName}`];
-		if (opt.alias) for (const a of opt.alias) patterns.push(a.length === 1 ? `-${a}` : `--${a}`);
-		lines.push(`            ${patterns.join("|")})`);
-		for (const vl of valLines) lines.push(`                ${vl}`);
-		lines.push(`                return 0 ;;`);
-	}
-	return lines;
-}
-/** Generate positional completion block */
-function positionalBlock(positionals, fn) {
-	if (positionals.length === 0) return [];
-	const lines = [];
-	lines.push(`    case "$_pos_count" in`);
-	for (const pos of positionals) {
-		if (pos.variadic) lines.push(`        ${pos.position}|*)`);
-		else lines.push(`        ${pos.position})`);
-		const valLines = zshValueLines(pos.valueCompletion, fn);
-		for (const vl of valLines) lines.push(`            ${vl}`);
-		lines.push(`            ;;`);
-	}
-	lines.push(`    esac`);
-	return lines;
-}
-/** Generate prev-word value completion case block */
-function valueCompletionBlock(options, fn) {
-	if (!options.some((o) => o.takesValue && o.valueCompletion)) return [];
-	const prevCases = optionValueCases(options, fn);
-	if (prevCases.length === 0) return [];
-	return [
-		`    case "\${words[CURRENT-1]}" in`,
-		...prevCases,
-		`    esac`
-	];
-}
-/** Generate available-options list lines */
-function availableOptionLines(options, fn) {
-	const lines = [];
-	for (const opt of options) {
-		const desc = opt.description ? `:${escapeDesc(opt.description)}` : "";
-		if (opt.valueType === "array") lines.push(`        _opts+=("--${opt.cliName}${desc}")`);
-		else {
-			const patterns = [`"--${opt.cliName}"`];
-			if (opt.alias) for (const a of opt.alias) patterns.push(a.length === 1 ? `"-${a}"` : `"--${a}"`);
-			lines.push(`        __${fn}_not_used ${patterns.join(" ")} && _opts+=("--${opt.cliName}${desc}")`);
-		}
-	}
-	lines.push(`        __${fn}_not_used "--help" && _opts+=("--help:Show help")`);
-	return lines;
-}
-/**
-* Generate a per-subcommand completion function.
-* Recursively generates functions for nested subcommands.
-*/
-function generateSubHandler(sub, fn, path) {
-	const fullPath = [...path, sub.name];
-	const funcName = `__${fn}_complete_${fullPath.map(sanitize).join("_")}`;
-	const visibleSubs = getVisibleSubs(sub.subcommands);
-	const lines = [];
-	for (const child of visibleSubs) lines.push(...generateSubHandler(child, fn, fullPath));
-	lines.push(`${funcName}() {`);
-	lines.push(`    local -a _vals=()`);
-	lines.push(...valueCompletionBlock(sub.options, fn));
-	const fullPathStr = fullPath.join(":");
-	lines.push(`    if __${fn}_opt_takes_value "${fullPathStr}" "\${words[CURRENT-1]}"; then return 0; fi`);
-	if (sub.positionals.length > 0) {
-		lines.push(`    if (( _after_dd )); then`);
-		lines.push(...positionalBlock(sub.positionals, fn).map((l) => `    ${l}`));
-		lines.push(`        return 0`);
-		lines.push(`    fi`);
-	} else lines.push(`    if (( _after_dd )); then return 0; fi`);
-	lines.push(`    if [[ "\${words[CURRENT]}" == -* ]]; then`);
-	lines.push(`        local -a _opts=()`);
-	lines.push(...availableOptionLines(sub.options, fn));
-	lines.push(`        __${fn}_cdescribe 'options' _opts`);
-	lines.push(`        return 0`);
-	lines.push(`    fi`);
-	if (visibleSubs.length > 0) {
-		const subItems = getSubNamesWithAliases(sub.subcommands).map((s) => {
-			const desc = s.description ? `:${escapeDesc(s.description)}` : "";
-			return `"${s.name}${desc}"`;
-		}).join(" ");
-		lines.push(`    local -a _subs=(${subItems})`);
-		lines.push(`    __${fn}_cdescribe 'subcommands' _subs`);
-	} else if (sub.positionals.length > 0) lines.push(...positionalBlock(sub.positionals, fn));
-	lines.push(`}`);
-	lines.push(``);
-	return lines;
-}
-function generateZshCompletion(command, options) {
-	const { programName } = options;
-	const data = extractCompletionData(command, programName, options.globalArgsSchema);
-	const fn = sanitize(programName);
-	const root = data.command;
-	const visibleSubs = getVisibleSubs(root.subcommands);
-	const lines = [];
-	lines.push(`#compdef ${programName}`);
-	lines.push(``);
-	lines.push(`# Zsh completion for ${programName}`);
-	lines.push(`# Generated by politty`);
-	lines.push(``);
-	lines.push(`__${fn}_not_used() {`);
-	lines.push(`    local _u _chk`);
-	lines.push(`    for _u in "\${_used_opts[@]}"; do`);
-	lines.push(`        for _chk in "$@"; do`);
-	lines.push(`            [[ "$_u" == "$_chk" ]] && return 1`);
-	lines.push(`        done`);
-	lines.push(`    done`);
-	lines.push(`    return 0`);
-	lines.push(`}`);
-	lines.push(``);
-	lines.push(`__${fn}_cdescribe() {`);
-	lines.push(`    _describe "$@" 2>/dev/null && return 0`);
-	lines.push(`    shift`);
-	lines.push(`    local -a _cd_vals=("\${(@)\${(P)1}%%:*}")`);
-	lines.push(`    compadd -a _cd_vals 2>/dev/null`);
-	lines.push(`    return 0`);
-	lines.push(`}`);
-	lines.push(``);
-	lines.push(`__${fn}_opt_takes_value() {`);
-	lines.push(`    case "$1:$2" in`);
-	lines.push(...optTakesValueEntries(root, ""));
-	lines.push(`    esac`);
-	lines.push(`    return 1`);
-	lines.push(`}`);
-	lines.push(``);
-	const routeEntries = collectRouteEntries(root);
-	if (routeEntries.length > 0) {
-		lines.push(`__${fn}_is_subcmd() {`);
-		lines.push(`    case "$1:$2" in`);
-		lines.push(...isSubcmdCaseLines(routeEntries));
-		lines.push(`    esac`);
-		lines.push(`    return 1`);
-		lines.push(`}`);
-		lines.push(``);
-	}
-	for (const sub of visibleSubs) lines.push(...generateSubHandler(sub, fn, []));
-	lines.push(`__${fn}_complete_root() {`);
-	lines.push(`    local -a _vals=()`);
-	lines.push(...valueCompletionBlock(root.options, fn));
-	lines.push(`    if __${fn}_opt_takes_value "" "\${words[CURRENT-1]}"; then return 0; fi`);
-	if (root.positionals.length > 0) {
-		lines.push(`    if (( _after_dd )); then`);
-		lines.push(...positionalBlock(root.positionals, fn).map((l) => `    ${l}`));
-		lines.push(`        return 0`);
-		lines.push(`    fi`);
-	} else lines.push(`    if (( _after_dd )); then return 0; fi`);
-	lines.push(`    if [[ "\${words[CURRENT]}" == -* ]]; then`);
-	lines.push(`        local -a _opts=()`);
-	lines.push(...availableOptionLines(root.options, fn));
-	lines.push(`        __${fn}_cdescribe 'options' _opts`);
-	if (visibleSubs.length > 0) {
-		lines.push(`    else`);
-		const subItems = getSubNamesWithAliases(root.subcommands).map((s) => {
-			const desc = s.description ? `:${escapeDesc(s.description)}` : "";
-			return `"${s.name}${desc}"`;
-		}).join(" ");
-		lines.push(`        local -a _subs=(${subItems})`);
-		lines.push(`        __${fn}_cdescribe 'subcommands' _subs`);
-	} else if (root.positionals.length > 0) {
-		lines.push(`    else`);
-		lines.push(...positionalBlock(root.positionals, fn).map((l) => `    ${l}`));
-	}
-	lines.push(`    fi`);
-	lines.push(`}`);
-	lines.push(``);
-	const subRouting = routeEntries.map((r) => `        ${r.pathStr}) __${fn}_complete_${r.funcSuffix} ;;`).join("\n");
-	lines.push(`_${fn}() {`);
-	lines.push(`    (( CURRENT )) || CURRENT=\${#words}`);
-	lines.push(``);
-	lines.push(`    local _subcmd="" _after_dd=0 _pos_count=0 _skip_next=0`);
-	lines.push(`    local -a _used_opts=()`);
-	lines.push(``);
-	lines.push(`    local _j=2`);
-	lines.push(`    while (( _j < CURRENT )); do`);
-	lines.push(`        local _w="\${words[_j]}"`);
-	lines.push(`        if (( _skip_next )); then _skip_next=0; (( _j++ )); continue; fi`);
-	lines.push(`        if [[ "$_w" == "--" ]]; then _after_dd=1; (( _j++ )); continue; fi`);
-	lines.push(`        if (( _after_dd )); then (( _pos_count++ )); (( _j++ )); continue; fi`);
-	lines.push(`        if [[ "$_w" == --*=* ]]; then _used_opts+=("\${_w%%=*}"); (( _j++ )); continue; fi`);
-	lines.push(`        if [[ "$_w" == -* ]]; then`);
-	lines.push(`            _used_opts+=("$_w")`);
-	lines.push(`            __${fn}_opt_takes_value "$_subcmd" "$_w" && _skip_next=1`);
-	lines.push(`            (( _j++ )); continue`);
-	lines.push(`        fi`);
-	if (routeEntries.length > 0) lines.push(`        if __${fn}_is_subcmd "$_subcmd" "$_w"; then _subcmd="\${_subcmd:+\${_subcmd}:}$_w"; _used_opts=(); _pos_count=0; else (( _pos_count++ )); fi`);
-	else lines.push(`        (( _pos_count++ ))`);
-	lines.push(`        (( _j++ ))`);
-	lines.push(`    done`);
-	lines.push(``);
-	lines.push(`    case "$_subcmd" in`);
-	lines.push(subRouting);
-	lines.push(`        *) __${fn}_complete_root ;;`);
-	lines.push(`    esac`);
-	lines.push(`}`);
-	lines.push(``);
-	lines.push(`zstyle ':completion:*:*:${programName}:*' file-patterns '%p:globbed-files *(-/):directories'`);
-	lines.push(``);
-	lines.push(`compdef _${fn} ${programName}`);
-	lines.push(``);
-	return {
-		script: lines.join("\n"),
-		shell: "zsh",
-		installInstructions: `# To enable completions, add the following to your ~/.zshrc:
-
-# Option 1: Source directly (add before compinit)
-eval "$(${programName} completion zsh)"
-
-# Option 2: Save to a file in your fpath
-${programName} completion zsh > ~/.zsh/completions/_${programName}
-
-# Make sure your fpath includes the completions directory:
-# fpath=(~/.zsh/completions $fpath)
-# autoload -Uz compinit && compinit
-
-# Then reload your shell or run:
-source ~/.zshrc`
-	};
-}
-
-//#endregion
-//#region src/completion/index.ts
-/**
-* Shell completion generation module
-*
-* Provides utilities to generate shell completion scripts for bash, zsh, and fish.
-*
-* @example
-* ```typescript
-* import { generateCompletion, createCompletionCommand } from "politty/completion";
-*
-* // Generate completion script directly
-* const result = generateCompletion(myCommand, {
-*   shell: "bash",
-*   programName: "mycli"
-* });
-* console.log(result.script);
-*
-* // Or add a completion subcommand to your CLI
-* const mainCommand = withCompletionCommand(
-*   defineCommand({
-*     name: "mycli",
-*     subCommands: { ... },
-*   }),
-* );
-* ```
-*/
-/**
-* Generate completion script for the specified shell
-*/
-function generateCompletion(command, options) {
-	switch (options.shell) {
-		case "bash": return generateBashCompletion(command, options);
-		case "zsh": return generateZshCompletion(command, options);
-		case "fish": return generateFishCompletion(command, options);
-		default: throw new Error(`Unsupported shell: ${options.shell}`);
-	}
-}
-/**
-* Get the list of supported shells
-*/
-function getSupportedShells() {
-	return [
-		"bash",
-		"zsh",
-		"fish"
-	];
-}
-/**
-* Detect the current shell from environment
-*/
-function detectShell() {
-	const shellName = (process.env.SHELL || "").split("/").pop()?.toLowerCase() || "";
-	if (shellName.includes("bash")) return "bash";
-	if (shellName.includes("zsh")) return "zsh";
-	if (shellName.includes("fish")) return "fish";
-	return null;
-}
-/**
-* Schema for the completion command arguments
-*/
-const completionArgsSchema = z.object({
-	shell: arg(z.enum([
-		"bash",
-		"zsh",
-		"fish"
-	]).optional().describe("Shell type (auto-detected if not specified)"), {
-		positional: true,
-		description: "Shell type (bash, zsh, or fish)",
-		placeholder: "SHELL"
-	}),
-	instructions: arg(z.boolean().default(false), {
-		alias: "i",
-		description: "Show installation instructions"
-	})
-});
-/**
-* Create a completion subcommand for your CLI
-*
-* This creates a ready-to-use subcommand that generates completion scripts.
-*
-* @example
-* ```typescript
-* const mainCommand = defineCommand({
-*   name: "mycli",
-*   subCommands: {
-*     completion: createCompletionCommand(mainCommand)
-*   }
-* });
-* ```
-*/
-function createCompletionCommand(rootCommand, programName, globalArgsSchema) {
-	const resolvedProgramName = programName ?? rootCommand.name;
-	if (!rootCommand.subCommands?.__complete) rootCommand.subCommands = {
-		...rootCommand.subCommands,
-		__complete: createDynamicCompleteCommand(rootCommand, resolvedProgramName)
-	};
-	return defineCommand({
-		name: "completion",
-		description: "Generate shell completion script",
-		args: completionArgsSchema,
-		run(args) {
-			const shellType = args.shell || detectShell();
-			if (!shellType) {
-				console.error("Could not detect shell type. Please specify one of: bash, zsh, fish");
-				process.exitCode = 1;
-				return;
-			}
-			const result = generateCompletion(rootCommand, {
-				shell: shellType,
-				programName: resolvedProgramName,
-				includeDescriptions: true,
-				...globalArgsSchema !== void 0 && { globalArgsSchema }
-			});
-			if (args.instructions) console.log(result.installInstructions);
-			else console.log(result.script);
-		}
-	});
-}
-/**
-* Wrap a command with a completion subcommand
-*
-* This avoids circular references that occur when a command references itself
-* in its subCommands (e.g., for completion generation).
-*
-* @param command - The command to wrap
-* @param options - Options including programName
-* @returns A new command with the completion subcommand added
-*
-* @example
-* ```typescript
-* const mainCommand = withCompletionCommand(
-*   defineCommand({
-*     name: "mycli",
-*     subCommands: { ... },
-*   }),
-* );
-* ```
-*/
-function withCompletionCommand(command, options) {
-	const { programName, globalArgsSchema } = typeof options === "string" ? { programName: options } : options ?? {};
-	const wrappedCommand = { ...command };
-	wrappedCommand.subCommands = {
-		...command.subCommands,
-		completion: createCompletionCommand(wrappedCommand, programName, globalArgsSchema),
-		__complete: createDynamicCompleteCommand(wrappedCommand, programName)
-	};
-	return wrappedCommand;
-}
-
-//#endregion
-export { withCompletionCommand as a, formatForShell as c, generateCandidates as d, extractCompletionData as f, defineCommand as g, createDefineCommand as h, getSupportedShells as i, parseCompletionContext as l, resolveValueCompletion as m, detectShell as n, createDynamicCompleteCommand as o, extractPositionals as p, generateCompletion as r, hasCompleteCommand as s, createCompletionCommand as t, CompletionDirective as u };
-//# sourceMappingURL=completion-Ca5ESJlG.js.map