@kubb/cli 5.1.0 → 5.2.0

package/dist/{run-DAGbErY0.cjs → utils-B0SrWoNh.cjs}

@@ -1,22 +1,127 @@
 const require_rolldown_runtime = require("./rolldown-runtime-qbf5tadS.cjs");
-const require_Telemetry = require("./Telemetry-D-Jpt27O.cjs");
-const require_errors = require("./errors-CZtH2dKk.cjs");
-const require_package = require("./package-CnUMuss9.cjs");
-const require_tools = require("./tools-bwKAf_r-.cjs");
+const require_errors = require("./errors-C-wEou02.cjs");
+const require_Telemetry = require("./Telemetry-DKfJQxnC.cjs");
+const require_env = require("./env-DHaFBZTX.cjs");
 let node_util = require("node:util");
 let node_crypto = require("node:crypto");
 let node_process = require("node:process");
 node_process = require_rolldown_runtime.__toESM(node_process, 1);
 let node_path = require("node:path");
-node_path = require_rolldown_runtime.__toESM(node_path, 1);
-let node_fs = require("node:fs");
+let node_child_process = require("node:child_process");
+let _kubb_core = require("@kubb/core");
 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");
 let verkit = require("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 = (0, node_child_process.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.
@@ -50,7 +155,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.
@@ -161,43 +266,6 @@ 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/clackLogger.ts
 /**
 * TTY logger for local development, with spinners and progress bars.
@@ -325,6 +393,46 @@ Run \`npm install -g @kubb/cli\` to update`, "Update available for `Kubb`", {
 				secondarySymbol: ""
 			});
 		});
+		context.hook("studio:connecting", ({ url }) => {
+			if (logLevel <= _kubb_core.logLevel.silent) return;
+			state.spinner = _clack_prompts.spinner();
+			state.spinner.start(getMessage(`Connecting to ${(0, node_util.styleText)("cyan", url)}`));
+			state.isSpinning = true;
+		});
+		context.hook("studio:connected", ({ url, versions }) => {
+			if (logLevel <= _kubb_core.logLevel.silent) return;
+			const text = getMessage(`Connected to ${(0, node_util.styleText)("cyan", url)} ${(0, node_util.styleText)("dim", `(${formatVersions(versions)})`)}`);
+			if (state.isSpinning) {
+				stopSpinner(text);
+				return;
+			}
+			_clack_prompts.log.success(text);
+		});
+		context.hook("studio:disconnected", ({ reason }) => {
+			if (logLevel < _kubb_core.logLevel.warn) return;
+			stopSpinner();
+			_clack_prompts.log.warn(getMessage(`Kubb Studio ended the session (${reason})`));
+		});
+		context.hook("studio:command:start", ({ command }) => {
+			if (logLevel <= _kubb_core.logLevel.silent) return;
+			_clack_prompts.log.info(getMessage(`Kubb Studio asked to ${(0, node_util.styleText)("bold", command)}`));
+		});
+		context.hook("studio:command:end", ({ command, info }) => {
+			if (logLevel <= _kubb_core.logLevel.silent) return;
+			_clack_prompts.log.success(getMessage(`Finished ${command}${info ? ` ${(0, node_util.styleText)("dim", `(${info})`)}` : ""}`));
+		});
+		context.hook("studio:warn", ({ message }) => {
+			if (logLevel < _kubb_core.logLevel.warn) return;
+			_clack_prompts.log.warn(getMessage(message));
+		});
+		context.hook("studio:error", ({ error }) => {
+			const text = getMessage([(0, node_util.styleText)("red", "✗"), error.message].join(" "));
+			if (state.isSpinning) {
+				stopSpinner(text);
+				return;
+			}
+			_clack_prompts.log.error(text);
+		});
 		context.hook("kubb:lifecycle:start", async ({ version }) => {
 			console.log(`\n${getIntro({
 				title: "The meta framework for code generation",
@@ -519,6 +627,33 @@ const plainLogger = {
 			if (logLevel <= _kubb_core.logLevel.silent && diagnostic.severity !== "error") return;
 			console.log(getMessage(_kubb_core.Diagnostics.formatLines(diagnostic).join("\n")));
 		});
+		context.hook("studio:connecting", ({ url }) => {
+			if (logLevel <= _kubb_core.logLevel.silent) return;
+			console.log(getMessage(`Connecting to ${url}`));
+		});
+		context.hook("studio:connected", ({ url, versions }) => {
+			if (logLevel <= _kubb_core.logLevel.silent) return;
+			console.log(getMessage(`✓ Connected to ${url} (${formatVersions(versions)})`));
+		});
+		context.hook("studio:disconnected", ({ reason }) => {
+			if (logLevel < _kubb_core.logLevel.warn) return;
+			console.log(getMessage(`⚠ Kubb Studio ended the session (${reason})`));
+		});
+		context.hook("studio:command:start", ({ command }) => {
+			if (logLevel <= _kubb_core.logLevel.silent) return;
+			console.log(getMessage(`Kubb Studio asked to ${command}`));
+		});
+		context.hook("studio:command:end", ({ command, info }) => {
+			if (logLevel <= _kubb_core.logLevel.silent) return;
+			console.log(getMessage(`✓ Finished ${command}${info ? ` (${info})` : ""}`));
+		});
+		context.hook("studio:warn", ({ message }) => {
+			if (logLevel < _kubb_core.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}`);
 		});
@@ -610,12 +745,29 @@ function formatMessage(message, logLevel) {
 	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) {
 	if (!error.stack) return null;
 	const frames = error.stack.split("\n").slice(1, 4).map((frame) => frame.trim());
-	const caused = require_errors.toCause(error);
+	const caused = toCause(error);
 	if (!caused?.stack) return { frames };
 	return {
 		frames,
@@ -731,7 +883,7 @@ async function setupReporters(context, { logLevel, reporters }) {
 	for (const reporter of reporters) {
 		if (reporter.name === "cli") {
 			if (hasJson) continue;
-			await (require_Telemetry.canUseTTY() && !require_Telemetry.getAgentName() ? clackLogger : plainLogger).install(context, { logLevel });
+			await (require_env.canUseTTY() && !require_env.getAgentName() ? clackLogger : plainLogger).install(context, { logLevel });
 		}
 		installReporter(context, reporter, ctx);
 	}
@@ -860,18 +1012,6 @@ function isNewerVersion(current, latest) {
 	return (0, verkit.isGreater)((0, verkit.truncate)(latest, "patch"), (0, verkit.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.
 */
@@ -952,6 +1092,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(require_errors.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
@@ -988,272 +1163,77 @@ 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, 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}: ${(0, node_util.styleText)("dim", resolvedTool)}` });
-		}
+Object.defineProperty(exports, "FORMATTER_PREFERENCE", {
+	enumerable: true,
+	get: function() {
+		return FORMATTER_PREFERENCE;
 	}
-	let toolError = null;
-	if (resolvedTool && resolvedTool !== "auto" && resolvedTool in tool.map && (0, node_fs.existsSync)(outputPath)) {
-		const toolConfig = tool.map[resolvedTool];
-		const successMessage = [
-			`${tool.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 = (0, node_crypto.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 = require_errors.toError(caughtError);
-		}
+});
+Object.defineProperty(exports, "LINTER_PREFERENCE", {
+	enumerable: true,
+	get: function() {
+		return LINTER_PREFERENCE;
 	}
-	await onEnd();
-	return toolError;
-}
-async function generate(options) {
-	const { input, hooks, logLevel, dryRun = false } = options;
-	const hrStart = node_process.default.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 ? (0, _kubb_core.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 _kubb_core.Diagnostics.emit(hooks, diagnostic);
-		};
-		const toolPasses = [{
-			value: resolvedConfig.output.format,
-			code: _kubb_core.Diagnostics.code.formatFailed,
-			tool: {
-				label: "formatter",
-				map: require_tools.formatters,
-				detect: () => require_tools.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: _kubb_core.Diagnostics.code.lintFailed,
-			tool: {
-				label: "linter",
-				map: require_tools.linters,
-				detect: () => require_tools.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(_kubb_core.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 = (0, _kubb_core.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 require_Telemetry.sendTelemetry(require_Telemetry.buildTelemetryEvent({
-		command: "generate",
-		kubbVersion: require_package.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 = require_errors.toError(caughtError);
-	return {
-		code,
-		severity: "error",
-		message: `${label} failed: ${error.message}`,
-		help: "Check that the tool is installed and that the command and its config are correct.",
-		location: { kind: "config" },
-		cause: error
-	};
-}
-async function checkForUpdate(hooks) {
-	try {
-		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
-		}));
-	} 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 = _kubb_core.logLevel[logLevelKey] ?? _kubb_core.logLevel.info;
-	const hooks = new _kubb_core.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,
-			reporters: [_kubb_core.cliReporter]
-		});
-		await hooks.callHook("kubb:error", { error: require_errors.toError(error) });
-		node_process.default.exit(1);
+});
+Object.defineProperty(exports, "detectTool", {
+	enumerable: true,
+	get: function() {
+		return detectTool;
 	}
-	const requestedNames = cliReporters?.length ? cliReporters : ["cli"];
-	await setupReporters(hooks, {
-		logLevel,
-		reporters: selectReporters(configs[0]?.reporters ?? [], requestedNames)
-	});
-	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.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" && (0, _kubb_core.getInputKind)(effectiveInput) === "file" ? effectiveInput : void 0;
-			if (watchPath && watch) {
-				const watchedPaths = [watchPath];
-				const build = async (paths) => {
-					await generate({
-						input,
-						config,
-						logLevel,
-						hooks,
-						dryRun
-					});
-					_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)
-				});
-			} else try {
-				if (!await generate({
-					input,
-					config,
-					logLevel,
-					hooks,
-					dryRun
-				})) anyFailed = true;
-			} catch (configError) {
-				await hooks.callHook("kubb:error", { error: require_errors.toError(configError) });
-				anyFailed = true;
-			}
-		}
-		await hooks.callHook("kubb:lifecycle:end");
-		if (anyFailed) node_process.default.exit(1);
-	} catch (error) {
-		await hooks.callHook("kubb:error", { error: require_errors.toError(error) });
-		node_process.default.exit(1);
+});
+Object.defineProperty(exports, "formatters", {
+	enumerable: true,
+	get: function() {
+		return formatters;
 	}
-}
-//#endregion
-exports.run = run;
+});
+Object.defineProperty(exports, "getConfigs", {
+	enumerable: true,
+	get: function() {
+		return getConfigs;
+	}
+});
+Object.defineProperty(exports, "isNewerVersion", {
+	enumerable: true,
+	get: function() {
+		return isNewerVersion;
+	}
+});
+Object.defineProperty(exports, "linters", {
+	enumerable: true,
+	get: function() {
+		return linters;
+	}
+});
+Object.defineProperty(exports, "runHook", {
+	enumerable: true,
+	get: function() {
+		return runHook;
+	}
+});
+Object.defineProperty(exports, "runPostGenerate", {
+	enumerable: true,
+	get: function() {
+		return runPostGenerate;
+	}
+});
+Object.defineProperty(exports, "selectReporters", {
+	enumerable: true,
+	get: function() {
+		return selectReporters;
+	}
+});
+Object.defineProperty(exports, "setupReporters", {
+	enumerable: true,
+	get: function() {
+		return setupReporters;
+	}
+});
+Object.defineProperty(exports, "startWatcher", {
+	enumerable: true,
+	get: function() {
+		return startWatcher;
+	}
+});
 
-//# sourceMappingURL=run-DAGbErY0.cjs.map
+//# sourceMappingURL=utils-B0SrWoNh.cjs.map