@kubb/core 5.0.0-alpha.2 → 5.0.0-alpha.21

package/dist/index.js

@@ -1,29 +1,37 @@
 import "./chunk--u3MIqq1.js";
-import mod from "node:module";
 import { EventEmitter } from "node:events";
-import { parseArgs, styleText } from "node:util";
 import { readFileSync } from "node:fs";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
-import path, { dirname, join, posix, relative, resolve } from "node:path";
-import { definePrinter } from "@kubb/ast";
-import { createFabric } from "@kubb/react-fabric";
+import path, { basename, dirname, extname, join, posix, relative, resolve } from "node:path";
+import { definePrinter, isOperationNode, isSchemaNode } from "@kubb/ast";
+import { Fabric, createFabric, createReactFabric } from "@kubb/react-fabric";
 import { typescriptParser } from "@kubb/react-fabric/parsers";
 import { fsPlugin } from "@kubb/react-fabric/plugins";
 import { performance } from "node:perf_hooks";
 import { deflateSync } from "fflate";
 import { x } from "tinyexec";
 import { version } from "node:process";
-import os from "node:os";
-import { pathToFileURL } from "node:url";
+import { jsx } from "@kubb/react-fabric/jsx-runtime";
+import { sortBy } from "remeda";
 import * as pkg from "empathic/package";
 import { coerce, satisfies } from "semver";
-import { sortBy } from "remeda";
-//#region ../../internals/utils/dist/index.js
-/** Thrown when a plugin's configuration or input fails validation. */
+//#region ../../internals/utils/src/errors.ts
+/** Thrown when a plugin's configuration or input fails validation.
+*
+* @example
+* ```ts
+* throw new ValidationPluginError('Invalid config: "output.path" is required')
+* ```
+*/
 var ValidationPluginError = class extends Error {};
 /**
 * 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;
@@ -35,19 +43,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) {
@@ -55,8 +78,13 @@ var AsyncEventEmitter = class {
 	}
 	#emitter = new EventEmitter();
 	/**
-	* Emits an event and awaits all registered listeners in parallel.
+	* Emits `eventName` and awaits all registered listeners in parallel.
 	* 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);
@@ -75,11 +103,25 @@ var AsyncEventEmitter = class {
 			}
 		}));
 	}
-	/** 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);
@@ -87,15 +129,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)
@@ -114,9 +172,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("/");
 }
 /**
@@ -134,190 +195,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${styleText("bold", "Usage:")} ${programName}${argsPart}${subCmdPart} [options]\n`);
-	if (schema.description) console.log(`  ${schema.description}\n`);
-	if (schema.subCommands.length) {
-		console.log(styleText("bold", "Commands:"));
-		for (const sub of schema.subCommands) console.log(`  ${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(styleText("bold", "Options:"));
-	for (const opt of options) {
-		const flags = styleText("cyan", opt.flags.padEnd(30));
-		const defaultPart = opt.default !== void 0 ? 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 = 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(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(styleText("red", `Error: ${err instanceof Error ? err.message : String(err)}`));
-		renderHelp(def, parentName);
-		process.exit(1);
-	}
-}
-function printRootHelp(programName, version, defs) {
-	console.log(`\n${styleText("bold", "Usage:")} ${programName} <command> [options]\n`);
-	console.log(`  Kubb generation — v${version}\n`);
-	console.log(styleText("bold", "Commands:"));
-	for (const def of defs) console.log(`  ${styleText("cyan", def.name.padEnd(16))}${def.description}`);
-	console.log();
-	console.log(styleText("bold", "Options:"));
-	console.log(`  ${styleText("cyan", "-v, --version".padEnd(30))}Show version number`);
-	console.log(`  ${styleText("cyan", "-h, --help".padEnd(30))}Show help`);
-	console.log();
-	console.log(`Run ${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);
@@ -325,39 +229,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.
@@ -367,8 +254,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 || ""}`);
@@ -378,43 +271,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 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 readFile(path, { encoding: "utf8" });
-}
-/** Synchronous counterpart of `read`. */
 function readSync(path) {
 	return 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 = 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 readFile(resolved, { encoding: "utf-8" }) === trimmed) return void 0;
+		if (await readFile(resolved, { encoding: "utf-8" }) === trimmed) return null;
 	} catch {}
 	await mkdir(dirname(resolved), { recursive: true });
 	await writeFile(resolved, trimmed, { encoding: "utf-8" });
@@ -425,16 +329,32 @@ 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 rm(path, {
 		recursive: true,
 		force: true
 	});
 }
+//#endregion
+//#region ../../internals/utils/src/names.ts
 /**
 * Registers `originalName` in `data` without altering the returned name.
-* Use this when you need to track usage frequency but always emit the original identifier.
+* Use when you need to track usage frequency but always emit the original identifier.
+*
+* @example
+* ```ts
+* const seen: Record<string, number> = {}
+* setUniqueName('Foo', seen) // 'Foo'  (seen = { Foo: 1 })
+* setUniqueName('Foo', seen) // 'Foo'  (seen = { Foo: 2 })
+* ```
 */
 function setUniqueName(originalName, data) {
 	let used = data[originalName] || 0;
@@ -445,11 +365,26 @@ function setUniqueName(originalName, data) {
 	data[originalName] = 1;
 	return originalName;
 }
+//#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 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",
@@ -531,18 +466,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 {
@@ -552,6 +500,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.
 *
@@ -561,18 +511,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;
@@ -590,11 +555,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();
 	}
@@ -602,7 +581,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];
@@ -639,6 +620,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 = {};
@@ -648,7 +635,13 @@ 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");
 	}
@@ -666,11 +659,27 @@ function isInputPath(config) {
 }
 //#endregion
 //#region src/constants.ts
+/**
+* Base URL for the Kubb Studio web app.
+*/
 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,
@@ -679,6 +688,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",
@@ -700,6 +716,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",
@@ -899,7 +922,11 @@ 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.
 */
 function hookSeq(promises) {
 	return promises.filter(Boolean).reduce((promise, func) => {
@@ -912,7 +939,10 @@ 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.
 */
 function hookFirst(promises, nullCheck = (state) => state !== null) {
 	let promise = Promise.resolve(null);
@@ -923,7 +953,10 @@ 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.
 */
 function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
 	const limit = pLimit(concurrency);
@@ -931,29 +964,13 @@ 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
 function getMode(fileOrFolder) {
 	if (!fileOrFolder) return "split";
-	return path.extname(fileOrFolder) ? "single" : "split";
+	return extname(fileOrFolder) ? "single" : "split";
 }
-var PluginManager = class {
+const hookFirstNullCheck = (state) => !!state?.result;
+var PluginDriver = class {
 	config;
 	options;
 	/**
@@ -961,14 +978,13 @@ var PluginManager = class {
 	* the build pipeline after the adapter's `parse()` resolves.
 	*/
 	rootNode = void 0;
+	adapter = void 0;
 	#studioIsOpen = false;
 	#plugins = /* @__PURE__ */ new Set();
 	#usedPluginNames = {};
-	#promiseManager;
 	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);
@@ -979,14 +995,14 @@ var PluginManager = class {
 	}
 	getContext(plugin) {
 		const plugins = [...this.#plugins];
-		const pluginManager = this;
+		const driver = this;
 		const baseContext = {
 			fabric: this.options.fabric,
 			config: this.config,
 			plugin,
 			events: this.options.events,
-			pluginManager: this,
-			mode: getMode(path.resolve(this.config.root, this.config.output.path)),
+			driver: this,
+			mode: getMode(resolve(this.config.root, this.config.output.path)),
 			addFile: async (...files) => {
 				await this.options.fabric.addFile(...files);
 			},
@@ -994,15 +1010,18 @@ var PluginManager = class {
 				await this.options.fabric.upsertFile(...files);
 			},
 			get rootNode() {
-				return pluginManager.rootNode;
+				return driver.rootNode;
+			},
+			get adapter() {
+				return driver.adapter;
 			},
 			openInStudio(options) {
-				if (typeof pluginManager.config.devtools !== "object") throw new Error("Devtools must be an object");
-				if (!pluginManager.rootNode) throw new Error("RootNode is not defined, make sure you have set the parser in kubb.config.ts");
-				if (pluginManager.#studioIsOpen) return;
-				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 = {};
@@ -1019,17 +1038,21 @@ var PluginManager = class {
 		return this.#getSortedPlugins();
 	}
 	getFile({ name, mode, extname, pluginName, options }) {
-		const baseName = `${name}${extname}`;
+		const resolvedName = mode ? mode === "single" ? "" : this.resolveName({
+			name,
+			pluginName,
+			type: "file"
+		}) : name;
 		const path = this.resolvePath({
-			baseName,
+			baseName: `${resolvedName}${extname}`,
 			mode,
 			pluginName,
 			options
 		});
-		if (!path) throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginName "${pluginName}"`);
+		if (!path) throw new Error(`Filepath should be defined for resolvedName "${resolvedName}" and pluginName "${pluginName}"`);
 		return {
 			path,
-			baseName,
+			baseName: basename(path),
 			meta: { pluginName },
 			sources: [],
 			imports: [],
@@ -1037,8 +1060,7 @@ var PluginManager = class {
 		};
 	}
 	resolvePath = (params) => {
-		const root = path.resolve(this.config.root, this.config.output.path);
-		const defaultPath = path.resolve(root, params.baseName);
+		const defaultPath = resolve(resolve(this.config.root, this.config.output.path), params.baseName);
 		if (params.pluginName) return this.hookForPluginSync({
 			pluginName: params.pluginName,
 			hookName: "resolvePath",
@@ -1118,7 +1140,7 @@ var PluginManager = class {
 			hookName,
 			plugins
 		});
-		const promises = plugins.map((plugin) => {
+		const result = await hookFirst(plugins.map((plugin) => {
 			return async () => {
 				const value = await this.#execute({
 					strategy: "hookFirst",
@@ -1131,8 +1153,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;
 	}
@@ -1168,7 +1189,7 @@ var PluginManager = class {
 			plugins
 		});
 		const pluginStartTimes = /* @__PURE__ */ new Map();
-		const promises = plugins.map((plugin) => {
+		const results = await hookParallel(plugins.map((plugin) => {
 			return () => {
 				pluginStartTimes.set(plugin, performance.now());
 				return this.#execute({
@@ -1178,8 +1199,7 @@ 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];
@@ -1210,15 +1230,14 @@ var PluginManager = class {
 			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) {
@@ -1226,7 +1245,8 @@ var PluginManager = class {
 		if (hookName) return plugins.filter((plugin) => hookName in plugin);
 		return plugins.map((plugin) => {
 			if (plugin.pre) {
-				const missingPlugins = plugin.pre.filter((pluginName) => !plugins.find((pluginToFind) => pluginToFind.name === pluginName));
+				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;
@@ -1346,19 +1366,12 @@ var PluginManager = class {
 	}
 };
 //#endregion
-//#region src/defineStorage.ts
+//#region src/createStorage.ts
 /**
-* Wraps a storage builder so the `options` argument is optional, following the
-* same factory pattern as `definePlugin`, `defineLogger`, and `defineAdapter`.
-*
-* The builder receives the resolved options object and must return a
-* `DefineStorage`-compatible object that includes a `name` string.
+* 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',
@@ -1366,13 +1379,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
@@ -1400,7 +1415,7 @@ function defineStorage(build) {
 * })
 * ```
 */
-const fsStorage = defineStorage(() => ({
+const fsStorage = createStorage(() => ({
 	name: "fs",
 	async hasItem(key) {
 		try {
@@ -1448,11 +1463,14 @@ const fsStorage = defineStorage(() => ({
 }));
 //#endregion
 //#region package.json
-var version$1 = "5.0.0-alpha.2";
+var version$1 = "5.0.0-alpha.21";
 //#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 {
@@ -1465,6 +1483,17 @@ function getDiagnosticInfo() {
 }
 //#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`.
+*
+* 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();
@@ -1562,7 +1591,7 @@ async function setup(options) {
 			`  • Barrel type: ${definedConfig.output.barrelType || "none"}`
 		]
 	});
-	const pluginManager = new PluginManager(definedConfig, {
+	const pluginDriver = new PluginDriver(definedConfig, {
 		fabric,
 		events,
 		concurrency: 15
@@ -1573,25 +1602,32 @@ async function setup(options) {
 			date: /* @__PURE__ */ new Date(),
 			logs: [`Running adapter: ${definedConfig.adapter.name}`]
 		});
-		pluginManager.rootNode = await definedConfig.adapter.parse(source);
+		pluginDriver.adapter = definedConfig.adapter;
+		pluginDriver.rootNode = await definedConfig.adapter.parse(source);
 		await events.emit("debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: [
 				`✓ Adapter '${definedConfig.adapter.name}' resolved RootNode`,
-				`  • Schemas: ${pluginManager.rootNode.schemas.length}`,
-				`  • Operations: ${pluginManager.rootNode.operations.length}`
+				`  • Schemas: ${pluginDriver.rootNode.schemas.length}`,
+				`  • Operations: ${pluginDriver.rootNode.operations.length}`
 			]
 		});
 	}
 	return {
 		events,
 		fabric,
-		pluginManager,
+		driver: pluginDriver,
 		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);
@@ -1601,20 +1637,30 @@ async function build(options, overrides) {
 		failedPlugins,
 		fabric,
 		files,
-		pluginManager,
+		driver,
 		pluginTimings,
 		error: void 0,
 		sources
 	};
 }
+/**
+* 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) {
+			const context = driver.getContext(plugin);
 			const hrStart = process.hrtime();
 			const installer = plugin.install.bind(context);
 			try {
@@ -1687,7 +1733,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: [],
@@ -1705,7 +1751,7 @@ async function safeBuild(options, overrides) {
 			failedPlugins,
 			fabric,
 			files,
-			pluginManager,
+			driver,
 			pluginTimings,
 			sources
 		};
@@ -1714,16 +1760,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) pluginNameMap.set(plugin.name, plugin);
 	return barrelFiles.flatMap((file) => {
 		const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly);
 		return (file.sources ?? []).flatMap((source) => {
@@ -1748,133 +1794,572 @@ function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, plu
 function inputToAdapterSource(config) {
 	if (Array.isArray(config.input)) return {
 		type: "paths",
-		paths: config.input.map((i) => resolve(config.root, i.path))
+		paths: config.input.map((i) => new URLPath(i.path).isURL ? i.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: 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 defineAdapter(build) {
+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
+* export const myPlugin = createPlugin<MyPlugin>((options) => {
+*   return {
+*     name: 'my-plugin',
+*     options,
+*     resolvePath(baseName) { ... },
+*     resolveName(name, type) { ... },
+*   }
+* })
+*
+* // instantiate
+* const plugin = myPlugin({ output: { path: 'src/gen' } })
+*/
+function createPlugin(build) {
+	return (options) => build(options ?? {});
+}
+//#endregion
+//#region src/defineBuilder.ts
+/**
+* Defines a builder for a plugin — a named collection of schema-building helpers that
+* can be exported alongside the plugin and imported by other plugins or generators.
+*
+* @example
+* export const builder = defineBuilder<PluginTs>(() => ({
+*   name: 'default',
+*   buildParamsSchema({ params, node, resolver }) {
+*     return createSchema({ type: 'object', properties: [] })
+*   },
+*   buildDataSchemaNode({ node, resolver }) {
+*     return createSchema({ type: 'object', properties: [] })
+*   },
+* }))
+*/
+function defineBuilder(build) {
+	return build();
+}
+//#endregion
+//#region src/defineGenerator.ts
+function defineGenerator(generator) {
+	if (generator.type === "react") return {
+		version: "2",
+		Operations() {
+			return null;
+		},
+		Operation() {
+			return null;
+		},
+		Schema() {
+			return null;
+		},
+		...generator
+	};
+	return {
+		version: "2",
+		async operations() {
+			return [];
+		},
+		async operation() {
+			return [];
+		},
+		async schema() {
+			return [];
+		},
+		...generator
+	};
+}
+//#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/definePreset.ts
 /**
-* Wraps a plugin builder to make the options parameter optional.
+* Creates a typed preset object that bundles a name, resolvers, optional
+* transformers, and optional generators — the building block for composable plugin presets.
+*
+* @example
+* import { definePreset } from '@kubb/core'
+* import { resolverTsLegacy } from '@kubb/plugin-ts'
+*
+* export const myPreset = definePreset('myPreset', { resolvers: [resolverTsLegacy] })
+*
+* @example
+* // With custom transformers
+* export const myPreset = definePreset('myPreset', { resolvers: [resolverTsLegacy], transformers: [myTransformer] })
+*
+* @example
+* // With generators
+* export const myPreset = definePreset('myPreset', { resolvers: [resolverTsLegacy], generators: [typeGeneratorLegacy] })
 */
-function definePlugin(build) {
-	return (options) => build(options ?? {});
+function definePreset(name, { resolvers, transformers, generators }) {
+	return {
+		name,
+		resolvers,
+		transformers,
+		generators
+	};
+}
+//#endregion
+//#region src/definePresets.ts
+/**
+* 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 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 = mod.createRequire(this.normalizeDirectory(this.#cwd)).resolve(path);
-		return location;
-	}
-	async import(path) {
-		let location = this.getLocation(path);
-		if (os.platform() === "win32") location = pathToFileURL(location).href;
-		const module = await import(location);
-		return module?.default ?? module;
-	}
-	async getPackageJSON() {
-		const pkgPath = pkg.up({ cwd: this.#cwd });
-		if (!pkgPath) return;
-		const json = await read(pkgPath);
-		return JSON.parse(json);
-	}
-	getPackageJSONSync() {
-		const pkgPath = pkg.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);
+		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 (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 = coerce(packageVersion);
-		if (!semVer) return false;
-		return satisfies(semVer, version);
-	}
-	isValidSync(dependency, version) {
-		const packageVersion = this.getVersionSync(dependency);
-		if (!packageVersion) return false;
-		if (packageVersion === version) return true;
-		const semVer = coerce(packageVersion);
-		if (!semVer) return false;
-		return satisfies(semVer, version);
 	}
-};
+	if (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(path.resolve(root, output.path))) === "single") return path.resolve(root, output.path);
+	if (group && (groupPath || tag)) {
+		const groupName = group.name ? group.name : (ctx) => {
+			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+			return `${camelCase(ctx.group)}Controller`;
+		};
+		return path.resolve(root, output.path, groupName({ group: group.type === "path" ? groupPath : tag }), baseName);
+	}
+	return path.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(path.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: path.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 = path.basename(first.path);
+		} else if ("path" in config.input) source = path.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.
+*
+* - When `output.banner` is a function and `node` is provided, calls it with the node.
+* - When `output.banner` is a function and `node` is absent, falls back to the default Kubb banner.
+* - When `output.banner` is a string, returns it directly.
+* - When `config.output.defaultBanner` is `false`, returns `undefined`.
+* - Otherwise returns the default "Generated by Kubb" banner.
+*
+* @example String banner
+* ```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 Disabled banner
+* ```ts
+* defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
+* // → undefined
+* ```
+*/
+function defaultResolveBanner(node, { output, config }) {
+	if (typeof output?.banner === "function") return node ? output.banner(node) : buildDefaultBanner({ config });
+	if (typeof output?.banner === "string") return output.banner;
+	if (config.output.defaultBanner === false) return;
+	return buildDefaultBanner({ 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/renderNode.tsx
+/**
+* Renders a React component for a list of operation nodes (V2 generators).
+*/
+async function renderOperations(nodes, options) {
+	const { config, fabric, plugin, Component, driver, adapter } = options;
+	if (!Component) return;
+	const fabricChild = createReactFabric();
+	await fabricChild.render(/* @__PURE__ */ jsx(Fabric, {
+		meta: {
+			plugin,
+			driver
+		},
+		children: /* @__PURE__ */ jsx(Component, {
+			config,
+			plugin,
+			adapter,
+			nodes,
+			options: options.options
+		})
+	}));
+	fabric.context.fileManager.upsert(...fabricChild.files);
+	fabricChild.unmount();
+}
+/**
+* Renders a React component for a single operation node (V2 generators).
+*/
+async function renderOperation(node, options) {
+	const { config, fabric, plugin, Component, adapter, driver } = options;
+	if (!Component) return;
+	const fabricChild = createReactFabric();
+	await fabricChild.render(/* @__PURE__ */ jsx(Fabric, {
+		meta: {
+			plugin,
+			driver
+		},
+		children: /* @__PURE__ */ jsx(Component, {
+			config,
+			plugin,
+			adapter,
+			node,
+			options: options.options
+		})
+	}));
+	fabric.context.fileManager.upsert(...fabricChild.files);
+	fabricChild.unmount();
+}
+/**
+* Renders a React component for a single schema node (V2 generators).
+*/
+async function renderSchema(node, options) {
+	const { config, fabric, plugin, Component, adapter, driver } = options;
+	if (!Component) return;
+	const fabricChild = createReactFabric();
+	await fabricChild.render(/* @__PURE__ */ jsx(Fabric, {
+		meta: {
+			plugin,
+			driver
+		},
+		children: /* @__PURE__ */ jsx(Component, {
+			config,
+			plugin,
+			adapter,
+			node,
+			options: options.options
+		})
+	}));
+	fabric.context.fileManager.upsert(...fabricChild.files);
+	fabricChild.unmount();
+}
 //#endregion
 //#region src/storages/memoryStorage.ts
 /**
@@ -1894,7 +2379,7 @@ var PackageManager = class PackageManager {
 * })
 * ```
 */
-const memoryStorage = defineStorage(() => {
+const memoryStorage = createStorage(() => {
 	const store = /* @__PURE__ */ new Map();
 	return {
 		name: "memory",
@@ -1926,7 +2411,7 @@ const memoryStorage = defineStorage(() => {
 //#endregion
 //#region src/utils/FunctionParams.ts
 /**
-* @deprecated
+* @deprecated use ast package instead
 */
 var FunctionParams = class FunctionParams {
 	#items = [];
@@ -2002,14 +2487,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 {
@@ -2020,34 +2501,39 @@ async function isFormatterAvailable(formatter) {
 	}
 }
 /**
-* Detect which formatter is available in the system.
+* Detects the first available code formatter on the current system.
 *
-* @returns Promise that resolves to the first available formatter or undefined if none are found
-*
-* @remarks
-* Checks in order of preference: biome, oxfmt, prettier.
-* Uses the `--version` flag to detect if each formatter command is available.
-* This is a reliable method as all supported formatters implement this flag.
+* - 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
+/**
+* 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;
@@ -2063,10 +2549,18 @@ var TreeNode = class TreeNode {
 		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;
@@ -2097,6 +2591,12 @@ var TreeNode = class TreeNode {
 		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);
@@ -2167,65 +2667,64 @@ function buildDirectoryTree(files, rootFolder = "") {
 	return root;
 }
 //#endregion
-//#region src/BarrelManager.ts
+//#region src/utils/getBarrelFiles.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: 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
-					});
+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: 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
+		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 barrelManager = new BarrelManager();
 	const pathToBuildFrom = join(root, output.path);
 	if (trimExtName(pathToBuildFrom).endsWith("index")) return [];
-	const barrelFiles = barrelManager.getFiles({
-		files,
-		root: pathToBuildFrom,
-		meta
-	});
+	const barrelFiles = getBarrelFilesByRoot(pathToBuildFrom, files);
 	if (type === "all") return barrelFiles.map((file) => {
 		return {
 			...file,
@@ -2245,38 +2744,62 @@ async function getBarrelFiles(files, { type, meta = {}, root, output }) {
 	});
 }
 //#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);
+//#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) => ({ ...item }));
 }
-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);
+//#endregion
+//#region src/utils/mergeResolvers.ts
+/**
+* Merges an array of resolvers into a single resolver. Later entries override earlier ones (last wins).
+*/
+function mergeResolvers(...resolvers) {
+	return resolvers.reduce((acc, curr) => ({
+		...acc,
+		...curr
+	}), resolvers[0]);
 }
 //#endregion
-//#region src/utils/getConfigs.ts
+//#region src/utils/getPreset.ts
 /**
-* Converting UserConfig to Config Array without a change in the object beside the JSON convert.
+* Resolves a named preset into merged resolvers, transformers, and generators.
+*
+* - Merges the preset's resolvers on top of the first (default)
+* - Merges any additional user-supplied resolvers on top of that to produce the final `resolver`.
+* - Concatenates preset transformers before user-supplied transformers.
+* - 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, resolvers, transformers: userTransformers, generators: userGenerators } = params;
+	const [defaultResolver, ...userResolvers] = resolvers;
+	const preset = presets[presetName];
+	const resolver = mergeResolvers(mergeResolvers(defaultResolver, ...preset?.resolvers ?? []), ...userResolvers ?? []);
+	const transformers = [...preset?.transformers ?? [], ...userTransformers ?? []];
+	const presetGenerators = preset?.generators ?? [];
+	const defaultPresetGenerators = presets["default"]?.generators ?? [];
+	return {
+		resolver,
+		transformers,
+		generators: presetGenerators.length > 0 || userGenerators.length ? [...presetGenerators, ...userGenerators] : defaultPresetGenerators,
+		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 x(linter, ["--version"], { nodeOptions: { stdio: "ignore" } });
@@ -2285,14 +2808,73 @@ 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 = pkg.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 = coerce(packageVersion);
+	if (!semVer) return false;
+	return satisfies(semVer, version);
 }
 //#endregion
-export { AsyncEventEmitter, FunctionParams, PackageManager, PluginManager, PromiseManager, URLPath, build, build as default, defineAdapter, defineConfig, defineLogger, definePlugin, definePrinter, defineStorage, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getMode, isInputPath, linters, logLevel, memoryStorage, safeBuild, setup };
+export { AsyncEventEmitter, FunctionParams, PluginDriver, URLPath, build, build as default, buildDefaultBanner, createAdapter, createPlugin, createStorage, defaultResolveBanner, defaultResolveFile, defaultResolveFooter, defaultResolveOptions, defaultResolvePath, defineBuilder, defineConfig, defineGenerator, defineLogger, definePreset, definePresets, definePrinter, defineResolver, detectFormatter, detectLinter, formatters, fsStorage, getBarrelFiles, getConfigs, getMode, getPreset, isInputPath, linters, logLevel, memoryStorage, mergeResolvers, renderOperation, renderOperations, renderSchema, safeBuild, satisfiesDependency, setup };
 
 //# sourceMappingURL=index.js.map