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

package/dist/{KubbDriver-Cxii_rBp.js → KubbDriver-Cq1isv2P.js}

@@ -1,8 +1,152 @@
 import "./chunk--u3MIqq1.js";
+import { EventEmitter } from "node:events";
 import path, { extname, resolve } from "node:path";
-import { createFile, createStreamInput, isOperationNode, isSchemaNode } from "@kubb/ast";
+import { collectUsedSchemaNames, createFile, createStreamInput, extractStringsFromNodes, isOperationNode, isSchemaNode, transform } from "@kubb/ast";
 import { deflateSync } from "fflate";
 import { x } from "tinyexec";
+//#region ../../internals/utils/src/errors.ts
+/**
+* Thrown when one or more errors occur during a Kubb build.
+* Carries the full list of underlying errors on `errors`.
+*
+* @example
+* ```ts
+* throw new BuildError('Build failed', { errors: [err1, err2] })
+* ```
+*/
+var BuildError = class extends Error {
+	errors;
+	constructor(message, options) {
+		super(message, { cause: options.cause });
+		this.name = "BuildError";
+		this.errors = options.errors;
+	}
+};
+/**
+* Coerces an unknown thrown value to an `Error` instance.
+* Returns the value as-is when it is already an `Error`; otherwise wraps it with `String(value)`.
+*
+* @example
+* ```ts
+* try { ... } catch(err) {
+*   throw new BuildError('Build failed', { cause: toError(err), errors: [] })
+* }
+* ```
+*/
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+//#endregion
+//#region ../../internals/utils/src/asyncEventEmitter.ts
+/**
+* Typed `EventEmitter` that awaits all async listeners before resolving.
+* Wraps Node's `EventEmitter` with full TypeScript event-map inference.
+*
+* @example
+* ```ts
+* const emitter = new AsyncEventEmitter<{ build: [name: string] }>()
+* emitter.on('build', async (name) => { console.log(name) })
+* await emitter.emit('build', 'petstore') // all listeners awaited
+* ```
+*/
+var AsyncEventEmitter = class {
+	/**
+	* Maximum number of listeners per event before Node emits a memory-leak warning.
+	* @default 10
+	*/
+	constructor(maxListener = 10) {
+		this.#emitter.setMaxListeners(maxListener);
+	}
+	#emitter = new EventEmitter();
+	/**
+	* Emits `eventName` and awaits all registered listeners sequentially.
+	* Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
+	*
+	* @example
+	* ```ts
+	* await emitter.emit('build', 'petstore')
+	* ```
+	*/
+	emit(eventName, ...eventArgs) {
+		const listeners = this.#emitter.listeners(eventName);
+		if (listeners.length === 0) return;
+		return this.#emitAll(eventName, listeners, eventArgs);
+	}
+	async #emitAll(eventName, listeners, eventArgs) {
+		for (const listener of listeners) try {
+			await listener(...eventArgs);
+		} catch (err) {
+			let serializedArgs;
+			try {
+				serializedArgs = JSON.stringify(eventArgs);
+			} catch {
+				serializedArgs = String(eventArgs);
+			}
+			throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
+		}
+	}
+	/**
+	* Registers a persistent listener for `eventName`.
+	*
+	* @example
+	* ```ts
+	* emitter.on('build', async (name) => { console.log(name) })
+	* ```
+	*/
+	on(eventName, handler) {
+		this.#emitter.on(eventName, handler);
+	}
+	/**
+	* Registers a one-shot listener that removes itself after the first invocation.
+	*
+	* @example
+	* ```ts
+	* emitter.onOnce('build', async (name) => { console.log(name) })
+	* ```
+	*/
+	onOnce(eventName, handler) {
+		const wrapper = (...args) => {
+			this.off(eventName, wrapper);
+			return handler(...args);
+		};
+		this.on(eventName, wrapper);
+	}
+	/**
+	* Removes a previously registered listener.
+	*
+	* @example
+	* ```ts
+	* emitter.off('build', handler)
+	* ```
+	*/
+	off(eventName, handler) {
+		this.#emitter.off(eventName, handler);
+	}
+	/**
+	* Returns the number of listeners registered for `eventName`.
+	*
+	* @example
+	* ```ts
+	* emitter.on('build', handler)
+	* emitter.listenerCount('build') // 1
+	* ```
+	*/
+	listenerCount(eventName) {
+		return this.#emitter.listenerCount(eventName);
+	}
+	/**
+	* Removes all listeners from every event channel.
+	*
+	* @example
+	* ```ts
+	* emitter.removeAll()
+	* ```
+	*/
+	removeAll() {
+		this.#emitter.removeAllListeners();
+	}
+};
+//#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -67,6 +211,39 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
+//#region ../../internals/utils/src/time.ts
+/**
+* Calculates elapsed time in milliseconds from a high-resolution `process.hrtime` start time.
+* Rounds to 2 decimal places for sub-millisecond precision without noise.
+*
+* @example
+* ```ts
+* const start = process.hrtime()
+* doWork()
+* getElapsedMs(start) // 42.35
+* ```
+*/
+function getElapsedMs(hrStart) {
+	const [seconds, nanoseconds] = process.hrtime(hrStart);
+	const ms = seconds * 1e3 + nanoseconds / 1e6;
+	return Math.round(ms * 100) / 100;
+}
+/**
+* Converts a millisecond duration into a human-readable string (`ms`, `s`, or `m s`).
+*
+* @example
+* ```ts
+* formatMs(250)   // '250ms'
+* formatMs(1500)  // '1.50s'
+* formatMs(90000) // '1m 30.0s'
+* ```
+*/
+function formatMs(ms) {
+	if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
+	if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
+	return `${Math.round(ms)}ms`;
+}
+//#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);
@@ -109,22 +286,6 @@ async function forBatches(source, process, options) {
 		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
@@ -787,13 +948,13 @@ function buildDefaultBanner({ title, description, version, config }) {
 * @example Disabled default banner
 * ```ts
 * defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
-* // → undefined
+* // → null
 * ```
 */
 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;
+	if (config.output.defaultBanner === false) return null;
 	return buildDefaultBanner({
 		title: meta?.title,
 		version: meta?.version,
@@ -822,6 +983,7 @@ function defaultResolveBanner(meta, { output, config }) {
 function defaultResolveFooter(meta, { output }) {
 	if (typeof output?.footer === "function") return output.footer(meta);
 	if (typeof output?.footer === "string") return output.footer;
+	return null;
 }
 /**
 * Defines a resolver for a plugin, injecting built-in defaults for name casing,
@@ -932,111 +1094,241 @@ function mergeFile(a, b) {
 		...a,
 		banner: b.banner,
 		footer: b.footer,
-		sources: [...a.sources || [], ...b.sources || []],
-		imports: [...a.imports || [], ...b.imports || []],
-		exports: [...a.exports || [], ...b.exports || []]
+		sources: a.sources.length ? b.sources.length ? [...a.sources, ...b.sources] : a.sources : b.sources,
+		imports: a.imports.length ? b.imports.length ? [...a.imports, ...b.imports] : a.imports : b.imports,
+		exports: a.exports.length ? b.exports.length ? [...a.exports, ...b.exports] : a.exports : b.exports
 	};
 }
-/**
-* Collapses a list of files so that duplicates sharing the same `path` are merged
-* in arrival order. Keeps the original order of first occurrence.
-*/
-function mergeFilesByPath(files) {
-	const merged = /* @__PURE__ */ new Map();
-	for (const file of files) {
-		const existing = merged.get(file.path);
-		merged.set(file.path, existing ? mergeFile(existing, file) : file);
-	}
-	return merged;
+function isIndexPath(path) {
+	return path.endsWith("/index.ts") || path === "index.ts";
+}
+function compareFiles(a, b) {
+	const lenDiff = a.path.length - b.path.length;
+	if (lenDiff !== 0) return lenDiff;
+	const aIsIndex = isIndexPath(a.path);
+	const bIsIndex = isIndexPath(b.path);
+	if (aIsIndex && !bIsIndex) return 1;
+	if (!aIsIndex && bIsIndex) return -1;
+	return 0;
 }
 /**
-* In-memory file store for generated files.
-*
-* Files with the same `path` are merged — sources, imports, and exports are concatenated.
-* The `files` getter returns all stored files sorted by path length (shortest first).
+* In-memory file store for generated files. Files sharing a `path` are merged
+* (sources/imports/exports concatenated). The `files` getter is sorted by
+* path length (barrel `index.ts` last within a bucket).
 *
 * @example
 * ```ts
-* import { FileManager } from '@kubb/core'
-*
 * const manager = new FileManager()
 * manager.upsert(myFile)
-* console.log(manager.files) // all stored files
+* manager.files // sorted view
 * ```
 */
 var FileManager = class {
 	#cache = /* @__PURE__ */ new Map();
-	#filesCache = null;
+	#sorted = null;
+	#onUpsert = null;
 	/**
-	* Adds one or more files. Incoming files with the same path are merged
-	* (sources/imports/exports concatenated), but existing cache entries are
-	* replaced — use {@link upsert} when you want to merge into the cache too.
+	* Registers a callback invoked with the resolved {@link FileNode} on every
+	* `add` / `upsert`. Used by the build loop to track newly written files
+	* without keeping its own scan-based diff. Single subscriber by design —
+	* setting again replaces the previous callback. Pass `null` to detach.
 	*/
+	setOnUpsert(callback) {
+		this.#onUpsert = callback;
+	}
 	add(...files) {
 		return this.#store(files, false);
 	}
-	/**
-	* Adds or merges one or more files.
-	* If a file with the same path already exists in the cache, its
-	* sources/imports/exports are merged into the incoming file.
-	*/
 	upsert(...files) {
 		return this.#store(files, true);
 	}
 	#store(files, mergeExisting) {
-		const resolvedFiles = [];
-		for (const file of mergeFilesByPath(files).values()) {
-			const existing = mergeExisting ? this.#cache.get(file.path) : void 0;
-			const resolvedFile = createFile(existing ? mergeFile(existing, file) : file);
-			this.#cache.set(resolvedFile.path, resolvedFile);
-			resolvedFiles.push(resolvedFile);
+		const batch = files.length > 1 ? this.#dedupe(files) : files;
+		const resolved = [];
+		for (const file of batch) {
+			const existing = this.#cache.get(file.path);
+			const merged = existing && mergeExisting ? createFile(mergeFile(existing, file)) : file;
+			this.#cache.set(merged.path, merged);
+			resolved.push(merged);
+			this.#onUpsert?.(merged);
 		}
-		this.#filesCache = null;
-		return resolvedFiles;
+		if (resolved.length > 0) this.#sorted = null;
+		return resolved;
+	}
+	#dedupe(files) {
+		const seen = /* @__PURE__ */ new Map();
+		for (const file of files) {
+			const prev = seen.get(file.path);
+			seen.set(file.path, prev ? mergeFile(prev, file) : file);
+		}
+		return [...seen.values()];
 	}
 	getByPath(path) {
 		return this.#cache.get(path) ?? null;
 	}
 	deleteByPath(path) {
-		this.#cache.delete(path);
-		this.#filesCache = null;
+		if (!this.#cache.delete(path)) return;
+		this.#sorted = null;
 	}
 	clear() {
 		this.#cache.clear();
-		this.#filesCache = null;
+		this.#sorted = null;
 	}
 	/**
-	* Releases all stored files. Called by the core after `kubb:build:end` to
-	* free the per-plugin FileNode caches for the rest of the process lifetime.
+	* Releases all stored files. Called by the core after `kubb:build:end`.
 	*/
 	dispose() {
 		this.clear();
+		this.#onUpsert = null;
 	}
 	[Symbol.dispose]() {
 		this.dispose();
 	}
 	/**
-	* All stored files, sorted by path length (shorter paths first).
+	* All stored files in stable sort order (shortest path first, barrel files
+	* last within a length bucket). Returns a cached view — do not mutate.
 	*/
 	get files() {
-		if (this.#filesCache) return this.#filesCache;
-		this.#filesCache = [...this.#cache.values()].sort((a, b) => {
-			const lenDiff = a.path.length - b.path.length;
-			if (lenDiff !== 0) return lenDiff;
-			const aIsIndex = a.path.endsWith("/index.ts") || a.path === "index.ts";
-			const bIsIndex = b.path.endsWith("/index.ts") || b.path === "index.ts";
-			if (aIsIndex && !bIsIndex) return 1;
-			if (!aIsIndex && bIsIndex) return -1;
-			return 0;
+		return this.#sorted ??= [...this.#cache.values()].sort(compareFiles);
+	}
+};
+//#endregion
+//#region src/FileProcessor.ts
+function joinSources(file) {
+	const sources = file.sources;
+	if (sources.length === 0) return "";
+	const parts = [];
+	for (const source of sources) {
+		const s = extractStringsFromNodes(source.nodes);
+		if (s) parts.push(s);
+	}
+	return parts.join("\n\n");
+}
+/**
+* Converts a single file to a string using the registered parsers.
+* Falls back to joining source values when no matching parser is found.
+*
+* @internal
+*/
+var FileProcessor = class {
+	events = new AsyncEventEmitter();
+	parse(file, { parsers, extension } = {}) {
+		const parseExtName = extension?.[file.extname] || void 0;
+		if (!parsers || !file.extname) return joinSources(file);
+		const parser = parsers.get(file.extname);
+		if (!parser) return joinSources(file);
+		return parser.parse(file, { extname: parseExtName });
+	}
+	*stream(files, options = {}) {
+		const total = files.length;
+		if (total === 0) return;
+		let processed = 0;
+		for (const file of files) {
+			const source = this.parse(file, options);
+			processed++;
+			yield {
+				file,
+				source,
+				processed,
+				total,
+				percentage: processed / total * 100
+			};
+		}
+	}
+	async run(files, options = {}) {
+		await this.events.emit("start", files);
+		for (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
+			file,
+			source,
+			processed,
+			percentage,
+			total
 		});
-		return this.#filesCache;
+		await this.events.emit("end", files);
+		return files;
+	}
+	/**
+	* Clears all registered event listeners.
+	*/
+	dispose() {
+		this.events.removeAll();
+	}
+	[Symbol.dispose]() {
+		this.dispose();
 	}
 };
 //#endregion
+//#region \0@oxc-project+runtime@0.129.0/helpers/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	};
+	var e = {};
+	var n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o;
+			var t = this.e;
+			var s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
 //#region src/KubbDriver.ts
 function enforceOrder(enforce) {
 	return enforce === "pre" ? -1 : enforce === "post" ? 1 : 0;
 }
+const OPERATION_FILTER_TYPES = new Set([
+	"tag",
+	"operationId",
+	"path",
+	"method",
+	"contentType"
+]);
 var KubbDriver = class KubbDriver {
 	config;
 	options;
@@ -1056,8 +1348,8 @@ var KubbDriver = class KubbDriver {
 	* The streaming `InputStreamNode` produced by the adapter.
 	* Always set after adapter setup — parse-only adapters are wrapped automatically.
 	*/
-	inputNode = void 0;
-	adapter = void 0;
+	inputNode = null;
+	adapter = null;
 	/**
 	* Studio session state, kept together so `dispose()` can reset it atomically.
 	*
@@ -1068,9 +1360,9 @@ var KubbDriver = class KubbDriver {
 	*   per studio session, even when `openInStudio()` is called multiple times.
 	*/
 	#studio = {
-		source: void 0,
+		source: null,
 		isOpen: false,
-		inputNode: void 0
+		inputNode: null
 	};
 	#middlewareListeners = [];
 	/**
@@ -1079,6 +1371,7 @@ var KubbDriver = class KubbDriver {
 	* add files; this property gives direct read/write access when needed.
 	*/
 	fileManager = new FileManager();
+	#fileProcessor = new FileProcessor();
 	plugins = /* @__PURE__ */ new Map();
 	/**
 	* Tracks which plugins have generators registered via `addGenerator()` (event-based path).
@@ -1091,7 +1384,7 @@ var KubbDriver = class KubbDriver {
 	constructor(config, options) {
 		this.config = config;
 		this.options = options;
-		this.adapter = config.adapter;
+		this.adapter = config.adapter ?? null;
 	}
 	async setup() {
 		const normalized = this.config.plugins.map((rawPlugin) => this.#normalizePlugin(rawPlugin));
@@ -1302,6 +1595,334 @@ var KubbDriver = class KubbDriver {
 		return this.#eventGeneratorPlugins.has(pluginName);
 	}
 	/**
+	* Runs the full plugin pipeline. Returns timings/failures collected so far even
+	* when an outer hook throws — the orchestrator preserves partial state by capturing
+	* the error into `error` instead of propagating.
+	*/
+	async run({ storage }) {
+		const hooks = this.hooks;
+		const config = this.config;
+		const failedPlugins = /* @__PURE__ */ new Set();
+		const pluginTimings = /* @__PURE__ */ new Map();
+		const parsersMap = /* @__PURE__ */ new Map();
+		for (const parser of config.parsers) if (parser.extNames) for (const ext of parser.extNames) parsersMap.set(ext, parser);
+		const pendingFiles = /* @__PURE__ */ new Map();
+		this.fileManager.setOnUpsert((file) => {
+			pendingFiles.set(file.path, file);
+		});
+		try {
+			const flushPending = async () => {
+				if (pendingFiles.size === 0) return;
+				const files = [...pendingFiles.values()];
+				pendingFiles.clear();
+				await hooks.emit("kubb:debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [`Writing ${files.length} files...`]
+				});
+				await hooks.emit("kubb:files:processing:start", { files });
+				const items = [...this.#fileProcessor.stream(files, {
+					parsers: parsersMap,
+					extension: config.output.extension
+				})];
+				await hooks.emit("kubb:files:processing:update", { files: items.map(({ file, source, processed, total, percentage }) => ({
+					file,
+					source,
+					processed,
+					total,
+					percentage,
+					config
+				})) });
+				const queue = [];
+				for (const { file, source } of items) if (source) {
+					queue.push(storage.setItem(file.path, source));
+					if (queue.length >= 50) await Promise.all(queue.splice(0));
+				}
+				await Promise.all(queue);
+				await hooks.emit("kubb:files:processing:end", { files });
+				await hooks.emit("kubb:debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [`✓ File write process completed for ${files.length} files`]
+				});
+			};
+			await this.emitSetupHooks();
+			if (this.adapter && this.inputNode) await hooks.emit("kubb:build:start", Object.assign({
+				config,
+				adapter: this.adapter,
+				meta: this.inputNode.meta,
+				getPlugin: this.getPlugin.bind(this)
+			}, this.#filesPayload()));
+			const generatorPlugins = [];
+			for (const plugin of this.plugins.values()) {
+				const context = this.getContext(plugin);
+				const hrStart = process.hrtime();
+				try {
+					await hooks.emit("kubb:plugin:start", { plugin });
+					await hooks.emit("kubb:debug", {
+						date: /* @__PURE__ */ new Date(),
+						logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
+					});
+				} catch (caughtError) {
+					const error = caughtError;
+					const duration = getElapsedMs(hrStart);
+					pluginTimings.set(plugin.name, duration);
+					await this.#emitPluginEnd({
+						plugin,
+						duration,
+						success: false,
+						error
+					});
+					failedPlugins.add({
+						plugin,
+						error
+					});
+					continue;
+				}
+				if (plugin.generators?.length || this.hasEventGenerators(plugin.name)) {
+					generatorPlugins.push({
+						plugin,
+						context,
+						hrStart
+					});
+					continue;
+				}
+				const duration = getElapsedMs(hrStart);
+				pluginTimings.set(plugin.name, duration);
+				await this.#emitPluginEnd({
+					plugin,
+					duration,
+					success: true
+				});
+				await hooks.emit("kubb:debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
+				});
+			}
+			if (generatorPlugins.length > 0) if (this.inputNode) {
+				const { timings, failed } = await this.#runGenerators(generatorPlugins, flushPending);
+				await flushPending();
+				for (const [name, duration] of timings) pluginTimings.set(name, duration);
+				for (const entry of failed) failedPlugins.add(entry);
+			} else for (const { plugin, hrStart } of generatorPlugins) {
+				const duration = getElapsedMs(hrStart);
+				pluginTimings.set(plugin.name, duration);
+				await this.#emitPluginEnd({
+					plugin,
+					duration,
+					success: true
+				});
+			}
+			await hooks.emit("kubb:plugins:end", Object.assign({ config }, this.#filesPayload()));
+			await flushPending();
+			const files = this.fileManager.files;
+			await hooks.emit("kubb:build:end", {
+				files,
+				config,
+				outputDir: resolve(config.root, config.output.path)
+			});
+			return {
+				failedPlugins,
+				pluginTimings
+			};
+		} catch (caughtError) {
+			return {
+				failedPlugins,
+				pluginTimings,
+				error: caughtError
+			};
+		} finally {
+			this.fileManager.setOnUpsert(null);
+		}
+	}
+	#filesPayload() {
+		const driver = this;
+		return {
+			get files() {
+				return driver.fileManager.files;
+			},
+			upsertFile: (...files) => driver.fileManager.upsert(...files)
+		};
+	}
+	#emitPluginEnd({ plugin, duration, success, error }) {
+		return this.hooks.emit("kubb:plugin:end", Object.assign({
+			plugin,
+			duration,
+			success,
+			...error ? { error } : {},
+			config: this.config
+		}, this.#filesPayload()));
+	}
+	async #runGenerators(entries, flushPending) {
+		const timings = /* @__PURE__ */ new Map();
+		const failed = /* @__PURE__ */ new Set();
+		const driver = this;
+		const { schemas, operations } = this.inputNode;
+		const states = entries.map(({ plugin, context, hrStart }) => {
+			const { exclude, include, override } = plugin.options;
+			const hasExclude = Array.isArray(exclude) && exclude.length > 0;
+			const hasInclude = Array.isArray(include) && include.length > 0;
+			const hasOverride = Array.isArray(override) && override.length > 0;
+			return {
+				plugin,
+				generatorContext: {
+					...context,
+					resolver: this.getResolver(plugin.name)
+				},
+				generators: plugin.generators ?? [],
+				hrStart,
+				failed: false,
+				error: null,
+				optionsAreStatic: !hasExclude && !hasInclude && !hasOverride,
+				allowedSchemaNames: null
+			};
+		});
+		const emitsSchemaHook = this.hooks.listenerCount("kubb:generate:schema") > 0;
+		const emitsOperationHook = this.hooks.listenerCount("kubb:generate:operation") > 0;
+		const pruningStates = states.filter(({ plugin }) => {
+			const { include } = plugin.options;
+			return (include?.some(({ type }) => OPERATION_FILTER_TYPES.has(type)) ?? false) && !(include?.some(({ type }) => type === "schemaName") ?? false);
+		});
+		if (pruningStates.length > 0) {
+			const allSchemas = [];
+			for await (const schema of schemas) allSchemas.push(schema);
+			const includedOpsByState = new Map(pruningStates.map((s) => [s, []]));
+			for await (const operation of operations) for (const state of pruningStates) {
+				const { exclude, include, override } = state.plugin.options;
+				if (state.generatorContext.resolver.resolveOptions(operation, {
+					options: state.plugin.options,
+					exclude,
+					include,
+					override
+				}) !== null) includedOpsByState.get(state)?.push(operation);
+			}
+			for (const state of pruningStates) {
+				state.allowedSchemaNames = collectUsedSchemaNames(includedOpsByState.get(state) ?? [], allSchemas);
+				includedOpsByState.delete(state);
+			}
+		}
+		const resolveRendererFor = (gen, state) => gen.renderer === null ? void 0 : gen.renderer ?? state.plugin.renderer ?? state.generatorContext.config.renderer;
+		const dispatchSchema = async (state, node) => {
+			if (state.failed) return;
+			try {
+				const { plugin, generatorContext, generators } = state;
+				const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+				if (state.allowedSchemaNames !== null && transformedNode.name && !state.allowedSchemaNames.has(transformedNode.name)) return;
+				const { exclude, include, override } = plugin.options;
+				const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+					options: plugin.options,
+					exclude,
+					include,
+					override
+				});
+				if (options === null) return;
+				const ctx = {
+					...generatorContext,
+					options
+				};
+				for (const gen of generators) {
+					if (!gen.schema) continue;
+					const raw = gen.schema(transformedNode, ctx);
+					const applied = applyHookResult({
+						result: isPromise(raw) ? await raw : raw,
+						driver,
+						rendererFactory: resolveRendererFor(gen, state)
+					});
+					if (isPromise(applied)) await applied;
+				}
+				if (emitsSchemaHook) await this.hooks.emit("kubb:generate:schema", transformedNode, ctx);
+			} catch (caughtError) {
+				state.failed = true;
+				state.error = caughtError;
+			}
+		};
+		const dispatchOperation = async (state, node) => {
+			if (state.failed) return;
+			try {
+				const { plugin, generatorContext, generators } = state;
+				const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+				const { exclude, include, override } = plugin.options;
+				const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
+					options: plugin.options,
+					exclude,
+					include,
+					override
+				});
+				if (options === null) return;
+				const ctx = {
+					...generatorContext,
+					options
+				};
+				for (const gen of generators) {
+					if (!gen.operation) continue;
+					const raw = gen.operation(transformedNode, ctx);
+					const applied = applyHookResult({
+						result: isPromise(raw) ? await raw : raw,
+						driver,
+						rendererFactory: resolveRendererFor(gen, state)
+					});
+					if (isPromise(applied)) await applied;
+				}
+				if (emitsOperationHook) await this.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+			} catch (caughtError) {
+				state.failed = true;
+				state.error = caughtError;
+			}
+		};
+		const needsCollectedOperations = this.hooks.listenerCount("kubb:generate:operations") > 0 || states.some((s) => s.generators.some((g) => !!g.operations));
+		const collectedOperations = needsCollectedOperations ? [] : void 0;
+		await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((n) => states.map((state) => dispatchSchema(state, n)))), {
+			concurrency: 8,
+			flush: flushPending
+		});
+		await forBatches(operations, (nodes) => {
+			if (needsCollectedOperations) collectedOperations.push(...nodes);
+			return Promise.all(nodes.flatMap((n) => states.map((state) => dispatchOperation(state, n))));
+		}, {
+			concurrency: 8,
+			flush: flushPending
+		});
+		for (const state of states) {
+			if (!state.failed && needsCollectedOperations) try {
+				const { plugin, generatorContext, generators } = state;
+				const ctx = {
+					...generatorContext,
+					options: plugin.options
+				};
+				for (const gen of generators) {
+					if (!gen.operations) continue;
+					await applyHookResult({
+						result: await gen.operations(collectedOperations, ctx),
+						driver,
+						rendererFactory: resolveRendererFor(gen, state)
+					});
+				}
+				await this.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
+			} catch (caughtError) {
+				state.failed = true;
+				state.error = caughtError;
+			}
+			const duration = getElapsedMs(state.hrStart);
+			timings.set(state.plugin.name, duration);
+			await this.#emitPluginEnd({
+				plugin: state.plugin,
+				duration,
+				success: !state.failed,
+				error: state.failed && state.error ? state.error : void 0
+			});
+			if (state.failed && state.error) failed.add({
+				plugin: state.plugin,
+				error: state.error
+			});
+			await this.hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [state.failed ? "✗ Plugin start failed" : `✓ Plugin started successfully (${formatMs(duration)})`]
+			});
+		}
+		return {
+			timings,
+			failed
+		};
+	}
+	/**
 	* Unregisters all plugin lifecycle listeners from the shared event emitter.
 	* Called at the end of a build to prevent listener leaks across repeated builds.
 	*
@@ -1314,11 +1935,12 @@ var KubbDriver = class KubbDriver {
 		this.#resolvers.clear();
 		this.#defaultResolvers.clear();
 		this.fileManager.dispose();
-		this.inputNode = void 0;
+		this.#fileProcessor.dispose();
+		this.inputNode = null;
 		this.#studio = {
-			source: void 0,
+			source: null,
 			isOpen: false,
-			inputNode: void 0
+			inputNode: null
 		};
 		for (const [event, handler] of this.#middlewareListeners) this.hooks.off(event, handler);
 	}
@@ -1438,10 +2060,15 @@ function applyHookResult({ result, driver, rendererFactory }) {
 	}
 	if (!rendererFactory) return;
 	const renderer = rendererFactory();
-	if (renderer.stream) {
-		for (const file of renderer.stream(result)) driver.fileManager.upsert(file);
-		renderer.unmount();
+	if (renderer.stream) try {
+		var _usingCtx$1 = _usingCtx();
+		const r = _usingCtx$1.u(renderer);
+		for (const file of r.stream(result)) driver.fileManager.upsert(file);
 		return;
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
 	}
 	return applyAsyncRender({
 		renderer,
@@ -1450,9 +2077,16 @@ function applyHookResult({ result, driver, rendererFactory }) {
 	});
 }
 async function applyAsyncRender({ renderer, result, driver }) {
-	await renderer.render(result);
-	driver.fileManager.upsert(...renderer.files);
-	renderer.unmount();
+	try {
+		var _usingCtx3 = _usingCtx();
+		const r = _usingCtx3.u(renderer);
+		await r.render(result);
+		driver.fileManager.upsert(...r.files);
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		_usingCtx3.d();
+	}
 }
 function inputToAdapterSource(config) {
 	const input = config.input;
@@ -1471,6 +2105,6 @@ function inputToAdapterSource(config) {
 	};
 }
 //#endregion
-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 };
+export { FileManager as a, DEFAULT_BANNER as c, logLevel as d, URLPath as f, FileProcessor as i, DEFAULT_EXTENSION as l, BuildError as m, applyHookResult as n, defineResolver as o, AsyncEventEmitter as p, _usingCtx as r, definePlugin as s, KubbDriver as t, DEFAULT_STUDIO_URL as u };
 
-//# sourceMappingURL=KubbDriver-Cxii_rBp.js.map
+//# sourceMappingURL=KubbDriver-Cq1isv2P.js.map