@kubb/cli 5.5.6 → 5.6.0

package/dist/output-i3s5c4Xu.cjs

@@ -0,0 +1,878 @@
+const require_agent = require("./agent-DElUuYuy.cjs");
+let node_util = require("node:util");
+let node_process = require("node:process");
+node_process = require_agent.__toESM(node_process, 1);
+let node_path = require("node:path");
+let _kubb_core = require("@kubb/core");
+let _clack_prompts = require("@clack/prompts");
+_clack_prompts = require_agent.__toESM(_clack_prompts, 1);
+//#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.
+*/
+function parseHex(color) {
+	const int = Number.parseInt(color.replace("#", ""), 16);
+	return Number.isNaN(int) ? {
+		r: 255,
+		g: 255,
+		b: 255
+	} : {
+		r: int >> 16 & 255,
+		g: int >> 8 & 255,
+		b: int & 255
+	};
+}
+/**
+* Returns a function that wraps a string in a 24-bit ANSI true-color escape sequence
+* for the given hex color.
+*/
+function hex(color) {
+	const { r, g, b } = parseHex(color);
+	return (text) => `\x1b[38;2;${r};${g};${b}m${text}\x1b[0m`;
+}
+function gradient(colorStops, text) {
+	const chars = text.split("");
+	return chars.map((char, i) => {
+		const t = chars.length <= 1 ? 0 : i / (chars.length - 1);
+		const seg = Math.min(Math.floor(t * (colorStops.length - 1)), colorStops.length - 2);
+		const lt = t * (colorStops.length - 1) - seg;
+		const from = parseHex(colorStops[seg]);
+		const to = parseHex(colorStops[seg + 1]);
+		return `\x1b[38;2;${Math.round(from.r + (to.r - from.r) * lt)};${Math.round(from.g + (to.g - from.g) * lt)};${Math.round(from.b + (to.b - from.b) * lt)}m${char}\x1b[0m`;
+	}).join("");
+}
+/**
+* ANSI color functions for each part of the Kubb mascot illustration.
+*/
+const palette = {
+	/**
+	* Top cap of the skittle.
+	*/
+	lid: hex("#F55A17"),
+	/**
+	* Upper wood body.
+	*/
+	woodTop: hex("#F5A217"),
+	/**
+	* Middle wood body.
+	*/
+	woodMid: hex("#F58517"),
+	/**
+	* Base wood body.
+	*/
+	woodBase: hex("#B45309"),
+	/**
+	* Eye whites.
+	*/
+	eye: hex("#FFFFFF"),
+	/**
+	* Highlight accent.
+	*/
+	highlight: hex("#adadc6"),
+	/**
+	* Cheek blush.
+	*/
+	blush: hex("#FDA4AF")
+};
+/**
+* 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 = gradient([
+		"#F58517",
+		"#F5A217",
+		"#F55A17"
+	], `KUBB v${version}`);
+	const eyeTop = areEyesOpen ? palette.eye("█▀█") : palette.eye("───");
+	const eyeBottom = areEyesOpen ? palette.eye("▀▀▀") : palette.eye("───");
+	return [
+		`   ${palette.lid("▄▄▄▄▄▄▄▄▄▄▄▄▄")}`,
+		`  ${palette.woodTop("█  ")}${palette.highlight("▄▄")}${palette.woodTop("     ")}${palette.highlight("▄▄")}${palette.woodTop("  █")} ${kubbVersion}`,
+		`  ${palette.woodMid("█ ")}${eyeTop}${palette.woodMid("     ")}${eyeTop}${palette.woodMid(" █")} ${(0, node_util.styleText)("gray", title)}`,
+		`  ${palette.woodMid("█ ")}${eyeBottom}${palette.woodMid("  ")}${palette.blush("◡")}${palette.woodMid("  ")}${eyeBottom}${palette.woodMid(" █")} ${(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_agent.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, 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(", ");
+}
+/** The first three frames of a stack, without the message line. */
+function topFrames(stack) {
+	return stack.split("\n").slice(1, 4).map((frame) => frame.trim());
+}
+/** First stack frames for verbose error output, including an optional `cause` chain. */
+function formatErrorFrames(error) {
+	if (!error.stack) return null;
+	const frames = topFrames(error.stack);
+	const caused = error.cause instanceof Error ? error.cause : void 0;
+	if (!caused?.stack) return { frames };
+	return {
+		frames,
+		cause: {
+			header: `└─ caused by ${caused.message}`,
+			frames: topFrames(caused.stack)
+		}
+	};
+}
+/** The progress summary line the clack logger shows, `null` when there is nothing to display. */
+function buildProgressLine(state) {
+	const parts = [];
+	const duration = require_agent.formatMs(require_agent.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)
+* ```
+*/
+function createLogger(writer) {
+	return function install(context, { logLevel }) {
+		const silent = logLevel <= _kubb_core.logLevel.silent;
+		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
+		};
+		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_agent.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);
+		}
+		function closeGroup(status) {
+			if (!state.groupOpen) return;
+			state.groupOpen = false;
+			stopSpinner();
+			stopProgress();
+			writer.groupEnd(status === "failed" ? (0, node_util.styleText)("red", "✗ Generation failed") : (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;
+		}
+		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;
+			if (state.spinner) stopSpinner(error.message, "failed");
+			else writer.error(text(error.message));
+			const frames = logLevel >= _kubb_core.logLevel.verbose ? formatErrorFrames(error) : null;
+			if (!frames) return;
+			writer.block(frames.frames.map((frame) => text((0, node_util.styleText)("dim", frame))));
+			if (frames.cause) writer.block([(0, node_util.styleText)("dim", frames.cause.header), ...frames.cause.frames.map((frame) => text(`    ${(0, node_util.styleText)("dim", frame)}`))]);
+		});
+		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;
+			}
+			const { headline, details } = _kubb_core.Diagnostics.format(diagnostic);
+			writer.diagnostic([headline, ...details]);
+		});
+		context.hook("studio:connecting", ({ url }) => {
+			startSpinner(`Connecting to ${(0, node_util.styleText)("cyan", url)}`);
+		});
+		context.hook("studio:disconnected", ({ reason }) => {
+			if (logLevel < _kubb_core.logLevel.warn) return;
+			stopSpinner();
+			writer.warn(text(`⚠ Kubb Studio ended the session (${reason})`));
+		});
+		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;
+			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_agent.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", () => {
+			stopSpinner();
+			stopProgress();
+		});
+		context.hook("kubb:lifecycle:end", () => {
+			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 }) => {
+				const line = `Connected to ${(0, node_util.styleText)("cyan", url)} ${(0, node_util.styleText)("dim", `(${formatVersions(versions)})`)}`;
+				if (state.spinner) {
+					stopSpinner(line);
+					return;
+				}
+				writer.success(text(`✓ ${line}`));
+			});
+			context.hook("studio:ready", () => {
+				startSpinner("✓ Ready to receive jobs");
+			});
+			context.hook("studio:command:start", ({ command }) => {
+				stopSpinner();
+				writer.info(text(`Kubb Studio asked to ${(0, node_util.styleText)("bold", command)}`));
+			});
+			context.hook("studio:command:end", ({ command, info }) => {
+				writer.success(text(`✓ Finished ${command}${info ? ` ${(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_agent.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) ?? "No plugins ran", 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(`Writing ${pluralize(files.length, "file")}`));
+			});
+			context.hook("kubb:files:processing:update", ({ files }) => {
+				for (const { file, config } of files) {
+					state.processedFiles++;
+					state.progress?.advance(`Writing ${(0, node_path.relative)(config.root, file.path)}`);
+				}
+			});
+			context.hook("kubb:files:processing:end", () => {
+				stopProgress(`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;
+			closeGroup(status);
+			writer.diagnostic([...lines]);
+		} };
+	};
+}
+//#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_agent.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() && !require_agent.getAgentName();
+}
+//#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() {
+		const spinner = _clack_prompts.spinner();
+		return {
+			start: (text) => spinner.start(text),
+			message: (text) => spinner.message(text),
+			clear: () => spinner.clear(),
+			stop: (text) => spinner.stop(text),
+			error: (text) => spinner.error(text)
+		};
+	},
+	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);
+//#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));
+}
+/** 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);
+//#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, "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, "isRichOutput", {
+	enumerable: true,
+	get: function() {
+		return isRichOutput;
+	}
+});
+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-i3s5c4Xu.cjs.map