@kubb/core 5.0.0-beta.84 → 5.0.0-beta.86

package/dist/index.js

@@ -1,12 +1,47 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { _ as getErrorMessage, a as createStorage, c as clean, d as write, f as runtime, g as BuildError, h as AsyncEventEmitter, i as FileManager, l as toFilePath, m as pascalCase, n as _usingCtx, o as OPERATION_FILTER_TYPES, p as camelCase, r as FileProcessor, s as diagnosticCode, t as memoryStorage, u as toPosixPath } from "./memoryStorage-BjUIqpYE.js";
-import { hash } from "node:crypto";
+import { a as toFilePath, c as BuildError, d as camelCase, i as clean, l as getErrorMessage, n as FileManager, o as toPosixPath, r as Hookable, s as write, t as _usingCtx, u as toError } from "./usingCtx-Cnrm3TcM.js";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { stripVTControlCharacters, styleText } from "node:util";
+import { hash } from "node:crypto";
 import { access, glob, readFile, rm } from "node:fs/promises";
 import path, { join, relative, resolve } from "node:path";
-import { AsyncLocalStorage } from "node:async_hooks";
 import { ast, collectUsedSchemaNames, composeMacros, operationDef, schemaDef, transform } from "@kubb/ast";
 import process$1 from "node:process";
+//#region src/createAdapter.ts
+/**
+* Defines a custom adapter that translates a spec format into Kubb's universal
+* AST, for example GraphQL, gRPC, or AsyncAPI. The built-in `@kubb/adapter-oas`
+* handles OpenAPI/Swagger documents.
+*
+* Adapters must return an `InputNode` from `parse`. That node is what every
+* plugin in the build consumes.
+*
+* @example
+* ```ts
+* import { createAdapter, type AdapterFactoryOptions } from '@kubb/core'
+* import { ast } from '@kubb/ast'
+*
+* type MyAdapter = AdapterFactoryOptions<'my-adapter', { validate?: boolean }>
+*
+* export const myAdapter = createAdapter<MyAdapter>((options) => ({
+*   name: 'my-adapter',
+*   options,
+*   document: null,
+*   async parse(_source) {
+*     // Convert the source (path or inline data) into an InputNode.
+*     return ast.factory.createInput()
+*   },
+*   getImports: () => [],
+*   async validate() {
+*     // Throw here when the spec is invalid.
+*   },
+* }))
+* ```
+*/
+function createAdapter(build) {
+	return (options) => build(options ?? {});
+}
+//#endregion
 //#region ../../internals/utils/src/time.ts
 /**
 * Calculates elapsed time in milliseconds from a high-resolution `process.hrtime` start time.
@@ -90,21 +125,11 @@ const randomColors = [
 */
 function randomCliColor(text) {
 	if (!text) return "";
-	return styleText(randomColors[hash("sha256", text, "buffer").readUInt32BE(0) % randomColors.length] ?? "white", text);
+	const index = hash("sha256", text, "buffer").readUInt32BE(0) % randomColors.length;
+	return styleText(randomColors[index] ?? "white", text);
 }
 //#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";
-}
 /**
 * Wraps `factory` with a keyed cache backed by the provided store.
 *
@@ -143,258 +168,116 @@ function memoize(store, factory) {
 		return value;
 	};
 }
-/**
-* Wraps a plain array in a reusable `AsyncIterable`.
-* Each `[Symbol.asyncIterator]()` call returns a fresh generator so the
-* iterable can be consumed multiple times (e.g. once per plugin pre-scan).
-*
-* @example
-* ```ts
-* const stream = arrayToAsyncIterable([1, 2, 3])
-* for await (const n of stream) console.log(n) // 1, 2, 3
-* ```
-*/
-function arrayToAsyncIterable(arr) {
-	return { [Symbol.asyncIterator]() {
-		return (async function* () {
-			yield* arr;
-		})();
-	} };
-}
 //#endregion
-//#region ../../internals/utils/src/reserved.ts
+//#region package.json
+var version = "5.0.0-beta.86";
+//#endregion
+//#region src/constants.ts
 /**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+* Plugin `include` filter types that select operations directly. When one of these is set
+* without a `schemaName` include, the generate phase pre-scans operations to compute the set
+* of schemas they reach, so unreachable schemas can be pruned for that plugin.
 */
-const reservedWords = /* @__PURE__ */ 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"
+const OPERATION_FILTER_TYPES = /* @__PURE__ */ new Set([
+	"tag",
+	"operationId",
+	"path",
+	"method",
+	"contentType"
 ]);
 /**
-* 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)
-* ```
+* Stable codes Kubb attaches to a `Diagnostic`. Each maps to a known failure mode
+* and stays stable so it can be referenced in tooling and (later) docs. Reference
+* these instead of inlining the string at a throw site.
 */
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return isIdentifier(name);
-}
-/**
-* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
-*
-* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
-* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
-* deciding whether an object key needs quoting.
-*
-* @example
-* ```ts
-* isIdentifier('name')   // true
-* isIdentifier('x-total')// false
-* ```
-*/
-function isIdentifier(name) {
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
-}
-//#endregion
-//#region ../../internals/utils/src/url.ts
-function transformParam(raw, casing) {
-	const param = isValidVarName(raw) ? raw : camelCase(raw);
-	return casing === "camelcase" ? camelCase(param) : param;
-}
-function toParamsObject(path, { replacer, casing } = {}) {
-	const params = {};
-	for (const match of path.matchAll(/\{([^}]+)\}/g)) {
-		const param = transformParam(match[1], casing);
-		const key = replacer ? replacer(param) : param;
-		params[key] = key;
-	}
-	return Object.keys(params).length > 0 ? params : null;
-}
-/**
-* Helpers for OpenAPI/Swagger paths, plus a thin wrapper over the native `URL`.
-*/
-var Url = class Url {
+const diagnosticCode = {
 	/**
-	* Converts an OpenAPI/Swagger path to Express-style colon syntax.
-	*
-	* @example
-	* Url.toPath('/pet/{petId}') // '/pet/:petId'
+	* Fallback for an unstructured error with no specific code.
 	*/
-	static toPath(path) {
-		return path.replace(/\{([^}]+)\}/g, ":$1");
-	}
+	unknown: "KUBB_UNKNOWN",
 	/**
-	* Converts an OpenAPI/Swagger path to a TypeScript template literal string.
-	* `prefix` is prepended inside the literal, `replacer` transforms each parameter name,
-	* and `casing` controls parameter identifier casing.
-	*
-	* @example
-	* Url.toTemplateString('/pet/{petId}') // '`/pet/${petId}`'
-	*
-	* @example
-	* Url.toTemplateString('/pet/{petId}', { prefix: 'https://api' }) // '`https://api/pet/${petId}`'
+	* The `input.path` file or URL could not be read.
 	*/
-	static toTemplateString(path, { prefix, replacer, casing } = {}) {
-		const result = path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = transformParam(part, casing);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("");
-		return `\`${prefix ?? ""}${result}\``;
-	}
+	inputNotFound: "KUBB_INPUT_NOT_FOUND",
 	/**
-	* Returns the path and its extracted params as a structured `URLObject`, or as a stringified
-	* expression when `stringify` is set.
-	*
-	* @example
-	* Url.toObject('/pet/{petId}')
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	*/
-	static toObject(path, { type = "path", replacer, stringify, casing } = {}) {
-		const object = {
-			url: type === "path" ? Url.toPath(path) : Url.toTemplateString(path, {
-				replacer,
-				casing
-			}),
-			params: toParamsObject(path, {
-				replacer,
-				casing
-			})
-		};
-		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;
-	}
+	* An adapter was configured without an `input`.
+	*/
+	inputRequired: "KUBB_INPUT_REQUIRED",
+	/**
+	* A `$ref` (or equivalent reference) could not be resolved in the source document.
+	*/
+	refNotFound: "KUBB_REF_NOT_FOUND",
+	/**
+	* A server variable value is not allowed by its `enum`.
+	*/
+	invalidServerVariable: "KUBB_INVALID_SERVER_VARIABLE",
+	/**
+	* A required plugin is missing from the config.
+	*/
+	pluginNotFound: "KUBB_PLUGIN_NOT_FOUND",
+	/**
+	* A plugin threw while generating.
+	*/
+	pluginFailed: "KUBB_PLUGIN_FAILED",
+	/**
+	* A plugin reported a non-fatal warning through `ctx.warn`.
+	*/
+	pluginWarning: "KUBB_PLUGIN_WARNING",
+	/**
+	* A plugin reported an informational message through `ctx.info`.
+	*/
+	pluginInfo: "KUBB_PLUGIN_INFO",
+	/**
+	* A schema uses a `format` Kubb does not map to a specific type. Reserved for
+	* adapters to emit as a `warning`.
+	*/
+	unsupportedFormat: "KUBB_UNSUPPORTED_FORMAT",
+	/**
+	* A referenced schema or operation is marked `deprecated`. Reserved for adapters
+	* to emit as an `info`.
+	*/
+	deprecated: "KUBB_DEPRECATED",
+	/**
+	* An adapter is required but the config has none. The build cannot read the input
+	* without one.
+	*/
+	adapterRequired: "KUBB_ADAPTER_REQUIRED",
+	/**
+	* A resolved output path escapes the output directory, which can stem from a path
+	* traversal in the spec or a misconfigured `group.name`.
+	*/
+	pathTraversal: "KUBB_PATH_TRAVERSAL",
+	/**
+	* A plugin's options are invalid, for example `output.mode: 'file'` paired with a `group` option.
+	*/
+	invalidPluginOptions: "KUBB_INVALID_PLUGIN_OPTIONS",
+	/**
+	* A post-generate shell hook (`hooks.done`) exited with a failure.
+	*/
+	hookFailed: "KUBB_HOOK_FAILED",
+	/**
+	* The formatter pass over the generated files failed.
+	*/
+	formatFailed: "KUBB_FORMAT_FAILED",
+	/**
+	* The linter pass over the generated files failed.
+	*/
+	lintFailed: "KUBB_LINT_FAILED",
+	/**
+	* Not a failure. Carries a plugin's elapsed time, summed into the run total.
+	*/
+	performance: "KUBB_PERFORMANCE",
+	/**
+	* Not a failure. A newer Kubb version is available on npm.
+	*/
+	updateAvailable: "KUBB_UPDATE_AVAILABLE"
 };
 //#endregion
-//#region src/createAdapter.ts
-/**
-* Defines a custom adapter that translates a spec format into Kubb's universal
-* AST, for example GraphQL, gRPC, or AsyncAPI. The built-in `@kubb/adapter-oas`
-* handles OpenAPI/Swagger documents.
-*
-* Adapters must return an `InputNode` from `parse`. That node is what every
-* plugin in the build consumes.
-*
-* @example
-* ```ts
-* import { createAdapter, type AdapterFactoryOptions } from '@kubb/core'
-* import { ast } from '@kubb/ast'
-*
-* type MyAdapter = AdapterFactoryOptions<'my-adapter', { validate?: boolean }>
-*
-* export const myAdapter = createAdapter<MyAdapter>((options) => ({
-*   name: 'my-adapter',
-*   options,
-*   document: null,
-*   async parse(_source) {
-*     // Convert the source (path or inline data) into an InputNode.
-*     return ast.factory.createInput()
-*   },
-*   getImports: () => [],
-*   async validate() {
-*     // Throw here when the spec is invalid.
-*   },
-* }))
-* ```
-*/
-function createAdapter(build) {
-	return (options) => build(options ?? {});
-}
-//#endregion
-//#region src/diagnostics.ts
+//#region src/Diagnostics.ts
 /**
 * Docs major version, derived from the package version so the link tracks the published major.
 */
-const docsMajor = "5.0.0-beta.84".split(".")[0] ?? "5";
+const docsMajor = version.split(".")[0] ?? "5";
 /**
 * Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
 *
@@ -452,9 +335,9 @@ const isUpdate = isKind("update");
 * blue info).
 */
 const severityStyle = {
-	error: { color: "red" },
-	warning: { color: "yellow" },
-	info: { color: "blue" }
+	error: "red",
+	warning: "yellow",
+	info: "blue"
 };
 /**
 * Explanation for every {@link diagnosticCode}. Use {@link Diagnostics.explain} to look one up
@@ -563,8 +446,8 @@ const diagnosticCatalog = {
 *
 * The sink lives in a single `AsyncLocalStorage` in the `@kubb/core` bundle.
 * `Diagnostics.scope` activates it for a run, so anything inside that run (the
-* adapter parse, a lazily consumed stream, a generator) reports through
-* `Diagnostics.report` and lands in the same run.
+* adapter parse, a generator) reports through `Diagnostics.report` and lands
+* in the same run.
 */
 var Diagnostics = class Diagnostics {
 	static #reporterStorage = new AsyncLocalStorage();
@@ -634,12 +517,12 @@ var Diagnostics = class Diagnostics {
 		return true;
 	}
 	/**
-	* Emits a diagnostic on the run's `kubb:diagnostic` event so the loggers render it live.
-	* Use it instead of calling `hooks.emit('kubb:diagnostic', ...)` directly. To collect a
+	* Emits a diagnostic on the run's `kubb:diagnostic` hook so the loggers render it live.
+	* Use it instead of calling `hooks.callHook('kubb:diagnostic', ...)` directly. To collect a
 	* diagnostic into the build result from deep in a run, use {@link Diagnostics.report} instead.
 	*/
 	static async emit(hooks, diagnostic) {
-		await hooks.emit("kubb:diagnostic", { diagnostic });
+		await hooks.callHook("kubb:diagnostic", { diagnostic });
 	}
 	/**
 	* Coerces any thrown value into a {@link ProblemDiagnostic}. A {@link Diagnostics.Error}
@@ -750,7 +633,8 @@ var Diagnostics = class Diagnostics {
 	* `KUBB_REF_NOT_FOUND` → `https://kubb.dev/docs/5.x/reference/diagnostics/kubb-ref-not-found`.
 	*/
 	static docsUrl(code) {
-		return `https://kubb.dev/docs/${docsMajor}.x/reference/diagnostics/${code.toLowerCase().replaceAll("_", "-")}`;
+		const slug = code.toLowerCase().replaceAll("_", "-");
+		return `https://kubb.dev/docs/${docsMajor}.x/reference/diagnostics/${slug}`;
 	}
 	/**
 	* The catalog entry for a code: its title, cause, and fix. Mirrors the kubb.dev
@@ -786,7 +670,7 @@ var Diagnostics = class Diagnostics {
 	*/
 	static format(diagnostic) {
 		const { code, severity, message } = diagnostic;
-		const { color } = severityStyle[severity];
+		const color = severityStyle[severity];
 		const problem = isProblem(diagnostic) ? diagnostic : void 0;
 		const tag = styleText(color, styleText("bold", `[${code}]`));
 		const headline = problem?.plugin ? `${tag} ${problem.plugin}: ${message}` : `${tag}: ${message}`;
@@ -856,412 +740,286 @@ function definePlugin(factory) {
 	return (options) => factory(options ?? {});
 }
 //#endregion
-//#region src/defineResolver.ts
-/**
-* Merges document `meta` with per-file `file` context into the `BannerMeta` passed to a
-* `banner`/`footer` function. Missing fields default to empty/`false` so the object shape
-* is stable even when a caller (e.g. the barrel plugin) has no document metadata.
-*/
-function buildBannerMeta({ meta, file }) {
-	return {
-		title: meta?.title,
-		description: meta?.description,
-		version: meta?.version,
-		baseURL: meta?.baseURL,
-		circularNames: meta?.circularNames ?? [],
-		enumNames: meta?.enumNames ?? [],
-		filePath: file?.path ?? "",
-		baseName: file?.baseName ?? "",
-		isBarrel: file?.isBarrel ?? false,
-		isAggregation: file?.isAggregation ?? false
-	};
-}
-const stringPatternCache = /* @__PURE__ */ new Map();
-function testPattern(value, pattern) {
-	if (typeof pattern === "string") {
-		let regex = stringPatternCache.get(pattern);
-		if (!regex) {
-			regex = new RegExp(pattern);
-			stringPatternCache.set(pattern, regex);
-		}
-		return regex.test(value);
-	}
-	return value.match(pattern) !== null;
+//#region src/Resolver.ts
+function isNamespace(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
-* Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
-*/
-function matchesOperationPattern(node, type, pattern) {
-	if (type === "tag") return node.tags.some((tag) => testPattern(tag, pattern));
-	if (type === "operationId") return testPattern(node.operationId, pattern);
-	if (type === "path") return node.path !== void 0 && testPattern(node.path, pattern);
-	if (type === "method") return node.method !== void 0 && testPattern(node.method.toLowerCase(), pattern);
-	if (type === "contentType") return node.requestBody?.content?.some((c) => testPattern(c.contentType, pattern)) ?? false;
-	return false;
-}
-/**
-* Checks if a schema matches a pattern for a given filter type (`schemaName`).
-*
-* Returns `null` when the filter type doesn't apply to schemas.
-*/
-function matchesSchemaPattern(node, type, pattern) {
-	if (type === "schemaName") return node.name ? testPattern(node.name, pattern) : false;
-	return null;
-}
-/**
-* Default name resolver used by `defineResolver`.
-*
-* - `camelCase` for `file`, with dotted names split into `/`-joined nested paths.
-* - `PascalCase` for `type`.
-* - `camelCase` for `function` and everything else.
-*/
-function defaultResolver(name, type) {
-	if (type === "file") return toFilePath(name);
-	if (type === "type") return pascalCase(name);
-	return camelCase(name);
-}
-/**
-* Default option resolver. Applies include/exclude filters and merges matching override options.
+* Base constraint for all plugin resolver objects.
 *
-* Returns `null` when the node is filtered out by an `exclude` rule or not matched by any `include` rule.
+* The built-in machinery lives under `default`. Generators call the top-level `name` and
+* `file`, and a plugin overrides them to set its conventions. Extend with top-level helpers
+* (`typeName`, …) and/or grouped namespaces (`query`, `schema`, …).
 *
-* @example Include/exclude filtering
+* @example Top-level helper
 * ```ts
-* const options = defaultResolveOptions(operationNode, {
-*   options: { output: 'types' },
-*   exclude: [{ type: 'tag', pattern: 'internal' }],
-* })
-* // → null when node has tag 'internal'
+* type MyResolver = Resolver & {
+*   typeName(name: string): string
+* }
 * ```
 *
-* @example Override merging
+* @example Grouped namespace
 * ```ts
-* const options = defaultResolveOptions(operationNode, {
-*   options: { enumType: 'asConst' },
-*   override: [{ type: 'operationId', pattern: 'listPets', options: { enumType: 'enum' } }],
-* })
-* // → { enumType: 'enum' } when operationId matches
+* type MyResolver = Resolver & {
+*   query: {
+*     name(node: OperationNode): string
+*     keyName(node: OperationNode): string
+*   }
+* }
 * ```
 */
-const resolveOptionsCache = /* @__PURE__ */ new WeakMap();
-function computeOptions(node, options, exclude, include, override) {
-	if (operationDef.is(node)) {
-		if (exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
-		if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
-		const overrideOptions = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))?.options;
+var Resolver = class Resolver {
+	static #patternCache = /* @__PURE__ */ new Map();
+	static #optionsCache = /* @__PURE__ */ new WeakMap();
+	pluginName;
+	#options;
+	constructor(options) {
+		this.pluginName = options.pluginName;
+		this.#options = options;
+		this.#apply(options);
+	}
+	/**
+	* The built-in resolution machinery. Always reaches the untouched defaults, even when a
+	* plugin overrides the top-level `name` or `file`.
+	*/
+	get default() {
 		return {
-			...options,
-			...overrideOptions
+			name: camelCase,
+			options: this.#resolveOptions.bind(this),
+			path: this.#resolvePath.bind(this),
+			file: this.#resolveFile.bind(this),
+			banner: this.#resolveBanner.bind(this),
+			footer: this.#resolveFooter.bind(this)
 		};
 	}
-	if (schemaDef.is(node)) {
-		if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) return null;
-		if (include) {
-			const applicable = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern)).filter((result) => result !== null);
-			if (applicable.length > 0 && !applicable.includes(true)) return null;
+	name(name) {
+		return this.default.name(name);
+	}
+	file(params, context) {
+		return this.default.file(params, context);
+	}
+	/**
+	* Merges `override` over `base` and returns a new resolver with helpers re-bound.
+	* Each key is replaced wholesale. Used when applying `setResolver` partial overrides.
+	*/
+	static merge(base, override) {
+		const patch = override instanceof Resolver ? override.#options : override;
+		return new Resolver({
+			...base.#options,
+			...patch
+		});
+	}
+	/**
+	* Binds each entry of `options` onto the resolver, so `this.name`, `this.default`, and
+	* `this.file` resolve there for top-level helpers and namespace methods alike. `default`
+	* is skipped so it can't be shadowed.
+	*/
+	#apply(options) {
+		const root = this;
+		const bind = (value) => typeof value === "function" ? value.bind(root) : value;
+		for (const [key, value] of Object.entries(options)) {
+			if (key === "pluginName" || key === "default" || value === void 0) continue;
+			root[key] = isNamespace(value) ? Object.fromEntries(Object.entries(value).map(([method, member]) => [method, bind(member)])) : bind(value);
 		}
-		const overrideOptions = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)?.options;
-		return {
-			...options,
-			...overrideOptions
-		};
 	}
-	return options;
-}
-function defaultResolveOptions(node, { options, exclude = [], include, override = [] }) {
-	if (typeof options !== "object" || options === null) return computeOptions(node, options, exclude, include, override);
-	let byOptions = resolveOptionsCache.get(options);
-	if (!byOptions) {
-		byOptions = /* @__PURE__ */ new WeakMap();
-		resolveOptionsCache.set(options, byOptions);
-	}
-	const cached = byOptions.get(node);
-	if (cached !== void 0) return cached.value;
-	const result = computeOptions(node, options, exclude, include, override);
-	byOptions.set(node, { value: result });
-	return result;
-}
-/**
-* Default path resolver used by `defineResolver`.
-*
-* - `mode: 'file'` resolves directly to `output.path` (the full file path, extension included).
-* - `mode: 'directory'` (default) resolves to `output.path/{baseName}`, or into a
-*   subdirectory when `group` and a `tag`/`path` value are provided.
-*
-* A custom `group.name` function overrides the default subdirectory naming.
-* For `tag` groups the default is the camelCased tag.
-* For `path` groups the default is the first path segment after `/`.
-*
-* @example Flat output
-* ```ts
-* defaultResolvePath({ baseName: 'petTypes.ts' }, { root: '/src', output: { path: 'types' } })
-* // → '/src/types/petTypes.ts'
-* ```
-*
-* @example Tag-based grouping
-* ```ts
-* defaultResolvePath(
-*   { baseName: 'petTypes.ts', tag: 'pets' },
-*   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
-* )
-* // → '/src/types/pets/petTypes.ts'
-* ```
-*
-* @example Path-based grouping
-* ```ts
-* defaultResolvePath(
-*   { baseName: 'petTypes.ts', path: '/pets/list' },
-*   { root: '/src', output: { path: 'types' }, group: { type: 'path' } },
-* )
-* // → '/src/types/pets/petTypes.ts'
-* ```
-*
-* @example Single file (`mode: 'file'`)
-* ```ts
-* defaultResolvePath(
-*   { baseName: 'petTypes.ts' },
-*   { root: '/src', output: { path: 'types.ts', mode: 'file' } },
-* )
-* // → '/src/types.ts'
-* ```
-*/
-function defaultResolvePath({ baseName, tag, path: groupPath }, { root, output, group }) {
-	if ((output.mode ?? "directory") === "file") return path.resolve(root, output.path);
-	const result = (() => {
-		if (group && (groupPath || tag)) {
-			const groupValue = group.type === "path" ? groupPath : tag;
-			const defaultName = group.type === "tag" ? ({ group: groupName }) => camelCase(groupName) : ({ group: groupName }) => {
-				const segment = groupName.split("/").filter((part) => part !== "" && part !== "." && part !== "..")[0];
-				return segment ? camelCase(segment) : "";
+	static #testPattern(value, pattern) {
+		if (typeof pattern === "string") {
+			let regex = Resolver.#patternCache.get(pattern);
+			regex ??= new RegExp(pattern);
+			Resolver.#patternCache.set(pattern, regex);
+			return regex.test(value);
+		}
+		return value.match(pattern) !== null;
+	}
+	static #matchesOperation(node, { type, pattern }) {
+		if (type === "tag") return node.tags.some((tag) => Resolver.#testPattern(tag, pattern));
+		if (type === "operationId") return Resolver.#testPattern(node.operationId, pattern);
+		if (type === "path") return node.path !== void 0 && Resolver.#testPattern(node.path, pattern);
+		if (type === "method") return node.method !== void 0 && Resolver.#testPattern(node.method.toLowerCase(), pattern);
+		if (type === "contentType") return node.requestBody?.content?.some((c) => Resolver.#testPattern(c.contentType, pattern)) ?? false;
+		return false;
+	}
+	/**
+	* Returns `null` when the filter type doesn't apply to schemas, so include rules built
+	* from operation filters (e.g. `tag`) don't exclude every schema.
+	*/
+	static #matchesSchema(node, { type, pattern }) {
+		if (type === "schemaName") return node.name ? Resolver.#testPattern(node.name, pattern) : false;
+		return null;
+	}
+	static #computeOptions(node, { options, exclude = [], include, override = [] }) {
+		if (operationDef.is(node)) {
+			if (exclude.some((filter) => Resolver.#matchesOperation(node, filter))) return null;
+			if (include && !include.some((filter) => Resolver.#matchesOperation(node, filter))) return null;
+			return {
+				...options,
+				...override.find((filter) => Resolver.#matchesOperation(node, filter))?.options
 			};
-			const groupName = (group.name ?? defaultName)({ group: groupValue });
-			return path.resolve(root, output.path, groupName, baseName);
 		}
-		return path.resolve(root, output.path, baseName);
-	})();
-	const outputDir = path.resolve(root, output.path);
-	const outputDirWithSep = outputDir.endsWith(path.sep) ? outputDir : `${outputDir}${path.sep}`;
-	if (result !== outputDir && !result.startsWith(outputDirWithSep)) throw new Diagnostics.Error({
-		code: Diagnostics.code.pathTraversal,
-		severity: "error",
-		message: `Resolved path "${result}" is outside the output directory "${outputDir}".`,
-		help: "This can stem from a path traversal in the OpenAPI specification or a misconfigured `group.name` function. Keep generated paths within the output directory.",
-		location: { kind: "config" }
-	});
-	return result;
-}
-/**
-* Default file resolver used by `defineResolver`.
-*
-* Resolves a `FileNode` by combining name resolution (`resolver.default`) with
-* path resolution (`resolver.resolvePath`). The resolved file always has empty
-* `sources`, `imports`, and `exports` arrays, which consumers populate separately.
-*
-* In `mode: 'file'` the name is omitted and the file sits directly at the output path.
-*
-* @example Resolve a schema file
-* ```ts
-* const file = defaultResolveFile.call(
-*   resolver,
-*   { name: 'pet', extname: '.ts' },
-*   { root: '/src', output: { path: 'types' } },
-* )
-* // → { baseName: 'pet.ts', path: '/src/types/pet.ts', sources: [], ... }
-* ```
-*
-* @example Resolve an operation file with tag grouping
-* ```ts
-* const file = defaultResolveFile.call(
-*   resolver,
-*   { name: 'listPets', extname: '.ts', tag: 'pets' },
-*   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
-* )
-* // → { baseName: 'listPets.ts', path: '/src/types/pets/listPets.ts', ... }
-* ```
-*/
-function defaultResolveFile({ name, extname, tag, path: groupPath }, context) {
-	const baseName = `${(context.output.mode ?? "directory") === "file" ? "" : this.default(name, "file")}${extname}`;
-	const filePath = this.resolvePath({
-		baseName,
-		tag,
-		path: groupPath
-	}, context);
-	return ast.factory.createFile({
-		path: filePath,
-		baseName: path.basename(filePath),
-		meta: { pluginName: this.pluginName },
-		sources: [],
-		imports: [],
-		exports: []
-	});
-}
-/**
-* Generates the default "Generated by Kubb" banner from config and optional node metadata.
-*/
-function buildDefaultBanner({ title, description, version, config }) {
-	try {
-		const source = (() => {
-			if (Array.isArray(config.input)) {
-				const first = config.input[0];
-				if (first && "path" in first) return path.basename(first.path);
-				return "";
+		if (schemaDef.is(node)) {
+			if (exclude.some((filter) => Resolver.#matchesSchema(node, filter) === true)) return null;
+			if (include) {
+				const applicable = include.map((filter) => Resolver.#matchesSchema(node, filter)).filter((result) => result !== null);
+				if (applicable.length > 0 && !applicable.includes(true)) return null;
 			}
-			if (config.input && "path" in config.input) return path.basename(config.input.path);
-			if (config.input && "data" in config.input) return "text content";
-			return "";
-		})();
-		let banner = "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n";
-		if (config.output.defaultBanner === "simple") {
-			banner += "*/\n";
-			return banner;
+			return {
+				...options,
+				...override.find((filter) => Resolver.#matchesSchema(node, filter) === true)?.options
+			};
 		}
-		if (source) banner += `* Source: ${source}\n`;
-		if (title) banner += `* Title: ${title}\n`;
-		if (description) {
-			const formattedDescription = description.replace(/\n/gm, "\n* ");
-			banner += `* Description: ${formattedDescription}\n`;
+		return options;
+	}
+	/**
+	* Applies include/exclude filters and merges matching override options, caching the result
+	* per `(options, node)` pair. Returns `null` when the node is filtered out.
+	*/
+	#resolveOptions(node, context) {
+		const { options } = context;
+		if (typeof options !== "object" || options === null) return Resolver.#computeOptions(node, context);
+		let byOptions = Resolver.#optionsCache.get(options);
+		if (!byOptions) {
+			byOptions = /* @__PURE__ */ new WeakMap();
+			Resolver.#optionsCache.set(options, byOptions);
 		}
-		if (version) banner += `* OpenAPI spec version: ${version}\n`;
-		banner += "*/\n";
-		return banner;
-	} catch (_error) {
-		return "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n*/";
+		const cached = byOptions.get(node);
+		if (cached) return cached.value;
+		const result = Resolver.#computeOptions(node, context);
+		byOptions.set(node, { value: result });
+		return result;
 	}
-}
-/**
-* Default banner resolver. Returns the banner string for a generated file.
-*
-* A user-supplied `output.banner` overrides the default Kubb "Generated by Kubb" notice.
-* When no `output.banner` is set, the Kubb notice is used (including `title` and `version`
-* from the document metadata when `meta` is provided).
-*
-* - When `output.banner` is a function, calls it with the file's `BannerMeta` and returns the result.
-* - When `output.banner` is a string, returns it directly.
-* - When `config.output.defaultBanner` is `false`, returns `undefined`.
-* - Otherwise returns the Kubb "Generated by Kubb" notice.
-*
-* @example String banner overrides default
-* ```ts
-* defaultResolveBanner(undefined, { output: { banner: '// my banner' }, config })
-* // → '// my banner'
-* ```
-*
-* @example Function banner with metadata
-* ```ts
-* defaultResolveBanner(meta, { output: { banner: (m) => `// v${m.version}` }, config })
-* // → '// v3.0.0'
-* ```
-*
-* @example Function banner skips re-export files
-* ```ts
-* defaultResolveBanner(meta, { output: { banner: (m) => (m.isBarrel ? '' : "'use server'") }, config, file: { path, baseName, isBarrel: true } })
-* // → ''
-* ```
-*
-* @example No user banner, Kubb notice with OAS metadata
-* ```ts
-* defaultResolveBanner(meta, { config })
-* // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
-* ```
-*
-* @example Disabled default banner
-* ```ts
-* defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
-* // → null
-* ```
-*/
-function defaultResolveBanner(meta, { output, config, file }) {
-	if (typeof output?.banner === "function") return output.banner(buildBannerMeta({
-		meta,
-		file
-	}));
-	if (typeof output?.banner === "string") return output.banner;
-	if (config.output.defaultBanner === false) return null;
-	return buildDefaultBanner({
-		title: meta?.title,
-		version: meta?.version,
-		config
-	});
-}
-/**
-* Default footer resolver. Returns the footer string for a generated file.
-*
-* - When `output.footer` is a function, calls it with the file's `BannerMeta` and returns the result.
-* - When `output.footer` is a string, returns it directly.
-* - Otherwise returns `undefined`.
-*
-* @example String footer
-* ```ts
-* defaultResolveFooter(undefined, { output: { footer: '// end of file' }, config })
-* // → '// end of file'
-* ```
-*
-* @example Function footer with metadata
-* ```ts
-* defaultResolveFooter(meta, { output: { footer: (m) => `// ${m.title}` }, config })
-* // → '// Pet Store'
-* ```
-*/
-function defaultResolveFooter(meta, { output, file }) {
-	if (typeof output?.footer === "function") return output.footer(buildBannerMeta({
-		meta,
-		file
-	}));
-	if (typeof output?.footer === "string") return output.footer;
-	return null;
-}
+	/**
+	* A custom `group.name` wins; otherwise `tag` groups use the camelCased tag and `path`
+	* groups use the first non-traversal segment (`''` when none remain, placing the file in
+	* the output root, kept safe by the caller's boundary check).
+	*/
+	static #resolveGroupDir(group, groupValue) {
+		if (group.name) return group.name({ group: groupValue });
+		if (group.type === "tag") return camelCase(groupValue);
+		const segment = groupValue.split("/").filter((part) => part !== "" && part !== "." && part !== "..")[0];
+		return segment ? camelCase(segment) : "";
+	}
+	/**
+	* `mode: 'file'` resolves directly to `output.path`. `mode: 'directory'` (default) resolves
+	* to `output.path/{baseName}`, or into a subdirectory when `group` and a `tag`/`path` value
+	* are provided.
+	*/
+	#resolvePath({ baseName, tag, path: groupPath }, { root, output, group }) {
+		if (output.mode === "file") return path.resolve(root, output.path);
+		const outputDir = path.resolve(root, output.path);
+		const result = group && (groupPath || tag) ? path.resolve(outputDir, Resolver.#resolveGroupDir(group, group.type === "path" ? groupPath : tag), baseName) : path.resolve(outputDir, baseName);
+		const outputDirWithSep = outputDir.endsWith(path.sep) ? outputDir : `${outputDir}${path.sep}`;
+		if (result !== outputDir && !result.startsWith(outputDirWithSep)) throw new Diagnostics.Error({
+			code: Diagnostics.code.pathTraversal,
+			severity: "error",
+			message: `Resolved path "${result}" is outside the output directory "${outputDir}".`,
+			help: "This can stem from a path traversal in the OpenAPI specification or a misconfigured `group.name` function. Keep generated paths within the output directory.",
+			location: { kind: "config" }
+		});
+		return result;
+	}
+	/**
+	* Builds a `FileNode` by combining file-name casing (`params.resolveName`) with path
+	* resolution. The resolved file starts with empty `sources`, `imports`, and `exports`,
+	* which consumers populate separately.
+	*/
+	#resolveFile({ name, extname, tag, path: groupPath, resolveName = toFilePath }, context) {
+		const resolvedName = context.output.mode === "file" ? "" : resolveName(name);
+		const filePath = this.#resolvePath({
+			baseName: `${resolvedName}${extname}`,
+			tag,
+			path: groupPath
+		}, context);
+		return ast.factory.createFile({
+			path: filePath,
+			baseName: path.basename(filePath),
+			meta: { pluginName: this.pluginName },
+			sources: [],
+			imports: [],
+			exports: []
+		});
+	}
+	/**
+	* Missing fields default to empty/`false` so the `BannerMeta` shape stays stable even when
+	* a caller (e.g. the barrel plugin) has no document metadata.
+	*/
+	static #buildBannerMeta(meta, file) {
+		return {
+			title: meta?.title,
+			description: meta?.description,
+			version: meta?.version,
+			baseURL: meta?.baseURL,
+			circularNames: meta?.circularNames ?? [],
+			enumNames: meta?.enumNames ?? [],
+			filePath: file?.path ?? "",
+			baseName: file?.baseName ?? "",
+			isBarrel: file?.isBarrel ?? false,
+			isAggregation: file?.isAggregation ?? false
+		};
+	}
+	/**
+	* Resolves a user-configured banner/footer value. `undefined` means not configured.
+	*/
+	static #resolveUserText(value, meta, file) {
+		if (typeof value === "function") return value(Resolver.#buildBannerMeta(meta, file));
+		if (typeof value === "string") return value;
+	}
+	static #buildDefaultBanner({ title, version, config }) {
+		const lines = [
+			"/**",
+			"* Generated by Kubb (https://kubb.dev/).",
+			"* Do not edit manually."
+		];
+		if (config.output.defaultBanner !== "simple") {
+			const input = Array.isArray(config.input) ? config.input[0] : config.input;
+			const source = input && "path" in input ? path.basename(input.path) : input && "data" in input ? "text content" : "";
+			if (source) lines.push(`* Source: ${source}`);
+			if (title) lines.push(`* Title: ${title}`);
+			if (version) lines.push(`* OpenAPI spec version: ${version}`);
+		}
+		return `${lines.join("\n")}\n*/\n`;
+	}
+	/**
+	* A user-supplied `output.banner` overrides the default Kubb notice. When
+	* `config.output.defaultBanner` is `false` and no user banner is set, returns `null`.
+	*/
+	#resolveBanner(meta, { output, config, file }) {
+		const userBanner = Resolver.#resolveUserText(output?.banner, meta, file);
+		if (userBanner !== void 0) return userBanner;
+		if (config.output.defaultBanner === false) return null;
+		return Resolver.#buildDefaultBanner({
+			title: meta?.title,
+			version: meta?.version,
+			config
+		});
+	}
+	#resolveFooter(meta, { output, file }) {
+		return Resolver.#resolveUserText(output?.footer, meta, file) ?? null;
+	}
+};
+//#endregion
+//#region src/createResolver.ts
 /**
-* Defines a plugin resolver. The resolver is the object that decides what
-* every generated symbol and file path is called. Built-in defaults handle
-* name casing, include/exclude/override filtering, output path computation,
-* and file construction. Supply your own to override any of them:
-*
-* - `default` sets the name casing strategy (camelCase or PascalCase).
-* - `resolveOptions` does include/exclude/override filtering.
-* - `resolvePath` computes the output path.
-* - `resolveFile` builds the full `FileNode`.
-* - `resolveBanner` and `resolveFooter` produce the top and bottom of file text.
-*
-* Methods in the returned object can call sibling resolver methods via `this`.
-* A custom rule can delegate to a default, for example `this.default(name, 'type')`.
+* Defines a plugin resolver, the object that decides what every generated symbol and file
+* path is called. Override the top-level `name` and `file` to set the plugin's conventions,
+* and add your own naming helpers, top-level (`typeName`, …) or grouped in namespaces
+* (`query`, `schema`, …). Every method reaches sibling helpers and the built-in machinery
+* through `this.name`, `this.file`, and `this.default`.
 *
-* @example Basic resolver with naming helpers
+* @example Custom identifier and file casing
 * ```ts
-* export const resolverTs = defineResolver<PluginTs>(() => ({
-*   name: 'default',
-*   resolveName(name) {
-*     return this.default(name, 'function')
+* export const resolverTs = createResolver<PluginTs>({
+*   pluginName: 'plugin-ts',
+*   name(name) {
+*     return ensureValidVarName(pascalCase(name))
 *   },
-*   resolveTypeName(name) {
-*     return this.default(name, 'type')
+*   file(params, context) {
+*     return this.default.file({ ...params, resolveName: (name) => toFilePath(name, pascalCase) }, context)
 *   },
-* }))
-* ```
-*
-* @example Custom output path
-* ```ts
-* import path from 'node:path'
-*
-* export const resolverTs = defineResolver<PluginTs>(() => ({
-*   name: 'custom',
-*   resolvePath({ baseName }, { root, output }) {
-*     return path.resolve(root, output.path, 'generated', baseName)
-*   },
-* }))
+* })
 * ```
 */
-function defineResolver(build) {
-	let resolver;
-	resolver = {
-		default: defaultResolver,
-		resolveOptions: defaultResolveOptions,
-		resolvePath: defaultResolvePath,
-		resolveFile: (params, context) => defaultResolveFile.call(resolver, params, context),
-		resolveBanner: defaultResolveBanner,
-		resolveFooter: defaultResolveFooter,
-		...build()
-	};
-	return resolver;
+function createResolver(options) {
+	return new Resolver(options);
 }
 //#endregion
 //#region src/Transform.ts
@@ -1282,12 +1040,6 @@ var Transform = class {
 	#composed = /* @__PURE__ */ new Map();
 	#memo = /* @__PURE__ */ new Map();
 	/**
-	* Number of plugins with at least one registered macro.
-	*/
-	get size() {
-		return this.#macros.size;
-	}
-	/**
 	* Appends `macro` to the plugin's list, after any macros already registered.
 	*/
 	add(pluginName, macro) {
@@ -1304,12 +1056,6 @@ var Transform = class {
 		this.#invalidate(pluginName);
 	}
 	/**
-	* Looks up the composed visitor for `pluginName`, or `undefined` when the plugin has no macros.
-	*/
-	get(pluginName) {
-		return this.#visitorFor(pluginName);
-	}
-	/**
 	* Runs the plugin's macros on `node`. Returns the original node reference when the plugin has no
 	* macros, so callers can compare by identity to detect a no-op.
 	*/
@@ -1353,20 +1099,21 @@ var Transform = class {
 };
 //#endregion
 //#region src/KubbDriver.ts
-function enforceOrder(enforce) {
-	return enforce === "pre" ? -1 : enforce === "post" ? 1 : 0;
-}
+const ENFORCE_ORDER = {
+	pre: -1,
+	post: 1
+};
+const enforceWeight = (plugin) => plugin.enforce ? ENFORCE_ORDER[plugin.enforce] : 0;
 var KubbDriver = class {
 	config;
 	options;
 	/**
-	* The streaming `InputNode<true>` produced by the adapter. Set after adapter setup.
-	* Parse-only adapters are wrapped automatically.
+	* The `InputNode` produced by the adapter. Set after adapter setup.
 	*/
 	inputNode = null;
 	adapter = null;
 	/**
-	* Raw adapter source so `adapter.parse()` / `adapter.stream()` can run lazily.
+	* Raw adapter source so `adapter.parse()` can run lazily.
 	* Intentionally outlives the build, cleared by `dispose()`.
 	*/
 	#adapterSource = null;
@@ -1378,17 +1125,17 @@ var KubbDriver = class {
 	fileManager = new FileManager();
 	plugins = /* @__PURE__ */ new Map();
 	/**
-	* Tracks which plugins have generators registered via `addGenerator()` (event-based path).
-	* Used by the build loop to decide whether to emit generator events for a given plugin.
+	* Tracks which plugins have generators registered via `addGenerator()` (hook-based path).
+	* Used by the build loop to decide whether to emit generator hooks for a given plugin.
 	*/
-	#eventGeneratorPlugins = /* @__PURE__ */ new Set();
+	#hookGeneratorPlugins = /* @__PURE__ */ new Set();
 	#resolvers = /* @__PURE__ */ new Map();
 	#defaultResolvers = /* @__PURE__ */ new Map();
 	/**
-	* Tracks every listener the driver added (plugin, generator) so `dispose()` can remove them
-	* in one pass. External `hooks.on(...)` listeners are not tracked.
+	* Removers for every listener the driver added (plugin, generator) so `dispose()` can detach
+	* them in one pass. External `hooks.hook(...)` listeners are not tracked.
 	*/
-	#listeners = [];
+	#unhooks = [];
 	/**
 	* Transform registry. Plugins populate it during `kubb:plugin:setup` via `addMacro`/`setMacros`,
 	* and `#runGenerators` reads it once per `(plugin, node)` pair through `applyTo`.
@@ -1400,163 +1147,137 @@ var KubbDriver = class {
 		this.adapter = config.adapter ?? null;
 	}
 	/**
-	* Attaches a listener to the shared emitter and tracks it so `dispose()` can remove it later.
-	* Listeners attached directly via `hooks.on(...)` are not tracked and survive disposal.
-	*/
-	#trackListener(event, handler) {
-		this.hooks.on(event, handler);
-		this.#listeners.push([event, handler]);
-	}
-	/**
 	* Normalizes every configured plugin, orders them, and registers their lifecycle handlers.
 	* A plugin that another lists as a dependency runs first, then `enforce: 'pre'` before
 	* `'post'`. When the config has an adapter, the adapter source is resolved from the input
 	* so `run` can parse it later.
 	*/
 	async setup() {
-		const normalized = this.config.plugins.map((rawPlugin) => this.#normalizePlugin(rawPlugin));
-		const dependenciesByName = new Map(normalized.map((plugin) => [plugin.name, new Set(plugin.dependencies ?? [])]));
-		normalized.sort((a, b) => {
-			if (dependenciesByName.get(b.name)?.has(a.name)) return -1;
-			if (dependenciesByName.get(a.name)?.has(b.name)) return 1;
-			return enforceOrder(a.enforce) - enforceOrder(b.enforce);
-		});
+		const normalized = this.#sortPlugins(this.config.plugins.map((rawPlugin) => {
+			return {
+				name: rawPlugin.name,
+				dependencies: rawPlugin.dependencies,
+				enforce: rawPlugin.enforce,
+				hooks: rawPlugin.hooks,
+				options: rawPlugin.options ?? {
+					output: {
+						path: ".",
+						mode: "directory"
+					},
+					exclude: [],
+					override: []
+				}
+			};
+		}));
 		for (const plugin of normalized) {
-			if (plugin.apply) plugin.apply(this.config);
 			this.#registerPlugin(plugin);
 			this.plugins.set(plugin.name, plugin);
 		}
 		if (this.config.adapter) this.#adapterSource = inputToAdapterSource(this.config);
 	}
+	/**
+	* Orders plugins so every dependency runs before its dependents (Kahn's algorithm), with
+	* `enforce` (`'pre'` before normal before `'post'`) and declaration order as tiebreaks.
+	* A pairwise `Array.sort` comparator cannot do this: dependency relations are not transitive
+	* at the comparator level, so a chain where A depends on B and B depends on C could come out
+	* wrong when A and C are never compared directly. Dependencies on plugins missing from the
+	* config are ignored here and surface later through `requirePlugin`.
+	*/
+	#sortPlugins(plugins) {
+		const queue = [...plugins].sort((a, b) => enforceWeight(a) - enforceWeight(b));
+		const names = new Set(queue.map((plugin) => plugin.name));
+		const blockedBy = new Map(queue.map((plugin) => [plugin.name, new Set(plugin.dependencies?.filter((name) => names.has(name) && name !== plugin.name))]));
+		const sorted = [];
+		for (const _ of plugins) {
+			const index = queue.findIndex((plugin) => blockedBy.get(plugin.name)?.size === 0);
+			if (index === -1) throw new Diagnostics.Error({
+				code: Diagnostics.code.invalidPluginOptions,
+				severity: "error",
+				message: `Plugin dependencies form a cycle: ${queue.map((plugin) => plugin.name).join(" → ")}.`,
+				help: "Remove one of the `dependencies` entries so the plugins can be ordered.",
+				location: { kind: "config" }
+			});
+			const [plugin] = queue.splice(index, 1);
+			if (!plugin) break;
+			sorted.push(plugin);
+			for (const blockers of blockedBy.values()) blockers.delete(plugin.name);
+		}
+		return sorted;
+	}
 	get hooks() {
 		return this.options.hooks;
 	}
 	/**
-	* Builds a `NormalizedPlugin` from a hook-style plugin, filling in default
-	* options and copying `apply` when present. Registering its lifecycle handlers
-	* on the `AsyncEventEmitter` is done separately by `#registerPlugin`.
-	*/
-	#normalizePlugin(plugin) {
-		const normalized = {
-			name: plugin.name,
-			dependencies: plugin.dependencies,
-			enforce: plugin.enforce,
-			hooks: plugin.hooks,
-			options: plugin.options ?? {
-				output: {
-					path: ".",
-					mode: "directory"
-				},
-				exclude: [],
-				override: []
-			}
-		};
-		if ("apply" in plugin && typeof plugin.apply === "function") normalized.apply = plugin.apply;
-		return normalized;
-	}
-	/**
 	* Parses the adapter source into `this.inputNode`. Idempotent, so repeated calls from
-	* `run` do not re-parse. Adapters with `stream()` are used directly.
-	* Adapters with only `parse()` are wrapped via `ast.factory.createInput({ stream: true })` so the dispatch loop
-	* stays stream-only.
+	* `run` do not re-parse.
 	*/
 	async #parseInput() {
 		if (this.inputNode || !this.adapter || !this.#adapterSource) return;
-		const adapter = this.adapter;
-		const source = this.#adapterSource;
-		if (adapter.stream) {
-			this.inputNode = await adapter.stream(source);
-			return;
-		}
-		const parsed = await adapter.parse(source);
-		this.inputNode = ast.factory.createInput({
-			stream: true,
-			schemas: arrayToAsyncIterable(parsed.schemas),
-			operations: arrayToAsyncIterable(parsed.operations),
-			meta: parsed.meta
-		});
+		this.inputNode = await this.adapter.parse(this.#adapterSource);
 	}
 	/**
-	* Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
-	*
-	* The `kubb:plugin:setup` listener wraps the global context in a plugin-specific one so
-	* `addGenerator`, `setResolver`, and `setMacros` target the right `normalizedPlugin`.
-	* Every other `KubbHooks` event registers as a pass-through listener that external tooling
-	* can observe via `hooks.on(...)`.
+	* Registers a plugin's lifecycle hooks on the shared `Hookable` as pass-through listeners that
+	* external tooling can observe via `hooks.hook(...)`. The returned remover is tracked for
+	* `dispose`. `kubb:plugin:setup` is skipped here; `setupHooks` invokes it directly with a
+	* plugin-scoped context.
 	*
 	* @internal
 	*/
 	#registerPlugin(plugin) {
 		const { hooks } = plugin;
 		if (!hooks) return;
-		if (hooks["kubb:plugin:setup"]) {
-			const setupHandler = (globalCtx) => {
-				const pluginCtx = {
-					...globalCtx,
-					options: plugin.options ?? {},
-					addGenerator: (...generators) => {
-						for (const generator of generators.flat()) this.registerGenerator(plugin.name, generator);
-					},
-					setResolver: (resolver) => {
-						this.setPluginResolver(plugin.name, resolver);
-					},
-					addMacro: (macro) => {
-						this.#transforms.add(plugin.name, macro);
-					},
-					setMacros: (macros) => {
-						this.#transforms.set(plugin.name, macros);
-					},
-					setOptions: (opts) => {
-						plugin.options = {
-							...plugin.options,
-							...opts
-						};
-						if (plugin.options.output) {
-							const group = "group" in plugin.options ? plugin.options.group : void 0;
-							plugin.options.output = normalizeOutput({
-								output: plugin.options.output,
-								group,
-								pluginName: plugin.name
-							});
-						}
-					},
-					injectFile: (userFileNode) => {
-						this.fileManager.add(ast.factory.createFile(userFileNode));
-					}
-				};
-				return hooks["kubb:plugin:setup"](pluginCtx);
-			};
-			this.#trackListener("kubb:plugin:setup", setupHandler);
-		}
-		for (const event of Object.keys(hooks)) {
-			if (event === "kubb:plugin:setup") continue;
-			const handler = hooks[event];
-			if (!handler) continue;
-			this.#trackListener(event, handler);
-		}
+		const { "kubb:plugin:setup": _setup, ...configHooks } = hooks;
+		this.#unhooks.push(this.hooks.addHooks(configHooks));
 	}
 	/**
-	* Emits the `kubb:plugin:setup` event so that all registered hook-style plugin listeners
-	* can configure generators, resolvers, macros and renderers before `buildStart` runs.
-	*
-	* Called once from `run` before the plugin execution loop begins.
+	* Runs each plugin's `kubb:plugin:setup` handler, in plugin order, with a context scoped to that
+	* plugin so `addGenerator`, `setResolver`, `addMacro`, `setMacros`, and `setOptions` target its
+	* `NormalizedPlugin` entry. Called once from `run` before the plugin execution loop begins, so
+	* plugins can configure generators, resolvers, macros, and options before `buildStart`.
 	*/
-	async emitSetupHooks() {
+	async setupHooks() {
 		const noop = () => {};
-		await this.hooks.emit("kubb:plugin:setup", {
-			config: this.config,
-			options: {},
-			addGenerator: noop,
-			setResolver: noop,
-			addMacro: noop,
-			setMacros: noop,
-			setOptions: noop,
-			injectFile: noop,
-			updateConfig: noop
-		});
+		for (const plugin of this.plugins.values()) {
+			const setup = plugin.hooks?.["kubb:plugin:setup"];
+			if (!setup) continue;
+			await setup({
+				config: this.config,
+				options: plugin.options ?? {},
+				updateConfig: noop,
+				addGenerator: (...generators) => {
+					for (const generator of generators) this.registerGenerator(plugin.name, generator);
+				},
+				setResolver: (resolver) => {
+					this.setPluginResolver(plugin.name, resolver);
+				},
+				addMacro: (macro) => {
+					this.#transforms.add(plugin.name, macro);
+				},
+				setMacros: (macros) => {
+					this.#transforms.set(plugin.name, macros);
+				},
+				setOptions: (opts) => {
+					plugin.options = {
+						...plugin.options,
+						...opts
+					};
+					if (plugin.options.output) {
+						const group = "group" in plugin.options ? plugin.options.group : void 0;
+						plugin.options.output = normalizeOutput({
+							output: plugin.options.output,
+							group,
+							pluginName: plugin.name
+						});
+					}
+				},
+				injectFile: (userFileNode) => {
+					this.fileManager.add(ast.factory.createFile(userFileNode));
+				}
+			});
+		}
 	}
 	/**
-	* Registers a generator for the given plugin on the shared event emitter.
+	* Registers a generator for the given plugin on the shared hook emitter.
 	*
 	* The generator's `schema`, `operation`, and `operations` methods are registered as
 	* listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
@@ -1569,9 +1290,9 @@ var KubbDriver = class {
 	* Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
 	*/
 	registerGenerator(pluginName, generator) {
-		const register = (event, method) => {
-			if (!method) return;
-			const handler = async (node, ctx) => {
+		const wrap = (method) => {
+			if (!method) return void 0;
+			return async (node, ctx) => {
 				if (ctx.plugin.name !== pluginName) return;
 				const result = await method(node, ctx);
 				await this.dispatch({
@@ -1579,22 +1300,23 @@ var KubbDriver = class {
 					renderer: generator.renderer
 				});
 			};
-			this.#trackListener(event, handler);
 		};
-		register("kubb:generate:schema", generator.schema);
-		register("kubb:generate:operation", generator.operation);
-		register("kubb:generate:operations", generator.operations);
-		this.#eventGeneratorPlugins.add(pluginName);
+		this.#unhooks.push(this.hooks.addHooks({
+			"kubb:generate:schema": wrap(generator.schema),
+			"kubb:generate:operation": wrap(generator.operation),
+			"kubb:generate:operations": wrap(generator.operations)
+		}));
+		this.#hookGeneratorPlugins.add(pluginName);
 	}
 	/**
 	* Returns `true` when at least one generator was registered for the given plugin
-	* via `addGenerator()` in `kubb:plugin:setup` (event-based path).
+	* via `addGenerator()` in `kubb:plugin:setup`.
 	*
-	* Used by the build loop to decide whether to walk the AST and emit generator events
-	* for a plugin that has no static `plugin.generators`.
+	* Used by the build loop to decide whether to walk the AST and emit generator hooks
+	* for a plugin.
 	*/
-	hasEventGenerators(pluginName) {
-		return this.#eventGeneratorPlugins.has(pluginName);
+	hasHookGenerators(pluginName) {
+		return this.#hookGeneratorPlugins.has(pluginName);
 	}
 	/**
 	* Runs the full plugin pipeline. Returns the diagnostics collected so far even
@@ -1603,40 +1325,36 @@ var KubbDriver = class {
 	* contributes a `timing` diagnostic for the run summary.
 	*/
 	async run({ storage }) {
-		const { hooks, config } = this;
+		const { hooks, config, fileManager } = this;
 		const diagnostics = [];
 		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 processor = new FileProcessor({
-			parsers: parsersMap,
-			storage,
-			extension: config.output.extension
-		});
-		processor.hooks.on("start", async (files) => {
-			await hooks.emit("kubb:files:processing:start", { files });
-		});
+		const onWriteStart = async (files) => {
+			await hooks.callHook("kubb:files:processing:start", { files });
+		};
 		const updateBuffer = [];
-		processor.hooks.on("update", (item) => {
+		const onWriteUpdate = (item) => {
 			updateBuffer.push(item);
-		});
-		processor.hooks.on("end", async (files) => {
-			await hooks.emit("kubb:files:processing:update", { files: updateBuffer.map((item) => ({
+		};
+		const onWriteEnd = async (files) => {
+			await hooks.callHook("kubb:files:processing:update", { files: updateBuffer.map((item) => ({
 				...item,
 				config
 			})) });
 			updateBuffer.length = 0;
-			await hooks.emit("kubb:files:processing:end", { files });
-		});
-		const onFileUpsert = (file) => {
-			processor.enqueue(file);
+			await hooks.callHook("kubb:files:processing:end", { files });
 		};
-		this.fileManager.hooks.on("upsert", onFileUpsert);
+		const unhookWrites = fileManager.hooks.addHooks({
+			start: onWriteStart,
+			update: onWriteUpdate,
+			end: onWriteEnd
+		});
 		return Diagnostics.scope((diagnostic) => diagnostics.push(diagnostic), async () => {
 			try {
 				const outputRoot = resolve(config.root, config.output.path);
 				await this.#parseInput();
-				await this.emitSetupHooks();
-				if (this.adapter && this.inputNode) await hooks.emit("kubb:build:start", Object.assign({
+				await this.setupHooks();
+				if (this.adapter && this.inputNode) await hooks.callHook("kubb:build:start", Object.assign({
 					config,
 					adapter: this.adapter,
 					meta: this.inputNode.meta,
@@ -1647,9 +1365,9 @@ var KubbDriver = class {
 					const context = this.getContext(plugin);
 					const hrStart = process.hrtime();
 					try {
-						await hooks.emit("kubb:plugin:start", { plugin });
+						await hooks.callHook("kubb:plugin:start", { plugin });
 					} catch (caughtError) {
-						const error = caughtError;
+						const error = toError(caughtError);
 						const duration = getElapsedMs(hrStart);
 						await this.#emitPluginEnd({
 							plugin,
@@ -1666,7 +1384,7 @@ var KubbDriver = class {
 						}));
 						continue;
 					}
-					if (this.hasEventGenerators(plugin.name)) {
+					if (this.hasHookGenerators(plugin.name)) {
 						generatorPlugins.push({
 							plugin,
 							context,
@@ -1685,11 +1403,14 @@ var KubbDriver = class {
 						success: true
 					});
 				}
-				diagnostics.push(...await this.#runGenerators(generatorPlugins, () => processor.flush()));
-				await processor.drain();
-				await hooks.emit("kubb:plugins:end", Object.assign({ config }, this.#filesPayload()));
-				await processor.drain();
-				await hooks.emit("kubb:build:end", {
+				diagnostics.push(...await this.#runGenerators(generatorPlugins));
+				await hooks.callHook("kubb:plugins:end", Object.assign({ config }, this.#filesPayload()));
+				await fileManager.write(fileManager.files, {
+					storage,
+					parsers: parsersMap,
+					extension: config.output.extension
+				});
+				await hooks.callHook("kubb:build:end", {
 					files: this.fileManager.files,
 					config,
 					outputDir: outputRoot
@@ -1699,7 +1420,7 @@ var KubbDriver = class {
 				diagnostics.push(Diagnostics.from(caughtError));
 				return { diagnostics: Diagnostics.dedupe(diagnostics) };
 			} finally {
-				this.fileManager.hooks.off("upsert", onFileUpsert);
+				unhookWrites();
 			}
 		});
 	}
@@ -1713,7 +1434,7 @@ var KubbDriver = class {
 		};
 	}
 	#emitPluginEnd({ plugin, duration, success, error }) {
-		return this.hooks.emit("kubb:plugin:end", Object.assign({
+		return this.hooks.callHook("kubb:plugin:end", Object.assign({
 			plugin,
 			duration,
 			success,
@@ -1722,22 +1443,21 @@ var KubbDriver = class {
 		}, this.#filesPayload()));
 	}
 	/**
-	* Streams schemas and operations through every plugin's generators. Each node is run
+	* Runs schemas and operations through every plugin's generators. Each node is run
 	* through the plugin's macros (from `this.#transforms`) before the generator sees it,
 	* so plugins stay isolated and the hot path stays per-node. Schemas run before operations
-	* because the two passes share `flushPending` and the FileProcessor's event emitter.
+	* so file output stays deterministic across runs.
 	* A failing plugin contributes an error diagnostic so the rest of the build continues.
 	* Every plugin also contributes a `timing` diagnostic.
 	*
-	* Plugins run sequentially so `kubb:plugin:end` fires as each plugin completes, instead
-	* of all at once after every plugin has marched through the parallel batches together.
-	* That ordering is what drives the CLI's `Plugins N/M` counter. Without it the bar would
-	* sit at the initial value until the very end of the run.
+	* Plugins are processed one at a time, in full, so `kubb:plugin:end` fires as each one
+	* completes rather than all at once at the end. That ordering drives the CLI's
+	* `Plugins N/M` counter.
 	*
 	* When `this.inputNode` is `null`, every entry still gets a `kubb:plugin:end` so
 	* post-plugin listeners (the barrel writer and friends) complete.
 	*/
-	async #runGenerators(entries, flushPending) {
+	async #runGenerators(entries) {
 		const diagnostics = [];
 		if (entries.length === 0) return diagnostics;
 		if (!this.inputNode) {
@@ -1757,160 +1477,104 @@ var KubbDriver = class {
 		}
 		const transforms = this.#transforms;
 		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 emitsOperationsHook = this.hooks.listenerCount("kubb:generate:operations") > 0;
-		const schemasBuffer = await Array.fromAsync(schemas);
-		const operationsBuffer = await Array.fromAsync(operations);
-		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 includedOpsByState = new Map(pruningStates.map((state) => [state, []]));
-			for (const operation of operationsBuffer) 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) ?? [], schemasBuffer);
-				includedOpsByState.delete(state);
-			}
-		}
-		const resolveForPlugin = (state, node) => {
-			const { plugin, generatorContext } = state;
-			const transformedNode = transforms.applyTo(plugin.name, node);
-			if (state.optionsAreStatic) return {
-				transformedNode,
-				options: plugin.options
-			};
+		const allowedSchemaNamesByPlugin = /* @__PURE__ */ new Map();
+		for (const { plugin } of entries) {
 			const { exclude, include, override } = plugin.options;
-			const options = generatorContext.resolver.resolveOptions(transformedNode, {
+			if (!((include?.some(({ type }) => OPERATION_FILTER_TYPES.has(type)) ?? false) && !(include?.some(({ type }) => type === "schemaName") ?? false))) continue;
+			const resolver = this.getResolver(plugin.name);
+			const includedOps = operations.filter((operation) => resolver.default.options(operation, {
 				options: plugin.options,
 				exclude,
 				include,
 				override
-			});
-			if (options === null) return null;
-			return {
-				transformedNode,
-				options
+			}) !== null);
+			allowedSchemaNamesByPlugin.set(plugin.name, collectUsedSchemaNames(includedOps, schemas));
+		}
+		for (const { plugin, context, hrStart } of entries) {
+			const generatorContext = {
+				...context,
+				resolver: this.getResolver(plugin.name)
 			};
-		};
-		const dispatchNode = async (state, node, dispatch) => {
-			if (state.failed) return;
-			try {
-				const resolved = resolveForPlugin(state, node);
-				if (!resolved) return;
-				const { transformedNode, options } = resolved;
-				if (dispatch.checkAllowedNames && state.allowedSchemaNames !== null && "name" in transformedNode && transformedNode.name && !state.allowedSchemaNames.has(transformedNode.name)) return;
-				const ctx = {
-					...state.generatorContext,
+			const { exclude, include, override } = plugin.options;
+			const optionsAreStatic = !exclude?.length && !include?.length && !override?.length;
+			const allowedSchemaNames = allowedSchemaNamesByPlugin.get(plugin.name) ?? null;
+			let error = null;
+			const resolveForPlugin = (node) => {
+				const transformedNode = transforms.applyTo(plugin.name, node);
+				if (optionsAreStatic) return {
+					transformedNode,
+					options: plugin.options
+				};
+				const options = generatorContext.resolver.default.options(transformedNode, {
+					options: plugin.options,
+					exclude,
+					include,
+					override
+				});
+				if (options === null) return null;
+				return {
+					transformedNode,
 					options
 				};
-				for (const gen of state.generators) {
-					const run = gen[dispatch.method];
-					if (!run) continue;
-					const raw = run(transformedNode, ctx);
-					const result = isPromise(raw) ? await raw : raw;
-					const applied = this.dispatch({
-						result,
-						renderer: gen.renderer
+			};
+			if (emitsSchemaHook) for (const node of schemas) {
+				if (error) break;
+				try {
+					const resolved = resolveForPlugin(node);
+					if (!resolved) continue;
+					const { transformedNode, options } = resolved;
+					if (allowedSchemaNames !== null && transformedNode.name && !allowedSchemaNames.has(transformedNode.name)) continue;
+					await this.hooks.callHook("kubb:generate:schema", transformedNode, {
+						...generatorContext,
+						options
 					});
-					if (isPromise(applied)) await applied;
+				} catch (caughtError) {
+					error = toError(caughtError);
 				}
-				if (dispatch.emit) await dispatch.emit(transformedNode, ctx);
-			} catch (caughtError) {
-				state.failed = true;
-				state.error = caughtError;
 			}
-		};
-		const schemaDispatch = {
-			method: "schema",
-			checkAllowedNames: true,
-			emit: emitsSchemaHook ? (node, ctx) => this.hooks.emit("kubb:generate:schema", node, ctx) : null
-		};
-		const operationDispatch = {
-			method: "operation",
-			checkAllowedNames: false,
-			emit: emitsOperationHook ? (node, ctx) => this.hooks.emit("kubb:generate:operation", node, ctx) : null
-		};
-		const dispatchPass = async (state, nodes, dispatch) => {
-			let sinceFlush = 0;
-			for (const node of nodes) {
-				await dispatchNode(state, node, dispatch);
-				if (++sinceFlush >= 8) {
-					sinceFlush = 0;
-					await flushPending();
+			if (emitsOperationHook) for (const node of operations) {
+				if (error) break;
+				try {
+					const resolved = resolveForPlugin(node);
+					if (!resolved) continue;
+					await this.hooks.callHook("kubb:generate:operation", resolved.transformedNode, {
+						...generatorContext,
+						options: resolved.options
+					});
+				} catch (caughtError) {
+					error = toError(caughtError);
 				}
 			}
-			if (sinceFlush > 0) await flushPending();
-		};
-		for (const state of states) {
-			const needsOperationsAggregate = emitsOperationsHook || state.generators.some((gen) => !!gen.operations);
-			await dispatchPass(state, schemasBuffer, schemaDispatch);
-			await dispatchPass(state, operationsBuffer, operationDispatch);
-			if (!state.failed && needsOperationsAggregate) try {
-				const { plugin, generatorContext, generators } = state;
+			if (!error && emitsOperationsHook) try {
 				const ctx = {
 					...generatorContext,
 					options: plugin.options
 				};
-				const pluginOperations = operationsBuffer.reduce((acc, node) => {
-					const resolved = resolveForPlugin(state, node);
+				const pluginOperations = operations.reduce((acc, node) => {
+					const resolved = resolveForPlugin(node);
 					if (resolved) acc.push(resolved.transformedNode);
 					return acc;
 				}, []);
-				for (const gen of generators) {
-					if (!gen.operations) continue;
-					const result = await gen.operations(pluginOperations, ctx);
-					await this.dispatch({
-						result,
-						renderer: gen.renderer
-					});
-				}
-				await this.hooks.emit("kubb:generate:operations", pluginOperations, ctx);
+				await this.hooks.callHook("kubb:generate:operations", pluginOperations, ctx);
 			} catch (caughtError) {
-				state.failed = true;
-				state.error = caughtError;
+				error = toError(caughtError);
 			}
-			const duration = getElapsedMs(state.hrStart);
+			const duration = getElapsedMs(hrStart);
 			await this.#emitPluginEnd({
-				plugin: state.plugin,
+				plugin,
 				duration,
-				success: !state.failed,
-				error: state.failed && state.error ? state.error : void 0
+				success: !error,
+				error: error ?? void 0
 			});
-			if (state.failed && state.error) diagnostics.push({
-				...Diagnostics.from(state.error),
-				plugin: state.plugin.name
+			if (error) diagnostics.push({
+				...Diagnostics.from(error),
+				plugin: plugin.name
 			});
 			diagnostics.push(Diagnostics.performance({
-				plugin: state.plugin.name,
+				plugin: plugin.name,
 				duration
 			}));
 		}
@@ -1938,10 +1602,6 @@ var KubbDriver = class {
 			}
 			if (!renderer) return;
 			const instance = _usingCtx$2.u(renderer());
-			if (instance.stream) {
-				for (const file of instance.stream(result)) this.fileManager.upsert(file);
-				return;
-			}
 			await instance.render(result);
 			this.fileManager.upsert(...instance.files);
 		} catch (_) {
@@ -1957,9 +1617,9 @@ var KubbDriver = class {
 	* @internal
 	*/
 	dispose() {
-		for (const [event, handler] of this.#listeners) this.hooks.off(event, handler);
-		this.#listeners.length = 0;
-		this.#eventGeneratorPlugins.clear();
+		for (const unhook of this.#unhooks) unhook();
+		this.#unhooks.length = 0;
+		this.#hookGeneratorPlugins.clear();
 		this.#transforms.dispose();
 		this.#resolvers.clear();
 		this.#defaultResolvers.clear();
@@ -1970,26 +1630,21 @@ var KubbDriver = class {
 	[Symbol.dispose]() {
 		this.dispose();
 	}
-	#getDefaultResolver = memoize(this.#defaultResolvers, (pluginName) => defineResolver(() => ({
-		name: "default",
-		pluginName
-	})));
+	#getDefaultResolver = memoize(this.#defaultResolvers, (pluginName) => createResolver({ pluginName }));
 	/**
 	* Merges `partial` with the plugin's default resolver and stores the result.
 	* Also mirrors it onto `plugin.resolver` so callers using `getPlugin(name).resolver`
 	* get the up-to-date resolver without going through `getResolver()`.
 	*/
 	setPluginResolver(pluginName, partial) {
-		const merged = {
-			...this.#getDefaultResolver(pluginName),
-			...partial
-		};
+		const defaultResolver = this.#getDefaultResolver(pluginName);
+		const merged = Resolver.merge(defaultResolver, partial);
 		this.#resolvers.set(pluginName, merged);
 		const plugin = this.plugins.get(pluginName);
 		if (plugin) plugin.resolver = merged;
 	}
 	getResolver(pluginName) {
-		return this.#resolvers.get(pluginName) ?? this.plugins.get(pluginName)?.resolver ?? this.#getDefaultResolver(pluginName);
+		return this.#resolvers.get(pluginName) ?? this.#getDefaultResolver(pluginName);
 	}
 	getContext(plugin) {
 		const driver = this;
@@ -2057,18 +1712,18 @@ var KubbDriver = class {
 		return this.plugins.get(pluginName);
 	}
 	requirePlugin(pluginName, context) {
-		const plugin = this.plugins.get(pluginName);
-		if (!plugin) {
-			const requiredBy = context?.requiredBy;
-			throw new Diagnostics.Error({
-				code: Diagnostics.code.pluginNotFound,
-				severity: "error",
-				message: requiredBy ? `Plugin "${pluginName}" is required by "${requiredBy}" but not found. Make sure it is included in your Kubb config.` : `Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`,
-				help: requiredBy ? `Add "${pluginName}" to the \`plugins\` array in kubb.config.ts (required by "${requiredBy}"), or remove the dependency on it.` : `Add "${pluginName}" to the \`plugins\` array in kubb.config.ts, or remove the dependency on it.`,
-				location: { kind: "config" }
-			});
-		}
-		return plugin;
+		const plugin = this.getPlugin(pluginName);
+		if (plugin) return plugin;
+		const requiredBy = context?.requiredBy;
+		const by = requiredBy ? ` by "${requiredBy}"` : "";
+		const help = requiredBy ? ` (required by "${requiredBy}")` : "";
+		throw new Diagnostics.Error({
+			code: Diagnostics.code.pluginNotFound,
+			severity: "error",
+			message: `Plugin "${pluginName}" is required${by} but not found. Make sure it is included in your Kubb config.`,
+			help: `Add "${pluginName}" to the \`plugins\` array in kubb.config.ts${help}, or remove the dependency on it.`,
+			location: { kind: "config" }
+		});
 	}
 };
 function inputToAdapterSource(config) {
@@ -2094,7 +1749,73 @@ function inputToAdapterSource(config) {
 	};
 }
 //#endregion
+//#region src/createStorage.ts
+/**
+* Defines a custom storage backend. The builder receives user options and
+* returns a `Storage` implementation. Kubb ships with filesystem and in-memory
+* storages. A custom backend writes generated files elsewhere, such as cloud
+* storage or a database.
+*
+* @example In-memory storage (the built-in implementation)
+* ```ts
+* import { createStorage } from '@kubb/core'
+*
+* export const memoryStorage = createStorage(() => {
+*   const store = new Map<string, string>()
+*
+*   return {
+*     name: 'memory',
+*     async hasItem(key) {
+*       return store.has(key)
+*     },
+*     async getItem(key) {
+*       return store.get(key) ?? null
+*     },
+*     async setItem(key, value) {
+*       store.set(key, value)
+*     },
+*     async removeItem(key) {
+*       store.delete(key)
+*     },
+*     async getKeys(base) {
+*       const keys = [...store.keys()]
+*       return base ? keys.filter((k) => k.startsWith(base)) : keys
+*     },
+*     async clear(base) {
+*       if (!base) store.clear()
+*     },
+*   }
+* })
+* ```
+*/
+function createStorage(build) {
+	return (options) => build(options ?? {});
+}
+//#endregion
 //#region src/storages/fsStorage.ts
+const WRITE_CONCURRENCY = 50;
+function createLimiter(concurrency) {
+	let active = 0;
+	const queue = [];
+	function next() {
+		if (active >= concurrency) return;
+		const run = queue.shift();
+		if (!run) return;
+		active++;
+		run();
+	}
+	return function limit(task) {
+		return new Promise((resolve, reject) => {
+			queue.push(() => {
+				task().then(resolve, reject).finally(() => {
+					active--;
+					next();
+				});
+			});
+			next();
+		});
+	};
+}
 /**
 * Built-in filesystem storage driver.
 *
@@ -2107,6 +1828,8 @@ function inputToAdapterSource(config) {
 * - the write is skipped when the file content is already identical
 * - missing parent directories are created automatically
 * - Bun's native file API is used when running under Bun
+* - concurrent `setItem` calls are capped at {@link WRITE_CONCURRENCY} in flight, so a caller
+*   can fire every file's write without pacing itself
 *
 * @example
 * ```ts
@@ -2120,91 +1843,50 @@ function inputToAdapterSource(config) {
 * })
 * ```
 */
-const fsStorage = createStorage(() => ({
-	name: "fs",
-	async hasItem(key) {
-		try {
-			await access(resolve(key));
-			return true;
-		} catch (_error) {
-			return false;
-		}
-	},
-	async getItem(key) {
-		try {
-			return await readFile(resolve(key), "utf8");
-		} catch (_error) {
-			return null;
-		}
-	},
-	async setItem(key, value) {
-		await write(resolve(key), value, { sanity: false });
-	},
-	async removeItem(key) {
-		await rm(resolve(key), { force: true });
-	},
-	async getKeys(base) {
-		const resolvedBase = resolve(base ?? process.cwd());
-		if (runtime.isBun) {
-			const bunGlob = new Bun.Glob("**/*");
-			return Array.fromAsync(bunGlob.scan({
-				cwd: resolvedBase,
-				onlyFiles: true,
-				dot: true
-			}));
-		}
-		const keys = [];
-		try {
-			for await (const entry of glob("**/*", {
-				cwd: resolvedBase,
-				withFileTypes: true
-			})) if (entry.isFile()) keys.push(toPosixPath(relative(resolvedBase, join(entry.parentPath, entry.name))));
-		} catch (_error) {}
-		return keys;
-	},
-	async clear(base) {
-		if (!base) return;
-		await clean(resolve(base));
-	}
-}));
-//#endregion
-//#region src/createKubb.ts
-/**
-* Builds a `Storage` view scoped to the file paths produced by the current build.
-* Reads delegate to the underlying `storage` so source bytes stay where they were
-* written. Writes register the key so subsequent reads and `getKeys` are scoped
-* to this build's output.
-*/
-function createSourcesView(storage) {
-	const paths = /* @__PURE__ */ new Set();
-	return createStorage(() => ({
-		name: `${storage.name}:sources`,
+const fsStorage = createStorage(() => {
+	const limit = createLimiter(WRITE_CONCURRENCY);
+	return {
+		name: "fs",
 		async hasItem(key) {
-			return paths.has(key) && await storage.hasItem(key);
+			try {
+				await access(resolve(key));
+				return true;
+			} catch (_error) {
+				return false;
+			}
 		},
 		async getItem(key) {
-			return paths.has(key) ? storage.getItem(key) : null;
+			try {
+				return await readFile(resolve(key), "utf8");
+			} catch (_error) {
+				return null;
+			}
 		},
 		async setItem(key, value) {
-			paths.add(key);
-			await storage.setItem(key, value);
+			await limit(() => write(resolve(key), value, { sanity: false }));
 		},
 		async removeItem(key) {
-			paths.delete(key);
-			await storage.removeItem(key);
+			await rm(resolve(key), { force: true });
 		},
 		async getKeys(base) {
-			if (!base) return [...paths];
-			const result = [];
-			for (const key of paths) if (key.startsWith(base)) result.push(key);
-			return result;
+			const resolvedBase = resolve(base ?? process.cwd());
+			const keys = [];
+			try {
+				for await (const entry of glob("**/*", {
+					cwd: resolvedBase,
+					withFileTypes: true
+				})) if (entry.isFile()) keys.push(toPosixPath(relative(resolvedBase, join(entry.parentPath, entry.name))));
+			} catch (_error) {}
+			return keys;
 		},
-		async clear() {
-			paths.clear();
-			await storage.clear();
+		async clear(base) {
+			if (!base) return;
+			await clean(resolve(base));
 		}
-	}))();
-}
+	};
+});
+//#endregion
+//#region src/createKubb.ts
 function resolveConfig(userConfig) {
 	return {
 		...userConfig,
@@ -2230,12 +1912,12 @@ function resolveConfig(userConfig) {
 * `createKubb` takes a plain config object (the shape `defineConfig` produces),
 * not a fluent builder.
 *
-* Attach event listeners to `.hooks` before calling `setup()` or `build()`.
+* Attach hook listeners to `.hooks` before calling `setup()` or `build()`.
 *
 * @example
 * ```ts
 * const kubb = createKubb(userConfig)
-* kubb.hooks.on('kubb:plugin:end', ({ plugin, duration }) => console.log(plugin.name, duration))
+* kubb.hooks.hook('kubb:plugin:end', ({ plugin, duration }) => console.log(plugin.name, duration))
 * const { files, diagnostics } = await kubb.safeBuild()
 * ```
 */
@@ -2246,7 +1928,7 @@ var Kubb = class {
 	#storage = null;
 	constructor(userConfig, options = {}) {
 		this.config = resolveConfig(userConfig);
-		this.hooks = options.hooks ?? new AsyncEventEmitter();
+		this.hooks = options.hooks ?? new Hookable();
 	}
 	get storage() {
 		if (!this.#storage) throw new Error("[kubb] setup() must be called before accessing storage");
@@ -2262,12 +1944,11 @@ var Kubb = class {
 	async setup() {
 		const config = this.config;
 		const driver = new KubbDriver(config, { hooks: this.hooks });
-		const storage = createSourcesView(config.storage);
 		this.hooks.setMaxListeners(Math.max(10, config.plugins.length * 4));
 		if (config.output.clean) await config.storage.clear(resolve(config.root, config.output.path));
 		await driver.setup();
 		this.#driver = driver;
-		this.#storage = storage;
+		this.#storage = config.storage;
 	}
 	/**
 	* Runs the full pipeline and throws on any plugin error.
@@ -2290,9 +1971,9 @@ var Kubb = class {
 		try {
 			var _usingCtx$1 = _usingCtx();
 			if (!this.#driver) await this.setup();
-			const cleanup = _usingCtx$1.u(this);
-			const driver = cleanup.driver;
-			const storage = cleanup.storage;
+			const self = _usingCtx$1.u(this);
+			const driver = self.driver;
+			const storage = self.storage;
 			const { diagnostics } = await driver.run({ storage });
 			return {
 				diagnostics,
@@ -2353,7 +2034,7 @@ const logLevel = {
 /**
 * Defines a reporter. When the definition has a `drain`, the returned reporter buffers each value
 * `report` returns and hands the array to `drain` once, then clears it. Without a `drain`, nothing
-* is buffered. Wiring the reporter onto the run's events is the host's job, so the reporter only
+* is buffered. Wiring the reporter onto the run's hooks is the host's job, so the reporter only
 * ever deals with a {@link GenerationResult}.
 *
 * @example
@@ -2372,22 +2053,19 @@ const logLevel = {
 * ```
 */
 function createReporter(reporter) {
-	const drain = reporter.drain;
-	if (!drain) return {
-		name: reporter.name,
-		async report(result, context) {
-			await reporter.report(result, context);
-		}
-	};
-	const reports = [];
+	const reports = /* @__PURE__ */ new Set();
 	return {
 		name: reporter.name,
 		async report(result, context) {
-			reports.push(await reporter.report(result, context));
+			const report = await reporter.report(result, context);
+			reports.add(report);
 		},
 		async drain(context) {
-			await drain(context, reports);
-			reports.length = 0;
+			await reporter.drain?.(context, Array.from(reports));
+			reports.clear();
+		},
+		[Symbol.dispose]() {
+			reports.clear();
 		}
 	};
 }
@@ -2540,7 +2218,7 @@ function buildTimingSection(report) {
 * `## Timings` section. Selected with `--reporter file` (or `reporters: ['file']`).
 *
 * @note It captures the collected diagnostics once a config finishes, not the live
-* `kubb:info`/`kubb:plugin` event stream. Color is stripped so the file stays plain text even when
+* `kubb:info`/`kubb:plugin` hook stream. Color is stripped so the file stays plain text even when
 * the run is attached to a TTY.
 */
 const fileReporter = createReporter({
@@ -2678,6 +2356,56 @@ function defineParser(parser) {
 	return parser;
 }
 //#endregion
-export { AsyncEventEmitter, Diagnostics, KubbDriver, Url, cliReporter, createAdapter, createKubb, createRenderer, createReporter, createStorage, defineGenerator, defineParser, definePlugin, defineResolver, fileReporter, fsStorage, jsonReporter, logLevel, memoryStorage };
+//#region src/storages/memoryStorage.ts
+/**
+* In-memory storage driver. Useful for testing and dry-run scenarios where
+* generated output should be captured without touching the filesystem.
+*
+* All data lives in a `Map` scoped to the storage instance and is discarded
+* when the instance is garbage-collected.
+*
+* @example
+* ```ts
+* import { memoryStorage } from '@kubb/core'
+* import { defineConfig } from 'kubb'
+*
+* export default defineConfig({
+*   input:  { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   storage: memoryStorage(),
+* })
+* ```
+*/
+const memoryStorage = createStorage(() => {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		name: "memory",
+		async hasItem(key) {
+			return store.has(key);
+		},
+		async getItem(key) {
+			return store.get(key) ?? null;
+		},
+		async setItem(key, value) {
+			store.set(key, value);
+		},
+		async removeItem(key) {
+			store.delete(key);
+		},
+		async getKeys(base) {
+			const keys = [...store.keys()];
+			return base ? keys.filter((k) => k.startsWith(base)) : keys;
+		},
+		async clear(base) {
+			if (!base) {
+				store.clear();
+				return;
+			}
+			for (const key of store.keys()) if (key.startsWith(base)) store.delete(key);
+		}
+	};
+});
+//#endregion
+export { Diagnostics, Hookable, KubbDriver, Resolver, cliReporter, createAdapter, createKubb, createRenderer, createReporter, createResolver, createStorage, defineGenerator, defineParser, definePlugin, fileReporter, fsStorage, jsonReporter, logLevel, memoryStorage };
 
 //# sourceMappingURL=index.js.map