@kubb/cli 5.0.0-beta.75 → 5.0.0-beta.8

package/dist/{generate-Cg8yufrw.js → run-CXTVu3Wl.js}

@@ -1,9 +1,9 @@
-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-DqZsMLZ9.js";
-import { a as SUMMARY_SEPARATOR, n as KUBB_NPM_PACKAGE_URL, o as WATCHER_IGNORED_PATHS } from "./constants-aL3CP_Wq.js";
+import "./chunk-BvFE5Tac.js";
+import { n as toCause, r as toError } from "./errors-CINO1EIv.js";
+import { a as canUseTTY, i as executeIfOnline, o as isGitHubActions, r as sendTelemetry, t as buildTelemetryEvent } from "./telemetry-BkektVz6.js";
+import { n as tokenize } from "./shell-CN6DNqeC.js";
+import { t as version } from "./package-s8PvCnk-.js";
+import { a as WATCHER_IGNORED_PATHS, i as SUMMARY_SEPARATOR, t as KUBB_NPM_PACKAGE_URL } from "./constants-B2JTeRBb.js";
 import { styleText } from "node:util";
 import { EventEmitter } from "node:events";
 import { createHash } from "node:crypto";
@@ -14,10 +14,10 @@ import path, { dirname, relative, resolve } from "node:path";
 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.
@@ -486,100 +486,11 @@ 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;
-}
-//#endregion
-//#region src/utils/runHook.ts
+//#region src/loggers/clackLogger.ts
 /**
-* Executes a hook command, emits debug and completion events, and forwards output to an optional sink.
+* Node.js `Writable` stream that forwards each chunk to a clack `taskLog` message.
+* Used to pipe hook subprocess output into the clack task log UI.
 */
-async function runHook({ id, command, args, commandWithArgs, context, stream = false, sink }) {
-	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 });
-	}
-}
-//#endregion
-//#region src/utils/Writables.ts
 var ClackWritable = class extends Writable {
 	taskLog;
 	constructor(taskLog, opts) {
@@ -591,8 +502,6 @@ var ClackWritable = class extends Writable {
 		callback();
 	}
 };
-//#endregion
-//#region src/loggers/clackLogger.ts
 /**
 * TTY logger with beautiful UI and progress indicators for local development.
 */
@@ -818,40 +727,10 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			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;
-			}
+		context.on("kubb:hook:start", ({ command, args }) => {
+			if (logLevel$8 <= logLevel.silent) return;
+			const text = getMessage(`Hook ${styleText("dim", formatCommandWithArgs(command, args))} started`);
 			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)
-				}
-			});
 		});
 		context.on("kubb:hook:end", ({ command, args }) => {
 			if (logLevel$8 <= logLevel.silent) return;
@@ -887,13 +766,28 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 		context.on("kubb:lifecycle:end", () => {
 			reset();
 		});
+		return (commandWithArgs) => {
+			if (logLevel$8 <= logLevel.silent) return {
+				onStdout: (s) => console.log(s),
+				onStderr: (s) => console.error(s)
+			};
+			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);
+			return {
+				stream: true,
+				onLine: (line) => writable.write(line),
+				onStdout: (s) => logger.message(s),
+				onStderr: (s) => logger.error(s)
+			};
+		};
 	}
 });
 //#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.
+*
+* @note Logs are written on `kubb:lifecycle:end` or process exit. Cached logs may be lost if the process crashes before either event.
 */
 const fileSystemLogger = defineLogger({
 	name: "filesystem",
@@ -918,29 +812,31 @@ const fileSystemLogger = defineLogger({
 				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")}`);
+					const prefix = `[${log.date.toLocaleString()}] `;
+					const indent = " ".repeat(prefix.length);
+					const [first, ...rest] = log.logs;
+					files[pathName].push([prefix + first, ...rest.map((line) => indent + line)].join("\n"));
 				}
 			}
-			for (const [fileName, logs] of Object.entries(files)) await write(fileName, logs.join("\n\n"));
+			for (const [fileName, logs] of Object.entries(files)) await write(fileName, logs.join("\n"));
 			return Object.keys(files);
 		}
 		context.on("kubb:info", ({ message, info }) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: [`ℹ ${message} ${info}`]
+				logs: [`ℹ ${[message, info].filter(Boolean).join(" ")}`]
 			});
 		});
 		context.on("kubb:success", ({ message, info }) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: [`✓ ${message} ${info}`]
+				logs: [`✓ ${[message, info].filter(Boolean).join(" ")}`]
 			});
 		});
 		context.on("kubb:warn", ({ message, info }) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: [`⚠ ${message} ${info}`]
+				logs: [`⚠ ${[message, info].filter(Boolean).join(" ")}`]
 			});
 		});
 		context.on("kubb:error", ({ error }) => {
@@ -949,29 +845,30 @@ const fileSystemLogger = defineLogger({
 				logs: [`✗ ${error.message}`, error.stack || "unknown stack"]
 			});
 		});
-		context.on("kubb:debug", (message) => {
+		context.on("kubb:debug", ({ date, fileName, logs }) => {
 			state.cachedLogs.add({
-				date: /* @__PURE__ */ new Date(),
-				logs: message.logs
+				date,
+				fileName,
+				logs
 			});
 		});
 		context.on("kubb:plugin:start", ({ plugin }) => {
 			state.cachedLogs.add({
 				date: /* @__PURE__ */ new Date(),
-				logs: [`Generating ${plugin.name}`]
+				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}`]
+				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)]
+				logs: [`► Writing ${files.length} files`, ...files.map((file) => `  ${file.path}`)]
 			});
 		});
 		context.on("kubb:generation:end", async ({ config }) => {
@@ -1164,25 +1061,12 @@ const githubActionsLogger = defineLogger({
 			console.log(text);
 			if (state.currentConfigs.length === 1) closeGroup("Linting");
 		});
-		context.on("kubb:hook:start", async ({ id, command, args }) => {
+		context.on("kubb:hook:start", ({ command, args }) => {
+			if (logLevel$7 <= logLevel.silent) return;
 			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;
@@ -1202,6 +1086,10 @@ const githubActionsLogger = defineLogger({
 		context.on("kubb:lifecycle:end", () => {
 			reset();
 		});
+		return (_commandWithArgs) => ({
+			onStdout: logLevel$7 > logLevel.silent ? (s) => console.log(s) : void 0,
+			onStderr: logLevel$7 > logLevel.silent ? (s) => console.error(`::error::${s}`) : void 0
+		});
 	}
 });
 //#endregion
@@ -1324,22 +1212,10 @@ const plainLogger = defineLogger({
 			const text = getMessage("Lint completed");
 			console.log(text);
 		});
-		context.on("kubb:hook:start", async ({ id, command, args }) => {
-			const commandWithArgs = formatCommandWithArgs(command, args);
-			const text = getMessage(`Hook ${commandWithArgs} started`);
-			if (logLevel$6 > logLevel.silent) console.log(text);
-			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
-				}
-			});
+		context.on("kubb:hook:start", ({ command, args }) => {
+			if (logLevel$6 <= logLevel.silent) return;
+			const text = getMessage(`Hook ${formatCommandWithArgs(command, args)} started`);
+			console.log(text);
 		});
 		context.on("kubb:hook:end", ({ command, args }) => {
 			if (logLevel$6 <= logLevel.silent) return;
@@ -1359,6 +1235,10 @@ const plainLogger = defineLogger({
 			console.log(summary.join("\n"));
 			console.log(SUMMARY_SEPARATOR);
 		});
+		return (_commandWithArgs) => ({
+			onStdout: logLevel$6 > logLevel.silent ? (s) => console.log(s) : void 0,
+			onStderr: logLevel$6 > logLevel.silent ? (s) => console.error(s) : void 0
+		});
 	}
 });
 //#endregion
@@ -1413,124 +1293,233 @@ 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 });
+	const makeSink = await logger.install(context, { logLevel: logLevel$5 });
 	if (logLevel$5 >= logLevel.debug) await fileSystemLogger.install(context, { logLevel: logLevel$5 });
-	return cleanup;
+	return typeof makeSink === "function" ? makeSink : void 0;
 }
-//#endregion
-//#region src/utils/executeHooks.ts
-async function executeHooks({ configHooks, hooks }) {
-	const commands = Array.isArray(configHooks.done) ? configHooks.done : [configHooks.done].filter(Boolean);
-	for (const command of commands) {
-		const [cmd, ...args] = tokenize(command);
-		if (!cmd) continue;
-		const hookId = 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);
-		});
-		await hooks.emit("kubb:hook:start", {
-			id: hookId,
-			command: cmd,
-			args
+/**
+* Builds the generation summary lines rendered in the end-of-run box.
+* Returns an array of styled strings, one per summary row.
+*/
+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}`);
 		});
-		await hookEndPromise;
 	}
+	summaryLines.push(`${labels.output.padEnd(maxLength + 2)} ${meta.output}`);
+	return summaryLines;
 }
 //#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, {
+//#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: [
-			...searchPlaces.map((searchPlace) => {
-				return `.config/${searchPlace}`;
-			}),
-			...searchPlaces.map((searchPlace) => {
-				return `configs/${searchPlace}`;
-			}),
-			...searchPlaces
-		],
+		searchPlaces: SEARCH_PLACES,
 		loaders: {
 			".ts": tsLoader,
 			".mts": tsLoader,
 			".cts": tsLoader
 		}
 	});
+	let result;
 	try {
-		result = config ? await explorer.load(config) : await explorer.search();
+		result = configFile ? await explorer.load(configFile) : await explorer.search();
 	} catch (error) {
 		throw new Error("Config failed loading", { cause: error });
 	}
-	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");
+	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;
 }
-//#endregion
-//#region src/utils/watcher.ts
-async function startWatcher(path, cb) {
+/**
+* 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 }) {
+	const result = await getCosmiConfig(configPath);
+	const resolved = await (typeof result.config === "function" ? result.config({ input }) : 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 commandWithArgs = [cmd, ...args].join(" ");
+		await hooks.emit("kubb:hook:start", {
+			id: hookId,
+			command: cmd,
+			args
+		});
+		const { stream = false, onLine, onStdout, onStderr } = makeSink?.(commandWithArgs) ?? {};
+		await runHook({
+			id: hookId,
+			command: cmd,
+			args,
+			commandWithArgs,
+			context: hooks,
+			stream,
+			sink: {
+				onLine,
+				onStdout,
+				onStderr
+			}
+		});
+	}
+}
+async function runHook({ id, command, args, commandWithArgs, context, stream = false, sink }) {
+	const emitEnd = (success, error) => context.emit("kubb:hook:end", {
+		command,
+		args,
+		id,
+		success,
+		error
+	});
+	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:success", { message: `${styleText("dim", commandWithArgs)} successfully executed` });
+		await emitEnd(true, null);
+	} catch (err) {
+		if (!(err instanceof NonZeroExitError)) {
+			const error = toError(err);
+			await emitEnd(false, error);
+			await context.emit("kubb:error", { error });
+			return;
+		}
+		const stderr = err.output?.stderr ?? "";
+		const stdout = err.output?.stdout ?? "";
+		await context.emit("kubb:debug", {
+			date: /* @__PURE__ */ new Date(),
+			logs: [stdout, stderr].filter(Boolean)
+		});
+		if (stderr) sink?.onStderr?.(stderr);
+		if (stdout) sink?.onStdout?.(stdout);
+		const error = /* @__PURE__ */ new Error(`Hook execute failed: ${commandWithArgs}`);
+		await emitEnd(false, error);
+		await context.emit("kubb:error", { error });
+	}
+}
+/**
+* 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, {
 		ignorePermissionErrors: true,
 		ignored: WATCHER_IGNORED_PATHS
 	}).on("all", async (type, file) => {
-		console.log(styleText("yellow", styleText("bold", `Change detected: ${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
+//#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;
+			}
+			onSuccess().then(resolve).catch(reject);
+		};
+		hooks.on("kubb:hook:end", handler);
+	});
+}
 async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefix, noToolMessage, configName, outputPath, logLevel: logLevel$1, hooks, onStart, onEnd }) {
 	await onStart();
 	let resolvedTool = toolValue;
@@ -1545,24 +1534,14 @@ async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefi
 	let toolError;
 	if (resolvedTool && resolvedTool !== "auto" && resolvedTool in toolMap) {
 		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 hookEndPromise = waitForHookEnd(hooks, hookId, () => hooks.emit("kubb:success", { message: successMessage }), toolConfig.errorMessage);
 			await hooks.emit("kubb:hook:start", {
 				id: hookId,
 				command: toolConfig.command,
@@ -1579,9 +1558,9 @@ async function runToolPass({ toolValue, detect, toolMap, toolLabel, successPrefi
 	if (toolError) throw toolError;
 }
 async function generate(options) {
-	const { input, hooks, logLevel: logLevel$2 } = options;
+	const { input, hooks, logLevel: logLevel$2, makeSink } = options;
 	const hrStart = process$1.hrtime();
-	const inputPath = input ?? ("path" in options.config.input ? options.config.input.path : void 0);
+	const inputPath = input ?? (options.config.input && "path" in options.config.input ? options.config.input.path : void 0);
 	const config = {
 		...options.config,
 		input: inputPath ? {
@@ -1603,8 +1582,20 @@ async function generate(options) {
 	});
 	const { files, failedPlugins, pluginTimings, error, driver } = await kubb.safeBuild();
 	await hooks.emit("kubb:info", { message: "Load summary" });
+	const telemetryPlugins = Array.from(driver.plugins.values(), (p) => ({
+		name: p.name,
+		options: p.options
+	}));
+	const reportTelemetry = (status) => sendTelemetry(buildTelemetryEvent({
+		command: "generate",
+		kubbVersion: version,
+		plugins: telemetryPlugins,
+		hrStart,
+		filesCreated: files.length,
+		status
+	}));
 	if (failedPlugins.size > 0 || error) {
-		const allErrors = [error, ...Array.from(failedPlugins).filter((it) => it.error).map((it) => it.error)].filter(Boolean);
+		const allErrors = [error, ...Array.from(failedPlugins, (it) => it.error)].filter(Boolean);
 		for (const err of allErrors) await hooks.emit("kubb:error", { error: err });
 		await hooks.emit("kubb:generation:end", {
 			config,
@@ -1619,21 +1610,11 @@ async function generate(options) {
 			hrStart,
 			pluginTimings: logLevel$2 >= logLevel.verbose ? pluginTimings : void 0
 		});
-		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"
-		}));
+		await reportTelemetry("failed");
 		process$1.exit(1);
 	}
 	await hooks.emit("kubb:success", {
-		message: "Generation successfully",
+		message: "Generation succeeded",
 		info: inputPath
 	});
 	await hooks.emit("kubb:generation:end", {
@@ -1642,39 +1623,38 @@ async function generate(options) {
 		sources: kubb.sources
 	});
 	const outputPath = path.resolve(config.root, config.output.path);
-	if (config.output.format) await runToolPass({
+	const toolPasses = [config.output.format && {
 		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 && {
 		toolValue: config.output.lint,
 		detect: detectLinter,
 		toolMap: linters,
 		toolLabel: "linter",
 		successPrefix: "Linting",
 		noToolMessage: "No linter found (oxlint, biome, or eslint). Skipping linting.",
+		onStart: () => hooks.emit("kubb:lint:start"),
+		onEnd: () => hooks.emit("kubb:lint:end")
+	}].filter(Boolean);
+	for (const pass of toolPasses) await runToolPass({
+		...pass,
 		configName: config.name,
 		outputPath,
 		logLevel: logLevel$2,
-		hooks,
-		onStart: () => hooks.emit("kubb:lint:start"),
-		onEnd: () => hooks.emit("kubb:lint:end")
+		hooks
 	});
 	if (config.hooks) {
 		await hooks.emit("kubb:hooks:start");
 		await executeHooks({
 			configHooks: config.hooks,
-			hooks
+			hooks,
+			makeSink
 		});
 		await hooks.emit("kubb:hooks:end");
 	}
@@ -1686,42 +1666,42 @@ async function generate(options) {
 		hrStart,
 		pluginTimings
 	});
-	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("success");
 }
-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 });
+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 hooks.emit("kubb:version:new", {
 				currentVersion: version,
-				latestVersion
+				latestVersion: data.version
 			});
 		} catch {}
 	});
+}
+/**
+* Runs the full Kubb generation lifecycle for the given CLI options.
+* Sets up the logger, checks for a newer version, loads configs, and calls `generate` for each config entry.
+*/
+async function run({ input, configPath, logLevel: logLevelKey, watch }) {
+	const logLevel$3 = logLevel[logLevelKey] ?? logLevel.info;
+	const hooks = new AsyncEventEmitter();
+	const makeSink = await setupLogger(hooks, { logLevel: logLevel$3 });
+	await checkForUpdate(hooks);
 	try {
-		const result = await getCosmiConfig("kubb", configPath);
-		const configs = await getConfigs(result.config, { input });
+		const { configs, configPath: resolvedConfigPath } = await getConfigs({
+			configPath,
+			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 });
@@ -1731,15 +1711,20 @@ async function runGenerateCommand({ input, configPath, logLevel: logLevelKey, wa
 				input,
 				config,
 				logLevel: logLevel$3,
-				hooks
+				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
+			hooks,
+			makeSink
 		});
 		await hooks.emit("kubb:lifecycle:end");
 	} catch (error) {
@@ -1748,6 +1733,6 @@ async function runGenerateCommand({ input, configPath, logLevel: logLevelKey, wa
 	}
 }
 //#endregion
-export { runGenerateCommand };
+export { run };
 
-//# sourceMappingURL=generate-Cg8yufrw.js.map
+//# sourceMappingURL=run-CXTVu3Wl.js.map