padrone 1.9.0 → 2.0.0

package/dist/index.mjs

@@ -1,4377 +1,25 @@
-import { _ as resolveStdin, c as getCommandRuntime, d as repathCommandTree, f as resolveAllCommands, g as createTerminalReplSession, h as suggestSimilar, i as commandSymbol, l as lazyResolver, n as buildReplCompleter, o as findCommandByName, p as resolveCommand, u as mergeCommands, v as resolveStdinAlways, y as REPL_SIGINT } from "./commands-ohEApqIw.mjs";
-import { a as getJsonSchema, c as parsePositionalConfig, i as extractSchemaMetadata, l as preprocessArgs, n as coerceArgs, o as isArrayField, r as detectUnknownArgs, s as isAsyncStreamField, t as applyValues } from "./args-WmyGc59s.mjs";
-import { i as createStdinStream, r as concatBytes, t as asyncStream } from "./stream-DC4H8YTx.mjs";
-import { a as escapeHtml, i as getVersion, o as resolveOutputFormat, r as getRootCommand, s as colorThemes, t as generateHelp } from "./help-CeI45CJx.mjs";
-import { a as SignalError, i as RoutingError, n as ConfigError, o as ValidationError, r as PadroneError, s as signalExitCode, t as ActionError } from "./errors-DA4KzK1M.mjs";
-//#region src/core/results.ts
-/**
-* Brands a schema as async, signaling that its `validate()` may return a Promise.
-* When an async-branded schema is passed to `.arguments()`, `.configFile()`, or `.env()`,
-* the command's `parse()` and `cli()` will return Promises.
-*/
-function asyncSchema(schema) {
-	return Object.assign(schema, { "~async": true });
-}
-const noop = () => void 0;
-/**
-* Maps over a value that may or may not be a Promise.
-* If the value is a Promise, chains with `.then()`. Otherwise, calls the function synchronously.
-* This preserves sync behavior for sync schemas and async behavior for async schemas.
-*/
-function thenMaybe(value, fn) {
-	if (value instanceof Promise) return value.then(fn);
-	return fn(value);
-}
-/**
-* Makes a sync result object thenable by adding `.then()`, `.catch()`, and `.finally()` methods.
-* If the value is already a Promise, returns it as-is.
-* This allows users to write `await program.cli()` or `program.cli().then(...)` regardless of sync/async.
-*
-* The `.then()` resolves with a plain copy (without thenable methods) to avoid infinite
-* recursive unwrapping by the Promise resolution algorithm.
-*/
-function makeThenable(value) {
-	if (value instanceof Promise) return value;
-	if (value !== null && typeof value === "object" && !("then" in value)) {
-		const toPlain = () => {
-			const plain = { ...value };
-			delete plain.then;
-			delete plain.catch;
-			delete plain.finally;
-			return plain;
-		};
-		value.then = (onfulfilled, onrejected) => {
-			try {
-				const result = onfulfilled ? onfulfilled(toPlain()) : toPlain();
-				return Promise.resolve(result);
-			} catch (err) {
-				if (onrejected) return Promise.resolve(onrejected(err));
-				return Promise.reject(err);
-			}
-		};
-		value.catch = (onrejected) => value.then(void 0, onrejected);
-		value.finally = (onfinally) => value.then((v) => {
-			onfinally?.();
-			return v;
-		}, (err) => {
-			onfinally?.();
-			throw err;
-		});
-	}
-	return value;
-}
-/**
-* Wraps a Promise to include a `drain()` method at the top level.
-* This allows `await promise.drain()` without first awaiting the promise.
-* Since cli/eval never reject, this just delegates to the resolved result's `drain()`.
-*/
-function withPromiseDrain(promise) {
-	promise.drain = async () => {
-		return (await promise).drain();
-	};
-	return promise;
-}
-function isIterator(value) {
-	return typeof value === "object" && value !== null && Symbol.iterator in value && typeof value[Symbol.iterator] === "function";
-}
-function isAsyncIterator(value) {
-	return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
-}
-/**
-* Resolves a result value by unwrapping Promises and collecting iterables into arrays.
-* This is the runtime counterpart of the `Drained<T>` type.
-*/
-async function drainValue(value) {
-	if (value instanceof Promise) return drainValue(await value);
-	if (isAsyncIterator(value)) {
-		const items = [];
-		const iter = value[Symbol.asyncIterator]();
-		while (true) {
-			const { done, value: item } = await iter.next();
-			if (done) break;
-			items.push(item);
-		}
-		return items;
-	}
-	if (typeof value !== "string" && !Array.isArray(value) && isIterator(value)) {
-		const items = [];
-		const iter = value[Symbol.iterator]();
-		while (true) {
-			const { done, value: item } = iter.next();
-			if (done) break;
-			items.push(item);
-		}
-		return items;
-	}
-	return value;
-}
-/**
-* Attaches a `drain()` method to a command result object.
-* If the result has an `error` field, `drain()` returns `{ error }`.
-* Otherwise, resolves the result (unwrapping Promises, collecting iterables), catches errors,
-* and returns a discriminated union `{ value } | { error }` that never throws.
-*/
-function withDrain(obj) {
-	obj.drain = async () => {
-		if ("error" in obj && obj.error !== void 0) return { error: obj.error };
-		try {
-			return { value: await drainValue(obj.result) };
-		} catch (err) {
-			return { error: err };
-		}
-	};
-	return obj;
-}
-/**
-* Creates an error command result with a `drain()` that returns the error.
-*/
-function errorResult(error, partial) {
-	return withDrain({
-		error,
-		result: void 0,
-		command: partial?.command,
-		args: partial?.args,
-		argsResult: partial?.argsResult
-	});
-}
-function isAsyncBranded(schema) {
-	return !!schema && typeof schema === "object" && "~async" in schema && schema["~async"] === true;
-}
-function hasInteractiveConfig(meta) {
-	if (!meta || typeof meta !== "object") return false;
-	const m = meta;
-	return m.interactive === true || Array.isArray(m.interactive) || m.optionalInteractive === true || Array.isArray(m.optionalInteractive);
-}
-function warnIfUnexpectedAsync(value, command) {
-	const runtime = getCommandRuntime(command);
-	if (runtime.env().NODE_ENV === "production") return value;
-	if (value instanceof Promise && !command.isAsync) runtime.error(`[padrone] Command "${command.path || command.name}" returned a Promise from validation, but was not marked as async. Use \`.async()\` on the builder or \`asyncSchema()\` to brand your schema. Without this, TypeScript will infer a sync return type and the result will be a Promise at runtime.`);
-	return value;
-}
-//#endregion
-//#region src/core/interceptors.ts
-function buildInterceptorFn(meta, factory) {
-	Object.defineProperty(factory, "name", {
-		value: meta.name,
-		configurable: true
-	});
-	if (meta.id !== void 0) factory.id = meta.id;
-	if (meta.order !== void 0) factory.order = meta.order;
-	if (meta.disabled !== void 0) factory.disabled = meta.disabled;
-	if (meta.inherit !== void 0) factory.inherit = meta.inherit;
-	factory.provides = () => factory;
-	factory.requires = () => factory;
-	return factory;
-}
-function defineInterceptor(meta, factory) {
-	if (factory) return buildInterceptorFn(meta, factory);
-	const builder = {
-		requires: () => builder,
-		factory: (f) => buildInterceptorFn(meta, f)
-	};
-	return builder;
-}
-/**
-* Normalizes an interceptor input (single-value form or two-arg form) into the internal
-* `RegisteredInterceptor` storage format.
-*/
-function toRegisteredInterceptor(metaOrFn, factory) {
-	if (typeof metaOrFn === "function") return {
-		meta: {
-			name: metaOrFn.name,
-			id: metaOrFn.id,
-			order: metaOrFn.order,
-			disabled: metaOrFn.disabled,
-			inherit: metaOrFn.inherit
-		},
-		factory: metaOrFn
-	};
-	return {
-		meta: metaOrFn,
-		factory
-	};
-}
-/**
-* Resolves registered interceptors by calling their factories and merging the resulting
-* phase handlers with the static metadata. Uses a cache to ensure each factory is called
-* at most once per execution (so root interceptor closures are shared across all phases).
-*/
-function resolveRegisteredInterceptors(registered, cache) {
-	return registered.map((reg) => {
-		let resolved = cache.get(reg);
-		if (!resolved) {
-			resolved = {
-				...reg.meta,
-				...reg.factory()
-			};
-			cache.set(reg, resolved);
-		}
-		return resolved;
-	});
-}
-/**
-* Deduplicates interceptors by `id`. When multiple interceptors share the same `id`,
-* only the last one in the array is kept. Interceptors without an `id` are always kept.
-*/
-function deduplicateInterceptors(interceptors) {
-	if (!interceptors.some((p) => p.id)) return interceptors;
-	const lastIndex = /* @__PURE__ */ new Map();
-	for (let i = 0; i < interceptors.length; i++) {
-		const id = interceptors[i].id;
-		if (id) lastIndex.set(id, i);
-	}
-	return interceptors.filter((p, i) => !p.id || lastIndex.get(p.id) === i);
-}
-/**
-* Runs an interceptor chain for a given phase using the onion/middleware pattern.
-* Interceptors are sorted by `order` (ascending, stable), then composed so that
-* the first interceptor in sorted order is the outermost wrapper.
-* If no interceptors handle this phase, `core` is called directly.
-*
-* Each interceptor's `next()` accepts optional partial overrides that are merged
-* into the context before passing to the next interceptor or core function.
-*/
-function runInterceptorChain(phase, interceptors, ctx, core) {
-	const phaseInterceptors = deduplicateInterceptors(interceptors).filter((p) => p[phase] && !p.disabled);
-	if (phaseInterceptors.length === 0) return core(ctx);
-	phaseInterceptors.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
-	let next = core;
-	for (let i = phaseInterceptors.length - 1; i >= 0; i--) {
-		const handler = phaseInterceptors[i][phase];
-		const prevNext = next;
-		next = (currentCtx) => handler(currentCtx, (overrides) => {
-			if (!overrides) return prevNext(currentCtx);
-			if (overrides.context != null && typeof overrides.context === "object") overrides = {
-				...overrides,
-				context: Object.assign({}, currentCtx.context, overrides.context)
-			};
-			return prevNext(Object.assign({}, currentCtx, overrides));
-		});
-	}
-	return next(ctx);
-}
-/**
-* Wraps a pipeline with start → error → shutdown lifecycle hooks.
-* - `start` interceptors wrap the pipeline (onion pattern, root interceptors only).
-* - On error: `error` interceptors run (can transform/suppress the error).
-* - Always: `shutdown` interceptors run (success or failure).
-*/
-function wrapWithLifecycle(interceptors, command, input, pipeline, wrapErrorResult, signal, context, runtime, program, caller = "eval", pipelineState) {
-	const defaultSignal = typeof AbortSignal !== "undefined" ? AbortSignal.abort() : void 0;
-	const hasStart = interceptors.some((p) => p.start);
-	const hasError = interceptors.some((p) => p.error);
-	const hasShutdown = interceptors.some((p) => p.shutdown);
-	const effectivePipelineState = pipelineState ?? { phase: "start" };
-	if (!hasStart && !hasError && !hasShutdown) return pipeline(signal ?? defaultSignal, context);
-	let effectiveSignal = signal ?? defaultSignal;
-	let effectiveContext = context;
-	const runShutdown = (error, result) => {
-		if (!hasShutdown) return;
-		return runInterceptorChain("shutdown", interceptors, {
-			command,
-			input,
-			error,
-			result,
-			signal: effectiveSignal,
-			context: effectiveContext,
-			runtime,
-			program,
-			caller,
-			...effectivePipelineState
-		}, () => {});
-	};
-	const runError = (error) => {
-		if (!hasError) {
-			const s = runShutdown(error);
-			if (s instanceof Promise) return s.then(() => {
-				throw error;
-			});
-			throw error;
-		}
-		return thenMaybe(runInterceptorChain("error", interceptors, {
-			command,
-			input,
-			error,
-			signal: effectiveSignal,
-			context: effectiveContext,
-			runtime,
-			program,
-			caller,
-			...effectivePipelineState
-		}, () => ({ error })), (er) => {
-			if (er.error !== void 0) return thenMaybe(runShutdown(er.error), () => {
-				throw er.error;
-			});
-			const wrapped = wrapErrorResult ? wrapErrorResult(er.result) : er.result;
-			return thenMaybe(runShutdown(void 0, wrapped), () => wrapped);
-		});
-	};
-	const handleSuccess = (result) => {
-		const s = runShutdown(void 0, result);
-		if (s instanceof Promise) return s.then(() => result);
-		return result;
-	};
-	const startCtx = {
-		command,
-		signal: effectiveSignal,
-		context: effectiveContext,
-		runtime,
-		program,
-		input,
-		caller
-	};
-	let result;
-	try {
-		result = hasStart ? runInterceptorChain("start", interceptors, startCtx, (ctx) => {
-			effectiveSignal = ctx.signal;
-			effectiveContext = ctx.context;
-			return pipeline(ctx.signal, ctx.context);
-		}) : pipeline(effectiveSignal, effectiveContext);
-	} catch (e) {
-		return runError(e);
-	}
-	if (result instanceof Promise) return result.then(handleSuccess, runError);
-	return handleSuccess(result);
-}
-/**
-* Wraps a command-level pipeline (validate + execute) with error → shutdown lifecycle hooks.
-* Unlike `wrapWithLifecycle`, this has no `start` phase and uses the resolved command context.
-* Only interceptors exclusive to the command chain (not in root) should be passed here.
-*/
-function wrapWithCommandLifecycle(interceptors, command, input, pipeline, wrapErrorResult, signal, context, runtime, program, caller, pipelineState) {
-	const hasError = interceptors.some((p) => p.error);
-	const hasShutdown = interceptors.some((p) => p.shutdown);
-	if (!hasError && !hasShutdown) return pipeline();
-	const runShutdown = (error, result) => {
-		if (!hasShutdown) return;
-		return runInterceptorChain("shutdown", interceptors, {
-			command,
-			input,
-			error,
-			result,
-			signal,
-			context,
-			runtime,
-			program,
-			caller,
-			...pipelineState
-		}, () => {});
-	};
-	const runError = (error) => {
-		if (!hasError) {
-			const s = runShutdown(error);
-			if (s instanceof Promise) return s.then(() => {
-				throw error;
-			});
-			throw error;
-		}
-		return thenMaybe(runInterceptorChain("error", interceptors, {
-			command,
-			input,
-			error,
-			signal,
-			context,
-			runtime,
-			program,
-			caller,
-			...pipelineState
-		}, () => ({ error })), (er) => {
-			if (er.error !== void 0) return thenMaybe(runShutdown(er.error), () => {
-				throw er.error;
-			});
-			const wrapped = wrapErrorResult ? wrapErrorResult(er.result) : er.result;
-			return thenMaybe(runShutdown(void 0, wrapped), () => wrapped);
-		});
-	};
-	const handleSuccess = (result) => {
-		const s = runShutdown(void 0, result);
-		if (s instanceof Promise) return s.then(() => result);
-		return result;
-	};
-	let result;
-	try {
-		result = pipeline();
-	} catch (e) {
-		return runError(e);
-	}
-	if (result instanceof Promise) return result.then(handleSuccess, runError);
-	return handleSuccess(result);
-}
-//#endregion
-//#region src/output/primitives.ts
-function stringifyCell(value) {
-	if (value === void 0 || value === null) return "";
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	return JSON.stringify(value);
-}
-function truncate(text, max) {
-	if (max <= 0 || text.length <= max) return text;
-	return max <= 1 ? "…" : `${text.slice(0, max - 1)}…`;
-}
-function padCell(text, width, alignment = "left") {
-	const pad = width - text.length;
-	if (pad <= 0) return text;
-	if (alignment === "right") return " ".repeat(pad) + text;
-	if (alignment === "center") {
-		const left = Math.floor(pad / 2);
-		return " ".repeat(left) + text + " ".repeat(pad - left);
-	}
-	return text + " ".repeat(pad);
-}
-function renderTable(data, options, ctx) {
-	if (data.length === 0) return "";
-	if (ctx.format === "json") return JSON.stringify(data, null, 2);
-	const columns = options?.columns ?? Object.keys(data[0]);
-	if (columns.length === 0) return "";
-	const headers = columns.map((col) => options?.headers?.[col] ?? col);
-	const maxCol = options?.maxColumnWidth;
-	const rows = data.map((row) => columns.map((col) => {
-		const text = stringifyCell(row[col]);
-		return maxCol ? truncate(text, maxCol) : text;
-	}));
-	const colWidths = columns.map((_, i) => {
-		const headerWidth = headers[i].length;
-		const maxCellWidth = rows.reduce((max, row) => Math.max(max, row[i].length), 0);
-		return Math.max(headerWidth, maxCellWidth);
-	});
-	const getAlign = (i) => options?.align?.[columns[i]] ?? "left";
-	if (ctx.format === "markdown") return renderTableMarkdown(headers, rows, colWidths, getAlign);
-	if (ctx.format === "html") return renderTableHtml(columns, headers, rows, data, getAlign);
-	return renderTableText(headers, rows, colWidths, getAlign, options?.border !== false, ctx);
-}
-function renderTableText(headers, rows, colWidths, getAlign, border, ctx) {
-	const { styler } = ctx;
-	const formatRow = (cells, style) => cells.map((cell, i) => {
-		const padded = padCell(cell, colWidths[i], getAlign(i));
-		return style ? style(padded) : padded;
-	});
-	if (border) {
-		const sep = ctx.styler.meta("─");
-		const divider = colWidths.map((w) => sep.repeat(w + 2)).join(styler.meta("┼"));
-		const row = (cells) => cells.map((c, i) => ` ${padCell(c, colWidths[i], getAlign(i))} `).join(styler.meta("│"));
-		const headerRow = row(headers.map((h) => styler.label(h)));
-		const dataRows = rows.map((r) => row(r.map((c) => styler.description(c))));
-		return [
-			headerRow,
-			styler.meta("─") + divider + styler.meta("─"),
-			...dataRows
-		].join("\n");
-	}
-	const headerCells = formatRow(headers, styler.label);
-	const dataCells = rows.map((r) => formatRow(r, styler.description));
-	const gap = "  ";
-	return [headerCells.join(gap), ...dataCells.map((r) => r.join(gap))].join("\n");
-}
-function renderTableMarkdown(headers, rows, colWidths, getAlign) {
-	return [
-		`| ${headers.map((h, i) => padCell(h, colWidths[i], "left")).join(" | ")} |`,
-		"| " + colWidths.map((w, i) => {
-			const a = getAlign(i);
-			const dashes = "─".repeat(Math.max(w, 3));
-			if (a === "center") return `:${dashes}:`;
-			if (a === "right") return `${dashes}:`;
-			return dashes;
-		}).join(" | ") + " |",
-		...rows.map((r) => `| ${r.map((c, i) => padCell(c, colWidths[i], "left")).join(" | ")} |`)
-	].join("\n");
-}
-function renderTableHtml(columns, headers, _rows, data, getAlign) {
-	const ths = headers.map((h, i) => {
-		const a = getAlign(i);
-		return `<th${a !== "left" ? ` style="text-align: ${a};"` : ""}>${escapeHtml(h)}</th>`;
-	});
-	const trs = data.map((row) => "<tr>" + columns.map((col, i) => {
-		const a = getAlign(i);
-		return `<td${a !== "left" ? ` style="text-align: ${a};"` : ""}>${escapeHtml(stringifyCell(row[col]))}</td>`;
-	}).join("") + "</tr>");
-	return `<table><thead><tr>${ths.join("")}</tr></thead><tbody>${trs.join("")}</tbody></table>`;
-}
-function renderTree(data, options, ctx) {
-	const nodes = Array.isArray(data) ? data : [data];
-	if (nodes.length === 0) return "";
-	if (ctx.format === "json") return JSON.stringify(nodes, null, 2);
-	if (ctx.format === "markdown") return renderTreeMarkdown(nodes, 0);
-	if (ctx.format === "html") return renderTreeHtml(nodes);
-	return renderTreeText(nodes, "", options?.guides !== false, ctx).join("\n");
-}
-function renderTreeText(nodes, prefix, guides, ctx) {
-	const lines = [];
-	for (let i = 0; i < nodes.length; i++) {
-		const node = nodes[i];
-		const isLast = i === nodes.length - 1;
-		if (guides) {
-			const connector = isLast ? "└── " : "├── ";
-			const childPrefix = isLast ? "    " : "│   ";
-			lines.push(prefix + ctx.styler.meta(connector) + ctx.styler.label(node.label));
-			if (node.children?.length) lines.push(...renderTreeText(node.children, prefix + ctx.styler.meta(childPrefix), guides, ctx));
-		} else {
-			const indent = prefix ? `${prefix}  ` : "";
-			lines.push(indent + ctx.styler.label(node.label));
-			if (node.children?.length) lines.push(...renderTreeText(node.children, indent, guides, ctx));
-		}
-	}
-	return lines;
-}
-function renderTreeMarkdown(nodes, depth) {
-	return nodes.map((node) => {
-		const line = `${"  ".repeat(depth)}- ${node.label}`;
-		if (!node.children?.length) return line;
-		return `${line}\n${renderTreeMarkdown(node.children, depth + 1)}`;
-	}).join("\n");
-}
-function renderTreeHtml(nodes) {
-	return `<ul>${nodes.map((node) => {
-		const label = escapeHtml(node.label);
-		if (!node.children?.length) return `<li>${label}</li>`;
-		return `<li>${label}${renderTreeHtml(node.children)}</li>`;
-	}).join("")}</ul>`;
-}
-function renderList(data, options, ctx) {
-	if (data.length === 0) return "";
-	if (ctx.format === "json") {
-		const normalized = data.map((item) => typeof item === "string" ? { label: item } : item);
-		return JSON.stringify(normalized, null, 2);
-	}
-	if (ctx.format === "markdown") return renderListMarkdown(data, options);
-	if (ctx.format === "html") return renderListHtml(data, options);
-	return renderListText(data, options, ctx);
-}
-function renderListText(data, options, ctx) {
-	const { styler } = ctx;
-	const numbered = options?.numbered ?? false;
-	const bullet = options?.bullet ?? (ctx.format === "ansi" ? "•" : "-");
-	const baseIndent = "  ".repeat(options?.indent ?? 0);
-	return data.map((item, i) => {
-		const prefix = numbered ? `${i + 1}.` : bullet;
-		const label = typeof item === "string" ? item : item.label;
-		const desc = typeof item === "object" && item.description ? item.description : void 0;
-		const line = `${baseIndent}${styler.meta(prefix)} ${styler.label(label)}`;
-		if (!desc) return line;
-		return `${line}  ${styler.description(desc)}`;
-	}).join("\n");
-}
-function renderListMarkdown(data, options) {
-	const numbered = options?.numbered ?? false;
-	return data.map((item, i) => {
-		const prefix = numbered ? `${i + 1}.` : "-";
-		const label = typeof item === "string" ? item : item.label;
-		const desc = typeof item === "object" && item.description ? item.description : void 0;
-		if (!desc) return `${prefix} ${label}`;
-		return `${prefix} **${label}** — ${desc}`;
-	}).join("\n");
-}
-function renderListHtml(data, options) {
-	const tag = options?.numbered ? "ol" : "ul";
-	return `<${tag}>${data.map((item) => {
-		const label = typeof item === "string" ? item : item.label;
-		const desc = typeof item === "object" && item.description ? item.description : void 0;
-		if (!desc) return `<li>${escapeHtml(label)}</li>`;
-		return `<li><strong>${escapeHtml(label)}</strong> — ${escapeHtml(desc)}</li>`;
-	}).join("")}</${tag}>`;
-}
-function renderKeyValue(data, options, ctx) {
-	const entries = Object.entries(data);
-	if (entries.length === 0) return "";
-	if (ctx.format === "json") return JSON.stringify(data, null, 2);
-	if (ctx.format === "markdown") return renderKeyValueMarkdown(entries, options);
-	if (ctx.format === "html") return renderKeyValueHtml(entries, options);
-	return renderKeyValueText(entries, options, ctx);
-}
-function getLabel(key, labels) {
-	return labels?.[key] ?? key;
-}
-function renderKeyValueText(entries, options, ctx) {
-	const { styler } = ctx;
-	const sep = options?.separator ?? ": ";
-	const shouldAlign = options?.align !== false;
-	const displayLabels = entries.map(([k]) => getLabel(k, options?.labels));
-	const maxWidth = shouldAlign ? Math.max(...displayLabels.map((l) => l.length)) : 0;
-	return entries.map(([_key, value], i) => {
-		const label = displayLabels[i];
-		const paddedLabel = shouldAlign ? label + " ".repeat(maxWidth - label.length) : label;
-		return `${styler.label(paddedLabel)}${styler.meta(sep)}${styler.description(stringifyCell(value))}`;
-	}).join("\n");
-}
-function renderKeyValueMarkdown(entries, options) {
-	return entries.map(([key, value]) => `- **${getLabel(key, options?.labels)}**: ${stringifyCell(value)}`).join("\n");
-}
-function renderKeyValueHtml(entries, options) {
-	return `<dl>${entries.map(([key, value]) => `<dt>${escapeHtml(getLabel(key, options?.labels))}</dt><dd>${escapeHtml(stringifyCell(value))}</dd>`).join("")}</dl>`;
-}
-//#endregion
-//#region src/output/output-indicator.ts
-/** Create an output indicator that renders through the given output function and format context. */
-function createOutputIndicator(outputFn, ctx) {
-	let _called = false;
-	const emit = (rendered) => {
-		_called = true;
-		outputFn(rendered);
-	};
-	return {
-		table(data, options) {
-			emit(renderTable(data, options, ctx));
-		},
-		tree(data, options) {
-			emit(renderTree(data, options, ctx));
-		},
-		list(data, options) {
-			emit(renderList(data, options, ctx));
-		},
-		kv(data, options) {
-			emit(renderKeyValue(data, options, ctx));
-		},
-		raw(...args) {
-			_called = true;
-			outputFn(...args);
-		},
-		get called() {
-			return _called;
-		}
-	};
-}
-/** Format a return value using a declarative output config. */
-function formatDeclarativeOutput(value, config, ctx) {
-	const type = typeof config === "string" ? config : config.type;
-	const options = typeof config === "object" ? config.options : void 0;
-	switch (type) {
-		case "table":
-			if (!Array.isArray(value)) return void 0;
-			return renderTable(value, options, ctx);
-		case "tree": return renderTree(value, options, ctx);
-		case "list":
-			if (!Array.isArray(value)) return void 0;
-			return renderList(value, options, ctx);
-		case "kv":
-			if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-			return renderKeyValue(value, options, ctx);
-		case "json": return JSON.stringify(value, null, 2);
-		default: return;
-	}
-}
-//#endregion
-//#region src/extension/auto-output.ts
-/**
-* Outputs each value and collects into a result.
-* For iterators: outputs each yielded value, returns collected array.
-* For promises: awaits, then recurses.
-* For other values: outputs directly, returns as-is.
-*/
-function outputAndCollect(value, output) {
-	if (value == null) return value;
-	if (isAsyncIterator(value)) return (async () => {
-		const items = [];
-		const iter = value[Symbol.asyncIterator]();
-		while (true) {
-			const { done, value: item } = await iter.next();
-			if (done) break;
-			items.push(item);
-			if (item != null) output(item);
-		}
-		return items;
-	})();
-	if (typeof value !== "string" && !Array.isArray(value) && isIterator(value)) {
-		const items = [];
-		const iter = value[Symbol.iterator]();
-		while (true) {
-			const { done, value: item } = iter.next();
-			if (done) break;
-			items.push(item);
-			if (item != null) output(item);
-		}
-		return items;
-	}
-	if (value instanceof Promise) return value.then((resolved) => outputAndCollect(resolved, output));
-	output(value);
-	return value;
-}
-const autoOutputMeta = {
-	id: "padrone:auto-output",
-	name: "padrone:auto-output",
-	order: -1100
-};
-function createAutoOutputInterceptor(outputConfig, errorOutput) {
-	return defineInterceptor(autoOutputMeta, () => ({
-		error(ctx, next) {
-			const handleResult = (er) => {
-				if (!er.error || errorOutput === false || ctx.caller !== "cli" || ctx.phase !== "execute") return er;
-				const message = er.error instanceof Error ? er.error.message : String(er.error);
-				ctx.runtime.error(message);
-				return er;
-			};
-			const result = next();
-			if (result instanceof Promise) return result.then(handleResult);
-			return handleResult(result);
-		},
-		execute(ctx, next) {
-			const outputCtx = resolveOutputFormat(ctx.runtime, ctx.caller);
-			const indicator = createOutputIndicator(ctx.runtime.output, outputCtx);
-			const handleResult = (e) => {
-				if (indicator.called) return e;
-				const autoOutput = (value) => {
-					if (value == null) return value;
-					if (outputConfig) {
-						const rendered = formatDeclarativeOutput(value, outputConfig, outputCtx);
-						if (rendered !== void 0) {
-							ctx.runtime.output(rendered);
-							return value;
-						}
-					}
-					return outputAndCollect(value, ctx.runtime.output);
-				};
-				if (e.result instanceof Promise) return { result: e.result.then(autoOutput) };
-				const collected = autoOutput(e.result);
-				if (collected instanceof Promise) return collected.then((v) => ({ result: v }));
-				return { result: collected };
-			};
-			const executedOrPromise = next({ context: { output: indicator } });
-			if (executedOrPromise instanceof Promise) return executedOrPromise.then(handleResult);
-			return handleResult(executedOrPromise);
-		}
-	}));
-}
-/**
-* Extension that automatically writes a command's return value to output after execution.
-*
-* - Values are passed directly to the runtime's `output` function (no stringification).
-* - Promises are awaited before output.
-* - Iterators and async iterators are consumed, outputting each yielded value as it arrives.
-*   The result is replaced with the collected array so `drain()` still works.
-* - `undefined` and `null` results produce no output.
-*
-* Also injects `ctx.context.output` with format-aware output primitives (table, tree, list, kv).
-* When action handlers use these methods, auto-output skips to avoid double output.
-*
-* Included in the default extensions. Can also be applied per-command:
-* ```ts
-* createPadrone('my-cli')
-*   .command('users', (c) =>
-*     c.extend(padroneAutoOutput({ output: 'table' }))
-*       .action(() => fetchUsers())
-*   )
-* ```
-*/
-function padroneAutoOutput(options) {
-	const interceptor = options?.disabled ? defineInterceptor({
-		...autoOutputMeta,
-		disabled: true
-	}, () => ({})) : createAutoOutputInterceptor(options?.output, options?.errorOutput);
-	return ((builder) => builder.intercept(interceptor));
-}
-//#endregion
-//#region src/extension/color.ts
-const colorInterceptor = defineInterceptor({
-	id: "padrone:color",
-	name: "padrone:color",
-	order: -1001
-}, () => ({ parse(ctx, next) {
-	return thenMaybe(next(), (res) => {
-		if ("color" in res.rawArgs) {
-			const color = res.rawArgs.color;
-			delete res.rawArgs.color;
-			ctx.runtime.theme = color;
-		}
-		return res;
-	});
-} }));
-/**
-* Extension that handles `--color` / `--no-color` flags:
-* - `--color` or `--color=true` → use default theme
-* - `--color=false` or `--no-color` → disable colors (text format)
-* - `--color=<theme>` → use the named theme
-*
-* Modifies the runtime's format and theme accordingly.
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli').extend(padroneColor())
-* ```
-*/
-function padroneColor() {
-	return ((builder) => builder.intercept(colorInterceptor));
-}
-//#endregion
-//#region src/core/parse.ts
-/**
-* Split a string by a delimiter, respecting quoted segments and optional bracket nesting.
-* Handles escape sequences within quotes (\\" and \\\\).
-*/
-function splitQuoteAware(input, delimiter, opts) {
-	const results = [];
-	let current = "";
-	let inQuote = null;
-	let bracketDepth = 0;
-	let i = 0;
-	while (i < input.length) {
-		const char = input[i];
-		if (inQuote) {
-			if (char === "\\" && i + 1 < input.length) {
-				const nextChar = input[i + 1];
-				if (nextChar === inQuote || nextChar === "\\") {
-					current += nextChar;
-					i += 2;
-					continue;
-				}
-			}
-			if (char === inQuote) inQuote = null;
-			else current += char;
-		} else if (opts?.brackets && char === "[") {
-			bracketDepth++;
-			current += char;
-		} else if (opts?.brackets && char === "]") {
-			bracketDepth = Math.max(0, bracketDepth - 1);
-			current += char;
-		} else if (bracketDepth > 0) current += char;
-		else if (char === "\"" || char === "'" || char === "`") inQuote = char;
-		else if (char === delimiter || delimiter === " " && char === "	") {
-			if (delimiter === " " ? current : true) {
-				results.push(opts?.trim ? current.trim() : current);
-				current = "";
-			}
-		} else current += char;
-		i++;
-	}
-	if (delimiter === " " ? current : current || results.length > 0) results.push(opts?.trim ? current.trim() : current);
-	return results;
-}
-function parseCliInputToParts(input) {
-	const parts = splitQuoteAware(input.trim(), " ", { brackets: true });
-	const result = [];
-	let pendingIdx = -1;
-	let allowTerm = true;
-	let afterDoubleDash = false;
-	for (const part of parts) {
-		if (!part) continue;
-		if (part === "--" && !afterDoubleDash) {
-			pendingIdx = -1;
-			afterDoubleDash = true;
-			allowTerm = false;
-			continue;
-		}
-		if (afterDoubleDash) {
-			result.push({
-				type: "arg",
-				value: part
-			});
-			continue;
-		}
-		const hadPending = pendingIdx;
-		pendingIdx = -1;
-		if (part.startsWith("--no-") && part.length > 5) {
-			const key = part.slice(5).split(".");
-			result.push({
-				type: "named",
-				key,
-				value: void 0,
-				negated: true
-			});
-		} else if (part.startsWith("--")) {
-			const [keyStr = "", value] = splitNamedArgValue(part.slice(2));
-			const key = keyStr.split(".");
-			result.push({
-				type: "named",
-				key,
-				value
-			});
-			if (typeof value === "undefined") pendingIdx = result.length - 1;
-		} else if (part.startsWith("-") && part.length > 1 && !/^-\d/.test(part)) {
-			const [keyStr = "", value] = splitNamedArgValue(part.slice(1));
-			if (keyStr.length > 1 && typeof value === "undefined") {
-				for (let ci = 0; ci < keyStr.length - 1; ci++) result.push({
-					type: "alias",
-					key: [keyStr[ci]],
-					value: void 0
-				});
-				result.push({
-					type: "alias",
-					key: [keyStr[keyStr.length - 1]],
-					value: void 0
-				});
-				pendingIdx = result.length - 1;
-			} else if (keyStr.length > 1 && typeof value !== "undefined") {
-				for (let ci = 0; ci < keyStr.length - 1; ci++) result.push({
-					type: "alias",
-					key: [keyStr[ci]],
-					value: void 0
-				});
-				result.push({
-					type: "alias",
-					key: [keyStr[keyStr.length - 1]],
-					value
-				});
-			} else {
-				result.push({
-					type: "alias",
-					key: [keyStr],
-					value
-				});
-				if (typeof value === "undefined") pendingIdx = result.length - 1;
-			}
-		} else if (hadPending >= 0) result[hadPending].value = part;
-		else if (/^[a-zA-Z0-9_-]+$/.test(part) && allowTerm) result.push({
-			type: "term",
-			value: part
-		});
-		else {
-			result.push({
-				type: "arg",
-				value: part
-			});
-			allowTerm = false;
-		}
-	}
-	return result;
-}
-/**
-* Split named arg key and value, handling quoted values after =.
-*/
-function splitNamedArgValue(str) {
-	const eqIndex = str.indexOf("=");
-	if (eqIndex === -1) return [str, void 0];
-	const key = str.slice(0, eqIndex);
-	let value = str.slice(eqIndex + 1);
-	if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'") || value.startsWith("`") && value.endsWith("`")) {
-		value = value.slice(1, -1);
-		return [key, value];
-	}
-	if (value.startsWith("[") && value.endsWith("]")) {
-		const inner = value.slice(1, -1);
-		if (inner === "") return [key, []];
-		return [key, splitQuoteAware(inner, ",", { trim: true })];
-	}
-	return [key, value];
-}
-/**
-* Sets a value at a nested path in an object.
-* For example: setNestedValue(obj, ['user', 'profile', 'name'], 'John')
-* Creates intermediate objects as needed.
-*/
-function setNestedValue(obj, path, value) {
-	let current = obj;
-	for (let i = 0; i < path.length - 1; i++) {
-		const part = path[i];
-		if (!(part in current) || typeof current[part] !== "object" || current[part] === null) current[part] = {};
-		current = current[part];
-	}
-	const lastPart = path[path.length - 1];
-	current[lastPart] = value;
-}
-/**
-* Gets a value at a nested path in an object.
-* Returns undefined if the path doesn't exist.
-*/
-function getNestedValue(obj, path) {
-	let current = obj;
-	for (const part of path) {
-		if (current === null || current === void 0 || typeof current !== "object") return;
-		current = current[part];
-	}
-	return current;
-}
-//#endregion
-//#region src/core/validate.ts
-/**
-* Parses CLI input to find the command and extract raw arguments without validation.
-*/
-function parseCommand(input, rootCommand, findCommandByName) {
-	input ??= getCommandRuntime(rootCommand).argv().join(" ") || void 0;
-	if (!input) {
-		const defaultCommand = findCommandByName("", rootCommand.commands);
-		if (defaultCommand) return {
-			command: defaultCommand,
-			rawArgs: {},
-			args: [],
-			unmatchedTerms: []
-		};
-		return {
-			command: rootCommand,
-			rawArgs: {},
-			args: [],
-			unmatchedTerms: []
-		};
-	}
-	const parts = parseCliInputToParts(input);
-	const terms = parts.filter((p) => p.type === "term").map((p) => p.value);
-	const argTokens = parts.filter((p) => p.type === "arg").map((p) => p.value);
-	let curCommand = rootCommand;
-	let unmatchedTerms = [];
-	if (terms[0] === rootCommand.name) terms.shift();
-	for (let i = 0; i < terms.length; i++) {
-		const found = findCommandByName(terms[i] || "", curCommand.commands);
-		if (found) curCommand = found;
-		else {
-			unmatchedTerms = terms.slice(i);
-			argTokens.unshift(...unmatchedTerms);
-			break;
-		}
-	}
-	if (unmatchedTerms.length === 0 && curCommand.commands?.length) {
-		const defaultCommand = findCommandByName("", curCommand.commands);
-		if (defaultCommand) curCommand = defaultCommand;
-	}
-	if (!curCommand) return {
-		command: rootCommand,
-		rawArgs: {},
-		args: argTokens,
-		unmatchedTerms
-	};
-	const argsMeta = curCommand.meta?.fields;
-	const { flags, aliases, negatives, customNegation } = curCommand.argsSchema ? extractSchemaMetadata(curCommand.argsSchema, argsMeta, curCommand.meta?.autoAlias) : {
-		flags: {},
-		aliases: {},
-		negatives: {},
-		customNegation: /* @__PURE__ */ new Set()
-	};
-	const arrayArguments = /* @__PURE__ */ new Set();
-	if (curCommand.argsSchema) try {
-		const jsonSchema = getJsonSchema(curCommand.argsSchema);
-		if (jsonSchema.type === "object" && jsonSchema.properties) {
-			for (const [key, prop] of Object.entries(jsonSchema.properties)) if (prop?.type === "array") arrayArguments.add(key);
-		}
-	} catch {}
-	const argParts = parts.filter((p) => p.type === "named" || p.type === "alias");
-	const rawArgs = {};
-	for (const arg of argParts) {
-		let key;
-		if (arg.type === "alias" && arg.key.length === 1 && flags[arg.key[0]]) key = [flags[arg.key[0]]];
-		else if (arg.type === "named" && arg.key.length === 1 && aliases[arg.key[0]]) key = [aliases[arg.key[0]]];
-		else if (arg.type === "named" && arg.key.length === 1 && negatives[arg.key[0]]) {
-			setNestedValue(rawArgs, [negatives[arg.key[0]]], false);
-			continue;
-		} else key = arg.key;
-		const rootKey = key[0];
-		if (arg.type === "named" && arg.negated) {
-			if (customNegation.has(rootKey)) {
-				setNestedValue(rawArgs, [`no-${key.join(".")}`], false);
-				continue;
-			}
-			setNestedValue(rawArgs, key, false);
-			continue;
-		}
-		const value = arg.value ?? true;
-		if (arrayArguments.has(rootKey)) {
-			const existing = getNestedValue(rawArgs, key);
-			if (existing !== void 0) if (Array.isArray(existing)) if (Array.isArray(value)) existing.push(...value);
-			else existing.push(value);
-			else if (Array.isArray(value)) setNestedValue(rawArgs, key, [existing, ...value]);
-			else setNestedValue(rawArgs, key, [existing, value]);
-			else setNestedValue(rawArgs, key, Array.isArray(value) ? value : [value]);
-		} else {
-			const existing = getNestedValue(rawArgs, key);
-			if (existing !== void 0) if (Array.isArray(existing)) if (Array.isArray(value)) existing.push(...value);
-			else existing.push(value);
-			else if (Array.isArray(value)) setNestedValue(rawArgs, key, [existing, ...value]);
-			else setNestedValue(rawArgs, key, [existing, value]);
-			else setNestedValue(rawArgs, key, value);
-		}
-	}
-	return {
-		command: curCommand,
-		rawArgs,
-		args: argTokens,
-		unmatchedTerms
-	};
-}
-/**
-* Preprocesses raw arguments: maps positional arguments and performs auto-coercion.
-* External data sources (stdin, env, config) are handled by extensions before this runs.
-*/
-function buildCommandArgs(command, rawArgs, positionalArgs) {
-	let preprocessedArgs = preprocessArgs(rawArgs, {
-		flags: {},
-		aliases: {}
-	});
-	let issues;
-	const positionalConfig = command.meta?.positional ? parsePositionalConfig(command.meta.positional) : [];
-	if (positionalConfig.length > 0) {
-		let argIndex = 0;
-		for (let i = 0; i < positionalConfig.length; i++) {
-			const { name, variadic } = positionalConfig[i];
-			if (argIndex >= positionalArgs.length) break;
-			if (name in preprocessedArgs) {
-				issues ??= [];
-				issues.push({
-					path: [name],
-					message: `Ambiguous argument "${name}": provided both positionally and as a named option`
-				});
-				continue;
-			}
-			if (variadic) {
-				const nonVariadicAfter = positionalConfig.slice(i + 1).filter((p) => !p.variadic).length;
-				const variadicEnd = positionalArgs.length - nonVariadicAfter;
-				preprocessedArgs[name] = positionalArgs.slice(argIndex, variadicEnd);
-				argIndex = variadicEnd;
-			} else if (i === positionalConfig.length - 1 && positionalArgs.length > argIndex + 1) {
-				preprocessedArgs[name] = positionalArgs.slice(argIndex).join(" ");
-				argIndex = positionalArgs.length;
-			} else {
-				preprocessedArgs[name] = positionalArgs[argIndex];
-				argIndex++;
-			}
-		}
-	}
-	if (command.argsSchema) preprocessedArgs = coerceArgs(preprocessedArgs, command.argsSchema);
-	return {
-		args: preprocessedArgs,
-		issues
-	};
-}
-/**
-* Detects unknown options in args that aren't defined in the schema.
-* Returns unknown key info with suggestions, or empty array if schema is loose.
-*/
-function checkUnknownArgs(command, preprocessedArgs) {
-	if (!command.argsSchema) {
-		const unknowns = [];
-		for (const key of Object.keys(preprocessedArgs)) unknowns.push({ key });
-		return unknowns;
-	}
-	const argsMeta = command.meta?.fields;
-	const { flags, aliases, negatives } = extractSchemaMetadata(command.argsSchema, argsMeta, command.meta?.autoAlias);
-	return detectUnknownArgs(preprocessedArgs, command.argsSchema, flags, aliases, negatives);
-}
-/**
-* Validates preprocessed arguments against the command's schema.
-* First checks for unknown args (strict by default), then runs schema validation.
-* Returns sync or async result depending on the schema's validate method.
-*/
-function validateCommandArgs(command, preprocessedArgs) {
-	const unknownArgs = checkUnknownArgs(command, preprocessedArgs);
-	if (unknownArgs.length > 0) return {
-		args: void 0,
-		argsResult: { issues: unknownArgs.map(({ key }) => ({
-			path: [key],
-			message: `Unknown option: "${key}"`
-		})) }
-	};
-	const argsParsed = command.argsSchema ? command.argsSchema["~standard"].validate(preprocessedArgs) : { value: {} };
-	const buildResult = (parsed) => ({
-		args: parsed.issues ? void 0 : parsed.value,
-		argsResult: parsed
-	});
-	return thenMaybe(argsParsed, buildResult);
-}
-/**
-* Returns the list of known option names from a command's schema (for fuzzy suggestion).
-*/
-function getKnownOptionNames(command) {
-	if (!command.argsSchema) return [];
-	try {
-		const js = getJsonSchema(command.argsSchema);
-		if (js.type === "object" && js.properties) return Object.keys(js.properties);
-	} catch {}
-	return [];
-}
-/**
-* Formats validation issue messages for display.
-*/
-function formatIssueMessages(issues) {
-	return issues.map((i) => `  - ${i.path?.join(".") || "root"}: ${i.message}`).join("\n");
-}
-/**
-* Core validate function for parse() — preprocesses and validates CLI args.
-* Used by the parse program method (lighter weight than the full exec pipeline).
-* External data sources (stdin, env, config) are not resolved here — use eval() for that.
-*/
-function coreValidateForParse(command, rawArgs, positionalArgs) {
-	const { args: preprocessedArgs, issues } = buildCommandArgs(command, rawArgs, positionalArgs);
-	if (issues) return {
-		args: void 0,
-		argsResult: { issues }
-	};
-	return thenMaybe(validateCommandArgs(command, preprocessedArgs), (v) => v);
-}
-//#endregion
-//#region src/extension/utils.ts
-/** Minimal Standard Schema that passes through known fields, ignoring unknown ones. */
-function passthroughSchema(fields) {
-	return { "~standard": {
-		version: 1,
-		vendor: "padrone",
-		jsonSchema: {
-			input: () => ({}),
-			output: () => ({})
-		},
-		validate: (value) => {
-			const input = value && typeof value === "object" ? value : {};
-			const result = {};
-			for (const [name, type] of Object.entries(fields)) {
-				const v = input[name];
-				if (v === void 0) continue;
-				if (type === "string[]") {
-					if (Array.isArray(v)) result[name] = v.map(String);
-					else if (typeof v === "string") result[name] = [v];
-				} else if (type === "string") {
-					if (typeof v === "string") result[name] = v;
-					else if (Array.isArray(v) && v.length > 0) result[name] = String(v[0]);
-				} else if (type === "boolean") result[name] = v === true || v === "true";
-			}
-			return { value: result };
-		}
-	} };
-}
-/** Find a command by space-separated name in the command tree. */
-function findCommandInTree(name, rootCommand) {
-	const parts = name.split(" ").filter(Boolean);
-	let current = rootCommand;
-	for (const part of parts) {
-		const found = current.commands?.find((c) => c.name === part || c.aliases?.includes(part));
-		if (!found) return void 0;
-		current = found;
-	}
-	return current;
-}
-//#endregion
-//#region src/extension/help.ts
-const helpInterceptor = defineInterceptor({
-	id: "padrone:help",
-	name: "padrone:help",
-	order: -1e3
-}, () => {
-	let helpText;
-	let showDefaultHelp = false;
-	return {
-		parse(ctx, next) {
-			return thenMaybe(next(), (res) => {
-				const hasHelpFlag = res.rawArgs.help || res.rawArgs.h;
-				const reverseHelp = !hasHelpFlag && res.positionalArgs?.length > 0 && res.positionalArgs[res.positionalArgs.length - 1] === "help";
-				if (hasHelpFlag || reverseHelp) {
-					delete res.rawArgs.help;
-					delete res.rawArgs.h;
-					const detail = res.rawArgs.detail;
-					const format = res.rawArgs.format;
-					const all = res.rawArgs.all;
-					delete res.rawArgs.detail;
-					delete res.rawArgs.format;
-					delete res.rawArgs.all;
-					delete res.rawArgs.d;
-					delete res.rawArgs.f;
-					const rootCommand = getRootCommand(res.command);
-					resolveAllCommands(rootCommand);
-					helpText = generateHelp(rootCommand, res.command, {
-						detail,
-						format: format ?? ctx.runtime.format,
-						theme: ctx.runtime.theme,
-						all,
-						terminal: ctx.runtime.terminal,
-						env: ctx.runtime.env()
-					});
-					return res;
-				}
-				if (helpText === void 0) {
-					const { command } = res;
-					const hasSubcommands = command.commands && command.commands.length > 0;
-					const hasSchema = command.argsSchema != null;
-					const hasUnmatchedTerms = res.positionalArgs?.length > 0 && !command.meta?.positional?.length;
-					if (!command.action && (hasSubcommands || !hasSchema) && !hasUnmatchedTerms) showDefaultHelp = true;
-				}
-				return res;
-			});
-		},
-		validate(_ctx, next) {
-			if (helpText !== void 0) return {
-				args: void 0,
-				argsResult: { value: void 0 }
-			};
-			return next();
-		},
-		execute(ctx, next) {
-			if (helpText !== void 0) return { result: helpText };
-			if (showDefaultHelp) {
-				const rootCommand = getRootCommand(ctx.command);
-				resolveAllCommands(rootCommand);
-				return { result: generateHelp(rootCommand, ctx.command, {
-					format: ctx.runtime.format,
-					theme: ctx.runtime.theme,
-					terminal: ctx.runtime.terminal,
-					env: ctx.runtime.env()
-				}) };
-			}
-			return next();
-		},
-		error(ctx, next) {
-			return thenMaybe(next(), (er) => {
-				if (ctx.caller !== "cli" || !er.error) return er;
-				const rootCommand = getRootCommand(ctx.command);
-				if (er.error instanceof RoutingError) {
-					const targetPath = er.error.command;
-					const sourceCmd = (targetPath ? findCommandInTree(targetPath, rootCommand) : void 0) ?? rootCommand;
-					ctx.runtime.error(er.error.message);
-					if (er.error.suggestions.length > 0) {
-						const visibleCommands = (sourceCmd.commands ?? []).filter((c) => !c.hidden && c.name);
-						if (visibleCommands.length > 0) {
-							for (const cmd of visibleCommands) resolveCommand(cmd);
-							const cmdList = visibleCommands.map((c) => c.name).join(", ");
-							ctx.runtime.output(`\nAvailable commands: ${cmdList}`);
-						}
-					} else {
-						resolveAllCommands(rootCommand);
-						const helpText = generateHelp(rootCommand, sourceCmd, {
-							format: ctx.runtime.format,
-							theme: ctx.runtime.theme,
-							terminal: ctx.runtime.terminal,
-							env: ctx.runtime.env()
-						});
-						ctx.runtime.error(helpText);
-					}
-					return er;
-				}
-				if (er.error instanceof ValidationError) {
-					const targetPath = er.error.command;
-					const targetCommand = targetPath ? findCommandInTree(targetPath, rootCommand) : void 0;
-					const issueMessages = formatIssueMessages(er.error.issues);
-					resolveAllCommands(rootCommand);
-					const helpText = generateHelp(rootCommand, targetCommand ?? rootCommand, {
-						format: ctx.runtime.format,
-						theme: ctx.runtime.theme,
-						terminal: ctx.runtime.terminal,
-						env: ctx.runtime.env()
-					});
-					ctx.runtime.error(`Validation error:\n${issueMessages}`);
-					ctx.runtime.error(helpText);
-					return er;
-				}
-				return er;
-			});
-		}
-	};
-});
-/**
-* Extension that adds help support:
-* - `help` command with aliases `h` and `` (empty = executes on root when no subcommand matches)
-* - `--help` / `-h` flags
-* - `<cmd> help` reverse syntax
-* - Default help display when a command has no action
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli').extend(padroneHelp())
-* ```
-*/
-function padroneHelp() {
-	return ((builder) => builder.command(["help", "h"], (c) => c.configure({
-		description: "Display help for a command",
-		hidden: true
-	}).arguments(passthroughSchema({
-		command: "string[]",
-		detail: "string",
-		format: "string",
-		all: "boolean"
-	}), { positional: ["...command"] }).action((args, ctx) => {
-		const rootCommand = getRootCommand(ctx.command);
-		resolveAllCommands(rootCommand);
-		const commandName = args.command?.join(" ");
-		return generateHelp(rootCommand, (commandName ? findCommandInTree(commandName, rootCommand) : rootCommand) ?? rootCommand, {
-			detail: args.detail,
-			format: args.format ?? ctx.runtime.format,
-			theme: ctx.runtime.theme,
-			all: args.all,
-			terminal: ctx.runtime.terminal,
-			env: ctx.runtime.env()
-		});
-	})).intercept(helpInterceptor));
-}
-//#endregion
-//#region src/feature/interactive.ts
-/**
-* Auto-detect the prompt type for a field based on its JSON schema property definition.
-*/
-function detectPromptConfig(name, propSchema, description) {
-	const message = description || propSchema?.description || name;
-	if (!propSchema) return {
-		name,
-		message,
-		type: "input"
-	};
-	if (propSchema.type === "boolean") return {
-		name,
-		message,
-		type: "confirm",
-		default: propSchema.default
-	};
-	if (propSchema.enum) return {
-		name,
-		message,
-		type: "select",
-		choices: propSchema.enum.map((v) => ({
-			label: String(v),
-			value: v
-		})),
-		default: propSchema.default
-	};
-	if (propSchema.type === "array" && propSchema.items?.enum) return {
-		name,
-		message,
-		type: "multiselect",
-		choices: propSchema.items.enum.map((v) => ({
-			label: String(v),
-			value: v
-		})),
-		default: propSchema.default
-	};
-	if (propSchema.format === "password") return {
-		name,
-		message,
-		type: "password",
-		default: propSchema.default
-	};
-	return {
-		name,
-		message,
-		type: "input",
-		default: propSchema.default
-	};
-}
-/**
-* Prompt a single field and validate it against the command's schema.
-* Re-prompts with a warning until the user provides a valid value.
-*/
-async function promptWithValidation(field, config, currentData, command, runtime) {
-	let promptConfig = config;
-	while (true) {
-		const value = await runtime.prompt(promptConfig);
-		if (!command.argsSchema) return value;
-		const testData = {
-			...currentData,
-			[field]: value
-		};
-		const validated = await command.argsSchema["~standard"].validate(testData);
-		if (!validated.issues) return value;
-		const fieldIssues = validated.issues.filter((issue) => {
-			const rootKey = issue.path?.[0];
-			return rootKey !== void 0 && String(rootKey) === field;
-		});
-		if (fieldIssues.length === 0) return value;
-		const messages = fieldIssues.map((i) => i.message).join("; ");
-		runtime.error(`Invalid value for "${field}": ${messages}`);
-		promptConfig = {
-			...config,
-			default: value
-		};
-	}
-}
-/**
-* Prompt for missing interactive fields.
-* Runs after env/config preprocessing and before schema validation.
-*
-* When `force` is true, all configured interactive fields are prompted even if they already
-* have values. The current values are used as defaults in the prompts.
-*/
-async function promptInteractiveFields(data, command, runtime, force) {
-	if (!runtime.prompt) return data;
-	const meta = command.meta;
-	const interactiveConfig = meta?.interactive;
-	const optionalInteractiveConfig = meta?.optionalInteractive;
-	if (!interactiveConfig && !optionalInteractiveConfig) return data;
-	let jsonProperties = {};
-	let requiredFields = /* @__PURE__ */ new Set();
-	if (command.argsSchema) try {
-		const jsonSchema = getJsonSchema(command.argsSchema);
-		if (jsonSchema.type === "object" && jsonSchema.properties) jsonProperties = jsonSchema.properties;
-		if (Array.isArray(jsonSchema.required)) requiredFields = new Set(jsonSchema.required);
-	} catch {}
-	const fieldDescriptions = {};
-	if (meta?.fields) {
-		for (const [key, value] of Object.entries(meta.fields)) if (value?.description) fieldDescriptions[key] = value.description;
-	}
-	const result = { ...data };
-	let fieldsToPrompt = [];
-	if (interactiveConfig === true) if (force) fieldsToPrompt = [...requiredFields];
-	else fieldsToPrompt = [...requiredFields].filter((name) => result[name] === void 0);
-	else if (Array.isArray(interactiveConfig)) if (force) fieldsToPrompt = [...interactiveConfig];
-	else fieldsToPrompt = interactiveConfig.filter((name) => result[name] === void 0);
-	for (const field of fieldsToPrompt) {
-		const config = detectPromptConfig(field, jsonProperties[field], fieldDescriptions[field]);
-		if (force && result[field] !== void 0) config.default = result[field];
-		result[field] = await promptWithValidation(field, config, result, command, runtime);
-	}
-	let optionalFields = [];
-	if (optionalInteractiveConfig === true) if (force) optionalFields = Object.keys(jsonProperties).filter((name) => !requiredFields.has(name));
-	else optionalFields = Object.keys(jsonProperties).filter((name) => !requiredFields.has(name) && result[name] === void 0);
-	else if (Array.isArray(optionalInteractiveConfig)) if (force) optionalFields = [...optionalInteractiveConfig];
-	else optionalFields = optionalInteractiveConfig.filter((name) => result[name] === void 0);
-	if (optionalFields.length > 0) {
-		const selected = await runtime.prompt({
-			name: "_optionalFields",
-			message: "Would you also like to configure:",
-			type: "multiselect",
-			choices: optionalFields.map((f) => {
-				const label = fieldDescriptions[f] || jsonProperties[f]?.description || f;
-				const currentValue = result[f];
-				return {
-					label: force && currentValue !== void 0 ? `${label} (current: ${currentValue})` : label,
-					value: f
-				};
-			})
-		});
-		if (Array.isArray(selected)) for (const field of selected) {
-			const config = detectPromptConfig(field, jsonProperties[field], fieldDescriptions[field]);
-			if (force && result[field] !== void 0) config.default = result[field];
-			result[field] = await promptWithValidation(field, config, result, command, runtime);
-		}
-	}
-	return result;
-}
-//#endregion
-//#region src/extension/interactive.ts
-const interactiveInterceptor = defineInterceptor({
-	id: "padrone:interactive",
-	name: "padrone:interactive",
-	order: -999
-}, () => ({ validate(ctx, next) {
-	let flagInteractive;
-	if (hasInteractiveConfig(ctx.command.meta)) {
-		if (ctx.rawArgs.interactive !== void 0) {
-			flagInteractive = ctx.rawArgs.interactive !== false && ctx.rawArgs.interactive !== "false";
-			delete ctx.rawArgs.interactive;
-		}
-		if (ctx.rawArgs.i !== void 0) {
-			flagInteractive = ctx.rawArgs.i !== false && ctx.rawArgs.i !== "false";
-			delete ctx.rawArgs.i;
-		}
-	}
-	const { runtime, command } = ctx;
-	const runtimeDefault = runtime.interactive === "forced" ? true : runtime.interactive === "disabled" ? false : void 0;
-	const effectiveInteractive = flagInteractive ?? ctx.evalInteractive ?? runtimeDefault;
-	const stdinIsPiped = !!command.meta?.stdin && (runtime.stdin ? !runtime.stdin.isTTY : runtime.terminal?.isTTY !== true);
-	const interactivitySuppressed = runtime.interactive === "unsupported" || effectiveInteractive === false || stdinIsPiped && effectiveInteractive !== true;
-	const forceInteractive = !interactivitySuppressed && effectiveInteractive === true;
-	if (!(!interactivitySuppressed && runtime.prompt && hasInteractiveConfig(command.meta))) return next();
-	const { args: preprocessedArgs, issues: positionalIssues } = buildCommandArgs(command, ctx.rawArgs, ctx.positionalArgs);
-	if (positionalIssues) return {
-		args: void 0,
-		argsResult: { issues: positionalIssues }
-	};
-	const unknowns = checkUnknownArgs(command, preprocessedArgs);
-	if (unknowns.length > 0) return {
-		args: void 0,
-		argsResult: { issues: unknowns.map(({ key }) => ({
-			path: [key],
-			message: `Unknown option: "${key}"`
-		})) }
-	};
-	const earlyValidateAndPrompt = () => {
-		if (command.argsSchema) {
-			const providedKeys = new Set(Object.keys(preprocessedArgs).filter((k) => preprocessedArgs[k] !== void 0));
-			const earlyCheck = command.argsSchema["~standard"].validate(preprocessedArgs);
-			const checkForProvidedFieldErrors = (result) => {
-				if (!result.issues) return void 0;
-				const providedFieldIssues = result.issues.filter((issue) => {
-					const rootKey = issue.path?.[0];
-					return rootKey !== void 0 && providedKeys.has(String(rootKey));
-				});
-				if (providedFieldIssues.length > 0) return {
-					args: void 0,
-					argsResult: { issues: providedFieldIssues }
-				};
-			};
-			const earlyResult = thenMaybe(earlyCheck, (result) => checkForProvidedFieldErrors(result) ?? void 0);
-			if (earlyResult instanceof Promise) return earlyResult.then((err) => err ? err : doPrompt());
-			if (earlyResult) return earlyResult;
-		}
-		return doPrompt();
-	};
-	const doPrompt = () => {
-		return thenMaybe(promptInteractiveFields(preprocessedArgs, command, runtime, forceInteractive || void 0), (filledArgs) => {
-			return next({
-				rawArgs: filledArgs,
-				positionalArgs: []
-			});
-		});
-	};
-	return earlyValidateAndPrompt();
-} }));
-/**
-* Extension that handles interactive prompting for missing arguments.
-* Extracts `--interactive` / `-i` flags, resolves effective interactivity,
-* and prompts for missing fields before passing filled args to validation.
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli').extend(padroneInteractive())
-* ```
-*/
-function padroneInteractive() {
-	return ((builder) => builder.intercept(interactiveInterceptor));
-}
-//#endregion
-//#region src/extension/repl.ts
-/**
-* Extension that adds REPL support:
-* - `repl` command that starts an interactive REPL
-* - `--repl` flag that starts the REPL from any invocation
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli').extend(padroneRepl())
-* ```
-*/
-function padroneRepl(defaults) {
-	const disabled = defaults?.disabled;
-	return ((builder) => builder.command("repl", (c) => c.configure({
-		description: "Start an interactive REPL",
-		hidden: true
-	}).arguments(passthroughSchema({ scope: "string" }), { positional: ["scope"] }).async().action(async (args, ctx) => {
-		const prefs = {
-			...defaults,
-			scope: args.scope ?? defaults?.scope
-		};
-		const { value } = await ctx.program.repl(prefs).drain();
-		return value;
-	})).intercept(createReplInterceptor(defaults, disabled)));
-}
-function createReplInterceptor(defaults, disabled) {
-	return defineInterceptor({
-		id: "padrone:repl",
-		name: "padrone:repl",
-		order: -1e3,
-		disabled
-	}, () => ({ start(ctx, next) {
-		const replInfo = checkReplFlag(ctx.input, ctx.command);
-		if (!replInfo) return next();
-		const program = ctx.program;
-		if (!program?.repl) return next();
-		const prefs = {
-			...defaults,
-			scope: replInfo.scope ?? defaults?.scope
-		};
-		return program.repl(prefs).drain().then((r) => withDrain({
-			command: ctx.command,
-			args: void 0,
-			result: r.value
-		}));
-	} }));
-}
-/** Check for --repl flag in input. */
-function checkReplFlag(input, rootCommand) {
-	if (!input) return null;
-	const parts = parseCliInputToParts(input);
-	const terms = parts.filter((p) => p.type === "term").map((p) => p.value);
-	const args = parts.filter((p) => p.type === "named");
-	const keyIs = (key, name) => key.length === 1 && key[0] === name;
-	if (!args.some((p) => p.type === "named" && keyIs(p.key, "repl"))) return null;
-	const normalizedTerms = [...terms];
-	if (normalizedTerms[0] === rootCommand.name) normalizedTerms.shift();
-	return { scope: normalizedTerms.length > 0 ? normalizedTerms.join(" ") : void 0 };
-}
-//#endregion
-//#region src/extension/signal.ts
-const signalMeta = {
-	id: "padrone:signal",
-	name: "padrone:signal",
-	order: -2e3
-};
-const signalInterceptor = defineInterceptor(signalMeta, () => {
-	const abortController = new AbortController();
-	let receivedSignal;
-	let lastSigintTime = 0;
-	let unsubscribe;
-	const DOUBLE_SIGINT_MS = 2e3;
-	const cleanup = () => {
-		unsubscribe?.();
-		unsubscribe = void 0;
-	};
-	const attachSignalInfo = (result) => {
-		if (receivedSignal && result && typeof result === "object") {
-			result.signal = receivedSignal;
-			result.exitCode = signalExitCode(receivedSignal);
-		}
-		return result;
-	};
-	return {
-		start(ctx, next) {
-			const runtimeExit = ctx.runtime.exit;
-			unsubscribe = ctx.runtime.onSignal?.((sig) => {
-				if (abortController.signal.aborted) {
-					if (sig === "SIGINT") {
-						const elapsed = Date.now() - lastSigintTime;
-						if (elapsed > 0 && elapsed < DOUBLE_SIGINT_MS) runtimeExit?.(signalExitCode(sig));
-						lastSigintTime = Date.now();
-					}
-					return;
-				}
-				if (sig === "SIGINT") lastSigintTime = Date.now();
-				receivedSignal = sig;
-				abortController.abort(sig);
-			});
-			return thenMaybe(next({ signal: abortController.signal }), (r) => {
-				cleanup();
-				return attachSignalInfo(r);
-			});
-		},
-		error(_ctx, next) {
-			return thenMaybe(next(), (er) => {
-				if (receivedSignal && er.error instanceof Error) er.error = new SignalError(receivedSignal, { cause: er.error });
-				return er;
-			});
-		},
-		shutdown(_ctx, next) {
-			cleanup();
-			return next();
-		}
-	};
-});
-/**
-* Extension that wires process signal handling (SIGINT, SIGTERM, SIGHUP) into the interceptor lifecycle.
-*
-* - Creates an `AbortController` whose signal is propagated to all downstream phases.
-* - Subscribes to `runtime.onSignal` to forward OS signals to the abort controller.
-* - Implements SIGINT double-tap: two SIGINTs within 2 seconds force-exits the process.
-* - Attaches `signal` and `exitCode` to results and errors when interrupted.
-* - Cleans up the signal subscription on completion or failure.
-*
-* Included in the default extensions. Runs at order `-2000` (outermost).
-*/
-function padroneSignalHandling(options) {
-	const interceptor = options?.disabled ? defineInterceptor({
-		...signalMeta,
-		disabled: true
-	}, () => ({})) : signalInterceptor;
-	return ((builder) => builder.intercept(interceptor));
-}
-//#endregion
-//#region src/extension/stdin.ts
-const stdinInterceptor = defineInterceptor({
-	id: "padrone:stdin",
-	name: "padrone:stdin",
-	order: -1001
-}, () => ({ validate(ctx, next) {
-	const stdinField = ctx.command.meta?.stdin;
-	if (!stdinField) return next();
-	if (stdinField in ctx.rawArgs && ctx.rawArgs[stdinField] !== void 0) return next();
-	const streamInfo = isAsyncStreamField(ctx.command.argsSchema, stdinField);
-	if (streamInfo) {
-		const stdinForStream = resolveStdinAlways(ctx.runtime);
-		return next({ rawArgs: applyValues(ctx.rawArgs, { [stdinField]: createStdinStream(stdinForStream, streamInfo.itemSchema) }) });
-	}
-	const stdin = resolveStdin(ctx.runtime);
-	if (!stdin) return next();
-	if (isArrayField(ctx.command.argsSchema, stdinField)) return (async () => {
-		const lines = [];
-		for await (const line of stdin.lines()) lines.push(line);
-		return next({ rawArgs: applyValues(ctx.rawArgs, { [stdinField]: lines }) });
-	})();
-	return stdin.text().then((text) => {
-		if (!text) return next();
-		return next({ rawArgs: applyValues(ctx.rawArgs, { [stdinField]: text }) });
-	});
-} }));
-/**
-* Extension that reads stdin data into the argument field specified by `meta.stdin`.
-* Included by default via `createPadrone()`.
-*
-* Read mode is inferred from the schema type:
-* - `string` field → reads all stdin as a single string
-* - `string[]` field → reads stdin line-by-line into an array
-* - `AsyncIterable` field → returns a stream for line-by-line async consumption
-*
-* Stdin is only read when piped (not a TTY) and the field wasn't already provided via CLI flags.
-*/
-function padroneStdin(options) {
-	const interceptor = options?.disabled ? defineInterceptor({
-		...stdinInterceptor,
-		disabled: true
-	}, () => ({})) : stdinInterceptor;
-	return ((builder) => builder.intercept(interceptor));
-}
-//#endregion
-//#region src/extension/suggestions.ts
-function formatSuggestions(names, prefix = "") {
-	if (names.length === 0) return "";
-	const quoted = names.map((n) => `"${prefix}${n}"`);
-	if (quoted.length === 1) return `Did you mean ${quoted[0]}?`;
-	return `Did you mean ${quoted.slice(0, -1).join(", ")} or ${quoted.at(-1)}?`;
-}
-function findSourceCommand(commandPath, root) {
-	if (!commandPath || commandPath === root.name || commandPath === root.path) return root;
-	const parts = commandPath.split(" ");
-	let current = root;
-	for (const part of parts) {
-		const found = current.commands?.find((c) => {
-			resolveCommand(c);
-			return c.name === part || c.aliases?.includes(part);
-		});
-		if (found) current = found;
-		else break;
-	}
-	return current;
-}
-function enrichRoutingError(err, rootCommand) {
-	if (!(err instanceof RoutingError)) return err;
-	const unknownMatch = err.message.match(/^Unknown command: (\S+)/);
-	const unexpectedMatch = err.message.match(/^Unexpected arguments for '[^']+': (\S+)/);
-	const term = unknownMatch?.[1] ?? unexpectedMatch?.[1];
-	if (!term) return err;
-	const sourceCmd = findSourceCommand(err.command, rootCommand);
-	const candidateNames = [];
-	if (sourceCmd.commands) for (const cmd of sourceCmd.commands) {
-		resolveCommand(cmd);
-		if (!cmd.hidden) {
-			candidateNames.push(cmd.name);
-			if (cmd.aliases) candidateNames.push(...cmd.aliases);
-		}
-	}
-	const suggestionText = formatSuggestions(suggestSimilar(term, candidateNames));
-	if (!suggestionText) return err;
-	const suggestions = [suggestionText];
-	return new RoutingError(`${err.message}\n\n  ${suggestionText}`, {
-		suggestions,
-		command: err.command
-	});
-}
-function enrichIssuesWithSuggestions(issues, knownOptions) {
-	return issues.map((i) => {
-		const unknownMatch = i.message?.match(/^Unknown option: "([^"]+)"$/);
-		if (unknownMatch) {
-			const similar = suggestSimilar(unknownMatch[1], knownOptions());
-			if (similar.length) {
-				const hint = formatSuggestions(similar, "--");
-				return {
-					...i,
-					message: `${i.message} ${hint}`
-				};
-			}
-			return i;
-		}
-		const keys = i.keys ?? i.message?.match(/[Uu]nrecognized key(?:s)?[^"]*"([^"]+)"/)?.slice(1);
-		if (!keys?.length) return i;
-		const hints = keys.flatMap((k) => {
-			const similar = suggestSimilar(k, knownOptions());
-			return similar.length ? [formatSuggestions(similar, "--")] : [];
-		});
-		if (!hints.length) return i;
-		return {
-			...i,
-			message: `${i.message} ${hints.join(" ")}`
-		};
-	});
-}
-const suggestionsInterceptor = defineInterceptor({
-	id: "padrone:suggestions",
-	name: "padrone:suggestions",
-	order: -500
-}, () => ({
-	parse(ctx, next) {
-		try {
-			const result = next();
-			if (result instanceof Promise) return result.catch((err) => {
-				throw enrichRoutingError(err, ctx.command);
-			});
-			return result;
-		} catch (err) {
-			throw enrichRoutingError(err, ctx.command);
-		}
-	},
-	validate(ctx, next) {
-		return thenMaybe(next(), (v) => {
-			if (!v.argsResult?.issues?.length) return v;
-			const enriched = enrichIssuesWithSuggestions(v.argsResult.issues, () => getKnownOptionNames(ctx.command));
-			return {
-				...v,
-				argsResult: {
-					...v.argsResult,
-					issues: enriched
-				}
-			};
-		});
-	}
-}));
-function padroneSuggestions() {
-	return ((builder) => builder.intercept(suggestionsInterceptor));
-}
-//#endregion
-//#region src/extension/version.ts
-const versionInterceptor = defineInterceptor({
-	id: "padrone:version",
-	name: "padrone:version",
-	order: -1e3
-}, () => ({ parse(_ctx, next) {
-	return thenMaybe(next(), (res) => {
-		if ((res.rawArgs.version || res.rawArgs.v || res.rawArgs.V) && !res.command.parent) {
-			delete res.rawArgs.version;
-			delete res.rawArgs.v;
-			delete res.rawArgs.V;
-			const versionCmd = res.command.commands?.find((c) => c.name === "version");
-			if (versionCmd) {
-				resolveCommand(versionCmd);
-				return {
-					...res,
-					command: versionCmd,
-					rawArgs: {},
-					positionalArgs: []
-				};
-			}
-		}
-		return res;
-	});
-} }));
-/**
-* Extension that adds version support:
-* - `version` command
-* - `--version` / `-v` / `-V` flags (root command only)
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli').extend(padroneVersion())
-* ```
-*/
-function padroneVersion() {
-	return ((builder) => builder.command("version", (c) => c.configure({
-		description: "Display the version number",
-		hidden: true
-	}).action((_args, ctx) => {
-		return getVersion(getRootCommand(ctx.command).version);
-	})).intercept(versionInterceptor));
-}
-//#endregion
-//#region src/feature/wrap.ts
-/**
-* Converts parsed arguments to CLI arguments for an external command.
-*/
-function argsToCliArgs(input, positional = []) {
-	const args = [];
-	if (!input) return args;
-	const positionalValues = {};
-	const regularArguments = {};
-	for (const [key, value] of Object.entries(input)) if (positional.includes(key) || positional.includes(`...${key}`)) positionalValues[key] = value;
-	else regularArguments[key] = value;
-	for (const [key, value] of Object.entries(regularArguments)) {
-		if (value === void 0 || value === null) continue;
-		const flag = `--${key}`;
-		if (typeof value === "boolean") {
-			if (value) args.push(flag);
-		} else if (Array.isArray(value)) for (const item of value) args.push(flag, String(item));
-		else args.push(flag, String(value));
-	}
-	for (const posKey of positional) {
-		const isVariadic = posKey.startsWith("...");
-		const value = positionalValues[isVariadic ? posKey.slice(3) : posKey];
-		if (value === void 0 || value === null) continue;
-		if (isVariadic && Array.isArray(value)) args.push(...value.map(String));
-		else args.push(String(value));
-	}
-	return args;
-}
-/**
-* Creates an action handler that wraps an external CLI tool.
-* @param config - Configuration for wrapping the external command (includes optional schema)
-* @param commandArguments - The command's arguments schema
-* @param commandPositional - Default positional config from the wrapping command
-*/
-function createWrapHandler(config, commandArguments, commandPositional) {
-	return async (args) => {
-		const { command, args: fixedArgs = [], inheritStdio = true, positional = commandPositional, schema: wrapSchema } = config;
-		const validationResult = (wrapSchema ? typeof wrapSchema === "function" ? wrapSchema(commandArguments) : wrapSchema : commandArguments)["~standard"].validate(args);
-		const processResult = (result) => {
-			if (result.issues) throw new ValidationError(`Wrap schema validation failed:\n${result.issues.map((i) => `  - ${i.path?.join(".") || "root"}: ${i.message}`).join("\n")}`, result.issues);
-			return result.value;
-		};
-		const regularArgs = argsToCliArgs(validationResult instanceof Promise ? await validationResult.then(processResult) : processResult(validationResult), positional);
-		const allArgs = [...fixedArgs, ...regularArgs];
-		const { spawn } = await import("node:child_process");
-		return new Promise((resolve, reject) => {
-			const proc = spawn(command, allArgs, { stdio: inheritStdio ? "inherit" : [
-				"ignore",
-				"pipe",
-				"pipe"
-			] });
-			const stdoutChunks = [];
-			const stderrChunks = [];
-			if (!inheritStdio) {
-				proc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
-				proc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
-			}
-			const decoder = new TextDecoder();
-			proc.on("error", reject);
-			proc.on("close", (code) => {
-				const exitCode = code ?? 1;
-				resolve({
-					exitCode,
-					stdout: inheritStdio ? void 0 : decoder.decode(concatBytes(stdoutChunks)),
-					stderr: inheritStdio ? void 0 : decoder.decode(concatBytes(stderrChunks)),
-					success: exitCode === 0
-				});
-			});
-		});
-	};
-}
-//#endregion
-//#region src/core/exec.ts
-/**
-* Collects registered interceptors from the command's parent chain (root → ... → target).
-* Root/program interceptors come first (outermost), target command's interceptors last (innermost).
-*/
-function collectInterceptors(cmd, rootCommand) {
-	const chain = [];
-	let current = cmd;
-	while (current) {
-		const isTarget = current === cmd;
-		if (!current.parent) {
-			if (rootCommand.interceptors?.length) {
-				const isRootTarget = cmd === rootCommand || !cmd.parent;
-				chain.unshift(isRootTarget ? rootCommand.interceptors : rootCommand.interceptors.filter((i) => i.meta.inherit !== false));
-			}
-		} else if (current.interceptors?.length) chain.unshift(isTarget ? current.interceptors : current.interceptors.filter((i) => i.meta.inherit !== false));
-		current = current.parent;
-	}
-	return chain.flat();
-}
-/** Wraps an error into a result, preserving any signal info from the pipeline. */
-function errorResultWithSignal(err) {
-	const result = errorResult(err);
-	if (err instanceof SignalError) {
-		result.signal = err.signal;
-		result.exitCode = err.exitCode;
-	}
-	return result;
-}
-/** Resolve context by walking the command parent chain and applying transforms from root to target. */
-function resolveContext(command, initialContext) {
-	const chain = [];
-	let current = command;
-	while (current) {
-		chain.unshift(current);
-		current = current.parent;
-	}
-	let resolved = initialContext;
-	for (const cmd of chain) if (cmd.contextTransform) resolved = cmd.contextTransform(resolved);
-	return resolved;
-}
-/** Validate parse result — reject unmatched terms when the command doesn't accept positional args. */
-function validateParseResult(parseResult, rootCommand) {
-	const { command, rawArgs, args, unmatchedTerms } = parseResult;
-	if (unmatchedTerms.length > 0) {
-		if (!(command.meta?.positional && command.meta.positional.length > 0)) {
-			const isRootCommand = command === rootCommand;
-			const commandDisplayName = command.name || command.aliases?.[0] || command.path || "(default)";
-			throw new RoutingError(isRootCommand ? `Unknown command: ${unmatchedTerms[0]}` : `Unexpected arguments for '${commandDisplayName}': ${unmatchedTerms.join(" ")}`, { command: command.path || command.name });
-		}
-	}
-	return {
-		command,
-		rawArgs,
-		positionalArgs: args
-	};
-}
-/** Handle validation issues based on error mode: throw (hard) or return result with issues (soft). */
-function handleValidationIssues(argsResult, command, errorMode) {
-	if (errorMode === "hard") throw new ValidationError(`Validation error:\n${formatIssueMessages(argsResult.issues)}`, argsResult.issues, { command: command.path || command.name });
-	return withDrain({
-		command,
-		args: void 0,
-		argsResult,
-		result: void 0
-	});
-}
-/**
-* Core execution logic shared by eval() and cli().
-* errorMode controls validation error behavior:
-* - 'soft': return result with issues (eval behavior)
-* - 'hard': print error + help and throw (cli-without-input behavior)
-*/
-function execCommand(resolvedInput, ctx, evalOptions, errorMode = "soft", caller = "eval") {
-	const { rootCommand, parseCommandFn, collectInterceptorsFn } = ctx;
-	const baseRuntime = getCommandRuntime(rootCommand);
-	const runtime = evalOptions?.runtime ? Object.assign({}, baseRuntime, Object.fromEntries(Object.entries(evalOptions.runtime).filter(([, v]) => v !== void 0))) : baseRuntime;
-	const inertSignal = new AbortController().signal;
-	const pipelineState = { phase: "start" };
-	const initialContext = evalOptions?.context;
-	const factoryCache = /* @__PURE__ */ new Map();
-	const rootInterceptors = resolveRegisteredInterceptors(rootCommand.interceptors ?? [], factoryCache);
-	const rootInterceptorSet = new Set(rootInterceptors);
-	const runPipeline = (signal, pipelineContext) => {
-		const parseCtx = {
-			input: resolvedInput,
-			command: rootCommand,
-			signal,
-			context: pipelineContext,
-			runtime,
-			program: ctx.builder,
-			caller
-		};
-		const coreParse = (parseCtx) => validateParseResult(parseCommandFn(parseCtx.input), rootCommand);
-		const parsedOrPromise = runInterceptorChain("parse", rootInterceptors, parseCtx, coreParse);
-		const continueAfterParse = (parsed) => {
-			const { command } = parsed;
-			pipelineState.phase = "parse";
-			pipelineState.rawArgs = parsed.rawArgs;
-			pipelineState.positionalArgs = parsed.positionalArgs;
-			const commandInterceptors = resolveRegisteredInterceptors(collectInterceptorsFn(command), factoryCache);
-			const commandOnlyInterceptors = commandInterceptors.filter((i) => !rootInterceptorSet.has(i));
-			const context = resolveContext(command, pipelineContext);
-			const routedOrPromise = runInterceptorChain("route", commandInterceptors, {
-				...parseCtx,
-				command,
-				rawArgs: parsed.rawArgs,
-				positionalArgs: parsed.positionalArgs,
-				context
-			}, () => {});
-			const continueAfterRoute = () => {
-				pipelineState.phase = "route";
-				const runValidateAndExecute = () => {
-					const validateCtx = {
-						...parseCtx,
-						command,
-						rawArgs: parsed.rawArgs,
-						positionalArgs: parsed.positionalArgs,
-						context,
-						evalInteractive: evalOptions?.interactive
-					};
-					const coreValidate = (validateCtx) => {
-						const { args: preprocessedArgs, issues } = buildCommandArgs(validateCtx.command, validateCtx.rawArgs, validateCtx.positionalArgs);
-						if (issues) return {
-							args: void 0,
-							argsResult: { issues }
-						};
-						return thenMaybe(validateCommandArgs(validateCtx.command, preprocessedArgs), (v) => v);
-					};
-					const validatedOrPromise = runInterceptorChain("validate", commandInterceptors, validateCtx, coreValidate);
-					const continueAfterValidate = (v) => {
-						pipelineState.phase = "validate";
-						pipelineState.args = v.args;
-						if (v.argsResult?.issues) return handleValidationIssues(v.argsResult, command, errorMode);
-						const executeCtx = {
-							...validateCtx,
-							args: v.args
-						};
-						const coreExecute = (executeCtx) => {
-							const handler = command.action ?? noop;
-							const actionCtx = {
-								runtime: executeCtx.runtime,
-								command: executeCtx.command,
-								program: ctx.builder,
-								signal: executeCtx.signal,
-								context: executeCtx.context,
-								caller
-							};
-							return { result: handler(executeCtx.args, actionCtx) };
-						};
-						pipelineState.phase = "execute";
-						return thenMaybe(runInterceptorChain("execute", commandInterceptors, executeCtx, coreExecute), (e) => {
-							const finalize = (result) => withDrain({
-								command,
-								args: v.args,
-								argsResult: v.argsResult,
-								result
-							});
-							if (e.result instanceof Promise) return e.result.then(finalize);
-							return finalize(e.result);
-						});
-					};
-					return thenMaybe(warnIfUnexpectedAsync(validatedOrPromise, command), continueAfterValidate);
-				};
-				return wrapWithCommandLifecycle(commandOnlyInterceptors, command, resolvedInput, runValidateAndExecute, (result) => withDrain({
-					command,
-					args: void 0,
-					argsResult: void 0,
-					result
-				}), signal, context, runtime, ctx.builder, caller, pipelineState);
-			};
-			return thenMaybe(routedOrPromise, continueAfterRoute);
-		};
-		return thenMaybe(parsedOrPromise, continueAfterParse);
-	};
-	return wrapWithLifecycle(rootInterceptors, rootCommand, resolvedInput, runPipeline, (result) => withDrain({
-		command: rootCommand,
-		args: void 0,
-		argsResult: void 0,
-		result
-	}), inertSignal, initialContext, runtime, ctx.builder, caller, pipelineState);
-}
-//#endregion
-//#region src/feature/repl-loop.ts
-/**
-* Creates a REPL async iterable for running commands interactively.
-*/
-function createReplIterator(deps, options) {
-	const { existingCommand, evalCommand, replActiveRef } = deps;
-	if (replActiveRef.value) {
-		getCommandRuntime(existingCommand).error("REPL is already running. Nested REPL sessions are not supported.");
-		return (async function* () {})();
-	}
-	const runtime = getCommandRuntime(existingCommand);
-	const programName = existingCommand.name || "padrone";
-	const env = runtime.env();
-	const useAnsi = runtime.format === "ansi" || runtime.format === "auto" && !env.NO_COLOR && !env.CI && runtime.terminal?.isTTY === true;
-	const commandHistory = [];
-	const resolveScope = (scope) => {
-		const parts = scope.split(/\s+/);
-		const stack = [];
-		let current = existingCommand;
-		for (const part of parts) {
-			const found = findCommandByName(part, current.commands);
-			if (!found) break;
-			stack.push(found);
-			current = found;
-		}
-		return stack;
-	};
-	async function* replIterator() {
-		replActiveRef.value = true;
-		const showGreeting = options?.greeting !== false;
-		const showHint = options?.hint !== false;
-		if (showGreeting || showHint) runtime.output("");
-		if (showGreeting) if (options?.greeting) runtime.output(options.greeting);
-		else {
-			const displayName = existingCommand.title || programName;
-			const version = existingCommand.version ? await getVersion(existingCommand.version) : void 0;
-			const greeting = version ? `Welcome to ${displayName} v${version}` : `Welcome to ${displayName}`;
-			runtime.output(greeting);
-		}
-		if (showHint) {
-			const hintText = (typeof options?.hint === "string" ? options.hint : void 0) ?? "Type \".help\" for more information, \".exit\" to quit.";
-			runtime.output(useAnsi ? `\x1b[2m${hintText}\x1b[0m` : hintText);
-		}
-		if (showGreeting || showHint) runtime.output("");
-		const scopeStack = options?.scope ? resolveScope(options.scope) : [];
-		const getScopeCommand = () => scopeStack.length ? scopeStack[scopeStack.length - 1] : existingCommand;
-		const getScopePath = () => scopeStack.map((c) => c.name).join(" ");
-		const buildPrompt = () => {
-			if (options?.prompt) return typeof options.prompt === "function" ? options.prompt() : options.prompt;
-			const scopePath = getScopePath();
-			const label = scopePath ? `${programName}/${scopePath.replace(/ /g, "/")}` : programName;
-			return useAnsi ? `\x1b[1m${label}\x1b[0m ❯ ` : `${label} ❯ `;
-		};
-		const buildScopedCompleter = () => {
-			return buildReplCompleter(getScopeCommand(), { inScope: scopeStack.length > 0 });
-		};
-		const sessionConfig = { history: options?.history };
-		if (options?.completion !== false) sessionConfig.completer = buildScopedCompleter();
-		const session = runtime.readLine ? void 0 : createTerminalReplSession(sessionConfig);
-		const questionFn = session ? (prompt) => session.question(prompt) : runtime.readLine;
-		const updateCompleter = () => {
-			if (options?.completion === false) return;
-			const completer = buildScopedCompleter();
-			if (session) session.completer = completer;
-			sessionConfig.completer = completer;
-		};
-		let lastSigintTime = 0;
-		try {
-			while (true) {
-				const input = await questionFn(buildPrompt());
-				if (input === null) break;
-				if (input === REPL_SIGINT) {
-					const now = Date.now();
-					if (now - lastSigintTime < 2e3) break;
-					lastSigintTime = now;
-					runtime.output("(press Ctrl+C again to exit, or Ctrl+D)");
-					continue;
-				}
-				const trimmed = input.trim();
-				if (!trimmed) continue;
-				lastSigintTime = 0;
-				commandHistory.push(trimmed);
-				if (trimmed === ".exit" || trimmed === ".quit") break;
-				if (trimmed === ".clear") {
-					runtime.output("\x1B[2J\x1B[H");
-					continue;
-				}
-				if (trimmed === ".help") {
-					const lines = [
-						"REPL Commands:",
-						"  .                 Execute the current scoped command",
-						"  .help             Print this help message",
-						"  .exit             Exit the REPL",
-						"  .clear            Clear the screen",
-						"  .history          Show command history",
-						"  .scope <cmd>      Scope into a subcommand",
-						"  .scope ..         Go up one scope level"
-					];
-					lines.push("", "Keybindings:", "  Ctrl+C       Cancel current line (press twice to exit)", "  Ctrl+D       Exit the REPL", "  Up/Down      Navigate history", "  Tab          Auto-complete", "", "Type \"help\" to see available commands.");
-					runtime.output(lines.join("\n"));
-					continue;
-				}
-				if (trimmed === ".history") {
-					const entries = commandHistory.slice(0, -1);
-					if (entries.length === 0) runtime.output("No history.");
-					else runtime.output(entries.map((entry, i) => `${i + 1}  ${entry}`).join("\n"));
-					continue;
-				}
-				if (trimmed.startsWith(".scope ") || trimmed === ".scope") {
-					const target = trimmed.slice(6).trim();
-					if (target === ".." || target === "") {
-						if (scopeStack.length > 0) {
-							scopeStack.pop();
-							updateCompleter();
-						}
-					} else {
-						const found = findCommandByName(target, getScopeCommand().commands);
-						if (found) if (found.commands?.length) {
-							scopeStack.push(found);
-							updateCompleter();
-						} else runtime.error(`"${target}" has no subcommands to scope into.`);
-						else runtime.error(`Unknown command: ${target}`);
-					}
-					continue;
-				}
-				if (trimmed === "..") {
-					if (scopeStack.length > 0) {
-						scopeStack.pop();
-						updateCompleter();
-					}
-					continue;
-				}
-				let evalInput = trimmed;
-				if (trimmed === ".") evalInput = "";
-				const prefix = options?.outputPrefix;
-				const prefixLines = prefix ? (text) => text.split("\n").map((l) => prefix + l).join("\n") : void 0;
-				const savedRuntimes = [];
-				if (prefixLines) {
-					const prefixedRuntime = {
-						...existingCommand.runtime,
-						output: (...args) => {
-							const first = args[0];
-							runtime.output(typeof first === "string" ? prefixLines(first) : first, ...args.slice(1));
-						},
-						error: (text) => runtime.error(prefixLines(text))
-					};
-					const patchAll = (cmd) => {
-						savedRuntimes.push({
-							cmd,
-							runtime: cmd.runtime
-						});
-						cmd.runtime = prefixedRuntime;
-						cmd.commands?.forEach(patchAll);
-					};
-					patchAll(existingCommand);
-				}
-				const sp = options?.spacing;
-				const isSpacingObject = typeof sp === "object" && sp !== null && !Array.isArray(sp);
-				const spacingBefore = isSpacingObject ? sp.before : sp;
-				const spacingAfter = isSpacingObject ? sp.after : sp;
-				const emitSpacingLine = (value) => {
-					if (typeof value === "string") {
-						const sep = value.length === 1 ? value.repeat(runtime.terminal?.columns ?? 80) : value;
-						runtime.output(sep);
-					} else if (value) runtime.output("");
-				};
-				const emitSpacing = (value) => {
-					if (!value) return;
-					if (Array.isArray(value)) for (const line of value) emitSpacingLine(line);
-					else emitSpacingLine(value);
-				};
-				emitSpacing(spacingBefore);
-				const scopePath = getScopePath();
-				const scopedInput = scopePath ? evalInput ? `${scopePath} ${evalInput}` : scopePath : evalInput;
-				try {
-					const result = await evalCommand(scopedInput, { caller: "repl" });
-					if (result.error) {
-						const msg = result.error instanceof Error ? result.error.message : String(result.error);
-						runtime.error(prefixLines ? prefixLines(msg) : msg);
-					} else if (result.argsResult?.issues) {
-						const msg = `Validation error:\n${result.argsResult.issues.map((i) => `  - ${i.path?.join(".") || "root"}: ${i.message}`).join("\n")}`;
-						runtime.error(prefixLines ? prefixLines(msg) : msg);
-					}
-					yield result;
-				} catch (err) {
-					const msg = err instanceof Error ? err.message : String(err);
-					runtime.error(prefixLines ? prefixLines(msg) : msg);
-				} finally {
-					for (const { cmd, runtime: saved } of savedRuntimes) cmd.runtime = saved;
-					emitSpacing(spacingAfter);
-				}
-			}
-		} finally {
-			replActiveRef.value = false;
-			session?.close();
-		}
-	}
-	const iterable = replIterator();
-	iterable.drain = async () => {
-		try {
-			const results = [];
-			for await (const result of iterable) results.push(result);
-			return { value: results };
-		} catch (err) {
-			return { error: err };
-		}
-	};
-	return iterable;
-}
-//#endregion
-//#region src/core/program-methods.ts
-function createProgramMethods(ctx, evalCommand) {
-	const { rootCommand } = ctx;
-	const inertSignal = new AbortController().signal;
-	const stringify = (command = "", args) => {
-		const commandObj = typeof command === "string" ? findCommandByName(command, rootCommand.commands) : command;
-		if (!commandObj) throw new RoutingError(`Command "${command ?? ""}" not found`);
-		const parts = [];
-		if (commandObj.path) parts.push(commandObj.path);
-		const positionalConfig = commandObj.meta?.positional ? parsePositionalConfig(commandObj.meta.positional) : [];
-		const positionalNames = new Set(positionalConfig.map((p) => p.name));
-		const negativeKeyword = {};
-		if (commandObj.argsSchema) {
-			const { negatives } = extractSchemaMetadata(commandObj.argsSchema, commandObj.meta?.fields, commandObj.meta?.autoAlias);
-			for (const [keyword, argName] of Object.entries(negatives)) if (!(argName in negativeKeyword)) negativeKeyword[argName] = keyword;
-		}
-		if (args && typeof args === "object") {
-			for (const { name, variadic } of positionalConfig) {
-				const value = args[name];
-				if (value === void 0) continue;
-				if (variadic && Array.isArray(value)) for (const v of value) {
-					const vStr = String(v);
-					if (vStr.includes(" ")) parts.push(`"${vStr}"`);
-					else parts.push(vStr);
-				}
-				else {
-					const argStr = String(value);
-					if (argStr.includes(" ")) parts.push(`"${argStr}"`);
-					else parts.push(argStr);
-				}
-			}
-			const stringifyValue = (key, value) => {
-				if (value === void 0) return;
-				if (typeof value === "boolean") if (value) parts.push(`--${key}`);
-				else if (negativeKeyword[key]) parts.push(`--${negativeKeyword[key]}`);
-				else parts.push(`--no-${key}`);
-				else if (Array.isArray(value)) for (const v of value) {
-					const vStr = String(v);
-					if (vStr.includes(" ")) parts.push(`--${key}="${vStr}"`);
-					else parts.push(`--${key}=${vStr}`);
-				}
-				else if (typeof value === "object" && value !== null) for (const [nestedKey, nestedValue] of Object.entries(value)) stringifyValue(`${key}.${nestedKey}`, nestedValue);
-				else if (typeof value === "string") if (value.includes(" ")) parts.push(`--${key}="${value}"`);
-				else parts.push(`--${key}=${value}`);
-				else parts.push(`--${key}=${value}`);
-			};
-			for (const [key, value] of Object.entries(args)) {
-				if (value === void 0 || positionalNames.has(key)) continue;
-				stringifyValue(key, value);
-			}
-		}
-		return parts.join(" ");
-	};
-	const resolveContext = (command, initialContext) => {
-		const chain = [];
-		let current = command;
-		while (current) {
-			chain.unshift(current);
-			current = current.parent;
-		}
-		let resolved = initialContext;
-		for (const cmd of chain) if (cmd.contextTransform) resolved = cmd.contextTransform(resolved);
-		return resolved;
-	};
-	const run = (command, args, prefs) => {
-		try {
-			const commandObj = typeof command === "string" ? findCommandByName(command, rootCommand.commands) : command;
-			if (!commandObj) throw new RoutingError(`Command "${command ?? ""}" not found`);
-			if (!commandObj.action) throw new RoutingError(`Command "${commandObj.path}" has no action`, { command: commandObj.path });
-			const executeCtx = {
-				command: commandObj,
-				input: void 0,
-				rawArgs: {},
-				positionalArgs: [],
-				args,
-				signal: inertSignal,
-				context: resolveContext(commandObj, prefs?.context),
-				runtime: getCommandRuntime(commandObj),
-				program: ctx.builder,
-				caller: "run"
-			};
-			const coreExecute = (executeCtx) => {
-				const actionCtx = {
-					runtime: executeCtx.runtime,
-					command: executeCtx.command,
-					program: ctx.builder,
-					signal: inertSignal,
-					context: executeCtx.context,
-					caller: "run"
-				};
-				return { result: commandObj.action(executeCtx.args, actionCtx) };
-			};
-			const executedOrPromise = runInterceptorChain("execute", resolveRegisteredInterceptors(collectInterceptors(commandObj, rootCommand), /* @__PURE__ */ new Map()), executeCtx, coreExecute);
-			const toResult = (e) => withDrain({
-				command: commandObj,
-				args,
-				result: e.result
-			});
-			if (executedOrPromise instanceof Promise) return executedOrPromise.then(toResult).catch((err) => errorResult(err, {
-				command: commandObj,
-				args
-			}));
-			return toResult(executedOrPromise);
-		} catch (err) {
-			return errorResult(err);
-		}
-	};
-	const tool = () => {
-		resolveAllCommands(rootCommand);
-		const description = `Run a command. Pass the full command string including arguments. Use "help <command>" for detailed usage.\n\n${generateHelp(rootCommand, void 0, { format: "text" })}`;
-		return {
-			type: "function",
-			name: rootCommand.name,
-			strict: true,
-			title: rootCommand.description,
-			description,
-			inputExamples: [{ input: { command: "<command> [positionals...] [arguments...]" } }],
-			inputSchema: {
-				[Symbol.for("vercel.ai.schema")]: true,
-				jsonSchema: {
-					type: "object",
-					properties: { command: { type: "string" } },
-					additionalProperties: false
-				},
-				_type: void 0,
-				validate: (value) => {
-					const command = value?.command;
-					if (typeof command === "string") return {
-						success: true,
-						value: { command }
-					};
-					return {
-						success: false,
-						error: /* @__PURE__ */ new Error("Expected an object with command property as string.")
-					};
-				}
-			},
-			needsApproval: async (input) => {
-				const parsed = await parse(input.command);
-				if (typeof parsed.command.needsApproval === "function") return parsed.command.needsApproval(parsed.args);
-				if (parsed.command.needsApproval != null) return !!parsed.command.needsApproval;
-				return !!parsed.command.mutation;
-			},
-			execute: async (input) => {
-				const output = [];
-				const errors = [];
-				return {
-					result: (await evalCommand(input.command, {
-						caller: "tool",
-						runtime: {
-							output: (...args) => output.push(args.map(String).join(" ")),
-							error: (text) => errors.push(text),
-							interactive: "unsupported",
-							format: "text"
-						}
-					})).result,
-					logs: output.join("\n"),
-					error: errors.join("\n")
-				};
-			}
-		};
-	};
-	const replActiveRef = { value: false };
-	const replFn = (options) => createReplIterator({
-		existingCommand: rootCommand,
-		evalCommand,
-		replActiveRef
-	}, options);
-	const cli = (cliOptions) => {
-		try {
-			const result = execCommand(getCommandRuntime(rootCommand).argv().join(" ") || void 0, ctx, cliOptions, "hard", "cli");
-			if (result instanceof Promise) return withPromiseDrain(result.catch((err) => errorResultWithSignal(err)));
-			return makeThenable(result);
-		} catch (err) {
-			return makeThenable(errorResultWithSignal(err));
-		}
-	};
-	const find = (command) => {
-		if (typeof command !== "string") return findCommandByName(command.path, rootCommand.commands);
-		return findCommandByName(command, rootCommand.commands);
-	};
-	const parse = (input) => {
-		const { command, rawArgs, args } = ctx.parseCommandFn(input);
-		return makeThenable(warnIfUnexpectedAsync(thenMaybe(coreValidateForParse(command, rawArgs, args), (v) => ({
-			command,
-			args: v.args,
-			argsResult: v.argsResult
-		})), command));
-	};
-	const help = (command, prefs) => {
-		resolveAllCommands(rootCommand);
-		const commandObj = !command ? rootCommand : typeof command === "string" ? findCommandByName(command, rootCommand.commands) : command;
-		if (!commandObj) throw new RoutingError(`Command "${command ?? ""}" not found`);
-		const runtime = getCommandRuntime(rootCommand);
-		return generateHelp(rootCommand, commandObj, {
-			...prefs,
-			format: prefs?.format ?? runtime.format,
-			theme: prefs?.theme ?? runtime.theme,
-			terminal: prefs?.terminal ?? runtime.terminal,
-			env: prefs?.env ?? runtime.env()
-		});
-	};
-	const api = () => {
-		resolveAllCommands(rootCommand);
-		function buildApi(command) {
-			const runCommand = ((args) => run(command, args).result);
-			if (!command.commands) return runCommand;
-			for (const cmd of command.commands) runCommand[cmd.name] = buildApi(cmd);
-			return runCommand;
-		}
-		return buildApi(rootCommand);
-	};
-	const completion = async (shell) => {
-		resolveAllCommands(rootCommand);
-		const { generateCompletionOutput } = await import("./completion-D8qkAinX.mjs");
-		return generateCompletionOutput(rootCommand, shell);
-	};
-	const mcp = async (prefs) => {
-		resolveAllCommands(rootCommand);
-		const { startMcpServer } = await import("./mcp-wCoVFTXz.mjs");
-		return startMcpServer(ctx.builder, rootCommand, evalCommand, prefs);
-	};
-	const serve = async (prefs) => {
-		resolveAllCommands(rootCommand);
-		const { startServeServer } = await import("./serve-ICZFl3xr.mjs");
-		return startServeServer(ctx.builder, rootCommand, evalCommand, prefs);
-	};
-	return {
-		find,
-		parse,
-		stringify,
-		run,
-		eval: evalCommand,
-		cli,
-		tool,
-		repl: replFn,
-		api,
-		help,
-		completion,
-		mcp,
-		serve
-	};
-}
-//#endregion
-//#region src/core/create.ts
-function createPadrone(name, options) {
-	let builder = createPadroneBuilder({
-		name,
-		path: "",
-		commands: []
-	});
-	const b = options?.builtins;
-	if (b?.help !== false) builder = builder.extend(padroneHelp());
-	if (b?.version !== false) builder = builder.extend(padroneVersion());
-	if (b?.repl !== false) builder = builder.extend(padroneRepl());
-	if (b?.color !== false) builder = builder.extend(padroneColor());
-	if (b?.suggestions !== false) builder = builder.extend(padroneSuggestions());
-	if (b?.signal !== false) builder = builder.extend(padroneSignalHandling());
-	if (b?.autoOutput !== false) builder = builder.extend(padroneAutoOutput());
-	if (b?.stdin !== false) builder = builder.extend(padroneStdin());
-	if (b?.interactive !== false) builder = builder.extend(padroneInteractive());
-	return builder;
-}
-function createPadroneBuilder(inputCommand) {
-	const existingCommand = inputCommand.commands?.length && inputCommand.commands.some((c) => c.parent && c.parent !== inputCommand) ? {
-		...inputCommand,
-		commands: inputCommand.commands.map((c) => c.parent && c.parent !== inputCommand ? {
-			...c,
-			parent: inputCommand
-		} : c)
-	} : inputCommand;
-	const parseCommandFn = (input) => parseCommand(input, existingCommand, findCommandByName);
-	const collectInterceptorsFn = (cmd) => collectInterceptors(cmd, existingCommand);
-	const execCtx = {
-		rootCommand: existingCommand,
-		builder: void 0,
-		parseCommandFn,
-		collectInterceptorsFn
-	};
-	const evalCommand = (input, evalOptions) => {
-		try {
-			const result = execCommand(input, execCtx, evalOptions, "soft", evalOptions?.caller ?? "eval");
-			if (result instanceof Promise) return withPromiseDrain(result.catch((err) => errorResultWithSignal(err)));
-			return makeThenable(result);
-		} catch (err) {
-			return makeThenable(errorResultWithSignal(err));
-		}
-	};
-	const builder = {
-		extend(extension) {
-			return extension(builder);
-		},
-		configure(config) {
-			return createPadroneBuilder({
-				...existingCommand,
-				...config
-			});
-		},
-		runtime(runtimeConfig) {
-			return createPadroneBuilder({
-				...existingCommand,
-				runtime: {
-					...existingCommand.runtime,
-					...runtimeConfig
-				}
-			});
-		},
-		async() {
-			return createPadroneBuilder({
-				...existingCommand,
-				isAsync: true
-			});
-		},
-		context(transform) {
-			if (!transform) return createPadroneBuilder({ ...existingCommand });
-			const existing = existingCommand.contextTransform;
-			const composed = existing ? (ctx) => transform(existing(ctx)) : transform;
-			return createPadroneBuilder({
-				...existingCommand,
-				contextTransform: composed
-			});
-		},
-		arguments(schema, meta) {
-			const resolvedArgs = typeof schema === "function" ? schema(existingCommand.argsSchema) : schema;
-			const isAsync = existingCommand.isAsync || isAsyncBranded(resolvedArgs) || hasInteractiveConfig(meta);
-			return createPadroneBuilder({
-				...existingCommand,
-				argsSchema: resolvedArgs,
-				meta,
-				isAsync
-			});
-		},
-		action(handler = noop) {
-			const baseHandler = existingCommand.action ?? noop;
-			return createPadroneBuilder({
-				...existingCommand,
-				action: (args, ctx) => handler(args, ctx, baseHandler)
-			});
-		},
-		wrap(config) {
-			const handler = createWrapHandler(config, existingCommand.argsSchema, existingCommand.meta?.positional);
-			return createPadroneBuilder({
-				...existingCommand,
-				action: handler
-			});
-		},
-		command(nameOrNames, builderFn) {
-			const name = Array.isArray(nameOrNames) ? nameOrNames[0] : nameOrNames;
-			const aliases = Array.isArray(nameOrNames) && nameOrNames.length > 1 ? nameOrNames.slice(1) : void 0;
-			const existingSubcommand = existingCommand.commands?.find((c) => c.name === name);
-			if (existingSubcommand) resolveCommand(existingSubcommand);
-			const initialCommand = existingSubcommand ? {
-				...existingSubcommand,
-				aliases: aliases ?? existingSubcommand.aliases,
-				parent: existingCommand
-			} : {
-				name,
-				path: existingCommand.path ? `${existingCommand.path} ${name}` : name,
-				aliases,
-				parent: existingCommand,
-				"~types": {}
-			};
-			if (builderFn) {
-				const lazyCmd = { ...initialCommand };
-				lazyCmd[lazyResolver] = (target) => {
-					const savedParent = target.parent;
-					const commandObj = builderFn(createPadroneBuilder(target))?.[commandSymbol] ?? target;
-					const mergedCommandObj = existingSubcommand ? mergeCommands(existingSubcommand, commandObj) : commandObj;
-					Object.assign(target, mergedCommandObj);
-					target.parent = savedParent;
-				};
-				const commands = existingCommand.commands || [];
-				const existingIndex = commands.findIndex((c) => c.name === name);
-				const updatedCommands = existingIndex >= 0 ? [
-					...commands.slice(0, existingIndex),
-					lazyCmd,
-					...commands.slice(existingIndex + 1)
-				] : [...commands, lazyCmd];
-				return createPadroneBuilder({
-					...existingCommand,
-					commands: updatedCommands
-				});
-			}
-			const commands = existingCommand.commands || [];
-			const existingIndex = commands.findIndex((c) => c.name === name);
-			const updatedCommands = existingIndex >= 0 ? [
-				...commands.slice(0, existingIndex),
-				initialCommand,
-				...commands.slice(existingIndex + 1)
-			] : [...commands, initialCommand];
-			return createPadroneBuilder({
-				...existingCommand,
-				commands: updatedCommands
-			});
-		},
-		mount(nameOrNames, program, options) {
-			const name = Array.isArray(nameOrNames) ? nameOrNames[0] : nameOrNames;
-			const aliases = Array.isArray(nameOrNames) && nameOrNames.length > 1 ? nameOrNames.slice(1) : void 0;
-			const programCommand = program[commandSymbol];
-			if (!programCommand) throw new RoutingError("Cannot mount: not a valid Padrone program");
-			const remounted = repathCommandTree(programCommand, name, existingCommand.path || "", existingCommand);
-			remounted.aliases = aliases;
-			if (options?.context) {
-				const existing = remounted.contextTransform;
-				remounted.contextTransform = existing ? (ctx) => existing(options.context(ctx)) : options.context;
-			}
-			const existingSubcommand = existingCommand.commands?.find((c) => c.name === name);
-			const mergedCommandObj = existingSubcommand ? mergeCommands(existingSubcommand, remounted) : remounted;
-			const commands = existingCommand.commands || [];
-			const existingIndex = commands.findIndex((c) => c.name === name);
-			const updatedCommands = existingIndex >= 0 ? [
-				...commands.slice(0, existingIndex),
-				mergedCommandObj,
-				...commands.slice(existingIndex + 1)
-			] : [...commands, mergedCommandObj];
-			return createPadroneBuilder({
-				...existingCommand,
-				commands: updatedCommands
-			});
-		},
-		intercept(metaOrFn, factory) {
-			const registered = toRegisteredInterceptor(metaOrFn, factory);
-			return createPadroneBuilder({
-				...existingCommand,
-				interceptors: [...existingCommand.interceptors ?? [], registered]
-			});
-		},
-		...createProgramMethods(execCtx, evalCommand),
-		get info() {
-			return {
-				name: existingCommand.name,
-				title: existingCommand.title,
-				description: existingCommand.description,
-				version: existingCommand.version,
-				examples: existingCommand.examples,
-				deprecated: existingCommand.deprecated,
-				commands: (existingCommand.commands ?? []).map((c) => c.name)
-			};
-		},
-		"~types": {},
-		[commandSymbol]: existingCommand
-	};
-	execCtx.builder = builder;
-	return builder;
-}
-function defineCommand(fn) {
-	if (fn) return fn;
-	const builder = {
-		requires: () => builder,
-		define: (f) => f
-	};
-	return builder;
-}
-//#endregion
-//#region src/extension/completion.ts
-/**
-* Extension that adds the `completion` command for shell completion script generation.
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli').extend(padroneCompletion())
-* ```
-*/
-function padroneCompletion() {
-	return ((builder) => builder.command("completion", (c) => c.configure({
-		description: "Generate shell completion scripts",
-		hidden: true
-	}).arguments(passthroughSchema({
-		shell: "string",
-		setup: "boolean"
-	}), { positional: ["shell"] }).async().action(async (args, ctx) => {
-		const rootCommand = getRootCommand(ctx.command);
-		resolveAllCommands(rootCommand);
-		const { detectShell, generateCompletionOutput, setupCompletions } = await import("./completion-D8qkAinX.mjs");
-		const shell = args.shell;
-		if (args.setup) {
-			const resolvedShell = shell ?? await detectShell();
-			if (!resolvedShell) throw new Error("Could not detect shell. Specify one: completion bash --setup");
-			const setupResult = await setupCompletions(rootCommand.name, resolvedShell);
-			return `${setupResult.updated ? "Updated" : "Added"} ${rootCommand.name} completions in ${setupResult.file}`;
-		}
-		return generateCompletionOutput(rootCommand, shell);
-	})));
-}
-//#endregion
-//#region src/extension/config.ts
-let _fs$1;
-let _path$1;
-async function initNodeModules$1() {
-	if (_fs$1 && _path$1) return;
-	_fs$1 = await import("node:fs");
-	_path$1 = await import("node:path");
-}
-try {
-	if (typeof process !== "undefined") initNodeModules$1();
-} catch {}
-function getUserConfigDir(path, appName) {
-	const platform = process.platform;
-	const xdgHome = process.env.XDG_CONFIG_HOME;
-	if (xdgHome) return path.join(xdgHome, appName);
-	const home = process.env.HOME || process.env.USERPROFILE;
-	if (!home) return void 0;
-	if (platform === "win32") {
-		const appData = process.env.APPDATA;
-		return appData ? path.join(appData, appName) : path.join(home, "AppData", "Roaming", appName);
-	}
-	if (platform === "darwin") return path.join(home, "Library", "Application Support", appName);
-	return path.join(home, ".config", appName);
-}
-function resolveConfigPath(fs, path, cwd, files, xdgAppName) {
-	if (typeof files === "string") {
-		const abs = path.isAbsolute(files) ? files : path.resolve(cwd, files);
-		if (!fs.existsSync(abs)) {
-			console.error(`Config file not found: ${abs}`);
-			return;
-		}
-		return abs;
-	}
-	for (const candidate of files) {
-		const abs = path.isAbsolute(candidate) ? candidate : path.resolve(cwd, candidate);
-		if (fs.existsSync(abs)) return abs;
-	}
-	if (xdgAppName) {
-		const configDir = getUserConfigDir(path, xdgAppName);
-		if (configDir) for (const candidate of files) {
-			const abs = path.join(configDir, candidate);
-			if (fs.existsSync(abs)) return abs;
-		}
-	}
-}
-function loadConfigSync(fs, path, files, xdgAppName) {
-	const absolutePath = resolveConfigPath(fs, path, process.cwd(), files, xdgAppName);
-	if (!absolutePath) return void 0;
-	const getContent = () => fs.readFileSync(absolutePath, "utf-8");
-	const ext = path.extname(absolutePath).toLowerCase();
-	if (ext === ".yaml" || ext === ".yml") return Bun.YAML.parse(getContent());
-	if (ext === ".toml") return Bun.TOML.parse(getContent());
-	if (ext === ".jsonc") return Bun.JSONC.parse(getContent());
-	if (ext === ".json") {
-		if (Bun.JSONC) return Bun.JSONC.parse(getContent());
-		try {
-			return JSON.parse(getContent());
-		} catch {
-			return Bun.JSONC.parse(getContent());
-		}
-	}
-	if (ext === ".js" || ext === ".cjs" || ext === ".mjs" || ext === ".ts" || ext === ".cts" || ext === ".mts") return import(
-		/* @vite-ignore */
-		absolutePath
-).then((mod) => mod.default ?? mod);
-	try {
-		return JSON.parse(getContent());
-	} catch {
-		console.error(`Unable to parse config file: ${absolutePath}`);
-		return;
-	}
-}
-/**
-* Built-in config file loader. Directly accesses the file system.
-* Returns `undefined` in non-CLI environments where `node:fs` is unavailable.
-*/
-function loadConfig(files, xdgAppName) {
-	if (typeof process === "undefined") return void 0;
-	try {
-		if (_fs$1 && _path$1) return loadConfigSync(_fs$1, _path$1, files, xdgAppName);
-		return initNodeModules$1().then(() => loadConfigSync(_fs$1, _path$1, files, xdgAppName));
-	} catch {
-		return;
-	}
-}
-/**
-* Extension that handles config file loading, validation, and merging into command arguments.
-*
-* Features:
-* - `--config` / `-c` flag for explicit config file path (can be disabled via `flag: false`)
-* - Auto-detection of config files from a list of candidate names
-* - Optional schema validation and transformation of config data
-* - Directly accesses the file system (gracefully no-ops in non-CLI environments)
-*
-* Config values have the lowest precedence (CLI > stdin > env > config).
-*
-* Not included in the default built-in extensions — must be explicitly added:
-* ```ts
-* createPadrone('my-cli')
-*   .extend(padroneConfig({
-*     files: ['config.json', '.myapprc'],
-*     schema: z.object({ port: z.number(), host: z.string() }),
-*   }))
-* ```
-*/
-function padroneConfig(options) {
-	if (options?.disabled) {
-		const disabled = defineInterceptor({
-			id: "padrone:config",
-			name: "padrone:config",
-			order: -999,
-			disabled: true
-		}, () => ({}));
-		return ((builder) => builder.intercept(disabled));
-	}
-	const configFiles = options?.files ? Array.isArray(options.files) ? options.files : [options.files] : void 0;
-	const configSchema = options?.schema;
-	const flagEnabled = options?.flag !== false;
-	const inherit = options?.inherit;
-	const xdgOption = options?.xdg;
-	const configLoader = options?.loadConfig ?? loadConfig;
-	const interceptor = defineInterceptor({
-		id: "padrone:config",
-		name: "padrone:config",
-		order: -999,
-		...inherit === false && { inherit: false }
-	}, () => ({ validate(ctx, next) {
-		let explicitConfigPath;
-		if (flagEnabled) {
-			explicitConfigPath = ctx.rawArgs.config ?? ctx.rawArgs.c;
-			if (typeof explicitConfigPath === "string") {
-				delete ctx.rawArgs.config;
-				delete ctx.rawArgs.c;
-			}
-		}
-		if (!explicitConfigPath && !configFiles) return next();
-		let xdgAppName;
-		if (typeof xdgOption === "string") xdgAppName = xdgOption;
-		else if (xdgOption === true) xdgAppName = getRootCommand(ctx.command).name;
-		const configDataOrPromise = configLoader(explicitConfigPath ?? configFiles ?? [], xdgAppName);
-		const applyConfig = (configData) => {
-			if (!configData) return next();
-			if (configSchema) return thenMaybe(configSchema["~standard"].validate(configData), (result) => {
-				if (result.issues) throw new ConfigError(`Invalid config file:\n${result.issues.map((i) => `  - ${i.path?.join(".") || "root"}: ${i.message}`).join("\n")}`, { command: ctx.command.path || ctx.command.name });
-				const validatedData = result.value;
-				return next({ rawArgs: applyValues(ctx.rawArgs, validatedData) });
-			});
-			return next({ rawArgs: applyValues(ctx.rawArgs, configData) });
-		};
-		return thenMaybe(configDataOrPromise, applyConfig);
-	} }));
-	return ((builder) => builder.intercept(interceptor));
-}
-//#endregion
-//#region src/util/dotenv.ts
-/** Returns ordered list of `.env` file names to load (no fs access). */
-function resolveEnvFiles(modes = [], local = true, base = true) {
-	const files = [];
-	if (base) {
-		files.push(".env");
-		if (local) files.push(".env.local");
-	}
-	for (const mode of modes) {
-		files.push(`.env.${mode}`);
-		if (local) files.push(`.env.${mode}.local`);
-	}
-	return files;
-}
-/** Parse a `.env` file string into key-value pairs. */
-function parseEnvFile(content) {
-	const result = {};
-	const lines = content.split("\n");
-	let i = 0;
-	while (i < lines.length) {
-		const line = lines[i].trim();
-		i++;
-		if (!line || line.startsWith("#")) continue;
-		const stripped = line.startsWith("export ") ? line.slice(7) : line;
-		const eqIndex = stripped.indexOf("=");
-		if (eqIndex === -1) continue;
-		const key = stripped.slice(0, eqIndex).trim();
-		let raw = stripped.slice(eqIndex + 1);
-		const trimmedRaw = raw.trimStart();
-		const quote = trimmedRaw[0];
-		if (quote === "\"" || quote === "'" || quote === "`") {
-			let value = trimmedRaw.slice(1);
-			const closeIndex = findClosingQuote(value, quote);
-			if (closeIndex !== -1) value = value.slice(0, closeIndex);
-			else while (i < lines.length) {
-				const nextLine = lines[i];
-				i++;
-				const ci = findClosingQuote(nextLine, quote);
-				if (ci !== -1) {
-					value += `\n${nextLine.slice(0, ci)}`;
-					break;
-				}
-				value += `\n${nextLine}`;
-			}
-			if (quote === "\"") value = unescapeDoubleQuoted(value);
-			result[key] = value;
-		} else {
-			const commentIndex = raw.indexOf(" #");
-			if (commentIndex !== -1) raw = raw.slice(0, commentIndex);
-			result[key] = raw.trim();
-		}
-	}
-	return result;
-}
-function findClosingQuote(s, quote) {
-	let i = 0;
-	while (i < s.length) {
-		if (s[i] === "\\" && quote === "\"") {
-			i += 2;
-			continue;
-		}
-		if (s[i] === quote) return i;
-		i++;
-	}
-	return -1;
-}
-function unescapeDoubleQuoted(s) {
-	return s.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
-}
-/**
-* Expand `$VAR`, `${VAR}`, `${VAR:-default}`, `${VAR-default}` in a string.
-* Escaped `\$` produces a literal `$`. Undefined variables resolve to `""`.
-*/
-function expandVariables(value, env) {
-	let result = "";
-	let i = 0;
-	while (i < value.length) {
-		if (value[i] === "\\" && value[i + 1] === "$") {
-			result += "$";
-			i += 2;
-			continue;
-		}
-		if (value[i] === "$") {
-			i++;
-			if (i >= value.length) {
-				result += "$";
-				break;
-			}
-			if (value[i] === "{") {
-				i++;
-				const closeIdx = value.indexOf("}", i);
-				if (closeIdx === -1) {
-					result += `\${${value.slice(i)}`;
-					break;
-				}
-				const expr = value.slice(i, closeIdx);
-				i = closeIdx + 1;
-				const colonDashIdx = expr.indexOf(":-");
-				const dashIdx = colonDashIdx === -1 ? expr.indexOf("-") : -1;
-				if (colonDashIdx !== -1) {
-					const varName = expr.slice(0, colonDashIdx);
-					const fallback = expr.slice(colonDashIdx + 2);
-					const val = env[varName];
-					result += val ? val : expandVariables(fallback, env);
-				} else if (dashIdx !== -1) {
-					const varName = expr.slice(0, dashIdx);
-					const fallback = expr.slice(dashIdx + 1);
-					const val = env[varName];
-					result += val !== void 0 ? val : expandVariables(fallback, env);
-				} else result += env[expr] ?? "";
-			} else {
-				let varName = "";
-				while (i < value.length && /[\w]/.test(value[i])) {
-					varName += value[i];
-					i++;
-				}
-				if (varName) result += env[varName] ?? "";
-				else result += "$";
-			}
-			continue;
-		}
-		result += value[i];
-		i++;
-	}
-	return result;
-}
-/**
-* Load and merge `.env` files, returning the combined key-value map.
-* Variable expansion uses the merged file values + process env as lookup.
-*
-* Returns synchronously when `node:fs`/`node:path` are already cached (typical),
-* or a Promise on the very first call.
-*/
-function loadEnvFiles(options, processEnv) {
-	if (typeof process === "undefined") return {};
-	try {
-		if (_fs && _path) return loadEnvFilesSync(_fs, _path, options, processEnv);
-		return initNodeModules().then(() => loadEnvFilesSync(_fs, _path, options, processEnv)).catch(() => ({}));
-	} catch {
-		return {};
-	}
-}
-let _fs;
-let _path;
-async function initNodeModules() {
-	if (_fs && _path) return;
-	_fs = await import("node:fs");
-	_path = await import("node:path");
-}
-if (typeof process !== "undefined") initNodeModules();
-function loadEnvFilesSync(fs, path, options, processEnv) {
-	const dir = options.dir ?? process.cwd();
-	const fileNames = resolveEnvFiles(options.modes, options.local ?? true, options.base ?? true);
-	const merged = {};
-	for (const name of fileNames) {
-		const filePath = path.resolve(dir, name);
-		if (!fs.existsSync(filePath)) continue;
-		const parsed = parseEnvFile(fs.readFileSync(filePath, "utf-8"));
-		Object.assign(merged, parsed);
-	}
-	const lookup = options.override ? {
-		...processEnv,
-		...merged
-	} : {
-		...merged,
-		...processEnv
-	};
-	for (const key of Object.keys(merged)) merged[key] = expandVariables(merged[key], lookup);
-	return merged;
-}
-//#endregion
-//#region src/extension/env.ts
-function isSchema(value) {
-	return value != null && typeof value === "object" && "~standard" in value;
-}
-function padroneEnv(schemaOrOptions, maybeOptions) {
-	const schema = isSchema(schemaOrOptions) ? schemaOrOptions : void 0;
-	const options = isSchema(schemaOrOptions) ? maybeOptions : schemaOrOptions;
-	const hasFiles = options?.modes !== void 0;
-	const fileOptions = hasFiles ? options : void 0;
-	const override = options?.override ?? false;
-	const interceptor = defineInterceptor({
-		id: "padrone:env",
-		name: "padrone:env",
-		order: -1e3
-	}, () => ({ validate(ctx, next) {
-		const processEnv = ctx.runtime.env();
-		const applyEnv = (envFromFiles) => {
-			const rawEnv = override ? {
-				...processEnv,
-				...envFromFiles
-			} : {
-				...envFromFiles,
-				...processEnv
-			};
-			if (schema) return thenMaybe(schema["~standard"].validate(rawEnv), (result) => {
-				if (result.issues || !result.value) return next();
-				return next({ rawArgs: applyValues(ctx.rawArgs, result.value) });
-			});
-			if (Object.keys(envFromFiles).length > 0) return next({ rawArgs: applyValues(ctx.rawArgs, envFromFiles) });
-			return next();
-		};
-		if (hasFiles) return thenMaybe(loadEnvFiles(fileOptions, processEnv), applyEnv);
-		return applyEnv({});
-	} }));
-	return ((builder) => builder.intercept(interceptor));
-}
-//#endregion
-//#region src/extension/ink.ts
-const reactElement = Symbol.for("react.element");
-const reactTransitional = Symbol.for("react.transitional.element");
-/** Checks whether a value is a React element (JSX) by inspecting its `$$typeof` symbol. */
-function isReactElement(value) {
-	if (value === null || typeof value !== "object") return false;
-	const tag = value.$$typeof;
-	return tag === reactElement || tag === reactTransitional;
-}
-const inkMeta = {
-	id: "padrone:ink",
-	name: "padrone:ink",
-	order: -1050
-};
-function createInkInterceptor(rawOptions) {
-	return defineInterceptor(inkMeta).requires().factory(() => ({ execute(ctx, next) {
-		const options = {
-			...ctx.context?.inkConfig,
-			...rawOptions
-		};
-		const { waitUntilExit = true } = options;
-		const handleResult = async (e) => {
-			let value = e.result;
-			if (value instanceof Promise) value = await value;
-			if (!isReactElement(value)) return e;
-			const { render } = await import("ink");
-			const instance = render(value, options.render);
-			const onAbort = () => instance.unmount();
-			ctx.signal.addEventListener("abort", onAbort, { once: true });
-			if (waitUntilExit) try {
-				await instance.waitUntilExit();
-			} finally {
-				ctx.signal.removeEventListener("abort", onAbort);
-			}
-			return { result: void 0 };
-		};
-		const executedOrPromise = next();
-		if (executedOrPromise instanceof Promise) return executedOrPromise.then(handleResult);
-		return handleResult(executedOrPromise);
-	} }));
-}
-/**
-* Extension that renders React (Ink) components returned from command actions.
-*
-* When a command's action returns a React element (JSX), this extension
-* renders it using Ink instead of passing it to the normal output path.
-*
-* Requires `ink` and `react` as peer dependencies.
-*
-* ```ts
-* import { createPadrone, padroneInk } from 'padrone';
-*
-* const program = createPadrone('my-tui')
-*   .extend(padroneInk())
-*   .command('dashboard', (c) =>
-*     c.action(() => <Dashboard />)
-*   );
-* ```
-*/
-function padroneInk(options) {
-	const interceptor = createInkInterceptor(options);
-	return ((builder) => builder.intercept(interceptor));
-}
-//#endregion
-//#region src/extension/logger.ts
-const LEVEL_ORDER = {
-	trace: 0,
-	debug: 1,
-	info: 2,
-	warn: 3,
-	error: 4,
-	silent: 5
-};
-const LEVEL_LABELS = {
-	trace: "TRACE",
-	debug: "DEBUG",
-	info: "INFO",
-	warn: "WARN",
-	error: "ERROR"
-};
-const VALID_LEVELS = new Set(Object.keys(LEVEL_ORDER));
-/** Format specifier pattern: matches %s, %d, %i, %f, %o, %O, %j, %% */
-const FORMAT_PATTERN = /%%|%[sdifjoO]/g;
-/**
-* Applies printf-style format specifiers to args, following the WHATWG Console Standard
-* and Node.js `util.format` conventions. Remaining args are appended space-separated.
-*/
-function formatArgs(args) {
-	if (args.length === 0) return "";
-	if (typeof args[0] !== "string" || !FORMAT_PATTERN.test(args[0])) return args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-	const template = args[0];
-	let argIndex = 1;
-	const result = template.replace(FORMAT_PATTERN, (token) => {
-		if (token === "%%") return "%";
-		if (argIndex >= args.length) return token;
-		const val = args[argIndex++];
-		switch (token) {
-			case "%s": return String(val);
-			case "%d":
-			case "%i": return String(Math.trunc(Number(val)));
-			case "%f": return String(Number(val));
-			case "%j": try {
-				return JSON.stringify(val);
-			} catch {
-				return "[Circular]";
-			}
-			case "%o":
-			case "%O": return typeof val === "string" ? val : JSON.stringify(val);
-			default: return token;
-		}
-	});
-	const remaining = args.slice(argIndex);
-	if (remaining.length === 0) return result;
-	return `${result} ${remaining.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}`;
-}
-function resolveCliLevel(rawArgs) {
-	if ("trace" in rawArgs) {
-		const t = rawArgs.trace;
-		delete rawArgs.trace;
-		if (t !== false) return "trace";
-	}
-	if ("verbose" in rawArgs) {
-		const v = rawArgs.verbose;
-		delete rawArgs.verbose;
-		if (v !== false) return "debug";
-	}
-	if ("debug" in rawArgs) {
-		const d = rawArgs.debug;
-		delete rawArgs.debug;
-		if (d !== false) return "debug";
-	}
-	if ("silent" in rawArgs) {
-		const s = rawArgs.silent;
-		delete rawArgs.silent;
-		if (s !== false) return "silent";
-	}
-	if ("quiet" in rawArgs) {
-		const q = rawArgs.quiet;
-		delete rawArgs.quiet;
-		if (q !== false) return "silent";
-	}
-	if ("log-level" in rawArgs) {
-		const val = rawArgs["log-level"];
-		delete rawArgs["log-level"];
-		if (typeof val === "string" && VALID_LEVELS.has(val)) return val;
-	}
-}
-function createLogger(runtime, level, config, tracing) {
-	const threshold = LEVEL_ORDER[level];
-	function format(lvl, prefix, args) {
-		const parts = [];
-		if (config.timestamps) parts.push((/* @__PURE__ */ new Date()).toISOString());
-		parts.push(`[${LEVEL_LABELS[lvl]}]`);
-		if (prefix) parts.push(prefix);
-		parts.push(formatArgs(args));
-		return parts.join(" ");
-	}
-	function makeLogger(prefix) {
-		const emit = (lvl, args) => {
-			if (LEVEL_ORDER[lvl] < threshold) return;
-			const message = format(lvl, prefix, args);
-			tracing?.rootSpan.addEvent("log", {
-				"log.level": lvl,
-				"log.message": args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")
-			});
-			if (lvl === "error" || lvl === "warn") runtime.error(message);
-			else runtime.output(message);
-		};
-		return {
-			trace: (...args) => emit("trace", args),
-			debug: (...args) => emit("debug", args),
-			info: (...args) => emit("info", args),
-			warn: (...args) => emit("warn", args),
-			error: (...args) => emit("error", args),
-			level,
-			child: (label) => makeLogger(prefix ? `${prefix} [${label}]` : `[${label}]`)
-		};
-	}
-	return makeLogger(config.prefix);
-}
-function loggerInterceptor(rawConfig) {
-	return defineInterceptor({
-		id: "padrone:logger",
-		name: "padrone:logger"
-	}).requires().factory(() => {
-		let cliLevel;
-		return {
-			parse(_ctx, next) {
-				return thenMaybe(next(), (res) => {
-					cliLevel = resolveCliLevel(res.rawArgs);
-					return res;
-				});
-			},
-			execute(ctx, next) {
-				const ctxCfg = ctx.context?.loggerConfig;
-				const resolved = {
-					level: cliLevel ?? rawConfig?.level ?? ctxCfg?.level ?? "info",
-					prefix: rawConfig?.prefix ?? "",
-					timestamps: rawConfig?.timestamps ?? ctxCfg?.timestamps ?? false
-				};
-				return next({ context: { logger: createLogger(ctx.runtime, resolved.level, resolved, ctx.context?.tracing) } });
-			}
-		};
-	});
-}
-/**
-* Extension that injects a structured logger into the command context.
-*
-* The logger respects a configurable log level threshold, supports prefixed
-* child loggers, and routes output through the runtime's `output`/`error`
-* functions so it works in any environment (terminal, test, web).
-*
-* Supports CLI flags for runtime level overrides:
-* - `--trace` → sets level to `trace`
-* - `--verbose` or `--debug` → sets level to `debug`
-* - `--silent` or `--quiet` → sets level to `silent`
-* - `--log-level=<level>` → sets an explicit level (`trace`, `debug`, `info`, `warn`, `error`, `silent`)
-*
-* CLI flags take precedence over the programmatic config.
-*
-* Provides `{ logger: PadroneLogger }` on the command context.
-* Access it in action handlers as `ctx.context.logger`.
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli')
-*   .extend(padroneLogger({ level: 'info' }))
-*   .command('sync', (c) =>
-*     c.action((_args, ctx) => {
-*       ctx.context.logger.info('starting sync');
-*       const db = ctx.context.logger.child('db');
-*       db.debug('connecting...');
-*     })
-*   )
-* ```
-*
-* Then run:
-* ```sh
-* my-cli sync --verbose      # debug level
-* my-cli sync --quiet        # silent
-* my-cli sync --log-level=warn
-* ```
-*/
-function padroneLogger(config) {
-	return ((builder) => builder.intercept(loggerInterceptor(config)));
-}
-//#endregion
-//#region src/extension/man.ts
-/**
-* Extension that adds the `man` command for man page generation.
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli').extend(padroneMan())
-* ```
-*/
-function padroneMan() {
-	return ((builder) => builder.command("man", (c) => c.configure({
-		description: "Generate man pages",
-		hidden: true
-	}).arguments(passthroughSchema({
-		setup: "boolean",
-		remove: "boolean"
-	})).async().action(async (args, ctx) => {
-		const rootCommand = getRootCommand(ctx.command);
-		resolveAllCommands(rootCommand);
-		const { setupManPages, removeManPages, generateDocs } = await import("./docs/index.mjs");
-		if (args.setup) {
-			const setupResult = await setupManPages(rootCommand);
-			return `${setupResult.updated ? "Updated" : "Installed"} ${setupResult.written.length} man page(s) in ${setupResult.dir}`;
-		}
-		if (args.remove) {
-			const removeResult = await removeManPages(rootCommand);
-			return removeResult.removed.length > 0 ? `Removed ${removeResult.removed.length} man page(s) from ${removeResult.dir}` : "No man pages found to remove.";
-		}
-		return generateDocs(rootCommand, { format: "man" }).pages[0]?.content ?? "";
-	})));
-}
-//#endregion
-//#region src/extension/mcp.ts
-/**
-* Extension that adds the `mcp` command for starting a Model Context Protocol server.
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli').extend(padroneMcp())
-* ```
-*/
-function padroneMcp(defaults) {
-	return ((builder) => builder.command("mcp", (c) => c.configure({
-		description: "Start a Model Context Protocol server",
-		hidden: true
-	}).arguments(passthroughSchema({
-		transport: "string",
-		port: "string",
-		host: "string",
-		"base-path": "string"
-	}), { positional: ["transport"] }).async().action(async (args, ctx) => {
-		const rootCommand = getRootCommand(ctx.command);
-		resolveAllCommands(rootCommand);
-		const { startMcpServer } = await import("./mcp-wCoVFTXz.mjs");
-		const transport = args.transport === "stdio" || args.transport === "http" ? args.transport : void 0;
-		const port = args.port ? parseInt(args.port, 10) : void 0;
-		const prefs = {
-			...defaults,
-			transport: transport ?? defaults?.transport,
-			port: port && !Number.isNaN(port) ? port : defaults?.port,
-			host: args.host ?? defaults?.host,
-			basePath: args["base-path"] ?? defaults?.basePath
-		};
-		await startMcpServer(ctx.program, rootCommand, ctx.program.eval, prefs);
-	})));
-}
-//#endregion
-//#region src/extension/progress-renderer.ts
-const spinnerPresets = {
-	dots: [
-		"⠋",
-		"⠙",
-		"⠹",
-		"⠸",
-		"⠼",
-		"⠴",
-		"⠦",
-		"⠧",
-		"⠇",
-		"⠏"
-	],
-	line: [
-		"-",
-		"\\",
-		"|",
-		"/"
-	],
-	arc: [
-		"◜",
-		"◠",
-		"◝",
-		"◞",
-		"◡",
-		"◟"
-	],
-	bounce: [
-		"⠁",
-		"⠂",
-		"⠄",
-		"⡀",
-		"⢀",
-		"⠠",
-		"⠐",
-		"⠈"
-	]
-};
-function resolveSpinnerConfig(config) {
-	if (config === false) return {
-		frames: [],
-		interval: 80,
-		show: "never"
-	};
-	if (config === true) return {
-		frames: spinnerPresets.dots,
-		interval: 80,
-		show: "always"
-	};
-	if (typeof config === "string") return {
-		frames: spinnerPresets[config],
-		interval: 80,
-		show: "auto"
-	};
-	if (typeof config === "object") return {
-		frames: config.frames ?? spinnerPresets.dots,
-		interval: config.interval ?? 80,
-		show: config.show ?? "auto"
-	};
-	return {
-		frames: spinnerPresets.dots,
-		interval: 80,
-		show: "auto"
-	};
-}
-const defaultBarConfig = {
-	width: 20,
-	filled: "█",
-	empty: "░",
-	animation: "bounce",
-	show: "auto"
-};
-function resolveBarConfig(bar) {
-	if (bar === false) return void 0;
-	if (!bar) return { ...defaultBarConfig };
-	if (bar === true) return {
-		...defaultBarConfig,
-		show: "always"
-	};
-	return {
-		width: bar.width ?? 20,
-		filled: bar.filled ?? "█",
-		empty: bar.empty ?? "░",
-		animation: bar.animation ?? "bounce",
-		show: bar.show ?? "always"
-	};
-}
-const SEGMENT_RATIO = .25;
-const pulseGradient = [
-	"░",
-	"▒",
-	"▓",
-	"█",
-	"▓",
-	"▒",
-	"░"
-];
-function formatIndeterminate(cfg, frame) {
-	const { width, filled, empty, animation } = cfg;
-	const pad = "".padStart(4);
-	if (animation === "pulse") return `${pad} ${pulseGradient[frame % pulseGradient.length].repeat(width)}`;
-	const seg = Math.max(2, Math.round(width * SEGMENT_RATIO));
-	const travel = width - seg;
-	if (animation === "slide") {
-		const offset = frame % (travel + 1);
-		return `${pad} ${empty.repeat(offset)}${filled.repeat(seg)}${empty.repeat(travel - offset)}`;
-	}
-	const cycle = travel * 2;
-	const pos = frame % cycle;
-	const offset = pos <= travel ? pos : cycle - pos;
-	return `${pad} ${empty.repeat(offset)}${filled.repeat(seg)}${empty.repeat(width - offset - seg)}`;
-}
-function formatBar(progress, cfg, frame) {
-	if (progress === void 0) return formatIndeterminate(cfg, frame);
-	const { width, filled, empty } = cfg;
-	const clamped = Math.max(0, Math.min(1, progress));
-	const filledCount = Math.round(clamped * width);
-	return `${`${Math.round(clamped * 100)}%`.padStart(4)} ${filled.repeat(filledCount)}${empty.repeat(width - filledCount)}`;
-}
-function parseUpdate(value) {
-	if (typeof value === "string") return { message: value };
-	if (typeof value === "number") return { progress: value };
-	return value;
-}
-function formatDuration$1(ms) {
-	const totalSeconds = Math.floor(ms / 1e3);
-	const hours = Math.floor(totalSeconds / 3600);
-	const minutes = Math.floor(totalSeconds % 3600 / 60);
-	const seconds = totalSeconds % 60;
-	if (hours > 0) return `${hours}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`;
-	return `${minutes}:${String(seconds).padStart(2, "0")}`;
-}
-function estimateEta(samples) {
-	if (samples.length < 2) return void 0;
-	const first = samples[0];
-	const last = samples[samples.length - 1];
-	const progressDelta = last.progress - first.progress;
-	if (progressDelta <= 0) return void 0;
-	const rate = progressDelta / (last.time - first.time);
-	const remaining = 1 - last.progress;
-	if (remaining <= 0) return 0;
-	return remaining / rate;
-}
-/**
-* Creates a terminal progress indicator (spinner, bar, or both).
-* Returns a no-op indicator in non-TTY/CI environments.
-*/
-function createTerminalProgress(message, options) {
-	const spinnerCfg = resolveSpinnerConfig(options?.spinner);
-	const successIcon = options?.successIndicator ?? "✔";
-	const errorIcon = options?.errorIndicator ?? "✖";
-	const barCfg = resolveBarConfig(options?.bar);
-	const formatFinal = (icon, msg) => icon ? `${icon} ${msg}\n` : `${msg}\n`;
-	if (typeof process === "undefined" || !process.stderr?.isTTY) return {
-		update() {},
-		eta: {
-			start() {},
-			stop() {},
-			reset() {}
-		},
-		succeed(msg, opts) {
-			if (msg === null) return;
-			const icon = opts?.indicator ?? successIcon;
-			if (msg || message) process?.stderr?.write?.(formatFinal(icon, msg || message));
-		},
-		fail(msg, opts) {
-			if (msg === null) return;
-			const icon = opts?.indicator ?? errorIcon;
-			if (msg || message) process?.stderr?.write?.(formatFinal(icon, msg || message));
-		},
-		stop() {},
-		pause() {},
-		resume() {}
-	};
-	const ansiPattern = /\x1b\[[0-9;]*m/g;
-	if (spinnerCfg.show === "never" && (!barCfg || barCfg.show === "never") && !message) return {
-		update() {},
-		eta: {
-			start() {},
-			stop() {},
-			reset() {}
-		},
-		succeed() {},
-		fail() {},
-		stop() {},
-		pause() {},
-		resume() {}
-	};
-	const showTime = options?.time ?? false;
-	let etaEnabled = options?.eta ?? false;
-	let spinnerFrame = 0;
-	let barFrame = 0;
-	let text = message;
-	let progress;
-	let indeterminate = false;
-	let stopped = false;
-	let paused = false;
-	let timeEnabled = showTime;
-	let startTime = showTime ? Date.now() : 0;
-	const etaSamples = [];
-	let etaMs;
-	let etaCalculatedAt = 0;
-	const writeStderr = process.stderr.write.bind(process.stderr);
-	const writeStdout = process.stdout.write.bind(process.stdout);
-	let prevLineCount = 0;
-	const clearLines = () => {
-		if (prevLineCount > 1) for (let i = 1; i < prevLineCount; i++) writeStderr("\x1B[1A\x1B[2K");
-		writeStderr("\x1B[2K\r");
-		prevLineCount = 0;
-	};
-	/** Count how many terminal rows `str` occupies, accounting for line wrapping. */
-	const lineCount = (str) => {
-		const cols = process.stderr.columns || 80;
-		const visible = str.replace(ansiPattern, "");
-		return Math.max(1, Math.ceil(visible.length / cols));
-	};
-	const render = () => {
-		if (paused || stopped) return;
-		const barVisible = barCfg && (barCfg.show === "always" || barCfg.show === "auto" && (progress !== void 0 || indeterminate));
-		const spinnerVisible = spinnerCfg.show === "always" || spinnerCfg.show === "auto" && !barVisible;
-		let line = "";
-		if (barVisible) line += formatBar(progress, barCfg, barFrame);
-		const hasEta = etaEnabled && progress !== void 0 && progress < 1 && etaMs !== void 0;
-		if (timeEnabled || hasEta) {
-			const parts = [];
-			if (timeEnabled) parts.push(`⏱ ${formatDuration$1(Date.now() - startTime)}`);
-			if (hasEta) {
-				const elapsed = Date.now() - etaCalculatedAt;
-				parts.push(`ETA ${formatDuration$1(Math.max(0, etaMs - elapsed))}`);
-			}
-			if (line) line += " ";
-			line += parts.join(" | ");
-		}
-		if (spinnerVisible) {
-			if (line) line += " ";
-			line += frames[spinnerFrame] ?? "";
-		}
-		if (text) {
-			if (line) line += " ";
-			line += text;
-		}
-		if (line) {
-			clearLines();
-			writeStderr(line);
-			prevLineCount = lineCount(line);
-		} else clearLines();
-	};
-	const { frames } = spinnerCfg;
-	const needsAnimation = spinnerCfg.show !== "never" || barCfg && barCfg.show !== "never";
-	const tickInterval = barCfg && barCfg.show !== "never" ? Math.min(80, spinnerCfg.interval) : spinnerCfg.interval;
-	const timer = needsAnimation ? setInterval(() => {
-		spinnerFrame = (spinnerFrame + 1) % (frames.length || 1);
-		barFrame++;
-		render();
-	}, tickInterval) : void 0;
-	if (timer && typeof timer === "object" && "unref" in timer) timer.unref();
-	render();
-	const clear = () => {
-		if (stopped) return;
-		stopped = true;
-		paused = false;
-		if (timer) clearInterval(timer);
-		clearLines();
-	};
-	return {
-		update(value) {
-			if (stopped) return;
-			const parsed = parseUpdate(value);
-			if (parsed.message !== void 0) text = parsed.message;
-			if (parsed.progress !== void 0) {
-				progress = parsed.progress;
-				if (etaEnabled) {
-					const now = Date.now();
-					etaSamples.push({
-						time: now,
-						progress: parsed.progress
-					});
-					const estimated = estimateEta(etaSamples);
-					if (estimated !== void 0) {
-						etaMs = estimated;
-						etaCalculatedAt = now;
-					}
-				}
-			}
-			if (parsed.indeterminate !== void 0) {
-				indeterminate = parsed.indeterminate;
-				if (indeterminate) progress = void 0;
-			}
-			if (parsed.time !== void 0) {
-				if (parsed.time && !timeEnabled) {
-					timeEnabled = true;
-					startTime = Date.now();
-				} else if (!parsed.time) timeEnabled = false;
-			}
-			render();
-		},
-		eta: {
-			start() {
-				if (stopped) return;
-				etaEnabled = true;
-				render();
-			},
-			stop() {
-				if (stopped) return;
-				etaEnabled = false;
-				etaMs = void 0;
-				render();
-			},
-			reset() {
-				if (stopped) return;
-				etaSamples.length = 0;
-				etaMs = void 0;
-				etaCalculatedAt = 0;
-				render();
-			}
-		},
-		succeed(msg, opts) {
-			clear();
-			if (msg === null) return;
-			const finalMsg = msg ?? text;
-			const icon = opts?.indicator ?? successIcon;
-			if (finalMsg) writeStderr(formatFinal(icon, finalMsg));
-		},
-		fail(msg, opts) {
-			clear();
-			if (msg === null) return;
-			const finalMsg = msg ?? text;
-			const icon = opts?.indicator ?? errorIcon;
-			if (finalMsg) writeStderr(formatFinal(icon, finalMsg));
-		},
-		stop() {
-			clear();
-		},
-		pause() {
-			if (stopped || paused) return;
-			paused = true;
-			clearLines();
-			writeStdout("\x1B[2K\r");
-		},
-		resume() {
-			if (stopped || !paused) return;
-			paused = false;
-			render();
-		}
-	};
-}
-//#endregion
-//#region src/extension/progress.ts
-const noopIndicator = {
-	update() {},
-	eta: {
-		start() {},
-		stop() {},
-		reset() {}
-	},
-	succeed() {},
-	fail() {},
-	stop() {},
-	pause() {},
-	resume() {}
-};
-function resolveMessage(field, value, fallback) {
-	const raw = typeof field === "function" ? field(value) : field;
-	if (raw === void 0) return { message: fallback };
-	if (raw === null || typeof raw === "string") return { message: raw };
-	if (typeof raw === "object" && raw !== null) {
-		const obj = raw;
-		return {
-			message: obj.message,
-			indicator: obj.indicator
-		};
-	}
-	return { message: fallback };
-}
-function cleanup(indicator, successConfig, errorConfig, error, result, isError) {
-	if (isError) {
-		const { message: errorMsg, indicator: errorIcon } = resolveMessage(errorConfig, error, error instanceof Error ? error.message : String(error));
-		indicator.fail(errorMsg, errorIcon !== void 0 ? { indicator: errorIcon } : void 0);
-	} else {
-		const { message: successMsg, indicator: successIcon } = resolveMessage(successConfig, result);
-		indicator.succeed(successMsg, successIcon !== void 0 ? { indicator: successIcon } : void 0);
-	}
-}
-function resolveMessages(raw) {
-	if (!raw || typeof raw === "string") return {
-		progress: raw || "Working...",
-		validation: "",
-		success: void 0,
-		error: void 0
-	};
-	return {
-		progress: raw.progress ?? "Working...",
-		validation: raw.validation ?? "",
-		success: raw.success,
-		error: raw.error
-	};
-}
-function mergeMessages(cmd, ctx, cmdRaw) {
-	if (typeof cmdRaw === "string") return cmd;
-	const obj = typeof cmdRaw === "object" ? cmdRaw : void 0;
-	return {
-		progress: obj?.progress !== void 0 ? cmd.progress : ctx.progress ?? cmd.progress,
-		validation: obj?.validation !== void 0 ? cmd.validation : ctx.validation || cmd.validation,
-		success: obj?.success !== void 0 ? cmd.success : ctx.success ?? cmd.success,
-		error: obj?.error !== void 0 ? cmd.error : ctx.error ?? cmd.error
-	};
-}
-function progressInterceptor(config) {
-	const isObj = typeof config === "object";
-	const rawMessage = typeof config === "string" ? config : isObj ? config.message : void 0;
-	const rawSpinner = isObj ? config.spinner : void 0;
-	const rawBar = isObj ? config.bar : void 0;
-	const rawRenderer = isObj ? config.renderer : void 0;
-	const rawTime = isObj ? config.time : void 0;
-	const rawEta = isObj ? config.eta : void 0;
-	const rawSilent = isObj ? config.silent : void 0;
-	return defineInterceptor({
-		id: "padrone:progress",
-		name: "padrone:progress"
-	}).requires().factory(() => {
-		let indicator;
-		let restoreOutput;
-		let resolvedRenderer;
-		let resolvedOptions;
-		let resolvedSilent = false;
-		let msgs;
-		function resolve(ctx) {
-			if (resolvedRenderer) return;
-			const ctxCfg = ctx.context?.progressConfig;
-			resolvedSilent = rawSilent ?? ctxCfg?.silent ?? false;
-			const spinner = rawSpinner ?? ctxCfg?.spinner;
-			const bar = rawBar ?? ctxCfg?.bar;
-			const time = rawTime ?? ctxCfg?.time;
-			const eta = rawEta ?? ctxCfg?.eta;
-			resolvedRenderer = rawRenderer ?? ctxCfg?.renderer ?? createTerminalProgress;
-			resolvedOptions = spinner !== void 0 || bar !== void 0 || time !== void 0 || eta !== void 0 ? {
-				spinner,
-				bar,
-				time,
-				eta
-			} : void 0;
-			msgs = mergeMessages(resolveMessages(rawMessage), resolveMessages(ctxCfg?.message), rawMessage);
-		}
-		const teardown = () => {
-			restoreOutput?.();
-			indicator = void 0;
-			restoreOutput = void 0;
-		};
-		return {
-			validate(ctx, next) {
-				resolve(ctx);
-				if (resolvedSilent) return next();
-				indicator = resolvedRenderer(msgs.validation || msgs.progress, resolvedOptions);
-				const originalOutput = ctx.runtime.output;
-				const originalError = ctx.runtime.error;
-				ctx.runtime.output = (...args) => {
-					indicator.pause();
-					originalOutput(...args);
-					indicator.resume();
-				};
-				ctx.runtime.error = (text) => {
-					indicator.pause();
-					originalError(text);
-					indicator.resume();
-				};
-				restoreOutput = () => {
-					ctx.runtime.output = originalOutput;
-					ctx.runtime.error = originalError;
-				};
-				const onValidationFailure = (error) => {
-					if (indicator) {
-						cleanup(indicator, msgs.success, msgs.error, error, void 0, true);
-						teardown();
-					}
-				};
-				const checkResult = (result) => {
-					if (result.argsResult?.issues) onValidationFailure(/* @__PURE__ */ new Error("Validation failed"));
-					return result;
-				};
-				let result;
-				try {
-					result = next();
-				} catch (err) {
-					onValidationFailure(err);
-					throw err;
-				}
-				if (result instanceof Promise) return result.then(checkResult, (err) => {
-					onValidationFailure(err);
-					throw err;
-				});
-				return checkResult(result);
-			},
-			execute(_ctx, next) {
-				if (resolvedSilent) return next({ context: { progress: noopIndicator } });
-				if (indicator && msgs.validation) indicator.update(msgs.progress);
-				const effectiveIndicator = indicator ?? noopIndicator;
-				const onSuccess = (value) => {
-					cleanup(effectiveIndicator, msgs.success, msgs.error, void 0, value, false);
-					teardown();
-				};
-				const onError = (err) => {
-					if (indicator) {
-						cleanup(indicator, msgs.success, msgs.error, err, void 0, true);
-						teardown();
-					}
-					throw err;
-				};
-				let result;
-				try {
-					result = next({ context: { progress: effectiveIndicator } });
-				} catch (err) {
-					onError(err);
-				}
-				if (result instanceof Promise) return result.then((r) => {
-					if (r.result instanceof Promise) return { result: r.result.then((value) => {
-						onSuccess(value);
-						return value;
-					}, (err) => onError(err)) };
-					onSuccess(r.result);
-					return r;
-				}, (err) => onError(err));
-				if (result.result instanceof Promise) return { result: result.result.then((value) => {
-					onSuccess(value);
-					return value;
-				}, (err) => onError(err)) };
-				onSuccess(result.result);
-				return result;
-			},
-			shutdown(ctx) {
-				if (indicator) {
-					cleanup(indicator, msgs.success, msgs.error, ctx.error, ctx.result, !!ctx.error);
-					teardown();
-				}
-			}
-		};
-	}).provides();
-}
-/**
-* Extension that adds an auto-managed progress indicator to the command pipeline.
-*
-* - `string` — a single message used for all states.
-* - `PadroneProgressConfig` — separate messages for validation, progress, success, and error.
-*
-* The indicator is automatically started before validation, updated at each phase transition,
-* and stopped on success (`.succeed()`) or failure (`.fail()`).
-*
-* Provides `{ progress: PadroneProgress }` on the command context.
-* Access it in action handlers as `ctx.context.progress`.
-*
-* Uses the built-in terminal renderer by default. Pass a custom `renderer` for non-terminal
-* environments (web UIs, testing, etc).
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli')
-*   .command('sync', (c) =>
-*     c.extend(padroneProgress('Syncing...'))
-*       .action((_args, ctx) => {
-*         ctx.context.progress.update('halfway');
-*       })
-*   )
-* ```
-*/
-function padroneProgress(config) {
-	return ((builder) => builder.intercept(progressInterceptor(config ?? "Working...")));
-}
-//#endregion
-//#region src/extension/serve.ts
-/**
-* Extension that adds the `serve` command for starting a REST HTTP server.
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli').extend(padroneServe())
-* ```
-*/
-function padroneServe(defaults) {
-	return ((builder) => builder.command("serve", (c) => c.configure({
-		description: "Start a REST HTTP server",
-		hidden: true
-	}).arguments(passthroughSchema({
-		port: "string",
-		host: "string",
-		"base-path": "string"
-	})).async().action(async (args, ctx) => {
-		const rootCommand = getRootCommand(ctx.command);
-		resolveAllCommands(rootCommand);
-		const { startServeServer } = await import("./serve-ICZFl3xr.mjs");
-		const port = args.port ? parseInt(args.port, 10) : void 0;
-		const prefs = {
-			...defaults,
-			port: port && !Number.isNaN(port) ? port : defaults?.port,
-			host: args.host ?? defaults?.host,
-			basePath: args["base-path"] ?? defaults?.basePath
-		};
-		await startServeServer(ctx.program, rootCommand, ctx.program.eval, prefs);
-	})));
-}
-//#endregion
-//#region src/extension/timing.ts
-function formatDuration(ms) {
-	if (ms < 1e3) return `${ms.toFixed(0)}ms`;
-	if (ms < 6e4) return `${(ms / 1e3).toFixed(2)}s`;
-	return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(2)}s`;
-}
-const timingMeta = {
-	id: "padrone:timing",
-	name: "padrone:timing",
-	order: -1002
-};
-function createTimingInterceptor(enabledByDefault) {
-	return defineInterceptor(timingMeta, () => {
-		let enabled = enabledByDefault;
-		let startTime = 0;
-		return {
-			parse(_ctx, next) {
-				return thenMaybe(next(), (res) => {
-					if ("timing" in res.rawArgs) {
-						enabled = res.rawArgs.timing !== false;
-						delete res.rawArgs.timing;
-					}
-					if ("time" in res.rawArgs) {
-						enabled = res.rawArgs.time !== false;
-						delete res.rawArgs.time;
-					}
-					return res;
-				});
-			},
-			start(_ctx, next) {
-				startTime = performance.now();
-				return next();
-			},
-			shutdown(ctx, next) {
-				return thenMaybe(next(), (res) => {
-					if (enabled) {
-						const elapsed = performance.now() - startTime;
-						ctx.runtime.error(`\nDone in ${formatDuration(elapsed)}`);
-					}
-					return res;
-				});
-			}
-		};
-	});
-}
-/**
-* Extension that tracks command execution time.
-*
-* - `--time` / `--timing` → enables timing output
-* - `--no-time` / `--no-timing` → disables timing output
-*
-* Pass `{ enabled: true }` to enable timing by default (can be disabled via `--no-time`).
-*
-* Usage:
-* ```ts
-* // Opt-in via flag
-* createPadrone('my-cli').extend(padroneTiming())
-*
-* // Always on, opt-out via --no-time
-* createPadrone('my-cli').extend(padroneTiming({ enabled: true }))
-* ```
-*/
-function padroneTiming(options) {
-	return ((builder) => builder.intercept(createTimingInterceptor(options?.enabled ?? false)));
-}
-//#endregion
-//#region src/extension/tracing.ts
-const OTEL_ERROR = 2;
-function tracingInterceptor(config) {
-	return defineInterceptor({
-		id: "padrone:tracing",
-		name: "padrone:tracing",
-		order: -1
-	}, () => {
-		let rootSpan;
-		let tracer;
-		return {
-			start(ctx, next) {
-				tracer = config.provider.getTracer(config.serviceName ?? ctx.command.name);
-				return next();
-			},
-			execute(ctx, next) {
-				rootSpan = tracer.startSpan(`cli ${ctx.command.name}`);
-				return next({ context: { tracing: {
-					tracer,
-					rootSpan,
-					span(name, fn) {
-						const child = tracer.startSpan(name);
-						try {
-							const result = fn(child);
-							if (result != null && typeof result.then === "function") return result.then((v) => {
-								child.end();
-								return v;
-							}, (err) => {
-								child.recordException(err);
-								child.setStatus({ code: OTEL_ERROR });
-								child.end();
-								throw err;
-							});
-							child.end();
-							return result;
-						} catch (err) {
-							child.recordException(err);
-							child.setStatus({ code: OTEL_ERROR });
-							child.end();
-							throw err;
-						}
-					}
-				} } });
-			},
-			error(ctx, next) {
-				rootSpan?.recordException(ctx.error);
-				rootSpan?.setStatus({ code: OTEL_ERROR });
-				return next();
-			},
-			shutdown(_ctx, next) {
-				return thenMaybe(next(), (res) => {
-					rootSpan?.end();
-					return res;
-				});
-			}
-		};
-	});
-}
-/**
-* Extension that adds OpenTelemetry tracing to command execution.
-*
-* Creates a root span for each command invocation and provides a `PadroneTracer`
-* on the command context for creating child spans in action handlers.
-*
-* When used with `padroneLogger()`, the logger automatically emits span events
-* for each log call — no extra configuration needed. The logger detects the
-* tracing context and bridges log output to span events.
-*
-* Uses minimal OTEL-compatible interfaces — pass any `TracerProvider` that
-* implements `getTracer()`. Works with `@opentelemetry/api` or compatible
-* libraries.
-*
-* Provides `{ tracing: PadroneTracer }` on the command context.
-* Access it in action handlers as `ctx.context.tracing`.
-*
-* Usage:
-* ```ts
-* import { trace } from '@opentelemetry/api';
-*
-* createPadrone('my-cli')
-*   .extend(padroneTracing({ provider: trace.getTracerProvider() }))
-*   .extend(padroneLogger())
-*   .command('deploy', (c) =>
-*     c.action((_args, ctx) => {
-*       ctx.context.logger.info('deploying');  // also emits a span event
-*       ctx.context.tracing.span('build', (span) => {
-*         span.setAttribute('target', 'production');
-*       });
-*     })
-*   )
-* ```
-*/
-function padroneTracing(config) {
-	const resolved = {
-		provider: config.provider,
-		serviceName: config.serviceName
-	};
-	return ((builder) => builder.intercept(tracingInterceptor(resolved)));
-}
-//#endregion
-//#region src/extension/update-check.ts
-function createUpdateCheckInterceptor(config) {
-	return defineInterceptor({
-		id: "padrone:update-check",
-		name: "padrone:update-check",
-		order: 1e3
-	}, () => {
-		let checkPromise;
-		let suppressed = false;
-		return {
-			start(ctx, next) {
-				const rootCommand = ctx.command;
-				const runtime = ctx.runtime;
-				checkPromise = Promise.resolve(getVersion(rootCommand.version)).then((currentVersion) => import("./update-check-CZ2VqjnV.mjs").then(({ createUpdateChecker }) => createUpdateChecker(rootCommand.name, currentVersion, config, runtime)));
-				return next();
-			},
-			parse(_ctx, next) {
-				return thenMaybe(next(), (res) => {
-					if ("update-check" in res.rawArgs) {
-						if (res.rawArgs["update-check"] === false) suppressed = true;
-						delete res.rawArgs["update-check"];
-					}
-					return res;
-				});
-			},
-			shutdown(_ctx, next) {
-				const result = next();
-				if (suppressed || !checkPromise) return result;
-				let resolved = null;
-				checkPromise.then((fn) => {
-					resolved = fn;
-				}, () => {
-					resolved = void 0;
-				});
-				if (resolved !== null) resolved?.();
-				return result;
-			}
-		};
-	});
-}
-/**
-* Extension that adds background update checking:
-* - Checks for newer versions on npm (or custom registry) in the background
-* - Shows an update notification after command execution
-* - Respects `--no-update-check` flag to suppress
-*
-* Usage:
-* ```ts
-* createPadrone('my-cli')
-*   .extend(padroneUpdateCheck({ packageName: 'my-cli' }))
-* ```
-*/
-function padroneUpdateCheck(config = {}) {
-	return ((builder) => builder.intercept(createUpdateCheckInterceptor(config)));
-}
-//#endregion
-export { ActionError, ConfigError, PadroneError, REPL_SIGINT, RoutingError, SignalError, ValidationError, asyncSchema, asyncStream, buildReplCompleter, colorThemes, createPadrone, createTerminalProgress, defineCommand, defineInterceptor, isReactElement, padroneAutoOutput, padroneColor, padroneCompletion, padroneConfig, padroneEnv, padroneHelp, padroneInk, padroneInteractive, padroneLogger, padroneMan, padroneMcp, padroneProgress, padroneRepl, padroneServe, padroneSignalHandling, padroneStdin, padroneSuggestions, padroneTiming, padroneTracing, padroneUpdateCheck, padroneVersion };
-
-//# sourceMappingURL=index.mjs.map
+import { asyncStream } from "./util/stream.mjs";
+import { REPL_SIGINT } from "./core/runtime.mjs";
+import { buildReplCompleter } from "./core/commands.mjs";
+import { asyncSchema } from "./core/results.mjs";
+import { defineInterceptor } from "./core/interceptors.mjs";
+import { colorThemes } from "./output/colorizer.mjs";
+import { padroneAutoOutput } from "./extension/auto-output.mjs";
+import { padroneColor } from "./extension/color.mjs";
+import { ActionError, ConfigError, PadroneError, RoutingError, SignalError, ValidationError } from "./core/errors.mjs";
+import { padroneHelp } from "./extension/help.mjs";
+import { padroneInteractive } from "./extension/interactive.mjs";
+import { padroneRepl } from "./extension/repl.mjs";
+import { padroneSignalHandling } from "./extension/signal.mjs";
+import { padroneStdin } from "./extension/stdin.mjs";
+import { padroneSuggestions } from "./extension/suggestions.mjs";
+import { padroneVersion } from "./extension/version.mjs";
+import { createPadrone, defineCommand } from "./core/create.mjs";
+import { padroneConfig } from "./extension/config.mjs";
+import { padroneEnv } from "./extension/env.mjs";
+import { padroneLogger } from "./extension/logger.mjs";
+import { createTerminalProgress } from "./extension/progress-renderer.mjs";
+import { padroneProgress } from "./extension/progress.mjs";
+import { padroneTiming } from "./extension/timing.mjs";
+import { padroneUpdateCheck } from "./extension/update-check.mjs";
+export { ActionError, ConfigError, PadroneError, REPL_SIGINT, RoutingError, SignalError, ValidationError, asyncSchema, asyncStream, buildReplCompleter, colorThemes, createPadrone, createTerminalProgress, defineCommand, defineInterceptor, padroneAutoOutput, padroneColor, padroneConfig, padroneEnv, padroneHelp, padroneInteractive, padroneLogger, padroneProgress, padroneRepl, padroneSignalHandling, padroneStdin, padroneSuggestions, padroneTiming, padroneUpdateCheck, padroneVersion };