@kubb/studio 5.9.0 → 5.9.2

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./rolldown-runtime-CRm0XQPb.js";
-import { M as PublishedSnapshot, V as SnapshotUploadMetadata, a as AgentConnectInfo, c as ConfigEdit, l as ConfigEditOutcome, m as ExtensionEntry, o as AgentPermissions } from "./protocol-BfjNY8-8.js";
+import { L as SnapshotUploadMetadata, a as AgentConnectInfo, c as ConfigEdit, j as PublishedSnapshot, l as ConfigEditOutcome, o as AgentPermissions, w as InstalledExtensions } from "./protocol-gXoAXvT3.js";
 import { Config, Hookable, KubbHooks } from "@kubb/core";
 //#region src/connect.d.ts
 /**
@@ -242,13 +242,6 @@ export declare function createSnapshot({ studioUrl, apiKey, config, hooks, signa
  */
 export declare const defaultStudioUrl = "https://kubb.studio";
 //#endregion
-//#region src/extensions.d.ts
-/**
- * The extension packages installed in a project, keyed by package name. Only these, besides
- * `@kubb/plugin-*` packages, may be imported on behalf of Studio.
- */
-type InstalledExtensions = ReadonlyMap<string, ExtensionEntry>;
-//#endregion
 //#region src/configFile.d.ts
 /**
  * Applies `edits` to the config file at `filePath`, writing it only when something changed.
@@ -264,5 +257,5 @@ export declare function writeConfigEdits({ filePath, edits, extensions }: {
   changed: boolean;
 }>;
 //#endregion
-export type { ConnectAgentOptions, InstalledExtensions, StudioConnectedContext };
+export type { ConnectAgentOptions, StudioConnectedContext };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -71,74 +71,34 @@ function getErrorMessage(value) {
 }
 //#endregion
 //#region ../../internals/utils/src/runtime.ts
+const isBun = typeof Bun !== "undefined";
+const isDeno = "Deno" in globalThis;
 /**
-* Detects the JavaScript runtime executing the current process and exposes its name and version.
+* The JavaScript runtime executing the current process: its name, version and whether it is Bun.
 *
-* Prefer the shared {@link runtime} instance over constructing your own.
+* @example
+* ```ts
+* runtime.name // 'bun' when run with `bun kubb`, 'node' otherwise
+* ```
 */
-var Runtime = class {
-	/**
-	* `true` when the current process is running under Bun.
-	*
-	* Detection keys off the global `Bun` object rather than `process.versions`,
-	* because Bun polyfills `process.versions.node` for Node compatibility and would
-	* otherwise look like Node.
-	*
-	* @example
-	* ```ts
-	* if (runtime.isBun) {
-	*   await Bun.write(path, data)
-	* }
-	* ```
-	*/
-	get isBun() {
-		return typeof Bun !== "undefined";
-	}
-	/**
-	* `true` when the current process is running under Deno.
-	*/
-	get isDeno() {
-		return typeof globalThis.Deno !== "undefined";
-	}
-	/**
-	* `true` when the current process is running under Node.
-	*
-	* Bun and Deno are excluded first so a polyfilled `process` does not register as Node.
-	*/
-	get isNode() {
-		return !this.isBun && !this.isDeno && typeof process !== "undefined" && process.versions?.node != null;
-	}
-	/**
-	* Name of the runtime executing the current process.
-	*
-	* @example
-	* ```ts
-	* runtime.name // 'bun' when run with `bun kubb`, 'node' otherwise
-	* ```
-	*/
-	get name() {
-		if (this.isBun) return "bun";
-		if (this.isDeno) return "deno";
-		return "node";
-	}
-	/**
-	* Version of the active runtime, or an empty string when it cannot be read.
-	*
-	* @example
-	* ```ts
-	* runtime.version // '1.3.11' under Bun, '22.22.2' under Node
-	* ```
-	*/
-	get version() {
-		if (this.isBun) return process.versions.bun ?? "";
-		if (this.isDeno) return globalThis.Deno?.version?.deno ?? "";
-		return process.versions?.node ?? "";
-	}
+const runtime = {
+	isBun,
+	...detect()
 };
-/**
-* Shared {@link Runtime} instance describing the JavaScript runtime executing the current process.
-*/
-const runtime = new Runtime();
+function detect() {
+	if (isBun) return {
+		name: "bun",
+		version: process.versions.bun ?? ""
+	};
+	if (isDeno) return {
+		name: "deno",
+		version: globalThis.Deno?.version?.deno ?? ""
+	};
+	return {
+		name: "node",
+		version: process.versions?.node ?? ""
+	};
+}
 //#endregion
 //#region ../../internals/utils/src/fs.ts
 /**
@@ -192,7 +152,7 @@ function getElapsedMs(hrStart) {
 }
 //#endregion
 //#region package.json
-var version = "5.9.0";
+var version = "5.9.2";
 //#endregion
 //#region src/resolveConfig.ts
 /**
@@ -237,47 +197,19 @@ function toPluginName(packageName) {
 function toPackageName(name) {
 	return name.startsWith("plugin-") ? `@kubb/${name}` : name;
 }
-function resolvesFrom(base, packageName) {
-	try {
-		createRequire(base).resolve(`${packageName}/package.json`);
-		return true;
-	} catch {
-		return false;
-	}
-}
 /**
-* Whether `packageName` resolves from the project at `root`, from this package, or from the `kubb`
-* package the project installs, which brings the plugins Kubb adds on its own such as
-* `@kubb/plugin-barrel`. Only resolves the package, it never runs it.
-*/
-function isInstalled({ packageName, root }) {
-	const project = pathToFileURL(`${root}/`);
-	if (resolvesFrom(project, packageName) || resolvesFrom(import.meta.url, packageName)) return true;
-	try {
-		return resolvesFrom(createRequire(project).resolve("kubb/package.json"), packageName);
-	} catch {
-		return false;
-	}
-}
-/**
-* The name Studio knows a plugin by: its `@kubb/plugin-*` package when one is installed, otherwise
-* the plugin's own `name`, so a plugin defined in the user's project is never reported as a Kubb
-* package that does not exist. An installed extension whose manifest `name` matches wins.
+* 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', root })              // '@kubb/plugin-ts'
-* toStudioName({ name: 'plugin-zod-operations', root })  // 'plugin-zod-operations', a local plugin
+* toStudioName({ name: 'plugin-ts', extensions })              // '@kubb/plugin-ts'
+* toStudioName({ name: 'plugin-zod-operations', extensions })  // 'plugin-zod-operations', a local plugin
 * ```
 */
-function toStudioName({ name, root, extensions = /* @__PURE__ */ new Map() }) {
-	const installed = [...extensions.values()].find(({ manifest }) => manifest.kind === "plugin" && manifest.name === name);
-	if (installed) return installed.package;
-	const packageName = toPackageName(name);
-	return packageName !== name && isInstalled({
-		packageName,
-		root
-	}) ? packageName : name;
+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.
@@ -356,33 +288,6 @@ async function resolvePlugins({ plugins, extensions = /* @__PURE__ */ new Map()
 		}))(options ?? {});
 	}));
 }
-/** The installed version of each plugin's package, plus the names that could not be resolved. */
-async function resolvePeerDependencies(names) {
-	const require = createRequire(import.meta.url);
-	const uniqueNames = [...new Set(names.map(toPackageName))];
-	const peerDependencies = {};
-	const missingDependencies = [];
-	const versions = await Promise.all(uniqueNames.map(async (name) => {
-		try {
-			const path = require.resolve(`${name}/package.json`);
-			return JSON.parse(await readFile(path, "utf8")).version;
-		} catch {
-			return;
-		}
-	}));
-	for (const [index, name] of uniqueNames.entries()) {
-		const version = versions[index];
-		if (version) {
-			peerDependencies[name] = version;
-			continue;
-		}
-		missingDependencies.push(name);
-	}
-	return {
-		peerDependencies,
-		missingDependencies
-	};
-}
 /**
 * Keys that reach an object's prototype when assigned. Never read from or written into options.
 */
@@ -445,6 +350,7 @@ function isOptionValue(value) {
 * ```ts
 * mergeOptions({ macros: [camelCaseMacro], syntaxType: 'type' }, { macros: [{ name: 'camelCase' }], syntaxType: 'interface' })
 * // { macros: [camelCaseMacro], syntaxType: 'interface' }
+* mergeOptions({ emptySchemaType: 'any' }, { emptySchemaType: null }) // {}
 * ```
 */
 function mergeOptions(disk, studio) {
@@ -452,6 +358,10 @@ function mergeOptions(disk, studio) {
 	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;
@@ -509,20 +419,54 @@ async function mergePlugins({ diskPlugins, studioPlugins, extensions = /* @__PUR
 	})];
 }
 /**
-* Merges Studio-provided adapter option overrides into the disk config's adapter.
-*
-* Adapter instances carry live functions (`parse`, `getImports`, ...) that can't survive
-* JSON serialization over the WebSocket, so `studioOptions` is treated as an options patch
-* rather than a replacement adapter. Re-invokes the same `@kubb/adapter-<name>` factory the
-* disk config used, with the merged options, so the resulting instance has fresh closures
-* over the merged values instead of a plain object missing `parse`.
+* 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);
+	const installed = [...extensions.values()].find(({ manifest }) => manifest.kind === kind && manifest.name === name);
+	const packageName = installed?.package ?? `@kubb/${kind}-${name}`;
+	const factory = await importFromProject(packageName).then((mod) => mod[installed?.manifest.export ?? toExportName(packageName)]).catch((cause) => {
+		throw new Error(`The ${kind} "${name}" is not an installed Kubb extension, so Studio cannot change its options. Edit it in the config file.`, { cause });
+	});
+	if (typeof factory !== "function") throw new Error(`The ${kind} "${name}" is not an installed Kubb extension, so Studio cannot change its options. Edit it in the config file.`);
+	return factory(mergeOptions(disk.options ?? {}, studioOptions));
+}
+/**
+* Merges Studio-provided adapter option overrides into the disk config's adapter, see {@link rebuildExtension}.
 */
-async function mergeAdapter(diskAdapter, studioOptions) {
-	if (!studioOptions || !diskAdapter) return diskAdapter;
-	const packageName = `@kubb/adapter-${diskAdapter.name}`;
-	const factory = (await importFromProject(packageName))[toExportName(packageName)];
-	if (typeof factory !== "function") return diskAdapter;
-	return factory(mergeOptions(diskAdapter.options ?? {}, studioOptions));
+async function mergeAdapter(diskAdapter, studioOptions, extensions = /* @__PURE__ */ new Map()) {
+	if (!diskAdapter) return diskAdapter;
+	return rebuildExtension({
+		disk: diskAdapter,
+		studioOptions,
+		kind: "adapter",
+		extensions
+	});
+}
+/**
+* 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
+	})));
 }
 //#endregion
 //#region src/configFile.ts
@@ -543,14 +487,21 @@ const OPERATIONS = /* @__PURE__ */ new Set([
 	"disable-plugin",
 	"enable-plugin"
 ]);
+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 { operation, plugin, config, path, importName } = typeof edit === "object" && edit !== null ? edit : {};
+	const { operation, plugin, config, path, kind } = typeof edit === "object" && edit !== null ? edit : {};
 	if (typeof operation !== "string" || !OPERATIONS.has(operation)) return `unknown operation ${JSON.stringify(operation)}`;
 	if (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 !== "set" && operation !== "remove") return `${operation} edits the plugins array, so it takes no kind`;
 	if (config !== void 0 && typeof config !== "string" && !Number.isSafeInteger(config)) return "config must name an entry or give its index";
 	if (operation === "set" || operation === "remove") {
 		if (!Array.isArray(path) || !path.every((key) => typeof key === "string" && key)) return "path must be a list of option names";
@@ -558,7 +509,6 @@ function invalidEdit(edit) {
 		const unsafe = path.find((key) => !isSafeKey(key));
 		if (unsafe !== void 0) return `${unsafe} cannot be used as an option name`;
 	}
-	if (operation === "add-plugin" && importName !== void 0 && typeof importName !== "string") return "importName must be a string";
 }
 /** Where a node sits in the source text. */
 function rangeOf(node) {
@@ -753,29 +703,42 @@ function importedFrom(mod) {
 	const imports = /* @__PURE__ */ new Map();
 	for (const statement of bodyOf(mod)) {
 		if (statement.type === "ImportDeclaration") {
-			for (const specifier of statement.specifiers) imports.set(specifier.local.name, statement.source.value);
+			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);
+			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 `pluginX(...)` element of a config's plugins array that resolves to an import. */
-function pluginCalls(mod, config) {
-	const plugins = property(config, "plugins");
-	if (plugins?.type !== "ArrayExpression") return [];
+/**
+* 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 plugins.elements.flatMap((element) => {
+	return elements.flatMap((element) => {
 		if (element?.type !== "CallExpression" || element.callee.type !== "Identifier") return [];
-		const packageName = imports.get(element.callee.name);
-		return packageName ? [{
+		const imported = imports.get(element.callee.name);
+		return imported ? [{
 			importName: element.callee.name,
-			packageName,
+			exportName: imported.exported,
+			packageName: imported.from,
 			call: element
 		}] : [];
 	});
@@ -844,11 +807,11 @@ function readConfig(source) {
 		reason: parsed.reason
 	};
 	const { mod, configs } = parsed;
-	const importNames = new Map([...importedFrom(mod)].map(([local, from]) => [from, local]));
+	const importNames = new Map([...importedFrom(mod)].map(([local, { from }]) => [from, local]));
 	return {
 		managed: true,
 		configs: configs.map((config) => {
-			const active = pluginCalls(mod, config).map(({ importName, packageName, call }) => ({
+			const active = factoryCalls(mod, config).map(({ importName, packageName, call }) => ({
 				line: call.loc?.start.line ?? 0,
 				plugin: {
 					importName,
@@ -866,9 +829,18 @@ function readConfig(source) {
 				}
 			}));
 			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);
 			return {
 				name: configName(config),
-				plugins
+				plugins,
+				...adapter && { adapter },
+				...parsers.length ? { parsers } : {}
 			};
 		})
 	};
@@ -876,7 +848,7 @@ function readConfig(source) {
 /** The modules the config file imports, in source order. Empty when the file cannot be parsed. */
 function readImports(source) {
 	try {
-		return [...new Set(importedFrom(parseModule(source)).values())];
+		return [...new Set([...importedFrom(parseModule(source)).values()].map(({ from }) => from))];
 	} catch {
 		return [];
 	}
@@ -913,10 +885,10 @@ function applySet(source, call, path, value, quote) {
 	const options = call.arguments[0];
 	if (!options) {
 		const closing = rangeOf(call).end - 1;
-		if (source[closing] !== ")") return { reason: "the plugin call could not be located in the file" };
+		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)) };
 	}
-	if (options.type !== "ObjectExpression") return { reason: "the plugin was not called with an object literal" };
+	if (options.type !== "ObjectExpression") return { reason: "the factory was not called with an object literal" };
 	const target = walk(options, path);
 	if ("reason" in target) return target;
 	if ("missing" in target) {
@@ -928,7 +900,7 @@ function applySet(source, call, path, value, quote) {
 /** Deletes the option at `path`, falling the plugin back to its default for it. */
 function applyRemove(source, call, path) {
 	const options = call.arguments[0];
-	if (options?.type !== "ObjectExpression") return { reason: "the plugin has no options to remove" };
+	if (options?.type !== "ObjectExpression") return { reason: "the factory call has no options to remove" };
 	const target = walk(options, path);
 	if ("reason" in target) return target;
 	if ("missing" in target) return { reason: `${path.join(".")} is not set` };
@@ -959,10 +931,10 @@ function applyAddPlugin({ source, parsed, config, edit, quote, extensions }) {
 		packageName: edit.plugin,
 		extensions
 	})) return { reason: `"${edit.plugin}" is not a @kubb/plugin-* package or an installed Kubb plugin` };
-	const importName = extensions.get(edit.plugin)?.manifest.export ?? edit.importName ?? toExportName(edit.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 (pluginCalls(parsed.mod, config).some((plugin) => plugin.packageName === edit.plugin)) return { source };
-	const taken = importedFrom(parsed.mod).get(importName);
+	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}` };
 	const options = edit.options ?? {};
 	if (!isOptionValue(options)) return { reason: "the options are not literals that can be written to a config file" };
@@ -973,7 +945,7 @@ function applyAddPlugin({ source, parsed, config, edit, quote, extensions }) {
 }
 /** 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 = pluginCalls(mod, config).find((entry) => entry.packageName === plugin)?.call.loc;
+	const loc = factoryCalls(mod, config).find((entry) => entry.packageName === plugin)?.call.loc;
 	if (!loc) return { reason: `${plugin} is not in the plugins array` };
 	const lines = source.split("\n");
 	const from = loc.start.line - 1;
@@ -1010,8 +982,14 @@ function applyEdit({ source, edit, quote, extensions }) {
 		quote,
 		extensions
 	});
-	const call = pluginCalls(parsed.mod, config).find((plugin) => plugin.packageName === edit.plugin)?.call;
-	if (!call) return { reason: disabledBlocks(source, config).some((block) => block.packageName === edit.plugin) ? `${edit.plugin} is disabled, enable it first` : `${edit.plugin} is not in the plugins array` };
+	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` };
+	}
 	return edit.operation === "set" ? applySet(source, call, edit.path, edit.value, quote) : applyRemove(source, call, edit.path);
 }
 /**
@@ -1083,32 +1061,6 @@ async function writeConfigEdits({ filePath, edits, extensions }) {
 	return result;
 }
 //#endregion
-//#region src/extensions.ts
-/** 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"
-];
-/**
-* Finds the extensions installed in the project at `root`: its `dependencies` and `devDependencies`,
-* the `packages` its config file imports, and the extensions `kubb` ships with. Keeps each package
-* that resolves and ships a valid `kubb-extension.json`. Never throws.
-*/
-async function discoverExtensions({ root, packages = [] }) {
-	const installed = await readInstalledPackages({
-		root,
-		packages: [...packages, ...BUILT_IN_PACKAGES],
-		resolveFrom: ["kubb"]
-	});
-	return new Map(installed.flatMap(({ package: name, version, manifest }) => version !== void 0 && manifest ? [[name, {
-		package: name,
-		version,
-		manifest
-	}]] : []));
-}
-//#endregion
 //#region src/generations.ts
 const READ_CONCURRENCY = 50;
 const MB = 1048576;
@@ -1516,6 +1468,13 @@ const OPEN_TIMEOUT_MS = 5e3;
 const MAX_RETRY_DELAY_MS = 3e4;
 const DISK_SNAPSHOT_MAX_FILES = 1e4;
 const SANDBOX_GENERATION_TTL_MS = 9e5;
+/** 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.
 */
@@ -1614,10 +1573,10 @@ var Agent = class extends RpcTarget {
 		});
 		return value;
 	}
-	async #readConfigFileView(source) {
+	async #readConfigFileView() {
 		if (!this.#permissions.allowConfigEdit) return void 0;
 		try {
-			return readConfig(source ?? await read(this.#options.configFile));
+			return readConfig(await read(this.#options.configFile));
 		} catch (error) {
 			await this.#warn({ message: `Could not read ${this.#options.configFile}: ${getErrorMessage(error)}` });
 			return;
@@ -1625,10 +1584,16 @@ var Agent = class extends RpcTarget {
 	}
 	async #installedExtensions() {
 		const source = await read(this.#options.configFile).catch(() => "");
-		return discoverExtensions({
+		const installed = await readInstalledPackages({
 			root: this.#options.root,
-			packages: readImports(source)
+			packages: [...readImports(source), ...BUILT_IN_PACKAGES],
+			resolveFrom: ["kubb"]
 		});
+		return new Map(installed.flatMap(({ package: name, version, manifest }) => version !== void 0 && manifest ? [[name, {
+			package: name,
+			version,
+			manifest
+		}]] : []));
 	}
 	async connect(info) {
 		this.#session.info = info;
@@ -1651,11 +1616,26 @@ var Agent = class extends RpcTarget {
 				plugins: config.plugins.map((plugin) => ({
 					name: toStudioName({
 						name: resolveMeta(plugin).name,
-						root,
 						extensions
 					}),
 					options: toJSONOptions(plugin.options)
 				})),
+				adapter: config.adapter && {
+					name: toStudioName({
+						name: resolveMeta(config.adapter).name,
+						extensions,
+						kind: "adapter"
+					}),
+					options: toJSONOptions(config.adapter.options)
+				},
+				parsers: config.parsers.map((parser) => ({
+					name: toStudioName({
+						name: resolveMeta(parser).name,
+						extensions,
+						kind: "parser"
+					}),
+					options: toJSONOptions(parser.options)
+				})),
 				extensions: [...extensions.values()]
 			},
 			permissions: this.#permissions
@@ -1715,11 +1695,19 @@ var Agent = class extends RpcTarget {
 		const studioInput = this.#sandbox ? patch?.input : void 0;
 		if (this.#sandbox && (typeof studioInput !== "string" || !studioInput.trim() || getInputKind(studioInput) !== "inline")) return this.#refuse({ message: "A sandbox agent generates only from the OpenAPI document content Studio sends, not from a file path or URL" });
 		const [config, extensions] = await Promise.all([this.#options.loadConfig(), this.#installedExtensions()]);
-		const [plugins, adapter] = await Promise.all([mergePlugins({
-			diskPlugins: config.plugins,
-			studioPlugins: patch?.plugins,
-			extensions
-		}), mergeAdapter(config.adapter, patch?.adapter)]).catch(async (error) => {
+		const [plugins, adapter, parsers] = await Promise.all([
+			mergePlugins({
+				diskPlugins: config.plugins,
+				studioPlugins: patch?.plugins,
+				extensions
+			}),
+			mergeAdapter(config.adapter, patch?.adapter, extensions),
+			mergeParsers({
+				diskParsers: config.parsers,
+				studioParsers: patch?.parsers,
+				extensions
+			})
+		]).catch(async (error) => {
 			await emit(this.#options.hooks, "kubb:error", { error: toError(error) });
 			throw error;
 		});
@@ -1743,7 +1731,8 @@ var Agent = class extends RpcTarget {
 				input: studioInput ?? config.input,
 				storage: this.#permissions.allowWrite ? fsStorage() : memoryStorage(),
 				plugins: activePlugins,
-				adapter
+				adapter,
+				parsers
 			},
 			hooks: this.#options.hooks,
 			signal,
@@ -1805,7 +1794,7 @@ var Agent = class extends RpcTarget {
 		}
 		if (this.#session.active) return { value: refuse("a generation is in progress") };
 		try {
-			const { source, outcomes, changed } = await writeConfigEdits({
+			const { outcomes, changed } = await writeConfigEdits({
 				filePath: configFile,
 				edits,
 				extensions: await this.#installedExtensions()
@@ -1814,8 +1803,7 @@ var Agent = class extends RpcTarget {
 			return {
 				value: {
 					outcomes,
-					changed,
-					file: changed ? await this.#readConfigFileView(source) : void 0
+					changed
 				},
 				info: `applied ${applied}/${outcomes.length} edits to ${configPath}`
 			};
@@ -2296,8 +2284,16 @@ async function createSnapshot({ studioUrl = defaultStudioUrl, apiKey, config, ho
 		if (content === null) throw new Error(`The generation listed ${path} but did not keep its content`);
 		return [path, content];
 	})));
-	const { peerDependencies, missingDependencies } = await resolvePeerDependencies(config.plugins.map((plugin) => resolveMeta(plugin).name));
-	const missing = missingDependencies.filter((dependency) => !BUNDLED_DEPENDENCIES.includes(dependency));
+	const pluginNames = config.plugins.map((plugin) => resolveMeta(plugin).name);
+	const installed = await readInstalledPackages({
+		root: config.root,
+		packages: pluginNames.map(toPackageName),
+		resolveFrom: ["kubb"]
+	});
+	const packageOf = (name) => installed.find(({ manifest }) => manifest?.kind === "plugin" && manifest.name === name)?.package ?? toPackageName(name);
+	const names = [...new Set(pluginNames.map(packageOf))];
+	const peerDependencies = Object.fromEntries(installed.flatMap(({ package: name, version }) => names.includes(name) && version ? [[name, version]] : []));
+	const missing = names.filter((name) => !(name in peerDependencies) && !BUNDLED_DEPENDENCIES.includes(name));
 	if (missing.length) throw new Error(`Missing dependencies: ${missing.join(", ")}`);
 	const bytes = await createSnapshotPackage({
 		files,