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

package/dist/index.js

@@ -1,187 +1,9 @@
 import "./chunk--u3MIqq1.js";
-import { a as definePlugin, c as DEFAULT_STUDIO_URL, d as forBatches, f as isPromise, i as defineResolver, l as logLevel, n as applyHookResult, o as DEFAULT_BANNER, p as withDrain, r as FileManager, s as DEFAULT_EXTENSION, t as KubbDriver, u as URLPath } from "./KubbDriver-Cxii_rBp.js";
-import { EventEmitter } from "node:events";
+import { a as FileManager, c as DEFAULT_BANNER, d as logLevel, f as URLPath, i as FileProcessor, l as DEFAULT_EXTENSION, m as BuildError, o as defineResolver, p as AsyncEventEmitter, r as _usingCtx, s as definePlugin, t as KubbDriver, u as DEFAULT_STUDIO_URL } from "./KubbDriver-Cq1isv2P.js";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import * as ast from "@kubb/ast";
-import { collectUsedSchemaNames, extractStringsFromNodes, transform } from "@kubb/ast";
 import { version } from "node:process";
-//#region ../../internals/utils/src/errors.ts
-/**
-* Thrown when one or more errors occur during a Kubb build.
-* Carries the full list of underlying errors on `errors`.
-*
-* @example
-* ```ts
-* throw new BuildError('Build failed', { errors: [err1, err2] })
-* ```
-*/
-var BuildError = class extends Error {
-	errors;
-	constructor(message, options) {
-		super(message, { cause: options.cause });
-		this.name = "BuildError";
-		this.errors = options.errors;
-	}
-};
-/**
-* Coerces an unknown thrown value to an `Error` instance.
-* Returns the value as-is when it is already an `Error`; otherwise wraps it with `String(value)`.
-*
-* @example
-* ```ts
-* try { ... } catch(err) {
-*   throw new BuildError('Build failed', { cause: toError(err), errors: [] })
-* }
-* ```
-*/
-function toError(value) {
-	return value instanceof Error ? value : new Error(String(value));
-}
-//#endregion
-//#region ../../internals/utils/src/asyncEventEmitter.ts
-/**
-* Typed `EventEmitter` that awaits all async listeners before resolving.
-* Wraps Node's `EventEmitter` with full TypeScript event-map inference.
-*
-* @example
-* ```ts
-* const emitter = new AsyncEventEmitter<{ build: [name: string] }>()
-* emitter.on('build', async (name) => { console.log(name) })
-* await emitter.emit('build', 'petstore') // all listeners awaited
-* ```
-*/
-var AsyncEventEmitter = class {
-	/**
-	* Maximum number of listeners per event before Node emits a memory-leak warning.
-	* @default 10
-	*/
-	constructor(maxListener = 10) {
-		this.#emitter.setMaxListeners(maxListener);
-	}
-	#emitter = new EventEmitter();
-	/**
-	* Emits `eventName` and awaits all registered listeners sequentially.
-	* Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
-	*
-	* @example
-	* ```ts
-	* await emitter.emit('build', 'petstore')
-	* ```
-	*/
-	emit(eventName, ...eventArgs) {
-		const listeners = this.#emitter.listeners(eventName);
-		if (listeners.length === 0) return;
-		return this.#emitAll(eventName, listeners, eventArgs);
-	}
-	async #emitAll(eventName, listeners, eventArgs) {
-		for (const listener of listeners) try {
-			await listener(...eventArgs);
-		} catch (err) {
-			let serializedArgs;
-			try {
-				serializedArgs = JSON.stringify(eventArgs);
-			} catch {
-				serializedArgs = String(eventArgs);
-			}
-			throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
-		}
-	}
-	/**
-	* Registers a persistent listener for `eventName`.
-	*
-	* @example
-	* ```ts
-	* emitter.on('build', async (name) => { console.log(name) })
-	* ```
-	*/
-	on(eventName, handler) {
-		this.#emitter.on(eventName, handler);
-	}
-	/**
-	* Registers a one-shot listener that removes itself after the first invocation.
-	*
-	* @example
-	* ```ts
-	* emitter.onOnce('build', async (name) => { console.log(name) })
-	* ```
-	*/
-	onOnce(eventName, handler) {
-		const wrapper = (...args) => {
-			this.off(eventName, wrapper);
-			return handler(...args);
-		};
-		this.on(eventName, wrapper);
-	}
-	/**
-	* Removes a previously registered listener.
-	*
-	* @example
-	* ```ts
-	* emitter.off('build', handler)
-	* ```
-	*/
-	off(eventName, handler) {
-		this.#emitter.off(eventName, handler);
-	}
-	/**
-	* Returns the number of listeners registered for `eventName`.
-	*
-	* @example
-	* ```ts
-	* emitter.on('build', handler)
-	* emitter.listenerCount('build') // 1
-	* ```
-	*/
-	listenerCount(eventName) {
-		return this.#emitter.listenerCount(eventName);
-	}
-	/**
-	* Removes all listeners from every event channel.
-	*
-	* @example
-	* ```ts
-	* emitter.removeAll()
-	* ```
-	*/
-	removeAll() {
-		this.#emitter.removeAllListeners();
-	}
-};
-//#endregion
-//#region ../../internals/utils/src/time.ts
-/**
-* Calculates elapsed time in milliseconds from a high-resolution `process.hrtime` start time.
-* Rounds to 2 decimal places for sub-millisecond precision without noise.
-*
-* @example
-* ```ts
-* const start = process.hrtime()
-* doWork()
-* getElapsedMs(start) // 42.35
-* ```
-*/
-function getElapsedMs(hrStart) {
-	const [seconds, nanoseconds] = process.hrtime(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/fs.ts
 /**
 * Resolves to `true` when the file or directory at `path` exists.
@@ -279,7 +101,7 @@ function createAdapter(build) {
 }
 //#endregion
 //#region package.json
-var version$1 = "5.0.0-beta.20";
+var version$1 = "5.0.0-beta.21";
 //#endregion
 //#region src/createStorage.ts
 /**
@@ -318,62 +140,6 @@ function createStorage(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
-//#region src/FileProcessor.ts
-function joinSources(file) {
-	const sources = file.sources;
-	if (sources.length === 0) return "";
-	const parts = [];
-	for (const source of sources) {
-		const s = extractStringsFromNodes(source.nodes);
-		if (s) parts.push(s);
-	}
-	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.
-*
-* @internal
-*/
-var FileProcessor = class {
-	events = new AsyncEventEmitter();
-	parse(file, { parsers, extension } = {}) {
-		const parseExtName = 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 = {}) {
-		const total = files.length;
-		if (total === 0) return;
-		let processed = 0;
-		for (const file of files) {
-			const source = this.parse(file, options);
-			processed++;
-			yield {
-				file,
-				source,
-				processed,
-				total,
-				percentage: processed / total * 100
-			};
-		}
-	}
-	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", {
-			file,
-			source,
-			processed,
-			percentage,
-			total
-		});
-		await this.events.emit("end", files);
-		return files;
-	}
-};
-//#endregion
 //#region src/storages/fsStorage.ts
 /**
 * Built-in filesystem storage driver.
@@ -448,74 +214,12 @@ const fsStorage = createStorage(() => ({
 	}
 }));
 //#endregion
-//#region \0@oxc-project+runtime@0.129.0/helpers/usingCtx.js
-function _usingCtx() {
-	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
-		var n = Error();
-		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
-	};
-	var e = {};
-	var n = [];
-	function using(r, e) {
-		if (null != e) {
-			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
-			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
-			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
-			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
-			t && (o = function o() {
-				try {
-					t.call(e);
-				} catch (r) {
-					return Promise.reject(r);
-				}
-			}), n.push({
-				v: e,
-				d: o,
-				a: r
-			});
-		} else r && n.push({
-			d: e,
-			a: r
-		});
-		return e;
-	}
-	return {
-		e,
-		u: using.bind(null, !1),
-		a: using.bind(null, !0),
-		d: function d() {
-			var o;
-			var t = this.e;
-			var s = 0;
-			function next() {
-				for (; o = n.pop();) try {
-					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
-					if (o.d) {
-						var r = o.d.call(o.v);
-						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
-					} else s |= 1;
-				} catch (r) {
-					return err(r);
-				}
-				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
-				if (t !== e) throw t;
-			}
-			function err(n) {
-				return t = t !== e ? new r(n, t) : n, next();
-			}
-			return next();
-		}
-	};
-}
-//#endregion
 //#region src/createKubb.ts
 /**
 * Builds a `Storage` view scoped to the file paths produced by the current build.
-*
-* Reads delegate to the underlying `storage` (typically `fsStorage()`) so source bytes
-* stay where they were written instead of being held in an extra in-memory map.
-* Writing via `setItem` stores the content in the underlying storage and registers the
-* key so subsequent reads and `getKeys` are scoped to this build's output.
+* Reads delegate to the underlying `storage` so source bytes stay where they were
+* written; writes register the key so subsequent reads and `getKeys` are scoped
+* to this build's output.
 */
 function createSourcesView(storage) {
 	const paths = /* @__PURE__ */ new Set();
@@ -547,9 +251,8 @@ function createSourcesView(storage) {
 		}
 	}))();
 }
-async function setup(userConfig, options = {}) {
-	const hooks = options.hooks ?? new AsyncEventEmitter();
-	const config = {
+function resolveConfig(userConfig) {
+	return {
 		...userConfig,
 		root: userConfig.root || process.cwd(),
 		parsers: userConfig.parsers ?? [],
@@ -567,422 +270,6 @@ async function setup(userConfig, options = {}) {
 		} : void 0,
 		plugins: userConfig.plugins ?? []
 	};
-	const driver = new KubbDriver(config, { hooks });
-	const storage = createSourcesView(config.storage);
-	const diagnosticInfo = getDiagnosticInfo();
-	await hooks.emit("kubb:debug", {
-		date: /* @__PURE__ */ new Date(),
-		logs: [
-			"Configuration:",
-			`  • Name: ${userConfig.name || "unnamed"}`,
-			`  • Root: ${userConfig.root || process.cwd()}`,
-			`  • Output: ${userConfig.output?.path || "not specified"}`,
-			`  • Plugins: ${userConfig.plugins?.length || 0}`,
-			"Output Settings:",
-			`  • Storage: ${config.storage.name}`,
-			`  • Formatter: ${userConfig.output?.format || "none"}`,
-			`  • Linter: ${userConfig.output?.lint || "none"}`,
-			`Running adapter: ${config.adapter?.name || "none"}`,
-			"Environment:",
-			Object.entries(diagnosticInfo).map(([key, value]) => `  • ${key}: ${value}`).join("\n")
-		]
-	});
-	try {
-		if (isInputPath(userConfig) && !new URLPath(userConfig.input.path).isURL) {
-			await exists(userConfig.input.path);
-			await hooks.emit("kubb:debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`✓ Input file validated: ${userConfig.input.path}`]
-			});
-		}
-	} catch (caughtError) {
-		if (isInputPath(userConfig)) {
-			const error = caughtError;
-			throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${userConfig.input.path}`, { cause: error });
-		}
-	}
-	if (config.output.clean) {
-		await hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: ["Cleaning output directories", `  • Output: ${config.output.path}`]
-		});
-		await config.storage.clear(resolve(config.root, config.output.path));
-	}
-	await driver.setup();
-	return {
-		config,
-		hooks,
-		driver,
-		storage,
-		dispose,
-		[Symbol.dispose]: dispose
-	};
-	function dispose() {
-		driver.dispose();
-	}
-}
-async function safeBuild(setupResult) {
-	try {
-		var _usingCtx$1 = _usingCtx();
-		_usingCtx$1.u(setupResult);
-		const { driver, hooks, storage } = setupResult;
-		const failedPlugins = /* @__PURE__ */ new Set();
-		const pluginTimings = /* @__PURE__ */ new Map();
-		const config = driver.config;
-		const writtenPaths = /* @__PURE__ */ new Set();
-		const parsersMap = /* @__PURE__ */ new Map();
-		const fileProcessor = new FileProcessor();
-		for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
-		async function flushPendingFiles() {
-			const files = driver.fileManager.files.filter((f) => !writtenPaths.has(f.path));
-			if (files.length === 0) return;
-			await hooks.emit("kubb:debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`Writing ${files.length} files...`]
-			});
-			await hooks.emit("kubb:files:processing:start", { files });
-			const stream = fileProcessor.stream(files, {
-				parsers: parsersMap,
-				extension: config.output.extension
-			});
-			const queue = [];
-			for (const { file, source, processed, total, percentage } of stream) {
-				writtenPaths.add(file.path);
-				queue.push((async () => {
-					await hooks.emit("kubb:file:processing:update", {
-						file,
-						source,
-						processed,
-						total,
-						percentage,
-						config
-					});
-					if (source) await storage.setItem(file.path, source);
-				})());
-				if (queue.length >= 50) await Promise.all(queue.splice(0));
-			}
-			await Promise.all(queue);
-			await hooks.emit("kubb:files:processing:end", { files });
-			await hooks.emit("kubb:debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`✓ File write process completed for ${files.length} files`]
-			});
-		}
-		async function dispatchOperationsToGenerators(generators, collectedOperations, ctx, rendererFor) {
-			for (const gen of generators) {
-				if (!gen.operations) continue;
-				await applyHookResult({
-					result: await gen.operations(collectedOperations, ctx),
-					driver,
-					rendererFactory: rendererFor(gen)
-				});
-			}
-			await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
-		}
-		/**
-		* Single-pass fan-out: iterates all schemas and operations once, distributing each node
-		* to every generator-plugin in parallel. This replaces the N-pass-per-plugin pattern
-		* (each plugin getting its own iterator) with one parse pass fanned to all plugins,
-		* eliminating the N×parse-time overhead for multi-plugin builds.
-		*/
-		async function runPlugins(entries) {
-			const { schemas, operations } = driver.inputNode;
-			const operationFilterTypes = new Set([
-				"tag",
-				"operationId",
-				"path",
-				"method",
-				"contentType"
-			]);
-			const states = entries.map(({ plugin, context, hrStart }) => {
-				const { exclude, include, override } = plugin.options;
-				const hasExclude = Array.isArray(exclude) && exclude.length > 0;
-				const hasInclude = Array.isArray(include) && include.length > 0;
-				const hasOverride = Array.isArray(override) && override.length > 0;
-				return {
-					plugin,
-					generatorContext: {
-						...context,
-						resolver: driver.getResolver(plugin.name)
-					},
-					generators: plugin.generators ?? [],
-					hrStart,
-					failed: false,
-					error: void 0,
-					optionsAreStatic: !hasExclude && !hasInclude && !hasOverride,
-					allowedSchemaNames: void 0
-				};
-			});
-			const pruningStates = states.filter(({ plugin }) => {
-				const { include } = plugin.options;
-				return (include?.some(({ type }) => operationFilterTypes.has(type)) ?? false) && !(include?.some(({ type }) => type === "schemaName") ?? false);
-			});
-			if (pruningStates.length > 0) {
-				const allSchemas = [];
-				for await (const schema of schemas) allSchemas.push(schema);
-				const includedOpsByState = new Map(pruningStates.map((s) => [s, []]));
-				for await (const operation of operations) for (const state of pruningStates) {
-					const { exclude, include, override } = state.plugin.options;
-					if (state.generatorContext.resolver.resolveOptions(operation, {
-						options: state.plugin.options,
-						exclude,
-						include,
-						override
-					}) !== null) includedOpsByState.get(state)?.push(operation);
-				}
-				for (const state of pruningStates) state.allowedSchemaNames = collectUsedSchemaNames(includedOpsByState.get(state) ?? [], allSchemas);
-			}
-			function resolveRendererFor(gen, state) {
-				return gen.renderer === null ? void 0 : gen.renderer ?? state.plugin.renderer ?? state.generatorContext.config.renderer;
-			}
-			async function dispatchSchema(state, node) {
-				if (state.failed) return;
-				try {
-					const { plugin, generatorContext, generators } = state;
-					const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-					if (state.allowedSchemaNames !== void 0 && transformedNode.name && !state.allowedSchemaNames.has(transformedNode.name)) return;
-					const { exclude, include, override } = plugin.options;
-					const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
-						options: plugin.options,
-						exclude,
-						include,
-						override
-					});
-					if (options === null) return;
-					const ctx = {
-						...generatorContext,
-						options
-					};
-					for (const gen of generators) {
-						if (!gen.schema) continue;
-						const raw = gen.schema(transformedNode, ctx);
-						const applied = applyHookResult({
-							result: isPromise(raw) ? await raw : raw,
-							driver,
-							rendererFactory: resolveRendererFor(gen, state)
-						});
-						if (isPromise(applied)) await applied;
-					}
-					await driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
-				} catch (caughtError) {
-					state.failed = true;
-					state.error = caughtError;
-				}
-			}
-			async function dispatchOperation(state, node) {
-				if (state.failed) return;
-				try {
-					const { plugin, generatorContext, generators } = state;
-					const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node;
-					const { exclude, include, override } = plugin.options;
-					const options = state.optionsAreStatic ? plugin.options : generatorContext.resolver.resolveOptions(transformedNode, {
-						options: plugin.options,
-						exclude,
-						include,
-						override
-					});
-					if (options === null) return;
-					const ctx = {
-						...generatorContext,
-						options
-					};
-					for (const gen of generators) {
-						if (!gen.operation) continue;
-						const raw = gen.operation(transformedNode, ctx);
-						const applied = applyHookResult({
-							result: isPromise(raw) ? await raw : raw,
-							driver,
-							rendererFactory: resolveRendererFor(gen, state)
-						});
-						if (isPromise(applied)) await applied;
-					}
-					await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
-				} catch (caughtError) {
-					state.failed = true;
-					state.error = caughtError;
-				}
-			}
-			await forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((n) => states.map((state) => dispatchSchema(state, n)))), {
-				concurrency: 8,
-				flush: flushPendingFiles
-			});
-			const collectedOperations = [];
-			await forBatches(operations, (nodes) => {
-				collectedOperations.push(...nodes);
-				return Promise.all(nodes.flatMap((n) => states.map((state) => dispatchOperation(state, n))));
-			}, {
-				concurrency: 8,
-				flush: flushPendingFiles
-			});
-			for (const state of states) {
-				if (!state.failed) try {
-					const { plugin, generatorContext, generators } = state;
-					await dispatchOperationsToGenerators(generators, collectedOperations, {
-						...generatorContext,
-						options: plugin.options
-					}, (gen) => resolveRendererFor(gen, state));
-				} catch (caughtError) {
-					state.failed = true;
-					state.error = caughtError;
-				}
-				const duration = getElapsedMs(state.hrStart);
-				pluginTimings.set(state.plugin.name, duration);
-				await driver.hooks.emit("kubb:plugin:end", {
-					plugin: state.plugin,
-					duration,
-					success: !state.failed,
-					...state.failed && state.error ? { error: state.error } : {},
-					config: driver.config,
-					get files() {
-						return driver.fileManager.files;
-					},
-					upsertFile: (...files) => driver.fileManager.upsert(...files)
-				});
-				if (state.failed && state.error) failedPlugins.add({
-					plugin: state.plugin,
-					error: state.error
-				});
-				await driver.hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [state.failed ? "✗ Plugin start failed" : `✓ Plugin started successfully (${formatMs(duration)})`]
-				});
-			}
-		}
-		try {
-			await driver.emitSetupHooks();
-			if (driver.adapter && driver.inputNode) await hooks.emit("kubb:build:start", {
-				config,
-				adapter: driver.adapter,
-				meta: driver.inputNode.meta,
-				getPlugin: driver.getPlugin.bind(driver),
-				get files() {
-					return driver.fileManager.files;
-				},
-				upsertFile: (...files) => driver.fileManager.upsert(...files)
-			});
-			const generatorPlugins = [];
-			for (const plugin of driver.plugins.values()) {
-				const context = driver.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;
-					const duration = getElapsedMs(hrStart);
-					pluginTimings.set(plugin.name, duration);
-					await hooks.emit("kubb:plugin:end", {
-						plugin,
-						duration,
-						success: false,
-						error,
-						config,
-						get files() {
-							return driver.fileManager.files;
-						},
-						upsertFile: (...files) => driver.fileManager.upsert(...files)
-					});
-					failedPlugins.add({
-						plugin,
-						error
-					});
-					continue;
-				}
-				if (plugin.generators?.length || driver.hasEventGenerators(plugin.name)) {
-					generatorPlugins.push({
-						plugin,
-						context,
-						hrStart
-					});
-					continue;
-				}
-				const duration = getElapsedMs(hrStart);
-				pluginTimings.set(plugin.name, duration);
-				await hooks.emit("kubb:plugin:end", {
-					plugin,
-					duration,
-					success: true,
-					config,
-					get files() {
-						return driver.fileManager.files;
-					},
-					upsertFile: (...files) => driver.fileManager.upsert(...files)
-				});
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
-				});
-			}
-			if (generatorPlugins.length > 0) if (driver.inputNode) await withDrain(() => runPlugins(generatorPlugins), flushPendingFiles);
-			else for (const { plugin, hrStart } of generatorPlugins) {
-				const duration = getElapsedMs(hrStart);
-				pluginTimings.set(plugin.name, duration);
-				await hooks.emit("kubb:plugin:end", {
-					plugin,
-					duration,
-					success: true,
-					config,
-					get files() {
-						return driver.fileManager.files;
-					},
-					upsertFile: (...files) => driver.fileManager.upsert(...files)
-				});
-			}
-			await hooks.emit("kubb:plugins:end", {
-				config,
-				get files() {
-					return driver.fileManager.files;
-				},
-				upsertFile: (...files) => driver.fileManager.upsert(...files)
-			});
-			await flushPendingFiles();
-			const files = driver.fileManager.files;
-			await hooks.emit("kubb:build:end", {
-				files,
-				config,
-				outputDir: resolve(config.root, config.output.path)
-			});
-			return {
-				failedPlugins,
-				files,
-				driver,
-				pluginTimings,
-				storage
-			};
-		} catch (error) {
-			return {
-				failedPlugins,
-				files: [],
-				driver,
-				pluginTimings,
-				error,
-				storage
-			};
-		}
-	} catch (_) {
-		_usingCtx$1.e = _;
-	} finally {
-		_usingCtx$1.d();
-	}
-}
-async function build(setupResult) {
-	const { files, driver, failedPlugins, pluginTimings, error, storage } = await safeBuild(setupResult);
-	if (error) throw error;
-	if (failedPlugins.size > 0) {
-		const errors = [...failedPlugins].map(({ error }) => error);
-		throw new BuildError(`Build Error with ${failedPlugins.size} failed plugins`, { errors });
-	}
-	return {
-		failedPlugins,
-		files,
-		driver,
-		pluginTimings,
-		error: void 0,
-		storage
-	};
 }
 /**
 * Returns a snapshot of the current runtime environment.
@@ -1003,56 +290,143 @@ function isInputPath(config) {
 	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
 }
 /**
-* Creates a Kubb instance bound to a single config entry.
+* Kubb code-generation instance bound to a single config entry. Resolves the user
+* config during `setup()` and shares `hooks`, `storage`, `driver`, and `config` across
+* the `setup → build` lifecycle.
 *
-* Accepts a user-facing config shape and resolves it to a full {@link Config} during
-* `setup()`. The instance then holds shared state (`hooks`, `storage`, `driver`, `config`)
-* across the `setup → build` lifecycle. Attach event listeners to `kubb.hooks` before
-* calling `setup()` or `build()`.
+* Attach event listeners to `.hooks` before calling `setup()` or `build()`.
 *
 * @example
 * ```ts
 * const kubb = createKubb(userConfig)
-*
-* kubb.hooks.on('kubb:plugin:end', ({ plugin, duration }) => {
-*   console.log(`${plugin.name} completed in ${duration}ms`)
-* })
-*
+* kubb.hooks.on('kubb:plugin:end', ({ plugin, duration }) => console.log(plugin.name, duration))
 * const { files, failedPlugins } = await kubb.safeBuild()
 * ```
 */
-function createKubb(userConfig, options = {}) {
-	const hooks = options.hooks ?? new AsyncEventEmitter();
-	let setupResult;
-	const instance = {
-		get hooks() {
-			return hooks;
-		},
-		get storage() {
-			if (!setupResult) throw new Error("[kubb] setup() must be called before accessing storage");
-			return setupResult.storage;
-		},
-		get driver() {
-			if (!setupResult) throw new Error("[kubb] setup() must be called before accessing driver");
-			return setupResult.driver;
-		},
-		get config() {
-			if (!setupResult) throw new Error("[kubb] setup() must be called before accessing config");
-			return setupResult.config;
-		},
-		async setup() {
-			setupResult = await setup(userConfig, { hooks });
-		},
-		async build() {
-			if (!setupResult) await instance.setup();
-			return build(setupResult);
-		},
-		async safeBuild() {
-			if (!setupResult) await instance.setup();
-			return safeBuild(setupResult);
+var Kubb = class {
+	hooks;
+	#userConfig;
+	#config = null;
+	#driver = null;
+	#storage = null;
+	constructor(userConfig, options = {}) {
+		this.#userConfig = userConfig;
+		this.hooks = options.hooks ?? new AsyncEventEmitter();
+	}
+	get storage() {
+		if (!this.#storage) throw new Error("[kubb] setup() must be called before accessing storage");
+		return this.#storage;
+	}
+	get driver() {
+		if (!this.#driver) throw new Error("[kubb] setup() must be called before accessing driver");
+		return this.#driver;
+	}
+	get config() {
+		if (!this.#config) throw new Error("[kubb] setup() must be called before accessing config");
+		return this.#config;
+	}
+	/**
+	* Resolves config and initializes the driver. `build()` calls this automatically.
+	*/
+	async setup() {
+		const config = resolveConfig(this.#userConfig);
+		const driver = new KubbDriver(config, { hooks: this.hooks });
+		const storage = createSourcesView(config.storage);
+		await this.hooks.emit("kubb:debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: this.#configLogs(config)
+		});
+		if (isInputPath(this.#userConfig) && !new URLPath(this.#userConfig.input.path).isURL) try {
+			await exists(this.#userConfig.input.path);
+			await this.hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [`✓ Input file validated: ${this.#userConfig.input.path}`]
+			});
+		} catch (caughtError) {
+			throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${this.#userConfig.input.path}`, { cause: caughtError });
 		}
-	};
-	return instance;
+		if (config.output.clean) {
+			await this.hooks.emit("kubb:debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: ["Cleaning output directories", `  • Output: ${config.output.path}`]
+			});
+			await config.storage.clear(resolve(config.root, config.output.path));
+		}
+		await driver.setup();
+		this.#config = config;
+		this.#driver = driver;
+		this.#storage = storage;
+	}
+	/**
+	* Runs the full pipeline and throws on any plugin error.
+	* Automatically calls `setup()` if needed.
+	*/
+	async build() {
+		const out = await this.safeBuild();
+		if (out.error) throw out.error;
+		if (out.failedPlugins.size > 0) {
+			const errors = [...out.failedPlugins].map(({ error }) => error);
+			throw new BuildError(`Build Error with ${out.failedPlugins.size} failed plugins`, { errors });
+		}
+		return out;
+	}
+	/**
+	* Runs the full pipeline and captures errors in `BuildOutput` instead of throwing.
+	* Automatically calls `setup()` if needed.
+	*/
+	async safeBuild() {
+		try {
+			var _usingCtx$1 = _usingCtx();
+			if (!this.#driver) await this.setup();
+			const cleanup = _usingCtx$1.u(this);
+			const driver = cleanup.driver;
+			const storage = cleanup.storage;
+			const { failedPlugins, pluginTimings, error } = await driver.run({ storage });
+			return {
+				failedPlugins,
+				files: driver.fileManager.files,
+				driver,
+				pluginTimings,
+				storage,
+				...error ? { error } : {}
+			};
+		} catch (_) {
+			_usingCtx$1.e = _;
+		} finally {
+			_usingCtx$1.d();
+		}
+	}
+	dispose() {
+		this.#driver?.dispose();
+	}
+	[Symbol.dispose]() {
+		this.dispose();
+	}
+	#configLogs(config) {
+		const u = this.#userConfig;
+		const diag = getDiagnosticInfo();
+		return [
+			"Configuration:",
+			`  • Name: ${u.name || "unnamed"}`,
+			`  • Root: ${u.root || process.cwd()}`,
+			`  • Output: ${u.output?.path || "not specified"}`,
+			`  • Plugins: ${u.plugins?.length || 0}`,
+			"Output Settings:",
+			`  • Storage: ${config.storage.name}`,
+			`  • Formatter: ${u.output?.format || "none"}`,
+			`  • Linter: ${u.output?.lint || "none"}`,
+			`Running adapter: ${config.adapter?.name || "none"}`,
+			"Environment:",
+			Object.entries(diag).map(([key, value]) => `  • ${key}: ${value}`).join("\n")
+		];
+	}
+};
+/**
+* Factory for {@link Kubb}. Equivalent to `new Kubb(userConfig, options)` and kept
+* as the canonical public entry point.
+*/
+function createKubb(userConfig, options = {}) {
+	return new Kubb(userConfig, options);
 }
 //#endregion
 //#region src/createRenderer.ts
@@ -1066,6 +440,7 @@ function createKubb(userConfig, options = {}) {
 *   return {
 *     async render(element) { await runtime.render(element) },
 *     get files() { return runtime.nodes },
+*     dispose() { runtime.unmount() },
 *     unmount(error) { runtime.unmount(error) },
 *   }
 * })