@kubb/core 5.0.0-beta.100 → 5.0.0-beta.101

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { $ as definePlugin, A as Generator, At as DiagnosticSeverity, B as Include, Bt as AdapterSource, C as KubbWarnContext, Ct as UserReporter, D as CreateKubbOptions, Dt as DiagnosticDoc, E as UserConfig, Et as Diagnostic, F as Parser, Ft as SerializedDiagnostic, G as Output, H as KubbPluginSetupContext, I as defineParser, It as UpdateDiagnostic, J as Override, K as OutputMode, L as Exclude, Lt as Hookable, M as defineGenerator, Mt as PerformanceDiagnostic, N as KubbDriver, Nt as ProblemCode, O as Kubb, Ot as DiagnosticKind, P as FileManagerHooks, Pt as ProblemDiagnostic, Q as ResolvePluginOptions, R as Filter, Rt as Adapter, S as KubbSuccessContext, St as ReporterName, T as PostGenerateCommand, Tt as logLevel, U as KubbPluginStartContext, V as KubbPluginEndContext, Vt as createAdapter, W as NormalizedPlugin, X as PluginFactoryOptions, Y as Plugin, Z as PluginName, _ as KubbHookStartContext, _t as Storage, a as KubbBuildEndContext, at as ResolveOptionsContext, b as KubbLifecycleStartContext, bt as Reporter, c as KubbErrorContext, ct as ResolverDefault, d as KubbFilesProcessingStartContext, dt as ResolverFilePathParams, et as BannerMeta, f as KubbFilesProcessingUpdateContext, ft as ResolverPatch, g as KubbHookLineContext, gt as createRenderer, h as KubbHookEndContext, ht as RendererFactory, i as Input, it as ResolveImportsOptions, j as GeneratorContext, jt as Diagnostics, k as createKubb, kt as DiagnosticLocation, l as KubbFileProcessingUpdate, lt as ResolverFile, m as KubbGenerationStartContext, mt as Renderer, n as CLIOptions, nt as ResolveBannerFile, o as KubbBuildStartContext, ot as ResolvePathOptions, p as KubbGenerationEndContext, pt as ResolverPathParams, q as OutputOptions, r as Config, rt as ResolveFileOptions, s as KubbDiagnosticContext, st as Resolver, t as BuildOutput, tt as ResolveBannerContext, u as KubbFilesProcessingEndContext, ut as ResolverFileParams, v as KubbHooks, vt as createStorage, w as PossibleConfig, wt as createReporter, x as KubbPluginsEndContext, xt as ReporterContext, y as KubbInfoContext, yt as GenerationResult, z as Group, zt as AdapterFactoryOptions } from "./types-DM7-MGjZ.js";
+import { $ as PluginName, A as Kubb, At as DiagnosticKind, B as Filter, Bt as Adapter, C as KubbWarnContext, Ct as ReporterContext, D as CreateKubbOptions, Dt as logLevel, E as UserConfig, Et as createReporter, F as KubbDriver, Ft as ProblemCode, G as KubbPluginStartContext, H as Include, Ht as AdapterSource, I as FileManagerHooks, It as ProblemDiagnostic, J as OutputMode, K as NormalizedPlugin, L as Parser, Lt as SerializedDiagnostic, M as Generator, Mt as DiagnosticSeverity, N as GeneratorContext, Nt as Diagnostics, O as GenerateOptions, Ot as Diagnostic, P as defineGenerator, Pt as PerformanceDiagnostic, Q as PluginFactoryOptions, R as defineParser, Rt as UpdateDiagnostic, S as KubbSuccessContext, St as Reporter, T as PostGenerateCommand, Tt as UserReporter, U as KubbPluginEndContext, Ut as createAdapter, V as Group, Vt as AdapterFactoryOptions, W as KubbPluginSetupContext, X as Override, Y as OutputOptions, Z as Plugin, _ as KubbHookStartContext, _t as RendererFactory, a as KubbBuildEndContext, at as ResolveFileOptions, b as KubbLifecycleStartContext, bt as createStorage, c as KubbErrorContext, ct as ResolvePathOptions, d as KubbFilesProcessingStartContext, dt as ResolverFile, et as ResolvePluginOptions, f as KubbFilesProcessingUpdateContext, ft as ResolverFileParams, g as KubbHookLineContext, gt as Renderer, h as KubbHookEndContext, ht as ResolverPathParams, i as Input, it as ResolveBannerFile, j as createKubb, jt as DiagnosticLocation, k as GenerateResult, kt as DiagnosticDoc, l as KubbFileProcessingUpdate, lt as Resolver, m as KubbGenerationStartContext, mt as ResolverPatch, n as CLIOptions, nt as BannerMeta, o as KubbBuildStartContext, ot as ResolveImportsOptions, p as KubbGenerationEndContext, pt as ResolverFilePathParams, q as Output, r as Config, rt as ResolveBannerContext, s as KubbDiagnosticContext, st as ResolveOptionsContext, t as BuildOutput, tt as definePlugin, u as KubbFilesProcessingEndContext, ut as ResolverDefault, v as KubbHooks, vt as createRenderer, w as PossibleConfig, wt as ReporterName, x as KubbPluginsEndContext, xt as GenerationResult, y as KubbInfoContext, yt as Storage, z as Exclude, zt as Hookable } from "./types-B14Ba9P7.js";
 //#region src/applyConfigDefaults.d.ts
 type ApplyConfigDefaultsOptions<TOutput> = {
   defaultAdapter: Adapter;
@@ -183,5 +183,5 @@ declare const fsStorage: (options?: Record<string, never> | undefined) => Storag
  */
 declare const memoryStorage: (options?: Record<string, never> | undefined) => Storage;
 //#endregion
-export { type Adapter, type AdapterFactoryOptions, type AdapterSource, type BannerMeta, BuildOutput, CLIOptions, Config, type CreateKubbOptions, type Diagnostic, type DiagnosticDoc, type DiagnosticKind, type DiagnosticLocation, type DiagnosticSeverity, Diagnostics, type Exclude, type FileManagerHooks, type Filter, type GenerationResult, type Generator, type GeneratorContext, type Group, Hookable, type Include, Input, type InputKind, type Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbDiagnosticContext, KubbDriver, KubbErrorContext, KubbFileProcessingUpdate, KubbFilesProcessingEndContext, KubbFilesProcessingStartContext, KubbFilesProcessingUpdateContext, KubbGenerationEndContext, KubbGenerationStartContext, KubbHookEndContext, KubbHookLineContext, KubbHookStartContext, KubbHooks, KubbInfoContext, KubbLifecycleStartContext, type KubbPluginEndContext, type KubbPluginSetupContext, type KubbPluginStartContext, KubbPluginsEndContext, KubbSuccessContext, KubbWarnContext, type NormalizedPlugin, type Output, type OutputMode, type OutputOptions, type Override, type Parser, type PerformanceDiagnostic, type Plugin, type PluginFactoryOptions, type PluginName, PossibleConfig, PostGenerateCommand, type ProblemCode, type ProblemDiagnostic, type Renderer, type RendererFactory, type Reporter, type ReporterContext, type ReporterName, type ResolveBannerContext, type ResolveBannerFile, type ResolveFileOptions, type ResolveImportsOptions, type ResolveOptionsContext, type ResolvePathOptions, type ResolvePluginOptions, Resolver, type ResolverDefault, type ResolverFile, type ResolverFileParams, type ResolverFilePathParams, type ResolverPatch, type ResolverPathParams, type SerializedDiagnostic, type Storage, type UpdateDiagnostic, UserConfig, type UserReporter, applyConfigDefaults, cliReporter, createAdapter, createKubb, createRenderer, createReporter, createResolver, createStorage, defineGenerator, defineParser, definePlugin, fileReporter, fsStorage, getInputKind, jsonReporter, logLevel, memoryStorage };
+export { type Adapter, type AdapterFactoryOptions, type AdapterSource, type BannerMeta, BuildOutput, CLIOptions, Config, type CreateKubbOptions, type Diagnostic, type DiagnosticDoc, type DiagnosticKind, type DiagnosticLocation, type DiagnosticSeverity, Diagnostics, type Exclude, type FileManagerHooks, type Filter, type GenerateOptions, type GenerateResult, type GenerationResult, type Generator, type GeneratorContext, type Group, Hookable, type Include, Input, type InputKind, type Kubb, KubbBuildEndContext, KubbBuildStartContext, KubbDiagnosticContext, KubbDriver, KubbErrorContext, KubbFileProcessingUpdate, KubbFilesProcessingEndContext, KubbFilesProcessingStartContext, KubbFilesProcessingUpdateContext, KubbGenerationEndContext, KubbGenerationStartContext, KubbHookEndContext, KubbHookLineContext, KubbHookStartContext, KubbHooks, KubbInfoContext, KubbLifecycleStartContext, type KubbPluginEndContext, type KubbPluginSetupContext, type KubbPluginStartContext, KubbPluginsEndContext, KubbSuccessContext, KubbWarnContext, type NormalizedPlugin, type Output, type OutputMode, type OutputOptions, type Override, type Parser, type PerformanceDiagnostic, type Plugin, type PluginFactoryOptions, type PluginName, PossibleConfig, PostGenerateCommand, type ProblemCode, type ProblemDiagnostic, type Renderer, type RendererFactory, type Reporter, type ReporterContext, type ReporterName, type ResolveBannerContext, type ResolveBannerFile, type ResolveFileOptions, type ResolveImportsOptions, type ResolveOptionsContext, type ResolvePathOptions, type ResolvePluginOptions, Resolver, type ResolverDefault, type ResolverFile, type ResolverFileParams, type ResolverFilePathParams, type ResolverPatch, type ResolverPathParams, type SerializedDiagnostic, type Storage, type UpdateDiagnostic, UserConfig, type UserReporter, applyConfigDefaults, cliReporter, createAdapter, createKubb, createRenderer, createReporter, createResolver, createStorage, defineGenerator, defineParser, definePlugin, fileReporter, fsStorage, getInputKind, jsonReporter, logLevel, memoryStorage };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -148,48 +148,8 @@ function randomCliColor(text) {
 	return styleText(randomColors[index] ?? "white", text);
 }
 //#endregion
-//#region ../../internals/utils/src/promise.ts
-/**
-* Wraps `factory` with a keyed cache backed by the provided store.
-*
-* Pass a `WeakMap` for object keys (results are GC-eligible when the key is
-* collected) or a `Map` for primitive keys. For multi-argument functions,
-* nest two `memoize` calls — the outer keyed by the first argument, the
-* inner (created once per outer miss) keyed by the second.
-*
-* Because the cache is owned by the caller, it can be shared, inspected, or
-* cleared independently of the memoized function.
-*
-* @example Single WeakMap key
-* ```ts
-* const cache = new WeakMap<SchemaNode, Set<string>>()
-* const getRefs = memoize(cache, (node) => collectRefs(node))
-* ```
-*
-* @example Single Map key (primitive)
-* ```ts
-* const cache = new Map<string, Resolver>()
-* const getResolver = memoize(cache, (name) => buildResolver(name))
-* ```
-*
-* @example Two-level (object + primitive)
-* ```ts
-* const outer = new WeakMap<Params[], Map<string, Params[]>>()
-* const fn = memoize(outer, (params) => memoize(new Map(), (key) => transform(params, key)))
-* fn(params)('camelcase')
-* ```
-*/
-function memoize(store, factory) {
-	return (key) => {
-		if (store.has(key)) return store.get(key);
-		const value = factory(key);
-		store.set(key, value);
-		return value;
-	};
-}
-//#endregion
 //#region package.json
-var version = "5.0.0-beta.100";
+var version = "5.0.0-beta.101";
 //#endregion
 //#region src/constants.ts
 /**
@@ -1286,6 +1246,38 @@ const ENFORCE_ORDER = {
 	post: 1
 };
 const enforceWeight = (plugin) => plugin.enforce ? ENFORCE_ORDER[plugin.enforce] : 0;
+/**
+* The options bag a `NormalizedPlugin` starts with before a plugin refines it: a directory output
+* at the plugin root and empty filter lists.
+*/
+function defaultPluginOptions() {
+	return {
+		output: {
+			path: ".",
+			mode: "directory"
+		},
+		exclude: [],
+		override: []
+	};
+}
+/**
+* Fills in the `output`, `exclude`, and `override` a `NormalizedPlugin` needs from a plugin's raw
+* options, running `output` through `normalizeOutput`. Idempotent, so the driver can apply it after
+* `setOptions` has already run without disturbing an already-normalized bag.
+*/
+function normalizePluginOptions(rawOptions, pluginName) {
+	const options = {
+		...defaultPluginOptions(),
+		...rawOptions ?? {}
+	};
+	const group = "group" in options ? options.group : void 0;
+	options.output = normalizeOutput({
+		output: options.output,
+		group,
+		pluginName
+	});
+	return options;
+}
 var KubbDriver = class {
 	config;
 	options;
@@ -1307,13 +1299,6 @@ var KubbDriver = class {
 	fileManager = new FileManager();
 	plugins = /* @__PURE__ */ new Map();
 	/**
-	* 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.
-	*/
-	#hookGeneratorPlugins = /* @__PURE__ */ new Set();
-	#resolvers = /* @__PURE__ */ new Map();
-	#defaultResolvers = /* @__PURE__ */ new Map();
-	/**
 	* Removers for every listener the driver added (plugin, generator) so `dispose()` can detach
 	* them in one pass. External `hooks.hook(...)` listeners are not tracked.
 	*/
@@ -1341,15 +1326,8 @@ var KubbDriver = class {
 				dependencies: rawPlugin.dependencies,
 				enforce: rawPlugin.enforce,
 				hooks: rawPlugin.hooks,
-				options: rawPlugin.options ?? {
-					output: {
-						path: ".",
-						mode: "directory"
-					},
-					exclude: [],
-					override: []
-				},
-				resolver: this.#getDefaultResolver(rawPlugin.name)
+				options: rawPlugin.options ?? defaultPluginOptions(),
+				resolver: createResolver({ pluginName: rawPlugin.name })
 			};
 		}));
 		for (const plugin of normalized) {
@@ -1458,46 +1436,30 @@ var KubbDriver = class {
 		}
 	}
 	/**
-	* Registers a generator for the given plugin on the shared hook emitter.
+	* Appends a generator to its owning plugin so the generate loop can call it directly.
 	*
-	* The generator's `schema`, `operation`, and `operations` methods are registered as
-	* listeners on `kubb:generate:schema`, `kubb:generate:operation`, and `kubb:generate:operations`
-	* respectively. Each listener is scoped to the owning plugin via a `ctx.plugin.name` check
-	* so that generators from different plugins do not cross-fire.
-	*
-	* The renderer comes from `generator.renderer`. Set `generator.renderer = null` (or leave it
-	* unset) to opt out of rendering.
+	* The generator's `schema`, `operation`, and `operations` methods run per node during the AST
+	* walk in `#runGenerators`, and their result is routed through `dispatch`. Because a generator is
+	* bound to a plugin, generators from different plugins never cross-fire without a name check. The
+	* renderer comes from `generator.renderer`; set it to `null` (or leave it unset) to opt out of
+	* rendering.
 	*
 	* Call this method inside `addGenerator()` (in `kubb:plugin:setup`) to wire up a generator.
 	*/
 	registerGenerator(pluginName, generator) {
-		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({
-					result,
-					renderer: generator.renderer
-				});
-			};
-		};
-		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);
+		const plugin = this.plugins.get(pluginName);
+		if (!plugin) return;
+		plugin.generators = plugin.generators ? [...plugin.generators, generator] : [generator];
 	}
 	/**
 	* 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 hooks
+	* Used by the build loop to decide whether to walk the AST and run the generators
 	* for a plugin.
 	*/
 	hasHookGenerators(pluginName) {
-		return this.#hookGeneratorPlugins.has(pluginName);
+		return (this.plugins.get(pluginName)?.generators?.length ?? 0) > 0;
 	}
 	/**
 	* Runs the full plugin pipeline. Returns the diagnostics collected so far even
@@ -1532,12 +1494,16 @@ var KubbDriver = class {
 				const outputRoot = resolve(config.root, config.output.path);
 				await this.#parseInput();
 				await this.setupHooks();
-				if (this.adapter && this.inputNode) await hooks.callHook("kubb:build:start", Object.assign({
-					config,
-					adapter: this.adapter,
-					meta: this.inputNode.meta,
-					getPlugin: this.getPlugin.bind(this)
-				}, this.#filesPayload()));
+				for (const plugin of this.plugins.values()) plugin.options = normalizePluginOptions(plugin.options, plugin.name);
+				if (this.adapter && this.inputNode) {
+					const buildStartContext = this.#withFiles({
+						config,
+						adapter: this.adapter,
+						meta: this.inputNode.meta,
+						getPlugin: this.getPlugin.bind(this)
+					});
+					await hooks.callHook("kubb:build:start", buildStartContext);
+				}
 				const generatorPlugins = [];
 				for (const plugin of this.plugins.values()) {
 					const context = this.getContext(plugin);
@@ -1582,7 +1548,7 @@ var KubbDriver = class {
 					});
 				}
 				diagnostics.push(...await this.#runGenerators(generatorPlugins));
-				await hooks.callHook("kubb:plugins:end", Object.assign({ config }, this.#filesPayload()));
+				await hooks.callHook("kubb:plugins:end", this.#withFiles({ config }));
 				await fileManager.write(fileManager.files, {
 					storage: config.storage,
 					parsers: parsersMap
@@ -1601,23 +1567,26 @@ var KubbDriver = class {
 			}
 		});
 	}
-	#filesPayload() {
-		const driver = this;
+	/**
+	* Widens `extra` with the files present at emit time and a bound `upsertFile`, the shape every
+	* file-carrying hook context shares. Building it here in one place keeps the `files` and
+	* `upsertFile` keys from being dropped by a stray spread at the call site.
+	*/
+	#withFiles(extra) {
 		return {
-			get files() {
-				return driver.fileManager.files;
-			},
-			upsertFile: (...files) => driver.fileManager.upsert(...files)
+			...extra,
+			files: this.fileManager.files,
+			upsertFile: (...files) => this.fileManager.upsert(...files)
 		};
 	}
 	#emitPluginEnd({ plugin, duration, success, error }) {
-		return this.hooks.callHook("kubb:plugin:end", Object.assign({
+		return this.hooks.callHook("kubb:plugin:end", this.#withFiles({
 			plugin,
 			duration,
 			success,
 			...error ? { error } : {},
 			config: this.config
-		}, this.#filesPayload()));
+		}));
 	}
 	/**
 	* Runs schemas and operations through every plugin's generators. Each node is run
@@ -1654,9 +1623,6 @@ var KubbDriver = class {
 		}
 		const transforms = this.#transforms;
 		const { schemas, operations } = this.inputNode;
-		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 allowedSchemaNamesByPlugin = /* @__PURE__ */ new Map();
 		for (const { plugin } of entries) {
 			const { exclude, include, override } = plugin.options;
@@ -1678,6 +1644,10 @@ var KubbDriver = class {
 			const { exclude, include, override } = plugin.options;
 			const optionsAreStatic = !exclude?.length && !include?.length && !override?.length;
 			const allowedSchemaNames = allowedSchemaNamesByPlugin.get(plugin.name) ?? null;
+			const generators = plugin.generators ?? [];
+			const schemaGenerators = generators.filter((generator) => generator.schema);
+			const operationGenerators = generators.filter((generator) => generator.operation);
+			const operationsGenerators = generators.filter((generator) => generator.operations);
 			let error = null;
 			const resolveForPlugin = (node) => {
 				const transformedNode = transforms.applyTo(plugin.name, node);
@@ -1697,44 +1667,57 @@ var KubbDriver = class {
 					options
 				};
 			};
-			if (emitsSchemaHook) for (const node of schemas) {
+			if (schemaGenerators.length) 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, {
+					const ctx = {
 						...generatorContext,
 						options
+					};
+					for (const generator of schemaGenerators) await this.dispatch({
+						result: await generator.schema(transformedNode, ctx),
+						renderer: generator.renderer
 					});
+					await this.hooks.callHook("kubb:generate:schema", transformedNode, ctx);
 				} catch (caughtError) {
 					error = toError(caughtError);
 				}
 			}
-			if (emitsOperationHook) for (const node of operations) {
+			const pluginOperations = [];
+			if (operationGenerators.length || operationsGenerators.length) 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
-					});
+					pluginOperations.push(resolved.transformedNode);
+					if (operationGenerators.length) {
+						const ctx = {
+							...generatorContext,
+							options: resolved.options
+						};
+						for (const generator of operationGenerators) await this.dispatch({
+							result: await generator.operation(resolved.transformedNode, ctx),
+							renderer: generator.renderer
+						});
+						await this.hooks.callHook("kubb:generate:operation", resolved.transformedNode, ctx);
+					}
 				} catch (caughtError) {
 					error = toError(caughtError);
 				}
 			}
-			if (!error && emitsOperationsHook) try {
+			if (!error && operationsGenerators.length) try {
 				const ctx = {
 					...generatorContext,
 					options: plugin.options
 				};
-				const pluginOperations = operations.reduce((acc, node) => {
-					const resolved = resolveForPlugin(node);
-					if (resolved) acc.push(resolved.transformedNode);
-					return acc;
-				}, []);
+				for (const generator of operationsGenerators) await this.dispatch({
+					result: await generator.operations(pluginOperations, ctx),
+					renderer: generator.renderer
+				});
 				await this.hooks.callHook("kubb:generate:operations", pluginOperations, ctx);
 			} catch (caughtError) {
 				error = toError(caughtError);
@@ -1796,10 +1779,7 @@ var KubbDriver = class {
 	dispose() {
 		for (const unhook of this.#unhooks) unhook();
 		this.#unhooks.length = 0;
-		this.#hookGeneratorPlugins.clear();
 		this.#transforms.dispose();
-		this.#resolvers.clear();
-		this.#defaultResolvers.clear();
 		this.fileManager.dispose();
 		this.inputNode = null;
 		this.#adapterSource = null;
@@ -1807,21 +1787,17 @@ var KubbDriver = class {
 	[Symbol.dispose]() {
 		this.dispose();
 	}
-	#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()`.
+	* Merges `partial` onto a fresh default resolver and stores the result on `plugin.resolver`,
+	* which is the single source `getResolver` and `getPlugin(name).resolver` both read.
 	*/
 	setPluginResolver(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;
+		if (!plugin) return;
+		plugin.resolver = Resolver.merge(createResolver({ pluginName }), partial);
 	}
 	getResolver(pluginName) {
-		return this.#resolvers.get(pluginName) ?? this.#getDefaultResolver(pluginName);
+		return this.plugins.get(pluginName)?.resolver ?? createResolver({ pluginName });
 	}
 	getContext(plugin) {
 		const driver = this;
@@ -2151,6 +2127,69 @@ var Kubb = class {
 			_usingCtx$1.d();
 		}
 	}
+	/**
+	* Run one build and its output passes end to end, emitting the surrounding `kubb:generation:*`
+	* hooks. Never throws on a build error: the outcome comes back in {@link GenerateResult} so the
+	* host decides how failures surface. Telemetry and progress narration stay with the host, which
+	* reads the result and subscribes to the `kubb:*` hooks.
+	*
+	* @example
+	* ```ts
+	* const result = await createKubb(config, { hooks }).generate()
+	* if (!result.success) process.exitCode = 1
+	* ```
+	*/
+	async generate(options = {}) {
+		const { hooks, config } = this;
+		const hrStart = process.hrtime();
+		await hooks.callHook("kubb:generation:start", { config });
+		await hooks.callHook("kubb:setup:start");
+		await this.setup();
+		await hooks.callHook("kubb:setup:end");
+		const { files, diagnostics, storage } = await this.safeBuild();
+		for (const diagnostic of diagnostics) {
+			if (!Diagnostics.isProblem(diagnostic)) continue;
+			if (diagnostic.code === Diagnostics.code.unknown) {
+				await hooks.callHook("kubb:error", { error: diagnostic.cause ?? new Error(diagnostic.message) });
+				continue;
+			}
+			await Diagnostics.emit(hooks, diagnostic);
+		}
+		if (Diagnostics.hasError(diagnostics)) {
+			await hooks.callHook("kubb:generation:end", {
+				config,
+				storage,
+				diagnostics,
+				filesCreated: files.length,
+				status: "failed",
+				hrStart
+			});
+			return {
+				success: false,
+				files,
+				diagnostics
+			};
+		}
+		const outputDiagnostics = options.processOutput ? await options.processOutput({
+			config,
+			outputPath: resolve(config.root, config.output.path)
+		}) : [];
+		const finalDiagnostics = [...diagnostics, ...outputDiagnostics];
+		const failed = Diagnostics.hasError(outputDiagnostics);
+		await hooks.callHook("kubb:generation:end", {
+			config,
+			storage,
+			diagnostics: finalDiagnostics,
+			filesCreated: files.length,
+			status: failed ? "failed" : "success",
+			hrStart
+		});
+		return {
+			success: !failed,
+			files,
+			diagnostics: finalDiagnostics
+		};
+	}
 	dispose() {
 		this.#driver?.dispose();
 	}