@kubb/core 5.0.0-beta.36 → 5.0.0-beta.38

package/dist/{KubbDriver-Dil5m3NF.cjs → KubbDriver-BYBUfOZ8.cjs}

@@ -28,6 +28,7 @@ let node_events = require("node:events");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
 let _kubb_ast = require("@kubb/ast");
+let node_async_hooks = require("node:async_hooks");
 let fflate = require("fflate");
 let tinyexec = require("tinyexec");
 //#region ../../internals/utils/src/errors.ts
@@ -62,6 +63,18 @@ var BuildError = class extends Error {
 function toError(value) {
 	return value instanceof Error ? value : new Error(String(value));
 }
+/**
+* Extracts a human-readable message from any thrown value.
+*
+* @example
+* ```ts
+* getErrorMessage(new Error('oops')) // 'oops'
+* getErrorMessage('plain string')    // 'plain string'
+* ```
+*/
+function getErrorMessage(value) {
+	return value instanceof Error ? value.message : String(value);
+}
 //#endregion
 //#region ../../internals/utils/src/asyncEventEmitter.ts
 /**
@@ -161,6 +174,24 @@ var AsyncEventEmitter = class {
 		return this.#emitter.listenerCount(eventName);
 	}
 	/**
+	* Raises or lowers the per-event listener ceiling before Node warns about a memory leak.
+	* Set this above the expected listener count when many listeners attach by design.
+	*
+	* @example
+	* ```ts
+	* emitter.setMaxListeners(40)
+	* ```
+	*/
+	setMaxListeners(max) {
+		this.#emitter.setMaxListeners(max);
+	}
+	/**
+	* Returns the current per-event listener ceiling.
+	*/
+	getMaxListeners() {
+		return this.#emitter.getMaxListeners();
+	}
+	/**
 	* Removes all listeners from every event channel.
 	*
 	* @example
@@ -254,21 +285,6 @@ function getElapsedMs(hrStart) {
 	const ms = seconds * 1e3 + nanoseconds / 1e6;
 	return Math.round(ms * 100) / 100;
 }
-/**
-* Converts a millisecond duration into a human-readable string (`ms`, `s`, or `m s`).
-*
-* @example
-* ```ts
-* formatMs(250)   // '250ms'
-* formatMs(1500)  // '1.50s'
-* formatMs(90000) // '1m 30.0s'
-* ```
-*/
-function formatMs(ms) {
-	if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
-	if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
-	return `${Math.round(ms)}ms`;
-}
 //#endregion
 //#region ../../internals/utils/src/promise.ts
 function* chunks(arr, size) {
@@ -636,13 +652,17 @@ var URLPath = class {
 */
 const DEFAULT_STUDIO_URL = "https://kubb.studio";
 /**
-* Default banner style written at the top of every generated file.
-*/
-const DEFAULT_BANNER = "simple";
-/**
-* Default file-extension mapping used when no explicit mapping is configured.
+* 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 DEFAULT_EXTENSION = { ".ts": ".ts" };
+const OPERATION_FILTER_TYPES = new Set([
+	"tag",
+	"operationId",
+	"path",
+	"method",
+	"contentType"
+]);
 /**
 * Numeric log-level thresholds used internally to compare verbosity.
 *
@@ -653,8 +673,453 @@ const logLevel = {
 	error: 0,
 	warn: 1,
 	info: 3,
-	verbose: 4,
-	debug: 5
+	verbose: 4
+};
+/**
+* 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.
+*/
+const diagnosticCode = {
+	/**
+	* Fallback for an unstructured error with no specific code.
+	*/
+	unknown: "KUBB_UNKNOWN",
+	/**
+	* The `input.path` file or URL could not be read.
+	*/
+	inputNotFound: "KUBB_INPUT_NOT_FOUND",
+	/**
+	* 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",
+	/**
+	* The `devtools` config is set to something other than an object.
+	*/
+	devtoolsInvalid: "KUBB_DEVTOOLS_INVALID",
+	/**
+	* 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 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/diagnostics.ts
+/**
+* Docs major, derived from the package version so the link tracks the published major.
+*/
+const docsMajor = "5.0.0-beta.38".split(".")[0] ?? "5";
+/**
+* Narrows a {@link Diagnostic} to the variant for `code`, or `null` when it does not match.
+*
+* @example
+* ```ts
+* const update = narrowDiagnostic(diagnostic, diagnosticCode.updateAvailable)
+* if (update) {
+*   console.log(update.latestVersion)
+* }
+* ```
+*/
+function narrowDiagnostic(diagnostic, code) {
+	return diagnostic.code === code ? diagnostic : null;
+}
+/**
+* Builds a type guard that narrows a {@link Diagnostic} to the variant for `kind`. A diagnostic
+* with no `kind` is treated as a `problem`.
+*/
+function isKind(kind) {
+	return (diagnostic) => (diagnostic.kind ?? "problem") === kind;
+}
+/**
+* Returns `true` when the diagnostic is a build {@link ProblemDiagnostic}.
+*
+* @example
+* ```ts
+* if (isProblemDiagnostic(diagnostic)) {
+*   console.log(diagnostic.location)
+* }
+* ```
+*/
+const isProblemDiagnostic = isKind("problem");
+/**
+* Returns `true` when the diagnostic is a per-plugin {@link PerformanceDiagnostic}.
+*
+* @example
+* ```ts
+* const timings = diagnostics.filter(isPerformanceDiagnostic)
+* ```
+*/
+const isPerformanceDiagnostic = isKind("performance");
+/**
+* Returns `true` when the diagnostic is a version-update {@link UpdateDiagnostic}.
+*
+* @example
+* ```ts
+* if (isUpdateDiagnostic(diagnostic)) {
+*   console.log(diagnostic.latestVersion)
+* }
+* ```
+*/
+const isUpdateDiagnostic = isKind("update");
+/**
+* An `Error` that carries a {@link Diagnostic}, so structured problems can flow
+* through the existing throw/catch paths while keeping their code and location.
+*
+* @example
+* ```ts
+* throw new DiagnosticError({ code: diagnosticCode.refNotFound, severity: 'error', message: `Could not find ${ref}`, location: { kind: 'schema', pointer: ref, ref } })
+* ```
+*/
+var DiagnosticError = class extends Error {
+	diagnostic;
+	constructor(diagnostic) {
+		super(diagnostic.message, { cause: diagnostic.cause });
+		this.name = "DiagnosticError";
+		this.diagnostic = diagnostic;
+	}
+};
+/**
+* Structural check for a {@link DiagnosticError}, including one thrown from a duplicated
+* `@kubb/core` copy where `instanceof` fails. Matches on the `name` and a `diagnostic`
+* that carries a `code`.
+*/
+function isDiagnosticError(error) {
+	if (error instanceof DiagnosticError) return true;
+	return error instanceof Error && error.name === "DiagnosticError" && "diagnostic" in error && typeof error.diagnostic === "object" && error.diagnostic !== null && typeof error.diagnostic?.code === "string";
+}
+/**
+* Explanation for every {@link diagnosticCode}. Use {@link Diagnostics.explain} to look one up
+* and `Diagnostics.docsUrl` for the matching kubb.dev page.
+*/
+const diagnosticCatalog = {
+	[diagnosticCode.unknown]: {
+		title: "Unknown error",
+		cause: "An error was thrown without a stable Kubb code, so it is reported as-is.",
+		fix: "Read the underlying message and stack. If it comes from a plugin or adapter, check its configuration; otherwise report it as a possible Kubb bug."
+	},
+	[diagnosticCode.inputNotFound]: {
+		title: "Input not found",
+		cause: "The file or URL set in `input.path` (or passed as `kubb generate PATH`) could not be read.",
+		fix: "Check that the path or URL exists and is readable, then set it in `input.path` or pass it on the CLI."
+	},
+	[diagnosticCode.inputRequired]: {
+		title: "Input required",
+		cause: "An adapter is configured but no `input` was provided.",
+		fix: "Set `input.path` (a file or URL) or `input.data` (an inline spec) in your Kubb config."
+	},
+	[diagnosticCode.refNotFound]: {
+		title: "Reference not found",
+		cause: "A `$ref` could not be resolved in the source document.",
+		fix: "Add the missing definition (for example under `components.schemas`) or fix the `$ref`. Run `kubb validate` to check the spec."
+	},
+	[diagnosticCode.invalidServerVariable]: {
+		title: "Invalid server variable",
+		cause: "A server variable value is not allowed by its `enum`.",
+		fix: "Use one of the values listed in the server variable `enum`, or update the spec."
+	},
+	[diagnosticCode.pluginNotFound]: {
+		title: "Plugin not found",
+		cause: "A plugin that another plugin depends on is missing from the config.",
+		fix: "Add the required plugin to the `plugins` array in kubb.config.ts, or remove the dependency on it."
+	},
+	[diagnosticCode.pluginFailed]: {
+		title: "Plugin failed",
+		cause: "A plugin threw while generating, or reported an error through `ctx.error`.",
+		fix: "Read the underlying error and check the plugin options and the schema or operation it failed on."
+	},
+	[diagnosticCode.pluginWarning]: {
+		title: "Plugin warning",
+		cause: "A plugin reported a non-fatal warning through `ctx.warn`.",
+		fix: "Review the message. It does not fail the build; adjust the plugin options or input if the warning is unwanted."
+	},
+	[diagnosticCode.pluginInfo]: {
+		title: "Plugin info",
+		cause: "A plugin reported an informational message through `ctx.info`.",
+		fix: "Informational only. No action is required."
+	},
+	[diagnosticCode.unsupportedFormat]: {
+		title: "Unsupported format",
+		cause: "A schema uses a `format` Kubb does not map to a specific type, so it falls back to the base type.",
+		fix: "Use a format Kubb supports, or handle the custom format with a parser or plugin."
+	},
+	[diagnosticCode.deprecated]: {
+		title: "Deprecated",
+		cause: "A referenced schema or operation is marked `deprecated`.",
+		fix: "Migrate off the deprecated definition if the warning is unwanted."
+	},
+	[diagnosticCode.adapterRequired]: {
+		title: "Adapter required",
+		cause: "An action needs an adapter (for example opening Kubb Studio) but none is configured.",
+		fix: "Set `adapter` in kubb.config.ts, for example `adapterOas()`."
+	},
+	[diagnosticCode.devtoolsInvalid]: {
+		title: "Invalid devtools config",
+		cause: "The `devtools` config is set to something other than an object.",
+		fix: "Set `devtools` to an options object, or remove it to disable Kubb Studio."
+	},
+	[diagnosticCode.pathTraversal]: {
+		title: "Path traversal",
+		cause: "A resolved output path escaped the output directory, which can stem from a path traversal in the spec or a misconfigured `group.name`.",
+		fix: "Keep generated paths within the output directory. Review the `group.name` function and the names coming from the spec."
+	},
+	[diagnosticCode.hookFailed]: {
+		title: "Hook failed",
+		cause: "A post-generate shell hook (`hooks.done`) exited with a non-zero status.",
+		fix: "Check the command is installed and correct, and run it manually to see the error."
+	},
+	[diagnosticCode.formatFailed]: {
+		title: "Format failed",
+		cause: "The formatter pass over the generated files failed.",
+		fix: "Check the formatter (oxfmt, biome, or prettier) is installed and its config is valid, then run it manually on the output."
+	},
+	[diagnosticCode.lintFailed]: {
+		title: "Lint failed",
+		cause: "The linter pass over the generated files failed.",
+		fix: "Check the linter (oxlint, biome, or eslint) is installed and its config is valid, then run it manually on the output."
+	},
+	[diagnosticCode.performance]: {
+		title: "Performance",
+		cause: "Not a failure. Records a plugin’s elapsed time, summed into the run total.",
+		fix: "No action. This is an informational metric."
+	},
+	[diagnosticCode.updateAvailable]: {
+		title: "Update available",
+		cause: "A newer Kubb version is published on npm than the one running.",
+		fix: "Update the `@kubb/*` packages, for example `npm install -g @kubb/cli`, to get the latest fixes."
+	}
+};
+/**
+* Static helpers for working with {@link Diagnostic}s, plus the run-scoped sink
+* that lets deep code report a diagnostic without threading a callback.
+*
+* 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.
+*/
+var Diagnostics = class Diagnostics {
+	static #reporterStorage = new node_async_hooks.AsyncLocalStorage();
+	/**
+	* Runs `fn` with `sink` as the active diagnostic sink for the whole async
+	* subtree, so {@link Diagnostics.report} reaches it from anywhere inside.
+	*/
+	static scope(sink, fn) {
+		return Diagnostics.#reporterStorage.run(sink, fn);
+	}
+	/**
+	* Collects a diagnostic into the active build via the run-scoped sink, without throwing.
+	* Returns `true` when a run consumed it, `false` when called outside a {@link Diagnostics.scope}
+	* (so callers can fall back to throwing). Use a `warning`/`info` severity for non-fatal issues.
+	* For rendering a diagnostic live on the hook bus, use {@link Diagnostics.emit} instead.
+	*/
+	static report(diagnostic) {
+		const sink = Diagnostics.#reporterStorage.getStore();
+		if (!sink) return false;
+		sink(diagnostic);
+		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
+	* 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 });
+	}
+	/**
+	* Coerces any thrown value into a {@link ProblemDiagnostic}. A {@link DiagnosticError}
+	* keeps its structured data, and anything else becomes a `KUBB_UNKNOWN` error.
+	*/
+	static from(error) {
+		const seen = /* @__PURE__ */ new Set();
+		let current = error;
+		let root;
+		while (current instanceof Error && !seen.has(current)) {
+			if (isDiagnosticError(current)) return current.diagnostic;
+			seen.add(current);
+			root = current;
+			current = current.cause;
+		}
+		return {
+			code: diagnosticCode.unknown,
+			severity: "error",
+			message: root ? root.message : getErrorMessage(error),
+			cause: root
+		};
+	}
+	/**
+	* Builds a per-plugin performance record. Reporters sum these into the run total.
+	*/
+	static performance({ plugin, duration }) {
+		return {
+			kind: "performance",
+			code: diagnosticCode.performance,
+			severity: "info",
+			message: `${plugin} generated in ${Math.round(duration)}ms`,
+			plugin,
+			duration
+		};
+	}
+	/**
+	* Builds the version-update notice shown when a newer Kubb is published on npm.
+	*/
+	static update({ currentVersion, latestVersion }) {
+		return {
+			kind: "update",
+			code: diagnosticCode.updateAvailable,
+			severity: "info",
+			message: `Update available: v${currentVersion} → v${latestVersion}. Run \`npm install -g @kubb/cli\` to update.`,
+			currentVersion,
+			latestVersion
+		};
+	}
+	/**
+	* True when any diagnostic is an error, the severity that fails a build. Non-error
+	* diagnostics are ignored.
+	*/
+	static hasError(diagnostics) {
+		return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+	}
+	/**
+	* Names of the plugins that failed, deduped, derived from the error diagnostics
+	* that carry a `plugin`.
+	*/
+	static failedPlugins(diagnostics) {
+		const names = /* @__PURE__ */ new Set();
+		for (const diagnostic of diagnostics) if (diagnostic.severity === "error" && diagnostic.plugin) names.add(diagnostic.plugin);
+		return [...names];
+	}
+	/**
+	* Counts `problem` diagnostics by severity for the run summary. `timing`
+	* diagnostics are ignored.
+	*/
+	static count(diagnostics) {
+		let errors = 0;
+		let warnings = 0;
+		let infos = 0;
+		for (const diagnostic of diagnostics) {
+			if (!isProblemDiagnostic(diagnostic)) continue;
+			if (diagnostic.severity === "error") errors += 1;
+			else if (diagnostic.severity === "warning") warnings += 1;
+			else infos += 1;
+		}
+		return {
+			errors,
+			warnings,
+			infos
+		};
+	}
+	/**
+	* Drops duplicate `problem` diagnostics that share a code, location pointer, and
+	* plugin, so the same issue reported across several passes is shown once. Non-problem
+	* diagnostics are always kept.
+	*/
+	static dedupe(diagnostics) {
+		const seen = /* @__PURE__ */ new Set();
+		const result = [];
+		for (const diagnostic of diagnostics) {
+			if (!isProblemDiagnostic(diagnostic)) {
+				result.push(diagnostic);
+				continue;
+			}
+			const pointer = diagnostic.location && "pointer" in diagnostic.location ? diagnostic.location.pointer : "";
+			const key = `${diagnostic.code} ${pointer} ${diagnostic.plugin ?? ""}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			result.push(diagnostic);
+		}
+		return result;
+	}
+	/**
+	* Builds the kubb.dev docs URL for a diagnostic code, e.g.
+	* `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("_", "-")}`;
+	}
+	/**
+	* The catalog entry for a code: its title, cause, and fix. Mirrors the kubb.dev
+	* `/diagnostics/<slug>` page.
+	*/
+	static explain(code) {
+		return diagnosticCatalog[code];
+	}
+	/**
+	* Reduces a diagnostic to its JSON-safe fields plus a `docsUrl`, for machine-readable
+	* consumers. The `cause`, `kind`, and `duration` are dropped, and absent optional
+	* fields are omitted rather than set to `undefined`.
+	*/
+	static serialize(diagnostic) {
+		const problem = isProblemDiagnostic(diagnostic) ? diagnostic : void 0;
+		return {
+			code: diagnostic.code,
+			severity: diagnostic.severity,
+			message: diagnostic.message,
+			...problem?.location ? { location: problem.location } : {},
+			...problem?.help ? { help: problem.help } : {},
+			...problem?.plugin ? { plugin: problem.plugin } : {},
+			...diagnostic.code === diagnosticCode.unknown ? {} : { docsUrl: Diagnostics.docsUrl(diagnostic.code) }
+		};
+	}
 };
 //#endregion
 //#region src/definePlugin.ts
@@ -764,7 +1229,7 @@ function defaultResolver(name, type) {
 	return camelCase(name);
 }
 /**
-* Default option resolver — applies include/exclude filters and merges matching override options.
+* Default option resolver. Applies include/exclude filters and merges matching override options.
 *
 * Returns `null` when the node is filtered out by an `exclude` rule or not matched by any `include` rule.
 *
@@ -800,7 +1265,7 @@ function computeOptions(node, options, exclude, include, override) {
 	if ((0, _kubb_ast.isSchemaNode)(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((r) => r !== null);
+			const applicable = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern)).filter((result) => result !== null);
 			if (applicable.length > 0 && !applicable.includes(true)) return null;
 		}
 		const overrideOptions = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)?.options;
@@ -873,8 +1338,8 @@ function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root
 	const result = (() => {
 		if (group && (groupPath || tag)) {
 			const groupValue = group.type === "path" ? groupPath : tag;
-			const defaultName = group.type === "tag" ? ({ group: g }) => `${camelCase(g)}Controller` : ({ group: g }) => {
-				const segment = g.split("/").filter((s) => s !== "" && s !== "." && s !== "..")[0];
+			const defaultName = group.type === "tag" ? ({ group: groupName }) => `${camelCase(groupName)}Controller` : ({ group: groupName }) => {
+				const segment = groupName.split("/").filter((part) => part !== "" && part !== "." && part !== "..")[0];
 				return segment ? camelCase(segment) : "";
 			};
 			const resolveName = group.name ?? defaultName;
@@ -884,7 +1349,13 @@ function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root
 	})();
 	const outputDir = node_path.default.resolve(root, output.path);
 	const outputDirWithSep = outputDir.endsWith(node_path.default.sep) ? outputDir : `${outputDir}${node_path.default.sep}`;
-	if (result !== outputDir && !result.startsWith(outputDirWithSep)) throw new Error(`[Kubb] Resolved path "${result}" is outside the output directory "${outputDir}". This may indicate a path traversal attempt in the OpenAPI specification or a misconfigured group.name function.`);
+	if (result !== outputDir && !result.startsWith(outputDirWithSep)) throw new DiagnosticError({
+		code: diagnosticCode.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;
 }
 /**
@@ -892,7 +1363,7 @@ function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root
 *
 * 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 — consumers populate those separately.
+* `sources`, `imports`, and `exports` arrays, which consumers populate separately.
 *
 * In `single` mode the name is omitted and the file sits directly in the output directory.
 *
@@ -968,7 +1439,7 @@ function buildDefaultBanner({ title, description, version, config }) {
 	}
 }
 /**
-* Default banner resolver — returns the banner string for a generated file.
+* 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`
@@ -997,7 +1468,7 @@ function buildDefaultBanner({ title, description, version, config }) {
 * // → ''
 * ```
 *
-* @example No user banner — Kubb notice with OAS metadata
+* @example No user banner, Kubb notice with OAS metadata
 * ```ts
 * defaultResolveBanner(meta, { config })
 * // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
@@ -1023,7 +1494,7 @@ function defaultResolveBanner(meta, { output, config, file }) {
 	});
 }
 /**
-* Default footer resolver — returns the footer string for a generated file.
+* 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.
@@ -1055,11 +1526,11 @@ function defaultResolveFooter(meta, { output, file }) {
 * name casing, include/exclude/override filtering, output path computation,
 * and file construction. Supply your own to override any of them:
 *
-* - `default` — name casing strategy (camelCase / PascalCase).
-* - `resolveOptions` — include/exclude/override filtering.
-* - `resolvePath` — output path computation.
-* - `resolveFile` — full `FileNode` construction.
-* - `resolveBanner` / `resolveFooter` — top/bottom-of-file text.
+* - `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`,
 * which keeps custom rules small (`this.default(name, 'type')` to delegate).
@@ -1108,7 +1579,7 @@ function defineResolver(build) {
 * Encodes an `InputNode` as a compressed, URL-safe string.
 *
 * The JSON representation is deflate-compressed with {@link deflateSync} before
-* base64url encoding, which typically reduces payload size by 70–80 % and
+* base64url encoding, which typically reduces payload size by 70, 80 % and
 * keeps URLs well within browser and server path-length limits.
 */
 function encodeAst(input) {
@@ -1125,8 +1596,7 @@ function getStudioUrl(input, studioUrl, options = {}) {
 	return `${studioUrl.replace(/\/$/, "")}${options.ast ? "/ast" : ""}?root=${encodeAst(input)}`;
 }
 /**
-* Opens the Kubb Studio URL for the given `InputNode` in the default browser —
-*
+* Opens the Kubb Studio URL for the given `InputNode` in the default browser,  *
 * Falls back to printing the URL if the browser cannot be launched.
 */
 async function openInStudio(input, studioUrl, options = {}) {
@@ -1181,18 +1651,13 @@ function compareFiles(a, b) {
 * ```
 */
 var FileManager = class {
-	#cache = /* @__PURE__ */ new Map();
-	#sorted = null;
-	#onUpsert = null;
 	/**
-	* Registers a callback invoked with the resolved {@link FileNode} on every
-	* `add` / `upsert`. Used by the build loop to track newly written files
-	* without keeping its own scan-based diff. Single subscriber by design —
-	* setting again replaces the previous callback. Pass `null` to detach.
+	* Subscribe to file-store changes. Listeners on `upsert` see each resolved file as it lands
+	* through `add` or `upsert`.
 	*/
-	setOnUpsert(callback) {
-		this.#onUpsert = callback;
-	}
+	hooks = new AsyncEventEmitter();
+	#cache = /* @__PURE__ */ new Map();
+	#sorted = null;
 	add(...files) {
 		return this.#store(files, false);
 	}
@@ -1207,7 +1672,7 @@ var FileManager = class {
 			const merged = existing && mergeExisting ? (0, _kubb_ast.createFile)(mergeFile(existing, file)) : (0, _kubb_ast.createFile)(file);
 			this.#cache.set(merged.path, merged);
 			resolved.push(merged);
-			this.#onUpsert?.(merged);
+			this.hooks.emit("upsert", merged);
 		}
 		if (resolved.length > 0) this.#sorted = null;
 		return resolved;
@@ -1232,18 +1697,19 @@ var FileManager = class {
 		this.#sorted = null;
 	}
 	/**
-	* Releases all stored files. Called by the core after `kubb:build:end`.
+	* Releases all stored files and clears every `hooks` listener. Called by the core after
+	* `kubb:build:end`.
 	*/
 	dispose() {
 		this.clear();
-		this.#onUpsert = null;
+		this.hooks.removeAll();
 	}
 	[Symbol.dispose]() {
 		this.dispose();
 	}
 	/**
 	* All stored files in stable sort order (shortest path first, barrel files
-	* last within a length bucket). Returns a cached view — do not mutate.
+	* last within a length bucket). Returns a cached view, do not mutate.
 	*/
 	get files() {
 		return this.#sorted ??= [...this.#cache.values()].sort(compareFiles);
@@ -1256,32 +1722,57 @@ function joinSources(file) {
 	if (sources.length === 0) return "";
 	const parts = [];
 	for (const source of sources) {
-		const s = (0, _kubb_ast.extractStringsFromNodes)(source.nodes);
-		if (s) parts.push(s);
+		const text = (0, _kubb_ast.extractStringsFromNodes)(source.nodes);
+		if (text) parts.push(text);
 	}
 	return parts.join("\n\n");
 }
 /**
-* Converts a single file to a string using the registered parsers.
-* Falls back to joining source values when no matching parser is found.
+* Turns `FileNode`s into source strings and writes them to storage.
+*
+* Two modes share the same instance. Stateless mode (`parse`, `stream`, `run`) just runs the
+* conversion. Queue mode (`enqueue`, `flush`, `drain`) buffers files deduped by path and
+* writes each batch through storage with up to `STREAM_FLUSH_EVERY` requests in flight.
+*
+* `flush` does not wait for its batch to finish, so dispatch can overlap with IO. The next
+* `flush` or `drain` picks the in-flight batch up. `drain` blocks until everything has been
+* written and is meant for the end of a build.
 *
-* @internal
+* To surface build-level hook signals (`kubb:files:processing:*` and friends) subscribe to
+* `hooks` and re-emit on the kubb bus.
 */
 var FileProcessor = class {
-	events = new AsyncEventEmitter();
-	parse(file, { parsers, extension } = {}) {
-		const parseExtName = extension?.[file.extname] || void 0;
+	hooks = new AsyncEventEmitter();
+	#parsers;
+	#storage;
+	#extension;
+	#pending = /* @__PURE__ */ new Map();
+	#runningFlush = null;
+	constructor(options) {
+		this.#parsers = options.parsers ?? null;
+		this.#storage = options.storage;
+		this.#extension = options.extension ?? null;
+	}
+	/**
+	* Files waiting in the queue.
+	*/
+	get size() {
+		return this.#pending.size;
+	}
+	parse(file) {
+		const parsers = this.#parsers;
+		const parseExtName = this.#extension?.[file.extname] || void 0;
 		if (!parsers || !file.extname) return joinSources(file);
 		const parser = parsers.get(file.extname);
 		if (!parser) return joinSources(file);
 		return parser.parse(file, { extname: parseExtName });
 	}
-	*stream(files, options = {}) {
+	*stream(files) {
 		const total = files.length;
 		if (total === 0) return;
 		let processed = 0;
 		for (const file of files) {
-			const source = this.parse(file, options);
+			const source = this.parse(file);
 			processed++;
 			yield {
 				file,
@@ -1292,29 +1783,157 @@ var FileProcessor = class {
 			};
 		}
 	}
-	async run(files, options = {}) {
-		await this.events.emit("start", files);
-		for (const { file, source, processed, total, percentage } of this.stream(files, options)) await this.events.emit("update", {
+	async run(files) {
+		await this.hooks.emit("start", files);
+		for (const { file, source, processed, total, percentage } of this.stream(files)) await this.hooks.emit("update", {
 			file,
 			source,
 			processed,
 			percentage,
 			total
 		});
-		await this.events.emit("end", files);
+		await this.hooks.emit("end", files);
 		return files;
 	}
 	/**
-	* Clears all registered event listeners.
+	* Adds a file to the next flush. A later `enqueue` for the same path replaces the previous
+	* entry, matching `FileManager.upsert`. Fires the `enqueue` event.
+	*/
+	enqueue(file) {
+		this.#pending.set(file.path, file);
+		this.hooks.emit("enqueue", file);
+	}
+	/**
+	* Starts processing the queued files. Waits for any previous flush to finish (so two
+	* batches never run together) and then returns without waiting for the new one. The next
+	* `flush` or `drain` picks up the in-flight task.
+	*/
+	async flush() {
+		if (this.#runningFlush) await this.#runningFlush;
+		if (this.#pending.size === 0) return;
+		const batch = [...this.#pending.values()];
+		this.#pending.clear();
+		this.#runningFlush = this.#processAndWrite(batch).finally(() => {
+			this.#runningFlush = null;
+		});
+	}
+	/**
+	* Waits for the in-flight flush and writes any files still queued. Fires the `drain` event
+	* when both are done.
+	*/
+	async drain() {
+		if (this.#runningFlush) await this.#runningFlush;
+		if (this.#pending.size > 0) {
+			const batch = [...this.#pending.values()];
+			this.#pending.clear();
+			await this.#processAndWrite(batch);
+		}
+		await this.hooks.emit("drain");
+	}
+	async #processAndWrite(files) {
+		const storage = this.#storage;
+		await this.hooks.emit("start", files);
+		const items = [...this.stream(files)];
+		for (const item of items) await this.hooks.emit("update", item);
+		const queue = [];
+		for (const { file, source } of items) if (source) {
+			queue.push(storage.setItem(file.path, source));
+			if (queue.length >= 50) await Promise.all(queue.splice(0));
+		}
+		await Promise.all(queue);
+		await this.hooks.emit("end", files);
+	}
+	/**
+	* Clears every listener and the pending queue.
 	*/
 	dispose() {
-		this.events.removeAll();
+		this.hooks.removeAll();
+		this.#pending.clear();
 	}
 	[Symbol.dispose]() {
 		this.dispose();
 	}
 };
 //#endregion
+//#region src/HookRegistry.ts
+/**
+* Listener bookkeeping around an `AsyncEventEmitter`. Listeners attached through `register`
+* stay on the emitter but are tracked so `dispose()` removes only them, listeners attached
+* directly via `emitter.on(...)` survive.
+*/
+var HookRegistry = class {
+	#emitter;
+	#entries = /* @__PURE__ */ new Set();
+	constructor(options) {
+		this.#emitter = options.emitter;
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	get size() {
+		return this.#entries.size;
+	}
+	register(options) {
+		this.#emitter.on(options.event, options.handler);
+		this.#entries.add(options);
+	}
+	dispose() {
+		for (const entry of this.#entries) this.#emitter.off(entry.event, entry.handler);
+		this.#entries.clear();
+	}
+};
+//#endregion
+//#region src/Transform.ts
+/**
+* Holds one `Visitor` per plugin, keyed by plugin name. Each plugin's transformer runs in
+* isolation on the original adapter node. `applyTo` is a lookup, not a chain, so plugin A's
+* visitor never sees plugin B's output. When no transformer is registered, `applyTo` returns
+* the original node reference, and the `@kubb/ast` `transform` primitive does the same when
+* its visitor leaves the tree untouched. Callers can compare by identity to detect a no-op.
+*
+* Registration order matches the order setup hooks fire, which the driver has already sorted
+* by `enforce` and dependency edges. The registry does not re-order anything.
+*/
+var Transform = class {
+	#visitors = /* @__PURE__ */ new Map();
+	/**
+	* Number of plugins with a registered transformer.
+	*/
+	get size() {
+		return this.#visitors.size;
+	}
+	/**
+	* Records `visitor` as the transformer for `pluginName`. A second call for the same plugin
+	* replaces the first.
+	*/
+	register(pluginName, visitor) {
+		this.#visitors.set(pluginName, visitor);
+	}
+	/**
+	* Looks up the transformer for `pluginName`. The generator context uses this so plugins can
+	* read their own visitor through `ctx.transformer`.
+	*/
+	get(pluginName) {
+		return this.#visitors.get(pluginName);
+	}
+	/**
+	* Runs the plugin's transformer on `node`. Returns the original node reference when the
+	* plugin has no transformer, so callers can compare by identity to detect a no-op.
+	*/
+	applyTo(pluginName, node) {
+		const visitor = this.#visitors.get(pluginName);
+		if (!visitor) return node;
+		return (0, _kubb_ast.transform)(node, visitor);
+	}
+	/**
+	* Clears every registration. Called from the driver's `dispose()` so visitors do not leak
+	* across builds.
+	*/
+	dispose() {
+		this.#visitors.clear();
+	}
+};
+//#endregion
 //#region \0@oxc-project+runtime@0.133.0/helpers/esm/usingCtx.js
 function _usingCtx() {
 	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
@@ -1379,13 +1998,6 @@ function _usingCtx() {
 function enforceOrder(enforce) {
 	return enforce === "pre" ? -1 : enforce === "post" ? 1 : 0;
 }
-const OPERATION_FILTER_TYPES = new Set([
-	"tag",
-	"operationId",
-	"path",
-	"method",
-	"contentType"
-]);
 var KubbDriver = class KubbDriver {
 	config;
 	options;
@@ -1403,7 +2015,7 @@ var KubbDriver = class KubbDriver {
 	}
 	/**
 	* The streaming `InputStreamNode` produced by the adapter.
-	* Always set after adapter setup — parse-only adapters are wrapped automatically.
+	* Always set after adapter setup, parse-only adapters are wrapped automatically.
 	*/
 	inputNode = null;
 	adapter = null;
@@ -1411,7 +2023,7 @@ var KubbDriver = class KubbDriver {
 	* Studio session state, kept together so `dispose()` can reset it atomically.
 	*
 	* - `source` holds the raw adapter source so `adapter.parse()` can be called lazily.
-	*   Intentionally outlives the build; cleared by `dispose()`.
+	*   Intentionally outlives the build, cleared by `dispose()`.
 	* - `isOpen` prevents opening the studio more than once per build.
 	* - `inputNode` caches the parse promise so `adapter.parse()` is called at most once
 	*   per studio session, even when `openInStudio()` is called multiple times.
@@ -1421,14 +2033,12 @@ var KubbDriver = class KubbDriver {
 		isOpen: false,
 		inputNode: null
 	};
-	#middlewareListeners = [];
 	/**
 	* Central file store for all generated files.
 	* Plugins should use `this.addFile()` / `this.upsertFile()` (via their context) to
-	* add files; this property gives direct read/write access when needed.
+	* add files. This property gives direct read/write access when needed.
 	*/
 	fileManager = new FileManager();
-	#fileProcessor = new FileProcessor();
 	plugins = /* @__PURE__ */ new Map();
 	/**
 	* Tracks which plugins have generators registered via `addGenerator()` (event-based path).
@@ -1437,11 +2047,22 @@ var KubbDriver = class KubbDriver {
 	#eventGeneratorPlugins = /* @__PURE__ */ new Set();
 	#resolvers = /* @__PURE__ */ new Map();
 	#defaultResolvers = /* @__PURE__ */ new Map();
-	#hookListeners = /* @__PURE__ */ new Map();
+	/**
+	* Tracks every listener the driver added (plugin, middleware, generator) so `dispose()` can
+	* remove them in one pass. Middleware registers after plugins, so it fires last via `Set`
+	* insertion order. External `hooks.on(...)` listeners are not tracked.
+	*/
+	#registry;
+	/**
+	* Transform registry. Plugins populate it during `kubb:plugin:setup` via `setTransformer`,
+	* and `#runGenerators` reads it once per `(plugin, node)` pair through `applyTo`.
+	*/
+	#transforms = new Transform();
 	constructor(config, options) {
 		this.config = config;
 		this.options = options;
 		this.adapter = config.adapter ?? null;
+		this.#registry = new HookRegistry({ emitter: options.hooks });
 	}
 	async setup() {
 		const normalized = this.config.plugins.map((rawPlugin) => this.#normalizePlugin(rawPlugin));
@@ -1456,7 +2077,7 @@ var KubbDriver = class KubbDriver {
 			this.plugins.set(plugin.name, plugin);
 		}
 		if (this.config.middleware) for (const middleware of this.config.middleware) for (const event of Object.keys(middleware.hooks)) this.#registerMiddleware(event, middleware.hooks);
-		if (this.config.adapter) await this.#registerAdapter(this.config.adapter);
+		if (this.config.adapter) this.#studio.source = inputToAdapterSource(this.config);
 	}
 	get hooks() {
 		return this.options.hooks;
@@ -1480,46 +2101,39 @@ var KubbDriver = class KubbDriver {
 		if ("apply" in plugin && typeof plugin.apply === "function") normalized.apply = plugin.apply;
 		return normalized;
 	}
-	async #registerAdapter(adapter) {
-		const source = inputToAdapterSource(this.config);
-		this.#studio.source = source;
+	/**
+	* Parses the adapter source into `this.inputNode`. Idempotent, so repeated calls from
+	* `run` or the studio path do not re-parse. Adapters with `stream()` are used directly.
+	* Adapters with only `parse()` are wrapped via `createStreamInput` so the dispatch loop
+	* stays stream-only.
+	*/
+	async #parseInput() {
+		if (this.inputNode || !this.adapter || !this.#studio.source) return;
+		const adapter = this.adapter;
+		const source = this.#studio.source;
 		if (adapter.stream) {
 			this.inputNode = await adapter.stream(source);
-			await this.hooks.emit("kubb:debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`✓ Adapter '${adapter.name}' producing input stream`]
-			});
-		} else {
-			const inputNode = await adapter.parse(source);
-			this.inputNode = (0, _kubb_ast.createStreamInput)(arrayToAsyncIterable(inputNode.schemas), arrayToAsyncIterable(inputNode.operations), inputNode.meta);
-			await this.hooks.emit("kubb:debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [
-					`✓ Adapter '${adapter.name}' resolved InputNode (wrapped as stream)`,
-					`  • Schemas: ${inputNode.schemas.length}`,
-					`  • Operations: ${inputNode.operations.length}`
-				]
-			});
+			return;
 		}
+		const parsed = await adapter.parse(source);
+		this.inputNode = (0, _kubb_ast.createStreamInput)(arrayToAsyncIterable(parsed.schemas), arrayToAsyncIterable(parsed.operations), parsed.meta);
 	}
 	#registerMiddleware(event, middlewareHooks) {
 		const handler = middlewareHooks[event];
 		if (!handler) return;
-		this.hooks.on(event, handler);
-		this.#middlewareListeners.push([event, handler]);
+		this.#registry.register({
+			event,
+			handler,
+			source: "middleware"
+		});
 	}
 	/**
 	* Registers a hook-style plugin's lifecycle handlers on the shared `AsyncEventEmitter`.
 	*
-	* For `kubb:plugin:setup`, the registered listener wraps the globally emitted context with a
-	* plugin-specific one so that `addGenerator`, `setResolver`, `setTransformer`, and
-	* `setRenderer` all target the correct `normalizedPlugin` entry in the plugins map.
-	*
-	* All other hooks are iterated and registered directly as pass-through listeners.
-	* Any event key present in the global `KubbHooks` interface can be subscribed to.
-	*
-	* External tooling can subscribe to any of these events via `hooks.on(...)` to observe
-	* the plugin lifecycle without modifying plugin behavior.
+	* The `kubb:plugin:setup` listener wraps the global context in a plugin-specific one so
+	* `addGenerator`, `setResolver`, and `setTransformer` target the right `normalizedPlugin`.
+	* Every other `KubbHooks` event registers as a pass-through listener that external tooling
+	* can observe via `hooks.on(...)`.
 	*
 	* @internal
 	*/
@@ -1538,10 +2152,7 @@ var KubbDriver = class KubbDriver {
 						this.setPluginResolver(plugin.name, resolver);
 					},
 					setTransformer: (visitor) => {
-						plugin.transformer = visitor;
-					},
-					setRenderer: (renderer) => {
-						plugin.renderer = renderer;
+						this.#transforms.register(plugin.name, visitor);
 					},
 					setOptions: (opts) => {
 						plugin.options = {
@@ -1555,13 +2166,21 @@ var KubbDriver = class KubbDriver {
 				};
 				return hooks["kubb:plugin:setup"](pluginCtx);
 			};
-			this.hooks.on("kubb:plugin:setup", setupHandler);
-			this.#trackHookListener("kubb:plugin:setup", setupHandler);
+			this.#registry.register({
+				event: "kubb:plugin:setup",
+				handler: setupHandler,
+				source: "plugin"
+			});
 		}
-		for (const [event, handler] of Object.entries(hooks)) {
-			if (event === "kubb:plugin:setup" || !handler) continue;
-			this.hooks.on(event, handler);
-			this.#trackHookListener(event, handler);
+		for (const event of Object.keys(hooks)) {
+			if (event === "kubb:plugin:setup") continue;
+			const handler = hooks[event];
+			if (!handler) continue;
+			this.#registry.register({
+				event,
+				handler,
+				source: "plugin"
+			});
 		}
 	}
 	/**
@@ -1578,7 +2197,6 @@ var KubbDriver = class KubbDriver {
 			addGenerator: noop,
 			setResolver: noop,
 			setTransformer: noop,
-			setRenderer: noop,
 			setOptions: noop,
 			injectFile: noop,
 			updateConfig: noop
@@ -1592,52 +2210,56 @@ var KubbDriver = class KubbDriver {
 	* 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 resolution chain is: `generator.renderer → plugin.renderer → config.renderer`.
-	* Set `generator.renderer = null` to explicitly opt out of rendering even when the plugin
-	* declares a renderer.
+	* The renderer comes from `generator.renderer`. Set `generator.renderer = 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, gen) {
-		const resolveRenderer = () => {
-			const plugin = this.plugins.get(pluginName);
-			return gen.renderer === null ? void 0 : gen.renderer ?? plugin?.renderer ?? this.config.renderer;
-		};
-		if (gen.schema) {
+	registerGenerator(pluginName, generator) {
+		if (generator.schema) {
 			const schemaHandler = async (node, ctx) => {
 				if (ctx.plugin.name !== pluginName) return;
-				await applyHookResult({
-					result: await gen.schema(node, ctx),
-					driver: this,
-					rendererFactory: resolveRenderer()
+				const result = await generator.schema(node, ctx);
+				await this.dispatch({
+					result,
+					renderer: generator.renderer
 				});
 			};
-			this.hooks.on("kubb:generate:schema", schemaHandler);
-			this.#trackHookListener("kubb:generate:schema", schemaHandler);
+			this.#registry.register({
+				event: "kubb:generate:schema",
+				handler: schemaHandler,
+				source: "driver"
+			});
 		}
-		if (gen.operation) {
+		if (generator.operation) {
 			const operationHandler = async (node, ctx) => {
 				if (ctx.plugin.name !== pluginName) return;
-				await applyHookResult({
-					result: await gen.operation(node, ctx),
-					driver: this,
-					rendererFactory: resolveRenderer()
+				const result = await generator.operation(node, ctx);
+				await this.dispatch({
+					result,
+					renderer: generator.renderer
 				});
 			};
-			this.hooks.on("kubb:generate:operation", operationHandler);
-			this.#trackHookListener("kubb:generate:operation", operationHandler);
+			this.#registry.register({
+				event: "kubb:generate:operation",
+				handler: operationHandler,
+				source: "driver"
+			});
 		}
-		if (gen.operations) {
+		if (generator.operations) {
 			const operationsHandler = async (nodes, ctx) => {
 				if (ctx.plugin.name !== pluginName) return;
-				await applyHookResult({
-					result: await gen.operations(nodes, ctx),
-					driver: this,
-					rendererFactory: resolveRenderer()
+				const result = await generator.operations(nodes, ctx);
+				await this.dispatch({
+					result,
+					renderer: generator.renderer
 				});
 			};
-			this.hooks.on("kubb:generate:operations", operationsHandler);
-			this.#trackHookListener("kubb:generate:operations", operationsHandler);
+			this.#registry.register({
+				event: "kubb:generate:operations",
+				handler: operationsHandler,
+				source: "driver"
+			});
 		}
 		this.#eventGeneratorPlugins.add(pluginName);
 	}
@@ -1652,143 +2274,110 @@ var KubbDriver = class KubbDriver {
 		return this.#eventGeneratorPlugins.has(pluginName);
 	}
 	/**
-	* Runs the full plugin pipeline. Returns timings/failures collected so far even
-	* when an outer hook throws — the orchestrator preserves partial state by capturing
-	* the error into `error` instead of propagating.
+	* Runs the full plugin pipeline. Returns the diagnostics collected so far even
+	* when an outer hook throws, since the orchestrator preserves partial state by capturing
+	* the failure as a {@link Diagnostic} instead of propagating. Each plugin also
+	* contributes a `timing` diagnostic for the run summary.
 	*/
 	async run({ storage }) {
-		const hooks = this.hooks;
-		const config = this.config;
-		const failedPlugins = /* @__PURE__ */ new Set();
-		const pluginTimings = /* @__PURE__ */ new Map();
+		const { hooks, config } = 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 pendingFiles = /* @__PURE__ */ new Map();
-		this.fileManager.setOnUpsert((file) => {
-			pendingFiles.set(file.path, file);
+		const processor = new FileProcessor({
+			parsers: parsersMap,
+			storage,
+			extension: config.output.extension
 		});
-		try {
-			const flushPending = async () => {
-				if (pendingFiles.size === 0) return;
-				const files = [...pendingFiles.values()];
-				pendingFiles.clear();
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [`Writing ${files.length} files...`]
-				});
-				await hooks.emit("kubb:files:processing:start", { files });
-				const items = [...this.#fileProcessor.stream(files, {
-					parsers: parsersMap,
-					extension: config.output.extension
-				})];
-				await hooks.emit("kubb:files:processing:update", { files: items.map(({ file, source, processed, total, percentage }) => ({
-					file,
-					source,
-					processed,
-					total,
-					percentage,
-					config
-				})) });
-				const queue = [];
-				for (const { file, source } of items) if (source) {
-					queue.push(storage.setItem(file.path, source));
-					if (queue.length >= 50) await Promise.all(queue.splice(0));
-				}
-				await Promise.all(queue);
-				await hooks.emit("kubb:files:processing:end", { files });
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ File write process completed for ${files.length} files`]
-				});
-			};
-			await this.emitSetupHooks();
-			if (this.adapter && this.inputNode) await hooks.emit("kubb:build:start", Object.assign({
-				config,
-				adapter: this.adapter,
-				meta: this.inputNode.meta,
-				getPlugin: this.getPlugin.bind(this)
-			}, this.#filesPayload()));
-			const generatorPlugins = [];
-			for (const plugin of this.plugins.values()) {
-				const context = this.getContext(plugin);
-				const hrStart = process.hrtime();
-				try {
-					await hooks.emit("kubb:plugin:start", { plugin });
-					await hooks.emit("kubb:debug", {
-						date: /* @__PURE__ */ new Date(),
-						logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
-					});
-				} catch (caughtError) {
-					const error = caughtError;
+		processor.hooks.on("start", async (files) => {
+			await hooks.emit("kubb:files:processing:start", { files });
+		});
+		const updateBuffer = [];
+		processor.hooks.on("update", (item) => {
+			updateBuffer.push(item);
+		});
+		processor.hooks.on("end", async (files) => {
+			await hooks.emit("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);
+		};
+		this.fileManager.hooks.on("upsert", onFileUpsert);
+		return Diagnostics.scope((diagnostic) => diagnostics.push(diagnostic), async () => {
+			try {
+				await this.#parseInput();
+				await this.emitSetupHooks();
+				if (this.adapter && this.inputNode) await hooks.emit("kubb:build:start", Object.assign({
+					config,
+					adapter: this.adapter,
+					meta: this.inputNode.meta,
+					getPlugin: this.getPlugin.bind(this)
+				}, this.#filesPayload()));
+				const generatorPlugins = [];
+				for (const plugin of this.plugins.values()) {
+					const context = this.getContext(plugin);
+					const hrStart = process.hrtime();
+					try {
+						await hooks.emit("kubb:plugin:start", { plugin });
+					} catch (caughtError) {
+						const error = caughtError;
+						const duration = getElapsedMs(hrStart);
+						await this.#emitPluginEnd({
+							plugin,
+							duration,
+							success: false,
+							error
+						});
+						diagnostics.push({
+							...Diagnostics.from(error),
+							plugin: plugin.name
+						}, Diagnostics.performance({
+							plugin: plugin.name,
+							duration
+						}));
+						continue;
+					}
+					if (this.hasEventGenerators(plugin.name)) {
+						generatorPlugins.push({
+							plugin,
+							context,
+							hrStart
+						});
+						continue;
+					}
 					const duration = getElapsedMs(hrStart);
-					pluginTimings.set(plugin.name, duration);
+					diagnostics.push(Diagnostics.performance({
+						plugin: plugin.name,
+						duration
+					}));
 					await this.#emitPluginEnd({
 						plugin,
 						duration,
-						success: false,
-						error
-					});
-					failedPlugins.add({
-						plugin,
-						error
-					});
-					continue;
-				}
-				if (plugin.generators?.length || this.hasEventGenerators(plugin.name)) {
-					generatorPlugins.push({
-						plugin,
-						context,
-						hrStart
+						success: true
 					});
-					continue;
 				}
-				const duration = getElapsedMs(hrStart);
-				pluginTimings.set(plugin.name, duration);
-				await this.#emitPluginEnd({
-					plugin,
-					duration,
-					success: true
-				});
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
-				});
-			}
-			if (generatorPlugins.length > 0) if (this.inputNode) {
-				const { timings, failed } = await this.#runGenerators(generatorPlugins, flushPending);
-				await flushPending();
-				for (const [name, duration] of timings) pluginTimings.set(name, duration);
-				for (const entry of failed) failedPlugins.add(entry);
-			} else for (const { plugin, hrStart } of generatorPlugins) {
-				const duration = getElapsedMs(hrStart);
-				pluginTimings.set(plugin.name, duration);
-				await this.#emitPluginEnd({
-					plugin,
-					duration,
-					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", {
+					files: this.fileManager.files,
+					config,
+					outputDir: (0, node_path.resolve)(config.root, config.output.path)
 				});
+				return { diagnostics: Diagnostics.dedupe(diagnostics) };
+			} catch (caughtError) {
+				diagnostics.push(Diagnostics.from(caughtError));
+				return { diagnostics: Diagnostics.dedupe(diagnostics) };
+			} finally {
+				this.fileManager.hooks.off("upsert", onFileUpsert);
 			}
-			await hooks.emit("kubb:plugins:end", Object.assign({ config }, this.#filesPayload()));
-			await flushPending();
-			const files = this.fileManager.files;
-			await hooks.emit("kubb:build:end", {
-				files,
-				config,
-				outputDir: (0, node_path.resolve)(config.root, config.output.path)
-			});
-			return {
-				failedPlugins,
-				pluginTimings
-			};
-		} catch (caughtError) {
-			return {
-				failedPlugins,
-				pluginTimings,
-				error: caughtError
-			};
-		} finally {
-			this.fileManager.setOnUpsert(null);
-		}
+		});
 	}
 	#filesPayload() {
 		const driver = this;
@@ -1808,10 +2397,36 @@ var KubbDriver = class KubbDriver {
 			config: this.config
 		}, this.#filesPayload()));
 	}
+	/**
+	* Streams schemas and operations through every plugin's generators. Each node is run
+	* through the plugin's transformer (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.
+	* A failing plugin contributes an error diagnostic so the rest of the build continues.
+	* Every plugin also contributes a `timing` diagnostic.
+	*
+	* When `entries` is empty or `this.inputNode` is `null`, every entry still gets a
+	* `kubb:plugin:end` so middleware listeners (the barrel writer and friends) complete.
+	*/
 	async #runGenerators(entries, flushPending) {
-		const timings = /* @__PURE__ */ new Map();
-		const failed = /* @__PURE__ */ new Set();
-		const driver = this;
+		const diagnostics = [];
+		if (entries.length === 0) return diagnostics;
+		if (!this.inputNode) {
+			for (const { plugin, hrStart } of entries) {
+				const duration = getElapsedMs(hrStart);
+				diagnostics.push(Diagnostics.performance({
+					plugin: plugin.name,
+					duration
+				}));
+				await this.#emitPluginEnd({
+					plugin,
+					duration,
+					success: true
+				});
+			}
+			return diagnostics;
+		}
+		const transforms = this.#transforms;
 		const { schemas, operations } = this.inputNode;
 		const states = entries.map(({ plugin, context, hrStart }) => {
 			const { exclude, include, override } = plugin.options;
@@ -1841,7 +2456,7 @@ var KubbDriver = class KubbDriver {
 		if (pruningStates.length > 0) {
 			const allSchemas = [];
 			for await (const schema of schemas) allSchemas.push(schema);
-			const includedOpsByState = new Map(pruningStates.map((s) => [s, []]));
+			const includedOpsByState = new Map(pruningStates.map((state) => [state, []]));
 			for await (const operation of operations) for (const state of pruningStates) {
 				const { exclude, include, override } = state.plugin.options;
 				if (state.generatorContext.resolver.resolveOptions(operation, {
@@ -1856,33 +2471,45 @@ var KubbDriver = class KubbDriver {
 				includedOpsByState.delete(state);
 			}
 		}
-		const resolveRendererFor = (gen, state) => gen.renderer === null ? void 0 : gen.renderer ?? state.plugin.renderer ?? state.generatorContext.config.renderer;
+		const resolveForPlugin = (state, node) => {
+			const { plugin, generatorContext } = state;
+			const transformedNode = transforms.applyTo(plugin.name, node);
+			if (state.optionsAreStatic) return {
+				transformedNode,
+				options: plugin.options
+			};
+			const { exclude, include, override } = plugin.options;
+			const options = generatorContext.resolver.resolveOptions(transformedNode, {
+				options: plugin.options,
+				exclude,
+				include,
+				override
+			});
+			if (options === null) return null;
+			return {
+				transformedNode,
+				options
+			};
+		};
 		const dispatchNode = async (state, node, dispatch) => {
 			if (state.failed) return;
 			try {
-				const { plugin, generatorContext, generators } = state;
-				const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
+				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 { exclude, include, override } = plugin.options;
-				const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
-					options: plugin.options,
-					exclude,
-					include,
-					override
-				});
-				if (options === null) return;
 				const ctx = {
-					...generatorContext,
+					...state.generatorContext,
 					options
 				};
-				for (const gen of generators) {
-					const generate = gen[dispatch.method];
-					if (!generate) continue;
-					const raw = generate(transformedNode, ctx);
-					const applied = applyHookResult({
-						result: isPromise(raw) ? await raw : raw,
-						driver,
-						rendererFactory: resolveRendererFor(gen, state)
+				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 (isPromise(applied)) await applied;
 				}
@@ -1902,15 +2529,15 @@ var KubbDriver = class KubbDriver {
 			checkAllowedNames: false,
 			emit: emitsOperationHook ? (node, ctx) => this.hooks.emit("kubb:generate:operation", node, ctx) : null
 		};
-		const needsCollectedOperations = this.hooks.listenerCount("kubb:generate:operations") > 0 || states.some((s) => s.generators.some((g) => !!g.operations));
+		const needsCollectedOperations = this.hooks.listenerCount("kubb:generate:operations") > 0 || states.some((state) => state.generators.some((gen) => !!gen.operations));
 		const collectedOperations = needsCollectedOperations ? [] : void 0;
-		await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((n) => states.map((state) => dispatchNode(state, n, schemaDispatch)))), {
+		await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((node) => states.map((state) => dispatchNode(state, node, schemaDispatch)))), {
 			concurrency: 8,
 			flush: flushPending
 		});
 		await forBatches(operations, (nodes) => {
 			if (needsCollectedOperations) collectedOperations?.push(...nodes);
-			return Promise.all(nodes.flatMap((n) => states.map((state) => dispatchNode(state, n, operationDispatch))));
+			return Promise.all(nodes.flatMap((node) => states.map((state) => dispatchNode(state, node, operationDispatch))));
 		}, {
 			concurrency: 8,
 			flush: flushPending
@@ -1922,23 +2549,17 @@ var KubbDriver = class KubbDriver {
 					...generatorContext,
 					options: plugin.options
 				};
-				const ops = collectedOperations ?? [];
-				const pluginOperations = state.optionsAreStatic ? ops : ops.filter((node) => {
-					const transformed = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
-					const { exclude, include, override } = plugin.options;
-					return generatorContext.resolver.resolveOptions(transformed, {
-						options: plugin.options,
-						exclude,
-						include,
-						override
-					}) !== null;
-				});
+				const pluginOperations = (collectedOperations ?? []).reduce((acc, node) => {
+					const resolved = resolveForPlugin(state, node);
+					if (resolved) acc.push(resolved.transformedNode);
+					return acc;
+				}, []);
 				for (const gen of generators) {
 					if (!gen.operations) continue;
-					await applyHookResult({
-						result: await gen.operations(pluginOperations, ctx),
-						driver,
-						rendererFactory: resolveRendererFor(gen, state)
+					const result = await gen.operations(pluginOperations, ctx);
+					await this.dispatch({
+						result,
+						renderer: gen.renderer
 					});
 				}
 				await this.hooks.emit("kubb:generate:operations", pluginOperations, ctx);
@@ -1947,60 +2568,80 @@ var KubbDriver = class KubbDriver {
 				state.error = caughtError;
 			}
 			const duration = getElapsedMs(state.hrStart);
-			timings.set(state.plugin.name, duration);
 			await this.#emitPluginEnd({
 				plugin: state.plugin,
 				duration,
 				success: !state.failed,
 				error: state.failed && state.error ? state.error : void 0
 			});
-			if (state.failed && state.error) failed.add({
-				plugin: state.plugin,
-				error: state.error
-			});
-			await this.hooks.emit("kubb:debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [state.failed ? "✗ Plugin start failed" : `✓ Plugin started successfully (${formatMs(duration)})`]
+			if (state.failed && state.error) diagnostics.push({
+				...Diagnostics.from(state.error),
+				plugin: state.plugin.name
 			});
+			diagnostics.push(Diagnostics.performance({
+				plugin: state.plugin.name,
+				duration
+			}));
 		}
-		return {
-			timings,
-			failed
-		};
+		return diagnostics;
 	}
 	/**
-	* Unregisters all plugin lifecycle listeners from the shared event emitter.
-	* Called at the end of a build to prevent listener leaks across repeated builds.
+	* Stores whatever a generator method or `kubb:generate:*` hook returned.
+	*
+	* - An `Array<FileNode>` goes straight into `fileManager` via `upsert`.
+	* - A renderer element runs through `renderer` (the renderer factory, e.g. JSX) and the
+	*   produced files go to `fileManager.upsert`.
+	* - A falsy result is treated as a no-op. The generator wrote files itself via
+	*   `ctx.upsertFile`.
+	*
+	* Pass `renderer` when the result may be a renderer element. Generators that only return
+	* `Array<FileNode>` do not need one.
+	*/
+	async dispatch({ result, renderer }) {
+		try {
+			var _usingCtx$1 = _usingCtx();
+			if (!result) return;
+			if (Array.isArray(result)) {
+				this.fileManager.upsert(...result);
+				return;
+			}
+			if (!renderer) return;
+			const instance = _usingCtx$1.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 (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
+	}
+	/**
+	* Removes every listener the driver added. Listeners attached directly to `hooks` from outside
+	* the driver survive. Called at the end of a build to prevent leaks across repeated builds.
 	*
 	* @internal
 	*/
 	dispose() {
-		for (const [event, handlers] of this.#hookListeners) for (const handler of handlers) this.hooks.off(event, handler);
-		this.#hookListeners.clear();
+		this.#registry.dispose();
 		this.#eventGeneratorPlugins.clear();
+		this.#transforms.dispose();
 		this.#resolvers.clear();
 		this.#defaultResolvers.clear();
 		this.fileManager.dispose();
-		this.#fileProcessor.dispose();
 		this.inputNode = null;
 		this.#studio = {
 			source: null,
 			isOpen: false,
 			inputNode: null
 		};
-		for (const [event, handler] of this.#middlewareListeners) this.hooks.off(event, handler);
 	}
 	[Symbol.dispose]() {
 		this.dispose();
 	}
-	#trackHookListener(event, handler) {
-		let handlers = this.#hookListeners.get(event);
-		if (!handlers) {
-			handlers = /* @__PURE__ */ new Set();
-			this.#hookListeners.set(event, handlers);
-		}
-		handlers.add(handler);
-	}
 	#getDefaultResolver = memoize(this.#defaultResolvers, (pluginName) => defineResolver(() => ({
 		name: "default",
 		pluginName
@@ -2024,6 +2665,12 @@ var KubbDriver = class KubbDriver {
 	}
 	getContext(plugin) {
 		const driver = this;
+		const report = (diagnostic) => {
+			Diagnostics.report({
+				...diagnostic,
+				plugin: plugin.name
+			});
+		};
 		return {
 			config: driver.config,
 			get root() {
@@ -2057,21 +2704,47 @@ var KubbDriver = class KubbDriver {
 				return driver.getResolver(plugin.name);
 			},
 			get transformer() {
-				return plugin.transformer;
+				return driver.#transforms.get(plugin.name);
 			},
 			warn(message) {
-				driver.hooks.emit("kubb:warn", { message });
+				report({
+					code: diagnosticCode.pluginWarning,
+					severity: "warning",
+					message
+				});
 			},
 			error(error) {
-				driver.hooks.emit("kubb:error", { error: typeof error === "string" ? new Error(error) : error });
+				const cause = typeof error === "string" ? void 0 : error;
+				report({
+					code: diagnosticCode.pluginFailed,
+					severity: "error",
+					message: typeof error === "string" ? error : error.message,
+					cause
+				});
 			},
 			info(message) {
-				driver.hooks.emit("kubb:info", { message });
+				report({
+					code: diagnosticCode.pluginInfo,
+					severity: "info",
+					message
+				});
 			},
 			async openInStudio(options) {
 				if (!driver.config.devtools || driver.#studio.isOpen) return;
-				if (typeof driver.config.devtools !== "object") throw new Error("Devtools must be an object");
-				if (!driver.adapter || !driver.#studio.source) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
+				if (typeof driver.config.devtools !== "object") throw new DiagnosticError({
+					code: diagnosticCode.devtoolsInvalid,
+					severity: "error",
+					message: "The `devtools` config must be an object.",
+					help: "Set `devtools` to an options object, or remove it to disable Kubb Studio.",
+					location: { kind: "config" }
+				});
+				if (!driver.adapter || !driver.#studio.source) throw new DiagnosticError({
+					code: diagnosticCode.adapterRequired,
+					severity: "error",
+					message: "An adapter is required to open Kubb Studio, but none is configured.",
+					help: "Set `adapter` in kubb.config.ts (for example `adapterOas()`).",
+					location: { kind: "config" }
+				});
 				driver.#studio.isOpen = true;
 				const studioUrl = driver.config.devtools?.studioUrl ?? "https://kubb.studio";
 				driver.#studio.inputNode ??= Promise.resolve(driver.adapter.parse(driver.#studio.source));
@@ -2084,59 +2757,25 @@ var KubbDriver = class KubbDriver {
 	}
 	requirePlugin(pluginName) {
 		const plugin = this.plugins.get(pluginName);
-		if (!plugin) throw new Error(`[kubb] Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`);
+		if (!plugin) throw new DiagnosticError({
+			code: diagnosticCode.pluginNotFound,
+			severity: "error",
+			message: `Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`,
+			help: `Add "${pluginName}" to the \`plugins\` array in kubb.config.ts, or remove the dependency on it.`,
+			location: { kind: "config" }
+		});
 		return plugin;
 	}
 };
-/**
-* Handles the return value of a plugin AST hook or generator method.
-*
-* - Renderer output → rendered via the provided `rendererFactory` (e.g. JSX), files stored in `driver.fileManager`
-* - `Array<FileNode>` → added directly into `driver.fileManager`
-* - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
-*
-* Pass a `rendererFactory` (e.g. `jsxRenderer` from `@kubb/renderer-jsx`) when the result
-* may be a renderer element. Generators that only return `Array<FileNode>` do not need one.
-*/
-function applyHookResult({ result, driver, rendererFactory }) {
-	if (!result) return;
-	if (Array.isArray(result)) {
-		driver.fileManager.upsert(...result);
-		return;
-	}
-	if (!rendererFactory) return;
-	const renderer = rendererFactory();
-	if (renderer.stream) try {
-		var _usingCtx$1 = _usingCtx();
-		const r = _usingCtx$1.u(renderer);
-		for (const file of r.stream(result)) driver.fileManager.upsert(file);
-		return;
-	} catch (_) {
-		_usingCtx$1.e = _;
-	} finally {
-		_usingCtx$1.d();
-	}
-	return applyAsyncRender({
-		renderer,
-		result,
-		driver
-	});
-}
-async function applyAsyncRender({ renderer, result, driver }) {
-	try {
-		var _usingCtx3 = _usingCtx();
-		const r = _usingCtx3.u(renderer);
-		await r.render(result);
-		driver.fileManager.upsert(...r.files);
-	} catch (_) {
-		_usingCtx3.e = _;
-	} finally {
-		_usingCtx3.d();
-	}
-}
 function inputToAdapterSource(config) {
 	const input = config.input;
-	if (!input) throw new Error("[kubb] input is required when using an adapter. Provide input.path or input.data in your config.");
+	if (!input) throw new DiagnosticError({
+		code: diagnosticCode.inputRequired,
+		severity: "error",
+		message: "An adapter is configured without an input.",
+		help: "Provide `input.path` (a file or URL) or `input.data` (an inline spec) in your Kubb config.",
+		location: { kind: "config" }
+	});
 	if ("data" in input) return {
 		type: "data",
 		data: input.data
@@ -2163,22 +2802,22 @@ Object.defineProperty(exports, "BuildError", {
 		return BuildError;
 	}
 });
-Object.defineProperty(exports, "DEFAULT_BANNER", {
+Object.defineProperty(exports, "DEFAULT_STUDIO_URL", {
 	enumerable: true,
 	get: function() {
-		return DEFAULT_BANNER;
+		return DEFAULT_STUDIO_URL;
 	}
 });
-Object.defineProperty(exports, "DEFAULT_EXTENSION", {
+Object.defineProperty(exports, "DiagnosticError", {
 	enumerable: true,
 	get: function() {
-		return DEFAULT_EXTENSION;
+		return DiagnosticError;
 	}
 });
-Object.defineProperty(exports, "DEFAULT_STUDIO_URL", {
+Object.defineProperty(exports, "Diagnostics", {
 	enumerable: true,
 	get: function() {
-		return DEFAULT_STUDIO_URL;
+		return Diagnostics;
 	}
 });
 Object.defineProperty(exports, "FileManager", {
@@ -2223,12 +2862,6 @@ Object.defineProperty(exports, "_usingCtx", {
 		return _usingCtx;
 	}
 });
-Object.defineProperty(exports, "applyHookResult", {
-	enumerable: true,
-	get: function() {
-		return applyHookResult;
-	}
-});
 Object.defineProperty(exports, "definePlugin", {
 	enumerable: true,
 	get: function() {
@@ -2241,11 +2874,47 @@ Object.defineProperty(exports, "defineResolver", {
 		return defineResolver;
 	}
 });
+Object.defineProperty(exports, "diagnosticCatalog", {
+	enumerable: true,
+	get: function() {
+		return diagnosticCatalog;
+	}
+});
+Object.defineProperty(exports, "diagnosticCode", {
+	enumerable: true,
+	get: function() {
+		return diagnosticCode;
+	}
+});
+Object.defineProperty(exports, "isPerformanceDiagnostic", {
+	enumerable: true,
+	get: function() {
+		return isPerformanceDiagnostic;
+	}
+});
+Object.defineProperty(exports, "isProblemDiagnostic", {
+	enumerable: true,
+	get: function() {
+		return isProblemDiagnostic;
+	}
+});
+Object.defineProperty(exports, "isUpdateDiagnostic", {
+	enumerable: true,
+	get: function() {
+		return isUpdateDiagnostic;
+	}
+});
 Object.defineProperty(exports, "logLevel", {
 	enumerable: true,
 	get: function() {
 		return logLevel;
 	}
 });
+Object.defineProperty(exports, "narrowDiagnostic", {
+	enumerable: true,
+	get: function() {
+		return narrowDiagnostic;
+	}
+});
 
-//# sourceMappingURL=KubbDriver-Dil5m3NF.cjs.map
+//# sourceMappingURL=KubbDriver-BYBUfOZ8.cjs.map