rolldown-pnpm-config 0.2.2 → 0.4.0

package/README.md

@@ -77,11 +77,11 @@ The bundled `rolldown-pnpm-config upgrade` command rewrites the version ranges i
 
 ```bash
 npx rolldown-pnpm-config upgrade
-# walks each catalog package, then:
+# opens a radio-group table, one row per package, then on <Enter>:
 # Applied <n> change(s).
 ```
 
-The walk is interactive by default. `--yes` takes the latest in-range version without prompting, `--dry-run` prints the planned changes without writing and `--catalog <name>` restricts the walk to one catalog. Pass `--preview` for a non-interactive projection of what the walk would do, with `--full` to show the full tree without context collapsing. The output is colorized in a supporting terminal. For packages that declare a `strategy`, the command also resyncs their materialized peer range. See [upgrading catalogs](https://github.com/spencerbeggs/rolldown-pnpm-config/blob/main/docs/05-upgrading-catalogs.md) for the full surface.
+The command shows an interactive table by default — every catalog package at once, one row per package, `●`/`○` bubbles, modeled on `pnpm up -i`. `--yes` takes the latest in-range version for every package without prompting and fails hard on any warning or unresolvable package name; `--dry-run` runs the identical table and skips only the write; `--catalog <name>` restricts the table to one catalog. Pass `--preview` for a non-interactive projection of what an upgrade would do, with `--full` to show up-to-date entries too. The output is colorized in a supporting terminal. For packages that declare a `strategy`, the command also resyncs their materialized peer range, preserving any prerelease identifier rather than rebuilding it from parsed version parts. See [upgrading catalogs](https://github.com/spencerbeggs/rolldown-pnpm-config/blob/main/docs/05-upgrading-catalogs.md) for the full surface.
 
 ## Exporting to pnpm-workspace.yaml
 

package/bin/rolldown-pnpm-config.js

@@ -3,8 +3,8 @@ import { exportCommand } from "../cli/commands/export.js";
 import { previewCommand } from "../cli/commands/preview.js";
 import { upgradeCommand } from "../cli/commands/upgrade.js";
 import { Effect } from "effect";
-import { Command } from "@effect/cli";
-import { NodeContext, NodeRuntime } from "@effect/platform-node";
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { Command } from "effect/unstable/cli";
 
 //#region src/cli/bin.ts
 const root = Command.make("rolldown-pnpm-config").pipe(Command.withSubcommands([
@@ -12,10 +12,7 @@ const root = Command.make("rolldown-pnpm-config").pipe(Command.withSubcommands([
 	exportCommand,
 	previewCommand
 ]));
-Command.run(root, {
-	name: "rolldown-pnpm-config",
-	version: "0.2.2"
-})(process.argv).pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain);
+Command.run(root, { version: "0.4.0" }).pipe(Effect.provide(NodeServices.layer), NodeRuntime.runMain);
 
 //#endregion
 export {  };

package/cli/commands/export.js

@@ -16,7 +16,7 @@ import { overlayWorkspace } from "../workspace-overlay.js";
 import { Data, Effect, Option } from "effect";
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
-import { Args, Command, Options } from "@effect/cli";
+import { Argument, Command, Flag } from "effect/unstable/cli";
 
 //#region src/cli/commands/export.ts
 /**
@@ -110,9 +110,9 @@ function runExport(opts) {
 		};
 	});
 }
-const pathArg = Args.file({ name: "path" }).pipe(Args.optional);
-const dryRunFlag = Options.boolean("dry-run").pipe(Options.withDefault(false));
-const fullFlag = Options.boolean("full").pipe(Options.withDefault(false));
+const pathArg = Argument.file("path").pipe(Argument.optional);
+const dryRunFlag = Flag.boolean("dry-run").pipe(Flag.withDefault(false));
+const fullFlag = Flag.boolean("full").pipe(Flag.withDefault(false));
 /**
 * The "export" command. Materializes the plugin config into pnpm-workspace.yaml.
 * An optional path argument overrides the auto-detected workspace file. --dry-run

package/cli/commands/preview.js

@@ -11,7 +11,7 @@ import { runPreview } from "../ui/run-preview.js";
 import { Data, Effect, Option } from "effect";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { Args, Command } from "@effect/cli";
+import { Argument, Command } from "effect/unstable/cli";
 
 //#region src/cli/commands/preview.ts
 /** Typed failure for the preview run. @internal */
@@ -48,7 +48,7 @@ function runPreviewViews(opts) {
 		});
 	});
 }
-const pathArg = Args.file({ name: "path" }).pipe(Args.optional);
+const pathArg = Argument.file("path").pipe(Argument.optional);
 /**
 * The "preview" command: interactive ink-tab explorer of the export diff
 * (Changes / Full / Simulated). Falls back to printing the Changes view when

package/cli/commands/upgrade.js

@@ -12,11 +12,12 @@ import { RegistryResolver, RegistryResolverLive } from "../resolve.js";
 import { applyEdits } from "../rewrite.js";
 import { renderSummary } from "../summary.js";
 import { runWalk } from "../ui/run-walk.js";
+import { validateEdits } from "../validate.js";
 import { buildWalkItems } from "../walk-plan.js";
-import { Data, Effect, Option } from "effect";
+import { Data, Effect, Option, Result } from "effect";
 import { readFileSync, writeFileSync } from "node:fs";
-import { Args, Command, Options } from "@effect/cli";
-import { NodeContext } from "@effect/platform-node";
+import { NodeServices } from "@effect/platform-node";
+import { Argument, Command, Flag } from "effect/unstable/cli";
 
 //#region src/cli/commands/upgrade.ts
 /**
@@ -28,9 +29,9 @@ var UpgradeError = class extends Data.TaggedError("UpgradeError") {};
 /** Combine the config-declared and pnpm-resolved release-age gates (strictest of both). @internal */
 function computeGate(source, file, resolver) {
 	return Effect.gen(function* () {
-		const { config } = yield* Effect.try(() => evaluatePluginConfig(source, file)).pipe(Effect.catchAll(() => Effect.succeed({ config: null })));
+		const { config } = yield* Effect.try(() => evaluatePluginConfig(source, file)).pipe(Effect.catch(() => Effect.succeed({ config: null })));
 		const cfg = readConfigReleaseAge(config);
-		const [age, exc] = yield* Effect.all([resolver.pnpmConfig("minimumReleaseAge").pipe(Effect.catchAll(() => Effect.succeed(null))), resolver.pnpmConfig("minimumReleaseAgeExclude").pipe(Effect.catchAll(() => Effect.succeed(null)))], { concurrency: "unbounded" });
+		const [age, exc] = yield* Effect.all([resolver.pnpmConfig("minimumReleaseAge").pipe(Effect.catch(() => Effect.succeed(null))), resolver.pnpmConfig("minimumReleaseAgeExclude").pipe(Effect.catch(() => Effect.succeed(null)))], { concurrency: "unbounded" });
 		return combineReleaseAge(cfg, parsePnpmGate(age, exc));
 	});
 }
@@ -51,15 +52,27 @@ function resolveGatedVersions(entries, resolver, gate, now, onProgress) {
 	let resolved = 0;
 	onProgress?.(0, total);
 	return Effect.forEach(uniquePkgs, (pkg) => Effect.gen(function* () {
-		const vr = yield* resolver.versions(pkg).pipe(Effect.either);
-		if (vr._tag === "Left") {
+		const vr = yield* resolver.versions(pkg).pipe(Effect.result);
+		if (Result.isFailure(vr)) {
 			onProgress?.(++resolved, total);
-			return [pkg, []];
+			return [
+				pkg,
+				[],
+				[]
+			];
 		}
-		const times = gate.ageMinutes > 0 ? yield* resolver.times(pkg).pipe(Effect.catchAll(() => Effect.succeed({}))) : {};
+		const times = gate.ageMinutes > 0 ? yield* resolver.times(pkg).pipe(Effect.catch(() => Effect.succeed({}))) : {};
 		onProgress?.(++resolved, total);
-		return [pkg, filterByReleaseAge(vr.right, times, gate, pkg, now)];
-	}), { concurrency: 12 }).pipe(Effect.map((pairs) => new Map(pairs)));
+		return [
+			pkg,
+			filterByReleaseAge(vr.success, times, gate, pkg, now),
+			vr.success
+		];
+	}), { concurrency: 12 }).pipe(Effect.map((triples) => ({
+		gated: new Map(triples.map(([pkg, gated]) => [pkg, gated])),
+		raw: new Map(triples.map(([pkg, , raw]) => [pkg, raw])),
+		unresolved: triples.filter(([, , raw]) => raw.length === 0).map(([pkg]) => pkg)
+	})));
 }
 /**
 * Write a resolve-progress line to stderr. Overwrites the previous line with
@@ -85,6 +98,12 @@ function writeResolveProgress(resolved, total) {
 * is treated as a skip, except that a strategy entry can still resync or
 * materialize its managed peer offline from the current range.
 *
+* This path runs UNATTENDED (`--yes`, i.e. CI), so it fails hard rather than
+* degrading: any peer-strategy warning, or any planned edit no published
+* version satisfies, aborts the run and writes NOTHING. A warning that scrolls
+* past unread in a CI log is a bad range in a published artifact. The
+* interactive path is deliberately more forgiving (see `upgradeCommand`).
+*
 * @internal
 */
 function runUpgrade(opts) {
@@ -99,69 +118,69 @@ function runUpgrade(opts) {
 		});
 		const gate = yield* computeGate(source, opts.file, opts.resolver);
 		const versionsByPkg = yield* resolveGatedVersions(entries, opts.resolver, gate, Date.now(), opts.onProgress);
+		if (versionsByPkg.unresolved.length > 0) return yield* Effect.fail(new UpgradeError({ message: unresolvedMessage(versionsByPkg.unresolved) }));
 		const edits = [];
+		const interopEdits = [];
+		const warnings = [];
 		const changedSpans = /* @__PURE__ */ new Set();
 		for (const entry of entries) {
 			if (entry.strategy === "interop") continue;
-			const versions = versionsByPkg.get(entry.pkg) ?? [];
+			const versions = versionsByPkg.gated.get(entry.pkg) ?? [];
+			const pkg = entry.pkg;
+			const rangeEdit = (span, value) => ({
+				span,
+				text: JSON.stringify(value),
+				pkg,
+				kind: "range",
+				value
+			});
+			const peerEdit = (span, value) => ({
+				span,
+				text: JSON.stringify(value),
+				pkg,
+				kind: "peer",
+				value
+			});
+			const peerInsert = (at, value) => ({
+				span: [at, at],
+				text: `, peer: ${JSON.stringify(value)}`,
+				pkg,
+				kind: "peer",
+				value
+			});
+			const derived = entry.strategy ? yield* derivePeerRange(entry.currentRange, entry.strategy).pipe(Effect.catch(() => Effect.succeed(null))) : null;
+			if (derived?.warning) warnings.push(`${entry.pkg}: ${derived.warning.message}`);
 			if (versions.length === 0) {
 				const at = entry.rangeSpan[1];
 				if (entry.peer && entry.strategy) {
-					const expected = yield* detectPeerDrift(entry).pipe(Effect.catchAll(() => Effect.succeed(null)));
+					const expected = yield* detectPeerDrift(entry).pipe(Effect.catch(() => Effect.succeed(null)));
 					if (expected !== null) {
-						edits.push({
-							span: entry.peer.span,
-							text: JSON.stringify(expected)
-						});
-						changedSpans.add(entry.rangeSpan[0]);
-						continue;
-					}
-				} else if (!entry.peer && entry.strategy) {
-					const peerRange = yield* derivePeerRange(entry.currentRange, entry.strategy).pipe(Effect.catchAll(() => Effect.succeed(null)));
-					if (peerRange !== null) {
-						edits.push({
-							span: [at, at],
-							text: `, peer: ${JSON.stringify(peerRange)}`
-						});
+						edits.push(peerEdit(entry.peer.span, expected));
 						changedSpans.add(entry.rangeSpan[0]);
 						continue;
 					}
+				} else if (!entry.peer && entry.strategy && derived !== null) {
+					edits.push(peerInsert(at, derived.range));
+					changedSpans.add(entry.rangeSpan[0]);
+					continue;
 				}
 				skipped.push(`${entry.catalog}.${entry.pkg}`);
 				continue;
 			}
-			const inRange = (yield* planEntry(entry, versions).pipe(Effect.catchAll(() => Effect.succeed([])))).find((c) => c.kind === "in-range");
+			const inRange = (yield* planEntry(entry, versions).pipe(Effect.catch(() => Effect.succeed([])))).find((c) => c.kind === "in-range");
 			const at = entry.rangeSpan[1];
 			if (inRange) {
-				edits.push({
-					span: entry.rangeSpan,
-					text: JSON.stringify(inRange.range)
-				});
+				edits.push(rangeEdit(entry.rangeSpan, inRange.range));
+				changedSpans.add(entry.rangeSpan[0]);
+				if (entry.peer && inRange.peerRange) edits.push(peerEdit(entry.peer.span, inRange.peerRange));
+				else if (!entry.peer && entry.strategy && inRange.peerRange) edits.push(peerInsert(at, inRange.peerRange));
+			} else if (!entry.peer && entry.strategy && derived !== null) {
+				edits.push(peerInsert(at, derived.range));
 				changedSpans.add(entry.rangeSpan[0]);
-				if (entry.peer && inRange.peerRange) edits.push({
-					span: entry.peer.span,
-					text: JSON.stringify(inRange.peerRange)
-				});
-				else if (!entry.peer && entry.strategy && inRange.peerRange) edits.push({
-					span: [at, at],
-					text: `, peer: ${JSON.stringify(inRange.peerRange)}`
-				});
-			} else if (!entry.peer && entry.strategy) {
-				const peerRange = yield* derivePeerRange(entry.currentRange, entry.strategy).pipe(Effect.catchAll(() => Effect.succeed(null)));
-				if (peerRange !== null) {
-					edits.push({
-						span: [at, at],
-						text: `, peer: ${JSON.stringify(peerRange)}`
-					});
-					changedSpans.add(entry.rangeSpan[0]);
-				}
 			} else if (entry.peer && entry.strategy) {
-				const expected = yield* detectPeerDrift(entry).pipe(Effect.catchAll(() => Effect.succeed(null)));
+				const expected = yield* detectPeerDrift(entry).pipe(Effect.catch(() => Effect.succeed(null)));
 				if (expected !== null) {
-					edits.push({
-						span: entry.peer.span,
-						text: JSON.stringify(expected)
-					});
+					edits.push(peerEdit(entry.peer.span, expected));
 					changedSpans.add(entry.rangeSpan[0]);
 				}
 			}
@@ -177,8 +196,8 @@ function runUpgrade(opts) {
 		for (const [, group] of byCatalog) {
 			const members = [];
 			for (const e of group) {
-				const versions = versionsByPkg.get(e.pkg) ?? [];
-				const inRange = (yield* planEntry(e, versions).pipe(Effect.catchAll(() => Effect.succeed([])))).find((c) => c.kind === "in-range");
+				const versions = versionsByPkg.gated.get(e.pkg) ?? [];
+				const inRange = (yield* planEntry(e, versions).pipe(Effect.catch(() => Effect.succeed([])))).find((c) => c.kind === "in-range");
 				const ceiling = inRange ? inRange.version : e.currentRange.replace(/^[\^~]/, "");
 				members.push({
 					pkg: e.pkg,
@@ -187,12 +206,16 @@ function runUpgrade(opts) {
 				});
 			}
 			const result = yield* runInterop(members, opts.resolver);
-			edits.push(...buildInteropEdits(group, result));
+			interopEdits.push(...buildInteropEdits(group, result));
 			for (const e of group) if (interopEntryChanged(e, result)) changedSpans.add(e.rangeSpan[0]);
 			conflicts.push(...result.conflicts);
 		}
-		if (edits.length > 0) {
-			const next = applyEdits(source, edits);
+		if (warnings.length > 0) return yield* Effect.fail(new UpgradeError({ message: `Refusing to apply with an incompatible peer strategy:\n${warnings.map((w) => `  ${w}`).join("\n")}` }));
+		const { accepted, rejected } = yield* validateEdits(edits, versionsByPkg.raw);
+		if (rejected.length > 0) return yield* Effect.fail(new UpgradeError({ message: `Refusing to write unsatisfiable range(s):\n${rejected.map((r) => `  ${r.reason}`).join("\n")}` }));
+		const allEdits = [...accepted, ...interopEdits];
+		if (allEdits.length > 0 && !opts.dryRun) {
+			const next = applyEdits(source, allEdits);
 			yield* Effect.try({
 				try: () => writeFileSync(opts.file, next, "utf8"),
 				catch: () => new UpgradeError({ message: `Cannot write ${opts.file}` })
@@ -201,22 +224,29 @@ function runUpgrade(opts) {
 		return {
 			updated: changedSpans.size,
 			skipped,
-			conflicts
+			conflicts,
+			rejected
 		};
 	});
 }
+/** Count the decisions that actually change the file (a bump, a peer resync, or a materialize). @internal */
+function countChangedDecisions(decisions) {
+	return decisions.filter((d) => d.chosen.kind !== "keep" || d.item.entry.peer !== void 0 && d.item.driftPeer !== null || d.item.entry.peer === void 0 && d.item.materializePeer !== null).length;
+}
 /**
-* Apply the interactive result when interop members are present: the
-* non-interop decisions go through `buildEdits`, the interop members through
-* their separately-computed span edits. Interop members are EXCLUDED from
-* `buildEdits` so the two never emit a range edit over the same span (which
-* `applyEdits` would reject as overlapping).
+* Apply the interactive result: the (already validated) non-interop edits plus
+* the interop members' separately-computed span edits. Interop members are
+* EXCLUDED from `buildEdits` upstream so the two never emit a range edit over
+* the same span (which `applyEdits` would reject as overlapping).
+*
+* Edits arrive pre-validated so the caller can report what was dropped rather
+* than failing the whole run.
 *
 * @internal
 */
-function applyInteropAndDecisions(file, source, nonInteropDecisions, interopEdits) {
+function applyInteropAndDecisions(file, source, nonInteropEdits, interopEdits) {
 	return Effect.gen(function* () {
-		const edits = [...buildEdits(nonInteropDecisions), ...interopEdits];
+		const edits = [...nonInteropEdits, ...interopEdits];
 		if (edits.length === 0) return;
 		const next = applyEdits(source, edits);
 		yield* Effect.try({
@@ -225,6 +255,40 @@ function applyInteropAndDecisions(file, source, nonInteropDecisions, interopEdit
 		});
 	});
 }
+/**
+* Filter walk items down to the ones the interactive table should show: a row
+* is actionable when it is anything but up-to-date (a range bump, a peer
+* drift resync, or a peer materialization), unless `--full` asks for every
+* row including inert up-to-date ones. Parity with the old walk's
+* `nextActionable` auto-skip, now applied as an upfront filter instead of a
+* per-step cursor advance.
+*
+* @internal
+*/
+function actionableWalkItems(items, full) {
+	return full ? [...items] : items.filter((i) => !i.upToDate);
+}
+/**
+* The message printed instead of entering the interactive table when nothing
+* is actionable: either no catalog packages were discovered at all, or every
+* discovered package is already up to date.
+*
+* @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`;
+}
+/**
+* The message for packages the registry could not resolve. Almost always a
+* misspelt name in the config; occasionally a private package the current
+* .npmrc cannot authenticate against.
+*
+* @internal
+*/
+function unresolvedMessage(unresolved) {
+	const list = unresolved.map((p) => `  ${p}`).join("\n");
+	return `Could not resolve ${unresolved.length} package(s) from the registry — check the name(s) for typos, or your registry auth:\n${list}`;
+}
 /** Project walk items to the non-interactive default decisions (latest-in-range, plus peer-only keeps). @internal */
 function projectDecisions(items, full) {
 	const out = [];
@@ -270,7 +334,8 @@ function runUpgradePreview(opts) {
 		});
 		const gate = yield* computeGate(source, opts.file, opts.resolver);
 		const versions = yield* resolveGatedVersions(discovered.entries, opts.resolver, gate, Date.now());
-		return renderSummary(projectDecisions(yield* buildWalkItems(discovered.entries, versions).pipe(Effect.catchAll((e) => Effect.fail(new UpgradeError({ message: e.message })))), opts.full), void 0, { color: opts.color ?? false });
+		const text = renderSummary(projectDecisions(yield* buildWalkItems(discovered.entries, versions.gated).pipe(Effect.catch((e) => Effect.fail(new UpgradeError({ message: e.message })))), opts.full), void 0, { color: opts.color ?? false });
+		return versions.unresolved.length > 0 ? `${text}\n⚠ ${unresolvedMessage(versions.unresolved)}` : text;
 	});
 }
 /**
@@ -287,19 +352,17 @@ function resolveTargetFile(fileOpt) {
 		return picked.file;
 	});
 }
-const fileArg = Args.file({
-	name: "file",
-	exists: "yes"
-}).pipe(Args.optional);
-const yesFlag = Options.boolean("yes").pipe(Options.withAlias("y"), Options.withDefault(false));
-const dryRunFlag = Options.boolean("dry-run").pipe(Options.withDefault(false));
-const catalogOption = Options.text("catalog").pipe(Options.optional);
-const previewFlag = Options.boolean("preview").pipe(Options.withDefault(false));
-const fullFlag = Options.boolean("full").pipe(Options.withDefault(false));
+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));
 /**
-* The "upgrade" command. The default path runs the interactive walk;
-* --yes applies latest-in-range non-interactively; --dry-run prints the
-* summary without writing; --catalog restricts to a single catalog by name.
+* The "upgrade" command. The default path runs the interactive table;
+* --yes applies latest-in-range non-interactively; --dry-run runs the identical
+* interactive flow and reports what it would have written, but writes nothing;
+* --catalog restricts to a single catalog by name.
 *
 * @internal
 */
@@ -328,9 +391,10 @@ const upgradeCommand = Command.make("upgrade", {
 		const result = yield* runUpgrade({
 			file,
 			resolver,
+			dryRun,
 			...caps.interactive ? { onProgress: writeResolveProgress } : {}
 		});
-		yield* Effect.sync(() => process.stdout.write(`Updated ${result.updated} package(s); skipped ${result.skipped.length}.\n`));
+		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`));
 		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`));
@@ -348,18 +412,21 @@ const upgradeCommand = Command.make("upgrade", {
 	const catalogName = Option.getOrUndefined(catalog);
 	const entries = filterEntriesByCatalog(discovered.entries, catalogName);
 	const versions = yield* resolveGatedVersions(entries, resolver, yield* computeGate(source, file, resolver), Date.now(), caps.interactive ? writeResolveProgress : void 0);
-	const items = yield* buildWalkItems(entries, versions).pipe(Effect.catchAll((e) => Effect.fail(new UpgradeError({ message: e.message }))));
-	if (dryRun) {
-		const decisions = projectDecisions(items, false);
-		yield* Effect.sync(() => process.stdout.write(`${renderSummary(decisions, void 0, { color: caps.color })}\n`));
-		return;
-	}
+	const items = yield* buildWalkItems(entries, versions.gated).pipe(Effect.catch((e) => Effect.fail(new UpgradeError({ message: e.message }))));
 	if (!caps.interactive) {
 		const text = renderSummary(projectDecisions(items, full), void 0, { color: caps.color });
-		yield* Effect.sync(() => process.stdout.write(`${text}\n\n(non-interactive terminal — run with --yes to apply, or in a TTY to choose)\n`));
+		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 actionable = actionableWalkItems(items, full);
+	if (actionable.length === 0) {
+		const warn = versions.unresolved.length > 0 ? `⚠ ${unresolvedMessage(versions.unresolved)}\n\n` : "";
+		yield* Effect.sync(() => process.stdout.write(`${warn}${nothingToUpgradeMessage(items.length)}`));
 		return;
 	}
-	const decisions = yield* runWalk(items);
+	const decisions = yield* runWalk(actionable, dryRun, versions.unresolved);
 	const interopByCatalog = /* @__PURE__ */ new Map();
 	for (const e of entries) {
 		if (e.strategy !== "interop") continue;
@@ -382,7 +449,7 @@ const upgradeCommand = Command.make("upgrade", {
 		let members = group.map((e) => ({
 			pkg: e.pkg,
 			ceiling: pickOf(e.pkg),
-			candidates: versions.get(e.pkg) ?? []
+			candidates: versions.gated.get(e.pkg) ?? []
 		}));
 		const originalPick = new Map(members.map((m) => [m.pkg, m.ceiling]));
 		const peerCache = /* @__PURE__ */ new Map();
@@ -393,10 +460,10 @@ const upgradeCommand = Command.make("upgrade", {
 			const capEntries = group.filter((e) => reentry.some((rc) => rc.pkg === e.pkg));
 			const cappedVersions = /* @__PURE__ */ new Map();
 			for (const rc of reentry) {
-				const all = versions.get(rc.pkg) ?? [];
+				const all = versions.gated.get(rc.pkg) ?? [];
 				cappedVersions.set(rc.pkg, rc.cap === null ? all : yield* capVersions(all, rc.cap));
 			}
-			const reDecisions = yield* runWalk(yield* buildWalkItems(capEntries, cappedVersions).pipe(Effect.catchAll((err) => Effect.fail(new UpgradeError({ message: err.message })))));
+			const reDecisions = yield* runWalk(yield* buildWalkItems(capEntries, cappedVersions).pipe(Effect.catch((err) => Effect.fail(new UpgradeError({ message: err.message })))));
 			const before = new Map(members.map((m) => [m.pkg, m.ceiling]));
 			members = members.map((m) => {
 				const rd = reDecisions.find((d) => d.item.entry.pkg === m.pkg);
@@ -424,14 +491,17 @@ const upgradeCommand = Command.make("upgrade", {
 			});
 		}
 	}
+	const { accepted, rejected } = yield* validateEdits(buildEdits(nonInteropDecisions), versions.raw);
+	const acceptedPkgs = new Set(accepted.map((e) => e.pkg));
 	yield* Effect.sync(() => process.stdout.write(`${renderSummary(decisions, {
 		adjustments,
 		conflicts: allConflicts
-	}, { color: caps.color })}\n`));
-	yield* applyInteropAndDecisions(file, source, nonInteropDecisions, interopEdits);
-	const nonInteropChanged = nonInteropDecisions.filter((d) => d.chosen.kind !== "keep" || d.item.entry.peer !== void 0 && d.item.driftPeer !== null || d.item.entry.peer === void 0 && d.item.materializePeer !== null).length;
-	yield* Effect.sync(() => process.stdout.write(`Applied ${nonInteropChanged + interopChanged} change(s).\n`));
-}).pipe(Effect.provide(RegistryResolverLive), Effect.provide(NodeContext.layer))).pipe(Command.withDescription("Upgrade catalog versions in a config file"));
+	}, { color: caps.color }, rejected)}\n`));
+	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"));
 
 //#endregion
-export { UpgradeError, applyInteropAndDecisions, computeGate, projectDecisions, resolveGatedVersions, resolveTargetFile, runUpgrade, runUpgradePreview, upgradeCommand, writeResolveProgress };
+export { UpgradeError, actionableWalkItems, applyInteropAndDecisions, computeGate, countChangedDecisions, nothingToUpgradeMessage, projectDecisions, resolveGatedVersions, resolveTargetFile, runUpgrade, runUpgradePreview, unresolvedMessage, upgradeCommand, writeResolveProgress };

package/cli/drift.js

@@ -8,12 +8,18 @@ import { Effect } from "effect";
 * up-to-date peer range) on drift, or null when in sync or not applicable
 * (missing peer or strategy).
 *
+* "interop" is NOT a per-package derivation: an interop peer is computed
+* GROUP-WISE by `interop.ts` from the resolved peerDependencies of the whole
+* catalog group. Deriving one per package here would fall through to the
+* lock-minor branch and report a bogus resync target, so interop entries are
+* excluded — parity with `materializePeer` in walk-plan.ts.
+*
 * @internal
 */
 function detectPeerDrift(entry) {
 	return Effect.gen(function* () {
-		if (!entry.peer || !entry.strategy) return null;
-		const expected = yield* derivePeerRange(entry.currentRange, entry.strategy);
+		if (!entry.peer || !entry.strategy || entry.strategy === "interop") return null;
+		const { range: expected } = yield* derivePeerRange(entry.currentRange, entry.strategy);
 		return expected === entry.peer.value ? null : expected;
 	});
 }

package/cli/edits.js

@@ -5,34 +5,44 @@
 * recomputed peerRange). A keep with peer drift rewrites only the peer literal
 * to the resync target.
 *
+* Each edit is tagged with its package and unquoted range so `validateEdits`
+* can check it against the registry before it is written.
+*
 * @internal
 */
 function buildEdits(decisions) {
 	const edits = [];
 	for (const { item, chosen } of decisions) {
 		const { entry } = item;
+		const pkg = entry.pkg;
 		const insertAt = entry.rangeSpan[1];
-		if (chosen.kind !== "keep") {
-			edits.push({
-				span: entry.rangeSpan,
-				text: JSON.stringify(chosen.range)
-			});
-			if (entry.peer && chosen.peerRange) edits.push({
-				span: entry.peer.span,
-				text: JSON.stringify(chosen.peerRange)
-			});
-			else if (!entry.peer && entry.strategy && chosen.peerRange) edits.push({
-				span: [insertAt, insertAt],
-				text: `, peer: ${JSON.stringify(chosen.peerRange)}`
-			});
-		} else if (entry.peer && item.driftPeer) edits.push({
-			span: entry.peer.span,
-			text: JSON.stringify(item.driftPeer)
+		const range = (span, value) => ({
+			span,
+			text: JSON.stringify(value),
+			pkg,
+			kind: "range",
+			value
 		});
-		else if (!entry.peer && item.materializePeer) edits.push({
+		const peer = (span, value) => ({
+			span,
+			text: JSON.stringify(value),
+			pkg,
+			kind: "peer",
+			value
+		});
+		const peerInsert = (value) => ({
 			span: [insertAt, insertAt],
-			text: `, peer: ${JSON.stringify(item.materializePeer)}`
+			text: `, peer: ${JSON.stringify(value)}`,
+			pkg,
+			kind: "peer",
+			value
 		});
+		if (chosen.kind !== "keep") {
+			edits.push(range(entry.rangeSpan, chosen.range));
+			if (entry.peer && chosen.peerRange) edits.push(peer(entry.peer.span, chosen.peerRange));
+			else if (!entry.peer && entry.strategy && chosen.peerRange) edits.push(peerInsert(chosen.peerRange));
+		} else if (entry.peer && item.driftPeer) edits.push(peer(entry.peer.span, item.driftPeer));
+		else if (!entry.peer && item.materializePeer) edits.push(peerInsert(item.materializePeer));
 	}
 	return edits;
 }