@kubb/cli 5.0.0-beta.7 → 5.0.0-beta.70

package/dist/run-KlHwxNTr.js

@@ -0,0 +1,1377 @@
+import "./rolldown-runtime-C0LytTxp.js";
+import { n as toCause, r as toError } from "./errors-Dc_d7BfX.js";
+import { a as runtime, i as WATCHER_IGNORED_PATHS, n as KUBB_NPM_PACKAGE_URL, o as canUseTTY, t as Telemetry } from "./Telemetry-uAr3lK_-.js";
+import { i as linters, n as detectTool, r as formatters } from "./tools-D0UogMU3.js";
+import { t as version } from "./package-CsDaFmfZ.js";
+import { styleText } from "node:util";
+import { EventEmitter } from "node:events";
+import { hash } from "node:crypto";
+import { existsSync } from "node:fs";
+import path, { basename, dirname, relative, resolve } from "node:path";
+import process$1 from "node:process";
+import * as clack from "@clack/prompts";
+import { Diagnostics, cliReporter, createKubb, logLevel } from "@kubb/core";
+import { pathToFileURL } from "node:url";
+import { createJiti } from "jiti";
+import { NonZeroExitError, x } from "tinyexec";
+import { loadConfig } from "unconfig";
+//#region ../../internals/utils/src/asyncEventEmitter.ts
+/**
+* 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 {
+	/**
+	* Maximum number of listeners per event before Node emits a memory-leak warning.
+	* @default 10
+	*/
+	constructor(maxListener = 10) {
+		this.#emitter.setMaxListeners(maxListener);
+	}
+	#emitter = new EventEmitter();
+	/**
+	* Emits `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')
+	* ```
+	*/
+	emit(eventName, ...eventArgs) {
+		const listeners = this.#emitter.listeners(eventName);
+		if (listeners.length === 0) return;
+		return this.#emitAll(eventName, listeners, eventArgs);
+	}
+	async #emitAll(eventName, listeners, eventArgs) {
+		for (const listener of listeners) try {
+			await listener(...eventArgs);
+		} catch (err) {
+			let serializedArgs;
+			try {
+				serializedArgs = JSON.stringify(eventArgs);
+			} catch {
+				serializedArgs = String(eventArgs);
+			}
+			throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: toError(err) });
+		}
+	}
+	/**
+	* Registers a persistent listener for `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.
+	*
+	* @example
+	* ```ts
+	* emitter.onOnce('build', async (name) => { console.log(name) })
+	* ```
+	*/
+	onOnce(eventName, handler) {
+		const wrapper = (...args) => {
+			this.off(eventName, wrapper);
+			return handler(...args);
+		};
+		this.on(eventName, wrapper);
+	}
+	/**
+	* Removes a previously registered listener.
+	*
+	* @example
+	* ```ts
+	* emitter.off('build', handler)
+	* ```
+	*/
+	off(eventName, handler) {
+		this.#emitter.off(eventName, handler);
+	}
+	/**
+	* 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);
+	}
+	/**
+	* Raises or lowers the per-event listener ceiling before Node warns about a memory leak.
+	* Set this above the expected listener count when many listeners attach by design.
+	*
+	* @example
+	* ```ts
+	* emitter.setMaxListeners(40)
+	* ```
+	*/
+	setMaxListeners(max) {
+		this.#emitter.setMaxListeners(max);
+	}
+	/**
+	* Returns the current per-event listener ceiling.
+	*/
+	getMaxListeners() {
+		return this.#emitter.getMaxListeners();
+	}
+	/**
+	* Removes all listeners from every event channel.
+	*
+	* @example
+	* ```ts
+	* emitter.removeAll()
+	* ```
+	*/
+	removeAll() {
+		this.#emitter.removeAllListeners();
+	}
+};
+//#endregion
+//#region ../../internals/utils/src/time.ts
+/**
+* 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);
+	const ms = seconds * 1e3 + nanoseconds / 1e6;
+	return Math.round(ms * 100) / 100;
+}
+/**
+* Converts a millisecond duration into a human-readable string (`ms`, `s`, or `m s`).
+*
+* @example
+* ```ts
+* formatMs(250)   // '250ms'
+* formatMs(1500)  // '1.50s'
+* formatMs(90000) // '1m 30.0s'
+* ```
+*/
+function formatMs(ms) {
+	if (ms >= 6e4) return `${Math.floor(ms / 6e4)}m ${(ms % 6e4 / 1e3).toFixed(1)}s`;
+	if (ms >= 1e3) return `${(ms / 1e3).toFixed(2)}s`;
+	return `${Math.round(ms)}ms`;
+}
+/**
+* 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));
+}
+//#endregion
+//#region ../../internals/utils/src/colors.ts
+/**
+* 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`;
+}
+function gradient(colorStops, text) {
+	const chars = text.split("");
+	return chars.map((char, i) => {
+		const t = chars.length <= 1 ? 0 : i / (chars.length - 1);
+		const seg = Math.min(Math.floor(t * (colorStops.length - 1)), colorStops.length - 2);
+		const lt = t * (colorStops.length - 1) - seg;
+		const from = parseHex(colorStops[seg]);
+		const to = parseHex(colorStops[seg + 1]);
+		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.
+*/
+const palette = {
+	/**
+	* Top cap of the skittle.
+	*/
+	lid: hex("#F55A17"),
+	/**
+	* Upper wood body.
+	*/
+	woodTop: hex("#F5A217"),
+	/**
+	* Middle wood body.
+	*/
+	woodMid: hex("#F58517"),
+	/**
+	* Base wood body.
+	*/
+	woodBase: hex("#B45309"),
+	/**
+	* Eye whites.
+	*/
+	eye: hex("#FFFFFF"),
+	/**
+	* Highlight accent.
+	*/
+	highlight: hex("#adadc6"),
+	/**
+	* Cheek blush.
+	*/
+	blush: hex("#FDA4AF")
+};
+/**
+* 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([
+		"#F58517",
+		"#F5A217",
+		"#F55A17"
+	], `KUBB v${version}`);
+	const eyeTop = areEyesOpen ? palette.eye("█▀█") : palette.eye("───");
+	const eyeBottom = areEyesOpen ? palette.eye("▀▀▀") : palette.eye("───");
+	return `
+   ${palette.lid("▄▄▄▄▄▄▄▄▄▄▄▄▄")}
+  ${palette.woodTop("█  ")}${palette.highlight("▄▄")}${palette.woodTop("     ")}${palette.highlight("▄▄")}${palette.woodTop("  █")}  ${kubbVersion}
+  ${palette.woodMid("█ ")}${eyeTop}${palette.woodMid("     ")}${eyeTop}${palette.woodMid(" █")}  ${styleText("gray", title)}
+  ${palette.woodMid("█ ")}${eyeBottom}${palette.woodMid("  ")}${palette.blush("◡")}${palette.woodMid("  ")}${eyeBottom}${palette.woodMid(" █")}  ${styleText("yellow", "➜")} ${styleText("white", description)}
+   ${palette.woodBase("▀▀▀▀▀▀▀▀▀▀▀▀▀")}
+`;
+}
+/**
+* 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);
+	if (ms <= 500) return styleText("green", formatted);
+	if (ms <= 1e3) return styleText("yellow", formatted);
+	return styleText("red", formatted);
+}
+//#endregion
+//#region src/loggers/defineLogger.ts
+/**
+* Defines a typed logger. The `install` method subscribes to lifecycle events
+* on the shared emitter and forwards them to the logger's destination.
+*
+* @example
+* ```ts
+* import { defineLogger } from '@kubb/cli'
+*
+* export const myLogger = defineLogger({
+*   name: 'my-logger',
+*   install(context) {
+*     context.on('kubb:info', ({ message }) => console.log('ℹ', message))
+*     context.on('kubb:error', ({ error }) => console.error('✗', error.message))
+*   },
+* })
+* ```
+*/
+function defineLogger(logger) {
+	return logger;
+}
+//#endregion
+//#region src/loggers/clackLogger.ts
+/**
+* TTY logger for local development, with spinners and progress bars.
+*/
+const clackLogger = defineLogger({
+	name: "clack",
+	install(context, options) {
+		const logLevel$5 = options?.logLevel ?? logLevel.info;
+		const state = {
+			...createProgressCounters(),
+			spinner: clack.spinner(),
+			isSpinning: false,
+			runningPlugins: /* @__PURE__ */ new Set(),
+			activeProgress: /* @__PURE__ */ new Map(),
+			activeHookLogs: /* @__PURE__ */ new Map()
+		};
+		function stopActiveProgress() {
+			for (const [, active] of state.activeProgress) {
+				if (active.interval) clearInterval(active.interval);
+				active.progressBar?.stop();
+			}
+			state.activeProgress.clear();
+		}
+		function reset() {
+			stopActiveProgress();
+			resetProgressCounters(state);
+			state.spinner = clack.spinner();
+			state.isSpinning = false;
+			state.runningPlugins.clear();
+			state.activeHookLogs.clear();
+		}
+		function pluginProgressText() {
+			const running = [...state.runningPlugins].map((name) => styleText("bold", name));
+			return getMessage(running.length > 0 ? `Generating ${running.join(", ")}` : "Generating plugins");
+		}
+		function showProgressStep() {
+			if (logLevel$5 <= logLevel.silent) return;
+			const line = buildProgressLine(state);
+			if (line) clack.log.step(getMessage(line));
+		}
+		function getMessage(message) {
+			return formatMessage(message, logLevel$5);
+		}
+		function onStep(event, message) {
+			context.on(event, () => {
+				if (logLevel$5 <= logLevel.silent) return;
+				clack.log.step(getMessage(message));
+			});
+		}
+		function stopSpinner(text) {
+			if (!state.isSpinning) return;
+			state.spinner.stop(text);
+			state.isSpinning = false;
+		}
+		context.on("kubb:info", ({ message, info = "" }) => {
+			if (logLevel$5 <= logLevel.silent) return;
+			const text = getMessage([
+				styleText("blue", "ℹ"),
+				message,
+				info ? styleText("dim", info) : void 0
+			].filter(Boolean).join(" "));
+			if (state.isSpinning) {
+				state.spinner.message(text);
+				return;
+			}
+			clack.log.info(text);
+		});
+		context.on("kubb:success", ({ message, info = "" }) => {
+			if (logLevel$5 <= logLevel.silent) return;
+			const text = getMessage([
+				styleText("blue", "✓"),
+				message,
+				logLevel$5 >= logLevel.info ? styleText("dim", info) : void 0
+			].filter(Boolean).join(" "));
+			if (state.isSpinning) {
+				stopSpinner(text);
+				return;
+			}
+			clack.log.success(text);
+		});
+		context.on("kubb:warn", ({ message, info }) => {
+			if (logLevel$5 < logLevel.warn) return;
+			const text = getMessage([
+				styleText("yellow", "⚠"),
+				message,
+				logLevel$5 >= logLevel.info && info ? styleText("dim", info) : void 0
+			].filter(Boolean).join(" "));
+			clack.log.warn(text);
+		});
+		context.on("kubb:error", ({ error }) => {
+			const caused = toCause(error);
+			const text = [styleText("red", "✗"), error.message].join(" ");
+			if (state.isSpinning) {
+				stopSpinner(getMessage(text));
+				return;
+			}
+			clack.log.error(getMessage(text));
+			if (logLevel$5 >= logLevel.verbose && error.stack) {
+				const frames = error.stack.split("\n").slice(1, 4);
+				for (const frame of frames) clack.log.message(getMessage(styleText("dim", frame.trim())));
+				if (caused?.stack) {
+					clack.log.message(styleText("dim", `└─ caused by ${caused.message}`));
+					const frames = caused.stack.split("\n").slice(1, 4);
+					for (const frame of frames) clack.log.message(getMessage(`    ${styleText("dim", frame.trim())}`));
+				}
+			}
+		});
+		context.on("kubb:diagnostic", ({ diagnostic }) => {
+			if (logLevel$5 <= logLevel.silent && diagnostic.severity !== "error") return;
+			stopSpinner();
+			stopActiveProgress();
+			if (Diagnostics.isUpdate(diagnostic)) {
+				clack.box(`\`v${diagnostic.currentVersion}\` → \`v${diagnostic.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"
+				});
+				return;
+			}
+			const { headline, details } = Diagnostics.format(diagnostic);
+			clack.log.message([headline, ...details], {
+				symbol: "",
+				secondarySymbol: ""
+			});
+		});
+		context.on("kubb:lifecycle:start", async ({ version }) => {
+			console.log(`\n${getIntro({
+				title: "The meta framework for code generation",
+				description: "Ready to start",
+				version,
+				areEyesOpen: true
+			})}\n`);
+			reset();
+		});
+		context.on("kubb:generation:start", ({ config }) => {
+			reset();
+			state.totalPlugins = config.plugins?.length ?? 0;
+			if (logLevel$5 <= logLevel.silent) return;
+			const text = getMessage(["Generation started", config.name ? `for ${styleText("dim", config.name)}` : void 0].filter(Boolean).join(" "));
+			clack.intro(text);
+		});
+		context.on("kubb:plugin:start", ({ plugin }) => {
+			if (logLevel$5 <= logLevel.silent) return;
+			stopSpinner();
+			state.runningPlugins.add(plugin.name);
+			const active = state.activeProgress.get("plugins");
+			if (active) {
+				active.progressBar.advance(0, pluginProgressText());
+				return;
+			}
+			const progressBar = clack.progress({
+				style: "block",
+				max: Math.max(state.totalPlugins, 1),
+				size: 30
+			});
+			progressBar.start(pluginProgressText());
+			progressBar.advance(state.completedPlugins + state.failedPlugins, pluginProgressText());
+			state.activeProgress.set("plugins", { progressBar });
+		});
+		context.on("kubb:plugin:end", ({ plugin, success }) => {
+			stopSpinner();
+			const active = state.activeProgress.get("plugins");
+			if (!active || logLevel$5 === logLevel.silent) return;
+			state.runningPlugins.delete(plugin.name);
+			recordPluginResult(state, success);
+			active.progressBar.advance(1, pluginProgressText());
+			if (state.runningPlugins.size === 0) {
+				active.progressBar.stop(getMessage("Plugins generated"));
+				state.activeProgress.delete("plugins");
+				showProgressStep();
+			}
+		});
+		context.on("kubb:files:processing:start", ({ files }) => {
+			if (logLevel$5 <= logLevel.silent) return;
+			stopSpinner();
+			state.totalFiles = files.length;
+			state.processedFiles = 0;
+			const text = `Writing ${files.length} files`;
+			const progressBar = clack.progress({
+				style: "block",
+				max: files.length,
+				size: 30
+			});
+			context.emit("kubb:info", { message: text });
+			progressBar.start(getMessage(text));
+			state.activeProgress.set("files", { progressBar });
+		});
+		context.on("kubb:files:processing:update", ({ files }) => {
+			if (logLevel$5 <= logLevel.silent) return;
+			stopSpinner();
+			const active = state.activeProgress.get("files");
+			for (const { file, config } of files) {
+				state.processedFiles++;
+				if (active) active.progressBar.advance(void 0, `Writing ${relative(config.root, file.path)}`);
+			}
+		});
+		context.on("kubb:files:processing:end", () => {
+			if (logLevel$5 <= logLevel.silent) return;
+			stopSpinner();
+			const text = getMessage("Files written successfully");
+			const active = state.activeProgress.get("files");
+			if (!active) return;
+			active.progressBar.stop(text);
+			state.activeProgress.delete("files");
+			showProgressStep();
+		});
+		context.on("kubb:generation:end", ({ config }) => {
+			stopSpinner();
+			const text = getMessage(config.name ? `Generation completed for ${styleText("dim", config.name)}` : "Generation completed");
+			clack.outro(text);
+		});
+		onStep("kubb:format:start", "Formatting");
+		onStep("kubb:lint:start", "Linting");
+		onStep("kubb:hooks:start", "Running hooks");
+		context.on("kubb:hook:start", ({ id, command, args }) => {
+			if (logLevel$5 <= logLevel.silent || !id) return;
+			stopSpinner();
+			const title = getMessage(`Running ${styleText("dim", formatCommandWithArgs(command, args))}`);
+			const taskLog = clack.taskLog({ title });
+			state.activeHookLogs.set(id, {
+				taskLog,
+				hrStart: process$1.hrtime()
+			});
+		});
+		if (logLevel$5 > logLevel.silent) context.on("kubb:hook:line", ({ id, line }) => {
+			state.activeHookLogs.get(id)?.taskLog.message(styleText("dim", line));
+		});
+		context.on("kubb:hook:end", ({ id, command, args, success, error, stdout, stderr }) => {
+			if (!id) return;
+			if (logLevel$5 <= logLevel.silent) {
+				if (!success) {
+					if (stdout) console.log(stdout);
+					if (stderr) console.error(stderr);
+				}
+				return;
+			}
+			const active = state.activeHookLogs.get(id);
+			if (!active) return;
+			state.activeHookLogs.delete(id);
+			const commandWithArgs = formatCommandWithArgs(command, args);
+			const duration = formatMsWithColor(getElapsedMs(active.hrStart));
+			if (success) active.taskLog.success(getMessage(`${styleText("dim", commandWithArgs)} completed in ${duration}`));
+			else {
+				const reason = error?.message ? ` (${error.message})` : "";
+				active.taskLog.error(getMessage(`${styleText("dim", commandWithArgs)} failed${reason}`), { showLog: true });
+			}
+		});
+		context.on("kubb:lifecycle:end", () => {
+			reset();
+		});
+	}
+});
+//#endregion
+//#region src/loggers/plainLogger.ts
+/**
+* Plain console adapter for non-TTY environments, built on `console.log`.
+*/
+const plainLogger = defineLogger({
+	name: "plain",
+	install(context, options) {
+		const logLevel$4 = options?.logLevel ?? logLevel.info;
+		const hookTimer = createHookTimer();
+		function getMessage(message) {
+			return formatMessage(message, logLevel$4);
+		}
+		function onStep(event, message) {
+			context.on(event, () => {
+				if (logLevel$4 <= logLevel.silent) return;
+				console.log(getMessage(message));
+			});
+		}
+		context.on("kubb:info", ({ message, info }) => {
+			if (logLevel$4 <= logLevel.silent) return;
+			const text = getMessage([
+				"ℹ",
+				message,
+				info
+			].join(" "));
+			console.log(text);
+		});
+		context.on("kubb:success", ({ message, info = "" }) => {
+			if (logLevel$4 <= logLevel.silent) return;
+			const text = getMessage([
+				"✓",
+				message,
+				logLevel$4 >= logLevel.info ? info : void 0
+			].filter(Boolean).join(" "));
+			console.log(text);
+		});
+		context.on("kubb:warn", ({ message, info }) => {
+			if (logLevel$4 < logLevel.warn) return;
+			const text = getMessage([
+				"⚠",
+				message,
+				logLevel$4 >= logLevel.info ? info : void 0
+			].filter(Boolean).join(" "));
+			console.log(text);
+		});
+		context.on("kubb:error", ({ error }) => {
+			const caused = toCause(error);
+			const text = getMessage(["✗", error.message].join(" "));
+			console.log(text);
+			if (logLevel$4 >= logLevel.verbose && error.stack) {
+				const frames = error.stack.split("\n").slice(1, 4);
+				for (const frame of frames) console.log(getMessage(frame.trim()));
+				if (caused?.stack) {
+					console.log(`└─ caused by ${caused.message}`);
+					const frames = caused.stack.split("\n").slice(1, 4);
+					for (const frame of frames) console.log(getMessage(`    ${frame.trim()}`));
+				}
+			}
+		});
+		context.on("kubb:diagnostic", ({ diagnostic }) => {
+			if (logLevel$4 <= logLevel.silent && diagnostic.severity !== "error") return;
+			console.log(getMessage(Diagnostics.formatLines(diagnostic).join("\n")));
+		});
+		context.on("kubb:lifecycle:start", ({ version }) => {
+			console.log(`Kubb CLI v${version}`);
+		});
+		context.on("kubb:generation:start", () => {
+			const text = getMessage("Generation started");
+			console.log(text);
+		});
+		context.on("kubb:plugin:start", ({ plugin }) => {
+			if (logLevel$4 <= logLevel.silent) return;
+			const text = getMessage(`Generating ${plugin.name}`);
+			console.log(text);
+		});
+		context.on("kubb:plugin:end", ({ plugin, duration, success }) => {
+			if (logLevel$4 <= 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("kubb:files:processing:start", ({ files }) => {
+			if (logLevel$4 <= logLevel.silent) return;
+			const text = getMessage(`Writing ${files.length} files`);
+			console.log(text);
+		});
+		context.on("kubb:files:processing:update", ({ files }) => {
+			if (logLevel$4 <= logLevel.silent) return;
+			for (const { file, config } of files) console.log(getMessage(`Writing ${relative(config.root, file.path)}`));
+		});
+		context.on("kubb:files:processing:end", () => {
+			if (logLevel$4 <= logLevel.silent) return;
+			const text = getMessage("Files written successfully");
+			console.log(text);
+		});
+		context.on("kubb:generation:end", ({ config }) => {
+			const text = getMessage(config.name ? `Generation completed for ${config.name}` : "Generation completed");
+			console.log(text);
+		});
+		onStep("kubb:format:start", "Format started");
+		onStep("kubb:format:end", "Format completed");
+		onStep("kubb:lint:start", "Lint started");
+		onStep("kubb:lint:end", "Lint completed");
+		onStep("kubb:hooks:start", "Hooks started");
+		onStep("kubb:hooks:end", "Hooks completed");
+		context.on("kubb:hook:start", ({ id, command, args }) => {
+			if (logLevel$4 <= logLevel.silent) return;
+			if (id) hookTimer.start(id);
+			const commandWithArgs = formatCommandWithArgs(command, args);
+			console.log(getMessage(`Hook ${commandWithArgs} started`));
+		});
+		context.on("kubb:hook:end", ({ id, command, args, success, error, stdout, stderr }) => {
+			if (logLevel$4 <= logLevel.silent) return;
+			const ms = id ? hookTimer.end(id) : void 0;
+			const durationStr = ms !== void 0 ? ` in ${formatMs(ms)}` : "";
+			const commandWithArgs = formatCommandWithArgs(command, args);
+			if (success) console.log(getMessage(`✓ Hook ${commandWithArgs} completed${durationStr}`));
+			else {
+				if (stdout) console.log(stdout);
+				if (stderr) console.error(stderr);
+				const reason = error?.message ? ` (${error.message})` : "";
+				console.log(getMessage(`✗ Hook ${commandWithArgs} failed${durationStr}${reason}`));
+			}
+		});
+	}
+});
+//#endregion
+//#region src/loggers/utils.ts
+/**
+* Optionally prefix a message with a [HH:MM:SS] timestamp when logLevel >= verbose.
+* Shared across all logger adapters to avoid duplication.
+*/
+function formatMessage(message, logLevel$3) {
+	if (logLevel$3 >= logLevel.verbose) return `${styleText("dim", `[${(/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+		hour12: false,
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit"
+	})}]`)} ${message}`;
+	return message;
+}
+/**
+* Build the progress summary line shown by the clack logger.
+* Returns null when there is nothing to display.
+*/
+function buildProgressLine(state) {
+	const parts = [];
+	const duration = formatHrtime(state.hrStart);
+	if (state.totalPlugins > 0) {
+		const pluginStr = state.failedPlugins > 0 ? `Plugins ${styleText("green", state.completedPlugins.toString())}/${state.totalPlugins} ${styleText("red", `(${state.failedPlugins} failed)`)}` : `Plugins ${styleText("green", state.completedPlugins.toString())}/${state.totalPlugins}`;
+		parts.push(pluginStr);
+	}
+	if (state.totalFiles > 0) parts.push(`Files ${styleText("green", state.processedFiles.toString())}/${state.totalFiles}`);
+	if (parts.length === 0) return null;
+	parts.push(`${styleText("green", duration)} elapsed`);
+	return parts.join(styleText("dim", " | "));
+}
+/**
+* Creates the per-run progress counters used by the clack logger.
+*/
+function createProgressCounters() {
+	return {
+		totalPlugins: 0,
+		completedPlugins: 0,
+		failedPlugins: 0,
+		totalFiles: 0,
+		processedFiles: 0,
+		hrStart: process$1.hrtime()
+	};
+}
+/**
+* Resets the progress counters in place at the start/end of a generation run.
+*/
+function resetProgressCounters(state) {
+	state.totalPlugins = 0;
+	state.completedPlugins = 0;
+	state.failedPlugins = 0;
+	state.totalFiles = 0;
+	state.processedFiles = 0;
+	state.hrStart = process$1.hrtime();
+}
+/**
+* Records a finished plugin against the progress counters.
+*/
+function recordPluginResult(state, success) {
+	if (success) state.completedPlugins++;
+	else state.failedPlugins++;
+}
+/**
+* Creates a {@link HookTimer} backed by a private `id → hrtime` map.
+*/
+function createHookTimer() {
+	const starts = /* @__PURE__ */ new Map();
+	return {
+		start(id) {
+			starts.set(id, process$1.hrtime());
+		},
+		end(id) {
+			const hrStart = starts.get(id);
+			if (!hrStart) return;
+			starts.delete(id);
+			return getElapsedMs(hrStart);
+		},
+		clear() {
+			starts.clear();
+		}
+	};
+}
+/**
+* Join a command and its optional args into a single display string.
+*
+* @example With args
+* `formatCommandWithArgs('prettier', ['--write', '.'])` returns `'prettier --write .'`
+*/
+function formatCommandWithArgs(command, args) {
+	return args?.length ? `${command} ${args.join(" ")}` : command;
+}
+function detectLogger() {
+	if (canUseTTY()) return "clack";
+	return "plain";
+}
+const logMapper = {
+	clack: clackLogger,
+	plain: plainLogger
+};
+/**
+* Bridges a {@link Reporter} onto the run's event emitter: calls `report` with each config's
+* {@link GenerationResult} on `kubb:generation:end`. The reporter never touches the emitter.
+*/
+function installReporter(context, reporter, ctx) {
+	context.on("kubb:generation:end", async ({ config, diagnostics = [], filesCreated = 0, status = "success", hrStart = process$1.hrtime() }) => {
+		await reporter.report({
+			config,
+			diagnostics,
+			filesCreated,
+			status,
+			hrStart
+		}, ctx);
+	});
+	if (reporter.drain) context.on("kubb:lifecycle:end", () => reporter.drain?.(ctx));
+}
+/**
+* Installs the live logger (the TUI view) and the given reporters (the output). The reporters are
+* already selected by the caller (the CLI maps `--reporter` to names via `selectReporters`). This
+* only wires them. Loggers receive hook subprocess output through `kubb:hook:line` and the
+* `stdout`/`stderr` on `kubb:hook:end`, so nothing is returned here.
+*
+* Loggers and reporters are independent, except for `cli`: it both installs the live logger view
+* here and registers as a reporter that prints the per-config summary. The `json` reporter owns
+* stdout, so the whole `cli` reporter (live logger and summary) is skipped whenever `json` is
+* among the reporters, even if `cli` is also listed.
+*/
+async function setupReporters(context, { logLevel, reporters }) {
+	const hasJson = reporters.some((reporter) => reporter.name === "json");
+	const ctx = { logLevel };
+	for (const reporter of reporters) {
+		if (reporter.name === "cli") {
+			if (hasJson) continue;
+			const type = detectLogger();
+			const logger = logMapper[type];
+			if (!logger) throw new Error(`Unknown adapter type: ${type}`);
+			await logger.install(context, { logLevel });
+		}
+		installReporter(context, reporter, ctx);
+	}
+}
+/**
+* Picks the reporters whose `name` matches one of `names`, in the order the names are given.
+* The config carries every available reporter, and the host selects which to activate by name
+* (the CLI maps `--reporter` to this). Duplicate names and names without a matching reporter are
+* skipped.
+*/
+function selectReporters(reporters, names) {
+	const seen = /* @__PURE__ */ new Set();
+	const selected = [];
+	for (const name of names) {
+		if (seen.has(name)) continue;
+		seen.add(name);
+		const reporter = reporters.find((candidate) => candidate.name === name);
+		if (reporter) selected.push(reporter);
+	}
+	return selected;
+}
+//#endregion
+//#region ../../internals/shared/src/loader.ts
+/**
+* jiti options for loading Kubb config modules: the automatic JSX runtime pointed at
+* `@kubb/renderer-jsx`, and `moduleCache` off so a re-load re-evaluates the file.
+*/
+const JITI_OPTIONS = {
+	jsx: {
+		runtime: "automatic",
+		importSource: "@kubb/renderer-jsx"
+	},
+	moduleCache: false
+};
+/**
+* Creates a runtime-aware loader for Kubb's TypeScript and JavaScript config modules.
+*
+* On Bun and Deno it imports the file natively, skipping jiti's transform step, and falls back to
+* jiti only when the native import throws. On Node it always uses jiti, which transpiles TypeScript
+* and the `@kubb/renderer-jsx` JSX runtime on the fly. The jiti instance is created lazily, so the
+* Bun/Deno happy path never pays for it.
+*
+* @example
+* ```ts
+* const config = await createModuleLoader().load('/abs/kubb.config.ts', { default: true })
+* ```
+*/
+function createModuleLoader() {
+	let jiti;
+	const getJiti = () => jiti ??= createJiti(import.meta.url, JITI_OPTIONS);
+	const viaJiti = (filePath, options) => options?.default ? getJiti().import(filePath, { default: true }) : getJiti().import(filePath);
+	const viaNative = async (filePath, options) => {
+		const href = pathToFileURL(filePath).href;
+		const mod = await (options?.bust != null ? import(`${href}?t=${options.bust}`) : import(href));
+		return options?.default ? mod.default ?? mod : mod;
+	};
+	return { async load(filePath, options) {
+		if (runtime.isBun || runtime.isDeno) try {
+			return await viaNative(filePath, options);
+		} catch {
+			return viaJiti(filePath, options);
+		}
+		return viaJiti(filePath, options);
+	} };
+}
+//#endregion
+//#region src/runners/generate/utils.ts
+const loader = createModuleLoader();
+const tsLoader = (configFile) => loader.load(configFile, { default: true });
+const MODULE_NAME = "kubb";
+const SEARCH_FILES = [
+	"",
+	".config/",
+	"configs/"
+].flatMap((prefix) => [`${prefix}.${MODULE_NAME}rc`, `${prefix}${MODULE_NAME}.config`]);
+const SEARCH_EXTENSIONS = [
+	"ts",
+	"mts",
+	"cts",
+	"js",
+	"mjs",
+	"cjs"
+];
+/**
+* Discovers the Kubb config and resolves it into a normalized array of configs.
+* Every config in the result is guaranteed to have a `plugins` array.
+*/
+async function getConfigs({ configPath, input, watch, logLevel }) {
+	const abs = configPath ? resolve(configPath) : void 0;
+	const sources = abs ? [{
+		files: [basename(abs)],
+		extensions: [],
+		parser: tsLoader
+	}] : [{
+		files: SEARCH_FILES,
+		extensions: SEARCH_EXTENSIONS,
+		parser: tsLoader
+	}];
+	let result;
+	try {
+		result = await loadConfig({
+			cwd: abs ? dirname(abs) : process$1.cwd(),
+			sources,
+			merge: false
+		});
+	} catch (error) {
+		throw new Error("Config failed loading", { cause: error });
+	}
+	const [filepath] = result.sources;
+	if (!result.config || !filepath) throw new Error("Config not defined, create a kubb.config.js or pass through your config with the option --config");
+	const config = result.config;
+	const resolved = await (typeof config === "function" ? config({
+		config: configPath,
+		input,
+		watch,
+		logLevel
+	}) : config);
+	return {
+		configPath: filepath,
+		configs: (Array.isArray(resolved) ? resolved : [resolved]).map((item) => ({
+			...item,
+			plugins: item.plugins ?? []
+		}))
+	};
+}
+/**
+* Tokenizes a shell command string, respecting single and double quotes.
+*
+* @example
+* ```ts
+* tokenize('git commit -m "initial commit"')
+* // → ['git', 'commit', '-m', 'initial commit']
+* ```
+*/
+function tokenize(command) {
+	return (command.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g) ?? []).map((token) => token.replace(/^["']|["']$/g, ""));
+}
+/**
+* Runs the `done` hooks defined in a Kubb config in sequence.
+*/
+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;
+		const hookId = hash("sha256", command, "hex");
+		const commandWithArgs = [cmd, ...args].join(" ");
+		await hooks.emit("kubb:hook:start", {
+			id: hookId,
+			command: cmd,
+			args
+		});
+		await runHook({
+			id: hookId,
+			command: cmd,
+			args,
+			commandWithArgs,
+			hooks
+		});
+	}
+}
+/**
+* Spawns a hook command and reports its outcome through `kubb:hook:end`.
+* A non-zero exit signals failure via `kubb:hook:end` rather than throwing, so the caller can turn
+* it into a diagnostic. Other spawn errors do the same. Output is streamed through `kubb:hook:line`
+* only while a listener is attached.
+*/
+async function runHook({ id, command, args, commandWithArgs, hooks }) {
+	const emitEnd = (success, error, output) => hooks.emit("kubb:hook:end", {
+		command,
+		args,
+		id,
+		success,
+		error,
+		...output
+	});
+	const stream = hooks.listenerCount("kubb:hook:line") > 0;
+	try {
+		const proc = x(command, [...args ?? []], {
+			nodeOptions: { detached: process$1.platform !== "win32" },
+			throwOnError: true
+		});
+		if (stream) for await (const line of proc) await hooks.emit("kubb:hook:line", {
+			id,
+			line
+		});
+		await proc;
+		await hooks.emit("kubb:success", { message: `${styleText("dim", commandWithArgs)} successfully executed` });
+		await emitEnd(true, null);
+	} catch (err) {
+		if (!(err instanceof NonZeroExitError)) {
+			await emitEnd(false, toError(err));
+			return;
+		}
+		const stderr = err.output?.stderr ?? "";
+		const stdout = err.output?.stdout ?? "";
+		await emitEnd(false, /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`), {
+			stdout,
+			stderr
+		});
+	}
+}
+/**
+* Starts a file watcher on the given paths and calls `cb` on any change.
+* Ignores `.git` and `node_modules` directories.
+*/
+async function startWatcher(path, cb, log = {
+	info: console.log,
+	error: console.log
+}) {
+	const { watch } = await import("chokidar");
+	const watcher = watch(path, {
+		ignorePermissionErrors: true,
+		ignored: WATCHER_IGNORED_PATHS
+	});
+	process$1.once("SIGINT", () => {
+		watcher.close();
+	});
+	process$1.once("SIGTERM", () => {
+		watcher.close();
+	});
+	watcher.on("all", async (type, file) => {
+		log.info(styleText("yellow", styleText("bold", `Change detected: ${type} ${file}`)));
+		try {
+			await cb(path);
+		} catch (_e) {
+			log.error(styleText("red", "Watcher failed"));
+		}
+	});
+}
+//#endregion
+//#region src/runners/generate/run.ts
+/**
+* Registers a one-shot `kubb:hook:end` listener for `hookId` before the caller emits `kubb:hook:start`,
+* so a synchronous emitter cannot fire end before the listener is attached.
+*/
+function waitForHookEnd(hooks, hookId, onSuccess, fallbackErrorMessage) {
+	return new Promise((resolve, reject) => {
+		const handler = (ctx) => {
+			if (ctx.id !== hookId) return;
+			hooks.off("kubb:hook:end", handler);
+			if (!ctx.success) {
+				reject(ctx.error ?? new Error(fallbackErrorMessage));
+				return;
+			}
+			Promise.resolve(onSuccess()).then(resolve).catch(reject);
+		};
+		hooks.on("kubb:hook:end", handler);
+	});
+}
+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 hooks.emit("kubb:warn", { message: noToolMessage });
+		else {
+			resolvedTool = detected;
+			await hooks.emit("kubb:info", { message: `Auto-detected ${toolLabel}: ${styleText("dim", resolvedTool)}` });
+		}
+	}
+	let toolError;
+	if (resolvedTool && resolvedTool !== "auto" && resolvedTool in toolMap && existsSync(outputPath)) {
+		const toolConfig = toolMap[resolvedTool];
+		const hookId = hash("sha256", [configName, resolvedTool].filter(Boolean).join("-"), "hex");
+		const successMessage = [
+			`${successPrefix} with ${styleText("dim", resolvedTool)}`,
+			logLevel$1 >= logLevel.info ? `on ${styleText("dim", outputPath)}` : void 0,
+			"successfully"
+		].filter(Boolean).join(" ");
+		try {
+			const hookArgs = toolConfig.args(outputPath);
+			const commandWithArgs = [toolConfig.command, ...hookArgs].join(" ");
+			const hookEndPromise = waitForHookEnd(hooks, hookId, () => hooks.emit("kubb:success", { message: successMessage }), toolConfig.errorMessage);
+			await hooks.emit("kubb:hook:start", {
+				id: hookId,
+				command: toolConfig.command,
+				args: hookArgs
+			});
+			runHook({
+				id: hookId,
+				command: toolConfig.command,
+				args: hookArgs,
+				commandWithArgs,
+				hooks
+			}).catch(() => {});
+			await hookEndPromise;
+		} catch (caughtError) {
+			toolError = toError(caughtError);
+		}
+	}
+	await onEnd();
+	if (toolError) throw toolError;
+}
+async function generate(options) {
+	const { input, hooks, logLevel } = options;
+	const hrStart = process$1.hrtime();
+	const inputPath = input ?? (options.config.input && "path" in options.config.input ? options.config.input.path : void 0);
+	const config = {
+		...options.config,
+		input: inputPath ? {
+			...options.config.input,
+			path: inputPath
+		} : options.config.input,
+		...options.config.output
+	};
+	const kubb = createKubb(config, { hooks });
+	await hooks.emit("kubb:generation:start", { config });
+	await hooks.emit("kubb:info", {
+		message: config.name ? `Setup generation ${styleText("bold", config.name)}` : "Setup generation",
+		info: inputPath
+	});
+	await kubb.setup();
+	await hooks.emit("kubb:info", {
+		message: config.name ? `Build generation ${styleText("bold", config.name)}` : "Build generation",
+		info: inputPath
+	});
+	const { files, diagnostics, driver } = await kubb.safeBuild();
+	await hooks.emit("kubb:info", { message: "Load summary" });
+	const telemetryPlugins = Array.from(driver.plugins.values(), (p) => ({
+		name: p.name,
+		options: p.options
+	}));
+	const reportTelemetry = (status) => Telemetry.send(Telemetry.build({
+		command: "generate",
+		kubbVersion: version,
+		plugins: telemetryPlugins,
+		hrStart,
+		filesCreated: files.length,
+		status
+	}));
+	for (const diagnostic of diagnostics) {
+		if (!Diagnostics.isProblem(diagnostic)) continue;
+		const unknown = Diagnostics.narrow(diagnostic, Diagnostics.code.unknown);
+		if (unknown) await hooks.emit("kubb:error", { error: unknown.cause ?? new Error(unknown.message) });
+		else await Diagnostics.emit(hooks, diagnostic);
+	}
+	if (Diagnostics.hasError(diagnostics)) {
+		await hooks.emit("kubb:generation:end", {
+			config,
+			storage: kubb.storage,
+			diagnostics,
+			filesCreated: files.length,
+			status: "failed",
+			hrStart
+		});
+		await reportTelemetry("failed");
+		return false;
+	}
+	const outputPath = path.resolve(config.root, config.output.path);
+	const outputDiagnostics = [];
+	const toolPasses = [config.output.format && {
+		code: Diagnostics.code.formatFailed,
+		toolValue: config.output.format,
+		detect: () => detectTool([
+			"oxfmt",
+			"biome",
+			"prettier"
+		]),
+		toolMap: formatters,
+		toolLabel: "formatter",
+		successPrefix: "Formatting",
+		noToolMessage: "No formatter found (oxfmt, biome, or prettier). Skipping formatting.",
+		onStart: () => hooks.emit("kubb:format:start"),
+		onEnd: () => hooks.emit("kubb:format:end")
+	}, config.output.lint && {
+		code: Diagnostics.code.lintFailed,
+		toolValue: config.output.lint,
+		detect: () => detectTool([
+			"oxlint",
+			"biome",
+			"eslint"
+		]),
+		toolMap: linters,
+		toolLabel: "linter",
+		successPrefix: "Linting",
+		noToolMessage: "No linter found (oxlint, biome, or eslint). Skipping linting.",
+		onStart: () => hooks.emit("kubb:lint:start"),
+		onEnd: () => hooks.emit("kubb:lint:end")
+	}].filter(Boolean);
+	for (const { code, ...pass } of toolPasses) try {
+		await runToolPass({
+			...pass,
+			configName: config.name,
+			outputPath,
+			logLevel,
+			hooks
+		});
+	} catch (caughtError) {
+		const diagnostic = outputDiagnostic(code, pass.toolLabel, caughtError);
+		outputDiagnostics.push(diagnostic);
+		await Diagnostics.emit(hooks, diagnostic);
+	}
+	if (config.hooks) {
+		await hooks.emit("kubb:hooks:start");
+		const hookFailures = [];
+		const onHookEnd = (ctx) => {
+			if (!ctx.success) hookFailures.push(ctx.error ?? /* @__PURE__ */ new Error("Post-generate hook failed"));
+		};
+		hooks.on("kubb:hook:end", onHookEnd);
+		try {
+			await executeHooks({
+				configHooks: config.hooks,
+				hooks
+			});
+		} finally {
+			hooks.off("kubb:hook:end", onHookEnd);
+		}
+		for (const error of hookFailures) {
+			const diagnostic = outputDiagnostic(Diagnostics.code.hookFailed, "Post-generate hook", error);
+			outputDiagnostics.push(diagnostic);
+			await Diagnostics.emit(hooks, diagnostic);
+		}
+		await hooks.emit("kubb:hooks:end");
+	}
+	const finalDiagnostics = [...diagnostics, ...outputDiagnostics];
+	const failed = Diagnostics.hasError(outputDiagnostics);
+	if (!failed) await hooks.emit("kubb:success", {
+		message: "Generation succeeded",
+		info: inputPath
+	});
+	await hooks.emit("kubb:generation:end", {
+		config,
+		storage: kubb.storage,
+		diagnostics: finalDiagnostics,
+		filesCreated: files.length,
+		status: failed ? "failed" : "success",
+		hrStart
+	});
+	await reportTelemetry(failed ? "failed" : "success");
+	return !failed;
+}
+/**
+* Builds a coded diagnostic for an output-phase failure (formatter, linter, or `done` hook).
+*/
+function outputDiagnostic(code, label, caughtError) {
+	const error = toError(caughtError);
+	return {
+		code,
+		severity: "error",
+		message: `${label} failed: ${error.message}`,
+		help: "Check that the tool is installed and that the command and its config are correct.",
+		location: { kind: "config" },
+		cause: error
+	};
+}
+async function checkForUpdate(hooks) {
+	try {
+		const data = await (await fetch(KUBB_NPM_PACKAGE_URL)).json();
+		if (data.version && version < data.version) await Diagnostics.emit(hooks, Diagnostics.update({
+			currentVersion: version,
+			latestVersion: data.version
+		}));
+	} catch {}
+}
+/**
+* Runs the full Kubb generation lifecycle for the given CLI options.
+* Loads configs, sets up the reporters (CLI `--reporter` picks which of `config.reporters` to trigger),
+* checks for a newer version, and calls `generate` for each config entry.
+*/
+async function run({ input, configPath, logLevel: logLevelKey, watch, reporters: cliReporters }) {
+	const logLevel$2 = logLevel[logLevelKey] ?? logLevel.info;
+	const hooks = new AsyncEventEmitter();
+	let configs;
+	let resolvedConfigPath;
+	try {
+		const loaded = await getConfigs({
+			configPath,
+			input,
+			watch,
+			logLevel: logLevelKey
+		});
+		configs = loaded.configs;
+		resolvedConfigPath = loaded.configPath;
+	} catch (error) {
+		await setupReporters(hooks, {
+			logLevel: logLevel$2,
+			reporters: [cliReporter]
+		});
+		await hooks.emit("kubb:error", { error: toError(error) });
+		process$1.exit(1);
+	}
+	const requestedNames = cliReporters?.length ? cliReporters : ["cli"];
+	await setupReporters(hooks, {
+		logLevel: logLevel$2,
+		reporters: selectReporters(configs[0]?.reporters ?? [], requestedNames)
+	});
+	await hooks.emit("kubb:lifecycle:start", { version });
+	await checkForUpdate(hooks);
+	try {
+		const relativeConfigPath = path.relative(process$1.cwd(), resolvedConfigPath);
+		await hooks.emit("kubb:info", {
+			message: "Config loaded",
+			info: relativeConfigPath
+		});
+		await hooks.emit("kubb:success", {
+			message: "Config loaded successfully",
+			info: relativeConfigPath
+		});
+		let anyFailed = false;
+		for (const config of configs) if (config.input && "path" in config.input && watch) await startWatcher([input || config.input.path], async (paths) => {
+			await generate({
+				input,
+				config,
+				logLevel: logLevel$2,
+				hooks
+			});
+			clack.log.step(styleText("yellow", `Watching for changes in ${paths.join(" and ")}`));
+		}, {
+			info: (msg) => clack.log.info(msg),
+			error: (msg) => clack.log.error(msg)
+		});
+		else try {
+			if (!await generate({
+				input,
+				config,
+				logLevel: logLevel$2,
+				hooks
+			})) anyFailed = true;
+		} catch (configError) {
+			await hooks.emit("kubb:error", { error: toError(configError) });
+			anyFailed = true;
+		}
+		await hooks.emit("kubb:lifecycle:end");
+		if (anyFailed) process$1.exit(1);
+	} catch (error) {
+		await hooks.emit("kubb:error", { error: toError(error) });
+		process$1.exit(1);
+	}
+}
+//#endregion
+export { run };
+
+//# sourceMappingURL=run-KlHwxNTr.js.map