@kubb/cli 5.11.4 → 5.11.6

package/dist/reporters-Dl8lrJZG.js

@@ -0,0 +1,817 @@
+import "./rolldown-runtime-CRm0XQPb.js";
+import { a as getElapsedMs, i as formatMs } from "./Telemetry-CfJAUDnh.js";
+import { _ as isPathInside, f as formatBar, o as readOutputFiles, p as formatMsWithColor, r as diffOutput, v as read } from "./utils-CnjEJIdZ.js";
+import { n as toPermissionFlag, p as writer, t as pluralize } from "./text-CMP4M19Z.js";
+import { styleText } from "node:util";
+import process from "node:process";
+import { readFile } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+import { Diagnostics, cacheStorage, createCliReporter, createOutputManifest, getInputKind, logLevel } from "@kubb/core";
+//#region src/loggers/features/context.ts
+function createLoggerContext({ hooks, writer, logLevel: logLevel$5 }) {
+	const text = (message) => logLevel$5 >= logLevel.verbose ? `${styleText("dim", `[${clock()}]`)} ${message}` : message;
+	const ctx = {
+		hooks,
+		writer,
+		logLevel: logLevel$5,
+		silent: logLevel$5 <= logLevel.silent,
+		human: writer.audience === "human",
+		session: false,
+		groupOpen: false,
+		text,
+		line: (symbol, message, info) => text([
+			symbol,
+			message,
+			info && styleText("dim", info)
+		].filter(Boolean).join(" ")),
+		onRun(name, fn) {
+			return hooks.hook(name, (...args) => ctx.session ? void 0 : fn(...args));
+		}
+	};
+	return ctx;
+}
+/** `HH:MM:SS` in 24-hour time. */
+function clock(date = /* @__PURE__ */ new Date()) {
+	return date.toLocaleTimeString("en-US", {
+		hour12: false,
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit"
+	});
+}
+/** 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;
+}
+//#endregion
+//#region src/loggers/features/generation.ts
+/**
+* One config's run: the group it opens, the state every feature resets at its start, and the
+* closing line, which the lifecycle end draws too for a run that threw before its summary.
+*/
+function createGeneration(ctx, { spinner, progress, walk, phases, problems }) {
+	const { writer, silent, human, text, hooks, onRun } = ctx;
+	function reset() {
+		spinner.reset();
+		progress.reset();
+		walk.reset();
+		phases.reset();
+		problems.reset();
+	}
+	function closeGroup(status) {
+		if (!ctx.groupOpen) return;
+		ctx.groupOpen = false;
+		spinner.stop();
+		progress.stop();
+		writer.groupEnd(status === "failed" ? styleText("red", problems.failedTitle()) : styleText("green", "✓ Generation succeeded"));
+	}
+	hooks.hook("kubb:lifecycle:start", () => {
+		reset();
+	});
+	onRun("kubb:generation:start", ({ config }) => {
+		closeGroup("failed");
+		reset();
+		walk.state.totalPlugins = config.plugins?.length ?? 0;
+		progress.state.inMemory = config.storage?.name === "memory";
+		problems.setSpec(config);
+		if (silent) return;
+		const input = getInputPath(config);
+		writer.group(text([styleText("bold", config.name ?? "kubb"), input ? styleText("dim", input) : void 0].filter(Boolean).join(" ")));
+		ctx.groupOpen = true;
+		spinner.start("Parsing spec");
+	});
+	onRun("kubb:generation:end", async ({ diagnostics = [] }) => {
+		spinner.stop();
+		progress.stop();
+		problems.state.diagnostics = diagnostics;
+		await problems.flush();
+	});
+	hooks.hook("kubb:lifecycle:end", async () => {
+		await problems.flush();
+		closeGroup("failed");
+		reset();
+	});
+	const renderSummary = (lines, { status }) => {
+		if (silent || !ctx.groupOpen) return;
+		spinner.stop();
+		progress.stop();
+		if (human) closeGroup(status);
+		ctx.groupOpen = false;
+		writer.diagnostic([...lines]);
+	};
+	return { renderSummary };
+}
+//#endregion
+//#region src/loggers/features/phases.ts
+/**
+* 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
+	}
+};
+/** A hook's display name: its `name`, or the command line it runs. */
+function formatHookLabel({ command, name, args }) {
+	return name ?? (args?.length ? `${command} ${args.join(" ")}` : command);
+}
+/**
+* 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);
+}
+/** The format, lint and post-generate phases, and the hooks and messages they buffer while their step owns the line. */
+function createPhases({ writer, silent, logLevel: logLevel$4, text, line, onRun }, spinner) {
+	const state = {
+		phase: null,
+		hooks: /* @__PURE__ */ new Map()
+	};
+	function startPhase(options) {
+		state.phase = {
+			...options,
+			failed: false,
+			hrStart: process.hrtime(),
+			lines: [],
+			output: []
+		};
+		spinner.start(options.running);
+	}
+	function endPhase() {
+		const phase = state.phase;
+		state.phase = null;
+		if (!phase || silent) return;
+		const duration = formatMsWithColor(getElapsedMs(phase.hrStart));
+		spinner.stop(phase.failed ? `${phase.failure} after ${duration}` : `${phase.success} 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);
+	}
+	onRun("kubb:format:start", () => startPhase(PHASES.format));
+	onRun("kubb:format:end", endPhase);
+	onRun("kubb:lint:start", () => startPhase(PHASES.lint));
+	onRun("kubb:lint:end", endPhase);
+	onRun("kubb:hooks:start", () => startPhase(PHASES.hooks));
+	onRun("kubb:hooks:end", endPhase);
+	onRun("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 = styleText("dim", formatHookLabel({
+			command,
+			name,
+			args
+		}));
+		const reason = error?.message ? ` (${error.message})` : "";
+		const result = success ? `${styleText("green", "✓")} ${label} in ${formatMsWithColor(getElapsedMs(active.hrStart))}` : `${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;
+		}
+		spinner.stop();
+		writer.step(text(result));
+		writeOutput(active.lines);
+	});
+	if (!silent) {
+		onRun("kubb:info", ({ message, info }) => {
+			const formatted = line(styleText("blue", "ℹ"), message, info);
+			if (state.phase) {
+				state.phase.lines.push(formatted);
+				return;
+			}
+			if (spinner.message(formatted)) return;
+			writer.info(formatted);
+		});
+		onRun("kubb:success", ({ message, info }) => {
+			const formatted = line(styleText("green", "✓"), message, logLevel$4 >= logLevel.info ? info : void 0);
+			if (spinner.message(formatted)) return;
+			writer.success(formatted);
+		});
+		onRun("kubb:hook:start", ({ id, command, name, args }) => {
+			if (!id) return;
+			state.hooks.set(id, {
+				hrStart: process.hrtime(),
+				lines: []
+			});
+			spinner.message(text(`Running ${styleText("dim", formatHookLabel({
+				command,
+				name,
+				args
+			}))}`));
+		});
+		onRun("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 {
+		/** The phase whose step owns the line, so a failure or an info line can wait for it. */
+		get phase() {
+			return state.phase;
+		},
+		reset() {
+			state.phase = null;
+			state.hooks = /* @__PURE__ */ new Map();
+		}
+	};
+}
+//#endregion
+//#region src/loggers/specFrame.ts
+/**
+* Where `location` sits in `source` according to its adapter, with a code frame. `undefined` when the adapter cannot place it.
+*/
+function locateInSpec({ adapter, source, location }) {
+	const lines = source.split(/\r?\n/);
+	try {
+		const range = adapter.locate?.(source, location);
+		if (!range) return void 0;
+		const before = source.slice(0, range.start).split("\n");
+		const line = before.length;
+		const column = before.at(-1).length + 1;
+		const text = lines[line - 1] ?? "";
+		const width = String(line).length;
+		const gutter = (number) => styleText("dim", `${number === void 0 ? "".padStart(width) : String(number).padStart(width)} │`);
+		const carets = "^".repeat(Math.max(1, Math.min(range.end - range.start, text.length - column + 1)));
+		return {
+			line,
+			column,
+			frame: [
+				...line > 1 ? [`${gutter(line - 1)} ${lines[line - 2]}`] : [],
+				`${gutter(line)} ${text}`,
+				`${gutter()} ${" ".repeat(column - 1)}${styleText("red", carets)}`
+			]
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/loggers/features/problems.ts
+/** Warnings, errors and diagnostics: printed as they come, or held back and grouped by plugin once a human's build ends. */
+function createProblems(ctx, spinner, progress, phases) {
+	const { writer, silent, human, logLevel: logLevel$3, text, line, hooks } = ctx;
+	const { audience } = writer;
+	const formatOptions = {
+		audience,
+		verbose: logLevel$3 >= logLevel.verbose,
+		width: Math.min(process.stdout.columns || 80, 100) - (audience === "human" ? 4 : 2)
+	};
+	const state = {
+		/** Problems held back so the human view can print them grouped by plugin once the build ends. */
+		problems: [],
+		/** The finished config's diagnostics, for the closing verdict. */
+		diagnostics: [],
+		/** A local-file input, which a located diagnostic points into; `load` parses it once, on the first such diagnostic. */
+		spec: void 0
+	};
+	/** Format options for one problem, with its line and column in a local spec when its pointer resolves there. */
+	async function optionsFor(problem) {
+		const { location } = problem;
+		const { spec } = state;
+		if (!location || !spec) return formatOptions;
+		const source = await spec.source;
+		const position = source && locateInSpec({
+			adapter: spec.adapter,
+			source,
+			location
+		});
+		if (!position) return formatOptions;
+		return {
+			...formatOptions,
+			position: {
+				file: relative(process.cwd(), spec.path),
+				...position
+			}
+		};
+	}
+	/**
+	* Prints problems grouped under their plugin's name, each with the code aligned at the right.
+	*/
+	async function writeProblems(problems) {
+		if (!problems.length) return;
+		const formatted = await Promise.all(problems.map(async (problem) => Diagnostics.format(problem, await optionsFor(problem))));
+		if (!human) {
+			for (const lines of formatted) writer.diagnostic(lines);
+			return;
+		}
+		const lines = [...Map.groupBy(problems.map((problem, index) => ({
+			plugin: problem.plugin ?? "",
+			lines: formatted[index]
+		})), ({ plugin }) => plugin)].flatMap(([plugin, group]) => [...plugin ? [` ${styleText("bold", plugin)}`, ""] : [], ...group.flatMap((entry) => [...entry.lines.map((entryLine) => `  ${entryLine}`), ""])]);
+		writer.diagnostic(lines.slice(0, -1));
+	}
+	hooks.hook("kubb:warn", ({ message, info }) => {
+		if (logLevel$3 < logLevel.warn) return;
+		writer.warn(line(styleText("yellow", "⚠"), message, logLevel$3 >= logLevel.info ? info : void 0));
+	});
+	hooks.hook("kubb:error", ({ error }) => {
+		const phase = phases.phase;
+		if (phase) phase.failed = true;
+		const message = error.name === "Error" || Diagnostics.isError(error) ? error.message : `${error.name}: ${error.message}`;
+		const help = Diagnostics.isError(error) ? error.diagnostic.help : void 0;
+		const [headline = "", ...details] = Diagnostics.format({
+			code: Diagnostics.code.unknown,
+			severity: "error",
+			message,
+			help,
+			cause: error
+		}, formatOptions);
+		if (!human) {
+			spinner.stop();
+			progress.stop();
+			writer.diagnostic([headline, ...details]);
+			return;
+		}
+		if (spinner.active) spinner.stop(message, "failed");
+		else writer.error(text(message));
+		if (details.length) writer.block(details.map(text));
+	});
+	hooks.hook("kubb:diagnostic", async ({ diagnostic }) => {
+		if (silent && diagnostic.severity !== "error") return;
+		if (ctx.session && !Diagnostics.isUpdate(diagnostic)) return;
+		spinner.stop();
+		progress.stop();
+		if (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 && ctx.groupOpen) {
+			state.problems.push(diagnostic);
+			return;
+		}
+		await writeProblems([diagnostic]);
+	});
+	return {
+		state,
+		/** Points located diagnostics into the config's input when it is a local file. */
+		setSpec(config) {
+			const input = getInputPath(config);
+			if (input && config.adapter?.locate && getInputKind(input) === "file") {
+				const path = resolve(config.root, input);
+				let source;
+				state.spec = {
+					path,
+					adapter: config.adapter,
+					get source() {
+						return source ??= read(path).catch(() => void 0);
+					}
+				};
+			}
+		},
+		/** Prints the problems held back so far. */
+		flush() {
+			return writeProblems(state.problems.splice(0));
+		},
+		/** `✖ Failed  1 error · 1 warning  in plugin-ts` once the build ended, or `✗ Generation failed` for a run that stopped early. */
+		failedTitle() {
+			const { errors, warnings } = Diagnostics.count(state.diagnostics);
+			const counts = [errors && pluralize(errors, "error"), warnings && pluralize(warnings, "warning")].filter(Boolean).join(" · ");
+			if (!human || !counts) return "✗ Generation failed";
+			const plugins = Diagnostics.failedPlugins(state.diagnostics);
+			return `✖ Failed  ${counts}${plugins.length ? `  in ${plugins.join(", ")}` : ""}`;
+		},
+		reset() {
+			Object.assign(state, {
+				problems: [],
+				diagnostics: [],
+				spec: void 0
+			});
+		}
+	};
+}
+//#endregion
+//#region src/loggers/features/progress.ts
+/** The progress bar over the file writes, and the counts the summary line shows. */
+function createProgress({ writer, silent, text, onRun }, spinner) {
+	const state = {
+		progress: null,
+		totalFiles: 0,
+		processedFiles: 0,
+		/** Whether this run keeps its files in memory, as a `kubb studio` run without `--allow-write` does. */
+		inMemory: false
+	};
+	function stop(message) {
+		const progress = state.progress;
+		if (!progress) return;
+		state.progress = null;
+		progress.stop(message === void 0 ? "" : text(message));
+	}
+	if (!silent) {
+		onRun("kubb:files:processing:start", ({ files }) => {
+			spinner.stop();
+			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")}`));
+		});
+		onRun("kubb:files:processing:update", ({ files }) => {
+			for (const { file, config } of files) {
+				state.processedFiles++;
+				state.progress?.advance(`${state.inMemory ? "Generating" : "Writing"} ${relative(config.root, file.path)}`);
+			}
+		});
+		onRun("kubb:files:processing:end", ({ files, unchanged }) => {
+			const skipped = unchanged.length ? styleText("dim", ` · ${unchanged.length} unchanged`) : "";
+			stop(state.inMemory ? `Generated ${pluralize(state.processedFiles, "file")} in memory` : `Wrote ${pluralize(files.length - unchanged.length, "file")}${skipped}`);
+		});
+	}
+	return {
+		state,
+		stop,
+		reset() {
+			stop();
+			Object.assign(state, {
+				totalFiles: 0,
+				processedFiles: 0,
+				inMemory: false
+			});
+		}
+	};
+}
+//#endregion
+//#region src/loggers/features/session.ts
+/** One line of a Studio session's job log: the time, the command, who asked for it, and how it ended. */
+function formatJobLine({ command, result, requestedBy }) {
+	const by = requestedBy ? `${styleText("dim", `by ${requestedBy}`.padEnd(16))} ` : "";
+	return `${styleText("dim", clock())}  ${command.padEnd(10)} ${by}${result}`;
+}
+/**
+* A `kubb studio` session. It emits these on the same emitter as its generations, so one logger
+* renders the whole command: the connection, then one job line per command.
+*/
+function createSession(ctx, spinner) {
+	const { writer, silent, human, logLevel: logLevel$2, text, hooks } = ctx;
+	hooks.hook("studio:disconnected", ({ code, reason }) => {
+		if (logLevel$2 < logLevel.warn) return;
+		spinner.stop();
+		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}`})`));
+	});
+	hooks.hook("studio:warn", ({ message, permission }) => {
+		if (logLevel$2 < logLevel.warn) return;
+		const remedy = permission ? `; pass ${toPermissionFlag(permission)} to allow it` : "";
+		const paused = spinner.active;
+		spinner.stop();
+		writer.warn(text(`⚠ ${message}${remedy}`));
+		if (paused) spinner.start("Ready for jobs");
+	});
+	hooks.hook("studio:error", ({ error }) => {
+		if (spinner.active) {
+			spinner.stop(error.message, "failed");
+			return;
+		}
+		writer.error(text(error.message));
+	});
+	if (silent) return;
+	let job = null;
+	hooks.hook("studio:connected", ({ url, versions: { studio, kubb, agent } }) => {
+		ctx.session = human;
+		spinner.stop();
+		const versions = [
+			`v${agent}`,
+			kubb !== agent ? `runtime v${kubb}` : void 0,
+			`Studio v${studio}`
+		].filter(Boolean).join(" · ");
+		writer.success(text(`✓ Connected to ${styleText("cyan", url)} ${styleText("dim", `· ${versions}`)}`));
+		spinner.start("Ready for jobs");
+	});
+	hooks.hook("kubb:generation:start", () => {
+		if (ctx.session) spinner.message(text("Generating"));
+	});
+	hooks.hook("kubb:generation:end", ({ diagnostics = [], filesCreated = 0, status, hrStart = process.hrtime() }) => {
+		job = {
+			fileCount: filesCreated,
+			ms: getElapsedMs(hrStart),
+			errors: status === "failed" ? Diagnostics.count(diagnostics).errors : 0
+		};
+	});
+	hooks.hook("studio:command", ({ command, info, requestedBy, failed }) => {
+		spinner.stop();
+		const took = command === "generate" && job ? `${pluralize(job.fileCount, "file")} in ${formatMs(job.ms)} ` : "";
+		const result = failed ? `${styleText("red", "✖")} ${job?.errors ? pluralize(job.errors, "error") : "failed"}, see Studio` : `${styleText("green", "✓")} ${took}${styleText("dim", `(${info})`)}`;
+		writer.info(formatJobLine({
+			command,
+			requestedBy,
+			result
+		}));
+		job = null;
+		spinner.start("Ready for jobs");
+	});
+	hooks.hook("studio:reconnecting", ({ delayMs }) => {
+		spinner.stop();
+		writer.info(text(styleText("dim", `Retrying connection to Kubb Studio in ${formatMs(delayMs)}`)));
+	});
+}
+//#endregion
+//#region src/loggers/features/spinner.ts
+/** The step whose end is not known when it starts: the spec parse, the node walk, a phase, or a Studio session waiting for jobs. */
+function createSpinner({ writer, silent, text }) {
+	let spinner = null;
+	function stop(message, status = "success") {
+		const active = spinner;
+		if (!active) return;
+		spinner = null;
+		if (message === void 0) {
+			active.clear();
+			return;
+		}
+		if (status === "failed") {
+			active.error(text(message));
+			return;
+		}
+		active.stop(text(message));
+	}
+	return {
+		/** Whether a spinner is drawing right now. */
+		get active() {
+			return spinner !== null;
+		},
+		start(message) {
+			if (silent) return;
+			spinner = writer.spinner();
+			spinner.start(text(message));
+		},
+		stop,
+		/** Redraws the spinner's line. `false` when no spinner is running, so the caller prints the line itself. */
+		message(line) {
+			if (!spinner) return false;
+			spinner.message(line);
+			return true;
+		},
+		reset: () => stop()
+	};
+}
+//#endregion
+//#region src/loggers/features/walk.ts
+/** Milliseconds between redraws of the live generation block, about clack's spinner frame rate. */
+const WALK_REDRAW_MS = 80;
+function createState() {
+	return {
+		totalPlugins: 0,
+		completedPlugins: 0,
+		failedPlugins: 0,
+		/** `process.hrtime()` snapshot taken at the start of generation, for the elapsed time. */
+		hrStart: process.hrtime(),
+		/** Plugin results held back while the generation step owns the line. */
+		pluginLines: [],
+		/** The node walk's live state: the spec's node total, the distinct nodes generated, and each plugin's count and current node. */
+		walk: {
+			total: 0,
+			visited: /* @__PURE__ */ new Set(),
+			plugins: /* @__PURE__ */ new Map()
+		},
+		lastWalkDraw: 0
+	};
+}
+/** The node walk the plugins share: the live generation block, and the plugin results printed once the walk ends. */
+function createWalk({ writer, silent, human, text, onRun }, spinner, progress) {
+	const state = createState();
+	/** The progress summary line the clack logger shows, `null` when there is nothing to display. */
+	function buildProgressLine() {
+		const parts = [];
+		const duration = formatMs(getElapsedMs(state.hrStart));
+		const { totalFiles, processedFiles } = progress.state;
+		if (state.totalPlugins > 0) {
+			const failed = state.failedPlugins > 0 ? ` ${styleText("red", `(${state.failedPlugins} failed)`)}` : "";
+			parts.push(`Plugins ${styleText("green", state.completedPlugins.toString())}/${state.totalPlugins}${failed}`);
+		}
+		if (totalFiles > 0) parts.push(`Files ${styleText("green", processedFiles.toString())}/${totalFiles}`);
+		if (parts.length === 0) return null;
+		parts.push(`${styleText("green", duration)} elapsed`);
+		return parts.join(styleText("dim", " | "));
+	}
+	if (!silent) {
+		onRun("kubb:build:start", ({ nodeCounts: { schemas, operations } }) => {
+			state.walk.total = schemas + operations;
+			const details = `${pluralize(schemas, "schema")} · ${pluralize(operations, "operation")} · ${formatMs(getElapsedMs(state.hrStart))}`;
+			spinner.stop(`Parsed spec  ${styleText("dim", details)}`);
+			spinner.start("Generating");
+		});
+		if (human) {
+			const onNode = (key, name, plugin) => {
+				const { total, visited, plugins } = state.walk;
+				visited.add(key);
+				plugins.set(plugin, {
+					count: (plugins.get(plugin)?.count ?? 0) + 1,
+					current: name
+				});
+				const now = Date.now();
+				if (now - state.lastWalkDraw < WALK_REDRAW_MS) return;
+				state.lastWalkDraw = now;
+				const elapsed = styleText("dim", formatMs(getElapsedMs(state.hrStart)));
+				const head = total ? `Generating  ${formatBar(visited.size, total)}  ${visited.size}/${total} nodes  ${elapsed}` : `Generating  ${pluralize(visited.size, "node")}  ${elapsed}`;
+				const width = Math.max(...[...plugins.keys()].map((pluginName) => pluginName.length));
+				const rows = [...plugins].map(([pluginName, row]) => `${styleText("dim", "│")}   ${pluginName.padEnd(width)}  ${styleText("dim", String(row.count).padStart(4))}  ${styleText("cyan", row.current)}`);
+				spinner.message(text([head, ...rows].join("\n")));
+			};
+			onRun("kubb:generate:schema", (node, { plugin }) => onNode(`schema:${node.name}`, node.name ?? "schema", plugin.name));
+			onRun("kubb:generate:operation", (node, { plugin }) => onNode(`operation:${node.operationId}`, node.operationId, plugin.name));
+		}
+		onRun("kubb:plugin:end", ({ plugin, duration, success }) => {
+			state[success ? "completedPlugins" : "failedPlugins"]++;
+			state.pluginLines.push(text(`${plugin.name} ${success ? "completed" : "failed"} in ${formatMsWithColor(duration)}`));
+		});
+		onRun("kubb:plugins:end", () => {
+			const failed = state.failedPlugins > 0;
+			spinner.stop(buildProgressLine() ?? void 0, failed ? "failed" : "success");
+			if (state.pluginLines.length) {
+				writer.block(state.pluginLines);
+				state.pluginLines = [];
+			}
+		});
+	}
+	return {
+		state,
+		reset() {
+			Object.assign(state, createState());
+		}
+	};
+}
+//#endregion
+//#region src/loggers/features/index.ts
+/**
+* Wires a {@link LoggerWriter} onto the run's hooks. Each feature registers the hooks for one
+* concern, so every writer reports the same run in the same 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.
+* It hands back `renderSummary`, which writes the `cli` reporter's summary inside the group opened
+* for that config and closes the group.
+*/
+function installLogger({ hooks, writer, logLevel }) {
+	const ctx = createLoggerContext({
+		hooks,
+		writer,
+		logLevel
+	});
+	const spinner = createSpinner(ctx);
+	const progress = createProgress(ctx, spinner);
+	const walk = createWalk(ctx, spinner, progress);
+	const phases = createPhases(ctx, spinner);
+	const problems = createProblems(ctx, spinner, progress, phases);
+	createSession(ctx, spinner);
+	return createGeneration(ctx, {
+		spinner,
+		progress,
+		walk,
+		phases,
+		problems
+	});
+}
+//#endregion
+//#region src/loggers/reporters.ts
+/** Installs the live logger and wires the selected reporters. `cli` renders its summary through the logger, and is skipped when `json` owns stdout. */
+function setupReporters(context, { logLevel: logLevel$1, reporters, writer: writer$1 = writer(), dryRun = false }) {
+	const hasJson = reporters.some((reporter) => reporter.name === "json");
+	const selected = reporters.flatMap((reporter) => {
+		if (reporter.name !== "cli") return [reporter];
+		if (hasJson) return [];
+		return [createCliReporter({ render: installLogger({
+			hooks: context,
+			writer: writer$1,
+			logLevel: logLevel$1
+		}).renderSummary })];
+	});
+	const ctx = { logLevel: logLevel$1 };
+	const pluginFiles = selected.some((reporter) => reporter.needsPluginFiles) ? /* @__PURE__ */ new Map() : void 0;
+	const seen = /* @__PURE__ */ new Set();
+	if (pluginFiles) context.hook("kubb:plugin:end", ({ plugin, files }) => {
+		for (const file of files) {
+			if (seen.has(file.path)) continue;
+			seen.add(file.path);
+			const paths = pluginFiles.get(plugin.name) ?? [];
+			paths.push(file.path);
+			pluginFiles.set(plugin.name, paths);
+		}
+	});
+	let filesUnchanged = 0;
+	let previous;
+	let paths = [];
+	let outputPath = "";
+	const trackChanges = selected.some((reporter) => reporter.name === "cli") && logLevel$1 > logLevel.silent;
+	context.hook("kubb:generation:start", async ({ config }) => {
+		pluginFiles?.clear();
+		seen.clear();
+		filesUnchanged = 0;
+		paths = [];
+		outputPath = resolve(config.root, config.output.path);
+		previous = trackChanges && (dryRun || config.storage?.name === "fs") ? await readOutputFiles(outputPath) : void 0;
+	});
+	context.hook("kubb:files:processing:start", async ({ files }) => {
+		if (!previous) return;
+		for (const file of files) {
+			if (previous.has(file.path) || isPathInside(outputPath, file.path)) continue;
+			const source = await readFile(file.path, "utf8").catch(() => null);
+			if (source !== null) previous.set(file.path, source);
+		}
+	});
+	context.hook("kubb:files:processing:end", ({ files, unchanged }) => {
+		filesUnchanged = unchanged.length;
+		paths = files.map((file) => file.path);
+	});
+	context.hook("kubb:generation:end", async ({ config, storage, diagnostics = [], filesCreated = 0, status = "success", hrStart = process.hrtime() }) => {
+		const result = {
+			config,
+			diagnostics,
+			filesCreated,
+			filesUnchanged,
+			dryRun,
+			status,
+			hrStart
+		};
+		const cliResult = { ...result };
+		if (previous && status !== "failed") {
+			const manifest = dryRun ? await createOutputManifest({
+				storage,
+				cache: cacheStorage({ root: config.root })
+			}) : void 0;
+			const diff = await diffOutput({
+				storage,
+				paths,
+				clean: Boolean(config.output.clean),
+				manifest,
+				previousFiles: previous
+			});
+			const changes = {
+				added: 0,
+				modified: 0,
+				deleted: 0,
+				linesAdded: 0,
+				linesRemoved: 0
+			};
+			const counts = {
+				A: "added",
+				M: "modified",
+				D: "deleted"
+			};
+			for (const file of diff.files) {
+				changes[counts[file.status]]++;
+				changes.linesAdded += file.added ?? 0;
+				changes.linesRemoved += file.removed ?? 0;
+			}
+			cliResult.filesCreated = changes.added + changes.modified + diff.unchanged;
+			cliResult.filesUnchanged = diff.unchanged;
+			cliResult.fileChanges = changes;
+		}
+		for (const reporter of selected) {
+			const grouped = reporter.needsPluginFiles && pluginFiles?.size ? [...pluginFiles].map(([plugin, files]) => ({
+				plugin,
+				files: [...files]
+			})) : void 0;
+			await reporter.report({
+				...reporter.name === "cli" ? cliResult : result,
+				pluginFiles: grouped
+			}, ctx);
+		}
+	});
+	context.hook("kubb:lifecycle:end", async () => {
+		for (const reporter of selected) await reporter.drain?.(ctx);
+	});
+}
+/** Picks the reporters whose `name` is in `names`, in the given order (the CLI maps `--reporter` to this); duplicates and unknown names are skipped. */
+function selectReporters(reporters, names) {
+	return [...new Set(names)].flatMap((name) => reporters.find((reporter) => reporter.name === name) ?? []);
+}
+//#endregion
+export { setupReporters as n, selectReporters as t };
+
+//# sourceMappingURL=reporters-Dl8lrJZG.js.map