@kubb/core 5.0.0-alpha.9 → 5.0.0-beta.2

package/dist/index.cjs

@@ -1,32 +1,20 @@
-Object.defineProperties(exports, {
-	__esModule: { value: true },
-	[Symbol.toStringTag]: { value: "Module" }
-});
-const require_chunk = require("./chunk-ByKO4r7w.cjs");
-let _kubb_ast = require("@kubb/ast");
-let node_path = require("node:path");
-node_path = require_chunk.__toESM(node_path);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_PluginDriver = require("./PluginDriver-BXibeQk-.cjs");
 let node_events = require("node:events");
-let node_util = require("node:util");
-let node_fs = require("node:fs");
 let node_fs_promises = require("node:fs/promises");
-let _kubb_react_fabric = require("@kubb/react-fabric");
-let _kubb_react_fabric_parsers = require("@kubb/react-fabric/parsers");
-let _kubb_react_fabric_plugins = require("@kubb/react-fabric/plugins");
-let node_perf_hooks = require("node:perf_hooks");
-let fflate = require("fflate");
-let tinyexec = require("tinyexec");
+let node_path = require("node:path");
+let _kubb_ast = require("@kubb/ast");
+_kubb_ast = require_PluginDriver.__toESM(_kubb_ast, 1);
 let node_process = require("node:process");
-let remeda = require("remeda");
-let empathic_package = require("empathic/package");
-empathic_package = require_chunk.__toESM(empathic_package);
-let semver = require("semver");
-//#region ../../internals/utils/dist/index.js
-/** Thrown when a plugin's configuration or input fails validation. */
-var ValidationPluginError = class extends Error {};
+//#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;
@@ -38,19 +26,34 @@ var BuildError = class extends Error {
 };
 /**
 * Coerces an unknown thrown value to an `Error` instance.
-* When the value is already an `Error` it is returned as-is;
-* otherwise a new `Error` is created whose message is `String(value)`.
+* 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
 /**
-* A typed EventEmitter that awaits all async listeners before resolving.
+* 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 {
 	/**
-	* `maxListener` controls the maximum number of listeners per event before Node emits a memory-leak warning.
+	* Maximum number of listeners per event before Node emits a memory-leak warning.
 	* @default 10
 	*/
 	constructor(maxListener = 10) {
@@ -58,31 +61,48 @@ var AsyncEventEmitter = class {
 	}
 	#emitter = new node_events.EventEmitter();
 	/**
-	* Emits an event and awaits all registered listeners in parallel.
+	* 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')
+	* ```
 	*/
 	async emit(eventName, ...eventArgs) {
 		const listeners = this.#emitter.listeners(eventName);
 		if (listeners.length === 0) return;
-		await Promise.all(listeners.map(async (listener) => {
+		for (const listener of listeners) try {
+			await listener(...eventArgs);
+		} catch (err) {
+			let serializedArgs;
 			try {
-				return 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) });
+				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 the given event. */
+	/**
+	* 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. */
+	/**
+	* 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);
@@ -90,252 +110,53 @@ var AsyncEventEmitter = class {
 		};
 		this.on(eventName, wrapper);
 	}
-	/** Removes a previously registered listener. */
+	/**
+	* Removes a previously registered listener.
+	*
+	* @example
+	* ```ts
+	* emitter.off('build', handler)
+	* ```
+	*/
 	off(eventName, handler) {
 		this.#emitter.off(eventName, handler);
 	}
-	/** Removes all listeners from every event channel. */
+	/**
+	* 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
 /**
-* Shared implementation for camelCase and PascalCase conversion.
-* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
-* and capitalizes each word according to `pascal`.
-*
-* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
-*/
-function toCamelOrPascal(text, pascal) {
-	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
-		if (word.length > 1 && word === word.toUpperCase()) return word;
-		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
-		return word.charAt(0).toUpperCase() + word.slice(1);
-	}).join("").replace(/[^a-zA-Z0-9]/g, "");
-}
-/**
-* Splits `text` on `.` and applies `transformPart` to each segment.
-* The last segment receives `isLast = true`, all earlier segments receive `false`.
-* Segments are joined with `/` to form a file path.
-*/
-function applyToFileParts(text, transformPart) {
-	const parts = text.split(".");
-	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
-}
-/**
-* Converts `text` to camelCase.
-* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
-*
-* @example
-* camelCase('hello-world')                   // 'helloWorld'
-* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
-*/
-function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
-		prefix,
-		suffix
-	} : {}));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
-}
-/**
-* Converts `text` to PascalCase.
-* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+* 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
-* pascalCase('hello-world')                  // 'HelloWorld'
-* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
-*/
-function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
-	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
-		prefix,
-		suffix
-	}) : camelCase(part));
-	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
-}
-/** Returns a `CLIAdapter` with type inference. Pass a different adapter to `createCLI` to swap the CLI engine. */
-function defineCLIAdapter(adapter) {
-	return adapter;
-}
-/**
-* Serializes `CommandDefinition[]` to a plain, JSON-serializable structure.
-* Use to expose CLI capabilities to AI agents or MCP tools.
-*/
-function getCommandSchema(defs) {
-	return defs.map(serializeCommand);
-}
-function serializeCommand(def) {
-	return {
-		name: def.name,
-		description: def.description,
-		arguments: def.arguments,
-		options: serializeOptions(def.options ?? {}),
-		subCommands: def.subCommands ? def.subCommands.map(serializeCommand) : []
-	};
-}
-function serializeOptions(options) {
-	return Object.entries(options).map(([name, opt]) => {
-		return {
-			name,
-			flags: `${opt.short ? `-${opt.short}, ` : ""}--${name}${opt.type === "string" ? ` <${opt.hint ?? name}>` : ""}`,
-			type: opt.type,
-			description: opt.description,
-			...opt.default !== void 0 ? { default: opt.default } : {},
-			...opt.hint ? { hint: opt.hint } : {},
-			...opt.enum ? { enum: opt.enum } : {},
-			...opt.required ? { required: opt.required } : {}
-		};
-	});
-}
-/** Prints formatted help output for a command using its `CommandDefinition`. */
-function renderHelp(def, parentName) {
-	const schema = getCommandSchema([def])[0];
-	const programName = parentName ? `${parentName} ${schema.name}` : schema.name;
-	const argsPart = schema.arguments?.length ? ` ${schema.arguments.join(" ")}` : "";
-	const subCmdPart = schema.subCommands.length ? " <command>" : "";
-	console.log(`\n${(0, node_util.styleText)("bold", "Usage:")} ${programName}${argsPart}${subCmdPart} [options]\n`);
-	if (schema.description) console.log(`  ${schema.description}\n`);
-	if (schema.subCommands.length) {
-		console.log((0, node_util.styleText)("bold", "Commands:"));
-		for (const sub of schema.subCommands) console.log(`  ${(0, node_util.styleText)("cyan", sub.name.padEnd(16))}${sub.description}`);
-		console.log();
-	}
-	const options = [...schema.options, {
-		name: "help",
-		flags: "-h, --help",
-		type: "boolean",
-		description: "Show help"
-	}];
-	console.log((0, node_util.styleText)("bold", "Options:"));
-	for (const opt of options) {
-		const flags = (0, node_util.styleText)("cyan", opt.flags.padEnd(30));
-		const defaultPart = opt.default !== void 0 ? (0, node_util.styleText)("dim", ` (default: ${opt.default})`) : "";
-		console.log(`  ${flags}${opt.description}${defaultPart}`);
-	}
-	console.log();
-}
-function buildParseOptions(def) {
-	const result = { help: {
-		type: "boolean",
-		short: "h"
-	} };
-	for (const [name, opt] of Object.entries(def.options ?? {})) result[name] = {
-		type: opt.type,
-		...opt.short ? { short: opt.short } : {},
-		...opt.default !== void 0 ? { default: opt.default } : {}
-	};
-	return result;
-}
-async function runCommand(def, argv, parentName) {
-	const parseOptions = buildParseOptions(def);
-	let parsed;
-	try {
-		const result = (0, node_util.parseArgs)({
-			args: argv,
-			options: parseOptions,
-			allowPositionals: true,
-			strict: false
-		});
-		parsed = {
-			values: result.values,
-			positionals: result.positionals
-		};
-	} catch {
-		renderHelp(def, parentName);
-		process.exit(1);
-	}
-	if (parsed.values["help"]) {
-		renderHelp(def, parentName);
-		process.exit(0);
-	}
-	for (const [name, opt] of Object.entries(def.options ?? {})) if (opt.required && parsed.values[name] === void 0) {
-		console.error((0, node_util.styleText)("red", `Error: --${name} is required`));
-		renderHelp(def, parentName);
-		process.exit(1);
-	}
-	if (!def.run) {
-		renderHelp(def, parentName);
-		process.exit(0);
-	}
-	try {
-		await def.run(parsed);
-	} catch (err) {
-		console.error((0, node_util.styleText)("red", `Error: ${err instanceof Error ? err.message : String(err)}`));
-		renderHelp(def, parentName);
-		process.exit(1);
-	}
-}
-function printRootHelp(programName, version, defs) {
-	console.log(`\n${(0, node_util.styleText)("bold", "Usage:")} ${programName} <command> [options]\n`);
-	console.log(`  Kubb generation — v${version}\n`);
-	console.log((0, node_util.styleText)("bold", "Commands:"));
-	for (const def of defs) console.log(`  ${(0, node_util.styleText)("cyan", def.name.padEnd(16))}${def.description}`);
-	console.log();
-	console.log((0, node_util.styleText)("bold", "Options:"));
-	console.log(`  ${(0, node_util.styleText)("cyan", "-v, --version".padEnd(30))}Show version number`);
-	console.log(`  ${(0, node_util.styleText)("cyan", "-h, --help".padEnd(30))}Show help`);
-	console.log();
-	console.log(`Run ${(0, node_util.styleText)("cyan", `${programName} <command> --help`)} for command-specific help.\n`);
-}
-defineCLIAdapter({
-	renderHelp(def, parentName) {
-		renderHelp(def, parentName);
-	},
-	async run(defs, argv, opts) {
-		const { programName, defaultCommandName, version } = opts;
-		const args = argv.length >= 2 && argv[0]?.includes("node") ? argv.slice(2) : argv;
-		if (args[0] === "--version" || args[0] === "-v") {
-			console.log(version);
-			process.exit(0);
-		}
-		if (args[0] === "--help" || args[0] === "-h") {
-			printRootHelp(programName, version, defs);
-			process.exit(0);
-		}
-		if (args.length === 0) {
-			const defaultDef = defs.find((d) => d.name === defaultCommandName);
-			if (defaultDef?.run) await runCommand(defaultDef, [], programName);
-			else printRootHelp(programName, version, defs);
-			return;
-		}
-		const [first, ...rest] = args;
-		const isKnownSubcommand = defs.some((d) => d.name === first);
-		let def;
-		let commandArgv;
-		let parentName;
-		if (isKnownSubcommand) {
-			def = defs.find((d) => d.name === first);
-			commandArgv = rest;
-			parentName = programName;
-		} else {
-			def = defs.find((d) => d.name === defaultCommandName);
-			commandArgv = args;
-			parentName = programName;
-		}
-		if (!def) {
-			console.error(`Unknown command: ${first}`);
-			printRootHelp(programName, version, defs);
-			process.exit(1);
-		}
-		if (def.subCommands?.length) {
-			const [subName, ...subRest] = commandArgv;
-			const subDef = def.subCommands.find((s) => s.name === subName);
-			if (subName === "--help" || subName === "-h") {
-				renderHelp(def, parentName);
-				process.exit(0);
-			}
-			if (!subDef) {
-				renderHelp(def, parentName);
-				process.exit(subName ? 1 : 0);
-			}
-			await runCommand(subDef, subRest, `${parentName} ${def.name}`);
-			return;
-		}
-		await runCommand(def, commandArgv, parentName);
-	}
-});
-/**
-* Calculates elapsed time in milliseconds from a high-resolution start time.
-* Rounds to 2 decimal places to provide sub-millisecond precision without noise.
+* ```ts
+* const start = process.hrtime()
+* doWork()
+* getElapsedMs(start) // 42.35
+* ```
 */
 function getElapsedMs(hrStart) {
 	const [seconds, nanoseconds] = process.hrtime(hrStart);
@@ -343,88 +164,62 @@ function getElapsedMs(hrStart) {
 	return Math.round(ms * 100) / 100;
 }
 /**
-* Converts a millisecond duration into a human-readable string.
-* Adjusts units (ms, s, m s) based on the magnitude of the duration.
+* 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`;
 }
-/**
-* Parses a CSS hex color string (`#RGB`) into its RGB channels.
-* Falls back to `255` for any channel that cannot be parsed.
-*/
-function parseHex(color) {
-	const int = Number.parseInt(color.replace("#", ""), 16);
-	return Number.isNaN(int) ? {
-		r: 255,
-		g: 255,
-		b: 255
-	} : {
-		r: int >> 16 & 255,
-		g: int >> 8 & 255,
-		b: int & 255
-	};
-}
-/**
-* Returns a function that wraps a string in a 24-bit ANSI true-color escape sequence
-* for the given hex color.
-*/
-function hex(color) {
-	const { r, g, b } = parseHex(color);
-	return (text) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
-}
-hex("#F55A17"), hex("#F5A217"), hex("#F58517"), hex("#B45309"), hex("#FFFFFF"), hex("#adadc6"), hex("#FDA4AF");
-/**
-* Converts all backslashes to forward slashes.
-* Extended-length Windows paths (`\\?\...`) are left unchanged.
-*/
-function toSlash(p) {
-	if (p.startsWith("\\\\?\\")) return p;
-	return p.replaceAll("\\", "/");
-}
-/**
-* Returns the relative path from `rootDir` to `filePath`, always using
-* forward slashes and prefixed with `./` when not already traversing upward.
-*/
-function getRelativePath(rootDir, filePath) {
-	if (!rootDir || !filePath) throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
-	const relativePath = node_path.posix.relative(toSlash(rootDir), toSlash(filePath));
-	return relativePath.startsWith("../") ? relativePath : `./${relativePath}`;
-}
+//#endregion
+//#region ../../internals/utils/src/fs.ts
 /**
 * Resolves to `true` when the file or directory at `path` exists.
 * Uses `Bun.file().exists()` when running under Bun, `fs.access` otherwise.
+*
+* @example
+* ```ts
+* if (await exists('./kubb.config.ts')) {
+*   const content = await read('./kubb.config.ts')
+* }
+* ```
 */
 async function exists(path) {
 	if (typeof Bun !== "undefined") return Bun.file(path).exists();
 	return (0, node_fs_promises.access)(path).then(() => true, () => false);
 }
-/** Synchronous counterpart of `read`. */
-function readSync(path) {
-	return (0, node_fs.readFileSync)(path, { encoding: "utf8" });
-}
 /**
 * Writes `data` to `path`, trimming leading/trailing whitespace before saving.
-* Skips the write and returns `undefined` when the trimmed content is empty or
-* identical to what is already on disk.
+* Skips the write when the trimmed content is empty or identical to what is already on disk.
 * Creates any missing parent directories automatically.
-* When `sanity` is `true`, re-reads the file after writing and throws if the
-* content does not match.
+* When `sanity` is `true`, re-reads the file after writing and throws if the content does not match.
+*
+* @example
+* ```ts
+* await write('./src/Pet.ts', source)         // writes and returns trimmed content
+* await write('./src/Pet.ts', source)         // null — file unchanged
+* await write('./src/Pet.ts', '  ')           // null — empty content skipped
+* ```
 */
 async function write(path, data, options = {}) {
 	const trimmed = data.trim();
-	if (trimmed === "") return void 0;
+	if (trimmed === "") return null;
 	const resolved = (0, node_path.resolve)(path);
 	if (typeof Bun !== "undefined") {
 		const file = Bun.file(resolved);
-		if ((await file.exists() ? await file.text() : null) === trimmed) return void 0;
+		if ((await file.exists() ? await file.text() : null) === trimmed) return null;
 		await Bun.write(resolved, trimmed);
 		return trimmed;
 	}
 	try {
-		if (await (0, node_fs_promises.readFile)(resolved, { encoding: "utf-8" }) === trimmed) return void 0;
+		if (await (0, node_fs_promises.readFile)(resolved, { encoding: "utf-8" }) === trimmed) return null;
 	} catch {}
 	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(resolved), { recursive: true });
 	await (0, node_fs_promises.writeFile)(resolved, trimmed, { encoding: "utf-8" });
@@ -435,30 +230,22 @@ async function write(path, data, options = {}) {
 	}
 	return trimmed;
 }
-/** Recursively removes `path`. Silently succeeds when `path` does not exist. */
+/**
+* Recursively removes `path`. Silently succeeds when `path` does not exist.
+*
+* @example
+* ```ts
+* await clean('./dist')
+* ```
+*/
 async function clean(path) {
 	return (0, node_fs_promises.rm)(path, {
 		recursive: true,
 		force: true
 	});
 }
-/**
-* Registers `originalName` in `data` without altering the returned name.
-* Use this when you need to track usage frequency but always emit the original identifier.
-*/
-function setUniqueName(originalName, data) {
-	let used = data[originalName] || 0;
-	if (used) {
-		data[originalName] = ++used;
-		return originalName;
-	}
-	data[originalName] = 1;
-	return originalName;
-}
-/** Type guard for a rejected `Promise.allSettled` result with a typed `reason`. */
-function isPromiseRejectedResult(result) {
-	return result.status === "rejected";
-}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
 * @link https://github.com/jonschlinkert/reserved/blob/master/index.js
@@ -547,25 +334,21 @@ const reservedWords = new Set([
 	"valueOf"
 ]);
 /**
-* Prefixes a word with `_` when it is a reserved JavaScript/Java identifier
-* or starts with a digit.
-*/
-function transformReservedWord(word) {
-	const firstChar = word.charCodeAt(0);
-	if (word && (reservedWords.has(word) || firstChar >= 48 && firstChar <= 57)) return `_${word}`;
-	return word;
-}
-/**
 * 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) {
-	try {
-		new Function(`var ${name}`);
-	} catch {
-		return false;
-	}
-	return true;
+	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.
 *
@@ -575,18 +358,33 @@ function isValidVarName(name) {
 * p.template // '`/pet/${petId}`'
 */
 var URLPath = class {
-	/** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+	/**
+	* 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`. */
+	/** 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://`). */
+	/** 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;
@@ -604,19 +402,35 @@ var URLPath = class {
 	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. */
+	/** 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. */
+	/** 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 : camelCase(raw);
-		return this.#options.casing === "camelcase" ? camelCase(param) : param;
+		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. */
+	/**
+	* 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];
@@ -653,6 +467,12 @@ var URLPath = class {
 	* 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 = {};
@@ -662,125 +482,46 @@ var URLPath = class {
 		});
 		return Object.keys(params).length > 0 ? params : void 0;
 	}
-	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+	/** 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/config.ts
-function defineConfig(config) {
-	return config;
-}
-/**
-* Type guard to check if a given config has an `input.path`.
-*/
-function isInputPath(config) {
-	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
-}
-//#endregion
-//#region src/constants.ts
-const DEFAULT_STUDIO_URL = "https://studio.kubb.dev";
-const BARREL_FILENAME = "index.ts";
-const DEFAULT_BANNER = "simple";
-const DEFAULT_EXTENSION = { ".ts": ".ts" };
-const logLevel = {
-	silent: Number.NEGATIVE_INFINITY,
-	error: 0,
-	warn: 1,
-	info: 3,
-	verbose: 4,
-	debug: 5
-};
-const linters = {
-	eslint: {
-		command: "eslint",
-		args: (outputPath) => [outputPath, "--fix"],
-		errorMessage: "Eslint not found"
-	},
-	biome: {
-		command: "biome",
-		args: (outputPath) => [
-			"lint",
-			"--fix",
-			outputPath
-		],
-		errorMessage: "Biome not found"
-	},
-	oxlint: {
-		command: "oxlint",
-		args: (outputPath) => ["--fix", outputPath],
-		errorMessage: "Oxlint not found"
-	}
-};
-const formatters = {
-	prettier: {
-		command: "prettier",
-		args: (outputPath) => [
-			"--ignore-unknown",
-			"--write",
-			outputPath
-		],
-		errorMessage: "Prettier not found"
-	},
-	biome: {
-		command: "biome",
-		args: (outputPath) => [
-			"format",
-			"--write",
-			outputPath
-		],
-		errorMessage: "Biome not found"
-	},
-	oxfmt: {
-		command: "oxfmt",
-		args: (outputPath) => [outputPath],
-		errorMessage: "Oxfmt not found"
-	}
-};
-//#endregion
-//#region src/devtools.ts
+//#region src/createAdapter.ts
 /**
-* Encodes a `RootNode` as a compressed, URL-safe string.
+* Factory for implementing custom adapters that translate non-OpenAPI specs into Kubb's AST.
 *
-* The JSON representation is deflate-compressed with {@link deflateSync} before
-* base64url encoding, which typically reduces payload size by 70–80 % and
-* keeps URLs well within browser and server path-length limits.
+* Use this to support GraphQL schemas, gRPC definitions, AsyncAPI, or custom domain-specific languages.
+* Built-in adapters include `@kubb/adapter-oas` for OpenAPI and Swagger documents.
 *
-* Use {@link decodeAst} to reverse.
-*/
-function encodeAst(root) {
-	const compressed = (0, fflate.deflateSync)(new TextEncoder().encode(JSON.stringify(root)));
-	return Buffer.from(compressed).toString("base64url");
-}
-/**
-* Constructs the Kubb Studio URL for the given `RootNode`.
-* When `options.ast` is `true`, navigates to the AST inspector (`/ast`).
-* The `root` is encoded and attached as the `?root=` query parameter so Studio
-* can decode and render it without a round-trip to any server.
-*/
-function getStudioUrl(root, studioUrl, options = {}) {
-	return `${studioUrl.replace(/\/$/, "")}${options.ast ? "/ast" : ""}?root=${encodeAst(root)}`;
-}
-/**
-* Opens the Kubb Studio URL for the given `RootNode` in the default browser —
+* @note Adapters must parse their input format to Kubb's `InputNode` structure.
+*
+* @example
+* ```ts
+* export const myAdapter = createAdapter<MyAdapter>((options) => {
+*   return {
+*     name: 'my-adapter',
+*     options,
+*     async parse(source) {
+*       // Transform source format to InputNode
+*       return { ... }
+*     },
+*   }
+* })
 *
-* Falls back to printing the URL if the browser cannot be launched.
+* // Instantiate:
+* const adapter = myAdapter({ validate: true })
+* ```
 */
-async function openInStudio(root, studioUrl, options = {}) {
-	const url = getStudioUrl(root, studioUrl, options);
-	const cmd = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
-	const args = process.platform === "win32" ? [
-		"/c",
-		"start",
-		"",
-		url
-	] : [url];
-	try {
-		await (0, tinyexec.x)(cmd, args);
-	} catch {
-		console.log(`\n  ${url}\n`);
-	}
+function createAdapter(build) {
+	return (options) => build(options ?? {});
 }
 //#endregion
 //#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
@@ -910,472 +651,99 @@ 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/utils/executeStrategies.ts
-/**
-* Chains promises
-*/
-function hookSeq(promises) {
-	return promises.filter(Boolean).reduce((promise, func) => {
-		if (typeof func !== "function") throw new Error("HookSeq needs a function that returns a promise `() => Promise<unknown>`");
-		return promise.then((state) => {
-			const calledFunc = func(state);
-			if (calledFunc) return calledFunc.then(Array.prototype.concat.bind(state));
-			return state;
-		});
-	}, Promise.resolve([]));
+//#region src/FileProcessor.ts
+function joinSources(file) {
+	return file.sources.map((item) => (0, _kubb_ast.extractStringsFromNodes)(item.nodes)).filter(Boolean).join("\n\n");
 }
 /**
-* Chains promises, first non-null result stops and returns
+* 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 hookFirst(promises, nullCheck = (state) => state !== null) {
-	let promise = Promise.resolve(null);
-	for (const func of promises.filter(Boolean)) promise = promise.then((state) => {
-		if (nullCheck(state)) return state;
-		return func(state);
-	});
-	return promise;
-}
+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;
+	}
+};
+//#endregion
+//#region src/createStorage.ts
 /**
-* Runs an array of promise functions with optional concurrency limit.
+* Factory for implementing custom storage backends that control where generated files are written.
+*
+* Takes a builder function `(options: TOptions) => Storage` and returns a factory `(options?: TOptions) => Storage`.
+* Kubb provides filesystem and in-memory implementations out of the box.
+*
+* @note Call the returned factory with optional options to instantiate the storage adapter.
+*
+* @example
+* ```ts
+* import { createStorage } from '@kubb/core'
+*
+* export const memoryStorage = createStorage(() => {
+*   const store = new Map<string, string>()
+*   return {
+*     name: 'memory',
+*     async hasItem(key) { return store.has(key) },
+*     async getItem(key) { return store.get(key) ?? null },
+*     async setItem(key, value) { store.set(key, value) },
+*     async removeItem(key) { store.delete(key) },
+*     async getKeys(base) {
+*       const keys = [...store.keys()]
+*       return base ? keys.filter((k) => k.startsWith(base)) : keys
+*     },
+*     async clear(base) { if (!base) store.clear() },
+*   }
+* })
+*
+* // Instantiate:
+* const storage = memoryStorage()
+* ```
 */
-function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
-	const limit = pLimit(concurrency);
-	const tasks = promises.filter(Boolean).map((promise) => limit(() => promise()));
-	return Promise.allSettled(tasks);
+function createStorage(build) {
+	return (options) => build(options ?? {});
 }
 //#endregion
-//#region src/PluginDriver.ts
-function getMode(fileOrFolder) {
-	if (!fileOrFolder) return "split";
-	return (0, node_path.extname)(fileOrFolder) ? "single" : "split";
+//#region src/storages/fsStorage.ts
+/**
+* Detects the filesystem error used to indicate that a path does not exist.
+*/
+function isMissingPathError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-const hookFirstNullCheck = (state) => !!state?.result;
-var PluginDriver = class {
-	config;
-	options;
-	/**
-	* The universal `@kubb/ast` `RootNode` produced by the adapter, set by
-	* the build pipeline after the adapter's `parse()` resolves.
-	*/
-	rootNode = void 0;
-	adapter = void 0;
-	#studioIsOpen = false;
-	#plugins = /* @__PURE__ */ new Set();
-	#usedPluginNames = {};
-	constructor(config, options) {
-		this.config = config;
-		this.options = options;
-		[...config.plugins || []].forEach((plugin) => {
-			const parsedPlugin = this.#parse(plugin);
-			this.#plugins.add(parsedPlugin);
-		});
-	}
-	get events() {
-		return this.options.events;
-	}
-	getContext(plugin) {
-		const plugins = [...this.#plugins];
-		const driver = this;
-		const baseContext = {
-			fabric: this.options.fabric,
-			config: this.config,
-			plugin,
-			events: this.options.events,
-			driver: this,
-			mode: getMode((0, node_path.resolve)(this.config.root, this.config.output.path)),
-			addFile: async (...files) => {
-				await this.options.fabric.addFile(...files);
-			},
-			upsertFile: async (...files) => {
-				await this.options.fabric.upsertFile(...files);
-			},
-			get rootNode() {
-				return driver.rootNode;
-			},
-			get adapter() {
-				return driver.adapter;
-			},
-			openInStudio(options) {
-				if (!driver.config.devtools || driver.#studioIsOpen) return;
-				if (typeof driver.config.devtools !== "object") throw new Error("Devtools must be an object");
-				if (!driver.rootNode || !driver.adapter) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
-				driver.#studioIsOpen = true;
-				const studioUrl = driver.config.devtools?.studioUrl ?? "https://studio.kubb.dev";
-				return openInStudio(driver.rootNode, studioUrl, options);
-			}
-		};
-		const mergedExtras = {};
-		for (const p of plugins) if (typeof p.inject === "function") {
-			const result = p.inject.call(baseContext, baseContext);
-			if (result !== null && typeof result === "object") Object.assign(mergedExtras, result);
-		}
-		return {
-			...baseContext,
-			...mergedExtras
-		};
-	}
-	get plugins() {
-		return this.#getSortedPlugins();
-	}
-	getFile({ name, mode, extname, pluginName, options }) {
-		const resolvedName = mode ? mode === "single" ? "" : this.resolveName({
-			name,
-			pluginName,
-			type: "file"
-		}) : name;
-		const path = this.resolvePath({
-			baseName: `${resolvedName}${extname}`,
-			mode,
-			pluginName,
-			options
-		});
-		if (!path) throw new Error(`Filepath should be defined for resolvedName "${resolvedName}" and pluginName "${pluginName}"`);
-		return {
-			path,
-			baseName: (0, node_path.basename)(path),
-			meta: { pluginName },
-			sources: [],
-			imports: [],
-			exports: []
-		};
-	}
-	resolvePath = (params) => {
-		const defaultPath = (0, node_path.resolve)((0, node_path.resolve)(this.config.root, this.config.output.path), params.baseName);
-		if (params.pluginName) return this.hookForPluginSync({
-			pluginName: params.pluginName,
-			hookName: "resolvePath",
-			parameters: [
-				params.baseName,
-				params.mode,
-				params.options
-			]
-		})?.at(0) || defaultPath;
-		return this.hookFirstSync({
-			hookName: "resolvePath",
-			parameters: [
-				params.baseName,
-				params.mode,
-				params.options
-			]
-		})?.result || defaultPath;
-	};
-	resolveName = (params) => {
-		if (params.pluginName) {
-			const names = this.hookForPluginSync({
-				pluginName: params.pluginName,
-				hookName: "resolveName",
-				parameters: [params.name.trim(), params.type]
-			});
-			return transformReservedWord([...new Set(names)].at(0) || params.name);
-		}
-		const name = this.hookFirstSync({
-			hookName: "resolveName",
-			parameters: [params.name.trim(), params.type]
-		})?.result;
-		return transformReservedWord(name ?? params.name);
-	};
-	/**
-	* Run a specific hookName for plugin x.
-	*/
-	async hookForPlugin({ pluginName, hookName, parameters }) {
-		const plugins = this.getPluginsByName(hookName, pluginName);
-		this.events.emit("plugins:hook:progress:start", {
-			hookName,
-			plugins
-		});
-		const items = [];
-		for (const plugin of plugins) {
-			const result = await this.#execute({
-				strategy: "hookFirst",
-				hookName,
-				parameters,
-				plugin
-			});
-			if (result !== void 0 && result !== null) items.push(result);
-		}
-		this.events.emit("plugins:hook:progress:end", { hookName });
-		return items;
-	}
-	/**
-	* Run a specific hookName for plugin x.
-	*/
-	hookForPluginSync({ pluginName, hookName, parameters }) {
-		return this.getPluginsByName(hookName, pluginName).map((plugin) => {
-			return this.#executeSync({
-				strategy: "hookFirst",
-				hookName,
-				parameters,
-				plugin
-			});
-		}).filter((x) => x !== null);
-	}
-	/**
-	* Returns the first non-null result.
-	*/
-	async hookFirst({ hookName, parameters, skipped }) {
-		const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
-			return skipped ? !skipped.has(plugin) : true;
-		});
-		this.events.emit("plugins:hook:progress:start", {
-			hookName,
-			plugins
-		});
-		const result = await hookFirst(plugins.map((plugin) => {
-			return async () => {
-				const value = await this.#execute({
-					strategy: "hookFirst",
-					hookName,
-					parameters,
-					plugin
-				});
-				return Promise.resolve({
-					plugin,
-					result: value
-				});
-			};
-		}), hookFirstNullCheck);
-		this.events.emit("plugins:hook:progress:end", { hookName });
-		return result;
-	}
-	/**
-	* Returns the first non-null result.
-	*/
-	hookFirstSync({ hookName, parameters, skipped }) {
-		let parseResult = null;
-		const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
-			return skipped ? !skipped.has(plugin) : true;
-		});
-		for (const plugin of plugins) {
-			parseResult = {
-				result: this.#executeSync({
-					strategy: "hookFirst",
-					hookName,
-					parameters,
-					plugin
-				}),
-				plugin
-			};
-			if (parseResult?.result != null) break;
-		}
-		return parseResult;
-	}
-	/**
-	* Runs all plugins in parallel based on `this.plugin` order and `pre`/`post` settings.
-	*/
-	async hookParallel({ hookName, parameters }) {
-		const plugins = this.#getSortedPlugins(hookName);
-		this.events.emit("plugins:hook:progress:start", {
-			hookName,
-			plugins
-		});
-		const pluginStartTimes = /* @__PURE__ */ new Map();
-		const results = await hookParallel(plugins.map((plugin) => {
-			return () => {
-				pluginStartTimes.set(plugin, node_perf_hooks.performance.now());
-				return this.#execute({
-					strategy: "hookParallel",
-					hookName,
-					parameters,
-					plugin
-				});
-			};
-		}), this.options.concurrency);
-		results.forEach((result, index) => {
-			if (isPromiseRejectedResult(result)) {
-				const plugin = this.#getSortedPlugins(hookName)[index];
-				if (plugin) {
-					const startTime = pluginStartTimes.get(plugin) ?? node_perf_hooks.performance.now();
-					this.events.emit("error", result.reason, {
-						plugin,
-						hookName,
-						strategy: "hookParallel",
-						duration: Math.round(node_perf_hooks.performance.now() - startTime),
-						parameters
-					});
-				}
-			}
-		});
-		this.events.emit("plugins:hook:progress:end", { hookName });
-		return results.reduce((acc, result) => {
-			if (result.status === "fulfilled") acc.push(result.value);
-			return acc;
-		}, []);
-	}
-	/**
-	* Chains plugins
-	*/
-	async hookSeq({ hookName, parameters }) {
-		const plugins = this.#getSortedPlugins(hookName);
-		this.events.emit("plugins:hook:progress:start", {
-			hookName,
-			plugins
-		});
-		await hookSeq(plugins.map((plugin) => {
-			return () => this.#execute({
-				strategy: "hookSeq",
-				hookName,
-				parameters,
-				plugin
-			});
-		}));
-		this.events.emit("plugins:hook:progress:end", { hookName });
-	}
-	#getSortedPlugins(hookName) {
-		const plugins = [...this.#plugins];
-		if (hookName) return plugins.filter((plugin) => hookName in plugin);
-		return plugins.map((plugin) => {
-			if (plugin.pre) {
-				let missingPlugins = plugin.pre.filter((pluginName) => !plugins.find((pluginToFind) => pluginToFind.name === pluginName));
-				if (missingPlugins.includes("plugin-oas") && this.adapter) missingPlugins = missingPlugins.filter((pluginName) => pluginName !== "plugin-oas");
-				if (missingPlugins.length > 0) throw new ValidationPluginError(`The plugin '${plugin.name}' has a pre set that references missing plugins for '${missingPlugins.join(", ")}'`);
-			}
-			return plugin;
-		}).sort((a, b) => {
-			if (b.pre?.includes(a.name)) return 1;
-			if (b.post?.includes(a.name)) return -1;
-			return 0;
-		});
-	}
-	getPluginByName(pluginName) {
-		return [...this.#plugins].find((item) => item.name === pluginName);
-	}
-	getPluginsByName(hookName, pluginName) {
-		const plugins = [...this.plugins];
-		const pluginByPluginName = plugins.filter((plugin) => hookName in plugin).filter((item) => item.name === pluginName);
-		if (!pluginByPluginName?.length) {
-			const corePlugin = plugins.find((plugin) => plugin.name === "core" && hookName in plugin);
-			return corePlugin ? [corePlugin] : [];
-		}
-		return pluginByPluginName;
-	}
-	/**
-	* Run an async plugin hook and return the result.
-	* @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
-	* @param args Arguments passed to the plugin hook.
-	* @param plugin The actual pluginObject to run.
-	*/
-	#emitProcessingEnd({ startTime, output, strategy, hookName, plugin, parameters }) {
-		this.events.emit("plugins:hook:processing:end", {
-			duration: Math.round(node_perf_hooks.performance.now() - startTime),
-			parameters,
-			output,
-			strategy,
-			hookName,
-			plugin
-		});
-	}
-	#execute({ strategy, hookName, parameters, plugin }) {
-		const hook = plugin[hookName];
-		if (!hook) return null;
-		this.events.emit("plugins:hook:processing:start", {
-			strategy,
-			hookName,
-			parameters,
-			plugin
-		});
-		const startTime = node_perf_hooks.performance.now();
-		return (async () => {
-			try {
-				const output = typeof hook === "function" ? await Promise.resolve(hook.apply(this.getContext(plugin), parameters ?? [])) : hook;
-				this.#emitProcessingEnd({
-					startTime,
-					output,
-					strategy,
-					hookName,
-					plugin,
-					parameters
-				});
-				return output;
-			} catch (error) {
-				this.events.emit("error", error, {
-					plugin,
-					hookName,
-					strategy,
-					duration: Math.round(node_perf_hooks.performance.now() - startTime)
-				});
-				return null;
-			}
-		})();
-	}
-	/**
-	* Run a sync plugin hook and return the result.
-	* @param hookName Name of the plugin hook. Must be in `PluginHooks`.
-	* @param args Arguments passed to the plugin hook.
-	* @param plugin The actual plugin
-	*/
-	#executeSync({ strategy, hookName, parameters, plugin }) {
-		const hook = plugin[hookName];
-		if (!hook) return null;
-		this.events.emit("plugins:hook:processing:start", {
-			strategy,
-			hookName,
-			parameters,
-			plugin
-		});
-		const startTime = node_perf_hooks.performance.now();
-		try {
-			const output = typeof hook === "function" ? hook.apply(this.getContext(plugin), parameters) : hook;
-			this.#emitProcessingEnd({
-				startTime,
-				output,
-				strategy,
-				hookName,
-				plugin,
-				parameters
-			});
-			return output;
-		} catch (error) {
-			this.events.emit("error", error, {
-				plugin,
-				hookName,
-				strategy,
-				duration: Math.round(node_perf_hooks.performance.now() - startTime)
-			});
-			return null;
-		}
-	}
-	#parse(plugin) {
-		const usedPluginNames = this.#usedPluginNames;
-		setUniqueName(plugin.name, usedPluginNames);
-		const usageCount = usedPluginNames[plugin.name];
-		if (usageCount && usageCount > 1) throw new ValidationPluginError(`Duplicate plugin "${plugin.name}" detected. Each plugin can only be used once. Use a different configuration instead of adding multiple instances of the same plugin.`);
-		return {
-			install() {},
-			...plugin
-		};
-	}
-};
-//#endregion
-//#region src/createStorage.ts
-/**
-* Creates a storage factory. Call the returned function with optional options to get the storage instance.
-*
-* @example
-* export const memoryStorage = createStorage(() => {
-*   const store = new Map<string, string>()
-*   return {
-*     name: 'memory',
-*     async hasItem(key) { return store.has(key) },
-*     async getItem(key) { return store.get(key) ?? null },
-*     async setItem(key, value) { store.set(key, value) },
-*     async removeItem(key) { store.delete(key) },
-*     async getKeys(base) {
-*       const keys = [...store.keys()]
-*       return base ? keys.filter((k) => k.startsWith(base)) : keys
-*     },
-*     async clear(base) { if (!base) store.clear() },
-*   }
-* })
-*/
-function createStorage(build) {
-	return (options) => build(options ?? {});
-}
-//#endregion
-//#region src/storages/fsStorage.ts
 /**
 * Built-in filesystem storage driver.
 *
-* This is the default storage when no `storage` option is configured in `output`.
+* This is the default storage when no `storage` option is configured in the root config.
 * Keys are resolved against `process.cwd()`, so root-relative paths such as
 * `src/gen/api/getPets.ts` are written to the correct location without extra configuration.
 *
@@ -1387,11 +755,13 @@ function createStorage(build) {
 *
 * @example
 * ```ts
-* import { defineConfig, fsStorage } from '@kubb/core'
+* import { fsStorage } from '@kubb/core'
+* import { defineConfig } from 'kubb'
 *
 * export default defineConfig({
 *   input:  { path: './petStore.yaml' },
-*   output: { path: './src/gen', storage: fsStorage() },
+*   output: { path: './src/gen' },
+*   storage: fsStorage(),
 * })
 * ```
 */
@@ -1401,15 +771,17 @@ const fsStorage = createStorage(() => ({
 		try {
 			await (0, node_fs_promises.access)((0, node_path.resolve)(key));
 			return true;
-		} catch {
-			return false;
+		} catch (error) {
+			if (isMissingPathError(error)) return false;
+			throw new Error(`Failed to access storage item "${key}"`, { cause: error });
 		}
 	},
 	async getItem(key) {
 		try {
 			return await (0, node_fs_promises.readFile)((0, node_path.resolve)(key), "utf8");
-		} catch {
-			return null;
+		} catch (error) {
+			if (isMissingPathError(error)) return null;
+			throw new Error(`Failed to read storage item "${key}"`, { cause: error });
 		}
 	},
 	async setItem(key, value) {
@@ -1420,12 +792,14 @@ const fsStorage = createStorage(() => ({
 	},
 	async getKeys(base) {
 		const keys = [];
+		const resolvedBase = (0, node_path.resolve)(base ?? process.cwd());
 		async function walk(dir, prefix) {
 			let entries;
 			try {
 				entries = await (0, node_fs_promises.readdir)(dir, { withFileTypes: true });
-			} catch {
-				return;
+			} catch (error) {
+				if (isMissingPathError(error)) return;
+				throw new Error(`Failed to list storage keys under "${resolvedBase}"`, { cause: error });
 			}
 			for (const entry of entries) {
 				const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
@@ -1433,7 +807,7 @@ const fsStorage = createStorage(() => ({
 				else keys.push(rel);
 			}
 		}
-		await walk((0, node_path.resolve)(base ?? process.cwd()), "");
+		await walk(resolvedBase, "");
 		return keys;
 	},
 	async clear(base) {
@@ -1443,11 +817,14 @@ const fsStorage = createStorage(() => ({
 }));
 //#endregion
 //#region package.json
-var version = "5.0.0-alpha.9";
+var version = "5.0.0-beta.2";
 //#endregion
 //#region src/utils/diagnostics.ts
 /**
-* Get diagnostic information for debugging
+* 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 {
@@ -1459,13 +836,18 @@ function getDiagnosticInfo() {
 	};
 }
 //#endregion
-//#region src/build.ts
-async function setup(options) {
-	const { config: userConfig, events = new AsyncEventEmitter() } = options;
+//#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
+async function setup(userConfig, options = {}) {
+	const hooks = options.hooks ?? new AsyncEventEmitter();
 	const sources = /* @__PURE__ */ new Map();
 	const diagnosticInfo = getDiagnosticInfo();
-	if (Array.isArray(userConfig.input)) await events.emit("warn", "This feature is still under development — use with caution");
-	await events.emit("debug", {
+	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: [
 			"Configuration:",
@@ -1474,7 +856,7 @@ async function setup(options) {
 			`  • Output: ${userConfig.output?.path || "not specified"}`,
 			`  • Plugins: ${userConfig.plugins?.length || 0}`,
 			"Output Settings:",
-			`  • Storage: ${userConfig.output?.storage ? `custom(${userConfig.output.storage.name})` : userConfig.output?.write === false ? "disabled" : "filesystem (default)"}`,
+			`  • Storage: ${userConfig.storage ? `custom(${userConfig.storage.name})` : userConfig.output?.write === false ? "disabled" : "filesystem (default)"}`,
 			`  • Formatter: ${userConfig.output?.format || "none"}`,
 			`  • Linter: ${userConfig.output?.lint || "none"}`,
 			"Environment:",
@@ -1484,7 +866,7 @@ async function setup(options) {
 	try {
 		if (isInputPath(userConfig) && !new URLPath(userConfig.input.path).isURL) {
 			await exists(userConfig.input.path);
-			await events.emit("debug", {
+			await hooks.emit("kubb:debug", {
 				date: /* @__PURE__ */ new Date(),
 				logs: [`✓ Input file validated: ${userConfig.input.path}`]
 			});
@@ -1495,155 +877,223 @@ async function setup(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 });
 		}
 	}
-	const definedConfig = {
-		root: userConfig.root || process.cwd(),
+	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,
-			barrelType: "named",
-			extension: DEFAULT_EXTENSION,
-			defaultBanner: DEFAULT_BANNER,
+			extension: require_PluginDriver.DEFAULT_EXTENSION,
+			defaultBanner: require_PluginDriver.DEFAULT_BANNER,
 			...userConfig.output
 		},
 		devtools: userConfig.devtools ? {
-			studioUrl: DEFAULT_STUDIO_URL,
+			studioUrl: require_PluginDriver.DEFAULT_STUDIO_URL,
 			...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
 		} : void 0,
 		plugins: userConfig.plugins
 	};
-	const storage = definedConfig.output.write === false ? null : definedConfig.output.storage ?? fsStorage();
-	if (definedConfig.output.clean) {
-		await events.emit("debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: ["Cleaning output directories", `  • Output: ${definedConfig.output.path}`]
-		});
-		await storage?.clear((0, node_path.resolve)(definedConfig.root, definedConfig.output.path));
-	}
-	const fabric = (0, _kubb_react_fabric.createFabric)();
-	fabric.use(_kubb_react_fabric_plugins.fsPlugin);
-	fabric.use(_kubb_react_fabric_parsers.typescriptParser);
-	fabric.context.on("files:processing:start", (files) => {
-		events.emit("files:processing:start", files);
-		events.emit("debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [`Writing ${files.length} files...`]
-		});
-	});
-	fabric.context.on("file:processing:update", async (params) => {
-		const { file, source } = params;
-		await events.emit("file:processing:update", {
-			...params,
-			config: definedConfig,
-			source
-		});
-		if (source) {
-			const key = (0, node_path.relative)((0, node_path.resolve)(definedConfig.root), file.path);
-			await storage?.setItem(key, source);
-			sources.set(file.path, source);
-		}
-	});
-	fabric.context.on("files:processing:end", async (files) => {
-		await events.emit("files:processing:end", files);
-		await events.emit("debug", {
+	const storage = config.output.write === false ? null : config.storage ?? fsStorage();
+	if (config.output.clean) {
+		await hooks.emit("kubb:debug", {
 			date: /* @__PURE__ */ new Date(),
-			logs: [`✓ File write process completed for ${files.length} files`]
+			logs: ["Cleaning output directories", `  • Output: ${config.output.path}`]
 		});
+		await 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}`]
 	});
-	await events.emit("debug", {
+	driver.adapter = adapter;
+	driver.inputNode = await adapter.parse(source);
+	await hooks.emit("kubb:debug", {
 		date: /* @__PURE__ */ new Date(),
 		logs: [
-			"✓ Fabric initialized",
-			`  • Storage: ${storage ? storage.name : "disabled (dry-run)"}`,
-			`  • Barrel type: ${definedConfig.output.barrelType || "none"}`
+			`✓ Adapter '${adapter.name}' resolved InputNode`,
+			`  • Schemas: ${driver.inputNode.schemas.length}`,
+			`  • Operations: ${driver.inputNode.operations.length}`
 		]
 	});
-	const pluginDriver = new PluginDriver(definedConfig, {
-		fabric,
-		events,
-		concurrency: 15
-	});
-	if (definedConfig.adapter) {
-		const source = inputToAdapterSource(definedConfig);
-		await events.emit("debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [`Running adapter: ${definedConfig.adapter.name}`]
-		});
-		pluginDriver.adapter = definedConfig.adapter;
-		pluginDriver.rootNode = await definedConfig.adapter.parse(source);
-		await events.emit("debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [
-				`✓ Adapter '${definedConfig.adapter.name}' resolved RootNode`,
-				`  • Schemas: ${pluginDriver.rootNode.schemas.length}`,
-				`  • Operations: ${pluginDriver.rootNode.operations.length}`
-			]
-		});
-	}
 	return {
-		events,
-		fabric,
-		driver: pluginDriver,
-		sources
+		config,
+		hooks,
+		driver,
+		sources,
+		storage
 	};
 }
-async function build(options, overrides) {
-	const { fabric, files, driver, failedPlugins, pluginTimings, error, sources } = await safeBuild(options, overrides);
-	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,
-		fabric,
-		files,
-		driver,
-		pluginTimings,
-		error: void 0,
-		sources
+/**
+* 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;
+	}
+	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
+			});
+			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 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
+			});
+			if (options !== null) {
+				collectedOperations.push(transformedNode);
+				const ctx = {
+					...generatorContext,
+					options
+				};
+				for (const gen of generators) {
+					if (!gen.operation) continue;
+					await require_PluginDriver.applyHookResult(await gen.operation(transformedNode, ctx), driver, resolveRenderer(gen));
+				}
+				await driver.hooks.emit("kubb:generate:operation", transformedNode, ctx);
+			}
+		}
+	});
+	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(options, overrides) {
-	const { fabric, driver, events, sources } = overrides ? overrides : await setup(options);
+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 {
-		for (const plugin of driver.plugins) {
+		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();
-			const installer = plugin.install.bind(context);
 			try {
 				const timestamp = /* @__PURE__ */ new Date();
-				await events.emit("plugin:start", plugin);
-				await events.emit("debug", {
+				await hooks.emit("kubb:plugin:start", { plugin });
+				await hooks.emit("kubb:debug", {
 					date: timestamp,
-					logs: ["Installing plugin...", `  • Plugin Name: ${plugin.name}`]
+					logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
 				});
-				await installer(context);
+				if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
 				const duration = getElapsedMs(hrStart);
 				pluginTimings.set(plugin.name, duration);
-				await events.emit("plugin:end", plugin, {
+				await hooks.emit("kubb:plugin:end", {
+					plugin,
 					duration,
-					success: true
+					success: true,
+					config,
+					get files() {
+						return driver.fileManager.files;
+					},
+					upsertFile: (...files) => driver.fileManager.upsert(...files)
 				});
-				await events.emit("debug", {
+				await hooks.emit("kubb:debug", {
 					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ Plugin installed successfully (${formatMs(duration)})`]
+					logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
 				});
 			} catch (caughtError) {
 				const error = caughtError;
 				const errorTimestamp = /* @__PURE__ */ new Date();
 				const duration = getElapsedMs(hrStart);
-				await events.emit("plugin:end", plugin, {
+				await hooks.emit("kubb:plugin:end", {
+					plugin,
 					duration,
 					success: false,
-					error
+					error,
+					config,
+					get files() {
+						return driver.fileManager.files;
+					},
+					upsertFile: (...files) => driver.fileManager.upsert(...files)
 				});
-				await events.emit("debug", {
+				await hooks.emit("kubb:debug", {
 					date: errorTimestamp,
 					logs: [
-						"✗ Plugin installation failed",
+						"✗ Plugin start failed",
 						`  • Plugin Name: ${plugin.name}`,
 						`  • Error: ${error.constructor.name} - ${error.message}`,
 						"  • Stack Trace:",
@@ -1656,50 +1106,56 @@ async function safeBuild(options, overrides) {
 				});
 			}
 		}
-		if (config.output.barrelType) {
-			const rootPath = (0, node_path.resolve)((0, node_path.resolve)(config.root), config.output.path, BARREL_FILENAME);
-			const rootDir = (0, node_path.dirname)(rootPath);
-			await events.emit("debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [
-					"Generating barrel file",
-					`  • Type: ${config.output.barrelType}`,
-					`  • Path: ${rootPath}`
-				]
-			});
-			const barrelFiles = fabric.files.filter((file) => {
-				return file.sources.some((source) => source.isIndexable);
-			});
-			await events.emit("debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`Found ${barrelFiles.length} indexable files for barrel export`]
-			});
-			const existingBarrel = fabric.files.find((f) => f.path === rootPath);
-			const rootFile = {
-				path: rootPath,
-				baseName: BARREL_FILENAME,
-				exports: buildBarrelExports({
-					barrelFiles,
-					rootDir,
-					existingExports: new Set(existingBarrel?.exports?.flatMap((e) => Array.isArray(e.name) ? e.name : [e.name]).filter((n) => Boolean(n)) ?? []),
-					config,
-					driver
-				}),
-				sources: [],
-				imports: [],
-				meta: {}
-			};
-			await fabric.upsertFile(rootFile);
-			await events.emit("debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`✓ Generated barrel file (${rootFile.exports?.length || 0} exports)`]
-			});
-		}
-		const files = [...fabric.files];
-		await fabric.write({ extension: config.output.extension });
+		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,
-			fabric,
 			files,
 			driver,
 			pluginTimings,
@@ -1708,123 +1164,141 @@ async function safeBuild(options, overrides) {
 	} catch (error) {
 		return {
 			failedPlugins,
-			fabric,
 			files: [],
 			driver,
 			pluginTimings,
 			error,
 			sources
 		};
+	} finally {
+		driver.dispose();
 	}
 }
-function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }) {
-	const pluginNameMap = /* @__PURE__ */ new Map();
-	for (const plugin of driver.plugins) pluginNameMap.set(plugin.name, plugin);
-	return barrelFiles.flatMap((file) => {
-		const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly);
-		return (file.sources ?? []).flatMap((source) => {
-			if (!file.path || !source.isIndexable) return [];
-			const meta = file.meta;
-			const pluginOptions = (meta?.pluginName ? pluginNameMap.get(meta.pluginName) : void 0)?.options;
-			if (!pluginOptions || pluginOptions.output?.barrelType === false) return [];
-			const exportName = config.output.barrelType === "all" ? void 0 : source.name ? [source.name] : void 0;
-			if (exportName?.some((n) => existingExports.has(n))) return [];
-			return [{
-				name: exportName,
-				path: getRelativePath(rootDir, file.path),
-				isTypeOnly: config.output.barrelType === "all" ? containsOnlyTypes : source.isTypeOnly
-			}];
-		});
-	});
+async function build(setupResult) {
+	const { files, driver, failedPlugins, pluginTimings, error, sources } = 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,
+		sources
+	};
 }
-/**
-* Maps the resolved `Config['input']` shape into an `AdapterSource` that
-* the adapter's `parse()` can consume.
-*/
 function inputToAdapterSource(config) {
 	if (Array.isArray(config.input)) return {
 		type: "paths",
-		paths: config.input.map((i) => (0, node_path.resolve)(config.root, i.path))
+		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
+	};
 	return {
 		type: "path",
 		path: (0, node_path.resolve)(config.root, config.input.path)
 	};
 }
-//#endregion
-//#region src/createAdapter.ts
 /**
-* Creates an adapter factory. Call the returned function with optional options to get the adapter instance.
+* 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`)
+* across the `setup → build` lifecycle. Attach event listeners to `kubb.hooks` before
+* calling `setup()` or `build()`.
 *
 * @example
-* export const myAdapter = createAdapter<MyAdapter>((options) => {
-*   return {
-*     name: 'my-adapter',
-*     options,
-*     async parse(source) { ... },
-*   }
+* ```ts
+* const kubb = createKubb(userConfig)
+*
+* kubb.hooks.on('kubb:plugin:end', ({ plugin, duration }) => {
+*   console.log(`${plugin.name} completed in ${duration}ms`)
 * })
 *
-* // instantiate
-* const adapter = myAdapter({ validate: true })
+* const { files, failedPlugins } = await kubb.safeBuild()
+* ```
 */
-function createAdapter(build) {
-	return (options) => build(options ?? {});
+function createKubb(userConfig, options = {}) {
+	const hooks = options.hooks ?? new AsyncEventEmitter();
+	let setupResult;
+	const instance = {
+		get hooks() {
+			return hooks;
+		},
+		get sources() {
+			return setupResult?.sources ?? /* @__PURE__ */ new Map();
+		},
+		get driver() {
+			return setupResult?.driver;
+		},
+		get 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);
+		}
+	};
+	return instance;
 }
 //#endregion
-//#region src/createPlugin.ts
+//#region src/createRenderer.ts
 /**
-* Creates a plugin factory. Call the returned function with optional options to get the plugin instance.
+* 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.
 *
 * @example
-* export const myPlugin = createPlugin<MyPlugin>((options) => {
+* ```ts
+* // packages/renderer-jsx/src/index.ts
+* export const jsxRenderer = createRenderer(() => {
+*   const runtime = new Runtime()
 *   return {
-*     name: 'my-plugin',
-*     options,
-*     resolvePath(baseName) { ... },
-*     resolveName(name, type) { ... },
+*     async render(element) { await runtime.render(element) },
+*     get files() { return runtime.nodes },
+*     unmount(error) { runtime.unmount(error) },
 *   }
 * })
 *
-* // instantiate
-* const plugin = myPlugin({ output: { path: 'src/gen' } })
+* // 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 createPlugin(build) {
-	return (options) => build(options ?? {});
+function createRenderer(factory) {
+	return factory;
 }
 //#endregion
 //#region src/defineGenerator.ts
+/**
+* Defines a generator. Returns the object as-is with correct `this` typings.
+* `applyHookResult` handles renderer elements and `File[]` uniformly using
+* the generator's declared `renderer` factory.
+*/
 function defineGenerator(generator) {
-	if (generator.type === "react") return {
-		version: "2",
-		Operations() {
-			return null;
-		},
-		Operation() {
-			return null;
-		},
-		Schema() {
-			return null;
-		},
-		...generator
-	};
-	return {
-		version: "2",
-		async operations() {
-			return [];
-		},
-		async operation() {
-			return [];
-		},
-		async schema() {
-			return [];
-		},
-		...generator
-	};
+	return generator;
 }
 //#endregion
 //#region src/defineLogger.ts
@@ -1832,101 +1306,111 @@ function defineGenerator(generator) {
 * Wraps a logger definition into a typed {@link Logger}.
 *
 * @example
+* ```ts
 * export const myLogger = defineLogger({
 *   name: 'my-logger',
 *   install(context, options) {
-*     context.on('info', (message) => console.log('ℹ', message))
-*     context.on('error', (error) => console.error('✗', error.message))
+*     context.on('kubb:info', (message) => console.log('ℹ', message))
+*     context.on('kubb:error', (error) => console.error('✗', error.message))
 *   },
 * })
+* ```
 */
 function defineLogger(logger) {
 	return logger;
 }
 //#endregion
-//#region src/defineResolver.ts
-/**
-* Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
-*/
-function matchesOperationPattern(node, type, pattern) {
-	switch (type) {
-		case "tag": return node.tags.some((tag) => !!tag.match(pattern));
-		case "operationId": return !!node.operationId.match(pattern);
-		case "path": return !!node.path.match(pattern);
-		case "method": return !!node.method.toLowerCase().match(pattern);
-		default: return false;
-	}
-}
-/**
-* Checks if a schema matches a pattern for a given filter type (`schemaName`).
-* Returns `null` when the filter type doesn't apply to schemas.
-*/
-function matchesSchemaPattern(node, type, pattern) {
-	switch (type) {
-		case "schemaName": return node.name ? !!node.name.match(pattern) : false;
-		default: return null;
-	}
-}
+//#region src/defineMiddleware.ts
 /**
-* Default name resolver — `camelCase` for most types, `PascalCase` for `type`.
+* Creates a middleware factory using the hook-style `hooks` API.
+*
+* Middleware handlers fire after all plugin handlers for any given event, making them ideal for post-processing, logging, and auditing.
+* Per-build state (such as accumulators) belongs inside the factory closure so each `createKubb` invocation gets its own isolated instance.
+*
+* @note The factory can accept typed options. See examples for using options and per-build state patterns.
+*
+* @example
+* ```ts
+* import { defineMiddleware } from '@kubb/core'
+*
+* // Stateless middleware
+* export const logMiddleware = defineMiddleware(() => ({
+*   name: 'log-middleware',
+*   hooks: {
+*     'kubb:build:end'({ files }) {
+*       console.log(`Build complete with ${files.length} files`)
+*     },
+*   },
+* }))
+*
+* // Middleware with options and per-build state
+* export const prefixMiddleware = defineMiddleware((options: { prefix: string } = { prefix: '' }) => {
+*   const seen = new Set<string>()
+*   return {
+*     name: 'prefix-middleware',
+*     hooks: {
+*       'kubb:plugin:end'({ plugin }) {
+*         seen.add(`${options.prefix}${plugin.name}`)
+*       },
+*     },
+*   }
+* })
+* ```
 */
-function defaultResolver(name, type) {
-	let resolvedName = camelCase(name);
-	if (type === "file" || type === "function") resolvedName = camelCase(name, { isFile: type === "file" });
-	if (type === "type") resolvedName = pascalCase(name);
-	return resolvedName;
+function defineMiddleware(factory) {
+	return (options) => factory(options ?? {});
 }
+//#endregion
+//#region src/defineParser.ts
 /**
-* Default option resolver — applies include/exclude filters and merges any matching override options.
-* Returns `null` when the node is filtered out.
+* Defines a parser with type safety. Creates parsers that transform generated files to strings based on their extension.
+*
+* @note Call the returned factory with optional options to instantiate the parser.
+*
+* @example
+* ```ts
+* import { defineParser } from '@kubb/core'
+*
+* export const jsonParser = defineParser({
+*   name: 'json',
+*   extNames: ['.json'],
+*   parse(file) {
+*     const { extractStringsFromNodes } = await import('@kubb/ast')
+*     return file.sources.map((s) => extractStringsFromNodes(s.nodes ?? [])).join('\n')
+*   },
+* })
+* ```
 */
-function defaultResolveOptions(node, { options, exclude = [], include, override = [] }) {
-	if ((0, _kubb_ast.isOperationNode)(node)) {
-		if (exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
-		if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) return null;
-		const overrideOptions = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))?.options;
-		return {
-			...options,
-			...overrideOptions
-		};
-	}
-	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);
-			if (applicable.length > 0 && !applicable.includes(true)) return null;
-		}
-		const overrideOptions = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)?.options;
-		return {
-			...options,
-			...overrideOptions
-		};
-	}
-	return options;
+function defineParser(parser) {
+	return parser;
 }
+//#endregion
+//#region src/definePlugin.ts
 /**
-* Defines a resolver for a plugin, with built-in defaults for name casing and include/exclude/override filtering.
-* Override `default` or `resolveOptions` in the builder to customize the behavior.
+* 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
-* export const resolver = defineResolver<PluginTs>(() => ({
-*   resolveName(name) {
-*     return this.default(name, 'function')
-*   },
-*   resolveTypedName(name) {
-*     return this.default(name, 'type')
-*   },
-*   resolveParamName(node, param) {
-*     return this.resolveName(`${node.operationId} ${param.in} ${param.name}`)
+* ```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 defineResolver(build) {
-	return {
-		default: defaultResolver,
-		resolveOptions: defaultResolveOptions,
-		...build()
-	};
+function definePlugin(factory) {
+	return (options) => factory(options ?? {});
 }
 //#endregion
 //#region src/storages/memoryStorage.ts
@@ -1939,11 +1423,13 @@ function defineResolver(build) {
 *
 * @example
 * ```ts
-* import { defineConfig, memoryStorage } from '@kubb/core'
+* import { memoryStorage } from '@kubb/core'
+* import { defineConfig } from 'kubb'
 *
 * export default defineConfig({
 *   input:  { path: './petStore.yaml' },
-*   output: { path: './src/gen', storage: memoryStorage() },
+*   output: { path: './src/gen' },
+*   storage: memoryStorage(),
 * })
 * ```
 */
@@ -1977,405 +1463,30 @@ const memoryStorage = createStorage(() => {
 	};
 });
 //#endregion
-//#region src/utils/FunctionParams.ts
-/**
-* @deprecated
-*/
-var FunctionParams = class FunctionParams {
-	#items = [];
-	get items() {
-		return this.#items.flat();
-	}
-	add(item) {
-		if (!item) return this;
-		if (Array.isArray(item)) {
-			item.filter((x) => x !== void 0).forEach((it) => {
-				this.#items.push(it);
-			});
-			return this;
-		}
-		this.#items.push(item);
-		return this;
-	}
-	static #orderItems(items) {
-		return (0, remeda.sortBy)(items.filter(Boolean), [(item) => Array.isArray(item), "desc"], [(item) => !Array.isArray(item) && item.default !== void 0, "asc"], [(item) => Array.isArray(item) || (item.required ?? true), "desc"]);
-	}
-	static #addParams(acc, item) {
-		const { enabled = true, name, type, required = true, ...rest } = item;
-		if (!enabled) return acc;
-		if (!name) {
-			acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
-			return acc;
-		}
-		const parameterName = name.startsWith("{") ? name : camelCase(name);
-		if (type) if (required) acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
-		else acc.push(`${parameterName}?: ${type}`);
-		else acc.push(`${parameterName}`);
-		return acc;
-	}
-	static toObject(items) {
-		let type = [];
-		let name = [];
-		const enabled = items.every((item) => item.enabled) ? items.at(0)?.enabled : true;
-		const required = items.every((item) => item.required) ?? true;
-		items.forEach((item) => {
-			name = FunctionParams.#addParams(name, {
-				...item,
-				type: void 0
-			});
-			if (items.some((item) => item.type)) type = FunctionParams.#addParams(type, item);
-		});
-		return {
-			name: `{ ${name.join(", ")} }`,
-			type: type.length ? `{ ${type.join("; ")} }` : void 0,
-			enabled,
-			required
-		};
-	}
-	toObject() {
-		const items = FunctionParams.#orderItems(this.#items).flat();
-		return FunctionParams.toObject(items);
-	}
-	static toString(items) {
-		return FunctionParams.#orderItems(items).reduce((acc, item) => {
-			if (Array.isArray(item)) {
-				if (item.length <= 0) return acc;
-				const subItems = FunctionParams.#orderItems(item);
-				const objectItem = FunctionParams.toObject(subItems);
-				return FunctionParams.#addParams(acc, objectItem);
-			}
-			return FunctionParams.#addParams(acc, item);
-		}, []).join(", ");
-	}
-	toString() {
-		const items = FunctionParams.#orderItems(this.#items);
-		return FunctionParams.toString(items);
-	}
-};
-//#endregion
-//#region src/utils/formatters.ts
-/**
-* Check if a formatter command is available in the system.
-*
-* @param formatter - The formatter to check ('biome', 'prettier', or 'oxfmt')
-* @returns Promise that resolves to true if the formatter is available, false otherwise
-*
-* @remarks
-* This function checks availability by running `<formatter> --version` command.
-* All supported formatters (biome, prettier, oxfmt) implement the --version flag.
-*/
-async function isFormatterAvailable(formatter) {
-	try {
-		await (0, tinyexec.x)(formatter, ["--version"], { nodeOptions: { stdio: "ignore" } });
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
-* Detect which formatter is available in the system.
-*
-* @returns Promise that resolves to the first available formatter or undefined if none are found
-*
-* @remarks
-* Checks in order of preference: biome, oxfmt, prettier.
-* Uses the `--version` flag to detect if each formatter command is available.
-* This is a reliable method as all supported formatters implement this flag.
-*
-* @example
-* ```typescript
-* const formatter = await detectFormatter()
-* if (formatter) {
-*   console.log(`Using ${formatter} for formatting`)
-* } else {
-*   console.log('No formatter found')
-* }
-* ```
-*/
-async function detectFormatter() {
-	const formatterNames = new Set([
-		"biome",
-		"oxfmt",
-		"prettier"
-	]);
-	for (const formatter of formatterNames) if (await isFormatterAvailable(formatter)) return formatter;
-}
-//#endregion
-//#region src/utils/TreeNode.ts
-var TreeNode = class TreeNode {
-	data;
-	parent;
-	children = [];
-	#cachedLeaves = void 0;
-	constructor(data, parent) {
-		this.data = data;
-		this.parent = parent;
-	}
-	addChild(data) {
-		const child = new TreeNode(data, this);
-		if (!this.children) this.children = [];
-		this.children.push(child);
-		return child;
-	}
-	get root() {
-		if (!this.parent) return this;
-		return this.parent.root;
-	}
-	get leaves() {
-		if (!this.children || this.children.length === 0) return [this];
-		if (this.#cachedLeaves) return this.#cachedLeaves;
-		const leaves = [];
-		for (const child of this.children) leaves.push(...child.leaves);
-		this.#cachedLeaves = leaves;
-		return leaves;
-	}
-	forEach(callback) {
-		if (typeof callback !== "function") throw new TypeError("forEach() callback must be a function");
-		callback(this);
-		for (const child of this.children) child.forEach(callback);
-		return this;
-	}
-	findDeep(predicate) {
-		if (typeof predicate !== "function") throw new TypeError("find() predicate must be a function");
-		return this.leaves.find(predicate);
-	}
-	forEachDeep(callback) {
-		if (typeof callback !== "function") throw new TypeError("forEach() callback must be a function");
-		this.leaves.forEach(callback);
-	}
-	filterDeep(callback) {
-		if (typeof callback !== "function") throw new TypeError("filter() callback must be a function");
-		return this.leaves.filter(callback);
-	}
-	mapDeep(callback) {
-		if (typeof callback !== "function") throw new TypeError("map() callback must be a function");
-		return this.leaves.map(callback);
-	}
-	static build(files, root) {
-		try {
-			const filteredTree = buildDirectoryTree(files, root);
-			if (!filteredTree) return null;
-			const treeNode = new TreeNode({
-				name: filteredTree.name,
-				path: filteredTree.path,
-				file: filteredTree.file,
-				type: getMode(filteredTree.path)
-			});
-			const recurse = (node, item) => {
-				const subNode = node.addChild({
-					name: item.name,
-					path: item.path,
-					file: item.file,
-					type: getMode(item.path)
-				});
-				if (item.children?.length) item.children?.forEach((child) => {
-					recurse(subNode, child);
-				});
-			};
-			filteredTree.children?.forEach((child) => {
-				recurse(treeNode, child);
-			});
-			return treeNode;
-		} catch (error) {
-			throw new Error("Something went wrong with creating barrel files with the TreeNode class", { cause: error });
-		}
-	}
-};
-const normalizePath = (p) => p.replaceAll("\\", "/");
-function buildDirectoryTree(files, rootFolder = "") {
-	const normalizedRootFolder = normalizePath(rootFolder);
-	const rootPrefix = normalizedRootFolder.endsWith("/") ? normalizedRootFolder : `${normalizedRootFolder}/`;
-	const filteredFiles = files.filter((file) => {
-		const normalizedFilePath = normalizePath(file.path);
-		return rootFolder ? normalizedFilePath.startsWith(rootPrefix) && !normalizedFilePath.endsWith(".json") : !normalizedFilePath.endsWith(".json");
-	});
-	if (filteredFiles.length === 0) return null;
-	const root = {
-		name: rootFolder || "",
-		path: rootFolder || "",
-		children: []
-	};
-	filteredFiles.forEach((file) => {
-		const parts = file.path.slice(rootFolder.length).split("/").filter(Boolean);
-		let currentLevel = root.children;
-		let currentPath = normalizePath(rootFolder);
-		parts.forEach((part, index) => {
-			currentPath = node_path.default.posix.join(currentPath, part);
-			let existingNode = currentLevel.find((node) => node.name === part);
-			if (!existingNode) {
-				if (index === parts.length - 1) existingNode = {
-					name: part,
-					file,
-					path: currentPath
-				};
-				else existingNode = {
-					name: part,
-					path: currentPath,
-					children: []
-				};
-				currentLevel.push(existingNode);
-			}
-			if (!existingNode.file) currentLevel = existingNode.children;
-		});
-	});
-	return root;
-}
-//#endregion
-//#region src/utils/getBarrelFiles.ts
-/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
-function getBarrelFilesByRoot(root, files) {
-	const cachedFiles = /* @__PURE__ */ new Map();
-	TreeNode.build(files, root)?.forEach((treeNode) => {
-		if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) return;
-		const barrelFile = {
-			path: (0, node_path.join)(treeNode.parent?.data.path, "index.ts"),
-			baseName: "index.ts",
-			exports: [],
-			imports: [],
-			sources: []
-		};
-		const previousBarrelFile = cachedFiles.get(barrelFile.path);
-		treeNode.leaves.forEach((item) => {
-			if (!item.data.name) return;
-			(item.data.file?.sources || []).forEach((source) => {
-				if (!item.data.file?.path || !source.isIndexable || !source.name) return;
-				if (previousBarrelFile?.sources.some((item) => item.name === source.name && item.isTypeOnly === source.isTypeOnly)) return;
-				barrelFile.exports.push({
-					name: [source.name],
-					path: getRelativePath(treeNode.parent?.data.path, item.data.path),
-					isTypeOnly: source.isTypeOnly
-				});
-				barrelFile.sources.push({
-					name: source.name,
-					isTypeOnly: source.isTypeOnly,
-					value: "",
-					isExportable: false,
-					isIndexable: false
-				});
-			});
-		});
-		if (previousBarrelFile) {
-			previousBarrelFile.sources.push(...barrelFile.sources);
-			previousBarrelFile.exports?.push(...barrelFile.exports || []);
-		} else cachedFiles.set(barrelFile.path, barrelFile);
-	});
-	return [...cachedFiles.values()];
-}
-function trimExtName(text) {
-	const dotIndex = text.lastIndexOf(".");
-	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
-	return text;
-}
-async function getBarrelFiles(files, { type, meta = {}, root, output }) {
-	if (!type || type === "propagate") return [];
-	const pathToBuildFrom = (0, node_path.join)(root, output.path);
-	if (trimExtName(pathToBuildFrom).endsWith("index")) return [];
-	const barrelFiles = getBarrelFilesByRoot(pathToBuildFrom, files);
-	if (type === "all") return barrelFiles.map((file) => {
-		return {
-			...file,
-			exports: file.exports?.map((exportItem) => {
-				return {
-					...exportItem,
-					name: void 0
-				};
-			})
-		};
-	});
-	return barrelFiles.map((indexFile) => {
-		return {
-			...indexFile,
-			meta
-		};
-	});
-}
-//#endregion
-//#region src/utils/getConfigs.ts
-/**
-* Converting UserConfig to Config Array without a change in the object beside the JSON convert.
-*/
-async function getConfigs(config, args) {
-	const resolved = await (typeof config === "function" ? config(args) : config);
-	return (Array.isArray(resolved) ? resolved : [resolved]).map((item) => ({ ...item }));
-}
-//#endregion
-//#region src/utils/linters.ts
-async function isLinterAvailable(linter) {
-	try {
-		await (0, tinyexec.x)(linter, ["--version"], { nodeOptions: { stdio: "ignore" } });
-		return true;
-	} catch {
-		return false;
+exports.AsyncEventEmitter = AsyncEventEmitter;
+exports.FileManager = require_PluginDriver.FileManager;
+exports.FileProcessor = FileProcessor;
+exports.PluginDriver = require_PluginDriver.PluginDriver;
+exports.URLPath = URLPath;
+Object.defineProperty(exports, "ast", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast;
 	}
-}
-async function detectLinter() {
-	const linterNames = new Set([
-		"biome",
-		"oxlint",
-		"eslint"
-	]);
-	for (const linter of linterNames) if (await isLinterAvailable(linter)) return linter;
-}
-//#endregion
-//#region src/utils/packageJSON.ts
-function getPackageJSONSync(cwd) {
-	const pkgPath = empathic_package.up({ cwd });
-	if (!pkgPath) return;
-	return JSON.parse(readSync(pkgPath));
-}
-function match(packageJSON, dependency) {
-	const dependencies = {
-		...packageJSON.dependencies || {},
-		...packageJSON.devDependencies || {}
-	};
-	if (typeof dependency === "string" && dependencies[dependency]) return dependencies[dependency];
-	const matched = Object.keys(dependencies).find((dep) => dep.match(dependency));
-	return matched ? dependencies[matched] : void 0;
-}
-function getVersionSync(dependency, cwd) {
-	const packageJSON = getPackageJSONSync(cwd);
-	return packageJSON ? match(packageJSON, dependency) : void 0;
-}
-function satisfiesDependency(dependency, version, cwd) {
-	const packageVersion = getVersionSync(dependency, cwd);
-	if (!packageVersion) return false;
-	if (packageVersion === version) return true;
-	const semVer = (0, semver.coerce)(packageVersion);
-	if (!semVer) return false;
-	return (0, semver.satisfies)(semVer, version);
-}
-//#endregion
-exports.FunctionParams = FunctionParams;
-exports.PluginDriver = PluginDriver;
-exports.build = build;
+});
 exports.createAdapter = createAdapter;
-exports.createPlugin = createPlugin;
+exports.createKubb = createKubb;
+exports.createRenderer = createRenderer;
 exports.createStorage = createStorage;
-exports.default = build;
-exports.defaultResolveOptions = defaultResolveOptions;
-exports.defineConfig = defineConfig;
 exports.defineGenerator = defineGenerator;
 exports.defineLogger = defineLogger;
-Object.defineProperty(exports, "definePrinter", {
-	enumerable: true,
-	get: function() {
-		return _kubb_ast.definePrinter;
-	}
-});
-exports.defineResolver = defineResolver;
-exports.detectFormatter = detectFormatter;
-exports.detectLinter = detectLinter;
-exports.formatters = formatters;
+exports.defineMiddleware = defineMiddleware;
+exports.defineParser = defineParser;
+exports.definePlugin = definePlugin;
+exports.defineResolver = require_PluginDriver.defineResolver;
 exports.fsStorage = fsStorage;
-exports.getBarrelFiles = getBarrelFiles;
-exports.getConfigs = getConfigs;
-exports.getMode = getMode;
 exports.isInputPath = isInputPath;
-exports.linters = linters;
-exports.logLevel = logLevel;
+exports.logLevel = require_PluginDriver.logLevel;
 exports.memoryStorage = memoryStorage;
-exports.safeBuild = safeBuild;
-exports.satisfiesDependency = satisfiesDependency;
-exports.setup = setup;
 
 //# sourceMappingURL=index.cjs.map