politty 0.5.0 → 0.6.0

package/dist/{completion-Cqs1Ja7C.cjs → completion-CLHO3Xaz.cjs}

@@ -1,9 +1,9 @@
-const require_log_collector = require('./log-collector-Cd2_mv87.cjs');
-const require_schema_extractor = require('./schema-extractor-SLPgBNgZ.cjs');
+const require_schema_extractor = require('./schema-extractor-BxSRwLrx.cjs');
 let zod = require("zod");
 let node_child_process = require("node:child_process");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
+let node_util = require("node:util");
 
 //#region src/core/command.ts
 function defineCommand(config) {
@@ -133,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
@@ -294,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
@@ -323,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))
 		};
 	});
 }
@@ -454,7 +487,7 @@ function extractPositionalsForContext(command) {
 		description: field.description,
 		required: field.required,
 		variadic: field.type === "array",
-		valueCompletion: stripPendingExpand(resolveValueCompletion(field))
+		valueCompletion: resolveRuntimeCompletion(resolveValueCompletion(field))
 	}));
 }
 /**
@@ -882,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);
 		}
 	}
 }
@@ -921,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
@@ -969,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;
@@ -1026,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,
@@ -1044,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
 */
@@ -1067,7 +1158,7 @@ function generateSubcommandCandidates(context) {
 	}
 	return {
 		candidates,
-		directive: CompletionDirective.FilterPrefix
+		directive: CompletionDirective.FilterPrefix | CompletionDirective.NoFileCompletion
 	};
 }
 /**
@@ -1101,7 +1192,7 @@ function generateOptionNameCandidates(context) {
 	});
 	return {
 		candidates,
-		directive: CompletionDirective.FilterPrefix
+		directive: CompletionDirective.FilterPrefix | CompletionDirective.NoFileCompletion
 	};
 }
 /**
@@ -1137,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
@@ -1153,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
@@ -1183,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.`);
@@ -1194,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 = {};
@@ -1404,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 = require_schema_extractor.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)",
@@ -1427,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. */
@@ -1826,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 = [];
@@ -1839,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 {
@@ -1858,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;
@@ -1875,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
@@ -1905,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] ?? "";
 }
 /**
@@ -1913,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}`);
@@ -1924,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 */
@@ -2025,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 [];
 	}
 }
 /**
@@ -2087,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 [];
@@ -2162,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(``);
@@ -2172,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);
@@ -2184,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;
@@ -2326,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}`));
@@ -2425,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`
@@ -2444,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 = (0, node_util.promisify)(node_child_process.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 (0, node_path.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 = (0, node_fs.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((0, node_path.dirname)((0, node_path.resolve)(path)));
+	try {
+		out.add((0, node_path.dirname)((0, node_fs.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 (0, node_fs.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 (!(0, node_fs.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 ((0, node_path.isAbsolute)(rel) && isBundledWorkerFile(rel, opts.programName, opts.shell)) return rel;
+	for (const base of bases) for (const rel of rels) {
+		if ((0, node_path.isAbsolute)(rel)) continue;
+		const candidate = (0, node_path.join)(base, rel);
+		if (isBundledWorkerFile(candidate, opts.programName, opts.shell)) return candidate;
+	}
+	return null;
+}
+function resolvePathFromCwd(path, cwd) {
+	return (0, node_path.isAbsolute)(path) ? path : (0, node_path.resolve)(cwd, path);
+}
+function executableCommand(bin, args, cwd) {
+	const binPath = bin.startsWith(".") || bin.includes("/") || bin.includes("\\") ? resolvePathFromCwd(bin, cwd) : bin;
+	const ext = (0, node_path.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 = (0, node_fs.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 = (0, node_path.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);
+	(0, node_fs.mkdirSync)((0, node_path.dirname)(outputPath), { recursive: true });
+	(0, node_fs.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 = (0, node_fs.realpathSync)(outputPath);
+		const reportedReal = (0, node_fs.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 = zod.z.object({
-	shell: require_schema_extractor.arg(zod.z.enum([
-		"bash",
-		"zsh",
-		"fish"
-	]), { description: "Target shell for output formatting" }),
-	args: require_schema_extractor.arg(zod.z.array(zod.z.string()).default([]), {
-		positional: true,
-		description: "Arguments to complete",
-		variadic: true
-	})
-});
-/**
-* Create the dynamic completion command
-*
-* @param rootCommand - The root command to generate completions for
-* @param programName - The program name (optional, defaults to rootCommand.name)
-* @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 = zod.z.object({
+	shell: require_schema_extractor.arg(zod.z.enum([
+		"bash",
+		"zsh",
+		"fish"
+	]), { description: "Target shell for output formatting" }),
+	args: require_schema_extractor.arg(zod.z.array(zod.z.string()).default([]), {
+		positional: true,
+		description: "Arguments to complete",
+		variadic: true
+	})
+});
+/**
+* Create the dynamic completion command
+*
+* @param rootCommand - The root command to generate completions for
+* @param programName - The program name (optional, defaults to rootCommand.name)
+* @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}`];
@@ -2658,6 +4011,7 @@ function fishValueLines(vc, fn, location) {
 			`end`
 		];
 		case "none": return [];
+		case "runtime-expand": return [];
 	}
 }
 /** Generate fish matcher-filtered file completion */
@@ -2679,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;
@@ -2718,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 = [];
@@ -2773,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;
@@ -2795,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);
@@ -2810,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]`);
@@ -2976,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));
@@ -3088,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`
 	};
 }
 
@@ -3122,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
@@ -3175,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
@@ -3257,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. */
@@ -3284,6 +4660,34 @@ function readCachedSig(path) {
 		return null;
 	}
 }
+function readCachedMode(path) {
+	try {
+		if (!(0, node_fs.existsSync)(path)) return void 0;
+		const m = (0, node_fs.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 (!(0, node_fs.existsSync)(path)) return null;
+		const m = (0, node_fs.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 (!(0, node_fs.existsSync)(path)) return false;
+		const lines = (0, node_fs.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
@@ -3299,7 +4703,9 @@ function readCachedSig(path) {
 */
 function refreshIfStale(ctx, shell) {
 	try {
-		const target = installPath(ctx.programName, shell, ctx.cacheDir);
+		const target = ctx.targetPath ? (0, node_fs.existsSync)(ctx.targetPath) ? (0, node_fs.realpathSync)(ctx.targetPath) : ctx.targetPath : installPath(ctx.programName, shell, ctx.cacheDir);
+		if (ctx.targetPath && (0, node_fs.existsSync)(target) && !isManagedTarget(target, ctx.programName, shell)) return;
+		if (ctx.targetPath && !(0, node_fs.existsSync)(target) && !ctx.allowTargetCreate) return;
 		const binPath = resolveBinPath(ctx.programName, ctx.binPath);
 		if (!binPath) return;
 		let currentSig;
@@ -3308,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) ?? ((0, node_fs.existsSync)(target) ? "static" : "dispatcher");
+		writeAtomic(target, generateScript({
+			...ctx,
+			completionMode
+		}, shell));
 	} catch {}
 }
 /**
@@ -3361,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).
@@ -3417,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 */
@@ -3461,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 [];
@@ -3532,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(``);
@@ -3546,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);
@@ -3555,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}=()`);
@@ -3637,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, ""));
@@ -3693,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}`));
@@ -3707,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`);
@@ -3773,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`
@@ -3826,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);
@@ -3843,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
 */
@@ -3871,15 +5384,36 @@ const completionArgsSchema = zod.z.object({
 		description: "Show installation instructions"
 	}),
 	loader: require_schema_extractor.arg(zod.z.boolean().default(false), { description: "Print just the rc loader snippet (bash/zsh). Add it to ~/.bashrc or ~/.zshrc; it auto-regenerates the cache when the binary changes." }),
-	install: require_schema_extractor.arg(zod.z.boolean().default(false), { description: "Write the completion script to its on-disk cache (bash/zsh) or autoload location (fish) instead of printing it." })
+	install: require_schema_extractor.arg(zod.z.boolean().default(false), { description: "Write the completion script to its on-disk cache (bash/zsh) or autoload location (fish) instead of printing it." }),
+	static: require_schema_extractor.arg(zod.z.boolean().default(false), { description: "Generate the legacy static completion script with command metadata baked in." }),
+	dispatcher: require_schema_extractor.arg(zod.z.boolean().default(false), { description: "Generate the runtime dispatcher completion script. This is the default." }),
+	worker: require_schema_extractor.arg(zod.z.boolean().default(false), { description: "Generate an internal static worker artifact for dispatcher mode." })
+});
+const refreshArgsSchema = zod.z.object({
+	shell: require_schema_extractor.arg(zod.z.enum([
+		"bash",
+		"zsh",
+		"fish"
+	]), {
+		positional: true,
+		description: "Shell to refresh",
+		placeholder: "SHELL"
+	}),
+	target: require_schema_extractor.arg(zod.z.string().optional(), {
+		positional: true,
+		description: "Existing politty-generated completion file to refresh",
+		placeholder: "TARGET"
+	}),
+	static: require_schema_extractor.arg(zod.z.boolean().default(false), { description: "Refresh using the legacy static completion script mode." }),
+	worker: require_schema_extractor.arg(zod.z.boolean().default(false), { description: "Refresh an internal static worker completion script." })
 });
-const refreshArgsSchema = zod.z.object({ shell: require_schema_extractor.arg(zod.z.enum([
+const workerPathArgsSchema = zod.z.object({ shell: require_schema_extractor.arg(zod.z.enum([
 	"bash",
 	"zsh",
 	"fish"
 ]), {
 	positional: true,
-	description: "Shell to refresh",
+	description: "Shell worker to locate",
 	placeholder: "SHELL"
 }) });
 /**
@@ -3903,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,
@@ -3921,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",
@@ -3932,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("");
@@ -3951,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) {
@@ -3965,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);
@@ -3989,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
 *
@@ -4015,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, {
@@ -4054,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];
@@ -4070,12 +5640,24 @@ Object.defineProperty(exports, 'CompletionDirective', {
     return CompletionDirective;
   }
 });
+Object.defineProperty(exports, 'bundledWorkerShellExtension', {
+  enumerable: true,
+  get: function () {
+    return bundledWorkerShellExtension;
+  }
+});
 Object.defineProperty(exports, 'createCompletionCommand', {
   enumerable: true,
   get: function () {
     return createCompletionCommand;
   }
 });
+Object.defineProperty(exports, 'createCompletionWorkerPathCommand', {
+  enumerable: true,
+  get: function () {
+    return createCompletionWorkerPathCommand;
+  }
+});
 Object.defineProperty(exports, 'createDefineCommand', {
   enumerable: true,
   get: function () {
@@ -4094,6 +5676,12 @@ Object.defineProperty(exports, 'createRefreshCompletionCommand', {
     return createRefreshCompletionCommand;
   }
 });
+Object.defineProperty(exports, 'defaultBundledWorkerOutputPath', {
+  enumerable: true,
+  get: function () {
+    return defaultBundledWorkerOutputPath;
+  }
+});
 Object.defineProperty(exports, 'defineCommand', {
   enumerable: true,
   get: function () {
@@ -4124,6 +5712,12 @@ Object.defineProperty(exports, 'formatForShell', {
     return formatForShell;
   }
 });
+Object.defineProperty(exports, 'generateBundledCompletionWorker', {
+  enumerable: true,
+  get: function () {
+    return generateBundledCompletionWorker;
+  }
+});
 Object.defineProperty(exports, 'generateCandidates', {
   enumerable: true,
   get: function () {
@@ -4160,10 +5754,16 @@ Object.defineProperty(exports, 'resolveValueCompletion', {
     return resolveValueCompletion;
   }
 });
+Object.defineProperty(exports, 'validateBundledWorkerFile', {
+  enumerable: true,
+  get: function () {
+    return validateBundledWorkerFile;
+  }
+});
 Object.defineProperty(exports, 'withCompletionCommand', {
   enumerable: true,
   get: function () {
     return withCompletionCommand;
   }
 });
-//# sourceMappingURL=completion-Cqs1Ja7C.cjs.map
+//# sourceMappingURL=completion-CLHO3Xaz.cjs.map