@kubb/core 5.0.0-beta.19 → 5.0.0-beta.20

package/dist/{PluginDriver-uNex0SAr.js → KubbDriver-Cxii_rBp.js}

@@ -1,6 +1,6 @@
 import "./chunk--u3MIqq1.js";
 import path, { extname, resolve } from "node:path";
-import { createFile, isOperationNode, isSchemaNode } from "@kubb/ast";
+import { createFile, createStreamInput, isOperationNode, isSchemaNode } from "@kubb/ast";
 import { deflateSync } from "fflate";
 import { x } from "tinyexec";
 //#region ../../internals/utils/src/casing.ts
@@ -67,6 +67,381 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
+//#region ../../internals/utils/src/promise.ts
+function* chunks(arr, size) {
+	for (let i = 0; i < arr.length; i += size) yield arr.slice(i, i + size);
+}
+/**
+* Slices `source` into batches of `concurrency` items and awaits `process` for each batch.
+* Accepts both plain arrays (sync) and `AsyncIterable` (streaming).
+*
+* `process` controls whether items inside a batch run in parallel; this helper only
+* controls batch size and per-batch flushing.
+*
+* @example
+* ```ts
+* // parallel dispatch inside each batch
+* await forBatches(schemas, (batch) => Promise.all(batch.map(process)), { concurrency: 8 })
+*
+* // async iterable with a flush after every batch
+* await forBatches(stream.schemas, (batch) => dispatch(batch), { concurrency: 8, flush })
+* ```
+*/
+async function forBatches(source, process, options) {
+	const { concurrency, flush } = options;
+	if (Array.isArray(source)) {
+		for (const batch of chunks(source, concurrency)) {
+			await process(batch);
+			if (flush) await flush();
+		}
+		return;
+	}
+	const batch = [];
+	for await (const item of source) {
+		batch.push(item);
+		if (batch.length >= concurrency) {
+			await process(batch.splice(0));
+			if (flush) await flush();
+		}
+	}
+	if (batch.length > 0) {
+		await process(batch.splice(0));
+		if (flush) await flush();
+	}
+}
+/**
+* Runs `work`, passing `flush` as its periodic-flush callback, then calls
+* `flush` once more to drain any items that did not cross a flush boundary.
+*
+* @example
+* ```ts
+* await withDrain(
+*   (flush) => processItems(items, { flush }),
+*   () => writeRemainingFiles(),
+* )
+* ```
+*/
+async function withDrain(work, flush) {
+	await work(flush);
+	await flush();
+}
+/** Returns `true` when `result` is a thenable `Promise`.
+*
+* @example
+* ```ts
+* isPromise(Promise.resolve(1)) // true
+* isPromise(42)                 // false
+* ```
+*/
+function isPromise(result) {
+	return result !== null && result !== void 0 && typeof result["then"] === "function";
+}
+/**
+* Wraps `factory` with a keyed cache backed by the provided store.
+*
+* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
+* collected) or a `Map` for primitive keys. For multi-argument functions,
+* nest two `memoize` calls — the outer keyed by the first argument, the
+* inner (created once per outer miss) keyed by the second.
+*
+* Because the cache is owned by the caller, it can be shared, inspected, or
+* cleared independently of the memoized function.
+*
+* @example Single WeakMap key
+* ```ts
+* const cache = new WeakMap<SchemaNode, Set<string>>()
+* const getRefs = memoize(cache, (node) => collectRefs(node))
+* ```
+*
+* @example Single Map key (primitive)
+* ```ts
+* const cache = new Map<string, Resolver>()
+* const getResolver = memoize(cache, (name) => buildResolver(name))
+* ```
+*
+* @example Two-level (object + primitive)
+* ```ts
+* const outer = new WeakMap<Params[], Map<string, Params[]>>()
+* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
+* fn(params)('camelcase')
+* ```
+*/
+function memoize(store, factory) {
+	return (key) => {
+		if (store.has(key)) return store.get(key);
+		const value = factory(key);
+		store.set(key, value);
+		return value;
+	};
+}
+/**
+* Wraps a plain array in a reusable `AsyncIterable`.
+* Each `[Symbol.asyncIterator]()` call returns a fresh generator so the
+* iterable can be consumed multiple times (e.g. once per plugin pre-scan).
+*
+* @example
+* ```ts
+* const stream = arrayToAsyncIterable([1, 2, 3])
+* for await (const n of stream) console.log(n) // 1, 2, 3
+* ```
+*/
+function arrayToAsyncIterable(arr) {
+	return { [Symbol.asyncIterator]() {
+		return (async function* () {
+			yield* arr;
+		})();
+	} };
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = new Set([
+	"abstract",
+	"arguments",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+//#endregion
+//#region ../../internals/utils/src/urlPath.ts
+/**
+* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
+*
+* @example
+* const p = new URLPath('/pet/{petId}')
+* p.URL      // '/pet/:petId'
+* p.template // '`/pet/${petId}`'
+*/
+var URLPath = class {
+	/**
+	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
+	*/
+	path;
+	#options;
+	constructor(path, options = {}) {
+		this.path = path;
+		this.#options = options;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
+	* ```
+	*/
+	get URL() {
+		return this.toURLPath();
+	}
+	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
+	*
+	* @example
+	* ```ts
+	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
+	* new URLPath('/pet/{petId}').isURL                       // false
+	* ```
+	*/
+	get isURL() {
+		try {
+			return !!new URL(this.path).href;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
+	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
+	*/
+	get template() {
+		return this.toTemplateString();
+	}
+	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').object
+	* // { url: '/pet/:petId', params: { petId: 'petId' } }
+	* ```
+	*/
+	get object() {
+		return this.toObject();
+	}
+	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
+	* new URLPath('/pet').params         // undefined
+	* ```
+	*/
+	get params() {
+		return this.getParams();
+	}
+	#transformParam(raw) {
+		const param = isValidVarName(raw) ? raw : camelCase(raw);
+		return this.#options.casing === "camelcase" ? camelCase(param) : param;
+	}
+	/**
+	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
+	*/
+	#eachParam(fn) {
+		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
+			const raw = match[1];
+			fn(raw, this.#transformParam(raw));
+		}
+	}
+	toObject({ type = "path", replacer, stringify } = {}) {
+		const object = {
+			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
+			params: this.getParams()
+		};
+		if (stringify) {
+			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+			return `{ url: '${object.url}' }`;
+		}
+		return object;
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	* An optional `replacer` can transform each extracted parameter name before interpolation.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
+	*/
+	toTemplateString({ prefix = "", replacer } = {}) {
+		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = this.#transformParam(part);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("")}\``;
+	}
+	/**
+	* Extracts all `{param}` segments from the path and returns them as a key-value map.
+	* An optional `replacer` transforms each parameter name in both key and value positions.
+	* Returns `undefined` when no path parameters are found.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
+	* // { petId: 'petId', tagId: 'tagId' }
+	* ```
+	*/
+	getParams(replacer) {
+		const params = {};
+		this.#eachParam((_raw, param) => {
+			const key = replacer ? replacer(param) : param;
+			params[key] = key;
+		});
+		return Object.keys(params).length > 0 ? params : void 0;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax.
+	*
+	* @example
+	* ```ts
+	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
+	* ```
+	*/
+	toURLPath() {
+		return this.path.replace(/\{([^}]+)\}/g, ":$1");
+	}
+};
+//#endregion
 //#region src/constants.ts
 /**
 * Base URL for the Kubb Studio web app.
@@ -147,14 +522,12 @@ function testPattern(value, pattern) {
 * Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
 */
 function matchesOperationPattern(node, type, pattern) {
-	switch (type) {
-		case "tag": return node.tags.some((tag) => testPattern(tag, pattern));
-		case "operationId": return testPattern(node.operationId, pattern);
-		case "path": return testPattern(node.path, pattern);
-		case "method": return testPattern(node.method.toLowerCase(), pattern);
-		case "contentType": return node.requestBody?.content?.some((c) => testPattern(c.contentType, pattern)) ?? false;
-		default: return false;
-	}
+	if (type === "tag") return node.tags.some((tag) => testPattern(tag, pattern));
+	if (type === "operationId") return testPattern(node.operationId, pattern);
+	if (type === "path") return testPattern(node.path, pattern);
+	if (type === "method") return testPattern(node.method.toLowerCase(), pattern);
+	if (type === "contentType") return node.requestBody?.content?.some((c) => testPattern(c.contentType, pattern)) ?? false;
+	return false;
 }
 /**
 * Checks if a schema matches a pattern for a given filter type (`schemaName`).
@@ -162,10 +535,8 @@ function matchesOperationPattern(node, type, pattern) {
 * Returns `null` when the filter type doesn't apply to schemas.
 */
 function matchesSchemaPattern(node, type, pattern) {
-	switch (type) {
-		case "schemaName": return node.name ? testPattern(node.name, pattern) : false;
-		default: return null;
-	}
+	if (type === "schemaName") return node.name ? testPattern(node.name, pattern) : false;
+	return null;
 }
 /**
 * Default name resolver used by `defineResolver`.
@@ -388,10 +759,9 @@ function buildDefaultBanner({ title, description, version, config }) {
 *
 * A user-supplied `output.banner` overrides the default Kubb "Generated by Kubb" notice.
 * When no `output.banner` is set, the Kubb notice is used (including `title` and `version`
-* from the OAS spec when a `node` is provided).
+* from the document metadata when `meta` is provided).
 *
-* - When `output.banner` is a function and `node` is provided, returns `output.banner(node)`.
-* - When `output.banner` is a function and `node` is absent, falls back to the Kubb notice.
+* - When `output.banner` is a function, calls it with `meta` and returns the result.
 * - When `output.banner` is a string, returns it directly.
 * - When `config.output.defaultBanner` is `false`, returns `undefined`.
 * - Otherwise returns the Kubb "Generated by Kubb" notice.
@@ -402,15 +772,15 @@ function buildDefaultBanner({ title, description, version, config }) {
 * // → '// my banner'
 * ```
 *
-* @example Function banner with node
+* @example Function banner with metadata
 * ```ts
-* defaultResolveBanner(inputNode, { output: { banner: (node) => `// v${node.version}` }, config })
+* defaultResolveBanner(meta, { output: { banner: (m) => `// v${m?.version}` }, config })
 * // → '// v3.0.0'
 * ```
 *
 * @example No user banner — Kubb notice with OAS metadata
 * ```ts
-* defaultResolveBanner(inputNode, { config })
+* defaultResolveBanner(meta, { config })
 * // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
 * ```
 *
@@ -420,21 +790,20 @@ function buildDefaultBanner({ title, description, version, config }) {
 * // → undefined
 * ```
 */
-function defaultResolveBanner(node, { output, config }) {
-	if (typeof output?.banner === "function") return output.banner(node);
+function defaultResolveBanner(meta, { output, config }) {
+	if (typeof output?.banner === "function") return output.banner(meta);
 	if (typeof output?.banner === "string") return output.banner;
 	if (config.output.defaultBanner === false) return;
 	return buildDefaultBanner({
-		title: node?.meta?.title,
-		version: node?.meta?.version,
+		title: meta?.title,
+		version: meta?.version,
 		config
 	});
 }
 /**
 * Default footer resolver — returns the footer string for a generated file.
 *
-* - When `output.footer` is a function and `node` is provided, calls it with the node.
-* - When `output.footer` is a function and `node` is absent, returns `undefined`.
+* - When `output.footer` is a function, calls it with `meta` and returns the result.
 * - When `output.footer` is a string, returns it directly.
 * - Otherwise returns `undefined`.
 *
@@ -444,14 +813,14 @@ function defaultResolveBanner(node, { output, config }) {
 * // → '// end of file'
 * ```
 *
-* @example Function footer with node
+* @example Function footer with metadata
 * ```ts
-* defaultResolveFooter(inputNode, { output: { footer: (node) => `// ${node.title}` }, config })
+* defaultResolveFooter(meta, { output: { footer: (m) => `// ${m?.title}` }, config })
 * // → '// Pet Store'
 * ```
 */
-function defaultResolveFooter(node, { output }) {
-	if (typeof output?.footer === "function") return node ? output.footer(node) : void 0;
+function defaultResolveFooter(meta, { output }) {
+	if (typeof output?.footer === "function") return output.footer(meta);
 	if (typeof output?.footer === "string") return output.footer;
 }
 /**
@@ -664,11 +1033,11 @@ var FileManager = class {
 	}
 };
 //#endregion
-//#region src/PluginDriver.ts
+//#region src/KubbDriver.ts
 function enforceOrder(enforce) {
 	return enforce === "pre" ? -1 : enforce === "post" ? 1 : 0;
 }
-var PluginDriver = class PluginDriver {
+var KubbDriver = class KubbDriver {
 	config;
 	options;
 	/**
@@ -676,25 +1045,34 @@ var PluginDriver = class PluginDriver {
 	*
 	* @example
 	* ```ts
-	* PluginDriver.getMode('src/gen/types.ts')  // 'single'
-	* PluginDriver.getMode('src/gen/types')     // 'split'
+	* KubbDriver.getMode('src/gen/types.ts')  // 'single'
+	* KubbDriver.getMode('src/gen/types')     // 'split'
 	* ```
 	*/
 	static getMode(fileOrFolder) {
 		return getMode(fileOrFolder);
 	}
 	/**
-	* The universal `@kubb/ast` `InputNode` produced by the adapter, set by
-	* the build pipeline after the adapter's `parse()` resolves.
+	* The streaming `InputStreamNode` produced by the adapter.
+	* Always set after adapter setup — parse-only adapters are wrapped automatically.
 	*/
 	inputNode = void 0;
+	adapter = void 0;
 	/**
-	* Set when the adapter returns a streaming `InputStreamNode` (large specs).
-	* Mutually exclusive with `inputNode` — exactly one is set after adapter setup.
+	* Studio session state, kept together so `dispose()` can reset it atomically.
+	*
+	* - `source` holds the raw adapter source so `adapter.parse()` can be called lazily.
+	*   Intentionally outlives the build; cleared by `dispose()`.
+	* - `isOpen` prevents opening the studio more than once per build.
+	* - `inputNode` caches the parse promise so `adapter.parse()` is called at most once
+	*   per studio session, even when `openInStudio()` is called multiple times.
 	*/
-	inputStreamNode = void 0;
-	adapter = void 0;
-	#studioIsOpen = false;
+	#studio = {
+		source: void 0,
+		isOpen: false,
+		inputNode: void 0
+	};
+	#middlewareListeners = [];
 	/**
 	* Central file store for all generated files.
 	* Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
@@ -706,23 +1084,29 @@ var PluginDriver = class PluginDriver {
 	* Tracks which plugins have generators registered via `addGenerator()` (event-based path).
 	* Used by the build loop to decide whether to emit generator events for a given plugin.
 	*/
-	#pluginsWithEventGenerators = /* @__PURE__ */ new Set();
+	#eventGeneratorPlugins = /* @__PURE__ */ new Set();
 	#resolvers = /* @__PURE__ */ new Map();
 	#defaultResolvers = /* @__PURE__ */ new Map();
 	#hookListeners = /* @__PURE__ */ new Map();
 	constructor(config, options) {
 		this.config = config;
 		this.options = options;
-		config.plugins.map((rawPlugin) => this.#normalizePlugin(rawPlugin)).filter((plugin) => {
-			if (typeof plugin.apply === "function") return plugin.apply(config);
-			return true;
-		}).sort((a, b) => {
+		this.adapter = config.adapter;
+	}
+	async setup() {
+		const normalized = this.config.plugins.map((rawPlugin) => this.#normalizePlugin(rawPlugin));
+		normalized.sort((a, b) => {
 			if (b.dependencies?.includes(a.name)) return -1;
 			if (a.dependencies?.includes(b.name)) return 1;
 			return enforceOrder(a.enforce) - enforceOrder(b.enforce);
-		}).forEach((plugin) => {
-			this.plugins.set(plugin.name, plugin);
 		});
+		for (const plugin of normalized) {
+			if (plugin.apply) plugin.apply(this.config);
+			this.#registerPlugin(plugin);
+			this.plugins.set(plugin.name, plugin);
+		}
+		if (this.config.middleware) for (const middleware of this.config.middleware) for (const event of Object.keys(middleware.hooks)) this.#registerMiddleware(event, middleware.hooks);
+		if (this.config.adapter) await this.#registerAdapter(this.config.adapter);
 	}
 	get hooks() {
 		return this.options.hooks;
@@ -731,19 +1115,48 @@ var PluginDriver = class PluginDriver {
 	* Creates an `NormalizedPlugin` from a hook-style plugin and registers
 	* its lifecycle handlers on the `AsyncEventEmitter`.
 	*/
-	#normalizePlugin(hookPlugin) {
-		const normalizedPlugin = {
-			name: hookPlugin.name,
-			dependencies: hookPlugin.dependencies,
-			enforce: hookPlugin.enforce,
-			options: {
+	#normalizePlugin(plugin) {
+		const normalized = {
+			name: plugin.name,
+			dependencies: plugin.dependencies,
+			enforce: plugin.enforce,
+			hooks: plugin.hooks,
+			options: plugin.options ?? {
 				output: { path: "." },
 				exclude: [],
 				override: []
 			}
 		};
-		this.registerPluginHooks(hookPlugin, normalizedPlugin);
-		return normalizedPlugin;
+		if ("apply" in plugin && typeof plugin.apply === "function") normalized.apply = plugin.apply;
+		return normalized;
+	}
+	async #registerAdapter(adapter) {
+		const source = inputToAdapterSource(this.config);
+		this.#studio.source = source;
+		if (adapter.stream) {
+			this.inputNode = await adapter.stream(source);
+			await this.hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [`✓ Adapter '${adapter.name}' producing input stream`]
+			});
+		} else {
+			const inputNode = await adapter.parse(source);
+			this.inputNode = createStreamInput(arrayToAsyncIterable(inputNode.schemas), arrayToAsyncIterable(inputNode.operations), inputNode.meta);
+			await this.hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [
+					`✓ Adapter '${adapter.name}' resolved InputNode (wrapped as stream)`,
+					`  • Schemas: ${inputNode.schemas.length}`,
+					`  • Operations: ${inputNode.operations.length}`
+				]
+			});
+		}
+	}
+	#registerMiddleware(event, middlewareHooks) {
+		const handler = middlewareHooks[event];
+		if (!handler) return;
+		this.hooks.on(event, handler);
+		this.#middlewareListeners.push([event, handler]);
 	}
 	/**
 	* Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
@@ -760,29 +1173,29 @@ var PluginDriver = class PluginDriver {
 	*
 	* @internal
 	*/
-	registerPluginHooks(hookPlugin, normalizedPlugin) {
-		const { hooks } = hookPlugin;
+	#registerPlugin(plugin) {
+		const { hooks } = plugin;
 		if (!hooks) return;
 		if (hooks["kubb:plugin:setup"]) {
 			const setupHandler = (globalCtx) => {
 				const pluginCtx = {
 					...globalCtx,
-					options: hookPlugin.options ?? {},
+					options: plugin.options ?? {},
 					addGenerator: (gen) => {
-						this.registerGenerator(normalizedPlugin.name, gen);
+						this.registerGenerator(plugin.name, gen);
 					},
 					setResolver: (resolver) => {
-						this.setPluginResolver(normalizedPlugin.name, resolver);
+						this.setPluginResolver(plugin.name, resolver);
 					},
 					setTransformer: (visitor) => {
-						normalizedPlugin.transformer = visitor;
+						plugin.transformer = visitor;
 					},
 					setRenderer: (renderer) => {
-						normalizedPlugin.renderer = renderer;
+						plugin.renderer = renderer;
 					},
 					setOptions: (opts) => {
-						normalizedPlugin.options = {
-							...normalizedPlugin.options,
+						plugin.options = {
+							...plugin.options,
 							...opts
 						};
 					},
@@ -876,7 +1289,7 @@ var PluginDriver = class PluginDriver {
 			this.hooks.on("kubb:generate:operations", operationsHandler);
 			this.#trackHookListener("kubb:generate:operations", operationsHandler);
 		}
-		this.#pluginsWithEventGenerators.add(pluginName);
+		this.#eventGeneratorPlugins.add(pluginName);
 	}
 	/**
 	* Returns `true` when at least one generator was registered for the given plugin
@@ -885,8 +1298,8 @@ var PluginDriver = class PluginDriver {
 	* Used by the build loop to decide whether to walk the AST and emit generator events
 	* for a plugin that has no static `plugin.generators`.
 	*/
-	hasRegisteredGenerators(pluginName) {
-		return this.#pluginsWithEventGenerators.has(pluginName);
+	hasEventGenerators(pluginName) {
+		return this.#eventGeneratorPlugins.has(pluginName);
 	}
 	/**
 	* Unregisters all plugin lifecycle listeners from the shared event emitter.
@@ -897,12 +1310,17 @@ var PluginDriver = class PluginDriver {
 	dispose() {
 		for (const [event, handlers] of this.#hookListeners) for (const handler of handlers) this.hooks.off(event, handler);
 		this.#hookListeners.clear();
-		this.#pluginsWithEventGenerators.clear();
+		this.#eventGeneratorPlugins.clear();
 		this.#resolvers.clear();
 		this.#defaultResolvers.clear();
 		this.fileManager.dispose();
 		this.inputNode = void 0;
-		this.inputStreamNode = void 0;
+		this.#studio = {
+			source: void 0,
+			isOpen: false,
+			inputNode: void 0
+		};
+		for (const [event, handler] of this.#middlewareListeners) this.hooks.off(event, handler);
 	}
 	[Symbol.dispose]() {
 		this.dispose();
@@ -915,16 +1333,10 @@ var PluginDriver = class PluginDriver {
 		}
 		handlers.add(handler);
 	}
-	#createDefaultResolver(pluginName) {
-		const existingResolver = this.#defaultResolvers.get(pluginName);
-		if (existingResolver) return existingResolver;
-		const resolver = defineResolver(() => ({
-			name: "default",
-			pluginName
-		}));
-		this.#defaultResolvers.set(pluginName, resolver);
-		return resolver;
-	}
+	#getDefaultResolver = memoize(this.#defaultResolvers, (pluginName) => defineResolver(() => ({
+		name: "default",
+		pluginName
+	})));
 	/**
 	* Merges `partial` with the plugin's default resolver and stores the result.
 	* Also mirrors it onto `plugin.resolver` so callers using `getPlugin(name).resolver`
@@ -932,7 +1344,7 @@ var PluginDriver = class PluginDriver {
 	*/
 	setPluginResolver(pluginName, partial) {
 		const merged = {
-			...this.#createDefaultResolver(pluginName),
+			...this.#getDefaultResolver(pluginName),
 			...partial
 		};
 		this.#resolvers.set(pluginName, merged);
@@ -940,7 +1352,7 @@ var PluginDriver = class PluginDriver {
 		if (plugin) plugin.resolver = merged;
 	}
 	getResolver(pluginName) {
-		return this.#resolvers.get(pluginName) ?? this.plugins.get(pluginName)?.resolver ?? this.#createDefaultResolver(pluginName);
+		return this.#resolvers.get(pluginName) ?? this.plugins.get(pluginName)?.resolver ?? this.#getDefaultResolver(pluginName);
 	}
 	getContext(plugin) {
 		const driver = this;
@@ -950,7 +1362,7 @@ var PluginDriver = class PluginDriver {
 				return resolve(driver.config.root, driver.config.output.path);
 			},
 			getMode(output) {
-				return PluginDriver.getMode(resolve(driver.config.root, driver.config.output.path, output.path));
+				return KubbDriver.getMode(resolve(driver.config.root, driver.config.output.path, output.path));
 			},
 			hooks: driver.hooks,
 			plugin,
@@ -964,13 +1376,10 @@ var PluginDriver = class PluginDriver {
 			upsertFile: async (...files) => {
 				driver.fileManager.upsert(...files);
 			},
-			get inputNode() {
-				if (driver.inputNode) return driver.inputNode;
-				return {
-					kind: "Input",
-					schemas: [],
-					operations: [],
-					meta: driver.inputStreamNode?.meta
+			get meta() {
+				return driver.inputNode?.meta ?? {
+					circularNames: [],
+					enumNames: []
 				};
 			},
 			get adapter() {
@@ -991,13 +1400,14 @@ var PluginDriver = class PluginDriver {
 			info(message) {
 				driver.hooks.emit("kubb:info", { message });
 			},
-			openInStudio(options) {
-				if (!driver.config.devtools || driver.#studioIsOpen) return;
+			async openInStudio(options) {
+				if (!driver.config.devtools || driver.#studio.isOpen) return;
 				if (typeof driver.config.devtools !== "object") throw new Error("Devtools must be an object");
-				if (!driver.inputNode || !driver.adapter) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
-				driver.#studioIsOpen = true;
+				if (!driver.adapter || !driver.#studio.source) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
+				driver.#studio.isOpen = true;
 				const studioUrl = driver.config.devtools?.studioUrl ?? "https://kubb.studio";
-				return openInStudio(driver.inputNode, studioUrl, options);
+				driver.#studio.inputNode ??= Promise.resolve(driver.adapter.parse(driver.#studio.source));
+				return openInStudio(await driver.#studio.inputNode, studioUrl, options);
 			}
 		};
 	}
@@ -1044,7 +1454,23 @@ async function applyAsyncRender({ renderer, result, driver }) {
 	driver.fileManager.upsert(...renderer.files);
 	renderer.unmount();
 }
+function inputToAdapterSource(config) {
+	const input = config.input;
+	if (!input) throw new Error("[kubb] input is required when using an adapter. Provide input.path or input.data in your config.");
+	if ("data" in input) return {
+		type: "data",
+		data: input.data
+	};
+	if (new URLPath(input.path).isURL) return {
+		type: "path",
+		path: input.path
+	};
+	return {
+		type: "path",
+		path: resolve(config.root, input.path)
+	};
+}
 //#endregion
-export { definePlugin as a, DEFAULT_STUDIO_URL as c, defineResolver as i, logLevel as l, applyHookResult as n, DEFAULT_BANNER as o, FileManager as r, DEFAULT_EXTENSION as s, PluginDriver as t, camelCase as u };
+export { definePlugin as a, DEFAULT_STUDIO_URL as c, forBatches as d, isPromise as f, defineResolver as i, logLevel as l, applyHookResult as n, DEFAULT_BANNER as o, withDrain as p, FileManager as r, DEFAULT_EXTENSION as s, KubbDriver as t, URLPath as u };
 
-//# sourceMappingURL=PluginDriver-uNex0SAr.js.map
+//# sourceMappingURL=KubbDriver-Cxii_rBp.js.map