politty 0.4.16 → 0.5.1

package/dist/completion-BlZxMSeU.cjs

@@ -1,2440 +0,0 @@
-const require_log_collector = require('./log-collector-Cd2_mv87.cjs');
-const require_subcommand_router = require('./subcommand-router-DQy0KZU-.cjs');
-let zod = require("zod");
-let node_fs = require("node:fs");
-let node_path = require("node:path");
-let node_child_process = require("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,
-		negation: field.negationDisplay,
-		negationDescription: field.negationDescription,
-		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 require_subcommand_router.extractFields(command.args).fields.filter((field) => !field.positional).map(fieldToOption);
-}
-/**
-* Extract positional arguments from a command
-*/
-function extractPositionals(command) {
-	if (!command.args) return [];
-	return require_subcommand_router.extractFields(command.args).fields.filter((field) => field.positional);
-}
-/**
-* Extract completable positional arguments from a command
-*/
-function extractCompletablePositionals(command) {
-	if (!command.args) return [];
-	return require_subcommand_router.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 = require_subcommand_router.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 = require_subcommand_router.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/header.ts
-/**
-* Static-script header utilities.
-*
-* Every completion script generated by politty starts with a small
-* machine-readable header. The rc loader and the runMain background
-* refresh path use the `# politty-bin-sig:` line to detect when the
-* cached script is stale relative to the binary on disk.
-*/
-/** Schema version of the header itself. Bump when the header layout changes. */
-const COMPLETION_VERSION = 1;
-/**
-* Read the binary's mtime in whole seconds (matches POSIX `stat -c %Y` /
-* BSD `stat -f %m`). Returns `"0"` on failure so the header is always
-* well-formed.
-*/
-function computeBinSig(binPath) {
-	try {
-		return Math.floor((0, node_fs.statSync)(binPath).mtimeMs / 1e3).toString();
-	} catch {
-		return "0";
-	}
-}
-/**
-* Walk `$PATH` looking for an executable named `programName`. Returns
-* the first match's full path, or `null` when not found. We mirror the
-* shell's `command -v <prog>` here so the sig embedded in the header
-* (computed by Node) lines up with what the rc loader stat-checks at
-* runtime — including pnpm/npm bin shims that wrap the real entrypoint.
-* Without this alignment, shimmed installs would never match the
-* embedded sig and the cache would regenerate on every shell startup.
-*/
-function findOnPath(programName) {
-	if (!programName || /[/\\\0]/.test(programName)) return null;
-	const path = process.env.PATH ?? "";
-	for (const dir of path.split(":")) {
-		if (!dir) continue;
-		const candidate = (0, node_path.join)(dir, programName);
-		try {
-			if ((0, node_fs.statSync)(candidate).isFile()) return candidate;
-		} catch {}
-	}
-	return null;
-}
-/**
-* Resolve the binary path used for sig computation and stat checks.
-*
-* Order: explicit override → `$PATH` lookup of `programName` → `process.argv[1]`.
-* The `$PATH` lookup keeps Node-side and shell-side stats pointed at the
-* same shim file when the CLI is invoked through a package-manager bin shim.
-*/
-function resolveBinPath(programName, override) {
-	if (override) return override;
-	return findOnPath(programName) ?? process.argv[1] ?? "";
-}
-/**
-* Build the header lines (no trailing blank line). Returned without a
-* leading `#!` so each generator can prepend its own shebang/compdef
-* marker.
-*/
-function buildHeaderLines(opts) {
-	const sig = computeBinSig(resolveBinPath(opts.programName, opts.binPath));
-	const lines = [
-		`# politty-completion-version: ${1}`,
-		`# politty-bin-sig: ${sig}`,
-		`# program: ${opts.programName}`
-	];
-	if (opts.programVersion) lines.push(`# program-version: ${opts.programVersion}`);
-	lines.push(`# shell: ${opts.shell}`);
-	return lines;
-}
-
-//#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}"`);
-		if (opt.negation) patterns.push(`"--${opt.negation}"`);
-		lines.push(`        __${fn}_not_used ${patterns.join(" ")} && _avail+=(--${opt.cliName})`);
-		if (opt.negation) lines.push(`        __${fn}_not_used ${patterns.join(" ")} && _avail+=(--${opt.negation})`);
-	}
-	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(...buildHeaderLines({
-		programName,
-		shell: "bash",
-		binPath: options.binPath,
-		programVersion: options.programVersion
-	}));
-	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 completion behavior */
-	Default: 0,
-	/** Don't add space after completion */
-	NoSpace: 1,
-	/** Don't offer file completion (even if no other completions) */
-	NoFileCompletion: 2,
-	/** Filter completions using current word as prefix */
-	FilterPrefix: 4,
-	/** Keep the order of completions */
-	KeepOrder: 8,
-	/** Trigger file completion */
-	FileCompletion: 16,
-	/** Trigger directory completion */
-	DirectoryCompletion: 32,
-	/** Error occurred during completion */
-	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 (0, node_child_process.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 = require_subcommand_router.resolveSubCommandMeta(sub)?.description;
-		else {
-			const canonical = require_subcommand_router.resolveSubCommandAlias(context.currentCommand, name);
-			if (canonical) {
-				const resolved = context.currentCommand.subCommands?.[canonical];
-				if (resolved) description = require_subcommand_router.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;
-		if (opt.negation && context.usedOptions.has(opt.negation)) return false;
-		return true;
-	});
-	for (const opt of availableOptions) {
-		candidates.push({
-			value: `--${opt.cliName}`,
-			description: opt.description,
-			type: "option"
-		});
-		if (opt.negation) candidates.push({
-			value: `--${opt.negation}`,
-			description: opt.negationDescription ?? 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 require_subcommand_router.extractFields(command.args).fields.filter((field) => !field.positional).map((field) => ({
-		name: field.name,
-		cliName: field.cliName,
-		alias: field.alias,
-		negation: field.negationDisplay,
-		negationDescription: field.negationDescription,
-		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 require_subcommand_router.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 = require_subcommand_router.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 require_subcommand_router.resolveSubCommandMeta(sub);
-	const canonical = require_subcommand_router.resolveSubCommandAlias(command, name);
-	if (canonical) return require_subcommand_router.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("-") && require_subcommand_router.toCamelCase(opt.cliName) === nameOrAlias) return true;
-			if (opt.alias?.some((a) => a.includes("-") && require_subcommand_router.toCamelCase(a) === nameOrAlias)) return true;
-			if (opt.negation) {
-				if (opt.negation === nameOrAlias) return true;
-				if (opt.negation.includes("-") && require_subcommand_router.toCamelCase(opt.negation) === 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.negation) usedOptions.add(opt.negation);
-				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 = zod.z.object({
-	shell: require_subcommand_router.arg(zod.z.enum([
-		"bash",
-		"zsh",
-		"fish"
-	]), { description: "Target shell for output formatting" }),
-	args: require_subcommand_router.arg(zod.z.array(zod.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 ?? "");
-		const negDesc = opt.negationDescription ? escapeDesc$1(opt.negationDescription) : desc;
-		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}"`);
-			if (opt.negation) checks.push(`"--${opt.negation}"`);
-			lines.push(`        __${fn}_not_used ${checks.join(" ")}; and echo "--${opt.cliName}\t${desc}"`);
-			if (opt.negation) lines.push(`        __${fn}_not_used ${checks.join(" ")}; and echo "--${opt.negation}\t${negDesc}"`);
-		}
-	}
-	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(...buildHeaderLines({
-		programName,
-		shell: "fish",
-		binPath: options.binPath,
-		programVersion: options.programVersion
-	}));
-	lines.push(`# Generated by politty`);
-	lines.push(``);
-	const sig = computeBinSig(resolveBinPath(programName, options.binPath));
-	const refreshFn = `__${fn}_refresh_completion`;
-	lines.push(`function ${refreshFn} --no-scope-shadowing`);
-	lines.push(`    set -l _bin (command -v ${programName})`);
-	lines.push(`    test -z "$_bin"; and return 1`);
-	lines.push(`    set -l _sig (stat -L -c '%Y' "$_bin" 2>/dev/null; or stat -L -f '%m' "$_bin" 2>/dev/null)`);
-	lines.push(`    test "$_sig" = "${sig}"; and return 1`);
-	lines.push(`    set -l _target "$__fish_config_dir/completions/${programName}.fish"`);
-	lines.push(`    "$_bin" __refresh-completion fish 2>/dev/null`);
-	lines.push(`    and source "$_target" 2>/dev/null`);
-	lines.push(`    and return 0`);
-	lines.push(`    return 1`);
-	lines.push(`end`);
-	lines.push(`${refreshFn}`);
-	lines.push(`set -l _politty_refreshed $status`);
-	lines.push(`functions -e ${refreshFn}`);
-	lines.push(`test $_politty_refreshed -eq 0; and return`);
-	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/loader.ts
-/**
-* Rc-loader generators (bash / zsh).
-*
-* These produce the small snippet a user adds once to `~/.bashrc` or
-* `~/.zshrc`. The snippet:
-*
-*   1. Looks up the binary on $PATH.
-*   2. Reads its mtime.
-*   3. If the on-disk completion cache is missing or its
-*      `# politty-bin-sig:` header differs, regenerates the cache by
-*      spawning the binary once.
-*   4. Sources the cache.
-*
-* All failure modes are silent no-ops so a broken / missing CLI never
-* blocks shell startup.
-*/
-/**
-* Single-quote escape: `'` -> `'\''`. Inside single quotes the shell
-* performs no expansion at all, so `$`, backticks, and `$(...)` are
-* inert. Used for hardcoded paths because callers may sources them
-* from env / config — we must not let metachars in the path execute as
-* commands when the rc snippet is sourced.
-*/
-function shSingleQuote(s) {
-	return `'${s.replace(/'/g, "'\\''")}'`;
-}
-function bashCachePathExpr(programName, cacheDir, shell) {
-	if (cacheDir) return shSingleQuote(`${cacheDir}/completion.${shell}`);
-	return `"\${XDG_CACHE_HOME:-$HOME/.cache}/${programName}/completion.${shell}"`;
-}
-function generateBashLoader(opts) {
-	const fn = sanitize(opts.programName);
-	const cache = bashCachePathExpr(opts.programName, opts.cacheDir, "bash");
-	return `__${fn}_load_completion() {
-    local _bin _cache _sig _hdr
-    _bin=$(type -P ${opts.programName} 2>/dev/null)
-    [[ -n "$_bin" ]] || return 0
-    _cache=${cache}
-    _sig=$(stat -L -c '%Y' "$_bin" 2>/dev/null || stat -L -f '%m' "$_bin" 2>/dev/null) || return 0
-    _hdr="# politty-bin-sig: $_sig"
-    if [[ ! -f "$_cache" ]] || ! head -5 "$_cache" 2>/dev/null | grep -qF "$_hdr"; then
-        # Use the hidden __refresh-completion subcommand instead of
-        # \`$_bin completion bash\`: the foreground completion command
-        # is subject to user setup/cleanup/prompt and required
-        # globalArgs validation, which can silently fail or block when
-        # invoked from rc; runMain bypasses those for __-prefixed
-        # internal subcommands.
-        "$_bin" __refresh-completion bash 2>/dev/null
-    fi
-    # If regen failed but a stale cache survived from a previous run,
-    # source it anyway — a stale completion is preferable to no
-    # completion at all.
-    [[ -f "$_cache" ]] || return 0
-    # shellcheck disable=SC1090
-    source "$_cache"
-}
-__${fn}_load_completion
-unset -f __${fn}_load_completion
-`;
-}
-function generateZshLoader(opts) {
-	const fn = sanitize(opts.programName);
-	const cache = bashCachePathExpr(opts.programName, opts.cacheDir, "zsh");
-	return `__${fn}_load_completion() {
-    emulate -L zsh
-    setopt local_options no_aliases
-    local _bin _cache _sig _hdr
-    _bin=$(whence -p ${opts.programName} 2>/dev/null)
-    [[ -n "$_bin" ]] || return 0
-    _cache=${cache}
-    _sig=$(stat -L -c '%Y' "$_bin" 2>/dev/null || stat -L -f '%m' "$_bin" 2>/dev/null) || return 0
-    _hdr="# politty-bin-sig: $_sig"
-    if [[ ! -f "$_cache" ]] || ! head -5 "$_cache" 2>/dev/null | grep -qF "$_hdr"; then
-        # See bash loader for why we use __refresh-completion instead
-        # of \`$_bin completion zsh\`.
-        "$_bin" __refresh-completion zsh 2>/dev/null
-    fi
-    # See bash loader: keep stale completion over no completion.
-    [[ -f "$_cache" ]] || return 0
-    source "$_cache"
-}
-__${fn}_load_completion
-unfunction __${fn}_load_completion
-`;
-}
-/**
-* Build the rc-loader snippet for bash or zsh. Fish doesn't have an
-* rc-loader; instead, `<program> completion fish --install` writes a
-* self-rewriting autoload file.
-*/
-function generateLoader(opts) {
-	switch (opts.shell) {
-		case "bash": return generateBashLoader(opts);
-		case "zsh": return generateZshLoader(opts);
-		case "fish": throw new Error("fish does not use an rc loader. Run `<program> completion fish --install` to write the self-refreshing autoload file instead.");
-	}
-}
-/**
-* Default cache file path (used by `completion <bash|zsh> --install`
-* and the `__refresh-completion` subcommand). For fish, the install
-* path is `$__fish_config_dir/completions/<program>.fish` and is
-* computed inside `installPath()` instead.
-*/
-function defaultCacheDir(programName) {
-	return `${process.env.XDG_CACHE_HOME ?? `${process.env.HOME ?? ""}/.cache`}/${programName}`;
-}
-
-//#endregion
-//#region src/completion/install.ts
-/**
-* On-disk install + refresh helpers.
-*
-* `install` writes the generated script to its canonical cache /
-* autoload path. `refresh` is the body of the `__refresh-completion`
-* hidden subcommand and the runMain background hook — it regenerates
-* the cache only when the binary's mtime no longer matches the
-* embedded `# politty-bin-sig:` header.
-*
-* All file I/O is best-effort: failures fall through silently. A stale
-* (or missing) cache is preferable to crashing the user's shell.
-*/
-/**
-* Resolve where a script for the given shell should live on disk.
-*
-* - bash/zsh: `<cacheDir>/completion.<shell>` — sourced by the rc loader.
-* - fish:    `$__fish_config_dir/completions/<program>.fish` — autoloaded
-*            by fish on TAB. We approximate `$__fish_config_dir` from
-*            `$XDG_CONFIG_HOME` / `$HOME`.
-*/
-function installPath(programName, shell, cacheDir) {
-	if (shell === "fish") return (0, node_path.join)(process.env.XDG_CONFIG_HOME ?? `${process.env.HOME ?? ""}/.config`, "fish", "completions", `${programName}.fish`);
-	return (0, node_path.join)(cacheDir ?? defaultCacheDir(programName), `completion.${shell}`);
-}
-/** Atomic write: tmp file in the same dir, then rename. */
-function writeAtomic(path, content) {
-	(0, node_fs.mkdirSync)((0, node_path.dirname)(path), { recursive: true });
-	const tmp = `${path}.tmp.${process.pid}`;
-	(0, node_fs.writeFileSync)(tmp, content);
-	(0, node_fs.renameSync)(tmp, path);
-}
-function generateScript(ctx, shell) {
-	return generateCompletion(ctx.rootCommand, {
-		shell,
-		programName: ctx.programName,
-		includeDescriptions: true,
-		...ctx.programVersion !== void 0 && { programVersion: ctx.programVersion },
-		...ctx.binPath !== void 0 && { binPath: ctx.binPath },
-		...ctx.cacheDir !== void 0 && { cacheDir: ctx.cacheDir },
-		...ctx.globalArgsSchema !== void 0 && { globalArgsSchema: ctx.globalArgsSchema }
-	}).script;
-}
-/** Write the script for `shell` to its install path. Returns the path. */
-function install(ctx, shell) {
-	const target = installPath(ctx.programName, shell, ctx.cacheDir);
-	writeAtomic(target, generateScript(ctx, shell));
-	return target;
-}
-/**
-* Read the first ~5 lines of an existing cache file and return its
-* embedded bin-sig. Returns `null` when the file is missing, unreadable,
-* or doesn't have a sig header.
-*/
-function readCachedSig(path) {
-	try {
-		if (!(0, node_fs.existsSync)(path)) return null;
-		const m = (0, node_fs.readFileSync)(path, "utf8").split("\n", 6).join("\n").match(/^# politty-bin-sig: (\S+)/m);
-		return m ? m[1] : null;
-	} catch {
-		return null;
-	}
-}
-/**
-* Rewrite the cache only when stale. Used by:
-*   - `<program> __refresh-completion <shell>` (the hidden subcommand
-*     spawned both by the rc loader and by the runMain background hook)
-*
-* Caller is responsible for gating: the runMain hook (`maybeSpawnRefresh`)
-* checks `hasManagedCache` before spawning so we don't silently create
-* a fish autoload the user never opted into. The rc loader / fish
-* autoload only run after the user has installed completion in the
-* first place, so they're allowed to refresh unconditionally.
-*
-* Must never throw — a stale completion is fine, a crash isn't.
-*/
-function refreshIfStale(ctx, shell) {
-	try {
-		const target = installPath(ctx.programName, shell, ctx.cacheDir);
-		const binPath = resolveBinPath(ctx.programName, ctx.binPath);
-		if (!binPath) return;
-		let currentSig;
-		try {
-			currentSig = Math.floor((0, node_fs.statSync)(binPath).mtimeMs / 1e3).toString();
-		} catch {
-			return;
-		}
-		if (readCachedSig(target) === currentSig) return;
-		writeAtomic(target, generateScript(ctx, shell));
-	} catch {}
-}
-/**
-* Returns true when a politty-managed cache file already exists on disk
-* for the given shell — i.e. the user has installed completion via
-* `<program> completion <shell> --install` or the rc loader has already
-* sourced one. Used by the runMain background hook to avoid spawning
-* the refresher (and thereby silently creating files) on plain CLI runs
-* the user never opted into.
-*/
-function hasManagedCache(ctx, shell) {
-	return readCachedSig(installPath(ctx.programName, shell, ctx.cacheDir)) !== null;
-}
-/**
-* Spawn a detached child process that runs `<program> __refresh-completion <shell>`.
-* The child is fully decoupled (`stdio: "ignore"` + `unref()`), so it
-* outlives the parent without holding any handles.
-*
-* Caller is expected to gate this on the right conditions (interactive
-* shell, not running inside `__complete` itself, etc.).
-*
-* Returns `void` and never throws — even spawn failures are absorbed.
-*/
-function spawnBackgroundRefresh(programArgv0, shell) {
-	try {
-		(0, node_child_process.spawn)(process.execPath, [
-			programArgv0,
-			"__refresh-completion",
-			shell
-		], {
-			detached: true,
-			stdio: "ignore"
-		}).unref();
-	} catch {}
-}
-
-//#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)}` : "";
-		const negDesc = opt.negationDescription ? `:${escapeDesc(opt.negationDescription)}` : desc;
-		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}"`);
-			if (opt.negation) patterns.push(`"--${opt.negation}"`);
-			lines.push(`        __${fn}_not_used ${patterns.join(" ")} && _opts+=("--${opt.cliName}${desc}")`);
-			if (opt.negation) lines.push(`        __${fn}_not_used ${patterns.join(" ")} && _opts+=("--${opt.negation}${negDesc}")`);
-		}
-	}
-	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(...buildHeaderLines({
-		programName,
-		shell: "zsh",
-		binPath: options.binPath,
-		programVersion: options.programVersion
-	}));
-	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 = zod.z.object({
-	shell: require_subcommand_router.arg(zod.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: require_subcommand_router.arg(zod.z.boolean().default(false), {
-		alias: "i",
-		description: "Show installation instructions"
-	}),
-	loader: require_subcommand_router.arg(zod.z.boolean().default(false), { description: "Print just the rc loader snippet (bash/zsh). Add it to ~/.bashrc or ~/.zshrc; it auto-regenerates the cache when the binary changes." }),
-	install: require_subcommand_router.arg(zod.z.boolean().default(false), { description: "Write the completion script to its on-disk cache (bash/zsh) or autoload location (fish) instead of printing it." })
-});
-const refreshArgsSchema = zod.z.object({ shell: require_subcommand_router.arg(zod.z.enum([
-	"bash",
-	"zsh",
-	"fish"
-]), {
-	positional: true,
-	description: "Shell to refresh",
-	placeholder: "SHELL"
-}) });
-/**
-* 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, extra = {}) {
-	const resolvedProgramName = programName ?? rootCommand.name;
-	const { cacheDir, programVersion } = extra;
-	const refreshExtra = {
-		...cacheDir !== void 0 && { cacheDir },
-		...programVersion !== void 0 && { programVersion },
-		...globalArgsSchema !== void 0 && { globalArgsSchema }
-	};
-	const installCtxBase = {
-		programName: resolvedProgramName,
-		...refreshExtra
-	};
-	const loaderOptsBase = {
-		programName: resolvedProgramName,
-		...cacheDir !== void 0 && { cacheDir }
-	};
-	if (!rootCommand.subCommands?.__complete) rootCommand.subCommands = {
-		...rootCommand.subCommands,
-		__complete: createDynamicCompleteCommand(rootCommand, resolvedProgramName)
-	};
-	if (!rootCommand.subCommands?.["__refresh-completion"]) rootCommand.subCommands = {
-		...rootCommand.subCommands,
-		"__refresh-completion": createRefreshCompletionCommand(rootCommand, resolvedProgramName, refreshExtra)
-	};
-	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;
-			}
-			if (args.install) {
-				let target;
-				try {
-					target = install({
-						rootCommand,
-						...installCtxBase
-					}, shellType);
-				} catch (e) {
-					throw new Error(`install failed: ${e instanceof Error ? e.message : String(e)}`);
-				}
-				console.error(`installed: ${target}`);
-				if (shellType !== "fish") {
-					console.error("");
-					console.error(`Add to your ~/.${shellType}rc:`);
-					console.error("");
-					console.error(generateLoader({
-						...loaderOptsBase,
-						shell: shellType
-					}).trim().replace(/^/gm, "    "));
-				}
-				return;
-			}
-			if (args.loader) {
-				if (shellType === "fish") throw new Error("fish does not use an rc loader. Run `<program> completion fish --install` to write the self-refreshing autoload file instead.");
-				process.stdout.write(generateLoader({
-					...loaderOptsBase,
-					shell: shellType
-				}));
-				return;
-			}
-			const result = generateCompletion(rootCommand, {
-				shell: shellType,
-				programName: resolvedProgramName,
-				includeDescriptions: true,
-				...globalArgsSchema !== void 0 && { globalArgsSchema },
-				...programVersion !== void 0 && { programVersion },
-				...cacheDir !== void 0 && { cacheDir }
-			});
-			if (args.instructions) console.log(result.installInstructions);
-			else console.log(result.script);
-		}
-	});
-}
-/**
-* Hidden subcommand that the runMain background hook spawns. It does
-* the same stat-compare + atomic rewrite as the rc loader, but in a
-* detached child process so it's invisible to the user.
-*/
-function createRefreshCompletionCommand(rootCommand, programName, extra = {}) {
-	return defineCommand({
-		name: "__refresh-completion",
-		description: "(internal) Refresh the on-disk completion cache if stale.",
-		args: refreshArgsSchema,
-		run(args) {
-			refreshIfStale({
-				rootCommand,
-				programName,
-				...extra
-			}, args.shell);
-		}
-	});
-}
-/**
-* 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, cacheDir, programVersion } = typeof options === "string" ? { programName: options } : options ?? {};
-	const resolvedProgramName = programName ?? command.name;
-	const extra = {
-		...cacheDir !== void 0 && { cacheDir },
-		...programVersion !== void 0 && { programVersion },
-		...globalArgsSchema !== void 0 && { globalArgsSchema }
-	};
-	const wrappedCommand = { ...command };
-	wrappedCommand.subCommands = {
-		...command.subCommands,
-		completion: createCompletionCommand(wrappedCommand, programName, globalArgsSchema, extra),
-		__complete: createDynamicCompleteCommand(wrappedCommand, programName),
-		"__refresh-completion": createRefreshCompletionCommand(wrappedCommand, resolvedProgramName, extra)
-	};
-	wrappedCommand.runMainHook = (argv) => {
-		maybeSpawnRefresh(argv, {
-			programName: resolvedProgramName,
-			...cacheDir !== void 0 && { cacheDir }
-		});
-	};
-	return wrappedCommand;
-}
-/**
-* Background-refresh trigger fired from `runMain` via `runMainHook`.
-*
-* Skipped when:
-*   - the user is invoking `__complete` / `__refresh-completion` /
-*     `completion` themselves (avoids loops and double work)
-*   - $SHELL doesn't resolve to a known shell
-*   - the user opted out via $POLITTY_NO_COMPLETION_REFRESH
-*   - process.argv[1] is missing (shouldn't happen for normal CLIs)
-*   - no politty-managed cache exists yet — i.e. the user hasn't
-*     installed completion. Without this gate the detached child would
-*     create a fish autoload (or any cache file) on every CLI run,
-*     even though the user never opted in via `--install` or the rc loader.
-*/
-function maybeSpawnRefresh(argv, ctx) {
-	if (process.env.POLITTY_NO_COMPLETION_REFRESH) return;
-	const firstPositional = argv.find((a) => !a.startsWith("-"));
-	if (firstPositional === "__complete" || firstPositional === "__refresh-completion" || firstPositional === "completion") return;
-	const shell = detectShell();
-	if (!shell) return;
-	const argv0 = process.argv[1];
-	if (!argv0) return;
-	if (!hasManagedCache(ctx, shell)) return;
-	spawnBackgroundRefresh(argv0, shell);
-}
-
-//#endregion
-Object.defineProperty(exports, 'CompletionDirective', {
-  enumerable: true,
-  get: function () {
-    return CompletionDirective;
-  }
-});
-Object.defineProperty(exports, 'createCompletionCommand', {
-  enumerable: true,
-  get: function () {
-    return createCompletionCommand;
-  }
-});
-Object.defineProperty(exports, 'createDefineCommand', {
-  enumerable: true,
-  get: function () {
-    return createDefineCommand;
-  }
-});
-Object.defineProperty(exports, 'createDynamicCompleteCommand', {
-  enumerable: true,
-  get: function () {
-    return createDynamicCompleteCommand;
-  }
-});
-Object.defineProperty(exports, 'createRefreshCompletionCommand', {
-  enumerable: true,
-  get: function () {
-    return createRefreshCompletionCommand;
-  }
-});
-Object.defineProperty(exports, 'defineCommand', {
-  enumerable: true,
-  get: function () {
-    return defineCommand;
-  }
-});
-Object.defineProperty(exports, 'detectShell', {
-  enumerable: true,
-  get: function () {
-    return detectShell;
-  }
-});
-Object.defineProperty(exports, 'extractCompletionData', {
-  enumerable: true,
-  get: function () {
-    return extractCompletionData;
-  }
-});
-Object.defineProperty(exports, 'extractPositionals', {
-  enumerable: true,
-  get: function () {
-    return extractPositionals;
-  }
-});
-Object.defineProperty(exports, 'formatForShell', {
-  enumerable: true,
-  get: function () {
-    return formatForShell;
-  }
-});
-Object.defineProperty(exports, 'generateCandidates', {
-  enumerable: true,
-  get: function () {
-    return generateCandidates;
-  }
-});
-Object.defineProperty(exports, 'generateCompletion', {
-  enumerable: true,
-  get: function () {
-    return generateCompletion;
-  }
-});
-Object.defineProperty(exports, 'getSupportedShells', {
-  enumerable: true,
-  get: function () {
-    return getSupportedShells;
-  }
-});
-Object.defineProperty(exports, 'hasCompleteCommand', {
-  enumerable: true,
-  get: function () {
-    return hasCompleteCommand;
-  }
-});
-Object.defineProperty(exports, 'parseCompletionContext', {
-  enumerable: true,
-  get: function () {
-    return parseCompletionContext;
-  }
-});
-Object.defineProperty(exports, 'resolveValueCompletion', {
-  enumerable: true,
-  get: function () {
-    return resolveValueCompletion;
-  }
-});
-Object.defineProperty(exports, 'withCompletionCommand', {
-  enumerable: true,
-  get: function () {
-    return withCompletionCommand;
-  }
-});
-//# sourceMappingURL=completion-BlZxMSeU.cjs.map