@kubb/cli 5.14.5 → 5.15.0

package/dist/index.js

@@ -1,151 +1,13 @@
-import { t as __name } from "./rolldown-runtime-CRm0XQPb.js";
-import { t as getErrorMessage } from "./errors-DmC83ALX.js";
-import { a as getElapsedMs, i as formatMs, r as version, t as isDisabled } from "./Telemetry-Dc79_cIA.js";
-import { _ as write, a as readOutputFiles, c as createSpinner, g as read, l as withSpinner, m as exists, n as diffFiles, v as writeRaw } from "./utils-D8VN40bN.js";
-import { _ as isRichOutput, a as logOutro, c as logBlock, d as logStep, f as logWarn, i as logIntro, l as logError, r as isInteractiveRun, t as pluralize } from "./text-CEyJhBnh.js";
-import { a as installSpec, c as toRegistryId, f as wantsMascot, i as incompatibility, l as toShortId, n as closestIds, o as isOutdated, r as fetchRegistryIndex, s as registryUrl, t as bumpOf, u as getBanner } from "./registry-ov1RYcD4.js";
-import { a as KUBB_PACKAGE_NAME, i as KUBB_CONFIG_FILENAME, n as findConfigFile, o as initDefaults, r as BUNDLED_PACKAGES, t as getConfigs } from "./config-CNqgDSu3.js";
-import { t as logCommandSummary } from "./summary-B219y888.js";
+import "./rolldown-runtime-xo6NMXYd.js";
+import { t as version } from "./package-D3Yss9Bb.js";
+import { t as isDisabled } from "./Telemetry-B3edcFoB.js";
+import { r as wantsMascot, t as getBanner } from "./mascot--q1xjKw1.js";
+import { n as dryRunId, r as logLevelArg, t as configArg } from "./shared-Ct9stKpp.js";
 import { styleText } from "node:util";
-import dryrun, { pluginId as dryRunId } from "@gunshi/plugin-dryrun";
-import { cli, define, defineWithTypes } from "gunshi";
-import process$1 from "node:process";
-import { x } from "tinyexec";
-import path from "node:path";
-import fs from "node:fs";
-import * as clack from "@clack/prompts";
-import { Diagnostics, Hookable, createKubb, isPackageName, readInstalledPackages } from "@kubb/core";
-import { parse } from "yuku-parser";
-//#region ../../internals/utils/src/casing.ts
-/**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function convert(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-const cache = /* @__PURE__ */ new Map();
-const cacheLimit = 1e4;
-function toCamelOrPascal(text, pascal) {
-	const key = `${pascal ? "P" : "c"}${text}`;
-	const cached = cache.get(key);
-	if (cached !== void 0) return cached;
-	const result = convert(text, pascal);
-	if (cache.size >= cacheLimit) cache.clear();
-	cache.set(key, result);
-	return result;
-}
-/**
-* Converts `text` to camelCase.
-*
-* @example Word boundaries
-* `camelCase('hello-world') // 'helloWorld'`
-*
-* @example With a prefix
-* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
-*/
-function camelCase(text, { prefix = "", suffix = "" } = {}) {
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-//#endregion
-//#region src/commands/shared.ts
-const configArg = { config: {
-	type: "string",
-	description: "Path to the Kubb config",
-	short: "c"
-} };
-const yesArg = { yes: {
-	type: "boolean",
-	description: "Skip the confirmation",
-	short: "y",
-	default: false
-} };
-const logLevelArg = { logLevel: {
-	type: "enum",
-	choices: [
-		"silent",
-		"info",
-		"verbose"
-	],
-	description: "Info, silent or verbose",
-	short: "l",
-	default: "info",
-	toKebab: true
-} };
-const studioConnectionArgs = {
-	url: {
-		type: "string",
-		description: "Base URL of the Kubb Studio instance"
-	},
-	token: {
-		type: "string",
-		description: "Organization CI API key for `snapshot`. Defaults to KUBB_TOKEN"
-	}
-};
-const studioPermissionArgs = {
-	allowRead: {
-		type: "boolean",
-		description: "Read the source of files a generation produced. Asked for once per project when omitted",
-		default: false,
-		toKebab: true
-	},
-	allowReadAst: {
-		type: "boolean",
-		description: "Read the parsed spec (the Kubb AST). Asked for once per project when omitted",
-		default: false,
-		toKebab: true
-	},
-	allowWrite: {
-		type: "boolean",
-		description: "Write generated files to disk. Asked for once per project when omitted",
-		default: false,
-		toKebab: true
-	},
-	allowConfigEdit: {
-		type: "boolean",
-		description: "Let Studio change plugin options in kubb.config.ts. Asked for once per project when omitted",
-		default: false,
-		toKebab: true
-	},
-	allowInstall: {
-		type: "boolean",
-		description: "Let Studio install extensions from the registry with kubb add; needs --allow-config-edit too. Asked for once per project when omitted",
-		default: false,
-		toKebab: true
-	},
-	allowUpdate: {
-		type: "boolean",
-		description: "Let Studio update installed extensions with kubb update. Asked for once per project when omitted",
-		default: false,
-		toKebab: true
-	},
-	allowRemove: {
-		type: "boolean",
-		description: "Let Studio remove extensions with kubb remove, which edits kubb.config.ts and uninstalls packages; needs --allow-config-edit too. Asked for once per project when omitted",
-		default: false,
-		toKebab: true
-	},
-	allowSaveInput: {
-		type: "boolean",
-		description: "Let Studio save the spec it sends as the input in kubb.config.ts; needs --allow-config-edit too. Asked for once per project when omitted",
-		default: false,
-		toKebab: true
-	},
-	allowExec: {
-		type: "boolean",
-		description: "Run the formatter, the linter, and output.postGenerate after a generation",
-		default: false,
-		toKebab: true
-	}
-};
-//#endregion
-//#region src/commands/generate.ts
+import dryrun from "@gunshi/plugin-dryrun";
+import { cli, defineWithTypes } from "gunshi";
+import { Diagnostics } from "@kubb/core";
+// src/commands/generate.ts
 const REPORTER_NAMES = [
 	"cli",
 	"json",
@@ -173,7 +35,7 @@ function resolveLogLevel({ verbose, silent, logLevel }) {
 	if (silent) return "silent";
 	return logLevel;
 }
-const command$14 = defineWithTypes()({
+const command = defineWithTypes()({
 	name: "generate",
 	rendering: { header: null },
 	description: "Generate types, clients, hooks, and schemas from an OpenAPI specification.",
@@ -224,7 +86,7 @@ const command$14 = defineWithTypes()({
 	async run(ctx) {
 		const { values } = ctx;
 		const logLevel = resolveLogLevel(values);
-		const { run } = await import("./run-YMSJnvYl.js");
+		const { run } = await import("./run-CbX6tpqB.js");
 		await run({
 			input: values.input,
 			configPath: values.config,
@@ -235,242 +97,7 @@ const command$14 = defineWithTypes()({
 		});
 	}
 });
-//#endregion
-//#region src/commands/mcp.ts
-/** The runner is imported when the command runs, so listing `kubb --help` never loads `@kubb/mcp`. */
-const command$13 = define({
-	name: "mcp",
-	description: "Start an MCP server for code generation from an AI assistant.",
-	examples: [
-		"kubb mcp",
-		"# Then add to your MCP client config:",
-		"# { \"mcpServers\": { \"kubb\": { \"command\": \"npx\", \"args\": [\"kubb\", \"mcp\"] } } }"
-	].join("\n"),
-	rendering: { header: null },
-	async run() {
-		const { run } = await import("./run-BK-A9JDf.js");
-		await run();
-	}
-});
-//#endregion
-//#region src/commands/studio/studioCommand.ts
-/**
-* Defines a `kubb studio` subcommand. The runner, and with it `@kubb/studio`, loads only when the
-* command runs, so `kubb --help` never does.
-*/
-function studioCommand({ action, block, ...definition }) {
-	return define({
-		...definition,
-		toKebab: true,
-		async run({ values }) {
-			const { runStudio } = await import("./run-v5aW1jjQ.js");
-			await runStudio(values, action, { block });
-		}
-	});
-}
-//#endregion
-//#region src/commands/studio/connect.ts
-const command$12 = studioCommand({
-	name: "connect",
-	description: "Connect this project to Kubb Studio and generate from the browser.",
-	examples: [
-		"kubb studio connect",
-		"kubb studio connect --allow-read",
-		"kubb studio connect --allow-write --allow-exec",
-		"kubb studio connect --url http://localhost:3000"
-	].join("\n"),
-	args: {
-		...configArg,
-		...studioConnectionArgs,
-		...studioPermissionArgs,
-		open: {
-			type: "boolean",
-			description: "Open the approval page in a browser while pairing",
-			default: true,
-			negatable: true
-		},
-		...logLevelArg
-	},
-	block: true,
-	async action(options) {
-		const { connect } = await import("./run-v5aW1jjQ.js");
-		await connect(options);
-	}
-});
-//#endregion
-//#region src/commands/studio/login.ts
-const command$11 = studioCommand({
-	name: "login",
-	description: "Pair this machine with Kubb Studio without connecting.",
-	examples: ["kubb studio login", "kubb studio login --url http://localhost:3000"].join("\n"),
-	args: command$12.args,
-	async action(options) {
-		const { login } = await import("./run-v5aW1jjQ.js");
-		await login(options);
-	}
-});
-//#endregion
-//#region src/commands/studio/logout.ts
-const command$10 = studioCommand({
-	name: "logout",
-	description: "Forget the stored Kubb Studio token.",
-	examples: "kubb studio logout",
-	args: {},
-	async action() {
-		const { stopWorker } = await import("./background-C877JFxE.js");
-		const { clearCredentials } = await import("./credentials-C8tjAhTo.js");
-		await stopWorker();
-		await clearCredentials();
-		console.log("Signed out of Kubb Studio.");
-	}
-});
-//#endregion
-//#region src/commands/studio/snapshot.ts
-const command$9 = define({
-	name: "snapshot",
-	description: "Generate and publish a Kubb Studio snapshot from CI.",
-	examples: ["kubb studio snapshot", "kubb studio snapshot --json"].join("\n"),
-	toKebab: true,
-	args: {
-		...configArg,
-		...studioConnectionArgs,
-		id: {
-			type: "string",
-			description: "Stable identity for the CI agent, such as a pull request. Auto-detected on GitHub Actions, GitLab CI, Bitbucket Pipelines and CircleCI"
-		},
-		baseId: {
-			type: "string",
-			description: "Identity of another CI agent, such as the base branch's, to also compare this snapshot with. Auto-detected on GitHub pull requests and GitLab merge requests",
-			toKebab: true
-		},
-		name: {
-			type: "string",
-			description: "Package name for the generated tarball. Defaults to the name in package.json"
-		},
-		packageVersion: {
-			type: "string",
-			description: "Package version for the generated tarball. Defaults to the version in package.json",
-			toKebab: true
-		},
-		json: {
-			type: "boolean",
-			description: "Print the result as one JSON object instead of a summary",
-			default: false
-		},
-		...logLevelArg
-	},
-	async run(ctx) {
-		const { runner } = await import("./snapshot-D2E7nhEf.js");
-		await runner(ctx);
-	}
-});
-//#endregion
-//#region src/commands/studio/background.ts
-const command$8 = studioCommand({
-	name: "start",
-	description: "Keep this project connected to Kubb Studio in the background.",
-	args: command$12.args,
-	async action(options) {
-		const { startWorker } = await import("./background-C877JFxE.js");
-		await startWorker(options);
-	}
-});
-const stopCommand = define({
-	name: "stop",
-	description: "Stop this project's background connection and keep its pairing.",
-	async run() {
-		const { stopWorker } = await import("./background-C877JFxE.js");
-		await stopWorker();
-		console.log("Background connection stopped.");
-	}
-});
-//#endregion
-//#region src/commands/studio/status.ts
-const command$7 = studioCommand({
-	name: "status",
-	description: "Show the project worker, Kubb Studio pairing, and saved permissions.",
-	examples: "kubb studio status",
-	args: { url: studioConnectionArgs.url },
-	async action(options) {
-		const { getWorkerLogPath, getWorkerStatus } = await import("./background-C877JFxE.js");
-		const { readCredentials } = await import("./credentials-C8tjAhTo.js");
-		const { formatStatus } = await import("./status-BHIOMCM0.js");
-		const [worker, credentials] = await Promise.all([getWorkerStatus(), readCredentials()]);
-		console.log([
-			"",
-			...formatStatus({
-				studioUrl: options.studioUrl,
-				credentials,
-				worker,
-				project: process$1.cwd(),
-				logPath: getWorkerLogPath()
-			}),
-			""
-		].join("\n"));
-	}
-});
-//#endregion
-//#region src/commands/studio/index.ts
-const command$6 = define({
-	...command$12,
-	name: "studio",
-	description: "Connect this project to Kubb Studio, or manage its pairing and snapshots.",
-	examples: [
-		"kubb studio",
-		"kubb studio --allow-read",
-		"kubb studio login",
-		"kubb studio status",
-		"kubb studio logout",
-		"kubb studio snapshot"
-	].join("\n"),
-	subCommands: {
-		start: command$8,
-		stop: stopCommand,
-		connect: command$12,
-		login: command$11,
-		logout: command$10,
-		status: command$7,
-		snapshot: command$9
-	}
-});
-/**
-* Sends `kubb studio --flag value` to `kubb studio connect`, the same runner. gunshi picks a
-* subcommand from the first token that is not a flag, so `--url http://…` would read the URL as one.
-*/
-function routeStudioFlags(args) {
-	const [name, next] = args;
-	if (name !== "studio" || !next?.startsWith("-") || next === "--help" || next === "-h") return args;
-	return [
-		"studio",
-		"connect",
-		...args.slice(1)
-	];
-}
-//#endregion
-//#region src/commands/validate.ts
-/** The runner is imported when the command runs, so listing `kubb --help` never loads `@kubb/adapter-oas`. */
-const command$5 = define({
-	name: "validate",
-	description: "Check a specification with the configured adapter before generating.",
-	examples: ["kubb validate ./openapi.yaml", "kubb validate https://petstore3.swagger.io/api/v3/openapi.json"].join("\n"),
-	args: {
-		...configArg,
-		input: {
-			type: "positional",
-			description: "Path or URL to the specification to validate",
-			required: true
-		}
-	},
-	async run({ values }) {
-		const { run } = await import("./run-UsAMlUyy.js");
-		await run({
-			input: values.input,
-			configPath: values.config
-		});
-	}
-});
-//#endregion
-//#region src/deprecatedFlags.ts
+// src/deprecatedFlags.ts
 /**
 * Maps each camelCase flag removed in favor of kebab-case (kubb-labs/kubb#4046) to its
 * replacement. Drop this table, and the rewrite it drives, once the deprecation window ends.
@@ -502,2323 +129,20 @@ function resolveDeprecatedFlags(args) {
 		return `--${replacement}${match?.[2] ?? ""}`;
 	});
 }
-//#endregion
-//#region ../../internals/shared/src/init.ts
-/** The `kubb.config.ts` `kubb init` writes before `kubb add` puts each plugin in. */
-function generateConfigFile({ inputPath, outputPath }) {
-	return `import { defineConfig } from 'kubb/config'
-
-export default defineConfig({
-  input: '${inputPath}',
-  output: {
-    path: '${outputPath}',
-    clean: true,
-  },
-  plugins: [],
-})
-`;
-}
-//#endregion
-//#region ../../internals/shared/src/configFile/ast.ts
-/** Node types the config editor reads from the yuku AST. */
-const nodeTypes = {
-	arrayExpression: "ArrayExpression",
-	arrowFunctionExpression: "ArrowFunctionExpression",
-	assignmentExpression: "AssignmentExpression",
-	blockStatement: "BlockStatement",
-	callExpression: "CallExpression",
-	exportDefaultDeclaration: "ExportDefaultDeclaration",
-	expressionStatement: "ExpressionStatement",
-	functionExpression: "FunctionExpression",
-	identifier: "Identifier",
-	importDeclaration: "ImportDeclaration",
-	importSpecifier: "ImportSpecifier",
-	literal: "Literal",
-	memberExpression: "MemberExpression",
-	objectExpression: "ObjectExpression",
-	objectPattern: "ObjectPattern",
-	property: "Property",
-	returnStatement: "ReturnStatement",
-	spreadElement: "SpreadElement",
-	tSAsExpression: "TSAsExpression",
-	tSSatisfiesExpression: "TSSatisfiesExpression",
-	templateLiteral: "TemplateLiteral",
-	unaryExpression: "UnaryExpression",
-	variableDeclaration: "VariableDeclaration"
-};
-const commentTypes = { line: "Line" };
-const propertyKinds = { init: "init" };
-const unaryOperators = {
-	minus: "-",
-	plus: "+"
-};
-const diagnosticSeverities = { error: "error" };
-/**
-* Parses `source` as a TypeScript module. Never throws: a syntax error, or a native parser that
-* cannot load on this platform, comes back as a `reason`.
-*/
-function parseSource(source) {
-	try {
-		const { program, comments, diagnostics } = parse(source, {
-			lang: "ts",
-			sourceType: "module",
-			preserveParens: false
-		});
-		if (diagnostics.some((diagnostic) => diagnostic.severity === diagnosticSeverities.error)) return { reason: "the config file could not be parsed" };
-		return {
-			program,
-			comments
-		};
-	} catch (error) {
-		return { reason: `the config parser could not load on this platform: ${getErrorMessage(error)}` };
-	}
-}
-/** Parses `source` as one expression, such as a commented-out `pluginTs({ ... })` call. */
-function parseExpression(source) {
-	const parsed = parseSource(source);
-	if ("reason" in parsed) return void 0;
-	const [statement] = parsed.program.body;
-	return parsed.program.body.length === 1 && statement?.type === nodeTypes.expressionStatement ? statement.expression : void 0;
-}
-//#endregion
-//#region ../../internals/shared/src/configFile/types.ts
-const extensionKinds = {
-	plugin: "plugin",
-	adapter: "adapter",
-	parser: "parser"
-};
-const ConfigEditOperation = {
-	SET_OPTION: "set-option",
-	REMOVE_OPTION: "remove-option",
-	ADD_PLUGIN: "add-plugin",
-	REMOVE_EXTENSION: "remove-extension",
-	DISABLE_PLUGIN: "disable-plugin",
-	ENABLE_PLUGIN: "enable-plugin",
-	SET_INPUT: "set-input",
-	SET_OUTPUT: "set-output",
-	REMOVE_OUTPUT: "remove-output"
-};
-//#endregion
-//#region ../../internals/shared/src/configFile/rules.ts
-/** `@kubb/plugin-ts` becomes `plugin-ts`, the `name` Kubb plugin factories use. */
-function toPluginName(packageName) {
-	return packageName.split("/").pop() ?? packageName;
-}
-/** `@kubb/plugin-react-query` becomes `pluginReactQuery`, the export a plugin package uses by convention. */
-function toExportName(packageName) {
-	return camelCase(toPluginName(packageName));
-}
-const KUBB_PLUGIN_SPECIFIER = /^@kubb\/plugin-[\w.-]+$/;
-/** Only a `@kubb/plugin-*` package or an installed extension of `kind` may be imported, never a path or URL. */
-function isAllowedPlugin({ packageName, extensions, kind = extensionKinds.plugin }) {
-	if (!isPackageName(packageName)) return false;
-	return kind === extensionKinds.plugin && KUBB_PLUGIN_SPECIFIER.test(packageName) || extensions.get(packageName)?.manifest.kind === kind;
-}
-const UNSAFE_KEYS = /* @__PURE__ */ new Set([
-	"__proto__",
-	"constructor",
-	"prototype"
-]);
-/** Whether `key` can be an option key without reaching the object's prototype. */
-function isSafeKey(key) {
-	return !UNSAFE_KEYS.has(key);
-}
-function isPlainObject(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || prototype === Object.prototype;
-}
-/** Whether `value` survives a JSON round trip, so an edit never writes a lossy copy into the file. */
-function isOptionValue(value) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
-	if (typeof value === "number") return Number.isFinite(value);
-	if (Array.isArray(value)) return value.every(isOptionValue);
-	if (isPlainObject(value)) return Object.entries(value).every(([key, entry]) => isSafeKey(key) && isOptionValue(entry));
-	return false;
-}
-/** The root `output` members Studio may set, with the values each takes. */
-const OUTPUT_VALUES = {
-	barrel: (value) => value === false || isPlainObject(value) && Object.keys(value).length === 1 && (value.type === "named" || value.type === "all"),
-	format: (value) => value === false || [
-		"auto",
-		"prettier",
-		"biome",
-		"oxfmt"
-	].includes(value),
-	lint: (value) => value === false || [
-		"auto",
-		"eslint",
-		"biome",
-		"oxlint"
-	].includes(value),
-	clean: (value) => typeof value === "boolean",
-	defaultBanner: (value) => value === false || value === "simple" || value === "full"
-};
-function isOutputKey(key) {
-	return Object.hasOwn(OUTPUT_VALUES, key);
-}
-function isOutputValue({ key, value }) {
-	return isOutputKey(key) && OUTPUT_VALUES[key](value);
-}
-function pickOutput(output) {
-	return Object.fromEntries(Object.entries(output).filter(([key]) => isOutputKey(key)));
-}
-//#endregion
-//#region ../../internals/shared/src/configFile/text.ts
-/**
-* A valid JavaScript identifier, so an import name can only ever print as `import { name } from`,
-* never as source that breaks out of the import statement.
-*/
-const IDENTIFIER_PATTERN = /^[A-Za-z_$][\w$]*$/;
-const quotes = {
-	single: `'`,
-	double: `"`
-};
-/** `source` with the text between `start` and `end` replaced by `text`. */
-function replaceText(source, start, end, text = "") {
-	return `${source.slice(0, start)}${text}${source.slice(end)}`;
-}
-/** The 1-based line and 0-based column of `offset` in `source`. */
-function getPosition(source, offset) {
-	return {
-		line: source.slice(0, offset).split("\n").length,
-		column: offset - source.lastIndexOf("\n", offset - 1) - 1
-	};
-}
-/** Writes `value` as a single-line literal with the file's quote style. */
-function printValue(value, quote) {
-	if (typeof value === "string") {
-		const escaped = JSON.stringify(value).slice(1, -1);
-		return quote === quotes.double ? `"${escaped}"` : `'${escaped.replaceAll(`\\"`, `"`).replaceAll(`'`, `\\'`)}'`;
-	}
-	if (value === null || typeof value !== "object") return String(value);
-	if (Array.isArray(value)) return `[${value.map((item) => printValue(item, quote)).join(", ")}]`;
-	const entries = Object.entries(value);
-	return entries.length ? `{ ${entries.map(([key, item]) => `${printKey(key, quote)}: ${printValue(item, quote)}`).join(", ")} }` : "{}";
-}
-/** An object key as source text: bare when it is an identifier, quoted otherwise. */
-function printKey(key, quote) {
-	return IDENTIFIER_PATTERN.test(key) ? key : printValue(key, quote);
-}
-/** `value` wrapped in one object per key of `path`: `wrapPath(['enum', 'type'], 'enum')` is `{ enum: { type: 'enum' } }`. */
-function wrapPath(path, value) {
-	return path.reduceRight((inner, key) => ({ [key]: inner }), value);
-}
-/**
-* Adds `text` as the last item of an object or array literal, following its layout: on a line of
-* its own with the last item's indentation when the literal spans lines, inline otherwise.
-*/
-function appendItem(source, container, text) {
-	const { start, end } = container;
-	const last = (container.type === nodeTypes.objectExpression ? container.properties : container.elements).filter((item) => item !== null).at(-1);
-	if (!last) {
-		const inner = source.slice(start + 1, end - 1);
-		if (inner.trim()) return replaceText(source, start + 1, start + 1, /^\s/.test(inner) ? `${text},` : `${text}, `);
-		return replaceText(source, start, end, container.type === nodeTypes.objectExpression ? `{ ${text} }` : `[${text}]`);
-	}
-	const between = source.slice(last.end, end - 1);
-	if (!between.includes("\n")) return replaceText(source, last.end, last.end, `, ${text}`);
-	const lineStart = source.lastIndexOf("\n", last.start - 1) + 1;
-	const indent = source.slice(lineStart).match(/^[ \t]*/)?.[0] ?? "";
-	const lineEnd = source.indexOf("\n", last.end);
-	const comma = /^\s*,/.test(between);
-	return `${source.slice(0, last.end)}${comma ? "" : ","}${source.slice(last.end, lineEnd)}\n${indent}${text}${comma ? "," : ""}${source.slice(lineEnd)}`;
-}
-/** Drops the item at `index` from an object or array literal, with its own lines when it sits on them alone. */
-function removeItem(source, node, index) {
-	const items = node.type === nodeTypes.objectExpression ? node.properties : node.elements.filter((element) => element !== null);
-	if (items.length === 1) return replaceText(source, node.start, node.end, node.type === nodeTypes.objectExpression ? "{}" : "[]");
-	const { start, end } = items[index];
-	const lineStart = source.lastIndexOf("\n", start - 1) + 1;
-	const nextNewline = source.indexOf("\n", end);
-	const lineEnd = nextNewline === -1 ? source.length : nextNewline;
-	if (!source.slice(lineStart, start).trim() && /^\s*,?\s*(\/\/.*)?$/.test(source.slice(end, lineEnd))) return replaceText(source, lineStart, Math.min(lineEnd + 1, source.length));
-	const next = items[index + 1];
-	return next ? replaceText(source, start, next.start) : replaceText(source, items[index - 1].end, end);
-}
-//#endregion
-//#region ../../internals/shared/src/configFile/configFile.ts
-/** The marker `disable-plugin` writes, with the block's line count so `enable-plugin` restores exactly those lines. */
-const DISABLED_MARKER_PATTERN = /^kubb:disabled (.+)\s+(\d+)$/;
-const OPERATIONS = new Set(Object.values(ConfigEditOperation));
-const OPTION_OPERATIONS = /* @__PURE__ */ new Set([ConfigEditOperation.SET_OPTION, ConfigEditOperation.REMOVE_OPTION]);
-const OUTPUT_OPERATIONS = /* @__PURE__ */ new Set([ConfigEditOperation.SET_OUTPUT, ConfigEditOperation.REMOVE_OUTPUT]);
-const KINDS = new Set(Object.values(extensionKinds));
-/** Identifiers the editor matches by name. */
-const identifiers = {
-	defineConfig: "defineConfig",
-	require: "require",
-	module: "module",
-	exports: "exports"
-};
-const moduleKinds = {
-	esm: "esm",
-	cjs: "cjs"
+// src/index.ts
+/** The subcommands besides `generate`, imported only when the run needs them, so `kubb generate` never loads their code. */
+const commandLoaders = {
+	init: () => import("./run-CCsdLz3X.js"),
+	validate: () => import("./validate-8ZcWXfMt.js"),
+	mcp: () => import("./mcp-CxeZR5vb.js"),
+	studio: () => import("./studio-mw6HaPkr.js"),
+	add: () => import("./run-D-nn9-Wq.js"),
+	update: () => import("./run-RN_31Q4u.js"),
+	remove: () => import("./run-BrM7-NSV.js"),
+	list: () => import("./run-1H9TGT8v.js")
 };
-function isNonEmptyString(value) {
-	return typeof value === "string" && value !== "";
-}
-/** Edits cross the wire, so their shape is checked before anything reads them. */
-function validateEdit(edit) {
-	const { operation, plugin, config, path, kind, input } = typeof edit === "object" && edit !== null ? edit : {};
-	if (typeof operation !== "string" || !OPERATIONS.has(operation)) return `unknown operation ${JSON.stringify(operation)}`;
-	if (config !== void 0 && typeof config !== "string" && !Number.isSafeInteger(config)) return "config must name an entry or give its index";
-	if (operation === ConfigEditOperation.SET_INPUT) return typeof input === "string" && input.trim() !== "" ? void 0 : "the edit names no input";
-	const isOption = OPTION_OPERATIONS.has(operation);
-	const isOutput = OUTPUT_OPERATIONS.has(operation);
-	if (!isOutput && !isNonEmptyString(plugin)) return "the edit names no plugin";
-	if (kind !== void 0) {
-		if (typeof kind !== "string" || !KINDS.has(kind)) return `unknown kind ${JSON.stringify(kind)}`;
-		const takesKind = operation === ConfigEditOperation.ADD_PLUGIN || operation === ConfigEditOperation.REMOVE_EXTENSION;
-		if (takesKind && kind === extensionKinds.adapter) return `${operation} takes a plugin or a parser, since a config has one adapter`;
-		if (!isOption && !takesKind) return `${operation} edits the plugins array, so it takes no kind`;
-	}
-	if (!isOption && !isOutput) return void 0;
-	if (!Array.isArray(path) || !path.every(isNonEmptyString)) return "path must be a list of option names";
-	if (path.length === 0) return "no option path given";
-	const unsafe = path.find((key) => !isSafeKey(key));
-	if (unsafe !== void 0) return `${unsafe} cannot be used as an option name`;
-	if (isOutput && !isOutputKey(path[0])) return `output.${path[0]} can only be changed in the config file`;
-}
-/** Steps through `as`/`satisfies` and `() => ...` wrappers to the config object. */
-function unwrapValue(node) {
-	if (!node) return void 0;
-	if (node.type === nodeTypes.tSAsExpression || node.type === nodeTypes.tSSatisfiesExpression) return unwrapValue(node.expression);
-	if (node.type !== nodeTypes.arrowFunctionExpression && node.type !== nodeTypes.functionExpression) return node;
-	if (node.body?.type !== nodeTypes.blockStatement) return unwrapValue(node.body);
-	const returned = node.body.body.find((statement) => statement.type === nodeTypes.returnStatement);
-	return unwrapValue(returned?.type === nodeTypes.returnStatement ? returned.argument : void 0);
-}
-function isModuleExports(node) {
-	return node.type === nodeTypes.memberExpression && !node.computed && node.object.type === nodeTypes.identifier && node.object.name === identifiers.module && node.property.type === nodeTypes.identifier && node.property.name === identifiers.exports;
-}
-/** The exported config value and how the file exports it. */
-function findExport(program) {
-	for (const node of program.body) {
-		if (node.type === nodeTypes.exportDefaultDeclaration) return {
-			exported: node.declaration,
-			kind: moduleKinds.esm
-		};
-		if (node.type === nodeTypes.expressionStatement && node.expression.type === nodeTypes.assignmentExpression && isModuleExports(node.expression.left)) return {
-			exported: node.expression.right,
-			kind: moduleKinds.cjs
-		};
-	}
-	return {
-		exported: void 0,
-		kind: moduleKinds.esm
-	};
-}
-/** Every config object in `export default` or `module.exports = defineConfig(...)`, or why the file is unmanaged. */
-function findConfigs(source) {
-	const parsed = parseSource(source);
-	if ("reason" in parsed) return parsed;
-	const { exported, kind } = findExport(parsed.program);
-	const value = unwrapValue(exported);
-	if (!value) return { reason: "no `export default` or `module.exports` found" };
-	if (value.type !== nodeTypes.callExpression || value.callee.type !== nodeTypes.identifier || value.callee.name !== identifiers.defineConfig) return { reason: "the exported config is not a defineConfig(...) call" };
-	const argument = unwrapValue(value.arguments[0]);
-	if (!argument) return { reason: "defineConfig(...) was called without a config" };
-	const entries = argument.type === nodeTypes.arrayExpression ? argument.elements.map((element) => unwrapValue(element)) : [argument];
-	const configs = entries.filter((entry) => entry?.type === nodeTypes.objectExpression);
-	if (configs.length !== entries.length) return { reason: "config is not an object literal" };
-	return {
-		...parsed,
-		configs,
-		kind
-	};
-}
-function findConfigEntry(configs, ref) {
-	return typeof ref === "string" ? configs.find((entry) => getConfigName(entry) === ref) : configs[ref ?? 0];
-}
-function getKey(entry) {
-	if (entry.type !== nodeTypes.property || entry.computed) return void 0;
-	if (entry.key.type === nodeTypes.identifier) return entry.key.name;
-	return entry.key.type === nodeTypes.literal && typeof entry.key.value === "string" ? entry.key.value : void 0;
-}
-/** The last one wins when the key repeats, as at runtime. */
-function findProperty(node, key) {
-	const index = node.properties.findLastIndex((entry) => getKey(entry) === key);
-	return index === -1 ? void 0 : {
-		member: node.properties[index],
-		index
-	};
-}
-function getValue(node, key) {
-	const member = findProperty(node, key)?.member;
-	return member?.type === nodeTypes.property ? member.value : member;
-}
-function getConfigName(config) {
-	const name = getValue(config, "name");
-	return name?.type === nodeTypes.literal && typeof name.value === "string" ? name.value : void 0;
-}
-function isOverridden(node, index) {
-	return node.properties.slice(index + 1).some((entry) => entry.type === nodeTypes.spreadElement);
-}
-/** `key: value`, not a method, getter, setter, or `{ key }` shorthand. */
-function isPlainProperty(member) {
-	return !member.method && !member.shorthand && member.kind === propertyKinds.init;
-}
-/** A literal's value, `undefined` for code. */
-function readLiteral(node) {
-	switch (node?.type) {
-		case nodeTypes.literal: return "regex" in node || "bigint" in node ? void 0 : node.value;
-		case nodeTypes.templateLiteral: return node.expressions.length ? void 0 : node.quasis[0]?.value.cooked ?? "";
-		case nodeTypes.unaryExpression: {
-			const value = readLiteral(node.argument);
-			if (typeof value !== "number") return void 0;
-			if (node.operator === unaryOperators.minus) return -value;
-			if (node.operator === unaryOperators.plus) return value;
-			return;
-		}
-		case nodeTypes.arrayExpression: {
-			const values = node.elements.map((element) => readLiteral(element));
-			return values.every((value) => value !== void 0) ? values : void 0;
-		}
-		case nodeTypes.objectExpression: {
-			const entries = {};
-			for (const entry of node.properties) {
-				if (entry.type !== nodeTypes.property) return void 0;
-				const key = getKey(entry);
-				const value = readLiteral(entry.value);
-				if (key === void 0 || !isSafeKey(key) || value === void 0) return void 0;
-				entries[key] = value;
-			}
-			return entries;
-		}
-	}
-}
-function getRequirePath(node) {
-	if (node?.type !== nodeTypes.callExpression || node.callee.type !== nodeTypes.identifier || node.callee.name !== identifiers.require) return void 0;
-	const [argument] = node.arguments;
-	return argument?.type === nodeTypes.literal && typeof argument.value === "string" ? argument.value : void 0;
-}
-/** `import { exported as local } from '...'`. A default or namespace import has no exported name, so its local name stands in. */
-function importBindings(statement) {
-	return statement.specifiers.map((specifier) => {
-		const imported = specifier.type === nodeTypes.importSpecifier ? specifier.imported : specifier.local;
-		const exported = imported.type === nodeTypes.identifier ? imported.name : imported.value;
-		return [specifier.local.name, {
-			from: statement.source.value,
-			exported
-		}];
-	});
-}
-/** `const { exported: local } = require('...')`. */
-function requireBindings(statement) {
-	return statement.declarations.flatMap((declarator) => {
-		const from = getRequirePath(declarator.init);
-		if (from === void 0 || declarator.id.type !== nodeTypes.objectPattern) return [];
-		return declarator.id.properties.flatMap((entry) => {
-			if (entry.type !== nodeTypes.property || entry.value.type !== nodeTypes.identifier) return [];
-			return [[entry.value.name, {
-				from,
-				exported: getKey(entry) ?? entry.value.name
-			}]];
-		});
-	});
-}
-function getImports(program) {
-	return new Map(program.body.flatMap((statement) => {
-		if (statement.type === nodeTypes.importDeclaration) return importBindings(statement);
-		if (statement.type === nodeTypes.variableDeclaration) return requireBindings(statement);
-		return [];
-	}));
-}
-function isImportStatement(node, kind) {
-	if (kind === moduleKinds.esm) return node.type === nodeTypes.importDeclaration;
-	return node.type === nodeTypes.variableDeclaration && node.declarations.some((declarator) => getRequirePath(declarator.init) !== void 0);
-}
-/** The quote of the first string literal in the file, so new code matches it. */
-function detectQuote(node) {
-	if (!node || typeof node !== "object") return void 0;
-	const { type, raw } = node;
-	if (type === nodeTypes.literal && typeof raw === "string" && (raw[0] === quotes.single || raw[0] === quotes.double)) return raw[0];
-	for (const child of Object.values(node)) {
-		const quote = detectQuote(child);
-		if (quote) return quote;
-	}
-}
-/** The `adapter` value, or the elements of the `plugins` or `parsers` array. */
-function factoryNodes(config, kind) {
-	if (kind === extensionKinds.adapter) return [getValue(config, "adapter")];
-	const array = getValue(config, `${kind}s`);
-	return array?.type === nodeTypes.arrayExpression ? array.elements : [];
-}
-/** The factory calls of one kind whose callee the file imports. */
-function findCalls(program, config, kind = extensionKinds.plugin) {
-	const imports = getImports(program);
-	return factoryNodes(config, kind).flatMap((node) => {
-		if (node?.type !== nodeTypes.callExpression || node.callee.type !== nodeTypes.identifier) return [];
-		const imported = imports.get(node.callee.name);
-		return imported ? [{
-			importName: node.callee.name,
-			exportName: imported.exported,
-			packageName: imported.from,
-			call: node
-		}] : [];
-	});
-}
-/** Whether nothing but whitespace precedes `offset` on its line. */
-function startsLine(source, offset) {
-	return source.slice(source.lastIndexOf("\n", offset - 1) + 1, offset).trim() === "";
-}
-/** The `disable-plugin` blocks in this config, read from marker comments since the call is no longer a node. */
-function findDisabled(source, comments, config) {
-	const lines = source.split("\n");
-	return comments.flatMap((comment) => {
-		const match = comment.type === commentTypes.line ? comment.value.trim().match(DISABLED_MARKER_PATTERN) : null;
-		if (!match || comment.start < config.start || comment.end > config.end || !startsLine(source, comment.start)) return [];
-		const line = getPosition(source, comment.start).line;
-		const end = line + Number(match[2]);
-		const code = lines.slice(line, end).map((text) => text.replace(/^(\s*)\/\/ ?/, "$1").replace(/^\s+$/, ""));
-		return [{
-			packageName: match[1],
-			line,
-			end,
-			code
-		}];
-	});
-}
-/** Literal members as `value` and code paths as `locked`, `undefined` for a computed key. */
-function readEditable(node, prefix = []) {
-	const value = {};
-	const locked = [];
-	for (const [index, entry] of node.properties.entries()) {
-		if (entry.type === nodeTypes.spreadElement) continue;
-		const key = getKey(entry);
-		if (key === void 0) return void 0;
-		if (findProperty(node, key)?.index !== index) continue;
-		const path = [...prefix, key];
-		if (!isSafeKey(key)) {
-			locked.push(path);
-			continue;
-		}
-		const member = isOverridden(node, index) ? void 0 : entry.value;
-		const literal = readLiteral(member);
-		if (literal !== void 0) {
-			value[key] = literal;
-			continue;
-		}
-		if (member?.type !== nodeTypes.objectExpression) {
-			locked.push(path);
-			continue;
-		}
-		const nested = readEditable(member, path);
-		if (!nested) return void 0;
-		value[key] = nested.value;
-		locked.push(...nested.locked);
-	}
-	return {
-		value,
-		locked
-	};
-}
-function readObjectOptions(options) {
-	const entries = {};
-	for (const [index, entry] of options.properties.entries()) {
-		const key = getKey(entry);
-		if (key === void 0 || !isSafeKey(key)) continue;
-		const member = entry.type === nodeTypes.property && !isOverridden(options, index) ? entry.value : void 0;
-		const value = readLiteral(member);
-		if (value !== void 0) {
-			entries[key] = {
-				literal: true,
-				value
-			};
-			continue;
-		}
-		entries[key] = {
-			literal: false,
-			...member?.type === nodeTypes.objectExpression ? readEditable(member) : void 0
-		};
-	}
-	return entries;
-}
-function readCallOptions(call) {
-	const options = call.arguments[0];
-	return options?.type === nodeTypes.objectExpression ? readObjectOptions(options) : {};
-}
-function readDisabledOptions(code) {
-	const call = parseExpression(code.join("\n").trim().replace(/,$/, ""));
-	return call?.type === nodeTypes.callExpression ? readCallOptions(call) : {};
-}
-function toPluginView({ importName, packageName, call }) {
-	return {
-		importName,
-		packageName,
-		options: readCallOptions(call)
-	};
-}
-/** Active and disabled plugins, in source order so a disabled plugin keeps its place. */
-function readPlugins({ source, parsed, config }) {
-	const importNames = new Map([...getImports(parsed.program)].map(([local, { from }]) => [from, local]));
-	const active = findCalls(parsed.program, config).map((call) => ({
-		line: getPosition(source, call.call.start).line,
-		plugin: toPluginView(call)
-	}));
-	const disabled = findDisabled(source, parsed.comments, config).map(({ packageName, line, code }) => ({
-		line,
-		plugin: {
-			importName: importNames.get(packageName) ?? toExportName(packageName),
-			packageName,
-			options: readDisabledOptions(code),
-			disabled: true
-		}
-	}));
-	return [...active, ...disabled].sort((a, b) => a.line - b.line).map(({ plugin }) => plugin);
-}
-function readConfigView({ source, parsed, config }) {
-	const [adapter] = findCalls(parsed.program, config, extensionKinds.adapter).map(toPluginView);
-	const parsers = findCalls(parsed.program, config, extensionKinds.parser).map(toPluginView);
-	const output = getOutput(config);
-	return {
-		name: getConfigName(config),
-		plugins: readPlugins({
-			source,
-			parsed,
-			config
-		}),
-		...adapter && { adapter },
-		...parsers.length ? { parsers } : {},
-		...!("reason" in output) && { output: pickOutput(readObjectOptions(output.object)) }
-	};
-}
-/** Which plugins the file declares and which options Studio may write. */
-function readConfig(source) {
-	const parsed = findConfigs(source);
-	if ("reason" in parsed) return {
-		managed: false,
-		reason: parsed.reason
-	};
-	return {
-		managed: true,
-		configs: parsed.configs.map((config) => readConfigView({
-			source,
-			parsed,
-			config
-		}))
-	};
-}
-/** The modules the file imports, empty when it cannot be parsed. */
-function readImports(source) {
-	const parsed = parseSource(source);
-	if ("reason" in parsed) return [];
-	return [...new Set([...getImports(parsed.program).values()].map(({ from }) => from))];
-}
-/** Follows `path` to its literal, or to the first missing key. Refuses a value set in code. */
-function findPath(options, path) {
-	let object = options;
-	for (const [depth, key] of path.entries()) {
-		const found = findProperty(object, key);
-		if (!found) return {
-			object,
-			missing: depth
-		};
-		if (isOverridden(object, found.index)) return { reason: `${path.slice(0, depth + 1).join(".")} can be overridden by a spread after it, so it is customized in code` };
-		const { member, index } = found;
-		if (depth === path.length - 1) return member.type === nodeTypes.property && readLiteral(member.value) !== void 0 ? {
-			object,
-			index,
-			value: member.value
-		} : { reason: `${path.join(".")} is customized in code` };
-		if (member.type !== nodeTypes.property || member.value.type !== nodeTypes.objectExpression) return { reason: `${key} is not an object, so ${path.join(".")} cannot be reached` };
-		object = member.value;
-	}
-	return { reason: "no option path given" };
-}
-function setAtPath({ source, options, path, value, quote }) {
-	const target = findPath(options, path);
-	if ("reason" in target) return target;
-	if ("missing" in target) {
-		const [key, ...rest] = path.slice(target.missing);
-		return { source: appendItem(source, target.object, `${printKey(key, quote)}: ${printValue(wrapPath(rest, value), quote)}`) };
-	}
-	return { source: replaceText(source, target.value.start, target.value.end, printValue(value, quote)) };
-}
-function removeAtPath({ source, options, path }) {
-	const target = findPath(options, path);
-	if ("reason" in target) return target;
-	if ("missing" in target) return { source };
-	return { source: removeItem(source, target.object, target.index) };
-}
-function setOption(source, call, path, value, quote) {
-	if (!isOptionValue(value)) return { reason: "the value is not a literal that can be written to a config file" };
-	const options = call.arguments[0];
-	if (!options) {
-		const closing = call.end - 1;
-		if (source[closing] !== ")") return { reason: "the factory call could not be located in the file" };
-		return { source: replaceText(source, closing, closing, printValue(wrapPath(path, value), quote)) };
-	}
-	if (options.type !== nodeTypes.objectExpression) return { reason: "the factory was not called with an object literal" };
-	return setAtPath({
-		source,
-		options,
-		path,
-		value,
-		quote
-	});
-}
-function removeOption(source, call, path) {
-	const options = call.arguments[0];
-	if (!options) return { source };
-	if (options.type !== nodeTypes.objectExpression) return { reason: "the factory was not called with an object literal" };
-	return removeAtPath({
-		source,
-		options,
-		path
-	});
-}
-function editOption({ source, parsed, config, edit, quote, extensions }) {
-	const kind = edit.kind ?? extensionKinds.plugin;
-	const calls = findCalls(parsed.program, config, kind).filter((entry) => entry.packageName === edit.plugin);
-	const exportName = extensions.get(edit.plugin)?.manifest.export ?? toExportName(edit.plugin);
-	const call = (calls.find((entry) => entry.exportName === exportName) ?? calls[0])?.call;
-	if (!call) {
-		if (kind === extensionKinds.adapter) return { reason: `${edit.plugin} is not the config's adapter` };
-		return { reason: kind === extensionKinds.plugin && findDisabled(source, parsed.comments, config).some((block) => block.packageName === edit.plugin) ? `${edit.plugin} is disabled, enable it first` : `${edit.plugin} is not in the ${kind}s array` };
-	}
-	if (edit.operation === ConfigEditOperation.SET_OPTION) return setOption(source, call, edit.path, edit.value, quote);
-	return removeOption(source, call, edit.path);
-}
-function setInput(source, config, input, quote) {
-	const value = printValue(input, quote);
-	const found = findProperty(config, "input");
-	if (!found) return { source: appendItem(source, config, `input: ${value}`) };
-	if (found.member.type !== nodeTypes.property || !isPlainProperty(found.member)) return { reason: "input is not a plain property" };
-	if (isOverridden(config, found.index)) return { reason: "a spread after input could override it" };
-	return { source: replaceText(source, found.member.value.start, found.member.value.end, value) };
-}
-function getOutput(config) {
-	const found = findProperty(config, "output");
-	if (found?.member.type !== nodeTypes.property || found.member.value.type !== nodeTypes.objectExpression) return { reason: "output is not an object literal" };
-	if (isOverridden(config, found.index)) return { reason: "a spread after output could override it" };
-	return { object: found.member.value };
-}
-function editOutput({ source, config, edit, quote }) {
-	const output = getOutput(config);
-	if ("reason" in output) return output;
-	if (edit.operation === ConfigEditOperation.REMOVE_OUTPUT) return removeAtPath({
-		source,
-		options: output.object,
-		path: edit.path
-	});
-	const [key, ...rest] = edit.path;
-	if (!isOptionValue(edit.value) || !isOutputValue({
-		key,
-		value: wrapPath(rest, edit.value)
-	})) return { reason: `the value is not one output.${key} takes` };
-	return setAtPath({
-		source,
-		options: output.object,
-		path: edit.path,
-		value: edit.value,
-		quote
-	});
-}
-/** Adds the import after the last one, matching its semicolon style. */
-function addImport({ source, parsed, importNames, moduleSpecifier, quote }) {
-	const lastImport = parsed.program.body.findLast((node) => isImportStatement(node, parsed.kind));
-	const afterLine = lastImport ? getPosition(source, lastImport.end).line : 0;
-	const lines = source.split("\n");
-	const semicolon = afterLine > 0 && lines[afterLine - 1]?.trimEnd().endsWith(";") ? ";" : "";
-	const specifier = `${quote}${moduleSpecifier}${quote}`;
-	const statement = parsed.kind === moduleKinds.esm ? `import { ${importNames.join(", ")} } from ${specifier}` : `const { ${importNames.join(", ")} } = require(${specifier})`;
-	lines.splice(afterLine, 0, `${statement}${semicolon}`);
-	if (afterLine === 0) lines.splice(1, 0, "");
-	return lines.join("\n");
-}
-/**
-* The parsers `defineConfig` applies when a config sets no `parsers`, by import name. Adding a parser
-* to such a config writes these too, or the new array would replace them.
-*/
-const DEFAULT_PARSERS = [
-	{
-		importName: "parserTs",
-		packageName: "@kubb/parser-ts"
-	},
-	{
-		importName: "parserTsx",
-		packageName: "@kubb/parser-ts"
-	},
-	{
-		importName: "parserMd",
-		packageName: "@kubb/parser-md"
-	}
-];
-/**
-* Adds a plugin to `plugins`, or with `kind: 'parser'` a parser to `parsers`. Replaying the same add
-* is a no-op, while an import name taken by another package is an error.
-*/
-function addPlugin({ source, parsed, config, edit, quote, extensions }) {
-	const kind = edit.kind ?? extensionKinds.plugin;
-	const isParser = kind === extensionKinds.parser;
-	if (!isAllowedPlugin({
-		packageName: edit.plugin,
-		extensions,
-		kind
-	})) return { reason: isParser ? `"${edit.plugin}" is not an installed Kubb parser` : `"${edit.plugin}" is not a @kubb/plugin-* package or an installed Kubb plugin` };
-	const importName = extensions.get(edit.plugin)?.manifest.export ?? toExportName(edit.plugin);
-	if (!IDENTIFIER_PATTERN.test(importName)) return { reason: `"${importName}" is not a valid import name` };
-	if (findCalls(parsed.program, config, kind).some((entry) => entry.packageName === edit.plugin && (!isParser || entry.exportName === importName))) return { source };
-	const options = edit.options ?? {};
-	if (!isOptionValue(options)) return { reason: "the options are not literals that can be written to a config file" };
-	const key = `${kind}s`;
-	const array = getValue(config, key);
-	if (array ? array.type !== nodeTypes.arrayExpression : !isParser) return { reason: `${key} is not an array literal` };
-	const defaults = isParser && !array ? DEFAULT_PARSERS.filter((parser) => parser.importName !== importName) : [];
-	const imports = getImports(parsed.program);
-	const missing = /* @__PURE__ */ new Map();
-	for (const item of [...defaults, {
-		importName,
-		packageName: edit.plugin
-	}]) {
-		const from = imports.get(item.importName)?.from;
-		if (from && from !== item.packageName) return { reason: `${item.importName} is already imported from ${from}` };
-		if (!from) missing.set(item.packageName, [...missing.get(item.packageName) ?? [], item.importName]);
-	}
-	const call = `${importName}(${Object.keys(options).length ? printValue(options, quote) : ""})`;
-	const next = array?.type === nodeTypes.arrayExpression ? appendItem(source, array, call) : appendItem(source, config, `parsers: [${[...defaults.map((parser) => `${parser.importName}()`), call].join(", ")}]`);
-	return { source: [...missing].reduceRight((current, [moduleSpecifier, importNames]) => addImport({
-		source: current,
-		parsed,
-		importNames,
-		moduleSpecifier,
-		quote
-	}), next) };
-}
-/** One item per line, so a call can be commented out alone. Skipped when comments sit between items. */
-function splitPlugins(source, config) {
-	const array = getValue(config, "plugins");
-	if (array?.type !== nodeTypes.arrayExpression) return void 0;
-	const items = array.elements.flatMap((element) => element ? [element] : []);
-	const { start, end } = array;
-	const gaps = [source.slice(start + 1, items[0]?.start ?? end - 1), ...items.map((item, index) => source.slice(item.end, items[index + 1]?.start ?? end - 1))];
-	if (!items.length || gaps.some((gap) => !/^[\s,]*$/.test(gap))) return void 0;
-	const lineStart = source.lastIndexOf("\n", start - 1) + 1;
-	const indent = source.slice(lineStart).match(/^[ \t]*/)?.[0] ?? "";
-	return replaceText(source, start, end, `[\n${items.map((item) => `${indent}  ${source.slice(item.start, item.end)},`).join("\n")}\n${indent}]`);
-}
-function disablePlugin(source, program, config, plugin) {
-	const call = findCalls(program, config).find((entry) => entry.packageName === plugin)?.call;
-	if (!call) return { reason: `${plugin} is not in the plugins array` };
-	const start = getPosition(source, call.start);
-	const end = getPosition(source, call.end);
-	const lines = source.split("\n");
-	const from = start.line - 1;
-	const to = end.line - 1;
-	const firstLine = lines[from] ?? "";
-	if (firstLine.slice(0, start.column).trim() || !/^,?\s*$/.test((lines[to] ?? "").slice(end.column))) return { reason: `${plugin} shares a line with other code, so it cannot be commented out safely` };
-	const indent = firstLine.match(/^\s*/)?.[0] ?? "";
-	const commented = lines.slice(from, to + 1).map((line) => line.trim() ? `${indent}// ${line.slice(indent.length)}` : `${indent}//`);
-	lines.splice(from, commented.length, `${indent}// kubb:disabled ${plugin} ${commented.length}`, ...commented);
-	return { source: lines.join("\n") };
-}
-/** Disables the plugin, first putting a one-line `plugins: [a(), b()]` (what `add-plugin` writes) on separate lines. */
-function disablePluginInConfig({ source, parsed, config, edit }) {
-	const result = disablePlugin(source, parsed.program, config, edit.plugin);
-	if (!("reason" in result) || !result.reason.includes("shares a line")) return result;
-	const split = splitPlugins(source, config);
-	if (split === void 0) return result;
-	const reparsed = findConfigs(split);
-	const reparsedConfig = "reason" in reparsed ? void 0 : findConfigEntry(reparsed.configs, edit.config);
-	if ("reason" in reparsed || !reparsedConfig) return result;
-	return disablePlugin(split, reparsed.program, reparsedConfig, edit.plugin);
-}
-function enablePlugin(source, comments, config, plugin) {
-	const block = findDisabled(source, comments, config).find((entry) => entry.packageName === plugin);
-	if (!block) return { reason: `${plugin} is not disabled` };
-	const lines = source.split("\n");
-	lines.splice(block.line - 1, block.end - block.line + 1, ...block.code);
-	return { source: lines.join("\n") };
-}
-/** Drops the import statements of `packageName` once nothing else in the file uses their names. */
-function removeUnusedImports(source, packageName) {
-	const parsed = parseSource(source);
-	if ("reason" in parsed) return source;
-	return parsed.program.body.reduceRight((current, statement) => {
-		const bindings = statement.type === nodeTypes.importDeclaration ? importBindings(statement) : statement.type === nodeTypes.variableDeclaration ? requireBindings(statement) : [];
-		if (!bindings.length || bindings.some(([, { from }]) => from !== packageName)) return current;
-		const rest = replaceText(current, statement.start, statement.end);
-		if (bindings.some(([local]) => new RegExp(`(?<![\\w$])${local.replaceAll("$", "\\$")}(?![\\w$])`).test(rest))) return current;
-		const lineStart = current.lastIndexOf("\n", statement.start - 1) + 1;
-		const lineEnd = current.indexOf("\n", statement.end);
-		const after = lineEnd === -1 ? current.length : lineEnd + 1;
-		return replaceText(current, lineStart, lineStart === 0 && current[after] === "\n" ? after + 1 : after);
-	}, source);
-}
-/**
-* Removes every call of a plugin or parser package, and the block `disable-plugin` commented out,
-* then its unused imports. Removing what the config does not hold is a no-op. Refuses to empty
-* `parsers`, since a config with no parser cannot print files.
-*/
-function removeExtension(source, edit) {
-	const kind = edit.kind ?? extensionKinds.plugin;
-	let current = source;
-	for (;;) {
-		const parsed = findConfigs(current);
-		if ("reason" in parsed) return parsed;
-		const config = findConfigEntry(parsed.configs, edit.config);
-		if (!config) return { reason: `no config entry found for ${JSON.stringify(edit.config)}` };
-		const array = getValue(config, `${kind}s`);
-		const calls = findCalls(parsed.program, config, kind).filter((entry) => entry.packageName === edit.plugin);
-		const block = findDisabled(current, parsed.comments, config).find((entry) => entry.packageName === edit.plugin);
-		if (calls[0] && array?.type === nodeTypes.arrayExpression) {
-			const elements = array.elements.filter((element) => element !== null);
-			if (kind === extensionKinds.parser && elements.length === calls.length) return { reason: `${edit.plugin} is the last parser in the parsers array` };
-			current = removeItem(current, array, elements.indexOf(calls[0].call));
-			continue;
-		}
-		if (block && kind === extensionKinds.plugin) {
-			const lines = current.split("\n");
-			lines.splice(block.line - 1, block.end - block.line + 1);
-			current = lines.join("\n");
-			continue;
-		}
-		return { source: current === source ? source : removeUnusedImports(current, edit.plugin) };
-	}
-}
-/** Every edit re-parses the file, since the previous one rewrote it. */
-function applyEdit({ source, edit, extensions }) {
-	const parsed = findConfigs(source);
-	if ("reason" in parsed) return parsed;
-	const config = findConfigEntry(parsed.configs, edit.config);
-	if (!config) return { reason: `no config entry found for ${JSON.stringify(edit.config)}` };
-	const quote = detectQuote(parsed.program) ?? quotes.single;
-	switch (edit.operation) {
-		case ConfigEditOperation.SET_INPUT: return setInput(source, config, edit.input, quote);
-		case ConfigEditOperation.SET_OUTPUT:
-		case ConfigEditOperation.REMOVE_OUTPUT: return editOutput({
-			source,
-			config,
-			edit,
-			quote
-		});
-		case ConfigEditOperation.DISABLE_PLUGIN: return disablePluginInConfig({
-			source,
-			parsed,
-			config,
-			edit
-		});
-		case ConfigEditOperation.ENABLE_PLUGIN: return enablePlugin(source, parsed.comments, config, edit.plugin);
-		case ConfigEditOperation.ADD_PLUGIN: return addPlugin({
-			source,
-			parsed,
-			config,
-			edit,
-			quote,
-			extensions
-		});
-		case ConfigEditOperation.REMOVE_EXTENSION: return removeExtension(source, edit);
-		case ConfigEditOperation.SET_OPTION:
-		case ConfigEditOperation.REMOVE_OPTION: return editOption({
-			source,
-			parsed,
-			config,
-			edit,
-			quote,
-			extensions
-		});
-	}
-}
-/** Applies edits in place, touching only the text each targets. A refused edit is reported and the rest still run. */
-function editConfig({ source, edits, extensions = /* @__PURE__ */ new Map() }) {
-	let current = source;
-	const outcomes = edits.map((edit) => {
-		const invalid = validateEdit(edit);
-		if (invalid) return {
-			edit,
-			applied: false,
-			reason: invalid
-		};
-		try {
-			const result = applyEdit({
-				source: current,
-				edit,
-				extensions
-			});
-			if ("reason" in result) return {
-				edit,
-				applied: false,
-				reason: result.reason
-			};
-			current = result.source;
-			return {
-				edit,
-				applied: true
-			};
-		} catch (error) {
-			return {
-				edit,
-				applied: false,
-				reason: getErrorMessage(error)
-			};
-		}
-	});
-	return {
-		source: current,
-		outcomes,
-		changed: current !== source
-	};
-}
-/** Applies `edits` to `filePath`, writing only when something changed. */
-async function editConfigFile({ filePath, edits, extensions }) {
-	const result = editConfig({
-		source: await read(filePath),
-		edits,
-		extensions
-	});
-	if (result.changed) await writeRaw(filePath, result.source);
-	return result;
-}
-//#endregion
-//#region src/runners/init/utils.ts
-/** Metadata for each supported package manager, keyed by its short name. */
-const packageManagers = {
-	pnpm: {
-		name: "pnpm",
-		lockFiles: ["pnpm-lock.yaml"],
-		initCommand: ["init"],
-		installCommand: ["add", "-D"],
-		removeCommand: ["remove"],
-		runCommand: []
-	},
-	yarn: {
-		name: "yarn",
-		lockFiles: ["yarn.lock"],
-		initCommand: ["init", "-y"],
-		installCommand: ["add", "-D"],
-		removeCommand: ["remove"],
-		runCommand: []
-	},
-	bun: {
-		name: "bun",
-		lockFiles: ["bun.lock", "bun.lockb"],
-		initCommand: ["init", "-y"],
-		installCommand: ["add", "-d"],
-		removeCommand: ["remove"],
-		runCommand: ["run"]
-	},
-	npm: {
-		name: "npm",
-		lockFiles: ["package-lock.json"],
-		initCommand: ["init", "-y"],
-		installCommand: ["install", "--save-dev"],
-		removeCommand: ["uninstall"],
-		runCommand: ["run"]
-	}
-};
-/** Detects the package manager for `cwd`: the `packageManager` field in `package.json`, then a lock file, then `npm`. */
-function detectPackageManager(cwd = process$1.cwd()) {
-	const packageJsonPath = path.join(cwd, "package.json");
-	if (fs.existsSync(packageJsonPath)) try {
-		const pmField = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")).packageManager;
-		if (typeof pmField === "string") {
-			const name = pmField.split("@")[0];
-			if (name && name in packageManagers) return packageManagers[name];
-		}
-	} catch {}
-	for (const pm of Object.values(packageManagers)) if (pm.lockFiles.some((lockFile) => fs.existsSync(path.join(cwd, lockFile)))) return pm;
-	return packageManagers.npm;
-}
-/**
-* Initializes a new `package.json` at `cwd` using the detected package manager.
-*/
-async function initPackageJson(cwd, packageManager) {
-	await x(packageManager.name, [...packageManager.initCommand], {
-		nodeOptions: {
-			cwd,
-			stdio: "inherit"
-		},
-		throwOnError: true
-	});
-}
-const INSTALL_TIMEOUT_MS = 3e5;
-/**
-* Installs the given packages at `cwd` using the detected package manager. Each output line goes
-* to `onLine`, so the caller can show it while the install runs; a failed install also keeps the
-* end of the output in the error.
-*/
-async function installPackages(packages, packageManager, cwd = process$1.cwd(), onLine, command = packageManager.installCommand) {
-	const args = [...command, ...packages];
-	const result = x(packageManager.name, args, {
-		nodeOptions: {
-			cwd,
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			]
-		},
-		timeout: INSTALL_TIMEOUT_MS,
-		throwOnError: false
-	});
-	const lines = [];
-	for await (const line of result) {
-		lines.push(line);
-		onLine?.(line);
-	}
-	if (result.exitCode === 0) return;
-	if (result.exitCode === void 0) throw new Error(`\`${packageManager.name} ${args.join(" ")}\` timed out after ${INSTALL_TIMEOUT_MS / 6e4} minutes`);
-	const output = lines.slice(-20).join("\n");
-	throw new Error(`\`${packageManager.name} ${args.join(" ")}\` failed with exit code ${result.exitCode}${output ? `:\n${output}` : ""}`);
-}
-/**
-* Uninstalls the given packages at `cwd` with the package manager's remove command, like {@link installPackages}.
-*/
-function uninstallPackages(packages, packageManager, cwd = process$1.cwd()) {
-	return installPackages(packages, packageManager, cwd, void 0, packageManager.removeCommand);
-}
-/**
-* What the selected plugins' `manifests` say is missing from the selection: a `dependencies`
-* entry, or a `client` plugin next to a `consumer`. Empty when nothing is missing.
-* `optionalDependencies` are skipped, since `kubb init` writes the default options.
-*/
-function missingPluginDependencies(manifests) {
-	const selected = manifests.map((manifest) => manifest.name);
-	const hasClient = manifests.some((manifest) => manifest.role === "client");
-	return manifests.flatMap((manifest) => [...(manifest.dependencies ?? []).filter((name) => !selected.includes(name)).map((name) => `${manifest.name} needs ${name}.`), ...manifest.role === "consumer" && !hasClient ? [`${manifest.name} needs a client plugin, such as plugin-axios or plugin-fetch.`] : []]);
-}
-async function readPackageJson(cwd) {
-	try {
-		return JSON.parse(await read(path.join(cwd, "package.json")));
-	} catch {
-		return {};
-	}
-}
-const SPEC_FILE = /^(openapi|swagger)[\w.-]*\.(ya?ml|json)$/i;
-const SKIPPED_DIRS = /* @__PURE__ */ new Set([
-	"node_modules",
-	"dist",
-	"build",
-	"coverage"
-]);
-/**
-* Finds OpenAPI spec files up to `depth` folders below `cwd`, shallowest first, as `./`-relative
-* paths. Walks one level at a time and stops after `limit` files, so a large repo stays fast.
-*/
-async function findSpecFiles(cwd, { depth = 3, limit = 20 } = {}) {
-	const found = [];
-	let level = [""];
-	for (let current = 0; current <= depth && level.length && found.length < limit; current++) {
-		const listings = await Promise.all(level.map(async (dir) => ({
-			dir,
-			entries: await fs.promises.readdir(path.join(cwd, dir), { withFileTypes: true }).catch(() => [])
-		})));
-		level = [];
-		for (const { dir, entries } of listings) for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
-			if (entry.isFile() && SPEC_FILE.test(entry.name)) found.push(`./${path.posix.join(dir, entry.name)}`);
-			if (entry.isDirectory() && !entry.name.startsWith(".") && !SKIPPED_DIRS.has(entry.name)) level.push(path.posix.join(dir, entry.name));
-		}
-	}
-	return found.slice(0, limit);
-}
-const SPEC_HEAD_BYTES = 262144;
-const METHOD = "(?:get|put|post|delete|options|head|patch|trace)";
-/**
-* Reads the OpenAPI or Swagger version and counts the operations from the first 256 KB of the
-* file, so a large spec is never parsed. The count is left out when the file is longer.
-*/
-async function readSpecInfo(file) {
-	const handle = await fs.promises.open(file);
-	try {
-		const buffer = Buffer.alloc(SPEC_HEAD_BYTES);
-		const { bytesRead } = await handle.read(buffer, 0, SPEC_HEAD_BYTES, 0);
-		const head = buffer.toString("utf-8", 0, bytesRead);
-		const complete = bytesRead < SPEC_HEAD_BYTES;
-		const version = head.match(/^\s*["']?(?:openapi|swagger)["']?\s*:\s*["']?(\d[\d.]*)/m)?.[1];
-		const methods = new RegExp(`^\\s*["']?${METHOD}["']?\\s*:\\s*(?:\\{|$)`, "gm");
-		return {
-			version,
-			operations: complete ? head.match(methods)?.length ?? 0 : void 0
-		};
-	} finally {
-		await handle.close();
-	}
-}
-/** Finds a plugin by registry id, slug, or short name, so `ts`, `plugin-ts`, and `kubb-labs/plugin-ts` all match. */
-function findPlugin({ plugins, id }) {
-	const ids = id.includes("/") ? [id] : [`kubb-labs/${id}`, `kubb-labs/plugin-${id}`];
-	return plugins.find((entry) => ids.includes(entry.id));
-}
-/**
-* Turns the comma-separated `--plugins` value into registry entries.
-*
-* @throws when an id is not in `plugins`.
-*/
-function parsePluginsFlag({ plugins, value }) {
-	const ids = value.split(",").map((id) => id.trim()).filter(Boolean);
-	const unknown = ids.filter((id) => !findPlugin({
-		plugins,
-		id
-	}));
-	if (unknown.length) throw new Diagnostics.Error({
-		code: Diagnostics.code.pluginNotFound,
-		severity: "error",
-		message: `Not in the Kubb registry: ${unknown.join(", ")}. Browse the plugins at https://kubb.dev/extensions.`,
-		help: "Use plugin ids from https://kubb.dev/extensions, such as plugin-ts or ts."
-	});
-	return ids.map((id) => findPlugin({
-		plugins,
-		id
-	}));
-}
-/** Adds `"generate": "kubb generate"` to the `package.json` scripts at `cwd`. Returns `false`, and changes nothing, when a `generate` script exists. */
-async function addGenerateScript(cwd) {
-	const file = path.join(cwd, "package.json");
-	const source = await read(file);
-	const packageJson = JSON.parse(source);
-	if (packageJson.scripts?.generate !== void 0) return false;
-	const indent = source.match(/^[ \t]+/m)?.[0] ?? "  ";
-	const updated = {
-		...packageJson,
-		scripts: {
-			...packageJson.scripts,
-			generate: "kubb generate"
-		}
-	};
-	await write(file, JSON.stringify(updated, null, indent));
-	return true;
-}
-/** Reads the `generate` script from the `package.json` at `cwd`. */
-async function generateScript(cwd) {
-	return (await readPackageJson(cwd)).scripts?.generate;
-}
-//#endregion
-//#region src/runners/installWithSpinner.ts
-/** How many package manager lines stay visible under the install title while it runs. */
-const LOG_LINES = 6;
-/**
-* Installs `packages` and reports how long it took. A rich terminal shows the package manager's
-* last lines under the title while the install runs and clears them when it succeeds; a plain one
-* prints the start and end lines. A failed install keeps the output, reports the failure and rethrows.
-*/
-async function installWithSpinner({ packages, names, packageManager, cwd, install = installPackages }) {
-	const start = process$1.hrtime();
-	const task = createTask(`Installing ${names} with ${packageManager.name}`);
-	try {
-		await install(packages, packageManager, cwd, task.message);
-	} catch (error) {
-		task.error("Install failed");
-		throw error;
-	}
-	task.success(`Installed ${names} with ${packageManager.name} in ${formatMs(getElapsedMs(start))}`);
-}
-function createTask(title) {
-	if (isRichOutput()) {
-		const log = clack.taskLog({
-			title,
-			limit: LOG_LINES
-		});
-		return {
-			message: (line) => log.message(line),
-			error: (text) => log.error(text, { showLog: false }),
-			success: (text) => log.success(text)
-		};
-	}
-	const spinner = createSpinner();
-	spinner.start(title);
-	return {
-		message: () => {},
-		error: (text) => spinner.error(text),
-		success: (text) => spinner.stop(text)
-	};
-}
-//#endregion
-//#region src/runners/add/run.ts
-/** The import and the `defineConfig` property to merge into `kubb.config.ts` by hand. */
-function toSnippet({ artifact, manifest }) {
-	const call = `${manifest.export}()`;
-	const property = {
-		plugin: `plugins: [..., ${call}],`,
-		adapter: `adapter: ${call},`,
-		parser: `parsers: [..., ${call}],`
-	};
-	return [
-		`import { ${manifest.export} } from '${artifact.package}'`,
-		"",
-		property[manifest.kind]
-	].join("\n");
-}
-/** The `add-plugin` edits for `details`, and the manifests the edits read their export names from. */
-function toConfigEdits(details) {
-	return {
-		edits: details.map(({ artifact, manifest }) => ({
-			operation: ConfigEditOperation.ADD_PLUGIN,
-			...manifest.kind === extensionKinds.parser ? { kind: extensionKinds.parser } : {},
-			plugin: artifact.package
-		})),
-		extensions: new Map(details.map(({ artifact, manifest }) => [artifact.package, {
-			package: artifact.package,
-			version: artifact.version,
-			manifest
-		}]))
-	};
-}
-/** The lines adding `details` would put in the config `source`, trimmed, or why it could not add them. */
-function previewConfig({ details, source }) {
-	const result = editConfig({
-		source,
-		...toConfigEdits(details)
-	});
-	const failed = result.outcomes.find((outcome) => !outcome.applied);
-	if (failed) return { reason: failed.reason ?? "the config file was not changed" };
-	const remaining = source.split("\n");
-	return {
-		lines: result.source.split("\n").filter((line) => {
-			const index = remaining.indexOf(line);
-			if (index !== -1) remaining.splice(index, 1);
-			return index === -1;
-		}).map((line) => line.trim()),
-		source: result.source
-	};
-}
-async function selectExtension({ entries, versions, registry }) {
-	if (!entries.length) throw new Diagnostics.Error({
-		code: Diagnostics.code.unknown,
-		severity: "error",
-		message: `The registry at ${registry} lists no extensions.`,
-		help: "Check that `KUBB_REGISTRY` points at a Kubb registry, or unset it to use https://kubb.dev/registry."
-	});
-	const searchText = new Map(entries.map((entry) => [entry.id, `${entry.id} ${entry.manifest.displayName} ${entry.manifest.description}`.toLowerCase()]));
-	const options = entries.toSorted((a, b) => a.id.localeCompare(b.id)).map((entry) => {
-		const installed = versions.has(entry.artifact.package);
-		return {
-			value: entry.id,
-			label: toShortId(entry.id),
-			hint: installed ? "installed" : summarize(entry.manifest.description),
-			disabled: installed
-		};
-	});
-	const id = await clack.autocomplete({
-		message: `Add an extension · ${entries.length} in the registry`,
-		placeholder: "Search",
-		options,
-		filter: (search, option) => searchText.get(option.value)?.includes(search.toLowerCase()) ?? false
-	});
-	return clack.isCancel(id) ? void 0 : id;
-}
-/** Asks whether to also add the required plugins the config lacks. `--yes` adds them. */
-async function confirmDependencies({ entry, missing, yes }) {
-	if (!missing.length || yes) return true;
-	const names = missing.map((dependency) => dependency.manifest.name).join(", ");
-	const answer = await clack.select({
-		message: `${entry.manifest.name} needs ${names}. Add ${names} as well?`,
-		options: [{
-			value: true,
-			label: `Yes, add ${missing.length === 1 ? "both" : "all"}`,
-			hint: "recommended"
-		}, {
-			value: false,
-			label: `Only ${entry.manifest.name}`,
-			hint: "generate fails until you add it"
-		}],
-		initialValue: true
-	});
-	return clack.isCancel(answer) ? void 0 : answer;
-}
-/** The first sentence of a registry description, cut to one terminal line. */
-function summarize(description, max = 64) {
-	const sentence = description.split(/\.\s/)[0].replace(/\.$/, "");
-	return sentence.length > max ? `${sentence.slice(0, max - 1).trimEnd()}…` : sentence;
-}
-/**
-* Installs an extension from the Kubb registry at its reviewed version and, for a plugin or a parser,
-* adds it to `kubb.config.ts`, offering to add the plugins it needs as well. An adapter is never
-* written: the command prints the snippet to swap it in by hand. Without an id, asks which one.
-* Previews the packages and config lines before asking. Refuses when the running Kubb or Node.js
-* version is outside its compatibility.
-*/
-async function run$5({ id: input, configPath, yes, install }) {
-	const cwd = process$1.cwd();
-	const hrStart = process$1.hrtime();
-	const summary = (title, status, lines) => logCommandSummary({
-		title,
-		status,
-		hrStart,
-		block: true,
-		lines
-	});
-	const installedPackages = [];
-	const configured = [];
-	logIntro({ title: isInteractiveRun({ yes }) ? void 0 : styleText("bgCyan", styleText("black", " Kubb Add ")) });
-	try {
-		const registry = registryUrl();
-		if (!input && yes) throw new Diagnostics.Error({
-			code: Diagnostics.code.unknown,
-			severity: "error",
-			message: "Pass a registry id, such as plugin-zod, when using --yes.",
-			help: "Run `kubb add plugin-zod --yes`, or drop `--yes` to pick from a list."
-		});
-		const inputId = input ? toRegistryId(input) : void 0;
-		const foundConfig = configPath ? path.resolve(configPath) : findConfigFile(cwd);
-		const [entries, installed, configSource] = await withSpinner({
-			message: "Reading the registry",
-			promise: Promise.all([
-				fetchRegistryIndex({ registry }),
-				readInstalledPackages({ root: cwd }),
-				foundConfig ? read(foundConfig).catch(() => void 0) : void 0
-			])
-		});
-		const versions = new Map(installed.map((item) => [item.package, item.version]));
-		const id = inputId ?? await selectExtension({
-			entries,
-			versions,
-			registry
-		});
-		if (!id) {
-			summary("Add canceled", "canceled", ["  No changes made"]);
-			return;
-		}
-		const entry = entries.find((candidate) => candidate.id === id);
-		if (!entry) {
-			const suggestions = closestIds({
-				input: id,
-				ids: entries.map((entry) => entry.id)
-			}).map(toShortId);
-			summary(`No extension named ${input ?? id}`, "failed", [...suggestions.map((suggestion) => `  kubb add ${suggestion}`), "  Browse all  kubb.dev/extensions"]);
-			process$1.exitCode = 1;
-			return;
-		}
-		const { artifact, manifest } = entry;
-		const kind = manifest.kind.charAt(0).toUpperCase() + manifest.kind.slice(1);
-		const problem = incompatibility(manifest);
-		if (problem) throw new Diagnostics.Error({
-			code: Diagnostics.code.incompatibleExtension,
-			severity: "error",
-			message: problem,
-			help: "Upgrade Kubb or Node.js to a version the extension supports."
-		});
-		const configFile = manifest.kind === extensionKinds.adapter ? void 0 : foundConfig;
-		if (manifest.kind !== extensionKinds.adapter && !configFile) throw new Diagnostics.Error({
-			code: Diagnostics.code.unknown,
-			severity: "error",
-			message: "No kubb.config.ts found. Run `kubb init` first, or pass --config.",
-			help: "Run `kubb init` to create a config, or pass its path with `--config`."
-		});
-		const configName = configFile ? path.relative(cwd, configFile) || configFile : void 0;
-		const byName = new Map(entries.map((candidate) => [candidate.manifest.name, candidate]));
-		const inConfig = (name) => {
-			const dependency = byName.get(name);
-			return dependency ? !!configSource?.includes(`${dependency.manifest.export}(`) : installed.some((item) => item.manifest?.name === name);
-		};
-		const dependencies = manifest.dependencies ?? [];
-		const missing = configFile ? dependencies.filter((name) => !inConfig(name)).flatMap((name) => byName.get(name) ?? []) : [];
-		const withDependencies = await confirmDependencies({
-			entry,
-			missing,
-			yes
-		});
-		if (withDependencies === void 0) {
-			summary("Add canceled", "canceled", [`  ${kind}  ${manifest.name}`, "  No changes made"]);
-			return;
-		}
-		const targets = [...withDependencies ? missing : [], entry];
-		const dependencyStatus = (name) => {
-			if (inConfig(name)) return `${name} ${styleText("green", "✓ installed")}`;
-			return targets.some((target) => target.manifest.name === name) ? `${name} ${styleText("cyan", "+ adding")}` : `${name} ${styleText("yellow", "missing")}`;
-		};
-		const preview = configFile && configSource !== void 0 ? previewConfig({
-			details: targets,
-			source: configSource
-		}) : void 0;
-		const before = readImports(configSource ?? "");
-		const added = preview && "lines" in preview ? readImports(preview.source).filter((name) => !before.includes(name)) : [];
-		const bundled = BUNDLED_PACKAGES.filter((name) => added.includes(name) && !versions.has(name) && !targets.some((target) => target.artifact.package === name));
-		const kubbVersion = versions.get("kubb");
-		const specs = [...targets.filter((target) => target === entry || !versions.has(target.artifact.package)).map((target) => installSpec(target.artifact)), ...bundled.map((name) => kubbVersion ? `${name}@${kubbVersion}` : name)];
-		logStep(`${kind} ${styleText("cyan", manifest.name)} v${artifact.version} · ${summarize(manifest.description)}`);
-		logBlock([
-			...dependencies.length ? [`Needs     ${dependencies.map(dependencyStatus).join("  ")}`] : [],
-			install ? `Installs  ${specs.join("  ")}` : "Installs  nothing (--no-install)",
-			...configName ? [`Config    ${configName}`] : [`Config    prints the ${manifest.kind} snippet to add`],
-			...preview && "lines" in preview ? preview.lines.map((line) => styleText("green", `  + ${line}`)) : [],
-			...preview && "reason" in preview ? [styleText("yellow", `  cannot edit it: ${preview.reason}`)] : []
-		]);
-		const confirmed = yes || await clack.confirm({
-			message: "Add it?",
-			initialValue: true
-		});
-		if (clack.isCancel(confirmed) || !confirmed) {
-			summary("Add canceled", "canceled", [`  ${kind}  ${manifest.name}`, "  No changes made"]);
-			return;
-		}
-		const packageManager = detectPackageManager(cwd);
-		const packages = () => install ? `${installedPackages.length} installed with ${packageManager.name}` : "installation skipped (--no-install)";
-		if (install) {
-			const names = [...targets.filter((target) => specs.includes(installSpec(target.artifact))).map((target) => target.artifact.package), ...bundled];
-			await installWithSpinner({
-				packages: specs,
-				names: names.join(", "),
-				packageManager,
-				cwd
-			});
-			installedPackages.push(...names);
-		}
-		const unconfigured = configFile ? [] : [entry];
-		if (configFile) for (const target of targets) try {
-			const { outcomes, changed } = await editConfigFile({
-				filePath: configFile,
-				...toConfigEdits([target])
-			});
-			if (!outcomes[0]?.applied) throw new Error(outcomes[0]?.reason ?? "the config file was not changed");
-			if (changed) configured.push(target);
-			logStep(`${target.manifest.export}() configured in ${configName}`);
-		} catch (error) {
-			logWarn(`Could not edit ${configName}: ${getErrorMessage(error)}`);
-			unconfigured.push(target);
-		}
-		const manual = unconfigured.length > 0;
-		if (manual && manifest.kind !== extensionKinds.adapter) process$1.exitCode = 1;
-		if (manual) logBlock([
-			"Add the import to your Kubb config and merge the property into its defineConfig call:",
-			"",
-			...unconfigured.map((target) => toSnippet(target))
-		]);
-		const dependenciesMissing = !withDependencies && missing.length > 0;
-		summary(manual ? `${kind} needs configuration` : dependenciesMissing ? "Plugin configured; dependencies missing" : configured.length ? install ? `${kind} ready` : `${kind} configured` : `${kind} already configured`, manual || dependenciesMissing ? "warning" : "success", [
-			`  Packages  ${packages()}`,
-			...configured.map((target) => styleText("green", `  + ${target.manifest.export}()`)),
-			"",
-			...!install ? [`Install ${specs.join(" ")} to use it.`] : [],
-			...dependenciesMissing ? [`Missing plugins  ${missing.map((target) => target.manifest.name).join(", ")}`] : [],
-			manual ? "Add the snippet above, then run kubb generate." : "Next     kubb generate",
-			`Options  kubb.dev/extensions/${entry.id}`
-		]);
-	} catch (error) {
-		logError(getErrorMessage(error));
-		summary("Add failed", "failed", installedPackages.length ? [`  Packages  ${installedPackages.join(", ")} installed`] : ["  No changes made"]);
-		process$1.exitCode = 1;
-	}
-}
-__name(run$5, "run");
-const command$4 = define({
-	name: "add",
-	description: "Find and install plugins, adapters, and parsers from the Kubb registry.",
-	examples: [
-		"kubb add",
-		"kubb add plugin-zod",
-		"kubb add kubb-labs/plugin-react-query",
-		"kubb add acme/plugin-x --yes",
-		"kubb add plugin-zod --no-install"
-	].join("\n"),
-	toKebab: true,
-	args: {
-		id: {
-			type: "positional",
-			description: "Registry id: owner/slug, or a slug for an official extension. Asked for when omitted",
-			required: false
-		},
-		...configArg,
-		...yesArg,
-		install: {
-			type: "boolean",
-			description: "Install the package. Pass --no-install to only edit the config",
-			negatable: true,
-			default: true
-		}
-	},
-	run: ({ values }) => run$5({
-		id: values.id,
-		configPath: values.config,
-		yes: values.yes,
-		install: values.install
-	})
-});
-//#endregion
-//#region src/runners/init/run.ts
-function cancelAndExit(message = "Operation canceled.") {
-	clack.cancel(message);
-	process$1.exit(0);
-}
-function unwrap(value) {
-	if (clack.isCancel(value)) cancelAndExit();
-	return value;
-}
-/** The full `kubb.config.ts` for `choices`, with each plugin added the way `kubb add` adds it. */
-function buildConfig({ inputPath, outputPath, plugins }) {
-	const { source, outcomes } = editConfig({
-		source: generateConfigFile({
-			inputPath,
-			outputPath
-		}),
-		edits: plugins.map((entry) => ({
-			operation: ConfigEditOperation.ADD_PLUGIN,
-			plugin: entry.artifact.package
-		})),
-		extensions: new Map(plugins.map(({ artifact, manifest }) => [artifact.package, {
-			package: artifact.package,
-			version: artifact.version,
-			manifest
-		}]))
-	});
-	const failed = outcomes.find((outcome) => !outcome.applied);
-	if (failed && failed.edit.operation === ConfigEditOperation.ADD_PLUGIN) throw new Diagnostics.Error({
-		code: Diagnostics.code.unknown,
-		severity: "error",
-		message: `Could not add ${failed.edit.plugin} to ${KUBB_CONFIG_FILENAME}: ${failed.reason}`,
-		help: `Run kubb init without that plugin, then add it with kubb add.`
-	});
-	return source;
-}
-/** Generates from the config at `configPath` without reporters, and returns how many files it wrote. */
-async function firstRun(configPath) {
-	const { configs } = await getConfigs({ configPath });
-	let files = 0;
-	for (const config of configs) {
-		const result = await createKubb(config).generate();
-		if (!result.success) throw new Error(result.diagnostics.flatMap((diagnostic) => diagnostic.severity === "error" ? [diagnostic.message] : []).join("\n"));
-		files += result.files.length;
-	}
-	return files;
-}
-/** The command that runs `kubb generate`: the `generate` script when it runs Kubb, otherwise `npx kubb generate`. */
-function generateCommand({ packageManager, script, watch }) {
-	if (script !== "kubb generate") return `npx kubb generate${watch ? " --watch" : ""}`;
-	const run = [
-		packageManager.name,
-		...packageManager.runCommand,
-		"generate"
-	].join(" ");
-	if (!watch) return run;
-	return packageManager.name === "npm" ? `${run} -- --watch` : `${run} --watch`;
-}
-/**
-* Runs the Kubb setup wizard: detects the package manager and specs, asks for the spec, plugins, and
-* output folder, shows the config for review, then installs, writes `kubb.config.ts`, adds a
-* `generate` script, and runs the first generation.
-* Pass `yes: true` to skip all prompts and print one line per step.
-*/
-async function run$4({ yes, input: inputFlag, output: outputFlag, plugins: pluginsFlag, dryRun }) {
-	const cwd = process$1.cwd();
-	/** Runs `task` behind a spinner, or prints one line when it is done in `--yes` mode. */
-	async function step({ start, task, done, failed }) {
-		const spinner = createSpinner();
-		if (!yes) spinner.start(start);
-		try {
-			const result = await task();
-			if (yes) console.log(`${styleText("green", "✓")} ${done(result)}`);
-			else spinner.stop(done(result));
-			return result;
-		} catch (error) {
-			if (!yes) spinner.error(failed);
-			throw error;
-		}
-	}
-	if (!yes) logIntro({ title: isInteractiveRun({
-		yes,
-		dryRun: dryRun.enabled
-	}) ? void 0 : "Set up Kubb" });
-	try {
-		const registry = fetchRegistryIndex({ registry: registryUrl() }).then((entries) => entries.filter((entry) => entry.kind === "plugin" && !incompatibility(entry.manifest)));
-		registry.catch(() => {});
-		if (!await exists(path.join(cwd, "package.json"))) {
-			if (!yes) {
-				if (!unwrap(await clack.confirm({
-					message: "No package.json found. Would you like to create one?",
-					initialValue: true
-				}))) cancelAndExit();
-			}
-			const packageManager = detectPackageManager(cwd);
-			await step({
-				start: `Initializing package.json with ${packageManager.name}`,
-				task: () => initPackageJson(cwd, packageManager),
-				done: () => `Created package.json with ${packageManager.name}`,
-				failed: "Could not create package.json"
-			});
-		}
-		const packageManager = detectPackageManager(cwd);
-		const specs = await findSpecFiles(cwd);
-		if (!yes) {
-			logStep(`Package manager  ${packageManager.name}`);
-			if (specs[0]) {
-				const { version: specVersion, operations } = await readSpecInfo(path.join(cwd, specs[0]));
-				const details = [
-					specs[0].slice(2),
-					specVersion ? `${specVersion.startsWith("2") ? "Swagger" : "OpenAPI"} ${specVersion}` : void 0,
-					operations === void 0 ? void 0 : pluralize(operations, "operation"),
-					specs.length > 1 ? `+${specs.length - 1} more` : void 0
-				];
-				logStep(`Found     ${details.filter(Boolean).join(" · ")}`);
-			}
-		}
-		const plugins = pluginsFlag || yes ? await registry : void 0;
-		const defaultPlugins = (entries) => initDefaults.plugins.flatMap((id) => findPlugin({
-			plugins: entries,
-			id
-		}) ?? []);
-		const flagPlugins = pluginsFlag && plugins ? parsePluginsFlag({
-			plugins,
-			value: pluginsFlag
-		}) : void 0;
-		let choices = {
-			inputPath: inputFlag ?? specs[0] ?? initDefaults.inputPath,
-			outputPath: outputFlag ?? initDefaults.outputPath,
-			plugins: flagPlugins ?? (plugins ? defaultPlugins(plugins) : [])
-		};
-		if (yes && !choices.plugins.length) throw new Error("The registry has no default plugin. Pass --plugins to choose one.");
-		async function askInput(current) {
-			const choice = specs.length ? unwrap(await clack.select({
-				message: "Which spec should Kubb read?",
-				options: [
-					...specs.map((spec) => ({
-						value: spec,
-						label: spec,
-						hint: "found in this repo"
-					})),
-					{
-						value: "url",
-						label: "A URL"
-					},
-					{
-						value: "file",
-						label: "Another file"
-					}
-				],
-				initialValue: specs.includes(current) ? current : /^https?:\/\//.test(current) ? "url" : "file"
-			})) : /^https?:\/\//.test(current) ? "url" : "file";
-			if (specs.includes(choice)) return choice;
-			const isUrl = choice === "url";
-			const initial = isUrl === /^https?:\/\//.test(current) && !specs.includes(current) ? current : void 0;
-			return unwrap(await clack.text({
-				message: isUrl ? "Spec URL" : "Spec path",
-				placeholder: isUrl ? "https://example.com/openapi.yaml" : initDefaults.inputPath,
-				initialValue: initial,
-				defaultValue: isUrl ? void 0 : initDefaults.inputPath,
-				validate: (value) => {
-					if (isUrl && !/^https?:\/\//.test(value ?? "")) return "Enter an http(s) URL";
-				}
-			}));
-		}
-		async function askPlugins(previous) {
-			const plugins = await registry;
-			const current = previous.length ? previous : defaultPlugins(plugins);
-			const width = Math.max(...plugins.map((entry) => entry.manifest.displayName.length));
-			const nameWidth = Math.max(...plugins.map((entry) => entry.manifest.name.length));
-			const values = unwrap(await clack.multiselect({
-				message: "What should Kubb generate?",
-				options: plugins.map(({ id, manifest }) => ({
-					value: id,
-					label: `${manifest.displayName.padEnd(width)}  ${styleText("dim", manifest.name.padEnd(nameWidth))}`.trimEnd()
-				})),
-				initialValues: current.map((entry) => entry.id),
-				required: true
-			}));
-			return plugins.filter((entry) => values.includes(entry.id));
-		}
-		const answered = yes || Boolean(inputFlag && outputFlag && pluginsFlag);
-		if (!answered) {
-			let firstPass = true;
-			while (true) {
-				choices = {
-					inputPath: firstPass && inputFlag ? inputFlag : await askInput(choices.inputPath),
-					plugins: firstPass && flagPlugins ? flagPlugins : await askPlugins(choices.plugins),
-					outputPath: firstPass && outputFlag ? outputFlag : unwrap(await clack.text({
-						message: "Output folder",
-						placeholder: choices.outputPath,
-						defaultValue: choices.outputPath
-					}))
-				};
-				firstPass = false;
-				const missing = missingPluginDependencies(choices.plugins.map((entry) => entry.manifest));
-				if (missing.length) {
-					logWarn(`${missing.join("\n")}\nAdd the missing plugins.`);
-					continue;
-				}
-				const config = buildConfig(choices);
-				const packages = [KUBB_PACKAGE_NAME, ...choices.plugins.map((entry) => entry.artifact.package)];
-				logStep(`Review ${KUBB_CONFIG_FILENAME}`);
-				logBlock([
-					...config.trimEnd().split("\n"),
-					"",
-					`${styleText("dim", "Installs")}  ${packages.join(" ")} with ${packageManager.name}`
-				]);
-				const configExists = await exists(path.join(cwd, KUBB_CONFIG_FILENAME));
-				if (unwrap(await clack.select({
-					message: configExists ? `kubb.config.ts exists. Overwrite it?` : "Create it?",
-					options: [{
-						value: true,
-						label: "Yes"
-					}, {
-						value: false,
-						label: "Change a choice"
-					}]
-				}))) break;
-			}
-		}
-		const missing = missingPluginDependencies(choices.plugins.map((entry) => entry.manifest));
-		if (missing.length) throw new Diagnostics.Error({
-			code: Diagnostics.code.missingDependency,
-			severity: "error",
-			message: `${missing.join("\n")}\nAdd the missing plugins and run kubb init again.`
-		});
-		const configPath = path.join(cwd, KUBB_CONFIG_FILENAME);
-		if (answered && !yes && await exists(configPath)) {
-			if (!unwrap(await clack.confirm({
-				message: `kubb.config.ts exists. Overwrite it?`,
-				initialValue: false
-			}))) cancelAndExit("Keeping existing configuration.");
-		}
-		const packagesToInstall = [`${KUBB_PACKAGE_NAME}@${version}`, ...choices.plugins.map((entry) => installSpec(entry.artifact))];
-		const packageNames = [KUBB_PACKAGE_NAME, ...choices.plugins.map((entry) => entry.artifact.package)];
-		const dry = { message: `install ${packagesToInstall.length} packages with ${packageManager.name}` };
-		if (yes) await step({
-			start: "",
-			task: async () => void await dryRun.run(() => installPackages(packagesToInstall, packageManager, cwd), dry),
-			done: () => `Installed ${packageNames.join(" ")} with ${packageManager.name}`,
-			failed: "Installation failed"
-		});
-		else await installWithSpinner({
-			packages: packagesToInstall,
-			names: `${packagesToInstall.length} packages`,
-			packageManager,
-			cwd,
-			install: async (packages, packageManager, cwd, onLine) => void await dryRun.run(() => installPackages(packages, packageManager, cwd, onLine), dry)
-		});
-		await step({
-			start: `Writing ${KUBB_CONFIG_FILENAME}`,
-			task: async () => dryRun.run(async () => void await write(configPath, buildConfig(choices)), { message: `write ${KUBB_CONFIG_FILENAME}` }),
-			done: () => `Wrote ${KUBB_CONFIG_FILENAME}`,
-			failed: `Could not write ${KUBB_CONFIG_FILENAME}`
-		});
-		const scriptAdded = await dryRun.run(() => addGenerateScript(cwd), {
-			message: "add a generate script to package.json",
-			resolve: async () => await generateScript(cwd) === void 0
-		});
-		if (scriptAdded && !yes) logStep("Added \"generate\": \"kubb generate\" to package.json");
-		const script = scriptAdded ? "kubb generate" : await generateScript(cwd);
-		const runStart = process$1.hrtime();
-		try {
-			await dryRun.run(() => step({
-				start: "Running the first generation",
-				task: () => firstRun(configPath),
-				done: (files) => yes ? `Generated ${pluralize(files, "file")} in ${choices.outputPath}` : `First run  ${pluralize(files, "file")} in ${choices.outputPath} · ${formatMs(getElapsedMs(runStart))}`,
-				failed: "First run failed"
-			}), {
-				message: "run the first generation",
-				resolve: () => 0
-			});
-		} catch (error) {
-			logError(error instanceof Error ? error.message : String(error));
-			const message = `Kubb is set up, but the first run failed. Fix the error, then run ${generateCommand({
-				packageManager,
-				script,
-				watch: false
-			})}.`;
-			if (yes) console.log(message);
-			else logOutro(styleText("yellow", message));
-			process$1.exitCode = 1;
-			return;
-		}
-		if (yes) {
-			console.log(`Kubb is set up. Run ${generateCommand({
-				packageManager,
-				script,
-				watch: false
-			})} after changing the spec.`);
-			return;
-		}
-		logOutro(`${styleText("green", "✓ Kubb is set up")}\n   ${styleText("dim", "Next")}  ${generateCommand({
-			packageManager,
-			script,
-			watch: true
-		})}`);
-	} catch (error) {
-		logError(styleText("red", "An error occurred during initialization"));
-		if (error instanceof Error) logError(error.message);
-		process$1.exit(1);
-	}
-}
-__name(run$4, "run");
-const command$3 = defineWithTypes()({
-	name: "init",
-	description: "Set up a config, install plugins, and run the first generation.",
-	examples: [
-		"kubb init",
-		"kubb init --yes",
-		"kubb init --input ./openapi.yaml --output ./src/gen --plugins plugin-ts,plugin-zod",
-		"kubb init --yes --input ./openapi.yaml --plugins ts,zod --output src/api",
-		"kubb init --plugins plugin-ts,plugin-axios,plugin-react-query",
-		"kubb init --yes --dry-run"
-	].join("\n"),
-	toKebab: true,
-	args: {
-		yes: {
-			type: "boolean",
-			description: "Skip prompts and use the detected spec, the default plugin, and the default output folder",
-			short: "y",
-			default: false
-		},
-		input: {
-			type: "string",
-			description: "Path to the OpenAPI specification",
-			short: "i",
-			metavar: "path"
-		},
-		output: {
-			type: "string",
-			description: "Output directory for generated files",
-			short: "o",
-			metavar: "path"
-		},
-		plugins: {
-			type: "string",
-			description: "Comma-separated Kubb registry ids of the plugins to add, the same ids `kubb add` takes (plugin-ts, plugin-zod, acme/plugin-x), or short names (ts, zod)",
-			metavar: "plugin-ts,plugin-zod,..."
-		}
-	},
-	run: ({ values, extensions }) => run$4({
-		yes: values.yes,
-		input: values.input,
-		output: values.output,
-		plugins: values.plugins,
-		dryRun: extensions[dryRunId]
-	})
-});
-//#endregion
-//#region src/ui/table.ts
-/** Pads each column to its widest cell, one line per row. */
-function formatTable(rows) {
-	const widths = Array.from({ length: Math.max(0, ...rows.map((row) => row.length)) }, (_, index) => Math.max(...rows.map((row) => row[index]?.length ?? 0)));
-	return rows.map((row) => row.map((cell, index) => cell.padEnd(widths[index])).join("  ").trimEnd());
-}
-//#endregion
-//#region src/runners/list/run.ts
-/**
-* The installed packages that ship a `kubb-extension.json` or have a registry entry, with the
-* version the registry pins.
-*/
-async function listExtensions({ cwd, registry }) {
-	const [installed, entries] = await Promise.all([readInstalledPackages({ root: cwd }), fetchRegistryIndex({ registry }).catch((error) => {
-		logWarn(`Showing installed extensions only: ${getErrorMessage(error)}`);
-		return [];
-	})]);
-	const byPackage = new Map(entries.map((entry) => [entry.artifact.package, entry]));
-	return installed.flatMap(({ package: name, version, manifest }) => {
-		const entry = byPackage.get(name);
-		if (!entry && !manifest) return [];
-		const latest = entry?.artifact.version;
-		return [{
-			id: entry?.id,
-			package: name,
-			installed: version,
-			registry: latest,
-			update: !!latest && isOutdated({
-				installed: version,
-				latest
-			})
-		}];
-	});
-}
-/** Prints the installed extensions as a table. */
-async function run$3() {
-	try {
-		const rows = await listExtensions({
-			cwd: process$1.cwd(),
-			registry: registryUrl()
-		});
-		if (!rows.length) {
-			logOutro("No installed extensions found.");
-			return;
-		}
-		const [head, ...body] = formatTable([[
-			"ID",
-			"PACKAGE",
-			"INSTALLED",
-			"REGISTRY",
-			"UPDATE"
-		], ...rows.map((row) => [
-			row.id ?? "-",
-			row.package,
-			row.installed ?? "-",
-			row.registry ?? "-",
-			row.update ? "yes" : "no"
-		])]);
-		logBlock([styleText("dim", head), ...body]);
-	} catch (error) {
-		logError(getErrorMessage(error));
-		process$1.exitCode = 1;
-	}
-}
-__name(run$3, "run");
-const command$2 = define({
-	name: "list",
-	description: "List installed extensions, their versions, and available updates.",
-	examples: "kubb list",
-	run: () => run$3()
-});
-//#endregion
-//#region src/runners/remove/run.ts
-/** The lines of `before` that `after` no longer has, trimmed. */
-function removedLines({ before, after }) {
-	const remaining = after.split("\n");
-	return before.split("\n").filter((line) => {
-		const index = remaining.indexOf(line);
-		if (index !== -1) remaining.splice(index, 1);
-		return index === -1 && line.trim() !== "";
-	}).map((line) => line.trim());
-}
-/**
-* Removes a plugin or parser from `kubb.config.ts` and uninstalls its package. Refuses the adapter,
-* which the config needs, and an extension another one in the config depends on. Previews the
-* change before asking.
-*/
-async function run$2({ id: input, configPath, yes, uninstall }) {
-	const cwd = process$1.cwd();
-	const hrStart = process$1.hrtime();
-	const summary = (title, status, lines) => logCommandSummary({
-		title,
-		status,
-		hrStart,
-		block: true,
-		lines
-	});
-	const fail = (title, lines) => {
-		summary(title, "failed", lines);
-		process$1.exitCode = 1;
-	};
-	logIntro({ title: isInteractiveRun({ yes }) ? void 0 : styleText("bgCyan", styleText("black", " Kubb Remove ")) });
-	try {
-		const id = toRegistryId(input);
-		const configFile = configPath ? path.resolve(configPath) : findConfigFile(cwd);
-		if (!configFile) throw new Diagnostics.Error({
-			code: Diagnostics.code.unknown,
-			severity: "error",
-			message: "No kubb.config.ts found. Pass its path with --config.",
-			help: "Run `kubb remove <id> --config <path>`."
-		});
-		const configName = path.relative(cwd, configFile) || configFile;
-		const [entries, installed, source] = await withSpinner({
-			message: "Reading the registry",
-			promise: Promise.all([
-				fetchRegistryIndex({ registry: registryUrl() }),
-				readInstalledPackages({ root: cwd }),
-				read(configFile)
-			])
-		});
-		const versions = new Map(installed.map((item) => [item.package, item.version]));
-		const entry = entries.find((candidate) => candidate.id === id);
-		if (!entry) {
-			const suggestions = closestIds({
-				input: id,
-				ids: entries.map((candidate) => candidate.id)
-			}).map(toShortId);
-			return fail(`No extension named ${input}`, suggestions.map((suggestion) => `  kubb remove ${suggestion}`));
-		}
-		const { artifact, manifest } = entry;
-		const kind = manifest.kind.charAt(0).toUpperCase() + manifest.kind.slice(1);
-		if (manifest.kind === extensionKinds.adapter) return fail("The adapter cannot be removed", [`  A config needs one adapter. Change it in ${configName} by hand.`]);
-		const view = readConfig(source);
-		const running = new Set(view.managed ? view.configs.flatMap((config) => [...config.plugins, ...config.parsers ?? []].filter((call) => !call.disabled).map((call) => call.packageName)) : []);
-		const dependents = entries.filter((other) => other.id !== entry.id && other.manifest.dependencies?.includes(manifest.name) && running.has(other.artifact.package));
-		if (dependents.length) {
-			const names = dependents.map((other) => other.manifest.name).join(", ");
-			return fail(`${names} ${dependents.length === 1 ? "needs" : "need"} ${manifest.name}`, [`  Remove ${names} first.`]);
-		}
-		const edits = [{
-			operation: ConfigEditOperation.REMOVE_EXTENSION,
-			...manifest.kind === extensionKinds.parser ? { kind: extensionKinds.parser } : {},
-			plugin: artifact.package
-		}];
-		const preview = editConfig({
-			source,
-			edits
-		});
-		const outcome = preview.outcomes[0];
-		if (!outcome?.applied) return fail(`Could not edit ${configName}`, [`  ${outcome?.reason ?? "the config file was not changed"}`]);
-		const bundled = BUNDLED_PACKAGES.includes(artifact.package);
-		const stillImported = readImports(preview.source).includes(artifact.package);
-		const uninstalls = uninstall && !bundled && !stillImported && versions.has(artifact.package);
-		if (!preview.changed && !uninstalls) {
-			summary(`${manifest.name} is not in the project`, "success", ["  No changes made"]);
-			return;
-		}
-		const packageLine = (() => {
-			if (uninstalls) return `Uninstalls ${artifact.package}`;
-			if (bundled) return `Keeps     ${artifact.package}, which ships with kubb`;
-			if (stillImported) return `Keeps     ${artifact.package}, which another config entry still imports`;
-			return "Uninstalls nothing";
-		})();
-		logStep(`${kind} ${styleText("cyan", manifest.name)} v${versions.get(artifact.package) ?? artifact.version}`);
-		logBlock([
-			`Config    ${configName}`,
-			...removedLines({
-				before: source,
-				after: preview.source
-			}).map((line) => styleText("red", `  - ${line}`)),
-			packageLine
-		]);
-		const confirmed = yes || await clack.confirm({
-			message: "Remove it?",
-			initialValue: true
-		});
-		if (clack.isCancel(confirmed) || !confirmed) {
-			summary("Remove canceled", "canceled", [`  ${kind}  ${manifest.name}`, "  No changes made"]);
-			return;
-		}
-		if (preview.changed) {
-			const written = await editConfigFile({
-				filePath: configFile,
-				edits
-			});
-			if (!written.outcomes[0]?.applied) return fail(`Could not edit ${configName}`, [`  ${written.outcomes[0]?.reason ?? "the config file was not changed"}`]);
-			logStep(`${manifest.export}() removed from ${configName}`);
-		}
-		const packageManager = detectPackageManager(cwd);
-		if (uninstalls) await withSpinner({
-			message: `Uninstalling ${artifact.package} with ${packageManager.name}`,
-			promise: uninstallPackages([artifact.package], packageManager, cwd)
-		});
-		summary(`${kind} removed`, "success", [
-			`  Packages  ${uninstalls ? `${artifact.package} uninstalled with ${packageManager.name}` : "none uninstalled"}`,
-			"",
-			"Next     kubb generate"
-		]);
-	} catch (error) {
-		logError(getErrorMessage(error));
-		fail("Remove failed", ["  See the error above"]);
-	}
-}
-__name(run$2, "run");
-const command$1 = define({
-	name: "remove",
-	description: "Remove a plugin or parser from kubb.config.ts and uninstall its package.",
-	examples: [
-		"kubb remove plugin-zod",
-		"kubb remove acme/plugin-x --yes",
-		"kubb remove plugin-zod --no-uninstall"
-	].join("\n"),
-	toKebab: true,
-	args: {
-		id: {
-			type: "positional",
-			description: "Registry id: owner/slug, or a slug for an official extension",
-			required: true
-		},
-		...configArg,
-		...yesArg,
-		uninstall: {
-			type: "boolean",
-			description: "Uninstall the package. Pass --no-uninstall to only edit the config",
-			negatable: true,
-			default: true
-		}
-	},
-	run: ({ values }) => run$2({
-		id: values.id,
-		configPath: values.config,
-		yes: values.yes,
-		uninstall: values.uninstall
-	})
-});
-//#endregion
-//#region src/runners/update/run.ts
-/**
-* Generates every config in this process, the way `kubb generate` does, and returns the output files
-* it changed. Runs after the install, so the config loads the new versions. `undefined` when the
-* config fails to load or a build fails.
-*/
-async function regenerate({ cwd, configPath }) {
-	const spinner = createSpinner();
-	spinner.start("Generating with the new versions");
-	try {
-		const [{ getConfigs }, { generate }] = await Promise.all([import("./config-DWDpFSn1.js"), import("./run-YMSJnvYl.js")]);
-		const { configs } = await getConfigs({ configPath });
-		const dirs = configs.map((config) => path.resolve(config.root ?? cwd, config.output.path));
-		const before = new Map((await Promise.all(dirs.map(readOutputFiles))).flatMap((files) => [...files]));
-		const hooks = new Hookable();
-		for (const config of configs) if (!await generate({
-			config,
-			hooks
-		})) throw new Error("Generation failed");
-		const after = new Map((await Promise.all(dirs.map(readOutputFiles))).flatMap((files) => [...files]));
-		const diff = diffFiles(before, after);
-		spinner.stop(diff.files.length ? `Generated: ${pluralize(diff.files.length, "file")} changed` : "Generated: no files changed");
-		return {
-			...diff,
-			output: dirs.map((dir) => path.relative(cwd, dir) || ".").join(", ")
-		};
-	} catch (error) {
-		spinner.error(`Generation failed: ${getErrorMessage(error)}`);
-		return;
-	}
-}
-/**
-* Moves installed extensions to the version the registry pins. Shows each version change with its
-* bump, asks which to install with majors left out, installs them, and regenerates to show which
-* files changed. With `dryRun`, only lists the updates and installs nothing.
-*/
-async function run$1({ ids, dryRun, yes }) {
-	const cwd = process$1.cwd();
-	const hrStart = process$1.hrtime();
-	const installedPackages = [];
-	const summary = (title, status, lines) => logCommandSummary({
-		title,
-		status,
-		hrStart,
-		block: true,
-		lines
-	});
-	logIntro({ title: isInteractiveRun({
-		yes,
-		dryRun
-	}) ? void 0 : styleText("bgCyan", styleText("black", " Kubb Update ")) });
-	try {
-		const wanted = new Set(ids.map(toRegistryId));
-		const [entries, installed] = await withSpinner({
-			message: "Checking the registry",
-			promise: Promise.all([fetchRegistryIndex({ registry: registryUrl() }), readInstalledPackages({ root: cwd })])
-		});
-		const versions = new Map(installed.map((item) => [item.package, item.version]));
-		const tracked = entries.filter((entry) => versions.has(entry.artifact.package) && (!wanted.size || wanted.has(entry.id)));
-		for (const id of wanted) {
-			if (tracked.some((entry) => entry.id === id)) continue;
-			logWarn(`${id} is not installed, or not in the registry.`);
-			process$1.exitCode = 1;
-		}
-		const current = ({ artifact }) => versions.get(artifact.package);
-		const isMajor = (entry) => bumpOf({
-			installed: current(entry),
-			latest: entry.artifact.version
-		}) === "major";
-		const outdated = tracked.filter((entry) => isOutdated({
-			installed: current(entry),
-			latest: entry.artifact.version
-		}));
-		const proposals = outdated.filter((entry) => {
-			const problem = incompatibility(entry.manifest);
-			if (problem) {
-				logWarn(`Skipped ${entry.id}: ${problem}`);
-				if (wanted.has(entry.id)) process$1.exitCode = 1;
-			}
-			return !problem;
-		});
-		if (!proposals.length) {
-			const title = outdated.length ? "No compatible updates available" : "Already up to date";
-			summary(tracked.length ? title : "No installed extensions to update", outdated.length ? "warning" : "success", [`  ${tracked.length - outdated.length} of ${tracked.length} up to date`, ...ids.length ? ["", `No updates for ${ids.join(", ")}.`] : []]);
-			return;
-		}
-		if (tracked.length) {
-			const lines = formatTable([[
-				"Extension",
-				"Current",
-				"Latest",
-				""
-			], ...tracked.map((entry) => {
-				if (!outdated.includes(entry)) return [
-					entry.artifact.package,
-					current(entry) ?? "-",
-					"up to date",
-					""
-				];
-				const bump = bumpOf({
-					installed: current(entry),
-					latest: entry.artifact.version
-				}) ?? "";
-				return [
-					entry.artifact.package,
-					current(entry) ?? "not installed",
-					entry.artifact.version,
-					bump === "major" ? "major · breaking" : bump
-				];
-			})]);
-			logStep(`Checked ${pluralize(tracked.length, "extension")} against the registry`);
-			logBlock([styleText("dim", lines[0]), ...lines.slice(1).map((line, index) => {
-				if (!outdated.includes(tracked[index])) return styleText("dim", line);
-				return line.endsWith("major · breaking") ? styleText("yellow", line) : line;
-			})]);
-		}
-		if (dryRun) {
-			summary("Updates available", "planned", [`Dry run: nothing was installed. Run kubb update to install ${proposals.length === 1 ? "it" : "them"}.`]);
-			return;
-		}
-		const defaults = proposals.filter((entry) => wanted.has(entry.id) || !isMajor(entry));
-		const chosen = yes ? defaults.map((entry) => entry.id) : await clack.multiselect({
-			message: "Select the updates to install",
-			options: proposals.map((entry) => ({
-				value: entry.id,
-				label: entry.artifact.package,
-				hint: `${current(entry) ?? "not installed"} → ${entry.artifact.version}`
-			})),
-			initialValues: defaults.map((entry) => entry.id),
-			required: false
-		});
-		if (clack.isCancel(chosen)) {
-			summary("Update canceled", "canceled", ["  No changes made"]);
-			return;
-		}
-		const selected = proposals.filter((entry) => chosen.includes(entry.id));
-		const skipped = proposals.filter((entry) => !selected.includes(entry)).map((entry) => {
-			const kind = entry.manifest.kind.charAt(0).toUpperCase() + entry.manifest.kind.slice(1);
-			return `  ${styleText("dim", "Skipped")}  ${kind} ${entry.artifact.package} ${entry.artifact.version}  ${styleText("dim", `run kubb update ${toShortId(entry.id)} later`)}`;
-		});
-		if (!selected.length) {
-			summary("No updates installed", "canceled", ["  No updates selected.", ...skipped]);
-			return;
-		}
-		const packageManager = detectPackageManager(cwd);
-		const names = selected.map(({ artifact }) => artifact.package).join(", ");
-		await installWithSpinner({
-			packages: selected.map(({ artifact }) => installSpec(artifact)),
-			names,
-			packageManager,
-			cwd
-		});
-		installedPackages.push(...selected.map((entry) => entry.artifact.package));
-		const foundConfig = findConfigFile(cwd);
-		const configPath = foundConfig && !yes && await clack.confirm({
-			message: "Regenerate now? This rewrites the generated files.",
-			initialValue: true
-		}) === true ? foundConfig : void 0;
-		const changed = configPath ? await regenerate({
-			cwd,
-			configPath
-		}) : void 0;
-		const generationFailed = Boolean(configPath && !changed);
-		const fileCounts = {
-			A: 0,
-			M: 0,
-			D: 0
-		};
-		for (const file of changed?.files ?? []) fileCounts[file.status]++;
-		summary(generationFailed ? "Extensions updated; generation failed" : "Update complete", generationFailed ? "warning" : "success", [
-			`  Packages  ${selected.length} installed with ${packageManager.name}${skipped.length ? ` · ${skipped.length} skipped` : ""}`,
-			...skipped,
-			...changed ? [`  Files     ${fileCounts.A} added · ${fileCounts.M} modified · ${fileCounts.D} deleted`] : [],
-			...!configPath ? ["  Regeneration not run"] : [],
-			...generationFailed ? ["", "Fix the generation error, then run kubb generate."] : []
-		]);
-	} catch (error) {
-		logError(getErrorMessage(error));
-		summary("Update failed", "failed", installedPackages.length ? [`  Packages  ${installedPackages.join(", ")} installed`] : ["  No changes made"]);
-		process$1.exitCode = 1;
-	}
-}
-__name(run$1, "run");
-const command = defineWithTypes()({
-	name: "update",
-	description: "Update installed extensions, regenerate, and summarize file changes.",
-	examples: [
-		"kubb update",
-		"kubb update --dry-run",
-		"kubb update plugin-zod plugin-ts --yes"
-	].join("\n"),
-	args: {
-		ids: {
-			type: "positional",
-			description: "Registry ids to update, all installed extensions when omitted",
-			multiple: true
-		},
-		...yesArg
-	},
-	run: ({ values, extensions }) => run$1({
-		ids: values.ids ?? [],
-		dryRun: extensions[dryRunId].enabled,
-		yes: values.yes
-	})
-});
-//#endregion
-//#region src/index.ts
+/** Flags that print the root help, which lists every subcommand. */
+const HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
 /** Flags that short-circuit execution (help and version). The telemetry notice is suppressed for these. */
 const QUIET_FLAGS = /* @__PURE__ */ new Set([
 	"--help",
@@ -2832,24 +156,23 @@ const QUIET_FLAGS = /* @__PURE__ */ new Set([
 * quiet flag is passed, then runs the given command, or `generate` when none is given.
 */
 async function run(argv = process.argv.slice(2)) {
-	const args = routeStudioFlags(resolveDeprecatedFlags(argv));
+	const resolvedArgs = resolveDeprecatedFlags(argv);
+	const name = resolvedArgs.find((arg) => !arg.startsWith("-")) ?? "";
+	let names = [];
+	if (Object.hasOwn(commandLoaders, name)) names = [name];
+	if (!names.length && resolvedArgs.some((arg) => HELP_FLAGS.has(arg))) names = Object.keys(commandLoaders);
+	const modules = Object.fromEntries(await Promise.all(names.map(async (key) => [key, await commandLoaders[key]()])));
+	const args = name === "studio" ? (await import("./studio-mw6HaPkr.js")).routeStudioFlags(resolvedArgs) : resolvedArgs;
 	const isQuietFlag = args.some((arg) => QUIET_FLAGS.has(arg));
 	const isJsonOutput = args.includes("--json") || args.some((arg, index) => /^--reporter=.*\bjson\b/.test(arg) || arg === "--reporter" && /\bjson\b/.test(args[index + 1] ?? ""));
 	if (!isDisabled() && !isQuietFlag) console.error(`${styleText("yellow", "Notice:")} Kubb collects anonymous telemetry data to help improve the tool. No personal data or file contents are collected. \nTo disable, set ${styleText("cyan", "KUBB_DISABLE_TELEMETRY=1")}.\n`);
-	await cli(args, command$14, {
+	await cli(args, command, {
 		name: "kubb",
 		version,
 		description: "Generate code from an OpenAPI specification, manage Kubb extensions, or connect the project to Kubb Studio.",
 		subCommands: {
-			generate: command$14,
-			init: command$3,
-			validate: command$5,
-			mcp: command$13,
-			studio: command$6,
-			add: command$4,
-			update: command,
-			remove: command$1,
-			list: command$2
+			generate: command,
+			...Object.fromEntries(Object.entries(modules).map(([key, module]) => [key, module.command]))
 		},
 		fallbackToEntry: true,
 		renderHeader: isJsonOutput ? null : async (ctx) => {
@@ -2868,7 +191,6 @@ async function run(argv = process.argv.slice(2)) {
 		}
 	});
 }
-//#endregion
 export { run };
 
 //# sourceMappingURL=index.js.map