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

package/dist/index.js

@@ -1,5 +1,5 @@
 import "./chunk--u3MIqq1.js";
-import { a as definePlugin, c as DEFAULT_STUDIO_URL, i as defineResolver, l as logLevel, n as applyHookResult, o as DEFAULT_BANNER, r as FileManager, s as DEFAULT_EXTENSION, t as PluginDriver, u as camelCase } from "./PluginDriver-CT33kVoQ.js";
+import { a as definePlugin, c as DEFAULT_STUDIO_URL, i as defineResolver, l as logLevel, n as applyHookResult, o as DEFAULT_BANNER, r as FileManager, s as DEFAULT_EXTENSION, t as PluginDriver, u as camelCase } from "./PluginDriver-uNex0SAr.js";
 import { EventEmitter } from "node:events";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
@@ -69,9 +69,12 @@ var AsyncEventEmitter = class {
 	* await emitter.emit('build', 'petstore')
 	* ```
 	*/
-	async emit(eventName, ...eventArgs) {
+	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) {
@@ -245,6 +248,19 @@ async function clean(path) {
 	});
 }
 //#endregion
+//#region ../../internals/utils/src/promise.ts
+/** 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";
+}
+//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
@@ -525,7 +541,7 @@ function createAdapter(build) {
 }
 //#endregion
 //#region package.json
-var version$1 = "5.0.0-beta.17";
+var version$1 = "5.0.0-beta.19";
 //#endregion
 //#region src/createStorage.ts
 /**
@@ -566,7 +582,14 @@ function createStorage(build) {
 //#endregion
 //#region src/FileProcessor.ts
 function joinSources(file) {
-	return file.sources.map((item) => extractStringsFromNodes(item.nodes)).filter(Boolean).join("\n\n");
+	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.
@@ -576,25 +599,19 @@ function joinSources(file) {
 */
 var FileProcessor = class {
 	events = new AsyncEventEmitter();
-	async parse(file, { parsers, extension } = {}) {
+	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 });
 	}
-	/**
-	* Streams parsed files one at a time as each is processed.
-	*
-	* Unlike `run()`, files are yielded immediately after parsing rather than batched.
-	* Storage writes can begin as soon as the first file is ready, keeping peak
-	* memory proportional to one file at a time instead of the full batch.
-	*/
-	async *stream(files, options = {}) {
+	*stream(files, options = {}) {
 		const total = files.length;
+		if (total === 0) return;
 		let processed = 0;
 		for (const file of files) {
-			const source = await this.parse(file, options);
+			const source = this.parse(file, options);
 			processed++;
 			yield {
 				file,
@@ -607,7 +624,7 @@ var FileProcessor = class {
 	}
 	async run(files, options = {}) {
 		await this.events.emit("start", files);
-		for await (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
+		for (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
 			file,
 			source,
 			processed,
@@ -693,6 +710,66 @@ const fsStorage = createStorage(() => ({
 	}
 }));
 //#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/createKubb.ts
 /**
 * Builds a `Storage` view scoped to the file paths produced by the current build.
@@ -821,18 +898,9 @@ async function setup(userConfig, options = {}) {
 						`  • Operations: ${operationCount}`
 					]
 				});
-			} else {
-				driver.inputNode = await config.adapter.parse(source);
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [
-						`✓ Adapter '${config.adapter.name}' resolved InputNode`,
-						`  • Schemas: ${driver.inputNode.schemas.length}`,
-						`  • Operations: ${driver.inputNode.operations.length}`
-					]
-				});
 			}
-		} else {
+		}
+		if (!driver.inputStreamNode) {
 			driver.inputNode = await config.adapter.parse(source);
 			await hooks.emit("kubb:debug", {
 				date: /* @__PURE__ */ new Date(),
@@ -849,11 +917,13 @@ async function setup(userConfig, options = {}) {
 		hooks,
 		driver,
 		storage,
-		dispose: () => {
-			driver.dispose();
-			for (const [event, handler] of middlewareListeners) hooks.off(event, handler);
-		}
+		dispose,
+		[Symbol.dispose]: dispose
 	};
+	function dispose() {
+		driver.dispose();
+		for (const [event, handler] of middlewareListeners) hooks.off(event, handler);
+	}
 }
 /**
 * Single-pass fan-out for streaming mode.
@@ -866,84 +936,101 @@ async function setup(userConfig, options = {}) {
 * Each plugin still gets independent `plugin:start` / `plugin:end` events and its own
 * timing, but the schema and operation nodes are parsed only once total.
 */
-async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, config, pluginTimings, failedPlugins, flushPendingFiles) {
+async function runPluginStreamHooks({ entries, driver, pluginTimings, failedPlugins }) {
+	const inputStreamNode = driver.inputStreamNode;
 	function resolveRendererFor(gen, state) {
 		return gen.renderer === null ? void 0 : gen.renderer ?? state.plugin.renderer ?? state.generatorContext.config.renderer;
 	}
-	const states = entries.map(({ plugin, context, hrStart }) => ({
-		plugin,
-		generatorContext: {
-			...context,
-			resolver: driver.getResolver(plugin.name)
-		},
-		generators: plugin.generators ?? [],
-		hrStart,
-		failed: false,
-		error: void 0
-	}));
-	let schemasProcessed = 0;
-	for await (const node of inputStreamNode.schemas) {
-		for (const state of states) {
-			if (state.failed) continue;
-			try {
-				const { plugin, generatorContext, generators } = state;
-				const { exclude, include, override } = plugin.options;
-				const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-				const options = generatorContext.resolver.resolveOptions(transformedNode, {
-					options: plugin.options,
-					exclude,
-					include,
-					override
+	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: driver.getResolver(plugin.name)
+			},
+			generators: plugin.generators ?? [],
+			hrStart,
+			failed: false,
+			error: void 0,
+			optionsAreStatic: !hasExclude && !hasInclude && !hasOverride
+		};
+	});
+	async function dispatchSchema(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.schema) continue;
+				const raw = gen.schema(transformedNode, ctx);
+				const applied = applyHookResult({
+					result: isPromise(raw) ? await raw : raw,
+					driver,
+					rendererFactory: resolveRendererFor(gen, state)
 				});
-				if (options === null) continue;
-				const ctx = {
-					...generatorContext,
-					options
-				};
-				for (const gen of generators) {
-					if (!gen.schema) continue;
-					await applyHookResult(await gen.schema(transformedNode, ctx), driver, resolveRendererFor(gen, state));
-				}
-				await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
-			} catch (caughtError) {
-				state.failed = true;
-				state.error = caughtError;
+				if (isPromise(applied)) await applied;
 			}
+			await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
+		} catch (caughtError) {
+			state.failed = true;
+			state.error = caughtError;
 		}
-		schemasProcessed++;
-		if (schemasProcessed % 50 === 0) await flushPendingFiles();
 	}
-	const collectedOperations = [];
-	for await (const node of inputStreamNode.operations) {
-		collectedOperations.push(node);
-		for (const state of states) {
-			if (state.failed) continue;
-			try {
-				const { plugin, generatorContext, generators } = state;
-				const { exclude, include, override } = plugin.options;
-				const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-				const options = generatorContext.resolver.resolveOptions(transformedNode, {
-					options: plugin.options,
-					exclude,
-					include,
-					override
+	async function dispatchOperation(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 (options === null) continue;
-				const ctx = {
-					...generatorContext,
-					options
-				};
-				for (const gen of generators) {
-					if (!gen.operation) continue;
-					await applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRendererFor(gen, state));
-				}
-				await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
-			} catch (caughtError) {
-				state.failed = true;
-				state.error = caughtError;
+				if (isPromise(applied)) await applied;
 			}
+			await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+		} catch (caughtError) {
+			state.failed = true;
+			state.error = caughtError;
 		}
 	}
+	for await (const node of inputStreamNode.schemas) await Promise.all(states.map((state) => dispatchSchema(state, node)));
+	const collectedOperations = [];
+	for await (const node of inputStreamNode.operations) {
+		collectedOperations.push(node);
+		await Promise.all(states.map((state) => dispatchOperation(state, node)));
+	}
 	for (const state of states) {
 		if (!state.failed) try {
 			const { plugin, generatorContext, generators } = state;
@@ -953,7 +1040,11 @@ async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, con
 			};
 			for (const gen of generators) {
 				if (!gen.operations) continue;
-				await applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRendererFor(gen, state));
+				await applyHookResult({
+					result: await gen.operations(collectedOperations, ctx),
+					driver,
+					rendererFactory: resolveRendererFor(gen, state)
+				});
 			}
 			await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
 		} catch (caughtError) {
@@ -962,12 +1053,12 @@ async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, con
 		}
 		const duration = getElapsedMs(state.hrStart);
 		pluginTimings.set(state.plugin.name, duration);
-		await hooks.emit("kubb:plugin:end", {
+		await driver.hooks.emit("kubb:plugin:end", {
 			plugin: state.plugin,
 			duration,
 			success: !state.failed,
 			...state.failed && state.error ? { error: state.error } : {},
-			config,
+			config: driver.config,
 			get files() {
 				return driver.fileManager.files;
 			},
@@ -977,13 +1068,22 @@ async function runPluginStreamHooks(inputStreamNode, entries, driver, hooks, con
 			plugin: state.plugin,
 			error: state.error
 		});
-		await hooks.emit("kubb:debug", {
+		await driver.hooks.emit("kubb:debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: [state.failed ? "✗ Plugin start failed" : `✓ Plugin started successfully (${formatMs(duration)})`]
 		});
 	}
-	await flushPendingFiles();
 }
+/**
+* Walks the AST and dispatches nodes to a plugin's direct AST hooks
+* (`schema`, `operation`, `operations`).
+*
+* When `include` contains only operation-scoped filters (`tag`, `operationId`, `path`,
+* `method`, `contentType`) and no `schemaName` filter, the function pre-computes the set
+* of top-level schema names transitively reachable from the included operations and skips
+* schemas that fall outside that set. This ensures that component schemas referenced
+* exclusively by excluded operations are not generated.
+*/
 async function runPluginAstHooks(plugin, context) {
 	const { adapter, inputNode, resolver, driver } = context;
 	const { exclude, include, override } = plugin.options;
@@ -1006,13 +1106,15 @@ async function runPluginAstHooks(plugin, context) {
 	]);
 	const hasOperationBasedIncludes = include?.some(({ type }) => operationFilterTypes.has(type)) ?? false;
 	const hasSchemaNameIncludes = include?.some(({ type }) => type === "schemaName") ?? false;
-	let allowedSchemaNames;
-	if (hasOperationBasedIncludes && !hasSchemaNameIncludes) allowedSchemaNames = collectUsedSchemaNames(inputNode.operations.filter((op) => resolver.resolveOptions(op, {
-		options: plugin.options,
-		exclude,
-		include,
-		override
-	}) !== null), inputNode.schemas);
+	const allowedSchemaNames = (() => {
+		if (!hasOperationBasedIncludes || hasSchemaNameIncludes) return void 0;
+		return collectUsedSchemaNames(inputNode.operations.filter((op) => resolver.resolveOptions(op, {
+			options: plugin.options,
+			exclude,
+			include,
+			override
+		}) !== null), inputNode.schemas);
+	})();
 	await walk(inputNode, {
 		depth: "shallow",
 		async schema(node) {
@@ -1029,7 +1131,13 @@ async function runPluginAstHooks(plugin, context) {
 				...generatorContext,
 				options
 			};
-			await Promise.all(generators.filter((gen) => gen.schema).map((gen) => Promise.resolve(gen.schema(transformedNode, ctx)).then((result) => applyHookResult(result, driver, resolveRenderer(gen)))));
+			await Promise.all(generators.filter((gen) => gen.schema).map(async (gen) => {
+				return applyHookResult({
+					result: await gen.schema(transformedNode, ctx),
+					driver,
+					rendererFactory: resolveRenderer(gen)
+				});
+			}));
 			await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
 		},
 		async operation(node) {
@@ -1040,15 +1148,20 @@ async function runPluginAstHooks(plugin, context) {
 				include,
 				override
 			});
-			if (options !== null) {
-				collectedOperations.push(transformedNode);
-				const ctx = {
-					...generatorContext,
-					options
-				};
-				await Promise.all(generators.filter((gen) => gen.operation).map((gen) => Promise.resolve(gen.operation(transformedNode, ctx)).then((result) => applyHookResult(result, driver, resolveRenderer(gen)))));
-				await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
-			}
+			if (options === null) return;
+			collectedOperations.push(transformedNode);
+			const ctx = {
+				...generatorContext,
+				options
+			};
+			await Promise.all(generators.filter((gen) => gen.operation).map(async (gen) => {
+				return applyHookResult({
+					result: await gen.operation(transformedNode, ctx),
+					driver,
+					rendererFactory: resolveRenderer(gen)
+				});
+			}));
+			await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
 		}
 	});
 	if (collectedOperations.length > 0) {
@@ -1058,84 +1171,129 @@ async function runPluginAstHooks(plugin, context) {
 		};
 		for (const gen of generators) {
 			if (!gen.operations) continue;
-			await applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRenderer(gen));
+			await applyHookResult({
+				result: await gen.operations(collectedOperations, ctx),
+				driver,
+				rendererFactory: resolveRenderer(gen)
+			});
 		}
 		await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
 	}
 }
 async function safeBuild(setupResult) {
-	const { driver, hooks, storage } = setupResult;
-	const failedPlugins = /* @__PURE__ */ new Set();
-	const pluginTimings = /* @__PURE__ */ new Map();
-	const config = driver.config;
-	const writtenPaths = /* @__PURE__ */ new Set();
-	const parsersMap = /* @__PURE__ */ new Map();
-	for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
-	const fileProcessor = new FileProcessor();
-	async function flushPendingFiles(snapshot) {
-		const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path) && (!snapshot || !snapshot.has(f.path)));
-		if (files.length === 0) return;
-		await hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [`Writing ${files.length} files...`]
-		});
-		await hooks.emit("kubb:files:processing:start", { files });
-		const stream = fileProcessor.stream(files, {
-			parsers: parsersMap,
-			extension: config.output.extension
-		});
-		for await (const { file, source, processed, total, percentage } of stream) {
-			await hooks.emit("kubb:file:processing:update", {
-				file,
-				source,
-				processed,
-				total,
-				percentage,
-				config
+	try {
+		var _usingCtx$1 = _usingCtx();
+		_usingCtx$1.u(setupResult);
+		const { driver, hooks, storage } = setupResult;
+		const failedPlugins = /* @__PURE__ */ new Set();
+		const pluginTimings = /* @__PURE__ */ new Map();
+		const config = driver.config;
+		const writtenPaths = /* @__PURE__ */ new Set();
+		const parsersMap = /* @__PURE__ */ new Map();
+		for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
+		const fileProcessor = new FileProcessor();
+		async function flushPendingFiles() {
+			const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path));
+			if (files.length === 0) return;
+			await hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [`Writing ${files.length} files...`]
+			});
+			await hooks.emit("kubb:files:processing:start", { files });
+			const stream = fileProcessor.stream(files, {
+				parsers: parsersMap,
+				extension: config.output.extension
+			});
+			for (const { file, source, processed, total, percentage } of stream) {
+				await hooks.emit("kubb:file:processing:update", {
+					file,
+					source,
+					processed,
+					total,
+					percentage,
+					config
+				});
+				if (source) await storage.setItem(file.path, source);
+				writtenPaths.add(file.path);
+			}
+			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`]
 			});
-			if (source) await storage.setItem(file.path, source);
-			writtenPaths.add(file.path);
 		}
-		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`]
-		});
-	}
-	try {
-		await driver.emitSetupHooks();
-		if (driver.adapter && (driver.inputNode || driver.inputStreamNode)) await hooks.emit("kubb:build:start", {
-			config,
-			adapter: driver.adapter,
-			inputNode: driver.inputNode ?? {
-				kind: "Input",
-				schemas: [],
-				operations: [],
-				meta: driver.inputStreamNode?.meta
-			},
-			getPlugin: driver.getPlugin.bind(driver),
-			get files() {
-				return driver.fileManager.files;
-			},
-			upsertFile: (...files) => driver.fileManager.upsert(...files)
-		});
-		const inputStreamNode = driver.inputStreamNode;
-		if (inputStreamNode) {
-			const streamPluginEntries = [];
-			for (const plugin of driver.plugins.values()) {
+		try {
+			await driver.emitSetupHooks();
+			if (driver.adapter && (driver.inputNode || driver.inputStreamNode)) await hooks.emit("kubb:build:start", {
+				config,
+				adapter: driver.adapter,
+				inputNode: driver.inputNode ?? {
+					kind: "Input",
+					schemas: [],
+					operations: [],
+					meta: driver.inputStreamNode?.meta
+				},
+				getPlugin: driver.getPlugin.bind(driver),
+				get files() {
+					return driver.fileManager.files;
+				},
+				upsertFile: (...files) => driver.fileManager.upsert(...files)
+			});
+			if (driver.inputStreamNode) {
+				const streamPluginEntries = [];
+				for (const plugin of driver.plugins.values()) {
+					const context = driver.getContext(plugin);
+					const hrStart = process.hrtime();
+					await hooks.emit("kubb:plugin:start", { plugin });
+					await hooks.emit("kubb:debug", {
+						date: /* @__PURE__ */ new Date(),
+						logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
+					});
+					if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) {
+						streamPluginEntries.push({
+							plugin,
+							context,
+							hrStart
+						});
+						continue;
+					}
+					const duration = getElapsedMs(hrStart);
+					pluginTimings.set(plugin.name, duration);
+					await hooks.emit("kubb:plugin:end", {
+						plugin,
+						duration,
+						success: true,
+						config,
+						get files() {
+							return driver.fileManager.files;
+						},
+						upsertFile: (...files) => driver.fileManager.upsert(...files)
+					});
+					await hooks.emit("kubb:debug", {
+						date: /* @__PURE__ */ new Date(),
+						logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
+					});
+				}
+				if (streamPluginEntries.length > 0) {
+					await runPluginStreamHooks({
+						entries: streamPluginEntries,
+						driver,
+						pluginTimings,
+						failedPlugins
+					});
+					await flushPendingFiles();
+				}
+			} else for (const plugin of driver.plugins.values()) {
 				const context = driver.getContext(plugin);
 				const hrStart = process.hrtime();
-				await hooks.emit("kubb:plugin:start", { plugin });
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
-				});
-				if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) streamPluginEntries.push({
-					plugin,
-					context,
-					hrStart
-				});
-				else {
+				try {
+					const timestamp = /* @__PURE__ */ new Date();
+					await hooks.emit("kubb:plugin:start", { plugin });
+					await hooks.emit("kubb:debug", {
+						date: timestamp,
+						logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
+					});
+					if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
 					const duration = getElapsedMs(hrStart);
 					pluginTimings.set(plugin.name, duration);
 					await hooks.emit("kubb:plugin:end", {
@@ -1152,100 +1310,73 @@ async function safeBuild(setupResult) {
 						date: /* @__PURE__ */ new Date(),
 						logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
 					});
+				} catch (caughtError) {
+					const error = caughtError;
+					const errorTimestamp = /* @__PURE__ */ new Date();
+					const duration = getElapsedMs(hrStart);
+					await hooks.emit("kubb:plugin:end", {
+						plugin,
+						duration,
+						success: false,
+						error,
+						config,
+						get files() {
+							return driver.fileManager.files;
+						},
+						upsertFile: (...files) => driver.fileManager.upsert(...files)
+					});
+					await hooks.emit("kubb:debug", {
+						date: errorTimestamp,
+						logs: [
+							"✗ Plugin start failed",
+							`  • Plugin Name: ${plugin.name}`,
+							`  • Error: ${error.constructor.name} - ${error.message}`,
+							"  • Stack Trace:",
+							error.stack || "No stack trace available"
+						]
+					});
+					failedPlugins.add({
+						plugin,
+						error
+					});
 				}
+				await flushPendingFiles();
 			}
-			if (streamPluginEntries.length > 0) await runPluginStreamHooks(inputStreamNode, streamPluginEntries, driver, hooks, config, pluginTimings, failedPlugins, flushPendingFiles);
-		} else for (const plugin of driver.plugins.values()) {
-			const context = driver.getContext(plugin);
-			const hrStart = process.hrtime();
-			try {
-				const timestamp = /* @__PURE__ */ new Date();
-				await hooks.emit("kubb:plugin:start", { plugin });
-				await hooks.emit("kubb:debug", {
-					date: timestamp,
-					logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
-				});
-				if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
-				const duration = getElapsedMs(hrStart);
-				pluginTimings.set(plugin.name, duration);
-				await hooks.emit("kubb:plugin:end", {
-					plugin,
-					duration,
-					success: true,
-					config,
-					get files() {
-						return driver.fileManager.files;
-					},
-					upsertFile: (...files) => driver.fileManager.upsert(...files)
-				});
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
-				});
-			} catch (caughtError) {
-				const error = caughtError;
-				const errorTimestamp = /* @__PURE__ */ new Date();
-				const duration = getElapsedMs(hrStart);
-				await hooks.emit("kubb:plugin:end", {
-					plugin,
-					duration,
-					success: false,
-					error,
-					config,
-					get files() {
-						return driver.fileManager.files;
-					},
-					upsertFile: (...files) => driver.fileManager.upsert(...files)
-				});
-				await hooks.emit("kubb:debug", {
-					date: errorTimestamp,
-					logs: [
-						"✗ Plugin start failed",
-						`  • Plugin Name: ${plugin.name}`,
-						`  • Error: ${error.constructor.name} - ${error.message}`,
-						"  • Stack Trace:",
-						error.stack || "No stack trace available"
-					]
-				});
-				failedPlugins.add({
-					plugin,
-					error
-				});
-			}
+			await hooks.emit("kubb:plugins:end", {
+				config,
+				get files() {
+					return driver.fileManager.files;
+				},
+				upsertFile: (...files) => driver.fileManager.upsert(...files)
+			});
 			await flushPendingFiles();
+			const files = driver.fileManager.files;
+			await hooks.emit("kubb:build:end", {
+				files,
+				config,
+				outputDir: resolve(config.root, config.output.path)
+			});
+			return {
+				failedPlugins,
+				files,
+				driver,
+				pluginTimings,
+				storage
+			};
+		} catch (error) {
+			return {
+				failedPlugins,
+				files: [],
+				driver,
+				pluginTimings,
+				error,
+				storage
+			};
 		}
-		await hooks.emit("kubb:plugins:end", {
-			config,
-			get files() {
-				return driver.fileManager.files;
-			},
-			upsertFile: (...files) => driver.fileManager.upsert(...files)
-		});
-		await flushPendingFiles();
-		const files = driver.fileManager.files;
-		await hooks.emit("kubb:build:end", {
-			files,
-			config,
-			outputDir: resolve(config.root, config.output.path)
-		});
-		return {
-			failedPlugins,
-			files,
-			driver,
-			pluginTimings,
-			storage
-		};
-	} catch (error) {
-		return {
-			failedPlugins,
-			files: [],
-			driver,
-			pluginTimings,
-			error,
-			storage
-		};
+	} catch (_) {
+		_usingCtx$1.e = _;
 	} finally {
-		setupResult.dispose();
+		_usingCtx$1.d();
 	}
 }
 async function build(setupResult) {
@@ -1353,15 +1484,10 @@ function createKubb(userConfig, options = {}) {
 //#endregion
 //#region src/createRenderer.ts
 /**
-* Creates a renderer factory for use in generator definitions.
-*
-* Wrap your renderer factory function with this helper to register it as the
-* renderer for a generator. Core will call this factory once per render cycle
-* to obtain a fresh renderer instance.
+* Wraps a renderer factory for use in generator definitions.
 *
 * @example
 * ```ts
-* // packages/renderer-jsx/src/index.ts
 * export const jsxRenderer = createRenderer(() => {
 *   const runtime = new Runtime()
 *   return {
@@ -1370,14 +1496,6 @@ function createKubb(userConfig, options = {}) {
 *     unmount(error) { runtime.unmount(error) },
 *   }
 * })
-*
-* // packages/plugin-zod/src/generators/zodGenerator.tsx
-* import { jsxRenderer } from '@kubb/renderer-jsx'
-* export const zodGenerator = defineGenerator<PluginZod>({
-*   name: 'zod',
-*   renderer: jsxRenderer,
-*   schema(node, options) { return <File ...>...</File> },
-* })
 * ```
 */
 function createRenderer(factory) {