@kubb/agent 5.0.0-alpha.35 → 5.0.0-alpha.36

package/.output/server/node_modules/@kubb/core/dist/index.js

@@ -0,0 +1,2311 @@
+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 { 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 * 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. */
+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`.
+*/
+var BuildError = class extends Error {
+	errors;
+	constructor(message, options) {
+		super(message, { cause: options.cause });
+		this.name = "BuildError";
+		this.errors = options.errors;
+	}
+};
+/**
+* Coerces an unknown thrown value to an `Error` instance.
+* When the value is already an `Error` it is returned as-is;
+* otherwise a new `Error` is created whose message is `String(value)`.
+*/
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+/**
+* A typed EventEmitter that awaits all async listeners before resolving.
+* Wraps Node's `EventEmitter` with full TypeScript event-map inference.
+*/
+var AsyncEventEmitter = class {
+	/**
+	* `maxListener` controls the maximum number of listeners per event before Node emits a memory-leak warning.
+	* @default 10
+	*/
+	constructor(maxListener = 10) {
+		this.#emitter.setMaxListeners(maxListener);
+	}
+	#emitter = new EventEmitter();
+	/**
+	* Emits an event and awaits all registered listeners in parallel.
+	* Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
+	*/
+	async emit(eventName, ...eventArgs) {
+		const listeners = this.#emitter.listeners(eventName);
+		if (listeners.length === 0) return;
+		await Promise.all(listeners.map(async (listener) => {
+			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) });
+			}
+		}));
+	}
+	/** Registers a persistent listener for the given event. */
+	on(eventName, handler) {
+		this.#emitter.on(eventName, handler);
+	}
+	/** Registers a one-shot listener that removes itself after the first invocation. */
+	onOnce(eventName, handler) {
+		const wrapper = (...args) => {
+			this.off(eventName, wrapper);
+			return handler(...args);
+		};
+		this.on(eventName, wrapper);
+	}
+	/** Removes a previously registered listener. */
+	off(eventName, handler) {
+		this.#emitter.off(eventName, handler);
+	}
+	/** Removes all listeners from every event channel. */
+	removeAll() {
+		this.#emitter.removeAllListeners();
+	}
+};
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(".");
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/** Returns a `CLIAdapter` with type inference. Pass a different adapter to `createCLI` to swap the CLI engine. */
+function defineCLIAdapter(adapter) {
+	return adapter;
+}
+/**
+* Serializes `CommandDefinition[]` to a plain, JSON-serializable structure.
+* Use to expose CLI capabilities to AI agents or MCP tools.
+*/
+function getCommandSchema(defs) {
+	return defs.map(serializeCommand);
+}
+function serializeCommand(def) {
+	return {
+		name: def.name,
+		description: def.description,
+		arguments: def.arguments,
+		options: serializeOptions(def.options ?? {}),
+		subCommands: def.subCommands ? def.subCommands.map(serializeCommand) : []
+	};
+}
+function serializeOptions(options) {
+	return Object.entries(options).map(([name, opt]) => {
+		return {
+			name,
+			flags: `${opt.short ? `-${opt.short}, ` : ""}--${name}${opt.type === "string" ? ` <${opt.hint ?? name}>` : ""}`,
+			type: opt.type,
+			description: opt.description,
+			...opt.default !== void 0 ? { default: opt.default } : {},
+			...opt.hint ? { hint: opt.hint } : {},
+			...opt.enum ? { enum: opt.enum } : {},
+			...opt.required ? { required: opt.required } : {}
+		};
+	});
+}
+/** Prints formatted help output for a command using its `CommandDefinition`. */
+function renderHelp(def, parentName) {
+	const schema = getCommandSchema([def])[0];
+	const programName = parentName ? `${parentName} ${schema.name}` : schema.name;
+	const argsPart = schema.arguments?.length ? ` ${schema.arguments.join(" ")}` : "";
+	const subCmdPart = schema.subCommands.length ? " <command>" : "";
+	console.log(`\n${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;
+}
+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);
+	}
+});
+/**
+* Calculates elapsed time in milliseconds from a high-resolution start time.
+* Rounds to 2 decimal places to provide sub-millisecond precision without noise.
+*/
+function getElapsedMs(hrStart) {
+	const [seconds, nanoseconds] = process.hrtime(hrStart);
+	const ms = seconds * 1e3 + nanoseconds / 1e6;
+	return Math.round(ms * 100) / 100;
+}
+/**
+* Converts a millisecond duration into a human-readable string.
+* Adjusts units (ms, s, m s) based on the magnitude of the duration.
+*/
+function formatMs(ms) {
+	if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
+	if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
+	return `${Math.round(ms)}ms`;
+}
+/**
+* Parses a CSS hex color string (`#RGB`) into its RGB channels.
+* Falls back to `255` for any channel that cannot be parsed.
+*/
+function parseHex(color) {
+	const int = Number.parseInt(color.replace("#", ""), 16);
+	return Number.isNaN(int) ? {
+		r: 255,
+		g: 255,
+		b: 255
+	} : {
+		r: int >> 16 & 255,
+		g: int >> 8 & 255,
+		b: int & 255
+	};
+}
+/**
+* Returns a function that wraps a string in a 24-bit ANSI true-color escape sequence
+* for the given hex color.
+*/
+function hex(color) {
+	const { r, g, b } = parseHex(color);
+	return (text) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+hex("#F55A17"), hex("#F5A217"), hex("#F58517"), hex("#B45309"), hex("#FFFFFF"), hex("#adadc6"), hex("#FDA4AF");
+/**
+* Converts all backslashes to forward slashes.
+* Extended-length Windows paths (`\\?\...`) are left unchanged.
+*/
+function toSlash(p) {
+	if (p.startsWith("\\\\?\\")) return p;
+	return p.replaceAll("\\", "/");
+}
+/**
+* Returns the relative path from `rootDir` to `filePath`, always using
+* forward slashes and prefixed with `./` when not already traversing upward.
+*/
+function getRelativePath(rootDir, filePath) {
+	if (!rootDir || !filePath) throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
+	const relativePath = posix.relative(toSlash(rootDir), toSlash(filePath));
+	return relativePath.startsWith("../") ? relativePath : `./${relativePath}`;
+}
+/**
+* Resolves to `true` when the file or directory at `path` exists.
+* Uses `Bun.file().exists()` when running under Bun, `fs.access` otherwise.
+*/
+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.
+*/
+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.
+* Creates any missing parent directories automatically.
+* When `sanity` is `true`, re-reads the file after writing and throws if the
+* content does not match.
+*/
+async function write(path, data, options = {}) {
+	const trimmed = data.trim();
+	if (trimmed === "") return void 0;
+	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;
+		await Bun.write(resolved, trimmed);
+		return trimmed;
+	}
+	try {
+		if (await readFile(resolved, { encoding: "utf-8" }) === trimmed) return void 0;
+	} catch {}
+	await mkdir(dirname(resolved), { recursive: true });
+	await writeFile(resolved, trimmed, { encoding: "utf-8" });
+	if (options.sanity) {
+		const savedData = await readFile(resolved, { encoding: "utf-8" });
+		if (savedData !== trimmed) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
+		return savedData;
+	}
+	return trimmed;
+}
+/** Recursively removes `path`. Silently succeeds when `path` does not exist. */
+async function clean(path) {
+	return rm(path, {
+		recursive: true,
+		force: true
+	});
+}
+/**
+* Registers `originalName` in `data` without altering the returned name.
+* Use this when you need to track usage frequency but always emit the original identifier.
+*/
+function setUniqueName(originalName, data) {
+	let used = data[originalName] || 0;
+	if (used) {
+		data[originalName] = ++used;
+		return originalName;
+	}
+	data[originalName] = 1;
+	return originalName;
+}
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = [
+	"abstract",
+	"arguments",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+];
+/**
+* Prefixes a word with `_` when it is a reserved JavaScript/Java identifier
+* or starts with a digit.
+*/
+function transformReservedWord(word) {
+	const firstChar = word.charCodeAt(0);
+	if (word && (reservedWords.includes(word) || firstChar >= 48 && firstChar <= 57)) return `_${word}`;
+	return word;
+}
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*/
+function isValidVarName(name) {
+	try {
+		new Function(`var ${name}`);
+	} catch {
+		return false;
+	}
+	return true;
+}
+/**
+* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
+*
+* @example
+* const p = new URLPath('/pet/{petId}')
+* p.URL      // '/pet/:petId'
+* p.template // '`/pet/${petId}`'
+*/
+var URLPath = class {
+	/** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+	path;
+	#options;
+	constructor(path, options = {}) {
+		this.path = path;
+		this.#options = options;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+	get URL() {
+		return this.toURLPath();
+	}
+	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+	get isURL() {
+		try {
+			return !!new URL(this.path).href;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
+	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
+	*/
+	get template() {
+		return this.toTemplateString();
+	}
+	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+	get object() {
+		return this.toObject();
+	}
+	/** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+	get params() {
+		return this.getParams();
+	}
+	#transformParam(raw) {
+		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. */
+	#eachParam(fn) {
+		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
+			const raw = match[1];
+			fn(raw, this.#transformParam(raw));
+		}
+	}
+	toObject({ type = "path", replacer, stringify } = {}) {
+		const object = {
+			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
+			params: this.getParams()
+		};
+		if (stringify) {
+			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+			return `{ url: '${object.url}' }`;
+		}
+		return object;
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	* An optional `replacer` can transform each extracted parameter name before interpolation.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
+	*/
+	toTemplateString({ prefix = "", replacer } = {}) {
+		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = this.#transformParam(part);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("")}\``;
+	}
+	/**
+	* Extracts all `{param}` segments from the path and returns them as a key-value map.
+	* An optional `replacer` transforms each parameter name in both key and value positions.
+	* Returns `undefined` when no path parameters are found.
+	*/
+	getParams(replacer) {
+		const params = {};
+		this.#eachParam((_raw, param) => {
+			const key = replacer ? replacer(param) : param;
+			params[key] = key;
+		});
+		return Object.keys(params).length > 0 ? params : void 0;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+	toURLPath() {
+		return this.path.replace(/\{([^}]+)\}/g, ":$1");
+	}
+};
+//#endregion
+//#region src/config.ts
+function defineConfig(config) {
+	return config;
+}
+/**
+* Type guard to check if a given config has an `input.path`.
+*/
+function isInputPath(config) {
+	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
+}
+//#endregion
+//#region src/constants.ts
+const DEFAULT_STUDIO_URL = "https://studio.kubb.dev";
+const BARREL_FILENAME = "index.ts";
+const DEFAULT_BANNER = "simple";
+const DEFAULT_EXTENSION = { ".ts": ".ts" };
+const PATH_SEPARATORS = ["/", "\\"];
+const logLevel = {
+	silent: Number.NEGATIVE_INFINITY,
+	error: 0,
+	warn: 1,
+	info: 3,
+	verbose: 4,
+	debug: 5
+};
+const linters = {
+	eslint: {
+		command: "eslint",
+		args: (outputPath) => [outputPath, "--fix"],
+		errorMessage: "Eslint not found"
+	},
+	biome: {
+		command: "biome",
+		args: (outputPath) => [
+			"lint",
+			"--fix",
+			outputPath
+		],
+		errorMessage: "Biome not found"
+	},
+	oxlint: {
+		command: "oxlint",
+		args: (outputPath) => ["--fix", outputPath],
+		errorMessage: "Oxlint not found"
+	}
+};
+const formatters = {
+	prettier: {
+		command: "prettier",
+		args: (outputPath) => [
+			"--ignore-unknown",
+			"--write",
+			outputPath
+		],
+		errorMessage: "Prettier not found"
+	},
+	biome: {
+		command: "biome",
+		args: (outputPath) => [
+			"format",
+			"--write",
+			outputPath
+		],
+		errorMessage: "Biome not found"
+	},
+	oxfmt: {
+		command: "oxfmt",
+		args: (outputPath) => [outputPath],
+		errorMessage: "Oxfmt not found"
+	}
+};
+//#endregion
+//#region src/devtools.ts
+/**
+* Encodes a `RootNode` as a compressed, URL-safe string.
+*
+* The JSON representation is deflate-compressed with {@link deflateSync} before
+* base64url encoding, which typically reduces payload size by 70–80 % and
+* keeps URLs well within browser and server path-length limits.
+*
+* Use {@link decodeAst} to reverse.
+*/
+function encodeAst(root) {
+	const compressed = deflateSync(new TextEncoder().encode(JSON.stringify(root)));
+	return Buffer.from(compressed).toString("base64url");
+}
+/**
+* Constructs the Kubb Studio URL for the given `RootNode`.
+* When `options.ast` is `true`, navigates to the AST inspector (`/ast`).
+* The `root` is encoded and attached as the `?root=` query parameter so Studio
+* can decode and render it without a round-trip to any server.
+*/
+function getStudioUrl(root, studioUrl, options = {}) {
+	return `${studioUrl.replace(/\/$/, "")}${options.ast ? "/ast" : ""}?root=${encodeAst(root)}`;
+}
+/**
+* Opens the Kubb Studio URL for the given `RootNode` in the default browser —
+*
+* Falls back to printing the URL if the browser cannot be launched.
+*/
+async function openInStudio(root, studioUrl, options = {}) {
+	const url = getStudioUrl(root, studioUrl, options);
+	const cmd = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
+	const args = process.platform === "win32" ? [
+		"/c",
+		"start",
+		"",
+		url
+	] : [url];
+	try {
+		await x(cmd, args);
+	} catch {
+		console.log(`\n  ${url}\n`);
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
+var Node = class {
+	value;
+	next;
+	constructor(value) {
+		this.value = value;
+	}
+};
+var Queue = class {
+	#head;
+	#tail;
+	#size;
+	constructor() {
+		this.clear();
+	}
+	enqueue(value) {
+		const node = new Node(value);
+		if (this.#head) {
+			this.#tail.next = node;
+			this.#tail = node;
+		} else {
+			this.#head = node;
+			this.#tail = node;
+		}
+		this.#size++;
+	}
+	dequeue() {
+		const current = this.#head;
+		if (!current) return;
+		this.#head = this.#head.next;
+		this.#size--;
+		if (!this.#head) this.#tail = void 0;
+		return current.value;
+	}
+	peek() {
+		if (!this.#head) return;
+		return this.#head.value;
+	}
+	clear() {
+		this.#head = void 0;
+		this.#tail = void 0;
+		this.#size = 0;
+	}
+	get size() {
+		return this.#size;
+	}
+	*[Symbol.iterator]() {
+		let current = this.#head;
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+	*drain() {
+		while (this.#head) yield this.dequeue();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/p-limit@7.3.0/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+	let rejectOnClear = false;
+	if (typeof concurrency === "object") ({concurrency, rejectOnClear = false} = concurrency);
+	validateConcurrency(concurrency);
+	if (typeof rejectOnClear !== "boolean") throw new TypeError("Expected `rejectOnClear` to be a boolean");
+	const queue = new Queue();
+	let activeCount = 0;
+	const resumeNext = () => {
+		if (activeCount < concurrency && queue.size > 0) {
+			activeCount++;
+			queue.dequeue().run();
+		}
+	};
+	const next = () => {
+		activeCount--;
+		resumeNext();
+	};
+	const run = async (function_, resolve, arguments_) => {
+		const result = (async () => function_(...arguments_))();
+		resolve(result);
+		try {
+			await result;
+		} catch {}
+		next();
+	};
+	const enqueue = (function_, resolve, reject, arguments_) => {
+		const queueItem = { reject };
+		new Promise((internalResolve) => {
+			queueItem.run = internalResolve;
+			queue.enqueue(queueItem);
+		}).then(run.bind(void 0, function_, resolve, arguments_));
+		if (activeCount < concurrency) resumeNext();
+	};
+	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
+		enqueue(function_, resolve, reject, arguments_);
+	});
+	Object.defineProperties(generator, {
+		activeCount: { get: () => activeCount },
+		pendingCount: { get: () => queue.size },
+		clearQueue: { value() {
+			if (!rejectOnClear) {
+				queue.clear();
+				return;
+			}
+			const abortError = AbortSignal.abort().reason;
+			while (queue.size > 0) queue.dequeue().reject(abortError);
+		} },
+		concurrency: {
+			get: () => concurrency,
+			set(newConcurrency) {
+				validateConcurrency(newConcurrency);
+				concurrency = newConcurrency;
+				queueMicrotask(() => {
+					while (activeCount < concurrency && queue.size > 0) resumeNext();
+				});
+			}
+		},
+		map: { async value(iterable, function_) {
+			const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+			return Promise.all(promises);
+		} }
+	});
+	return generator;
+}
+function validateConcurrency(concurrency) {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+}
+//#endregion
+//#region src/utils/executeStrategies.ts
+/**
+* Chains promises
+*/
+function hookSeq(promises) {
+	return promises.filter(Boolean).reduce((promise, func) => {
+		if (typeof func !== "function") throw new Error("HookSeq needs a function that returns a promise `() => Promise<unknown>`");
+		return promise.then((state) => {
+			const calledFunc = func(state);
+			if (calledFunc) return calledFunc.then(Array.prototype.concat.bind(state));
+			return state;
+		});
+	}, Promise.resolve([]));
+}
+/**
+* Chains promises, first non-null result stops and returns
+*/
+function hookFirst(promises, nullCheck = (state) => state !== null) {
+	let promise = Promise.resolve(null);
+	for (const func of promises.filter(Boolean)) promise = promise.then((state) => {
+		if (nullCheck(state)) return state;
+		return func(state);
+	});
+	return promise;
+}
+/**
+* Runs an array of promise functions with optional concurrency limit.
+*/
+function hookParallel(promises, concurrency = Number.POSITIVE_INFINITY) {
+	const limit = pLimit(concurrency);
+	const tasks = promises.filter(Boolean).map((promise) => limit(() => promise()));
+	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
+function getMode(fileOrFolder) {
+	if (!fileOrFolder) return "split";
+	return path.extname(fileOrFolder) ? "single" : "split";
+}
+var PluginManager = class {
+	config;
+	options;
+	/**
+	* The universal `@kubb/ast` `RootNode` produced by the adapter, set by
+	* the build pipeline after the adapter's `parse()` resolves.
+	*/
+	rootNode = void 0;
+	#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);
+		});
+	}
+	get events() {
+		return this.options.events;
+	}
+	getContext(plugin) {
+		const plugins = [...this.#plugins];
+		const pluginManager = 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)),
+			addFile: async (...files) => {
+				await this.options.fabric.addFile(...files);
+			},
+			upsertFile: async (...files) => {
+				await this.options.fabric.upsertFile(...files);
+			},
+			get rootNode() {
+				return pluginManager.rootNode;
+			},
+			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);
+			}
+		};
+		const mergedExtras = {};
+		for (const p of plugins) if (typeof p.inject === "function") {
+			const result = p.inject.call(baseContext, baseContext);
+			if (result !== null && typeof result === "object") Object.assign(mergedExtras, result);
+		}
+		return {
+			...baseContext,
+			...mergedExtras
+		};
+	}
+	get plugins() {
+		return this.#getSortedPlugins();
+	}
+	getFile({ name, mode, extname, pluginKey, options }) {
+		const baseName = `${name}${extname}`;
+		const path = this.resolvePath({
+			baseName,
+			mode,
+			pluginKey,
+			options
+		});
+		if (!path) throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginKey [${JSON.stringify(pluginKey)}]`);
+		return {
+			path,
+			baseName,
+			meta: { pluginKey },
+			sources: [],
+			imports: [],
+			exports: []
+		};
+	}
+	resolvePath = (params) => {
+		const root = path.resolve(this.config.root, this.config.output.path);
+		const defaultPath = path.resolve(root, params.baseName);
+		if (params.pluginKey) return this.hookForPluginSync({
+			pluginKey: params.pluginKey,
+			hookName: "resolvePath",
+			parameters: [
+				params.baseName,
+				params.mode,
+				params.options
+			]
+		})?.at(0) || defaultPath;
+		return this.hookFirstSync({
+			hookName: "resolvePath",
+			parameters: [
+				params.baseName,
+				params.mode,
+				params.options
+			]
+		})?.result || defaultPath;
+	};
+	resolveName = (params) => {
+		if (params.pluginKey) {
+			const names = this.hookForPluginSync({
+				pluginKey: params.pluginKey,
+				hookName: "resolveName",
+				parameters: [params.name.trim(), params.type]
+			});
+			return transformReservedWord([...new Set(names)].at(0) || params.name);
+		}
+		const name = this.hookFirstSync({
+			hookName: "resolveName",
+			parameters: [params.name.trim(), params.type]
+		})?.result;
+		return transformReservedWord(name ?? params.name);
+	};
+	/**
+	* Run a specific hookName for plugin x.
+	*/
+	async hookForPlugin({ pluginKey, hookName, parameters }) {
+		const plugins = this.getPluginsByKey(hookName, pluginKey);
+		this.events.emit("plugins:hook:progress:start", {
+			hookName,
+			plugins
+		});
+		const items = [];
+		for (const plugin of plugins) {
+			const result = await this.#execute({
+				strategy: "hookFirst",
+				hookName,
+				parameters,
+				plugin
+			});
+			if (result !== void 0 && result !== null) items.push(result);
+		}
+		this.events.emit("plugins:hook:progress:end", { hookName });
+		return items;
+	}
+	/**
+	* Run a specific hookName for plugin x.
+	*/
+	hookForPluginSync({ pluginKey, hookName, parameters }) {
+		return this.getPluginsByKey(hookName, pluginKey).map((plugin) => {
+			return this.#executeSync({
+				strategy: "hookFirst",
+				hookName,
+				parameters,
+				plugin
+			});
+		}).filter((x) => x !== null);
+	}
+	/**
+	* Returns the first non-null result.
+	*/
+	async hookFirst({ hookName, parameters, skipped }) {
+		const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
+			return skipped ? !skipped.has(plugin) : true;
+		});
+		this.events.emit("plugins:hook:progress:start", {
+			hookName,
+			plugins
+		});
+		const promises = plugins.map((plugin) => {
+			return async () => {
+				const value = await this.#execute({
+					strategy: "hookFirst",
+					hookName,
+					parameters,
+					plugin
+				});
+				return Promise.resolve({
+					plugin,
+					result: value
+				});
+			};
+		});
+		const result = await this.#promiseManager.run("first", promises);
+		this.events.emit("plugins:hook:progress:end", { hookName });
+		return result;
+	}
+	/**
+	* Returns the first non-null result.
+	*/
+	hookFirstSync({ hookName, parameters, skipped }) {
+		let parseResult = null;
+		const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
+			return skipped ? !skipped.has(plugin) : true;
+		});
+		for (const plugin of plugins) {
+			parseResult = {
+				result: this.#executeSync({
+					strategy: "hookFirst",
+					hookName,
+					parameters,
+					plugin
+				}),
+				plugin
+			};
+			if (parseResult?.result != null) break;
+		}
+		return parseResult;
+	}
+	/**
+	* Runs all plugins in parallel based on `this.plugin` order and `pre`/`post` settings.
+	*/
+	async hookParallel({ hookName, parameters }) {
+		const plugins = this.#getSortedPlugins(hookName);
+		this.events.emit("plugins:hook:progress:start", {
+			hookName,
+			plugins
+		});
+		const pluginStartTimes = /* @__PURE__ */ new Map();
+		const promises = plugins.map((plugin) => {
+			return () => {
+				pluginStartTimes.set(plugin, performance.now());
+				return this.#execute({
+					strategy: "hookParallel",
+					hookName,
+					parameters,
+					plugin
+				});
+			};
+		});
+		const results = await this.#promiseManager.run("parallel", promises, { concurrency: this.options.concurrency });
+		results.forEach((result, index) => {
+			if (isPromiseRejectedResult(result)) {
+				const plugin = this.#getSortedPlugins(hookName)[index];
+				if (plugin) {
+					const startTime = pluginStartTimes.get(plugin) ?? performance.now();
+					this.events.emit("error", result.reason, {
+						plugin,
+						hookName,
+						strategy: "hookParallel",
+						duration: Math.round(performance.now() - startTime),
+						parameters
+					});
+				}
+			}
+		});
+		this.events.emit("plugins:hook:progress:end", { hookName });
+		return results.reduce((acc, result) => {
+			if (result.status === "fulfilled") acc.push(result.value);
+			return acc;
+		}, []);
+	}
+	/**
+	* Chains plugins
+	*/
+	async hookSeq({ hookName, parameters }) {
+		const plugins = this.#getSortedPlugins(hookName);
+		this.events.emit("plugins:hook:progress:start", {
+			hookName,
+			plugins
+		});
+		const promises = 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) {
+				const missingPlugins = plugin.pre.filter((pluginName) => !plugins.find((pluginToFind) => pluginToFind.name === pluginName));
+				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;
+		});
+	}
+	getPluginByKey(pluginKey) {
+		const plugins = [...this.#plugins];
+		const [searchPluginName] = pluginKey;
+		return plugins.find((item) => {
+			const [name] = item.key;
+			return name === searchPluginName;
+		});
+	}
+	getPluginsByKey(hookName, pluginKey) {
+		const plugins = [...this.plugins];
+		const [searchPluginName, searchIdentifier] = pluginKey;
+		const pluginByPluginName = plugins.filter((plugin) => hookName in plugin).filter((item) => {
+			const [name, identifier] = item.key;
+			const identifierCheck = identifier?.toString() === searchIdentifier?.toString();
+			const nameCheck = name === searchPluginName;
+			if (searchIdentifier) return identifierCheck && nameCheck;
+			return nameCheck;
+		});
+		if (!pluginByPluginName?.length) {
+			const corePlugin = plugins.find((plugin) => plugin.name === "core" && hookName in plugin);
+			return corePlugin ? [corePlugin] : [];
+		}
+		return pluginByPluginName;
+	}
+	/**
+	* Run an async plugin hook and return the result.
+	* @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
+	* @param args Arguments passed to the plugin hook.
+	* @param plugin The actual pluginObject to run.
+	*/
+	#emitProcessingEnd({ startTime, output, strategy, hookName, plugin, parameters }) {
+		this.events.emit("plugins:hook:processing:end", {
+			duration: Math.round(performance.now() - startTime),
+			parameters,
+			output,
+			strategy,
+			hookName,
+			plugin
+		});
+	}
+	#execute({ strategy, hookName, parameters, plugin }) {
+		const hook = plugin[hookName];
+		if (!hook) return null;
+		this.events.emit("plugins:hook:processing:start", {
+			strategy,
+			hookName,
+			parameters,
+			plugin
+		});
+		const startTime = performance.now();
+		return (async () => {
+			try {
+				const output = typeof hook === "function" ? await Promise.resolve(hook.apply(this.getContext(plugin), parameters ?? [])) : hook;
+				this.#emitProcessingEnd({
+					startTime,
+					output,
+					strategy,
+					hookName,
+					plugin,
+					parameters
+				});
+				return output;
+			} catch (error) {
+				this.events.emit("error", error, {
+					plugin,
+					hookName,
+					strategy,
+					duration: Math.round(performance.now() - startTime)
+				});
+				return null;
+			}
+		})();
+	}
+	/**
+	* Run a sync plugin hook and return the result.
+	* @param hookName Name of the plugin hook. Must be in `PluginHooks`.
+	* @param args Arguments passed to the plugin hook.
+	* @param plugin The actual plugin
+	*/
+	#executeSync({ strategy, hookName, parameters, plugin }) {
+		const hook = plugin[hookName];
+		if (!hook) return null;
+		this.events.emit("plugins:hook:processing:start", {
+			strategy,
+			hookName,
+			parameters,
+			plugin
+		});
+		const startTime = performance.now();
+		try {
+			const output = typeof hook === "function" ? hook.apply(this.getContext(plugin), parameters) : hook;
+			this.#emitProcessingEnd({
+				startTime,
+				output,
+				strategy,
+				hookName,
+				plugin,
+				parameters
+			});
+			return output;
+		} catch (error) {
+			this.events.emit("error", error, {
+				plugin,
+				hookName,
+				strategy,
+				duration: Math.round(performance.now() - startTime)
+			});
+			return null;
+		}
+	}
+	#parse(plugin) {
+		const usedPluginNames = this.#usedPluginNames;
+		setUniqueName(plugin.name, usedPluginNames);
+		const usageCount = usedPluginNames[plugin.name];
+		if (usageCount && usageCount > 1) this.events.emit("warn", `Multiple instances of plugin "${plugin.name}" detected. This behavior is deprecated and will be removed in v5.`, `Plugin key: [${plugin.name}, ${usageCount}]`);
+		return {
+			install() {},
+			...plugin,
+			key: [plugin.name, usedPluginNames[plugin.name]].filter(Boolean)
+		};
+	}
+};
+//#endregion
+//#region src/defineStorage.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.
+*
+* @example
+* ```ts
+* import { defineStorage } from '@kubb/core'
+*
+* export const memoryStorage = defineStorage((_options) => {
+*   const store = new Map<string, string>()
+*   return {
+*     name: 'memory',
+*     async hasItem(key) { return store.has(key) },
+*     async getItem(key) { return store.get(key) ?? null },
+*     async setItem(key, value) { store.set(key, value) },
+*     async removeItem(key) { store.delete(key) },
+*     async getKeys() { return [...store.keys()] },
+*     async clear() { store.clear() },
+*   }
+* })
+* ```
+*/
+function defineStorage(build) {
+	return (options) => build(options ?? {});
+}
+//#endregion
+//#region src/storages/fsStorage.ts
+/**
+* Built-in filesystem storage driver.
+*
+* This is the default storage when no `storage` option is configured in `output`.
+* Keys are resolved against `process.cwd()`, so root-relative paths such as
+* `src/gen/api/getPets.ts` are written to the correct location without extra configuration.
+*
+* Internally uses the `write` utility from `@internals/utils`, which:
+* - trims leading/trailing whitespace before writing
+* - skips the write when file content is already identical (deduplication)
+* - creates missing parent directories automatically
+* - supports Bun's native file API when running under Bun
+*
+* @example
+* ```ts
+* import { defineConfig, fsStorage } from '@kubb/core'
+*
+* export default defineConfig({
+*   input:  { path: './petStore.yaml' },
+*   output: { path: './src/gen', storage: fsStorage() },
+* })
+* ```
+*/
+const fsStorage = defineStorage(() => ({
+	name: "fs",
+	async hasItem(key) {
+		try {
+			await access(resolve(key));
+			return true;
+		} catch {
+			return false;
+		}
+	},
+	async getItem(key) {
+		try {
+			return await readFile(resolve(key), "utf8");
+		} catch {
+			return null;
+		}
+	},
+	async setItem(key, value) {
+		await write(resolve(key), value, { sanity: false });
+	},
+	async removeItem(key) {
+		await rm(resolve(key), { force: true });
+	},
+	async getKeys(base) {
+		const keys = [];
+		async function walk(dir, prefix) {
+			let entries;
+			try {
+				entries = await readdir(dir, { withFileTypes: true });
+			} catch {
+				return;
+			}
+			for (const entry of entries) {
+				const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+				if (entry.isDirectory()) await walk(join(dir, entry.name), rel);
+				else keys.push(rel);
+			}
+		}
+		await walk(resolve(base ?? process.cwd()), "");
+		return keys;
+	},
+	async clear(base) {
+		if (!base) return;
+		await clean(resolve(base));
+	}
+}));
+//#endregion
+//#region package.json
+var version$1 = "4.37.2";
+//#endregion
+//#region src/utils/diagnostics.ts
+/**
+* Get diagnostic information for debugging
+*/
+function getDiagnosticInfo() {
+	return {
+		nodeVersion: version,
+		KubbVersion: version$1,
+		platform: process.platform,
+		arch: process.arch,
+		cwd: process.cwd()
+	};
+}
+//#endregion
+//#region src/build.ts
+async function setup(options) {
+	const { config: userConfig, events = new AsyncEventEmitter() } = options;
+	const sources = /* @__PURE__ */ new Map();
+	const diagnosticInfo = getDiagnosticInfo();
+	if (Array.isArray(userConfig.input)) await events.emit("warn", "This feature is still under development — use with caution");
+	await events.emit("debug", {
+		date: /* @__PURE__ */ new Date(),
+		logs: [
+			"Configuration:",
+			`  • Name: ${userConfig.name || "unnamed"}`,
+			`  • Root: ${userConfig.root || process.cwd()}`,
+			`  • Output: ${userConfig.output?.path || "not specified"}`,
+			`  • Plugins: ${userConfig.plugins?.length || 0}`,
+			"Output Settings:",
+			`  • Storage: ${userConfig.output?.storage ? `custom(${userConfig.output.storage.name})` : userConfig.output?.write === false ? "disabled" : "filesystem (default)"}`,
+			`  • Formatter: ${userConfig.output?.format || "none"}`,
+			`  • Linter: ${userConfig.output?.lint || "none"}`,
+			"Environment:",
+			Object.entries(diagnosticInfo).map(([key, value]) => `  • ${key}: ${value}`).join("\n")
+		]
+	});
+	try {
+		if (isInputPath(userConfig) && !new URLPath(userConfig.input.path).isURL) {
+			await exists(userConfig.input.path);
+			await events.emit("debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [`✓ Input file validated: ${userConfig.input.path}`]
+			});
+		}
+	} catch (caughtError) {
+		if (isInputPath(userConfig)) {
+			const error = caughtError;
+			throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${userConfig.input.path}`, { cause: error });
+		}
+	}
+	const definedConfig = {
+		root: userConfig.root || process.cwd(),
+		...userConfig,
+		output: {
+			write: true,
+			barrelType: "named",
+			extension: DEFAULT_EXTENSION,
+			defaultBanner: DEFAULT_BANNER,
+			...userConfig.output
+		},
+		devtools: userConfig.devtools ? {
+			studioUrl: DEFAULT_STUDIO_URL,
+			...typeof userConfig.devtools === "boolean" ? {} : userConfig.devtools
+		} : void 0,
+		plugins: userConfig.plugins
+	};
+	const storage = definedConfig.output.write === false ? null : definedConfig.output.storage ?? fsStorage();
+	if (definedConfig.output.clean) {
+		await events.emit("debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: ["Cleaning output directories", `  • Output: ${definedConfig.output.path}`]
+		});
+		await storage?.clear(resolve(definedConfig.root, definedConfig.output.path));
+	}
+	const fabric = createFabric();
+	fabric.use(fsPlugin);
+	fabric.use(typescriptParser);
+	fabric.context.on("files:processing:start", (files) => {
+		events.emit("files:processing:start", files);
+		events.emit("debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [`Writing ${files.length} files...`]
+		});
+	});
+	fabric.context.on("file:processing:update", async (params) => {
+		const { file, source } = params;
+		await events.emit("file:processing:update", {
+			...params,
+			config: definedConfig,
+			source
+		});
+		if (source) {
+			const key = relative(resolve(definedConfig.root), file.path);
+			await storage?.setItem(key, source);
+			sources.set(file.path, source);
+		}
+	});
+	fabric.context.on("files:processing:end", async (files) => {
+		await events.emit("files:processing:end", files);
+		await events.emit("debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [`✓ File write process completed for ${files.length} files`]
+		});
+	});
+	await events.emit("debug", {
+		date: /* @__PURE__ */ new Date(),
+		logs: [
+			"✓ Fabric initialized",
+			`  • Storage: ${storage ? storage.name : "disabled (dry-run)"}`,
+			`  • Barrel type: ${definedConfig.output.barrelType || "none"}`
+		]
+	});
+	const pluginManager = new PluginManager(definedConfig, {
+		fabric,
+		events,
+		concurrency: 15
+	});
+	if (definedConfig.adapter) {
+		const source = inputToAdapterSource(definedConfig);
+		await events.emit("debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [`Running adapter: ${definedConfig.adapter.name}`]
+		});
+		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}`
+			]
+		});
+	}
+	return {
+		events,
+		fabric,
+		pluginManager,
+		sources
+	};
+}
+async function build(options, overrides) {
+	const { fabric, files, pluginManager, failedPlugins, pluginTimings, error, sources } = await safeBuild(options, overrides);
+	if (error) throw error;
+	if (failedPlugins.size > 0) {
+		const errors = [...failedPlugins].map(({ error }) => error);
+		throw new BuildError(`Build Error with ${failedPlugins.size} failed plugins`, { errors });
+	}
+	return {
+		failedPlugins,
+		fabric,
+		files,
+		pluginManager,
+		pluginTimings,
+		error: void 0,
+		sources
+	};
+}
+async function safeBuild(options, overrides) {
+	const { fabric, pluginManager, events, sources } = overrides ? overrides : await setup(options);
+	const failedPlugins = /* @__PURE__ */ new Set();
+	const pluginTimings = /* @__PURE__ */ new Map();
+	const config = pluginManager.config;
+	try {
+		for (const plugin of pluginManager.plugins) {
+			const context = pluginManager.getContext(plugin);
+			const hrStart = process.hrtime();
+			const installer = plugin.install.bind(context);
+			try {
+				const timestamp = /* @__PURE__ */ new Date();
+				await events.emit("plugin:start", plugin);
+				await events.emit("debug", {
+					date: timestamp,
+					logs: ["Installing plugin...", `  • Plugin Key: [${plugin.key.join(", ")}]`]
+				});
+				await installer(context);
+				const duration = getElapsedMs(hrStart);
+				pluginTimings.set(plugin.name, duration);
+				await events.emit("plugin:end", plugin, {
+					duration,
+					success: true
+				});
+				await events.emit("debug", {
+					date: /* @__PURE__ */ new Date(),
+					logs: [`✓ Plugin installed successfully (${formatMs(duration)})`]
+				});
+			} catch (caughtError) {
+				const error = caughtError;
+				const errorTimestamp = /* @__PURE__ */ new Date();
+				const duration = getElapsedMs(hrStart);
+				await events.emit("plugin:end", plugin, {
+					duration,
+					success: false,
+					error
+				});
+				await events.emit("debug", {
+					date: errorTimestamp,
+					logs: [
+						"✗ Plugin installation failed",
+						`  • Plugin Key: ${JSON.stringify(plugin.key)}`,
+						`  • Error: ${error.constructor.name} - ${error.message}`,
+						"  • Stack Trace:",
+						error.stack || "No stack trace available"
+					]
+				});
+				failedPlugins.add({
+					plugin,
+					error
+				});
+			}
+		}
+		if (config.output.barrelType) {
+			const rootPath = resolve(resolve(config.root), config.output.path, BARREL_FILENAME);
+			const rootDir = dirname(rootPath);
+			await events.emit("debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [
+					"Generating barrel file",
+					`  • Type: ${config.output.barrelType}`,
+					`  • Path: ${rootPath}`
+				]
+			});
+			const barrelFiles = fabric.files.filter((file) => {
+				return file.sources.some((source) => source.isIndexable);
+			});
+			await events.emit("debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [`Found ${barrelFiles.length} indexable files for barrel export`]
+			});
+			const existingBarrel = fabric.files.find((f) => f.path === rootPath);
+			const rootFile = {
+				path: rootPath,
+				baseName: BARREL_FILENAME,
+				exports: buildBarrelExports({
+					barrelFiles,
+					rootDir,
+					existingExports: new Set(existingBarrel?.exports?.flatMap((e) => Array.isArray(e.name) ? e.name : [e.name]).filter((n) => Boolean(n)) ?? []),
+					config,
+					pluginManager
+				}),
+				sources: [],
+				imports: [],
+				meta: {}
+			};
+			await fabric.upsertFile(rootFile);
+			await events.emit("debug", {
+				date: /* @__PURE__ */ new Date(),
+				logs: [`✓ Generated barrel file (${rootFile.exports?.length || 0} exports)`]
+			});
+		}
+		const files = [...fabric.files];
+		await fabric.write({ extension: config.output.extension });
+		return {
+			failedPlugins,
+			fabric,
+			files,
+			pluginManager,
+			pluginTimings,
+			sources
+		};
+	} catch (error) {
+		return {
+			failedPlugins,
+			fabric,
+			files: [],
+			pluginManager,
+			pluginTimings,
+			error,
+			sources
+		};
+	}
+}
+function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, pluginManager }) {
+	const pluginKeyMap = /* @__PURE__ */ new Map();
+	for (const plugin of pluginManager.plugins) pluginKeyMap.set(JSON.stringify(plugin.key), plugin);
+	return barrelFiles.flatMap((file) => {
+		const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly);
+		return (file.sources ?? []).flatMap((source) => {
+			if (!file.path || !source.isIndexable) return [];
+			const meta = file.meta;
+			const pluginOptions = (meta?.pluginKey ? pluginKeyMap.get(JSON.stringify(meta.pluginKey)) : void 0)?.options;
+			if (!pluginOptions || pluginOptions.output?.barrelType === false) return [];
+			const exportName = config.output.barrelType === "all" ? void 0 : source.name ? [source.name] : void 0;
+			if (exportName?.some((n) => existingExports.has(n))) return [];
+			return [{
+				name: exportName,
+				path: getRelativePath(rootDir, file.path),
+				isTypeOnly: config.output.barrelType === "all" ? containsOnlyTypes : source.isTypeOnly
+			}];
+		});
+	});
+}
+/**
+* Maps the resolved `Config['input']` shape into an `AdapterSource` that
+* the adapter's `parse()` can consume.
+*/
+function inputToAdapterSource(config) {
+	if (Array.isArray(config.input)) return {
+		type: "paths",
+		paths: config.input.map((i) => resolve(config.root, i.path))
+	};
+	if ("data" in config.input) return {
+		type: "data",
+		data: config.input.data
+	};
+	return {
+		type: "path",
+		path: resolve(config.root, config.input.path)
+	};
+}
+//#endregion
+//#region src/defineAdapter.ts
+/**
+* Wraps an adapter builder to make the options parameter optional.
+*
+* @example
+* ```ts
+* export const adapterOas = defineAdapter<OasAdapter>((options) => {
+*   const { validate = true, dateType = 'string' } = options
+*   return {
+*     name: adapterOasName,
+*     options: { validate, dateType, ... },
+*     parse(source) { ... },
+*   }
+* })
+* ```
+*/
+function defineAdapter(build) {
+	return (options) => build(options ?? {});
+}
+//#endregion
+//#region src/defineLogger.ts
+function defineLogger(logger) {
+	return { ...logger };
+}
+//#endregion
+//#region src/definePlugin.ts
+/**
+* Wraps a plugin builder to make the options parameter optional.
+*/
+function definePlugin(build) {
+	return (options) => build(options ?? {});
+}
+//#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 || {}
+		};
+		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);
+	}
+};
+//#endregion
+//#region src/storages/memoryStorage.ts
+/**
+* In-memory storage driver. Useful for testing and dry-run scenarios where
+* generated output should be captured without touching the filesystem.
+*
+* All data lives in a `Map` scoped to the storage instance and is discarded
+* when the instance is garbage-collected.
+*
+* @example
+* ```ts
+* import { defineConfig, memoryStorage } from '@kubb/core'
+*
+* export default defineConfig({
+*   input:  { path: './petStore.yaml' },
+*   output: { path: './src/gen', storage: memoryStorage() },
+* })
+* ```
+*/
+const memoryStorage = defineStorage(() => {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		name: "memory",
+		async hasItem(key) {
+			return store.has(key);
+		},
+		async getItem(key) {
+			return store.get(key) ?? null;
+		},
+		async setItem(key, value) {
+			store.set(key, value);
+		},
+		async removeItem(key) {
+			store.delete(key);
+		},
+		async getKeys(base) {
+			const keys = [...store.keys()];
+			return base ? keys.filter((k) => k.startsWith(base)) : keys;
+		},
+		async clear(base) {
+			if (!base) {
+				store.clear();
+				return;
+			}
+			for (const key of store.keys()) if (key.startsWith(base)) store.delete(key);
+		}
+	};
+});
+//#endregion
+//#region src/utils/FunctionParams.ts
+/**
+* @deprecated
+*/
+var FunctionParams = class FunctionParams {
+	#items = [];
+	get items() {
+		return this.#items.flat();
+	}
+	add(item) {
+		if (!item) return this;
+		if (Array.isArray(item)) {
+			item.filter((x) => x !== void 0).forEach((it) => {
+				this.#items.push(it);
+			});
+			return this;
+		}
+		this.#items.push(item);
+		return this;
+	}
+	static #orderItems(items) {
+		return sortBy(items.filter(Boolean), [(item) => Array.isArray(item), "desc"], [(item) => !Array.isArray(item) && item.default !== void 0, "asc"], [(item) => Array.isArray(item) || (item.required ?? true), "desc"]);
+	}
+	static #addParams(acc, item) {
+		const { enabled = true, name, type, required = true, ...rest } = item;
+		if (!enabled) return acc;
+		if (!name) {
+			acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
+			return acc;
+		}
+		const parameterName = name.startsWith("{") ? name : camelCase(name);
+		if (type) if (required) acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
+		else acc.push(`${parameterName}?: ${type}`);
+		else acc.push(`${parameterName}`);
+		return acc;
+	}
+	static toObject(items) {
+		let type = [];
+		let name = [];
+		const enabled = items.every((item) => item.enabled) ? items.at(0)?.enabled : true;
+		const required = items.every((item) => item.required) ?? true;
+		items.forEach((item) => {
+			name = FunctionParams.#addParams(name, {
+				...item,
+				type: void 0
+			});
+			if (items.some((item) => item.type)) type = FunctionParams.#addParams(type, item);
+		});
+		return {
+			name: `{ ${name.join(", ")} }`,
+			type: type.length ? `{ ${type.join("; ")} }` : void 0,
+			enabled,
+			required
+		};
+	}
+	toObject() {
+		const items = FunctionParams.#orderItems(this.#items).flat();
+		return FunctionParams.toObject(items);
+	}
+	static toString(items) {
+		return FunctionParams.#orderItems(items).reduce((acc, item) => {
+			if (Array.isArray(item)) {
+				if (item.length <= 0) return acc;
+				const subItems = FunctionParams.#orderItems(item);
+				const objectItem = FunctionParams.toObject(subItems);
+				return FunctionParams.#addParams(acc, objectItem);
+			}
+			return FunctionParams.#addParams(acc, item);
+		}, []).join(", ");
+	}
+	toString() {
+		const items = FunctionParams.#orderItems(this.#items);
+		return FunctionParams.toString(items);
+	}
+};
+//#endregion
+//#region src/utils/formatters.ts
+/**
+* Check if a formatter command is available in the system.
+*
+* @param formatter - The formatter to check ('biome', 'prettier', or 'oxfmt')
+* @returns Promise that resolves to true if the formatter is available, false otherwise
+*
+* @remarks
+* This function checks availability by running `<formatter> --version` command.
+* All supported formatters (biome, prettier, oxfmt) implement the --version flag.
+*/
+async function isFormatterAvailable(formatter) {
+	try {
+		await x(formatter, ["--version"], { nodeOptions: { stdio: "ignore" } });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Detect which formatter is available in the system.
+*
+* @returns Promise that resolves to the first available formatter or undefined if none are found
+*
+* @remarks
+* Checks in order of preference: biome, oxfmt, prettier.
+* Uses the `--version` flag to detect if each formatter command is available.
+* This is a reliable method as all supported formatters implement this flag.
+*
+* @example
+* ```typescript
+* const formatter = await detectFormatter()
+* if (formatter) {
+*   console.log(`Using ${formatter} for formatting`)
+* } else {
+*   console.log('No formatter found')
+* }
+* ```
+*/
+async function detectFormatter() {
+	for (const formatter of [
+		"biome",
+		"oxfmt",
+		"prettier"
+	]) if (await isFormatterAvailable(formatter)) return formatter;
+}
+//#endregion
+//#region src/utils/TreeNode.ts
+var TreeNode = class TreeNode {
+	data;
+	parent;
+	children = [];
+	#cachedLeaves = void 0;
+	constructor(data, parent) {
+		this.data = data;
+		this.parent = parent;
+	}
+	addChild(data) {
+		const child = new TreeNode(data, this);
+		if (!this.children) this.children = [];
+		this.children.push(child);
+		return child;
+	}
+	get root() {
+		if (!this.parent) return this;
+		return this.parent.root;
+	}
+	get leaves() {
+		if (!this.children || this.children.length === 0) return [this];
+		if (this.#cachedLeaves) return this.#cachedLeaves;
+		const leaves = [];
+		for (const child of this.children) leaves.push(...child.leaves);
+		this.#cachedLeaves = leaves;
+		return leaves;
+	}
+	forEach(callback) {
+		if (typeof callback !== "function") throw new TypeError("forEach() callback must be a function");
+		callback(this);
+		for (const child of this.children) child.forEach(callback);
+		return this;
+	}
+	findDeep(predicate) {
+		if (typeof predicate !== "function") throw new TypeError("find() predicate must be a function");
+		return this.leaves.find(predicate);
+	}
+	forEachDeep(callback) {
+		if (typeof callback !== "function") throw new TypeError("forEach() callback must be a function");
+		this.leaves.forEach(callback);
+	}
+	filterDeep(callback) {
+		if (typeof callback !== "function") throw new TypeError("filter() callback must be a function");
+		return this.leaves.filter(callback);
+	}
+	mapDeep(callback) {
+		if (typeof callback !== "function") throw new TypeError("map() callback must be a function");
+		return this.leaves.map(callback);
+	}
+	static build(files, root) {
+		try {
+			const filteredTree = buildDirectoryTree(files, root);
+			if (!filteredTree) return null;
+			const treeNode = new TreeNode({
+				name: filteredTree.name,
+				path: filteredTree.path,
+				file: filteredTree.file,
+				type: getMode(filteredTree.path)
+			});
+			const recurse = (node, item) => {
+				const subNode = node.addChild({
+					name: item.name,
+					path: item.path,
+					file: item.file,
+					type: getMode(item.path)
+				});
+				if (item.children?.length) item.children?.forEach((child) => {
+					recurse(subNode, child);
+				});
+			};
+			filteredTree.children?.forEach((child) => {
+				recurse(treeNode, child);
+			});
+			return treeNode;
+		} catch (error) {
+			throw new Error("Something went wrong with creating barrel files with the TreeNode class", { cause: error });
+		}
+	}
+};
+const normalizePath = (p) => p.replaceAll("\\", "/");
+function buildDirectoryTree(files, rootFolder = "") {
+	const normalizedRootFolder = normalizePath(rootFolder);
+	const rootPrefix = normalizedRootFolder.endsWith("/") ? normalizedRootFolder : `${normalizedRootFolder}/`;
+	const filteredFiles = files.filter((file) => {
+		const normalizedFilePath = normalizePath(file.path);
+		return rootFolder ? normalizedFilePath.startsWith(rootPrefix) && !normalizedFilePath.endsWith(".json") : !normalizedFilePath.endsWith(".json");
+	});
+	if (filteredFiles.length === 0) return null;
+	const root = {
+		name: rootFolder || "",
+		path: rootFolder || "",
+		children: []
+	};
+	filteredFiles.forEach((file) => {
+		const parts = file.path.slice(rootFolder.length).split("/").filter(Boolean);
+		let currentLevel = root.children;
+		let currentPath = normalizePath(rootFolder);
+		parts.forEach((part, index) => {
+			currentPath = path.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: 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 = 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
+		};
+	});
+}
+//#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);
+}
+//#endregion
+//#region src/utils/getConfigs.ts
+/**
+* Converting UserConfig to Config Array without a change in the object beside the JSON convert.
+*/
+async function getConfigs(config, args) {
+	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;
+}
+//#endregion
+//#region src/utils/linters.ts
+async function isLinterAvailable(linter) {
+	try {
+		await x(linter, ["--version"], { nodeOptions: { stdio: "ignore" } });
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function detectLinter() {
+	for (const linter of [
+		"biome",
+		"oxlint",
+		"eslint"
+	]) if (await isLinterAvailable(linter)) return linter;
+}
+//#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 };
+
+//# sourceMappingURL=index.js.map