@kubb/cli 5.1.0 → 5.2.0

package/dist/{run-CLGgnrjg.js → utils-CzoNURwq.js}

@@ -1,19 +1,125 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { c as getAgentName, i as KUBB_NPM_PACKAGE_URL, l as canUseTTY, o as UPDATE_CHECK_TIMEOUT_MS, r as sendTelemetry, s as WATCHER_IGNORED_PATHS, t as buildTelemetryEvent } from "./Telemetry-Fiymfxez.js";
-import { n as toError, t as toCause } from "./errors-CMvLO2NE.js";
-import { t as version } from "./package-DiBDd6nT.js";
-import { i as linters, n as detectTool, r as formatters } from "./tools-DH1a7ZJH.js";
+import { t as toError } from "./errors-C8yNfV7w.js";
+import { s as WATCHER_IGNORED_PATHS } from "./Telemetry-BCTY-Nzq.js";
+import { i as getAgentName, t as canUseTTY } from "./env-DqPKEL59.js";
 import { styleText } from "node:util";
 import { randomUUID } from "node:crypto";
 import process$1 from "node:process";
-import path, { basename, dirname, relative, resolve } from "node:path";
-import { existsSync } from "node:fs";
+import { basename, dirname, relative, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { Diagnostics, logLevel } from "@kubb/core";
 import * as clack from "@clack/prompts";
-import { Diagnostics, Hookable, cliReporter, createKubb, getInputKind, logLevel, memoryStorage } from "@kubb/core";
 import { createJiti } from "jiti";
 import { NonZeroExitError, x } from "tinyexec";
 import { loadConfig } from "unconfig";
 import { isGreater, isValid, truncate } from "verkit";
+//#region ../../internals/utils/src/tools.ts
+/**
+* CLI command descriptors for each supported code formatter.
+*/
+const formatters = {
+	prettier: {
+		command: "prettier",
+		args: (outputPath) => [
+			"--ignore-unknown",
+			"--write",
+			outputPath
+		],
+		errorMessage: "Prettier not found"
+	},
+	biome: {
+		command: "biome",
+		args: (outputPath) => [
+			"format",
+			"--write",
+			outputPath
+		],
+		errorMessage: "Biome not found"
+	},
+	oxfmt: {
+		command: "oxfmt",
+		args: (outputPath) => [outputPath],
+		errorMessage: "Oxfmt not found"
+	}
+};
+/**
+* CLI command descriptors for each supported linter.
+*/
+const linters = {
+	eslint: {
+		command: "eslint",
+		args: (outputPath) => [outputPath, "--fix"],
+		errorMessage: "Eslint not found"
+	},
+	biome: {
+		command: "biome",
+		args: (outputPath) => [
+			"lint",
+			"--fix",
+			outputPath
+		],
+		errorMessage: "Biome not found"
+	},
+	oxlint: {
+		command: "oxlint",
+		args: (outputPath) => [
+			"--fix",
+			"--no-ignore",
+			outputPath
+		],
+		errorMessage: "Oxlint not found"
+	}
+};
+/**
+* Preference order for `format: 'auto'`, most-preferred first. Spelled out rather than taken from
+* the table's key order, which is arbitrary and would silently change what `auto` picks.
+*/
+const FORMATTER_PREFERENCE = [
+	"oxfmt",
+	"biome",
+	"prettier"
+];
+/**
+* Preference order for `lint: 'auto'`, most-preferred first.
+*/
+const LINTER_PREFERENCE = [
+	"oxlint",
+	"biome",
+	"eslint"
+];
+/**
+* Whether `name` is on PATH and answers `--version` with a zero exit.
+*/
+function isToolAvailable(name) {
+	return new Promise((resolve) => {
+		const child = spawn(name, ["--version"], { stdio: "ignore" });
+		child.on("close", (code) => resolve(code === 0));
+		child.on("error", () => resolve(false));
+	});
+}
+/**
+* Returns the first installed executable from `candidates`, or `null` when none are found.
+*
+* Not memoized: a long-running host that probes repeatedly should cache the result itself, and a
+* `--watch` build should keep noticing a tool installed mid-session.
+*/
+async function detectTool(candidates) {
+	for (const candidate of candidates) if (await isToolAvailable(candidate)) return candidate;
+	return null;
+}
+/**
+* Tokenizes a shell command string, respecting single and double quotes.
+*
+* @example
+* ```ts
+* tokenize('git commit -m "initial commit"')
+* // → ['git', 'commit', '-m', 'initial commit']
+* ```
+*/
+function tokenize(command) {
+	return (command.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g) ?? []).map((token) => token.replace(/^["']|["']$/g, ""));
+}
+//#endregion
 //#region ../../internals/utils/src/time.ts
 /**
 * Calculates elapsed time in milliseconds from a high-resolution `process.hrtime` start time.
@@ -47,7 +153,7 @@ function formatMs(ms) {
 	return `${Math.round(ms)}ms`;
 }
 //#endregion
-//#region ../../internals/utils/src/colors.ts
+//#region src/loggers/banner.ts
 /**
 * Parses a CSS hex color string (`#RGB`) into its RGB channels.
 * Falls back to `255` for any channel that cannot be parsed.
@@ -158,43 +264,6 @@ function formatMsWithColor(ms) {
 	return 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(toError(error));
-			}
-		} while (dirty);
-		running = false;
-	};
-}
-//#endregion
 //#region src/loggers/clackLogger.ts
 /**
 * TTY logger for local development, with spinners and progress bars.
@@ -202,7 +271,7 @@ function createSerialRunner({ run, onError }) {
 const clackLogger = {
 	name: "clack",
 	install(context, options) {
-		const logLevel$5 = options?.logLevel ?? logLevel.info;
+		const logLevel$3 = options?.logLevel ?? logLevel.info;
 		const state = {
 			...createProgressCounters(),
 			spinner: clack.spinner(),
@@ -231,16 +300,16 @@ const clackLogger = {
 			return getMessage(running.length > 0 ? `Generating ${running.join(", ")}` : "Generating plugins");
 		}
 		function showProgressStep() {
-			if (logLevel$5 <= logLevel.silent) return;
+			if (logLevel$3 <= logLevel.silent) return;
 			const line = buildProgressLine(state);
 			if (line) clack.log.step(getMessage(line));
 		}
 		function getMessage(message) {
-			return formatMessage(message, logLevel$5);
+			return formatMessage(message, logLevel$3);
 		}
 		function onStep(hook, message) {
 			context.hook(hook, () => {
-				if (logLevel$5 <= logLevel.silent) return;
+				if (logLevel$3 <= logLevel.silent) return;
 				clack.log.step(getMessage(message));
 			});
 		}
@@ -250,7 +319,7 @@ const clackLogger = {
 			state.isSpinning = false;
 		}
 		context.hook("kubb:info", ({ message, info = "" }) => {
-			if (logLevel$5 <= logLevel.silent) return;
+			if (logLevel$3 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("blue", "ℹ"),
 				message,
@@ -263,11 +332,11 @@ const clackLogger = {
 			clack.log.info(text);
 		});
 		context.hook("kubb:success", ({ message, info = "" }) => {
-			if (logLevel$5 <= logLevel.silent) return;
+			if (logLevel$3 <= logLevel.silent) return;
 			const text = getMessage([
 				styleText("blue", "✓"),
 				message,
-				logLevel$5 >= logLevel.info ? styleText("dim", info) : void 0
+				logLevel$3 >= logLevel.info ? styleText("dim", info) : void 0
 			].filter(Boolean).join(" "));
 			if (state.isSpinning) {
 				stopSpinner(text);
@@ -276,11 +345,11 @@ const clackLogger = {
 			clack.log.success(text);
 		});
 		context.hook("kubb:warn", ({ message, info }) => {
-			if (logLevel$5 < logLevel.warn) return;
+			if (logLevel$3 < logLevel.warn) return;
 			const text = getMessage([
 				styleText("yellow", "⚠"),
 				message,
-				logLevel$5 >= logLevel.info && info ? styleText("dim", info) : void 0
+				logLevel$3 >= logLevel.info && info ? styleText("dim", info) : void 0
 			].filter(Boolean).join(" "));
 			clack.log.warn(text);
 		});
@@ -291,7 +360,7 @@ const clackLogger = {
 				return;
 			}
 			clack.log.error(getMessage(text));
-			const frames = logLevel$5 >= logLevel.verbose ? formatErrorFrames(error) : null;
+			const frames = logLevel$3 >= logLevel.verbose ? formatErrorFrames(error) : null;
 			if (frames) {
 				for (const frame of frames.frames) clack.log.message(getMessage(styleText("dim", frame)));
 				if (frames.cause) {
@@ -301,7 +370,7 @@ const clackLogger = {
 			}
 		});
 		context.hook("kubb:diagnostic", ({ diagnostic }) => {
-			if (logLevel$5 <= logLevel.silent && diagnostic.severity !== "error") return;
+			if (logLevel$3 <= logLevel.silent && diagnostic.severity !== "error") return;
 			stopSpinner();
 			stopActiveProgress();
 			if (Diagnostics.isUpdate(diagnostic)) {
@@ -322,6 +391,46 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				secondarySymbol: ""
 			});
 		});
+		context.hook("studio:connecting", ({ url }) => {
+			if (logLevel$3 <= logLevel.silent) return;
+			state.spinner = clack.spinner();
+			state.spinner.start(getMessage(`Connecting to ${styleText("cyan", url)}`));
+			state.isSpinning = true;
+		});
+		context.hook("studio:connected", ({ url, versions }) => {
+			if (logLevel$3 <= logLevel.silent) return;
+			const text = getMessage(`Connected to ${styleText("cyan", url)} ${styleText("dim", `(${formatVersions(versions)})`)}`);
+			if (state.isSpinning) {
+				stopSpinner(text);
+				return;
+			}
+			clack.log.success(text);
+		});
+		context.hook("studio:disconnected", ({ reason }) => {
+			if (logLevel$3 < logLevel.warn) return;
+			stopSpinner();
+			clack.log.warn(getMessage(`Kubb Studio ended the session (${reason})`));
+		});
+		context.hook("studio:command:start", ({ command }) => {
+			if (logLevel$3 <= logLevel.silent) return;
+			clack.log.info(getMessage(`Kubb Studio asked to ${styleText("bold", command)}`));
+		});
+		context.hook("studio:command:end", ({ command, info }) => {
+			if (logLevel$3 <= logLevel.silent) return;
+			clack.log.success(getMessage(`Finished ${command}${info ? ` ${styleText("dim", `(${info})`)}` : ""}`));
+		});
+		context.hook("studio:warn", ({ message }) => {
+			if (logLevel$3 < logLevel.warn) return;
+			clack.log.warn(getMessage(message));
+		});
+		context.hook("studio:error", ({ error }) => {
+			const text = getMessage([styleText("red", "✗"), error.message].join(" "));
+			if (state.isSpinning) {
+				stopSpinner(text);
+				return;
+			}
+			clack.log.error(text);
+		});
 		context.hook("kubb:lifecycle:start", async ({ version }) => {
 			console.log(`\n${getIntro({
 				title: "The meta framework for code generation",
@@ -334,7 +443,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 		context.hook("kubb:generation:start", ({ config }) => {
 			reset();
 			state.totalPlugins = config.plugins?.length ?? 0;
-			if (logLevel$5 <= logLevel.silent) return;
+			if (logLevel$3 <= logLevel.silent) return;
 			const text = getMessage([
 				"Generation started",
 				config.name ? `for ${styleText("dim", config.name)}` : void 0,
@@ -343,7 +452,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			clack.intro(text);
 		});
 		context.hook("kubb:plugin:start", ({ plugin }) => {
-			if (logLevel$5 <= logLevel.silent) return;
+			if (logLevel$3 <= logLevel.silent) return;
 			stopSpinner();
 			state.runningPlugins.add(plugin.name);
 			const active = state.activeProgress.get("plugins");
@@ -363,7 +472,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 		context.hook("kubb:plugin:end", ({ plugin, success }) => {
 			stopSpinner();
 			const active = state.activeProgress.get("plugins");
-			if (!active || logLevel$5 <= logLevel.silent) return;
+			if (!active || logLevel$3 <= logLevel.silent) return;
 			state.runningPlugins.delete(plugin.name);
 			recordPluginResult(state, success);
 			active.progressBar.advance(1, pluginProgressText());
@@ -374,7 +483,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			}
 		});
 		context.hook("kubb:files:processing:start", ({ files }) => {
-			if (logLevel$5 <= logLevel.silent) return;
+			if (logLevel$3 <= logLevel.silent) return;
 			stopSpinner();
 			state.totalFiles = files.length;
 			state.processedFiles = 0;
@@ -389,7 +498,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			state.activeProgress.set("files", { progressBar });
 		});
 		context.hook("kubb:files:processing:update", ({ files }) => {
-			if (logLevel$5 <= logLevel.silent) return;
+			if (logLevel$3 <= logLevel.silent) return;
 			stopSpinner();
 			const active = state.activeProgress.get("files");
 			for (const { file, config } of files) {
@@ -398,7 +507,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 			}
 		});
 		context.hook("kubb:files:processing:end", () => {
-			if (logLevel$5 <= logLevel.silent) return;
+			if (logLevel$3 <= logLevel.silent) return;
 			stopSpinner();
 			const text = getMessage("Files written successfully");
 			const active = state.activeProgress.get("files");
@@ -416,7 +525,7 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 		onStep("kubb:lint:start", "Linting");
 		onStep("kubb:hooks:start", "Running hooks");
 		context.hook("kubb:hook:start", ({ id, command, name, args }) => {
-			if (logLevel$5 <= logLevel.silent || !id) return;
+			if (logLevel$3 <= logLevel.silent || !id) return;
 			stopSpinner();
 			const commandWithArgs = formatCommandWithArgs(command, args);
 			const title = getMessage(`Running ${styleText("dim", name ?? commandWithArgs)}`);
@@ -426,12 +535,12 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				hrStart: process$1.hrtime()
 			});
 		});
-		if (logLevel$5 > logLevel.silent) context.hook("kubb:hook:line", ({ id, line }) => {
+		if (logLevel$3 > logLevel.silent) context.hook("kubb:hook:line", ({ id, line }) => {
 			state.activeHookLogs.get(id)?.taskLog.message(styleText("dim", line));
 		});
 		context.hook("kubb:hook:end", ({ id, command, name, args, success, error, stdout, stderr }) => {
 			if (!id) return;
-			if (logLevel$5 <= logLevel.silent) {
+			if (logLevel$3 <= logLevel.silent) {
 				if (!success) {
 					if (stdout) console.log(stdout);
 					if (stderr) console.error(stderr);
@@ -462,19 +571,19 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 const plainLogger = {
 	name: "plain",
 	install(context, options) {
-		const logLevel$4 = options?.logLevel ?? logLevel.info;
+		const logLevel$2 = options?.logLevel ?? logLevel.info;
 		const hookTimer = createHookTimer();
 		function getMessage(message) {
-			return formatMessage(message, logLevel$4);
+			return formatMessage(message, logLevel$2);
 		}
 		function onStep(hook, message) {
 			context.hook(hook, () => {
-				if (logLevel$4 <= logLevel.silent) return;
+				if (logLevel$2 <= logLevel.silent) return;
 				console.log(getMessage(message));
 			});
 		}
 		context.hook("kubb:info", ({ message, info }) => {
-			if (logLevel$4 <= logLevel.silent) return;
+			if (logLevel$2 <= logLevel.silent) return;
 			const text = getMessage([
 				"ℹ",
 				message,
@@ -483,27 +592,27 @@ const plainLogger = {
 			console.log(text);
 		});
 		context.hook("kubb:success", ({ message, info = "" }) => {
-			if (logLevel$4 <= logLevel.silent) return;
+			if (logLevel$2 <= logLevel.silent) return;
 			const text = getMessage([
 				"✓",
 				message,
-				logLevel$4 >= logLevel.info ? info : void 0
+				logLevel$2 >= logLevel.info ? info : void 0
 			].filter(Boolean).join(" "));
 			console.log(text);
 		});
 		context.hook("kubb:warn", ({ message, info }) => {
-			if (logLevel$4 < logLevel.warn) return;
+			if (logLevel$2 < logLevel.warn) return;
 			const text = getMessage([
 				"⚠",
 				message,
-				logLevel$4 >= logLevel.info ? info : void 0
+				logLevel$2 >= logLevel.info ? info : void 0
 			].filter(Boolean).join(" "));
 			console.log(text);
 		});
 		context.hook("kubb:error", ({ error }) => {
 			const text = getMessage(["✗", error.message].join(" "));
 			console.log(text);
-			const frames = logLevel$4 >= logLevel.verbose ? formatErrorFrames(error) : null;
+			const frames = logLevel$2 >= logLevel.verbose ? formatErrorFrames(error) : null;
 			if (frames) {
 				for (const frame of frames.frames) console.log(getMessage(frame));
 				if (frames.cause) {
@@ -513,9 +622,36 @@ const plainLogger = {
 			}
 		});
 		context.hook("kubb:diagnostic", ({ diagnostic }) => {
-			if (logLevel$4 <= logLevel.silent && diagnostic.severity !== "error") return;
+			if (logLevel$2 <= logLevel.silent && diagnostic.severity !== "error") return;
 			console.log(getMessage(Diagnostics.formatLines(diagnostic).join("\n")));
 		});
+		context.hook("studio:connecting", ({ url }) => {
+			if (logLevel$2 <= logLevel.silent) return;
+			console.log(getMessage(`Connecting to ${url}`));
+		});
+		context.hook("studio:connected", ({ url, versions }) => {
+			if (logLevel$2 <= logLevel.silent) return;
+			console.log(getMessage(`✓ Connected to ${url} (${formatVersions(versions)})`));
+		});
+		context.hook("studio:disconnected", ({ reason }) => {
+			if (logLevel$2 < logLevel.warn) return;
+			console.log(getMessage(`⚠ Kubb Studio ended the session (${reason})`));
+		});
+		context.hook("studio:command:start", ({ command }) => {
+			if (logLevel$2 <= logLevel.silent) return;
+			console.log(getMessage(`Kubb Studio asked to ${command}`));
+		});
+		context.hook("studio:command:end", ({ command, info }) => {
+			if (logLevel$2 <= logLevel.silent) return;
+			console.log(getMessage(`✓ Finished ${command}${info ? ` (${info})` : ""}`));
+		});
+		context.hook("studio:warn", ({ message }) => {
+			if (logLevel$2 < logLevel.warn) return;
+			console.log(getMessage(`⚠ ${message}`));
+		});
+		context.hook("studio:error", ({ error }) => {
+			console.log(getMessage(`✗ ${error.message}`));
+		});
 		context.hook("kubb:lifecycle:start", ({ version }) => {
 			console.log(`Kubb CLI v${version}`);
 		});
@@ -524,27 +660,27 @@ const plainLogger = {
 			console.log(text);
 		});
 		context.hook("kubb:plugin:start", ({ plugin }) => {
-			if (logLevel$4 <= logLevel.silent) return;
+			if (logLevel$2 <= logLevel.silent) return;
 			const text = getMessage(`Generating ${plugin.name}`);
 			console.log(text);
 		});
 		context.hook("kubb:plugin:end", ({ plugin, duration, success }) => {
-			if (logLevel$4 <= logLevel.silent) return;
+			if (logLevel$2 <= 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.hook("kubb:files:processing:start", ({ files }) => {
-			if (logLevel$4 <= logLevel.silent) return;
+			if (logLevel$2 <= logLevel.silent) return;
 			const text = getMessage(`Writing ${files.length} files`);
 			console.log(text);
 		});
 		context.hook("kubb:files:processing:update", ({ files }) => {
-			if (logLevel$4 <= logLevel.silent) return;
+			if (logLevel$2 <= logLevel.silent) return;
 			for (const { file, config } of files) console.log(getMessage(`Writing ${relative(config.root, file.path)}`));
 		});
 		context.hook("kubb:files:processing:end", () => {
-			if (logLevel$4 <= logLevel.silent) return;
+			if (logLevel$2 <= logLevel.silent) return;
 			const text = getMessage("Files written successfully");
 			console.log(text);
 		});
@@ -559,13 +695,13 @@ const plainLogger = {
 		onStep("kubb:hooks:start", "Hooks started");
 		onStep("kubb:hooks:end", "Hooks completed");
 		context.hook("kubb:hook:start", ({ id, command, name, args }) => {
-			if (logLevel$4 <= logLevel.silent) return;
+			if (logLevel$2 <= logLevel.silent) return;
 			if (id) hookTimer.start(id);
 			const commandWithArgs = formatCommandWithArgs(command, args);
 			console.log(getMessage(`Hook ${name ?? commandWithArgs} started`));
 		});
 		context.hook("kubb:hook:end", ({ id, command, name, args, success, error, stdout, stderr }) => {
-			if (logLevel$4 <= logLevel.silent) return;
+			if (logLevel$2 <= logLevel.silent) return;
 			const ms = id ? hookTimer.end(id) : void 0;
 			const durationStr = ms !== void 0 ? ` in ${formatMs(ms)}` : "";
 			const commandWithArgs = formatCommandWithArgs(command, args);
@@ -594,8 +730,8 @@ function getInputPath(config) {
 * Optionally prefix a message with a [HH:MM:SS] timestamp when logLevel >= verbose.
 * Shared across all logger adapters to avoid duplication.
 */
-function formatMessage(message, logLevel$3) {
-	if (logLevel$3 >= logLevel.verbose) {
+function formatMessage(message, logLevel$1) {
+	if (logLevel$1 >= logLevel.verbose) {
 		const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
 			hour12: false,
 			hour: "2-digit",
@@ -607,6 +743,23 @@ function formatMessage(message, logLevel$3) {
 	return message;
 }
 /**
+* Renders the versions from a `studio:connected` event as one parenthetical. The runtime is listed
+* only when it differs from the host, and Studio's only when it sent one.
+*/
+function formatVersions({ studio, kubb, agent }) {
+	return [
+		`v${agent}`,
+		kubb !== agent ? `runtime v${kubb}` : void 0,
+		studio ? `Studio v${studio}` : void 0
+	].filter(Boolean).join(", ");
+}
+/**
+* Extracts the `.cause` of an `Error` as an `Error`, or `undefined` when absent or not an `Error`.
+*/
+function toCause(error) {
+	return error.cause instanceof Error ? error.cause : void 0;
+}
+/**
 * First stack frames for verbose error output, including an optional `cause` chain.
 */
 function formatErrorFrames(error) {
@@ -857,18 +1010,6 @@ function isNewerVersion(current, latest) {
 	return isGreater(truncate(latest, "patch"), truncate(current, "patch"));
 }
 /**
-* Tokenizes a shell command string, respecting single and double quotes.
-*
-* @example
-* ```ts
-* tokenize('git commit -m "initial commit"')
-* // → ['git', 'commit', '-m', 'initial commit']
-* ```
-*/
-function tokenize(command) {
-	return (command.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g) ?? []).map((token) => token.replace(/^["']|["']$/g, ""));
-}
-/**
 * Runs the `output.postGenerate` commands of a Kubb config in sequence and returns each command's
 * outcome, so the caller can turn failures into diagnostics.
 */
@@ -949,6 +1090,41 @@ async function runHook({ id, command, name, args, commandWithArgs, hooks }) {
 	}
 }
 /**
+* 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(toError(error));
+			}
+		} while (dirty);
+		running = false;
+	};
+}
+/**
 * Starts a file watcher on the given paths and calls `cb` on any change.
 * 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
@@ -985,272 +1161,6 @@ async function startWatcher(path, cb, log = {
 	});
 }
 //#endregion
-//#region src/runners/generate/run.ts
-/**
-* 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.
-*/
-async function runToolPass({ toolValue, tool, outputPath, logLevel: logLevel$1, hooks, onStart, onEnd }) {
-	await onStart();
-	let resolvedTool = toolValue;
-	if (resolvedTool === "auto") {
-		const detected = await tool.detect();
-		if (!detected) await hooks.callHook("kubb:warn", { message: tool.noToolMessage });
-		else {
-			resolvedTool = detected;
-			await hooks.callHook("kubb:info", { message: `Auto-detected ${tool.label}: ${styleText("dim", resolvedTool)}` });
-		}
-	}
-	let toolError = null;
-	if (resolvedTool && resolvedTool !== "auto" && resolvedTool in tool.map && existsSync(outputPath)) {
-		const toolConfig = tool.map[resolvedTool];
-		const successMessage = [
-			`${tool.successPrefix} with ${styleText("dim", resolvedTool)}`,
-			logLevel$1 >= logLevel.info ? `on ${styleText("dim", outputPath)}` : void 0,
-			"successfully"
-		].filter(Boolean).join(" ");
-		try {
-			const hookId = randomUUID();
-			const hookArgs = toolConfig.args(outputPath);
-			const commandWithArgs = [toolConfig.command, ...hookArgs].join(" ");
-			await hooks.callHook("kubb:hook:start", {
-				id: hookId,
-				command: toolConfig.command,
-				args: hookArgs
-			});
-			const result = await runHook({
-				id: hookId,
-				command: toolConfig.command,
-				args: hookArgs,
-				commandWithArgs,
-				hooks
-			});
-			if (result.success) await hooks.callHook("kubb:success", { message: successMessage });
-			else toolError = result.error ?? new Error(toolConfig.errorMessage);
-		} catch (caughtError) {
-			toolError = toError(caughtError);
-		}
-	}
-	await onEnd();
-	return toolError;
-}
-async function generate(options) {
-	const { input, hooks, logLevel, dryRun = false } = options;
-	const hrStart = process$1.hrtime();
-	const inputPath = input ?? (typeof options.config.input === "string" ? options.config.input : void 0);
-	const config = {
-		...options.config,
-		input: input ?? options.config.input,
-		storage: dryRun ? memoryStorage() : options.config.storage
-	};
-	const processOutput = async ({ config: resolvedConfig, outputPath }) => {
-		if (dryRun) return [];
-		const outputDiagnostics = [];
-		const reportOutputFailure = async (code, label, error) => {
-			const diagnostic = outputDiagnostic(code, label, error);
-			outputDiagnostics.push(diagnostic);
-			await Diagnostics.emit(hooks, diagnostic);
-		};
-		const toolPasses = [{
-			value: resolvedConfig.output.format,
-			code: Diagnostics.code.formatFailed,
-			tool: {
-				label: "formatter",
-				map: formatters,
-				detect: () => detectTool([
-					"oxfmt",
-					"biome",
-					"prettier"
-				]),
-				successPrefix: "Formatting",
-				noToolMessage: "No formatter found (oxfmt, biome, or prettier). Skipping formatting."
-			},
-			onStart: () => hooks.callHook("kubb:format:start"),
-			onEnd: () => hooks.callHook("kubb:format:end")
-		}, {
-			value: resolvedConfig.output.lint,
-			code: Diagnostics.code.lintFailed,
-			tool: {
-				label: "linter",
-				map: linters,
-				detect: () => detectTool([
-					"oxlint",
-					"biome",
-					"eslint"
-				]),
-				successPrefix: "Linting",
-				noToolMessage: "No linter found (oxlint, biome, or eslint). Skipping linting."
-			},
-			onStart: () => hooks.callHook("kubb:lint:start"),
-			onEnd: () => hooks.callHook("kubb:lint:end")
-		}];
-		for (const pass of toolPasses) {
-			if (!pass.value) continue;
-			const error = await runToolPass({
-				toolValue: pass.value,
-				tool: pass.tool,
-				onStart: pass.onStart,
-				onEnd: pass.onEnd,
-				outputPath,
-				logLevel,
-				hooks
-			});
-			if (error) await reportOutputFailure(pass.code, pass.tool.label, error);
-		}
-		if (resolvedConfig.output.postGenerate?.length) {
-			await hooks.callHook("kubb:hooks:start");
-			const hookResults = await runPostGenerate({
-				commands: resolvedConfig.output.postGenerate,
-				hooks
-			});
-			for (const hookResult of hookResults) {
-				if (hookResult.success) continue;
-				await reportOutputFailure(Diagnostics.code.postGenerateFailed, "Post-generate command", hookResult.error ?? /* @__PURE__ */ new Error("Post-generate command failed"));
-			}
-			await hooks.callHook("kubb:hooks:end");
-		}
-		return outputDiagnostics;
-	};
-	hooks.hook("kubb:generation:end", ({ status }) => {
-		if (status === "success") return hooks.callHook("kubb:success", {
-			message: "Generation succeeded",
-			info: inputPath
-		});
-	});
-	const kubb = createKubb(config, { hooks });
-	const result = await kubb.generate({ processOutput });
-	if (dryRun) await hooks.callHook("kubb:info", {
-		message: "Dry run: no files were written",
-		info: `${result.files.length} file(s) would be generated`
-	});
-	const telemetryPlugins = Array.from(kubb.driver.plugins.values(), (p) => ({
-		name: p.name,
-		options: p.options
-	}));
-	await sendTelemetry(buildTelemetryEvent({
-		command: "generate",
-		kubbVersion: version,
-		plugins: telemetryPlugins,
-		hrStart,
-		filesCreated: result.files.length,
-		status: result.success ? "success" : "failed"
-	}));
-	return result.success;
-}
-/**
-* Builds a coded diagnostic for an output-phase failure (formatter, linter, or `done` hook).
-*/
-function outputDiagnostic(code, label, caughtError) {
-	const error = toError(caughtError);
-	return {
-		code,
-		severity: "error",
-		message: `${label} failed: ${error.message}`,
-		help: "Check that the tool is installed and that the command and its config are correct.",
-		location: { kind: "config" },
-		cause: error
-	};
-}
-async function checkForUpdate(hooks) {
-	try {
-		const data = await (await fetch(KUBB_NPM_PACKAGE_URL, { signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS) })).json();
-		if (data.version && isNewerVersion(version, data.version)) await Diagnostics.emit(hooks, Diagnostics.update({
-			currentVersion: version,
-			latestVersion: data.version
-		}));
-	} catch {}
-}
-/**
-* Runs the full Kubb generation lifecycle for the given CLI options.
-* Loads configs, sets up the reporters (CLI `--reporter` picks which of `config.reporters` to trigger),
-* checks for a newer version, and calls `generate` for each config entry.
-*/
-async function run({ input, configPath, logLevel: logLevelKey, watch, reporters: cliReporters, dryRun }) {
-	const logLevel$2 = logLevel[logLevelKey] ?? logLevel.info;
-	const hooks = new Hookable();
-	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.callHook("kubb:error", { error: toError(error) });
-		process$1.exit(1);
-	}
-	const requestedNames = cliReporters?.length ? cliReporters : ["cli"];
-	await setupReporters(hooks, {
-		logLevel: logLevel$2,
-		reporters: selectReporters(configs[0]?.reporters ?? [], requestedNames)
-	});
-	await hooks.callHook("kubb:lifecycle:start", { version });
-	await checkForUpdate(hooks);
-	try {
-		const relativeConfigPath = path.relative(process$1.cwd(), resolvedConfigPath);
-		await hooks.callHook("kubb:info", {
-			message: "Config loaded",
-			info: relativeConfigPath
-		});
-		await hooks.callHook("kubb:success", {
-			message: "Config loaded successfully",
-			info: relativeConfigPath
-		});
-		let anyFailed = false;
-		for (const config of configs) {
-			const effectiveInput = input ?? config.input;
-			const watchPath = typeof effectiveInput === "string" && getInputKind(effectiveInput) === "file" ? effectiveInput : void 0;
-			if (watchPath && watch) {
-				const watchedPaths = [watchPath];
-				const build = async (paths) => {
-					await generate({
-						input,
-						config,
-						logLevel: logLevel$2,
-						hooks,
-						dryRun
-					});
-					clack.log.step(styleText("yellow", `Watching for changes in ${paths.join(" and ")}`));
-				};
-				try {
-					await build(watchedPaths);
-				} catch (buildError) {
-					await hooks.callHook("kubb:error", { error: toError(buildError) });
-				}
-				await startWatcher(watchedPaths, build, {
-					info: (msg) => clack.log.info(msg),
-					error: (msg) => clack.log.error(msg)
-				});
-			} else try {
-				if (!await generate({
-					input,
-					config,
-					logLevel: logLevel$2,
-					hooks,
-					dryRun
-				})) anyFailed = true;
-			} catch (configError) {
-				await hooks.callHook("kubb:error", { error: toError(configError) });
-				anyFailed = true;
-			}
-		}
-		await hooks.callHook("kubb:lifecycle:end");
-		if (anyFailed) process$1.exit(1);
-	} catch (error) {
-		await hooks.callHook("kubb:error", { error: toError(error) });
-		process$1.exit(1);
-	}
-}
-//#endregion
-export { run };
+export { startWatcher as a, FORMATTER_PREFERENCE as c, formatters as d, linters as f, runPostGenerate as i, LINTER_PREFERENCE as l, isNewerVersion as n, selectReporters as o, runHook as r, setupReporters as s, getConfigs as t, detectTool as u };
 
-//# sourceMappingURL=run-CLGgnrjg.js.map
+//# sourceMappingURL=utils-CzoNURwq.js.map