@kubb/core 5.11.3 → 5.11.5

package/dist/index.cjs

@@ -29,10 +29,10 @@ let tinyexec = require("tinyexec");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
+let node_fs = require("node:fs");
 let node_util = require("node:util");
 let _kubb_ast = require("@kubb/ast");
 let node_crypto = require("node:crypto");
-let node_fs = require("node:fs");
 let node_os = require("node:os");
 let node_readline = require("node:readline");
 let unstorage = require("unstorage");
@@ -41,7 +41,7 @@ unstorage_drivers_fs = __toESM(unstorage_drivers_fs, 1);
 let node_url = require("node:url");
 let node_module = require("node:module");
 //#region package.json
-var version = "5.11.3";
+var version = "5.11.5";
 //#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -247,9 +247,26 @@ async function write(path, data, options = {}) {
 		stored: stored ?? "",
 		source: trimmed
 	})) return null;
+	await writeRaw(resolved, content);
+	if (options.sanity) {
+		const savedData = await read(resolved);
+		if (savedData !== content) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
+		return savedData;
+	}
+	return content;
+}
+/**
+* Writes UTF-8 content verbatim, including empty files and surrounding whitespace.
+* Uses Bun.write under Bun and creates missing parent directories under either runtime.
+*
+* @example
+* await writeRaw('./cache/output.ts', '  // keep these bytes\n\n')
+*/
+async function writeRaw(path, content) {
+	const resolved = (0, node_path.resolve)(path);
 	if (runtime.isBun) {
 		await Bun.write(resolved, content);
-		return content;
+		return;
 	}
 	try {
 		await (0, node_fs_promises.writeFile)(resolved, content, { encoding: "utf-8" });
@@ -258,12 +275,29 @@ async function write(path, data, options = {}) {
 		await (0, node_fs_promises.mkdir)((0, node_path.dirname)(resolved), { recursive: true });
 		await (0, node_fs_promises.writeFile)(resolved, content, { encoding: "utf-8" });
 	}
-	if (options.sanity) {
-		const savedData = await (0, node_fs_promises.readFile)(resolved, { encoding: "utf-8" });
-		if (savedData !== content) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
-		return savedData;
+}
+/**
+* Lists non-hidden regular files below `directory` as relative POSIX paths, excluding directories and symlinks.
+* Uses Bun.Glob under Bun because its Node glob compatibility API lacks directory-entry support.
+*
+* @example
+* for await (const path of listFiles('./src')) console.log(path)
+*/
+async function* listFiles(directory) {
+	const cwd = (0, node_path.resolve)(directory);
+	if (runtime.isBun) {
+		yield* new Bun.Glob("**/*").scan({
+			cwd,
+			dot: false,
+			onlyFiles: true,
+			followSymlinks: false
+		});
+		return;
 	}
-	return content;
+	for await (const entry of (0, node_fs_promises.glob)("**/*", {
+		cwd,
+		withFileTypes: true
+	})) if (entry.isFile()) yield toPosixPath((0, node_path.relative)(cwd, (0, node_path.join)(entry.parentPath, entry.name)));
 }
 /**
 * Converts a filesystem path to use POSIX (`/`) separators.
@@ -745,13 +779,15 @@ function serialize(diagnostic) {
 * with `at`, `fix`, the first cause, and `Learn more` for an error, and one row for a warning.
 * `verbose` adds the full stack.
 */
-function format(diagnostic, { audience = "agent", verbose = false, width = 0 } = {}) {
+function format(diagnostic, { audience = "agent", verbose = false, width = 0, position } = {}) {
 	const { code, severity, message } = diagnostic;
 	const problem = Diagnostics.isProblem(diagnostic) ? diagnostic : void 0;
 	const human = audience === "human";
 	const paint = human ? node_util.styleText : (_format, text) => text;
 	const [firstLine = "", ...rest] = message.split("\n");
 	const pointer = problem?.location && "pointer" in problem.location ? problem.location.pointer : void 0;
+	const at = position ? `${position.file}:${position.line}:${position.column}` : void 0;
+	const where = at ?? pointer;
 	const help = problem ? getHelp(problem) : void 0;
 	const causes = problem ? getCauses(problem) : [];
 	const crash = problem ? crashCodes.has(problem.code) : false;
@@ -761,7 +797,7 @@ function format(diagnostic, { audience = "agent", verbose = false, width = 0 } =
 		const row = (label, value) => {
 			if (value) details.push(`  ${label}: ${value}`);
 		};
-		row("at", pointer);
+		row("at", at && pointer ? `${at} (${pointer})` : pointer);
 		if (problem && severity !== "info") row("why", Diagnostics.explain(problem.code).cause);
 		row("fix", help);
 		for (const cause of causes) row("caused by", cause);
@@ -771,24 +807,25 @@ function format(diagnostic, { audience = "agent", verbose = false, width = 0 } =
 		return [`${severity} ${code}${problem?.plugin ? ` [${problem.plugin}]` : ""}: ${firstLine}`, ...details];
 	}
 	const left = `${paint(severityStyle[severity], severityIcon[severity])} ${paint("bold", firstLine)}`;
-	const gap = Math.max(2, width - (0, node_util.stripVTControlCharacters)(left).length - code.length);
-	const headline = `${left}${" ".repeat(gap)}${paint("dim", code)}`;
+	const gap = width - (0, node_util.stripVTControlCharacters)(left).length - code.length;
+	const headline = width && gap < 2 ? [left, `${" ".repeat(Math.max(0, width - code.length))}${paint("dim", code)}`] : [`${left}${" ".repeat(Math.max(2, gap))}${paint("dim", code)}`];
 	const frame = rest.filter((line) => line.trim()).map((line) => `  ${paint("dim", line)}`);
 	const label = (name) => paint("dim", name.length < 4 ? name.padEnd(4) : `${name} `);
-	const rows = [["at", pointer && paint("cyan", pointer)], ["fix", help]];
+	const rows = [["at", where && paint("cyan", where)], ["fix", help]];
 	if (severity !== "error") {
 		const first = rows.find(([, value]) => value);
 		return [
-			headline,
+			...headline,
 			...frame,
 			...first ? [`  ${label(first[0])} ${first[1]}`] : []
 		];
 	}
 	rows.push(["caused by", causes[0]], ["report", problem?.issues && paint("cyan", problem.issues)]);
-	const details = [...frame, ...rows.flatMap(([name, value]) => value ? [`  ${label(name)} ${value}`] : [])];
+	const codeFrame = (position?.frame ?? []).map((line) => `    ${line}`);
+	const details = [...frame, ...rows.flatMap(([name, value]) => value ? [`  ${label(name)} ${value}`, ...name === "at" ? codeFrame : []] : [])];
 	if (frames?.length) details.push(`  ${paint("dim", "stack")}`, ...frames);
 	if (code !== diagnosticCode.unknown) details.push(`  ${paint("dim", "↳ Learn more")}  ${paint("cyan", Diagnostics.docsUrl(code).replace(/^https:\/\//, ""))}`);
-	return [headline, ...details];
+	return [...headline, ...details];
 }
 //#endregion
 //#region src/Diagnostics.ts
@@ -840,6 +877,7 @@ const failedCode = {
 	parser: diagnosticCode.parserFailed
 };
 const docsByCode = new Map(Object.values(diagnosticCatalog).map((doc) => [doc.code, doc]));
+const reporterKey = Symbol.for("kubb.diagnostics.reporter");
 const countKey = {
 	error: "errors",
 	warning: "warnings",
@@ -849,13 +887,13 @@ const countKey = {
 * Static helpers for working with {@link Diagnostic}s, plus the run-scoped sink
 * that lets deep code report a diagnostic without threading a callback.
 *
-* The sink lives in a single `AsyncLocalStorage` in the `@kubb/core` bundle.
+* The sink lives in a single `AsyncLocalStorage` on `globalThis`, shared by every copy of `@kubb/core`.
 * `Diagnostics.scope` activates it for a run, so anything inside that run (the
 * adapter parse, a generator) reports through `Diagnostics.report` and lands
 * in the same run.
 */
 var Diagnostics = class Diagnostics {
-	static #reporterStorage = new node_async_hooks.AsyncLocalStorage();
+	static #reporterStorage = globalThis[reporterKey] ??= new node_async_hooks.AsyncLocalStorage();
 	/**
 	* The diagnostic code catalog, exposed as `Diagnostics.code` (e.g. `Diagnostics.code.refNotFound`).
 	*/
@@ -1198,7 +1236,7 @@ function defineExtension(definition) {
 					return Object.assign(build(options), {
 						name: meta.name,
 						meta,
-						options
+						options: raw
 					});
 				}
 			});
@@ -1711,7 +1749,8 @@ var Resolver = class Resolver {
 	#resolvePath({ baseName, tag, path: groupPath, root, output, group }) {
 		if (output.mode !== "directory") return node_path.default.resolve(root, output.path);
 		const outputDir = node_path.default.resolve(root, output.path);
-		const result = group && (groupPath || tag) ? node_path.default.resolve(outputDir, Resolver.#resolveGroupDir(group, group.type === "path" ? groupPath : tag), baseName) : node_path.default.resolve(outputDir, baseName);
+		const groupValue = group?.type === "path" ? groupPath : tag;
+		const result = group && groupValue ? node_path.default.resolve(outputDir, Resolver.#resolveGroupDir(group, groupValue), baseName) : node_path.default.resolve(outputDir, baseName);
 		assertInside({
 			target: result,
 			parent: outputDir,
@@ -1952,10 +1991,7 @@ function runParser(parser, print) {
 * Reads a `copy` file and prints it through the parser's `copy` hook, or verbatim with `banner`/`footer` when there is none.
 */
 async function parseCopy(file, parser) {
-	let content;
-	try {
-		content = await (0, node_fs_promises.readFile)(file.copy, "utf8");
-	} catch (err) {
+	const content = await (0, node_fs_promises.readFile)(file.copy, "utf8").catch((err) => {
 		throw new Diagnostics.Error({
 			code: Diagnostics.code.pluginFailed,
 			severity: "error",
@@ -1963,7 +1999,7 @@ async function parseCopy(file, parser) {
 			help: "Check that the file a plugin copies into the output exists and is readable.",
 			cause: toError(err)
 		});
-	}
+	});
 	if (parser?.copy) return runParser(parser, () => parser.parse(_kubb_ast.ast.factory.createFile(parser.copy(file, content))));
 	return [
 		file.banner,
@@ -1977,9 +2013,9 @@ function mergeFile(a, b) {
 		banner: b.banner,
 		footer: b.footer,
 		copy: b.copy ?? a.copy,
-		sources: a.sources.length ? b.sources.length ? [...a.sources, ...b.sources] : a.sources : b.sources,
-		imports: a.imports.length ? b.imports.length ? [...a.imports, ...b.imports] : a.imports : b.imports,
-		exports: a.exports.length ? b.exports.length ? [...a.exports, ...b.exports] : a.exports : b.exports
+		sources: [...a.sources, ...b.sources],
+		imports: [...a.imports, ...b.imports],
+		exports: [...a.exports, ...b.exports]
 	};
 }
 function isIndexPath(path) {
@@ -1988,17 +2024,49 @@ function isIndexPath(path) {
 function compareFiles(a, b) {
 	return a.path.length - b.path.length || Number(isIndexPath(a.path)) - Number(isIndexPath(b.path));
 }
-function isUnchanged({ stored, source, key, manifest }) {
-	if (stored === null) return false;
-	if (matchesStored({
+/**
+* Writes `source` to `file.path` unless the storage already holds it, either verbatim or, per the
+* manifest, as what the output passes make of it. Checking here rather than in a driver gives a
+* storage writing to S3 or a database the same guarantee `fsStorage` has. `false` when skipped.
+*/
+async function writeChanged({ storage, manifest, file, source, signal }) {
+	signal?.throwIfAborted();
+	const stored = await storage.readItem(file.path);
+	if (stored !== null && (matchesStored({
 		stored,
 		source
-	})) return true;
-	return manifest?.isUpToDate({
-		key,
+	}) || manifest?.isUpToDate({
+		key: file.path,
 		source,
 		disk: stored
-	}) ?? false;
+	}))) return false;
+	signal?.throwIfAborted();
+	await storage.writeItem(file.path, source, { stored });
+	manifest?.track({
+		key: file.path,
+		source
+	});
+	return true;
+}
+/** Reports finished files in input order: each finished file flushes the run of finished files ahead of it as one update. */
+function createProgress(files, config, hooks) {
+	const finished = [];
+	let flushed = 0;
+	return async (index) => {
+		finished[index] = true;
+		const updates = [];
+		while (finished[flushed]) {
+			flushed++;
+			updates.push({
+				file: files[flushed - 1],
+				processed: flushed,
+				total: files.length,
+				percentage: flushed / files.length * 100,
+				config
+			});
+		}
+		if (updates.length) await hooks.callHook("kubb:files:processing:update", { files: updates });
+	};
 }
 /**
 * In-memory file store for generated files, and the writer that turns them into source
@@ -2043,25 +2111,17 @@ var FileManager = class {
 		}
 	}
 	#store(files, mergeExisting) {
-		const batch = files.length > 1 ? this.#dedupe(files) : files;
-		const resolved = [];
-		for (const file of batch) {
+		const batch = /* @__PURE__ */ new Set();
+		const resolved = files.map((file) => {
 			const existing = this.#cache.get(file.path);
-			const merged = existing && mergeExisting ? _kubb_ast.ast.factory.createFile(mergeFile(existing, file)) : _kubb_ast.ast.factory.createFile(file);
+			const merged = _kubb_ast.ast.factory.createFile(existing && (mergeExisting || batch.has(file.path)) ? mergeFile(existing, file) : file);
 			this.#cache.set(merged.path, merged);
-			resolved.push(merged);
-		}
+			batch.add(merged.path);
+			return merged;
+		});
 		if (resolved.length > 0) this.#sorted = null;
 		return resolved;
 	}
-	#dedupe(files) {
-		const seen = /* @__PURE__ */ new Map();
-		for (const file of files) {
-			const prev = seen.get(file.path);
-			seen.set(file.path, prev ? mergeFile(prev, file) : file);
-		}
-		return [...seen.values()];
-	}
 	/**
 	* Releases all stored files. Called by the core after `kubb:build:end`.
 	*/
@@ -2089,50 +2149,38 @@ var FileManager = class {
 	* Parses and writes every file through a bounded pool of workers. A small spec runs all its files
 	* at once; a spec with thousands of files keeps at most {@link FILE_CONCURRENCY} parsed sources in
 	* memory rather than holding every source, while still overlapping each file's write with the
-	* next file's parse. Files finish in whatever order they parse, so the update rows are sorted back
-	* into input order before `kubb:files:processing:update` fires once with the whole batch.
+	* next file's parse. Files finish in whatever order they parse, so each finished file flushes the
+	* run of finished files ahead of it as one `kubb:files:processing:update`, keeping rows in input order.
 	*
 	* A file the storage already holds is skipped, so a rebuild that generates identical output
-	* writes nothing and leaves every mtime where it was.
+	* writes nothing and leaves every mtime where it was. `kubb:files:processing:end` lists the
+	* skipped paths as `unchanged`.
 	*/
 	async write(files, { storage, parsers, manifest, signal, hooks, config }) {
 		if (files.length === 0) return;
 		await hooks?.callHook("kubb:files:processing:start", { files });
-		const total = files.length;
-		const updates = [];
+		const unchanged = [];
+		const progress = hooks && config ? createProgress(files, config, hooks) : void 0;
 		await inParallel({
 			items: files,
 			limit: 50,
 			run: async (file, index) => {
 				signal?.throwIfAborted();
 				const source = await this.parse(file, { parsers });
-				if (config) updates.push({
+				if (source && !await writeChanged({
+					storage,
+					manifest,
 					file,
-					processed: index + 1,
-					total,
-					percentage: (index + 1) / total * 100,
-					config
-				});
-				if (!source) return;
-				signal?.throwIfAborted();
-				const stored = await storage.readItem(file.path);
-				if (isUnchanged({
-					stored,
 					source,
-					key: file.path,
-					manifest
-				})) return;
-				signal?.throwIfAborted();
-				await storage.writeItem(file.path, source, { stored });
-				manifest?.track({
-					key: file.path,
-					source
-				});
+					signal
+				})) unchanged.push(file.path);
+				await progress?.(index);
 			}
 		});
-		updates.sort((a, b) => a.processed - b.processed);
-		await hooks?.callHook("kubb:files:processing:update", { files: updates });
-		await hooks?.callHook("kubb:files:processing:end", { files });
+		await hooks?.callHook("kubb:files:processing:end", {
+			files,
+			unchanged
+		});
 	}
 };
 //#endregion
@@ -2460,10 +2508,15 @@ var KubbDriver = class {
 					plugin.options = normalizePluginOptions(plugin.options, plugin.name);
 				}
 				if (this.adapter && this.inputNode) {
+					const { meta, schemas, operations } = this.inputNode;
 					const buildStartContext = this.#withFiles({
 						config,
 						adapter: this.adapter,
-						meta: this.inputNode.meta,
+						meta,
+						nodeCounts: {
+							schemas: schemas.length,
+							operations: operations.length
+						},
 						getPlugin: this.getPlugin.bind(this)
 					});
 					await hooks.callHook("kubb:build:start", buildStartContext);
@@ -2748,7 +2801,10 @@ var KubbDriver = class {
 		}
 		return diagnostics;
 	}
-	/** Runs `node` through the generators whose `match` accepts it; `generate` picks the method for the node kind. */
+	/**
+	* Runs `node` through the generators whose `match` accepts it; `generate` picks the method for the
+	* node kind.
+	*/
 	async #dispatchNode({ generators, node, ctx, generate }) {
 		for (const generator of generators) {
 			if (!(generator.match ? await generator.match(node, ctx) : true)) continue;
@@ -3008,7 +3064,7 @@ const fsStorage = createStorage(() => ({
 	name: "fs",
 	async readItem(key) {
 		try {
-			return await (0, node_fs_promises.readFile)((0, node_path.resolve)(key), "utf8");
+			return await read((0, node_path.resolve)(key));
 		} catch (_error) {
 			return null;
 		}
@@ -3026,10 +3082,7 @@ const fsStorage = createStorage(() => ({
 		const resolvedBase = (0, node_path.resolve)(base ?? process.cwd());
 		const keys = [];
 		try {
-			for await (const entry of (0, node_fs_promises.glob)("**/*", {
-				cwd: resolvedBase,
-				withFileTypes: true
-			})) if (entry.isFile()) keys.push(toPosixPath((0, node_path.relative)(resolvedBase, (0, node_path.join)(entry.parentPath, entry.name))));
+			for await (const path of listFiles(resolvedBase)) keys.push(path);
 		} catch (_error) {}
 		return keys;
 	},
@@ -3075,7 +3128,9 @@ const cacheStorage = createStorage(({ root = process.cwd() }) => {
 	return {
 		name: "cache",
 		readItem: (key) => fs.readItem(toPath(key)),
-		writeItem: (key, value) => fs.writeItem(toPath(key), value),
+		async writeItem(key, value) {
+			await writeRaw(toPath(key), value);
+		},
 		removeItem: (key) => fs.removeItem(toPath(key)),
 		readKeys: (base) => fs.readKeys(base ? toPath(base) : dir),
 		empty: async (base) => base ? fs.empty(toPath(base)) : void 0
@@ -3659,17 +3714,23 @@ const logLevel = {
 * ```
 */
 function createReporter(reporter) {
+	const { name, needsPluginFiles, drain } = reporter;
+	if (!drain) return {
+		name,
+		needsPluginFiles,
+		async report(result, context) {
+			await reporter.report(result, context);
+		}
+	};
 	const reports = [];
 	return {
-		name: reporter.name,
-		needsPluginFiles: reporter.needsPluginFiles,
+		name,
+		needsPluginFiles,
 		async report(result, context) {
-			const report = await reporter.report(result, context);
-			if (reporter.drain) reports.push(report);
+			reports.push(await reporter.report(result, context));
 		},
 		async drain(context) {
-			await reporter.drain?.(context, [...reports]);
-			reports.length = 0;
+			await drain(context, reports.splice(0));
 		}
 	};
 }
@@ -3681,7 +3742,7 @@ function createReporter(reporter) {
 * counts, so every reporter renders the same data.
 */
 function buildReport(result) {
-	const { config, diagnostics, filesCreated, status, hrStart } = result;
+	const { config, diagnostics, filesCreated, filesUnchanged = 0, status, hrStart } = result;
 	const failed = Diagnostics.failedPlugins(diagnostics);
 	const total = config.plugins?.length ?? 0;
 	const counts = Diagnostics.count(diagnostics);
@@ -3700,6 +3761,9 @@ function buildReport(result) {
 		},
 		counts,
 		filesCreated,
+		filesUnchanged,
+		fileChanges: result.fileChanges,
+		dryRun: result.dryRun,
 		durationMs: getElapsedMs(hrStart),
 		output: (0, node_path.resolve)(config.root, config.output.path),
 		timings,
@@ -3709,39 +3773,48 @@ function buildReport(result) {
 //#endregion
 //#region src/reporters/summary.ts
 /**
-* Formats the vitest/jest-style summary for one {@link Report}: right-aligned dim labels with
-* `N passed (total)` counts, and a per-plugin `Timings` section when `showTimings`. Pure, so a host
-* can render the same lines through whatever output it already owns.
+* Puts the outcome first, followed by file counts, labeled plugin results, and the output path.
+* Hosts that collect file changes get a compact diff section. Verbose output adds plugin timings.
 */
 function formatSummary(report, { showTimings }) {
-	const { status, plugins, counts, filesCreated, durationMs, output, timings } = report;
-	const rows = [];
+	const { status, plugins, counts, filesCreated, filesUnchanged, fileChanges, dryRun, durationMs, output, timings } = report;
+	const failed = status === "failed";
+	const successTone = counts.warnings ? "yellow" : "green";
+	const tone = failed ? "red" : successTone;
+	const title = (() => {
+		if (failed) return "✗ Generation failed";
+		if (dryRun) return "◇ Dry run complete";
+		if (counts.warnings) return "✓ Generation complete with warnings";
+		if (filesCreated > 0 && filesCreated === filesUnchanged) return "✓ Already up to date";
+		return "✓ Generation complete";
+	})();
+	const separator = (0, node_util.styleText)("dim", " · ");
+	const generated = Math.max(0, filesCreated - filesUnchanged);
+	const fileLabel = `${generated} ${generated === 1 ? "file" : "files"} ${dryRun ? "planned" : "generated"}`;
+	const lines = [
+		`${(0, node_util.styleText)(tone, title)}  ${(0, node_util.styleText)("dim", formatMs(durationMs))}`,
+		"",
+		`  ${(0, node_util.styleText)(generated ? "bold" : "dim", fileLabel)}${filesUnchanged ? separator + (0, node_util.styleText)("dim", `${filesUnchanged} unchanged`) : ""}`
+	];
 	const notRun = plugins.total - plugins.passed - plugins.failed.length;
-	rows.push(["Plugins", status === "success" ? `${(0, node_util.styleText)("green", `${plugins.passed} passed`)} (${plugins.total})` : [
-		(0, node_util.styleText)("green", `${plugins.passed} passed`),
-		(0, node_util.styleText)("red", `${plugins.failed.length} failed`),
+	const pluginCounts = [
+		plugins.passed > 0 ? (0, node_util.styleText)("green", `${plugins.passed} passed`) : void 0,
+		plugins.failed.length > 0 ? (0, node_util.styleText)("red", `${plugins.failed.length} failed`) : void 0,
 		notRun > 0 ? (0, node_util.styleText)("dim", `${notRun} not run`) : void 0
-	].filter(Boolean).join(" | ") + ` (${plugins.total})`]);
-	if (status === "failed" && plugins.failed.length > 0) rows.push(["Failed", plugins.failed.map((name) => (0, node_util.styleText)("red", name)).join(", ")]);
-	if (counts.errors > 0 || counts.warnings > 0) {
-		const issues = [counts.errors > 0 ? (0, node_util.styleText)("red", `${counts.errors} ${counts.errors === 1 ? "error" : "errors"}`) : void 0, counts.warnings > 0 ? (0, node_util.styleText)("yellow", `${counts.warnings} ${counts.warnings === 1 ? "warning" : "warnings"}`) : void 0].filter(Boolean).join(" | ");
-		rows.push(["Issues", issues]);
-	}
-	rows.push(["Files", `${(0, node_util.styleText)("green", String(filesCreated))} generated`]);
-	rows.push(["Duration", (0, node_util.styleText)("green", formatMs(durationMs))]);
-	rows.push(["Output", output]);
-	const labelWidth = Math.max(...rows.map(([label]) => label.length), timings.length > 0 ? 7 : 0);
-	const lines = rows.map(([label, value]) => `${(0, node_util.styleText)("dim", label.padStart(labelWidth))}  ${value}`);
+	].filter(Boolean);
+	lines.push(`  ${(0, node_util.styleText)("dim", "Plugins")}  ${pluginCounts.join(separator) || (0, node_util.styleText)("dim", "none configured")}`);
+	if (plugins.failed.length) lines.push(`  ${(0, node_util.styleText)("dim", "Failed plugins")}  ${(0, node_util.styleText)("red", plugins.failed.join(", "))}`);
+	const issues = [counts.errors > 0 ? (0, node_util.styleText)("red", `${counts.errors} ${counts.errors === 1 ? "error" : "errors"}`) : void 0, counts.warnings > 0 ? (0, node_util.styleText)("yellow", `${counts.warnings} ${counts.warnings === 1 ? "warning" : "warnings"}`) : void 0].filter(Boolean);
+	if (issues.length) lines.push(`  ${(0, node_util.styleText)("dim", "Issues")}   ${issues.join(separator)}`);
+	const destination = (0, node_path.relative)(process.cwd(), output);
+	const displayPath = destination.startsWith("..") || (0, node_path.isAbsolute)(destination) ? output : `./${destination}`;
+	lines.push(`  ${(0, node_util.styleText)("dim", failed || dryRun ? "Target" : "Output")}   ${(0, node_util.styleText)(failed ? "dim" : "cyan", displayPath)}`);
+	if (dryRun) lines.push(`  ${(0, node_util.styleText)("dim", "Nothing was written.")}`);
+	if (fileChanges) lines.push("", (0, node_util.styleText)("bold", dryRun ? "Planned file changes" : "File changes"), `  ${(0, node_util.styleText)(fileChanges.added ? "green" : "dim", `${fileChanges.added} added`)}${separator}${(0, node_util.styleText)(fileChanges.modified ? "yellow" : "dim", `${fileChanges.modified} modified`)}${separator}${(0, node_util.styleText)(fileChanges.deleted ? "red" : "dim", `${fileChanges.deleted} deleted`)}`, `  ${(0, node_util.styleText)("dim", "Lines")}  ${(0, node_util.styleText)(fileChanges.linesAdded ? "green" : "dim", `+${fileChanges.linesAdded}`)} ${(0, node_util.styleText)(fileChanges.linesRemoved ? "red" : "dim", `−${fileChanges.linesRemoved}`)}`);
 	if (showTimings && timings.length > 0) {
-		const nameWidth = Math.max(0, ...timings.map((timing) => timing.plugin.length));
-		const indent = " ".repeat(labelWidth + 2);
-		lines.push((0, node_util.styleText)("dim", "Timings".padStart(labelWidth)));
-		for (const timing of timings) {
-			const timeStr = formatMs(timing.durationMs);
-			const barLength = Math.min(Math.ceil(timing.durationMs / 100), 10);
-			const bar = (0, node_util.styleText)("dim", "█".repeat(barLength));
-			lines.push(`${indent}${(0, node_util.styleText)("dim", "•")} ${timing.plugin.padEnd(nameWidth)} ${bar} ${timeStr}`);
-		}
+		const nameWidth = Math.max(...timings.map((timing) => timing.plugin.length));
+		lines.push("", (0, node_util.styleText)("dim", "Plugin timings"));
+		for (const timing of timings) lines.push(`  ${timing.plugin.padEnd(nameWidth)}  ${(0, node_util.styleText)("dim", formatMs(timing.durationMs))}`);
 	}
 	return lines;
 }
@@ -4193,6 +4266,7 @@ exports.cliReporter = cliReporter;
 exports.createAdapter = createAdapter;
 exports.createCliReporter = createCliReporter;
 exports.createKubb = createKubb;
+exports.createOutputManifest = createOutputManifest;
 exports.createRenderer = createRenderer;
 exports.createReporter = createReporter;
 exports.createResolver = createResolver;