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

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_usingCtx = require("./usingCtx-fxRpJw0P.cjs");
+const require_usingCtx = require("./usingCtx-BN2OKJRx.cjs");
 let node_async_hooks = require("node:async_hooks");
 let node_util = require("node:util");
 let node_crypto = require("node:crypto");
@@ -172,7 +172,7 @@ function memoize(store, factory) {
 }
 //#endregion
 //#region package.json
-var version = "5.0.0-beta.85";
+var version = "5.0.0-beta.86";
 //#endregion
 //#region src/constants.ts
 /**
@@ -519,12 +519,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}
@@ -742,7 +742,7 @@ function definePlugin(factory) {
 	return (options) => factory(options ?? {});
 }
 //#endregion
-//#region src/createResolver.ts
+//#region src/Resolver.ts
 function isNamespace(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -806,7 +806,7 @@ var Resolver = class Resolver {
 	*/
 	static merge(base, override) {
 		const patch = override instanceof Resolver ? override.#options : override;
-		return createResolver({
+		return new Resolver({
 			...base.#options,
 			...patch
 		});
@@ -998,6 +998,8 @@ var Resolver = class Resolver {
 		return Resolver.#resolveUserText(output?.footer, meta, file) ?? null;
 	}
 };
+//#endregion
+//#region src/createResolver.ts
 /**
 * 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,
@@ -1103,35 +1105,7 @@ const ENFORCE_ORDER = {
 	pre: -1,
 	post: 1
 };
-/**
-* 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`.
-*/
-function sortPlugins(plugins) {
-	const queue = [...plugins].sort((a, b) => (a.enforce ? ENFORCE_ORDER[a.enforce] : 0) - (b.enforce ? ENFORCE_ORDER[b.enforce] : 0));
-	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 = [];
-	while (queue.length > 0) {
-		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;
-}
+const enforceWeight = (plugin) => plugin.enforce ? ENFORCE_ORDER[plugin.enforce] : 0;
 var KubbDriver = class {
 	config;
 	options;
@@ -1153,17 +1127,17 @@ var KubbDriver = class {
 	fileManager = new require_usingCtx.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`.
@@ -1175,52 +1149,67 @@ 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 = sortPlugins(this.config.plugins.map((rawPlugin) => this.#normalizePlugin(rawPlugin)));
+		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) {
 			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. Registering its lifecycle handlers on the `AsyncEventEmitter` is
-	* done separately by `#registerPlugin`.
-	*/
-	#normalizePlugin(plugin) {
-		return {
-			name: plugin.name,
-			dependencies: plugin.dependencies,
-			enforce: plugin.enforce,
-			hooks: plugin.hooks,
-			options: plugin.options ?? {
-				output: {
-					path: ".",
-					mode: "directory"
-				},
-				exclude: [],
-				override: []
-			}
-		};
-	}
-	/**
 	* Parses the adapter source into `this.inputNode`. Idempotent, so repeated calls from
 	* `run` do not re-parse.
 	*/
@@ -1229,86 +1218,68 @@ var KubbDriver = class {
 		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(_kubb_ast.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(_kubb_ast.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`
@@ -1321,9 +1292,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({
@@ -1331,22 +1302,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`.
 	*
-	* Used by the build loop to decide whether to walk the AST and emit generator events
+	* 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
@@ -1360,29 +1332,31 @@ var KubbDriver = class {
 		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 onWriteStart = async (files) => {
-			await hooks.emit("kubb:files:processing:start", { files });
+			await hooks.callHook("kubb:files:processing:start", { files });
 		};
 		const updateBuffer = [];
 		const onWriteUpdate = (item) => {
 			updateBuffer.push(item);
 		};
 		const onWriteEnd = async (files) => {
-			await hooks.emit("kubb:files:processing:update", { files: updateBuffer.map((item) => ({
+			await hooks.callHook("kubb:files:processing:update", { files: updateBuffer.map((item) => ({
 				...item,
 				config
 			})) });
 			updateBuffer.length = 0;
-			await hooks.emit("kubb:files:processing:end", { files });
+			await hooks.callHook("kubb:files:processing:end", { files });
 		};
-		fileManager.hooks.on("start", onWriteStart);
-		fileManager.hooks.on("update", onWriteUpdate);
-		fileManager.hooks.on("end", onWriteEnd);
+		const unhookWrites = fileManager.hooks.addHooks({
+			start: onWriteStart,
+			update: onWriteUpdate,
+			end: onWriteEnd
+		});
 		return Diagnostics.scope((diagnostic) => diagnostics.push(diagnostic), async () => {
 			try {
 				const outputRoot = (0, node_path.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,
@@ -1393,9 +1367,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 = require_usingCtx.toError(caughtError);
 						const duration = getElapsedMs(hrStart);
 						await this.#emitPluginEnd({
 							plugin,
@@ -1412,7 +1386,7 @@ var KubbDriver = class {
 						}));
 						continue;
 					}
-					if (this.hasEventGenerators(plugin.name)) {
+					if (this.hasHookGenerators(plugin.name)) {
 						generatorPlugins.push({
 							plugin,
 							context,
@@ -1432,13 +1406,13 @@ var KubbDriver = class {
 					});
 				}
 				diagnostics.push(...await this.#runGenerators(generatorPlugins));
-				await hooks.emit("kubb:plugins:end", Object.assign({ config }, this.#filesPayload()));
+				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.emit("kubb:build:end", {
+				await hooks.callHook("kubb:build:end", {
 					files: this.fileManager.files,
 					config,
 					outputDir: outputRoot
@@ -1448,9 +1422,7 @@ var KubbDriver = class {
 				diagnostics.push(Diagnostics.from(caughtError));
 				return { diagnostics: Diagnostics.dedupe(diagnostics) };
 			} finally {
-				fileManager.hooks.off("start", onWriteStart);
-				fileManager.hooks.off("update", onWriteUpdate);
-				fileManager.hooks.off("end", onWriteEnd);
+				unhookWrites();
 			}
 		});
 	}
@@ -1464,7 +1436,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,
@@ -1557,12 +1529,12 @@ var KubbDriver = class {
 					if (!resolved) continue;
 					const { transformedNode, options } = resolved;
 					if (allowedSchemaNames !== null && transformedNode.name && !allowedSchemaNames.has(transformedNode.name)) continue;
-					await this.hooks.emit("kubb:generate:schema", transformedNode, {
+					await this.hooks.callHook("kubb:generate:schema", transformedNode, {
 						...generatorContext,
 						options
 					});
 				} catch (caughtError) {
-					error = caughtError;
+					error = require_usingCtx.toError(caughtError);
 				}
 			}
 			if (emitsOperationHook) for (const node of operations) {
@@ -1570,12 +1542,12 @@ var KubbDriver = class {
 				try {
 					const resolved = resolveForPlugin(node);
 					if (!resolved) continue;
-					await this.hooks.emit("kubb:generate:operation", resolved.transformedNode, {
+					await this.hooks.callHook("kubb:generate:operation", resolved.transformedNode, {
 						...generatorContext,
 						options: resolved.options
 					});
 				} catch (caughtError) {
-					error = caughtError;
+					error = require_usingCtx.toError(caughtError);
 				}
 			}
 			if (!error && emitsOperationsHook) try {
@@ -1588,9 +1560,9 @@ var KubbDriver = class {
 					if (resolved) acc.push(resolved.transformedNode);
 					return acc;
 				}, []);
-				await this.hooks.emit("kubb:generate:operations", pluginOperations, ctx);
+				await this.hooks.callHook("kubb:generate:operations", pluginOperations, ctx);
 			} catch (caughtError) {
-				error = caughtError;
+				error = require_usingCtx.toError(caughtError);
 			}
 			const duration = getElapsedMs(hrStart);
 			await this.#emitPluginEnd({
@@ -1647,9 +1619,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();
@@ -1742,18 +1714,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) {
@@ -1942,12 +1914,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()
 * ```
 */
@@ -1958,7 +1930,7 @@ var Kubb = class {
 	#storage = null;
 	constructor(userConfig, options = {}) {
 		this.config = resolveConfig(userConfig);
-		this.hooks = options.hooks ?? new require_usingCtx.AsyncEventEmitter();
+		this.hooks = options.hooks ?? new require_usingCtx.Hookable();
 	}
 	get storage() {
 		if (!this.#storage) throw new Error("[kubb] setup() must be called before accessing storage");
@@ -2001,9 +1973,9 @@ var Kubb = class {
 		try {
 			var _usingCtx$1 = require_usingCtx._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,
@@ -2064,7 +2036,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
@@ -2248,7 +2220,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({
@@ -2436,8 +2408,8 @@ const memoryStorage = createStorage(() => {
 	};
 });
 //#endregion
-exports.AsyncEventEmitter = require_usingCtx.AsyncEventEmitter;
 exports.Diagnostics = Diagnostics;
+exports.Hookable = require_usingCtx.Hookable;
 exports.KubbDriver = KubbDriver;
 exports.Resolver = Resolver;
 exports.cliReporter = cliReporter;