@kubb/cli 5.0.0-alpha.5 → 5.0.0-alpha.50

package/dist/{generate-CtFkZeTU.js → generate-CQPHU8Xt.js}

@@ -1,30 +1,38 @@
 import "./chunk--u3MIqq1.js";
-import { n as toCause, r as toError } from "./errors-6mF_WKxg.js";
-import { a as canUseTTY, i as executeIfOnline, o as isGitHubActions, r as sendTelemetry, t as buildTelemetryEvent } from "./telemetry-DxiR7clS.js";
-import { n as tokenize } from "./shell-DqqWsHCD.js";
-import { t as version } from "./package-DxH_MEG4.js";
-import { i as WATCHER_IGNORED_PATHS, r as SUMMARY_SEPARATOR, t as KUBB_NPM_PACKAGE_URL } from "./constants-CM3dJzjK.js";
+import { n as toCause, r as toError } from "./errors-CjPmyZHy.js";
+import { a as canUseTTY, i as executeIfOnline, o as isGitHubActions, r as sendTelemetry, t as buildTelemetryEvent } from "./telemetry-Dis5nWR_.js";
+import { n as tokenize } from "./shell-DLzN4fRo.js";
+import { t as version } from "./package-BRmZkKt7.js";
+import { a as SUMMARY_SEPARATOR, n as KUBB_NPM_PACKAGE_URL, o as WATCHER_IGNORED_PATHS } from "./constants-T_2rsi7T.js";
 import { styleText } from "node:util";
 import { EventEmitter } from "node:events";
 import { createHash } from "node:crypto";
-import "node:fs";
+import { spawn } from "node:child_process";
+import { readdirSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path, { dirname, relative, resolve } from "node:path";
 import process$1 from "node:process";
 import * as clack from "@clack/prompts";
-import { PromiseManager, defineLogger, detectFormatter, detectLinter, formatters, getConfigs, isInputPath, linters, logLevel, safeBuild, setup } from "@kubb/core";
+import { createKubb, defineLogger, isInputPath, logLevel } from "@kubb/core";
 import { NonZeroExitError, x } from "tinyexec";
 import { Writable } from "node:stream";
 import { cosmiconfig } from "cosmiconfig";
 import { createJiti } from "jiti";
 //#region ../../internals/utils/src/asyncEventEmitter.ts
 /**
-* A typed EventEmitter that awaits all async listeners before resolving.
+* Typed `EventEmitter` that awaits all async listeners before resolving.
 * Wraps Node's `EventEmitter` with full TypeScript event-map inference.
+*
+* @example
+* ```ts
+* const emitter = new AsyncEventEmitter<{ build: [name: string] }>()
+* emitter.on('build', async (name) => { console.log(name) })
+* await emitter.emit('build', 'petstore') // all listeners awaited
+* ```
 */
 var AsyncEventEmitter = class {
 	/**
-	* `maxListener` controls the maximum number of listeners per event before Node emits a memory-leak warning.
+	* Maximum number of listeners per event before Node emits a memory-leak warning.
 	* @default 10
 	*/
 	constructor(maxListener = 10) {
@@ -32,31 +40,48 @@ var AsyncEventEmitter = class {
 	}
 	#emitter = new EventEmitter();
 	/**
-	* Emits an event and awaits all registered listeners in parallel.
+	* Emits `eventName` and awaits all registered listeners sequentially.
 	* Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
+	*
+	* @example
+	* ```ts
+	* await emitter.emit('build', 'petstore')
+	* ```
 	*/
 	async emit(eventName, ...eventArgs) {
 		const listeners = this.#emitter.listeners(eventName);
 		if (listeners.length === 0) return;
-		await Promise.all(listeners.map(async (listener) => {
+		for (const listener of listeners) try {
+			await listener(...eventArgs);
+		} catch (err) {
+			let serializedArgs;
 			try {
-				return await listener(...eventArgs);
-			} catch (err) {
-				let serializedArgs;
-				try {
-					serializedArgs = JSON.stringify(eventArgs);
-				} catch {
-					serializedArgs = String(eventArgs);
-				}
-				throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
+				serializedArgs = JSON.stringify(eventArgs);
+			} catch {
+				serializedArgs = String(eventArgs);
 			}
-		}));
+			throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
+		}
 	}
-	/** Registers a persistent listener for the given event. */
+	/**
+	* Registers a persistent listener for `eventName`.
+	*
+	* @example
+	* ```ts
+	* emitter.on('build', async (name) => { console.log(name) })
+	* ```
+	*/
 	on(eventName, handler) {
 		this.#emitter.on(eventName, handler);
 	}
-	/** Registers a one-shot listener that removes itself after the first invocation. */
+	/**
+	* Registers a one-shot listener that removes itself after the first invocation.
+	*
+	* @example
+	* ```ts
+	* emitter.onOnce('build', async (name) => { console.log(name) })
+	* ```
+	*/
 	onOnce(eventName, handler) {
 		const wrapper = (...args) => {
 			this.off(eventName, wrapper);
@@ -64,11 +89,37 @@ var AsyncEventEmitter = class {
 		};
 		this.on(eventName, wrapper);
 	}
-	/** Removes a previously registered listener. */
+	/**
+	* Removes a previously registered listener.
+	*
+	* @example
+	* ```ts
+	* emitter.off('build', handler)
+	* ```
+	*/
 	off(eventName, handler) {
 		this.#emitter.off(eventName, handler);
 	}
-	/** Removes all listeners from every event channel. */
+	/**
+	* Returns the number of listeners registered for `eventName`.
+	*
+	* @example
+	* ```ts
+	* emitter.on('build', handler)
+	* emitter.listenerCount('build') // 1
+	* ```
+	*/
+	listenerCount(eventName) {
+		return this.#emitter.listenerCount(eventName);
+	}
+	/**
+	* Removes all listeners from every event channel.
+	*
+	* @example
+	* ```ts
+	* emitter.removeAll()
+	* ```
+	*/
 	removeAll() {
 		this.#emitter.removeAllListeners();
 	}
@@ -76,8 +127,15 @@ var AsyncEventEmitter = class {
 //#endregion
 //#region ../../internals/utils/src/time.ts
 /**
-* Calculates elapsed time in milliseconds from a high-resolution start time.
-* Rounds to 2 decimal places to provide sub-millisecond precision without noise.
+* Calculates elapsed time in milliseconds from a high-resolution `process.hrtime` start time.
+* Rounds to 2 decimal places for sub-millisecond precision without noise.
+*
+* @example
+* ```ts
+* const start = process.hrtime()
+* doWork()
+* getElapsedMs(start) // 42.35
+* ```
 */
 function getElapsedMs(hrStart) {
 	const [seconds, nanoseconds] = process.hrtime(hrStart);
@@ -85,8 +143,14 @@ function getElapsedMs(hrStart) {
 	return Math.round(ms * 100) / 100;
 }
 /**
-* Converts a millisecond duration into a human-readable string.
-* Adjusts units (ms, s, m s) based on the magnitude of the duration.
+* Converts a millisecond duration into a human-readable string (`ms`, `s`, or `m s`).
+*
+* @example
+* ```ts
+* formatMs(250)   // '250ms'
+* formatMs(1500)  // '1.50s'
+* formatMs(90000) // '1m 30.0s'
+* ```
 */
 function formatMs(ms) {
 	if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
@@ -94,7 +158,14 @@ function formatMs(ms) {
 	return `${Math.round(ms)}ms`;
 }
 /**
-* Convenience helper: formats the elapsed time since `hrStart` in one step.
+* Formats the elapsed time since `hrStart` as a human-readable string.
+*
+* @example
+* ```ts
+* const start = process.hrtime()
+* doWork()
+* formatHrtime(start) // '1.50s'
+* ```
 */
 function formatHrtime(hrStart) {
 	return formatMs(getElapsedMs(hrStart));
@@ -136,7 +207,9 @@ function gradient(colorStops, text) {
 		return `\x1b[38;2;${Math.round(from.r + (to.r - from.r) * lt)};${Math.round(from.g + (to.g - from.g) * lt)};${Math.round(from.b + (to.b - from.b) * lt)}m${char}\x1b[0m`;
 	}).join("");
 }
-/** ANSI color functions for each part of the Kubb mascot illustration. */
+/**
+* ANSI color functions for each part of the Kubb mascot illustration.
+*/
 const palette = {
 	lid: hex("#F55A17"),
 	woodTop: hex("#F5A217"),
@@ -147,7 +220,12 @@ const palette = {
 	blush: hex("#FDA4AF")
 };
 /**
-* Generates the Kubb mascot welcome banner.
+* Generates the Kubb mascot welcome banner as an ANSI-colored string.
+*
+* @example
+* ```ts
+* console.log(getIntro({ title: 'kubb.config.ts', description: 'generating…', version: '5.0.0', areEyesOpen: true }))
+* ```
 */
 function getIntro({ title, description, version, areEyesOpen }) {
 	const kubbVersion = gradient([
@@ -165,7 +243,13 @@ function getIntro({ title, description, version, areEyesOpen }) {
    ${palette.woodBase("▀▀▀▀▀▀▀▀▀▀▀▀▀")}
 `;
 }
-/** ANSI color names available for terminal output. */
+/** ANSI color names available for deterministic terminal coloring.
+*
+* @example
+* ```ts
+* const color = randomColors[2] // 'green'
+* ```
+*/
 const randomColors = [
 	"black",
 	"red",
@@ -178,15 +262,27 @@ const randomColors = [
 	"gray"
 ];
 /**
-* Returns the text wrapped in a deterministic ANSI color derived from the text's SHA-256 hash.
+* Wraps `text` in a deterministic ANSI color derived from the text's SHA-256 hash.
+*
+* @example
+* ```ts
+* randomCliColor('petstore') // '\x1b[33m' + 'petstore' + '\x1b[39m' (always the same color for 'petstore')
+* ```
 */
 function randomCliColor(text) {
 	if (!text) return "";
 	return styleText(randomColors[createHash("sha256").update(text).digest().readUInt32BE(0) % randomColors.length] ?? "white", text);
 }
 /**
-* Formats a millisecond duration with an ANSI color based on thresholds:
-* green ≤ 500 ms · yellow ≤ 1 000 ms · red > 1 000 ms
+* Formats a millisecond duration with a threshold-based ANSI color.
+* `≤ 500 ms` → green · `≤ 1 000 ms` → yellow · `> 1 000 ms` → red.
+*
+* @example
+* ```ts
+* formatMsWithColor(200)  // '\x1b[32m200ms\x1b[39m'
+* formatMsWithColor(800)  // '\x1b[33m800ms\x1b[39m'
+* formatMsWithColor(1500) // '\x1b[31m1.50s\x1b[39m'
+* ```
 */
 function formatMsWithColor(ms) {
 	const formatted = formatMs(ms);
@@ -195,27 +291,96 @@ function formatMsWithColor(ms) {
 	return styleText("red", formatted);
 }
 //#endregion
+//#region ../../internals/utils/src/formatters.ts
+/**
+* CLI command descriptors for each supported code formatter.
+*
+* Each entry contains the executable `command`, an `args` factory that maps an
+* output path to the correct argument list, and an `errorMessage` shown when
+* the formatter is not found.
+*/
+const formatters = {
+	prettier: {
+		command: "prettier",
+		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"
+	}
+};
+async function isFormatterAvailable(formatter) {
+	return new Promise((resolve) => {
+		const child = spawn(formatter, ["--version"], { stdio: "ignore" });
+		child.on("close", (code) => resolve(code === 0));
+		child.on("error", () => resolve(false));
+	});
+}
+/**
+* Detects the first available code formatter on the current system.
+*
+* - Checks in preference order: `oxfmt`, `biome`, `prettier`.
+* - Returns `null` when none are found.
+*
+* @example
+* ```ts
+* const formatter = await detectFormatter()
+* if (formatter) {
+*   console.log(`Using ${formatter} for formatting`)
+* }
+* ```
+*/
+async function detectFormatter() {
+	const formatterNames = new Set([
+		"oxfmt",
+		"biome",
+		"prettier"
+	]);
+	for (const formatter of formatterNames) if (await isFormatterAvailable(formatter)) return formatter;
+	return null;
+}
+//#endregion
 //#region ../../internals/utils/src/fs.ts
 /**
 * Writes `data` to `path`, trimming leading/trailing whitespace before saving.
-* Skips the write and returns `undefined` when the trimmed content is empty or
-* identical to what is already on disk.
+* Skips the write when the trimmed content is empty or identical to what is already on disk.
 * Creates any missing parent directories automatically.
-* When `sanity` is `true`, re-reads the file after writing and throws if the
-* content does not match.
+* When `sanity` is `true`, re-reads the file after writing and throws if the content does not match.
+*
+* @example
+* ```ts
+* await write('./src/Pet.ts', source)         // writes and returns trimmed content
+* await write('./src/Pet.ts', source)         // null — file unchanged
+* await write('./src/Pet.ts', '  ')           // null — empty content skipped
+* ```
 */
 async function write(path, data, options = {}) {
 	const trimmed = data.trim();
-	if (trimmed === "") return void 0;
+	if (trimmed === "") return null;
 	const resolved = resolve(path);
 	if (typeof Bun !== "undefined") {
 		const file = Bun.file(resolved);
-		if ((await file.exists() ? await file.text() : null) === trimmed) return void 0;
+		if ((await file.exists() ? await file.text() : null) === trimmed) return null;
 		await Bun.write(resolved, trimmed);
 		return trimmed;
 	}
 	try {
-		if (await readFile(resolved, { encoding: "utf-8" }) === trimmed) return void 0;
+		if (await readFile(resolved, { encoding: "utf-8" }) === trimmed) return null;
 	} catch {}
 	await mkdir(dirname(resolved), { recursive: true });
 	await writeFile(resolved, trimmed, { encoding: "utf-8" });
@@ -227,6 +392,83 @@ async function write(path, data, options = {}) {
 	return trimmed;
 }
 //#endregion
+//#region ../../internals/utils/src/linters.ts
+/**
+* Collects all files under `dir` recursively using Node's built-in fs APIs.
+*
+* Passing explicit file paths to oxlint (instead of a directory) bypasses
+* oxlint's `.gitignore`-aware directory traversal, which would otherwise skip
+* files that are listed in `.gitignore` (e.g. generated output directories).
+*/
+function findLintableFiles(dir) {
+	try {
+		return readdirSync(dir, {
+			withFileTypes: true,
+			recursive: true
+		}).filter((d) => d.isFile()).map((d) => `${d.parentPath}/${d.name}`);
+	} catch {
+		return [];
+	}
+}
+/**
+* CLI command descriptors for each supported linter.
+*
+* Each entry contains the executable `command`, an `args` factory that maps an
+* output path to the correct argument list, and an `errorMessage` shown when
+* the linter is not found.
+*/
+const linters = {
+	eslint: {
+		command: "eslint",
+		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", ...findLintableFiles(outputPath)],
+		errorMessage: "Oxlint not found"
+	}
+};
+async function isLinterAvailable(linter) {
+	return new Promise((resolve) => {
+		const child = spawn(linter, ["--version"], { stdio: "ignore" });
+		child.on("close", (code) => resolve(code === 0));
+		child.on("error", () => resolve(false));
+	});
+}
+/**
+* Detects the first available linter on the current system.
+*
+* - Checks in preference order: `oxlint`, `biome`, `eslint`.
+* - Returns `null` when none are found.
+*
+* @example
+* ```ts
+* const linter = await detectLinter()
+* if (linter) {
+*   console.log(`Using ${linter} for linting`)
+* }
+* ```
+*/
+async function detectLinter() {
+	const linterNames = new Set([
+		"oxlint",
+		"biome",
+		"eslint"
+	]);
+	for (const linter of linterNames) if (await isLinterAvailable(linter)) return linter;
+	return null;
+}
+//#endregion
 //#region src/utils/getSummary.ts
 function getSummary({ failedPlugins, filesCreated, status, hrStart, config, pluginTimings }) {
 	const duration = formatHrtime(hrStart);
@@ -237,7 +479,7 @@ function getSummary({ failedPlugins, filesCreated, status, hrStart, config, plug
 		pluginsFailed: status === "failed" ? [...failedPlugins].map(({ plugin }) => randomCliColor(plugin.name)).join(", ") : void 0,
 		filesCreated,
 		time: styleText("green", duration),
-		output: path.isAbsolute(config.root) ? path.resolve(config.root, config.output.path) : config.root
+		output: path.resolve(config.root, config.output.path)
 	};
 	const labels = {
 		plugins: "Plugins:",
@@ -279,11 +521,11 @@ async function runHook({ id, command, args, commandWithArgs, context, stream = f
 		});
 		if (stream && sink?.onLine) for await (const line of proc) sink.onLine(line);
 		const result = await proc;
-		await context.emit("debug", {
+		await context.emit("kubb:debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: [result.stdout.trimEnd()]
 		});
-		await context.emit("hook:end", {
+		await context.emit("kubb:hook:end", {
 			command,
 			args,
 			id,
@@ -292,33 +534,33 @@ async function runHook({ id, command, args, commandWithArgs, context, stream = f
 		});
 	} catch (err) {
 		if (!(err instanceof NonZeroExitError)) {
-			await context.emit("hook:end", {
+			await context.emit("kubb:hook:end", {
 				command,
 				args,
 				id,
 				success: false,
 				error: toError(err)
 			});
-			await context.emit("error", toError(err));
+			await context.emit("kubb:error", toError(err));
 			return;
 		}
 		const stderr = err.output?.stderr ?? "";
 		const stdout = err.output?.stdout ?? "";
-		await context.emit("debug", {
+		await context.emit("kubb:debug", {
 			date: /* @__PURE__ */ new Date(),
 			logs: [stdout, stderr].filter(Boolean)
 		});
 		if (stderr) sink?.onStderr?.(stderr);
 		if (stdout) sink?.onStdout?.(stdout);
 		const errorMessage = /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`);
-		await context.emit("hook:end", {
+		await context.emit("kubb:hook:end", {
 			command,
 			args,
 			id,
 			success: false,
 			error: errorMessage
 		});
-		await context.emit("error", errorMessage);
+		await context.emit("kubb:error", errorMessage);
 	}
 }
 //#endregion
@@ -386,7 +628,7 @@ const clackLogger = defineLogger({
 			state.spinner.stop(text);
 			state.isSpinning = false;
 		}
-		context.on("info", (message, info = "") => {
+		context.on("kubb:info", (message, info = "") => {
 			if (logLevel$8 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("blue", "ℹ"),
@@ -396,7 +638,7 @@ const clackLogger = defineLogger({
 			if (state.isSpinning) state.spinner.message(text);
 			else clack.log.info(text);
 		});
-		context.on("success", (message, info = "") => {
+		context.on("kubb:success", (message, info = "") => {
 			if (logLevel$8 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("blue", "✓"),
@@ -406,7 +648,7 @@ const clackLogger = defineLogger({
 			if (state.isSpinning) stopSpinner(text);
 			else clack.log.success(text);
 		});
-		context.on("warn", (message, info) => {
+		context.on("kubb:warn", (message, info) => {
 			if (logLevel$8 < logLevel.warn) return;
 			const text = getMessage([
 				styleText("yellow", "⚠"),
@@ -415,7 +657,7 @@ const clackLogger = defineLogger({
 			].filter(Boolean).join(" "));
 			clack.log.warn(text);
 		});
-		context.on("error", (error) => {
+		context.on("kubb:error", (error) => {
 			const caused = toCause(error);
 			const text = [styleText("red", "✗"), error.message].join(" ");
 			if (state.isSpinning) stopSpinner(getMessage(text));
@@ -430,19 +672,24 @@ const clackLogger = defineLogger({
 				}
 			}
 		});
-		context.on("version:new", (version, latestVersion) => {
+		context.on("kubb:version:new", (version, latestVersion) => {
 			if (logLevel$8 <= logLevel.silent) return;
-			clack.box(`\`v${version}\` → \`v${latestVersion}\`
+			try {
+				clack.box(`\`v${version}\` → \`v${latestVersion}\`
 Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
-				width: "auto",
-				formatBorder: (s) => styleText("yellow", s),
-				rounded: true,
-				withGuide: false,
-				contentAlign: "center",
-				titleAlign: "center"
-			});
+					width: "auto",
+					formatBorder: (s) => styleText("yellow", s),
+					rounded: true,
+					withGuide: false,
+					contentAlign: "center",
+					titleAlign: "center"
+				});
+			} catch {
+				console.log(`Update available for Kubb: v${version} → v${latestVersion}`);
+				console.log("Run `npm install -g @kubb/cli` to update");
+			}
 		});
-		context.on("lifecycle:start", async (version) => {
+		context.on("kubb:lifecycle:start", async (version) => {
 			console.log(`\n${getIntro({
 				title: "The ultimate toolkit for working with APIs",
 				description: "Ready to start",
@@ -451,24 +698,24 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			})}\n`);
 			reset();
 		});
-		context.on("config:start", () => {
+		context.on("kubb:config:start", () => {
 			if (logLevel$8 <= logLevel.silent) return;
 			const text = getMessage("Configuration started");
 			clack.intro(text);
 			startSpinner(getMessage("Configuration loading"));
 		});
-		context.on("config:end", (_configs) => {
+		context.on("kubb:config:end", (_configs) => {
 			if (logLevel$8 <= logLevel.silent) return;
 			const text = getMessage("Configuration completed");
 			clack.outro(text);
 		});
-		context.on("generation:start", (config) => {
+		context.on("kubb:generation:start", (config) => {
 			reset();
 			state.totalPlugins = config.plugins?.length ?? 0;
 			const text = getMessage(["Generation started", config.name ? `for ${styleText("dim", config.name)}` : void 0].filter(Boolean).join(" "));
 			clack.intro(text);
 		});
-		context.on("plugin:start", (plugin) => {
+		context.on("kubb:plugin:start", (plugin) => {
 			if (logLevel$8 <= logLevel.silent) return;
 			stopSpinner();
 			const progressBar = clack.progress({
@@ -486,7 +733,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				interval
 			});
 		});
-		context.on("plugin:end", (plugin, { duration, success }) => {
+		context.on("kubb:plugin:end", (plugin, { duration, success }) => {
 			stopSpinner();
 			const active = state.activeProgress.get(plugin.name);
 			if (!active || logLevel$8 === logLevel.silent) return;
@@ -499,7 +746,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			state.activeProgress.delete(plugin.name);
 			showProgressStep();
 		});
-		context.on("files:processing:start", (files) => {
+		context.on("kubb:files:processing:start", (files) => {
 			if (logLevel$8 <= logLevel.silent) return;
 			stopSpinner();
 			state.totalFiles = files.length;
@@ -510,11 +757,11 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				max: files.length,
 				size: 30
 			});
-			context.emit("info", text);
+			context.emit("kubb:info", text);
 			progressBar.start(getMessage(text));
 			state.activeProgress.set("files", { progressBar });
 		});
-		context.on("file:processing:update", ({ file, config }) => {
+		context.on("kubb:file:processing:update", ({ file, config }) => {
 			if (logLevel$8 <= logLevel.silent) return;
 			stopSpinner();
 			state.processedFiles++;
@@ -523,7 +770,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			if (!active) return;
 			active.progressBar.advance(void 0, text);
 		});
-		context.on("files:processing:end", () => {
+		context.on("kubb:files:processing:end", () => {
 			if (logLevel$8 <= logLevel.silent) return;
 			stopSpinner();
 			const text = getMessage("Files written successfully");
@@ -533,31 +780,31 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			state.activeProgress.delete("files");
 			showProgressStep();
 		});
-		context.on("generation:end", (config) => {
+		context.on("kubb:generation:end", (config) => {
 			const text = getMessage(config.name ? `Generation completed for ${styleText("dim", config.name)}` : "Generation completed");
 			clack.outro(text);
 		});
-		context.on("format:start", () => {
+		context.on("kubb:format:start", () => {
 			if (logLevel$8 <= logLevel.silent) return;
 			const text = getMessage("Format started");
 			clack.intro(text);
 		});
-		context.on("format:end", () => {
+		context.on("kubb:format:end", () => {
 			if (logLevel$8 <= logLevel.silent) return;
 			const text = getMessage("Format completed");
 			clack.outro(text);
 		});
-		context.on("lint:start", () => {
+		context.on("kubb:lint:start", () => {
 			if (logLevel$8 <= logLevel.silent) return;
 			const text = getMessage("Lint started");
 			clack.intro(text);
 		});
-		context.on("lint:end", () => {
+		context.on("kubb:lint:end", () => {
 			if (logLevel$8 <= logLevel.silent) return;
 			const text = getMessage("Lint completed");
 			clack.outro(text);
 		});
-		context.on("hook:start", async ({ id, command, args }) => {
+		context.on("kubb:hook:start", async ({ id, command, args }) => {
 			const commandWithArgs = formatCommandWithArgs(command, args);
 			const text = getMessage(`Hook ${styleText("dim", commandWithArgs)} started`);
 			if (!id) return;
@@ -592,12 +839,12 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				}
 			});
 		});
-		context.on("hook:end", ({ command, args }) => {
+		context.on("kubb:hook:end", ({ command, args }) => {
 			if (logLevel$8 <= logLevel.silent) return;
 			const text = getMessage(`Hook ${styleText("dim", formatCommandWithArgs(command, args))} successfully executed`);
 			clack.outro(text);
 		});
-		context.on("generation:summary", (config, { pluginTimings, failedPlugins, filesCreated, status, hrStart }) => {
+		context.on("kubb:generation:summary", (config, { pluginTimings, failedPlugins, filesCreated, status, hrStart }) => {
 			const summary = getSummary({
 				failedPlugins,
 				filesCreated,
@@ -610,16 +857,20 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			summary.unshift("\n");
 			summary.push("\n");
 			const borderColor = status === "success" ? "green" : "red";
-			clack.box(summary.join("\n"), getMessage(title), {
-				width: "auto",
-				formatBorder: (s) => styleText(borderColor, s),
-				rounded: true,
-				withGuide: false,
-				contentAlign: "left",
-				titleAlign: "center"
-			});
+			try {
+				clack.box(summary.join("\n"), getMessage(title), {
+					width: "auto",
+					formatBorder: (s) => styleText(borderColor, s),
+					rounded: true,
+					withGuide: false,
+					contentAlign: "left",
+					titleAlign: "center"
+				});
+			} catch {
+				console.log(summary.join("\n"));
+			}
 		});
-		context.on("lifecycle:end", () => {
+		context.on("kubb:lifecycle:end", () => {
 			reset();
 		});
 	}
@@ -660,63 +911,63 @@ const fileSystemLogger = defineLogger({
 					files[pathName].push(`[${timestamp}]\n${log.logs.join("\n")}`);
 				}
 			}
-			await Promise.all(Object.entries(files).map(([fileName, logs]) => write(fileName, logs.join("\n\n"))));
+			for (const [fileName, logs] of Object.entries(files)) await write(fileName, logs.join("\n\n"));
 			return Object.keys(files);
 		}
-		context.on("info", (message, info) => {
+		context.on("kubb:info", (message, info) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
 				logs: [`ℹ ${message} ${info}`]
 			});
 		});
-		context.on("success", (message, info) => {
+		context.on("kubb:success", (message, info) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
 				logs: [`✓ ${message} ${info}`]
 			});
 		});
-		context.on("warn", (message, info) => {
+		context.on("kubb:warn", (message, info) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
 				logs: [`⚠ ${message} ${info}`]
 			});
 		});
-		context.on("error", (error) => {
+		context.on("kubb:error", (error) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
 				logs: [`✗ ${error.message}`, error.stack || "unknown stack"]
 			});
 		});
-		context.on("debug", (message) => {
+		context.on("kubb:debug", (message) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
 				logs: message.logs
 			});
 		});
-		context.on("plugin:start", (plugin) => {
+		context.on("kubb:plugin:start", (plugin) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
 				logs: [`Generating ${plugin.name}`]
 			});
 		});
-		context.on("plugin:end", (plugin, { duration, success }) => {
+		context.on("kubb:plugin:end", (plugin, { duration, success }) => {
 			const durationStr = formatMs(duration);
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
 				logs: [success ? `${plugin.name} completed in ${durationStr}` : `${plugin.name} failed in ${durationStr}`]
 			});
 		});
-		context.on("files:processing:start", (files) => {
+		context.on("kubb:files:processing:start", (files) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
 				logs: [`Start ${files.length} writing:`, ...files.map((file) => file.path)]
 			});
 		});
-		context.on("generation:end", async (config) => {
+		context.on("kubb:generation:end", async (config) => {
 			const writtenFilePaths = await writeLogs(config.name);
 			if (writtenFilePaths.length > 0) {
 				const files = writtenFilePaths.map((f) => relative(process$1.cwd(), f));
-				await context.emit("info", "Debug files written to:", files.join(", "));
+				await context.emit("kubb:info", "Debug files written to:", files.join(", "));
 			}
 			reset();
 		});
@@ -770,7 +1021,7 @@ const githubActionsLogger = defineLogger({
 		function closeGroup(_name) {
 			console.log("::endgroup::");
 		}
-		context.on("info", (message, info = "") => {
+		context.on("kubb:info", (message, info = "") => {
 			if (logLevel$7 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("blue", "ℹ"),
@@ -779,7 +1030,7 @@ const githubActionsLogger = defineLogger({
 			].join(" "));
 			console.log(text);
 		});
-		context.on("success", (message, info = "") => {
+		context.on("kubb:success", (message, info = "") => {
 			if (logLevel$7 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("blue", "✓"),
@@ -788,7 +1039,7 @@ const githubActionsLogger = defineLogger({
 			].filter(Boolean).join(" "));
 			console.log(text);
 		});
-		context.on("warn", (message, info = "") => {
+		context.on("kubb:warn", (message, info = "") => {
 			if (logLevel$7 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("yellow", "⚠"),
@@ -797,7 +1048,7 @@ const githubActionsLogger = defineLogger({
 			].filter(Boolean).join(" "));
 			console.warn(`::warning::${text}`);
 		});
-		context.on("error", (error) => {
+		context.on("kubb:error", (error) => {
 			const caused = toCause(error);
 			if (logLevel$7 <= logLevel.silent) return;
 			const message = error.message || String(error);
@@ -812,37 +1063,37 @@ const githubActionsLogger = defineLogger({
 				}
 			}
 		});
-		context.on("lifecycle:start", (version) => {
+		context.on("kubb:lifecycle:start", (version) => {
 			console.log(styleText("yellow", `Kubb ${version} 🧩`));
 			reset();
 		});
-		context.on("config:start", () => {
+		context.on("kubb:config:start", () => {
 			if (logLevel$7 <= logLevel.silent) return;
 			const text = getMessage("Configuration started");
 			openGroup("Configuration");
 			console.log(text);
 		});
-		context.on("config:end", (configs) => {
+		context.on("kubb:config:end", (configs) => {
 			state.currentConfigs = configs;
 			if (logLevel$7 <= logLevel.silent) return;
 			const text = getMessage("Configuration completed");
 			console.log(text);
 			closeGroup("Configuration");
 		});
-		context.on("generation:start", (config) => {
+		context.on("kubb:generation:start", (config) => {
 			reset();
 			state.totalPlugins = config.plugins?.length ?? 0;
 			const text = config.name ? `Generation for ${styleText("bold", config.name)}` : "Generation";
 			if (state.currentConfigs.length > 1) openGroup(text);
 			if (state.currentConfigs.length === 1) console.log(getMessage(text));
 		});
-		context.on("plugin:start", (plugin) => {
+		context.on("kubb:plugin:start", (plugin) => {
 			if (logLevel$7 <= logLevel.silent) return;
 			const text = getMessage(`Generating ${styleText("bold", plugin.name)}`);
 			if (state.currentConfigs.length === 1) openGroup(`Plugin: ${plugin.name}`);
 			console.log(text);
 		});
-		context.on("plugin:end", (plugin, { duration, success }) => {
+		context.on("kubb:plugin:end", (plugin, { duration, success }) => {
 			if (logLevel$7 <= logLevel.silent) return;
 			if (success) state.completedPlugins++;
 			else state.failedPlugins++;
@@ -853,7 +1104,7 @@ const githubActionsLogger = defineLogger({
 			if (state.currentConfigs.length === 1) closeGroup(`Plugin: ${plugin.name}`);
 			showProgressStep();
 		});
-		context.on("files:processing:start", (files) => {
+		context.on("kubb:files:processing:start", (files) => {
 			if (logLevel$7 <= logLevel.silent) return;
 			state.totalFiles = files.length;
 			state.processedFiles = 0;
@@ -861,46 +1112,46 @@ const githubActionsLogger = defineLogger({
 			const text = getMessage(`Writing ${files.length} files`);
 			console.log(text);
 		});
-		context.on("files:processing:end", () => {
+		context.on("kubb:files:processing:end", () => {
 			if (logLevel$7 <= logLevel.silent) return;
 			const text = getMessage("Files written successfully");
 			console.log(text);
 			if (state.currentConfigs.length === 1) closeGroup("File Generation");
 			showProgressStep();
 		});
-		context.on("file:processing:update", () => {
+		context.on("kubb:file:processing:update", () => {
 			if (logLevel$7 <= logLevel.silent) return;
 			state.processedFiles++;
 		});
-		context.on("generation:end", (config) => {
+		context.on("kubb:generation:end", (config) => {
 			const text = getMessage(config.name ? `${styleText("blue", "✓")} Generation completed for ${styleText("dim", config.name)}` : `${styleText("blue", "✓")} Generation completed`);
 			console.log(text);
 		});
-		context.on("format:start", () => {
+		context.on("kubb:format:start", () => {
 			if (logLevel$7 <= logLevel.silent) return;
 			const text = getMessage("Format started");
 			if (state.currentConfigs.length === 1) openGroup("Formatting");
 			console.log(text);
 		});
-		context.on("format:end", () => {
+		context.on("kubb:format:end", () => {
 			if (logLevel$7 <= logLevel.silent) return;
 			const text = getMessage("Format completed");
 			console.log(text);
 			if (state.currentConfigs.length === 1) closeGroup("Formatting");
 		});
-		context.on("lint:start", () => {
+		context.on("kubb:lint:start", () => {
 			if (logLevel$7 <= logLevel.silent) return;
 			const text = getMessage("Lint started");
 			if (state.currentConfigs.length === 1) openGroup("Linting");
 			console.log(text);
 		});
-		context.on("lint:end", () => {
+		context.on("kubb:lint:end", () => {
 			if (logLevel$7 <= logLevel.silent) return;
 			const text = getMessage("Lint completed");
 			console.log(text);
 			if (state.currentConfigs.length === 1) closeGroup("Linting");
 		});
-		context.on("hook:start", async ({ id, command, args }) => {
+		context.on("kubb:hook:start", async ({ id, command, args }) => {
 			const commandWithArgs = formatCommandWithArgs(command, args);
 			const text = getMessage(`Hook ${styleText("dim", commandWithArgs)} started`);
 			if (logLevel$7 > logLevel.silent) {
@@ -920,14 +1171,14 @@ const githubActionsLogger = defineLogger({
 				}
 			});
 		});
-		context.on("hook:end", ({ command, args }) => {
+		context.on("kubb:hook:end", ({ command, args }) => {
 			if (logLevel$7 <= logLevel.silent) return;
 			const commandWithArgs = formatCommandWithArgs(command, args);
 			const text = getMessage(`Hook ${styleText("dim", commandWithArgs)} completed`);
 			console.log(text);
 			if (state.currentConfigs.length === 1) closeGroup(`Hook ${commandWithArgs}`);
 		});
-		context.on("generation:summary", (config, { status, hrStart, failedPlugins }) => {
+		context.on("kubb:generation:summary", (config, { status, hrStart, failedPlugins }) => {
 			const pluginsCount = config.plugins?.length ?? 0;
 			const successCount = pluginsCount - failedPlugins.size;
 			const duration = formatHrtime(hrStart);
@@ -935,7 +1186,7 @@ const githubActionsLogger = defineLogger({
 			console.log(status === "success" ? `Kubb Summary: ${styleText("blue", "✓")} ${`${successCount} successful`}, ${pluginsCount} total, ${styleText("green", duration)}` : `Kubb Summary: ${styleText("blue", "✓")} ${`${successCount} successful`}, ✗ ${`${failedPlugins.size} failed`}, ${pluginsCount} total, ${styleText("green", duration)}`);
 			if (state.currentConfigs.length > 1) closeGroup(config.name ? `Generation for ${styleText("bold", config.name)}` : "Generation");
 		});
-		context.on("lifecycle:end", () => {
+		context.on("kubb:lifecycle:end", () => {
 			reset();
 		});
 	}
@@ -953,7 +1204,7 @@ const plainLogger = defineLogger({
 		function getMessage(message) {
 			return formatMessage(message, logLevel$6);
 		}
-		context.on("info", (message, info) => {
+		context.on("kubb:info", (message, info) => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage([
 				"ℹ",
@@ -962,7 +1213,7 @@ const plainLogger = defineLogger({
 			].join(" "));
 			console.log(text);
 		});
-		context.on("success", (message, info = "") => {
+		context.on("kubb:success", (message, info = "") => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage([
 				"✓",
@@ -971,7 +1222,7 @@ const plainLogger = defineLogger({
 			].filter(Boolean).join(" "));
 			console.log(text);
 		});
-		context.on("warn", (message, info) => {
+		context.on("kubb:warn", (message, info) => {
 			if (logLevel$6 < logLevel.warn) return;
 			const text = getMessage([
 				"⚠",
@@ -980,7 +1231,7 @@ const plainLogger = defineLogger({
 			].filter(Boolean).join(" "));
 			console.log(text);
 		});
-		context.on("error", (error) => {
+		context.on("kubb:error", (error) => {
 			const caused = toCause(error);
 			const text = getMessage(["✗", error.message].join(" "));
 			console.log(text);
@@ -994,74 +1245,74 @@ const plainLogger = defineLogger({
 				}
 			}
 		});
-		context.on("lifecycle:start", () => {
+		context.on("kubb:lifecycle:start", () => {
 			console.log("Kubb CLI 🧩");
 		});
-		context.on("config:start", () => {
+		context.on("kubb:config:start", () => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage("Configuration started");
 			console.log(text);
 		});
-		context.on("config:end", () => {
+		context.on("kubb:config:end", () => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage("Configuration completed");
 			console.log(text);
 		});
-		context.on("generation:start", () => {
+		context.on("kubb:generation:start", () => {
 			const text = getMessage("Generation started");
 			console.log(text);
 		});
-		context.on("plugin:start", (plugin) => {
+		context.on("kubb:plugin:start", (plugin) => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage(`Generating ${plugin.name}`);
 			console.log(text);
 		});
-		context.on("plugin:end", (plugin, { duration, success }) => {
+		context.on("kubb:plugin:end", (plugin, { duration, success }) => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const durationStr = formatMs(duration);
 			const text = getMessage(success ? `${plugin.name} completed in ${durationStr}` : `${plugin.name} failed in ${durationStr}`);
 			console.log(text);
 		});
-		context.on("files:processing:start", (files) => {
+		context.on("kubb:files:processing:start", (files) => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage(`Writing ${files.length} files`);
 			console.log(text);
 		});
-		context.on("file:processing:update", ({ file, config }) => {
+		context.on("kubb:file:processing:update", ({ file, config }) => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage(`Writing ${relative(config.root, file.path)}`);
 			console.log(text);
 		});
-		context.on("files:processing:end", () => {
+		context.on("kubb:files:processing:end", () => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage("Files written successfully");
 			console.log(text);
 		});
-		context.on("generation:end", (config) => {
+		context.on("kubb:generation:end", (config) => {
 			const text = getMessage(config.name ? `Generation completed for ${config.name}` : "Generation completed");
 			console.log(text);
 		});
-		context.on("format:start", () => {
+		context.on("kubb:format:start", () => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage("Format started");
 			console.log(text);
 		});
-		context.on("format:end", () => {
+		context.on("kubb:format:end", () => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage("Format completed");
 			console.log(text);
 		});
-		context.on("lint:start", () => {
+		context.on("kubb:lint:start", () => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage("Lint started");
 			console.log(text);
 		});
-		context.on("lint:end", () => {
+		context.on("kubb:lint:end", () => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage("Lint completed");
 			console.log(text);
 		});
-		context.on("hook:start", async ({ id, command, args }) => {
+		context.on("kubb:hook:start", async ({ id, command, args }) => {
 			const commandWithArgs = formatCommandWithArgs(command, args);
 			const text = getMessage(`Hook ${commandWithArgs} started`);
 			if (logLevel$6 > logLevel.silent) console.log(text);
@@ -1078,12 +1329,12 @@ const plainLogger = defineLogger({
 				}
 			});
 		});
-		context.on("hook:end", ({ command, args }) => {
+		context.on("kubb:hook:end", ({ command, args }) => {
 			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage(`Hook ${formatCommandWithArgs(command, args)} completed`);
 			console.log(text);
 		});
-		context.on("generation:summary", (config, { pluginTimings, status, hrStart, failedPlugins, filesCreated }) => {
+		context.on("kubb:generation:summary", (config, { pluginTimings, status, hrStart, failedPlugins, filesCreated }) => {
 			const summary = getSummary({
 				failedPlugins,
 				filesCreated,
@@ -1156,8 +1407,8 @@ async function setupLogger(context, { logLevel: logLevel$5 }) {
 }
 //#endregion
 //#region src/utils/executeHooks.ts
-async function executeHooks({ hooks, events }) {
-	const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done].filter(Boolean);
+async function executeHooks({ configHooks, hooks }) {
+	const commands = Array.isArray(configHooks.done) ? configHooks.done : [configHooks.done].filter(Boolean);
 	for (const command of commands) {
 		const [cmd, ...args] = tokenize(command);
 		if (!cmd) continue;
@@ -1165,16 +1416,16 @@ async function executeHooks({ hooks, events }) {
 		const hookEndPromise = new Promise((resolve, reject) => {
 			const handler = ({ id, success, error }) => {
 				if (id !== hookId) return;
-				events.off("hook:end", handler);
+				hooks.off("kubb:hook:end", handler);
 				if (!success) {
 					reject(error ?? /* @__PURE__ */ new Error(`Hook failed: ${command}`));
 					return;
 				}
-				events.emit("success", `${styleText("dim", command)} successfully executed`).then(resolve).catch(reject);
+				hooks.emit("kubb:success", `${styleText("dim", command)} successfully executed`).then(resolve).catch(reject);
 			};
-			events.on("hook:end", handler);
+			hooks.on("kubb:hook:end", handler);
 		});
-		await events.emit("hook:start", {
+		await hooks.emit("kubb:hook:start", {
 			id: hookId,
 			command: cmd,
 			args
@@ -1183,11 +1434,20 @@ async function executeHooks({ hooks, events }) {
 	}
 }
 //#endregion
+//#region src/utils/getConfig.ts
+async function getConfigs(config, args) {
+	const resolved = await (typeof config === "function" ? config(args) : config);
+	return (Array.isArray(resolved) ? resolved : [resolved]).map((item) => ({
+		...item,
+		plugins: item.plugins ?? []
+	}));
+}
+//#endregion
 //#region src/utils/getCosmiConfig.ts
 const jiti = createJiti(import.meta.url, {
 	jsx: {
 		runtime: "automatic",
-		importSource: "@kubb/react-fabric"
+		importSource: "@kubb/renderer-jsx"
 	},
 	sourceMaps: true,
 	interopDefault: true
@@ -1204,10 +1464,14 @@ async function getCosmiConfig(moduleName, config) {
 		`.${moduleName}rc.yaml`,
 		`.${moduleName}rc.yml`,
 		`.${moduleName}rc.ts`,
+		`.${moduleName}rc.mts`,
+		`.${moduleName}rc.cts`,
 		`.${moduleName}rc.js`,
 		`.${moduleName}rc.mjs`,
 		`.${moduleName}rc.cjs`,
 		`${moduleName}.config.ts`,
+		`${moduleName}.config.mts`,
+		`${moduleName}.config.cts`,
 		`${moduleName}.config.js`,
 		`${moduleName}.config.mjs`,
 		`${moduleName}.config.cjs`
@@ -1223,7 +1487,11 @@ async function getCosmiConfig(moduleName, config) {
 			}),
 			...searchPlaces
 		],
-		loaders: { ".ts": tsLoader }
+		loaders: {
+			".ts": tsLoader,
+			".mts": tsLoader,
+			".cts": tsLoader
+		}
 	});
 	try {
 		result = config ? await explorer.load(config) : await explorer.search();
@@ -1251,17 +1519,18 @@ async function startWatcher(path, cb) {
 }
 //#endregion
 //#region src/runners/generate.ts
-async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefix, noToolMessage, configName, outputPath, logLevel: logLevel$1, events, onStart, onEnd }) {
+async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefix, noToolMessage, configName, outputPath, logLevel: logLevel$1, hooks, onStart, onEnd }) {
 	await onStart();
 	let resolvedTool = toolValue;
 	if (resolvedTool === "auto") {
 		const detected = await detect();
-		if (!detected) await events.emit("warn", noToolMessage);
+		if (!detected) await hooks.emit("kubb:warn", noToolMessage);
 		else {
 			resolvedTool = detected;
-			await events.emit("info", `Auto-detected ${toolLabel}: ${styleText("dim", resolvedTool)}`);
+			await hooks.emit("kubb:info", `Auto-detected ${toolLabel}: ${styleText("dim", resolvedTool)}`);
 		}
 	}
+	let toolError;
 	if (resolvedTool && resolvedTool !== "auto" && resolvedTool in toolMap) {
 		const toolConfig = toolMap[resolvedTool];
 		try {
@@ -1269,73 +1538,58 @@ async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefi
 			const hookEndPromise = new Promise((resolve, reject) => {
 				const handler = ({ id, success, error }) => {
 					if (id !== hookId) return;
-					events.off("hook:end", handler);
+					hooks.off("kubb:hook:end", handler);
 					if (!success) {
 						reject(error ?? /* @__PURE__ */ new Error(`${toolConfig.errorMessage}`));
 						return;
 					}
-					events.emit("success", [
+					hooks.emit("kubb:success", [
 						`${successPrefix} with ${styleText("dim", resolvedTool)}`,
 						logLevel$1 >= logLevel.info ? `on ${styleText("dim", outputPath)}` : void 0,
 						"successfully"
 					].filter(Boolean).join(" ")).then(resolve).catch(reject);
 				};
-				events.on("hook:end", handler);
+				hooks.on("kubb:hook:end", handler);
 			});
-			await events.emit("hook:start", {
+			await hooks.emit("kubb:hook:start", {
 				id: hookId,
 				command: toolConfig.command,
 				args: toolConfig.args(outputPath)
 			});
 			await hookEndPromise;
 		} catch (caughtError) {
-			const err = new Error(toolConfig.errorMessage);
-			err.cause = caughtError;
-			await events.emit("error", err);
+			const err = toError(caughtError);
+			await hooks.emit("kubb:error", err);
+			toolError = err;
 		}
 	}
 	await onEnd();
+	if (toolError) throw toolError;
 }
-async function generate({ input, config: userConfig, events, logLevel: logLevel$2 }) {
-	const inputPath = input ?? ("path" in userConfig.input ? userConfig.input.path : void 0);
+async function generate(options) {
+	const { input, hooks, logLevel: logLevel$2 } = options;
 	const hrStart = process$1.hrtime();
+	const inputPath = input ?? ("path" in options.config.input ? options.config.input.path : void 0);
 	const config = {
-		...userConfig,
-		root: userConfig.root || process$1.cwd(),
+		...options.config,
 		input: inputPath ? {
-			...userConfig.input,
+			...options.config.input,
 			path: inputPath
-		} : userConfig.input,
-		output: {
-			write: true,
-			barrelType: "named",
-			extension: { ".ts": ".ts" },
-			format: "prettier",
-			...userConfig.output
-		}
+		} : options.config.input,
+		...options.config.output
 	};
-	await events.emit("generation:start", config);
-	await events.emit("info", config.name ? `Setup generation ${styleText("bold", config.name)}` : "Setup generation", inputPath);
-	const { sources, fabric, pluginManager } = await setup({
-		config,
-		events
-	});
-	await events.emit("info", config.name ? `Build generation ${styleText("bold", config.name)}` : "Build generation", inputPath);
-	const { files, failedPlugins, pluginTimings, error } = await safeBuild({
-		config,
-		events
-	}, {
-		pluginManager,
-		fabric,
-		events,
-		sources
-	});
-	await events.emit("info", "Load summary");
+	const kubb = createKubb(config, { hooks });
+	await kubb.setup();
+	await hooks.emit("kubb:generation:start", config);
+	await hooks.emit("kubb:info", config.name ? `Setup generation ${styleText("bold", config.name)}` : "Setup generation", inputPath);
+	await hooks.emit("kubb:info", config.name ? `Build generation ${styleText("bold", config.name)}` : "Build generation", inputPath);
+	const { files, failedPlugins, pluginTimings, error, driver } = await kubb.safeBuild();
+	await hooks.emit("kubb:info", "Load summary");
 	if (failedPlugins.size > 0 || error) {
 		const allErrors = [error, ...Array.from(failedPlugins).filter((it) => it.error).map((it) => it.error)].filter(Boolean);
-		for (const err of allErrors) await events.emit("error", err);
-		await events.emit("generation:end", config, files, sources);
-		await events.emit("generation:summary", config, {
+		for (const err of allErrors) await hooks.emit("kubb:error", err);
+		await hooks.emit("kubb:generation:end", config, files, kubb.sources);
+		await hooks.emit("kubb:generation:summary", config, {
 			failedPlugins,
 			filesCreated: files.length,
 			status: "failed",
@@ -1345,7 +1599,7 @@ async function generate({ input, config: userConfig, events, logLevel: logLevel$
 		await sendTelemetry(buildTelemetryEvent({
 			command: "generate",
 			kubbVersion: version,
-			plugins: pluginManager.plugins.map((p) => ({
+			plugins: Array.from(driver.plugins.values(), (p) => ({
 				name: p.name,
 				options: p.options
 			})),
@@ -1355,8 +1609,8 @@ async function generate({ input, config: userConfig, events, logLevel: logLevel$
 		}));
 		process$1.exit(1);
 	}
-	await events.emit("success", "Generation successfully", inputPath);
-	await events.emit("generation:end", config, files, sources);
+	await hooks.emit("kubb:success", "Generation successfully", inputPath);
+	await hooks.emit("kubb:generation:end", config, files, kubb.sources);
 	const outputPath = path.resolve(config.root, config.output.path);
 	if (config.output.format) await runToolPass({
 		toolValue: config.output.format,
@@ -1364,13 +1618,13 @@ async function generate({ input, config: userConfig, events, logLevel: logLevel$
 		toolMap: formatters,
 		toolLabel: "formatter",
 		successPrefix: "Formatting",
-		noToolMessage: "No formatter found (biome, prettier, or oxfmt). Skipping formatting.",
+		noToolMessage: "No formatter found (oxfmt, biome, or prettier). Skipping formatting.",
 		configName: config.name,
 		outputPath,
 		logLevel: logLevel$2,
-		events,
-		onStart: () => events.emit("format:start"),
-		onEnd: () => events.emit("format:end")
+		hooks,
+		onStart: () => hooks.emit("kubb:format:start"),
+		onEnd: () => hooks.emit("kubb:format:end")
 	});
 	if (config.output.lint) await runToolPass({
 		toolValue: config.output.lint,
@@ -1378,23 +1632,23 @@ async function generate({ input, config: userConfig, events, logLevel: logLevel$
 		toolMap: linters,
 		toolLabel: "linter",
 		successPrefix: "Linting",
-		noToolMessage: "No linter found (biome, oxlint, or eslint). Skipping linting.",
+		noToolMessage: "No linter found (oxlint, biome, or eslint). Skipping linting.",
 		configName: config.name,
 		outputPath,
 		logLevel: logLevel$2,
-		events,
-		onStart: () => events.emit("lint:start"),
-		onEnd: () => events.emit("lint:end")
+		hooks,
+		onStart: () => hooks.emit("kubb:lint:start"),
+		onEnd: () => hooks.emit("kubb:lint:end")
 	});
 	if (config.hooks) {
-		await events.emit("hooks:start");
+		await hooks.emit("kubb:hooks:start");
 		await executeHooks({
-			hooks: config.hooks,
-			events
+			configHooks: config.hooks,
+			hooks
 		});
-		await events.emit("hooks:end");
+		await hooks.emit("kubb:hooks:end");
 	}
-	await events.emit("generation:summary", config, {
+	await hooks.emit("kubb:generation:summary", config, {
 		failedPlugins,
 		filesCreated: files.length,
 		status: "success",
@@ -1404,7 +1658,7 @@ async function generate({ input, config: userConfig, events, logLevel: logLevel$
 	await sendTelemetry(buildTelemetryEvent({
 		command: "generate",
 		kubbVersion: version,
-		plugins: pluginManager.plugins.map((p) => ({
+		plugins: Array.from(driver.plugins.values(), (p) => ({
 			name: p.name,
 			options: p.options
 		})),
@@ -1415,54 +1669,45 @@ async function generate({ input, config: userConfig, events, logLevel: logLevel$
 }
 async function runGenerateCommand({ input, configPath, logLevel: logLevelKey, watch }) {
 	const logLevel$3 = logLevel[logLevelKey] ?? logLevel.info;
-	const events = new AsyncEventEmitter();
-	const promiseManager = new PromiseManager();
-	await setupLogger(events, { logLevel: logLevel$3 });
+	const hooks = new AsyncEventEmitter();
+	await setupLogger(hooks, { logLevel: logLevel$3 });
 	await executeIfOnline(async () => {
 		try {
 			const latestVersion = (await (await fetch(KUBB_NPM_PACKAGE_URL)).json()).version;
-			if (latestVersion && version < latestVersion) await events.emit("version:new", version, latestVersion);
+			if (latestVersion && version < latestVersion) await hooks.emit("kubb:version:new", version, latestVersion);
 		} catch {}
 	});
 	try {
 		const result = await getCosmiConfig("kubb", configPath);
 		const configs = await getConfigs(result.config, { input });
-		await events.emit("config:start");
-		await events.emit("info", "Config loaded", path.relative(process$1.cwd(), result.filepath));
-		await events.emit("success", "Config loaded successfully", path.relative(process$1.cwd(), result.filepath));
-		await events.emit("config:end", configs);
-		await events.emit("lifecycle:start", version);
-		const promises = configs.map((config) => {
-			return async () => {
-				if (isInputPath(config) && watch) {
-					await startWatcher([input || config.input.path], async (paths) => {
-						events.removeAll();
-						await generate({
-							input,
-							config,
-							logLevel: logLevel$3,
-							events
-						});
-						clack.log.step(styleText("yellow", `Watching for changes in ${paths.join(" and ")}`));
-					});
-					return;
-				}
-				await generate({
-					input,
-					config,
-					logLevel: logLevel$3,
-					events
-				});
-			};
+		await hooks.emit("kubb:config:start");
+		await hooks.emit("kubb:info", "Config loaded", path.relative(process$1.cwd(), result.filepath));
+		await hooks.emit("kubb:success", "Config loaded successfully", path.relative(process$1.cwd(), result.filepath));
+		await hooks.emit("kubb:config:end", configs);
+		await hooks.emit("kubb:lifecycle:start", version);
+		for (const config of configs) if (isInputPath(config) && watch) await startWatcher([input || config.input.path], async (paths) => {
+			hooks.removeAll();
+			await generate({
+				input,
+				config,
+				logLevel: logLevel$3,
+				hooks
+			});
+			clack.log.step(styleText("yellow", `Watching for changes in ${paths.join(" and ")}`));
+		});
+		else await generate({
+			input,
+			config,
+			logLevel: logLevel$3,
+			hooks
 		});
-		await promiseManager.run("seq", promises);
-		await events.emit("lifecycle:end");
+		await hooks.emit("kubb:lifecycle:end");
 	} catch (error) {
-		await events.emit("error", toError(error));
+		await hooks.emit("kubb:error", toError(error));
 		process$1.exit(1);
 	}
 }
 //#endregion
 export { runGenerateCommand };
 
-//# sourceMappingURL=generate-CtFkZeTU.js.map
+//# sourceMappingURL=generate-CQPHU8Xt.js.map