rolldown-pnpm-config 0.2.2 → 0.3.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

@@ -14,7 +14,7 @@ const root = Command.make("rolldown-pnpm-config").pipe(Command.withSubcommands([
 ]));
 Command.run(root, {
 	name: "rolldown-pnpm-config",
-	version: "0.2.2"
+	version: "0.3.0"
 })(process.argv).pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain);
 
 //#endregion

package/cli/commands/upgrade.js

@@ -12,6 +12,7 @@ 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 { readFileSync, writeFileSync } from "node:fs";
@@ -54,12 +55,24 @@ function resolveGatedVersions(entries, resolver, gate, now, onProgress) {
 		const vr = yield* resolver.versions(pkg).pipe(Effect.either);
 		if (vr._tag === "Left") {
 			onProgress?.(++resolved, total);
-			return [pkg, []];
+			return [
+				pkg,
+				[],
+				[]
+			];
 		}
 		const times = gate.ageMinutes > 0 ? yield* resolver.times(pkg).pipe(Effect.catchAll(() => 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.right, times, gate, pkg, now),
+			vr.right
+		];
+	}), { 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,33 +118,51 @@ 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.catchAll(() => 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)));
 					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;
@@ -133,35 +170,17 @@ function runUpgrade(opts) {
 			const inRange = (yield* planEntry(entry, versions).pipe(Effect.catchAll(() => 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)));
 				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,7 +196,7 @@ function runUpgrade(opts) {
 		for (const [, group] of byCatalog) {
 			const members = [];
 			for (const e of group) {
-				const versions = versionsByPkg.get(e.pkg) ?? [];
+				const versions = versionsByPkg.gated.get(e.pkg) ?? [];
 				const inRange = (yield* planEntry(e, versions).pipe(Effect.catchAll(() => Effect.succeed([])))).find((c) => c.kind === "in-range");
 				const ceiling = inRange ? inRange.version : e.currentRange.replace(/^[\^~]/, "");
 				members.push({
@@ -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.catchAll((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;
 	});
 }
 /**
@@ -297,9 +362,10 @@ 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));
 /**
-* 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 +394,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 +415,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.catchAll((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 +452,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,7 +463,7 @@ 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 })))));
@@ -424,14 +494,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`));
+	}, { 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(NodeContext.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;
 }

package/cli/peer-range.js

@@ -15,8 +15,20 @@ const PREFIX_RE = /^(\^|~|)(\d.*)$/;
 * "lock" pins to the exact version; "lock-minor" floors the patch to .0.
 * The operator (^/~/exact) is preserved.
 *
-* Note: expects a release (non-prerelease) version string; a prerelease tag
-* would be dropped by the major.minor.patch reconstruction.
+* "lock" reuses the version text verbatim rather than rebuilding it from
+* major.minor.patch, so prerelease and build identifiers survive intact
+* (rebuilding would silently drop them and derive an unpublished range).
+*
+* "lock-minor" floors a stable version's patch to .0, which intentionally
+* drops any build metadata: `^6.5.1+build.7` derives to `^6.5.0`, not
+* `^6.5.0+build.7`. Build metadata identifies a specific build of 6.5.1, not
+* of the floored 6.5.0, and semver ignores build metadata when matching
+* ranges anyway, so carrying it forward would be misleading.
+*
+* "lock-minor" is not meaningful on a prerelease — flooring `3.0.0-next.8` to
+* `^3.0.0` yields a range that does not match `3.0.0-next.8` at all, excluding
+* the very version being catalogued. It therefore degrades to "lock" behavior
+* and reports a warning rather than emitting an unsatisfiable range.
 *
 * @internal
 */
@@ -26,7 +38,21 @@ function derivePeerRange(range, strategy) {
 		if (!match) return yield* Effect.fail(new PeerRangeError({ message: `Cannot derive peer range from "${range}"` }));
 		const [, prefix, version] = match;
 		const parsed = yield* SemVer.parse(version).pipe(Effect.mapError(() => new PeerRangeError({ message: `Invalid version in range "${range}"` })));
-		return strategy === "lock" ? `${prefix}${parsed.major}.${parsed.minor}.${parsed.patch}` : `${prefix}${parsed.major}.${parsed.minor}.0`;
+		if (strategy === "lock") return {
+			range: `${prefix}${version}`,
+			warning: null
+		};
+		if (parsed.prerelease.length > 0) return {
+			range: `${prefix}${version}`,
+			warning: {
+				kind: "lock-minor-prerelease",
+				message: `lock-minor cannot floor the prerelease "${version}" — pinned to the exact version instead`
+			}
+		};
+		return {
+			range: `${prefix}${parsed.major}.${parsed.minor}.0`,
+			warning: null
+		};
 	});
 }
 

package/cli/plan.js

@@ -17,19 +17,21 @@ const parseOrNull = (v) => SemVer.parse(v).pipe(Effect.catchAll(() => Effect.suc
 function planEntry(entry, versions) {
 	return Effect.gen(function* () {
 		const range = yield* Range.parse(entry.currentRange).pipe(Effect.catchAll(() => Effect.succeed(null)));
+		const currentStripped = entry.currentRange.replace(/^[\^~]/, "");
+		const current = yield* parseOrNull(currentStripped);
+		const currentMajor = current?.major ?? 0;
+		const track = current && current.prerelease.length > 0 ? String(current.prerelease[0]) : null;
+		const onTrack = (v) => track !== null && v.prerelease.length > 0 && String(v.prerelease[0]) === track;
 		const parsed = [];
 		for (const v of versions) {
 			const sv = yield* parseOrNull(v);
-			if (sv?.isStable) parsed.push(sv);
+			if (sv && (sv.isStable || onTrack(sv))) parsed.push(sv);
 		}
 		parsed.sort((a, b) => a.compare(b));
 		const maxOf = (list) => list.length ? list[list.length - 1] : null;
-		const currentStripped = entry.currentRange.replace(/^[\^~]/, "");
-		const current = yield* parseOrNull(currentStripped);
-		const currentMajor = current?.major ?? 0;
 		const inRangeMax = range ? maxOf(parsed.filter((v) => range.test(v))) : null;
 		const overallMax = maxOf(parsed);
-		const withPeer = (version) => entry.strategy && entry.strategy !== "interop" ? derivePeerRange(`${entry.operator}${version}`, entry.strategy) : Effect.succeed(void 0);
+		const withPeer = (version) => entry.strategy && entry.strategy !== "interop" ? derivePeerRange(`${entry.operator}${version}`, entry.strategy).pipe(Effect.map((d) => d.range)) : Effect.succeed(void 0);
 		const candidates = [];
 		if (inRangeMax && (current === null || inRangeMax.gt(current))) {
 			const version = inRangeMax.toString();

package/cli/summary.js

@@ -1,89 +1,90 @@
 import { toAnsi } from "./ui/ansi.js";
+import { displayCandidates, peerFor } from "./walk-reducer.js";
 
 //#region src/cli/summary.ts
+/** Trailing annotation appended to a major candidate's cell, e.g. " ⚠ major". */
+const MAJOR_SUFFIX = " ⚠ major";
+/** Filled / hollow radio glyphs. MUST match `ui/Walk.ts` — the summary mirrors the table. */
+const SELECTED = "●";
+const UNSELECTED = "○";
+/** "● " / "○ " glyph-plus-space prefix width, common to every cell. */
+const BUBBLE_WIDTH = 2;
 /**
-* Build the pending-decisions summary as styled lines: one line per real
-* change, peer changes indented, a dim tally, then interop adjustments and
-* conflicts. Pure; color is applied by `renderSummary`/`toAnsi`.
+* Build the pending-decisions summary as styled lines: one table row per
+* decision — mirroring the interactive selection table, catalog headers,
+* chosen bubble filled — then a dim tally, interop adjustments, conflicts,
+* and any rejected edits. Pure; color is applied by `renderSummary`/`toAnsi`.
 *
 * @internal
 */
-function summaryLines(decisions, interop) {
+function summaryLines(decisions, interop, rejected) {
 	const lines = [];
 	let toUpdate = 0;
 	let major = 0;
 	let resync = 0;
 	let materialize = 0;
 	let upToDate = 0;
+	const pkgWidth = decisions.length ? Math.max(...decisions.map((d) => d.item.entry.pkg.length)) : 0;
+	const cellWidth = decisions.length ? Math.max(...decisions.flatMap((d) => displayCandidates(d.item).map((c) => c.range.length + (c.isMajor ? 8 : 0)))) : 0;
+	const maxCells = decisions.length ? Math.max(...decisions.map((d) => displayCandidates(d.item).length)) : 0;
+	const blankCell = `${" ".repeat(BUBBLE_WIDTH + cellWidth)}  `;
+	let lastCatalog = null;
 	for (const { item, chosen } of decisions) {
 		const { entry } = item;
-		if (chosen.kind !== "keep") {
-			toUpdate++;
-			if (chosen.isMajor) major++;
+		if (entry.catalog !== lastCatalog) {
+			lastCatalog = entry.catalog;
 			lines.push({
 				indent: 0,
-				gutter: "~",
+				gutter: " ",
 				segments: [{
-					text: `${entry.catalog} › ${entry.pkg}  ${entry.currentRange} → ${chosen.range}`,
-					style: "changed"
+					text: `── catalog: ${entry.catalog} ──`,
+					style: "unchanged"
 				}]
 			});
-			if (entry.peer && chosen.peerRange && chosen.peerRange !== entry.peer.value) lines.push({
-				indent: 1,
-				gutter: "~",
-				segments: [{
-					text: `↳ peer  ${entry.peer.value} → ${chosen.peerRange}`,
-					style: "changed"
-				}]
-			});
-			else if (!entry.peer && entry.strategy && chosen.peerRange) {
-				lines.push({
-					indent: 1,
-					gutter: "+",
-					segments: [{
-						text: `↳ peer (new)  → ${chosen.peerRange}`,
-						style: "added"
-					}]
-				});
-				materialize++;
-			}
-		} else if (entry.peer && item.driftPeer) {
-			resync++;
-			lines.push({
-				indent: 0,
-				gutter: "~",
-				segments: [{
-					text: `${entry.catalog} › ${entry.pkg}  (resync peer)`,
-					style: "changed"
-				}]
-			});
-			lines.push({
-				indent: 1,
-				gutter: "~",
-				segments: [{
-					text: `↳ peer  ${entry.peer.value} → ${item.driftPeer}`,
-					style: "changed"
-				}]
-			});
-		} else if (!entry.peer && item.materializePeer) {
-			materialize++;
-			lines.push({
-				indent: 0,
-				gutter: "+",
-				segments: [{
-					text: `${entry.catalog} › ${entry.pkg}  (materialize peer)`,
-					style: "added"
-				}]
-			});
-			lines.push({
-				indent: 1,
-				gutter: "+",
-				segments: [{
-					text: `↳ peer (new)  → ${item.materializePeer}`,
-					style: "added"
-				}]
+		}
+		const cells = displayCandidates(item);
+		const segments = [{
+			text: entry.pkg.padEnd(pkgWidth + 2),
+			style: "plain"
+		}];
+		for (const c of cells) {
+			const selected = c.kind === chosen.kind;
+			const bubble = selected ? SELECTED : UNSELECTED;
+			const style = !selected ? "unchanged" : c.kind === "keep" ? "unchanged" : c.isMajor ? "changed" : "added";
+			const content = `${c.range}${c.isMajor ? MAJOR_SUFFIX : ""}`.padEnd(cellWidth);
+			segments.push({
+				text: `${bubble} ${content}  `,
+				style
 			});
-		} else upToDate++;
+		}
+		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"
+			}]
+		});
+		if (chosen.kind !== "keep") {
+			toUpdate++;
+			if (chosen.isMajor) major++;
+			if (!entry.peer && entry.strategy && chosen.peerRange) materialize++;
+		} else if (entry.peer && item.driftPeer) resync++;
+		else if (!entry.peer && item.materializePeer) materialize++;
+		else upToDate++;
 	}
 	lines.push({
 		indent: 0,
@@ -121,6 +122,32 @@ function summaryLines(decisions, interop) {
 			}]
 		});
 	}
+	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;
 }
 /**
@@ -129,8 +156,8 @@ function summaryLines(decisions, interop) {
 *
 * @internal
 */
-function renderSummary(decisions, interop, opts) {
-	return toAnsi(summaryLines(decisions, interop), { color: opts?.color ?? false });
+function renderSummary(decisions, interop, opts, rejected) {
+	return toAnsi(summaryLines(decisions, interop, rejected), { color: opts?.color ?? false });
 }
 
 //#endregion

package/cli/ui/Walk.js

@@ -1,54 +1,80 @@
-import { initWalk, walkStep } from "../walk-reducer.js";
+import { cellColor, displayCandidates, initTable, peerFor, tableDecisions, tableStep } from "../walk-reducer.js";
 import { Box, Text, useApp, useInput } from "ink";
 import { createElement, useEffect, useState } from "react";
 
 //#region src/cli/ui/Walk.ts
+/** Rows visible at once before the viewport scrolls. */
+const VIEWPORT = 20;
 /**
-* Interactive per-package upgrade selector rendered with Ink.
+* Interactive upgrade table rendered with Ink. Every package is one row; each
+* row is a radio group over its candidates with keep (index 0) preselected, so
+* the default state of the table applies nothing.
 *
 * Written with React.createElement (no JSX) so the file can be plain .ts
 * without requiring TSX transform configuration.
 *
 * @internal
 */
-function Walk({ items, onDone }) {
+function Walk({ items, onDone, dryRun = false, unresolved = [] }) {
 	const app = useApp();
-	const [state, setState] = useState(() => initWalk(items));
+	const [state, setState] = useState(() => initTable(items));
 	useEffect(() => {
-		if (state.done) {
-			onDone(state.decisions);
+		if (items.length === 0) {
+			onDone([]);
 			app.exit();
 		}
 	}, []);
 	useInput((_input, key) => {
 		if (state.done) return;
-		const which = key.upArrow ? "up" : key.downArrow ? "down" : key.return ? "enter" : null;
+		const which = key.upArrow ? "up" : key.downArrow ? "down" : key.leftArrow ? "left" : key.rightArrow ? "right" : key.return ? "submit" : key.escape ? "cancel" : null;
 		if (!which) return;
-		const next = walkStep(state, items, which);
+		const next = tableStep(state, items, which);
 		setState(next);
 		if (next.done) {
-			onDone(next.decisions);
+			onDone(tableDecisions(next, items));
 			app.exit();
 		}
 	});
-	if (state.done || state.index >= items.length) return createElement(Text, null, "Done.");
-	const item = items[state.index];
-	const e = item.entry;
-	return createElement(Box, { flexDirection: "column" }, createElement(Text, null, [
-		`${e.catalog} › ${e.pkg}   current ${e.currentRange}`,
-		e.peer ? `   peer ${e.peer.value}` : "",
-		e.strategy ? `   strategy: ${e.strategy}` : ""
-	].join("")), ...item.candidates.map((c, i) => {
-		const selected = i === state.cursor;
-		const cursor = selected ? "❯ " : "  ";
-		const base = c.kind === "keep" ? `keep ${c.range}` : `${c.range}   ${c.kind}`;
-		const colorProps = selected ? { color: "cyan" } : c.isMajor ? { color: "yellow" } : {};
-		const text = c.kind === "keep" ? `${cursor}${base}` : `${cursor}${base}${c.isMajor ? "  ⚠ major" : ""}`;
-		return createElement(Text, {
-			key: c.kind,
-			...colorProps
-		}, text);
-	}));
+	if (state.done || items.length === 0) return createElement(Text, null, "Done.");
+	const pkgWidth = Math.max(...items.map((i) => i.entry.pkg.length));
+	const MAJOR_SUFFIX = " ⚠ major";
+	const SELECTED = "●";
+	const UNSELECTED = "○";
+	const cellWidth = Math.max(...items.flatMap((i) => displayCandidates(i).map((c) => c.range.length + (c.isMajor ? 8 : 0))));
+	const maxCells = Math.max(...items.map((i) => displayCandidates(i).length));
+	const blankCell = `${" ".repeat(2 + cellWidth)}  `;
+	const start = Math.max(0, Math.min(state.cursor - Math.floor(VIEWPORT / 2), items.length - VIEWPORT));
+	const visible = items.slice(Math.max(0, start), Math.max(0, start) + VIEWPORT);
+	const rows = [];
+	let lastCatalog = null;
+	visible.forEach((item, offset) => {
+		const i = Math.max(0, start) + offset;
+		if (item.entry.catalog !== lastCatalog) {
+			lastCatalog = item.entry.catalog;
+			rows.push(createElement(Text, {
+				key: `cat-${item.entry.catalog}`,
+				dimColor: true
+			}, `  ── catalog: ${lastCatalog} ──`));
+		}
+		const onCursor = i === state.cursor;
+		const pick = state.picks[i] ?? 0;
+		const candidates = displayCandidates(item);
+		const cells = candidates.map((c, ci) => {
+			const selected = ci === pick;
+			const bubble = selected ? SELECTED : UNSELECTED;
+			const major = c.isMajor ? MAJOR_SUFFIX : "";
+			const content = `${c.range}${major}`.padEnd(cellWidth);
+			const color = cellColor(c, selected);
+			return createElement(Text, {
+				key: c.kind,
+				...color ? { color } : {}
+			}, `${bubble} ${content}  `);
+		});
+		for (let ci = candidates.length; ci < maxCells; ci++) cells.push(createElement(Text, { key: `blank-${ci}` }, blankCell));
+		const chosen = candidates[pick];
+		rows.push(createElement(Box, { key: `${item.entry.catalog}/${item.entry.pkg}` }, createElement(Text, { ...onCursor ? { color: "cyan" } : {} }, onCursor ? "❯ " : "  "), createElement(Text, { bold: onCursor }, item.entry.pkg.padEnd(pkgWidth + 2)), ...cells, createElement(Text, { dimColor: true }, `│ ${chosen === void 0 ? "—" : peerFor(item, chosen)}`), item.peerWarning ? createElement(Text, { color: "red" }, `  ⚠ ${item.peerWarning.message}`) : null));
+	});
+	return createElement(Box, { flexDirection: "column" }, createElement(Text, { bold: true }, dryRun ? "Enter to preview • Esc to cancel" : "Enter to update • Esc to cancel"), dryRun ? createElement(Text, { color: "yellow" }, "DRY RUN — nothing will be written to the config") : null, unresolved.length > 0 ? createElement(Text, { color: "red" }, `⚠ Could not resolve from the registry — check for a typo: ${unresolved.join(", ")}`) : null, createElement(Box, { height: 1 }), ...rows);
 }
 
 //#endregion

package/cli/ui/run-walk.js

@@ -5,17 +5,19 @@ import { createElement } from "react";
 
 //#region src/cli/ui/run-walk.ts
 /**
-* Render the interactive Walk inside an Effect, resolving with the collected
-* decisions once the user finishes (or immediately when nothing is actionable),
-* after Ink has fully exited.
+* Render the interactive table inside an Effect, resolving with the collected
+* decisions once the user submits (or with an empty list when they cancel with
+* Esc, or when no rows are actionable), after Ink has fully exited.
 *
 * @internal
 */
-function runWalk(items) {
+function runWalk(items, dryRun = false, unresolved = []) {
 	return Effect.async((resume) => {
 		let collected = [];
 		render(createElement(Walk, {
 			items,
+			dryRun,
+			unresolved,
 			onDone: (d) => {
 				collected = d;
 			}

package/cli/validate.js

@@ -0,0 +1,88 @@
+import { Effect } from "effect";
+import { Range, SemVer } from "semver-effect";
+
+//#region src/cli/validate.ts
+/**
+* Whether at least one published version satisfies `range`.
+*
+* The predicate is deliberately "some published version satisfies this range",
+* NOT "this exact version was published": `^3.4.0` is a valid lock-minor floor
+* even when 3.4.0 itself never shipped but 3.4.1 did. Conversely `^3.0.0`
+* against a package with only `3.0.0-next.*` releases matches nothing.
+*
+* Fails OPEN — an empty version list (fetch failure, fully age-gated package)
+* or an unparseable range yields `true`. Validation is a safety net against
+* ranges we DERIVED wrongly, not a gate on the author's own hand-written
+* ranges, and rejecting everything the moment the registry is unreachable would
+* break offline peer materialization.
+*
+* @internal
+*/
+function rangeIsSatisfiable(range, versions) {
+	return Effect.gen(function* () {
+		if (versions.length === 0) return true;
+		const parsedRange = yield* Range.parse(range).pipe(Effect.catchAll(() => Effect.succeed(null)));
+		if (parsedRange === null) return true;
+		for (const v of versions) {
+			const sv = yield* SemVer.parse(v).pipe(Effect.catchAll(() => Effect.succeed(null)));
+			if (sv && parsedRange.test(sv)) return true;
+		}
+		return false;
+	});
+}
+/**
+* Partition planned edits into those whose range some published version
+* satisfies and those none does — ATOMICALLY per package. A catalog package
+* with a `strategy` produces a `range` edit and a `peer` edit as a pair; if
+* either is unsatisfiable, BOTH are rejected. Writing one half of the pair
+* (say, an accepted range bump next to a rejected, stale peer) would leave the
+* file internally inconsistent — the peer no longer matches what the strategy
+* derives from the new range — and every subsequent run would re-report the
+* same drift and re-reject it forever. A package is either fully updated or
+* not touched at all.
+*
+* `versionsByPkg` MUST be the UNGATED version list. Validating against the
+* release-age-gated list would spuriously reject a package whose only matching
+* version was published inside the gate window.
+*
+* @internal
+*/
+function validateEdits(edits, versionsByPkg) {
+	return Effect.gen(function* () {
+		const byPkg = /* @__PURE__ */ new Map();
+		for (const e of edits) {
+			const group = byPkg.get(e.pkg) ?? [];
+			group.push(e);
+			byPkg.set(e.pkg, group);
+		}
+		const accepted = [];
+		const rejected = [];
+		for (const [pkg, group] of byPkg) {
+			const versions = versionsByPkg.get(pkg) ?? [];
+			const checked = [];
+			for (const e of group) checked.push({
+				edit: e,
+				ok: yield* rangeIsSatisfiable(e.value, versions)
+			});
+			const failing = checked.filter((c) => !c.ok);
+			if (failing.length === 0) {
+				accepted.push(...group);
+				continue;
+			}
+			const failingKinds = failing.map((f) => f.edit.kind).join(" and ");
+			for (const { edit, ok } of checked) rejected.push({
+				pkg,
+				kind: edit.kind,
+				value: edit.value,
+				reason: ok ? `dropped along with its ${failingKinds} edit for ${pkg}, which is unsatisfiable` : `no published version of ${pkg} satisfies ${edit.value}`
+			});
+		}
+		return {
+			accepted,
+			rejected
+		};
+	});
+}
+
+//#endregion
+export { rangeIsSatisfiable, validateEdits };

package/cli/walk-plan.js

@@ -7,7 +7,8 @@ import { Effect } from "effect";
 /**
 * Build the interactive walk items: for each entry, its candidate list (from
 * planEntry against the resolved versions), an up-to-date flag (only the keep
-* candidate remains), and any peer drift resync target.
+* candidate remains), any peer drift resync target, any peer to materialize,
+* and any strategy/prerelease incompatibility warning.
 *
 * @internal
 */
@@ -17,14 +18,21 @@ function buildWalkItems(entries, versionsByPkg) {
 		for (const entry of entries) {
 			const candidates = yield* planEntry(entry, [...versionsByPkg.get(entry.pkg) ?? []]);
 			const driftPeer = yield* detectPeerDrift(entry);
-			const materializePeer = entry.strategy && !entry.peer ? yield* derivePeerRange(entry.currentRange, entry.strategy) : null;
+			let peerWarning = null;
+			let materializePeer = null;
+			if (entry.strategy && entry.strategy !== "interop") {
+				const derived = yield* derivePeerRange(entry.currentRange, entry.strategy);
+				peerWarning = derived.warning;
+				if (!entry.peer) materializePeer = derived.range;
+			}
 			const upToDate = candidates.length === 1 && driftPeer === null && materializePeer === null;
 			items.push({
 				entry,
 				candidates,
 				upToDate,
 				driftPeer,
-				materializePeer
+				materializePeer,
+				peerWarning
 			});
 		}
 		return items;

package/cli/walk-reducer.js

@@ -1,61 +1,116 @@
 //#region src/cli/walk-reducer.ts
-/** Index of the next actionable (not up-to-date) item at or after `from`, or -1. */
-function nextActionable(items, from) {
-	for (let i = from; i < items.length; i++) if (!items[i].upToDate) return i;
-	return -1;
+const ORDER = {
+	keep: 0,
+	"in-range": 1,
+	latest: 2
+};
+/**
+* The row's options in display order: keep first (always index 0, always the
+* default), then the in-range bump, then the latest-overall bump. `planEntry`
+* emits them in the opposite order, with keep last.
+*
+* @internal
+*/
+function displayCandidates(item) {
+	return [...item.candidates].sort((a, b) => ORDER[a.kind] - ORDER[b.kind]);
 }
 /**
-* Initialize the walk on the first actionable item (auto-skipping up-to-date
-* items). If none are actionable, the walk is immediately done.
+* Initialize the table: cursor on the first row, keep selected on every row, so
+* the default state applies nothing.
 *
 * @internal
 */
-function initWalk(items) {
-	const index = nextActionable(items, 0);
+function initTable(items) {
 	return {
-		index: index === -1 ? items.length : index,
 		cursor: 0,
-		decisions: [],
-		done: index === -1
+		picks: items.map(() => 0),
+		done: false,
+		cancelled: false
 	};
 }
+const clamp = (n, max) => n < 0 ? 0 : n > max ? max : n;
 /**
-* Advance the walk by a key. up/down move the cursor within the current item's
-* candidates; enter records the highlighted candidate and moves to the next
-* actionable item (or completes).
+* Advance the table by a key. up/down move between rows; left/right move the
+* radio selection within the row under the cursor; submit applies; cancel exits
+* without applying. Both axes clamp at their ends rather than wrapping.
 *
 * @internal
 */
-function walkStep(state, items, key) {
+function tableStep(state, items, key) {
 	if (state.done) return state;
-	const item = items[state.index];
-	const count = item.candidates.length;
-	if (key === "up") return {
+	if (key === "submit") return {
 		...state,
-		cursor: (state.cursor - 1 + count) % count
+		done: true
 	};
-	if (key === "down") return {
+	if (key === "cancel") return {
 		...state,
-		cursor: (state.cursor + 1) % count
+		done: true,
+		cancelled: true
 	};
-	const chosen = item.candidates[state.cursor];
-	const decisions = [...state.decisions, {
-		item,
-		chosen
-	}];
-	const next = nextActionable(items, state.index + 1);
-	if (next === -1) return {
+	if (items.length === 0) return state;
+	if (key === "up") return {
 		...state,
-		decisions,
-		done: true
+		cursor: clamp(state.cursor - 1, items.length - 1)
+	};
+	if (key === "down") return {
+		...state,
+		cursor: clamp(state.cursor + 1, items.length - 1)
 	};
+	const count = displayCandidates(items[state.cursor]).length;
+	const delta = key === "right" ? 1 : -1;
+	const picks = [...state.picks];
+	picks[state.cursor] = clamp(picks[state.cursor] + delta, count - 1);
 	return {
-		index: next,
-		cursor: 0,
-		decisions,
-		done: false
+		...state,
+		picks
 	};
 }
+/**
+* Project the table's selections into decisions. A cancelled table yields none,
+* so nothing is written.
+*
+* @internal
+*/
+function tableDecisions(state, items) {
+	if (state.cancelled) return [];
+	return items.map((item, i) => ({
+		item,
+		chosen: displayCandidates(item)[state.picks[i] ?? 0]
+	}));
+}
+/**
+* The peer range that would be written for a row's currently chosen candidate.
+* Non-keep candidates carry their own recomputed `peerRange`; keep reuses
+* whichever peer source the item already resolved (a drift resync, a
+* materialize target, or the entry's existing literal), falling back to an
+* em dash placeholder when none applies.
+*
+* @internal
+*/
+function peerFor(item, chosen) {
+	if (chosen.kind !== "keep") return chosen.peerRange ?? "—";
+	if (item.driftPeer) return item.driftPeer;
+	if (item.materializePeer) return item.materializePeer;
+	return item.entry.peer?.value ?? "—";
+}
+/**
+* The Ink color for one candidate cell, or null for the terminal's default.
+*
+* Only a SELECTED UPGRADE is colored — green in-range, yellow for a major. A
+* selected KEEP is deliberately left uncolored: it is the current value, not a
+* change, and coloring it dim made the column the eye lands on first read as
+* disabled. Unselected cells are always default.
+*
+* Extracted from the render so it can be unit-tested: `ink-testing-library`
+* strips ANSI from `lastFrame()`, so a color assertion is impossible against
+* the rendered output.
+*
+* @internal
+*/
+function cellColor(candidate, selected) {
+	if (!selected || candidate.kind === "keep") return null;
+	return candidate.isMajor ? "yellow" : "green";
+}
 
 //#endregion
-export { initWalk, walkStep };
+export { cellColor, displayCandidates, initTable, peerFor, tableDecisions, tableStep };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rolldown-pnpm-config",
-	"version": "0.2.2",
+	"version": "0.3.0",
 	"private": false,
 	"description": "A dogfooding example of our plugin",
 	"repository": {
@@ -47,7 +47,7 @@
 		"effect": "^3.21.4",
 		"ink": "^7.1.0",
 		"ink-tab": "^5.2.0",
-		"oxc-parser": "^0.139.0",
+		"oxc-parser": "^0.140.0",
 		"react": "^19.2.7",
 		"semver-effect": "^0.3.1",
 		"std-env": "^4.2.0",