@kubb/cli 5.10.1 → 5.10.3

package/dist/output-C5g7AtWH.cjs

@@ -0,0 +1,1008 @@
+const require_rolldown_runtime = require("./rolldown-runtime-C0BPl7ul.cjs");
+const require_Telemetry = require("./Telemetry-CH2kkxWK.cjs");
+let node_util = require("node:util");
+let node_process = require("node:process");
+node_process = require_rolldown_runtime.__toESM(node_process, 1);
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let gunshi_agent = require("gunshi/agent");
+let _kubb_core = require("@kubb/core");
+let _clack_prompts = require("@clack/prompts");
+_clack_prompts = require_rolldown_runtime.__toESM(_clack_prompts, 1);
+let node_fs = require("node:fs");
+let jiti = require("jiti");
+//#region ../../internals/shared/src/constants.ts
+const KUBB_CONFIG_FILENAME = "kubb.config.ts";
+/** File extensions a Kubb config file may use. */
+const CONFIG_EXTENSIONS = [
+	".ts",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs"
+];
+const KUBB_PACKAGE_NAME = "kubb";
+const initDefaults = {
+	inputPath: "./openapi.yaml",
+	outputPath: "./src/gen",
+	plugins: ["plugin-ts"]
+};
+//#endregion
+//#region ../../internals/shared/src/loader.ts
+/**
+* jiti options for loading Kubb config modules: the automatic JSX runtime pointed at
+* `@kubb/renderer-jsx`, and `moduleCache` off so a re-load re-evaluates the file.
+*/
+const JITI_OPTIONS = {
+	jsx: {
+		runtime: "automatic",
+		importSource: "@kubb/renderer-jsx"
+	},
+	moduleCache: false
+};
+/**
+* Plain JavaScript files. jiti hands these to Node's native `import()`, whose module cache never
+* lets go of a file, so `moduleCache: false` alone would keep returning the first version of it.
+*/
+const JAVASCRIPT_EXTENSION = /\.[cm]?jsx?$/;
+const jiti$1 = (0, jiti.createJiti)(require("url").pathToFileURL(__filename).href, JITI_OPTIONS);
+/**
+* Loads a Kubb TypeScript or JavaScript config module via jiti.
+*
+* jiti transpiles TypeScript and the `@kubb/renderer-jsx` JSX runtime on the fly. Every load
+* re-evaluates the file, so a config edited on disk is picked up by the next load.
+*
+* @example
+* ```ts
+* const config = await loadModule('/abs/kubb.config.ts', { default: true })
+* ```
+*/
+async function loadModule(filePath, options) {
+	if (!JAVASCRIPT_EXTENSION.test(filePath)) return options?.default ? jiti$1.import(filePath, { default: true }) : jiti$1.import(filePath);
+	const mod = await jiti$1.evalModule(await (0, node_fs_promises.readFile)(filePath, "utf8"), {
+		filename: filePath,
+		async: true,
+		forceTranspile: true
+	});
+	return options?.default ? mod?.default ?? mod : mod;
+}
+//#endregion
+//#region ../../internals/shared/src/config.ts
+const SEARCH_FILES = [
+	"",
+	".config/",
+	"configs/"
+].flatMap((prefix) => [`${prefix}.kubbrc`, `${prefix}kubb.config`]);
+/**
+* The first Kubb config file in `cwd` or the nearest parent folder that has one: `.kubbrc` before
+* `kubb.config`, the folder itself before its `.config/` and `configs/`, and {@link CONFIG_EXTENSIONS} in order.
+*/
+function findConfigFile(cwd = node_process.default.cwd()) {
+	for (let dir = (0, node_path.resolve)(cwd);; dir = (0, node_path.dirname)(dir)) {
+		const found = SEARCH_FILES.flatMap((file) => CONFIG_EXTENSIONS.map((extension) => (0, node_path.join)(dir, `${file}${extension}`))).find((file) => (0, node_fs.existsSync)(file));
+		if (found || (0, node_path.dirname)(dir) === dir) return found;
+	}
+}
+/**
+* Loads a Kubb config module, calls it with `cli` when it exports a function, and returns its
+* configs as a list, so a single config and a `defineConfig([...])` array read the same.
+*/
+async function loadConfigFile(file, cli) {
+	const loaded = await loadModule(file, { default: true });
+	const resolved = await (typeof loaded === "function" ? loaded(cli) : loaded);
+	return Array.isArray(resolved) ? resolved : [resolved];
+}
+//#endregion
+//#region src/utils/env.ts
+/**
+* Returns `true` when the process has an interactive TTY with a valid terminal
+* width and is not running in CI.
+*
+* Some IDE-embedded terminals report `isTTY = true` but set `columns` to `0`,
+* which breaks clack's box-drawing helpers (they call `String.prototype.repeat`
+* with a negative count and throw a `RangeError`). A positive column count is
+* required before the TTY counts as usable.
+*
+* @example
+* ```ts
+* if (canUseTTY()) {
+*   renderProgressBar()
+* }
+* ```
+*/
+function canUseTTY() {
+	return process.stdout.isTTY && (process.stdout.columns ?? 0) > 0 && !require_Telemetry.isCIEnvironment();
+}
+/**
+* Returns `true` when output can carry spinners and clack's gutter: an interactive TTY that no AI
+* coding agent is reading. Cursor-movement escapes are hard for an agent to parse even over a
+* pseudo-TTY, so it gets the plain writer.
+*/
+function isRichOutput() {
+	return canUseTTY() && !(0, gunshi_agent.getAgentProfile)().isAgent;
+}
+//#endregion
+//#region src/loggers/banner.ts
+/**
+* Colors for each part of the Kubb mascot illustration.
+*/
+const palette = {
+	/**
+	* Top cap of the skittle.
+	*/
+	lid: (text) => (0, node_util.styleText)("red", text),
+	/**
+	* Wood body.
+	*/
+	wood: (text) => (0, node_util.styleText)("yellow", text),
+	/**
+	* Base wood body.
+	*/
+	woodBase: (text) => (0, node_util.styleText)(["dim", "yellow"], text),
+	/**
+	* Eye whites.
+	*/
+	eye: (text) => (0, node_util.styleText)("white", text),
+	/**
+	* Highlight accent.
+	*/
+	highlight: (text) => (0, node_util.styleText)("gray", text),
+	/**
+	* Cheek blush.
+	*/
+	blush: (text) => (0, node_util.styleText)("magenta", text)
+};
+/**
+* Generates the Kubb mascot welcome banner as an ANSI-colored string.
+*
+* @example
+* ```ts
+* console.log(getIntro({ title: 'kubb.config.ts', description: 'generating…', version: '5.0.0', areEyesOpen: true }))
+* ```
+*/
+function getIntro({ title, description, version, areEyesOpen }) {
+	const kubbVersion = (0, node_util.styleText)(["bold", "yellow"], `KUBB v${version}`);
+	const eyeTop = areEyesOpen ? palette.eye("█▀█") : palette.eye("───");
+	const eyeBottom = areEyesOpen ? palette.eye("▀▀▀") : palette.eye("───");
+	return [
+		`   ${palette.lid("▄▄▄▄▄▄▄▄▄▄▄▄▄")}`,
+		`  ${palette.wood("█  ")}${palette.highlight("▄▄")}${palette.wood("     ")}${palette.highlight("▄▄")}${palette.wood("  █")} ${kubbVersion}`,
+		`  ${palette.wood("█ ")}${eyeTop}${palette.wood("     ")}${eyeTop}${palette.wood(" █")} ${(0, node_util.styleText)("gray", title)}`,
+		`  ${palette.wood("█ ")}${eyeBottom}${palette.wood("  ")}${palette.blush("◡")}${palette.wood("  ")}${eyeBottom}${palette.wood(" █")} ${(0, node_util.styleText)("yellow", "➜")} ${(0, node_util.styleText)("white", description)}`,
+		`   ${palette.woodBase("▀▀▀▀▀▀▀▀▀▀▀▀▀")}`
+	].join("\n");
+}
+/**
+* Formats a millisecond duration with a threshold-based ANSI color.
+* `≤ 500 ms` → green · `≤ 1 000 ms` → yellow · `> 1 000 ms` → red.
+*
+* @example
+* ```ts
+* formatMsWithColor(200)  // '\x1b[32m200ms\x1b[39m'
+* formatMsWithColor(800)  // '\x1b[33m800ms\x1b[39m'
+* formatMsWithColor(1500) // '\x1b[31m1.50s\x1b[39m'
+* ```
+*/
+function formatMsWithColor(ms) {
+	const formatted = require_Telemetry.formatMs(ms);
+	if (ms <= 500) return (0, node_util.styleText)("green", formatted);
+	if (ms <= 1e3) return (0, node_util.styleText)("yellow", formatted);
+	return (0, node_util.styleText)("red", formatted);
+}
+//#endregion
+//#region src/loggers/createLogger.ts
+/** Display path for a config's input: the string form, or its `path` field when the input is an object. */
+function getInputPath(config) {
+	const { input } = config;
+	if (typeof input === "string") return input;
+	return typeof input?.path === "string" ? input.path : void 0;
+}
+/** Counts a noun, so a message never reads `1 files`. */
+function pluralize(count, noun) {
+	return `${count} ${count === 1 ? noun : `${noun}s`}`;
+}
+/** Prefixes a `[HH:MM:SS]` timestamp at verbose and above. */
+function formatMessage(message, logLevel) {
+	if (logLevel >= _kubb_core.logLevel.verbose) {
+		const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+			hour12: false,
+			hour: "2-digit",
+			minute: "2-digit",
+			second: "2-digit"
+		});
+		return `${(0, node_util.styleText)("dim", `[${timestamp}]`)} ${message}`;
+	}
+	return message;
+}
+/**
+* Renders a `studio:connected` event's versions: the runtime only when it differs from the host.
+*/
+function formatVersions({ studio, kubb, agent }) {
+	return [
+		`v${agent}`,
+		kubb !== agent ? `runtime v${kubb}` : void 0,
+		`Studio v${studio}`
+	].filter(Boolean).join(", ");
+}
+/** The progress summary line the clack logger shows, `null` when there is nothing to display. */
+function buildProgressLine(state) {
+	const parts = [];
+	const duration = require_Telemetry.formatMs(require_Telemetry.getElapsedMs(state.hrStart));
+	if (state.totalPlugins > 0) {
+		const pluginStr = state.failedPlugins > 0 ? `Plugins ${(0, node_util.styleText)("green", state.completedPlugins.toString())}/${state.totalPlugins} ${(0, node_util.styleText)("red", `(${state.failedPlugins} failed)`)}` : `Plugins ${(0, node_util.styleText)("green", state.completedPlugins.toString())}/${state.totalPlugins}`;
+		parts.push(pluginStr);
+	}
+	if (state.totalFiles > 0) parts.push(`Files ${(0, node_util.styleText)("green", state.processedFiles.toString())}/${state.totalFiles}`);
+	if (parts.length === 0) return null;
+	parts.push(`${(0, node_util.styleText)("green", duration)} elapsed`);
+	return parts.join((0, node_util.styleText)("dim", " | "));
+}
+function createProgressCounters() {
+	return {
+		totalPlugins: 0,
+		completedPlugins: 0,
+		failedPlugins: 0,
+		totalFiles: 0,
+		processedFiles: 0,
+		hrStart: node_process.default.hrtime()
+	};
+}
+/**
+* The three output phases, in the order the generate runner runs them.
+*/
+const PHASES = {
+	format: {
+		running: "Formatting",
+		success: "Formatted",
+		failure: "Formatting failed"
+	},
+	lint: {
+		running: "Linting",
+		success: "Linted",
+		failure: "Linting failed"
+	},
+	hooks: {
+		running: "Running post-generate hooks",
+		success: "Post-generate hooks completed",
+		failure: "Post-generate hooks failed",
+		showHookResults: true
+	}
+};
+/**
+* Drops the blank lines a subprocess leaves at either end of its output, so its block does not open
+* or close on an empty row.
+*/
+function trimBlankEdges(lines) {
+	const start = lines.findIndex((line) => line.trim());
+	if (start === -1) return [];
+	return lines.slice(start, lines.findLastIndex((line) => line.trim()) + 1);
+}
+/**
+* Wires a {@link LoggerWriter} onto the run's hooks. This owns what a run says and in what order:
+* one group per config, a step over the plugin work, a progress bar for the writes, one step per
+* output phase, then the summary and the group's closing result. The writer only decides how each
+* line looks, so every logger reports the same run the same way.
+*
+* @example
+* ```ts
+* export const plainLogger = createLogger(writer, { audience: 'agent' })
+* ```
+*/
+function createLogger(writer, { audience }) {
+	return function install(context, { logLevel }) {
+		const silent = logLevel <= _kubb_core.logLevel.silent;
+		const human = audience === "human";
+		const formatOptions = {
+			audience,
+			verbose: logLevel >= _kubb_core.logLevel.verbose,
+			width: Math.min(node_process.default.stdout.columns || 80, 100) - 2
+		};
+		const state = {
+			...createProgressCounters(),
+			spinner: null,
+			progress: null,
+			hooks: /* @__PURE__ */ new Map(),
+			/**
+			* Plugin results held back while the generation step owns the line.
+			*/
+			pluginLines: [],
+			phase: null,
+			groupOpen: false,
+			/**
+			* Whether this run keeps its files in memory, as a `kubb studio` run without `--allow-write` does.
+			*/
+			inMemory: false,
+			/**
+			* Problems held back so the human view can print them grouped by plugin once the build ends.
+			*/
+			problems: [],
+			/**
+			* The finished config's diagnostics and file count, for the closing summary.
+			*/
+			outcome: null
+		};
+		function text(message) {
+			return formatMessage(message, logLevel);
+		}
+		function startSpinner(message) {
+			if (silent) return;
+			state.spinner = writer.spinner();
+			state.spinner.start(text(message));
+		}
+		function stopSpinner(message, status = "success") {
+			const spinner = state.spinner;
+			if (!spinner) return;
+			state.spinner = null;
+			if (message === void 0) {
+				spinner.clear();
+				return;
+			}
+			if (status === "failed") {
+				spinner.error(text(message));
+				return;
+			}
+			spinner.stop(text(message));
+		}
+		function stopProgress(message) {
+			const progress = state.progress;
+			if (!progress) return;
+			state.progress = null;
+			progress.stop(message === void 0 ? "" : text(message));
+		}
+		function startPhase({ running, success, failure, showHookResults = false }) {
+			state.phase = {
+				successLabel: success,
+				failureLabel: failure,
+				showHookResults,
+				failed: false,
+				hrStart: node_process.default.hrtime(),
+				lines: [],
+				output: []
+			};
+			startSpinner(running);
+		}
+		function endPhase() {
+			const phase = state.phase;
+			state.phase = null;
+			if (!phase || silent) return;
+			const duration = formatMsWithColor(require_Telemetry.getElapsedMs(phase.hrStart));
+			stopSpinner(phase.failed ? `${phase.failureLabel} after ${duration}` : `${phase.successLabel} in ${duration}`, phase.failed ? "failed" : "success");
+			if (phase.lines.length) writer.block(phase.lines);
+			writeOutput(phase.output);
+		}
+		function writeOutput(lines) {
+			const output = trimBlankEdges(lines);
+			if (output.length) writer.raw(output);
+		}
+		/** `✖ Failed  1 error · 1 warning  in plugin-ts` once the build ended, or `✗ Generation failed` for a run that stopped early. */
+		function failedTitle() {
+			const diagnostics = state.outcome?.diagnostics ?? [];
+			const counts = formatCounts(diagnostics);
+			if (!human || !counts) return "✗ Generation failed";
+			const plugins = _kubb_core.Diagnostics.failedPlugins(diagnostics);
+			return `✖ Failed  ${counts}${plugins.length ? `  in ${plugins.join(", ")}` : ""}`;
+		}
+		function closeGroup(status) {
+			if (!state.groupOpen) return;
+			state.groupOpen = false;
+			stopSpinner();
+			stopProgress();
+			writer.groupEnd(status === "failed" ? (0, node_util.styleText)("red", failedTitle()) : (0, node_util.styleText)("green", "✓ Generation succeeded"));
+		}
+		function reset() {
+			stopSpinner();
+			stopProgress();
+			Object.assign(state, createProgressCounters());
+			state.hooks.clear();
+			state.pluginLines = [];
+			state.phase = null;
+			state.groupOpen = false;
+			state.problems = [];
+			state.outcome = null;
+		}
+		/**
+		* Prints problems grouped under their plugin's name, each with the code aligned at the right.
+		*/
+		function writeProblems(problems) {
+			if (!problems.length) return;
+			if (!human) {
+				for (const problem of problems) writer.diagnostic(_kubb_core.Diagnostics.format(problem, formatOptions));
+				return;
+			}
+			const lines = [...Map.groupBy(problems, (problem) => problem.plugin ?? "")].flatMap(([plugin, group]) => [...plugin ? [` ${(0, node_util.styleText)("bold", plugin)}`, ""] : [], ...group.flatMap((problem) => [..._kubb_core.Diagnostics.format(problem, formatOptions).map((line) => `  ${line}`), ""])]);
+			writer.diagnostic(lines.slice(0, -1));
+		}
+		/** The run's verdict: `1 error · 1 warning` for a human, `1 error, 1 warning` for an agent. */
+		function formatCounts(diagnostics) {
+			const { errors, warnings } = _kubb_core.Diagnostics.count(diagnostics);
+			return [errors && pluralize(errors, "error"), warnings && pluralize(warnings, "warning")].filter(Boolean).join(human ? " · " : ", ");
+		}
+		function formatLine(symbol, message, info) {
+			return text([
+				symbol,
+				message,
+				info && (0, node_util.styleText)("dim", info)
+			].filter(Boolean).join(" "));
+		}
+		context.hook("kubb:warn", ({ message, info }) => {
+			if (logLevel < _kubb_core.logLevel.warn) return;
+			writer.warn(formatLine((0, node_util.styleText)("yellow", "⚠"), message, logLevel >= _kubb_core.logLevel.info ? info : void 0));
+		});
+		context.hook("kubb:error", ({ error }) => {
+			if (state.phase) state.phase.failed = true;
+			const message = error.name === "Error" || _kubb_core.Diagnostics.isError(error) ? error.message : `${error.name}: ${error.message}`;
+			const help = _kubb_core.Diagnostics.isError(error) ? error.diagnostic.help : void 0;
+			const [headline = "", ...details] = _kubb_core.Diagnostics.format({
+				code: _kubb_core.Diagnostics.code.unknown,
+				severity: "error",
+				message,
+				help,
+				cause: error
+			}, formatOptions);
+			if (!human) {
+				stopSpinner();
+				stopProgress();
+				writer.diagnostic([headline, ...details]);
+				return;
+			}
+			if (state.spinner) stopSpinner(message, "failed");
+			else writer.error(text(message));
+			if (details.length) writer.block(details.map(text));
+		});
+		context.hook("kubb:diagnostic", ({ diagnostic }) => {
+			if (silent && diagnostic.severity !== "error") return;
+			stopSpinner();
+			stopProgress();
+			if (_kubb_core.Diagnostics.isUpdate(diagnostic)) {
+				writer.update([`\`v${diagnostic.currentVersion}\` → \`v${diagnostic.latestVersion}\``, "Run `npm install -g @kubb/cli` to update"], "Update available for `Kubb`");
+				return;
+			}
+			if (human && state.groupOpen) {
+				state.problems.push(diagnostic);
+				return;
+			}
+			writeProblems([diagnostic]);
+		});
+		context.hook("studio:disconnected", ({ code, reason }) => {
+			if (logLevel < _kubb_core.logLevel.warn) return;
+			stopSpinner();
+			if (code === 4002) {
+				writer.warn(text("⚠ Another process connected to Kubb Studio as this agent, so this one stopped"));
+				return;
+			}
+			writer.warn(text(`⚠ Kubb Studio ended the session (${reason || `code ${code}`})`));
+		});
+		context.hook("studio:warn", ({ message, permission }) => {
+			if (logLevel < _kubb_core.logLevel.warn) return;
+			const remedy = permission ? `; pass --${permission.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`)} to allow it` : "";
+			writer.warn(text(`⚠ ${message}${remedy}`));
+		});
+		context.hook("studio:error", ({ error }) => {
+			if (state.spinner) {
+				stopSpinner(error.message, "failed");
+				return;
+			}
+			writer.error(text(error.message));
+		});
+		context.hook("kubb:lifecycle:start", () => {
+			reset();
+		});
+		context.hook("kubb:generation:start", ({ config }) => {
+			closeGroup("failed");
+			reset();
+			state.totalPlugins = config.plugins?.length ?? 0;
+			state.inMemory = config.storage?.name === "memory";
+			if (silent) return;
+			const inputPath = getInputPath(config);
+			writer.group(text([(0, node_util.styleText)("bold", config.name ?? "kubb"), inputPath ? (0, node_util.styleText)("dim", inputPath) : void 0].filter(Boolean).join(" ")));
+			state.groupOpen = true;
+			startSpinner("Generating");
+		});
+		context.hook("kubb:format:start", () => startPhase(PHASES.format));
+		context.hook("kubb:format:end", endPhase);
+		context.hook("kubb:lint:start", () => startPhase(PHASES.lint));
+		context.hook("kubb:lint:end", endPhase);
+		context.hook("kubb:hooks:start", () => startPhase(PHASES.hooks));
+		context.hook("kubb:hooks:end", endPhase);
+		context.hook("kubb:hook:end", (ctx) => {
+			const { id, command, name, args, success, error } = ctx;
+			if (!id) return;
+			if (!success && state.phase) state.phase.failed = true;
+			if (silent) {
+				if (!ctx.success) {
+					if (ctx.stdout) console.log(ctx.stdout);
+					if (ctx.stderr) console.error(ctx.stderr);
+				}
+				return;
+			}
+			const active = state.hooks.get(id);
+			if (!active) return;
+			state.hooks.delete(id);
+			const label = (0, node_util.styleText)("dim", name ?? (args?.length ? `${command} ${args.join(" ")}` : command));
+			const reason = error?.message ? ` (${error.message})` : "";
+			const result = success ? `${(0, node_util.styleText)("green", "✓")} ${label} in ${formatMsWithColor(require_Telemetry.getElapsedMs(active.hrStart))}` : `${(0, node_util.styleText)("red", "✗")} ${label} failed${reason}`;
+			const phase = state.phase;
+			if (phase) {
+				if (phase.showHookResults || !success) phase.lines.push(result);
+				phase.output.push(...active.lines);
+				return;
+			}
+			stopSpinner();
+			writer.step(text(result));
+			writeOutput(active.lines);
+		});
+		context.hook("kubb:generation:end", ({ diagnostics = [], filesCreated = 0, hrStart = node_process.default.hrtime() }) => {
+			stopSpinner();
+			stopProgress();
+			state.outcome = {
+				diagnostics,
+				filesCreated,
+				hrStart
+			};
+			writeProblems(state.problems.splice(0));
+		});
+		context.hook("kubb:lifecycle:end", () => {
+			writeProblems(state.problems.splice(0));
+			closeGroup("failed");
+			reset();
+		});
+		if (!silent) {
+			context.hook("kubb:info", ({ message, info }) => {
+				const line = formatLine((0, node_util.styleText)("blue", "ℹ"), message, info);
+				if (state.phase) {
+					state.phase.lines.push(line);
+					return;
+				}
+				if (state.spinner) {
+					state.spinner.message(line);
+					return;
+				}
+				writer.info(line);
+			});
+			context.hook("kubb:success", ({ message, info }) => {
+				const line = formatLine((0, node_util.styleText)("green", "✓"), message, logLevel >= _kubb_core.logLevel.info ? info : void 0);
+				if (state.spinner) {
+					state.spinner.message(line);
+					return;
+				}
+				writer.success(line);
+			});
+			context.hook("studio:connected", ({ url, versions }) => {
+				stopSpinner();
+				writer.success(text(`✓ Connected to ${(0, node_util.styleText)("cyan", url)} ${(0, node_util.styleText)("dim", `(${formatVersions(versions)})`)}`));
+				startSpinner("✓ Ready to receive jobs");
+			});
+			context.hook("studio:command", ({ command, info }) => {
+				stopSpinner();
+				writer.success(text(`✓ Finished ${command} ${(0, node_util.styleText)("dim", `(${info})`)}`));
+				startSpinner("✓ Ready to receive jobs");
+			});
+			context.hook("studio:reconnecting", ({ delayMs }) => {
+				stopSpinner();
+				writer.info(text((0, node_util.styleText)("dim", `Retrying connection to Kubb Studio in ${require_Telemetry.formatMs(delayMs)}`)));
+			});
+			context.hook("kubb:plugin:start", ({ plugin }) => {
+				state.spinner?.message(text(`Generating ${(0, node_util.styleText)("dim", plugin.name)}`));
+			});
+			context.hook("kubb:plugin:end", ({ plugin, duration, success }) => {
+				if (success) state.completedPlugins++;
+				if (!success) state.failedPlugins++;
+				state.pluginLines.push(text(`${plugin.name} ${success ? "completed" : "failed"} in ${formatMsWithColor(duration)}`));
+			});
+			context.hook("kubb:plugins:end", () => {
+				const failed = state.failedPlugins > 0;
+				stopSpinner(buildProgressLine(state) ?? void 0, failed ? "failed" : "success");
+				if (state.pluginLines.length) {
+					writer.block(state.pluginLines);
+					state.pluginLines = [];
+				}
+			});
+			context.hook("kubb:files:processing:start", ({ files }) => {
+				stopSpinner();
+				state.totalFiles = files.length;
+				state.processedFiles = 0;
+				state.progress = writer.progress(files.length);
+				state.progress.start(text(`${state.inMemory ? "Generating" : "Writing"} ${pluralize(files.length, "file")}`));
+			});
+			context.hook("kubb:files:processing:update", ({ files }) => {
+				for (const { file, config } of files) {
+					state.processedFiles++;
+					state.progress?.advance(`${state.inMemory ? "Generating" : "Writing"} ${(0, node_path.relative)(config.root, file.path)}`);
+				}
+			});
+			context.hook("kubb:files:processing:end", () => {
+				stopProgress(state.inMemory ? `Generated ${pluralize(state.processedFiles, "file")} in memory` : `Wrote ${pluralize(state.processedFiles, "file")}`);
+			});
+			context.hook("kubb:hook:start", ({ id }) => {
+				if (!id) return;
+				state.hooks.set(id, {
+					hrStart: node_process.default.hrtime(),
+					lines: []
+				});
+			});
+			context.hook("kubb:hook:line", ({ id, line }) => {
+				const active = state.hooks.get(id);
+				if (!active) return;
+				if (state.phase) {
+					active.lines.push(line);
+					return;
+				}
+				writer.raw([line]);
+			});
+		}
+		return { renderSummary(lines, { status }) {
+			if (silent || !state.groupOpen) return;
+			if (human) {
+				closeGroup(status);
+				writer.diagnostic([...lines]);
+				return;
+			}
+			stopSpinner();
+			stopProgress();
+			state.groupOpen = false;
+			const { diagnostics = [], filesCreated = 0, hrStart = node_process.default.hrtime() } = state.outcome ?? {};
+			if (status === "failed") {
+				const plugins = _kubb_core.Diagnostics.failedPlugins(diagnostics);
+				writer.diagnostic([`Kubb failed: ${formatCounts(diagnostics) || "an error"}${plugins.length ? ` (${plugins.join(", ")})` : ""}. Exit code 1.`, "Rerun with --reporter json for machine-readable diagnostics."]);
+				return;
+			}
+			const warnings = formatCounts(diagnostics);
+			writer.diagnostic([`Kubb succeeded: ${pluralize(filesCreated, "file")} generated in ${require_Telemetry.formatMs(require_Telemetry.getElapsedMs(hrStart))}${warnings ? `, ${warnings}` : ""}.`]);
+		} };
+	};
+}
+//#endregion
+//#region src/loggers/clackLogger.ts
+/**
+* Draws with clack: a gutter bar per group, animated steps, and a progress bar for the writes.
+*/
+const clackWriter = {
+	group: (title) => _clack_prompts.intro(title),
+	groupEnd: (text) => _clack_prompts.outro(text),
+	step: (text) => _clack_prompts.log.step(text, { spacing: 0 }),
+	info: (text) => _clack_prompts.log.info(text),
+	success: (text) => _clack_prompts.log.success(text),
+	warn: (text) => _clack_prompts.log.warn(text),
+	error: (text) => _clack_prompts.log.error(text),
+	block: (lines) => _clack_prompts.log.message(lines, { spacing: 0 }),
+	raw: (lines) => console.log((0, node_util.styleText)("dim", lines.join("\n"))),
+	diagnostic: (lines) => _clack_prompts.log.message(lines, {
+		symbol: "",
+		secondarySymbol: ""
+	}),
+	update: (lines, title) => _clack_prompts.box(lines.join("\n"), title, {
+		width: "auto",
+		formatBorder: (border) => (0, node_util.styleText)("yellow", border),
+		rounded: true,
+		withGuide: false,
+		contentAlign: "center",
+		titleAlign: "center"
+	}),
+	spinner: () => _clack_prompts.spinner(),
+	progress(max) {
+		const bar = _clack_prompts.progress({
+			style: "block",
+			max,
+			size: 30
+		});
+		return {
+			start: (text) => bar.start(text),
+			advance: (text) => bar.advance(1, text),
+			stop: (text) => bar.stop(text)
+		};
+	}
+};
+/**
+* TTY logger for local development, with animated steps and progress bars.
+*/
+const clackLogger = createLogger(clackWriter, { audience: "human" });
+//#endregion
+//#region src/loggers/plainLogger.ts
+/**
+* Prefixes that stand in for the symbols clack draws, so plain output reads the same way.
+*/
+const SYMBOLS = {
+	info: "ℹ",
+	warn: "⚠",
+	error: "✗",
+	step: "◇"
+};
+/** Draws with one `write` call per line. Nothing animates, so a step prints at start and end. */
+function createWriter(write) {
+	return {
+		group: write,
+		groupEnd: write,
+		step: (text) => write(`${SYMBOLS.step} ${text}`),
+		info: write,
+		success: write,
+		warn: write,
+		error: (text) => write(`${SYMBOLS.error} ${text}`),
+		block: (lines) => write(lines.join("\n")),
+		raw: (lines) => write(lines.join("\n")),
+		diagnostic: (lines) => write(lines.join("\n")),
+		update: (lines, title) => write([title, ...lines].join("\n")),
+		spinner: () => ({
+			start: write,
+			message: write,
+			clear: () => {},
+			stop: (text) => text && write(text),
+			error: (text) => write(`${SYMBOLS.error} ${text}`)
+		}),
+		progress: () => ({
+			start: write,
+			advance: write,
+			stop: (text) => text && write(text)
+		})
+	};
+}
+/** The plain logger writing through `write`, e.g. `console.error` so stdout carries only JSON. */
+function createPlainLogger(write) {
+	return createLogger(createWriter(write), { audience: "agent" });
+}
+/** Draws on the console, for non-TTY environments and for an AI coding agent reading the output. */
+const plainWriter = createWriter((line) => console.log(line));
+/**
+* Console adapter for non-TTY environments, and for an AI coding agent reading the output. Reports
+* the same run in the same order as `clackLogger`, without the animation.
+*/
+const plainLogger = createLogger(plainWriter, { audience: "agent" });
+//#endregion
+//#region src/loggers/output.ts
+const SPONSOR_TIPS = [
+	"Your sponsorship keeps Kubb codegen, plugins, and docs maintained",
+	"Sponsor faster generators and better Kubb Studio workflows",
+	"Help keep Kubb free for TypeScript teams building APIs",
+	"Support React Query, Zod, Faker, and MSW integrations",
+	"Back open-source tools that turn OpenAPI into TypeScript",
+	"Sponsor fixes, releases, and new plugins for your API workflow",
+	"Help Kubb stay independent and focused on developer tools"
+];
+const SPONSOR_LINKS = [
+	"https://github.com/sponsors/stijnvanhulle",
+	"https://opencollective.com/kubb",
+	"https://kubb.dev/sponsors"
+];
+/** The writer the loggers draw with on this terminal, so a command's own lines look like its run. */
+function writer() {
+	return isRichOutput() ? clackWriter : plainWriter;
+}
+function nextTip() {
+	return `${SPONSOR_TIPS[Math.floor(Math.random() * SPONSOR_TIPS.length)]}: ${SPONSOR_LINKS[Math.floor(Math.random() * SPONSOR_LINKS.length)]}`;
+}
+function formatTip(tip) {
+	return (0, node_util.styleText)("magenta", " Tip  ") + (0, node_util.styleText)("yellow", tip);
+}
+/**
+* Prints one random tip outside every group. Rich terminals get the styled variant;
+* plain/CI output gets a stable text-only line so the tip is still visible as final output.
+*/
+function logTip() {
+	const tip = nextTip();
+	if (!isRichOutput()) {
+		console.log(`Tip: ${tip}`);
+		return;
+	}
+	console.log(`${(0, node_util.styleText)("magenta", "✦")}${formatTip(tip)}`);
+}
+function write(level, message) {
+	if (isRichOutput()) {
+		_clack_prompts.log[level](message);
+		return;
+	}
+	console.log(`${SYMBOLS[level]} ${message}`);
+}
+/**
+* Opens a command's output with its title.
+*/
+function logIntro({ title, warning, block = true }) {
+	if (block && isRichOutput()) {
+		if (title) _clack_prompts.intro(title);
+		if (warning) _clack_prompts.log.warn(warning);
+		return;
+	}
+	if (title) console.log(title);
+	if (warning) console.warn(warning);
+	if (title || warning) console.log();
+}
+/**
+* Closes the block {@link logIntro} opened. The closing gutter is not a written line, so plain
+* output prints the text on its own.
+*/
+function logOutro(text) {
+	writer().groupEnd(text);
+}
+/**
+* Prints one empty line between two groups, without clack's gutter bar, since the bar belongs to a
+* group and a spacer sits outside every one.
+*/
+function logSpacer() {
+	console.log("");
+}
+/**
+* Opens the command with the Kubb mascot and version, or a single version line where the terminal
+* cannot draw it.
+*/
+function logBanner(version) {
+	if (isRichOutput()) {
+		console.log(`\n${getIntro({
+			title: "Turn your API spec into type-safe code",
+			description: "Ready to start",
+			version,
+			areEyesOpen: true
+		})}\n`);
+		return;
+	}
+	console.log(`Kubb CLI v${version}`);
+}
+/** Prints lines as one block, without a symbol in front of them. Not the writer's block, which drops clack's spacing around it. */
+function logBlock(lines) {
+	if (isRichOutput()) {
+		_clack_prompts.log.message(lines);
+		return;
+	}
+	console.log([lines].flat().join("\n"));
+}
+function logInfo(message) {
+	write("info", message);
+}
+function logWarn(message) {
+	write("warn", message);
+}
+function logError(message) {
+	write("error", message);
+}
+/**
+* Reports a step the command is taking, rather than something it found.
+*/
+function logStep(message) {
+	write("step", message);
+}
+/**
+* A progress spinner, or a writer that prints each message it is given when the terminal cannot
+* animate one. Callers drive both the same way, including the failure state.
+*/
+function createSpinner() {
+	return writer().spinner();
+}
+//#endregion
+Object.defineProperty(exports, "CONFIG_EXTENSIONS", {
+	enumerable: true,
+	get: function() {
+		return CONFIG_EXTENSIONS;
+	}
+});
+Object.defineProperty(exports, "KUBB_CONFIG_FILENAME", {
+	enumerable: true,
+	get: function() {
+		return KUBB_CONFIG_FILENAME;
+	}
+});
+Object.defineProperty(exports, "KUBB_PACKAGE_NAME", {
+	enumerable: true,
+	get: function() {
+		return KUBB_PACKAGE_NAME;
+	}
+});
+Object.defineProperty(exports, "canUseTTY", {
+	enumerable: true,
+	get: function() {
+		return canUseTTY;
+	}
+});
+Object.defineProperty(exports, "clackLogger", {
+	enumerable: true,
+	get: function() {
+		return clackLogger;
+	}
+});
+Object.defineProperty(exports, "createPlainLogger", {
+	enumerable: true,
+	get: function() {
+		return createPlainLogger;
+	}
+});
+Object.defineProperty(exports, "createSpinner", {
+	enumerable: true,
+	get: function() {
+		return createSpinner;
+	}
+});
+Object.defineProperty(exports, "findConfigFile", {
+	enumerable: true,
+	get: function() {
+		return findConfigFile;
+	}
+});
+Object.defineProperty(exports, "initDefaults", {
+	enumerable: true,
+	get: function() {
+		return initDefaults;
+	}
+});
+Object.defineProperty(exports, "isRichOutput", {
+	enumerable: true,
+	get: function() {
+		return isRichOutput;
+	}
+});
+Object.defineProperty(exports, "loadConfigFile", {
+	enumerable: true,
+	get: function() {
+		return loadConfigFile;
+	}
+});
+Object.defineProperty(exports, "logBanner", {
+	enumerable: true,
+	get: function() {
+		return logBanner;
+	}
+});
+Object.defineProperty(exports, "logBlock", {
+	enumerable: true,
+	get: function() {
+		return logBlock;
+	}
+});
+Object.defineProperty(exports, "logError", {
+	enumerable: true,
+	get: function() {
+		return logError;
+	}
+});
+Object.defineProperty(exports, "logInfo", {
+	enumerable: true,
+	get: function() {
+		return logInfo;
+	}
+});
+Object.defineProperty(exports, "logIntro", {
+	enumerable: true,
+	get: function() {
+		return logIntro;
+	}
+});
+Object.defineProperty(exports, "logOutro", {
+	enumerable: true,
+	get: function() {
+		return logOutro;
+	}
+});
+Object.defineProperty(exports, "logSpacer", {
+	enumerable: true,
+	get: function() {
+		return logSpacer;
+	}
+});
+Object.defineProperty(exports, "logStep", {
+	enumerable: true,
+	get: function() {
+		return logStep;
+	}
+});
+Object.defineProperty(exports, "logTip", {
+	enumerable: true,
+	get: function() {
+		return logTip;
+	}
+});
+Object.defineProperty(exports, "logWarn", {
+	enumerable: true,
+	get: function() {
+		return logWarn;
+	}
+});
+Object.defineProperty(exports, "plainLogger", {
+	enumerable: true,
+	get: function() {
+		return plainLogger;
+	}
+});
+Object.defineProperty(exports, "pluralize", {
+	enumerable: true,
+	get: function() {
+		return pluralize;
+	}
+});
+
+//# sourceMappingURL=output-C5g7AtWH.cjs.map