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

package/dist/index.cjs

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_PluginDriver = require("./PluginDriver-BXibeQk-.cjs");
+const require_KubbDriver = require("./KubbDriver-BXSnJ3qM.cjs");
 let node_events = require("node:events");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 let _kubb_ast = require("@kubb/ast");
-_kubb_ast = require_PluginDriver.__toESM(_kubb_ast, 1);
+_kubb_ast = require_KubbDriver.__toESM(_kubb_ast, 1);
 let node_process = require("node:process");
 //#region ../../internals/utils/src/errors.ts
 /**
@@ -69,9 +69,12 @@ var AsyncEventEmitter = class {
 	* await emitter.emit('build', 'petstore')
 	* ```
 	*/
-	async emit(eventName, ...eventArgs) {
+	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) {
@@ -245,255 +248,6 @@ async function clean(path) {
 	});
 }
 //#endregion
-//#region ../../internals/utils/src/reserved.ts
-/**
-* JavaScript and Java reserved words.
-* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
-*/
-const reservedWords = new Set([
-	"abstract",
-	"arguments",
-	"boolean",
-	"break",
-	"byte",
-	"case",
-	"catch",
-	"char",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"double",
-	"else",
-	"enum",
-	"eval",
-	"export",
-	"extends",
-	"false",
-	"final",
-	"finally",
-	"float",
-	"for",
-	"function",
-	"goto",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"int",
-	"interface",
-	"let",
-	"long",
-	"native",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"short",
-	"static",
-	"super",
-	"switch",
-	"synchronized",
-	"this",
-	"throw",
-	"throws",
-	"transient",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"volatile",
-	"while",
-	"with",
-	"yield",
-	"Array",
-	"Date",
-	"hasOwnProperty",
-	"Infinity",
-	"isFinite",
-	"isNaN",
-	"isPrototypeOf",
-	"length",
-	"Math",
-	"name",
-	"NaN",
-	"Number",
-	"Object",
-	"prototype",
-	"String",
-	"toString",
-	"undefined",
-	"valueOf"
-]);
-/**
-* Returns `true` when `name` is a syntactically valid JavaScript variable name.
-*
-* @example
-* ```ts
-* isValidVarName('status')  // true
-* isValidVarName('class')   // false (reserved word)
-* isValidVarName('42foo')   // false (starts with digit)
-* ```
-*/
-function isValidVarName(name) {
-	if (!name || reservedWords.has(name)) return false;
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
-}
-//#endregion
-//#region ../../internals/utils/src/urlPath.ts
-/**
-* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
-*
-* @example
-* const p = new URLPath('/pet/{petId}')
-* p.URL      // '/pet/:petId'
-* p.template // '`/pet/${petId}`'
-*/
-var URLPath = class {
-	/**
-	* The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`.
-	*/
-	path;
-	#options;
-	constructor(path, options = {}) {
-		this.path = path;
-		this.#options = options;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').URL // '/pet/:petId'
-	* ```
-	*/
-	get URL() {
-		return this.toURLPath();
-	}
-	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`).
-	*
-	* @example
-	* ```ts
-	* new URLPath('https://petstore.swagger.io/v2/pet').isURL // true
-	* new URLPath('/pet/{petId}').isURL                       // false
-	* ```
-	*/
-	get isURL() {
-		try {
-			return !!new URL(this.path).href;
-		} catch {
-			return false;
-		}
-	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
-	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
-	*/
-	get template() {
-		return this.toTemplateString();
-	}
-	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').object
-	* // { url: '/pet/:petId', params: { petId: 'petId' } }
-	* ```
-	*/
-	get object() {
-		return this.toObject();
-	}
-	/** Returns a map of path parameter names, or `undefined` when the path has no parameters.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').params // { petId: 'petId' }
-	* new URLPath('/pet').params         // undefined
-	* ```
-	*/
-	get params() {
-		return this.getParams();
-	}
-	#transformParam(raw) {
-		const param = isValidVarName(raw) ? raw : require_PluginDriver.camelCase(raw);
-		return this.#options.casing === "camelcase" ? require_PluginDriver.camelCase(param) : param;
-	}
-	/**
-	* Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name.
-	*/
-	#eachParam(fn) {
-		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
-			const raw = match[1];
-			fn(raw, this.#transformParam(raw));
-		}
-	}
-	toObject({ type = "path", replacer, stringify } = {}) {
-		const object = {
-			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
-			params: this.getParams()
-		};
-		if (stringify) {
-			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
-			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
-			return `{ url: '${object.url}' }`;
-		}
-		return object;
-	}
-	/**
-	* Converts the OpenAPI path to a TypeScript template literal string.
-	* An optional `replacer` can transform each extracted parameter name before interpolation.
-	*
-	* @example
-	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
-	*/
-	toTemplateString({ prefix = "", replacer } = {}) {
-		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
-			if (i % 2 === 0) return part;
-			const param = this.#transformParam(part);
-			return `\${${replacer ? replacer(param) : param}}`;
-		}).join("")}\``;
-	}
-	/**
-	* Extracts all `{param}` segments from the path and returns them as a key-value map.
-	* An optional `replacer` transforms each parameter name in both key and value positions.
-	* Returns `undefined` when no path parameters are found.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}/tag/{tagId}').getParams()
-	* // { petId: 'petId', tagId: 'tagId' }
-	* ```
-	*/
-	getParams(replacer) {
-		const params = {};
-		this.#eachParam((_raw, param) => {
-			const key = replacer ? replacer(param) : param;
-			params[key] = key;
-		});
-		return Object.keys(params).length > 0 ? params : void 0;
-	}
-	/** Converts the OpenAPI path to Express-style colon syntax.
-	*
-	* @example
-	* ```ts
-	* new URLPath('/pet/{petId}').toURLPath() // '/pet/:petId'
-	* ```
-	*/
-	toURLPath() {
-		return this.path.replace(/\{([^}]+)\}/g, ":$1");
-	}
-};
-//#endregion
 //#region src/createAdapter.ts
 /**
 * Factory for implementing custom adapters that translate non-OpenAPI specs into Kubb's AST.
@@ -524,177 +278,8 @@ function createAdapter(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
-//#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
-var Node = class {
-	value;
-	next;
-	constructor(value) {
-		this.value = value;
-	}
-};
-var Queue = class {
-	#head;
-	#tail;
-	#size;
-	constructor() {
-		this.clear();
-	}
-	enqueue(value) {
-		const node = new Node(value);
-		if (this.#head) {
-			this.#tail.next = node;
-			this.#tail = node;
-		} else {
-			this.#head = node;
-			this.#tail = node;
-		}
-		this.#size++;
-	}
-	dequeue() {
-		const current = this.#head;
-		if (!current) return;
-		this.#head = this.#head.next;
-		this.#size--;
-		if (!this.#head) this.#tail = void 0;
-		return current.value;
-	}
-	peek() {
-		if (!this.#head) return;
-		return this.#head.value;
-	}
-	clear() {
-		this.#head = void 0;
-		this.#tail = void 0;
-		this.#size = 0;
-	}
-	get size() {
-		return this.#size;
-	}
-	*[Symbol.iterator]() {
-		let current = this.#head;
-		while (current) {
-			yield current.value;
-			current = current.next;
-		}
-	}
-	*drain() {
-		while (this.#head) yield this.dequeue();
-	}
-};
-//#endregion
-//#region ../../node_modules/.pnpm/p-limit@7.3.0/node_modules/p-limit/index.js
-function pLimit(concurrency) {
-	let rejectOnClear = false;
-	if (typeof concurrency === "object") ({concurrency, rejectOnClear = false} = concurrency);
-	validateConcurrency(concurrency);
-	if (typeof rejectOnClear !== "boolean") throw new TypeError("Expected `rejectOnClear` to be a boolean");
-	const queue = new Queue();
-	let activeCount = 0;
-	const resumeNext = () => {
-		if (activeCount < concurrency && queue.size > 0) {
-			activeCount++;
-			queue.dequeue().run();
-		}
-	};
-	const next = () => {
-		activeCount--;
-		resumeNext();
-	};
-	const run = async (function_, resolve, arguments_) => {
-		const result = (async () => function_(...arguments_))();
-		resolve(result);
-		try {
-			await result;
-		} catch {}
-		next();
-	};
-	const enqueue = (function_, resolve, reject, arguments_) => {
-		const queueItem = { reject };
-		new Promise((internalResolve) => {
-			queueItem.run = internalResolve;
-			queue.enqueue(queueItem);
-		}).then(run.bind(void 0, function_, resolve, arguments_));
-		if (activeCount < concurrency) resumeNext();
-	};
-	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
-		enqueue(function_, resolve, reject, arguments_);
-	});
-	Object.defineProperties(generator, {
-		activeCount: { get: () => activeCount },
-		pendingCount: { get: () => queue.size },
-		clearQueue: { value() {
-			if (!rejectOnClear) {
-				queue.clear();
-				return;
-			}
-			const abortError = AbortSignal.abort().reason;
-			while (queue.size > 0) queue.dequeue().reject(abortError);
-		} },
-		concurrency: {
-			get: () => concurrency,
-			set(newConcurrency) {
-				validateConcurrency(newConcurrency);
-				concurrency = newConcurrency;
-				queueMicrotask(() => {
-					while (activeCount < concurrency && queue.size > 0) resumeNext();
-				});
-			}
-		},
-		map: { async value(iterable, function_) {
-			const promises = Array.from(iterable, (value, index) => this(function_, value, index));
-			return Promise.all(promises);
-		} }
-	});
-	return generator;
-}
-function validateConcurrency(concurrency) {
-	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
-}
-//#endregion
-//#region src/FileProcessor.ts
-function joinSources(file) {
-	return file.sources.map((item) => (0, _kubb_ast.extractStringsFromNodes)(item.nodes)).filter(Boolean).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 {
-	#limit = pLimit(100);
-	async 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 });
-	}
-	async run(files, { parsers, mode = "sequential", extension, onStart, onEnd, onUpdate } = {}) {
-		await onStart?.(files);
-		const total = files.length;
-		let processed = 0;
-		const processOne = async (file) => {
-			const source = await this.parse(file, {
-				extension,
-				parsers
-			});
-			const currentProcessed = ++processed;
-			const percentage = currentProcessed / total * 100;
-			await onUpdate?.({
-				file,
-				source,
-				processed: currentProcessed,
-				percentage,
-				total
-			});
-		};
-		if (mode === "sequential") for (const file of files) await processOne(file);
-		else await Promise.all(files.map((file) => this.#limit(() => processOne(file))));
-		await onEnd?.(files);
-		return files;
-	}
-};
+//#region package.json
+var version = "5.0.0-beta.20";
 //#endregion
 //#region src/createStorage.ts
 /**
@@ -733,13 +318,63 @@ function createStorage(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
-//#region src/storages/fsStorage.ts
+//#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 = (0, _kubb_ast.extractStringsFromNodes)(source.nodes);
+		if (s) parts.push(s);
+	}
+	return parts.join("\n\n");
+}
 /**
-* Detects the filesystem error used to indicate that a path does not exist.
+* Converts a single file to a string using the registered parsers.
+* Falls back to joining source values when no matching parser is found.
+*
+* @internal
 */
-function isMissingPathError(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
+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.
 *
@@ -771,17 +406,15 @@ const fsStorage = createStorage(() => ({
 		try {
 			await (0, node_fs_promises.access)((0, node_path.resolve)(key));
 			return true;
-		} catch (error) {
-			if (isMissingPathError(error)) return false;
-			throw new Error(`Failed to access storage item "${key}"`, { cause: error });
+		} catch (_error) {
+			return false;
 		}
 	},
 	async getItem(key) {
 		try {
 			return await (0, node_fs_promises.readFile)((0, node_path.resolve)(key), "utf8");
-		} catch (error) {
-			if (isMissingPathError(error)) return null;
-			throw new Error(`Failed to read storage item "${key}"`, { cause: error });
+		} catch (_error) {
+			return null;
 		}
 	},
 	async setItem(key, value) {
@@ -791,23 +424,22 @@ const fsStorage = createStorage(() => ({
 		await (0, node_fs_promises.rm)((0, node_path.resolve)(key), { force: true });
 	},
 	async getKeys(base) {
-		const keys = [];
 		const resolvedBase = (0, node_path.resolve)(base ?? process.cwd());
-		async function walk(dir, prefix) {
+		async function* walk(dir, prefix) {
 			let entries;
 			try {
 				entries = await (0, node_fs_promises.readdir)(dir, { withFileTypes: true });
-			} catch (error) {
-				if (isMissingPathError(error)) return;
-				throw new Error(`Failed to list storage keys under "${resolvedBase}"`, { cause: error });
+			} catch (_error) {
+				return;
 			}
 			for (const entry of entries) {
 				const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-				if (entry.isDirectory()) await walk((0, node_path.join)(dir, entry.name), rel);
-				else keys.push(rel);
+				if (entry.isDirectory()) yield* walk((0, node_path.join)(dir, entry.name), rel);
+				else yield rel;
 			}
 		}
-		await walk(resolvedBase, "");
+		const keys = [];
+		for await (const key of walk(resolvedBase, "")) keys.push(key);
 		return keys;
 	},
 	async clear(base) {
@@ -816,37 +448,128 @@ const fsStorage = createStorage(() => ({
 	}
 }));
 //#endregion
-//#region package.json
-var version = "5.0.0-beta.2";
-//#endregion
-//#region src/utils/diagnostics.ts
-/**
-* Returns a snapshot of the current runtime environment.
-*
-* Useful for attaching context to debug logs and error reports so that
-* issues can be reproduced without manual information gathering.
-*/
-function getDiagnosticInfo() {
+//#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 {
-		nodeVersion: node_process.version,
-		KubbVersion: version,
-		platform: process.platform,
-		arch: process.arch,
-		cwd: process.cwd()
+		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/utils/isInputPath.ts
-function isInputPath(config) {
-	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
-}
-//#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.
+*/
+function createSourcesView(storage) {
+	const paths = /* @__PURE__ */ new Set();
+	return createStorage(() => ({
+		name: `${storage.name}:sources`,
+		async hasItem(key) {
+			return paths.has(key) && await storage.hasItem(key);
+		},
+		async getItem(key) {
+			return paths.has(key) ? storage.getItem(key) : null;
+		},
+		async setItem(key, value) {
+			paths.add(key);
+			await storage.setItem(key, value);
+		},
+		async removeItem(key) {
+			paths.delete(key);
+			await storage.removeItem(key);
+		},
+		async getKeys(base) {
+			if (!base) return [...paths];
+			const result = [];
+			for (const key of paths) if (key.startsWith(base)) result.push(key);
+			return result;
+		},
+		async clear() {
+			paths.clear();
+			await storage.clear();
+		}
+	}))();
+}
 async function setup(userConfig, options = {}) {
 	const hooks = options.hooks ?? new AsyncEventEmitter();
-	const sources = /* @__PURE__ */ new Map();
+	const config = {
+		...userConfig,
+		root: userConfig.root || process.cwd(),
+		parsers: userConfig.parsers ?? [],
+		output: {
+			format: false,
+			lint: false,
+			extension: require_KubbDriver.DEFAULT_EXTENSION,
+			defaultBanner: require_KubbDriver.DEFAULT_BANNER,
+			...userConfig.output
+		},
+		storage: userConfig.storage ?? fsStorage(),
+		devtools: userConfig.devtools ? {
+			studioUrl: require_KubbDriver.DEFAULT_STUDIO_URL,
+			...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
+		} : void 0,
+		plugins: userConfig.plugins ?? []
+	};
+	const driver = new require_KubbDriver.KubbDriver(config, { hooks });
+	const storage = createSourcesView(config.storage);
 	const diagnosticInfo = getDiagnosticInfo();
-	if (Array.isArray(userConfig.input)) await hooks.emit("kubb:warn", { message: "This feature is still under development — use with caution" });
 	await hooks.emit("kubb:debug", {
 		date: /* @__PURE__ */ new Date(),
 		logs: [
@@ -856,15 +579,16 @@ async function setup(userConfig, options = {}) {
 			`  • Output: ${userConfig.output?.path || "not specified"}`,
 			`  • Plugins: ${userConfig.plugins?.length || 0}`,
 			"Output Settings:",
-			`  • Storage: ${userConfig.storage ? `custom(${userConfig.storage.name})` : userConfig.output?.write === false ? "disabled" : "filesystem (default)"}`,
+			`  • 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) {
+		if (isInputPath(userConfig) && !new require_KubbDriver.URLPath(userConfig.input.path).isURL) {
 			await exists(userConfig.input.path);
 			await hooks.emit("kubb:debug", {
 				date: /* @__PURE__ */ new Date(),
@@ -877,188 +601,304 @@ async function setup(userConfig, options = {}) {
 			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 (!userConfig.adapter) throw new Error("Adapter should be defined");
-	const config = {
-		...userConfig,
-		root: userConfig.root || process.cwd(),
-		parsers: userConfig.parsers ?? [],
-		adapter: userConfig.adapter,
-		output: {
-			format: false,
-			lint: false,
-			write: true,
-			extension: require_PluginDriver.DEFAULT_EXTENSION,
-			defaultBanner: require_PluginDriver.DEFAULT_BANNER,
-			...userConfig.output
-		},
-		devtools: userConfig.devtools ? {
-			studioUrl: require_PluginDriver.DEFAULT_STUDIO_URL,
-			...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
-		} : void 0,
-		plugins: userConfig.plugins
-	};
-	const storage = config.output.write === false ? null : config.storage ?? fsStorage();
 	if (config.output.clean) {
 		await hooks.emit("kubb:debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: ["Cleaning output directories", `  • Output: ${config.output.path}`]
 		});
-		await storage?.clear((0, node_path.resolve)(config.root, config.output.path));
+		await config.storage.clear((0, node_path.resolve)(config.root, config.output.path));
 	}
-	const driver = new require_PluginDriver.PluginDriver(config, { hooks });
-	function registerMiddlewareHook(event, middlewareHooks) {
-		const handler = middlewareHooks[event];
-		if (handler) hooks.on(event, handler);
-	}
-	for (const middleware of config.middleware ?? []) for (const event of Object.keys(middleware.hooks)) registerMiddlewareHook(event, middleware.hooks);
-	const adapter = config.adapter;
-	if (!adapter) throw new Error("No adapter configured. Please provide an adapter in your kubb.config.ts.");
-	const source = inputToAdapterSource(config);
-	await hooks.emit("kubb:debug", {
-		date: /* @__PURE__ */ new Date(),
-		logs: [`Running adapter: ${adapter.name}`]
-	});
-	driver.adapter = adapter;
-	driver.inputNode = await adapter.parse(source);
-	await hooks.emit("kubb:debug", {
-		date: /* @__PURE__ */ new Date(),
-		logs: [
-			`✓ Adapter '${adapter.name}' resolved InputNode`,
-			`  • Schemas: ${driver.inputNode.schemas.length}`,
-			`  • Operations: ${driver.inputNode.operations.length}`
-		]
-	});
+	await driver.setup();
 	return {
 		config,
 		hooks,
 		driver,
-		sources,
-		storage
+		storage,
+		dispose,
+		[Symbol.dispose]: dispose
 	};
-}
-/**
-* Walks the AST and dispatches nodes to a plugin's direct AST hooks
-* (`schema`, `operation`, `operations`).
-*
-* When `include` contains only operation-scoped filters (`tag`, `operationId`, `path`,
-* `method`, `contentType`) and no `schemaName` filter, the function pre-computes the set
-* of top-level schema names transitively reachable from the included operations and skips
-* schemas that fall outside that set. This ensures that component schemas referenced
-* exclusively by excluded operations are not generated.
-*/
-async function runPluginAstHooks(plugin, context) {
-	const { adapter, inputNode, resolver, driver } = context;
-	const { exclude, include, override } = plugin.options;
-	if (!adapter || !inputNode) throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`);
-	function resolveRenderer(gen) {
-		return gen.renderer === null ? void 0 : gen.renderer ?? plugin.renderer ?? context.config.renderer;
+	function dispose() {
+		driver.dispose();
 	}
-	const generators = plugin.generators ?? [];
-	const collectedOperations = [];
-	const generatorContext = {
-		...context,
-		resolver: driver.getResolver(plugin.name)
-	};
-	const operationFilterTypes = new Set([
-		"tag",
-		"operationId",
-		"path",
-		"method",
-		"contentType"
-	]);
-	const hasOperationBasedIncludes = include?.some(({ type }) => operationFilterTypes.has(type)) ?? false;
-	const hasSchemaNameIncludes = include?.some(({ type }) => type === "schemaName") ?? false;
-	let allowedSchemaNames;
-	if (hasOperationBasedIncludes && !hasSchemaNameIncludes) allowedSchemaNames = (0, _kubb_ast.collectUsedSchemaNames)(inputNode.operations.filter((op) => resolver.resolveOptions(op, {
-		options: plugin.options,
-		exclude,
-		include,
-		override
-	}) !== null), inputNode.schemas);
-	await (0, _kubb_ast.walk)(inputNode, {
-		depth: "shallow",
-		async schema(node) {
-			const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
-			if (allowedSchemaNames !== void 0 && transformedNode.name && !allowedSchemaNames.has(transformedNode.name)) return;
-			const options = resolver.resolveOptions(transformedNode, {
-				options: plugin.options,
-				exclude,
-				include,
-				override
+}
+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...`]
 			});
-			if (options === null) return;
-			const ctx = {
-				...generatorContext,
-				options
-			};
-			for (const gen of generators) {
-				if (!gen.schema) continue;
-				await require_PluginDriver.applyHookResult(await gen.schema(transformedNode, ctx), driver, resolveRenderer(gen));
+			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 driver.hooks.emit("kubb:generate:schema", transformedNode, ctx);
-		},
-		async operation(node) {
-			const transformedNode = plugin.transformer ? (0, _kubb_ast.transform)(node, plugin.transformer) : node;
-			const options = resolver.resolveOptions(transformedNode, {
-				options: plugin.options,
-				exclude,
-				include,
-				override
+			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`]
 			});
-			if (options !== null) {
-				collectedOperations.push(transformedNode);
-				const ctx = {
-					...generatorContext,
-					options
+		}
+		async function dispatchOperationsToGenerators(generators, collectedOperations, ctx, rendererFor) {
+			for (const gen of generators) {
+				if (!gen.operations) continue;
+				await require_KubbDriver.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
 				};
-				for (const gen of generators) {
-					if (!gen.operation) continue;
-					await require_PluginDriver.applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRenderer(gen));
+			});
+			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);
 				}
-				await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+				for (const state of pruningStates) state.allowedSchemaNames = (0, _kubb_ast.collectUsedSchemaNames)(includedOpsByState.get(state) ?? [], allSchemas);
 			}
-		}
-	});
-	if (collectedOperations.length > 0) {
-		const ctx = {
-			...generatorContext,
-			options: plugin.options
-		};
-		for (const gen of generators) {
-			if (!gen.operations) continue;
-			await require_PluginDriver.applyHookResult(await gen.operations(collectedOperations, ctx), driver, resolveRenderer(gen));
-		}
-		await driver.hooks.emit("kubb:generate:operations", collectedOperations, ctx);
-	}
-}
-async function safeBuild(setupResult) {
-	const { driver, hooks, sources, storage } = setupResult;
-	const failedPlugins = /* @__PURE__ */ new Set();
-	const pluginTimings = /* @__PURE__ */ new Map();
-	const config = driver.config;
-	try {
-		await driver.emitSetupHooks();
-		if (driver.adapter && driver.inputNode) await hooks.emit("kubb:build:start", {
-			config,
-			adapter: driver.adapter,
-			inputNode: driver.inputNode,
-			getPlugin: driver.getPlugin.bind(driver),
-			get files() {
-				return driver.fileManager.files;
-			},
-			upsertFile: (...files) => driver.fileManager.upsert(...files)
-		});
-		for (const plugin of driver.plugins.values()) {
-			const context = driver.getContext(plugin);
-			const hrStart = process.hrtime();
-			try {
-				const timestamp = /* @__PURE__ */ new Date();
-				await hooks.emit("kubb:plugin:start", { plugin });
-				await hooks.emit("kubb:debug", {
-					date: timestamp,
-					logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
+			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 ? (0, _kubb_ast.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 = require_KubbDriver.applyHookResult({
+							result: require_KubbDriver.isPromise(raw) ? await raw : raw,
+							driver,
+							rendererFactory: resolveRendererFor(gen, state)
+						});
+						if (require_KubbDriver.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 ? (0, _kubb_ast.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 = require_KubbDriver.applyHookResult({
+							result: require_KubbDriver.isPromise(raw) ? await raw : raw,
+							driver,
+							rendererFactory: resolveRendererFor(gen, state)
+						});
+						if (require_KubbDriver.isPromise(applied)) await applied;
+					}
+					await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+				} catch (caughtError) {
+					state.failed = true;
+					state.error = caughtError;
+				}
+			}
+			await require_KubbDriver.forBatches(schemas, (nodes) => Promise.all(nodes.flatMap((n) => states.map((state) => dispatchSchema(state, n)))), {
+				concurrency: 8,
+				flush: flushPendingFiles
+			});
+			const collectedOperations = [];
+			await require_KubbDriver.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
 				});
-				if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
+				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", {
@@ -1075,107 +915,61 @@ async function safeBuild(setupResult) {
 					date: /* @__PURE__ */ new Date(),
 					logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
 				});
-			} catch (caughtError) {
-				const error = caughtError;
-				const errorTimestamp = /* @__PURE__ */ new Date();
+			}
+			if (generatorPlugins.length > 0) if (driver.inputNode) await require_KubbDriver.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: false,
-					error,
+					success: true,
 					config,
 					get files() {
 						return driver.fileManager.files;
 					},
 					upsertFile: (...files) => driver.fileManager.upsert(...files)
 				});
-				await hooks.emit("kubb:debug", {
-					date: errorTimestamp,
-					logs: [
-						"✗ Plugin start failed",
-						`  • Plugin Name: ${plugin.name}`,
-						`  • Error: ${error.constructor.name} - ${error.message}`,
-						"  • Stack Trace:",
-						error.stack || "No stack trace available"
-					]
-				});
-				failedPlugins.add({
-					plugin,
-					error
-				});
 			}
+			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: (0, node_path.resolve)(config.root, config.output.path)
+			});
+			return {
+				failedPlugins,
+				files,
+				driver,
+				pluginTimings,
+				storage
+			};
+		} catch (error) {
+			return {
+				failedPlugins,
+				files: [],
+				driver,
+				pluginTimings,
+				error,
+				storage
+			};
 		}
-		await hooks.emit("kubb:plugins:end", {
-			config,
-			get files() {
-				return driver.fileManager.files;
-			},
-			upsertFile: (...files) => driver.fileManager.upsert(...files)
-		});
-		const files = driver.fileManager.files;
-		const parsersMap = /* @__PURE__ */ new Map();
-		for (const parser of config.parsers) if (parser.extNames) for (const extname of parser.extNames) parsersMap.set(extname, parser);
-		const fileProcessor = new FileProcessor();
-		await hooks.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [`Writing ${files.length} files...`]
-		});
-		await fileProcessor.run(files, {
-			parsers: parsersMap,
-			extension: config.output.extension,
-			onStart: async (processingFiles) => {
-				await hooks.emit("kubb:files:processing:start", { files: processingFiles });
-			},
-			onUpdate: async ({ file, source, processed, total, percentage }) => {
-				await hooks.emit("kubb:file:processing:update", {
-					file,
-					source,
-					processed,
-					total,
-					percentage,
-					config
-				});
-				if (source) {
-					await storage?.setItem(file.path, source);
-					sources.set(file.path, source);
-				}
-			},
-			onEnd: async (processedFiles) => {
-				await hooks.emit("kubb:files:processing:end", { files: processedFiles });
-				await hooks.emit("kubb:debug", {
-					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ File write process completed for ${processedFiles.length} files`]
-				});
-			}
-		});
-		await hooks.emit("kubb:build:end", {
-			files,
-			config,
-			outputDir: (0, node_path.resolve)(config.root, config.output.path)
-		});
-		return {
-			failedPlugins,
-			files,
-			driver,
-			pluginTimings,
-			sources
-		};
-	} catch (error) {
-		return {
-			failedPlugins,
-			files: [],
-			driver,
-			pluginTimings,
-			error,
-			sources
-		};
+	} catch (_) {
+		_usingCtx$1.e = _;
 	} finally {
-		driver.dispose();
+		_usingCtx$1.d();
 	}
 }
 async function build(setupResult) {
-	const { files, driver, failedPlugins, pluginTimings, error, sources } = await safeBuild(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);
@@ -1187,32 +981,32 @@ async function build(setupResult) {
 		driver,
 		pluginTimings,
 		error: void 0,
-		sources
+		storage
 	};
 }
-function inputToAdapterSource(config) {
-	if (Array.isArray(config.input)) return {
-		type: "paths",
-		paths: config.input.map((i) => new URLPath(i.path).isURL ? i.path : (0, node_path.resolve)(config.root, i.path))
-	};
-	if ("data" in config.input) return {
-		type: "data",
-		data: config.input.data
-	};
-	if (new URLPath(config.input.path).isURL) return {
-		type: "path",
-		path: config.input.path
-	};
+/**
+* Returns a snapshot of the current runtime environment.
+*
+* Useful for attaching context to debug logs and error reports so that
+* issues can be reproduced without manual information gathering.
+*/
+function getDiagnosticInfo() {
 	return {
-		type: "path",
-		path: (0, node_path.resolve)(config.root, config.input.path)
+		nodeVersion: node_process.version,
+		KubbVersion: version,
+		platform: process.platform,
+		arch: process.arch,
+		cwd: process.cwd()
 	};
 }
+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.
 *
 * Accepts a user-facing config shape and resolves it to a full {@link Config} during
-* `setup()`. The instance then holds shared state (`hooks`, `sources`, `driver`, `config`)
+* `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()`.
 *
@@ -1234,14 +1028,17 @@ function createKubb(userConfig, options = {}) {
 		get hooks() {
 			return hooks;
 		},
-		get sources() {
-			return setupResult?.sources ?? /* @__PURE__ */ new Map();
+		get storage() {
+			if (!setupResult) throw new Error("[kubb] setup() must be called before accessing storage");
+			return setupResult.storage;
 		},
 		get driver() {
-			return setupResult?.driver;
+			if (!setupResult) throw new Error("[kubb] setup() must be called before accessing driver");
+			return setupResult.driver;
 		},
 		get config() {
-			return setupResult?.config;
+			if (!setupResult) throw new Error("[kubb] setup() must be called before accessing config");
+			return setupResult.config;
 		},
 		async setup() {
 			setupResult = await setup(userConfig, { hooks });
@@ -1260,15 +1057,10 @@ function createKubb(userConfig, options = {}) {
 //#endregion
 //#region src/createRenderer.ts
 /**
-* Creates a renderer factory for use in generator definitions.
-*
-* Wrap your renderer factory function with this helper to register it as the
-* renderer for a generator. Core will call this factory once per render cycle
-* to obtain a fresh renderer instance.
+* Wraps a renderer factory for use in generator definitions.
 *
 * @example
 * ```ts
-* // packages/renderer-jsx/src/index.ts
 * export const jsxRenderer = createRenderer(() => {
 *   const runtime = new Runtime()
 *   return {
@@ -1277,14 +1069,6 @@ function createKubb(userConfig, options = {}) {
 *     unmount(error) { runtime.unmount(error) },
 *   }
 * })
-*
-* // packages/plugin-zod/src/generators/zodGenerator.tsx
-* import { jsxRenderer } from '@kubb/renderer-jsx'
-* export const zodGenerator = defineGenerator<PluginZod>({
-*   name: 'zod',
-*   renderer: jsxRenderer,
-*   schema(node, options) { return <File ...>...</File> },
-* })
 * ```
 */
 function createRenderer(factory) {
@@ -1305,7 +1089,11 @@ function defineGenerator(generator) {
 /**
 * Wraps a logger definition into a typed {@link Logger}.
 *
-* @example
+* The optional second type parameter `TInstallReturn` allows loggers to return
+* a value from `install` — for example, a sink factory that the caller can
+* forward to hook execution.
+*
+* @example Basic logger
 * ```ts
 * export const myLogger = defineLogger({
 *   name: 'my-logger',
@@ -1315,6 +1103,17 @@ function defineGenerator(generator) {
 *   },
 * })
 * ```
+*
+* @example Logger that returns a hook sink factory
+* ```ts
+* export const myLogger = defineLogger<LoggerOptions, HookSinkFactory>({
+*   name: 'my-logger',
+*   install(context, options) {
+*     // … register event handlers …
+*     return (commandWithArgs) => ({ onStdout: console.log })
+*   },
+* })
+* ```
 */
 function defineLogger(logger) {
 	return logger;
@@ -1385,34 +1184,6 @@ function defineParser(parser) {
 	return parser;
 }
 //#endregion
-//#region src/definePlugin.ts
-/**
-* Wraps a factory function and returns a typed `Plugin` with lifecycle handlers grouped under `hooks`.
-*
-* Handlers live in a single `hooks` object (inspired by Astro integrations).
-* All lifecycle events from `KubbHooks` are available for subscription.
-*
-* @note For real plugins, use a `PluginFactoryOptions` type parameter to get type-safe context in `kubb:plugin:setup`.
-* Plugin names should follow the convention `plugin-<feature>` (e.g., `plugin-react-query`, `plugin-zod`).
-*
-* @example
-* ```ts
-* import { definePlugin } from '@kubb/core'
-*
-* export const pluginTs = definePlugin((options: { prefix?: string } = {}) => ({
-*   name: 'plugin-ts',
-*   hooks: {
-*     'kubb:plugin:setup'(ctx) {
-*       ctx.setResolver(resolverTs)
-*     },
-*   },
-* }))
-* ```
-*/
-function definePlugin(factory) {
-	return (options) => factory(options ?? {});
-}
-//#endregion
 //#region src/storages/memoryStorage.ts
 /**
 * In-memory storage driver. Useful for testing and dry-run scenarios where
@@ -1464,10 +1235,10 @@ const memoryStorage = createStorage(() => {
 });
 //#endregion
 exports.AsyncEventEmitter = AsyncEventEmitter;
-exports.FileManager = require_PluginDriver.FileManager;
+exports.FileManager = require_KubbDriver.FileManager;
 exports.FileProcessor = FileProcessor;
-exports.PluginDriver = require_PluginDriver.PluginDriver;
-exports.URLPath = URLPath;
+exports.KubbDriver = require_KubbDriver.KubbDriver;
+exports.URLPath = require_KubbDriver.URLPath;
 Object.defineProperty(exports, "ast", {
 	enumerable: true,
 	get: function() {
@@ -1482,11 +1253,11 @@ exports.defineGenerator = defineGenerator;
 exports.defineLogger = defineLogger;
 exports.defineMiddleware = defineMiddleware;
 exports.defineParser = defineParser;
-exports.definePlugin = definePlugin;
-exports.defineResolver = require_PluginDriver.defineResolver;
+exports.definePlugin = require_KubbDriver.definePlugin;
+exports.defineResolver = require_KubbDriver.defineResolver;
 exports.fsStorage = fsStorage;
 exports.isInputPath = isInputPath;
-exports.logLevel = require_PluginDriver.logLevel;
+exports.logLevel = require_KubbDriver.logLevel;
 exports.memoryStorage = memoryStorage;
 
 //# sourceMappingURL=index.cjs.map