rolldown-pnpm-config 1.0.11 → 2.0.0

package/cli/commands/upgrade.js

@@ -1,8 +1,11 @@
 import { bareVersion } from "../../semver-util.js";
+import { WorkingDirectory } from "../cwd.js";
 import { evaluatePluginConfig } from "../evaluate.js";
+import { printDoc } from "../render/print.js";
+import { failureDoc, warningDoc } from "../render/report.js";
 import { discoverCatalogEntries } from "../discover.js";
 import { filterEntriesByCatalog, findConfigFiles, pickConfigCandidate } from "../select-file.js";
-import { detectCapabilities } from "../ui/env.js";
+import { walkScreen, withProgress } from "../ui/screens.js";
 import { versionKeyOf } from "../version-key.js";
 import { buildEdits, entryEdits } from "../edits.js";
 import { buildInteropEdits, interopEntryChanged, makePeerFetcher, runInterop } from "../interop.js";
@@ -12,15 +15,16 @@ import { defaultPick, planEntry } from "../plan.js";
 import { parsePnpmGate, readConfigReleaseAge } from "../release-age.js";
 import { RegistryResolver, RegistryResolverLive } from "../resolve.js";
 import { applyEdits } from "../rewrite.js";
-import { renderSummary } from "../summary.js";
+import { summaryDoc } from "../summary.js";
 import { validateEdits } from "../validate.js";
 import { buildWalkItems } from "../walk-plan.js";
 import { findWorkspaceRoot, makeWorkspaceResolver } from "../workspace-resolve.js";
-import { Data, Effect, Option, Result } from "effect";
+import { Console, Data, Effect, Option, Result, Runtime } from "effect";
 import { readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
-import { NodeServices } from "@effect/platform-node";
+import { CliDoc, CliExit, CliInteractive, CliMessage, Doc } from "@effected/cli";
 import { Argument, Command, Flag } from "effect/cli";
+import { CliUi } from "@effected/cli/ui";
 import { ReleaseAgeGate } from "@effected/npm";
 
 //#region src/cli/commands/upgrade.ts
@@ -29,7 +33,45 @@ import { ReleaseAgeGate } from "@effected/npm";
 *
 * @internal
 */
-var UpgradeError = class extends Data.TaggedError("UpgradeError") {};
+var UpgradeError = class extends Data.TaggedError("UpgradeError") {
+	/** The failure report `CliRuntime.main` prints: the message, without the class name. */
+	[CliDoc]() {
+		return failureDoc(this.message);
+	}
+};
+/**
+* An invalid flag combination: a usage error, so it exits 64 (BSD
+* `EX_USAGE`) rather than the 1 a resolution failure exits with.
+*
+* @internal
+*/
+var UpgradeUsageError = class extends Data.TaggedError("UpgradeUsageError") {
+	[Runtime.errorExitCode] = 64;
+	/** The failure report `CliRuntime.main` prints: the message, without the class name. */
+	[CliDoc]() {
+		return failureDoc(this.message);
+	}
+};
+/** The heading of `--check`'s resolution-failure report. @internal */
+const CHECK_FAILED_LABEL = "Catalog check failed before drift could be evaluated (resolution error, not drift):";
+function indent(message) {
+	return message.split("\n").map((l) => `  ${l}`).join("\n");
+}
+/**
+* `--check`'s resolution failure: the run could not get far enough to say
+* whether the catalogs drifted. It shares `--check`'s non-zero exit with
+* drift, so its report names the failure family — a gate consuming the exit
+* code reports every non-zero as "drifted", and without the label the CI log
+* would blame drift for a typo'd package or an auth failure.
+*
+* @internal
+*/
+var CheckFailedError = class extends Data.TaggedError("CheckFailedError") {
+	/** The failure report: the family label, then the underlying message indented. */
+	[CliDoc]() {
+		return failureDoc(`${CHECK_FAILED_LABEL}\n${indent(this.message)}`);
+	}
+};
 /** Read a config file and statically discover its catalog entries. @internal */
 function readCatalogSource(file) {
 	return Effect.gen(function* () {
@@ -67,9 +109,9 @@ const RESOLVE_CONCURRENCY = 12;
 * registry-sourced in another, and the two routes must neither share a version
 * list nor a gate exemption.
 *
-* @param onProgress - Optional callback invoked after each package resolves with
-*   `(resolved, total)`. Useful for emitting CLI progress feedback. Called with
-*   `(0, total)` before any work starts so callers can emit the initial banner.
+* @param onProgress - Optional reporter run after each package resolves with
+*   `(resolved, total)`, for CLI progress feedback. Run with `(0, total)`
+*   before any work starts so callers can begin the phase.
 * @param workspace - Optional workspace-backed resolver. An entry whose
 *   `source` is `"workspace"` resolves through it instead of the registry, and
 *   is EXEMPT from the release-age gate: its next version is unpublished, so
@@ -85,12 +127,12 @@ function resolveGatedVersions(entries, resolver, gate, now, onProgress, workspac
 	});
 	const total = pairs.size;
 	let resolved = 0;
-	onProgress?.(0, total);
-	return Effect.forEach([...pairs], ([key, { pkg, fromWorkspace }]) => Effect.gen(function* () {
+	const report = onProgress ?? (() => Effect.void);
+	return Effect.andThen(report(0, total), () => Effect.forEach([...pairs], ([key, { pkg, fromWorkspace }]) => Effect.gen(function* () {
 		const routed = fromWorkspace && workspace !== void 0 ? workspace : resolver;
 		const needTimes = !fromWorkspace && gate.ageMinutes > 0;
 		const [vr, times] = yield* Effect.all([routed.versions(pkg).pipe(Effect.result), needTimes ? resolver.times(pkg).pipe(Effect.orElseSucceed(() => ({}))) : Effect.succeed({})], { concurrency: "unbounded" });
-		onProgress?.(++resolved, total);
+		yield* report(++resolved, total);
 		if (Result.isFailure(vr)) return [
 			key,
 			pkg,
@@ -113,22 +155,37 @@ function resolveGatedVersions(entries, resolver, gate, now, onProgress, workspac
 		gated: new Map(rows.map(([key, , gated]) => [key, gated])),
 		raw: new Map(rows.map(([key, , , raw]) => [key, raw])),
 		unresolved: [...new Set(rows.filter(([, , , raw]) => raw.length === 0).map(([, pkg]) => pkg))]
-	})));
+	}))));
 }
 /**
-* Write a resolve-progress line to stderr. Overwrites the previous line with
-* ANSI carriage return so the terminal shows a single updating counter instead
-* of a flood of lines. The initial call (resolved === 0) writes a newline so
-* the first subsequent overwrite lands on its own line.
-*
-* Only call when caps.interactive is true; this function is not gated itself.
+* Adapt a progress-event reporter to `resolveGatedVersions`' `(resolved,
+* total)` callback: the first call begins the resolve phase, each later one
+* steps it, and the last finishes it, so the live view commits a
+* "Resolved N packages" line as soon as resolution is done.
 *
 * @internal
 */
-function writeResolveProgress(resolved, total) {
-	if (resolved === 0) process.stderr.write(`Resolving ${total} package${total === 1 ? "" : "s"}...\n`);
-	else if (resolved === total) process.stderr.write(`\r  Resolved ${resolved}/${total}      \n`);
-	else process.stderr.write(`\r  Resolved ${resolved}/${total}`);
+function resolveProgress(report) {
+	const noun = (n) => `${n} package${n === 1 ? "" : "s"}`;
+	const finished = (total) => report({
+		_tag: "Finished",
+		label: `Resolved ${noun(total)}`
+	});
+	return (resolved, total) => {
+		if (resolved === 0) {
+			const begin = report({
+				_tag: "Phase",
+				label: `Resolving ${noun(total)}`,
+				total
+			});
+			return total === 0 ? Effect.andThen(begin, finished(total)) : begin;
+		}
+		const step = report({
+			_tag: "Step",
+			done: resolved
+		});
+		return resolved === total ? Effect.andThen(step, finished(total)) : step;
+	};
 }
 /**
 * Non-interactive upgrade core: read the config, discover catalog entries,
@@ -275,7 +332,7 @@ function applyInteropAndDecisions(file, source, nonInteropEdits, interopEdits) {
 * @internal
 */
 function nothingToUpgradeMessage(totalItems) {
-	return totalItems === 0 ? "Nothing to upgrade — no catalog packages found.\n" : `Nothing to upgrade — ${totalItems} package(s) already up to date.\n`;
+	return totalItems === 0 ? "Nothing to upgrade — no catalog packages found." : `Nothing to upgrade — ${totalItems} package(s) already up to date.`;
 }
 /**
 * The message for packages the registry could not resolve. Almost always a
@@ -320,49 +377,51 @@ function projectDecisions(items, full) {
 	}
 	return out;
 }
-/** Build the colored preview summary string without writing. @internal */
+/**
+* Build the `--preview` projection without writing: the summary document, and
+* the packages the registry could not resolve (which render as up to date and
+* would otherwise be invisible in the projection).
+*
+* @internal
+*/
 function runUpgradePreview(opts) {
 	return Effect.gen(function* () {
 		const { source, entries } = yield* readCatalogSource(opts.file);
 		const gate = yield* computeGate(source, opts.file, opts.resolver);
 		const versions = yield* resolveGatedVersions(entries, opts.resolver, gate, Date.now(), void 0, opts.workspaceResolver);
 		const items = yield* buildWalkItems(entries, versions.gated).pipe(Effect.mapError((e) => new UpgradeError({ message: e.message })));
-		const text = renderSummary(projectDecisions(items, opts.full), void 0, { color: opts.color ?? false });
-		return versions.unresolved.length > 0 ? `${text}\n⚠ ${unresolvedMessage(versions.unresolved)}` : text;
+		return {
+			doc: summaryDoc(projectDecisions(items, opts.full)),
+			unresolved: versions.unresolved
+		};
 	});
 }
 /**
-* Map a check run's drift list to the process outcome. `--check` is a pure
-* gate: exit 0 when every entry is in sync, exit 1 when an `upgrade --yes`
-* would rewrite anything — the exit code IS the contract (a release
-* validation phase calls this), and it never writes.
+* Map a check run's drift list to its report and exit code. `--check` is a
+* pure gate: exit 0 when every entry is in sync, exit 1 when an
+* `upgrade --yes` would rewrite anything — the exit code IS the contract (a
+* release validation phase calls this), and it never writes. Drift is a
+* finding, not a failure: the command succeeds and records the code with
+* `CliExit.set`.
 *
 * @internal
 */
 function checkOutcome(changed) {
 	if (changed.length === 0) return {
 		exitCode: 0,
-		text: "Catalogs are in sync.\n"
-	};
-	const list = changed.map((c) => `  ${c.name}  (${c.source})`).join("\n");
-	return {
-		exitCode: 1,
-		text: `Catalog drift detected in ${changed.length} package(s):\n${list}\nRun \`rolldown-pnpm-config upgrade --yes\` to apply.\n`
+		doc: [Doc.line("Catalogs are in sync.")]
 	};
-}
-/**
-* Map a check run's FAILURE (a resolution failure or peer warning — an
-* UpgradeError, not drift) to the process outcome. Shares --check's single
-* non-zero exit code with drift, so the OUTPUT must name the failure family:
-* a gate consuming the exit code reports every non-zero as "drifted", and
-* without this label the CI log lies about a typo'd package or auth failure.
-*
-* @internal
-*/
-function checkFailureOutcome(message) {
 	return {
 		exitCode: 1,
-		text: `Catalog check failed before drift could be evaluated (resolution error, not drift):\n${message.split("\n").map((l) => `  ${l}`).join("\n")}\n`
+		doc: [
+			Doc.line(`Catalog drift detected in ${changed.length} package(s):`),
+			Doc.lines(changed.map((c) => `  ${c.name}  (${c.source})`)),
+			Doc.line([
+				"Run ",
+				Doc.code("rolldown-pnpm-config upgrade --yes"),
+				" to apply."
+			])
+		]
 	};
 }
 /** Project a drift row to its stable `--json` object: catalog/pkg/from/to?/source, camelCase, `to` omitted (never null) when unknown. */
@@ -375,44 +434,43 @@ function driftRowJson(row) {
 		source: row.source
 	};
 }
-/** Serialize one single-line JSON document, newline-terminated — the ONLY bytes `--json` puts on stdout. */
-function jsonLine(doc) {
-	return `${JSON.stringify(doc)}\n`;
-}
 /**
 * The `--check --json` outcome. stdout carries exactly one single-line JSON
-* document in EVERY case — including the resolution-failure family, which
-* keeps its non-zero exit but must never leave a bash gate with exit 1 and an
-* empty stdout. The human failure label stays on stderr; the in-sync/drift
-* text is superseded by the document.
+* document (`json`, written with `Console.log`) in EVERY case — including the
+* resolution-failure family, which keeps its non-zero exit but must never
+* leave a bash gate with exit 1 and an empty stdout. A resolution failure is
+* also returned as `failure`, which the command fails with so the labelled
+* human report lands on stderr.
 *
 * @internal
 */
 function checkJsonOutcome(result) {
 	if (Result.isFailure(result)) {
-		const message = result.failure.message;
+		const { message, kind } = result.failure;
 		return {
 			exitCode: 1,
-			stdout: jsonLine({
+			json: JSON.stringify({
 				command: "check",
 				inSync: false,
 				error: {
-					kind: result.failure.kind ?? "resolution",
+					kind: kind ?? "resolution",
 					message
 				}
 			}),
-			stderr: checkFailureOutcome(message).text
+			failure: new CheckFailedError({
+				message,
+				...kind !== void 0 ? { kind } : {}
+			})
 		};
 	}
 	const changed = result.success.changed;
 	return {
 		exitCode: changed.length === 0 ? 0 : 1,
-		stdout: jsonLine({
+		json: JSON.stringify({
 			command: "check",
 			inSync: changed.length === 0,
 			drift: changed.map(driftRowJson)
-		}),
-		stderr: ""
+		})
 	};
 }
 /**
@@ -420,62 +478,59 @@ function checkJsonOutcome(result) {
 * the run wrote at least one change — always false under dry-run AND on an
 * already-in-sync run, so a consumer keying on it never reads a no-op as a
 * real apply; `changed` uses the same row object as check's `drift`. A failure
-* emits an error document on stdout with a non-zero exit and the human message
-* on stderr; `error.kind` is `"peer-strategy"` for a peer-strategy refusal and
-* `"resolution"` otherwise.
+* emits an error document on stdout and is returned as `failure`, which the
+* command fails with (non-zero exit, human message on stderr); `error.kind` is
+* `"peer-strategy"` for a peer-strategy refusal and `"resolution"` otherwise.
 *
 * @internal
 */
 function upgradeJsonOutcome(result, dryRun) {
 	if (Result.isFailure(result)) {
-		const message = result.failure.message;
+		const { message, kind } = result.failure;
 		return {
-			exitCode: 1,
-			stdout: jsonLine({
+			json: JSON.stringify({
 				command: "upgrade",
 				applied: false,
 				error: {
-					kind: result.failure.kind ?? "resolution",
+					kind: kind ?? "resolution",
 					message
 				}
 			}),
-			stderr: `${message}\n`
+			failure: result.failure
 		};
 	}
 	const r = result.success;
-	return {
-		exitCode: 0,
-		stdout: jsonLine({
-			command: "upgrade",
-			applied: !dryRun && r.updated > 0,
-			updated: r.updated,
-			changed: r.changed.map(driftRowJson),
-			skipped: r.skipped,
-			conflicts: r.conflicts.map((c) => ({
-				pkg: c.pkg,
-				ceiling: c.ceiling,
-				blockedBy: c.blockedBy
-			}))
-		}),
-		stderr: ""
-	};
+	return { json: JSON.stringify({
+		command: "upgrade",
+		applied: !dryRun && r.updated > 0,
+		updated: r.updated,
+		changed: r.changed.map(driftRowJson),
+		skipped: r.skipped,
+		conflicts: r.conflicts.map((c) => ({
+			pkg: c.pkg,
+			ceiling: c.ceiling,
+			blockedBy: c.blockedBy
+		}))
+	}) };
 }
 /**
 * Reject `--json` outside the non-interactive modes it exists for. JSON mode
 * is a machine contract (a GitHub Action parsing stdout from bash); the
 * interactive table and the preview views have no meaningful document to emit.
-* Returns the rejection to fail with, or null when the combination is valid.
+* Returns the usage error to fail with (exit 64), or null when the combination
+* is valid.
 *
 * @internal
 */
 function validateJsonMode(flags) {
 	if (!flags.json) return null;
-	if (flags.preview) return new UpgradeError({ message: "--json cannot be combined with --preview; use --check, --yes, or --dry-run" });
-	if (!flags.check && !flags.yes && !flags.dryRun) return new UpgradeError({ message: "--json requires a non-interactive mode: combine it with --check, --yes, or --dry-run" });
+	if (flags.preview) return new UpgradeUsageError({ message: "--json cannot be combined with --preview; use --check, --yes, or --dry-run" });
+	if (!flags.check && !flags.yes && !flags.dryRun) return new UpgradeUsageError({ message: "--json requires a non-interactive mode: combine it with --check, --yes, or --dry-run" });
 	return null;
 }
 /**
-* Resolve the target file: the passed path, or autodetect in cwd.
+* Resolve the target file: the passed path, or autodetect in the working
+* directory.
 *
 * @internal
 */
@@ -483,20 +538,77 @@ function resolveTargetFile(fileOpt) {
 	return Effect.gen(function* () {
 		const explicit = Option.getOrUndefined(fileOpt);
 		if (explicit !== void 0) return explicit;
-		const matches = yield* findConfigFiles(process.cwd());
+		const matches = yield* findConfigFiles(yield* WorkingDirectory);
 		const picked = pickConfigCandidate(matches);
 		if (!picked.ok) return yield* Effect.fail(new UpgradeError({ message: picked.message }));
 		return picked.file;
 	});
 }
-const fileArg = Argument.File("file", { mustExist: true }).pipe(Argument.optional);
-const yesFlag = Flag.Boolean("yes").pipe(Flag.withAlias("y"), Flag.withDefault(false));
-const dryRunFlag = Flag.Boolean("dry-run").pipe(Flag.withDefault(false));
-const catalogOption = Flag.String("catalog").pipe(Flag.optional);
-const previewFlag = Flag.Boolean("preview").pipe(Flag.withDefault(false));
-const fullFlag = Flag.Boolean("full").pipe(Flag.withDefault(false));
-const checkFlag = Flag.Boolean("check").pipe(Flag.withDefault(false));
-const jsonFlag = Flag.Boolean("json").pipe(Flag.withDefault(false));
+/** Print the unresolved-packages warning to stderr, when there is one. */
+function warnUnresolved(unresolved) {
+	return unresolved.length > 0 ? printDoc(warningDoc(unresolvedMessage(unresolved)), { stream: "stderr" }) : Effect.void;
+}
+/**
+* Resolve every entry's versions, then — for interop catalogs — pre-fetch the
+* peerDependencies of each candidate version so the live table can recompute
+* peer floors + conflicts as picks change (the same data `runInterop` fetches,
+* moved ahead of the walk). Interactively the live table IS the reconcile;
+* `--yes`/CI keeps the auto-reconcile (`runUpgrade`). Each phase reports
+* progress, which an interactive run draws as a live view.
+*/
+function resolveForWalk(entries, resolver, gate, workspaceResolver, report) {
+	return Effect.gen(function* () {
+		const versions = yield* resolveGatedVersions(entries, resolver, gate, Date.now(), resolveProgress(report), workspaceResolver);
+		const items = yield* buildWalkItems(entries, versions.gated).pipe(Effect.mapError((e) => new UpgradeError({ message: e.message })));
+		const interopByCatalog = /* @__PURE__ */ new Map();
+		for (const e of entries) {
+			if (e.strategy !== "interop") continue;
+			const list = interopByCatalog.get(e.catalog) ?? [];
+			list.push(e);
+			interopByCatalog.set(e.catalog, list);
+		}
+		const interopModels = /* @__PURE__ */ new Map();
+		if (interopByCatalog.size > 0) {
+			const fetchPeer = makePeerFetcher(resolver);
+			const total = interopByCatalog.size;
+			yield* report({
+				_tag: "Phase",
+				label: "Resolving peer dependencies",
+				total
+			});
+			for (const [catalog, group] of interopByCatalog) {
+				const candByPkg = /* @__PURE__ */ new Map();
+				for (const e of group) {
+					const it = items.find((i) => i.entry.catalog === catalog && i.entry.pkg === e.pkg);
+					candByPkg.set(e.pkg, it ? it.candidates.map((c) => c.version) : [bareVersion(e.currentRange)]);
+				}
+				interopModels.set(catalog, yield* buildGroupModel(candByPkg, fetchPeer));
+				yield* report({
+					_tag: "Step",
+					done: interopModels.size
+				});
+			}
+			yield* report({
+				_tag: "Finished",
+				label: "Resolved peer dependencies"
+			});
+		}
+		return {
+			versions,
+			items,
+			interopByCatalog,
+			interopModels
+		};
+	});
+}
+const fileArg = Argument.File("file").pipe(Argument.withDescription("The config file to upgrade (autodetected in the current directory when omitted)"), Argument.optional);
+const yesFlag = Flag.Boolean("yes").pipe(Flag.withAlias("y"), Flag.withDescription("Apply the latest in-range version of every entry without asking (never a major)"), Flag.withDefault(false));
+const dryRunFlag = Flag.Boolean("dry-run").pipe(Flag.withDescription("Run the whole flow and report what would change, but write nothing"), Flag.withDefault(false));
+const catalogOption = Flag.String("catalog").pipe(Flag.withDescription("Only upgrade entries in the named catalog"), Flag.optional);
+const previewFlag = Flag.Boolean("preview").pipe(Flag.withDescription("Print the default picks as a summary and exit"), Flag.withDefault(false));
+const fullFlag = Flag.Boolean("full").pipe(Flag.withDescription("Include up-to-date packages in a printed summary"), Flag.withDefault(false));
+const checkFlag = Flag.Boolean("check").pipe(Flag.withDescription("Exit 1 when --yes would change anything (a drift gate; never writes)"), Flag.withDefault(false));
+const jsonFlag = Flag.Boolean("json").pipe(Flag.withDescription("Print one JSON document on stdout (with --check, --yes or --dry-run)"), Flag.withDefault(false));
 /**
 * The "upgrade" command. The default path runs the interactive table;
 * --yes applies latest-in-range non-interactively; --dry-run runs the identical
@@ -523,111 +635,91 @@ const upgradeCommand = Command.make("upgrade", {
 		preview
 	});
 	if (jsonRejection !== null) return yield* Effect.fail(jsonRejection);
-	const file = yield* resolveTargetFile(fileOpt);
 	const resolver = yield* RegistryResolver;
-	const caps = detectCapabilities();
-	const workspaceResolver = makeWorkspaceResolver(findWorkspaceRoot(dirname(file)));
+	const workspaceOf = (file) => makeWorkspaceResolver(findWorkspaceRoot(dirname(file)));
+	const nonInteractive = (forceDryRun) => resolveTargetFile(fileOpt).pipe(Effect.flatMap((file) => runUpgrade({
+		file,
+		resolver,
+		workspaceResolver: workspaceOf(file),
+		dryRun: forceDryRun || dryRun
+	})), Effect.result);
 	if (check) {
-		const result = yield* runUpgrade({
-			file,
-			resolver,
-			workspaceResolver,
-			dryRun: true
-		}).pipe(Effect.result);
+		const result = yield* nonInteractive(true);
 		if (json) {
 			const o = checkJsonOutcome(result);
-			yield* Effect.sync(() => {
-				if (o.stderr !== "") process.stderr.write(o.stderr);
-				process.stdout.write(o.stdout);
-				process.exitCode = o.exitCode;
-			});
-			return;
+			yield* Console.log(o.json);
+			if (o.failure !== void 0) return yield* Effect.fail(o.failure);
+			return yield* CliExit.set(o.exitCode);
 		}
-		const failed = Result.isFailure(result);
-		const outcome = failed ? checkFailureOutcome(result.failure.message) : checkOutcome(result.success.changed);
-		yield* Effect.sync(() => {
-			(failed ? process.stderr : process.stdout).write(outcome.text);
-			process.exitCode = outcome.exitCode;
-		});
-		return;
+		if (Result.isFailure(result)) {
+			const { message, kind } = result.failure;
+			return yield* Effect.fail(new CheckFailedError({
+				message,
+				...kind !== void 0 ? { kind } : {}
+			}));
+		}
+		const outcome = checkOutcome(result.success.changed);
+		yield* printDoc(outcome.doc);
+		return yield* CliExit.set(outcome.exitCode);
 	}
 	if (json) {
-		const o = upgradeJsonOutcome(yield* runUpgrade({
-			file,
-			resolver,
-			dryRun,
-			workspaceResolver
-		}).pipe(Effect.result), dryRun);
-		yield* Effect.sync(() => {
-			if (o.stderr !== "") process.stderr.write(o.stderr);
-			process.stdout.write(o.stdout);
-			process.exitCode = o.exitCode;
-		});
+		const o = upgradeJsonOutcome(yield* nonInteractive(false), dryRun);
+		yield* Console.log(o.json);
+		if (o.failure !== void 0) return yield* Effect.fail(o.failure);
 		return;
 	}
+	const file = yield* resolveTargetFile(fileOpt);
+	const workspaceResolver = workspaceOf(file);
 	if (preview) {
-		const text = yield* runUpgradePreview({
+		const { doc, unresolved } = yield* runUpgradePreview({
 			file,
 			resolver,
 			full,
-			color: caps.color,
 			workspaceResolver
 		});
-		yield* Effect.sync(() => process.stdout.write(`${text}\n`));
-		return;
+		yield* printDoc(doc);
+		return yield* warnUnresolved(unresolved);
 	}
 	if (yes) {
-		const result = yield* runUpgrade({
+		const result = yield* withProgress((report) => runUpgrade({
 			file,
 			resolver,
 			dryRun,
 			workspaceResolver,
-			...caps.interactive ? { onProgress: writeResolveProgress } : {}
-		});
-		yield* Effect.sync(() => process.stdout.write(dryRun ? `Dry run — no changes written. ${result.updated} package(s) would be updated; skipped ${result.skipped.length}.\n` : `Updated ${result.updated} package(s); skipped ${result.skipped.length}.\n`));
+			onProgress: resolveProgress(report)
+		}));
+		yield* dryRun ? CliMessage.info(`Dry run — no changes written. ${result.updated} package(s) would be updated; skipped ${result.skipped.length}.`) : CliMessage.success(`Updated ${result.updated} package(s); skipped ${result.skipped.length}.`);
 		if (result.conflicts.length > 0) {
-			const lines = result.conflicts.map((c) => `  ${c.pkg} (kept ${c.ceiling}) blocked by ${c.blockedBy}`).join("\n");
-			yield* Effect.sync(() => process.stdout.write(`Interop conflicts (left at your pick):\n${lines}\n`));
+			const lines = result.conflicts.map((c) => `  ${c.pkg} (kept ${c.ceiling}) blocked by ${c.blockedBy}`);
+			yield* printDoc(warningDoc(["Interop conflicts (left at your pick):", ...lines].join("\n")), { stream: "stderr" });
 		}
 		return;
 	}
 	const { source, entries: discovered } = yield* readCatalogSource(file);
-	const catalogName = Option.getOrUndefined(catalog);
-	const entries = filterEntriesByCatalog(discovered, catalogName);
-	const versions = yield* resolveGatedVersions(entries, resolver, yield* computeGate(source, file, resolver), Date.now(), caps.interactive ? writeResolveProgress : void 0, workspaceResolver);
-	const items = yield* buildWalkItems(entries, versions.gated).pipe(Effect.mapError((e) => new UpgradeError({ message: e.message })));
-	if (!caps.interactive) {
-		const text = renderSummary(projectDecisions(items, full), void 0, { color: caps.color });
-		const note = dryRun ? "(dry run — nothing written)" : "(non-interactive terminal — run with --yes to apply, or in a TTY to choose)";
-		const warn = versions.unresolved.length > 0 ? `\n⚠ ${unresolvedMessage(versions.unresolved)}\n` : "";
-		yield* Effect.sync(() => process.stdout.write(`${text}${warn}\n\n${note}\n`));
-		return;
+	const entries = filterEntriesByCatalog(discovered, Option.getOrUndefined(catalog));
+	const gate = yield* computeGate(source, file, resolver);
+	if (!(yield* CliInteractive)) {
+		const versions = yield* resolveGatedVersions(entries, resolver, gate, Date.now(), void 0, workspaceResolver);
+		const items = yield* buildWalkItems(entries, versions.gated).pipe(Effect.mapError((e) => new UpgradeError({ message: e.message })));
+		const note = dryRun ? "(dry run — nothing written)" : "(not interactive — run with --yes to apply, or in a terminal to choose)";
+		yield* printDoc([
+			...summaryDoc(projectDecisions(items, full)),
+			Doc.line(""),
+			Doc.line(Doc.text(note, "muted"))
+		]);
+		return yield* warnUnresolved(versions.unresolved);
 	}
+	const { versions, items, interopByCatalog, interopModels } = yield* withProgress((report) => resolveForWalk(entries, resolver, gate, workspaceResolver, report));
 	if (items.length === 0) {
-		const warn = versions.unresolved.length > 0 ? `⚠ ${unresolvedMessage(versions.unresolved)}\n\n` : "";
-		yield* Effect.sync(() => process.stdout.write(`${warn}${nothingToUpgradeMessage(0)}`));
-		return;
-	}
-	const interopByCatalog = /* @__PURE__ */ new Map();
-	for (const e of entries) {
-		if (e.strategy !== "interop") continue;
-		const list = interopByCatalog.get(e.catalog) ?? [];
-		list.push(e);
-		interopByCatalog.set(e.catalog, list);
+		yield* warnUnresolved(versions.unresolved);
+		return yield* CliMessage.info(nothingToUpgradeMessage(0));
 	}
-	const fetchPeer = makePeerFetcher(resolver);
-	if (interopByCatalog.size > 0) yield* Effect.sync(() => process.stderr.write("Resolving peer dependencies…\n"));
-	const interopModels = /* @__PURE__ */ new Map();
-	for (const [catalog, group] of interopByCatalog) {
-		const candByPkg = /* @__PURE__ */ new Map();
-		for (const e of group) {
-			const it = items.find((i) => i.entry.catalog === catalog && i.entry.pkg === e.pkg);
-			candByPkg.set(e.pkg, it ? it.candidates.map((c) => c.version) : [bareVersion(e.currentRange)]);
-		}
-		interopModels.set(catalog, yield* buildGroupModel(candByPkg, fetchPeer));
-	}
-	const { runWalk } = yield* Effect.promise(() => import("../ui/run-walk.js"));
-	const decisions = yield* runWalk(items, dryRun, versions.unresolved, interopModels);
+	const decisions = yield* CliUi.run(walkScreen({
+		items,
+		dryRun,
+		unresolved: versions.unresolved,
+		interopModels
+	}));
 	const nonInteropDecisions = decisions.filter((d) => d.item.entry.strategy !== "interop");
 	const interopEdits = [];
 	const allConflicts = [];
@@ -663,12 +755,12 @@ const upgradeCommand = Command.make("upgrade", {
 	const planned = buildEdits(nonInteropDecisions);
 	const { accepted, rejected } = yield* validateEdits(planned, versions.raw);
 	const acceptedPkgs = new Set(accepted.map((e) => e.pkg));
-	yield* Effect.sync(() => process.stdout.write(`${renderSummary(decisions, { conflicts: allConflicts }, { color: caps.color }, rejected)}\n`));
+	yield* printDoc(summaryDoc(decisions, { conflicts: allConflicts }, rejected));
 	if (!dryRun) yield* applyInteropAndDecisions(file, source, accepted, interopEdits);
 	const changed = countChangedDecisions(nonInteropDecisions.filter((d) => acceptedPkgs.has(d.item.entry.pkg))) + interopChanged;
-	yield* Effect.sync(() => process.stdout.write(dryRun ? `Dry run — no changes written. ${changed} change(s) would be applied.\n` : `Applied ${changed} change(s).\n`));
-	if (versions.unresolved.length > 0) yield* Effect.sync(() => process.stdout.write(`\n⚠ ${unresolvedMessage(versions.unresolved)}\n`));
-}).pipe(Effect.provide(RegistryResolverLive), Effect.provide(NodeServices.layer))).pipe(Command.withDescription("Upgrade catalog versions in a config file"));
+	yield* dryRun ? CliMessage.info(`Dry run — no changes written. ${changed} change(s) would be applied.`) : CliMessage.success(`Applied ${changed} change(s).`);
+	yield* warnUnresolved(versions.unresolved);
+}).pipe(Effect.provide(RegistryResolverLive))).pipe(Command.withDescription("Upgrade catalog versions in a config file"));
 
 //#endregion
-export { UpgradeError, applyInteropAndDecisions, checkFailureOutcome, checkJsonOutcome, checkOutcome, computeGate, countChangedDecisions, nothingToUpgradeMessage, projectDecisions, readCatalogSource, resolveGatedVersions, resolveTargetFile, runUpgrade, runUpgradePreview, unresolvedMessage, upgradeCommand, upgradeJsonOutcome, validateJsonMode, writeResolveProgress };
+export { CHECK_FAILED_LABEL, CheckFailedError, UpgradeError, UpgradeUsageError, applyInteropAndDecisions, checkJsonOutcome, checkOutcome, computeGate, countChangedDecisions, nothingToUpgradeMessage, projectDecisions, readCatalogSource, resolveGatedVersions, resolveProgress, resolveTargetFile, runUpgrade, runUpgradePreview, unresolvedMessage, upgradeCommand, upgradeJsonOutcome, validateJsonMode };