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

package/dist/index.js

@@ -1,10 +1,10 @@
 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-uNex0SAr.js";
+import { a as definePlugin, c as DEFAULT_STUDIO_URL, d as forBatches, f as isPromise, i as defineResolver, l as logLevel, n as applyHookResult, o as DEFAULT_BANNER, p as withDrain, r as FileManager, s as DEFAULT_EXTENSION, t as KubbDriver, u as URLPath } from "./KubbDriver-Cxii_rBp.js";
 import { EventEmitter } from "node:events";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import * as ast from "@kubb/ast";
-import { collectUsedSchemaNames, extractStringsFromNodes, transform, walk } from "@kubb/ast";
+import { collectUsedSchemaNames, extractStringsFromNodes, transform } from "@kubb/ast";
 import { version } from "node:process";
 //#region ../../internals/utils/src/errors.ts
 /**
@@ -248,268 +248,6 @@ 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.
-* @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/createAdapter.ts
 /**
 * Factory for implementing custom adapters that translate non-OpenAPI specs into Kubb's AST.
@@ -541,7 +279,7 @@ function createAdapter(build) {
 }
 //#endregion
 //#region package.json
-var version$1 = "5.0.0-beta.19";
+var version$1 = "5.0.0-beta.20";
 //#endregion
 //#region src/createStorage.ts
 /**
@@ -815,7 +553,6 @@ async function setup(userConfig, options = {}) {
 		...userConfig,
 		root: userConfig.root || process.cwd(),
 		parsers: userConfig.parsers ?? [],
-		adapter: userConfig.adapter,
 		output: {
 			format: false,
 			lint: false,
@@ -830,7 +567,7 @@ async function setup(userConfig, options = {}) {
 		} : void 0,
 		plugins: userConfig.plugins ?? []
 	};
-	const driver = new PluginDriver(config, { hooks });
+	const driver = new KubbDriver(config, { hooks });
 	const storage = createSourcesView(config.storage);
 	const diagnosticInfo = getDiagnosticInfo();
 	await hooks.emit("kubb:debug", {
@@ -845,6 +582,7 @@ async function setup(userConfig, options = {}) {
 			`  • Storage: ${config.storage.name}`,
 			`  • Formatter: ${userConfig.output?.format || "none"}`,
 			`  • Linter: ${userConfig.output?.lint || "none"}`,
+			`Running adapter: ${config.adapter?.name || "none"}`,
 			"Environment:",
 			Object.entries(diagnosticInfo).map(([key, value]) => `  • ${key}: ${value}`).join("\n")
 		]
@@ -870,48 +608,7 @@ async function setup(userConfig, options = {}) {
 		});
 		await config.storage.clear(resolve(config.root, config.output.path));
 	}
-	const middlewareListeners = [];
-	function registerMiddlewareHook(event, middlewareHooks) {
-		const handler = middlewareHooks[event];
-		if (handler) {
-			hooks.on(event, handler);
-			middlewareListeners.push([event, handler]);
-		}
-	}
-	for (const middleware of config.middleware ?? []) for (const event of Object.keys(middleware.hooks)) registerMiddlewareHook(event, middleware.hooks);
-	if (config.adapter) {
-		const source = inputToAdapterSource(config);
-		await hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [`Running adapter: ${config.adapter.name}`]
-		});
-		driver.adapter = config.adapter;
-		if (config.adapter.count && config.adapter.stream) {
-			const { schemas: schemaCount, operations: operationCount } = await config.adapter.count(source);
-			if (schemaCount > 100) {
-				driver.inputStreamNode = await config.adapter.stream(source);
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [
-						`✓ Adapter '${config.adapter.name}' streaming InputStreamNode`,
-						`  • Schemas: ${schemaCount} (threshold: 100)`,
-						`  • Operations: ${operationCount}`
-					]
-				});
-			}
-		}
-		if (!driver.inputStreamNode) {
-			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}`
-				]
-			});
-		}
-	}
+	await driver.setup();
 	return {
 		config,
 		hooks,
@@ -922,262 +619,6 @@ async function setup(userConfig, options = {}) {
 	};
 	function dispose() {
 		driver.dispose();
-		for (const [event, handler] of middlewareListeners) hooks.off(event, handler);
-	}
-}
-/**
-* Single-pass fan-out for streaming mode.
-*
-* Iterates `inputStreamNode.schemas` and `.operations` exactly once, distributing each
-* node to every plugin in parallel. This replaces the N-pass-per-plugin pattern (where
-* each plugin got its own `for await` iterator) with a single parse pass fanned to all
-* plugins — eliminating the N×parse-time overhead for multi-plugin builds.
-*
-* 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({ 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 }) => {
-		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 (isPromise(applied)) await applied;
-			}
-			await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
-		} catch (caughtError) {
-			state.failed = true;
-			state.error = caughtError;
-		}
-	}
-	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 (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;
-			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 driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
-		} catch (caughtError) {
-			state.failed = true;
-			state.error = caughtError;
-		}
-		const duration = getElapsedMs(state.hrStart);
-		pluginTimings.set(state.plugin.name, duration);
-		await driver.hooks.emit("kubb:plugin:end", {
-			plugin: state.plugin,
-			duration,
-			success: !state.failed,
-			...state.failed && state.error ? { error: state.error } : {},
-			config: driver.config,
-			get files() {
-				return driver.fileManager.files;
-			},
-			upsertFile: (...files) => driver.fileManager.upsert(...files)
-		});
-		if (state.failed && state.error) failedPlugins.add({
-			plugin: state.plugin,
-			error: state.error
-		});
-		await driver.hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [state.failed ? "✗ Plugin start failed" : `✓ Plugin started successfully (${formatMs(duration)})`]
-		});
-	}
-}
-/**
-* 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;
-	if (!adapter || !inputNode) throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. adapterOas()) before this plugin in your Kubb config.`);
-	function resolveRenderer(gen) {
-		return gen.renderer === null ? void 0 : gen.renderer ?? plugin.renderer ?? context.config.renderer;
-	}
-	const generators = plugin.generators ?? [];
-	const collectedOperations = [];
-	const generatorContext = {
-		...context,
-		resolver: driver.getResolver(plugin.name)
-	};
-	const operationFilterTypes = new Set([
-		"tag",
-		"operationId",
-		"path",
-		"method",
-		"contentType"
-	]);
-	const hasOperationBasedIncludes = include?.some(({ type }) => operationFilterTypes.has(type)) ?? false;
-	const hasSchemaNameIncludes = include?.some(({ type }) => type === "schemaName") ?? false;
-	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) {
-			const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-			if (allowedSchemaNames !== void 0 && transformedNode.name && !allowedSchemaNames.has(transformedNode.name)) return;
-			const options = resolver.resolveOptions(transformedNode, {
-				options: plugin.options,
-				exclude,
-				include,
-				override
-			});
-			if (options === null) return;
-			const ctx = {
-				...generatorContext,
-				options
-			};
-			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) {
-			const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-			const options = resolver.resolveOptions(transformedNode, {
-				options: plugin.options,
-				exclude,
-				include,
-				override
-			});
-			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) {
-		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: resolveRenderer(gen)
-			});
-		}
-		await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
 	}
 }
 async function safeBuild(setupResult) {
@@ -1190,8 +631,8 @@ async function safeBuild(setupResult) {
 		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();
+		for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
 		async function flushPendingFiles() {
 			const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path));
 			if (files.length === 0) return;
@@ -1204,116 +645,235 @@ async function safeBuild(setupResult) {
 				parsers: parsersMap,
 				extension: config.output.extension
 			});
+			const queue = [];
 			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);
+				queue.push((async () => {
+					await hooks.emit("kubb:file:processing:update", {
+						file,
+						source,
+						processed,
+						total,
+						percentage,
+						config
+					});
+					if (source) await 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`]
 			});
 		}
+		async function dispatchOperationsToGenerators(generators, collectedOperations, ctx, rendererFor) {
+			for (const gen of generators) {
+				if (!gen.operations) continue;
+				await applyHookResult({
+					result: await gen.operations(collectedOperations, ctx),
+					driver,
+					rendererFactory: rendererFor(gen)
+				});
+			}
+			await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
+		}
+		/**
+		* Single-pass fan-out: iterates all schemas and operations once, distributing each node
+		* to every generator-plugin in parallel. This replaces the N-pass-per-plugin pattern
+		* (each plugin getting its own iterator) with one parse pass fanned to all plugins,
+		* eliminating the N×parse-time overhead for multi-plugin builds.
+		*/
+		async function runPlugins(entries) {
+			const { schemas, operations } = driver.inputNode;
+			const operationFilterTypes = new Set([
+				"tag",
+				"operationId",
+				"path",
+				"method",
+				"contentType"
+			]);
+			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,
+					allowedSchemaNames: void 0
+				};
+			});
+			const pruningStates = states.filter(({ plugin }) => {
+				const { include } = plugin.options;
+				return (include?.some(({ type }) => operationFilterTypes.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);
+			}
+			function resolveRendererFor(gen, state) {
+				return gen.renderer === null ? void 0 : gen.renderer ?? state.plugin.renderer ?? state.generatorContext.config.renderer;
+			}
+			async function dispatchSchema(state, node) {
+				if (state.failed) return;
+				try {
+					const { plugin, generatorContext, generators } = state;
+					const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
+					if (state.allowedSchemaNames !== void 0 && 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;
+					}
+					await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
+				} catch (caughtError) {
+					state.failed = true;
+					state.error = caughtError;
+				}
+			}
+			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 (isPromise(applied)) await applied;
+					}
+					await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+				} catch (caughtError) {
+					state.failed = true;
+					state.error = caughtError;
+				}
+			}
+			await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((n) => states.map((state) => dispatchSchema(state, n)))), {
+				concurrency: 8,
+				flush: flushPendingFiles
+			});
+			const collectedOperations = [];
+			await forBatches(operations, (nodes) => {
+				collectedOperations.push(...nodes);
+				return Promise.all(nodes.flatMap((n) => states.map((state) => dispatchOperation(state, n))));
+			}, {
+				concurrency: 8,
+				flush: flushPendingFiles
+			});
+			for (const state of states) {
+				if (!state.failed) try {
+					const { plugin, generatorContext, generators } = state;
+					await dispatchOperationsToGenerators(generators, collectedOperations, {
+						...generatorContext,
+						options: plugin.options
+					}, (gen) => resolveRendererFor(gen, state));
+				} catch (caughtError) {
+					state.failed = true;
+					state.error = caughtError;
+				}
+				const duration = getElapsedMs(state.hrStart);
+				pluginTimings.set(state.plugin.name, duration);
+				await driver.hooks.emit("kubb:plugin:end", {
+					plugin: state.plugin,
+					duration,
+					success: !state.failed,
+					...state.failed && state.error ? { error: state.error } : {},
+					config: driver.config,
+					get files() {
+						return driver.fileManager.files;
+					},
+					upsertFile: (...files) => driver.fileManager.upsert(...files)
+				});
+				if (state.failed && state.error) failedPlugins.add({
+					plugin: state.plugin,
+					error: state.error
+				});
+				await driver.hooks.emit("kubb:debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [state.failed ? "✗ Plugin start failed" : `✓ Plugin started successfully (${formatMs(duration)})`]
+				});
+			}
+		}
 		try {
 			await driver.emitSetupHooks();
-			if (driver.adapter && (driver.inputNode || driver.inputStreamNode)) await hooks.emit("kubb:build:start", {
+			if (driver.adapter && driver.inputNode) await hooks.emit("kubb:build:start", {
 				config,
 				adapter: driver.adapter,
-				inputNode: driver.inputNode ?? {
-					kind: "Input",
-					schemas: [],
-					operations: [],
-					meta: driver.inputStreamNode?.meta
-				},
+				meta: driver.inputNode.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 generatorPlugins = [];
+			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)})`]
+						logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
 					});
 				} catch (caughtError) {
 					const error = caughtError;
-					const errorTimestamp = /* @__PURE__ */ new Date();
 					const duration = getElapsedMs(hrStart);
+					pluginTimings.set(plugin.name, duration);
 					await hooks.emit("kubb:plugin:end", {
 						plugin,
 						duration,
@@ -1325,22 +885,51 @@ async function safeBuild(setupResult) {
 						},
 						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
 					});
+					continue;
+				}
+				if (plugin.generators?.length || driver.hasEventGenerators(plugin.name)) {
+					generatorPlugins.push({
+						plugin,
+						context,
+						hrStart
+					});
+					continue;
 				}
-				await flushPendingFiles();
+				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 (generatorPlugins.length > 0) if (driver.inputNode) await withDrain(() => runPlugins(generatorPlugins), flushPendingFiles);
+			else for (const { plugin, hrStart } of generatorPlugins) {
+				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:plugins:end", {
 				config,
@@ -1413,22 +1002,6 @@ function getDiagnosticInfo() {
 function isInputPath(config) {
 	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
 }
-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)
-	};
-}
 /**
 * Creates a Kubb instance bound to a single config entry.
 *
@@ -1661,6 +1234,6 @@ const memoryStorage = createStorage(() => {
 	};
 });
 //#endregion
-export { AsyncEventEmitter, FileManager, FileProcessor, PluginDriver, URLPath, ast, createAdapter, createKubb, createRenderer, createStorage, defineGenerator, defineLogger, defineMiddleware, defineParser, definePlugin, defineResolver, fsStorage, isInputPath, logLevel, memoryStorage };
+export { AsyncEventEmitter, FileManager, FileProcessor, KubbDriver, URLPath, ast, createAdapter, createKubb, createRenderer, createStorage, defineGenerator, defineLogger, defineMiddleware, defineParser, definePlugin, defineResolver, fsStorage, isInputPath, logLevel, memoryStorage };
 
 //# sourceMappingURL=index.js.map