rolldown-pnpm-config 1.0.11 → 2.0.0

package/cli/cwd.js

@@ -0,0 +1,25 @@
+import { findWorkspaceFile } from "./workspace-file.js";
+import { Context, Effect } from "effect";
+import { join } from "node:path";
+
+//#region src/cli/cwd.ts
+/**
+* The directory the CLI was invoked from. `main.ts` reads `process.cwd()` once
+* and provides it here, so no command reads `process` itself.
+*
+* @internal
+*/
+var WorkingDirectory = class extends Context.Service()("rolldown-pnpm-config/WorkingDirectory") {};
+/**
+* The `pnpm-workspace.yaml` a command targets: the explicit path when given,
+* else the nearest one upward from the working directory, else the working
+* directory's own (to be created).
+*
+* @internal
+*/
+function resolveWorkspacePath(explicit) {
+	return Effect.map(WorkingDirectory, (cwd) => explicit ?? findWorkspaceFile(cwd) ?? join(cwd, "pnpm-workspace.yaml"));
+}
+
+//#endregion
+export { WorkingDirectory, resolveWorkspacePath };

package/cli/diff/render.js

@@ -1,3 +1,6 @@
+import { row, tone } from "../render/tone.js";
+import { Doc } from "@effected/cli";
+
 //#region src/cli/diff/render.ts
 const CONTEXT = 2;
 const GUTTER = {
@@ -6,7 +9,7 @@ const GUTTER = {
 	changed: "~",
 	unchanged: " "
 };
-const STYLE = {
+const TONE = {
 	added: "added",
 	removed: "removed",
 	changed: "changed",
@@ -22,18 +25,11 @@ function flatten(node, depth, inheritedUnmanaged = false) {
 	const tag = node.tag;
 	const changed = node.kind !== "unchanged";
 	const unmanaged = inheritedUnmanaged || node.tag === "unmanaged" && node.kind === "unchanged";
-	const style = node.kind === "unchanged" && unmanaged ? "unmanaged" : STYLE[node.kind];
+	const t = node.kind === "unchanged" && unmanaged ? "unmanaged" : TONE[node.kind];
 	const isArrayEl = node.arrayElement === true;
 	if (node.children) return [{
-		line: {
-			indent,
-			gutter,
-			segments: [{
-				text: `${node.key}:`,
-				style
-			}],
-			...tag ? { tag } : {}
-		},
+		row: row(gutter, indent, [tone(`${node.key}:`, t)], tag),
+		indent,
 		changed
 	}, ...node.children.flatMap((c) => flatten(c, depth + 1, unmanaged))];
 	let text;
@@ -41,28 +37,21 @@ function flatten(node, depth, inheritedUnmanaged = false) {
 	else if (isArrayEl) text = `- ${node.key}`;
 	else text = `${node.key}: ${scalarText(node.after ?? node.before)}`;
 	return [{
-		line: {
-			indent,
-			gutter,
-			segments: [{
-				text,
-				style
-			}],
-			...tag ? { tag } : {}
-		},
+		row: row(gutter, indent, [tone(text, t)], tag),
+		indent,
 		changed
 	}];
 }
 /**
-* Render a diff tree to styled lines in canonical-YAML shape. Default collapses
-* unchanged lines outside a 2-line window around changes into a single
-* "… N unchanged" marker; `full` keeps every line.
+* Render a diff tree to a `Lines` block in canonical-YAML shape. Default
+* collapses unchanged lines outside a 2-line window around changes into a
+* single "… N unchanged" marker; `full` keeps every line.
 *
 * @internal
 */
 function renderExportDiff(root, opts) {
 	const flats = (root.children ?? []).flatMap((c) => flatten(c, 0));
-	if (opts.full) return flats.map((f) => f.line);
+	if (opts.full) return Doc.lines(flats.map((f) => f.row));
 	const keep = new Array(flats.length).fill(false);
 	flats.forEach((f, i) => {
 		if (!f.changed) return;
@@ -70,35 +59,28 @@ function renderExportDiff(root, opts) {
 	});
 	for (let i = 0; i < flats.length; i++) {
 		if (!keep[i]) continue;
-		let depth = flats[i].line.indent;
-		for (let j = i - 1; j >= 0 && depth > 0; j--) if (flats[j].line.indent < depth) {
+		let depth = flats[i].indent;
+		for (let j = i - 1; j >= 0 && depth > 0; j--) if (flats[j].indent < depth) {
 			keep[j] = true;
-			depth = flats[j].line.indent;
+			depth = flats[j].indent;
 		}
 	}
 	const out = [];
 	let dropped = 0;
 	const flushDropped = () => {
 		if (dropped > 0) {
-			out.push({
-				indent: 0,
-				gutter: " ",
-				segments: [{
-					text: `… ${dropped} unchanged`,
-					style: "unchanged"
-				}]
-			});
+			out.push(row(" ", 0, [tone(`… ${dropped} unchanged`, "unchanged")]));
 			dropped = 0;
 		}
 	};
 	flats.forEach((f, i) => {
 		if (keep[i]) {
 			flushDropped();
-			out.push(f.line);
+			out.push(f.row);
 		} else dropped++;
 	});
 	flushDropped();
-	return out;
+	return Doc.lines(out);
 }
 
 //#endregion

package/cli/load-config.js

@@ -1,14 +1,13 @@
+import { parseWorkspace } from "./workspace-file.js";
 import { evaluatePluginConfig } from "./evaluate.js";
-import { findWorkspaceFile, parseWorkspace } from "./workspace-file.js";
 import { Effect, Predicate } from "effect";
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
 
 //#region src/cli/load-config.ts
 /**
 * The prologue shared by `export` and `preview`: read and statically evaluate
-* the config file (failing on a missing call or non-literal values), locate
-* the workspace file, and parse it when present. `mkError` wraps each failure
+* the config file (failing on a missing call or non-literal values), and
+* parse the workspace file when present. `mkError` wraps each failure
 * message in the command's own error type.
 *
 * @internal
@@ -22,7 +21,7 @@ function loadConfigAndWorkspace(opts, mkError) {
 		const { config, errors } = evaluatePluginConfig(configSource, opts.configFile);
 		if (config === null) return yield* Effect.fail(mkError(`No PnpmConfigPlugin call found in ${opts.configFile}`));
 		if (errors.length > 0) return yield* Effect.fail(mkError(`Non-literal config values: ${errors.join("; ")}`));
-		const path = opts.workspacePath ?? findWorkspaceFile(process.cwd()) ?? join(process.cwd(), "pnpm-workspace.yaml");
+		const path = opts.workspacePath;
 		const parsed = existsSync(path) ? yield* Effect.try({
 			try: () => parseWorkspace(readFileSync(path, "utf8")),
 			catch: (e) => mkError(`Cannot read or parse ${path}: ${String(e)}`)

package/cli/main.js

@@ -0,0 +1,37 @@
+import { WorkingDirectory } from "./cwd.js";
+import { rootCommand } from "./root.js";
+import { CLI_VERSION } from "./version.js";
+import { Effect } from "effect";
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { CliAudience, CliRuntime } from "@effected/cli";
+
+//#region src/cli/main.ts
+/**
+* Assemble and run the CLI. One of the three files allowed to read `process`:
+* the working directory, argv for the build-time log format, and stderr's
+* terminal state are read here and passed down as plain values.
+*
+* `CliRuntime.main` builds the audience, terminal and theme from `env`,
+* decides whether the run may prompt, reports every failure on stderr for the
+* run's audience, and maps the exit code (usage 64, cancel 130, otherwise 1).
+*
+* @internal
+*/
+function main() {
+	const program = CliAudience.run(rootCommand, { version: CLI_VERSION }).pipe(Effect.provideService(WorkingDirectory, process.cwd()));
+	NodeRuntime.runMain(CliRuntime.main(program, {
+		platform: NodeServices.layer,
+		helpOnUsageError: "stderr",
+		env: {
+			audienceEnvVar: "ROLLDOWN_PNPM_CONFIG_AUDIENCE",
+			log: {
+				envVar: "ROLLDOWN_PNPM_CONFIG_LOG_LEVEL",
+				argv: process.argv.slice(2)
+			},
+			stderrIsTerminal: Effect.sync(() => process.stderr.isTTY === true)
+		}
+	}));
+}
+
+//#endregion
+export { main };

package/cli/preview-views.js

@@ -1,14 +1,14 @@
+import { canonicalize } from "./workspace-file.js";
 import { buildDiff } from "./diff/build.js";
 import { renderExportDiff } from "./diff/render.js";
 import { effectiveManaged, vanillaManaged } from "./effective.js";
-import { canonicalize } from "./workspace-file.js";
 import { overlayWorkspace } from "./workspace-overlay.js";
 import { WORKSPACE_FIELDS } from "./commands/export.js";
 import { renderSimulated } from "./simulated-view.js";
 
 //#region src/cli/preview-views.ts
 /**
-* Build the three preview views as styled lines: Changes (parsed→merged diff,
+* Build the three preview views as `Doc` blocks: Changes (parsed→merged diff,
 * with local + preserve + excludeByRepo), Full (same tree, full verbosity), and
 * Simulated (the fresh-consumer output rendered as a plain calculated file — not
 * a diff — with per-field merge/overwrite + enforcement annotations).

package/cli/render/legend.js

@@ -0,0 +1,42 @@
+import { tone } from "./tone.js";
+import { Doc } from "@effected/cli";
+
+//#region src/cli/render/legend.ts
+function swatches(entries) {
+	return Doc.line([Doc.text("  Legend:  "), ...entries.map(([label, t], i) => tone(`■ ${label}${i < entries.length - 1 ? "  " : ""}`, t))]);
+}
+/**
+* The colour legend for the config diff (the `preview` command and
+* `export --dry-run`). Each swatch carries the matching tone, so the legend
+* tracks the palette. Printed only when the output is coloured — without
+* colour the swatches are indistinguishable and the legend is noise.
+*
+* @internal
+*/
+function legend() {
+	return swatches([
+		["added", "added"],
+		["removed", "removed"],
+		["modified", "changed"],
+		["unchanged", "unchanged"],
+		["unmanaged", "unmanaged"]
+	]);
+}
+/**
+* The legend for the Simulated view. That view is not a diff — nothing is
+* added or removed — so it has its own vocabulary: how each field is combined
+* (`merge`/`overwrite`) and how divergence is enforced (`warn`/`error`).
+*
+* @internal
+*/
+function simulatedLegend() {
+	return swatches([
+		["merge", "merge"],
+		["overwrite", "overwrite"],
+		["warn", "changed"],
+		["error", "warn"]
+	]);
+}
+
+//#endregion
+export { legend, simulatedLegend };

package/cli/render/print.js

@@ -0,0 +1,50 @@
+import { Effect } from "effect";
+import { CliTheme, Doc } from "@effected/cli";
+import { Audience } from "@effected/env";
+
+//#region src/cli/render/print.ts
+/**
+* Whether stdout is painted for a person: a human audience at a colour level
+* above `none`. A legend is only worth printing then — without colour its
+* swatches are indistinguishable.
+*
+* @internal
+*/
+const coloured = Effect.gen(function* () {
+	const theme = yield* CliTheme;
+	return (yield* Audience).kind === "human" && theme.color !== "none";
+});
+/**
+* Print a document with no width limit, for every audience. Diffs, summaries
+* and package lists are line-oriented data: a hard wrap at a person's width (80
+* when output is piped) would split a row away from its gutter and break a
+* grep. A terminal still soft-wraps a long line when it shows it.
+*
+* @internal
+*/
+function printDoc(doc, options = {}) {
+	return Doc.print(doc, {
+		...options,
+		width: Number.POSITIVE_INFINITY
+	});
+}
+/**
+* Print a diff-shaped view to stdout: an optional heading line, the legend
+* when the output is coloured, then the view. The audience picks the
+* renderer (ANSI for a person, plain for an agent, the GitHub log under
+* Actions).
+*
+* @internal
+*/
+function printView(view, options = {}) {
+	return Effect.gen(function* () {
+		const doc = [];
+		if (options.heading !== void 0) doc.push(Doc.line(options.heading), Doc.line(""));
+		if (options.legend !== void 0 && (yield* coloured)) doc.push(options.legend, Doc.line(""));
+		doc.push(view);
+		yield* printDoc(doc);
+	});
+}
+
+//#endregion
+export { coloured, printDoc, printView };

package/cli/render/report.js

@@ -0,0 +1,38 @@
+import { Doc, Status } from "@effected/cli";
+
+//#region src/cli/render/report.ts
+function statusDoc(status, message) {
+	const [first = "", ...rest] = message.split("\n");
+	const blocks = [Doc.line([
+		Doc.status(Status.core, status),
+		" ",
+		first
+	])];
+	if (rest.length > 0) blocks.push(Doc.verbatim(rest.join("\n")));
+	return blocks;
+}
+/**
+* The failure report for one of the CLI's own errors: a status line carrying
+* the message's first line, then any further lines as they were written (a
+* list of packages, say). Used by each error's `CliDoc` method, so
+* `CliRuntime.main` draws the message without the error class's name.
+*
+* @internal
+*/
+function failureDoc(message) {
+	return statusDoc("failure", message);
+}
+/**
+* A multi-line warning drawn like a failure report but with the warning mark:
+* the first line beside the glyph, the rest as written. For a warning longer
+* than the one line `CliMessage.warning` takes (a list of packages, say);
+* printed to stderr.
+*
+* @internal
+*/
+function warningDoc(message) {
+	return statusDoc("warning", message);
+}
+
+//#endregion
+export { failureDoc, warningDoc };

package/cli/render/tone.js

@@ -0,0 +1,43 @@
+import { Doc, Token } from "@effected/cli";
+
+//#region src/cli/render/tone.ts
+/**
+* The palette: one theme token (or explicit style) per tone. Semantic tones
+* use the theme's tokens so a theme override restyles them; `unmanaged` is a
+* fixed dark gray (distinct from the dim `unchanged`) and `local`/`overwrite`
+* are magenta. `plain` is unstyled.
+*
+* @internal
+*/
+const TONES = {
+	added: "success",
+	removed: "failure",
+	changed: "warning",
+	unchanged: "muted",
+	warn: "failure",
+	local: Token.named("magenta"),
+	unmanaged: Token.hex("#585858"),
+	merge: "accent",
+	overwrite: Token.named("magenta")
+};
+/** A run of text in a tone. @internal */
+function tone(text, t) {
+	return t === "plain" ? Doc.text(text) : Doc.text(text, TONES[t]);
+}
+/**
+* One diff-shaped row: `<gutter><space><2-space indent><content><tag>`. The
+* gutter and the tag are plain characters, so a row keeps its meaning when the
+* renderer drops colour (an agent, a pipe, `NO_COLOR`).
+*
+* @internal
+*/
+function row(gutter, indent, content, tag) {
+	return [
+		Doc.text(`${gutter} ${"  ".repeat(indent)}`),
+		...content,
+		...tag === void 0 ? [] : [tone(`  (${tag})`, tag)]
+	];
+}
+
+//#endregion
+export { TONES, row, tone };

package/cli/root.js

@@ -0,0 +1,22 @@
+import { exportCommand } from "./commands/export.js";
+import { previewCommand } from "./commands/preview.js";
+import { upgradeCommand } from "./commands/upgrade.js";
+import { CliAudience } from "@effected/cli";
+import { Command } from "effect/cli";
+
+//#region src/cli/root.ts
+/**
+* The `rolldown-pnpm-config` command tree, with the audience flags
+* (`--audience`, `--human`, `--agent`, `--ci`) shared from the root so every
+* subcommand accepts them.
+*
+* @internal
+*/
+const rootCommand = Command.make("rolldown-pnpm-config").pipe(Command.withSharedFlags(CliAudience.flags()), Command.withSubcommands([
+	upgradeCommand,
+	exportCommand,
+	previewCommand
+]));
+
+//#endregion
+export { rootCommand };

package/cli/simulated-view.js

@@ -1,5 +1,7 @@
-import { scalarText } from "./diff/render.js";
 import { canonicalize } from "./workspace-file.js";
+import { row, tone } from "./render/tone.js";
+import { scalarText } from "./diff/render.js";
+import { Doc } from "@effected/cli";
 
 //#region src/cli/simulated-view.ts
 /**
@@ -22,14 +24,8 @@ const STRATEGY_VERB = {
 };
 /** The enforcement suffix, e.g. " · warn" / " · error"; empty when silent. */
 function enforcementSegs(e) {
-	if (e === "warn") return [{
-		text: " · warn",
-		style: "changed"
-	}];
-	if (e === "error") return [{
-		text: " · error",
-		style: "warn"
-	}];
+	if (e === "warn") return [tone(" · warn", "changed")];
+	if (e === "error") return [tone(" · error", "warn")];
 	return [];
 }
 /** The trailing "(merge)" / "(overwrite · error)" annotation for one field. */
@@ -37,54 +33,17 @@ function annotation(entry) {
 	if (!entry) return [];
 	const verb = STRATEGY_VERB[entry.strategy] ?? "merge";
 	return [
-		{
-			text: "  (",
-			style: "unchanged"
-		},
-		{
-			text: verb,
-			style: verb
-		},
+		tone("  (", "unchanged"),
+		tone(verb, verb),
 		...enforcementSegs(entry.enforcement),
-		{
-			text: ")",
-			style: "unchanged"
-		}
+		tone(")", "unchanged")
 	];
 }
 /** Flatten one key/value into YAML-shaped plain lines; `ann` annotates the head. */
 function flatten(key, value, depth, ann) {
-	if (Array.isArray(value)) return [{
-		indent: depth,
-		gutter: " ",
-		segments: [{
-			text: `${key}:`,
-			style: "plain"
-		}, ...ann]
-	}, ...value.map((el) => ({
-		indent: depth + 1,
-		gutter: " ",
-		segments: [{
-			text: `- ${scalarText(el)}`,
-			style: "plain"
-		}]
-	}))];
-	if (value !== null && typeof value === "object") return [{
-		indent: depth,
-		gutter: " ",
-		segments: [{
-			text: `${key}:`,
-			style: "plain"
-		}, ...ann]
-	}, ...Object.entries(value).flatMap(([k, v]) => flatten(k, v, depth + 1, []))];
-	return [{
-		indent: depth,
-		gutter: " ",
-		segments: [{
-			text: `${key}: ${scalarText(value)}`,
-			style: "plain"
-		}, ...ann]
-	}];
+	if (Array.isArray(value)) return [row(" ", depth, [tone(`${key}:`, "plain"), ...ann]), ...value.map((el) => row(" ", depth + 1, [tone(`- ${scalarText(el)}`, "plain")]))];
+	if (value !== null && typeof value === "object") return [row(" ", depth, [tone(`${key}:`, "plain"), ...ann]), ...Object.entries(value).flatMap(([k, v]) => flatten(k, v, depth + 1, []))];
+	return [row(" ", depth, [tone(`${key}: ${scalarText(value)}`, "plain"), ...ann])];
 }
 /**
 * Render the Simulated view: the calculated fresh-consumer config as a plain
@@ -96,7 +55,7 @@ function flatten(key, value, depth, ann) {
 */
 function renderSimulated(vanilla, manifest) {
 	const canon = canonicalize(vanilla);
-	return Object.entries(canon).flatMap(([k, v]) => flatten(k, v, 0, annotation(manifest[k])));
+	return Doc.lines(Object.entries(canon).flatMap(([k, v]) => flatten(k, v, 0, annotation(manifest[k]))));
 }
 
 //#endregion

package/cli/summary.js

@@ -1,16 +1,17 @@
-import { toAnsi } from "./ui/ansi.js";
-import { displayCandidates, peerFor, tableLayout } from "./walk-reducer.js";
+import { row, tone } from "./render/tone.js";
+import { cellTone, displayCandidates, peerFor, tableLayout } from "./walk-reducer.js";
+import { Doc } from "@effected/cli";
 
 //#region src/cli/summary.ts
 /**
-* Build the pending-decisions summary as styled lines: one table row per
+* Build the pending-decisions summary as a document: one table row per
 * decision — mirroring the interactive selection table, catalog headers,
 * chosen bubble filled — then a dim tally, interop conflicts, and any
-* rejected edits. Pure; color is applied by `renderSummary`/`toAnsi`.
+* rejected edits. Pure; the renderer the audience picks decides colour.
 *
 * @internal
 */
-function summaryLines(decisions, interop, rejected) {
+function summaryDoc(decisions, interop, rejected) {
 	const lines = [];
 	let toUpdate = 0;
 	let major = 0;
@@ -23,49 +24,18 @@ function summaryLines(decisions, interop, rejected) {
 		const { entry } = item;
 		if (entry.catalog !== lastCatalog) {
 			lastCatalog = entry.catalog;
-			lines.push({
-				indent: 0,
-				gutter: " ",
-				segments: [{
-					text: `── catalog: ${entry.catalog} ──`,
-					style: "unchanged"
-				}]
-			});
+			lines.push(row(" ", 0, [tone(`── catalog: ${entry.catalog} ──`, "unchanged")]));
 		}
 		const cells = displayCandidates(item);
-		const segments = [{
-			text: entry.pkg.padEnd(pkgWidth + 2),
-			style: "plain"
-		}];
+		const content = [tone(entry.pkg.padEnd(pkgWidth + 2), "plain")];
 		for (const c of cells) {
 			const selected = c.kind === chosen.kind;
-			const style = !selected ? "unchanged" : c.kind === "keep" ? "unchanged" : c.isMajor ? "changed" : "added";
-			segments.push({
-				text: cellText(c, selected),
-				style
-			});
+			content.push(tone(cellText(c, selected), cellTone(c, selected) ?? "unchanged"));
 		}
-		for (let ci = cells.length; ci < maxCells; ci++) segments.push({
-			text: blankCell,
-			style: "plain"
-		});
-		segments.push({
-			text: `│ ${peerFor(item, chosen)}`,
-			style: "unchanged"
-		});
-		lines.push({
-			indent: 0,
-			gutter: chosen.kind === "keep" ? " " : "~",
-			segments
-		});
-		if (item.peerWarning) lines.push({
-			indent: 1,
-			gutter: "⚠",
-			segments: [{
-				text: item.peerWarning.message,
-				style: "warn"
-			}]
-		});
+		for (let ci = cells.length; ci < maxCells; ci++) content.push(tone(blankCell, "plain"));
+		content.push(tone(`│ ${peerFor(item, chosen)}`, "unchanged"));
+		lines.push(row(chosen.kind === "keep" ? " " : "~", 0, content));
+		if (item.peerWarning) lines.push(row("⚠", 1, [tone(item.peerWarning.message, "warn")]));
 		if (chosen.kind !== "keep") {
 			toUpdate++;
 			if (chosen.isMajor) major++;
@@ -74,59 +44,12 @@ function summaryLines(decisions, interop, rejected) {
 		else if (!entry.peer && item.materializePeer) materialize++;
 		else upToDate++;
 	}
-	lines.push({
-		indent: 0,
-		gutter: " ",
-		segments: [{
-			text: `${toUpdate} to update · ${major} major · ${resync} resync · ${materialize} new peer · ${upToDate} up to date`,
-			style: "unchanged"
-		}]
-	});
-	if (interop) for (const c of interop.conflicts) lines.push({
-		indent: 0,
-		gutter: "⚠",
-		segments: [{
-			text: `${c.pkg} (kept ${c.ceiling}) blocked by ${c.blockedBy}`,
-			style: "warn"
-		}]
-	});
-	if (rejected && rejected.length > 0) {
-		lines.push({
-			indent: 0,
-			gutter: " ",
-			segments: [{
-				text: "",
-				style: "plain"
-			}]
-		});
-		lines.push({
-			indent: 0,
-			gutter: "⚠",
-			segments: [{
-				text: "Rejected (no published version satisfies these):",
-				style: "warn"
-			}]
-		});
-		for (const r of rejected) lines.push({
-			indent: 1,
-			gutter: "⚠",
-			segments: [{
-				text: `${r.pkg} ${r.kind} ${r.value} — ${r.reason}`,
-				style: "warn"
-			}]
-		});
-	}
-	return lines;
-}
-/**
-* Render the summary to a string. Color defaults off so non-TTY/test callers
-* get clean text; the upgrade command passes the detected color flag.
-*
-* @internal
-*/
-function renderSummary(decisions, interop, opts, rejected) {
-	return toAnsi(summaryLines(decisions, interop, rejected), { color: opts?.color ?? false });
+	lines.push(row(" ", 0, [tone(`${toUpdate} to update · ${major} major · ${resync} resync · ${materialize} new peer · ${upToDate} up to date`, "unchanged")]));
+	if (interop) for (const c of interop.conflicts) lines.push(row("⚠", 0, [tone(`${c.pkg} (kept ${c.ceiling}) blocked by ${c.blockedBy}`, "warn")]));
+	const blocks = [Doc.lines(lines)];
+	if (rejected && rejected.length > 0) blocks.push(Doc.line(""), Doc.lines([row("⚠", 0, [tone("Rejected (no published version satisfies these):", "warn")]), ...rejected.map((r) => row("⚠", 1, [tone(`${r.pkg} ${r.kind} ${r.value} — ${r.reason}`, "warn")]))]));
+	return blocks;
 }
 
 //#endregion
-export { renderSummary, summaryLines };
+export { summaryDoc };