@kubb/cli 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/{generate-CNrRLY4n.js → run-CHZKHTv0.js}

@@ -1,23 +1,21 @@
-import "./chunk--u3MIqq1.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-LgT_sdPe.js";
-import { n as tokenize } from "./shell-DLzN4fRo.js";
-import { t as version } from "./package-DyJE-qNq.js";
-import { a as SUMMARY_SEPARATOR, n as KUBB_NPM_PACKAGE_URL, o as WATCHER_IGNORED_PATHS } from "./constants-aL3CP_Wq.js";
+import "./chunk-CRm0XQPb.js";
+import { n as toCause, r as toError } from "./errors-CoxrNXaA.js";
+import { n as tokenize } from "./shell-BrqyJdB7.js";
+import { t as version } from "./package-CR5vEK4K.js";
+import { r as WATCHER_IGNORED_PATHS, t as KUBB_NPM_PACKAGE_URL } from "./constants-84a47qA-.js";
 import { styleText } from "node:util";
 import { EventEmitter } from "node:events";
 import { createHash } from "node:crypto";
 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 { existsSync } from "node:fs";
+import path, { relative } from "node:path";
+import { promises } from "node:dns";
+import { Diagnostics, Telemetry, cliReporter, createKubb, defineLogger, logLevel, selectReporters } from "@kubb/core";
 import process$1 from "node:process";
 import * as clack from "@clack/prompts";
-import { createKubb, defineLogger, isInputPath, logLevel } from "@kubb/core";
-import { NonZeroExitError, x } from "tinyexec";
-import { Writable } from "node:stream";
 import { cosmiconfig } from "cosmiconfig";
-import { unrun } from "unrun";
+import { createJiti } from "jiti";
+import { NonZeroExitError, x } from "tinyexec";
 //#region ../../internals/utils/src/asyncEventEmitter.ts
 /**
 * Typed `EventEmitter` that awaits all async listeners before resolving.
@@ -48,9 +46,12 @@ var AsyncEventEmitter = class {
 	* await emitter.emit('build', 'petstore')
 	* ```
 	*/
-	async emit(eventName, ...eventArgs) {
+	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) {
@@ -113,6 +114,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
@@ -265,32 +284,6 @@ function getIntro({ title, description, version, areEyesOpen }) {
 `;
 }
 /**
-* ANSI color names used by {@link randomCliColor} for deterministic terminal coloring.
-*/
-const randomColors = [
-	"black",
-	"red",
-	"green",
-	"yellow",
-	"blue",
-	"white",
-	"magenta",
-	"cyan",
-	"gray"
-];
-/**
-* 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 a threshold-based ANSI color.
 * `≤ 500 ms` → green · `≤ 1 000 ms` → yellow · `> 1 000 ms` → red.
 *
@@ -308,6 +301,55 @@ function formatMsWithColor(ms) {
 	return styleText("red", formatted);
 }
 //#endregion
+//#region ../../internals/utils/src/env.ts
+/**
+* Returns `true` when running inside a GitHub Actions workflow.
+*
+* @example
+* ```ts
+* if (isGitHubActions()) {
+*   core.setOutput('result', 'ok')
+* }
+* ```
+*/
+function isGitHubActions() {
+	return !!process.env.GITHUB_ACTIONS;
+}
+/**
+* Returns `true` when the process is running in a CI environment.
+* Covers GitHub Actions, GitLab CI, CircleCI, Travis CI, Jenkins, Bitbucket,
+* TeamCity, Buildkite, and Azure Pipelines.
+*
+* @example
+* ```ts
+* if (isCIEnvironment()) {
+*   logger.level = 'error'
+* }
+* ```
+*/
+function isCIEnvironment() {
+	return !!(process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.BITBUCKET_BUILD_NUMBER || process.env.JENKINS_URL || process.env.CIRCLECI || process.env.TRAVIS || process.env.TEAMCITY_VERSION || process.env.BUILDKITE || process.env.TF_BUILD);
+}
+/**
+* Returns `true` when the process has an interactive TTY with a valid terminal
+* width and is not running in CI.
+*
+* Some IDE-embedded terminals report `isTTY = true` but set `columns` to `0`,
+* which breaks clack's box-drawing helpers (they call `String.prototype.repeat`
+* with a negative count and throw a `RangeError`).  We therefore require a
+* positive column count before declaring the TTY usable.
+*
+* @example
+* ```ts
+* if (canUseTTY()) {
+*   renderProgressBar()
+* }
+* ```
+*/
+function canUseTTY() {
+	return !!process.stdout.isTTY && (process.stdout.columns ?? 0) > 0 && !isCIEnvironment();
+}
+//#endregion
 //#region ../../internals/utils/src/formatters.ts
 /**
 * CLI command descriptors for each supported code formatter.
@@ -372,62 +414,8 @@ async function detectFormatter() {
 	return null;
 }
 //#endregion
-//#region ../../internals/utils/src/fs.ts
-/**
-* Writes `data` to `path`, trimming leading/trailing whitespace before saving.
-* 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.
-*
-* @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 null;
-	const resolved = resolve(path);
-	if (typeof Bun !== "undefined") {
-		const file = Bun.file(resolved);
-		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 null;
-	} catch {}
-	await mkdir(dirname(resolved), { recursive: true });
-	await writeFile(resolved, trimmed, { encoding: "utf-8" });
-	if (options.sanity) {
-		const savedData = await readFile(resolved, { encoding: "utf-8" });
-		if (savedData !== trimmed) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
-		return savedData;
-	}
-	return trimmed;
-}
-//#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
@@ -451,7 +439,11 @@ const linters = {
 	},
 	oxlint: {
 		command: "oxlint",
-		args: (outputPath) => ["--fix", ...findLintableFiles(outputPath)],
+		args: (outputPath) => [
+			"--fix",
+			"--no-ignore",
+			outputPath
+		],
 		errorMessage: "Oxlint not found"
 	}
 };
@@ -486,112 +478,51 @@ async function detectLinter() {
 	return null;
 }
 //#endregion
-//#region src/utils/getSummary.ts
-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" ? `${styleText("green", `${successCount} successful`)}, ${pluginsCount} total` : `${styleText("green", `${successCount} successful`)}, ${styleText("red", `${failedPlugins.size} failed`)}, ${pluginsCount} total`,
-		pluginsFailed: status === "failed" ? [...failedPlugins].map(({ plugin }) => randomCliColor(plugin.name)).join(", ") : void 0,
-		filesCreated,
-		time: styleText("green", duration),
-		output: path.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 = styleText("dim", "█".repeat(barLength));
-			summaryLines.push(`${styleText("dim", "•")} ${name.padEnd(maxLength + 1)}${bar} ${timeStr}`);
-		});
-	}
-	summaryLines.push(`${labels.output.padEnd(maxLength + 2)} ${meta.output}`);
-	return summaryLines;
+//#region ../../internals/utils/src/network.ts
+/**
+* Well-known stable domains used as DNS probes to check internet connectivity.
+*/
+const TEST_DOMAINS = [
+	"dns.google.com",
+	"cloudflare.com",
+	"one.one.one.one"
+];
+/**
+* Returns `true` when the system has internet connectivity.
+* Probes DNS resolution against well-known stable domains.
+*
+* @example
+* ```ts
+* if (await isOnline()) {
+*   await fetchLatestVersion()
+* }
+* ```
+*/
+async function isOnline() {
+	for (const domain of TEST_DOMAINS) try {
+		await promises.resolve(domain);
+		return true;
+	} catch {}
+	return false;
 }
-//#endregion
-//#region src/utils/runHook.ts
 /**
-* Executes a hook command, emits debug and completion events, and forwards output to an optional sink.
+* Executes `fn` only when the system is online. Returns `null` when offline or on error.
+*
+* @example
+* ```ts
+* const version = await executeIfOnline(() => fetchLatestVersion('kubb'))
+* // null when offline
+* ```
 */
-async function runHook({ id, command, args, commandWithArgs, context, stream = false, sink }) {
+async function executeIfOnline(fn) {
+	if (!await isOnline()) return null;
 	try {
-		const proc = x(command, [...args ?? []], {
-			nodeOptions: { detached: process.platform !== "win32" },
-			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:hook:end", {
-			command,
-			args,
-			id,
-			success: true,
-			error: null
-		});
-	} catch (err) {
-		if (!(err instanceof NonZeroExitError)) {
-			await context.emit("kubb:hook:end", {
-				command,
-				args,
-				id,
-				success: false,
-				error: toError(err)
-			});
-			await context.emit("kubb:error", { error: 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 errorMessage = /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`);
-		await context.emit("kubb:hook:end", {
-			command,
-			args,
-			id,
-			success: false,
-			error: errorMessage
-		});
-		await context.emit("kubb:error", { error: errorMessage });
+		return await fn();
+	} catch {
+		return null;
 	}
 }
 //#endregion
-//#region src/utils/Writables.ts
-var ClackWritable = class extends Writable {
-	taskLog;
-	constructor(taskLog, opts) {
-		super(opts);
-		this.taskLog = taskLog;
-	}
-	_write(chunk, _encoding, callback) {
-		this.taskLog.message(`${styleText("dim", chunk.toString())}`);
-		callback();
-	}
-};
-//#endregion
 //#region src/loggers/clackLogger.ts
 /**
 * TTY logger with beautiful UI and progress indicators for local development.
@@ -599,84 +530,101 @@ var ClackWritable = class extends Writable {
 const clackLogger = defineLogger({
 	name: "clack",
 	install(context, options) {
-		const logLevel$8 = options?.logLevel ?? logLevel.info;
+		const logLevel$6 = options?.logLevel ?? logLevel.info;
 		const state = {
-			totalPlugins: 0,
-			completedPlugins: 0,
-			failedPlugins: 0,
-			totalFiles: 0,
-			processedFiles: 0,
-			hrStart: process$1.hrtime(),
+			...createProgressCounters(),
 			spinner: clack.spinner(),
 			isSpinning: false,
-			activeProgress: /* @__PURE__ */ new Map()
+			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.totalPlugins = 0;
-			state.completedPlugins = 0;
-			state.failedPlugins = 0;
-			state.totalFiles = 0;
-			state.processedFiles = 0;
-			state.hrStart = process$1.hrtime();
+			state.activeProgress.clear();
+		}
+		function reset() {
+			stopActiveProgress();
+			resetProgressCounters(state);
 			state.spinner = clack.spinner();
 			state.isSpinning = false;
-			state.activeProgress.clear();
+			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$8 <= logLevel.silent) return;
+			if (logLevel$6 <= logLevel.silent) return;
 			const line = buildProgressLine(state);
 			if (line) clack.log.step(getMessage(line));
 		}
 		function getMessage(message) {
-			return formatMessage(message, logLevel$8);
+			return formatMessage(message, logLevel$6);
+		}
+		function onStep(event, message) {
+			context.on(event, () => {
+				if (logLevel$6 <= logLevel.silent) return;
+				clack.log.step(getMessage(message));
+			});
 		}
 		function startSpinner(text) {
 			state.spinner.start(text);
 			state.isSpinning = true;
 		}
 		function stopSpinner(text) {
+			if (!state.isSpinning) return;
 			state.spinner.stop(text);
 			state.isSpinning = false;
 		}
 		context.on("kubb:info", ({ message, info = "" }) => {
-			if (logLevel$8 <= logLevel.silent) return;
+			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("blue", "ℹ"),
 				message,
-				styleText("dim", info)
-			].join(" "));
-			if (state.isSpinning) state.spinner.message(text);
-			else clack.log.info(text);
+				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$8 <= logLevel.silent) return;
+			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("blue", "✓"),
 				message,
-				logLevel$8 >= logLevel.info ? styleText("dim", info) : void 0
+				logLevel$6 >= logLevel.info ? styleText("dim", info) : void 0
 			].filter(Boolean).join(" "));
-			if (state.isSpinning) stopSpinner(text);
-			else clack.log.success(text);
+			if (state.isSpinning) {
+				stopSpinner(text);
+				return;
+			}
+			clack.log.success(text);
 		});
 		context.on("kubb:warn", ({ message, info }) => {
-			if (logLevel$8 < logLevel.warn) return;
+			if (logLevel$6 < logLevel.warn) return;
 			const text = getMessage([
 				styleText("yellow", "⚠"),
 				message,
-				logLevel$8 >= logLevel.info && info ? styleText("dim", info) : void 0
+				logLevel$6 >= 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));
-			else clack.log.error(getMessage(text));
-			if (logLevel$8 >= logLevel.debug && error.stack) {
+			if (state.isSpinning) {
+				stopSpinner(getMessage(text));
+				return;
+			}
+			clack.log.error(getMessage(text));
+			if (logLevel$6 >= 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) {
@@ -686,10 +634,12 @@ const clackLogger = defineLogger({
 				}
 			}
 		});
-		context.on("kubb:version:new", ({ currentVersion, latestVersion }) => {
-			if (logLevel$8 <= logLevel.silent) return;
-			try {
-				clack.box(`\`v${currentVersion}\` → \`v${latestVersion}\`
+		context.on("kubb:diagnostic", ({ diagnostic }) => {
+			if (logLevel$6 <= 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),
@@ -698,14 +648,14 @@ 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;
 			}
+			const { symbol, headline, details } = Diagnostics.format(diagnostic);
+			clack.log.message([headline, ...details], { symbol });
 		});
 		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
@@ -713,55 +663,56 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			reset();
 		});
 		context.on("kubb:config:start", () => {
-			if (logLevel$8 <= logLevel.silent) return;
+			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage("Configuration started");
 			clack.intro(text);
 			startSpinner(getMessage("Configuration loading"));
 		});
 		context.on("kubb:config:end", () => {
-			if (logLevel$8 <= logLevel.silent) return;
+			if (logLevel$6 <= logLevel.silent) return;
 			const text = getMessage("Configuration completed");
 			clack.outro(text);
 		});
 		context.on("kubb:generation:start", ({ config }) => {
 			reset();
 			state.totalPlugins = config.plugins?.length ?? 0;
+			if (logLevel$6 <= 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$8 <= logLevel.silent) return;
+			if (logLevel$6 <= 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: 100,
+				max: Math.max(state.totalPlugins, 1),
 				size: 30
 			});
-			const text = getMessage(`Generating ${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);
-			if (!active || logLevel$8 === logLevel.silent) return;
-			clearInterval(active.interval);
-			if (success) state.completedPlugins++;
-			else state.failedPlugins++;
-			const durationStr = formatMsWithColor(duration);
-			const text = getMessage(success ? `${styleText("bold", plugin.name)} completed in ${durationStr}` : `${styleText("bold", plugin.name)} failed in ${styleText("red", formatMs(duration))}`);
-			active.progressBar.stop(text);
-			state.activeProgress.delete(plugin.name);
-			showProgressStep();
+			const active = state.activeProgress.get("plugins");
+			if (!active || logLevel$6 === 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$8 <= logLevel.silent) return;
+			if (logLevel$6 <= logLevel.silent) return;
 			stopSpinner();
 			state.totalFiles = files.length;
 			state.processedFiles = 0;
@@ -775,17 +726,17 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			progressBar.start(getMessage(text));
 			state.activeProgress.set("files", { progressBar });
 		});
-		context.on("kubb:file:processing:update", ({ file, config }) => {
-			if (logLevel$8 <= logLevel.silent) return;
+		context.on("kubb:files:processing:update", ({ files }) => {
+			if (logLevel$6 <= logLevel.silent) return;
 			stopSpinner();
-			state.processedFiles++;
-			const text = `Writing ${relative(config.root, file.path)}`;
 			const active = state.activeProgress.get("files");
-			if (!active) return;
-			active.progressBar.advance(void 0, text);
+			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$8 <= logLevel.silent) return;
+			if (logLevel$6 <= logLevel.silent) return;
 			stopSpinner();
 			const text = getMessage("Files written successfully");
 			const active = state.activeProgress.get("files");
@@ -795,202 +746,54 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			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);
 		});
-		context.on("kubb:format:start", () => {
-			if (logLevel$8 <= logLevel.silent) return;
-			const text = getMessage("Format started");
-			clack.intro(text);
-		});
-		context.on("kubb:format:end", () => {
-			if (logLevel$8 <= logLevel.silent) return;
-			const text = getMessage("Format completed");
-			clack.outro(text);
-		});
-		context.on("kubb:lint:start", () => {
-			if (logLevel$8 <= logLevel.silent) return;
-			const text = getMessage("Lint started");
-			clack.intro(text);
-		});
-		context.on("kubb:lint:end", () => {
-			if (logLevel$8 <= logLevel.silent) return;
-			const text = getMessage("Lint completed");
-			clack.outro(text);
-		});
-		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;
-			if (logLevel$8 <= logLevel.silent) {
-				await runHook({
-					id,
-					command,
-					args,
-					commandWithArgs,
-					context,
-					sink: {
-						onStderr: (s) => console.error(s),
-						onStdout: (s) => console.log(s)
-					}
-				});
-				return;
-			}
-			clack.intro(text);
-			const logger = clack.taskLog({ title: getMessage(["Executing hook", logLevel$8 >= logLevel.info ? styleText("dim", commandWithArgs) : void 0].filter(Boolean).join(" ")) });
-			const writable = new ClackWritable(logger);
-			await runHook({
-				id,
-				command,
-				args,
-				commandWithArgs,
-				context,
-				stream: true,
-				sink: {
-					onLine: (line) => writable.write(line),
-					onStderr: (s) => logger.error(s),
-					onStdout: (s) => logger.message(s)
-				}
+		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$6 <= 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()
 			});
 		});
-		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("kubb:generation:summary", ({ config, pluginTimings, failedPlugins, filesCreated, status, hrStart }) => {
-			const summary = getSummary({
-				failedPlugins,
-				filesCreated,
-				config,
-				status,
-				hrStart,
-				pluginTimings: logLevel$8 >= logLevel.verbose ? pluginTimings : void 0
-			});
-			const title = config.name || "";
-			summary.unshift("\n");
-			summary.push("\n");
-			const borderColor = status === "success" ? "green" : "red";
-			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("kubb:hook:end", ({ id, command, args, success, error }) => {
+			if (logLevel$6 <= logLevel.silent || !id) 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/fileSystemLogger.ts
-/**
-* FileSystem logger that captures debug events and writes them to `.kubb` directory files.
-* Note: Logs write on `lifecycle:end` or process exit. Cached logs may be lost if the process crashes before these events.
-*/
-const fileSystemLogger = 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 = resolve(process$1.cwd(), ".kubb", baseName);
-				if (!files[pathName]) files[pathName] = [];
-				if (log.logs.length > 0) {
-					const timestamp = log.date.toLocaleString();
-					files[pathName].push(`[${timestamp}]\n${log.logs.join("\n")}`);
-				}
-			}
-			for (const [fileName, logs] of Object.entries(files)) await write(fileName, logs.join("\n\n"));
-			return Object.keys(files);
-		}
-		context.on("kubb:info", ({ message, info }) => {
-			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: [`ℹ ${message} ${info}`]
-			});
-		});
-		context.on("kubb:success", ({ message, info }) => {
-			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: [`✓ ${message} ${info}`]
-			});
-		});
-		context.on("kubb:warn", ({ message, info }) => {
-			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: [`⚠ ${message} ${info}`]
-			});
-		});
-		context.on("kubb:error", ({ error }) => {
-			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: [`✗ ${error.message}`, error.stack || "unknown stack"]
-			});
-		});
-		context.on("kubb:debug", (message) => {
-			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: message.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: [`Start ${files.length} writing:`, ...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) => relative(process$1.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(() => {});
+		return (_commandWithArgs, hookId) => {
+			if (logLevel$6 <= logLevel.silent) return {
+				onStdout: (s) => console.log(s),
+				onStderr: (s) => console.error(s)
+			};
+			const active = state.activeHookLogs.get(hookId);
+			if (!active) return null;
+			const { taskLog } = active;
+			return {
+				stream: true,
+				onLine: (line) => taskLog.message(styleText("dim", line)),
+				onStdout: (s) => taskLog.message(s),
+				onStderr: (s) => taskLog.message(styleText("red", s))
+			};
 		};
-		process$1.once("exit", exitHandler);
-		process$1.once("SIGINT", exitHandler);
-		process$1.once("SIGTERM", exitHandler);
 	}
 });
 //#endregion
@@ -1001,41 +804,57 @@ const fileSystemLogger = defineLogger({
 const githubActionsLogger = defineLogger({
 	name: "github-actions",
 	install(context, options) {
-		const logLevel$7 = options?.logLevel ?? logLevel.info;
+		const logLevel$5 = options?.logLevel ?? logLevel.info;
 		const state = {
-			totalPlugins: 0,
-			completedPlugins: 0,
-			failedPlugins: 0,
-			totalFiles: 0,
-			processedFiles: 0,
-			hrStart: process.hrtime(),
-			currentConfigs: []
+			...createProgressCounters(),
+			currentConfigs: [],
+			openGroupDepth: 0
 		};
+		const hookTimer = createHookTimer();
 		function reset() {
-			state.totalPlugins = 0;
-			state.completedPlugins = 0;
-			state.failedPlugins = 0;
-			state.totalFiles = 0;
-			state.processedFiles = 0;
-			state.hrStart = process.hrtime();
+			closeAllGroups();
+			resetProgressCounters(state);
 			state.currentConfigs = [];
+			hookTimer.clear();
 		}
 		function showProgressStep() {
-			if (logLevel$7 <= logLevel.silent) return;
+			if (logLevel$5 <= logLevel.silent) return;
 			const line = buildProgressLine(state);
 			if (line) console.log(getMessage(line));
 		}
 		function getMessage(message) {
-			return formatMessage(message, logLevel$7);
+			return formatMessage(message, logLevel$5);
 		}
 		function openGroup(name) {
 			console.log(`::group::${name}`);
+			state.openGroupDepth++;
 		}
 		function closeGroup(_name) {
 			console.log("::endgroup::");
+			if (state.openGroupDepth > 0) state.openGroupDepth--;
+		}
+		function closeAllGroups() {
+			while (state.openGroupDepth > 0) {
+				console.log("::endgroup::");
+				state.openGroupDepth--;
+			}
+		}
+		function onGroupStart(event, message, group) {
+			context.on(event, () => {
+				if (logLevel$5 <= logLevel.silent) return;
+				if (state.currentConfigs.length === 1) openGroup(group);
+				console.log(getMessage(message));
+			});
+		}
+		function onGroupEnd(event, message, group) {
+			context.on(event, () => {
+				if (logLevel$5 <= logLevel.silent) return;
+				console.log(getMessage(message));
+				if (state.currentConfigs.length === 1) closeGroup(group);
+			});
 		}
 		context.on("kubb:info", ({ message, info = "" }) => {
-			if (logLevel$7 <= logLevel.silent) return;
+			if (logLevel$5 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("blue", "ℹ"),
 				message,
@@ -1044,29 +863,29 @@ const githubActionsLogger = defineLogger({
 			console.log(text);
 		});
 		context.on("kubb:success", ({ message, info = "" }) => {
-			if (logLevel$7 <= logLevel.silent) return;
+			if (logLevel$5 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("blue", "✓"),
 				message,
-				logLevel$7 >= logLevel.info ? styleText("dim", info) : void 0
+				logLevel$5 >= logLevel.info ? styleText("dim", info) : void 0
 			].filter(Boolean).join(" "));
 			console.log(text);
 		});
 		context.on("kubb:warn", ({ message, info = "" }) => {
-			if (logLevel$7 <= logLevel.silent) return;
+			if (logLevel$5 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("yellow", "⚠"),
 				message,
-				logLevel$7 >= logLevel.info ? styleText("dim", info) : void 0
+				logLevel$5 >= logLevel.info ? styleText("dim", info) : void 0
 			].filter(Boolean).join(" "));
 			console.warn(`::warning::${text}`);
 		});
 		context.on("kubb:error", ({ error }) => {
 			const caused = toCause(error);
-			if (logLevel$7 <= logLevel.silent) return;
+			closeAllGroups();
 			const message = error.message || String(error);
 			console.error(`::error::${message}`);
-			if (logLevel$7 >= logLevel.debug && error.stack) {
+			if (logLevel$5 >= logLevel.verbose && error.stack) {
 				const frames = error.stack.split("\n").slice(1, 4);
 				for (const frame of frames) console.log(getMessage(styleText("dim", frame.trim())));
 				if (caused?.stack) {
@@ -1076,19 +895,33 @@ const githubActionsLogger = defineLogger({
 				}
 			}
 		});
+		context.on("kubb:diagnostic", ({ diagnostic }) => {
+			closeAllGroups();
+			if (logLevel$5 <= logLevel.silent && diagnostic.severity !== "error") return;
+			if (!Diagnostics.isProblem(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 !== Diagnostics.code.unknown) parts.push(`docs: ${Diagnostics.docsUrl(diagnostic.code)}`);
+			console.error(`::error::${parts.join(" ")}`);
+		});
 		context.on("kubb:lifecycle:start", ({ version }) => {
 			console.log(styleText("yellow", `Kubb ${version} 🧩`));
 			reset();
 		});
 		context.on("kubb:config:start", () => {
-			if (logLevel$7 <= logLevel.silent) return;
+			if (logLevel$5 <= logLevel.silent) return;
 			const text = getMessage("Configuration started");
 			openGroup("Configuration");
 			console.log(text);
 		});
 		context.on("kubb:config:end", ({ configs }) => {
 			state.currentConfigs = configs;
-			if (logLevel$7 <= logLevel.silent) return;
+			if (logLevel$5 <= logLevel.silent) return;
 			const text = getMessage("Configuration completed");
 			console.log(text);
 			closeGroup("Configuration");
@@ -1101,15 +934,14 @@ const githubActionsLogger = defineLogger({
 			if (state.currentConfigs.length === 1) console.log(getMessage(text));
 		});
 		context.on("kubb:plugin:start", ({ plugin }) => {
-			if (logLevel$7 <= logLevel.silent) return;
+			if (logLevel$5 <= 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("kubb:plugin:end", ({ plugin, duration, success }) => {
-			if (logLevel$7 <= logLevel.silent) return;
-			if (success) state.completedPlugins++;
-			else state.failedPlugins++;
+			if (logLevel$5 <= logLevel.silent) return;
+			recordPluginResult(state, success);
 			const durationStr = formatMsWithColor(duration);
 			const text = getMessage(success ? `${styleText("bold", plugin.name)} completed in ${durationStr}` : `${styleText("bold", plugin.name)} failed in ${styleText("red", formatMs(duration))}`);
 			console.log(text);
@@ -1118,7 +950,7 @@ const githubActionsLogger = defineLogger({
 			showProgressStep();
 		});
 		context.on("kubb:files:processing:start", ({ files }) => {
-			if (logLevel$7 <= logLevel.silent) return;
+			if (logLevel$5 <= logLevel.silent) return;
 			state.totalFiles = files.length;
 			state.processedFiles = 0;
 			if (state.currentConfigs.length === 1) openGroup("File Generation");
@@ -1126,82 +958,54 @@ const githubActionsLogger = defineLogger({
 			console.log(text);
 		});
 		context.on("kubb:files:processing:end", () => {
-			if (logLevel$7 <= logLevel.silent) return;
+			if (logLevel$5 <= logLevel.silent) return;
 			const text = getMessage("Files written successfully");
 			console.log(text);
 			if (state.currentConfigs.length === 1) closeGroup("File Generation");
 			showProgressStep();
 		});
-		context.on("kubb:file:processing:update", () => {
-			if (logLevel$7 <= logLevel.silent) return;
-			state.processedFiles++;
+		context.on("kubb:files:processing:update", ({ files }) => {
+			if (logLevel$5 <= logLevel.silent) return;
+			state.processedFiles += files.length;
 		});
 		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);
+			if (state.currentConfigs.length > 1) closeGroup(config.name ? `Generation for ${styleText("bold", config.name)}` : "Generation");
 		});
-		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("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("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("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("kubb:hook:start", async ({ id, command, args }) => {
+		onGroupStart("kubb:format:start", "Format started", "Formatting");
+		onGroupEnd("kubb:format:end", "Format completed", "Formatting");
+		onGroupStart("kubb:lint:start", "Lint started", "Linting");
+		onGroupEnd("kubb:lint:end", "Lint completed", "Linting");
+		onGroupStart("kubb:hooks:start", "Hooks started", "Hooks");
+		onGroupEnd("kubb:hooks:end", "Hooks completed", "Hooks");
+		context.on("kubb:hook:start", ({ id, command, args }) => {
+			if (logLevel$5 <= logLevel.silent) return;
+			if (id) hookTimer.start(id);
 			const commandWithArgs = formatCommandWithArgs(command, args);
 			const text = getMessage(`Hook ${styleText("dim", commandWithArgs)} started`);
-			if (logLevel$7 > logLevel.silent) {
-				if (state.currentConfigs.length === 1) openGroup(`Hook ${commandWithArgs}`);
-				console.log(text);
-			}
-			if (!id) return;
-			await runHook({
-				id,
-				command,
-				args,
-				commandWithArgs,
-				context,
-				sink: {
-					onStdout: logLevel$7 > logLevel.silent ? (s) => console.log(s) : void 0,
-					onStderr: logLevel$7 > logLevel.silent ? (s) => console.error(`::error::${s}`) : void 0
-				}
-			});
+			if (state.currentConfigs.length === 1) openGroup(`Hook ${commandWithArgs}`);
+			console.log(text);
 		});
-		context.on("kubb:hook:end", ({ command, args }) => {
-			if (logLevel$7 <= logLevel.silent) return;
+		context.on("kubb:hook:end", ({ id, command, args, success, error }) => {
+			if (logLevel$5 <= logLevel.silent) return;
+			const ms = id ? hookTimer.end(id) : void 0;
+			const durationStr = ms !== void 0 ? ` in ${formatMsWithColor(ms)}` : "";
 			const commandWithArgs = formatCommandWithArgs(command, args);
-			const text = getMessage(`Hook ${styleText("dim", commandWithArgs)} completed`);
-			console.log(text);
+			if (success) console.log(getMessage(`${styleText("green", "✓")} Hook ${styleText("dim", commandWithArgs)} completed${durationStr}`));
+			else {
+				const reason = error?.message ? ` (${error.message})` : "";
+				console.log(`::error::Hook ${commandWithArgs} failed${durationStr}${reason}`);
+			}
 			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: ${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("kubb:lifecycle:end", () => {
 			reset();
 		});
+		return (_commandWithArgs, _hookId) => ({
+			onStdout: logLevel$5 > logLevel.silent ? (s) => console.log(s) : void 0,
+			onStderr: logLevel$5 > logLevel.silent ? (s) => console.error(`::error::${s}`) : void 0
+		});
 	}
 });
 //#endregion
@@ -1212,12 +1016,19 @@ const githubActionsLogger = defineLogger({
 const plainLogger = defineLogger({
 	name: "plain",
 	install(context, options) {
-		const logLevel$6 = options?.logLevel ?? logLevel.info;
+		const logLevel$4 = options?.logLevel ?? logLevel.info;
+		const hookTimer = createHookTimer();
 		function getMessage(message) {
-			return formatMessage(message, logLevel$6);
+			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$6 <= logLevel.silent) return;
+			if (logLevel$4 <= logLevel.silent) return;
 			const text = getMessage([
 				"ℹ",
 				message,
@@ -1226,20 +1037,20 @@ const plainLogger = defineLogger({
 			console.log(text);
 		});
 		context.on("kubb:success", ({ message, info = "" }) => {
-			if (logLevel$6 <= logLevel.silent) return;
+			if (logLevel$4 <= logLevel.silent) return;
 			const text = getMessage([
 				"✓",
 				message,
-				logLevel$6 >= logLevel.info ? info : void 0
+				logLevel$4 >= logLevel.info ? info : void 0
 			].filter(Boolean).join(" "));
 			console.log(text);
 		});
 		context.on("kubb:warn", ({ message, info }) => {
-			if (logLevel$6 < logLevel.warn) return;
+			if (logLevel$4 < logLevel.warn) return;
 			const text = getMessage([
 				"⚠",
 				message,
-				logLevel$6 >= logLevel.info ? info : void 0
+				logLevel$4 >= logLevel.info ? info : void 0
 			].filter(Boolean).join(" "));
 			console.log(text);
 		});
@@ -1247,7 +1058,7 @@ const plainLogger = defineLogger({
 			const caused = toCause(error);
 			const text = getMessage(["✗", error.message].join(" "));
 			console.log(text);
-			if (logLevel$6 >= logLevel.debug && error.stack) {
+			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) {
@@ -1257,46 +1068,41 @@ const plainLogger = defineLogger({
 				}
 			}
 		});
-		context.on("kubb:lifecycle:start", () => {
-			console.log("Kubb CLI 🧩");
-		});
-		context.on("kubb:config:start", () => {
-			if (logLevel$6 <= logLevel.silent) return;
-			const text = getMessage("Configuration started");
-			console.log(text);
+		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:config:end", () => {
-			if (logLevel$6 <= logLevel.silent) return;
-			const text = getMessage("Configuration completed");
-			console.log(text);
+		context.on("kubb:lifecycle:start", ({ version }) => {
+			console.log(`Kubb CLI v${version}`);
 		});
+		onStep("kubb:config:start", "Configuration started");
+		onStep("kubb:config:end", "Configuration completed");
 		context.on("kubb:generation:start", () => {
 			const text = getMessage("Generation started");
 			console.log(text);
 		});
 		context.on("kubb:plugin:start", ({ plugin }) => {
-			if (logLevel$6 <= logLevel.silent) return;
+			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$6 <= logLevel.silent) return;
+			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$6 <= logLevel.silent) return;
+			if (logLevel$4 <= logLevel.silent) return;
 			const text = getMessage(`Writing ${files.length} files`);
 			console.log(text);
 		});
-		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("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$6 <= logLevel.silent) return;
+			if (logLevel$4 <= logLevel.silent) return;
 			const text = getMessage("Files written successfully");
 			console.log(text);
 		});
@@ -1304,60 +1110,32 @@ const plainLogger = defineLogger({
 			const text = getMessage(config.name ? `Generation completed for ${config.name}` : "Generation completed");
 			console.log(text);
 		});
-		context.on("kubb:format:start", () => {
-			if (logLevel$6 <= logLevel.silent) return;
-			const text = getMessage("Format started");
-			console.log(text);
-		});
-		context.on("kubb:format:end", () => {
-			if (logLevel$6 <= logLevel.silent) return;
-			const text = getMessage("Format completed");
-			console.log(text);
-		});
-		context.on("kubb:lint:start", () => {
-			if (logLevel$6 <= logLevel.silent) return;
-			const text = getMessage("Lint started");
-			console.log(text);
-		});
-		context.on("kubb:lint:end", () => {
-			if (logLevel$6 <= logLevel.silent) return;
-			const text = getMessage("Lint completed");
-			console.log(text);
-		});
-		context.on("kubb:hook:start", async ({ id, command, args }) => {
+		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);
-			const text = getMessage(`Hook ${commandWithArgs} started`);
-			if (logLevel$6 > logLevel.silent) console.log(text);
-			if (!id) return;
-			await runHook({
-				id,
-				command,
-				args,
-				commandWithArgs,
-				context,
-				sink: {
-					onStdout: logLevel$6 > logLevel.silent ? (s) => console.log(s) : void 0,
-					onStderr: logLevel$6 > logLevel.silent ? (s) => console.error(s) : void 0
-				}
-			});
+			console.log(getMessage(`Hook ${commandWithArgs} started`));
 		});
-		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("kubb:hook:end", ({ id, command, args, success, error }) => {
+			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 {
+				const reason = error?.message ? ` (${error.message})` : "";
+				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$6 >= logLevel.verbose ? pluginTimings : void 0
-			});
-			console.log(SUMMARY_SEPARATOR);
-			console.log(summary.join("\n"));
-			console.log(SUMMARY_SEPARATOR);
+		return (_commandWithArgs, _hookId) => ({
+			onStdout: logLevel$4 > logLevel.silent ? (s) => console.log(s) : void 0,
+			onStderr: logLevel$4 > logLevel.silent ? (s) => console.error(s) : void 0
 		});
 	}
 });
@@ -1367,8 +1145,8 @@ const plainLogger = defineLogger({
 * 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$4) {
-	if (logLevel$4 >= logLevel.verbose) return `${styleText("dim", `[${(/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+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",
@@ -1393,6 +1171,57 @@ function buildProgressLine(state) {
 	return parts.join(styleText("dim", " | "));
 }
 /**
+* Creates the per-run progress counters shared by the clack and GitHub Actions loggers.
+*/
+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.
 * e.g. ("prettier", ["--write", "."]) → "prettier --write ."
 */
@@ -1409,129 +1238,233 @@ const logMapper = {
 	plain: plainLogger,
 	"github-actions": githubActionsLogger
 };
-async function setupLogger(context, { logLevel: logLevel$5 }) {
-	const type = detectLogger();
-	const logger = logMapper[type];
-	if (!logger) throw new Error(`Unknown adapter type: ${type}`);
-	const cleanup = await logger.install(context, { logLevel: logLevel$5 });
-	if (logLevel$5 >= logLevel.debug) await fileSystemLogger.install(context, { logLevel: logLevel$5 });
-	return cleanup;
+/**
+* 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), returning the
+* terminal logger's hook sink when one was installed. The reporters are already selected by the
+* caller (the CLI maps `--reporter` to names via `selectReporters`); this only wires them.
+*
+* Loggers and reporters are independent: the `cli` reporter also activates the env logger summary.
+* The `json` reporter owns stdout, so the live logger and the `cli` summary are suppressed 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 };
+	let makeSink = null;
+	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}`);
+			const sink = await logger.install(context, { logLevel });
+			makeSink = typeof sink === "function" ? sink : null;
+		}
+		installReporter(context, reporter, ctx);
+	}
+	return makeSink;
 }
 //#endregion
-//#region src/utils/executeHooks.ts
-async function executeHooks({ configHooks, hooks }) {
+//#region src/runners/generate/utils.ts
+const jiti = createJiti(import.meta.url, {
+	jsx: {
+		runtime: "automatic",
+		importSource: "@kubb/renderer-jsx"
+	},
+	moduleCache: false
+});
+const tsLoader = (configFile) => jiti.import(configFile, { default: true });
+const MODULE_NAME = "kubb";
+const BASE_SEARCH_PLACES = [
+	"package.json",
+	`.${MODULE_NAME}rc`,
+	`.${MODULE_NAME}rc.json`,
+	`.${MODULE_NAME}rc.yaml`,
+	`.${MODULE_NAME}rc.yml`,
+	`.${MODULE_NAME}rc.ts`,
+	`.${MODULE_NAME}rc.mts`,
+	`.${MODULE_NAME}rc.cts`,
+	`.${MODULE_NAME}rc.js`,
+	`.${MODULE_NAME}rc.mjs`,
+	`.${MODULE_NAME}rc.cjs`,
+	`${MODULE_NAME}.config.ts`,
+	`${MODULE_NAME}.config.mts`,
+	`${MODULE_NAME}.config.cts`,
+	`${MODULE_NAME}.config.js`,
+	`${MODULE_NAME}.config.mjs`,
+	`${MODULE_NAME}.config.cjs`
+];
+const SEARCH_PLACES = [
+	"",
+	".config/",
+	"configs/"
+].flatMap((prefix) => BASE_SEARCH_PLACES.map((p) => `${prefix}${p}`));
+async function getCosmiConfig(configFile) {
+	const explorer = cosmiconfig(MODULE_NAME, {
+		cache: false,
+		searchPlaces: SEARCH_PLACES,
+		loaders: {
+			".ts": tsLoader,
+			".mts": tsLoader,
+			".cts": tsLoader
+		}
+	});
+	let result;
+	try {
+		result = configFile ? await explorer.load(configFile) : await explorer.search();
+	} catch (error) {
+		throw new Error("Config failed loading", { cause: error });
+	}
+	if (!result?.config || result.isEmpty) throw new Error("Config not defined, create a kubb.config.js or pass through your config with the option --config");
+	return result;
+}
+/**
+* Discovers the Kubb config via cosmiconfig 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 result = await getCosmiConfig(configPath);
+	const cli = {
+		config: configPath,
+		input,
+		watch,
+		logLevel
+	};
+	const resolved = await (typeof result.config === "function" ? result.config(cli) : result.config);
+	const userConfigs = Array.isArray(resolved) ? resolved : [resolved];
+	return {
+		configPath: result.filepath,
+		configs: userConfigs.map((item) => ({
+			...item,
+			plugins: item.plugins ?? []
+		}))
+	};
+}
+/**
+* Runs the `done` hooks defined in a Kubb config in sequence.
+*/
+async function executeHooks({ configHooks, hooks, makeSink }) {
 	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 = createHash("sha256").update(command).digest("hex");
-		const hookEndPromise = new Promise((resolve, reject) => {
-			const handler = (ctx) => {
-				if (ctx.id !== hookId) return;
-				hooks.off("kubb:hook:end", handler);
-				if (!ctx.success) {
-					reject(ctx.error ?? /* @__PURE__ */ new Error(`Hook failed: ${command}`));
-					return;
-				}
-				hooks.emit("kubb:success", { message: `${styleText("dim", command)} successfully executed` }).then(resolve).catch(reject);
-			};
-			hooks.on("kubb:hook:end", handler);
-		});
+		const commandWithArgs = [cmd, ...args].join(" ");
 		await hooks.emit("kubb:hook:start", {
 			id: hookId,
 			command: cmd,
 			args
 		});
-		await hookEndPromise;
+		const { stream = false, onLine, onStdout, onStderr } = makeSink?.(commandWithArgs, hookId) ?? {};
+		await runHook({
+			id: hookId,
+			command: cmd,
+			args,
+			commandWithArgs,
+			hooks,
+			stream,
+			sink: {
+				onLine,
+				onStdout,
+				onStderr
+			}
+		});
 	}
 }
-//#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 unrunInputOptions = { transform: { jsx: {
-	runtime: "automatic",
-	importSource: "@kubb/renderer-jsx"
-} } };
-const tsLoader = async (configFile) => {
-	const { module } = await unrun({
-		path: configFile,
-		inputOptions: unrunInputOptions
-	});
-	return module;
-};
-async function getCosmiConfig(moduleName, config) {
-	let result;
-	const searchPlaces = [
-		"package.json",
-		`.${moduleName}rc`,
-		`.${moduleName}rc.json`,
-		`.${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`
-	];
-	const explorer = cosmiconfig(moduleName, {
-		cache: false,
-		searchPlaces: [
-			...searchPlaces.map((searchPlace) => {
-				return `.config/${searchPlace}`;
-			}),
-			...searchPlaces.map((searchPlace) => {
-				return `configs/${searchPlace}`;
-			}),
-			...searchPlaces
-		],
-		loaders: {
-			".ts": tsLoader,
-			".mts": tsLoader,
-			".cts": tsLoader
-		}
+async function runHook({ id, command, args, commandWithArgs, hooks, stream = false, sink }) {
+	const emitEnd = (success, error) => hooks.emit("kubb:hook:end", {
+		command,
+		args,
+		id,
+		success,
+		error
 	});
 	try {
-		result = config ? await explorer.load(config) : await explorer.search();
-	} catch (error) {
-		throw new Error("Config failed loading", { cause: error });
+		const proc = x(command, [...args ?? []], {
+			nodeOptions: { detached: process.platform !== "win32" },
+			throwOnError: true
+		});
+		if (stream && sink?.onLine) for await (const line of proc) sink.onLine(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 ?? "";
+		if (stderr) sink?.onStderr?.(stderr);
+		if (stdout) sink?.onStdout?.(stdout);
+		await emitEnd(false, /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`));
 	}
-	if (result?.isEmpty || !result || !result.config) throw new Error("Config not defined, create a kubb.config.js or pass through your config with the option --config");
-	return result;
 }
-//#endregion
-//#region src/utils/watcher.ts
-async function startWatcher(path, cb) {
+/**
+* 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");
-	watch(path, {
+	const watcher = watch(path, {
 		ignorePermissionErrors: true,
 		ignored: WATCHER_IGNORED_PATHS
-	}).on("all", async (type, file) => {
-		console.log(styleText("yellow", styleText("bold", `Change detected: ${type} ${file}`)));
+	});
+	process.once("SIGINT", () => {
+		watcher.close();
+	});
+	process.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) {
-			console.log(styleText("red", "Watcher failed"));
+			log.error(styleText("red", "Watcher failed"));
 		}
 	});
 }
 //#endregion
-//#region src/runners/generate.ts
-async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefix, noToolMessage, configName, outputPath, logLevel: logLevel$1, hooks, onStart, onEnd }) {
+//#region src/runners/generate/run.ts
+/**
+* Registers a one-shot `kubb:hook:end` listener for `hookId` BEFORE the caller emits `kubb:hook:start`,
+* avoiding the race where a synchronous emitter fires 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, makeSink, onStart, onEnd }) {
 	await onStart();
 	let resolvedTool = toolValue;
 	if (resolvedTool === "auto") {
@@ -1543,43 +1476,47 @@ async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefi
 		}
 	}
 	let toolError;
-	if (resolvedTool && resolvedTool !== "auto" && resolvedTool in toolMap) {
+	if (resolvedTool && resolvedTool !== "auto" && resolvedTool in toolMap && existsSync(outputPath)) {
 		const toolConfig = toolMap[resolvedTool];
+		const hookId = createHash("sha256").update([configName, resolvedTool].filter(Boolean).join("-")).digest("hex");
+		const successMessage = [
+			`${successPrefix} with ${styleText("dim", resolvedTool)}`,
+			logLevel$1 >= logLevel.info ? `on ${styleText("dim", outputPath)}` : void 0,
+			"successfully"
+		].filter(Boolean).join(" ");
 		try {
-			const hookId = createHash("sha256").update([configName, resolvedTool].filter(Boolean).join("-")).digest("hex");
-			const hookEndPromise = new Promise((resolve, reject) => {
-				const handler = (ctx) => {
-					if (ctx.id !== hookId) return;
-					hooks.off("kubb:hook:end", handler);
-					if (!ctx.success) {
-						reject(ctx.error ?? /* @__PURE__ */ new Error(`${toolConfig.errorMessage}`));
-						return;
-					}
-					hooks.emit("kubb:success", { message: [
-						`${successPrefix} with ${styleText("dim", resolvedTool)}`,
-						logLevel$1 >= logLevel.info ? `on ${styleText("dim", outputPath)}` : void 0,
-						"successfully"
-					].filter(Boolean).join(" ") }).then(resolve).catch(reject);
-				};
-				hooks.on("kubb:hook:end", handler);
-			});
+			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: toolConfig.args(outputPath)
+				args: hookArgs
 			});
+			const { stream = false, onLine, onStdout, onStderr } = makeSink?.(commandWithArgs, hookId) ?? {};
+			runHook({
+				id: hookId,
+				command: toolConfig.command,
+				args: hookArgs,
+				commandWithArgs,
+				hooks,
+				stream,
+				sink: {
+					onLine,
+					onStdout,
+					onStderr
+				}
+			}).catch(() => {});
 			await hookEndPromise;
 		} catch (caughtError) {
-			const err = toError(caughtError);
-			await hooks.emit("kubb:error", { error: err });
-			toolError = err;
+			toolError = toError(caughtError);
 		}
 	}
 	await onEnd();
 	if (toolError) throw toolError;
 }
 async function generate(options) {
-	const { input, hooks, logLevel: logLevel$2 } = options;
+	const { input, hooks, logLevel, makeSink } = 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 = {
@@ -1591,163 +1528,230 @@ async function generate(options) {
 		...options.config.output
 	};
 	const kubb = createKubb(config, { hooks });
-	await kubb.setup();
 	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, failedPlugins, pluginTimings, error, driver } = await kubb.safeBuild();
+	const { files, diagnostics, driver } = await kubb.safeBuild();
 	await hooks.emit("kubb:info", { message: "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 hooks.emit("kubb:error", { error: err });
+	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,
-			files,
-			sources: kubb.sources
-		});
-		await hooks.emit("kubb:generation:summary", {
-			config,
-			failedPlugins,
+			storage: kubb.storage,
+			diagnostics,
 			filesCreated: files.length,
 			status: "failed",
-			hrStart,
-			pluginTimings: logLevel$2 >= logLevel.verbose ? pluginTimings : void 0
+			hrStart
 		});
-		await sendTelemetry(buildTelemetryEvent({
-			command: "generate",
-			kubbVersion: version,
-			plugins: Array.from(driver.plugins.values(), (p) => ({
-				name: p.name,
-				options: p.options
-			})),
-			hrStart,
-			filesCreated: files.length,
-			status: "failed"
-		}));
-		process$1.exit(1);
+		await reportTelemetry("failed");
+		return false;
 	}
-	await hooks.emit("kubb:success", {
-		message: "Generation successfully",
-		info: inputPath
-	});
-	await hooks.emit("kubb:generation:end", {
-		config,
-		files,
-		sources: kubb.sources
-	});
 	const outputPath = path.resolve(config.root, config.output.path);
-	if (config.output.format) await runToolPass({
+	const outputDiagnostics = [];
+	const toolPasses = [config.output.format && {
+		code: Diagnostics.code.formatFailed,
 		toolValue: config.output.format,
 		detect: detectFormatter,
 		toolMap: formatters,
 		toolLabel: "formatter",
 		successPrefix: "Formatting",
 		noToolMessage: "No formatter found (oxfmt, biome, or prettier). Skipping formatting.",
-		configName: config.name,
-		outputPath,
-		logLevel: logLevel$2,
-		hooks,
 		onStart: () => hooks.emit("kubb:format:start"),
 		onEnd: () => hooks.emit("kubb:format:end")
-	});
-	if (config.output.lint) await runToolPass({
+	}, config.output.lint && {
+		code: Diagnostics.code.lintFailed,
 		toolValue: config.output.lint,
 		detect: detectLinter,
 		toolMap: linters,
 		toolLabel: "linter",
 		successPrefix: "Linting",
 		noToolMessage: "No linter found (oxlint, biome, or eslint). Skipping linting.",
-		configName: config.name,
-		outputPath,
-		logLevel: logLevel$2,
-		hooks,
 		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,
+			makeSink
+		});
+	} 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");
-		await executeHooks({
-			configHooks: config.hooks,
-			hooks
-		});
+		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(Diagnostics.code.hookFailed, "Post-generate hook", error);
+			outputDiagnostics.push(diagnostic);
+			await Diagnostics.emit(hooks, diagnostic);
+		}
 		await hooks.emit("kubb:hooks:end");
 	}
-	await hooks.emit("kubb:generation:summary", {
+	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,
-		failedPlugins,
+		storage: kubb.storage,
+		diagnostics: finalDiagnostics,
 		filesCreated: files.length,
-		status: "success",
-		hrStart,
-		pluginTimings
+		status: failed ? "failed" : "success",
+		hrStart
 	});
-	await sendTelemetry(buildTelemetryEvent({
-		command: "generate",
-		kubbVersion: version,
-		plugins: Array.from(driver.plugins.values(), (p) => ({
-			name: p.name,
-			options: p.options
-		})),
-		hrStart,
-		filesCreated: files.length,
-		status: "success"
-	}));
+	await reportTelemetry(failed ? "failed" : "success");
+	return !failed;
 }
-async function runGenerateCommand({ input, configPath, logLevel: logLevelKey, watch }) {
-	const logLevel$3 = logLevel[logLevelKey] ?? logLevel.info;
-	const hooks = new AsyncEventEmitter();
-	await setupLogger(hooks, { logLevel: logLevel$3 });
+/**
+* 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) {
 	await executeIfOnline(async () => {
 		try {
-			const latestVersion = (await (await fetch(KUBB_NPM_PACKAGE_URL)).json()).version;
-			if (latestVersion && version < latestVersion) await hooks.emit("kubb:version:new", {
+			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
-			});
+				latestVersion: data.version
+			}));
 		} catch {}
 	});
+}
+/**
+* Runs the full Kubb generation lifecycle for the given CLI options.
+* 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, 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"];
+	const makeSink = await setupReporters(hooks, {
+		logLevel: logLevel$2,
+		reporters: selectReporters(configs[0]?.reporters ?? [], requestedNames)
+	});
+	await hooks.emit("kubb:lifecycle:start", { version });
+	await checkForUpdate(hooks);
 	try {
-		const result = await getCosmiConfig("kubb", configPath);
-		const configs = await getConfigs(result.config, { input });
+		const relativeConfigPath = path.relative(process$1.cwd(), resolvedConfigPath);
 		await hooks.emit("kubb:config:start");
 		await hooks.emit("kubb:info", {
 			message: "Config loaded",
-			info: path.relative(process$1.cwd(), result.filepath)
+			info: relativeConfigPath
 		});
 		await hooks.emit("kubb:success", {
 			message: "Config loaded successfully",
-			info: path.relative(process$1.cwd(), result.filepath)
+			info: relativeConfigPath
 		});
 		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();
+		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$3,
-				hooks
+				logLevel: logLevel$2,
+				hooks,
+				makeSink
 			});
 			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 await generate({
-			input,
-			config,
-			logLevel: logLevel$3,
-			hooks
-		});
+		else try {
+			if (!await generate({
+				input,
+				config,
+				logLevel: logLevel$2,
+				hooks,
+				makeSink
+			})) 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 { runGenerateCommand };
+export { run };
 
-//# sourceMappingURL=generate-CNrRLY4n.js.map
+//# sourceMappingURL=run-CHZKHTv0.js.map