politty 0.5.0 → 0.6.0

package/dist/{completion-BA5JMvVG.js → completion-DHnVx9Zk.js}

@@ -1,8 +1,9 @@
-import { a as toCamelCase, h as arg, m as resolveSubCommandMeta, n as getAllAliases, t as extractFields, u as resolveSubCommandAlias } from "./schema-extractor-C50R-1re.js";
+import { a as toCamelCase, h as arg, m as resolveSubCommandMeta, n as getAllAliases, t as extractFields, u as resolveSubCommandAlias } from "./schema-extractor-Dqe7_kyQ.js";
 import { z } from "zod";
-import { execSync, spawn } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { execFile, execSync, spawn } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { promisify } from "node:util";
 
 //#region src/core/command.ts
 function defineCommand(config) {
@@ -132,6 +133,33 @@ function ansiC(s) {
 	return out;
 }
 /**
+* Single-quote escape for a POSIX shell literal: `'` -> `'\''`. Inside single
+* quotes the shell performs no expansion at all, so `$`, backticks, and
+* `$(...)` stay inert. Used for hardcoded paths that may originate from
+* env/config so path metachars never execute as commands when the generated
+* snippet is sourced. Safe for bash, zsh, and fish.
+*/
+function shSingleQuote(s) {
+	return `'${s.replace(/'/g, "'\\''")}'`;
+}
+/**
+* Shell sub-expression that prints a file's stat signature, trying GNU
+* `stat -c` first (BSD `-f` is filesystem mode there) then falling back to
+* BSD `stat -f`. `-L` follows symlinks so the shell-side mtime matches Node's
+* `fs.statSync`. `posix` (bash/zsh) wraps it as `$(… || …)`; fish has no
+* `$(…)` capture inside `(…)`, so it uses `(…; or …)`. With `withSize`, the
+* signature is `mtime:size` so a worker cache rewritten within the same
+* second still reads as stale; otherwise it is the bare mtime in whole
+* seconds.
+*/
+function statSigExpr(fileVar, opts) {
+	const gnuFmt = opts.withSize ? "%Y:%s" : "%Y";
+	const bsdFmt = opts.withSize ? "%m:%z" : "%m";
+	const gnu = `stat -L -c '${gnuFmt}' "${fileVar}" 2>/dev/null`;
+	const bsd = `stat -L -f '${bsdFmt}' "${fileVar}" 2>/dev/null`;
+	return opts.shell === "fish" ? `(${gnu}; or ${bsd})` : `$(${gnu} || ${bsd})`;
+}
+/**
 * Render an alias as its CLI token form: single-char aliases become `-x`,
 * multi-char aliases become `--long`. Mirrors the parser's accepted shapes
 * and is the bare-token form (no quoting) used inside generated case
@@ -293,13 +321,19 @@ function resolveValueCompletion(field) {
 * Parse completion context from partial command line
 */
 /**
-* The dynamic completion path runs `__complete` at TAB time and never sees
-* "expand" fields (those are handled inline by the static shell script).
-* Strip the transient pending sentinel here so the rest of the runtime path
-* can stay strict about handling only resolved `ValueCompletion` values.
+* `completion.custom.expand` is baked into static scripts, but dispatcher
+* scripts call `__complete` at TAB time. Convert the pending sentinel into a
+* runtime form that can call `enumerate` with the dependency values already
+* typed on the command line.
 */
-function stripPendingExpand(vc) {
-	return vc?.type === "pending-expand" ? void 0 : vc;
+function resolveRuntimeCompletion(vc) {
+	if (!vc) return void 0;
+	if (vc.type !== "pending-expand") return vc;
+	return {
+		type: "runtime-expand",
+		dependsOn: vc.spec.dependsOn,
+		enumerate: vc.spec.enumerate
+	};
 }
 /**
 * Extract options from a command
@@ -322,7 +356,7 @@ function extractOptionsFromSchema(schema) {
 			valueType: field.type,
 			required: field.required,
 			defaultNegationAccepted: field.type === "boolean" && (field.negation === void 0 || field.negation === true),
-			valueCompletion: stripPendingExpand(resolveValueCompletion(field))
+			valueCompletion: resolveRuntimeCompletion(resolveValueCompletion(field))
 		};
 	});
 }
@@ -453,7 +487,7 @@ function extractPositionalsForContext(command) {
 		description: field.description,
 		required: field.required,
 		variadic: field.type === "array",
-		valueCompletion: stripPendingExpand(resolveValueCompletion(field))
+		valueCompletion: resolveRuntimeCompletion(resolveValueCompletion(field))
 	}));
 }
 /**
@@ -881,11 +915,15 @@ async function generateCandidates(context, options) {
 			return generateValueCandidates(inlinePrefix ? {
 				...context,
 				currentWord: context.currentWord.slice(inlinePrefix.length)
-			} : context, options, opt?.name, opt?.valueCompletion);
+			} : context, options, opt?.name, opt?.valueCompletion, void 0, opt?.valueType === "array");
 		}
 		case "positional": {
 			const positional = resolvePositionalTarget(context);
-			return generateValueCandidates(context, options, positional?.name, positional?.valueCompletion, positional?.description);
+			if (!positional) return {
+				candidates: [],
+				directive: CompletionDirective.NoFileCompletion
+			};
+			return generateValueCandidates(context, options, positional.name, positional.valueCompletion, positional.description, false);
 		}
 	}
 }
@@ -920,6 +958,16 @@ function executeShellCommand(command) {
 		return [];
 	}
 }
+function staticChoices(vc) {
+	return vc?.type === "choices" ? vc.choices : void 0;
+}
+function runtimeExpandDepChoices(context, dep) {
+	const localOption = context.options.find((opt) => opt.name === dep && opt.isGlobal !== true);
+	if (localOption) return staticChoices(localOption.valueCompletion);
+	const positional = context.positionals.find((pos) => pos.name === dep);
+	if (positional) return staticChoices(positional.valueCompletion);
+	return staticChoices(context.options.find((opt) => opt.name === dep && opt.isGlobal === true)?.valueCompletion);
+}
 /**
 * Two-stage `key=value` post-processing. Returns the transformed candidate
 * list plus whether it contains a bare `key=` entry so the caller can flip
@@ -968,7 +1016,7 @@ function dropBareKeyEcho(candidates, currentWord) {
 /**
 * Resolve value completion, executing shell commands and file lookups in JS
 */
-async function resolveValueCandidates(vc, ctx, description) {
+async function resolveValueCandidates(vc, ctx, completionContext, description, dedupeKeyValues) {
 	const candidates = [];
 	let directive = CompletionDirective.FilterPrefix;
 	let fileExtensions;
@@ -1025,9 +1073,40 @@ async function resolveValueCandidates(vc, ctx, description) {
 		case "expand":
 			directive |= CompletionDirective.NoFileCompletion;
 			break;
+		case "runtime-expand": {
+			const deps = {};
+			let missingDep = false;
+			for (const dep of vc.dependsOn) {
+				const raw = ctx.parsedArgs[dep];
+				const value = Array.isArray(raw) ? raw[raw.length - 1] : raw;
+				const allowedValues = runtimeExpandDepChoices(completionContext, dep);
+				if (typeof value !== "string" || allowedValues === void 0 || !allowedValues.includes(value)) {
+					missingDep = true;
+					break;
+				}
+				deps[dep] = value;
+			}
+			if (!missingDep) try {
+				const seen = /* @__PURE__ */ new Set();
+				for (const item of vc.enumerate(deps)) {
+					const normalized = typeof item === "string" ? { value: item } : item;
+					if (seen.has(normalized.value)) continue;
+					seen.add(normalized.value);
+					candidates.push({
+						...normalized,
+						type: "value"
+					});
+				}
+			} catch {
+				directive = CompletionDirective.NoFileCompletion | CompletionDirective.Error;
+				break;
+			}
+			directive |= CompletionDirective.NoFileCompletion;
+			break;
+		}
 	}
-	if (vc.type === "dynamic" || vc.type === "expand") {
-		const processed = applyKeyValuePostProcessing(candidates, ctx.currentWord);
+	if (vc.type === "dynamic" || vc.type === "expand" || vc.type === "runtime-expand") {
+		const processed = applyKeyValuePostProcessing(vc.type === "runtime-expand" && dedupeKeyValues === true ? dropAlreadyUsedKeyCandidates(candidates, ctx.previousValues) : candidates, ctx.currentWord);
 		if (processed.hasEqSuffix) directive |= CompletionDirective.NoSpace;
 		return {
 			candidates: processed.candidates,
@@ -1043,6 +1122,19 @@ async function resolveValueCandidates(vc, ctx, description) {
 		fileMatchers
 	};
 }
+function dropAlreadyUsedKeyCandidates(candidates, previousValues) {
+	const used = /* @__PURE__ */ new Set();
+	for (const value of previousValues) {
+		const eqIdx = value.indexOf("=");
+		if (eqIdx > 0) used.add(value.slice(0, eqIdx));
+	}
+	if (used.size === 0) return [...candidates];
+	return candidates.filter((candidate) => {
+		const eqIdx = candidate.value.indexOf("=");
+		if (eqIdx <= 0) return true;
+		return !used.has(candidate.value.slice(0, eqIdx));
+	});
+}
 /**
 * Generate subcommand candidates
 */
@@ -1066,7 +1158,7 @@ function generateSubcommandCandidates(context) {
 	}
 	return {
 		candidates,
-		directive: CompletionDirective.FilterPrefix
+		directive: CompletionDirective.FilterPrefix | CompletionDirective.NoFileCompletion
 	};
 }
 /**
@@ -1100,7 +1192,7 @@ function generateOptionNameCandidates(context) {
 	});
 	return {
 		candidates,
-		directive: CompletionDirective.FilterPrefix
+		directive: CompletionDirective.FilterPrefix | CompletionDirective.NoFileCompletion
 	};
 }
 /**
@@ -1136,12 +1228,12 @@ function parsedArgsWithoutTarget(parsedArgs, key) {
 * is propagated to choices candidates (positional path supplies it; option
 * path does not, mirroring the prior split implementations).
 */
-async function generateValueCandidates(context, options, targetFieldName, vc, description) {
+async function generateValueCandidates(context, options, targetFieldName, vc, description, dedupeKeyValues) {
 	if (!vc) return {
 		candidates: [],
 		directive: CompletionDirective.FilterPrefix
 	};
-	return resolveValueCandidates(vc, resolverContext(context, options, targetFieldName), description);
+	return resolveValueCandidates(vc, resolverContext(context, options, targetFieldName), context, description, dedupeKeyValues);
 }
 
 //#endregion
@@ -1152,10 +1244,10 @@ async function generateValueCandidates(context, options, targetFieldName, vc, de
 * sentinel via `resolveValueCompletion`) and passes them here once siblings
 * are known.
 */
-function resolveExpandTargets(sub, targets, globalOptions = []) {
+function resolveExpandTargets(sub, targets, globalOptions = [], validateOnly = false) {
 	if (targets.length === 0) return;
 	const siblingIndex = buildSiblingIndex(sub, globalOptions);
-	for (const target of targets) target.set(resolveOne(target, siblingIndex));
+	for (const target of targets) target.set(resolveOne(target, siblingIndex, validateOnly));
 }
 /**
 * Build a name → static-values map for siblings, using each field's already
@@ -1182,7 +1274,7 @@ function buildSiblingIndex(sub, globalOptions) {
 	visit(globalOptions, true);
 	return index;
 }
-function resolveOne(target, siblings) {
+function resolveOne(target, siblings, validateOnly = false) {
 	const { spec } = target;
 	const deps = spec.dependsOn;
 	if (deps.length === 0) throw new Error(`Field "${target.describe}": completion.custom.expand.dependsOn must list at least one sibling arg.`);
@@ -1193,6 +1285,11 @@ function resolveOne(target, siblings) {
 		if (!values) throw new Error(`Field "${target.describe}": completion.custom.expand.dependsOn references "${dep}", which is not a sibling arg with a static \`choices\`/enum schema on the same command. Chaining expand specs is not supported.`);
 		valueLists.push([...values]);
 	}
+	if (validateOnly) return {
+		type: "expand",
+		dependsOn: deps,
+		table: []
+	};
 	const table = [];
 	for (const combo of cartesian(valueLists)) {
 		const depsRecord = {};
@@ -1403,11 +1500,11 @@ function fieldsToPositionals(fields, pending) {
 /**
 * Extract a completable subcommand from a command
 */
-function extractSubcommand(name, command, globalOptions = []) {
+function extractSubcommand(name, command, globalOptions = [], validateOnly = false) {
 	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, globalOptions));
+		if (resolved) subcommands.push(extractSubcommand(subName, resolved, globalOptions, validateOnly));
 		else subcommands.push({
 			name: subName,
 			description: "(lazy loaded)",
@@ -1426,7 +1523,7 @@ function extractSubcommand(name, command, globalOptions = []) {
 		options: fieldsToOptions(fields, pending),
 		positionals: fieldsToPositionals(fields, pending)
 	};
-	resolveExpandTargets(node, pending, globalOptions);
+	resolveExpandTargets(node, pending, globalOptions, validateOnly);
 	return node;
 }
 /** Join parent and child with a separator, omitting separator when parent is empty. */
@@ -1825,7 +1922,7 @@ function propagateGlobalOptions(sub, globalOptions) {
 * @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) {
+function extractCompletionData(command, programName, globalArgsSchema, validateOnly = false) {
 	let globalOptions = [];
 	if (globalArgsSchema) {
 		const globalPending = [];
@@ -1838,9 +1935,9 @@ function extractCompletionData(command, programName, globalArgsSchema) {
 			subcommands: [],
 			options: globalOptions,
 			positionals: []
-		}, globalPending);
+		}, globalPending, [], validateOnly);
 	}
-	const rootSubcommand = extractSubcommand(programName, command, globalOptions);
+	const rootSubcommand = extractSubcommand(programName, command, globalOptions, validateOnly);
 	if (globalArgsSchema) propagateGlobalOptions(rootSubcommand, globalOptions);
 	else globalOptions = rootSubcommand.options;
 	return {
@@ -1857,8 +1954,9 @@ function extractCompletionData(command, programName, globalArgsSchema) {
 *
 * 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.
+* refresh path use the `# politty-bin-sig:` and `# politty-bin-path:`
+* lines 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;
@@ -1874,6 +1972,9 @@ function computeBinSig(binPath) {
 		return "0";
 	}
 }
+function headerValue(value) {
+	return value.replace(/\r?\n/g, " ");
+}
 /**
 * Walk `$PATH` looking for an executable named `programName`. Returns
 * the first match's full path, or `null` when not found. We mirror the
@@ -1904,6 +2005,8 @@ function findOnPath(programName) {
 */
 function resolveBinPath(programName, override) {
 	if (override) return override;
+	const envOverride = process.env[binEnvVarName(sanitize(programName))];
+	if (envOverride) return envOverride;
 	return findOnPath(programName) ?? process.argv[1] ?? "";
 }
 /**
@@ -1912,10 +2015,12 @@ function resolveBinPath(programName, override) {
 * marker.
 */
 function buildHeaderLines(opts) {
-	const sig = computeBinSig(resolveBinPath(opts.programName, opts.binPath));
+	const binPath = resolveBinPath(opts.programName, opts.binPath);
+	const sig = computeBinSig(binPath);
 	const lines = [
 		`# politty-completion-version: ${1}`,
 		`# politty-bin-sig: ${sig}`,
+		`# politty-bin-path: ${headerValue(binPath)}`,
 		`# program: ${opts.programName}`
 	];
 	if (opts.programVersion) lines.push(`# program-version: ${opts.programVersion}`);
@@ -1923,6 +2028,92 @@ function buildHeaderLines(opts) {
 	return lines;
 }
 
+//#endregion
+//#region src/completion/self-refresh.ts
+/**
+* Self-refresh guards embedded in generated bash/zsh scripts.
+*
+* These guards make the default `completion <shell>` output safe to
+* save as a static completion file: when the CLI binary changes, the
+* script asks the hidden refresh subcommand to rewrite the sourced
+* file in place, then sources the fresh file and stops executing the
+* stale body.
+*/
+function generateBashSelfRefresh(opts) {
+	const { programName, binPath } = opts;
+	const fn = sanitize(programName);
+	const envName = binEnvVarName(fn);
+	const resolvedBinPath = resolveBinPath(programName, binPath);
+	const sig = computeBinSig(resolvedBinPath);
+	const quotedBinPath = shSingleQuote(resolvedBinPath);
+	const refreshFn = `__${fn}_self_refresh`;
+	return [
+		`${refreshFn}() {`,
+		`    local _self _bin _sig`,
+		`    _self=\${BASH_SOURCE[0]:-}`,
+		`    [[ -n "$_self" && -f "$_self" ]] || return 1`,
+		`    head -n 8 "$_self" 2>/dev/null | grep -qF "# politty-completion-version:" || return 1`,
+		`    head -n 8 "$_self" 2>/dev/null | grep -qxF "# program: ${programName}" || return 1`,
+		`    head -n 8 "$_self" 2>/dev/null | grep -qxF "# shell: bash" || return 1`,
+		`    _bin="\${${envName}:-$(type -P ${programName} 2>/dev/null)}"`,
+		`    [[ -n "$_bin" ]] || return 1`,
+		`    _sig=${statSigExpr("$_bin", { shell: "posix" })} || return 1`,
+		`    [[ "$_sig" != "${sig}" || "$_bin" != ${quotedBinPath} ]] || return 1`,
+		`    "$_bin" __refresh-completion bash "$_self" --static 2>/dev/null || return 1`,
+		`    head -n 8 "$_self" 2>/dev/null | grep -qxF "# politty-bin-sig: $_sig" || return 1`,
+		`    head -n 8 "$_self" 2>/dev/null | grep -qxF "# politty-bin-path: $_bin" || return 1`,
+		`    source "$_self" 2>/dev/null || return 1`,
+		`    return 0`,
+		`}`,
+		`if ${refreshFn}; then`,
+		`    unset -f ${refreshFn}`,
+		`    return 0 2>/dev/null || true`,
+		`else`,
+		`    unset -f ${refreshFn}`,
+		`fi`,
+		``
+	];
+}
+function generateZshSelfRefresh(opts) {
+	const { programName, binPath } = opts;
+	const fn = sanitize(programName);
+	const envName = binEnvVarName(fn);
+	const completionFn = `_${programName}`;
+	const resolvedBinPath = resolveBinPath(programName, binPath);
+	const sig = computeBinSig(resolvedBinPath);
+	const quotedBinPath = shSingleQuote(resolvedBinPath);
+	const refreshFn = `__${fn}_self_refresh`;
+	return [
+		`${refreshFn}() {`,
+		`    emulate -L zsh`,
+		`    setopt local_options no_aliases`,
+		`    local _self _bin _sig`,
+		`    _self="\${(%):-%x}"`,
+		`    [[ -n "$_self" && -f "$_self" ]] || return 1`,
+		`    head -n 8 "$_self" 2>/dev/null | grep -qF "# politty-completion-version:" || return 1`,
+		`    head -n 8 "$_self" 2>/dev/null | grep -qxF "# program: ${programName}" || return 1`,
+		`    head -n 8 "$_self" 2>/dev/null | grep -qxF "# shell: zsh" || return 1`,
+		`    _bin="\${${envName}:-$(whence -p ${programName} 2>/dev/null)}"`,
+		`    [[ -n "$_bin" ]] || return 1`,
+		`    _sig=${statSigExpr("$_bin", { shell: "posix" })} || return 1`,
+		`    [[ "$_sig" != "${sig}" || "$_bin" != ${quotedBinPath} ]] || return 1`,
+		`    "$_bin" __refresh-completion zsh "$_self" --static 2>/dev/null || return 1`,
+		`    head -n 8 "$_self" 2>/dev/null | grep -qxF "# politty-bin-sig: $_sig" || return 1`,
+		`    head -n 8 "$_self" 2>/dev/null | grep -qxF "# politty-bin-path: $_bin" || return 1`,
+		`    source "$_self" 2>/dev/null || return 1`,
+		`    ${completionFn} "$@"`,
+		`    return 0`,
+		`}`,
+		`if ${refreshFn} "$@"; then`,
+		`    unfunction ${refreshFn} 2>/dev/null`,
+		`    return 0 2>/dev/null || true`,
+		`else`,
+		`    unfunction ${refreshFn} 2>/dev/null`,
+		`fi`,
+		``
+	];
+}
+
 //#endregion
 //#region src/completion/bash.ts
 /** Escape a string for use inside bash double-quotes */
@@ -2024,6 +2215,7 @@ function bashValueLines(vc, inline, fn, location) {
 		case "directory": return [`COMPREPLY=($(compgen -P "$_inline_prefix" -d -- "$_cur"))`, `compopt -o filenames`];
 		case "command": return [`COMPREPLY=($(compgen -P "$_inline_prefix" -W "$(${vc.shellCommand})" -- "$_cur"))`];
 		case "none": return [`compopt +o default 2>/dev/null`];
+		case "runtime-expand": return [];
 	}
 }
 /**
@@ -2086,6 +2278,28 @@ function positionalBlock$2(positionals, fn, funcSuffix, options = []) {
 	lines.push(`    esac`);
 	return lines;
 }
+/**
+* Subcommand-name completion. When the same node also has positionals, emit a
+* runtime check that completes subcommand names while the cursor still prefixes
+* one and falls through to positional completion otherwise. Returns lines at
+* base indentation; callers re-indent for their handler depth.
+*/
+function subOrPositionalLines$2(subNames, positionals, fn, funcSuffix, options) {
+	const subReply = [`COMPREPLY=($(compgen -W "${subNames}" -- "$_cur"))`, `compopt +o default 2>/dev/null`];
+	if (positionals.length === 0) return subReply;
+	return [
+		`local -a _sub_names=(${subNames})`,
+		`local _sub_name _sub_match=0`,
+		`for _sub_name in "\${_sub_names[@]}"; do`,
+		`    [[ "$_sub_name" == "$_cur"* ]] && _sub_match=1 && break`,
+		`done`,
+		`if (( _sub_match )); then`,
+		...subReply.map((l) => `    ${l}`),
+		`else`,
+		...positionalBlock$2(positionals, fn, funcSuffix, options),
+		`fi`
+	];
+}
 /** Generate prev/inline value completion blocks for options */
 function valueCompletionBlocks(options, positionals, fn, funcSuffix) {
 	if (!options.some((o) => o.takesValue && o.valueCompletion)) return [];
@@ -2161,8 +2375,7 @@ function generateSubHandler$2(sub, fn, path) {
 	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`);
+		lines.push(...subOrPositionalLines$2(subNames, sub.positionals, fn, funcSuffix, sub.options).map((l) => `    ${l}`));
 	} else if (sub.positionals.length > 0) lines.push(...positionalBlock$2(sub.positionals, fn, funcSuffix, sub.options));
 	lines.push(`}`);
 	lines.push(``);
@@ -2171,7 +2384,9 @@ function generateSubHandler$2(sub, fn, path) {
 function generateBashCompletion(command, options) {
 	const { programName } = options;
 	const data = extractCompletionData(command, programName, options.globalArgsSchema);
-	const fn = sanitize(programName);
+	const baseFn = sanitize(programName);
+	const fn = options.staticWorker ? `${baseFn}_${sanitize(options.staticWorker.functionSuffix)}` : baseFn;
+	const isWorker = options.staticWorker !== void 0;
 	const root = data.command;
 	const visibleSubs = getVisibleSubs(root.subcommands);
 	const expandSpecs = collectExpandSpecs(root);
@@ -2183,8 +2398,14 @@ function generateBashCompletion(command, options) {
 		binPath: options.binPath,
 		programVersion: options.programVersion
 	}));
+	lines.push(`# politty-completion-mode: ${isWorker ? "worker" : "static"}`);
+	if (isWorker) lines.push(`# politty-completion-worker: true`);
 	lines.push(`# Generated by politty`);
 	lines.push(``);
+	if (!isWorker) lines.push(...generateBashSelfRefresh({
+		programName,
+		binPath: options.binPath
+	}));
 	const hasExpand = expandSpecs.length > 0;
 	const arrayExpandSpecs = expandSpecs.filter((s) => s.isArrayOption);
 	const hasArrayExpand = arrayExpandSpecs.length > 0;
@@ -2325,8 +2546,7 @@ function generateBashCompletion(command, options) {
 	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`);
+		lines.push(...subOrPositionalLines$2(subNames, root.positionals, fn, "root", root.options).map((l) => `        ${l}`));
 	} else if (root.positionals.length > 0) {
 		lines.push(`    else`);
 		lines.push(...positionalBlock$2(root.positionals, fn, "root", root.options).map((l) => `    ${l}`));
@@ -2424,18 +2644,17 @@ function generateBashCompletion(command, options) {
 	lines.push(`    esac`);
 	lines.push(`}`);
 	lines.push(``);
-	lines.push(`complete -o default -F _${fn}_completions ${programName}`);
+	if (!isWorker) 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)"
+		installInstructions: `# To enable auto-refreshing bash completions, add this to your ~/.bashrc:
+eval "$(${programName} completion bash --static)"
 
-# Option 2: Save to a file
-${programName} completion bash > ~/.local/share/bash-completion/completions/${programName}
+# For faster shell startup, save the script instead:
+mkdir -p ~/.local/share/bash-completion/completions
+${programName} completion bash --static > ~/.local/share/bash-completion/completions/${programName}
 
 # Then reload your shell or run:
 source ~/.bashrc`
@@ -2443,182 +2662,1317 @@ source ~/.bashrc`
 }
 
 //#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);
+//#region src/completion/bundled-worker.ts
+const execFileAsync = promisify(execFile);
+const SHELL_EXT = {
+	bash: "bash",
+	zsh: "zsh",
+	fish: "fish"
+};
+const REQUIRED_WORKER_HEADERS = [
+	"# politty-completion-version: 1",
+	"# politty-completion-mode: worker",
+	"# politty-completion-worker: true"
+];
+function bundledWorkerShellExtension(shell) {
+	return SHELL_EXT[shell];
+}
+function defaultBundledWorkerOutputPath(shell) {
+	return join("dist", "completion", `${shell}-worker.${bundledWorkerShellExtension(shell)}`);
+}
+function defaultBundledWorkerRelativePaths(shell) {
+	const ext = SHELL_EXT[shell];
+	return [
+		`completion/${shell}-worker.${ext}`,
+		`../completion/${shell}-worker.${ext}`,
+		`dist/completion/${shell}-worker.${ext}`,
+		`../dist/completion/${shell}-worker.${ext}`,
+		`completion-worker.${shell}`,
+		`../completion-worker.${shell}`
+	];
+}
+function bundledWorkerRelativePaths(programName, shell, options) {
+	if (options?.disabled) return [];
+	const configured = options?.relativePaths?.[shell];
+	return (configured && configured.length > 0 ? configured : defaultBundledWorkerRelativePaths(shell)).map((p) => p.replaceAll("{shell}", shell).replaceAll("{ext}", SHELL_EXT[shell]).replaceAll("{program}", programName));
+}
+function readCmdShimTarget(path) {
+	try {
+		const content = readFileSync(path, "utf8");
+		let target = null;
+		for (const line of content.split("\n")) {
+			const match = line.match(/^# cmd-shim-target=(.+)$/);
+			if (match) target = match[1];
+		}
+		return target;
+	} catch {
+		return null;
 	}
 }
-/**
-* 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}`);
+function addBaseDirs(out, path) {
+	if (!path) return;
+	out.add(dirname(resolve(path)));
+	try {
+		out.add(dirname(realpathSync(path)));
+	} catch {}
+	const shimTarget = readCmdShimTarget(path);
+	if (shimTarget) addBaseDirs(out, shimTarget);
 }
-/**
-* 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) {
-	const lines = ((result.directive & CompletionDirective.FilterPrefix) !== 0 && options.currentWord ? result.candidates.filter((c) => c.value.startsWith(options.currentWord)) : result.candidates).map((c) => options.inlinePrefix ? `${options.inlinePrefix}${c.value}` : c.value);
-	appendMetadata(lines, result);
-	return lines.join("\n");
+function workerHead(path) {
+	return readFileSync(path, "utf8").split("\n", 24).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");
+function requiredBundledWorkerHeaders(programName, shell) {
+	return [
+		...REQUIRED_WORKER_HEADERS,
+		`# program: ${programName}`,
+		`# shell: ${shell}`
+	];
 }
-/**
-* 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;
+function missingBundledWorkerHeaders(head, programName, shell) {
+	const lines = head.split("\n").map((line) => line.trimEnd());
+	return requiredBundledWorkerHeaders(programName, shell).filter((header) => !lines.includes(header));
+}
+function validateBundledWorkerFile(path, programName, shell) {
+	if (!existsSync(path)) throw new Error(`Bundled completion worker does not exist: ${path}`);
+	const missing = missingBundledWorkerHeaders(workerHead(path), programName, shell);
+	if (missing.length > 0) throw new Error(`Invalid bundled completion worker ${path}: missing ${missing.map((h) => JSON.stringify(h)).join(", ")}`);
+}
+function isBundledWorkerFile(path, programName, shell) {
+	try {
+		validateBundledWorkerFile(path, programName, shell);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function resolveBundledWorkerPath(opts) {
+	const rels = bundledWorkerRelativePaths(opts.programName, opts.shell, opts.bundledWorker);
+	if (rels.length === 0) return null;
+	const bases = /* @__PURE__ */ new Set();
+	if (opts.binPath !== void 0) addBaseDirs(bases, opts.binPath);
+	if (process.argv[1]) addBaseDirs(bases, process.argv[1]);
+	addBaseDirs(bases, resolveBinPath(opts.programName, opts.binPath));
+	for (const rel of rels) if (isAbsolute(rel) && isBundledWorkerFile(rel, opts.programName, opts.shell)) return rel;
+	for (const base of bases) for (const rel of rels) {
+		if (isAbsolute(rel)) continue;
+		const candidate = join(base, rel);
+		if (isBundledWorkerFile(candidate, opts.programName, opts.shell)) return candidate;
+	}
+	return null;
+}
+function resolvePathFromCwd(path, cwd) {
+	return isAbsolute(path) ? path : resolve(cwd, path);
+}
+function executableCommand(bin, args, cwd) {
+	const binPath = bin.startsWith(".") || bin.includes("/") || bin.includes("\\") ? resolvePathFromCwd(bin, cwd) : bin;
+	const ext = extname(binPath).toLowerCase();
+	if (ext === ".js" || ext === ".mjs" || ext === ".cjs") return {
+		command: process.execPath,
+		args: [binPath, ...args]
+	};
+	return {
+		command: binPath,
+		args: [...args]
+	};
+}
+async function runTargetBin(bin, args, opts) {
+	const command = executableCommand(bin, args, opts.cwd);
+	try {
+		const { stdout, stderr } = await execFileAsync(command.command, command.args, {
+			cwd: opts.cwd,
+			env: {
+				...process.env,
+				...opts.env
+			},
+			encoding: "utf8",
+			maxBuffer: 10 * 1024 * 1024
+		});
+		return {
+			stdout,
+			stderr
+		};
+	} catch (error) {
+		const stderr = typeof error === "object" && error !== null && "stderr" in error ? String(error.stderr ?? "").trim() : "";
+		const detail = stderr ? `\n${stderr}` : "";
+		throw new Error(`Command failed: ${command.command} ${command.args.join(" ")}${detail}`, error instanceof Error ? { cause: error } : void 0);
+	}
+}
+function assertNonEmptyFile(path) {
+	const stat = statSync(path);
+	if (!stat.isFile() || stat.size === 0) throw new Error(`Generated bundled completion worker is empty: ${path}`);
+	return stat.size;
+}
+function formatSize(size) {
+	if (size < 1024) return `${size} B`;
+	return `${(size / 1024).toFixed(1)} KiB`;
+}
+function printSuccess(path, size, cwd) {
+	const rel = relative(cwd, path);
+	console.log(`Generated bundled completion worker: ${rel && !rel.startsWith("..") ? rel : path} (${formatSize(size)})`);
+}
+async function generateBundledCompletionWorker(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const outputPath = resolvePathFromCwd(options.outputPath ?? defaultBundledWorkerOutputPath(options.shell), cwd);
+	mkdirSync(dirname(outputPath), { recursive: true });
+	rmSync(outputPath, { force: true });
+	await runTargetBin(options.bin, [
+		"__refresh-completion",
+		options.shell,
+		outputPath,
+		"--static",
+		"--worker"
+	], {
+		cwd,
+		env: options.env
 	});
-	appendMetadata(lines, result);
-	return lines.join("\n");
+	const size = assertNonEmptyFile(outputPath);
+	validateBundledWorkerFile(outputPath, options.programName, options.shell);
+	let reportedPath;
+	if (options.verify) {
+		const lines = (await runTargetBin(options.bin, ["__completion-worker-path", options.shell], {
+			cwd,
+			env: options.env
+		})).stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+		if (lines.length !== 1) throw new Error(`Expected __completion-worker-path ${options.shell} to print exactly one path, got ${lines.length}.`);
+		reportedPath = resolvePathFromCwd(lines[0], cwd);
+		const generatedReal = realpathSync(outputPath);
+		const reportedReal = realpathSync(reportedPath);
+		if (reportedReal !== generatedReal) throw new Error(`Bundled completion worker path mismatch: generated ${generatedReal}, reported ${reportedReal}`);
+	}
+	if (!options.quiet) printSuccess(outputPath, size, cwd);
+	return {
+		outputPath,
+		size,
+		...reportedPath !== void 0 && { reportedPath }
+	};
 }
 
 //#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
-*/
-/**
-* 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)
-* @param globalArgsSchema - Global args schema. Forwarded to
-*   `parseCompletionContext` so resolvers attached to global options remain
-*   reachable at every subcommand level.
-* @returns A command that outputs completion candidates
-*/
-function createDynamicCompleteCommand(rootCommand, _programName, globalArgsSchema) {
-	return defineCommand({
-		name: "__complete",
-		args: completeArgsSchema,
-		async run(args) {
-			const context = parseCompletionContext(args.args, rootCommand, globalArgsSchema);
-			const inlinePrefix = context.completionType === "option-value" && context.targetOption ? detectInlineOptionPrefix(context.currentWord) : void 0;
-			const effectiveWord = inlinePrefix ? context.currentWord.slice(inlinePrefix.length) : context.currentWord;
-			const output = formatForShell(await generateCandidates(context, { shell: args.shell }), {
-				shell: args.shell,
-				currentWord: effectiveWord,
-				inlinePrefix
-			});
-			console.log(output);
-		}
-	});
+//#region src/completion/dispatcher.ts
+function compileCacheSuffix(programName) {
+	return shSingleQuote(`/${programName}/node-compile-cache`);
 }
-/**
-* Check if a command tree contains the __complete command
-*/
-function hasCompleteCommand(command) {
-	return Boolean(command.subCommands?.["__complete"]);
+function hardcodedCompileCacheDir(cacheDir) {
+	return cacheDir ? shSingleQuote(`${cacheDir}/node-compile-cache`) : void 0;
 }
-
-//#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, "\\$");
+function hardcodedWorkerPath(cacheDir, shell) {
+	return cacheDir ? shSingleQuote(`${cacheDir}/completion-worker.${shell}`) : void 0;
+}
+function workerPathSuffix(programName, shell) {
+	return shSingleQuote(`/${programName}/completion-worker.${shell}`);
 }
 /**
-* Escape a fish `switch` case pattern. Fish's `case` interprets its
-* arguments as globs even when double-quoted, so glob metacharacters
-* (`*`, `?`, `[`, `]`) must be backslash-escaped to keep the comparison
-* literal — otherwise a key like `prod*` would also match a runtime
-* value of `production`. Quote/dollar/backslash are escaped first so the
-* resulting string remains valid inside a double-quoted literal.
+* `<printCmd> <dir>` line resolving a cache path: the hardcoded `cacheDir` when
+* configured, else `${XDG_CACHE_HOME:-$HOME/.cache}` joined with `suffix`. Used
+* by bash and zsh, which both expand the XDG default inline.
 */
-function fishCaseEscape(s) {
-	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$").replace(/\*/g, "\\*").replace(/\?/g, "\\?").replace(/\[/g, "\\[").replace(/]/g, "\\]");
+function posixCacheDefault(printCmd, hardcoded, suffix) {
+	return hardcoded ? `        ${printCmd} ${hardcoded}` : `        ${printCmd} "\${XDG_CACHE_HOME:-$HOME/.cache}"${suffix}`;
 }
 /**
-* Generate fish value completion lines for a ValueCompletion spec.
-* Each line outputs candidates via echo (tab-separated value\tdescription).
-*
-* `location` is required for the expand variant (carries fieldName +
-* isArrayOption); other variants ignore it.
+* fish equivalent of {@link posixCacheDefault}. fish has no `${VAR:-default}`
+* form, so the XDG fallback is materialized over three lines.
 */
-function fishValueLines(vc, fn, location) {
-	if (!vc) return [];
-	switch (vc.type) {
-		case "expand": {
-			if (!location) throw new Error("fishValueLines: expand variant requires a location");
-			const depExpr = (d) => {
-				const safe = sanitize(d.name);
-				return d.isGlobal ? `$_global_arg_values_${safe}` : `$_arg_values_${safe}`;
-			};
-			const depKey = location.resolvedDeps.map((d) => `"${depExpr(d)}"`).join(`\\x1f`);
-			const bucket = sanitize(location.fieldName);
-			const bucketList = location.isGlobal ? `$_global_used_field_keys_${bucket}` : `$_used_field_keys_${bucket}`;
-			const out = [`switch ${depKey}`];
-			for (const entry of vc.table) {
-				const casePattern = entry.key.map((k) => `"${fishCaseEscape(k)}"`).join(`\\x1f`);
-				out.push(`    case ${casePattern}`);
-				const keyOnlyLines = [];
-				const fullLines = [];
-				const seenKeys = /* @__PURE__ */ new Set();
-				const printfLine = (value, description) => description ? `printf '%s\\t%s\\n' "${escapeDesc$1(value)}" "${escapeDesc$1(description)}"` : `printf '%s\\n' "${escapeDesc$1(value)}"`;
-				const wrapWithDedup = (echoLine, keyPart) => location.isArrayOption && keyPart.length > 0 ? [
-					`        if not contains -- "${escapeDesc$1(keyPart)}" ${bucketList}`,
+function fishCacheDefault(hardcoded, suffix) {
+	if (hardcoded) return `    printf '%s\\n' ${hardcoded}`;
+	return [
+		`    set -l _cache_root "$XDG_CACHE_HOME"`,
+		`    test -n "$_cache_root"; or set _cache_root "$HOME/.cache"`,
+		`    printf '%s\\n' "$_cache_root"${suffix}`
+	].join("\n");
+}
+function shellWorkerRelList(options, shell) {
+	return bundledWorkerRelativePaths(options.programName, shell, options.bundledWorker).map(shSingleQuote).join(" ");
+}
+function fishDQ(s) {
+	return `"${s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$")}"`;
+}
+function fishWorkerRelList(options) {
+	return bundledWorkerRelativePaths(options.programName, "fish", options.bundledWorker).map(fishDQ).join(" ");
+}
+function bundledWorkerPathCommandEnabled(options) {
+	return options.bundledWorker?.queryCommand === true && !options.bundledWorker.disabled;
+}
+function bashDispatcher(_command, options) {
+	const { programName } = options;
+	const fn = sanitize(programName);
+	const workerFn = `${fn}_worker`;
+	const workerBinEnvName = binEnvVarName(workerFn);
+	const envName = binEnvVarName(fn);
+	const programLookup = shSingleQuote(programName);
+	const compileCacheDefault = posixCacheDefault("printf '%s\\n'", hardcodedCompileCacheDir(options.cacheDir), compileCacheSuffix(programName));
+	const workerPathDefault = posixCacheDefault("printf '%s\\n'", hardcodedWorkerPath(options.cacheDir, "bash"), workerPathSuffix(programName, "bash"));
+	const workerRelList = shellWorkerRelList(options, "bash");
+	const canQueryBundledWorkerPath = bundledWorkerPathCommandEnabled(options);
+	const lines = [];
+	lines.push(...buildHeaderLines({
+		programName,
+		shell: "bash",
+		binPath: options.binPath,
+		programVersion: options.programVersion
+	}));
+	lines.push(`# Generated by politty`);
+	lines.push(`# politty-completion-mode: dispatcher`);
+	lines.push(``);
+	lines.push(`__${fn}_resolve_bin() {`);
+	lines.push(`    if [[ -n "\${${envName}:-}" ]]; then`);
+	lines.push(`        printf '%s\\n' "\${${envName}}"`);
+	lines.push(`        return 0`);
+	lines.push(`    fi`);
+	lines.push(`    type -P ${programLookup} 2>/dev/null`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_node_compile_cache_dir() {`);
+	lines.push(`    if [[ -n "\${NODE_COMPILE_CACHE:-}" ]]; then`);
+	lines.push(`        printf '%s\\n' "$NODE_COMPILE_CACHE"`);
+	lines.push(`        return 0`);
+	lines.push(`    fi`);
+	lines.push(compileCacheDefault);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_static_worker_path() {`);
+	lines.push(workerPathDefault);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_worker_file_sig() {`);
+	lines.push(`    local _worker="$1" _sig`);
+	lines.push(`    _sig=${statSigExpr("$_worker", {
+		shell: "posix",
+		withSize: true
+	})} || return 1`);
+	lines.push(`    printf '%s\\n' "$_sig"`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_is_worker_file() {`);
+	lines.push(`    local _worker="$1" _head`);
+	lines.push(`    [[ -f "$_worker" ]] || return 1`);
+	lines.push(`    _head="$(head -n 24 "$_worker" 2>/dev/null)" || return 1`);
+	lines.push(`    _head=$'\\n'"$_head"$'\\n'`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# politty-completion-version: 1"$'\\n'* ]] || return 1`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# program: ${programName}"$'\\n'* ]] || return 1`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# shell: bash"$'\\n'* ]] || return 1`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# politty-completion-mode: worker"$'\\n'* ]] || return 1`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# politty-completion-worker: true"$'\\n'* ]] || return 1`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_load_worker() {`);
+	lines.push(`    local _worker="$1" _sig _key`);
+	lines.push(`    __${fn}_is_worker_file "$_worker" || return 1`);
+	lines.push(`    _sig="$(__${fn}_worker_file_sig "$_worker")" || return 1`);
+	lines.push(`    _key="$_worker:$_sig"`);
+	lines.push(`    if [[ "\${__${fn}_loaded_worker_key:-}" != "$_key" ]]; then`);
+	lines.push(`        source "$_worker" 2>/dev/null || return 1`);
+	lines.push(`        __${fn}_loaded_worker_key="$_key"`);
+	lines.push(`    fi`);
+	lines.push(`    declare -F _${workerFn}_completions >/dev/null 2>&1`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_realpath() {`);
+	lines.push(`    local _path="$1" _dir _target _limit=0`);
+	lines.push(`    while [[ -L "$_path" && $_limit -lt 40 ]]; do`);
+	lines.push(`        _dir="$(cd -P "$(dirname "$_path")" 2>/dev/null && pwd)" || return 1`);
+	lines.push(`        _target="$(readlink "$_path")" || return 1`);
+	lines.push(`        if [[ "$_target" == /* ]]; then _path="$_target"; else _path="$_dir/$_target"; fi`);
+	lines.push(`        (( _limit++ ))`);
+	lines.push(`    done`);
+	lines.push(`    _dir="$(cd -P "$(dirname "$_path")" 2>/dev/null && pwd)" || return 1`);
+	lines.push(`    printf '%s\\n' "$_dir/$(basename "$_path")"`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_worker_from_dir() {`);
+	lines.push(`    local _dir="$1" _rel _candidate`);
+	if (workerRelList.length > 0) {
+		lines.push(`    for _rel in ${workerRelList}; do`);
+		lines.push(`        [[ "$_rel" == /* ]] && _candidate="$_rel" || _candidate="$_dir/$_rel"`);
+		lines.push(`        if __${fn}_is_worker_file "$_candidate"; then`);
+		lines.push(`            printf '%s\\n' "$_candidate"`);
+		lines.push(`            return 0`);
+		lines.push(`        fi`);
+		lines.push(`    done`);
+	}
+	lines.push(`    return 1`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_cmd_shim_target() {`);
+	lines.push(`    sed -n 's/^# cmd-shim-target=//p' "$1" 2>/dev/null | tail -n 1`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_bundled_worker_path() {`);
+	lines.push(`    local _bin="$1" _node_compile_cache="\${2:-}" _real _dir _target _reported`);
+	lines.push(`    _real="$(__${fn}_realpath "$_bin" 2>/dev/null)" || _real=""`);
+	lines.push(`    if [[ -n "$_real" ]]; then`);
+	lines.push(`        _dir="$(dirname "$_real")"`);
+	lines.push(`        __${fn}_worker_from_dir "$_dir" && return 0`);
+	lines.push(`    fi`);
+	lines.push(`    _dir="$(dirname "$_bin")"`);
+	lines.push(`    __${fn}_worker_from_dir "$_dir" && return 0`);
+	lines.push(`    _target="$(__${fn}_cmd_shim_target "$_bin")"`);
+	lines.push(`    if [[ -n "$_target" ]]; then`);
+	lines.push(`        _real="$(__${fn}_realpath "$_target" 2>/dev/null)" || _real="$_target"`);
+	lines.push(`        _dir="$(dirname "$_real")"`);
+	lines.push(`        __${fn}_worker_from_dir "$_dir" && return 0`);
+	lines.push(`    fi`);
+	if (canQueryBundledWorkerPath) {
+		lines.push(`    if [[ "\${__${fn}_queried_bin:-}" == "$_bin" && -n "\${__${fn}_queried_worker:-}" ]] && __${fn}_is_worker_file "\${__${fn}_queried_worker}"; then`);
+		lines.push(`        printf '%s\\n' "\${__${fn}_queried_worker}"`);
+		lines.push(`        return 0`);
+		lines.push(`    fi`);
+		lines.push(`    _reported="$(NODE_COMPILE_CACHE="$_node_compile_cache" "$_bin" __completion-worker-path bash 2>/dev/null)" || _reported=""`);
+		lines.push(`    if [[ -n "$_reported" ]] && __${fn}_is_worker_file "$_reported"; then`);
+		lines.push(`        __${fn}_queried_bin="$_bin"`);
+		lines.push(`        __${fn}_queried_worker="$_reported"`);
+		lines.push(`        printf '%s\\n' "$_reported"`);
+		lines.push(`        return 0`);
+		lines.push(`    fi`);
+	}
+	lines.push(`    return 1`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_bin_sig() {`);
+	lines.push(`    local _bin="$1" _sig`);
+	lines.push(`    _sig=${statSigExpr("$_bin", { shell: "posix" })} || return 1`);
+	lines.push(`    printf '%s\\n' "$_sig"`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_worker_matches_bin() {`);
+	lines.push(`    local _worker="$1" _sig="$2" _bin="$3" _head`);
+	lines.push(`    [[ -f "$_worker" ]] || return 1`);
+	lines.push(`    _head="$(head -n 12 "$_worker" 2>/dev/null)" || return 1`);
+	lines.push(`    grep -qxF "# politty-bin-sig: $_sig" <<< "$_head" || return 1`);
+	lines.push(`    grep -qxF "# politty-bin-path: $_bin" <<< "$_head" || return 1`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_apply_dynamic_output() {`);
+	lines.push(`    local _raw="$1" _cur="$2" _inline_prefix="$3"`);
+	lines.push(`    COMPREPLY=()`);
+	lines.push(`    local _directive=0`);
+	lines.push(`    local -a _lines=() _exts=() _matchers=()`);
+	lines.push(`    local _line`);
+	lines.push(`    while IFS= read -r _line; do _lines+=("$_line"); done <<< "$_raw"`);
+	lines.push(`    local _last=$((\${#_lines[@]} - 1))`);
+	lines.push(`    if (( _last >= 0 )) && [[ "\${_lines[$_last]}" == :[0-9]* ]]; then`);
+	lines.push(`        local -a _meta=()`);
+	lines.push(`        IFS=$'\\t' read -r -a _meta <<< "\${_lines[$_last]}"`);
+	lines.push(`        unset '_lines[_last]'`);
+	lines.push(`        _directive="\${_meta[0]#:}"`);
+	lines.push(`        local _m`);
+	lines.push(`        for _m in "\${_meta[@]:1}"; do`);
+	lines.push(`            if [[ "$_m" == @ext:* ]]; then`);
+	lines.push(`                IFS=',' read -r -a _exts <<< "\${_m#@ext:}"`);
+	lines.push(`            elif [[ "$_m" == @matcher:* ]]; then`);
+	lines.push(`                IFS=',' read -r -a _matchers <<< "\${_m#@matcher:}"`);
+	lines.push(`            fi`);
+	lines.push(`        done`);
+	lines.push(`    fi`);
+	lines.push(`    for _line in "\${_lines[@]}"; do`);
+	lines.push(`        [[ -z "$_line" ]] && continue`);
+	lines.push(`        COMPREPLY+=("$_line")`);
+	lines.push(`    done`);
+	lines.push(`    local _ip="\${_inline_prefix:-}"`);
+	lines.push(`    if (( \${#_exts[@]} > 0 || \${#_matchers[@]} > 0 )); then`);
+	lines.push(`        local _need_empty=0`);
+	lines.push(`        compopt +o default 2>/dev/null || _need_empty=1`);
+	lines.push(`        compopt -o filenames 2>/dev/null`);
+	lines.push(`        local _f _ext _pat _base _ok`);
+	lines.push(`        while IFS= read -r _f; do`);
+	lines.push(`            if [[ -d "$_f" ]]; then`);
+	lines.push(`                COMPREPLY+=("\${_ip}\${_f}")`);
+	lines.push(`                continue`);
+	lines.push(`            fi`);
+	lines.push(`            _ok=0`);
+	lines.push(`            if (( \${#_exts[@]} > 0 )); then`);
+	lines.push(`                for _ext in "\${_exts[@]}"; do`);
+	lines.push(`                    [[ -n "$_ext" && "$_f" == *."$_ext" ]] && _ok=1`);
+	lines.push(`                done`);
+	lines.push(`            fi`);
+	lines.push(`            if (( \${#_matchers[@]} > 0 )); then`);
+	lines.push(`                _base="\${_f##*/}"`);
+	lines.push(`                for _pat in "\${_matchers[@]}"; do`);
+	lines.push(`                    [[ -n "$_pat" && "$_base" == $_pat ]] && _ok=1`);
+	lines.push(`                done`);
+	lines.push(`            fi`);
+	lines.push(`            (( _ok )) && COMPREPLY+=("\${_ip}\${_f}")`);
+	lines.push(`        done < <(compgen -f -- "$_cur")`);
+	lines.push(`        if (( _need_empty && \${#COMPREPLY[@]} == 0 )); then COMPREPLY=( "" ); fi`);
+	lines.push(`    elif (( _directive & ${CompletionDirective.DirectoryCompletion} )); then`);
+	lines.push(`        local _need_empty=0`);
+	lines.push(`        compopt +o default 2>/dev/null || _need_empty=1`);
+	lines.push(`        compopt -o filenames 2>/dev/null`);
+	lines.push(`        local _d`);
+	lines.push(`        while IFS= read -r _d; do COMPREPLY+=("\${_ip}\${_d}"); done < <(compgen -d -- "$_cur")`);
+	lines.push(`        if (( _need_empty && \${#COMPREPLY[@]} == 0 )); then COMPREPLY=( "" ); fi`);
+	lines.push(`    elif (( _directive & ${CompletionDirective.FileCompletion} )); then`);
+	lines.push(`        compopt -o filenames 2>/dev/null`);
+	lines.push(`        local _p`);
+	lines.push(`        while IFS= read -r _p; do COMPREPLY+=("\${_ip}\${_p}"); done < <(compgen -f -- "$_cur")`);
+	lines.push(`    elif (( _directive & ${CompletionDirective.NoFileCompletion} )); then`);
+	lines.push(`        local _need_empty=0`);
+	lines.push(`        compopt +o default 2>/dev/null || _need_empty=1`);
+	lines.push(`        if (( _need_empty && \${#COMPREPLY[@]} == 0 )); then COMPREPLY=( "" ); fi`);
+	lines.push(`    fi`);
+	lines.push(`    if (( _directive & ${CompletionDirective.NoSpace} )); then`);
+	lines.push(`        compopt -o nospace 2>/dev/null`);
+	lines.push(`    fi`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`_${fn}_completions() {`);
+	lines.push(`    COMPREPLY=()`);
+	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(`    local _cur="" _inline_prefix=""`);
+	lines.push(`    (( \${#_words[@]} > 0 )) && _cur="\${_words[\${#_words[@]}-1]}"`);
+	lines.push(`    local _after_dd=0 _di=0`);
+	lines.push(`    while (( _di < \${#_words[@]} - 1 )); do`);
+	lines.push(`        [[ "\${_words[_di]}" == "--" ]] && { _after_dd=1; break; }`);
+	lines.push(`        (( _di++ ))`);
+	lines.push(`    done`);
+	lines.push(`    if (( ! _after_dd )) && [[ "$_cur" == -*=* ]]; then`);
+	lines.push(`        _inline_prefix="\${_cur%%=*}="`);
+	lines.push(`        _cur="\${_cur#*=}"`);
+	lines.push(`    fi`);
+	lines.push(`    local _bin _out _node_compile_cache _worker _bundled_worker _sig`);
+	lines.push(`    _bin="$(__${fn}_resolve_bin)" || _bin=""`);
+	lines.push(`    [[ -n "$_bin" ]] || return 0`);
+	lines.push(`    _node_compile_cache="$(__${fn}_node_compile_cache_dir)" || _node_compile_cache=""`);
+	lines.push(`    _bundled_worker="$(__${fn}_bundled_worker_path "$_bin" "$_node_compile_cache")" || _bundled_worker=""`);
+	lines.push(`    if [[ -n "$_bundled_worker" ]] && __${fn}_load_worker "$_bundled_worker"; then`);
+	lines.push(`        NODE_COMPILE_CACHE="$_node_compile_cache" ${workerBinEnvName}="$_bin" _${workerFn}_completions`);
+	lines.push(`        return 0`);
+	lines.push(`    fi`);
+	lines.push(`    _worker="$(__${fn}_static_worker_path)" || _worker=""`);
+	lines.push(`    _sig="$(__${fn}_bin_sig "$_bin")" || _sig=""`);
+	lines.push(`    if [[ -n "$_worker" && -n "$_sig" ]]; then`);
+	lines.push(`        if ! __${fn}_worker_matches_bin "$_worker" "$_sig" "$_bin"; then`);
+	lines.push(`            mkdir -p "\${_worker%/*}" 2>/dev/null`);
+	lines.push(`            NODE_COMPILE_CACHE="$_node_compile_cache" ${envName}="$_bin" "$_bin" __refresh-completion bash "$_worker" --static --worker 2>/dev/null`);
+	lines.push(`        fi`);
+	lines.push(`        if __${fn}_worker_matches_bin "$_worker" "$_sig" "$_bin" && __${fn}_load_worker "$_worker"; then`);
+	lines.push(`            NODE_COMPILE_CACHE="$_node_compile_cache" ${workerBinEnvName}="$_bin" _${workerFn}_completions`);
+	lines.push(`            return 0`);
+	lines.push(`        fi`);
+	lines.push(`    fi`);
+	lines.push(`    _out=$(NODE_COMPILE_CACHE="$_node_compile_cache" "$_bin" __complete --shell bash -- "\${_words[@]}" 2>/dev/null) || return 0`);
+	lines.push(`    __${fn}_apply_dynamic_output "$_out" "$_cur" "$_inline_prefix"`);
+	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 dispatcher bash completions, add this to your ~/.bashrc:
+eval "$(${programName} completion bash)"
+
+# To save the dispatcher script instead:
+mkdir -p ~/.local/share/bash-completion/completions
+${programName} completion bash > ~/.local/share/bash-completion/completions/${programName}
+
+# To generate the older static script:
+${programName} completion bash --static`
+	};
+}
+function zshDispatcher(_command, options) {
+	const { programName } = options;
+	const fn = sanitize(programName);
+	const workerFn = `${fn}_worker`;
+	const workerBinEnvName = binEnvVarName(workerFn);
+	const envName = binEnvVarName(fn);
+	const programLookup = shSingleQuote(programName);
+	const completionFn = `_${programName}`;
+	const autoloadCheck = `"\${funcstack[1]:-}" == "${completionFn}"`;
+	const compileCacheDefault = posixCacheDefault("print -r --", hardcodedCompileCacheDir(options.cacheDir), compileCacheSuffix(programName));
+	const workerPathDefault = posixCacheDefault("print -r --", hardcodedWorkerPath(options.cacheDir, "zsh"), workerPathSuffix(programName, "zsh"));
+	const workerRelList = shellWorkerRelList(options, "zsh");
+	const canQueryBundledWorkerPath = bundledWorkerPathCommandEnabled(options);
+	const lines = [];
+	lines.push(`#compdef ${programName}`);
+	lines.push(...buildHeaderLines({
+		programName,
+		shell: "zsh",
+		binPath: options.binPath,
+		programVersion: options.programVersion
+	}));
+	lines.push(`# Generated by politty`);
+	lines.push(`# politty-completion-mode: dispatcher`);
+	lines.push(``);
+	lines.push(`__${fn}_resolve_bin() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    if [[ -n "\${${envName}:-}" ]]; then`);
+	lines.push(`        print -r -- "\${${envName}}"`);
+	lines.push(`        return 0`);
+	lines.push(`    fi`);
+	lines.push(`    whence -p ${programLookup} 2>/dev/null`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_node_compile_cache_dir() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    if [[ -n "\${NODE_COMPILE_CACHE:-}" ]]; then`);
+	lines.push(`        print -r -- "$NODE_COMPILE_CACHE"`);
+	lines.push(`        return 0`);
+	lines.push(`    fi`);
+	lines.push(compileCacheDefault);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_static_worker_path() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(workerPathDefault);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_worker_file_sig() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    local _worker="$1" _sig`);
+	lines.push(`    _sig=${statSigExpr("$_worker", {
+		shell: "posix",
+		withSize: true
+	})} || return 1`);
+	lines.push(`    print -r -- "$_sig"`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_is_worker_file() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    local _worker="$1" _head`);
+	lines.push(`    [[ -f "$_worker" ]] || return 1`);
+	lines.push(`    _head="$(<$_worker)" || return 1`);
+	lines.push(`    _head=$'\\n'"$_head"$'\\n'`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# politty-completion-version: 1"$'\\n'* ]] || return 1`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# program: ${programName}"$'\\n'* ]] || return 1`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# shell: zsh"$'\\n'* ]] || return 1`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# politty-completion-mode: worker"$'\\n'* ]] || return 1`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# politty-completion-worker: true"$'\\n'* ]] || return 1`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_load_worker() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    local _worker="$1" _sig _key`);
+	lines.push(`    __${fn}_is_worker_file "$_worker" || return 1`);
+	lines.push(`    _sig="$(__${fn}_worker_file_sig "$_worker")" || return 1`);
+	lines.push(`    _key="$_worker:$_sig"`);
+	lines.push(`    if [[ "\${__${fn}_loaded_worker_key:-}" != "$_key" ]]; then`);
+	lines.push(`        source "$_worker" 2>/dev/null || return 1`);
+	lines.push(`        typeset -g __${fn}_loaded_worker_key="$_key"`);
+	lines.push(`    fi`);
+	lines.push(`    (( $+functions[_${workerFn}_completions] ))`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_realpath() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    local _path="$1"`);
+	lines.push(`    [[ -n "$_path" ]] || return 1`);
+	lines.push(`    print -r -- "\${_path:A}"`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_worker_from_dir() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    local _dir="$1" _rel _candidate`);
+	if (workerRelList.length > 0) {
+		lines.push(`    for _rel in ${workerRelList}; do`);
+		lines.push(`        [[ "$_rel" == /* ]] && _candidate="$_rel" || _candidate="$_dir/$_rel"`);
+		lines.push(`        if __${fn}_is_worker_file "$_candidate"; then`);
+		lines.push(`            print -r -- "$_candidate"`);
+		lines.push(`            return 0`);
+		lines.push(`        fi`);
+		lines.push(`    done`);
+	}
+	lines.push(`    return 1`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_cmd_shim_target() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    [[ -f "$1" ]] || return 0`);
+	lines.push(`    local _l _t=""`);
+	lines.push(`    for _l in "\${(@f)$(<$1)}"; do`);
+	lines.push(`        [[ "$_l" == "# cmd-shim-target="* ]] && _t="\${_l#\\# cmd-shim-target=}"`);
+	lines.push(`    done`);
+	lines.push(`    [[ -n "$_t" ]] && print -r -- "$_t"`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_bundled_worker_path() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    local _bin="$1" _node_compile_cache="\${2:-}" _real _dir _target _reported`);
+	lines.push(`    _real="$(__${fn}_realpath "$_bin" 2>/dev/null)" || _real=""`);
+	lines.push(`    if [[ -n "$_real" ]]; then`);
+	lines.push(`        _dir="\${_real:h}"`);
+	lines.push(`        __${fn}_worker_from_dir "$_dir" && return 0`);
+	lines.push(`    fi`);
+	lines.push(`    _dir="\${_bin:h}"`);
+	lines.push(`    __${fn}_worker_from_dir "$_dir" && return 0`);
+	lines.push(`    _target="$(__${fn}_cmd_shim_target "$_bin")"`);
+	lines.push(`    if [[ -n "$_target" ]]; then`);
+	lines.push(`        _real="$(__${fn}_realpath "$_target" 2>/dev/null)" || _real="$_target"`);
+	lines.push(`        _dir="\${_real:h}"`);
+	lines.push(`        __${fn}_worker_from_dir "$_dir" && return 0`);
+	lines.push(`    fi`);
+	if (canQueryBundledWorkerPath) {
+		lines.push(`    if [[ "\${__${fn}_queried_bin:-}" == "$_bin" && -n "\${__${fn}_queried_worker:-}" ]] && __${fn}_is_worker_file "\${__${fn}_queried_worker}"; then`);
+		lines.push(`        print -r -- "\${__${fn}_queried_worker}"`);
+		lines.push(`        return 0`);
+		lines.push(`    fi`);
+		lines.push(`    _reported="$(NODE_COMPILE_CACHE="$_node_compile_cache" "$_bin" __completion-worker-path zsh 2>/dev/null)" || _reported=""`);
+		lines.push(`    if [[ -n "$_reported" ]] && __${fn}_is_worker_file "$_reported"; then`);
+		lines.push(`        typeset -g __${fn}_queried_bin="$_bin"`);
+		lines.push(`        typeset -g __${fn}_queried_worker="$_reported"`);
+		lines.push(`        print -r -- "$_reported"`);
+		lines.push(`        return 0`);
+		lines.push(`    fi`);
+	}
+	lines.push(`    return 1`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_bin_sig() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    local _bin="$1" _sig`);
+	lines.push(`    _sig=${statSigExpr("$_bin", { shell: "posix" })} || return 1`);
+	lines.push(`    print -r -- "$_sig"`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_worker_matches_bin() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    local _worker="$1" _sig="$2" _bin="$3" _head`);
+	lines.push(`    [[ -f "$_worker" ]] || return 1`);
+	lines.push(`    _head=$'\\n'"$(<$_worker)"$'\\n'`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# politty-bin-sig: $_sig"$'\\n'* ]] || return 1`);
+	lines.push(`    [[ "$_head" == *$'\\n'"# politty-bin-path: $_bin"$'\\n'* ]] || return 1`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_cdescribe() {`);
+	lines.push(`    _describe "$@" 2>/dev/null && return 0`);
+	lines.push(`    shift`);
+	lines.push(`    local _cd_arr="$1"`);
+	lines.push(`    shift`);
+	lines.push(`    local -a _cd_vals=("\${(@)\${(P)_cd_arr}%%:*}")`);
+	lines.push(`    compadd "$@" -a _cd_vals 2>/dev/null`);
+	lines.push(`    return 0`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_add_path_candidate() {`);
+	lines.push(`    compadd -f -- "$1" 2>/dev/null && return 0`);
+	lines.push(`    print -r -- "$1"`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`__${fn}_apply_dynamic_output() {`);
+	lines.push(`    local _raw="$1"`);
+	lines.push(`    local _directive=0`);
+	lines.push(`    local -a _vals _lines _exts _matchers`);
+	lines.push(`    local _meta`);
+	lines.push(`    _lines=("\${(@f)_raw}")`);
+	lines.push(`    local _last=$#_lines`);
+	lines.push(`    if (( _last >= 1 )) && [[ "\${_lines[$_last]}" == :<->* ]]; then`);
+	lines.push(`        local _dline="\${_lines[$_last]}"`);
+	lines.push(`        _lines[$_last]=()`);
+	lines.push(`        local -a _dfields`);
+	lines.push(`        _dfields=("\${(@ps:\\t:)_dline}")`);
+	lines.push(`        _directive="\${_dfields[1]#:}"`);
+	lines.push(`        local _m`);
+	lines.push(`        for _m in "\${(@)_dfields[2,-1]}"; do`);
+	lines.push(`            if [[ "$_m" == @ext:* ]]; then`);
+	lines.push(`                _meta="\${_m#@ext:}"`);
+	lines.push(`                _exts=("\${(@s:,:)_meta}")`);
+	lines.push(`            elif [[ "$_m" == @matcher:* ]]; then`);
+	lines.push(`                _meta="\${_m#@matcher:}"`);
+	lines.push(`                _matchers=("\${(@s:,:)_meta}")`);
+	lines.push(`            fi`);
+	lines.push(`        done`);
+	lines.push(`    fi`);
+	lines.push(`    local _l`);
+	lines.push(`    for _l in "\${_lines[@]}"; do`);
+	lines.push(`        [[ -z "$_l" ]] && continue`);
+	lines.push(`        _vals+=("$_l")`);
+	lines.push(`    done`);
+	lines.push(`    if (( \${#_vals[@]} > 0 )); then`);
+	lines.push(`        if (( _directive & ${CompletionDirective.NoSpace} )); then`);
+	lines.push(`            __${fn}_cdescribe 'completions' _vals -S ''`);
+	lines.push(`        else`);
+	lines.push(`            __${fn}_cdescribe 'completions' _vals`);
+	lines.push(`        fi`);
+	lines.push(`    fi`);
+	lines.push(`    if (( \${#_exts[@]} > 0 || \${#_matchers[@]} > 0 )); then`);
+	lines.push(`        setopt local_options null_glob`);
+	lines.push(`        local _cur="\${words[CURRENT]:-}" _dir _prefix _f _out _ext _pat`);
+	lines.push(`        if [[ -z "$_cur" || "$_cur" != */* ]]; then`);
+	lines.push(`            _dir="."`);
+	lines.push(`            _prefix="$_cur"`);
+	lines.push(`        elif [[ "$_cur" == */ ]]; then`);
+	lines.push(`            _dir="\${_cur%/}"`);
+	lines.push(`            _prefix=""`);
+	lines.push(`        else`);
+	lines.push(`            _dir="\${_cur%/*}"`);
+	lines.push(`            _prefix="\${_cur##*/}"`);
+	lines.push(`        fi`);
+	lines.push(`        for _f in "$_dir"/"$_prefix"*(N/); do`);
+	lines.push(`            _out="\${_f#./}"`);
+	lines.push(`            __${fn}_add_path_candidate "$_out"`);
+	lines.push(`        done`);
+	lines.push(`        for _f in "$_dir"/"$_prefix"*(N.); do`);
+	lines.push(`            _out="\${_f#./}"`);
+	lines.push(`            for _ext in "\${_exts[@]}"; do`);
+	lines.push(`                [[ -n "$_ext" && "$_out" == *."$_ext" ]] && { __${fn}_add_path_candidate "$_out"; break; }`);
+	lines.push(`            done`);
+	lines.push(`        done`);
+	lines.push(`        for _pat in "\${_matchers[@]}"; do`);
+	lines.push(`            [[ -n "$_pat" ]] || continue`);
+	lines.push(`            for _f in "$_dir"/\${~_pat}(N.); do`);
+	lines.push(`                _out="\${_f#./}"`);
+	lines.push(`                [[ "$_out" == "$_cur"* ]] && __${fn}_add_path_candidate "$_out"`);
+	lines.push(`            done`);
+	lines.push(`        done`);
+	lines.push(`    elif (( _directive & ${CompletionDirective.DirectoryCompletion} )); then`);
+	lines.push(`        _files -/`);
+	lines.push(`    elif (( _directive & ${CompletionDirective.FileCompletion} )); then`);
+	lines.push(`        _files`);
+	lines.push(`    elif (( \${#_vals[@]} == 0 )) && ! (( _directive & ${CompletionDirective.NoFileCompletion} )); then`);
+	lines.push(`        _files`);
+	lines.push(`    fi`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`${completionFn}() {`);
+	lines.push(`    emulate -L zsh`);
+	lines.push(`    setopt local_options no_aliases`);
+	lines.push(`    local _bin _out _node_compile_cache _worker _bundled_worker _sig`);
+	lines.push(`    _bin="$(__${fn}_resolve_bin)"`);
+	lines.push(`    [[ -n "$_bin" ]] || return 1`);
+	lines.push(`    _node_compile_cache="$(__${fn}_node_compile_cache_dir)"`);
+	lines.push(`    _bundled_worker="$(__${fn}_bundled_worker_path "$_bin" "$_node_compile_cache")"`);
+	lines.push(`    if [[ -n "$_bundled_worker" ]] && __${fn}_load_worker "$_bundled_worker"; then`);
+	lines.push(`        NODE_COMPILE_CACHE="$_node_compile_cache" ${workerBinEnvName}="$_bin" _${workerFn}_completions "$@"`);
+	lines.push(`        return 0`);
+	lines.push(`    fi`);
+	lines.push(`    _worker="$(__${fn}_static_worker_path)"`);
+	lines.push(`    _sig="$(__${fn}_bin_sig "$_bin")"`);
+	lines.push(`    if [[ -n "$_worker" && -n "$_sig" ]]; then`);
+	lines.push(`        if ! __${fn}_worker_matches_bin "$_worker" "$_sig" "$_bin"; then`);
+	lines.push(`            mkdir -p "\${_worker%/*}" 2>/dev/null`);
+	lines.push(`            NODE_COMPILE_CACHE="$_node_compile_cache" ${envName}="$_bin" "$_bin" __refresh-completion zsh "$_worker" --static --worker 2>/dev/null`);
+	lines.push(`        fi`);
+	lines.push(`        if __${fn}_worker_matches_bin "$_worker" "$_sig" "$_bin" && __${fn}_load_worker "$_worker"; then`);
+	lines.push(`            NODE_COMPILE_CACHE="$_node_compile_cache" ${workerBinEnvName}="$_bin" _${workerFn}_completions "$@"`);
+	lines.push(`            return 0`);
+	lines.push(`        fi`);
+	lines.push(`    fi`);
+	lines.push(`    _out=$(NODE_COMPILE_CACHE="$_node_compile_cache" "$_bin" __complete --shell zsh -- "\${(@)words[2,CURRENT]}" 2>/dev/null) || return 1`);
+	lines.push(`    __${fn}_apply_dynamic_output "$_out"`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`zstyle ':completion:*:*:${programName}:*' file-patterns '%p:globbed-files *(-/):directories'`);
+	lines.push(``);
+	lines.push(`if [[ ${autoloadCheck} ]]; then`);
+	lines.push(`    ${completionFn} "$@"`);
+	lines.push(`else`);
+	lines.push(`    compdef ${completionFn} ${programName}`);
+	lines.push(`fi`);
+	lines.push(``);
+	return {
+		script: lines.join("\n"),
+		shell: "zsh",
+		installInstructions: `# To enable dispatcher zsh completions, add this to your ~/.zshrc after compinit:
+eval "$(${programName} completion zsh)"
+
+# To save the dispatcher script in your fpath:
+mkdir -p ~/.zsh/completions
+${programName} completion zsh > ~/.zsh/completions/_${programName}
+
+# Make sure your ~/.zshrc includes the fpath line before compinit:
+fpath=(~/.zsh/completions $fpath)
+autoload -Uz compinit && compinit
+
+# To generate the older static script:
+${programName} completion zsh --static`
+	};
+}
+function fishDispatcher(_command, options) {
+	const { programName } = options;
+	const fn = sanitize(programName);
+	const workerFn = `${fn}_worker`;
+	const workerBinEnvName = binEnvVarName(workerFn);
+	const envName = binEnvVarName(fn);
+	const programLookup = shSingleQuote(programName);
+	const compileCacheDefault = fishCacheDefault(hardcodedCompileCacheDir(options.cacheDir), compileCacheSuffix(programName));
+	const workerPathDefault = fishCacheDefault(hardcodedWorkerPath(options.cacheDir, "fish"), workerPathSuffix(programName, "fish"));
+	const workerRelList = fishWorkerRelList(options);
+	const canQueryBundledWorkerPath = bundledWorkerPathCommandEnabled(options);
+	const lines = [];
+	lines.push(...buildHeaderLines({
+		programName,
+		shell: "fish",
+		binPath: options.binPath,
+		programVersion: options.programVersion
+	}));
+	lines.push(`# Generated by politty`);
+	lines.push(`# politty-completion-mode: dispatcher`);
+	lines.push(``);
+	lines.push(`function __${fn}_resolve_bin`);
+	lines.push(`    if set -q ${envName}; and test -n "$${envName}"`);
+	lines.push(`        printf '%s\\n' "$${envName}"`);
+	lines.push(`        return 0`);
+	lines.push(`    end`);
+	lines.push(`    set -l _bin (command -v ${programLookup})`);
+	lines.push(`    test -n "$_bin"; and test -x "$_bin"; and not test -d "$_bin"; and printf '%s\\n' "$_bin"`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_node_compile_cache_dir`);
+	lines.push(`    if set -q NODE_COMPILE_CACHE; and test -n "$NODE_COMPILE_CACHE"`);
+	lines.push(`        printf '%s\\n' "$NODE_COMPILE_CACHE"`);
+	lines.push(`        return 0`);
+	lines.push(`    end`);
+	lines.push(compileCacheDefault);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_static_worker_path`);
+	lines.push(workerPathDefault);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_worker_file_sig`);
+	lines.push(`    set -l _worker $argv[1]`);
+	lines.push(`    set -l _sig ${statSigExpr("$_worker", {
+		shell: "fish",
+		withSize: true
+	})}`);
+	lines.push(`    test -n "$_sig"; and printf '%s\\n' "$_sig"`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_is_worker_file`);
+	lines.push(`    set -l _worker $argv[1]`);
+	lines.push(`    test -f "$_worker"; or return 1`);
+	lines.push(`    set -l _head (head -n 24 "$_worker" 2>/dev/null)`);
+	lines.push(`    string match -q -- "# politty-completion-version: 1" $_head; or return 1`);
+	lines.push(`    string match -q -- "# program: ${programName}" $_head; or return 1`);
+	lines.push(`    string match -q -- "# shell: fish" $_head; or return 1`);
+	lines.push(`    string match -q -- "# politty-completion-mode: worker" $_head; or return 1`);
+	lines.push(`    string match -q -- "# politty-completion-worker: true" $_head; or return 1`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_load_worker`);
+	lines.push(`    set -l _worker $argv[1]`);
+	lines.push(`    __${fn}_is_worker_file "$_worker"; or return 1`);
+	lines.push(`    set -l _sig (__${fn}_worker_file_sig "$_worker")`);
+	lines.push(`    test -n "$_sig"; or return 1`);
+	lines.push(`    set -l _key "$_worker:$_sig"`);
+	lines.push(`    if not set -q __${fn}_loaded_worker_key; or test "$__${fn}_loaded_worker_key" != "$_key"`);
+	lines.push(`        source "$_worker" 2>/dev/null; or return 1`);
+	lines.push(`        set -g __${fn}_loaded_worker_key "$_key"`);
+	lines.push(`    end`);
+	lines.push(`    functions -q __fish_${workerFn}_complete`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_realpath`);
+	lines.push(`    set -l _path $argv[1]`);
+	lines.push(`    set -l _old_pwd (pwd)`);
+	lines.push(`    set -l _limit 0`);
+	lines.push(`    while test -L "$_path"; and test $_limit -lt 40`);
+	lines.push(`        set -l _dir (dirname "$_path")`);
+	lines.push(`        if not cd "$_dir" 2>/dev/null`);
+	lines.push(`            cd "$_old_pwd" 2>/dev/null`);
+	lines.push(`            return 1`);
+	lines.push(`        end`);
+	lines.push(`        set -l _absdir (pwd -P)`);
+	lines.push(`        cd "$_old_pwd" 2>/dev/null`);
+	lines.push(`        test -n "$_absdir"; or return 1`);
+	lines.push(`        set -l _target (readlink "$_path")`);
+	lines.push(`        test -n "$_target"; or return 1`);
+	lines.push(`        if string match -q '/*' -- "$_target"`);
+	lines.push(`            set _path "$_target"`);
+	lines.push(`        else`);
+	lines.push(`            set _path "$_absdir/$_target"`);
+	lines.push(`        end`);
+	lines.push(`        set _limit (math $_limit + 1)`);
+	lines.push(`    end`);
+	lines.push(`    set -l _dir (dirname "$_path")`);
+	lines.push(`    if not cd "$_dir" 2>/dev/null`);
+	lines.push(`        cd "$_old_pwd" 2>/dev/null`);
+	lines.push(`        return 1`);
+	lines.push(`    end`);
+	lines.push(`    set -l _absdir (pwd -P)`);
+	lines.push(`    cd "$_old_pwd" 2>/dev/null`);
+	lines.push(`    test -n "$_absdir"; or return 1`);
+	lines.push(`    set -l _base (basename "$_path")`);
+	lines.push(`    printf '%s\\n' "$_absdir/$_base"`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_worker_from_dir`);
+	lines.push(`    set -l _dir $argv[1]`);
+	if (workerRelList.length > 0) {
+		lines.push(`    for _rel in ${workerRelList}`);
+		lines.push(`        if string match -q '/*' -- "$_rel"`);
+		lines.push(`            set _candidate "$_rel"`);
+		lines.push(`        else`);
+		lines.push(`            set _candidate "$_dir/$_rel"`);
+		lines.push(`        end`);
+		lines.push(`        if __${fn}_is_worker_file "$_candidate"`);
+		lines.push(`            printf '%s\\n' "$_candidate"`);
+		lines.push(`            return 0`);
+		lines.push(`        end`);
+		lines.push(`    end`);
+	}
+	lines.push(`    return 1`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_cmd_shim_target`);
+	lines.push(`    sed -n 's/^# cmd-shim-target=//p' "$argv[1]" 2>/dev/null | tail -n 1`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_bundled_worker_path`);
+	lines.push(`    set -l _bin $argv[1]`);
+	lines.push(`    set -l _node_compile_cache $argv[2]`);
+	lines.push(`    set -l _real (__${fn}_realpath "$_bin" 2>/dev/null)`);
+	lines.push(`    if test -n "$_real"`);
+	lines.push(`        set -l _dir (dirname "$_real")`);
+	lines.push(`        __${fn}_worker_from_dir "$_dir"; and return 0`);
+	lines.push(`    end`);
+	lines.push(`    set -l _dir (dirname "$_bin")`);
+	lines.push(`    __${fn}_worker_from_dir "$_dir"; and return 0`);
+	lines.push(`    set -l _target (__${fn}_cmd_shim_target "$_bin")`);
+	lines.push(`    if test -n "$_target"`);
+	lines.push(`        set _real (__${fn}_realpath "$_target" 2>/dev/null)`);
+	lines.push(`        test -n "$_real"; or set _real "$_target"`);
+	lines.push(`        set _dir (dirname "$_real")`);
+	lines.push(`        __${fn}_worker_from_dir "$_dir"; and return 0`);
+	lines.push(`    end`);
+	if (canQueryBundledWorkerPath) {
+		lines.push(`    if set -q __${fn}_queried_bin; and test "$__${fn}_queried_bin" = "$_bin"; and test -n "$__${fn}_queried_worker"; and __${fn}_is_worker_file "$__${fn}_queried_worker"`);
+		lines.push(`        printf '%s\\n' "$__${fn}_queried_worker"`);
+		lines.push(`        return 0`);
+		lines.push(`    end`);
+		lines.push(`    set -l _reported (env NODE_COMPILE_CACHE="$_node_compile_cache" "$_bin" __completion-worker-path fish 2>/dev/null)`);
+		lines.push(`    if test -n "$_reported"; and __${fn}_is_worker_file "$_reported"`);
+		lines.push(`        set -g __${fn}_queried_bin "$_bin"`);
+		lines.push(`        set -g __${fn}_queried_worker "$_reported"`);
+		lines.push(`        printf '%s\\n' "$_reported"`);
+		lines.push(`        return 0`);
+		lines.push(`    end`);
+	}
+	lines.push(`    return 1`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_bin_sig`);
+	lines.push(`    set -l _bin $argv[1]`);
+	lines.push(`    set -l _sig ${statSigExpr("$_bin", { shell: "fish" })}`);
+	lines.push(`    test -n "$_sig"; and printf '%s\\n' "$_sig"`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_worker_matches_bin`);
+	lines.push(`    set -l _worker $argv[1]`);
+	lines.push(`    set -l _sig $argv[2]`);
+	lines.push(`    set -l _bin $argv[3]`);
+	lines.push(`    test -f "$_worker"; or return 1`);
+	lines.push(`    set -l _head (head -n 12 "$_worker" 2>/dev/null)`);
+	lines.push(`    contains -- "# politty-bin-sig: $_sig" $_head; or return 1`);
+	lines.push(`    contains -- "# politty-bin-path: $_bin" $_head; or return 1`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __${fn}_apply_dynamic_output`);
+	lines.push(`    set -l _cur $argv[1]`);
+	lines.push(`    set -l _directive 0`);
+	lines.push(`    set -l _emitted 0`);
+	lines.push(`    set -l _exts`);
+	lines.push(`    set -l _matchers`);
+	lines.push(`    set -l _lines`);
+	lines.push(`    while read -l _l`);
+	lines.push(`        set -a _lines $_l`);
+	lines.push(`    end`);
+	lines.push(`    set -l _n (count $_lines)`);
+	lines.push(`    if test $_n -ge 1; and string match -qr '^:[0-9]+' -- $_lines[$_n]`);
+	lines.push(`        set -l _fields (string split \\t -- $_lines[$_n])`);
+	lines.push(`        set -e _lines[$_n]`);
+	lines.push(`        set _directive (string sub -s 2 -- $_fields[1])`);
+	lines.push(`        for _f in $_fields[2..-1]`);
+	lines.push(`            if string match -q '@ext:*' -- $_f`);
+	lines.push(`                set _exts (string split , -- (string sub -s 6 -- $_f))`);
+	lines.push(`            else if string match -q '@matcher:*' -- $_f`);
+	lines.push(`                set _matchers (string split , -- (string sub -s 10 -- $_f))`);
+	lines.push(`            end`);
+	lines.push(`        end`);
+	lines.push(`    end`);
+	lines.push(`    for _l in $_lines`);
+	lines.push(`        if test -n "$_l"`);
+	lines.push(`            printf '%s\\n' $_l`);
+	lines.push(`            set _emitted 1`);
+	lines.push(`        end`);
+	lines.push(`    end`);
+	lines.push(`    if test (count $_exts) -gt 0; or test (count $_matchers) -gt 0`);
+	lines.push(`        __fish_complete_directories "$_cur"`);
+	lines.push(`        set -l _dir ""`);
+	lines.push(`        if string match -q '*/*' "$_cur"`);
+	lines.push(`            set _dir (string replace -r '[^/]*$' '' "$_cur")`);
+	lines.push(`        end`);
+	lines.push(`        for _f in "$_cur"*`);
+	lines.push(`            test -f "$_f"; or continue`);
+	lines.push(`            for _ext in $_exts`);
+	lines.push(`                if string match -q -- "*.$_ext" "$_f"`);
+	lines.push(`                    printf '%s\\n' "$_f"`);
+	lines.push(`                    break`);
+	lines.push(`                end`);
+	lines.push(`            end`);
+	lines.push(`        end`);
+	lines.push(`        for _pat in $_matchers`);
+	lines.push(`            for _f in "$_dir"$_pat`);
+	lines.push(`                test -f "$_f"; and string match -q "$_cur*" "$_f"; and printf '%s\\n' "$_f"`);
+	lines.push(`            end`);
+	lines.push(`        end`);
+	lines.push(`    else if test (math "bitand($_directive, ${CompletionDirective.DirectoryCompletion})") -ne 0`);
+	lines.push(`        __fish_complete_directories "$_cur"`);
+	lines.push(`    else if test (math "bitand($_directive, ${CompletionDirective.FileCompletion})") -ne 0`);
+	lines.push(`        __fish_complete_path "$_cur"`);
+	lines.push(`    else if test $_emitted -eq 0; and test (math "bitand($_directive, ${CompletionDirective.NoFileCompletion})") -eq 0`);
+	lines.push(`        __fish_complete_path "$_cur"`);
+	lines.push(`    end`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`function __fish_${fn}_complete`);
+	lines.push(`    set -l _bin (__${fn}_resolve_bin)`);
+	lines.push(`    test -n "$_bin"; or return 0`);
+	lines.push(`    set -l _node_compile_cache (__${fn}_node_compile_cache_dir)`);
+	lines.push(`    set -l _bundled_worker (__${fn}_bundled_worker_path "$_bin" "$_node_compile_cache")`);
+	lines.push(`    if test -n "$_bundled_worker"; and __${fn}_load_worker "$_bundled_worker"`);
+	lines.push(`        set -lx ${workerBinEnvName} "$_bin"`);
+	lines.push(`        set -lx NODE_COMPILE_CACHE "$_node_compile_cache"`);
+	lines.push(`        __fish_${workerFn}_complete`);
+	lines.push(`        return 0`);
+	lines.push(`    end`);
+	lines.push(`    set -l _worker (__${fn}_static_worker_path)`);
+	lines.push(`    set -l _sig (__${fn}_bin_sig "$_bin")`);
+	lines.push(`    if test -n "$_worker"; and test -n "$_sig"`);
+	lines.push(`        if not __${fn}_worker_matches_bin "$_worker" "$_sig" "$_bin"`);
+	lines.push(`            mkdir -p (dirname "$_worker") 2>/dev/null`);
+	lines.push(`            env NODE_COMPILE_CACHE="$_node_compile_cache" ${envName}="$_bin" $_bin __refresh-completion fish "$_worker" --static --worker 2>/dev/null`);
+	lines.push(`        end`);
+	lines.push(`        if __${fn}_worker_matches_bin "$_worker" "$_sig" "$_bin"`);
+	lines.push(`            if __${fn}_load_worker "$_worker"`);
+	lines.push(`                set -lx ${workerBinEnvName} "$_bin"`);
+	lines.push(`                set -lx NODE_COMPILE_CACHE "$_node_compile_cache"`);
+	lines.push(`                __fish_${workerFn}_complete`);
+	lines.push(`                return 0`);
+	lines.push(`            end`);
+	lines.push(`        end`);
+	lines.push(`    end`);
+	lines.push(`    set -l _args (commandline -opc)`);
+	lines.push(`    set -l _cur (commandline -ct)`);
+	lines.push(`    if test (count $_args) -gt 0`);
+	lines.push(`        set _args $_args[2..]`);
+	lines.push(`    end`);
+	lines.push(`    env NODE_COMPILE_CACHE="$_node_compile_cache" $_bin __complete --shell fish -- $_args "$_cur" 2>/dev/null | __${fn}_apply_dynamic_output "$_cur"`);
+	lines.push(`end`);
+	lines.push(``);
+	lines.push(`complete -e -c ${programName}`);
+	lines.push(`complete -c ${programName} -f -a '(__fish_${fn}_complete)'`);
+	lines.push(``);
+	return {
+		script: lines.join("\n"),
+		shell: "fish",
+		installInstructions: `# To enable dispatcher fish completions, run:
+${programName} completion fish --install
+
+# To generate the older static script:
+${programName} completion fish --static`
+	};
+}
+function generateDispatcherCompletion(command, options) {
+	extractCompletionData(command, options.programName, options.globalArgsSchema, true);
+	switch (options.shell) {
+		case "bash": return bashDispatcher(command, options);
+		case "zsh": return zshDispatcher(command, options);
+		case "fish": return fishDispatcher(command, options);
+		default: throw new Error(`Unsupported shell: ${options.shell}`);
+	}
+}
+
+//#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);
+	}
+}
+/**
+* Append extension metadata and directive to output lines
+*/
+function appendMetadata(lines, result) {
+	let directiveLine = `:${result.directive}`;
+	if (result.fileExtensions && result.fileExtensions.length > 0) directiveLine += `\t@ext:${result.fileExtensions.join(",")}`;
+	if (result.fileMatchers && result.fileMatchers.length > 0) directiveLine += `\t@matcher:${result.fileMatchers.join(",")}`;
+	lines.push(directiveLine);
+}
+/**
+* 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) {
+	const lines = ((result.directive & CompletionDirective.FilterPrefix) !== 0 && options.currentWord ? result.candidates.filter((c) => c.value.startsWith(options.currentWord)) : result.candidates).map((c) => options.inlinePrefix ? `${options.inlinePrefix}${c.value}` : 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
+*/
+/**
+* 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)
+* @param globalArgsSchema - Global args schema. Forwarded to
+*   `parseCompletionContext` so resolvers attached to global options remain
+*   reachable at every subcommand level.
+* @returns A command that outputs completion candidates
+*/
+function createDynamicCompleteCommand(rootCommand, _programName, globalArgsSchema) {
+	return defineCommand({
+		name: "__complete",
+		args: completeArgsSchema,
+		async run(args) {
+			const context = parseCompletionContext(args.args, rootCommand, globalArgsSchema);
+			const inlinePrefix = context.completionType === "option-value" && context.targetOption ? detectInlineOptionPrefix(context.currentWord) : void 0;
+			const effectiveWord = inlinePrefix ? context.currentWord.slice(inlinePrefix.length) : context.currentWord;
+			const output = formatForShell(await generateCandidates(context, { shell: args.shell }), {
+				shell: args.shell,
+				currentWord: effectiveWord,
+				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, "\\$");
+}
+/**
+* Escape a fish `switch` case pattern. Fish's `case` interprets its
+* arguments as globs even when double-quoted, so glob metacharacters
+* (`*`, `?`, `[`, `]`) must be backslash-escaped to keep the comparison
+* literal — otherwise a key like `prod*` would also match a runtime
+* value of `production`. Quote/dollar/backslash are escaped first so the
+* resulting string remains valid inside a double-quoted literal.
+*/
+function fishCaseEscape(s) {
+	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$").replace(/\*/g, "\\*").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).
+*
+* `location` is required for the expand variant (carries fieldName +
+* isArrayOption); other variants ignore it.
+*/
+function fishValueLines(vc, fn, location) {
+	if (!vc) return [];
+	switch (vc.type) {
+		case "expand": {
+			if (!location) throw new Error("fishValueLines: expand variant requires a location");
+			const depExpr = (d) => {
+				const safe = sanitize(d.name);
+				return d.isGlobal ? `$_global_arg_values_${safe}` : `$_arg_values_${safe}`;
+			};
+			const depKey = location.resolvedDeps.map((d) => `"${depExpr(d)}"`).join(`\\x1f`);
+			const bucket = sanitize(location.fieldName);
+			const bucketList = location.isGlobal ? `$_global_used_field_keys_${bucket}` : `$_used_field_keys_${bucket}`;
+			const out = [`switch ${depKey}`];
+			for (const entry of vc.table) {
+				const casePattern = entry.key.map((k) => `"${fishCaseEscape(k)}"`).join(`\\x1f`);
+				out.push(`    case ${casePattern}`);
+				const keyOnlyLines = [];
+				const fullLines = [];
+				const seenKeys = /* @__PURE__ */ new Set();
+				const printfLine = (value, description) => description ? `printf '%s\\t%s\\n' "${escapeDesc$1(value)}" "${escapeDesc$1(description)}"` : `printf '%s\\n' "${escapeDesc$1(value)}"`;
+				const wrapWithDedup = (echoLine, keyPart) => location.isArrayOption && keyPart.length > 0 ? [
+					`        if not contains -- "${escapeDesc$1(keyPart)}" ${bucketList}`,
 					`            ${echoLine}`,
 					`        end`
 				] : [`        ${echoLine}`];
@@ -2657,6 +4011,7 @@ function fishValueLines(vc, fn, location) {
 			`end`
 		];
 		case "none": return [];
+		case "runtime-expand": return [];
 	}
 }
 /** Generate fish matcher-filtered file completion */
@@ -2678,9 +4033,13 @@ function fishMatcherLines(patterns) {
 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"`);
+	if (extensions.length > 0) {
+		const extMatch = extensions.map((ext) => `string match -q -- "*.${ext}" "$_f"`).join("; or ");
+		lines.push(`for _f in "$_cur"*`);
+		lines.push(`    test -f "$_f"; or continue`);
+		lines.push(`    if ${extMatch}`);
+		lines.push(`        echo "$_f"`);
+		lines.push(`    end`);
 		lines.push(`end`);
 	}
 	return lines;
@@ -2717,6 +4076,27 @@ function positionalBlock$1(positionals, fn, options = []) {
 	}
 	return lines;
 }
+/**
+* Subcommand-name echoes. When the same node also has positionals, complete
+* subcommand names only while the cursor still prefixes one and fall through to
+* positional completion otherwise. Returns lines at base indentation; callers
+* re-indent for their handler depth.
+*/
+function subOrPositionalLines$1(subItems, positionals, fn, options) {
+	const echoSubs = subItems.map((s) => `echo "${s.name}\t${escapeDesc$1(s.description ?? "")}"`);
+	if (positionals.length === 0) return echoSubs;
+	return [
+		`set -l _sub_match 0`,
+		`for _sub_name in ${subItems.map((s) => `"${escapeDesc$1(s.name)}"`).join(" ")}`,
+		`    test (string sub -l (string length -- "$_cur") -- "$_sub_name") = "$_cur"; and set _sub_match 1; and break`,
+		`end`,
+		`if test $_sub_match -eq 1`,
+		...echoSubs.map((l) => `    ${l}`),
+		`else`,
+		...positionalBlock$1(positionals, fn, options),
+		`end`
+	];
+}
 /** Generate available-option echo lines for fish */
 function availableOptionLines$1(options, fn) {
 	const lines = [];
@@ -2772,11 +4152,10 @@ function generateSubHandler$1(sub, fn, path) {
 	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, fn, sub.options));
+	if (visibleSubs.length > 0) {
+		const subItems = getSubNamesWithAliases(sub.subcommands);
+		lines.push(...subOrPositionalLines$1(subItems, sub.positionals, fn, sub.options).map((l) => `    ${l}`));
+	} else if (sub.positionals.length > 0) lines.push(...positionalBlock$1(sub.positionals, fn, sub.options));
 	lines.push(`end`);
 	lines.push(``);
 	return lines;
@@ -2794,7 +4173,9 @@ function optTakesValueCases(sub, parentPath) {
 function generateFishCompletion(command, options) {
 	const { programName } = options;
 	const data = extractCompletionData(command, programName, options.globalArgsSchema);
-	const fn = sanitize(programName);
+	const baseFn = sanitize(programName);
+	const fn = options.staticWorker ? `${baseFn}_${sanitize(options.staticWorker.functionSuffix)}` : baseFn;
+	const isWorker = options.staticWorker !== void 0;
 	const root = data.command;
 	const visibleSubs = getVisibleSubs(root.subcommands);
 	const expandSpecs = collectExpandSpecs(root);
@@ -2809,26 +4190,34 @@ function generateFishCompletion(command, options) {
 		binPath: options.binPath,
 		programVersion: options.programVersion
 	}));
+	lines.push(`# politty-completion-mode: ${isWorker ? "worker" : "static"}`);
+	if (isWorker) lines.push(`# politty-completion-worker: true`);
 	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(``);
+	if (!isWorker) {
+		const resolvedBinPath = resolveBinPath(programName, options.binPath);
+		const sig = computeBinSig(resolvedBinPath);
+		const refreshEnvName = binEnvVarName(baseFn);
+		const refreshFn = `__${fn}_refresh_completion`;
+		lines.push(`function ${refreshFn} --no-scope-shadowing`);
+		lines.push(`    set -l _bin $${refreshEnvName}`);
+		lines.push(`    test -z "$_bin"; and set _bin (command -v ${programName})`);
+		lines.push(`    test -z "$_bin"; and return 1`);
+		lines.push(`    set -l _sig ${statSigExpr("$_bin", { shell: "fish" })}`);
+		lines.push(`    test "$_sig" = "${sig}"; and test "$_bin" = "${escapeDesc$1(resolvedBinPath)}"; and return 1`);
+		lines.push(`    set -l _target (status current-filename)`);
+		lines.push(`    test -n "$_target"; and test -f "$_target"; or return 1`);
+		lines.push(`    "$_bin" __refresh-completion fish "$_target" --static 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(``);
+	}
 	if (hasDynamicCompletion(root)) {
 		lines.push(`function __${fn}_invoke_complete`);
 		lines.push(`    set -l _shell $argv[1]`);
@@ -2975,10 +4364,8 @@ function generateFishCompletion(command, options) {
 	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}"`);
-		}
+		const subItems = getSubNamesWithAliases(root.subcommands);
+		lines.push(...subOrPositionalLines$1(subItems, root.positionals, fn, root.options).map((l) => `        ${l}`));
 	} else if (root.positionals.length > 0) {
 		lines.push(`    else`);
 		lines.push(...positionalBlock$1(root.positionals, fn, root.options));
@@ -3087,26 +4474,19 @@ function generateFishCompletion(command, options) {
 	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)'`);
+	if (!isWorker) {
+		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`
+		installInstructions: `# To enable auto-refreshing fish completions, run:
+${programName} completion fish --install --static`
 	};
 }
 
@@ -3121,38 +4501,30 @@ source ~/.config/fish/completions/${programName}.fish`
 *   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.
+*      `# politty-bin-sig:` / `# politty-bin-path:` headers differ,
+*      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 envName = binEnvVarName(fn);
 	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)
+    local _bin _cache _sig _sig_hdr _path_hdr
+    _bin="\${${envName}:-$(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
+    _sig_hdr="# politty-bin-sig: $_sig"
+    _path_hdr="# politty-bin-path: $_bin"
+    if [[ ! -f "$_cache" ]] || ! head -8 "$_cache" 2>/dev/null | grep -qxF "$_sig_hdr" || ! head -8 "$_cache" 2>/dev/null | grep -qxF "$_path_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
@@ -3174,17 +4546,19 @@ unset -f __${fn}_load_completion
 }
 function generateZshLoader(opts) {
 	const fn = sanitize(opts.programName);
+	const envName = binEnvVarName(fn);
 	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)
+    local _bin _cache _sig _sig_hdr _path_hdr
+    _bin="\${${envName}:-$(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
+    _sig_hdr="# politty-bin-sig: $_sig"
+    _path_hdr="# politty-bin-path: $_bin"
+    if [[ ! -f "$_cache" ]] || ! head -8 "$_cache" 2>/dev/null | grep -qxF "$_sig_hdr" || ! head -8 "$_cache" 2>/dev/null | grep -qxF "$_path_hdr"; then
         # See bash loader for why we use __refresh-completion instead
         # of \`$_bin completion zsh\`.
         "$_bin" __refresh-completion zsh 2>/dev/null
@@ -3256,11 +4630,14 @@ function generateScript(ctx, shell) {
 	return generateCompletion(ctx.rootCommand, {
 		shell,
 		programName: ctx.programName,
+		mode: ctx.completionMode ?? "dispatcher",
 		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 }
+		...ctx.globalArgsSchema !== void 0 && { globalArgsSchema: ctx.globalArgsSchema },
+		...ctx.bundledWorker !== void 0 && { bundledWorker: ctx.bundledWorker },
+		...ctx.staticWorker !== void 0 && { staticWorker: ctx.staticWorker }
 	}).script;
 }
 /** Write the script for `shell` to its install path. Returns the path. */
@@ -3283,6 +4660,34 @@ function readCachedSig(path) {
 		return null;
 	}
 }
+function readCachedMode(path) {
+	try {
+		if (!existsSync(path)) return void 0;
+		const m = readFileSync(path, "utf8").split("\n", 10).join("\n").match(/^# politty-completion-mode: (dispatcher|static)$/m);
+		if (m) return m[1];
+		return;
+	} catch {
+		return;
+	}
+}
+function readCachedBinPath(path) {
+	try {
+		if (!existsSync(path)) return null;
+		const m = readFileSync(path, "utf8").split("\n", 10).join("\n").match(/^# politty-bin-path: (.*)$/m);
+		return m ? m[1] : null;
+	} catch {
+		return null;
+	}
+}
+function isManagedTarget(path, programName, shell) {
+	try {
+		if (!existsSync(path)) return false;
+		const lines = readFileSync(path, "utf8").split("\n", 8).map((line) => line.trimEnd());
+		return lines.some((line) => /^# politty-completion-version: \S+$/.test(line)) && lines.includes(`# program: ${programName}`) && lines.includes(`# shell: ${shell}`);
+	} catch {
+		return false;
+	}
+}
 /**
 * Rewrite the cache only when stale. Used by:
 *   - `<program> __refresh-completion <shell>` (the hidden subcommand
@@ -3298,7 +4703,9 @@ function readCachedSig(path) {
 */
 function refreshIfStale(ctx, shell) {
 	try {
-		const target = installPath(ctx.programName, shell, ctx.cacheDir);
+		const target = ctx.targetPath ? existsSync(ctx.targetPath) ? realpathSync(ctx.targetPath) : ctx.targetPath : installPath(ctx.programName, shell, ctx.cacheDir);
+		if (ctx.targetPath && existsSync(target) && !isManagedTarget(target, ctx.programName, shell)) return;
+		if (ctx.targetPath && !existsSync(target) && !ctx.allowTargetCreate) return;
 		const binPath = resolveBinPath(ctx.programName, ctx.binPath);
 		if (!binPath) return;
 		let currentSig;
@@ -3307,8 +4714,12 @@ function refreshIfStale(ctx, shell) {
 		} catch {
 			return;
 		}
-		if (readCachedSig(target) === currentSig) return;
-		writeAtomic(target, generateScript(ctx, shell));
+		if (readCachedSig(target) === currentSig && readCachedBinPath(target) === binPath) return;
+		const completionMode = ctx.completionMode ?? readCachedMode(target) ?? (existsSync(target) ? "static" : "dispatcher");
+		writeAtomic(target, generateScript({
+			...ctx,
+			completionMode
+		}, shell));
 	} catch {}
 }
 /**
@@ -3360,6 +4771,53 @@ function escapeDesc(s) {
 function escapeDescribeValue(s) {
 	return s.replace(/\\/g, "\\\\").replace(/:/g, "\\:");
 }
+/** Escape a string for use inside zsh double-quotes. */
+function escapeZshDQ(s) {
+	return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\$/g, "\\$").replace(/`/g, "\\`");
+}
+function zshArrayLiteral(values) {
+	return values.map((v) => `"${escapeZshDQ(v)}"`).join(" ");
+}
+function zshFilteredFileLines(fn, kind, values) {
+	const lines = [
+		`setopt local_options null_glob`,
+		`local _cur="\${words[CURRENT]:-}" _dir _prefix _f _out`,
+		`local -a ${kind === "extensions" ? "_exts" : "_matchers"}=(${zshArrayLiteral(values)})`,
+		`if [[ -z "$_cur" || "$_cur" != */* ]]; then`,
+		`    _dir="."`,
+		`    _prefix="$_cur"`,
+		`elif [[ "$_cur" == */ ]]; then`,
+		`    _dir="\${_cur%/}"`,
+		`    _prefix=""`,
+		`else`,
+		`    _dir="\${_cur%/*}"`,
+		`    _prefix="\${_cur##*/}"`,
+		`fi`,
+		`for _f in "$_dir"/"$_prefix"*(N/); do`,
+		`    _out="\${_f#./}"`,
+		`    __${fn}_add_path_candidate "$_out"`,
+		`done`
+	];
+	if (kind === "extensions") {
+		lines.push(`local _ext`);
+		lines.push(`for _f in "$_dir"/"$_prefix"*(N.); do`);
+		lines.push(`    _out="\${_f#./}"`);
+		lines.push(`    for _ext in "\${_exts[@]}"; do`);
+		lines.push(`        [[ -n "$_ext" && "$_out" == *."$_ext" ]] && { __${fn}_add_path_candidate "$_out"; break; }`);
+		lines.push(`    done`);
+		lines.push(`done`);
+	} else {
+		lines.push(`local _pat`);
+		lines.push(`for _pat in "\${_matchers[@]}"; do`);
+		lines.push(`    [[ -n "$_pat" ]] || continue`);
+		lines.push(`    for _f in "$_dir"/\${~_pat}(N.); do`);
+		lines.push(`        _out="\${_f#./}"`);
+		lines.push(`        [[ "$_out" == "$_cur"* ]] && __${fn}_add_path_candidate "$_out"`);
+		lines.push(`    done`);
+		lines.push(`done`);
+	}
+	return lines;
+}
 /**
 * Generate zsh value completion lines for a ValueCompletion spec.
 * Uses `_vals` array (must be declared in the calling function scope).
@@ -3416,12 +4874,13 @@ function zshValueLines(vc, fn, location) {
 		case "dynamic": return [`__${fn}_apply_dynamic_output "$(__${fn}_invoke_complete zsh "\${(@)words[2,CURRENT]}")"`];
 		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}"`);
+			if (vc.matcher?.length) return zshFilteredFileLines(fn, "matchers", vc.matcher);
+			if (vc.extensions?.length) return zshFilteredFileLines(fn, "extensions", vc.extensions);
 			return [`_files`];
 		case "directory": return [`_files -/`];
 		case "command": return [`_vals=("\${(@f)$(${vc.shellCommand})}")`, `__${fn}_cdescribe 'completions' _vals`];
 		case "none": return [];
+		case "runtime-expand": return [];
 	}
 }
 /** Generate option-value case branches */
@@ -3460,6 +4919,31 @@ function positionalBlock(positionals, fn, funcSuffix, options = []) {
 	lines.push(`    esac`);
 	return lines;
 }
+/**
+* Subcommand completion via `_describe`. When the same node also has
+* positionals, complete subcommand names only while the cursor still prefixes
+* one and fall through to positional completion otherwise. Returns lines at
+* base indentation; callers re-indent for their handler depth.
+*/
+function subOrPositionalLines(subItems, positionals, fn, funcSuffix, options) {
+	const describe = [`local -a _subs=(${subItems.map((s) => {
+		const desc = s.description ? `:${escapeDesc(s.description)}` : "";
+		return `"${s.name}${desc}"`;
+	}).join(" ")})`, `__${fn}_cdescribe 'subcommands' _subs`];
+	if (positionals.length === 0) return describe;
+	return [
+		`local -a _sub_names=(${subItems.map((s) => `"${escapeZshDQ(s.name)}"`).join(" ")})`,
+		`local _cur_word="\${words[CURRENT]:-}" _sub_name _sub_match=0`,
+		`for _sub_name in "\${_sub_names[@]}"; do`,
+		`    [[ "$_sub_name" == "$_cur_word"* ]] && _sub_match=1 && break`,
+		`done`,
+		`if (( _sub_match )); then`,
+		...describe.map((l) => `    ${l}`),
+		`else`,
+		...positionalBlock(positionals, fn, funcSuffix, options),
+		`fi`
+	];
+}
 /** Generate prev-word value completion case block */
 function valueCompletionBlock(options, positionals, fn, funcSuffix) {
 	if (!options.some((o) => o.takesValue && o.valueCompletion)) return [];
@@ -3531,12 +5015,8 @@ function generateSubHandler(sub, fn, path) {
 	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`);
+		const subItems = getSubNamesWithAliases(sub.subcommands);
+		lines.push(...subOrPositionalLines(subItems, sub.positionals, fn, funcSuffix, sub.options).map((l) => `    ${l}`));
 	} else if (sub.positionals.length > 0) lines.push(...positionalBlock(sub.positionals, fn, funcSuffix, sub.options));
 	lines.push(`}`);
 	lines.push(``);
@@ -3545,7 +5025,11 @@ function generateSubHandler(sub, fn, path) {
 function generateZshCompletion(command, options) {
 	const { programName } = options;
 	const data = extractCompletionData(command, programName, options.globalArgsSchema);
-	const fn = sanitize(programName);
+	const baseFn = sanitize(programName);
+	const fn = options.staticWorker ? `${baseFn}_${sanitize(options.staticWorker.functionSuffix)}` : baseFn;
+	const isWorker = options.staticWorker !== void 0;
+	const completionFn = isWorker ? `_${fn}_completions` : `_${programName}`;
+	const autoloadCheck = `"\${funcstack[1]:-}" == "${escapeZshDQ(completionFn)}"`;
 	const root = data.command;
 	const visibleSubs = getVisibleSubs(root.subcommands);
 	const expandSpecs = collectExpandSpecs(root);
@@ -3554,16 +5038,24 @@ function generateZshCompletion(command, options) {
 	const arrayExpandSpecs = expandSpecs.filter((s) => s.isArrayOption);
 	const hasArrayExpand = arrayExpandSpecs.length > 0;
 	const lines = [];
-	lines.push(`#compdef ${programName}`);
-	lines.push(``);
+	if (!isWorker) {
+		lines.push(`#compdef ${programName}`);
+		lines.push(``);
+	}
 	lines.push(...buildHeaderLines({
 		programName,
 		shell: "zsh",
 		binPath: options.binPath,
 		programVersion: options.programVersion
 	}));
+	lines.push(`# politty-completion-mode: ${isWorker ? "worker" : "static"}`);
+	if (isWorker) lines.push(`# politty-completion-worker: true`);
 	lines.push(`# Generated by politty`);
 	lines.push(``);
+	if (!isWorker) lines.push(...generateZshSelfRefresh({
+		programName,
+		binPath: options.binPath
+	}));
 	for (const spec of expandSpecs) {
 		const varName = expandTableVarName(fn, spec.funcSuffix, spec.fieldName);
 		if (spec.vc.table.length === 0) lines.push(`typeset -gA ${varName}=()`);
@@ -3636,6 +5128,11 @@ function generateZshCompletion(command, options) {
 	lines.push(`    return 0`);
 	lines.push(`}`);
 	lines.push(``);
+	lines.push(`__${fn}_add_path_candidate() {`);
+	lines.push(`    compadd -f -- "$1" 2>/dev/null && return 0`);
+	lines.push(`    print -r -- "$1"`);
+	lines.push(`}`);
+	lines.push(``);
 	lines.push(`__${fn}_opt_takes_value() {`);
 	lines.push(`    case "$1:$2" in`);
 	lines.push(...optTakesValueEntries(root, ""));
@@ -3692,12 +5189,8 @@ function generateZshCompletion(command, options) {
 	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`);
+		const subItems = getSubNamesWithAliases(root.subcommands);
+		lines.push(...subOrPositionalLines(subItems, root.positionals, fn, "root", root.options).map((l) => `        ${l}`));
 	} else if (root.positionals.length > 0) {
 		lines.push(`    else`);
 		lines.push(...positionalBlock(root.positionals, fn, "root", root.options).map((l) => `    ${l}`));
@@ -3706,7 +5199,7 @@ function generateZshCompletion(command, options) {
 	lines.push(`}`);
 	lines.push(``);
 	const subRouting = subDispatchCaseLines(routeEntries, fn).join("\n");
-	lines.push(`_${fn}() {`);
+	lines.push(`${completionFn}() {`);
 	lines.push(`    (( CURRENT )) || CURRENT=\${#words}`);
 	lines.push(``);
 	lines.push(`    local _subcmd="" _after_dd=0 _pos_count=0 _skip_next=0`);
@@ -3772,22 +5265,30 @@ function generateZshCompletion(command, options) {
 	lines.push(``);
 	lines.push(`zstyle ':completion:*:*:${programName}:*' file-patterns '%p:globbed-files *(-/):directories'`);
 	lines.push(``);
-	lines.push(`compdef _${fn} ${programName}`);
-	lines.push(``);
+	if (!isWorker) {
+		lines.push(`if [[ ${autoloadCheck} ]]; then`);
+		lines.push(`    ${completionFn} "$@"`);
+		lines.push(`else`);
+		lines.push(`    compdef ${completionFn} ${programName}`);
+		lines.push(`fi`);
+		lines.push(``);
+	}
 	return {
 		script: lines.join("\n"),
 		shell: "zsh",
-		installInstructions: `# To enable completions, add the following to your ~/.zshrc:
+		installInstructions: `# To enable auto-refreshing zsh completions, add this to your ~/.zshrc after compinit:
+eval "$(${programName} completion zsh --static)"
 
-# Option 1: Source directly (add before compinit)
-eval "$(${programName} completion zsh)"
+# For faster shell startup, save the script in your fpath:
+mkdir -p ~/.zsh/completions
+${programName} completion zsh --static > ~/.zsh/completions/_${programName}
 
-# Option 2: Save to a file in your fpath
-${programName} completion zsh > ~/.zsh/completions/_${programName}
+# Make sure your ~/.zshrc includes the fpath line before compinit:
+fpath=(~/.zsh/completions $fpath)
+autoload -Uz compinit && compinit
 
-# Make sure your fpath includes the completions directory:
-# fpath=(~/.zsh/completions $fpath)
-# autoload -Uz compinit && compinit
+# If ~/.zshrc already calls compinit, add only the fpath line before
+# the existing compinit call.
 
 # Then reload your shell or run:
 source ~/.zshrc`
@@ -3825,6 +5326,7 @@ source ~/.zshrc`
 * Generate completion script for the specified shell
 */
 function generateCompletion(command, options) {
+	if (options.mode === "dispatcher") return generateDispatcherCompletion(command, options);
 	switch (options.shell) {
 		case "bash": return generateBashCompletion(command, options);
 		case "zsh": return generateZshCompletion(command, options);
@@ -3842,6 +5344,18 @@ function getSupportedShells() {
 		"fish"
 	];
 }
+function printZshFpathSetup(programName, target) {
+	console.error("");
+	console.error("Configure zsh fpath with:");
+	console.error("");
+	console.error("    mkdir -p ~/.zsh/completions");
+	console.error(`    ln -sf ${shSingleQuote(target)} ~/.zsh/completions/_${programName}`);
+	console.error("");
+	console.error("Add only this block to your ~/.zshrc before compinit:");
+	console.error("");
+	console.error("    fpath=(~/.zsh/completions $fpath)");
+	console.error("    autoload -Uz compinit && compinit");
+}
 /**
 * Detect the current shell from environment
 */
@@ -3870,15 +5384,36 @@ const completionArgsSchema = z.object({
 		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." })
+	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." }),
+	static: arg(z.boolean().default(false), { description: "Generate the legacy static completion script with command metadata baked in." }),
+	dispatcher: arg(z.boolean().default(false), { description: "Generate the runtime dispatcher completion script. This is the default." }),
+	worker: arg(z.boolean().default(false), { description: "Generate an internal static worker artifact for dispatcher mode." })
+});
+const refreshArgsSchema = z.object({
+	shell: arg(z.enum([
+		"bash",
+		"zsh",
+		"fish"
+	]), {
+		positional: true,
+		description: "Shell to refresh",
+		placeholder: "SHELL"
+	}),
+	target: arg(z.string().optional(), {
+		positional: true,
+		description: "Existing politty-generated completion file to refresh",
+		placeholder: "TARGET"
+	}),
+	static: arg(z.boolean().default(false), { description: "Refresh using the legacy static completion script mode." }),
+	worker: arg(z.boolean().default(false), { description: "Refresh an internal static worker completion script." })
 });
-const refreshArgsSchema = z.object({ shell: arg(z.enum([
+const workerPathArgsSchema = z.object({ shell: arg(z.enum([
 	"bash",
 	"zsh",
 	"fish"
 ]), {
 	positional: true,
-	description: "Shell to refresh",
+	description: "Shell worker to locate",
 	placeholder: "SHELL"
 }) });
 /**
@@ -3902,7 +5437,8 @@ function createCompletionCommand(rootCommand, programName, globalArgsSchema, ext
 	const refreshExtra = {
 		...cacheDir !== void 0 && { cacheDir },
 		...programVersion !== void 0 && { programVersion },
-		...globalArgsSchema !== void 0 && { globalArgsSchema }
+		...globalArgsSchema !== void 0 && { globalArgsSchema },
+		...extra.bundledWorker !== void 0 && { bundledWorker: extra.bundledWorker }
 	};
 	const installCtxBase = {
 		programName: resolvedProgramName,
@@ -3920,6 +5456,10 @@ function createCompletionCommand(rootCommand, programName, globalArgsSchema, ext
 		...rootCommand.subCommands,
 		"__refresh-completion": createRefreshCompletionCommand(rootCommand, resolvedProgramName, refreshExtra)
 	};
+	if (!rootCommand.subCommands?.["__completion-worker-path"]) rootCommand.subCommands = {
+		...rootCommand.subCommands,
+		"__completion-worker-path": createCompletionWorkerPathCommand(resolvedProgramName, refreshExtra)
+	};
 	return defineCommand({
 		name: "completion",
 		description: "Generate shell completion script",
@@ -3931,18 +5471,23 @@ function createCompletionCommand(rootCommand, programName, globalArgsSchema, ext
 				process.exitCode = 1;
 				return;
 			}
+			if (args.static && args.dispatcher) throw new Error("Choose only one completion mode: --dispatcher or --static.");
+			if (args.worker && !args.static) throw new Error("`--worker` requires `--static`.");
+			if (args.worker && (args.install || args.loader || args.instructions)) throw new Error("`--worker` can only print a worker artifact.");
+			const completionMode = args.static ? "static" : "dispatcher";
 			if (args.install) {
 				let target;
 				try {
 					target = install({
 						rootCommand,
-						...installCtxBase
+						...installCtxBase,
+						completionMode
 					}, shellType);
 				} catch (e) {
 					throw new Error(`install failed: ${e instanceof Error ? e.message : String(e)}`);
 				}
 				console.error(`installed: ${target}`);
-				if (shellType !== "fish") {
+				if (shellType === "bash") {
 					console.error("");
 					console.error(`Add to your ~/.${shellType}rc:`);
 					console.error("");
@@ -3950,7 +5495,7 @@ function createCompletionCommand(rootCommand, programName, globalArgsSchema, ext
 						...loaderOptsBase,
 						shell: shellType
 					}).trim().replace(/^/gm, "    "));
-				}
+				} else if (shellType === "zsh") printZshFpathSetup(resolvedProgramName, target);
 				return;
 			}
 			if (args.loader) {
@@ -3964,10 +5509,13 @@ function createCompletionCommand(rootCommand, programName, globalArgsSchema, ext
 			const result = generateCompletion(rootCommand, {
 				shell: shellType,
 				programName: resolvedProgramName,
+				mode: completionMode,
 				includeDescriptions: true,
 				...globalArgsSchema !== void 0 && { globalArgsSchema },
 				...programVersion !== void 0 && { programVersion },
-				...cacheDir !== void 0 && { cacheDir }
+				...cacheDir !== void 0 && { cacheDir },
+				...extra.bundledWorker !== void 0 && { bundledWorker: extra.bundledWorker },
+				...args.worker && { staticWorker: { functionSuffix: "worker" } }
 			});
 			if (args.instructions) console.log(result.installInstructions);
 			else console.log(result.script);
@@ -3988,11 +5536,32 @@ function createRefreshCompletionCommand(rootCommand, programName, extra = {}) {
 			refreshIfStale({
 				rootCommand,
 				programName,
-				...extra
+				...extra,
+				completionMode: args.static || args.worker ? "static" : void 0,
+				...args.worker && { staticWorker: { functionSuffix: "worker" } },
+				...args.worker && { allowTargetCreate: true },
+				...args.target !== void 0 && { targetPath: args.target }
 			}, args.shell);
 		}
 	});
 }
+function createCompletionWorkerPathCommand(programName, extra = {}) {
+	return defineCommand({
+		name: "__completion-worker-path",
+		description: "(internal) Print the bundled completion worker path when available.",
+		args: workerPathArgsSchema,
+		run(args) {
+			const path = resolveBundledWorkerPath({
+				programName,
+				shell: args.shell,
+				...extra.binPath !== void 0 && { binPath: extra.binPath },
+				...extra.bundledWorker !== void 0 && { bundledWorker: extra.bundledWorker }
+			});
+			if (!path) throw new Error(`No bundled completion worker found for ${programName} (${args.shell}).`);
+			console.log(path);
+		}
+	});
+}
 /**
 * Wrap a command with a completion subcommand
 *
@@ -4014,19 +5583,21 @@ function createRefreshCompletionCommand(rootCommand, programName, extra = {}) {
 * ```
 */
 function withCompletionCommand(command, options) {
-	const { programName, globalArgsSchema, cacheDir, programVersion } = typeof options === "string" ? { programName: options } : options ?? {};
+	const { programName, globalArgsSchema, cacheDir, programVersion, bundledWorker } = 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 }
+		...globalArgsSchema !== void 0 && { globalArgsSchema },
+		...bundledWorker !== void 0 && { bundledWorker }
 	};
 	const wrappedCommand = { ...command };
 	wrappedCommand.subCommands = {
 		...command.subCommands,
 		completion: createCompletionCommand(wrappedCommand, programName, globalArgsSchema, extra),
 		__complete: createDynamicCompleteCommand(wrappedCommand, programName, globalArgsSchema),
-		"__refresh-completion": createRefreshCompletionCommand(wrappedCommand, resolvedProgramName, extra)
+		"__refresh-completion": createRefreshCompletionCommand(wrappedCommand, resolvedProgramName, extra),
+		"__completion-worker-path": createCompletionWorkerPathCommand(resolvedProgramName, extra)
 	};
 	wrappedCommand.runMainHook = (argv) => {
 		maybeSpawnRefresh(argv, {
@@ -4053,7 +5624,7 @@ function withCompletionCommand(command, options) {
 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;
+	if (firstPositional === "__complete" || firstPositional === "__refresh-completion" || firstPositional === "__completion-worker-path" || firstPositional === "completion") return;
 	const shell = detectShell();
 	if (!shell) return;
 	const argv0 = process.argv[1];
@@ -4063,5 +5634,5 @@ function maybeSpawnRefresh(argv, ctx) {
 }
 
 //#endregion
-export { defineCommand as _, getSupportedShells as a, hasCompleteCommand as c, extractPositionals as d, CompletionDirective as f, createDefineCommand as g, resolveValueCompletion as h, generateCompletion as i, formatForShell as l, parseCompletionContext as m, createRefreshCompletionCommand as n, withCompletionCommand as o, generateCandidates as p, detectShell as r, createDynamicCompleteCommand as s, createCompletionCommand as t, extractCompletionData as u };
-//# sourceMappingURL=completion-BA5JMvVG.js.map
+export { defineCommand as S, CompletionDirective as _, generateCompletion as a, resolveValueCompletion as b, createDynamicCompleteCommand as c, bundledWorkerShellExtension as d, defaultBundledWorkerOutputPath as f, extractPositionals as g, extractCompletionData as h, detectShell as i, hasCompleteCommand as l, validateBundledWorkerFile as m, createCompletionWorkerPathCommand as n, getSupportedShells as o, generateBundledCompletionWorker as p, createRefreshCompletionCommand as r, withCompletionCommand as s, createCompletionCommand as t, formatForShell as u, generateCandidates as v, createDefineCommand as x, parseCompletionContext as y };
+//# sourceMappingURL=completion-DHnVx9Zk.js.map