@kubb/studio 5.13.0 → 5.13.1

package/dist/index.js

@@ -1,4 +1,4 @@
-import { AGENT_INSTANCE_HEADER, AGENT_SOCKET_PATH, AgentCloseCode, AgentMessage, AgentPermission, ConfigEditOperation, MAX_SNAPSHOT_BYTES, generationEventTypes } from "./protocol.js";
+import { a as AgentPermission, c as MAX_SNAPSHOT_BYTES, d as extensionKinds, i as AgentMessage, l as generationEventTypes, n as AGENT_SOCKET_PATH, r as AgentCloseCode, t as AGENT_INSTANCE_HEADER, u as ConfigEditOperation } from "./protocol-DQnAN8NE.js";
 import { createRequire } from "node:module";
 import { createHash, hash, randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
@@ -10,10 +10,10 @@ import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { x } from "tinyexec";
 import { Diagnostics, Hookable, cacheStorage, checkoutGitInput, createKubb, fsStorage, getInputKind, isPackageName, isPublicAddress, readInstalledPackages, resolveCacheDir, resolveMeta } from "@kubb/core";
 import { RpcTarget, newWebSocketRpcSession } from "capnweb";
-import { detectCodeFormat, parseExpression, parseModule } from "magicast";
 import { pathToFileURL } from "node:url";
-import { structuredPatch } from "diff";
 import { stripVTControlCharacters } from "node:util";
+import { parse } from "yuku-parser";
+import { structuredPatch } from "diff";
 import { ast } from "@kubb/ast";
 import dns from "node:dns";
 import http from "node:http";
@@ -213,220 +213,112 @@ function getElapsedMs(hrStart) {
 }
 //#endregion
 //#region package.json
-var version = "5.13.0";
+var version = "5.13.1";
 //#endregion
-//#region src/resolveConfig.ts
+//#region ../../internals/shared/src/constants.ts
 /**
-* Turns the JSON config Studio sends back into live Kubb objects.
-*
-* A plugin or adapter instance carries closures (`parse`, `getImports`, ...) that cannot survive
-* JSON, so both sides pass options over the wire and the factory is re-invoked here with the merged
-* result. Only packages {@link isAllowedPlugin} accepts are resolved this way, never an arbitrary
-* module the payload names.
+* Extensions `kubb` ships at its own version, so they count as installed without being a direct
+* dependency. `constants.test.ts` checks it against the `kubb` package's dependencies.
 */
+const BUNDLED_PACKAGES = [
+	"@kubb/adapter-oas",
+	"@kubb/parser-ts",
+	"@kubb/parser-md",
+	"@kubb/plugin-barrel"
+];
+//#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" };
 /**
-* Imports a package, falling back to how the user's project would resolve it.
-*
-* `import()` resolves from this file, so a linked or globally installed Studio (`pnpm link`,
-* `npm i -g`) only sees its own `node_modules` and misses the plugins installed next to the user's
-* config. The retry resolves from `process.cwd()` instead.
+* 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`.
 */
-async function importFromProject(packageName) {
+function parseSource(source) {
 	try {
-		return await import(packageName);
-	} catch {
-		const resolved = createRequire(pathToFileURL(`${process.cwd()}/`)).resolve(packageName);
-		const esm = resolved.replace(/\.cjs$/, ".js");
-		return await import(pathToFileURL(esm !== resolved && existsSync(esm) ? esm : resolved).href);
+		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)}` };
 	}
 }
-/**
-* Strips the `@kubb/` scope from a plugin package name, matching the `name` convention Kubb
-* plugin factories use internally.
-*
-* @example
-* ```ts
-* toPluginName('@kubb/plugin-ts') // 'plugin-ts'
-* ```
-*/
+/** 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/rules.ts
+/** `@kubb/plugin-ts` becomes `plugin-ts`, the `name` Kubb plugin factories use. */
 function toPluginName(packageName) {
 	return packageName.split("/").pop() ?? packageName;
 }
-/**
-* Adds the `@kubb/` scope a plugin's package carries but its `name` does not, the inverse of
-* {@link toPluginName}. A name outside the `plugin-` convention is left alone, so a third-party
-* plugin is not reported as one of Kubb's.
-*
-* @example
-* ```ts
-* toPackageName('plugin-ts')       // '@kubb/plugin-ts'
-* toPackageName('@acme/my-plugin') // '@acme/my-plugin'
-* ```
-*/
-function toPackageName(name) {
-	return name.startsWith("plugin-") ? `@kubb/${name}` : name;
-}
-/**
-* The name Studio knows an extension by: the package of the installed extension whose manifest
-* `name` matches, otherwise its own `name`, so a plugin defined in the user's project is never
-* reported as a Kubb package that does not exist.
-*
-* @example
-* ```ts
-* toStudioName({ name: 'plugin-ts', extensions })              // '@kubb/plugin-ts'
-* toStudioName({ name: 'plugin-zod-operations', extensions })  // 'plugin-zod-operations', a local plugin
-* ```
-*/
-function toStudioName({ name, extensions = /* @__PURE__ */ new Map(), kind = "plugin" }) {
-	return [...extensions.values()].find(({ manifest }) => manifest.kind === kind && manifest.name === name)?.package ?? name;
-}
-/**
-* Derives the conventional named export for a `@kubb/*` plugin package from its package name.
-*
-* @example
-* ```ts
-* toExportName('@kubb/plugin-react-query') // 'pluginReactQuery'
-* toExportName('@kubb/plugin-ts')          // 'pluginTs'
-* ```
-*/
+/** `@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.-]+$/;
-/**
-* Whether Studio may import `packageName` as a plugin: a `@kubb/plugin-*` package, or an installed
-* package whose `kubb-extension.json` has `kind: "plugin"`. A path, URL or arbitrary package is
-* refused before it can execute. `configFile.ts` applies the same rule before printing a plugin name.
-*/
-function isAllowedPlugin({ packageName, extensions }) {
+/** 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 KUBB_PLUGIN_SPECIFIER.test(packageName) || extensions.get(packageName)?.manifest.kind === "plugin";
-}
-/**
-* Dynamically imports an extension package and returns its factory. Callers check
-* {@link isAllowedPlugin} or derive the package from a disk instance first, so an arbitrary module
-* never reaches `import()`.
-*
-* Packages must be pre-installed in the Docker image at build time via the `KUBB_PACKAGES`
-* build ARG, no runtime installation is possible in the distroless container.
-*
-* Resolution order: the manifest's `export`, else the camelCase named export the package name
-* implies (e.g. `pluginTs`), then the default export.
-*
-* @throws if the package cannot be imported or exports no callable factory.
-*/
-async function loadFactory({ packageName, extensions, kind = "plugin" }) {
-	const label = {
-		plugin: "Plugin",
-		adapter: "Adapter",
-		parser: "Parser"
-	}[kind];
-	let mod;
-	try {
-		mod = await importFromProject(packageName);
-	} catch (cause) {
-		throw new Diagnostics.Error({
-			code: kind === "plugin" ? Diagnostics.code.pluginNotFound : Diagnostics.code.unknown,
-			severity: "error",
-			message: `${label} "${packageName}" could not be loaded. Make sure it is installed: \`npm install ${packageName}\``,
-			cause: toError(cause)
-		});
-	}
-	const manifestExport = extensions.get(packageName)?.manifest.export;
-	if (manifestExport) {
-		if (typeof mod[manifestExport] === "function") return mod[manifestExport];
-		throw new Diagnostics.Error({
-			code: Diagnostics.code.incompatibleExtension,
-			severity: "error",
-			message: `${label} "${packageName}" does not export "${manifestExport}", the factory its kubb-extension.json names.`,
-			help: "Install a version of the plugin whose exports match its kubb-extension.json."
-		});
-	}
-	const exportName = toExportName(packageName);
-	if (typeof mod[exportName] === "function") return mod[exportName];
-	if (typeof mod["default"] === "function") return mod["default"];
-	throw new Diagnostics.Error({
-		code: Diagnostics.code.incompatibleExtension,
-		severity: "error",
-		message: `${label} "${packageName}" does not export a callable factory. Tried the named export "${exportName}" and "default".`,
-		help: "Install a Kubb plugin package that exports its factory."
-	});
-}
-/**
-* Resolves each plugin entry by dynamically importing its package and calling its factory with the
-* provided options. Only packages {@link isAllowedPlugin} accepts are loaded.
-*
-* @example
-* ```ts
-* const plugins = await resolvePlugins({
-*   plugins: [
-*     { name: '@kubb/plugin-react-query', options: { output: { path: './hooks' } } },
-*     { name: '@kubb/plugin-ts', options: { output: { path: './types' } } },
-*   ],
-* })
-* ```
-*/
-async function resolvePlugins({ plugins, extensions = /* @__PURE__ */ new Map() }) {
-	return Promise.all(plugins.map(async ({ name, options }) => {
-		if (!isAllowedPlugin({
-			packageName: name,
-			extensions
-		})) throw new Diagnostics.Error({
-			code: Diagnostics.code.pluginNotFound,
-			severity: "error",
-			message: `Plugin "${name}" is not an installed Kubb plugin. Studio loads @kubb/plugin-* packages and installed packages that ship a kubb-extension.json with kind "plugin".`
-		});
-		return (await loadFactory({
-			packageName: name,
-			extensions
-		}))(options ?? {});
-	}));
+	return kind === extensionKinds.plugin && KUBB_PLUGIN_SPECIFIER.test(packageName) || extensions.get(packageName)?.manifest.kind === kind;
 }
-/**
-* Keys that reach an object's prototype when assigned. Never read from or written into options.
-*/
 const UNSAFE_KEYS = /* @__PURE__ */ new Set([
 	"__proto__",
 	"constructor",
 	"prototype"
 ]);
-/**
-* Whether `key` can be used as an option key without touching an object's prototype.
-*/
+/** Whether `key` can be an option key without reaching the object's prototype. */
 function isSafeKey(key) {
 	return !UNSAFE_KEYS.has(key);
 }
-/**
-* A JSON copy of plugin or adapter options: functions and other values JSON cannot hold are left
-* out, so nothing callable crosses the socket. Options that cannot be copied at all, such as a
-* circular structure, come back empty.
-*
-* @example
-* ```ts
-* toJSONOptions({ output: { path: 'types' }, group: { name: () => 'x' } }) // { output: { path: 'types' }, group: {} }
-* ```
-*/
-function toJSONOptions(options) {
-	try {
-		const copy = JSON.parse(JSON.stringify(options ?? {}, (key, value) => isSafeKey(key) && typeof value !== "bigint" ? value : void 0));
-		return isPlainObject(copy) ? copy : {};
-	} catch {
-		return {};
-	}
-}
-/**
-* Whether `value` is an object literal or a null-prototype object, not an array or class instance.
-*/
 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 it can be printed into a config file as a literal.
-* A function, `undefined`, a non-finite number or a class instance comes back from Studio as a
-* lossy copy, so an edit carrying one is refused rather than written into the user's source.
-*/
+/** 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);
@@ -434,375 +326,250 @@ function isOptionValue(value) {
 	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
 /**
-* Deep-merges Studio's options over the disk options, with Studio taking priority, except where the
-* disk value cannot survive JSON. Studio only ever saw a lossy copy of such a value, so the disk
-* value is kept rather than replaced by what Studio echoes back. Plain objects merge key by key, so
-* Studio can still change a literal that sits next to a function (e.g. `group.type` beside `group.name`).
-*
-* @example
-* ```ts
-* mergeOptions({ macros: [camelCaseMacro], syntaxType: 'type' }, { macros: [{ name: 'camelCase' }], syntaxType: 'interface' })
-* // { macros: [camelCaseMacro], syntaxType: 'interface' }
-* mergeOptions({ emptySchemaType: 'any' }, { emptySchemaType: null }) // {}
-* ```
+* 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.
 */
-function mergeOptions(disk, studio) {
-	const merged = { ...disk };
-	for (const [key, value] of Object.entries(studio)) {
-		if (!isSafeKey(key)) continue;
-		const current = disk[key];
-		if (value === null) {
-			if (current === void 0 || isOptionValue(current)) delete merged[key];
-			continue;
-		}
-		if (isPlainObject(current) && isPlainObject(value)) {
-			merged[key] = mergeOptions(current, value);
-			continue;
-		}
-		if (current !== void 0 && !isOptionValue(current)) continue;
-		merged[key] = value;
+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(`'`, `\\'`)}'`;
 	}
-	return merged;
+	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(", ")} }` : "{}";
 }
-/**
-* Merges studio plugin options with disk config plugins.
-* Studio takes priority: options from studio win over disk (except values only the disk config
-* can express, see {@link mergeOptions}), and a plugin Studio explicitly
-* disabled is dropped even when the disk config still lists it. Disk plugins without a studio
-* counterpart are kept as-is. Studio plugins not present on disk are appended.
-*
-* For plugins present in both configs, the plugin is re-instantiated with merged options
-* so that all internal closures correctly reference the merged values.
-*/
-async function mergePlugins({ diskPlugins, studioPlugins, extensions = /* @__PURE__ */ new Map() }) {
-	const pluginNameOf = (packageName) => extensions.get(packageName)?.manifest.name ?? toPluginName(packageName);
-	const disabledNames = new Set((studioPlugins ?? []).filter((entry) => entry.disabled).map((entry) => pluginNameOf(entry.name)));
-	const activeDiskPlugins = disabledNames.size ? diskPlugins?.filter((plugin) => !disabledNames.has(resolveMeta(plugin).name)) : diskPlugins;
-	const activeStudioPlugins = studioPlugins?.filter((entry) => !entry.disabled);
-	if (!activeDiskPlugins && !activeStudioPlugins?.length) return void 0;
-	if (!activeStudioPlugins?.length) return activeDiskPlugins;
-	if (!activeDiskPlugins) return resolvePlugins({
-		plugins: activeStudioPlugins,
-		extensions
-	});
-	const studioEntryByName = new Map(activeStudioPlugins.map((entry) => [pluginNameOf(entry.name), entry]));
-	const diskNames = new Set(activeDiskPlugins.map((plugin) => plugin.name));
-	const merged = await Promise.all(activeDiskPlugins.map(async (diskPlugin) => {
-		const studioEntry = studioEntryByName.get(resolveMeta(diskPlugin).name);
-		if (!studioEntry) return diskPlugin;
-		const diskOptions = diskPlugin.options ?? {};
-		const options = mergeOptions(diskOptions, studioEntry.options ?? {});
-		const unchanged = JSON.stringify(toJSONOptions(options)) === JSON.stringify(toJSONOptions(diskOptions));
-		const [resolved] = await resolvePlugins({
-			plugins: [{
-				name: studioEntry.name,
-				options
-			}],
-			extensions
-		}).catch((cause) => {
-			if (unchanged) return [diskPlugin];
-			throw new Diagnostics.Error({
-				code: Diagnostics.code.pluginNotFound,
-				severity: "error",
-				message: `Plugin "${diskPlugin.name}" is not an installed @kubb/plugin-* package or Kubb extension, so Studio cannot change its options. Edit it in the config file, or only enable or disable it from Studio.`,
-				cause: toError(cause)
-			});
-		});
-		return resolved ?? diskPlugin;
-	}));
-	const studioOnly = activeStudioPlugins.filter((entry) => !diskNames.has(pluginNameOf(entry.name)));
-	return [...merged, ...await resolvePlugins({
-		plugins: studioOnly,
-		extensions
-	})];
-}
-/**
-* Throws `KUBB_PATH_TRAVERSAL` when a plugin would write outside the config's output folder to a path
-* the disk config does not set. Studio can change `output.path`, also inside `override`, and add
-* plugins, so without this check any member of the Studio organization could write any file the agent
-* can reach, including `node_modules` code the next run imports. A path from the config file stays
-* allowed, since a monorepo may write outside its root.
-*/
-function assertOutputPaths({ plugins, diskPlugins, root, outputPath }) {
-	const base = path.resolve(root, outputPath);
-	const targetsOf = (plugin) => {
-		const { output, override } = plugin.options ?? {};
-		return [output, ...Array.isArray(override) ? override.map((entry) => entry?.options?.output) : []].flatMap((entry) => typeof entry?.path === "string" ? [path.resolve(base, entry.path)] : []);
-	};
-	const diskTargets = new Set(diskPlugins.flatMap(targetsOf));
-	for (const plugin of plugins) {
-		const target = targetsOf(plugin).find((resolved) => !diskTargets.has(resolved) && !isPathInside(resolved, base));
-		if (!target) continue;
-		throw new Diagnostics.Error({
-			code: Diagnostics.code.pathTraversal,
-			severity: "error",
-			message: `Plugin "${plugin.name}" would write to "${target}", outside the output folder "${base}". Studio can only set an output path inside it.`,
-			help: "Choose an output path inside the output folder, or set this path in the config file.",
-			location: { kind: "config" },
-			plugin: plugin.name
-		});
-	}
-}
-/**
-* Re-invokes the factory behind a disk adapter or parser with Studio's options merged over its own.
-* An instance carries live functions (`parse`, `print`, ...) that cannot survive JSON, so Studio's
-* options are a patch, not a replacement, and the factory is found from the disk instance itself: the
-* installed extension whose manifest names it, or the `@kubb/<kind>-<name>` package for a built-in
-* one. Throws when no factory resolves, as `mergePlugins` does, so an override Studio sent is never
-* dropped without a word. An extension without a manifest, such as `parserTsx`, has no options in
-* Studio, so Studio never sends one for it.
-*/
-async function rebuildExtension({ disk, studioOptions, kind, extensions }) {
-	if (!studioOptions || !Object.keys(studioOptions).length) return disk;
-	const { name } = resolveMeta(disk);
-	return (await loadFactory({
-		packageName: [...extensions.values()].find(({ manifest }) => manifest.kind === kind && manifest.name === name)?.package ?? `@kubb/${kind}-${name}`,
-		extensions,
-		kind
-	}).catch((cause) => {
-		throw new Diagnostics.Error({
-			code: kind === "plugin" ? Diagnostics.code.pluginNotFound : Diagnostics.code.unknown,
-			severity: "error",
-			message: `The ${kind} "${name}" is not an installed Kubb extension, so Studio cannot change its options. Edit it in the config file.`,
-			cause: toError(cause)
-		});
-	}))(mergeOptions(disk.options ?? {}, studioOptions));
-}
-/** The root `output` members Studio may set, with the values each takes. The rest, `path` and `postGenerate` among them, stay with the config file. */
-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"
-};
-/** Whether Studio may set the root `output` member `key`. */
-function isOutputKey(key) {
-	return Object.hasOwn(OUTPUT_VALUES, key);
-}
-/** Whether Studio may set the root `output` member `key` to `value`. */
-function isOutputValue({ key, value }) {
-	return isOutputKey(key) && OUTPUT_VALUES[key](value);
-}
-/** The members of `output` Studio may see and set. */
-function pickOutput(output) {
-	return Object.fromEntries(Object.entries(output).filter(([key]) => isOutputKey(key)));
+/** 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);
 }
-/** Merges Studio's valid `output` overrides, with `null` unsetting a member. */
-function mergeOutput({ output, studio }) {
-	if (!isPlainObject(studio)) return output;
-	return mergeOptions(output, Object.fromEntries(Object.entries(studio).filter(([key, value]) => value === null ? isOutputKey(key) : isOutputValue({
-		key,
-		value
-	}))));
+/** `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);
 }
 /**
-* Merges Studio-provided adapter option overrides into the disk config's adapter, see {@link rebuildExtension}.
+* 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.
 */
-async function mergeAdapter(diskAdapter, studioOptions, extensions = /* @__PURE__ */ new Map()) {
-	if (!diskAdapter) return diskAdapter;
-	return rebuildExtension({
-		disk: diskAdapter,
-		studioOptions,
-		kind: "adapter",
-		extensions
-	});
+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)}`;
 }
-/**
-* Merges Studio-provided parser option overrides into the disk config's parsers, matched by the name
-* Studio knows each parser by, see {@link rebuildExtension}. Parsers Studio does not name are kept as is.
-*/
-async function mergeParsers({ diskParsers, studioParsers, extensions = /* @__PURE__ */ new Map() }) {
-	if (!studioParsers?.length) return diskParsers;
-	const studioOptions = new Map(studioParsers.map((entry) => [entry.name, entry.options]));
-	return Promise.all(diskParsers.map((parser) => rebuildExtension({
-		disk: parser,
-		studioOptions: studioOptions.get(toStudioName({
-			name: resolveMeta(parser).name,
-			extensions,
-			kind: "parser"
-		})),
-		kind: "parser",
-		extensions
-	})));
+/** 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 src/configFile.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 = /^[A-Za-z_$][\w$]*$/;
-/**
-* The marker line a `disable-plugin` writes above the block it comments out. It carries the block's
-* line count, so `enable-plugin` restores exactly those lines and not whatever comments follow.
-*/
-const DISABLED_MARKER = /^\/\/ kubb:disabled (.+)\s+(\d+)$/;
+//#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 KINDS = /* @__PURE__ */ new Set([
-	"plugin",
-	"adapter",
-	"parser"
-]);
-/**
-* Why an edit from Studio cannot be applied as sent, checked before anything reads its fields.
-* The edit crossed the wire, so its declared type is a promise the sender may not have kept.
-*/
-function invalidEdit(edit) {
+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 isOutput = operation === ConfigEditOperation.SET_OUTPUT || operation === ConfigEditOperation.REMOVE_OUTPUT;
-	if (!isOutput && (typeof plugin !== "string" || !plugin)) return "the edit names no plugin";
-	if (kind !== void 0 && (typeof kind !== "string" || !KINDS.has(kind))) return `unknown kind ${JSON.stringify(kind)}`;
-	if (kind !== void 0 && operation !== ConfigEditOperation.SET && operation !== ConfigEditOperation.REMOVE) return `${operation} edits the plugins array, so it takes no kind`;
-	if (isOutput || operation === ConfigEditOperation.SET || operation === ConfigEditOperation.REMOVE) {
-		if (!Array.isArray(path) || !path.every((key) => typeof key === "string" && key)) return "path must be a list of option names";
-		if (!path.length) 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`;
-	}
-}
-/** Where a node sits in the source text. */
-function rangeOf(node) {
-	if (typeof node.start !== "number" || typeof node.end !== "number") throw new Diagnostics.Error({
-		code: Diagnostics.code.internalError,
-		severity: "error",
-		message: "the config file could not be mapped back to its source text"
-	});
-	return {
-		start: node.start,
-		end: node.end
-	};
-}
-/** `source` with the text between `start` and `end` replaced by `text`. */
-function splice(source, start, end, text = "") {
-	return `${source.slice(0, start)}${text}${source.slice(end)}`;
-}
-function bodyOf(mod) {
-	return mod.$ast.type === "Program" ? mod.$ast.body : [];
-}
-/**
-* Steps through a config's wrappers to the object literal underneath: a `satisfies`/`as`
-* assertion, a `() => ...` factory, or a factory whose block body returns the config.
-*/
-function unwrap(node) {
+	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 === "TSAsExpression" || node.type === "TSSatisfiesExpression") return unwrap(node.expression);
-	if (node.type !== "ArrowFunctionExpression" && node.type !== "FunctionExpression") return node;
-	if (node.body.type !== "BlockStatement") return unwrap(node.body);
-	return unwrap(node.body.body.find((statement) => statement.type === "ReturnStatement")?.argument);
+	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 === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === "module" && node.property.type === "Identifier" && node.property.name === "exports";
-}
-/**
-* Parses `source` and finds every config object in `export default defineConfig(...)` or
-* `module.exports = defineConfig(...)`, or why the file is unmanaged. An array export gets one entry
-* per element, matching a numeric `config` index.
-*
-* Walks the parsed AST rather than magicast's proxies, which throw on node types they cannot
-* cast, most of what an unmanaged config file is made of.
-*/
-function parseConfigs(source) {
-	let mod;
-	try {
-		mod = parseModule(source);
-	} catch {
-		return { reason: "the config file could not be parsed" };
-	}
-	let exported;
-	let kind = "esm";
-	for (const node of bodyOf(mod)) {
-		if (node.type === "ExportDefaultDeclaration") {
-			exported = node.declaration;
-			break;
-		}
-		if (node.type === "ExpressionStatement" && node.expression.type === "AssignmentExpression" && isModuleExports(node.expression.left)) {
-			exported = node.expression.right;
-			kind = "cjs";
-			break;
-		}
+	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
+		};
 	}
-	const value = unwrap(exported);
+	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 !== "CallExpression" || value.callee.type !== "Identifier" || value.callee.name !== "defineConfig") return { reason: "the exported config is not a defineConfig(...) call" };
-	const argument = unwrap(value.arguments[0]);
+	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 === "ArrayExpression" ? argument.elements.map((element) => unwrap(element)) : [argument];
-	const configs = entries.filter((entry) => entry?.type === "ObjectExpression");
+	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 {
-		mod,
+		...parsed,
 		configs,
 		kind
 	};
 }
-/** The name of a `key` or `'key'` member, `undefined` for a spread or a computed key. */
-function memberKey(entry) {
-	if (entry.type === "SpreadElement" || entry.computed) return void 0;
-	return entry.key.type === "Identifier" ? entry.key.name : entry.key.type === "StringLiteral" ? entry.key.value : void 0;
+function findConfigEntry(configs, ref) {
+	return typeof ref === "string" ? configs.find((entry) => getConfigName(entry) === ref) : configs[ref ?? 0];
 }
-/** The member named `key`. The last one wins when the key repeats, as it does when the object is evaluated. */
-function findMember(node, key) {
-	const index = node.properties.findLastIndex((entry) => memberKey(entry) === key);
+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
 	};
 }
-/** The value node of a member. A method or accessor is its own value: it is code, never a literal. */
-function property(node, key) {
-	const member = findMember(node, key)?.member;
-	return member?.type === "ObjectProperty" ? member.value : member;
+function getValue(node, key) {
+	const member = findProperty(node, key)?.member;
+	return member?.type === nodeTypes.property ? member.value : member;
 }
-function configName(config) {
-	const name = property(config, "name");
-	return name?.type === "StringLiteral" ? name.value : void 0;
+function getConfigName(config) {
+	const name = getValue(config, "name");
+	return name?.type === nodeTypes.literal && typeof name.value === "string" ? name.value : void 0;
 }
-/** Whether a `...spread` after the member at `index` could override it. */
-function isShadowed(node, index) {
-	return node.properties.slice(index + 1).some((entry) => entry.type === "SpreadElement");
+function isOverridden(node, index) {
+	return node.properties.slice(index + 1).some((entry) => entry.type === nodeTypes.spreadElement);
 }
-/**
-* Reads a literal node's value: a primitive, or an object/array built only from primitives.
-* `undefined` for anything else, so a caller can use this both to read a value and to check
-* whether a node is a literal at all.
-*/
+/** `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 "StringLiteral":
-		case "NumericLiteral":
-		case "BooleanLiteral": return node.value;
-		case "NullLiteral": return null;
-		case "TemplateLiteral": return node.expressions.length ? void 0 : node.quasis[0]?.value.cooked ?? "";
-		case "UnaryExpression": {
+		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;
-			return node.operator === "-" ? -value : node.operator === "+" ? value : void 0;
+			if (node.operator === unaryOperators.minus) return -value;
+			if (node.operator === unaryOperators.plus) return value;
+			return;
 		}
-		case "ArrayExpression": {
+		case nodeTypes.arrayExpression: {
 			const values = node.elements.map((element) => readLiteral(element));
 			return values.every((value) => value !== void 0) ? values : void 0;
 		}
-		case "ObjectExpression": {
+		case nodeTypes.objectExpression: {
 			const entries = {};
 			for (const entry of node.properties) {
-				if (entry.type !== "ObjectProperty") return void 0;
-				const key = memberKey(entry);
+				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;
@@ -811,158 +578,123 @@ function readLiteral(node) {
 		}
 	}
 }
-/** 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 === `"` ? `"${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(", ")} }` : "{}";
+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
+		}];
+	});
 }
-/** An object key as source text: bare when it is an identifier, quoted otherwise. */
-function printKey(key, quote) {
-	return IDENTIFIER.test(key) ? key : printValue(key, quote);
+/** `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
+			}]];
+		});
+	});
 }
-/** `value` wrapped in one object per key of `path`: `nest(['enum', 'type'], 'enum')` is `{ enum: { type: 'enum' } }`. */
-function nest(path, value) {
-	return path.reduceRight((inner, key) => ({ [key]: inner }), value);
+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 [];
+	}));
 }
-/**
-* 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 insertItem(source, container, text) {
-	const { start, end } = rangeOf(container);
-	const last = (container.type === "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 splice(source, start + 1, start + 1, /^\s/.test(inner) ? `${text},` : `${text}, `);
-		return splice(source, start, end, container.type === "ObjectExpression" ? `{ ${text} }` : `[${text}]`);
-	}
-	const lastRange = rangeOf(last);
-	const between = source.slice(lastRange.end, end - 1);
-	if (!between.includes("\n")) return splice(source, lastRange.end, lastRange.end, `, ${text}`);
-	const lineStart = source.lastIndexOf("\n", lastRange.start - 1) + 1;
-	const indent = source.slice(lineStart).match(/^[ \t]*/)?.[0] ?? "";
-	const lineEnd = source.indexOf("\n", lastRange.end);
-	const comma = /^\s*,/.test(between);
-	return `${source.slice(0, lastRange.end)}${comma ? "" : ","}${source.slice(lastRange.end, lineEnd)}\n${indent}${text}${comma ? "," : ""}${source.slice(lineEnd)}`;
+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
+		}] : [];
+	});
 }
-/** Drops the member at `index` from an object literal, with its own lines when it sits on them alone. */
-function removeMember(source, node, index) {
-	if (node.properties.length === 1) return splice(source, rangeOf(node).start, rangeOf(node).end, "{}");
-	const { start, end } = rangeOf(node.properties[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 splice(source, lineStart, Math.min(lineEnd + 1, source.length));
-	const next = node.properties[index + 1];
-	return next ? splice(source, start, rangeOf(next).start) : splice(source, rangeOf(node.properties[index - 1]).end, end);
+/** 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 module a `require('...')` call loads, when `node` is one. */
-function requiredModule(node) {
-	if (node?.type !== "CallExpression" || node.callee.type !== "Identifier" || node.callee.name !== "require") return void 0;
-	const [argument] = node.arguments;
-	return argument?.type === "StringLiteral" ? argument.value : void 0;
-}
-/** Maps each identifier the file imports, through `import { x } from` or `const { x } = require(...)`, to its module. */
-function importedFrom(mod) {
-	const imports = /* @__PURE__ */ new Map();
-	for (const statement of bodyOf(mod)) {
-		if (statement.type === "ImportDeclaration") {
-			for (const specifier of statement.specifiers) {
-				const imported = specifier.type === "ImportSpecifier" ? specifier.imported : specifier.local;
-				imports.set(specifier.local.name, {
-					from: statement.source.value,
-					exported: imported.type === "Identifier" ? imported.name : imported.value
-				});
-			}
-			continue;
-		}
-		if (statement.type !== "VariableDeclaration") continue;
-		for (const declarator of statement.declarations) {
-			const from = requiredModule(declarator.init);
-			if (from === void 0 || declarator.id.type !== "ObjectPattern") continue;
-			for (const entry of declarator.id.properties) if (entry.type === "ObjectProperty" && entry.value.type === "Identifier") imports.set(entry.value.name, {
-				from,
-				exported: memberKey(entry) ?? entry.value.name
-			});
-		}
-	}
-	return imports;
-}
-/**
-* Every factory call of one kind that resolves to an import: the `pluginX(...)` elements of the
-* `plugins` array, the `adapter` value, or the elements of the `parsers` array.
-*/
-function factoryCalls(mod, config, kind = "plugin") {
-	const node = property(config, kind === "adapter" ? "adapter" : `${kind}s`);
-	const elements = kind === "adapter" ? [node] : node?.type === "ArrayExpression" ? node.elements : [];
-	const imports = importedFrom(mod);
-	return elements.flatMap((element) => {
-		if (element?.type !== "CallExpression" || element.callee.type !== "Identifier") return [];
-		const imported = imports.get(element.callee.name);
-		return imported ? [{
-			importName: element.callee.name,
-			exportName: imported.exported,
-			packageName: imported.from,
-			call: element
-		}] : [];
-	});
-}
-/**
-* The blocks a previous `disable-plugin` commented out of this config, read from the marker lines
-* since a commented-out call is no longer a node. `code` holds the block's lines as they were.
-*/
-function disabledBlocks(source, config) {
+/** 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");
-	const first = config.loc?.start.line ?? 0;
-	const last = config.loc?.end.line ?? Number.POSITIVE_INFINITY;
-	return lines.flatMap((text, index) => {
-		const match = text.trim().match(DISABLED_MARKER);
-		if (!match || index + 1 < first || index + 1 > last) return [];
-		const end = index + 1 + Number(match[2]);
-		const code = lines.slice(index + 1, end).map((line) => line.replace(/^(\s*)\/\/ ?/, "$1").replace(/^\s+$/, ""));
+	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: index + 1,
+			line,
 			end,
 			code
 		}];
 	});
 }
-/**
-* Reads an object option that holds some code: its literal members as `value`, and the paths of
-* the members that are code as `locked`. `set` can write any path outside `locked`, so Studio
-* edits those fields. `undefined` for a computed key, since it could set any path.
-*/
-function readPartial(node, prefix = []) {
+/** 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 === "SpreadElement") continue;
-		const key = memberKey(entry);
+		if (entry.type === nodeTypes.spreadElement) continue;
+		const key = getKey(entry);
 		if (key === void 0) return void 0;
-		if (findMember(node, key)?.index !== index) continue;
+		if (findProperty(node, key)?.index !== index) continue;
 		const path = [...prefix, key];
 		if (!isSafeKey(key)) {
 			locked.push(path);
 			continue;
 		}
-		const member = entry.type === "ObjectProperty" && !isShadowed(node, index) ? entry.value : void 0;
+		const member = isOverridden(node, index) ? void 0 : entry.value;
 		const literal = readLiteral(member);
 		if (literal !== void 0) {
 			value[key] = literal;
 			continue;
 		}
-		if (member?.type !== "ObjectExpression") {
+		if (member?.type !== nodeTypes.objectExpression) {
 			locked.push(path);
 			continue;
 		}
-		const nested = readPartial(member, path);
+		const nested = readEditable(member, path);
 		if (!nested) return void 0;
 		value[key] = nested.value;
 		locked.push(...nested.locked);
@@ -972,142 +704,144 @@ function readPartial(node, prefix = []) {
 		locked
 	};
 }
-/** The top-level options of a plugin call, each flagged with whether Studio may write it. */
-function readOptions(call) {
-	const options = call.arguments[0];
-	return options?.type === "ObjectExpression" ? readObject(options) : {};
-}
-/** The members of an object literal, each flagged with whether Studio may write it. */
-function readObject(options) {
+function readObjectOptions(options) {
 	const entries = {};
 	for (const [index, entry] of options.properties.entries()) {
-		const key = memberKey(entry);
+		const key = getKey(entry);
 		if (key === void 0 || !isSafeKey(key)) continue;
-		const member = entry.type === "ObjectProperty" && !isShadowed(options, index) ? entry.value : void 0;
+		const member = entry.type === nodeTypes.property && !isOverridden(options, index) ? entry.value : void 0;
 		const value = readLiteral(member);
-		const partial = value === void 0 && member?.type === "ObjectExpression" ? readPartial(member) : void 0;
-		entries[key] = value !== void 0 ? {
-			literal: true,
-			value
-		} : {
+		if (value !== void 0) {
+			entries[key] = {
+				literal: true,
+				value
+			};
+			continue;
+		}
+		entries[key] = {
 			literal: false,
-			...partial
+			...member?.type === nodeTypes.objectExpression ? readEditable(member) : void 0
 		};
 	}
 	return entries;
 }
-/** The options a commented-out plugin call holds, so Studio can show them while it is disabled. */
+function readCallOptions(call) {
+	const options = call.arguments[0];
+	return options?.type === nodeTypes.objectExpression ? readObjectOptions(options) : {};
+}
 function readDisabledOptions(code) {
-	try {
-		const call = parseExpression(code.join("\n").trim().replace(/,$/, "")).$ast;
-		return call.type === "CallExpression" ? readOptions(call) : {};
-	} catch {
-		return {};
-	}
+	const call = parseExpression(code.join("\n").trim().replace(/,$/, ""));
+	return call?.type === nodeTypes.callExpression ? readCallOptions(call) : {};
 }
-/**
-* Reads which plugins the file declares and which of their options Studio may write.
-*
-* @example
-* ```ts
-* const view = readConfig(await readFile('kubb.config.ts', 'utf8'))
-* if (view.managed) {
-*   view.configs.forEach((config) => console.log(config.name, config.plugins.length))
-* }
-* ```
-*/
+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 = parseConfigs(source);
+	const parsed = findConfigs(source);
 	if ("reason" in parsed) return {
 		managed: false,
 		reason: parsed.reason
 	};
-	const { mod, configs } = parsed;
-	const importNames = new Map([...importedFrom(mod)].map(([local, { from }]) => [from, local]));
 	return {
 		managed: true,
-		configs: configs.map((config) => {
-			const active = factoryCalls(mod, config).map(({ importName, packageName, call }) => ({
-				line: call.loc?.start.line ?? 0,
-				plugin: {
-					importName,
-					packageName,
-					options: readOptions(call)
-				}
-			}));
-			const disabled = disabledBlocks(source, config).map(({ packageName, line, code }) => ({
-				line,
-				plugin: {
-					importName: importNames.get(packageName) ?? toExportName(packageName),
-					packageName,
-					options: readDisabledOptions(code),
-					disabled: true
-				}
-			}));
-			const plugins = [...active, ...disabled].sort((a, b) => a.line - b.line).map(({ plugin }) => plugin);
-			const toView = ({ importName, packageName, call }) => ({
-				importName,
-				packageName,
-				options: readOptions(call)
-			});
-			const [adapter] = factoryCalls(mod, config, "adapter").map(toView);
-			const parsers = factoryCalls(mod, config, "parser").map(toView);
-			const output = outputObject(config);
-			return {
-				name: configName(config),
-				plugins,
-				...adapter && { adapter },
-				...parsers.length ? { parsers } : {},
-				...!("reason" in output) && { output: pickOutput(readObject(output.object)) }
-			};
-		})
+		configs: parsed.configs.map((config) => readConfigView({
+			source,
+			parsed,
+			config
+		}))
 	};
 }
-/** The modules the config file imports, in source order. Empty when the file cannot be parsed. */
+/** The modules the file imports, empty when it cannot be parsed. */
 function readImports(source) {
-	try {
-		return [...new Set([...importedFrom(parseModule(source)).values()].map(({ from }) => from))];
-	} catch {
-		return [];
-	}
+	const parsed = parseSource(source);
+	if ("reason" in parsed) return [];
+	return [...new Set([...getImports(parsed.program).values()].map(({ from }) => from))];
 }
-/**
-* Walks `path` through a plugin's options to the literal at its last key. Returns `missing` with
-* the index of the first key that is not there yet, so `set` can write the rest of the path as one
-* nested literal and `remove` can report it as unset. Refuses a value customized in code, so it is
-* never overwritten.
-*/
-function walk(options, path) {
+/** 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 = findMember(object, key);
+		const found = findProperty(object, key);
 		if (!found) return {
 			object,
 			missing: depth
 		};
-		if (isShadowed(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` };
+		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 === "ObjectProperty" && readLiteral(member.value) !== void 0 ? {
+		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 !== "ObjectProperty" || member.value.type !== "ObjectExpression") return { reason: `${key} is not an object, so ${path.join(".")} cannot be reached` };
+		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" };
 }
-/** Writes `value` at `path` inside a plugin call's options, adding the options object and any intermediate object it needs. */
-function applySet(source, call, path, value, quote) {
+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 = rangeOf(call).end - 1;
+		const closing = call.end - 1;
 		if (source[closing] !== ")") return { reason: "the factory call could not be located in the file" };
-		return { source: splice(source, closing, closing, printValue(nest(path, value), quote)) };
+		return { source: replaceText(source, closing, closing, printValue(wrapPath(path, value), quote)) };
 	}
-	if (options.type !== "ObjectExpression") return { reason: "the factory was not called with an object literal" };
-	return setIn({
+	if (options.type !== nodeTypes.objectExpression) return { reason: "the factory was not called with an object literal" };
+	return setAtPath({
 		source,
 		options,
 		path,
@@ -1115,46 +849,56 @@ function applySet(source, call, path, value, quote) {
 		quote
 	});
 }
-/** Writes the literal `value` at `path` inside `options`, adding any intermediate object it needs. */
-function setIn({ source, options, path, value, quote }) {
-	const target = walk(options, path);
-	if ("reason" in target) return target;
-	if ("missing" in target) {
-		const [key, ...rest] = path.slice(target.missing);
-		return { source: insertItem(source, target.object, `${printKey(key, quote)}: ${printValue(nest(rest, 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` };
 	}
-	return { source: splice(source, rangeOf(target.value).start, rangeOf(target.value).end, printValue(value, quote)) };
+	if (edit.operation === ConfigEditOperation.SET_OPTION) return setOption(source, call, edit.path, edit.value, quote);
+	return removeOption(source, call, edit.path);
 }
-/** Writes the config's top-level `input` as a string literal, replacing what it held. */
-function applySetInput(source, config, input, quote) {
+function setInput(source, config, input, quote) {
 	const value = printValue(input, quote);
-	const found = findMember(config, "input");
-	if (!found) return { source: insertItem(source, config, `input: ${value}`) };
-	if (found.member.type !== "ObjectProperty") return { reason: "input is not a plain property" };
-	if (isShadowed(config, found.index)) return { reason: "a spread after input could override it" };
-	return { source: splice(source, rangeOf(found.member.value).start, rangeOf(found.member.value).end, value) };
-}
-/** The config's root `output` object literal, or why Studio cannot edit inside it. */
-function outputObject(config) {
-	const found = findMember(config, "output");
-	if (found?.member.type !== "ObjectProperty" || found.member.value.type !== "ObjectExpression") return { reason: "output is not an object literal" };
-	if (isShadowed(config, found.index)) return { reason: "a spread after output could override it" };
+	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 };
 }
-/** Writes or drops a member of the config's root `output` object. */
-function applyOutputEdit({ source, config, edit, quote }) {
-	const output = outputObject(config);
+function editOutput({ source, config, edit, quote }) {
+	const output = getOutput(config);
 	if ("reason" in output) return output;
-	if (edit.operation === ConfigEditOperation.REMOVE_OUTPUT) return removeIn({
+	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: edit.path[0],
-		value: nest(edit.path.slice(1), edit.value)
-	})) return { reason: `the value is not one output.${edit.path[0]} takes` };
-	return setIn({
+		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,
@@ -1162,163 +906,216 @@ function applyOutputEdit({ source, config, edit, quote }) {
 		quote
 	});
 }
-/**
-* Deletes the option at `path`, falling the plugin back to its default for it. An option the file
-* does not set already has its default, so removing it changes nothing.
-*/
-function applyRemove(source, call, path) {
-	const options = call.arguments[0];
-	if (!options) return { source };
-	if (options.type !== "ObjectExpression") return { reason: "the factory was not called with an object literal" };
-	return removeIn({
-		source,
-		options,
-		path
-	});
-}
-/** Deletes the member at `path` inside `options`. A path that is not there already holds its default. */
-function removeIn({ source, options, path }) {
-	const target = walk(options, path);
-	if ("reason" in target) return target;
-	if ("missing" in target) return { source };
-	return { source: removeMember(source, target.object, target.index) };
-}
-/**
-* Writes an import after the last one already in the file, matching its quote style and whether it
-* ends in a semicolon: `import { x } from '...'`, or `const { x } = require('...')` in a CommonJS file.
-* The last import is read off the AST, so a multi-line `import {\n  x,\n} from '...'` counts to its closing line.
-*/
-function insertImport(source, { mod, kind }, importName, moduleSpecifier) {
-	const afterLine = bodyOf(mod).findLast((node) => kind === "esm" ? node.type === "ImportDeclaration" : node.type === "VariableDeclaration" && node.declarations.some((declarator) => requiredModule(declarator.init) !== void 0))?.loc?.end.line ?? 0;
+/** 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 lastImportLine = afterLine > 0 ? lines[afterLine - 1] : void 0;
-	const quote = lastImportLine?.includes(`"`) ? `"` : `'`;
-	const semicolon = lastImportLine?.trimEnd().endsWith(";") ? ";" : "";
+	const semicolon = afterLine > 0 && lines[afterLine - 1]?.trimEnd().endsWith(";") ? ";" : "";
 	const specifier = `${quote}${moduleSpecifier}${quote}`;
-	lines.splice(afterLine, 0, kind === "esm" ? `import { ${importName} } from ${specifier}${semicolon}` : `const { ${importName} } = require(${specifier})${semicolon}`);
+	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");
 }
 /**
-* Adds a `pluginX(...)` call to a config's plugins array, and its import. Replaying the same add is
-* a no-op, while an import name collision with an unrelated package remains an error.
+* 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.
 */
-function applyAddPlugin({ source, parsed, config, edit, quote, extensions }) {
+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
-	})) return { reason: `"${edit.plugin}" is not a @kubb/plugin-* package or an installed Kubb 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.test(importName)) return { reason: `"${importName}" is not a valid import name` };
-	if (factoryCalls(parsed.mod, config).some((plugin) => plugin.packageName === edit.plugin)) return { source };
-	const taken = importedFrom(parsed.mod).get(importName)?.from;
-	if (taken && taken !== edit.plugin) return { reason: `${importName} is already imported from ${taken}` };
+	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 plugins = property(config, "plugins");
-	if (plugins?.type !== "ArrayExpression") return { reason: "plugins is not an array literal" };
-	const next = insertItem(source, plugins, `${importName}(${Object.keys(options).length ? printValue(options, quote) : ""})`);
-	return { source: taken ? next : insertImport(next, parsed, importName, edit.plugin) };
+	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) };
 }
-/**
-* Rewrites the config's `plugins` array with one item per line, so a call can be commented out without
-* taking its neighbors with it. Not done when a comment sits between the items, which would have to move.
-*/
-function expandPluginsArray(source, config) {
-	const array = property(config, "plugins");
-	if (array?.type !== "ArrayExpression") return void 0;
+/** 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 } = rangeOf(array);
-	const ranges = items.map(rangeOf);
-	const gaps = [source.slice(start + 1, ranges[0]?.start ?? end - 1), ...ranges.map((range, index) => source.slice(range.end, ranges[index + 1]?.start ?? end - 1))];
+	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 splice(source, start, end, `[\n${ranges.map((range) => `${indent}  ${source.slice(range.start, range.end)},`).join("\n")}\n${indent}]`);
+	return replaceText(source, start, end, `[\n${items.map((item) => `${indent}  ${source.slice(item.start, item.end)},`).join("\n")}\n${indent}]`);
 }
-/** Comments out a plugin call in place, keeping its options on disk so `enable-plugin` can restore them exactly. */
-function disablePlugin(source, mod, config, plugin) {
-	const loc = factoryCalls(mod, config).find((entry) => entry.packageName === plugin)?.call.loc;
-	if (!loc) return { reason: `${plugin} is not in the plugins array` };
+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 = loc.start.line - 1;
-	const to = loc.end.line - 1;
+	const from = start.line - 1;
+	const to = end.line - 1;
 	const firstLine = lines[from] ?? "";
-	if (firstLine.slice(0, loc.start.column).trim() || !/^,?\s*$/.test((lines[to] ?? "").slice(loc.end.column))) return { reason: `${plugin} shares a line with other code, so it cannot be commented out safely` };
+	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") };
 }
-/** Uncomments the block a previous `disable-plugin` left behind for `plugin` in this config. */
-function enablePlugin(source, config, plugin) {
-	const block = disabledBlocks(source, config).find((entry) => entry.packageName === plugin);
+/** 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") };
 }
-/** Applies one edit to `source`. Every edit re-parses the file, since the previous one rewrote it. */
-function applyEdit({ source, edit, quote, extensions }) {
-	const parsed = parseConfigs(source);
+/** 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 ref = edit.config;
-	const findConfig = (entries) => typeof ref === "string" ? entries.configs.find((entry) => configName(entry) === ref) : entries.configs[ref ?? 0];
-	const config = findConfig(parsed);
-	if (!config) return { reason: `no config entry found for ${JSON.stringify(ref)}` };
-	if (edit.operation === ConfigEditOperation.SET_INPUT) return applySetInput(source, config, edit.input, quote);
-	if (edit.operation === ConfigEditOperation.SET_OUTPUT || edit.operation === ConfigEditOperation.REMOVE_OUTPUT) return applyOutputEdit({
-		source,
-		config,
-		edit,
-		quote
-	});
-	if (edit.operation === ConfigEditOperation.DISABLE_PLUGIN) {
-		const result = disablePlugin(source, parsed.mod, config, edit.plugin);
-		if (!("reason" in result) || !result.reason.includes("shares a line")) return result;
-		const expanded = expandPluginsArray(source, config);
-		const reparsed = expanded === void 0 ? void 0 : parseConfigs(expanded);
-		const reparsedConfig = reparsed && !("reason" in reparsed) ? findConfig(reparsed) : void 0;
-		return expanded !== void 0 && reparsed && !("reason" in reparsed) && reparsedConfig ? disablePlugin(expanded, reparsed.mod, reparsedConfig, edit.plugin) : result;
-	}
-	if (edit.operation === ConfigEditOperation.ENABLE_PLUGIN) return enablePlugin(source, config, edit.plugin);
-	if (edit.operation === ConfigEditOperation.ADD_PLUGIN) return applyAddPlugin({
-		source,
-		parsed,
-		config,
-		edit,
-		quote,
-		extensions
-	});
-	const kind = edit.kind ?? "plugin";
-	const calls = factoryCalls(parsed.mod, 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 === "adapter") return { reason: `${edit.plugin} is not the config's adapter` };
-		return { reason: kind === "plugin" && disabledBlocks(source, config).some((block) => block.packageName === edit.plugin) ? `${edit.plugin} is disabled, enable it first` : `${edit.plugin} is not in the ${kind}s array` };
+	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
+		});
 	}
-	return edit.operation === ConfigEditOperation.SET ? applySet(source, call, edit.path, edit.value, quote) : applyRemove(source, call, edit.path);
 }
-/**
-* Applies edits to a `kubb.config.ts` in place. Each edit rewrites only the text it targets, so
-* comments, formatting, and hand-written code around the config survive.
-*
-* Edits are independent: one that cannot be applied is reported in `outcomes` and the rest still run.
-*
-* @example
-* ```ts
-* const { source, outcomes } = applyConfigEdits({
-*   source: current,
-*   edits: [{ operation: 'set', plugin: '@kubb/plugin-ts', path: ['enum', 'type'], value: 'enum' }],
-* })
-* ```
-*/
-function applyConfigEdits({ source, edits, extensions = /* @__PURE__ */ new Map() }) {
+/** 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 quote = detectCodeFormat(source).quote === "double" ? `"` : `'`;
 	const outcomes = edits.map((edit) => {
-		const invalid = invalidEdit(edit);
+		const invalid = validateEdit(edit);
 		if (invalid) return {
 			edit,
 			applied: false,
@@ -1328,7 +1125,6 @@ function applyConfigEdits({ source, edits, extensions = /* @__PURE__ */ new Map(
 			const result = applyEdit({
 				source: current,
 				edit,
-				quote,
 				extensions
 			});
 			if ("reason" in result) return {
@@ -1355,17 +1151,14 @@ function applyConfigEdits({ source, edits, extensions = /* @__PURE__ */ new Map(
 		changed: current !== source
 	};
 }
-/**
-* Applies `edits` to the config file at `filePath`, writing it only when something changed.
-* `add-plugin` accepts `@kubb/plugin-*` packages and the plugins in `extensions`.
-*/
-async function writeConfigEdits({ filePath, edits, extensions }) {
-	const result = applyConfigEdits({
+/** 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 writeFile(filePath, result.source, "utf-8");
+	if (result.changed) await writeRaw(filePath, result.source);
 	return result;
 }
 //#endregion
@@ -1916,149 +1709,474 @@ function createGenerationStream(hooks, jobId) {
 			} : void 0
 		}]
 	};
-	function forward(type) {
-		on(type, (...args) => {
-			emitEvent(type, projections[type](...args));
-			if (!isDiscardable(type)) return new Promise((resolve) => setImmediate(resolve));
+	function forward(type) {
+		on(type, (...args) => {
+			emitEvent(type, projections[type](...args));
+			if (!isDiscardable(type)) return new Promise((resolve) => setImmediate(resolve));
+		});
+	}
+	on("kubb:build:start", ({ config }) => {
+		root = config.root;
+	});
+	for (const type of generationEventTypes) forward(type);
+	on("kubb:generation:end", ({ diagnostics = [], status, hrStart, filesCreated }) => {
+		if (!hrStart) return;
+		emitEvent("kubb:generation:summary", [{
+			duration: Math.round(getElapsedMs(hrStart)),
+			fileCount: filesCreated ?? 0,
+			failedPlugins: Diagnostics.failedPlugins(diagnostics).length,
+			status: status ?? "success"
+		}]);
+	});
+	/**
+	* Takes this generation's listeners off the session emitter. Safe to call twice.
+	*/
+	function detach() {
+		for (const unhook of unhooks) unhook();
+		unhooks.length = 0;
+	}
+	async function close() {
+		if (closed) return;
+		closed = true;
+		detach();
+		controller.close();
+	}
+	function fail(error) {
+		detach();
+		if (closed) return;
+		closed = true;
+		controller.error(error);
+	}
+	return {
+		stream,
+		close,
+		fail
+	};
+}
+//#endregion
+//#region src/publicFetch.ts
+const MAX_REDIRECTS = 5;
+const MAX_BYTES = 52428800;
+const REDIRECTS = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+const NO_BODY = /* @__PURE__ */ new Set([
+	204,
+	205,
+	304
+]);
+function notPublic(host) {
+	return /* @__PURE__ */ new Error(`${host} is not a public address, so a managed agent does not fetch from it`);
+}
+function createLookup(blocked) {
+	return (hostname, options, callback) => {
+		dns.lookup(hostname, {
+			...options,
+			all: true
+		}, (error, addresses) => {
+			if (error) return callback(error, "", 0);
+			const found = addresses;
+			if (!found.length || found.some(({ address }) => !isPublicAddress(address, blocked))) return callback(notPublic(hostname), "", 0);
+			return options.all ? callback(null, found) : callback(null, found[0].address, found[0].family);
+		});
+	};
+}
+function request({ url, blocked, signal }) {
+	if (url.protocol !== "http:" && url.protocol !== "https:") return Promise.reject(/* @__PURE__ */ new Error(`Only http and https URLs are fetched, not ${url.protocol}`));
+	const host = url.hostname.replace(/^\[|\]$/g, "");
+	if (net.isIP(host) && !isPublicAddress(host, blocked)) return Promise.reject(notPublic(host));
+	return new Promise((resolve, reject) => {
+		const req = (url.protocol === "https:" ? https.request : http.request)(url, {
+			method: "GET",
+			lookup: createLookup(blocked),
+			signal: signal ?? void 0,
+			headers: { "accept-encoding": "identity" }
+		}, (res) => {
+			const headers = new Headers();
+			for (const [key, value] of Object.entries(res.headers)) for (const item of [value].flat()) if (item !== void 0) headers.append(key, item);
+			let total = 0;
+			const limit = new Transform({ transform(chunk, _encoding, done) {
+				total += chunk.length;
+				done(total > MAX_BYTES ? /* @__PURE__ */ new Error("The response is larger than 50 MB") : null, chunk);
+			} });
+			res.on("error", (error) => limit.destroy(error));
+			res.pipe(limit);
+			const body = NO_BODY.has(res.statusCode ?? 0) ? null : Readable.toWeb(limit);
+			resolve(new Response(body, {
+				status: res.statusCode,
+				statusText: res.statusMessage,
+				headers
+			}));
+		});
+		req.on("error", reject);
+		req.end();
+	});
+}
+/**
+* Builds a `fetch` that only reaches addresses `blocked` does not list. It follows redirects itself
+* and checks every hop, and takes GET requests only, since that is all a spec load needs.
+*/
+function createPublicFetch(blocked) {
+	const publicFetch = async (input, init) => {
+		if (typeof input !== "string" && !(input instanceof URL)) throw new TypeError("A managed agent fetches by URL only");
+		if (init?.method && init.method.toUpperCase() !== "GET") throw new TypeError("A managed agent only sends GET requests");
+		let url = new URL(input);
+		for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+			const response = await request({
+				url,
+				blocked,
+				signal: init?.signal
+			});
+			const location = response.headers.get("location");
+			if (!REDIRECTS.has(response.status) || !location) return response;
+			await response.body?.cancel();
+			url = new URL(location, url);
+		}
+		throw new Error(`Stopped after ${MAX_REDIRECTS} redirects from ${String(input)}`);
+	};
+	return publicFetch;
+}
+/**
+* Runs `run` with the global `fetch` limited to public addresses, then puts the original back.
+* A managed agent runs one job at a time, so nothing else shares the window.
+*/
+async function withPublicFetch(run) {
+	const original = globalThis.fetch;
+	globalThis.fetch = createPublicFetch();
+	try {
+		return await run();
+	} finally {
+		globalThis.fetch = original;
+	}
+}
+//#endregion
+//#region src/resolveConfig.ts
+/**
+* Turns the JSON config Studio sends back into live Kubb objects.
+*
+* A plugin or adapter instance carries closures (`parse`, `getImports`, ...) that cannot survive
+* JSON, so both sides pass options over the wire and the factory is re-invoked here with the merged
+* result. Only packages {@link isAllowedPlugin} accepts are resolved this way, never an arbitrary
+* module the payload names.
+*/
+/**
+* Imports a package, falling back to how the user's project would resolve it.
+*
+* `import()` resolves from this file, so a linked or globally installed Studio (`pnpm link`,
+* `npm i -g`) only sees its own `node_modules` and misses the plugins installed next to the user's
+* config. The retry resolves from `process.cwd()` instead.
+*/
+async function importFromProject(packageName) {
+	try {
+		return await import(packageName);
+	} catch {
+		const resolved = createRequire(pathToFileURL(`${process.cwd()}/`)).resolve(packageName);
+		const esm = resolved.replace(/\.cjs$/, ".js");
+		return await import(pathToFileURL(esm !== resolved && existsSync(esm) ? esm : resolved).href);
+	}
+}
+/**
+* Adds the `@kubb/` scope a plugin's package carries but its `name` does not, the inverse of
+* {@link toPluginName}. A name outside the `plugin-` convention is left alone, so a third-party
+* plugin is not reported as one of Kubb's.
+*
+* @example
+* ```ts
+* toPackageName('plugin-ts')       // '@kubb/plugin-ts'
+* toPackageName('@acme/my-plugin') // '@acme/my-plugin'
+* ```
+*/
+function toPackageName(name) {
+	return name.startsWith("plugin-") ? `@kubb/${name}` : name;
+}
+/**
+* The name Studio knows an extension by: the package of the installed extension whose manifest
+* `name` matches, otherwise its own `name`, so a plugin defined in the user's project is never
+* reported as a Kubb package that does not exist.
+*
+* @example
+* ```ts
+* toStudioName({ name: 'plugin-ts', extensions })              // '@kubb/plugin-ts'
+* toStudioName({ name: 'plugin-zod-operations', extensions })  // 'plugin-zod-operations', a local plugin
+* ```
+*/
+function toStudioName({ name, extensions = /* @__PURE__ */ new Map(), kind = "plugin" }) {
+	return [...extensions.values()].find(({ manifest }) => manifest.kind === kind && manifest.name === name)?.package ?? name;
+}
+/**
+* Dynamically imports an extension package and returns its factory. Callers check
+* {@link isAllowedPlugin} or derive the package from a disk instance first, so an arbitrary module
+* never reaches `import()`.
+*
+* Packages must be pre-installed in the Docker image at build time via the `KUBB_PACKAGES`
+* build ARG, no runtime installation is possible in the distroless container.
+*
+* Resolution order: the manifest's `export`, else the camelCase named export the package name
+* implies (e.g. `pluginTs`), then the default export.
+*
+* @throws if the package cannot be imported or exports no callable factory.
+*/
+async function loadFactory({ packageName, extensions, kind = "plugin" }) {
+	const label = {
+		plugin: "Plugin",
+		adapter: "Adapter",
+		parser: "Parser"
+	}[kind];
+	let mod;
+	try {
+		mod = await importFromProject(packageName);
+	} catch (cause) {
+		throw new Diagnostics.Error({
+			code: kind === "plugin" ? Diagnostics.code.pluginNotFound : Diagnostics.code.unknown,
+			severity: "error",
+			message: `${label} "${packageName}" could not be loaded. Make sure it is installed: \`npm install ${packageName}\``,
+			cause: toError(cause)
+		});
+	}
+	const manifestExport = extensions.get(packageName)?.manifest.export;
+	if (manifestExport) {
+		if (typeof mod[manifestExport] === "function") return mod[manifestExport];
+		throw new Diagnostics.Error({
+			code: Diagnostics.code.incompatibleExtension,
+			severity: "error",
+			message: `${label} "${packageName}" does not export "${manifestExport}", the factory its kubb-extension.json names.`,
+			help: "Install a version of the plugin whose exports match its kubb-extension.json."
+		});
+	}
+	const exportName = toExportName(packageName);
+	if (typeof mod[exportName] === "function") return mod[exportName];
+	if (typeof mod["default"] === "function") return mod["default"];
+	throw new Diagnostics.Error({
+		code: Diagnostics.code.incompatibleExtension,
+		severity: "error",
+		message: `${label} "${packageName}" does not export a callable factory. Tried the named export "${exportName}" and "default".`,
+		help: "Install a Kubb plugin package that exports its factory."
+	});
+}
+/**
+* Resolves each plugin entry by dynamically importing its package and calling its factory with the
+* provided options. Only packages {@link isAllowedPlugin} accepts are loaded.
+*
+* @example
+* ```ts
+* const plugins = await resolvePlugins({
+*   plugins: [
+*     { name: '@kubb/plugin-react-query', options: { output: { path: './hooks' } } },
+*     { name: '@kubb/plugin-ts', options: { output: { path: './types' } } },
+*   ],
+* })
+* ```
+*/
+async function resolvePlugins({ plugins, extensions = /* @__PURE__ */ new Map() }) {
+	return Promise.all(plugins.map(async ({ name, options }) => {
+		if (!isAllowedPlugin({
+			packageName: name,
+			extensions
+		})) throw new Diagnostics.Error({
+			code: Diagnostics.code.pluginNotFound,
+			severity: "error",
+			message: `Plugin "${name}" is not an installed Kubb plugin. Studio loads @kubb/plugin-* packages and installed packages that ship a kubb-extension.json with kind "plugin".`
+		});
+		return (await loadFactory({
+			packageName: name,
+			extensions
+		}))(options ?? {});
+	}));
+}
+/**
+* A JSON copy of plugin or adapter options: functions and other values JSON cannot hold are left
+* out, so nothing callable crosses the socket. Options that cannot be copied at all, such as a
+* circular structure, come back empty.
+*
+* @example
+* ```ts
+* toJSONOptions({ output: { path: 'types' }, group: { name: () => 'x' } }) // { output: { path: 'types' }, group: {} }
+* ```
+*/
+function toJSONOptions(options) {
+	try {
+		const copy = JSON.parse(JSON.stringify(options ?? {}, (key, value) => isSafeKey(key) && typeof value !== "bigint" ? value : void 0));
+		return isPlainObject(copy) ? copy : {};
+	} catch {
+		return {};
+	}
+}
+/**
+* Deep-merges Studio's options over the disk options, with Studio taking priority, except where the
+* disk value cannot survive JSON. Studio only ever saw a lossy copy of such a value, so the disk
+* value is kept rather than replaced by what Studio echoes back. Plain objects merge key by key, so
+* Studio can still change a literal that sits next to a function (e.g. `group.type` beside `group.name`).
+*
+* @example
+* ```ts
+* mergeOptions({ macros: [camelCaseMacro], syntaxType: 'type' }, { macros: [{ name: 'camelCase' }], syntaxType: 'interface' })
+* // { macros: [camelCaseMacro], syntaxType: 'interface' }
+* mergeOptions({ emptySchemaType: 'any' }, { emptySchemaType: null }) // {}
+* ```
+*/
+function mergeOptions(disk, studio) {
+	const merged = { ...disk };
+	for (const [key, value] of Object.entries(studio)) {
+		if (!isSafeKey(key)) continue;
+		const current = disk[key];
+		if (value === null) {
+			if (current === void 0 || isOptionValue(current)) delete merged[key];
+			continue;
+		}
+		if (isPlainObject(current) && isPlainObject(value)) {
+			merged[key] = mergeOptions(current, value);
+			continue;
+		}
+		if (current !== void 0 && !isOptionValue(current)) continue;
+		merged[key] = value;
+	}
+	return merged;
+}
+/**
+* Merges studio plugin options with disk config plugins.
+* Studio takes priority: options from studio win over disk (except values only the disk config
+* can express, see {@link mergeOptions}), and a plugin Studio explicitly
+* disabled is dropped even when the disk config still lists it. Disk plugins without a studio
+* counterpart are kept as-is. Studio plugins not present on disk are appended.
+*
+* For plugins present in both configs, the plugin is re-instantiated with merged options
+* so that all internal closures correctly reference the merged values.
+*/
+async function mergePlugins({ diskPlugins, studioPlugins, extensions = /* @__PURE__ */ new Map() }) {
+	const pluginNameOf = (packageName) => extensions.get(packageName)?.manifest.name ?? toPluginName(packageName);
+	const disabledNames = new Set((studioPlugins ?? []).filter((entry) => entry.disabled).map((entry) => pluginNameOf(entry.name)));
+	const activeDiskPlugins = disabledNames.size ? diskPlugins?.filter((plugin) => !disabledNames.has(resolveMeta(plugin).name)) : diskPlugins;
+	const activeStudioPlugins = studioPlugins?.filter((entry) => !entry.disabled);
+	if (!activeDiskPlugins && !activeStudioPlugins?.length) return void 0;
+	if (!activeStudioPlugins?.length) return activeDiskPlugins;
+	if (!activeDiskPlugins) return resolvePlugins({
+		plugins: activeStudioPlugins,
+		extensions
+	});
+	const studioEntryByName = new Map(activeStudioPlugins.map((entry) => [pluginNameOf(entry.name), entry]));
+	const diskNames = new Set(activeDiskPlugins.map((plugin) => plugin.name));
+	const merged = await Promise.all(activeDiskPlugins.map(async (diskPlugin) => {
+		const studioEntry = studioEntryByName.get(resolveMeta(diskPlugin).name);
+		if (!studioEntry) return diskPlugin;
+		const diskOptions = diskPlugin.options ?? {};
+		const options = mergeOptions(diskOptions, studioEntry.options ?? {});
+		const unchanged = JSON.stringify(toJSONOptions(options)) === JSON.stringify(toJSONOptions(diskOptions));
+		const [resolved] = await resolvePlugins({
+			plugins: [{
+				name: studioEntry.name,
+				options
+			}],
+			extensions
+		}).catch((cause) => {
+			if (unchanged) return [diskPlugin];
+			throw new Diagnostics.Error({
+				code: Diagnostics.code.pluginNotFound,
+				severity: "error",
+				message: `Plugin "${diskPlugin.name}" is not an installed @kubb/plugin-* package or Kubb extension, so Studio cannot change its options. Edit it in the config file, or only enable or disable it from Studio.`,
+				cause: toError(cause)
+			});
+		});
+		return resolved ?? diskPlugin;
+	}));
+	const studioOnly = activeStudioPlugins.filter((entry) => !diskNames.has(pluginNameOf(entry.name)));
+	return [...merged, ...await resolvePlugins({
+		plugins: studioOnly,
+		extensions
+	})];
+}
+/**
+* Throws `KUBB_PATH_TRAVERSAL` when a plugin would write outside the config's output folder to a path
+* the disk config does not set. Studio can change `output.path`, also inside `override`, and add
+* plugins, so without this check any member of the Studio organization could write any file the agent
+* can reach, including `node_modules` code the next run imports. A path from the config file stays
+* allowed, since a monorepo may write outside its root.
+*/
+function assertOutputPaths({ plugins, diskPlugins, root, outputPath }) {
+	const base = path.resolve(root, outputPath);
+	const targetsOf = (plugin) => {
+		const { output, override } = plugin.options ?? {};
+		return [output, ...Array.isArray(override) ? override.map((entry) => entry?.options?.output) : []].flatMap((entry) => typeof entry?.path === "string" ? [path.resolve(base, entry.path)] : []);
+	};
+	const diskTargets = new Set(diskPlugins.flatMap(targetsOf));
+	for (const plugin of plugins) {
+		const target = targetsOf(plugin).find((resolved) => !diskTargets.has(resolved) && !isPathInside(resolved, base));
+		if (!target) continue;
+		throw new Diagnostics.Error({
+			code: Diagnostics.code.pathTraversal,
+			severity: "error",
+			message: `Plugin "${plugin.name}" would write to "${target}", outside the output folder "${base}". Studio can only set an output path inside it.`,
+			help: "Choose an output path inside the output folder, or set this path in the config file.",
+			location: { kind: "config" },
+			plugin: plugin.name
 		});
 	}
-	on("kubb:build:start", ({ config }) => {
-		root = config.root;
-	});
-	for (const type of generationEventTypes) forward(type);
-	on("kubb:generation:end", ({ diagnostics = [], status, hrStart, filesCreated }) => {
-		if (!hrStart) return;
-		emitEvent("kubb:generation:summary", [{
-			duration: Math.round(getElapsedMs(hrStart)),
-			fileCount: filesCreated ?? 0,
-			failedPlugins: Diagnostics.failedPlugins(diagnostics).length,
-			status: status ?? "success"
-		}]);
-	});
-	/**
-	* Takes this generation's listeners off the session emitter. Safe to call twice.
-	*/
-	function detach() {
-		for (const unhook of unhooks) unhook();
-		unhooks.length = 0;
-	}
-	async function close() {
-		if (closed) return;
-		closed = true;
-		detach();
-		controller.close();
-	}
-	function fail(error) {
-		detach();
-		if (closed) return;
-		closed = true;
-		controller.error(error);
-	}
-	return {
-		stream,
-		close,
-		fail
-	};
-}
-//#endregion
-//#region src/publicFetch.ts
-const MAX_REDIRECTS = 5;
-const MAX_BYTES = 52428800;
-const REDIRECTS = /* @__PURE__ */ new Set([
-	301,
-	302,
-	303,
-	307,
-	308
-]);
-const NO_BODY = /* @__PURE__ */ new Set([
-	204,
-	205,
-	304
-]);
-function notPublic(host) {
-	return /* @__PURE__ */ new Error(`${host} is not a public address, so a managed agent does not fetch from it`);
 }
-function createLookup(blocked) {
-	return (hostname, options, callback) => {
-		dns.lookup(hostname, {
-			...options,
-			all: true
-		}, (error, addresses) => {
-			if (error) return callback(error, "", 0);
-			const found = addresses;
-			if (!found.length || found.some(({ address }) => !isPublicAddress(address, blocked))) return callback(notPublic(hostname), "", 0);
-			return options.all ? callback(null, found) : callback(null, found[0].address, found[0].family);
+/**
+* Re-invokes the factory behind a disk adapter or parser with Studio's options merged over its own.
+* An instance carries live functions (`parse`, `print`, ...) that cannot survive JSON, so Studio's
+* options are a patch, not a replacement, and the factory is found from the disk instance itself: the
+* installed extension whose manifest names it, or the `@kubb/<kind>-<name>` package for a built-in
+* one. Throws when no factory resolves, as `mergePlugins` does, so an override Studio sent is never
+* dropped without a word. An extension without a manifest, such as `parserTsx`, has no options in
+* Studio, so Studio never sends one for it.
+*/
+async function rebuildExtension({ disk, studioOptions, kind, extensions }) {
+	if (!studioOptions || !Object.keys(studioOptions).length) return disk;
+	const { name } = resolveMeta(disk);
+	return (await loadFactory({
+		packageName: [...extensions.values()].find(({ manifest }) => manifest.kind === kind && manifest.name === name)?.package ?? `@kubb/${kind}-${name}`,
+		extensions,
+		kind
+	}).catch((cause) => {
+		throw new Diagnostics.Error({
+			code: kind === "plugin" ? Diagnostics.code.pluginNotFound : Diagnostics.code.unknown,
+			severity: "error",
+			message: `The ${kind} "${name}" is not an installed Kubb extension, so Studio cannot change its options. Edit it in the config file.`,
+			cause: toError(cause)
 		});
-	};
+	}))(mergeOptions(disk.options ?? {}, studioOptions));
 }
-function request({ url, blocked, signal }) {
-	if (url.protocol !== "http:" && url.protocol !== "https:") return Promise.reject(/* @__PURE__ */ new Error(`Only http and https URLs are fetched, not ${url.protocol}`));
-	const host = url.hostname.replace(/^\[|\]$/g, "");
-	if (net.isIP(host) && !isPublicAddress(host, blocked)) return Promise.reject(notPublic(host));
-	return new Promise((resolve, reject) => {
-		const req = (url.protocol === "https:" ? https.request : http.request)(url, {
-			method: "GET",
-			lookup: createLookup(blocked),
-			signal: signal ?? void 0,
-			headers: { "accept-encoding": "identity" }
-		}, (res) => {
-			const headers = new Headers();
-			for (const [key, value] of Object.entries(res.headers)) for (const item of [value].flat()) if (item !== void 0) headers.append(key, item);
-			let total = 0;
-			const limit = new Transform({ transform(chunk, _encoding, done) {
-				total += chunk.length;
-				done(total > MAX_BYTES ? /* @__PURE__ */ new Error("The response is larger than 50 MB") : null, chunk);
-			} });
-			res.on("error", (error) => limit.destroy(error));
-			res.pipe(limit);
-			const body = NO_BODY.has(res.statusCode ?? 0) ? null : Readable.toWeb(limit);
-			resolve(new Response(body, {
-				status: res.statusCode,
-				statusText: res.statusMessage,
-				headers
-			}));
-		});
-		req.on("error", reject);
-		req.end();
-	});
+/** Merges Studio's valid `output` overrides, with `null` unsetting a member. */
+function mergeOutput({ output, studio }) {
+	if (!isPlainObject(studio)) return output;
+	return mergeOptions(output, Object.fromEntries(Object.entries(studio).filter(([key, value]) => value === null ? isOutputKey(key) : isOutputValue({
+		key,
+		value
+	}))));
 }
 /**
-* Builds a `fetch` that only reaches addresses `blocked` does not list. It follows redirects itself
-* and checks every hop, and takes GET requests only, since that is all a spec load needs.
+* Merges Studio-provided adapter option overrides into the disk config's adapter, see {@link rebuildExtension}.
 */
-function createPublicFetch(blocked) {
-	const publicFetch = async (input, init) => {
-		if (typeof input !== "string" && !(input instanceof URL)) throw new TypeError("A managed agent fetches by URL only");
-		if (init?.method && init.method.toUpperCase() !== "GET") throw new TypeError("A managed agent only sends GET requests");
-		let url = new URL(input);
-		for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
-			const response = await request({
-				url,
-				blocked,
-				signal: init?.signal
-			});
-			const location = response.headers.get("location");
-			if (!REDIRECTS.has(response.status) || !location) return response;
-			await response.body?.cancel();
-			url = new URL(location, url);
-		}
-		throw new Error(`Stopped after ${MAX_REDIRECTS} redirects from ${String(input)}`);
-	};
-	return publicFetch;
+async function mergeAdapter(diskAdapter, studioOptions, extensions = /* @__PURE__ */ new Map()) {
+	if (!diskAdapter) return diskAdapter;
+	return rebuildExtension({
+		disk: diskAdapter,
+		studioOptions,
+		kind: "adapter",
+		extensions
+	});
 }
 /**
-* Runs `run` with the global `fetch` limited to public addresses, then puts the original back.
-* A managed agent runs one job at a time, so nothing else shares the window.
+* Merges Studio-provided parser option overrides into the disk config's parsers, matched by the name
+* Studio knows each parser by, see {@link rebuildExtension}. Parsers Studio does not name are kept as is.
 */
-async function withPublicFetch(run) {
-	const original = globalThis.fetch;
-	globalThis.fetch = createPublicFetch();
-	try {
-		return await run();
-	} finally {
-		globalThis.fetch = original;
-	}
+async function mergeParsers({ diskParsers, studioParsers, extensions = /* @__PURE__ */ new Map() }) {
+	if (!studioParsers?.length) return diskParsers;
+	const studioOptions = new Map(studioParsers.map((entry) => [entry.name, entry.options]));
+	return Promise.all(diskParsers.map((parser) => rebuildExtension({
+		disk: parser,
+		studioOptions: studioOptions.get(toStudioName({
+			name: resolveMeta(parser).name,
+			extensions,
+			kind: "parser"
+		})),
+		kind: "parser",
+		extensions
+	})));
 }
 //#endregion
 //#region src/url.ts
@@ -2102,13 +2220,6 @@ const MANAGED_INPUT_KINDS = /* @__PURE__ */ new Set([
 	"url",
 	"git"
 ]);
-/** Extensions `kubb` ships with, so they count as installed without being a direct dependency. */
-const BUILT_IN_PACKAGES = [
-	"@kubb/adapter-oas",
-	"@kubb/parser-ts",
-	"@kubb/parser-md",
-	"@kubb/plugin-barrel"
-];
 /**
 * Studio closed with {@link AgentCloseCode.UNAUTHORIZED}. Hosts forget the token and pair again.
 */
@@ -2236,6 +2347,7 @@ var Agent = class extends RpcTarget {
 			allowConfigEdit: false,
 			allowInstall: false,
 			allowUpdate: false,
+			allowRemove: false,
 			allowSaveInput: false,
 			allowRead: true,
 			allowReadAst: true
@@ -2301,13 +2413,14 @@ var Agent = class extends RpcTarget {
 		const imports = await source.then(readImports, () => []);
 		const installed = await readInstalledPackages({
 			root: this.#options.root,
-			packages: [...imports, ...BUILT_IN_PACKAGES],
+			packages: [...imports, ...BUNDLED_PACKAGES],
 			resolveFrom: ["kubb"]
 		});
 		return new Map(installed.flatMap(({ package: name, version, manifest }) => version !== void 0 && manifest ? [[name, {
 			package: name,
 			version,
-			manifest
+			manifest,
+			...BUNDLED_PACKAGES.includes(name) ? { bundled: true } : {}
 		}]] : []));
 	}
 	async connect(info) {
@@ -2546,7 +2659,7 @@ var Agent = class extends RpcTarget {
 		try {
 			const kept = [];
 			for (const edit of edits) kept.push(await this.#keepInput(edit));
-			const written = await writeConfigEdits({
+			const written = await editConfigFile({
 				filePath: configFile,
 				edits: kept.flatMap((edit) => "reason" in edit ? [] : [edit]),
 				extensions: await this.#installedExtensions()
@@ -2683,10 +2796,49 @@ var Agent = class extends RpcTarget {
 			reason: output
 		} : { updated: true };
 	}
+	/**
+	* Removes an extension with `kubb remove <id> --yes`, which deletes it from `kubb.config.ts` and
+	* uninstalls its package. Studio calls `connect()` again afterwards.
+	*/
+	async removeExtension(input) {
+		this.#assertConnected();
+		const { root, configFile, kubbBin = findKubbBin(root) } = this.#options;
+		const refuse = async (reason, permission) => {
+			await this.#warn({
+				message: `Ignored remove: ${reason}`,
+				permission
+			});
+			return {
+				removed: false,
+				reason
+			};
+		};
+		if (typeof input?.id !== "string" || !REGISTRY_ID.test(input.id)) return refuse("the message carried no registry id");
+		if (!this.#permissions.allowRemove) return refuse("removing extensions was not granted", AgentPermission.REMOVE);
+		if (!this.#permissions.allowConfigEdit) return refuse("editing kubb.config.ts was not granted", AgentPermission.CONFIG_EDIT);
+		const busy = this.#busy();
+		if (busy) return refuse(busy);
+		if (!kubbBin) return refuse("kubb is not installed in the project");
+		const { failed, output } = await this.#runKubb({
+			bin: kubbBin,
+			args: [
+				"remove",
+				input.id,
+				"--yes",
+				"--config",
+				configFile
+			]
+		});
+		await this.#logCommand("removeExtension", `${failed ? "failed to remove" : "removed"} ${input.id}`, input.requestedBy, failed);
+		return failed ? {
+			removed: false,
+			reason: output
+		} : { removed: true };
+	}
 	/** Why a command that touches the project cannot start right now. */
 	#busy() {
 		if (this.#session.active) return "a generation is in progress";
-		if (this.#session.install) return "an install or update is in progress";
+		if (this.#session.install) return "an install, update, or remove is in progress";
 		if (this.#session.saving) return "a save is in progress";
 	}
 	/** Runs `kubb` in the project while holding off saves and generations, and ends it when the socket closes. */
@@ -2973,6 +3125,7 @@ async function runAgent({ options, openRpc }) {
 			allowConfigEdit: false,
 			allowInstall: false,
 			allowUpdate: false,
+			allowRemove: false,
 			allowSaveInput: false,
 			allowExec: false,
 			allowRead: false,
@@ -3434,6 +3587,6 @@ async function createSnapshot({ studioUrl = defaultStudioUrl, apiKey, config, ho
 	return _data.snapshot;
 }
 //#endregion
-export { IncompatibleAgentError, InvalidAgentTokenError, PairingCanceledError, PairingDeniedError, PairingExpiredError, applyConfigEdits, connectAgent, createSnapshot, defaultStudioUrl, pairAgent, writeConfigEdits };
+export { IncompatibleAgentError, InvalidAgentTokenError, PairingCanceledError, PairingDeniedError, PairingExpiredError, connectAgent, createSnapshot, defaultStudioUrl, editConfig, editConfigFile, pairAgent };
 
 //# sourceMappingURL=index.js.map