@kubb/cli 5.12.8 → 5.13.1

package/dist/index.js

@@ -1,11 +1,11 @@
 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-Cwis9NRC.js";
-import { _ as write, a as readOutputFiles, c as createSpinner, g as read, l as withSpinner, m as exists, n as diffFiles } from "./utils-DNOlQ-6B.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-BBQbTT22.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-D8Vxs2q6.js";
-import { a as initDefaults, i as KUBB_PACKAGE_NAME, n as findConfigFile, r as KUBB_CONFIG_FILENAME, t as getConfigs } from "./config-CbjbW2J5.js";
-import { t as logCommandSummary } from "./summary-D6hq3I9C.js";
+import { a as getElapsedMs, i as formatMs, r as version, t as isDisabled } from "./Telemetry-B4hk3xGv.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--q06lp55.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-CaZG0KF2.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-DLasg7du.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-B1aj8T_V.js";
 import { styleText } from "node:util";
 import dryrun, { pluginId as dryRunId } from "@gunshi/plugin-dryrun";
 import { cli, define, defineWithTypes } from "gunshi";
@@ -14,7 +14,46 @@ import { x } from "tinyexec";
 import path from "node:path";
 import fs from "node:fs";
 import * as clack from "@clack/prompts";
-import { Diagnostics, Hookable, createKubb, readInstalledPackages } from "@kubb/core";
+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",
@@ -86,6 +125,12 @@ const studioPermissionArgs = {
 		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",
@@ -128,7 +173,7 @@ function resolveLogLevel({ verbose, silent, logLevel }) {
 	if (silent) return "silent";
 	return logLevel;
 }
-const command$13 = defineWithTypes()({
+const command$14 = defineWithTypes()({
 	name: "generate",
 	rendering: { header: null },
 	description: "Generate types, clients, hooks, and schemas from an OpenAPI specification.",
@@ -179,7 +224,7 @@ const command$13 = defineWithTypes()({
 	async run(ctx) {
 		const { values } = ctx;
 		const logLevel = resolveLogLevel(values);
-		const { run } = await import("./run-BPi2eh0e.js");
+		const { run } = await import("./run-BDmTZPT7.js");
 		await run({
 			input: values.input,
 			configPath: values.config,
@@ -193,7 +238,7 @@ const command$13 = 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$12 = define({
+const command$13 = define({
 	name: "mcp",
 	description: "Start an MCP server for code generation from an AI assistant.",
 	examples: [
@@ -203,7 +248,7 @@ const command$12 = define({
 	].join("\n"),
 	rendering: { header: null },
 	async run() {
-		const { run } = await import("./run-BJUijhbO.js");
+		const { run } = await import("./run-DoUk-2Xb.js");
 		await run();
 	}
 });
@@ -218,14 +263,14 @@ function studioCommand({ action, block, ...definition }) {
 		...definition,
 		toKebab: true,
 		async run({ values }) {
-			const { runStudio } = await import("./run-CfkP7AY1.js");
+			const { runStudio } = await import("./run-C9Q5R-p9.js");
 			await runStudio(values, action, { block });
 		}
 	});
 }
 //#endregion
 //#region src/commands/studio/connect.ts
-const command$11 = studioCommand({
+const command$12 = studioCommand({
 	name: "connect",
 	description: "Connect this project to Kubb Studio and generate from the browser.",
 	examples: [
@@ -248,31 +293,31 @@ const command$11 = studioCommand({
 	},
 	block: true,
 	async action(options) {
-		const { connect } = await import("./run-CfkP7AY1.js");
+		const { connect } = await import("./run-C9Q5R-p9.js");
 		await connect(options);
 	}
 });
 //#endregion
 //#region src/commands/studio/login.ts
-const command$10 = studioCommand({
+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$11.args,
+	args: command$12.args,
 	async action(options) {
-		const { login } = await import("./run-CfkP7AY1.js");
+		const { login } = await import("./run-C9Q5R-p9.js");
 		await login(options);
 	}
 });
 //#endregion
 //#region src/commands/studio/logout.ts
-const command$9 = studioCommand({
+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-nDhk-eNv.js");
+		const { stopWorker } = await import("./background-B7oEWLZs.js");
 		const { clearCredentials } = await import("./credentials-C8tjAhTo.js");
 		await stopWorker();
 		await clearCredentials();
@@ -281,7 +326,7 @@ const command$9 = studioCommand({
 });
 //#endregion
 //#region src/commands/studio/snapshot.ts
-const command$8 = define({
+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"),
@@ -315,18 +360,18 @@ const command$8 = define({
 		...logLevelArg
 	},
 	async run(ctx) {
-		const { runner } = await import("./snapshot-F8ShCYAC.js");
+		const { runner } = await import("./snapshot-O36QFuVw.js");
 		await runner(ctx);
 	}
 });
 //#endregion
 //#region src/commands/studio/background.ts
-const command$7 = studioCommand({
+const command$8 = studioCommand({
 	name: "start",
 	description: "Keep this project connected to Kubb Studio in the background.",
-	args: command$11.args,
+	args: command$12.args,
 	async action(options) {
-		const { startWorker } = await import("./background-nDhk-eNv.js");
+		const { startWorker } = await import("./background-B7oEWLZs.js");
 		await startWorker(options);
 	}
 });
@@ -334,22 +379,22 @@ const stopCommand = define({
 	name: "stop",
 	description: "Stop this project's background connection and keep its pairing.",
 	async run() {
-		const { stopWorker } = await import("./background-nDhk-eNv.js");
+		const { stopWorker } = await import("./background-B7oEWLZs.js");
 		await stopWorker();
 		console.log("Background connection stopped.");
 	}
 });
 //#endregion
 //#region src/commands/studio/status.ts
-const command$6 = studioCommand({
+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-nDhk-eNv.js");
+		const { getWorkerLogPath, getWorkerStatus } = await import("./background-B7oEWLZs.js");
 		const { readCredentials } = await import("./credentials-C8tjAhTo.js");
-		const { formatStatus } = await import("./status-D1O1SZi5.js");
+		const { formatStatus } = await import("./status-C5_IHiDc.js");
 		const [worker, credentials] = await Promise.all([getWorkerStatus(), readCredentials()]);
 		console.log([
 			"",
@@ -366,8 +411,8 @@ const command$6 = studioCommand({
 });
 //#endregion
 //#region src/commands/studio/index.ts
-const command$5 = define({
-	...command$11,
+const command$6 = define({
+	...command$12,
 	name: "studio",
 	description: "Connect this project to Kubb Studio, or manage its pairing and snapshots.",
 	examples: [
@@ -379,13 +424,13 @@ const command$5 = define({
 		"kubb studio snapshot"
 	].join("\n"),
 	subCommands: {
-		start: command$7,
+		start: command$8,
 		stop: stopCommand,
-		connect: command$11,
-		login: command$10,
-		logout: command$9,
-		status: command$6,
-		snapshot: command$8
+		connect: command$12,
+		login: command$11,
+		logout: command$10,
+		status: command$7,
+		snapshot: command$9
 	}
 });
 /**
@@ -404,7 +449,7 @@ function routeStudioFlags(args) {
 //#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$4 = define({
+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"),
@@ -417,7 +462,7 @@ const command$4 = define({
 		}
 	},
 	async run({ values }) {
-		const { run } = await import("./run-8K8KvqtO.js");
+		const { run } = await import("./run--OOU4YSR.js");
 		await run({
 			input: values.input,
 			configPath: values.config
@@ -474,6 +519,959 @@ export default defineConfig({
 `;
 }
 //#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"
+};
+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 = {
@@ -482,6 +1480,7 @@ const packageManagers = {
 		lockFiles: ["pnpm-lock.yaml"],
 		initCommand: ["init"],
 		installCommand: ["add", "-D"],
+		removeCommand: ["remove"],
 		runCommand: []
 	},
 	yarn: {
@@ -489,6 +1488,7 @@ const packageManagers = {
 		lockFiles: ["yarn.lock"],
 		initCommand: ["init", "-y"],
 		installCommand: ["add", "-D"],
+		removeCommand: ["remove"],
 		runCommand: []
 	},
 	bun: {
@@ -496,6 +1496,7 @@ const packageManagers = {
 		lockFiles: ["bun.lock", "bun.lockb"],
 		initCommand: ["init", "-y"],
 		installCommand: ["add", "-d"],
+		removeCommand: ["remove"],
 		runCommand: ["run"]
 	},
 	npm: {
@@ -503,6 +1504,7 @@ const packageManagers = {
 		lockFiles: ["package-lock.json"],
 		initCommand: ["init", "-y"],
 		installCommand: ["install", "--save-dev"],
+		removeCommand: ["uninstall"],
 		runCommand: ["run"]
 	}
 };
@@ -537,8 +1539,8 @@ const INSTALL_TIMEOUT_MS = 3e5;
 * 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) {
-	const args = [...packageManager.installCommand, ...packages];
+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,
@@ -562,6 +1564,12 @@ async function installPackages(packages, packageManager, cwd = process$1.cwd(),
 	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.
@@ -735,8 +1743,9 @@ function toSnippet({ artifact, manifest }) {
 /** The `add-plugin` edits for `details`, and the manifests the edits read their export names from. */
 function toConfigEdits(details) {
 	return {
-		edits: details.map(({ artifact }) => ({
-			operation: "add-plugin",
+		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, {
@@ -747,24 +1756,22 @@ function toConfigEdits(details) {
 	};
 }
 /** The lines adding `details` would put in the config `source`, trimmed, or why it could not add them. */
-async function previewConfig({ details, source }) {
-	try {
-		const { applyConfigEdits } = await import("@kubb/studio");
-		const result = applyConfigEdits({
-			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) => {
+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()) };
-	} catch (error) {
-		return { reason: getErrorMessage(error) };
-	}
+		}).map((line) => line.trim()),
+		source: result.source
+	};
 }
 async function selectExtension({ entries, versions, registry }) {
 	if (!entries.length) throw new Diagnostics.Error({
@@ -816,12 +1823,13 @@ function summarize(description, max = 64) {
 	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, adds it to
-* `kubb.config.ts`, offering to add the plugins it needs as well. Without an id, asks which one.
+* 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$4({ id: input, configPath, yes, install }) {
+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({
@@ -881,8 +1889,8 @@ async function run$4({ id: input, configPath, yes, install }) {
 			message: problem,
 			help: "Upgrade Kubb or Node.js to a version the extension supports."
 		});
-		const configFile = manifest.kind === "plugin" ? foundConfig : void 0;
-		if (manifest.kind === "plugin" && !configFile) throw new Diagnostics.Error({
+		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.",
@@ -906,15 +1914,19 @@ async function run$4({ id: input, configPath, yes, install }) {
 			return;
 		}
 		const targets = [...withDependencies ? missing : [], entry];
-		const specs = targets.filter((target) => target === entry || !versions.has(target.artifact.package)).map((target) => installSpec(target.artifact));
 		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 ? await previewConfig({
+		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("  ")}`] : [],
@@ -934,7 +1946,7 @@ async function run$4({ id: input, configPath, yes, install }) {
 		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);
+			const names = [...targets.filter((target) => specs.includes(installSpec(target.artifact))).map((target) => target.artifact.package), ...bundled];
 			await installWithSpinner({
 				packages: specs,
 				names: names.join(", "),
@@ -945,8 +1957,7 @@ async function run$4({ id: input, configPath, yes, install }) {
 		}
 		const unconfigured = configFile ? [] : [entry];
 		if (configFile) for (const target of targets) try {
-			const { writeConfigEdits } = await import("@kubb/studio");
-			const { outcomes, changed } = await writeConfigEdits({
+			const { outcomes, changed } = await editConfigFile({
 				filePath: configFile,
 				...toConfigEdits([target])
 			});
@@ -958,14 +1969,14 @@ async function run$4({ id: input, configPath, yes, install }) {
 			unconfigured.push(target);
 		}
 		const manual = unconfigured.length > 0;
-		if (manual && manifest.kind === "plugin") process$1.exitCode = 1;
+		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 ? "Plugin ready" : "Plugin configured" : "Plugin already configured", manual || dependenciesMissing ? "warning" : "success", [
+		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}()`)),
 			"",
@@ -980,8 +1991,8 @@ async function run$4({ id: input, configPath, yes, install }) {
 		process$1.exitCode = 1;
 	}
 }
-__name(run$4, "run");
-const command$3 = define({
+__name(run$5, "run");
+const command$4 = define({
 	name: "add",
 	description: "Find and install plugins, adapters, and parsers from the Kubb registry.",
 	examples: [
@@ -1007,7 +2018,7 @@ const command$3 = define({
 			default: true
 		}
 	},
-	run: ({ values }) => run$4({
+	run: ({ values }) => run$5({
 		id: values.id,
 		configPath: values.config,
 		yes: values.yes,
@@ -1025,15 +2036,14 @@ function unwrap(value) {
 	return value;
 }
 /** The full `kubb.config.ts` for `choices`, with each plugin added the way `kubb add` adds it. */
-async function buildConfig({ inputPath, outputPath, plugins }) {
-	const { applyConfigEdits } = await import("@kubb/studio");
-	const { source, outcomes } = applyConfigEdits({
+function buildConfig({ inputPath, outputPath, plugins }) {
+	const { source, outcomes } = editConfig({
 		source: generateConfigFile({
 			inputPath,
 			outputPath
 		}),
 		edits: plugins.map((entry) => ({
-			operation: "add-plugin",
+			operation: ConfigEditOperation.ADD_PLUGIN,
 			plugin: entry.artifact.package
 		})),
 		extensions: new Map(plugins.map(({ artifact, manifest }) => [artifact.package, {
@@ -1043,7 +2053,7 @@ async function buildConfig({ inputPath, outputPath, plugins }) {
 		}]))
 	});
 	const failed = outcomes.find((outcome) => !outcome.applied);
-	if (failed && failed.edit.operation === "add-plugin") throw new Diagnostics.Error({
+	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}`,
@@ -1079,7 +2089,7 @@ function generateCommand({ packageManager, script, watch }) {
 * `generate` script, and runs the first generation.
 * Pass `yes: true` to skip all prompts and print one line per step.
 */
-async function run$3({ yes, input: inputFlag, output: outputFlag, plugins: pluginsFlag, dryRun }) {
+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 }) {
@@ -1102,7 +2112,6 @@ async function run$3({ yes, input: inputFlag, output: outputFlag, plugins: plugi
 	try {
 		const registry = fetchRegistryIndex({ registry: registryUrl() }).then((entries) => entries.filter((entry) => entry.kind === "plugin" && !incompatibility(entry.manifest)));
 		registry.catch(() => {});
-		if (!yes) import("@kubb/studio").catch(() => {});
 		if (!await exists(path.join(cwd, "package.json"))) {
 			if (!yes) {
 				if (!unwrap(await clack.confirm({
@@ -1216,7 +2225,7 @@ async function run$3({ yes, input: inputFlag, output: outputFlag, plugins: plugi
 					logWarn(`${missing.join("\n")}\nAdd the missing plugins.`);
 					continue;
 				}
-				const config = await buildConfig(choices);
+				const config = buildConfig(choices);
 				const packages = [KUBB_PACKAGE_NAME, ...choices.plugins.map((entry) => entry.artifact.package)];
 				logStep(`Review ${KUBB_CONFIG_FILENAME}`);
 				logBlock([
@@ -1268,7 +2277,7 @@ async function run$3({ yes, input: inputFlag, output: outputFlag, plugins: plugi
 		});
 		await step({
 			start: `Writing ${KUBB_CONFIG_FILENAME}`,
-			task: async () => dryRun.run(async () => void await write(configPath, await buildConfig(choices)), { message: `write ${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}`
 		});
@@ -1320,8 +2329,8 @@ async function run$3({ yes, input: inputFlag, output: outputFlag, plugins: plugi
 		process$1.exit(1);
 	}
 }
-__name(run$3, "run");
-const command$2 = defineWithTypes()({
+__name(run$4, "run");
+const command$3 = defineWithTypes()({
 	name: "init",
 	description: "Set up a config, install plugins, and run the first generation.",
 	examples: [
@@ -1358,7 +2367,7 @@ const command$2 = defineWithTypes()({
 			metavar: "plugin-ts,plugin-zod,..."
 		}
 	},
-	run: ({ values, extensions }) => run$3({
+	run: ({ values, extensions }) => run$4({
 		yes: values.yes,
 		input: values.input,
 		output: values.output,
@@ -1402,7 +2411,7 @@ async function listExtensions({ cwd, registry }) {
 	});
 }
 /** Prints the installed extensions as a table. */
-async function run$2() {
+async function run$3() {
 	try {
 		const rows = await listExtensions({
 			cwd: process$1.cwd(),
@@ -1431,12 +2440,176 @@ async function run$2() {
 		process$1.exitCode = 1;
 	}
 }
-__name(run$2, "run");
-const command$1 = define({
+__name(run$3, "run");
+const command$2 = define({
 	name: "list",
 	description: "List installed extensions, their versions, and available updates.",
 	examples: "kubb list",
-	run: () => run$2()
+	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
@@ -1449,7 +2622,7 @@ async function regenerate({ cwd, configPath }) {
 	const spinner = createSpinner();
 	spinner.start("Generating with the new versions");
 	try {
-		const [{ getConfigs }, { generate }] = await Promise.all([import("./config-cP7k9YwA.js"), import("./run-BPi2eh0e.js")]);
+		const [{ getConfigs }, { generate }] = await Promise.all([import("./config-DWDpFSn1.js"), import("./run-BDmTZPT7.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]));
@@ -1498,7 +2671,11 @@ async function run$1({ ids, dryRun, yes }) {
 		});
 		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)) logWarn(`${id} is not installed, or not in the registry.`);
+		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),
@@ -1656,19 +2833,20 @@ async function run(argv = process.argv.slice(2)) {
 	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$13, {
+	await cli(args, command$14, {
 		name: "kubb",
 		version,
 		description: "Generate code from an OpenAPI specification, manage Kubb extensions, or connect the project to Kubb Studio.",
 		subCommands: {
-			generate: command$13,
-			init: command$2,
-			validate: command$4,
-			mcp: command$12,
-			studio: command$5,
-			add: command$3,
+			generate: command$14,
+			init: command$3,
+			validate: command$5,
+			mcp: command$13,
+			studio: command$6,
+			add: command$4,
 			update: command,
-			list: command$1
+			remove: command$1,
+			list: command$2
 		},
 		fallbackToEntry: true,
 		renderHeader: isJsonOutput ? null : async (ctx) => {