@kubb/cli 5.0.0-beta.36 → 5.0.0-beta.38

package/dist/{run-GvXhj9XF.cjs → run-BFZtWpcW.cjs}

@@ -1,9 +1,9 @@
 const require_chunk = require("./chunk-Bx3C2hgW.cjs");
 const require_errors = require("./errors-DykI11xo.cjs");
-const require_telemetry = require("./telemetry-DRhd3joO.cjs");
+const require_telemetry = require("./telemetry-B80oJfxR.cjs");
 const require_shell = require("./shell-Lh-vLWwH.cjs");
-const require_package = require("./package-DbsOo2rT.cjs");
-const require_constants = require("./constants-FhPsMOdo.cjs");
+const require_package = require("./package-guApEHiW.cjs");
+const require_constants = require("./constants-CAKUpLcQ.cjs");
 let node_util = require("node:util");
 let node_events = require("node:events");
 let node_crypto = require("node:crypto");
@@ -118,6 +118,24 @@ var AsyncEventEmitter = class {
 		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
@@ -491,6 +509,267 @@ async function detectLinter() {
 	return null;
 }
 //#endregion
+//#region src/reporters/report.ts
+/**
+* Builds the normalized {@link Report} for one config from its {@link GenerationResult}. Splits the
+* diagnostics into problems and per-plugin timings (slowest first) and derives the plugin and issue
+* counts, so every reporter renders the same data.
+*/
+function buildReport(result) {
+	const { config, diagnostics, filesCreated, status, hrStart } = result;
+	const failed = _kubb_core.Diagnostics.failedPlugins(diagnostics);
+	const total = config.plugins?.length ?? 0;
+	const counts = _kubb_core.Diagnostics.count(diagnostics);
+	const problems = diagnostics.filter(_kubb_core.isProblemDiagnostic);
+	const timings = diagnostics.filter(_kubb_core.isPerformanceDiagnostic).sort((a, b) => b.duration - a.duration).map((diagnostic) => ({
+		plugin: diagnostic.plugin,
+		durationMs: diagnostic.duration
+	}));
+	return {
+		name: config.name ?? "",
+		status,
+		plugins: {
+			passed: total - failed.length,
+			failed,
+			total
+		},
+		counts,
+		filesCreated,
+		durationMs: getElapsedMs(hrStart),
+		output: (0, node_path.resolve)(config.root, config.output.path),
+		timings,
+		diagnostics: problems.map((diagnostic) => _kubb_core.Diagnostics.serialize(diagnostic))
+	};
+}
+//#endregion
+//#region src/reporters/cliReporter.ts
+/**
+* Builds the vitest/jest-style summary for one {@link Report}: right-aligned dim labels with
+* `N passed (total)` counts, and a per-plugin `Timings` section when `showTimings`.
+*/
+function buildSummaryLines(report, { showTimings }) {
+	const { status, plugins, counts, filesCreated, durationMs, output, timings } = report;
+	const rows = [];
+	rows.push(["Plugins", status === "success" ? `${(0, node_util.styleText)("green", `${plugins.passed} passed`)} (${plugins.total})` : `${(0, node_util.styleText)("green", `${plugins.passed} passed`)} | ${(0, node_util.styleText)("red", `${plugins.failed.length} failed`)} (${plugins.total})`]);
+	if (status === "failed" && plugins.failed.length > 0) rows.push(["Failed", plugins.failed.map((name) => randomCliColor(name)).join(", ")]);
+	if (counts.errors > 0 || counts.warnings > 0) {
+		const issues = [counts.errors > 0 ? (0, node_util.styleText)("red", `${counts.errors} ${counts.errors === 1 ? "error" : "errors"}`) : void 0, counts.warnings > 0 ? (0, node_util.styleText)("yellow", `${counts.warnings} ${counts.warnings === 1 ? "warning" : "warnings"}`) : void 0].filter(Boolean).join(" | ");
+		rows.push(["Issues", issues]);
+	}
+	rows.push(["Files", `${(0, node_util.styleText)("green", String(filesCreated))} generated`]);
+	rows.push(["Duration", (0, node_util.styleText)("green", formatMs(durationMs))]);
+	rows.push(["Output", output]);
+	const labelWidth = Math.max(...rows.map(([label]) => label.length), timings.length > 0 ? 7 : 0);
+	const lines = rows.map(([label, value]) => `${(0, node_util.styleText)("dim", label.padStart(labelWidth))}  ${value}`);
+	if (showTimings && timings.length > 0) {
+		const nameWidth = Math.max(0, ...timings.map((timing) => timing.plugin.length));
+		const indent = " ".repeat(labelWidth + 2);
+		lines.push((0, node_util.styleText)("dim", "Timings".padStart(labelWidth)));
+		for (const timing of timings) {
+			const timeStr = formatMs(timing.durationMs);
+			const barLength = Math.min(Math.ceil(timing.durationMs / 100), 10);
+			const bar = (0, node_util.styleText)("dim", "█".repeat(barLength));
+			lines.push(`${indent}${(0, node_util.styleText)("dim", "•")} ${timing.plugin.padEnd(nameWidth)} ${bar} ${timeStr}`);
+		}
+	}
+	return lines;
+}
+/**
+* Renders the summary as plain `console.log` lines so it works in every CLI (no clack/TTY
+* dependency): a blank line, the config name colored by status, then the summary rows.
+*/
+function renderSummary(lines, { title, status }) {
+	console.log("");
+	if (title) console.log((0, node_util.styleText)(status === "failed" ? "red" : "green", title));
+	for (const line of lines) console.log(line);
+}
+/**
+* The default `cli` reporter. Renders the {@link Report} for each config as it finishes, independent
+* of the live logger view. Suppressed at `silent`; the `verbose` level adds the per-plugin timings.
+*/
+const cliReporter = (0, _kubb_core.createReporter)({
+	name: "cli",
+	report(result, { logLevel }) {
+		if (logLevel <= _kubb_core.logLevel.silent) return;
+		const report = buildReport(result);
+		renderSummary(buildSummaryLines(report, { showTimings: logLevel >= _kubb_core.logLevel.verbose }), {
+			title: report.name,
+			status: report.status
+		});
+	}
+});
+//#endregion
+//#region src/loggers/diagnostics.ts
+/**
+* Glyph and accent color per severity, matching the miette/oxlint convention
+* (`×` error, `⚠` warning, `ℹ` advice).
+*/
+const severityStyle = {
+	error: {
+		glyph: "×",
+		color: "red"
+	},
+	warning: {
+		glyph: "⚠",
+		color: "yellow"
+	},
+	info: {
+		glyph: "ℹ",
+		color: "blue"
+	}
+};
+/**
+* The colored, bold severity glyph (`×`, `⚠`, `ℹ`) on its own. Pass it as clack's
+* `symbol` so clack owns the gutter and adds the bar to the continuation lines,
+* instead of baking the glyph into the message text.
+*/
+function diagnosticSymbol(severity) {
+	const { glyph, color } = severityStyle[severity];
+	return (0, node_util.styleText)(color, (0, node_util.styleText)("bold", glyph));
+}
+/**
+* The `plugin(CODE): message` headline, without the leading severity glyph.
+*/
+function diagnosticHeadline(diagnostic) {
+	const { code, severity, message } = diagnostic;
+	const plugin = (0, _kubb_core.isProblemDiagnostic)(diagnostic) ? diagnostic.plugin : void 0;
+	const { color } = severityStyle[severity];
+	return `${(0, node_util.styleText)(color, (0, node_util.styleText)("bold", plugin ? `${plugin}(${code})` : code))}: ${message}`;
+}
+/**
+* The detail lines below the headline: optional `at <pointer>`, `help:`, and
+* `docs:`. OpenAPI has no line/column, so the location is the JSON pointer the
+* adapter built. Each line keeps a two-space indent so it sits under the headline.
+*/
+function diagnosticDetails(diagnostic) {
+	const { code } = diagnostic;
+	const problem = (0, _kubb_core.isProblemDiagnostic)(diagnostic) ? diagnostic : void 0;
+	const location = problem?.location;
+	const help = problem?.help;
+	const lines = [];
+	if (location && "pointer" in location) lines.push(`  ${(0, node_util.styleText)("dim", "at")} ${(0, node_util.styleText)("cyan", location.pointer)}`);
+	if (help) lines.push(`  ${(0, node_util.styleText)("cyan", "help:")} ${help}`);
+	if (code !== _kubb_core.diagnosticCode.unknown) lines.push(`  ${(0, node_util.styleText)("dim", "docs:")} ${(0, node_util.styleText)("cyan", _kubb_core.Diagnostics.docsUrl(code))}`);
+	return lines;
+}
+/**
+* Renders a {@link Diagnostic} in the oxlint style as a self-contained block: a
+* `× plugin(CODE): message` header followed by the {@link diagnosticDetails}.
+* Use this where clack's gutter is not available (plain, file output); clack
+* loggers pass {@link diagnosticSymbol}, {@link diagnosticHeadline}, and
+* {@link diagnosticDetails} to `clack.log.message` instead.
+*
+* @example
+* ```ts
+* formatDiagnostic({ code: 'KUBB_REF_NOT_FOUND', severity: 'error', message: 'Could not find Pet', help: 'Add Pet under components.schemas.', plugin: '@kubb/plugin-zod', location: { kind: 'schema', pointer: '#/components/schemas/Pet' } })
+* ```
+*/
+function formatDiagnostic(diagnostic) {
+	return [`${diagnosticSymbol(diagnostic.severity)} ${diagnosticHeadline(diagnostic)}`, ...diagnosticDetails(diagnostic)];
+}
+//#endregion
+//#region src/reporters/fileReporter.ts
+/**
+* Builds the `## Summary` section: the same counts the cli and json reporters expose, as a list of
+* `label  value` rows with the labels padded to a common width.
+*/
+function buildSummarySection(report) {
+	const { status, plugins, counts, filesCreated, durationMs, output } = report;
+	const rows = [["Status", status], ["Plugins", status === "success" ? `${plugins.passed} passed (${plugins.total})` : `${plugins.passed} passed | ${plugins.failed.length} failed (${plugins.total})`]];
+	if (plugins.failed.length > 0) rows.push(["Failed", plugins.failed.join(", ")]);
+	rows.push(["Issues", `${counts.errors} errors | ${counts.warnings} warnings | ${counts.infos} infos`]);
+	rows.push(["Files", `${filesCreated} generated`]);
+	rows.push(["Duration", formatMs(durationMs)]);
+	rows.push(["Output", output]);
+	const labelWidth = Math.max(...rows.map(([label]) => label.length));
+	return [
+		"## Summary",
+		"",
+		...rows.map(([label, value]) => `  ${label.padEnd(labelWidth)}  ${value}`)
+	];
+}
+/**
+* Builds the `## Problems` section: each problem rendered in the miette block format, blocks
+* separated by a blank line. Returns an empty array when there are no problems, so the caller
+* can drop the heading.
+*/
+function buildProblemSection(diagnostics) {
+	const problems = diagnostics.filter(_kubb_core.isProblemDiagnostic);
+	if (problems.length === 0) return [];
+	return [
+		"## Problems",
+		"",
+		problems.map((diagnostic) => formatDiagnostic(diagnostic).join("\n")).join("\n\n")
+	];
+}
+/**
+* Builds the `## Timings` section from a {@link Report}: one `plugin   duration` row per record,
+* slowest first with the plugin names left-aligned and the durations right-aligned. Returns an
+* empty array when there are no timings.
+*/
+function buildTimingSection(report) {
+	const { timings } = report;
+	if (timings.length === 0) return [];
+	const nameWidth = Math.max(...timings.map((timing) => timing.plugin.length));
+	const durations = timings.map((timing) => formatMs(timing.durationMs));
+	const durationWidth = Math.max(...durations.map((duration) => duration.length));
+	return [
+		"## Timings",
+		"",
+		...timings.map((timing, index) => `  ${timing.plugin.padEnd(nameWidth)}  ${durations[index].padStart(durationWidth)}`)
+	];
+}
+/**
+* The `file` reporter. Writes a config's {@link Report} to `.kubb/kubb-<name>-<timestamp>.log` as a
+* plain-text document: a `# <name> — <timestamp>` header, a `## Summary` with the same counts the
+* cli and json reporters expose, a `## Problems` section in the miette block format, and a
+* `## Timings` section. Selected with `--reporter file` (or `reporters: ['file']`), replacing the
+* old `--debug` flag.
+*
+* @note Unlike the streaming logger it replaced, it captures the collected diagnostics once a
+* config finishes, not the live `kubb:info`/`kubb:plugin` event stream. Color is stripped so the
+* file stays plain text even when the run is attached to a TTY.
+*/
+const fileReporter = (0, _kubb_core.createReporter)({
+	name: "file",
+	async report(result) {
+		const { diagnostics, config } = result;
+		if (diagnostics.length === 0) return;
+		const report = buildReport(result);
+		const content = (0, node_util.stripVTControlCharacters)([config.name ? `# ${config.name} — ${(/* @__PURE__ */ new Date()).toISOString()}` : `# ${(/* @__PURE__ */ new Date()).toISOString()}`, ...[
+			buildSummarySection(report),
+			buildProblemSection(diagnostics),
+			buildTimingSection(report)
+		].filter((section) => section.length > 0).map((section) => section.join("\n"))].join("\n\n"));
+		const baseName = `${[
+			"kubb",
+			config.name,
+			Date.now()
+		].filter(Boolean).join("-")}.log`;
+		const pathName = (0, node_path.resolve)(node_process.default.cwd(), ".kubb", baseName);
+		await write(pathName, `${content}\n`);
+		console.error(`Debug log written to ${(0, node_path.relative)(node_process.default.cwd(), pathName)}`);
+	}
+});
+//#endregion
+//#region src/reporters/jsonReporter.ts
+/**
+* The `json` reporter. `report` returns one config's {@link Report}, which {@link createReporter}
+* buffers, and `flush` writes them as a single pretty-printed JSON array on `kubb:lifecycle:end`.
+* Buffering keeps a multi-config run one valid JSON document on stdout instead of concatenated
+* objects that would break `jq .`. The terminal reporter is suppressed while `json` is active so
+* stdout stays valid JSON.
+*/
+const jsonReporter = (0, _kubb_core.createReporter)({
+	name: "json",
+	report(result) {
+		return buildReport(result);
+	},
+	flush(_context, reports) {
+		node_process.default.stdout.write(`${JSON.stringify(reports, null, 2)}\n`);
+	}
+});
+//#endregion
 //#region src/loggers/clackLogger.ts
 /**
 * TTY logger with beautiful UI and progress indicators for local development.
@@ -503,20 +782,29 @@ const clackLogger = (0, _kubb_core.defineLogger)({
 			...createProgressCounters(),
 			spinner: _clack_prompts.spinner(),
 			isSpinning: false,
+			runningPlugins: /* @__PURE__ */ new Set(),
 			activeProgress: /* @__PURE__ */ new Map(),
 			activeHookLogs: /* @__PURE__ */ new Map()
 		};
-		function reset() {
-			for (const [_key, active] of state.activeProgress) {
+		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_prompts.spinner();
 			state.isSpinning = false;
-			state.activeProgress.clear();
+			state.runningPlugins.clear();
 			state.activeHookLogs.clear();
 		}
+		function pluginProgressText() {
+			const running = [...state.runningPlugins].map((name) => (0, node_util.styleText)("bold", name));
+			return getMessage(running.length > 0 ? `Generating ${running.join(", ")}` : "Generating plugins");
+		}
 		function showProgressStep() {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const line = buildProgressLine(state);
@@ -545,8 +833,8 @@ const clackLogger = (0, _kubb_core.defineLogger)({
 			const text = getMessage([
 				(0, node_util.styleText)("blue", "ℹ"),
 				message,
-				(0, node_util.styleText)("dim", info)
-			].join(" "));
+				info ? (0, node_util.styleText)("dim", info) : void 0
+			].filter(Boolean).join(" "));
 			if (state.isSpinning) {
 				state.spinner.message(text);
 				return;
@@ -583,7 +871,7 @@ const clackLogger = (0, _kubb_core.defineLogger)({
 				return;
 			}
 			_clack_prompts.log.error(getMessage(text));
-			if (logLevel >= _kubb_core.logLevel.debug && error.stack) {
+			if (logLevel >= _kubb_core.logLevel.verbose && error.stack) {
 				const frames = error.stack.split("\n").slice(1, 4);
 				for (const frame of frames) _clack_prompts.log.message(getMessage((0, node_util.styleText)("dim", frame.trim())));
 				if (caused?.stack) {
@@ -593,10 +881,12 @@ const clackLogger = (0, _kubb_core.defineLogger)({
 				}
 			}
 		});
-		context.on("kubb:version:new", ({ currentVersion, latestVersion }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			try {
-				_clack_prompts.box(`\`v${currentVersion}\` → \`v${latestVersion}\`
+		context.on("kubb:diagnostic", ({ diagnostic }) => {
+			if (logLevel <= _kubb_core.logLevel.silent && diagnostic.severity !== "error") return;
+			stopSpinner();
+			stopActiveProgress();
+			if ((0, _kubb_core.isUpdateDiagnostic)(diagnostic)) {
+				_clack_prompts.box(`\`v${diagnostic.currentVersion}\` → \`v${diagnostic.latestVersion}\`
 Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 					width: "auto",
 					formatBorder: (s) => (0, node_util.styleText)("yellow", s),
@@ -605,14 +895,13 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 					contentAlign: "center",
 					titleAlign: "center"
 				});
-			} catch {
-				console.log(`Update available for Kubb: v${currentVersion} → v${latestVersion}`);
-				console.log("Run `npm install -g @kubb/cli` to update");
+				return;
 			}
+			_clack_prompts.log.message([diagnosticHeadline(diagnostic), ...diagnosticDetails(diagnostic)], { symbol: diagnosticSymbol(diagnostic.severity) });
 		});
 		context.on("kubb:lifecycle:start", async ({ version }) => {
 			console.log(`\n${getIntro({
-				title: "The ultimate toolkit for working with APIs",
+				title: "The meta framework for code generation",
 				description: "Ready to start",
 				version,
 				areEyesOpen: true
@@ -640,32 +929,33 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 		context.on("kubb:plugin:start", ({ plugin }) => {
 			if (logLevel <= _kubb_core.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_prompts.progress({
 				style: "block",
-				max: 100,
+				max: Math.max(state.totalPlugins, 1),
 				size: 30
 			});
-			const text = getMessage(`Generating ${(0, node_util.styleText)("bold", plugin.name)}`);
-			progressBar.start(text);
-			const interval = setInterval(() => {
-				progressBar.advance();
-			}, 100);
-			state.activeProgress.set(plugin.name, {
-				progressBar,
-				interval
-			});
+			progressBar.start(pluginProgressText());
+			progressBar.advance(state.completedPlugins + state.failedPlugins, pluginProgressText());
+			state.activeProgress.set("plugins", { progressBar });
 		});
-		context.on("kubb:plugin:end", ({ plugin, duration, success }) => {
+		context.on("kubb:plugin:end", ({ plugin, success }) => {
 			stopSpinner();
-			const active = state.activeProgress.get(plugin.name);
+			const active = state.activeProgress.get("plugins");
 			if (!active || logLevel === _kubb_core.logLevel.silent) return;
-			clearInterval(active.interval);
+			state.runningPlugins.delete(plugin.name);
 			recordPluginResult(state, success);
-			const durationStr = formatMsWithColor(duration);
-			const text = getMessage(success ? `${(0, node_util.styleText)("bold", plugin.name)} completed in ${durationStr}` : `${(0, node_util.styleText)("bold", plugin.name)} failed in ${(0, node_util.styleText)("red", formatMs(duration))}`);
-			active.progressBar.stop(text);
-			state.activeProgress.delete(plugin.name);
-			showProgressStep();
+			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 <= _kubb_core.logLevel.silent) return;
@@ -732,32 +1022,6 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				active.taskLog.error(getMessage(`${(0, node_util.styleText)("dim", commandWithArgs)} failed${reason}`), { showLog: true });
 			}
 		});
-		context.on("kubb:generation:summary", ({ config, pluginTimings, failedPlugins, filesCreated, status, hrStart }) => {
-			const summary = getSummary({
-				failedPlugins,
-				filesCreated,
-				config,
-				status,
-				hrStart,
-				pluginTimings: logLevel >= _kubb_core.logLevel.verbose ? pluginTimings : void 0
-			});
-			const title = config.name || "";
-			summary.unshift("\n");
-			summary.push("\n");
-			const borderColor = status === "success" ? "green" : "red";
-			try {
-				_clack_prompts.box(summary.join("\n"), getMessage(title), {
-					width: "auto",
-					formatBorder: (s) => (0, node_util.styleText)(borderColor, s),
-					rounded: true,
-					withGuide: false,
-					contentAlign: "left",
-					titleAlign: "center"
-				});
-			} catch {
-				console.log(summary.join("\n"));
-			}
-		});
 		context.on("kubb:lifecycle:end", () => {
 			reset();
 		});
@@ -779,114 +1043,6 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 	}
 });
 //#endregion
-//#region src/loggers/fileSystemLogger.ts
-/**
-* FileSystem logger that captures debug events and writes them to `.kubb` directory files.
-*
-* @note Logs are written on `kubb:lifecycle:end` or process exit. Cached logs may be lost if the process crashes before either event.
-*/
-const fileSystemLogger = (0, _kubb_core.defineLogger)({
-	name: "filesystem",
-	install(context) {
-		const state = {
-			cachedLogs: /* @__PURE__ */ new Set(),
-			startDate: Date.now()
-		};
-		function reset() {
-			state.cachedLogs = /* @__PURE__ */ new Set();
-			state.startDate = Date.now();
-		}
-		async function writeLogs(name) {
-			if (state.cachedLogs.size === 0) return [];
-			const files = {};
-			for (const log of state.cachedLogs) {
-				const baseName = log.fileName || `${[
-					"kubb",
-					name,
-					state.startDate
-				].filter(Boolean).join("-")}.log`;
-				const pathName = (0, node_path.resolve)(node_process.default.cwd(), ".kubb", baseName);
-				if (!files[pathName]) files[pathName] = [];
-				if (log.logs.length > 0) {
-					const prefix = `[${log.date.toLocaleString()}] `;
-					const indent = " ".repeat(prefix.length);
-					const [first, ...rest] = log.logs;
-					files[pathName].push([prefix + first, ...rest.map((line) => indent + line)].join("\n"));
-				}
-			}
-			for (const [fileName, logs] of Object.entries(files)) await write(fileName, logs.join("\n"));
-			return Object.keys(files);
-		}
-		context.on("kubb:info", ({ message, info }) => {
-			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: [`ℹ ${[message, info].filter(Boolean).join(" ")}`]
-			});
-		});
-		context.on("kubb:success", ({ message, info }) => {
-			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: [`✓ ${[message, info].filter(Boolean).join(" ")}`]
-			});
-		});
-		context.on("kubb:warn", ({ message, info }) => {
-			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: [`⚠ ${[message, info].filter(Boolean).join(" ")}`]
-			});
-		});
-		context.on("kubb:error", ({ error }) => {
-			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: [`✗ ${error.message}`, error.stack || "unknown stack"]
-			});
-		});
-		context.on("kubb:debug", ({ date, fileName, logs }) => {
-			state.cachedLogs.add({
-				date,
-				fileName,
-				logs
-			});
-		});
-		context.on("kubb:plugin:start", ({ plugin }) => {
-			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: [`► Generating ${plugin.name}`]
-			});
-		});
-		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("kubb:files:processing:start", ({ files }) => {
-			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: [`► Writing ${files.length} files`, ...files.map((file) => `  ${file.path}`)]
-			});
-		});
-		context.on("kubb:generation:end", async ({ config }) => {
-			const writtenFilePaths = await writeLogs(config.name);
-			if (writtenFilePaths.length > 0) {
-				const files = writtenFilePaths.map((f) => (0, node_path.relative)(node_process.default.cwd(), f));
-				await context.emit("kubb:info", {
-					message: "Debug files written to:",
-					info: files.join(", ")
-				});
-			}
-			reset();
-		});
-		const exitHandler = () => {
-			if (state.cachedLogs.size > 0) writeLogs().catch(() => {});
-		};
-		node_process.default.once("exit", exitHandler);
-		node_process.default.once("SIGINT", exitHandler);
-		node_process.default.once("SIGTERM", exitHandler);
-	}
-});
-//#endregion
 //#region src/loggers/githubActionsLogger.ts
 /**
 * GitHub Actions logger using group annotations for collapsible sections in CI.
@@ -973,10 +1129,9 @@ const githubActionsLogger = (0, _kubb_core.defineLogger)({
 		context.on("kubb:error", ({ error }) => {
 			const caused = require_errors.toCause(error);
 			closeAllGroups();
-			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const message = error.message || String(error);
 			console.error(`::error::${message}`);
-			if (logLevel >= _kubb_core.logLevel.debug && error.stack) {
+			if (logLevel >= _kubb_core.logLevel.verbose && error.stack) {
 				const frames = error.stack.split("\n").slice(1, 4);
 				for (const frame of frames) console.log(getMessage((0, node_util.styleText)("dim", frame.trim())));
 				if (caused?.stack) {
@@ -986,13 +1141,24 @@ const githubActionsLogger = (0, _kubb_core.defineLogger)({
 				}
 			}
 		});
+		context.on("kubb:diagnostic", ({ diagnostic }) => {
+			closeAllGroups();
+			if (logLevel <= _kubb_core.logLevel.silent && diagnostic.severity !== "error") return;
+			if (!(0, _kubb_core.isProblemDiagnostic)(diagnostic)) {
+				console.log(`::notice::${diagnostic.message}`);
+				return;
+			}
+			const parts = [`${diagnostic.code} ${diagnostic.message}`];
+			if (diagnostic.location && "pointer" in diagnostic.location) parts.push(`(at ${diagnostic.location.pointer})`);
+			if (diagnostic.plugin) parts.push(`[plugin: ${diagnostic.plugin}]`);
+			if (diagnostic.help) parts.push(`help: ${diagnostic.help}`);
+			if (diagnostic.code !== _kubb_core.diagnosticCode.unknown) parts.push(`docs: ${_kubb_core.Diagnostics.docsUrl(diagnostic.code)}`);
+			console.error(`::error::${parts.join(" ")}`);
+		});
 		context.on("kubb:lifecycle:start", ({ version }) => {
 			console.log((0, node_util.styleText)("yellow", `Kubb ${version} 🧩`));
 			reset();
 		});
-		context.on("kubb:version:new", ({ currentVersion, latestVersion }) => {
-			console.log(`::notice::Update available for Kubb: v${currentVersion} → v${latestVersion}. Run \`npm install -g @kubb/cli\` to update.`);
-		});
 		context.on("kubb:config:start", () => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const text = getMessage("Configuration started");
@@ -1051,6 +1217,7 @@ const githubActionsLogger = (0, _kubb_core.defineLogger)({
 		context.on("kubb:generation:end", ({ config }) => {
 			const text = getMessage(config.name ? `${(0, node_util.styleText)("blue", "✓")} Generation completed for ${(0, node_util.styleText)("dim", config.name)}` : `${(0, node_util.styleText)("blue", "✓")} Generation completed`);
 			console.log(text);
+			if (state.currentConfigs.length > 1) closeGroup(config.name ? `Generation for ${(0, node_util.styleText)("bold", config.name)}` : "Generation");
 		});
 		onGroupStart("kubb:format:start", "Format started", "Formatting");
 		onGroupEnd("kubb:format:end", "Format completed", "Formatting");
@@ -1078,14 +1245,6 @@ const githubActionsLogger = (0, _kubb_core.defineLogger)({
 			}
 			if (state.currentConfigs.length === 1) closeGroup(`Hook ${commandWithArgs}`);
 		});
-		context.on("kubb:generation:summary", ({ config, status, hrStart, failedPlugins }) => {
-			const pluginsCount = config.plugins?.length ?? 0;
-			const successCount = pluginsCount - failedPlugins.size;
-			const duration = formatHrtime(hrStart);
-			if (state.currentConfigs.length > 1) console.log(" ");
-			console.log(status === "success" ? `Kubb Summary: ${(0, node_util.styleText)("blue", "✓")} ${`${successCount} successful`}, ${pluginsCount} total, ${(0, node_util.styleText)("green", duration)}` : `Kubb Summary: ${(0, node_util.styleText)("blue", "✓")} ${`${successCount} successful`}, ✗ ${`${failedPlugins.size} failed`}, ${pluginsCount} total, ${(0, node_util.styleText)("green", duration)}`);
-			if (state.currentConfigs.length > 1) closeGroup(config.name ? `Generation for ${(0, node_util.styleText)("bold", config.name)}` : "Generation");
-		});
 		context.on("kubb:lifecycle:end", () => {
 			reset();
 		});
@@ -1145,7 +1304,7 @@ const plainLogger = (0, _kubb_core.defineLogger)({
 			const caused = require_errors.toCause(error);
 			const text = getMessage(["✗", error.message].join(" "));
 			console.log(text);
-			if (logLevel >= _kubb_core.logLevel.debug && error.stack) {
+			if (logLevel >= _kubb_core.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) {
@@ -1155,13 +1314,13 @@ const plainLogger = (0, _kubb_core.defineLogger)({
 				}
 			}
 		});
+		context.on("kubb:diagnostic", ({ diagnostic }) => {
+			if (logLevel <= _kubb_core.logLevel.silent && diagnostic.severity !== "error") return;
+			console.log(getMessage(formatDiagnostic(diagnostic).join("\n")));
+		});
 		context.on("kubb:lifecycle:start", ({ version }) => {
 			console.log(`Kubb CLI v${version}`);
 		});
-		context.on("kubb:version:new", ({ currentVersion, latestVersion }) => {
-			if (logLevel <= _kubb_core.logLevel.silent) return;
-			console.log(getMessage(`Update available: v${currentVersion} → v${latestVersion}. Run \`npm install -g @kubb/cli\` to update.`));
-		});
 		onStep("kubb:config:start", "Configuration started");
 		onStep("kubb:config:end", "Configuration completed");
 		context.on("kubb:generation:start", () => {
@@ -1220,19 +1379,6 @@ const plainLogger = (0, _kubb_core.defineLogger)({
 				console.log(getMessage(`✗ Hook ${commandWithArgs} failed${durationStr}${reason}`));
 			}
 		});
-		context.on("kubb:generation:summary", ({ config, pluginTimings, status, hrStart, failedPlugins, filesCreated }) => {
-			const summary = getSummary({
-				failedPlugins,
-				filesCreated,
-				config,
-				status,
-				hrStart,
-				pluginTimings: logLevel >= _kubb_core.logLevel.verbose ? pluginTimings : void 0
-			});
-			console.log(require_constants.SUMMARY_SEPARATOR);
-			console.log(summary.join("\n"));
-			console.log(require_constants.SUMMARY_SEPARATOR);
-		});
 		return (_commandWithArgs, _hookId) => ({
 			onStdout: logLevel > _kubb_core.logLevel.silent ? (s) => console.log(s) : void 0,
 			onStderr: logLevel > _kubb_core.logLevel.silent ? (s) => console.error(s) : void 0
@@ -1338,53 +1484,46 @@ const logMapper = {
 	plain: plainLogger,
 	"github-actions": githubActionsLogger
 };
-async function setupLogger(context, { logLevel }) {
-	const type = detectLogger();
-	const logger = logMapper[type];
-	if (!logger) throw new Error(`Unknown adapter type: ${type}`);
-	const makeSink = await logger.install(context, { logLevel });
-	if (logLevel >= _kubb_core.logLevel.debug) await fileSystemLogger.install(context, { logLevel });
-	return typeof makeSink === "function" ? makeSink : null;
+/**
+* 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 = node_process.default.hrtime() }) => {
+		await reporter.report({
+			config,
+			diagnostics,
+			filesCreated,
+			status,
+			hrStart
+		}, ctx);
+	});
+	if (reporter.flush) context.on("kubb:lifecycle:end", () => reporter.flush?.(ctx));
 }
 /**
-* Builds the generation summary lines rendered in the end-of-run box.
-* Returns an array of styled strings, one per summary row.
+* Installs the live logger (the TUI view) and the selected reporters (the output), returning the
+* terminal logger's hook sink when one was installed. Loggers and reporters are independent: the
+* `cli` selection activates the env logger plus the {@link cliReporter} summary.
+*
+* The `json` reporter owns stdout, so the terminal logger and `cli` summary are suppressed whenever
+* `json` is selected, even if `cli` is also listed.
 */
-function getSummary({ failedPlugins, filesCreated, status, hrStart, config, pluginTimings }) {
-	const duration = formatHrtime(hrStart);
-	const pluginsCount = config.plugins?.length ?? 0;
-	const successCount = pluginsCount - failedPlugins.size;
-	const meta = {
-		plugins: status === "success" ? `${(0, node_util.styleText)("green", `${successCount} successful`)}, ${pluginsCount} total` : `${(0, node_util.styleText)("green", `${successCount} successful`)}, ${(0, node_util.styleText)("red", `${failedPlugins.size} failed`)}, ${pluginsCount} total`,
-		pluginsFailed: status === "failed" ? [...failedPlugins].map(({ plugin }) => randomCliColor(plugin.name)).join(", ") : void 0,
-		filesCreated,
-		time: (0, node_util.styleText)("green", duration),
-		output: node_path.default.resolve(config.root, config.output.path)
-	};
-	const labels = {
-		plugins: "Plugins:",
-		failed: "Failed:",
-		generated: "Generated:",
-		pluginTimings: "Plugin Timings:",
-		output: "Output:"
-	};
-	const maxLength = Math.max(0, ...[...Object.values(labels), ...pluginTimings ? Array.from(pluginTimings.keys()) : []].map((s) => s.length));
-	const summaryLines = [];
-	summaryLines.push(`${labels.plugins.padEnd(maxLength + 2)} ${meta.plugins}`);
-	if (meta.pluginsFailed) summaryLines.push(`${labels.failed.padEnd(maxLength + 2)} ${meta.pluginsFailed}`);
-	summaryLines.push(`${labels.generated.padEnd(maxLength + 2)} ${meta.filesCreated} files in ${meta.time}`);
-	if (pluginTimings && pluginTimings.size > 0) {
-		const sortedTimings = Array.from(pluginTimings.entries()).sort((a, b) => b[1] - a[1]);
-		summaryLines.push(`${labels.pluginTimings}`);
-		sortedTimings.forEach(([name, time]) => {
-			const timeStr = time >= 1e3 ? `${(time / 1e3).toFixed(2)}s` : `${Math.round(time)}ms`;
-			const barLength = Math.min(Math.ceil(time / 100), 10);
-			const bar = (0, node_util.styleText)("dim", "█".repeat(barLength));
-			summaryLines.push(`${(0, node_util.styleText)("dim", "•")} ${name.padEnd(maxLength + 1)}${bar} ${timeStr}`);
-		});
+async function setupReporters(context, { logLevel, reporters }) {
+	const unique = new Set(reporters.length ? reporters : ["cli"]);
+	const hasJson = unique.has("json");
+	const ctx = { logLevel };
+	let makeSink = null;
+	if (unique.has("cli") && !hasJson) {
+		const type = detectLogger();
+		const logger = logMapper[type];
+		if (!logger) throw new Error(`Unknown adapter type: ${type}`);
+		const sink = await logger.install(context, { logLevel });
+		makeSink = typeof sink === "function" ? sink : null;
+		installReporter(context, cliReporter, ctx);
 	}
-	summaryLines.push(`${labels.output.padEnd(maxLength + 2)} ${meta.output}`);
-	return summaryLines;
+	if (hasJson) installReporter(context, jsonReporter, ctx);
+	if (unique.has("file")) installReporter(context, fileReporter, ctx);
+	return makeSink;
 }
 //#endregion
 //#region src/runners/generate/utils.ts
@@ -1483,7 +1622,7 @@ async function executeHooks({ configHooks, hooks, makeSink }) {
 			command: cmd,
 			args,
 			commandWithArgs,
-			context: hooks,
+			hooks,
 			stream,
 			sink: {
 				onLine,
@@ -1493,8 +1632,8 @@ async function executeHooks({ configHooks, hooks, makeSink }) {
 		});
 	}
 }
-async function runHook({ id, command, args, commandWithArgs, context, stream = false, sink }) {
-	const emitEnd = (success, error) => context.emit("kubb:hook:end", {
+async function runHook({ id, command, args, commandWithArgs, hooks, stream = false, sink }) {
+	const emitEnd = (success, error) => hooks.emit("kubb:hook:end", {
 		command,
 		args,
 		id,
@@ -1507,31 +1646,19 @@ async function runHook({ id, command, args, commandWithArgs, context, stream = f
 			throwOnError: true
 		});
 		if (stream && sink?.onLine) for await (const line of proc) sink.onLine(line);
-		const result = await proc;
-		await context.emit("kubb:debug", {
-			date: /* @__PURE__ */ new Date(),
-			logs: [result.stdout.trimEnd()]
-		});
-		await context.emit("kubb:success", { message: `${(0, node_util.styleText)("dim", commandWithArgs)} successfully executed` });
+		await proc;
+		await hooks.emit("kubb:success", { message: `${(0, node_util.styleText)("dim", commandWithArgs)} successfully executed` });
 		await emitEnd(true, null);
 	} catch (err) {
 		if (!(err instanceof tinyexec.NonZeroExitError)) {
-			const error = require_errors.toError(err);
-			await emitEnd(false, error);
-			await context.emit("kubb:error", { error });
+			await emitEnd(false, require_errors.toError(err));
 			return;
 		}
 		const stderr = err.output?.stderr ?? "";
 		const stdout = err.output?.stdout ?? "";
-		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 error = /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`);
-		await emitEnd(false, error);
-		await context.emit("kubb:error", { error });
+		await emitEnd(false, /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`));
 	}
 }
 /**
@@ -1617,7 +1744,7 @@ async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefi
 				command: toolConfig.command,
 				args: hookArgs,
 				commandWithArgs,
-				context: hooks,
+				hooks,
 				stream,
 				sink: {
 					onLine,
@@ -1627,9 +1754,7 @@ async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefi
 			}).catch(() => {});
 			await hookEndPromise;
 		} catch (caughtError) {
-			const err = require_errors.toError(caughtError);
-			await hooks.emit("kubb:error", { error: err });
-			toolError = err;
+			toolError = require_errors.toError(caughtError);
 		}
 	}
 	await onEnd();
@@ -1658,7 +1783,7 @@ async function generate(options) {
 		message: config.name ? `Build generation ${(0, node_util.styleText)("bold", config.name)}` : "Build generation",
 		info: inputPath
 	});
-	const { files, failedPlugins, pluginTimings, error, driver } = await kubb.safeBuild();
+	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,
@@ -1672,34 +1797,28 @@ async function generate(options) {
 		filesCreated: files.length,
 		status
 	}));
-	if (failedPlugins.size > 0 || error) {
-		const allErrors = [error, ...Array.from(failedPlugins, (it) => it.error)].filter(Boolean);
-		for (const err of allErrors) await hooks.emit("kubb:error", { error: err });
+	for (const diagnostic of diagnostics) {
+		if (!(0, _kubb_core.isProblemDiagnostic)(diagnostic)) continue;
+		const unknown = (0, _kubb_core.narrowDiagnostic)(diagnostic, _kubb_core.diagnosticCode.unknown);
+		if (unknown) await hooks.emit("kubb:error", { error: unknown.cause ?? new Error(unknown.message) });
+		else await _kubb_core.Diagnostics.emit(hooks, diagnostic);
+	}
+	if (_kubb_core.Diagnostics.hasError(diagnostics)) {
 		await hooks.emit("kubb:generation:end", {
 			config,
-			storage: kubb.storage
-		});
-		await hooks.emit("kubb:generation:summary", {
-			config,
-			failedPlugins,
+			storage: kubb.storage,
+			diagnostics,
 			filesCreated: files.length,
 			status: "failed",
-			hrStart,
-			pluginTimings: logLevel >= _kubb_core.logLevel.verbose ? pluginTimings : void 0
+			hrStart
 		});
 		await reportTelemetry("failed");
 		return false;
 	}
-	await hooks.emit("kubb:success", {
-		message: "Generation succeeded",
-		info: inputPath
-	});
-	await hooks.emit("kubb:generation:end", {
-		config,
-		storage: kubb.storage
-	});
 	const outputPath = node_path.default.resolve(config.root, config.output.path);
+	const outputDiagnostics = [];
 	const toolPasses = [config.output.format && {
+		code: _kubb_core.diagnosticCode.formatFailed,
 		toolValue: config.output.format,
 		detect: detectFormatter,
 		toolMap: formatters,
@@ -1709,6 +1828,7 @@ async function generate(options) {
 		onStart: () => hooks.emit("kubb:format:start"),
 		onEnd: () => hooks.emit("kubb:format:end")
 	}, config.output.lint && {
+		code: _kubb_core.diagnosticCode.lintFailed,
 		toolValue: config.output.lint,
 		detect: detectLinter,
 		toolMap: linters,
@@ -1718,64 +1838,121 @@ async function generate(options) {
 		onStart: () => hooks.emit("kubb:lint:start"),
 		onEnd: () => hooks.emit("kubb:lint:end")
 	}].filter(Boolean);
-	for (const pass of toolPasses) await runToolPass({
-		...pass,
-		configName: config.name,
-		outputPath,
-		logLevel,
-		hooks,
-		makeSink
-	});
-	if (config.hooks) {
-		await hooks.emit("kubb:hooks:start");
-		await executeHooks({
-			configHooks: config.hooks,
+	for (const { code, ...pass } of toolPasses) try {
+		await runToolPass({
+			...pass,
+			configName: config.name,
+			outputPath,
+			logLevel,
 			hooks,
 			makeSink
 		});
+	} catch (caughtError) {
+		const diagnostic = outputDiagnostic(code, pass.toolLabel, caughtError);
+		outputDiagnostics.push(diagnostic);
+		await _kubb_core.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,
+				makeSink
+			});
+		} finally {
+			hooks.off("kubb:hook:end", onHookEnd);
+		}
+		for (const error of hookFailures) {
+			const diagnostic = outputDiagnostic(_kubb_core.diagnosticCode.hookFailed, "Post-generate hook", error);
+			outputDiagnostics.push(diagnostic);
+			await _kubb_core.Diagnostics.emit(hooks, diagnostic);
+		}
 		await hooks.emit("kubb:hooks:end");
 	}
-	await hooks.emit("kubb:generation:summary", {
+	const finalDiagnostics = [...diagnostics, ...outputDiagnostics];
+	const failed = _kubb_core.Diagnostics.hasError(outputDiagnostics);
+	if (!failed) await hooks.emit("kubb:success", {
+		message: "Generation succeeded",
+		info: inputPath
+	});
+	await hooks.emit("kubb:generation:end", {
 		config,
-		failedPlugins,
+		storage: kubb.storage,
+		diagnostics: finalDiagnostics,
 		filesCreated: files.length,
-		status: "success",
-		hrStart,
-		pluginTimings
+		status: failed ? "failed" : "success",
+		hrStart
 	});
-	await reportTelemetry("success");
-	return true;
+	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 = require_errors.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) {
 	await require_telemetry.executeIfOnline(async () => {
 		try {
 			const data = await (await fetch(require_constants.KUBB_NPM_PACKAGE_URL)).json();
-			if (data.version && require_package.version < data.version) await hooks.emit("kubb:version:new", {
+			if (data.version && require_package.version < data.version) await _kubb_core.Diagnostics.emit(hooks, _kubb_core.Diagnostics.update({
 				currentVersion: require_package.version,
 				latestVersion: data.version
-			});
+			}));
 		} catch {}
 	});
 }
 /**
 * Runs the full Kubb generation lifecycle for the given CLI options.
-* Sets up the logger, checks for a newer version, loads configs, and calls `generate` for each config entry.
+* Loads configs, sets up the selected reporters (CLI `--reporter` overrides `config.reporters`),
+* checks for a newer version, and calls `generate` for each config entry.
 */
-async function run({ input, configPath, logLevel: logLevelKey, watch }) {
+async function run({ input, configPath, logLevel: logLevelKey, watch, reporters: cliReporters }) {
 	const logLevel = _kubb_core.logLevel[logLevelKey] ?? _kubb_core.logLevel.info;
 	const hooks = new AsyncEventEmitter();
-	const makeSink = await setupLogger(hooks, { logLevel });
-	await hooks.emit("kubb:lifecycle:start", { version: require_package.version });
-	await checkForUpdate(hooks);
+	let configs;
+	let resolvedConfigPath;
 	try {
-		await hooks.emit("kubb:config:start");
-		const { configs, configPath: resolvedConfigPath } = await getConfigs({
+		const loaded = await getConfigs({
 			configPath,
 			input,
 			watch,
 			logLevel: logLevelKey
 		});
+		configs = loaded.configs;
+		resolvedConfigPath = loaded.configPath;
+	} catch (error) {
+		await setupReporters(hooks, {
+			logLevel,
+			reporters: ["cli"]
+		});
+		await hooks.emit("kubb:error", { error: require_errors.toError(error) });
+		node_process.default.exit(1);
+	}
+	const makeSink = await setupReporters(hooks, {
+		logLevel,
+		reporters: cliReporters?.length ? cliReporters : configs[0]?.reporters ?? ["cli"]
+	});
+	await hooks.emit("kubb:lifecycle:start", { version: require_package.version });
+	await checkForUpdate(hooks);
+	try {
 		const relativeConfigPath = node_path.default.relative(node_process.default.cwd(), resolvedConfigPath);
+		await hooks.emit("kubb:config:start");
 		await hooks.emit("kubb:info", {
 			message: "Config loaded",
 			info: relativeConfigPath
@@ -1821,4 +1998,4 @@ async function run({ input, configPath, logLevel: logLevelKey, watch }) {
 //#endregion
 exports.run = run;
 
-//# sourceMappingURL=run-GvXhj9XF.cjs.map
+//# sourceMappingURL=run-BFZtWpcW.cjs.map