@kubb/core 4.32.4 → 4.33.1

package/dist/index.cjs

@@ -3,12 +3,16 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("./chunk-ByKO4r7w.cjs");
-const require_packageManager = require("./packageManager-jzjuEj2U.cjs");
-const require_fs = require("./fs-D4eqq6bR.cjs");
 let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_events = require("node:events");
+let node_util = require("node:util");
+let node_fs = require("node:fs");
+let node_fs_promises = require("node:fs/promises");
 let _kubb_react_fabric = require("@kubb/react-fabric");
 let _kubb_react_fabric_parsers = require("@kubb/react-fabric/parsers");
 let _kubb_react_fabric_plugins = require("@kubb/react-fabric/plugins");
+let node_perf_hooks = require("node:perf_hooks");
 let node_process = require("node:process");
 let node_module = require("node:module");
 node_module = require_chunk.__toESM(node_module);
@@ -18,30 +22,641 @@ let node_url = require("node:url");
 let empathic_package = require("empathic/package");
 empathic_package = require_chunk.__toESM(empathic_package);
 let semver = require("semver");
-//#region src/BaseGenerator.ts
+let remeda = require("remeda");
+let tinyexec = require("tinyexec");
+//#region ../../internals/utils/dist/index.js
+/** Thrown when a plugin's configuration or input fails validation. */
+var ValidationPluginError = class extends Error {};
 /**
-* Abstract class that contains the building blocks for plugins to create their own Generator
-* @link idea based on https://github.com/colinhacks/zod/blob/master/src/types.ts#L137
+* Thrown when one or more errors occur during a Kubb build.
+* Carries the full list of underlying errors on `errors`.
 */
-var BaseGenerator = class {
-	#options = {};
-	#context = {};
-	constructor(options, context) {
-		if (context) this.#context = context;
-		if (options) this.#options = options;
-		return this;
+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);
 	}
-	get options() {
-		return this.#options;
+	#emitter = new node_events.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) });
+			}
+		}));
 	}
-	get context() {
-		return this.#context;
+	/** Registers a persistent listener for the given event. */
+	on(eventName, handler) {
+		this.#emitter.on(eventName, handler);
 	}
-	set options(options) {
-		this.#options = {
-			...this.#options,
-			...options
+	/** 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${(0, node_util.styleText)("bold", "Usage:")} ${programName}${argsPart}${subCmdPart} [options]\n`);
+	if (schema.description) console.log(`  ${schema.description}\n`);
+	if (schema.subCommands.length) {
+		console.log((0, node_util.styleText)("bold", "Commands:"));
+		for (const sub of schema.subCommands) console.log(`  ${(0, node_util.styleText)("cyan", sub.name.padEnd(16))}${sub.description}`);
+		console.log();
+	}
+	const options = [...schema.options, {
+		name: "help",
+		flags: "-h, --help",
+		type: "boolean",
+		description: "Show help"
+	}];
+	console.log((0, node_util.styleText)("bold", "Options:"));
+	for (const opt of options) {
+		const flags = (0, node_util.styleText)("cyan", opt.flags.padEnd(30));
+		const defaultPart = opt.default !== void 0 ? (0, node_util.styleText)("dim", ` (default: ${opt.default})`) : "";
+		console.log(`  ${flags}${opt.description}${defaultPart}`);
+	}
+	console.log();
+}
+function buildParseOptions(def) {
+	const result = { help: {
+		type: "boolean",
+		short: "h"
+	} };
+	for (const [name, opt] of Object.entries(def.options ?? {})) result[name] = {
+		type: opt.type,
+		...opt.short ? { short: opt.short } : {},
+		...opt.default !== void 0 ? { default: opt.default } : {}
+	};
+	return result;
+}
+async function runCommand(def, argv, parentName) {
+	const parseOptions = buildParseOptions(def);
+	let parsed;
+	try {
+		const result = (0, node_util.parseArgs)({
+			args: argv,
+			options: parseOptions,
+			allowPositionals: true,
+			strict: false
+		});
+		parsed = {
+			values: result.values,
+			positionals: result.positionals
+		};
+	} catch {
+		renderHelp(def, parentName);
+		process.exit(1);
+	}
+	if (parsed.values["help"]) {
+		renderHelp(def, parentName);
+		process.exit(0);
+	}
+	for (const [name, opt] of Object.entries(def.options ?? {})) if (opt.required && parsed.values[name] === void 0) {
+		console.error((0, node_util.styleText)("red", `Error: --${name} is required`));
+		renderHelp(def, parentName);
+		process.exit(1);
+	}
+	if (!def.run) {
+		renderHelp(def, parentName);
+		process.exit(0);
+	}
+	try {
+		await def.run(parsed);
+	} catch (err) {
+		console.error((0, node_util.styleText)("red", `Error: ${err instanceof Error ? err.message : String(err)}`));
+		renderHelp(def, parentName);
+		process.exit(1);
+	}
+}
+function printRootHelp(programName, version, defs) {
+	console.log(`\n${(0, node_util.styleText)("bold", "Usage:")} ${programName} <command> [options]\n`);
+	console.log(`  Kubb generation — v${version}\n`);
+	console.log((0, node_util.styleText)("bold", "Commands:"));
+	for (const def of defs) console.log(`  ${(0, node_util.styleText)("cyan", def.name.padEnd(16))}${def.description}`);
+	console.log();
+	console.log((0, node_util.styleText)("bold", "Options:"));
+	console.log(`  ${(0, node_util.styleText)("cyan", "-v, --version".padEnd(30))}Show version number`);
+	console.log(`  ${(0, node_util.styleText)("cyan", "-h, --help".padEnd(30))}Show help`);
+	console.log();
+	console.log(`Run ${(0, node_util.styleText)("cyan", `${programName} <command> --help`)} for command-specific help.\n`);
+}
+defineCLIAdapter({
+	renderHelp(def, parentName) {
+		renderHelp(def, parentName);
+	},
+	async run(defs, argv, opts) {
+		const { programName, defaultCommandName, version } = opts;
+		const args = argv.length >= 2 && argv[0]?.includes("node") ? argv.slice(2) : argv;
+		if (args[0] === "--version" || args[0] === "-v") {
+			console.log(version);
+			process.exit(0);
+		}
+		if (args[0] === "--help" || args[0] === "-h") {
+			printRootHelp(programName, version, defs);
+			process.exit(0);
+		}
+		if (args.length === 0) {
+			const defaultDef = defs.find((d) => d.name === defaultCommandName);
+			if (defaultDef?.run) await runCommand(defaultDef, [], programName);
+			else printRootHelp(programName, version, defs);
+			return;
+		}
+		const [first, ...rest] = args;
+		const isKnownSubcommand = defs.some((d) => d.name === first);
+		let def;
+		let commandArgv;
+		let parentName;
+		if (isKnownSubcommand) {
+			def = defs.find((d) => d.name === first);
+			commandArgv = rest;
+			parentName = programName;
+		} else {
+			def = defs.find((d) => d.name === defaultCommandName);
+			commandArgv = args;
+			parentName = programName;
+		}
+		if (!def) {
+			console.error(`Unknown command: ${first}`);
+			printRootHelp(programName, version, defs);
+			process.exit(1);
+		}
+		if (def.subCommands?.length) {
+			const [subName, ...subRest] = commandArgv;
+			const subDef = def.subCommands.find((s) => s.name === subName);
+			if (subName === "--help" || subName === "-h") {
+				renderHelp(def, parentName);
+				process.exit(0);
+			}
+			if (!subDef) {
+				renderHelp(def, parentName);
+				process.exit(subName ? 1 : 0);
+			}
+			await runCommand(subDef, subRest, `${parentName} ${def.name}`);
+			return;
+		}
+		await runCommand(def, commandArgv, parentName);
+	}
+});
+/**
+* Calculates elapsed time in milliseconds from a high-resolution start time.
+* Rounds to 2 decimal places to provide sub-millisecond precision without noise.
+*/
+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 = node_path.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 (0, node_fs_promises.access)(path).then(() => true, () => false);
+}
+/**
+* Reads the file at `path` as a UTF-8 string.
+* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
+*/
+async function read(path) {
+	if (typeof Bun !== "undefined") return Bun.file(path).text();
+	return (0, node_fs_promises.readFile)(path, { encoding: "utf8" });
+}
+/** Synchronous counterpart of `read`. */
+function readSync(path) {
+	return (0, node_fs.readFileSync)(path, { encoding: "utf8" });
+}
+/**
+* Writes `data` to `path`, trimming leading/trailing whitespace before saving.
+* Skips the write and returns `undefined` when the trimmed content is empty or
+* identical to what is already on disk.
+* Creates any missing parent directories automatically.
+* When `sanity` is `true`, re-reads the file after writing and throws if the
+* content does not match — useful for catching write failures on unreliable file systems.
+*/
+async function write(path, data, options = {}) {
+	const trimmed = data.trim();
+	if (trimmed === "") return void 0;
+	const resolved = (0, node_path.resolve)(path);
+	if (typeof Bun !== "undefined") {
+		const file = Bun.file(resolved);
+		if ((await file.exists() ? await file.text() : null) === trimmed) return void 0;
+		await Bun.write(resolved, trimmed);
+		return trimmed;
+	}
+	try {
+		if (await (0, node_fs_promises.readFile)(resolved, { encoding: "utf-8" }) === trimmed) return void 0;
+	} catch {}
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(resolved), { recursive: true });
+	await (0, node_fs_promises.writeFile)(resolved, trimmed, { encoding: "utf-8" });
+	if (options.sanity) {
+		const savedData = await (0, node_fs_promises.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 (0, node_fs_promises.rm)(path, {
+		recursive: true,
+		force: true
+	});
+}
+/**
+* Registers `originalName` in `data` without altering the returned name.
+* Use this when you need to track usage frequency but always emit the original identifier.
+*/
+function setUniqueName(originalName, data) {
+	let used = data[originalName] || 0;
+	if (used) {
+		data[originalName] = ++used;
+		return originalName;
+	}
+	data[originalName] = 1;
+	return originalName;
+}
+/**
+* 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
@@ -69,9 +684,638 @@ function defineConfig(config) {
 function isInputPath(config) {
 	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
 }
+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 ../../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 node_path.default.extname(fileOrFolder) ? "single" : "split";
+}
+var PluginManager = class {
+	config;
+	options;
+	#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 baseContext = {
+			fabric: this.options.fabric,
+			config: this.config,
+			plugin,
+			events: this.options.events,
+			pluginManager: this,
+			mode: getMode(node_path.default.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);
+			}
+		};
+		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 = node_path.default.resolve(this.config.root, this.config.output.path);
+		const defaultPath = node_path.default.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, node_perf_hooks.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) ?? node_perf_hooks.performance.now();
+					this.events.emit("error", result.reason, {
+						plugin,
+						hookName,
+						strategy: "hookParallel",
+						duration: Math.round(node_perf_hooks.performance.now() - startTime),
+						parameters
+					});
+				}
+			}
+		});
+		this.events.emit("plugins:hook:progress:end", { hookName });
+		return results.reduce((acc, result) => {
+			if (result.status === "fulfilled") acc.push(result.value);
+			return acc;
+		}, []);
+	}
+	/**
+	* Chains plugins
+	*/
+	async hookSeq({ hookName, parameters }) {
+		const plugins = this.#getSortedPlugins(hookName);
+		this.events.emit("plugins:hook:progress:start", {
+			hookName,
+			plugins
+		});
+		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(node_perf_hooks.performance.now() - startTime),
+			parameters,
+			output,
+			strategy,
+			hookName,
+			plugin
+		});
+	}
+	#execute({ strategy, hookName, parameters, plugin }) {
+		const hook = plugin[hookName];
+		if (!hook) return null;
+		this.events.emit("plugins:hook:processing:start", {
+			strategy,
+			hookName,
+			parameters,
+			plugin
+		});
+		const startTime = node_perf_hooks.performance.now();
+		return (async () => {
+			try {
+				const output = typeof hook === "function" ? await Promise.resolve(hook.apply(this.getContext(plugin), parameters ?? [])) : hook;
+				this.#emitProcessingEnd({
+					startTime,
+					output,
+					strategy,
+					hookName,
+					plugin,
+					parameters
+				});
+				return output;
+			} catch (error) {
+				this.events.emit("error", error, {
+					plugin,
+					hookName,
+					strategy,
+					duration: Math.round(node_perf_hooks.performance.now() - startTime)
+				});
+				return null;
+			}
+		})();
+	}
+	/**
+	* Run a sync plugin hook and return the result.
+	* @param hookName Name of the plugin hook. Must be in `PluginHooks`.
+	* @param args Arguments passed to the plugin hook.
+	* @param plugin The actual plugin
+	*/
+	#executeSync({ strategy, hookName, parameters, plugin }) {
+		const hook = plugin[hookName];
+		if (!hook) return null;
+		this.events.emit("plugins:hook:processing:start", {
+			strategy,
+			hookName,
+			parameters,
+			plugin
+		});
+		const startTime = node_perf_hooks.performance.now();
+		try {
+			const output = typeof hook === "function" ? hook.apply(this.getContext(plugin), parameters) : hook;
+			this.#emitProcessingEnd({
+				startTime,
+				output,
+				strategy,
+				hookName,
+				plugin,
+				parameters
+			});
+			return output;
+		} catch (error) {
+			this.events.emit("error", error, {
+				plugin,
+				hookName,
+				strategy,
+				duration: Math.round(node_perf_hooks.performance.now() - startTime)
+			});
+			return null;
+		}
+	}
+	#parse(plugin) {
+		const usedPluginNames = this.#usedPluginNames;
+		setUniqueName(plugin.name, usedPluginNames);
+		const usageCount = usedPluginNames[plugin.name];
+		if (usageCount && usageCount > 1) 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 package.json
-var version = "4.32.4";
+var version = "4.33.1";
 //#endregion
 //#region src/utils/diagnostics.ts
 /**
@@ -89,7 +1333,7 @@ function getDiagnosticInfo() {
 //#endregion
 //#region src/build.ts
 async function setup(options) {
-	const { config: userConfig, events = new require_packageManager.AsyncEventEmitter() } = 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");
@@ -110,8 +1354,8 @@ async function setup(options) {
 		]
 	});
 	try {
-		if (isInputPath(userConfig) && !new require_packageManager.URLPath(userConfig.input.path).isURL) {
-			await require_fs.exists(userConfig.input.path);
+		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}`]
@@ -129,8 +1373,8 @@ async function setup(options) {
 		output: {
 			write: true,
 			barrelType: "named",
-			extension: { ".ts": ".ts" },
-			defaultBanner: "simple",
+			extension: DEFAULT_EXTENSION,
+			defaultBanner: DEFAULT_BANNER,
 			...userConfig.output
 		},
 		plugins: userConfig.plugins
@@ -140,7 +1384,7 @@ async function setup(options) {
 			date: /* @__PURE__ */ new Date(),
 			logs: ["Cleaning output directories", `  • Output: ${definedConfig.output.path}`]
 		});
-		await require_fs.clean(definedConfig.output.path);
+		await clean(definedConfig.output.path);
 	}
 	const fabric = (0, _kubb_react_fabric.createFabric)();
 	fabric.use(_kubb_react_fabric_plugins.fsPlugin);
@@ -160,7 +1404,7 @@ async function setup(options) {
 			source
 		});
 		if (source) {
-			if (definedConfig.output.write) await require_fs.write(file.path, source, { sanity: false });
+			if (definedConfig.output.write) await write(file.path, source, { sanity: false });
 			sources.set(file.path, source);
 		}
 	});
@@ -182,7 +1426,7 @@ async function setup(options) {
 	return {
 		events,
 		fabric,
-		pluginManager: new require_packageManager.PluginManager(definedConfig, {
+		pluginManager: new PluginManager(definedConfig, {
 			fabric,
 			events,
 			concurrency: 15
@@ -195,7 +1439,7 @@ async function build(options, overrides) {
 	if (error) throw error;
 	if (failedPlugins.size > 0) {
 		const errors = [...failedPlugins].map(({ error }) => error);
-		throw new require_packageManager.BuildError(`Build Error with ${failedPlugins.size} failed plugins`, { errors });
+		throw new BuildError(`Build Error with ${failedPlugins.size} failed plugins`, { errors });
 	}
 	return {
 		failedPlugins,
@@ -225,7 +1469,7 @@ async function safeBuild(options, overrides) {
 					logs: ["Installing plugin...", `  • Plugin Key: [${plugin.key.join(", ")}]`]
 				});
 				await installer(context);
-				const duration = require_packageManager.getElapsedMs(hrStart);
+				const duration = getElapsedMs(hrStart);
 				pluginTimings.set(plugin.name, duration);
 				await events.emit("plugin:end", plugin, {
 					duration,
@@ -233,12 +1477,12 @@ async function safeBuild(options, overrides) {
 				});
 				await events.emit("debug", {
 					date: /* @__PURE__ */ new Date(),
-					logs: [`✓ Plugin installed successfully (${require_packageManager.formatMs(duration)})`]
+					logs: [`✓ Plugin installed successfully (${formatMs(duration)})`]
 				});
 			} catch (caughtError) {
 				const error = caughtError;
 				const errorTimestamp = /* @__PURE__ */ new Date();
-				const duration = require_packageManager.getElapsedMs(hrStart);
+				const duration = getElapsedMs(hrStart);
 				await events.emit("plugin:end", plugin, {
 					duration,
 					success: false,
@@ -261,7 +1505,8 @@ async function safeBuild(options, overrides) {
 			}
 		}
 		if (config.output.barrelType) {
-			const rootPath = (0, node_path.resolve)((0, node_path.resolve)(config.root), config.output.path, "index.ts");
+			const rootPath = (0, node_path.resolve)((0, node_path.resolve)(config.root), config.output.path, BARREL_FILENAME);
+			const rootDir = (0, node_path.dirname)(rootPath);
 			await events.emit("debug", {
 				date: /* @__PURE__ */ new Date(),
 				logs: [
@@ -277,25 +1522,17 @@ async function safeBuild(options, overrides) {
 				date: /* @__PURE__ */ new Date(),
 				logs: [`Found ${barrelFiles.length} indexable files for barrel export`]
 			});
-			const pluginKeyMap = /* @__PURE__ */ new Map();
-			for (const plugin of pluginManager.plugins) pluginKeyMap.set(JSON.stringify(plugin.key), plugin);
+			const existingBarrel = fabric.files.find((f) => f.path === rootPath);
 			const rootFile = {
 				path: rootPath,
-				baseName: "index.ts",
-				exports: barrelFiles.flatMap((file) => {
-					const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly);
-					return file.sources?.map((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;
-						return {
-							name: config.output.barrelType === "all" ? void 0 : [source.name],
-							path: require_fs.getRelativePath(rootPath, file.path),
-							isTypeOnly: config.output.barrelType === "all" ? containsOnlyTypes : source.isTypeOnly
-						};
-					}).filter(Boolean);
-				}).filter(Boolean),
+				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: {}
@@ -328,6 +1565,26 @@ async function safeBuild(options, overrides) {
 		};
 	}
 }
+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
+			}];
+		});
+	});
+}
 //#endregion
 //#region src/defineLogger.ts
 function defineLogger(logger) {
@@ -346,10 +1603,8 @@ function definePlugin(build) {
 var PackageManager = class PackageManager {
 	static #cache = {};
 	#cwd;
-	#SLASHES = new Set(["/", "\\"]);
 	constructor(workspace) {
 		if (workspace) this.#cwd = workspace;
-		return this;
 	}
 	set workspace(workspace) {
 		this.#cwd = workspace;
@@ -359,7 +1614,7 @@ var PackageManager = class PackageManager {
 	}
 	normalizeDirectory(directory) {
 		const lastChar = directory[directory.length - 1];
-		if (lastChar && !this.#SLASHES.has(lastChar)) return `${directory}/`;
+		if (lastChar && !PATH_SEPARATORS.includes(lastChar)) return `${directory}/`;
 		return directory;
 	}
 	getLocation(path) {
@@ -368,26 +1623,21 @@ var PackageManager = class PackageManager {
 		return location;
 	}
 	async import(path) {
-		try {
-			let location = this.getLocation(path);
-			if (node_os.default.platform() === "win32") location = (0, node_url.pathToFileURL)(location).href;
-			const module = await import(location);
-			return module?.default ?? module;
-		} catch (error) {
-			console.error(error);
-			return;
-		}
+		let location = this.getLocation(path);
+		if (node_os.default.platform() === "win32") location = (0, node_url.pathToFileURL)(location).href;
+		const module = await import(location);
+		return module?.default ?? module;
 	}
 	async getPackageJSON() {
 		const pkgPath = empathic_package.up({ cwd: this.#cwd });
 		if (!pkgPath) return;
-		const json = await require_fs.read(pkgPath);
+		const json = await read(pkgPath);
 		return JSON.parse(json);
 	}
 	getPackageJSONSync() {
 		const pkgPath = empathic_package.up({ cwd: this.#cwd });
 		if (!pkgPath) return;
-		const json = require_fs.readSync(pkgPath);
+		const json = readSync(pkgPath);
 		return JSON.parse(json);
 	}
 	static setVersion(dependency, version) {
@@ -395,8 +1645,8 @@ var PackageManager = class PackageManager {
 	}
 	#match(packageJSON, dependency) {
 		const dependencies = {
-			...packageJSON["dependencies"] || {},
-			...packageJSON["devDependencies"] || {}
+			...packageJSON.dependencies || {},
+			...packageJSON.devDependencies || {}
 		};
 		if (typeof dependency === "string" && dependencies[dependency]) return dependencies[dependency];
 		const matchedDependency = Object.keys(dependencies).find((dep) => dep.match(dependency));
@@ -432,30 +1682,393 @@ var PackageManager = class PackageManager {
 	}
 };
 //#endregion
-//#region src/types.ts
-const LogLevel = {
-	silent: Number.NEGATIVE_INFINITY,
-	error: 0,
-	warn: 1,
-	info: 3,
-	verbose: 4,
-	debug: 5
+//#region src/utils/FunctionParams.ts
+/**
+* @deprecated
+*/
+var FunctionParams = class FunctionParams {
+	#items = [];
+	get items() {
+		return this.#items.flat();
+	}
+	add(item) {
+		if (!item) return this;
+		if (Array.isArray(item)) {
+			item.filter((x) => x !== void 0).forEach((it) => {
+				this.#items.push(it);
+			});
+			return this;
+		}
+		this.#items.push(item);
+		return this;
+	}
+	static #orderItems(items) {
+		return (0, remeda.sortBy)(items.filter(Boolean), [(item) => Array.isArray(item), "desc"], [(item) => !Array.isArray(item) && item.default !== void 0, "asc"], [(item) => Array.isArray(item) || (item.required ?? true), "desc"]);
+	}
+	static #addParams(acc, item) {
+		const { enabled = true, name, type, required = true, ...rest } = item;
+		if (!enabled) return acc;
+		if (!name) {
+			acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
+			return acc;
+		}
+		const parameterName = name.startsWith("{") ? name : camelCase(name);
+		if (type) if (required) acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
+		else acc.push(`${parameterName}?: ${type}`);
+		else acc.push(`${parameterName}`);
+		return acc;
+	}
+	static toObject(items) {
+		let type = [];
+		let name = [];
+		const enabled = items.every((item) => item.enabled) ? items.at(0)?.enabled : true;
+		const required = items.every((item) => item.required) ?? true;
+		items.forEach((item) => {
+			name = FunctionParams.#addParams(name, {
+				...item,
+				type: void 0
+			});
+			if (items.some((item) => item.type)) type = FunctionParams.#addParams(type, item);
+		});
+		return {
+			name: `{ ${name.join(", ")} }`,
+			type: type.length ? `{ ${type.join("; ")} }` : void 0,
+			enabled,
+			required
+		};
+	}
+	toObject() {
+		const items = FunctionParams.#orderItems(this.#items).flat();
+		return FunctionParams.toObject(items);
+	}
+	static toString(items) {
+		return FunctionParams.#orderItems(items).reduce((acc, item) => {
+			if (Array.isArray(item)) {
+				if (item.length <= 0) return acc;
+				const subItems = FunctionParams.#orderItems(item);
+				const objectItem = FunctionParams.toObject(subItems);
+				return FunctionParams.#addParams(acc, objectItem);
+			}
+			return FunctionParams.#addParams(acc, item);
+		}, []).join(", ");
+	}
+	toString() {
+		const items = FunctionParams.#orderItems(this.#items);
+		return FunctionParams.toString(items);
+	}
 };
 //#endregion
-exports.BaseGenerator = BaseGenerator;
-exports.LogLevel = LogLevel;
+//#region src/utils/formatters.ts
+/**
+* Check if a formatter command is available in the system.
+*
+* @param formatter - The formatter to check ('biome', 'prettier', or 'oxfmt')
+* @returns Promise that resolves to true if the formatter is available, false otherwise
+*
+* @remarks
+* This function checks availability by running `<formatter> --version` command.
+* All supported formatters (biome, prettier, oxfmt) implement the --version flag.
+*/
+async function isFormatterAvailable(formatter) {
+	try {
+		await (0, tinyexec.x)(formatter, ["--version"], { nodeOptions: { stdio: "ignore" } });
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Detect which formatter is available in the system.
+*
+* @returns Promise that resolves to the first available formatter or undefined if none are found
+*
+* @remarks
+* Checks in order of preference: biome, oxfmt, prettier.
+* Uses the `--version` flag to detect if each formatter command is available.
+* This is a reliable method as all supported formatters implement this flag.
+*
+* @example
+* ```typescript
+* const formatter = await detectFormatter()
+* if (formatter) {
+*   console.log(`Using ${formatter} for formatting`)
+* } else {
+*   console.log('No formatter found')
+* }
+* ```
+*/
+async function detectFormatter() {
+	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 = node_path.default.posix.join(currentPath, part);
+			let existingNode = currentLevel.find((node) => node.name === part);
+			if (!existingNode) {
+				if (index === parts.length - 1) existingNode = {
+					name: part,
+					file,
+					path: currentPath
+				};
+				else existingNode = {
+					name: part,
+					path: currentPath,
+					children: []
+				};
+				currentLevel.push(existingNode);
+			}
+			if (!existingNode.file) currentLevel = existingNode.children;
+		});
+	});
+	return root;
+}
+//#endregion
+//#region src/BarrelManager.ts
+/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
+var BarrelManager = class {
+	getFiles({ files: generatedFiles, root }) {
+		const cachedFiles = /* @__PURE__ */ new Map();
+		TreeNode.build(generatedFiles, root)?.forEach((treeNode) => {
+			if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) return;
+			const barrelFile = {
+				path: (0, node_path.join)(treeNode.parent?.data.path, "index.ts"),
+				baseName: "index.ts",
+				exports: [],
+				imports: [],
+				sources: []
+			};
+			const previousBarrelFile = cachedFiles.get(barrelFile.path);
+			treeNode.leaves.forEach((item) => {
+				if (!item.data.name) return;
+				(item.data.file?.sources || []).forEach((source) => {
+					if (!item.data.file?.path || !source.isIndexable || !source.name) return;
+					if (previousBarrelFile?.sources.some((item) => item.name === source.name && item.isTypeOnly === source.isTypeOnly)) return;
+					barrelFile.exports.push({
+						name: [source.name],
+						path: getRelativePath(treeNode.parent?.data.path, item.data.path),
+						isTypeOnly: source.isTypeOnly
+					});
+					barrelFile.sources.push({
+						name: source.name,
+						isTypeOnly: source.isTypeOnly,
+						value: "",
+						isExportable: false,
+						isIndexable: false
+					});
+				});
+			});
+			if (previousBarrelFile) {
+				previousBarrelFile.sources.push(...barrelFile.sources);
+				previousBarrelFile.exports?.push(...barrelFile.exports || []);
+			} else cachedFiles.set(barrelFile.path, barrelFile);
+		});
+		return [...cachedFiles.values()];
+	}
+};
+//#endregion
+//#region src/utils/getBarrelFiles.ts
+function trimExtName(text) {
+	const dotIndex = text.lastIndexOf(".");
+	if (dotIndex > 0 && !text.includes("/", dotIndex)) return text.slice(0, dotIndex);
+	return text;
+}
+async function getBarrelFiles(files, { type, meta = {}, root, output }) {
+	if (!type || type === "propagate") return [];
+	const barrelManager = new BarrelManager();
+	const pathToBuildFrom = (0, node_path.join)(root, output.path);
+	if (trimExtName(pathToBuildFrom).endsWith("index")) return [];
+	const barrelFiles = barrelManager.getFiles({
+		files,
+		root: pathToBuildFrom,
+		meta
+	});
+	if (type === "all") return barrelFiles.map((file) => {
+		return {
+			...file,
+			exports: file.exports?.map((exportItem) => {
+				return {
+					...exportItem,
+					name: void 0
+				};
+			})
+		};
+	});
+	return barrelFiles.map((indexFile) => {
+		return {
+			...indexFile,
+			meta
+		};
+	});
+}
+//#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 (0, tinyexec.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
+exports.FunctionParams = FunctionParams;
 exports.PackageManager = PackageManager;
-exports.PluginManager = require_packageManager.PluginManager;
-exports.PromiseManager = require_packageManager.PromiseManager;
+exports.PluginManager = PluginManager;
+exports.PromiseManager = PromiseManager;
 exports.build = build;
 exports.default = build;
 exports.defineConfig = defineConfig;
 exports.defineLogger = defineLogger;
 exports.definePlugin = definePlugin;
-exports.detectPackageManager = require_packageManager.detectPackageManager;
-exports.getBarrelFiles = require_packageManager.getBarrelFiles;
-exports.getMode = require_packageManager.getMode;
+exports.detectFormatter = detectFormatter;
+exports.detectLinter = detectLinter;
+exports.formatters = formatters;
+exports.getBarrelFiles = getBarrelFiles;
+exports.getConfigs = getConfigs;
+exports.getMode = getMode;
 exports.isInputPath = isInputPath;
+exports.linters = linters;
+exports.logLevel = logLevel;
 exports.safeBuild = safeBuild;
 exports.setup = setup;