@kubb/cli 5.0.0-beta.84 → 5.0.0-beta.86

package/dist/{run-ChSqYuc1.cjs → run-lAxAF-4t.cjs}

@@ -1,129 +1,21 @@
 const require_rolldown_runtime = require("./rolldown-runtime-Bx3C2hgW.cjs");
+const require_Telemetry = require("./Telemetry-CwQYBgsg.cjs");
 const require_errors = require("./errors-gxFK0vrp.cjs");
-const require_Telemetry = require("./Telemetry-jtbchpQE.cjs");
-const require_tools = require("./tools-CZT9wSA6.cjs");
-const require_package = require("./package-BBBOfxZz.cjs");
+const require_package = require("./package-Bar6zPkT.cjs");
+const require_tools = require("./tools-CeIABV0T.cjs");
 let node_util = require("node:util");
-let node_events = require("node:events");
-let node_crypto = require("node:crypto");
+require("node:crypto");
+let node_process = require("node:process");
+node_process = require_rolldown_runtime.__toESM(node_process, 1);
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
-let node_process = require("node:process");
-node_process = require_rolldown_runtime.__toESM(node_process, 1);
 let _clack_prompts = require("@clack/prompts");
 _clack_prompts = require_rolldown_runtime.__toESM(_clack_prompts, 1);
 let _kubb_core = require("@kubb/core");
 let jiti = require("jiti");
 let tinyexec = require("tinyexec");
 let unconfig = require("unconfig");
-//#region ../../internals/utils/src/asyncEventEmitter.ts
-/**
-* Typed `EventEmitter` that awaits all async listeners before resolving.
-* Wraps Node's `EventEmitter` with full TypeScript event-map inference.
-*
-* @example
-* ```ts
-* const emitter = new AsyncEventEmitter<{ build: [name: string] }>()
-* emitter.on('build', async (name) => { console.log(name) })
-* await emitter.emit('build', 'petstore') // all listeners awaited
-* ```
-*/
-var AsyncEventEmitter = class {
-	/**
-	* Maximum number of listeners per event before Node emits a memory-leak warning.
-	* @default 10
-	*/
-	constructor(maxListener = 10) {
-		this.#emitter.setMaxListeners(maxListener);
-	}
-	#emitter = new node_events.EventEmitter();
-	/**
-	* Emits `eventName` and awaits all registered listeners sequentially.
-	* Throws if any listener rejects, wrapping the cause with the event name and serialized arguments.
-	*
-	* @example
-	* ```ts
-	* await emitter.emit('build', 'petstore')
-	* ```
-	*/
-	emit(eventName, ...eventArgs) {
-		const listeners = this.#emitter.listeners(eventName);
-		if (listeners.length === 0) return;
-		return this.#emitAll(eventName, listeners, eventArgs);
-	}
-	async #emitAll(eventName, listeners, eventArgs) {
-		for (const listener of listeners) try {
-			await listener(...eventArgs);
-		} catch (err) {
-			let serializedArgs;
-			try {
-				serializedArgs = JSON.stringify(eventArgs);
-			} catch {
-				serializedArgs = String(eventArgs);
-			}
-			throw new Error(`Error in async listener for "${eventName}" with eventArgs ${serializedArgs}`, { cause: require_errors.toError(err) });
-		}
-	}
-	/**
-	* Registers a persistent listener for `eventName`.
-	*
-	* @example
-	* ```ts
-	* emitter.on('build', async (name) => { console.log(name) })
-	* ```
-	*/
-	on(eventName, handler) {
-		this.#emitter.on(eventName, handler);
-	}
-	/**
-	* Removes a previously registered listener.
-	*
-	* @example
-	* ```ts
-	* emitter.off('build', handler)
-	* ```
-	*/
-	off(eventName, handler) {
-		this.#emitter.off(eventName, handler);
-	}
-	/**
-	* Returns the number of listeners registered for `eventName`.
-	*
-	* @example
-	* ```ts
-	* emitter.on('build', handler)
-	* emitter.listenerCount('build') // 1
-	* ```
-	*/
-	listenerCount(eventName) {
-		return this.#emitter.listenerCount(eventName);
-	}
-	/**
-	* Raises or lowers the per-event listener ceiling before Node warns about a memory leak.
-	* Set this above the expected listener count when many listeners attach by design.
-	*
-	* @example
-	* ```ts
-	* emitter.setMaxListeners(40)
-	* ```
-	*/
-	setMaxListeners(max) {
-		this.#emitter.setMaxListeners(max);
-	}
-	/**
-	* Removes all listeners from every event channel.
-	*
-	* @example
-	* ```ts
-	* emitter.removeAll()
-	* ```
-	*/
-	removeAll() {
-		this.#emitter.removeAllListeners();
-	}
-};
-//#endregion
 //#region ../../internals/utils/src/time.ts
 /**
 * Calculates elapsed time in milliseconds from a high-resolution `process.hrtime` start time.
@@ -268,6 +160,43 @@ function formatMsWithColor(ms) {
 	return (0, node_util.styleText)("red", formatted);
 }
 //#endregion
+//#region ../../internals/utils/src/promise.ts
+/**
+* Wraps `run` so invocations never overlap: a trigger that lands while a run is in flight
+* marks it dirty and runs once more after it finishes, no matter how many triggers arrived.
+* Useful for event-driven reruns (a file watcher, a queue drain) where bursts should
+* coalesce into a single trailing run.
+*
+* @example
+* ```ts
+* const rebuild = createSerialRunner({
+*   run: () => build(),
+*   onError: (error) => log.error(error.message),
+* })
+* watcher.on('change', () => void rebuild())
+* ```
+*/
+function createSerialRunner({ run, onError }) {
+	let running = false;
+	let dirty = false;
+	return async () => {
+		if (running) {
+			dirty = true;
+			return;
+		}
+		running = true;
+		do {
+			dirty = false;
+			try {
+				await run();
+			} catch (error) {
+				onError(require_errors.toError(error));
+			}
+		} while (dirty);
+		running = false;
+	};
+}
+//#endregion
 //#region src/loggers/defineLogger.ts
 /**
 * Type-safe helper for authoring a {@link Logger}.
@@ -277,7 +206,7 @@ function formatMsWithColor(ms) {
 * export const myLogger = defineLogger({
 *   name: 'my-logger',
 *   install(context) {
-*     context.on('kubb:info', ({ message }) => console.log('ℹ', message))
+*     context.hook('kubb:info', ({ message }) => console.log('ℹ', message))
 *   },
 * })
 * ```
@@ -329,8 +258,8 @@ const clackLogger = defineLogger({
 		function getMessage(message) {
 			return formatMessage(message, logLevel);
 		}
-		function onStep(event, message) {
-			context.on(event, () => {
+		function onStep(hook, message) {
+			context.hook(hook, () => {
 				if (logLevel <= _kubb_core.logLevel.silent) return;
 				_clack_prompts.log.step(getMessage(message));
 			});
@@ -340,7 +269,7 @@ const clackLogger = defineLogger({
 			state.spinner.stop(text);
 			state.isSpinning = false;
 		}
-		context.on("kubb:info", ({ message, info = "" }) => {
+		context.hook("kubb:info", ({ message, info = "" }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const text = getMessage([
 				(0, node_util.styleText)("blue", "ℹ"),
@@ -353,7 +282,7 @@ const clackLogger = defineLogger({
 			}
 			_clack_prompts.log.info(text);
 		});
-		context.on("kubb:success", ({ message, info = "" }) => {
+		context.hook("kubb:success", ({ message, info = "" }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const text = getMessage([
 				(0, node_util.styleText)("blue", "✓"),
@@ -366,7 +295,7 @@ const clackLogger = defineLogger({
 			}
 			_clack_prompts.log.success(text);
 		});
-		context.on("kubb:warn", ({ message, info }) => {
+		context.hook("kubb:warn", ({ message, info }) => {
 			if (logLevel < _kubb_core.logLevel.warn) return;
 			const text = getMessage([
 				(0, node_util.styleText)("yellow", "⚠"),
@@ -375,25 +304,23 @@ const clackLogger = defineLogger({
 			].filter(Boolean).join(" "));
 			_clack_prompts.log.warn(text);
 		});
-		context.on("kubb:error", ({ error }) => {
-			const caused = require_errors.toCause(error);
+		context.hook("kubb:error", ({ error }) => {
 			const text = [(0, node_util.styleText)("red", "✗"), error.message].join(" ");
 			if (state.isSpinning) {
 				stopSpinner(getMessage(text));
 				return;
 			}
 			_clack_prompts.log.error(getMessage(text));
-			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) {
-					_clack_prompts.log.message((0, node_util.styleText)("dim", `└─ caused by ${caused.message}`));
-					const frames = caused.stack.split("\n").slice(1, 4);
-					for (const frame of frames) _clack_prompts.log.message(getMessage(`    ${(0, node_util.styleText)("dim", frame.trim())}`));
+			const frames = logLevel >= _kubb_core.logLevel.verbose ? formatErrorFrames(error) : null;
+			if (frames) {
+				for (const frame of frames.frames) _clack_prompts.log.message(getMessage((0, node_util.styleText)("dim", frame)));
+				if (frames.cause) {
+					_clack_prompts.log.message((0, node_util.styleText)("dim", frames.cause.header));
+					for (const frame of frames.cause.frames) _clack_prompts.log.message(getMessage(`    ${(0, node_util.styleText)("dim", frame)}`));
 				}
 			}
 		});
-		context.on("kubb:diagnostic", ({ diagnostic }) => {
+		context.hook("kubb:diagnostic", ({ diagnostic }) => {
 			if (logLevel <= _kubb_core.logLevel.silent && diagnostic.severity !== "error") return;
 			stopSpinner();
 			stopActiveProgress();
@@ -415,7 +342,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				secondarySymbol: ""
 			});
 		});
-		context.on("kubb:lifecycle:start", async ({ version }) => {
+		context.hook("kubb:lifecycle:start", async ({ version }) => {
 			console.log(`\n${getIntro({
 				title: "The meta framework for code generation",
 				description: "Ready to start",
@@ -424,14 +351,14 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			})}\n`);
 			reset();
 		});
-		context.on("kubb:generation:start", ({ config }) => {
+		context.hook("kubb:generation:start", ({ config }) => {
 			reset();
 			state.totalPlugins = config.plugins?.length ?? 0;
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const text = getMessage(["Generation started", config.name ? `for ${(0, node_util.styleText)("dim", config.name)}` : void 0].filter(Boolean).join(" "));
 			_clack_prompts.intro(text);
 		});
-		context.on("kubb:plugin:start", ({ plugin }) => {
+		context.hook("kubb:plugin:start", ({ plugin }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			stopSpinner();
 			state.runningPlugins.add(plugin.name);
@@ -449,7 +376,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			progressBar.advance(state.completedPlugins + state.failedPlugins, pluginProgressText());
 			state.activeProgress.set("plugins", { progressBar });
 		});
-		context.on("kubb:plugin:end", ({ plugin, success }) => {
+		context.hook("kubb:plugin:end", ({ plugin, success }) => {
 			stopSpinner();
 			const active = state.activeProgress.get("plugins");
 			if (!active || logLevel === _kubb_core.logLevel.silent) return;
@@ -462,7 +389,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				showProgressStep();
 			}
 		});
-		context.on("kubb:files:processing:start", ({ files }) => {
+		context.hook("kubb:files:processing:start", ({ files }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			stopSpinner();
 			state.totalFiles = files.length;
@@ -473,11 +400,11 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				max: files.length,
 				size: 30
 			});
-			context.emit("kubb:info", { message: text });
+			context.callHook("kubb:info", { message: text });
 			progressBar.start(getMessage(text));
 			state.activeProgress.set("files", { progressBar });
 		});
-		context.on("kubb:files:processing:update", ({ files }) => {
+		context.hook("kubb:files:processing:update", ({ files }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			stopSpinner();
 			const active = state.activeProgress.get("files");
@@ -486,7 +413,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				if (active) active.progressBar.advance(void 0, `Writing ${(0, node_path.relative)(config.root, file.path)}`);
 			}
 		});
-		context.on("kubb:files:processing:end", () => {
+		context.hook("kubb:files:processing:end", () => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			stopSpinner();
 			const text = getMessage("Files written successfully");
@@ -496,7 +423,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			state.activeProgress.delete("files");
 			showProgressStep();
 		});
-		context.on("kubb:generation:end", ({ config }) => {
+		context.hook("kubb:generation:end", ({ config }) => {
 			stopSpinner();
 			const text = getMessage(config.name ? `Generation completed for ${(0, node_util.styleText)("dim", config.name)}` : "Generation completed");
 			_clack_prompts.outro(text);
@@ -504,7 +431,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 		onStep("kubb:format:start", "Formatting");
 		onStep("kubb:lint:start", "Linting");
 		onStep("kubb:hooks:start", "Running hooks");
-		context.on("kubb:hook:start", ({ id, command, args }) => {
+		context.hook("kubb:hook:start", ({ id, command, args }) => {
 			if (logLevel <= _kubb_core.logLevel.silent || !id) return;
 			stopSpinner();
 			const title = getMessage(`Running ${(0, node_util.styleText)("dim", formatCommandWithArgs(command, args))}`);
@@ -514,10 +441,10 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				hrStart: node_process.default.hrtime()
 			});
 		});
-		if (logLevel > _kubb_core.logLevel.silent) context.on("kubb:hook:line", ({ id, line }) => {
+		if (logLevel > _kubb_core.logLevel.silent) context.hook("kubb:hook:line", ({ id, line }) => {
 			state.activeHookLogs.get(id)?.taskLog.message((0, node_util.styleText)("dim", line));
 		});
-		context.on("kubb:hook:end", ({ id, command, args, success, error, stdout, stderr }) => {
+		context.hook("kubb:hook:end", ({ id, command, args, success, error, stdout, stderr }) => {
 			if (!id) return;
 			if (logLevel <= _kubb_core.logLevel.silent) {
 				if (!success) {
@@ -537,7 +464,7 @@ 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:lifecycle:end", () => {
+		context.hook("kubb:lifecycle:end", () => {
 			reset();
 		});
 	}
@@ -555,13 +482,13 @@ const plainLogger = defineLogger({
 		function getMessage(message) {
 			return formatMessage(message, logLevel);
 		}
-		function onStep(event, message) {
-			context.on(event, () => {
+		function onStep(hook, message) {
+			context.hook(hook, () => {
 				if (logLevel <= _kubb_core.logLevel.silent) return;
 				console.log(getMessage(message));
 			});
 		}
-		context.on("kubb:info", ({ message, info }) => {
+		context.hook("kubb:info", ({ message, info }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const text = getMessage([
 				"ℹ",
@@ -570,7 +497,7 @@ const plainLogger = defineLogger({
 			].join(" "));
 			console.log(text);
 		});
-		context.on("kubb:success", ({ message, info = "" }) => {
+		context.hook("kubb:success", ({ message, info = "" }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const text = getMessage([
 				"✓",
@@ -579,7 +506,7 @@ const plainLogger = defineLogger({
 			].filter(Boolean).join(" "));
 			console.log(text);
 		});
-		context.on("kubb:warn", ({ message, info }) => {
+		context.hook("kubb:warn", ({ message, info }) => {
 			if (logLevel < _kubb_core.logLevel.warn) return;
 			const text = getMessage([
 				"⚠",
@@ -588,57 +515,55 @@ const plainLogger = defineLogger({
 			].filter(Boolean).join(" "));
 			console.log(text);
 		});
-		context.on("kubb:error", ({ error }) => {
-			const caused = require_errors.toCause(error);
+		context.hook("kubb:error", ({ error }) => {
 			const text = getMessage(["✗", error.message].join(" "));
 			console.log(text);
-			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) {
-					console.log(`└─ caused by ${caused.message}`);
-					const frames = caused.stack.split("\n").slice(1, 4);
-					for (const frame of frames) console.log(getMessage(`    ${frame.trim()}`));
+			const frames = logLevel >= _kubb_core.logLevel.verbose ? formatErrorFrames(error) : null;
+			if (frames) {
+				for (const frame of frames.frames) console.log(getMessage(frame));
+				if (frames.cause) {
+					console.log(frames.cause.header);
+					for (const frame of frames.cause.frames) console.log(getMessage(`    ${frame}`));
 				}
 			}
 		});
-		context.on("kubb:diagnostic", ({ diagnostic }) => {
+		context.hook("kubb:diagnostic", ({ diagnostic }) => {
 			if (logLevel <= _kubb_core.logLevel.silent && diagnostic.severity !== "error") return;
 			console.log(getMessage(_kubb_core.Diagnostics.formatLines(diagnostic).join("\n")));
 		});
-		context.on("kubb:lifecycle:start", ({ version }) => {
+		context.hook("kubb:lifecycle:start", ({ version }) => {
 			console.log(`Kubb CLI v${version}`);
 		});
-		context.on("kubb:generation:start", () => {
+		context.hook("kubb:generation:start", () => {
 			const text = getMessage("Generation started");
 			console.log(text);
 		});
-		context.on("kubb:plugin:start", ({ plugin }) => {
+		context.hook("kubb:plugin:start", ({ plugin }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const text = getMessage(`Generating ${plugin.name}`);
 			console.log(text);
 		});
-		context.on("kubb:plugin:end", ({ plugin, duration, success }) => {
+		context.hook("kubb:plugin:end", ({ plugin, duration, success }) => {
 			if (logLevel <= _kubb_core.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 }) => {
+		context.hook("kubb:files:processing:start", ({ files }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const text = getMessage(`Writing ${files.length} files`);
 			console.log(text);
 		});
-		context.on("kubb:files:processing:update", ({ files }) => {
+		context.hook("kubb:files:processing:update", ({ files }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			for (const { file, config } of files) console.log(getMessage(`Writing ${(0, node_path.relative)(config.root, file.path)}`));
 		});
-		context.on("kubb:files:processing:end", () => {
+		context.hook("kubb:files:processing:end", () => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const text = getMessage("Files written successfully");
 			console.log(text);
 		});
-		context.on("kubb:generation:end", ({ config }) => {
+		context.hook("kubb:generation:end", ({ config }) => {
 			const text = getMessage(config.name ? `Generation completed for ${config.name}` : "Generation completed");
 			console.log(text);
 		});
@@ -648,13 +573,13 @@ const plainLogger = defineLogger({
 		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 }) => {
+		context.hook("kubb:hook:start", ({ id, command, args }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			if (id) hookTimer.start(id);
 			const commandWithArgs = formatCommandWithArgs(command, args);
 			console.log(getMessage(`Hook ${commandWithArgs} started`));
 		});
-		context.on("kubb:hook:end", ({ id, command, args, success, error, stdout, stderr }) => {
+		context.hook("kubb:hook:end", ({ id, command, args, success, error, stdout, stderr }) => {
 			if (logLevel <= _kubb_core.logLevel.silent) return;
 			const ms = id ? hookTimer.end(id) : void 0;
 			const durationStr = ms !== void 0 ? ` in ${formatMs(ms)}` : "";
@@ -685,6 +610,22 @@ function formatMessage(message, logLevel) {
 	return message;
 }
 /**
+* First stack frames for verbose error output, including an optional `cause` chain.
+*/
+function formatErrorFrames(error) {
+	if (!error.stack) return null;
+	const frames = error.stack.split("\n").slice(1, 4).map((frame) => frame.trim());
+	const caused = require_errors.toCause(error);
+	if (!caused?.stack) return { frames };
+	return {
+		frames,
+		cause: {
+			header: `└─ caused by ${caused.message}`,
+			frames: caused.stack.split("\n").slice(1, 4).map((frame) => frame.trim())
+		}
+	};
+}
+/**
 * Build the progress summary line shown by the clack logger.
 * Returns null when there is nothing to display.
 */
@@ -745,9 +686,6 @@ function createHookTimer() {
 			if (!hrStart) return;
 			starts.delete(id);
 			return getElapsedMs(hrStart);
-		},
-		clear() {
-			starts.clear();
 		}
 	};
 }
@@ -760,20 +698,12 @@ function createHookTimer() {
 function formatCommandWithArgs(command, args) {
 	return args?.length ? `${command} ${args.join(" ")}` : command;
 }
-function detectLogger() {
-	if (require_Telemetry.canUseTTY()) return "clack";
-	return "plain";
-}
-const logMapper = {
-	clack: clackLogger,
-	plain: plainLogger
-};
 /**
-* Bridges a {@link Reporter} onto the run's event emitter: calls `report` with each config's
+* Bridges a {@link Reporter} onto the run's hook 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() }) => {
+	context.hook("kubb:generation:end", async ({ config, diagnostics = [], filesCreated = 0, status = "success", hrStart = node_process.default.hrtime() }) => {
 		await reporter.report({
 			config,
 			diagnostics,
@@ -782,7 +712,7 @@ function installReporter(context, reporter, ctx) {
 			hrStart
 		}, ctx);
 	});
-	if (reporter.drain) context.on("kubb:lifecycle:end", () => reporter.drain?.(ctx));
+	if (reporter.drain) context.hook("kubb:lifecycle:end", () => reporter.drain?.(ctx));
 }
 /**
 * Installs the live logger (the TUI view) and the given reporters (the output). The reporters are
@@ -801,10 +731,7 @@ async function setupReporters(context, { logLevel, reporters }) {
 	for (const reporter of reporters) {
 		if (reporter.name === "cli") {
 			if (hasJson) continue;
-			const type = detectLogger();
-			const logger = logMapper[type];
-			if (!logger) throw new Error(`Unknown adapter type: ${type}`);
-			await logger.install(context, { logLevel });
+			await (require_Telemetry.canUseTTY() ? clackLogger : plainLogger).install(context, { logLevel });
 		}
 		installReporter(context, reporter, ctx);
 	}
@@ -915,6 +842,34 @@ async function getConfigs({ configPath, input, watch, logLevel }) {
 		}))
 	};
 }
+let hookSequence = 0;
+/**
+* Returns a process-unique id that correlates a hook's `kubb:hook:start` and `kubb:hook:end`
+* emissions, which loggers use to key their per-hook state.
+*/
+function createHookId() {
+	hookSequence += 1;
+	return `hook-${hookSequence}`;
+}
+/**
+* Returns `true` when `latest` is a newer semver version than `current`. Compares each numeric
+* part, so `5.10.0` beats `5.9.0` where a plain string comparison would not. Prerelease
+* suffixes are ignored, and a malformed version never reports an update.
+*
+* @example Double-digit minor
+* `isNewerVersion('5.9.0', '5.10.0') // true`
+*
+* @example String comparison would get this wrong the other way
+* `isNewerVersion('5.10.0', '5.9.0') // false`
+*/
+function isNewerVersion(current, latest) {
+	const release = (value) => value.split("-")[0] ?? "";
+	const isNumeric = (value) => /^\d+(\.\d+)*$/.test(value);
+	const currentRelease = release(current);
+	const latestRelease = release(latest);
+	if (!isNumeric(currentRelease) || !isNumeric(latestRelease)) return false;
+	return currentRelease.localeCompare(latestRelease, void 0, { numeric: true }) < 0;
+}
 /**
 * Tokenizes a shell command string, respecting single and double quotes.
 *
@@ -928,65 +883,74 @@ function tokenize(command) {
 	return (command.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g) ?? []).map((token) => token.replace(/^["']|["']$/g, ""));
 }
 /**
-* Runs the `done` hooks defined in a Kubb config in sequence.
+* Runs the `done` hooks defined in a Kubb config in sequence and returns each hook's outcome,
+* so the caller can turn failures into diagnostics.
 */
 async function executeHooks({ configHooks, hooks }) {
 	const commands = Array.isArray(configHooks.done) ? configHooks.done : [configHooks.done].filter(Boolean);
+	const results = [];
 	for (const command of commands) {
 		const [cmd, ...args] = tokenize(command);
 		if (!cmd) continue;
-		const hookId = (0, node_crypto.hash)("sha256", command, "hex");
+		const hookId = createHookId();
 		const commandWithArgs = [cmd, ...args].join(" ");
-		await hooks.emit("kubb:hook:start", {
+		await hooks.callHook("kubb:hook:start", {
 			id: hookId,
 			command: cmd,
 			args
 		});
-		await runHook({
+		results.push(await runHook({
 			id: hookId,
 			command: cmd,
 			args,
 			commandWithArgs,
 			hooks
-		});
+		}));
 	}
+	return results;
 }
 /**
-* Spawns a hook command and reports its outcome through `kubb:hook:end`.
-* A non-zero exit signals failure via `kubb:hook:end` rather than throwing, so the caller can turn
+* Spawns a hook command and returns its outcome, mirroring it through `kubb:hook:end` for the
+* loggers. A non-zero exit returns `success: false` rather than throwing, so the caller can turn
 * it into a diagnostic. Other spawn errors do the same. Output is streamed through `kubb:hook:line`
 * only while a listener is attached.
 */
 async function runHook({ id, command, args, commandWithArgs, hooks }) {
-	const emitEnd = (success, error, output) => hooks.emit("kubb:hook:end", {
-		command,
-		args,
-		id,
-		success,
-		error,
-		...output
-	});
+	const emitEnd = async (result) => {
+		await hooks.callHook("kubb:hook:end", {
+			command,
+			args,
+			id,
+			...result
+		});
+		return result;
+	};
 	const stream = hooks.listenerCount("kubb:hook:line") > 0;
 	try {
 		const proc = (0, tinyexec.x)(command, [...args ?? []], {
 			nodeOptions: { detached: node_process.default.platform !== "win32" },
 			throwOnError: true
 		});
-		if (stream) for await (const line of proc) await hooks.emit("kubb:hook:line", {
+		if (stream) for await (const line of proc) await hooks.callHook("kubb:hook:line", {
 			id,
 			line
 		});
 		await proc;
-		await hooks.emit("kubb:success", { message: `${(0, node_util.styleText)("dim", commandWithArgs)} successfully executed` });
-		await emitEnd(true, null);
+		await hooks.callHook("kubb:success", { message: `${(0, node_util.styleText)("dim", commandWithArgs)} successfully executed` });
+		return emitEnd({
+			success: true,
+			error: null
+		});
 	} catch (err) {
-		if (!(err instanceof tinyexec.NonZeroExitError)) {
-			await emitEnd(false, require_errors.toError(err));
-			return;
-		}
+		if (!(err instanceof tinyexec.NonZeroExitError)) return emitEnd({
+			success: false,
+			error: require_errors.toError(err)
+		});
 		const stderr = err.output?.stderr ?? "";
 		const stdout = err.output?.stdout ?? "";
-		await emitEnd(false, /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`), {
+		return emitEnd({
+			success: false,
+			error: /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`),
 			stdout,
 			stderr
 		});
@@ -994,7 +958,9 @@ async function runHook({ id, command, args, commandWithArgs, hooks }) {
 }
 /**
 * Starts a file watcher on the given paths and calls `cb` on any change.
-* Ignores `.git` and `node_modules` directories.
+* Ignores `.git` and `node_modules` directories. Event bursts (an editor save emits several)
+* are debounced into one build, and builds never overlap: changes during a build queue exactly
+* one rebuild.
 */
 async function startWatcher(path, cb, log = {
 	info: console.log,
@@ -1003,7 +969,8 @@ async function startWatcher(path, cb, log = {
 	const { watch } = await import("chokidar");
 	const watcher = watch(path, {
 		ignorePermissionErrors: true,
-		ignored: require_Telemetry.WATCHER_IGNORED_PATHS
+		ignored: require_Telemetry.WATCHER_IGNORED_PATHS,
+		ignoreInitial: true
 	});
 	node_process.default.once("SIGINT", () => {
 		watcher.close();
@@ -1011,78 +978,70 @@ async function startWatcher(path, cb, log = {
 	node_process.default.once("SIGTERM", () => {
 		watcher.close();
 	});
-	watcher.on("all", async (type, file) => {
+	const runBuild = createSerialRunner({
+		run: () => cb(path),
+		onError: () => log.error((0, node_util.styleText)("red", "Watcher failed"))
+	});
+	let debounceTimer = null;
+	watcher.on("all", (type, file) => {
 		log.info((0, node_util.styleText)("yellow", (0, node_util.styleText)("bold", `Change detected: ${type} ${file}`)));
-		try {
-			await cb(path);
-		} catch (_e) {
-			log.error((0, node_util.styleText)("red", "Watcher failed"));
-		}
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(() => {
+			debounceTimer = null;
+			runBuild();
+		}, 100);
 	});
 }
 //#endregion
 //#region src/runners/generate/run.ts
 /**
-* Registers a one-shot `kubb:hook:end` listener for `hookId` before the caller emits `kubb:hook:start`,
-* so a synchronous emitter cannot fire end before the listener is attached.
+* Runs one formatter or linter pass over the output directory. Returns the failure instead of
+* throwing, so the caller can turn it into a coded diagnostic. Failures never render here:
+* the caller emits them through `Diagnostics.emit`, like every other diagnostic.
 */
-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, hooks, onStart, onEnd }) {
+async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefix, noToolMessage, outputPath, logLevel, hooks, onStart, onEnd }) {
 	await onStart();
 	let resolvedTool = toolValue;
 	if (resolvedTool === "auto") {
 		const detected = await detect();
-		if (!detected) await hooks.emit("kubb:warn", { message: noToolMessage });
+		if (!detected) await hooks.callHook("kubb:warn", { message: noToolMessage });
 		else {
 			resolvedTool = detected;
-			await hooks.emit("kubb:info", { message: `Auto-detected ${toolLabel}: ${(0, node_util.styleText)("dim", resolvedTool)}` });
+			await hooks.callHook("kubb:info", { message: `Auto-detected ${toolLabel}: ${(0, node_util.styleText)("dim", resolvedTool)}` });
 		}
 	}
-	let toolError;
+	let toolError = null;
 	if (resolvedTool && resolvedTool !== "auto" && resolvedTool in toolMap && (0, node_fs.existsSync)(outputPath)) {
 		const toolConfig = toolMap[resolvedTool];
-		const hookId = (0, node_crypto.hash)("sha256", [configName, resolvedTool].filter(Boolean).join("-"), "hex");
 		const successMessage = [
 			`${successPrefix} with ${(0, node_util.styleText)("dim", resolvedTool)}`,
 			logLevel >= _kubb_core.logLevel.info ? `on ${(0, node_util.styleText)("dim", outputPath)}` : void 0,
 			"successfully"
 		].filter(Boolean).join(" ");
 		try {
+			const hookId = createHookId();
 			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", {
+			await hooks.callHook("kubb:hook:start", {
 				id: hookId,
 				command: toolConfig.command,
 				args: hookArgs
 			});
-			runHook({
+			const result = await runHook({
 				id: hookId,
 				command: toolConfig.command,
 				args: hookArgs,
 				commandWithArgs,
 				hooks
-			}).catch(() => {});
-			await hookEndPromise;
+			});
+			if (result.success) await hooks.callHook("kubb:success", { message: successMessage });
+			else toolError = result.error ?? new Error(toolConfig.errorMessage);
 		} catch (caughtError) {
 			toolError = require_errors.toError(caughtError);
 		}
 	}
 	await onEnd();
-	if (toolError) throw toolError;
+	return toolError;
 }
 async function generate(options) {
 	const { input, hooks, logLevel } = options;
@@ -1093,22 +1052,21 @@ async function generate(options) {
 		input: inputPath ? {
 			...options.config.input,
 			path: inputPath
-		} : options.config.input,
-		...options.config.output
+		} : options.config.input
 	};
 	const kubb = (0, _kubb_core.createKubb)(config, { hooks });
-	await hooks.emit("kubb:generation:start", { config });
-	await hooks.emit("kubb:info", {
+	await hooks.callHook("kubb:generation:start", { config });
+	await hooks.callHook("kubb:info", {
 		message: config.name ? `Setup generation ${(0, node_util.styleText)("bold", config.name)}` : "Setup generation",
 		info: inputPath
 	});
 	await kubb.setup();
-	await hooks.emit("kubb:info", {
+	await hooks.callHook("kubb:info", {
 		message: config.name ? `Build generation ${(0, node_util.styleText)("bold", config.name)}` : "Build generation",
 		info: inputPath
 	});
 	const { files, diagnostics, driver } = await kubb.safeBuild();
-	await hooks.emit("kubb:info", { message: "Load summary" });
+	await hooks.callHook("kubb:info", { message: "Load summary" });
 	const telemetryPlugins = Array.from(driver.plugins.values(), (p) => ({
 		name: p.name,
 		options: p.options
@@ -1124,11 +1082,11 @@ async function generate(options) {
 	for (const diagnostic of diagnostics) {
 		if (!_kubb_core.Diagnostics.isProblem(diagnostic)) continue;
 		const unknown = _kubb_core.Diagnostics.narrow(diagnostic, _kubb_core.Diagnostics.code.unknown);
-		if (unknown) await hooks.emit("kubb:error", { error: unknown.cause ?? new Error(unknown.message) });
+		if (unknown) await hooks.callHook("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", {
+		await hooks.callHook("kubb:generation:end", {
 			config,
 			storage: kubb.storage,
 			diagnostics,
@@ -1141,77 +1099,70 @@ async function generate(options) {
 	}
 	const outputPath = node_path.default.resolve(config.root, config.output.path);
 	const outputDiagnostics = [];
-	const toolPasses = [config.output.format && {
-		code: _kubb_core.Diagnostics.code.formatFailed,
-		toolValue: config.output.format,
-		detect: () => require_tools.detectTool([
-			"oxfmt",
-			"biome",
-			"prettier"
-		]),
-		toolMap: require_tools.formatters,
-		toolLabel: "formatter",
-		successPrefix: "Formatting",
-		noToolMessage: "No formatter found (oxfmt, biome, or prettier). Skipping formatting.",
-		onStart: () => hooks.emit("kubb:format:start"),
-		onEnd: () => hooks.emit("kubb:format:end")
-	}, config.output.lint && {
-		code: _kubb_core.Diagnostics.code.lintFailed,
-		toolValue: config.output.lint,
-		detect: () => require_tools.detectTool([
-			"oxlint",
-			"biome",
-			"eslint"
-		]),
-		toolMap: require_tools.linters,
-		toolLabel: "linter",
-		successPrefix: "Linting",
-		noToolMessage: "No linter found (oxlint, biome, or eslint). Skipping linting.",
-		onStart: () => hooks.emit("kubb:lint:start"),
-		onEnd: () => hooks.emit("kubb:lint:end")
-	}].filter(Boolean);
-	for (const { code, ...pass } of toolPasses) try {
-		await runToolPass({
-			...pass,
-			configName: config.name,
+	const reportOutputFailure = async (code, label, error) => {
+		const diagnostic = outputDiagnostic(code, label, error);
+		outputDiagnostics.push(diagnostic);
+		await _kubb_core.Diagnostics.emit(hooks, diagnostic);
+	};
+	if (config.output.format) {
+		const error = await runToolPass({
+			toolValue: config.output.format,
+			detect: () => require_tools.detectTool([
+				"oxfmt",
+				"biome",
+				"prettier"
+			]),
+			toolMap: require_tools.formatters,
+			toolLabel: "formatter",
+			successPrefix: "Formatting",
+			noToolMessage: "No formatter found (oxfmt, biome, or prettier). Skipping formatting.",
+			onStart: () => hooks.callHook("kubb:format:start"),
+			onEnd: () => hooks.callHook("kubb:format:end"),
 			outputPath,
 			logLevel,
 			hooks
 		});
-	} catch (caughtError) {
-		const diagnostic = outputDiagnostic(code, pass.toolLabel, caughtError);
-		outputDiagnostics.push(diagnostic);
-		await _kubb_core.Diagnostics.emit(hooks, diagnostic);
+		if (error) await reportOutputFailure(_kubb_core.Diagnostics.code.formatFailed, "formatter", error);
+	}
+	if (config.output.lint) {
+		const error = await runToolPass({
+			toolValue: config.output.lint,
+			detect: () => require_tools.detectTool([
+				"oxlint",
+				"biome",
+				"eslint"
+			]),
+			toolMap: require_tools.linters,
+			toolLabel: "linter",
+			successPrefix: "Linting",
+			noToolMessage: "No linter found (oxlint, biome, or eslint). Skipping linting.",
+			onStart: () => hooks.callHook("kubb:lint:start"),
+			onEnd: () => hooks.callHook("kubb:lint:end"),
+			outputPath,
+			logLevel,
+			hooks
+		});
+		if (error) await reportOutputFailure(_kubb_core.Diagnostics.code.lintFailed, "linter", error);
 	}
 	if (config.hooks) {
-		await hooks.emit("kubb:hooks:start");
-		const hookFailures = [];
-		const onHookEnd = (ctx) => {
-			if (!ctx.success) hookFailures.push(ctx.error ?? /* @__PURE__ */ new Error("Post-generate hook failed"));
-		};
-		hooks.on("kubb:hook:end", onHookEnd);
-		try {
-			await executeHooks({
-				configHooks: config.hooks,
-				hooks
-			});
-		} finally {
-			hooks.off("kubb:hook:end", onHookEnd);
-		}
-		for (const error of hookFailures) {
-			const diagnostic = outputDiagnostic(_kubb_core.Diagnostics.code.hookFailed, "Post-generate hook", error);
-			outputDiagnostics.push(diagnostic);
-			await _kubb_core.Diagnostics.emit(hooks, diagnostic);
+		await hooks.callHook("kubb:hooks:start");
+		const hookResults = await executeHooks({
+			configHooks: config.hooks,
+			hooks
+		});
+		for (const result of hookResults) {
+			if (result.success) continue;
+			await reportOutputFailure(_kubb_core.Diagnostics.code.hookFailed, "Post-generate hook", result.error ?? /* @__PURE__ */ new Error("Post-generate hook failed"));
 		}
-		await hooks.emit("kubb:hooks:end");
+		await hooks.callHook("kubb:hooks:end");
 	}
 	const finalDiagnostics = [...diagnostics, ...outputDiagnostics];
 	const failed = _kubb_core.Diagnostics.hasError(outputDiagnostics);
-	if (!failed) await hooks.emit("kubb:success", {
+	if (!failed) await hooks.callHook("kubb:success", {
 		message: "Generation succeeded",
 		info: inputPath
 	});
-	await hooks.emit("kubb:generation:end", {
+	await hooks.callHook("kubb:generation:end", {
 		config,
 		storage: kubb.storage,
 		diagnostics: finalDiagnostics,
@@ -1238,8 +1189,8 @@ function outputDiagnostic(code, label, caughtError) {
 }
 async function checkForUpdate(hooks) {
 	try {
-		const data = await (await fetch(require_Telemetry.KUBB_NPM_PACKAGE_URL)).json();
-		if (data.version && require_package.version < data.version) await _kubb_core.Diagnostics.emit(hooks, _kubb_core.Diagnostics.update({
+		const data = await (await fetch(require_Telemetry.KUBB_NPM_PACKAGE_URL, { signal: AbortSignal.timeout(require_Telemetry.UPDATE_CHECK_TIMEOUT_MS) })).json();
+		if (data.version && isNewerVersion(require_package.version, data.version)) await _kubb_core.Diagnostics.emit(hooks, _kubb_core.Diagnostics.update({
 			currentVersion: require_package.version,
 			latestVersion: data.version
 		}));
@@ -1252,7 +1203,7 @@ async function checkForUpdate(hooks) {
 */
 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 hooks = new _kubb_core.Hookable();
 	let configs;
 	let resolvedConfigPath;
 	try {
@@ -1269,7 +1220,7 @@ async function run({ input, configPath, logLevel: logLevelKey, watch, reporters:
 			logLevel,
 			reporters: [_kubb_core.cliReporter]
 		});
-		await hooks.emit("kubb:error", { error: require_errors.toError(error) });
+		await hooks.callHook("kubb:error", { error: require_errors.toError(error) });
 		node_process.default.exit(1);
 	}
 	const requestedNames = cliReporters?.length ? cliReporters : ["cli"];
@@ -1277,32 +1228,40 @@ async function run({ input, configPath, logLevel: logLevelKey, watch, reporters:
 		logLevel,
 		reporters: selectReporters(configs[0]?.reporters ?? [], requestedNames)
 	});
-	await hooks.emit("kubb:lifecycle:start", { version: require_package.version });
+	await hooks.callHook("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:info", {
+		await hooks.callHook("kubb:info", {
 			message: "Config loaded",
 			info: relativeConfigPath
 		});
-		await hooks.emit("kubb:success", {
+		await hooks.callHook("kubb:success", {
 			message: "Config loaded successfully",
 			info: relativeConfigPath
 		});
 		let anyFailed = false;
-		for (const config of configs) if (config.input && "path" in config.input && watch) await startWatcher([input || config.input.path], async (paths) => {
-			await generate({
-				input,
-				config,
-				logLevel,
-				hooks
+		for (const config of configs) if (config.input && "path" in config.input && watch) {
+			const watchedPaths = [input || config.input.path];
+			const build = async (paths) => {
+				await generate({
+					input,
+					config,
+					logLevel,
+					hooks
+				});
+				_clack_prompts.log.step((0, node_util.styleText)("yellow", `Watching for changes in ${paths.join(" and ")}`));
+			};
+			try {
+				await build(watchedPaths);
+			} catch (buildError) {
+				await hooks.callHook("kubb:error", { error: require_errors.toError(buildError) });
+			}
+			await startWatcher(watchedPaths, build, {
+				info: (msg) => _clack_prompts.log.info(msg),
+				error: (msg) => _clack_prompts.log.error(msg)
 			});
-			_clack_prompts.log.step((0, node_util.styleText)("yellow", `Watching for changes in ${paths.join(" and ")}`));
-		}, {
-			info: (msg) => _clack_prompts.log.info(msg),
-			error: (msg) => _clack_prompts.log.error(msg)
-		});
-		else try {
+		} else try {
 			if (!await generate({
 				input,
 				config,
@@ -1310,17 +1269,17 @@ async function run({ input, configPath, logLevel: logLevelKey, watch, reporters:
 				hooks
 			})) anyFailed = true;
 		} catch (configError) {
-			await hooks.emit("kubb:error", { error: require_errors.toError(configError) });
+			await hooks.callHook("kubb:error", { error: require_errors.toError(configError) });
 			anyFailed = true;
 		}
-		await hooks.emit("kubb:lifecycle:end");
+		await hooks.callHook("kubb:lifecycle:end");
 		if (anyFailed) node_process.default.exit(1);
 	} catch (error) {
-		await hooks.emit("kubb:error", { error: require_errors.toError(error) });
+		await hooks.callHook("kubb:error", { error: require_errors.toError(error) });
 		node_process.default.exit(1);
 	}
 }
 //#endregion
 exports.run = run;
 
-//# sourceMappingURL=run-ChSqYuc1.cjs.map
+//# sourceMappingURL=run-lAxAF-4t.cjs.map