politty 0.4.16 → 0.5.0

package/dist/completion-B04iiki9.js

@@ -1,2338 +0,0 @@
-import { c as resolveSubCommandMeta, h as arg, i as resolveSubCommandAlias, l as extractFields, p as toCamelCase } from "./subcommand-router-XZBWe8HN.js";
-import { z } from "zod";
-import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { execSync, spawn } 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,
-		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 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/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(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 = join(dir, programName);
-		try {
-			if (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 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;
-		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 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 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;
-			if (opt.negation) {
-				if (opt.negation === nameOrAlias) return true;
-				if (opt.negation.includes("-") && 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 = 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 ?? "");
-		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 join(process.env.XDG_CONFIG_HOME ?? `${process.env.HOME ?? ""}/.config`, "fish", "completions", `${programName}.fish`);
-	return join(cacheDir ?? defaultCacheDir(programName), `completion.${shell}`);
-}
-/** Atomic write: tmp file in the same dir, then rename. */
-function writeAtomic(path, content) {
-	mkdirSync(dirname(path), { recursive: true });
-	const tmp = `${path}.tmp.${process.pid}`;
-	writeFileSync(tmp, content);
-	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 (!existsSync(path)) return null;
-		const m = 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(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 {
-		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 = 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"
-	}),
-	loader: arg(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: arg(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 = z.object({ shell: arg(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
-export { defineCommand as _, getSupportedShells as a, hasCompleteCommand as c, CompletionDirective as d, generateCandidates as f, createDefineCommand as g, resolveValueCompletion as h, generateCompletion as i, formatForShell as l, extractPositionals as m, createRefreshCompletionCommand as n, withCompletionCommand as o, extractCompletionData as p, detectShell as r, createDynamicCompleteCommand as s, createCompletionCommand as t, parseCompletionContext as u };
-//# sourceMappingURL=completion-B04iiki9.js.map