@kubb/core 5.0.0-alpha.3 → 5.0.0-alpha.31

package/dist/index.cjs

@@ -2,36 +2,33 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_chunk = require("./chunk-ByKO4r7w.cjs");
+const require_chunk = require("./chunk-MlS0t1Af.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 node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let _kubb_ast = require("@kubb/ast");
 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 _kubb_react_fabric_jsx_runtime = require("@kubb/react-fabric/jsx-runtime");
 let node_process = require("node:process");
-let node_module = require("node:module");
-node_module = require_chunk.__toESM(node_module);
-let node_os = require("node:os");
-node_os = require_chunk.__toESM(node_os);
-let node_url = require("node:url");
+let remeda = require("remeda");
 let empathic_package = require("empathic/package");
 empathic_package = require_chunk.__toESM(empathic_package);
 let semver = require("semver");
-let remeda = require("remeda");
-//#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;
@@ -43,19 +40,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) {
@@ -63,31 +75,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);
@@ -95,15 +124,31 @@ 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. */
+	/**
+	* Removes all listeners from every event channel.
+	*
+	* @example
+	* ```ts
+	* emitter.removeAll()
+	* ```
+	*/
 	removeAll() {
 		this.#emitter.removeAllListeners();
 	}
 };
+//#endregion
+//#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
 * Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
@@ -122,9 +167,12 @@ function toCamelOrPascal(text, pascal) {
 * 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.
+*
+* Only splits on dots followed by a letter so that version numbers
+* embedded in operationIds (e.g. `v2025.0`) are kept intact.
 */
 function applyToFileParts(text, transformPart) {
-	const parts = text.split(".");
+	const parts = text.split(/\.(?=[a-zA-Z])/);
 	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
 }
 /**
@@ -142,190 +190,33 @@ function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	} : {}));
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
-/** 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.
+* Converts `text` to PascalCase.
+* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+*
+* @example
+* pascalCase('hello-world')                  // 'HelloWorld'
+* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
 */
-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;
+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);
 }
-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);
-	}
-});
+//#endregion
+//#region ../../internals/utils/src/time.ts
 /**
-* Calculates elapsed time in milliseconds from a high-resolution start time.
-* Rounds to 2 decimal places to provide sub-millisecond precision without noise.
+* Calculates elapsed time in milliseconds from a high-resolution `process.hrtime` start time.
+* Rounds to 2 decimal places for sub-millisecond precision without noise.
+*
+* @example
+* ```ts
+* const start = process.hrtime()
+* doWork()
+* getElapsedMs(start) // 42.35
+* ```
 */
 function getElapsedMs(hrStart) {
 	const [seconds, nanoseconds] = process.hrtime(hrStart);
@@ -333,39 +224,22 @@ 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");
+//#endregion
+//#region ../../internals/utils/src/fs.ts
 /**
 * Converts all backslashes to forward slashes.
 * Extended-length Windows paths (`\\?\...`) are left unchanged.
@@ -375,8 +249,14 @@ function toSlash(p) {
 	return p.replaceAll("\\", "/");
 }
 /**
-* Returns the relative path from `rootDir` to `filePath`, always using
-* forward slashes and prefixed with `./` when not already traversing upward.
+* Returns the relative path from `rootDir` to `filePath`, always using forward slashes
+* and prefixed with `./` when not already traversing upward.
+*
+* @example
+* ```ts
+* getRelativePath('/src/components', '/src/components/Button.tsx') // './Button.tsx'
+* getRelativePath('/src/components', '/src/utils/helpers.ts')      // '../utils/helpers.ts'
+* ```
 */
 function getRelativePath(rootDir, filePath) {
 	if (!rootDir || !filePath) throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
@@ -386,43 +266,54 @@ function getRelativePath(rootDir, filePath) {
 /**
 * 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);
 }
 /**
-* Reads the file at `path` as a UTF-8 string.
-* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
+* Synchronous counterpart of `read`.
+*
+* @example
+* ```ts
+* const source = readSync('./src/Pet.ts')
+* ```
 */
-async function read(path) {
-	if (typeof Bun !== "undefined") return Bun.file(path).text();
-	return (0, node_fs_promises.readFile)(path, { encoding: "utf8" });
-}
-/** 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" });
@@ -433,31 +324,40 @@ 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.
+//#endregion
+//#region ../../internals/utils/src/promise.ts
+/** Returns `true` when `result` is a rejected `Promise.allSettled` result with a typed `reason`.
+*
+* @example
+* ```ts
+* const results = await Promise.allSettled([p1, p2])
+* results.filter(isPromiseRejectedResult<Error>).map((r) => r.reason.message)
+* ```
 */
-function setUniqueName(originalName, data) {
-	let used = data[originalName] || 0;
-	if (used) {
-		data[originalName] = ++used;
-		return originalName;
-	}
-	data[originalName] = 1;
-	return originalName;
+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
 */
-const reservedWords = [
+const reservedWords = new Set([
 	"abstract",
 	"arguments",
 	"boolean",
@@ -539,18 +439,31 @@ const reservedWords = [
 	"toString",
 	"undefined",
 	"valueOf"
-];
+]);
 /**
-* Prefixes a word with `_` when it is a reserved JavaScript/Java identifier
-* or starts with a digit.
+* Prefixes `word` with `_` when it is a reserved JavaScript/Java identifier or starts with a digit.
+*
+* @example
+* ```ts
+* transformReservedWord('class')  // '_class'
+* transformReservedWord('42foo')  // '_42foo'
+* transformReservedWord('status') // 'status'
+* ```
 */
 function transformReservedWord(word) {
 	const firstChar = word.charCodeAt(0);
-	if (word && (reservedWords.includes(word) || firstChar >= 48 && firstChar <= 57)) return `_${word}`;
+	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 {
@@ -560,6 +473,8 @@ function isValidVarName(name) {
 	}
 	return true;
 }
+//#endregion
+//#region ../../internals/utils/src/urlPath.ts
 /**
 * Parses and transforms an OpenAPI/Swagger path string into various URL formats.
 *
@@ -569,18 +484,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;
@@ -598,11 +528,25 @@ 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();
 	}
@@ -610,7 +554,9 @@ var URLPath = class {
 		const param = isValidVarName(raw) ? raw : camelCase(raw);
 		return this.#options.casing === "camelcase" ? 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];
@@ -647,6 +593,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 = {};
@@ -656,29 +608,40 @@ 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;
-}
+//#region src/constants.ts
 /**
-* Type guard to check if a given config has an `input.path`.
+* Base URL for the Kubb Studio web app.
 */
-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";
+/**
+* File name used for generated barrel (index) files.
+*/
 const BARREL_FILENAME = "index.ts";
+/**
+* Default banner style written at the top of every generated file.
+*/
 const DEFAULT_BANNER = "simple";
+/**
+* Default file-extension mapping used when no explicit mapping is configured.
+*/
 const DEFAULT_EXTENSION = { ".ts": ".ts" };
-const PATH_SEPARATORS = ["/", "\\"];
+/**
+* Numeric log-level thresholds used internally to compare verbosity.
+*
+* Higher numbers are more verbose.
+*/
 const logLevel = {
 	silent: Number.NEGATIVE_INFINITY,
 	error: 0,
@@ -687,6 +650,13 @@ const logLevel = {
 	verbose: 4,
 	debug: 5
 };
+/**
+* CLI command descriptors for each supported linter.
+*
+* Each entry contains the executable `command`, an `args` factory that maps an
+* output path to the correct argument list, and an `errorMessage` shown when
+* the linter is not found.
+*/
 const linters = {
 	eslint: {
 		command: "eslint",
@@ -708,6 +678,13 @@ const linters = {
 		errorMessage: "Oxlint not found"
 	}
 };
+/**
+* CLI command descriptors for each supported code formatter.
+*
+* Each entry contains the executable `command`, an `args` factory that maps an
+* output path to the correct argument list, and an `errorMessage` shown when
+* the formatter is not found.
+*/
 const formatters = {
 	prettier: {
 		command: "prettier",
@@ -734,6 +711,34 @@ const formatters = {
 	}
 };
 //#endregion
+//#region src/defineParser.ts
+/**
+* Defines a parser with type safety.
+*
+* Use this function to create parsers that transform generated files to strings
+* based on their extension.
+*
+* @example
+* ```ts
+* import { defineParser } from '@kubb/core'
+*
+* export const jsonParser = defineParser({
+*   name: 'json',
+*   extNames: ['.json'],
+*   parse(file) {
+*     return file.sources.map((s) => s.value).join('\n')
+*   },
+* })
+* ```
+*/
+function defineParser(parser) {
+	return {
+		install() {},
+		type: "parser",
+		...parser
+	};
+}
+//#endregion
 //#region src/devtools.ts
 /**
 * Encodes a `RootNode` as a compressed, URL-safe string.
@@ -907,7 +912,12 @@ function validateConcurrency(concurrency) {
 //#endregion
 //#region src/utils/executeStrategies.ts
 /**
-* Chains promises
+* Runs promise functions in sequence, threading each result into the next call.
+*
+* - Each function receives the accumulated state from the previous call.
+* - Skips functions that return a falsy value (acts as a no-op for that step).
+* - Returns an array of all individual results.
+*  @deprecated
 */
 function hookSeq(promises) {
 	return promises.filter(Boolean).reduce((promise, func) => {
@@ -920,7 +930,11 @@ function hookSeq(promises) {
 	}, Promise.resolve([]));
 }
 /**
-* Chains promises, first non-null result stops and returns
+* Runs promise functions in sequence and returns the first non-null result.
+*
+* - Stops as soon as `nullCheck` passes for a result (default: `!== null`).
+* - Subsequent functions are skipped once a match is found.
+*  @deprecated
 */
 function hookFirst(promises, nullCheck = (state) => state !== null) {
 	let promise = Promise.resolve(null);
@@ -931,7 +945,11 @@ function hookFirst(promises, nullCheck = (state) => state !== null) {
 	return promise;
 }
 /**
-* Runs an array of promise functions with optional concurrency limit.
+* Runs promise functions concurrently and returns all settled results.
+*
+* - Limits simultaneous executions to `concurrency` (default: unlimited).
+* - Uses `Promise.allSettled` so individual failures do not cancel other tasks.
+*  @deprecated
 */
 function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
 	const limit = pLimit(concurrency);
@@ -939,29 +957,22 @@ function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
 	return Promise.allSettled(tasks);
 }
 //#endregion
-//#region src/PromiseManager.ts
-var PromiseManager = class {
-	#options = {};
-	constructor(options = {}) {
-		this.#options = options;
-	}
-	run(strategy, promises, { concurrency = Number.POSITIVE_INFINITY } = {}) {
-		if (strategy === "seq") return hookSeq(promises);
-		if (strategy === "first") return hookFirst(promises, this.#options.nullCheck);
-		if (strategy === "parallel") return hookParallel(promises, concurrency);
-		throw new Error(`${strategy} not implemented`);
-	}
-};
-function isPromiseRejectedResult(result) {
-	return result.status === "rejected";
-}
-//#endregion
-//#region src/PluginManager.ts
+//#region src/PluginDriver.ts
+/**
+* Returns `'single'` when `fileOrFolder` has a file extension, `'split'` otherwise.
+*
+* @example
+* ```ts
+* getMode('src/gen/types.ts')  // 'single'
+* getMode('src/gen/types')     // 'split'
+* ```
+*/
 function getMode(fileOrFolder) {
 	if (!fileOrFolder) return "split";
 	return (0, node_path.extname)(fileOrFolder) ? "single" : "split";
 }
-var PluginManager = class {
+const hookFirstNullCheck = (state) => !!state?.result;
+var PluginDriver = class {
 	config;
 	options;
 	/**
@@ -971,31 +982,43 @@ var PluginManager = class {
 	rootNode = void 0;
 	adapter = void 0;
 	#studioIsOpen = false;
-	#plugins = /* @__PURE__ */ new Set();
-	#usedPluginNames = {};
-	#promiseManager;
+	plugins = /* @__PURE__ */ new Map();
 	constructor(config, options) {
 		this.config = config;
 		this.options = options;
-		this.#promiseManager = new PromiseManager({ nullCheck: (state) => !!state?.result });
-		[...config.plugins || []].forEach((plugin) => {
-			const parsedPlugin = this.#parse(plugin);
-			this.#plugins.add(parsedPlugin);
+		config.plugins.map((plugin) => Object.assign({
+			buildStart() {},
+			buildEnd() {}
+		}, plugin)).filter((plugin) => {
+			if (typeof plugin.apply === "function") return plugin.apply(config);
+			return true;
+		}).sort((a, b) => {
+			if (b.pre?.includes(a.name)) return 1;
+			if (b.post?.includes(a.name)) return -1;
+			return 0;
+		}).forEach((plugin) => {
+			this.plugins.set(plugin.name, plugin);
 		});
 	}
 	get events() {
 		return this.options.events;
 	}
 	getContext(plugin) {
-		const plugins = [...this.#plugins];
-		const pluginManager = this;
+		const driver = this;
 		const baseContext = {
-			fabric: this.options.fabric,
-			config: this.config,
+			fabric: driver.options.fabric,
+			config: driver.config,
+			get root() {
+				return (0, node_path.resolve)(driver.config.root, driver.config.output.path);
+			},
+			getMode(output) {
+				return getMode((0, node_path.resolve)(driver.config.root, driver.config.output.path, output.path));
+			},
+			events: driver.options.events,
 			plugin,
-			events: this.options.events,
-			pluginManager: this,
-			mode: getMode((0, node_path.resolve)(this.config.root, this.config.output.path)),
+			getPlugin: driver.getPlugin.bind(driver),
+			requirePlugin: driver.requirePlugin.bind(driver),
+			driver,
 			addFile: async (...files) => {
 				await this.options.fabric.addFile(...files);
 			},
@@ -1003,23 +1026,38 @@ var PluginManager = class {
 				await this.options.fabric.upsertFile(...files);
 			},
 			get rootNode() {
-				return pluginManager.rootNode;
+				return driver.rootNode;
 			},
 			get adapter() {
-				return pluginManager.adapter;
+				return driver.adapter;
+			},
+			get resolver() {
+				return plugin.resolver;
+			},
+			get transformer() {
+				return plugin.transformer;
+			},
+			warn(message) {
+				driver.events.emit("warn", message);
+			},
+			error(error) {
+				driver.events.emit("error", typeof error === "string" ? new Error(error) : error);
+			},
+			info(message) {
+				driver.events.emit("info", message);
 			},
 			openInStudio(options) {
-				if (!pluginManager.config.devtools || pluginManager.#studioIsOpen) return;
-				if (typeof pluginManager.config.devtools !== "object") throw new Error("Devtools must be an object");
-				if (!pluginManager.rootNode || !pluginManager.adapter) throw new Error("adapter is not defined, make sure you have set the parser in kubb.config.ts");
-				pluginManager.#studioIsOpen = true;
-				const studioUrl = pluginManager.config.devtools?.studioUrl ?? "https://studio.kubb.dev";
-				return openInStudio(pluginManager.rootNode, studioUrl, 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);
+		for (const p of this.plugins.values()) if (typeof p.inject === "function") {
+			const result = p.inject.call(baseContext);
 			if (result !== null && typeof result === "object") Object.assign(mergedExtras, result);
 		}
 		return {
@@ -1027,9 +1065,9 @@ var PluginManager = class {
 			...mergedExtras
 		};
 	}
-	get plugins() {
-		return this.#getSortedPlugins();
-	}
+	/**
+	* @deprecated use resolvers context instead
+	*/
 	getFile({ name, mode, extname, pluginName, options }) {
 		const resolvedName = mode ? mode === "single" ? "" : this.resolveName({
 			name,
@@ -1052,6 +1090,9 @@ var PluginManager = class {
 			exports: []
 		};
 	}
+	/**
+	* @deprecated use resolvers context instead
+	*/
 	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({
@@ -1072,15 +1113,15 @@ var PluginManager = class {
 			]
 		})?.result || defaultPath;
 	};
+	/**
+	* @deprecated use resolvers context instead
+	*/
 	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);
-		}
+		if (params.pluginName) return transformReservedWord(this.hookForPluginSync({
+			pluginName: params.pluginName,
+			hookName: "resolveName",
+			parameters: [params.name.trim(), params.type]
+		})?.at(0) ?? params.name);
 		const name = this.hookFirstSync({
 			hookName: "resolveName",
 			parameters: [params.name.trim(), params.type]
@@ -1091,49 +1132,46 @@ var PluginManager = class {
 	* Run a specific hookName for plugin x.
 	*/
 	async hookForPlugin({ pluginName, hookName, parameters }) {
-		const plugins = this.getPluginsByName(hookName, pluginName);
+		const plugin = this.plugins.get(pluginName);
+		if (!plugin) return [null];
 		this.events.emit("plugins:hook:progress:start", {
 			hookName,
-			plugins
+			plugins: [plugin]
+		});
+		const result = await this.#execute({
+			strategy: "hookFirst",
+			hookName,
+			parameters,
+			plugin
 		});
-		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;
+		return [result];
 	}
 	/**
 	* 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);
+		const plugin = this.plugins.get(pluginName);
+		if (!plugin) return null;
+		const result = this.#executeSync({
+			strategy: "hookFirst",
+			hookName,
+			parameters,
+			plugin
+		});
+		return result !== null ? [result] : [];
 	}
 	/**
 	* Returns the first non-null result.
 	*/
 	async hookFirst({ hookName, parameters, skipped }) {
-		const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
-			return skipped ? !skipped.has(plugin) : true;
-		});
+		const plugins = [];
+		for (const plugin of this.plugins.values()) if (hookName in plugin && (skipped ? !skipped.has(plugin) : true)) plugins.push(plugin);
 		this.events.emit("plugins:hook:progress:start", {
 			hookName,
 			plugins
 		});
-		const promises = plugins.map((plugin) => {
+		const result = await hookFirst(plugins.map((plugin) => {
 			return async () => {
 				const value = await this.#execute({
 					strategy: "hookFirst",
@@ -1146,8 +1184,7 @@ var PluginManager = class {
 					result: value
 				});
 			};
-		});
-		const result = await this.#promiseManager.run("first", promises);
+		}), hookFirstNullCheck);
 		this.events.emit("plugins:hook:progress:end", { hookName });
 		return result;
 	}
@@ -1156,10 +1193,9 @@ var PluginManager = class {
 	*/
 	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) {
+		for (const plugin of this.plugins.values()) {
+			if (!(hookName in plugin)) continue;
+			if (skipped?.has(plugin)) continue;
 			parseResult = {
 				result: this.#executeSync({
 					strategy: "hookFirst",
@@ -1169,7 +1205,7 @@ var PluginManager = class {
 				}),
 				plugin
 			};
-			if (parseResult?.result != null) break;
+			if (parseResult.result != null) break;
 		}
 		return parseResult;
 	}
@@ -1177,13 +1213,14 @@ var PluginManager = class {
 	* Runs all plugins in parallel based on `this.plugin` order and `pre`/`post` settings.
 	*/
 	async hookParallel({ hookName, parameters }) {
-		const plugins = this.#getSortedPlugins(hookName);
+		const plugins = [];
+		for (const plugin of this.plugins.values()) if (hookName in plugin) plugins.push(plugin);
 		this.events.emit("plugins:hook:progress:start", {
 			hookName,
 			plugins
 		});
 		const pluginStartTimes = /* @__PURE__ */ new Map();
-		const promises = plugins.map((plugin) => {
+		const results = await hookParallel(plugins.map((plugin) => {
 			return () => {
 				pluginStartTimes.set(plugin, node_perf_hooks.performance.now());
 				return this.#execute({
@@ -1193,11 +1230,10 @@ var PluginManager = class {
 					plugin
 				});
 			};
-		});
-		const results = await this.#promiseManager.run("parallel", promises, { concurrency: this.options.concurrency });
+		}), this.options.concurrency);
 		results.forEach((result, index) => {
 			if (isPromiseRejectedResult(result)) {
-				const plugin = this.#getSortedPlugins(hookName)[index];
+				const plugin = plugins[index];
 				if (plugin) {
 					const startTime = pluginStartTimes.get(plugin) ?? node_perf_hooks.performance.now();
 					this.events.emit("error", result.reason, {
@@ -1220,49 +1256,29 @@ var PluginManager = class {
 	* Chains plugins
 	*/
 	async hookSeq({ hookName, parameters }) {
-		const plugins = this.#getSortedPlugins(hookName);
+		const plugins = [];
+		for (const plugin of this.plugins.values()) if (hookName in plugin) plugins.push(plugin);
 		this.events.emit("plugins:hook:progress:start", {
 			hookName,
 			plugins
 		});
-		const promises = plugins.map((plugin) => {
+		await hookSeq(plugins.map((plugin) => {
 			return () => this.#execute({
 				strategy: "hookSeq",
 				hookName,
 				parameters,
 				plugin
 			});
-		});
-		await this.#promiseManager.run("seq", promises);
+		}));
 		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);
+	getPlugin(pluginName) {
+		return this.plugins.get(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;
+	requirePlugin(pluginName) {
+		const plugin = this.plugins.get(pluginName);
+		if (!plugin) throw new Error(`[kubb] Plugin "${pluginName}" is required but not found. Make sure it is included in your Kubb config.`);
+		return plugin;
 	}
 	/**
 	* Run an async plugin hook and return the result.
@@ -1350,31 +1366,34 @@ var PluginManager = class {
 			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/defineStorage.ts
+//#region src/renderNode.tsx
 /**
-* Wraps a storage builder so the `options` argument is optional, following the
-* same factory pattern as `definePlugin`, `defineLogger`, and `defineAdapter`.
+* Handles the return value of a plugin AST hook or generator method.
 *
-* The builder receives the resolved options object and must return a
-* `DefineStorage`-compatible object that includes a `name` string.
+* - React element → rendered via an isolated react-fabric context, files merged into `fabric`
+* - `Array<KubbFile.File>` → upserted directly into `fabric`
+* - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
+*/
+async function applyHookResult(result, fabric) {
+	if (!result) return;
+	if (Array.isArray(result)) {
+		await fabric.upsertFile(...result);
+		return;
+	}
+	const fabricChild = (0, _kubb_react_fabric.createReactFabric)();
+	await fabricChild.render(/* @__PURE__ */ (0, _kubb_react_fabric_jsx_runtime.jsx)(_kubb_react_fabric.Fabric, { children: result }));
+	fabric.context.fileManager.upsert(...fabricChild.files);
+	fabricChild.unmount();
+}
+//#endregion
+//#region src/createStorage.ts
+/**
+* Creates a storage factory. Call the returned function with optional options to get the storage instance.
 *
 * @example
-* ```ts
-* import { defineStorage } from '@kubb/core'
-*
-* export const memoryStorage = defineStorage((_options) => {
+* export const memoryStorage = createStorage(() => {
 *   const store = new Map<string, string>()
 *   return {
 *     name: 'memory',
@@ -1382,13 +1401,15 @@ var PluginManager = class {
 *     async getItem(key) { return store.get(key) ?? null },
 *     async setItem(key, value) { store.set(key, value) },
 *     async removeItem(key) { store.delete(key) },
-*     async getKeys() { return [...store.keys()] },
-*     async clear() { store.clear() },
+*     async getKeys(base) {
+*       const keys = [...store.keys()]
+*       return base ? keys.filter((k) => k.startsWith(base)) : keys
+*     },
+*     async clear(base) { if (!base) store.clear() },
 *   }
 * })
-* ```
 */
-function defineStorage(build) {
+function createStorage(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
@@ -1416,7 +1437,7 @@ function defineStorage(build) {
 * })
 * ```
 */
-const fsStorage = defineStorage(() => ({
+const fsStorage = createStorage(() => ({
 	name: "fs",
 	async hasItem(key) {
 		try {
@@ -1464,11 +1485,14 @@ const fsStorage = defineStorage(() => ({
 }));
 //#endregion
 //#region package.json
-var version = "5.0.0-alpha.3";
+var version = "5.0.0-alpha.31";
 //#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 {
@@ -1480,7 +1504,262 @@ function getDiagnosticInfo() {
 	};
 }
 //#endregion
+//#region src/utils/TreeNode.ts
+/**
+* Tree structure used to build per-directory barrel (`index.ts`) files from a
+* flat list of generated {@link KubbFile.File} entries.
+*
+* Each node represents either a directory or a file within the output tree.
+* Use {@link TreeNode.build} to construct a root node from a file list, then
+* traverse with {@link TreeNode.forEach}, {@link TreeNode.leaves}, or the
+* `*Deep` helpers.
+*/
+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;
+	}
+	/**
+	* Returns the root ancestor of this node, walking up via `parent` links.
+	*/
+	get root() {
+		if (!this.parent) return this;
+		return this.parent.root;
+	}
+	/**
+	* Returns all leaf descendants (nodes with no children) of this node.
+	*
+	* Results are cached after the first traversal.
+	*/
+	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;
+	}
+	/**
+	* Visits this node and every descendant in depth-first order.
+	*/
+	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;
+	}
+	/**
+	* Finds the first leaf that satisfies `predicate`, or `undefined` when none match.
+	*/
+	findDeep(predicate) {
+		if (typeof predicate !== "function") throw new TypeError("find() predicate must be a function");
+		return this.leaves.find(predicate);
+	}
+	/**
+	* Calls `callback` for every leaf of this node.
+	*/
+	forEachDeep(callback) {
+		if (typeof callback !== "function") throw new TypeError("forEach() callback must be a function");
+		this.leaves.forEach(callback);
+	}
+	/**
+	* Returns all leaves that satisfy `callback`.
+	*/
+	filterDeep(callback) {
+		if (typeof callback !== "function") throw new TypeError("filter() callback must be a function");
+		return this.leaves.filter(callback);
+	}
+	/**
+	* Maps every leaf through `callback` and returns the resulting array.
+	*/
+	mapDeep(callback) {
+		if (typeof callback !== "function") throw new TypeError("map() callback must be a function");
+		return this.leaves.map(callback);
+	}
+	/**
+	* Builds a {@link TreeNode} tree from a flat list of files.
+	*
+	* - Filters to files under `root` (when provided) and skips `.json` files.
+	* - Returns `null` when no files match.
+	*/
+	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?.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;
+}
+/**
+* Generates `index.ts` barrel files for all directories under `root/output.path`.
+*
+* - Returns an empty array when `type` is falsy or `'propagate'`.
+* - Skips generation when the output path itself ends with `index` (already a barrel).
+* - When `type` is `'all'`, strips named exports so every re-export becomes a wildcard (`export * from`).
+* - Attaches `meta` to each barrel file for downstream plugin identification.
+*/
+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/isInputPath.ts
+/**
+* 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/build.ts
+/**
+* Initializes all Kubb infrastructure for a build without executing any plugins.
+*
+* - Validates the input path (when applicable).
+* - Applies config defaults (`root`, `output.*`, `devtools`).
+* - Creates the Fabric instance and wires storage, format, and lint hooks.
+* - Runs the adapter (if configured) to produce the universal `RootNode`.
+*   When no adapter is supplied and `@kubb/adapter-oas` is installed as an
+*
+* Pass the returned {@link SetupResult} directly to {@link safeBuild} or {@link build}
+* via the `overrides` argument to reuse the same infrastructure across multiple runs.
+*/
 async function setup(options) {
 	const { config: userConfig, events = new AsyncEventEmitter() } = options;
 	const sources = /* @__PURE__ */ new Map();
@@ -1516,9 +1795,12 @@ 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 = {
+	if (!userConfig.adapter) throw new Error("Adapter should be defined");
+	const config = {
 		root: userConfig.root || process.cwd(),
 		...userConfig,
+		parsers: userConfig.parsers ?? [],
+		adapter: userConfig.adapter,
 		output: {
 			write: true,
 			barrelType: "named",
@@ -1532,17 +1814,24 @@ async function setup(options) {
 		} : void 0,
 		plugins: userConfig.plugins
 	};
-	const storage = definedConfig.output.write === false ? null : definedConfig.output.storage ?? fsStorage();
-	if (definedConfig.output.clean) {
+	const storage = config.output.write === false ? null : config.output.storage ?? fsStorage();
+	if (config.output.clean) {
 		await events.emit("debug", {
 			date: /* @__PURE__ */ new Date(),
-			logs: ["Cleaning output directories", `  • Output: ${definedConfig.output.path}`]
+			logs: ["Cleaning output directories", `  • Output: ${config.output.path}`]
 		});
-		await storage?.clear((0, node_path.resolve)(definedConfig.root, definedConfig.output.path));
+		await storage?.clear((0, node_path.resolve)(config.root, config.output.path));
 	}
 	const fabric = (0, _kubb_react_fabric.createFabric)();
 	fabric.use(_kubb_react_fabric_plugins.fsPlugin);
-	fabric.use(_kubb_react_fabric_parsers.typescriptParser);
+	for (const parser of config.parsers) fabric.use(parser);
+	fabric.use(defineParser({
+		name: "fallback",
+		extNames: void 0,
+		parse(file) {
+			return file.sources.map((item) => item.value).filter((value) => value != null).join("\n\n");
+		}
+	}));
 	fabric.context.on("files:processing:start", (files) => {
 		events.emit("files:processing:start", files);
 		events.emit("debug", {
@@ -1554,11 +1843,11 @@ async function setup(options) {
 		const { file, source } = params;
 		await events.emit("file:processing:update", {
 			...params,
-			config: definedConfig,
+			config,
 			source
 		});
 		if (source) {
-			const key = (0, node_path.relative)((0, node_path.resolve)(definedConfig.root), file.path);
+			const key = (0, node_path.relative)((0, node_path.resolve)(config.root), file.path);
 			await storage?.setItem(key, source);
 			sources.set(file.path, source);
 		}
@@ -1575,40 +1864,47 @@ async function setup(options) {
 		logs: [
 			"✓ Fabric initialized",
 			`  • Storage: ${storage ? storage.name : "disabled (dry-run)"}`,
-			`  • Barrel type: ${definedConfig.output.barrelType || "none"}`
+			`  • Barrel type: ${config.output.barrelType || "none"}`
 		]
 	});
-	const pluginManager = new PluginManager(definedConfig, {
+	const driver = new PluginDriver(config, {
 		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}`]
-		});
-		pluginManager.adapter = definedConfig.adapter;
-		pluginManager.rootNode = await definedConfig.adapter.parse(source);
-		await events.emit("debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [
-				`✓ Adapter '${definedConfig.adapter.name}' resolved RootNode`,
-				`  • Schemas: ${pluginManager.rootNode.schemas.length}`,
-				`  • Operations: ${pluginManager.rootNode.operations.length}`
-			]
-		});
-	}
+	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 events.emit("debug", {
+		date: /* @__PURE__ */ new Date(),
+		logs: [`Running adapter: ${adapter.name}`]
+	});
+	driver.adapter = adapter;
+	driver.rootNode = await adapter.parse(source);
+	await events.emit("debug", {
+		date: /* @__PURE__ */ new Date(),
+		logs: [
+			`✓ Adapter '${adapter.name}' resolved RootNode`,
+			`  • Schemas: ${driver.rootNode.schemas.length}`,
+			`  • Operations: ${driver.rootNode.operations.length}`
+		]
+	});
 	return {
+		config,
 		events,
 		fabric,
-		pluginManager,
+		driver,
 		sources
 	};
 }
+/**
+* Runs a full Kubb build and throws on any error or plugin failure.
+*
+* Internally delegates to {@link safeBuild} and rethrows collected errors.
+* Pass an existing {@link SetupResult} via `overrides` to skip the setup phase.
+*/
 async function build(options, overrides) {
-	const { fabric, files, pluginManager, failedPlugins, pluginTimings, error, sources } = await safeBuild(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);
@@ -1618,30 +1914,96 @@ async function build(options, overrides) {
 		failedPlugins,
 		fabric,
 		files,
-		pluginManager,
+		driver,
 		pluginTimings,
 		error: void 0,
 		sources
 	};
 }
+/**
+* Walks the AST and dispatches nodes to a plugin's direct AST hooks
+* (`schema`, `operation`, `operations`).
+*
+* - Each hook accepts a single handler **or an array** — all entries are called in sequence.
+* - Nodes that are excluded by `exclude`/`include` plugin options are skipped automatically.
+* - Return values are handled via `applyHookResult`: React elements are rendered,
+*   `KubbFile.File[]` are written via upsert, and `void` is a no-op (manual handling).
+* - Barrel files are generated automatically when `output.barrelType` is set.
+*/
+async function runPluginAstHooks(plugin, context) {
+	const { adapter, rootNode, resolver, fabric } = context;
+	const { exclude, include, override } = plugin.options;
+	if (!adapter || !rootNode) throw new Error(`[${plugin.name}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`);
+	const collectedOperations = [];
+	await (0, _kubb_ast.walk)(rootNode, {
+		depth: "shallow",
+		async schema(node) {
+			if (!plugin.schema) return;
+			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) return;
+			await applyHookResult(await plugin.schema.call(context, transformedNode, options), fabric);
+		},
+		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);
+				if (plugin.operation) await applyHookResult(await plugin.operation.call(context, transformedNode, options), fabric);
+			}
+		}
+	});
+	if (plugin.operations && collectedOperations.length > 0) await applyHookResult(await plugin.operations.call(context, collectedOperations, plugin.options), fabric);
+}
+/**
+* Runs a full Kubb build and captures errors instead of throwing.
+*
+* - Installs each plugin in order, recording failures in `failedPlugins`.
+* - Generates the root barrel file when `output.barrelType` is set.
+* - Writes all files through Fabric.
+*
+* Returns a {@link BuildOutput} even on failure — inspect `error` and
+* `failedPlugins` to determine whether the build succeeded.
+*/
 async function safeBuild(options, overrides) {
-	const { fabric, pluginManager, events, sources } = overrides ? overrides : await setup(options);
+	const { fabric, driver, events, sources } = overrides ? overrides : await setup(options);
 	const failedPlugins = /* @__PURE__ */ new Set();
 	const pluginTimings = /* @__PURE__ */ new Map();
-	const config = pluginManager.config;
+	const config = driver.config;
 	try {
-		for (const plugin of pluginManager.plugins) {
-			const context = pluginManager.getContext(plugin);
+		for (const plugin of driver.plugins.values()) {
+			const context = driver.getContext(plugin);
 			const hrStart = process.hrtime();
-			const installer = plugin.install.bind(context);
+			const { output } = plugin.options ?? {};
+			const root = (0, node_path.resolve)(config.root, config.output.path);
 			try {
 				const timestamp = /* @__PURE__ */ new Date();
 				await events.emit("plugin:start", plugin);
 				await events.emit("debug", {
 					date: timestamp,
-					logs: ["Installing plugin...", `  • Plugin Name: ${plugin.name}`]
+					logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
 				});
-				await installer(context);
+				await plugin.buildStart.call(context);
+				if (plugin.schema || plugin.operation || plugin.operations) await runPluginAstHooks(plugin, context);
+				if (output) {
+					const barrelFiles = await getBarrelFiles(fabric.files, {
+						type: output.barrelType ?? "named",
+						root,
+						output,
+						meta: { pluginName: plugin.name }
+					});
+					await context.upsertFile(...barrelFiles);
+				}
 				const duration = getElapsedMs(hrStart);
 				pluginTimings.set(plugin.name, duration);
 				await events.emit("plugin:end", plugin, {
@@ -1650,7 +2012,7 @@ async function safeBuild(options, overrides) {
 				});
 				await events.emit("debug", {
 					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ Plugin installed successfully (${formatMs(duration)})`]
+					logs: [`✓ Plugin started successfully (${formatMs(duration)})`]
 				});
 			} catch (caughtError) {
 				const error = caughtError;
@@ -1664,7 +2026,7 @@ async function safeBuild(options, overrides) {
 				await events.emit("debug", {
 					date: errorTimestamp,
 					logs: [
-						"✗ Plugin installation failed",
+						"✗ Plugin start failed",
 						`  • Plugin Name: ${plugin.name}`,
 						`  • Error: ${error.constructor.name} - ${error.message}`,
 						"  • Stack Trace:",
@@ -1704,7 +2066,7 @@ async function safeBuild(options, overrides) {
 					rootDir,
 					existingExports: new Set(existingBarrel?.exports?.flatMap((e) => Array.isArray(e.name) ? e.name : [e.name]).filter((n) => Boolean(n)) ?? []),
 					config,
-					pluginManager
+					driver
 				}),
 				sources: [],
 				imports: [],
@@ -1718,11 +2080,15 @@ async function safeBuild(options, overrides) {
 		}
 		const files = [...fabric.files];
 		await fabric.write({ extension: config.output.extension });
+		for (const plugin of driver.plugins.values()) if (plugin.buildEnd) {
+			const context = driver.getContext(plugin);
+			await plugin.buildEnd.call(context);
+		}
 		return {
 			failedPlugins,
 			fabric,
 			files,
-			pluginManager,
+			driver,
 			pluginTimings,
 			sources
 		};
@@ -1731,16 +2097,16 @@ async function safeBuild(options, overrides) {
 			failedPlugins,
 			fabric,
 			files: [],
-			pluginManager,
+			driver,
 			pluginTimings,
 			error,
 			sources
 		};
 	}
 }
-function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, pluginManager }) {
+function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }) {
 	const pluginNameMap = /* @__PURE__ */ new Map();
-	for (const plugin of pluginManager.plugins) pluginNameMap.set(plugin.name, plugin);
+	for (const plugin of driver.plugins.values()) pluginNameMap.set(plugin.name, plugin);
 	return barrelFiles.flatMap((file) => {
 		const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly);
 		return (file.sources ?? []).flatMap((source) => {
@@ -1765,133 +2131,497 @@ function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, plu
 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/defineAdapter.ts
+//#region src/createAdapter.ts
 /**
-* Wraps an adapter builder to make the options parameter optional.
+* Creates an adapter factory. Call the returned function with optional options to get the adapter instance.
 *
 * @example
-* ```ts
-* export const adapterOas = defineAdapter<OasAdapter>((options) => {
-*   const { validate = true, dateType = 'string' } = options
+* export const myAdapter = createAdapter<MyAdapter>((options) => {
 *   return {
-*     name: adapterOasName,
-*     options: { validate, dateType, ... },
-*     parse(source) { ... },
+*     name: 'my-adapter',
+*     options,
+*     async parse(source) { ... },
 *   }
 * })
+*
+* // instantiate
+* const adapter = myAdapter({ validate: true })
+*/
+function createAdapter(build) {
+	return (options) => build(options ?? {});
+}
+//#endregion
+//#region src/createPlugin.ts
+/**
+* Creates a plugin factory. Call the returned function with optional options to get the plugin instance.
+*
+* @example
+* ```ts
+* export const myPlugin = createPlugin<MyPlugin>((options) => {
+*   return {
+*     name: 'my-plugin',
+*     get options() { return options },
+*     resolvePath(baseName) { ... },
+*     resolveName(name, type) { ... },
+*   }
+* })
+*
+* // instantiate
+* const plugin = myPlugin({ output: { path: 'src/gen' } })
 * ```
 */
-function defineAdapter(build) {
+function createPlugin(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
+//#region src/defineConfig.ts
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+//#region src/defineGenerator.ts
+/**
+* Defines a generator. Returns the object as-is with correct `this` typings.
+* No type discrimination (`type: 'react' | 'core'`) needed — `applyHookResult`
+* handles React elements and `File[]` uniformly.
+*/
+function defineGenerator(generator) {
+	return generator;
+}
+/**
+* Merges an array of generators into a single generator.
+*
+* The merged generator's `schema`, `operation`, and `operations` methods run
+* the corresponding method from each input generator in sequence, applying each
+* result via `applyHookResult`. This eliminates the need to write the loop
+* manually in each plugin.
+*
+* @param generators - Array of generators to merge into a single generator.
+*
+* @example
+* ```ts
+* const merged = mergeGenerators(generators)
+*
+* return {
+*   name: pluginName,
+*   schema: merged.schema,
+*   operation: merged.operation,
+*   operations: merged.operations,
+* }
+* ```
+*/
+function mergeGenerators(generators) {
+	return {
+		name: generators.length > 0 ? generators.map((g) => g.name).join("+") : "merged",
+		async schema(node, options) {
+			for (const gen of generators) {
+				if (!gen.schema) continue;
+				await applyHookResult(await gen.schema.call(this, node, options), this.fabric);
+			}
+		},
+		async operation(node, options) {
+			for (const gen of generators) {
+				if (!gen.operation) continue;
+				await applyHookResult(await gen.operation.call(this, node, options), this.fabric);
+			}
+		},
+		async operations(nodes, options) {
+			for (const gen of generators) {
+				if (!gen.operations) continue;
+				await applyHookResult(await gen.operations.call(this, nodes, options), this.fabric);
+			}
+		}
+	};
+}
+//#endregion
 //#region src/defineLogger.ts
+/**
+* Wraps a logger definition into a typed {@link Logger}.
+*
+* @example
+* 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))
+*   },
+* })
+*/
 function defineLogger(logger) {
-	return { ...logger };
+	return logger;
 }
 //#endregion
-//#region src/definePlugin.ts
+//#region src/definePresets.ts
 /**
-* Wraps a plugin builder to make the options parameter optional.
+* Creates a typed presets registry object — a named collection of {@link Preset} entries.
+*
+* @example
+* import { definePreset, definePresets } from '@kubb/core'
+* import { resolverTsLegacy } from '@kubb/plugin-ts'
+*
+* export const myPresets = definePresets({
+*   kubbV4: definePreset('kubbV4', { resolvers: [resolverTsLegacy] }),
+* })
 */
-function definePlugin(build) {
-	return (options) => build(options ?? {});
+function definePresets(presets) {
+	return presets;
 }
 //#endregion
-//#region src/PackageManager.ts
-var PackageManager = class PackageManager {
-	static #cache = {};
-	#cwd;
-	constructor(workspace) {
-		if (workspace) this.#cwd = workspace;
-	}
-	set workspace(workspace) {
-		this.#cwd = workspace;
-	}
-	get workspace() {
-		return this.#cwd;
-	}
-	normalizeDirectory(directory) {
-		const lastChar = directory[directory.length - 1];
-		if (lastChar && !PATH_SEPARATORS.includes(lastChar)) return `${directory}/`;
-		return directory;
-	}
-	getLocation(path) {
-		let location = path;
-		if (this.#cwd) location = node_module.default.createRequire(this.normalizeDirectory(this.#cwd)).resolve(path);
-		return location;
-	}
-	async import(path) {
-		let location = this.getLocation(path);
-		if (node_os.default.platform() === "win32") location = (0, node_url.pathToFileURL)(location).href;
-		const module = await import(location);
-		return module?.default ?? module;
-	}
-	async getPackageJSON() {
-		const pkgPath = empathic_package.up({ cwd: this.#cwd });
-		if (!pkgPath) return;
-		const json = await read(pkgPath);
-		return JSON.parse(json);
-	}
-	getPackageJSONSync() {
-		const pkgPath = empathic_package.up({ cwd: this.#cwd });
-		if (!pkgPath) return;
-		const json = readSync(pkgPath);
-		return JSON.parse(json);
-	}
-	static setVersion(dependency, version) {
-		PackageManager.#cache[dependency] = version;
-	}
-	#match(packageJSON, dependency) {
-		const dependencies = {
-			...packageJSON.dependencies || {},
-			...packageJSON.devDependencies || {}
+//#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);
+		case "contentType": return !!node.requestBody?.contentType?.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;
+	}
+}
+/**
+* Default name resolver used by `defineResolver`.
+*
+* - `camelCase` for `function` and `file` types.
+* - `PascalCase` for `type`.
+* - `camelCase` for everything else.
+*/
+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;
+}
+/**
+* Default option resolver — applies include/exclude filters and merges matching override options.
+*
+* Returns `null` when the node is filtered out by an `exclude` rule or not matched by any `include` rule.
+*
+* @example Include/exclude filtering
+* ```ts
+* const options = defaultResolveOptions(operationNode, {
+*   options: { output: 'types' },
+*   exclude: [{ type: 'tag', pattern: 'internal' }],
+* })
+* // → null when node has tag 'internal'
+* ```
+*
+* @example Override merging
+* ```ts
+* const options = defaultResolveOptions(operationNode, {
+*   options: { enumType: 'asConst' },
+*   override: [{ type: 'operationId', pattern: 'listPets', options: { enumType: 'enum' } }],
+* })
+* // → { enumType: 'enum' } when operationId matches
+* ```
+*/
+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 (typeof dependency === "string" && dependencies[dependency]) return dependencies[dependency];
-		const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency));
-		return matchedDependency ? dependencies[matchedDependency] : void 0;
-	}
-	async getVersion(dependency) {
-		if (typeof dependency === "string" && PackageManager.#cache[dependency]) return PackageManager.#cache[dependency];
-		const packageJSON = await this.getPackageJSON();
-		if (!packageJSON) return;
-		return this.#match(packageJSON, dependency);
-	}
-	getVersionSync(dependency) {
-		if (typeof dependency === "string" && PackageManager.#cache[dependency]) return PackageManager.#cache[dependency];
-		const packageJSON = this.getPackageJSONSync();
-		if (!packageJSON) return;
-		return this.#match(packageJSON, dependency);
-	}
-	async isValid(dependency, version) {
-		const packageVersion = await this.getVersion(dependency);
-		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);
-	}
-	isValidSync(dependency, version) {
-		const packageVersion = this.getVersionSync(dependency);
-		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);
 	}
-};
+	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;
+}
+/**
+* Default path resolver used by `defineResolver`.
+*
+* - Returns the output directory in `single` mode.
+* - Resolves into a tag- or path-based subdirectory when `group` and a `tag`/`path` value are provided.
+* - Falls back to a flat `output/baseName` path otherwise.
+*
+* A custom `group.name` function overrides the default subdirectory naming.
+* For `tag` groups the default is `${camelCase(tag)}Controller`.
+* For `path` groups the default is the first path segment after `/`.
+*
+* @example Flat output
+* ```ts
+* defaultResolvePath({ baseName: 'petTypes.ts' }, { root: '/src', output: { path: 'types' } })
+* // → '/src/types/petTypes.ts'
+* ```
+*
+* @example Tag-based grouping
+* ```ts
+* defaultResolvePath(
+*   { baseName: 'petTypes.ts', tag: 'pets' },
+*   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+* )
+* // → '/src/types/petsController/petTypes.ts'
+* ```
+*
+* @example Path-based grouping
+* ```ts
+* defaultResolvePath(
+*   { baseName: 'petTypes.ts', path: '/pets/list' },
+*   { root: '/src', output: { path: 'types' }, group: { type: 'path' } },
+* )
+* // → '/src/types/pets/petTypes.ts'
+* ```
+*
+* @example Single-file mode
+* ```ts
+* defaultResolvePath(
+*   { baseName: 'petTypes.ts', pathMode: 'single' },
+*   { root: '/src', output: { path: 'types' } },
+* )
+* // → '/src/types'
+* ```
+*/
+function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }, { root, output, group }) {
+	if ((pathMode ?? getMode(node_path.default.resolve(root, output.path))) === "single") return node_path.default.resolve(root, output.path);
+	if (group && (groupPath || tag)) return node_path.default.resolve(root, output.path, group.name({ group: group.type === "path" ? groupPath : tag }), baseName);
+	return node_path.default.resolve(root, output.path, baseName);
+}
+/**
+* Default file resolver used by `defineResolver`.
+*
+* Resolves a `KubbFile.File` by combining name resolution (`resolver.default`) with
+* path resolution (`resolver.resolvePath`). The resolved file always has empty
+* `sources`, `imports`, and `exports` arrays — consumers populate those separately.
+*
+* In `single` mode the name is omitted and the file sits directly in the output directory.
+*
+* @example Resolve a schema file
+* ```ts
+* const file = defaultResolveFile.call(resolver,
+*   { name: 'pet', extname: '.ts' },
+*   { root: '/src', output: { path: 'types' } },
+* )
+* // → { baseName: 'pet.ts', path: '/src/types/pet.ts', sources: [], ... }
+* ```
+*
+* @example Resolve an operation file with tag grouping
+* ```ts
+* const file = defaultResolveFile.call(resolver,
+*   { name: 'listPets', extname: '.ts', tag: 'pets' },
+*   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+* )
+* // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
+* ```
+*/
+function defaultResolveFile({ name, extname, tag, path: groupPath }, context) {
+	const pathMode = getMode(node_path.default.resolve(context.root, context.output.path));
+	const baseName = `${pathMode === "single" ? "" : this.default(name, "file")}${extname}`;
+	const filePath = this.resolvePath({
+		baseName,
+		pathMode,
+		tag,
+		path: groupPath
+	}, context);
+	return {
+		path: filePath,
+		baseName: node_path.default.basename(filePath),
+		meta: { pluginName: this.pluginName },
+		sources: [],
+		imports: [],
+		exports: []
+	};
+}
+/**
+* Generates the default "Generated by Kubb" banner from config and optional node metadata.
+*/
+function buildDefaultBanner({ title, description, version, config }) {
+	try {
+		let source = "";
+		if (Array.isArray(config.input)) {
+			const first = config.input[0];
+			if (first && "path" in first) source = node_path.default.basename(first.path);
+		} else if ("path" in config.input) source = node_path.default.basename(config.input.path);
+		else if ("data" in config.input) source = "text content";
+		let banner = "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n";
+		if (config.output.defaultBanner === "simple") {
+			banner += "*/\n";
+			return banner;
+		}
+		if (source) banner += `* Source: ${source}\n`;
+		if (title) banner += `* Title: ${title}\n`;
+		if (description) {
+			const formattedDescription = description.replace(/\n/gm, "\n* ");
+			banner += `* Description: ${formattedDescription}\n`;
+		}
+		if (version) banner += `* OpenAPI spec version: ${version}\n`;
+		banner += "*/\n";
+		return banner;
+	} catch (_error) {
+		return "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n*/";
+	}
+}
+/**
+* Default banner resolver — returns the banner string for a generated file.
+*
+* A user-supplied `output.banner` overrides the default Kubb "Generated by Kubb" notice.
+* When no `output.banner` is set, the Kubb notice is used (including `title` and `version`
+* from the OAS spec when a `node` is provided).
+*
+* - When `output.banner` is a function and `node` is provided, returns `output.banner(node)`.
+* - When `output.banner` is a function and `node` is absent, falls back to the Kubb notice.
+* - When `output.banner` is a string, returns it directly.
+* - When `config.output.defaultBanner` is `false`, returns `undefined`.
+* - Otherwise returns the Kubb "Generated by Kubb" notice.
+*
+* @example String banner overrides default
+* ```ts
+* defaultResolveBanner(undefined, { output: { banner: '// my banner' }, config })
+* // → '// my banner'
+* ```
+*
+* @example Function banner with node
+* ```ts
+* defaultResolveBanner(rootNode, { output: { banner: (node) => `// v${node.version}` }, config })
+* // → '// v3.0.0'
+* ```
+*
+* @example No user banner — Kubb notice with OAS metadata
+* ```ts
+* defaultResolveBanner(rootNode, { config })
+* // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
+* ```
+*
+* @example Disabled default banner
+* ```ts
+* defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
+* // → undefined
+* ```
+*/
+function defaultResolveBanner(node, { output, config }) {
+	if (typeof output?.banner === "function") return output.banner(node);
+	if (typeof output?.banner === "string") return output.banner;
+	if (config.output.defaultBanner === false) return;
+	return buildDefaultBanner({
+		title: node?.meta?.title,
+		version: node?.meta?.version,
+		config
+	});
+}
+/**
+* Default footer resolver — returns the footer string for a generated file.
+*
+* - When `output.footer` is a function and `node` is provided, calls it with the node.
+* - When `output.footer` is a function and `node` is absent, returns `undefined`.
+* - When `output.footer` is a string, returns it directly.
+* - Otherwise returns `undefined`.
+*
+* @example String footer
+* ```ts
+* defaultResolveFooter(undefined, { output: { footer: '// end of file' }, config })
+* // → '// end of file'
+* ```
+*
+* @example Function footer with node
+* ```ts
+* defaultResolveFooter(rootNode, { output: { footer: (node) => `// ${node.title}` }, config })
+* // → '// Pet Store'
+* ```
+*/
+function defaultResolveFooter(node, { output }) {
+	if (typeof output?.footer === "function") return node ? output.footer(node) : void 0;
+	if (typeof output?.footer === "string") return output.footer;
+}
+/**
+* Defines a resolver for a plugin, injecting built-in defaults for name casing,
+* include/exclude/override filtering, path resolution, and file construction.
+*
+* All four defaults can be overridden by providing them in the builder function:
+* - `default` — name casing strategy (camelCase / PascalCase)
+* - `resolveOptions` — include/exclude/override filtering
+* - `resolvePath` — output path computation
+* - `resolveFile` — full `KubbFile.File` construction
+*
+* Methods in the builder have access to `this` (the full resolver object), so they
+* can call other resolver methods without circular imports.
+*
+* @example Basic resolver with naming helpers
+* ```ts
+* export const resolver = defineResolver<PluginTs>(() => ({
+*   name: 'default',
+*   resolveName(node) {
+*     return this.default(node.name, 'function')
+*   },
+*   resolveTypedName(node) {
+*     return this.default(node.name, 'type')
+*   },
+* }))
+* ```
+*
+* @example Override resolvePath for a custom output structure
+* ```ts
+* export const resolver = defineResolver<PluginTs>(() => ({
+*   name: 'custom',
+*   resolvePath({ baseName }, { root, output }) {
+*     return path.resolve(root, output.path, 'generated', baseName)
+*   },
+* }))
+* ```
+*
+* @example Use this.default inside a helper
+* ```ts
+* export const resolver = defineResolver<PluginTs>(() => ({
+*   name: 'default',
+*   resolveParamName(node, param) {
+*     return this.default(`${node.operationId} ${param.in} ${param.name}`, 'type')
+*   },
+* }))
+* ```
+*/
+function defineResolver(build) {
+	return {
+		default: defaultResolver,
+		resolveOptions: defaultResolveOptions,
+		resolvePath: defaultResolvePath,
+		resolveFile: defaultResolveFile,
+		resolveBanner: defaultResolveBanner,
+		resolveFooter: defaultResolveFooter,
+		...build()
+	};
+}
+//#endregion
+//#region src/KubbFile.ts
+var KubbFile_exports = /* @__PURE__ */ require_chunk.__exportAll({});
 //#endregion
 //#region src/storages/memoryStorage.ts
 /**
@@ -1911,7 +2641,7 @@ var PackageManager = class PackageManager {
 * })
 * ```
 */
-const memoryStorage = defineStorage(() => {
+const memoryStorage = createStorage(() => {
 	const store = /* @__PURE__ */ new Map();
 	return {
 		name: "memory",
@@ -1943,7 +2673,7 @@ const memoryStorage = defineStorage(() => {
 //#endregion
 //#region src/utils/FunctionParams.ts
 /**
-* @deprecated
+* @deprecated use ast package instead
 */
 var FunctionParams = class FunctionParams {
 	#items = [];
@@ -2019,14 +2749,10 @@ var FunctionParams = class FunctionParams {
 //#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
+* Returns `true` when the given formatter is installed and callable.
 *
-* @remarks
-* This function checks availability by running `<formatter> --version` command.
-* All supported formatters (biome, prettier, oxfmt) implement the --version flag.
+* Availability is detected by running `<formatter> --version` and checking
+* that the process exits without error.
 */
 async function isFormatterAvailable(formatter) {
 	try {
@@ -2037,263 +2763,93 @@ async function isFormatterAvailable(formatter) {
 	}
 }
 /**
-* Detect which formatter is available in the system.
-*
-* @returns Promise that resolves to the first available formatter or undefined if none are found
+* Detects the first available code formatter on the current system.
 *
-* @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.
+* - Checks in preference order: `biome`, `oxfmt`, `prettier`.
+* - Returns `null` when none are found.
 *
 * @example
-* ```typescript
+* ```ts
 * const formatter = await detectFormatter()
 * if (formatter) {
 *   console.log(`Using ${formatter} for formatting`)
-* } else {
-*   console.log('No formatter found')
 * }
 * ```
 */
 async function detectFormatter() {
-	for (const formatter of [
+	const formatterNames = new Set([
 		"biome",
 		"oxfmt",
 		"prettier"
-	]) if (await isFormatterAvailable(formatter)) return formatter;
+	]);
+	for (const formatter of formatterNames) if (await isFormatterAvailable(formatter)) return formatter;
+	return null;
 }
 //#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/BarrelManager.ts
-/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
-var BarrelManager = class {
-	getFiles({ files: generatedFiles, root }) {
-		const cachedFiles = /* @__PURE__ */ new Map();
-		TreeNode.build(generatedFiles, 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()];
-	}
-};
-//#endregion
-//#region src/utils/getBarrelFiles.ts
-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 barrelManager = new BarrelManager();
-	const pathToBuildFrom = (0, node_path.join)(root, output.path);
-	if (trimExtName(pathToBuildFrom).endsWith("index")) return [];
-	const barrelFiles = barrelManager.getFiles({
-		files,
-		root: pathToBuildFrom,
-		meta
-	});
-	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
-		};
-	});
+//#region src/utils/getConfigs.ts
+/**
+* Resolves a {@link ConfigInput} into a normalized array of {@link Config} objects.
+*
+* - Awaits the config when it is a `Promise`.
+* - Calls the factory function with `args` when the config is a function.
+* - Wraps a single config object in an array for uniform downstream handling.
+*/
+async function getConfigs(config, args) {
+	const resolved = await (typeof config === "function" ? config(args) : config);
+	return (Array.isArray(resolved) ? resolved : [resolved]).map((item) => ({
+		plugins: [],
+		...item
+	}));
 }
 //#endregion
-//#region src/utils/getPlugins.ts
-function isJSONPlugins(plugins) {
-	return Array.isArray(plugins) && plugins.some((plugin) => Array.isArray(plugin) && typeof plugin[0] === "string");
-}
-function isObjectPlugins(plugins) {
-	return plugins instanceof Object && !Array.isArray(plugins);
-}
-function getPlugins(plugins) {
-	if (isObjectPlugins(plugins)) throw new Error("Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
-	if (isJSONPlugins(plugins)) throw new Error("JSON plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json");
-	return Promise.resolve(plugins);
+//#region src/utils/getPreset.ts
+/**
+* Returns a copy of `defaults` where each function in `userOverrides` is wrapped
+* so a `null`/`undefined` return falls back to the original. Non-function values
+* are assigned directly. All calls use the merged object as `this`.
+*/
+function withFallback(defaults, userOverrides) {
+	const merged = { ...defaults };
+	for (const key of Object.keys(userOverrides)) {
+		const userVal = userOverrides[key];
+		const defaultVal = defaults[key];
+		if (typeof userVal === "function" && typeof defaultVal === "function") merged[key] = (...args) => userVal.apply(merged, args) ?? defaultVal.apply(merged, args);
+		else if (userVal !== void 0) merged[key] = userVal;
+	}
+	return merged;
 }
-//#endregion
-//#region src/utils/getConfigs.ts
 /**
-* Converting UserConfig to Config Array without a change in the object beside the JSON convert.
+* Resolves a named preset into a resolver, transformer, and generators.
+*
+* - Selects the preset resolver; wraps it with user overrides using null/undefined fallback.
+* - Composes the preset's transformers into a single visitor; wraps it with the user transformer using null/undefined fallback.
+* - Combines preset generators with user-supplied generators; falls back to the `default` preset's generators when neither provides any.
 */
-async function getConfigs(config, args) {
-	let userConfigs = await (typeof config === "function" ? Promise.resolve(config(args)) : Promise.resolve(config));
-	if (!Array.isArray(userConfigs)) userConfigs = [userConfigs];
-	const results = [];
-	for (const item of userConfigs) {
-		const plugins = item.plugins ? await getPlugins(item.plugins) : void 0;
-		results.push({
-			...item,
-			plugins
-		});
-	}
-	return results;
+function getPreset(params) {
+	const { preset: presetName, presets, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = params;
+	const preset = presets[presetName];
+	const presetResolver = preset?.resolver ?? presets["default"].resolver;
+	const resolver = userResolver ? withFallback(presetResolver, userResolver) : presetResolver;
+	const presetTransformers = preset?.transformers ?? [];
+	const presetTransformer = presetTransformers.length > 0 ? (0, _kubb_ast.composeTransformers)(...presetTransformers) : void 0;
+	const transformer = presetTransformer && userTransformer ? withFallback(presetTransformer, userTransformer) : userTransformer ?? presetTransformer;
+	const presetGenerators = preset?.generators ?? [];
+	const defaultGenerators = presets["default"]?.generators ?? [];
+	return {
+		resolver,
+		transformer,
+		generators: presetGenerators.length > 0 || userGenerators.length > 0 ? [...presetGenerators, ...userGenerators] : defaultGenerators,
+		preset
+	};
 }
 //#endregion
 //#region src/utils/linters.ts
+/**
+* Returns `true` when the given linter is installed and callable.
+*
+* Availability is detected by running `<linter> --version` and checking
+* that the process exits without error.
+*/
 async function isLinterAvailable(linter) {
 	try {
 		await (0, tinyexec.x)(linter, ["--version"], { nodeOptions: { stdio: "ignore" } });
@@ -2302,33 +2858,112 @@ async function isLinterAvailable(linter) {
 		return false;
 	}
 }
+/**
+* Detects the first available linter on the current system.
+*
+* - Checks in preference order: `biome`, `oxlint`, `eslint`.
+* - Returns `null` when none are found.
+*
+* @example
+* ```ts
+* const linter = await detectLinter()
+* if (linter) {
+*   console.log(`Using ${linter} for linting`)
+* }
+* ```
+*/
 async function detectLinter() {
-	for (const linter of [
+	const linterNames = new Set([
 		"biome",
 		"oxlint",
 		"eslint"
-	]) if (await isLinterAvailable(linter)) return linter;
+	]);
+	for (const linter of linterNames) if (await isLinterAvailable(linter)) return linter;
+	return null;
+}
+//#endregion
+//#region src/utils/packageJSON.ts
+function getPackageJSONSync(cwd) {
+	const pkgPath = empathic_package.up({ cwd });
+	if (!pkgPath) return null;
+	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] ?? null : null;
+}
+function getVersionSync(dependency, cwd) {
+	const packageJSON = getPackageJSONSync(cwd);
+	return packageJSON ? match(packageJSON, dependency) : null;
+}
+/**
+* Returns `true` when the nearest `package.json` declares a dependency that
+* satisfies the given semver range.
+*
+* - Searches both `dependencies` and `devDependencies`.
+* - Accepts a string package name or a `RegExp` to match scoped/pattern packages.
+* - Uses `semver.satisfies` for range comparison; returns `false` when the
+*   version string cannot be coerced into a valid semver.
+*
+* @example
+* ```ts
+* satisfiesDependency('react', '>=18')          // true when react@18.x is installed
+* satisfiesDependency(/^@tanstack\//, '>=5')    // true when any @tanstack/* >=5 is found
+* ```
+*/
+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.AsyncEventEmitter = AsyncEventEmitter;
 exports.FunctionParams = FunctionParams;
-exports.PackageManager = PackageManager;
-exports.PluginManager = PluginManager;
-exports.PromiseManager = PromiseManager;
+Object.defineProperty(exports, "KubbFile", {
+	enumerable: true,
+	get: function() {
+		return KubbFile_exports;
+	}
+});
+exports.PluginDriver = PluginDriver;
 exports.URLPath = URLPath;
 exports.build = build;
+exports.buildDefaultBanner = buildDefaultBanner;
+Object.defineProperty(exports, "composeTransformers", {
+	enumerable: true,
+	get: function() {
+		return _kubb_ast.composeTransformers;
+	}
+});
+exports.createAdapter = createAdapter;
+exports.createPlugin = createPlugin;
+exports.createStorage = createStorage;
 exports.default = build;
-exports.defineAdapter = defineAdapter;
+exports.defaultResolveBanner = defaultResolveBanner;
+exports.defaultResolveFile = defaultResolveFile;
+exports.defaultResolveFooter = defaultResolveFooter;
+exports.defaultResolveOptions = defaultResolveOptions;
+exports.defaultResolvePath = defaultResolvePath;
 exports.defineConfig = defineConfig;
+exports.defineGenerator = defineGenerator;
 exports.defineLogger = defineLogger;
-exports.definePlugin = definePlugin;
+exports.defineParser = defineParser;
+exports.definePresets = definePresets;
 Object.defineProperty(exports, "definePrinter", {
 	enumerable: true,
 	get: function() {
 		return _kubb_ast.definePrinter;
 	}
 });
-exports.defineStorage = defineStorage;
+exports.defineResolver = defineResolver;
 exports.detectFormatter = detectFormatter;
 exports.detectLinter = detectLinter;
 exports.formatters = formatters;
@@ -2336,11 +2971,14 @@ exports.fsStorage = fsStorage;
 exports.getBarrelFiles = getBarrelFiles;
 exports.getConfigs = getConfigs;
 exports.getMode = getMode;
+exports.getPreset = getPreset;
 exports.isInputPath = isInputPath;
 exports.linters = linters;
 exports.logLevel = logLevel;
 exports.memoryStorage = memoryStorage;
+exports.mergeGenerators = mergeGenerators;
 exports.safeBuild = safeBuild;
+exports.satisfiesDependency = satisfiesDependency;
 exports.setup = setup;
 
 //# sourceMappingURL=index.cjs.map