rolldown-pnpm-config 0.8.0 → 1.0.0

package/cli/edits.js

@@ -2,56 +2,68 @@ import { versionKeyOf } from "./version-key.js";
 
 //#region src/cli/edits.ts
 /**
-* Convert resolved decisions into span edits. A chosen upgrade rewrites the
-* range literal (and the existing peer literal when the candidate carries a
-* 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.
+* The edit constructors for one entry, each tagged with the entry's package
+* and route-aware version key so `validateEdits` can check it against the
+* registry before it is written. The single place that knows the insertion
+* syntax and the key routing — both the interactive and the `--yes` paths
+* build their edits through it.
 *
 * @internal
 */
-function buildEdits(decisions) {
-	const edits = [];
-	for (const { item, chosen } of decisions) {
-		const { entry } = item;
-		const pkg = entry.pkg;
-		const versionKey = versionKeyOf(entry);
-		const insertAt = entry.rangeSpan[1];
-		const range = (span, value) => ({
-			span,
+function entryEdits(entry) {
+	const pkg = entry.pkg;
+	const versionKey = versionKeyOf(entry);
+	const insertAt = entry.rangeSpan[1];
+	return {
+		range: (value) => ({
+			span: entry.rangeSpan,
 			text: JSON.stringify(value),
 			pkg,
 			versionKey,
 			kind: "range",
 			value
-		});
-		const peer = (span, value) => ({
-			span,
+		}),
+		setPeer: (value) => entry.peer ? {
+			span: entry.peer.span,
 			text: JSON.stringify(value),
 			pkg,
 			versionKey,
 			kind: "peer",
 			value
-		});
-		const peerInsert = (value) => ({
+		} : {
 			span: [insertAt, insertAt],
 			text: `, peer: ${JSON.stringify(value)}`,
 			pkg,
 			versionKey,
 			kind: "peer",
 			value
-		});
+		}
+	};
+}
+/**
+* Convert resolved decisions into span edits. A chosen upgrade rewrites the
+* range literal (and the existing peer literal when the candidate carries a
+* 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 { range, setPeer } = entryEdits(entry);
 		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));
+			edits.push(range(chosen.range));
+			if (chosen.peerRange && (entry.peer || entry.strategy)) edits.push(setPeer(chosen.peerRange));
+		} else if (entry.peer && item.driftPeer) edits.push(setPeer(item.driftPeer));
+		else if (!entry.peer && item.materializePeer) edits.push(setPeer(item.materializePeer));
 	}
 	return edits;
 }
 
 //#endregion
-export { buildEdits };
+export { buildEdits, entryEdits };

package/cli/evaluate.js

@@ -1,28 +1,7 @@
+import { findPluginArg, keyName } from "./ast.js";
 import { parseSync } from "oxc-parser";
 
 //#region src/cli/evaluate.ts
-/** Find the first `PnpmConfigPlugin(...)` call's first argument (an object literal). */
-function findPluginArg(program) {
-	let found;
-	const visit = (node) => {
-		if (found || node === null || typeof node !== "object") return;
-		const n = node;
-		if (n.type === "CallExpression") {
-			const callee = n.callee;
-			if (callee?.type === "Identifier" && callee.name === "PnpmConfigPlugin") {
-				const args = n.arguments;
-				if (args?.[0]?.type === "ObjectExpression") {
-					found = args[0];
-					return;
-				}
-			}
-		}
-		for (const value of Object.values(n)) if (Array.isArray(value)) value.forEach(visit);
-		else if (value && typeof value === "object") visit(value);
-	};
-	visit(program);
-	return found;
-}
 /** Evaluate a literal AST node into a plain JS value; unsupported nodes push to `errors`. */
 function evalNode(node, path, errors) {
 	switch (node.type) {
@@ -46,8 +25,7 @@ function evalNode(node, path, errors) {
 					errors.push(`${path}: spread/getter is not supported`);
 					continue;
 				}
-				const key = prop.key;
-				const name = key.type === "Identifier" ? key.name : key.type === "Literal" ? String(key.value) : void 0;
+				const name = keyName(prop.key);
 				if (name === void 0) {
 					errors.push(`${path}: computed key is not supported`);
 					continue;

package/cli/interop-live.js

@@ -1,12 +1,8 @@
+import { bareVersion, parseRange, parseVersion } from "../semver-util.js";
 import "./interop.js";
 import { Effect } from "effect";
-import { Range, SemVer } from "@effected/semver";
 
 //#region src/cli/interop-live.ts
-/** Strip a range operator to its bare version digits (e.g. `^3.17.0` → `3.17.0`). */
-function floorOf(range) {
-	return range.replace(/^[\^~>=\s]+/, "").split(/\s/)[0] ?? range;
-}
 /**
 * Recompute each member's peer floor and conflict for the current selection —
 * synchronously, from a pre-built {@link GroupModel}. Mirrors `deriveFloors`
@@ -24,7 +20,7 @@ function computeGroupPeers(model, selected) {
 		if (v === void 0) continue;
 		for (const { dep, range } of model.peerReqs.get(`${m}@${v}`) ?? []) {
 			const list = declaredFloors.get(dep) ?? [];
-			list.push(floorOf(range));
+			list.push(bareVersion(range));
 			declaredFloors.set(dep, list);
 		}
 	}
@@ -96,19 +92,15 @@ function buildGroupModel(candidatesByPkg, fetchPeer) {
 					range
 				});
 				rngStrings.add(range);
-				verStrings.add(floorOf(range));
+				verStrings.add(bareVersion(range));
 			}
 			peerReqs.set(`${pkg}@${v}`, reqs);
 		}
-		const ver = /* @__PURE__ */ new Map();
-		for (const s of verStrings) ver.set(s, yield* SemVer.parse(s).pipe(Effect.catch(() => Effect.succeed(null))));
-		const rng = /* @__PURE__ */ new Map();
-		for (const s of rngStrings) rng.set(s, yield* Range.parse(s).pipe(Effect.catch(() => Effect.succeed(null))));
 		return {
 			members,
 			peerReqs,
-			ver,
-			rng
+			ver: new Map([...verStrings].map((s) => [s, parseVersion(s)])),
+			rng: new Map([...rngStrings].map((s) => [s, parseRange(s)]))
 		};
 	});
 }

package/cli/interop.js

@@ -1,12 +1,27 @@
+import { bareVersion, parseRange, parseVersion } from "../semver-util.js";
 import { Effect } from "effect";
-import { Range, SemVer } from "@effected/semver";
 
 //#region src/cli/interop.ts
 /** Maximum number of concurrent peerDependencies fetches inside runInterop. @internal */
 const INTEROP_PEER_CONCURRENCY = 8;
-/** Strip a range operator to its bare version digits (e.g. `^3.17.0` → `3.17.0`). */
-function floorOf(range) {
-	return range.replace(/^[\^~>=\s]+/, "").split(/\s/)[0] ?? range;
+/**
+* Build an Effectful memoized peer-deps fetcher over `resolver`: a cache hit
+* returns immediately; a miss calls the resolver (degrading to `{}` on
+* failure), stores the result in `cache`, and returns it. A `(pkg, version)`
+* peerDeps lookup is immutable, so a shared `cache` may outlive one call.
+*
+* @internal
+*/
+function makePeerFetcher(resolver, cache = /* @__PURE__ */ new Map()) {
+	return (pkg, v) => {
+		const k = `${pkg}@${v}`;
+		const cached = cache.get(k);
+		if (cached !== void 0) return Effect.succeed(cached);
+		return resolver.peerDependencies(pkg, v).pipe(Effect.orElseSucceed(() => ({})), Effect.map((deps) => {
+			cache.set(k, deps);
+			return deps;
+		}));
+	};
 }
 /**
 * Derive each member's caret-capped peer floor: the lowest floor any in-group
@@ -23,33 +38,35 @@ function deriveFloors(resolved, fetchPeer) {
 			for (const [dep, range] of Object.entries(peers)) {
 				if (!resolved.has(dep)) continue;
 				const list = floors.get(dep) ?? [];
-				list.push(floorOf(range));
+				list.push(bareVersion(range));
 				floors.set(dep, list);
 			}
 		}
 		const out = /* @__PURE__ */ new Map();
 		for (const [pkg, version] of resolved) {
-			const declared = floors.get(pkg);
-			if (declared?.length) {
-				const valid = (yield* Effect.forEach(declared, (f) => SemVer.parse(f).pipe(Effect.map((sv) => ({
-					f,
-					sv
-				})), Effect.catch(() => Effect.succeed(null))))).filter((x) => x !== null);
-				valid.sort((a, b) => a.sv.compare(b.sv));
-				out.set(pkg, `^${valid[0]?.f ?? version}`);
-			} else out.set(pkg, `^${version}`);
+			const lowest = lowestVersion(floors.get(pkg) ?? []);
+			out.set(pkg, `^${lowest ?? version}`);
 		}
 		return out;
 	});
 }
+/** The lowest parseable version string in `list`, or null when none parses. */
+function lowestVersion(list) {
+	let best = null;
+	for (const f of list) {
+		const sv = parseVersion(f);
+		if (sv !== null && (best === null || sv.compare(best.sv) < 0)) best = {
+			f,
+			sv
+		};
+	}
+	return best?.f ?? null;
+}
 /** Does `version` satisfy `range`? Unparseable input is treated as not-satisfied. */
 function satisfies(version, range) {
-	return Effect.gen(function* () {
-		const r = yield* Range.parse(range).pipe(Effect.catch(() => Effect.succeed(null)));
-		if (!r) return false;
-		const v = yield* SemVer.parse(version).pipe(Effect.catch(() => Effect.succeed(null)));
-		return v ? r.test(v) : false;
-	});
+	const r = parseRange(range);
+	const v = parseVersion(version);
+	return r !== null && v !== null && r.test(v);
 }
 /**
 * In-group peers of (pkg@version) that the current resolution violates, as
@@ -63,7 +80,7 @@ function violations(pkg, version, resolved, memberSet, fetchPeer) {
 			if (!memberSet.has(dep)) continue;
 			const rv = resolved.get(dep);
 			if (rv === void 0) continue;
-			if (!(yield* satisfies(rv, range))) out.push(`${dep}@${range}`);
+			if (!satisfies(rv, range)) out.push(`${dep}@${range}`);
 		}
 		return out;
 	});
@@ -80,23 +97,23 @@ function resolveGroup(members, fetchPeer) {
 		const memberSet = new Set(members.map((m) => m.pkg));
 		const resolved = new Map(members.map((m) => [m.pkg, m.ceiling]));
 		const ceilingOf = new Map(members.map((m) => [m.pkg, m.ceiling]));
-		const leq = (a, b) => Effect.gen(function* () {
-			const av = yield* SemVer.parse(a).pipe(Effect.catch(() => Effect.succeed(null)));
-			const bv = yield* SemVer.parse(b).pipe(Effect.catch(() => Effect.succeed(null)));
-			return av && bv ? av.compare(bv) <= 0 : false;
-		});
+		const eligibleOf = /* @__PURE__ */ new Map();
+		for (const m of members) {
+			const ceiling = parseVersion(m.ceiling);
+			const eligible = ceiling ? m.candidates.map((v) => ({
+				v,
+				sv: parseVersion(v)
+			})).filter((x) => x.sv !== null && x.sv.compare(ceiling) <= 0).sort((a, b) => b.sv.compare(a.sv)).map((x) => x.v) : [];
+			eligibleOf.set(m.pkg, eligible);
+		}
 		const maxIter = members.reduce((n, m) => n + m.candidates.length, 0) + members.length + 1;
 		for (let i = 0; i < maxIter; i++) {
 			let changed = false;
 			for (const m of members) {
 				const cur = resolved.get(m.pkg);
 				if ((yield* violations(m.pkg, cur, resolved, memberSet, fetchPeer)).length === 0) continue;
-				const ceiling = ceilingOf.get(m.pkg);
-				const eligible = [];
-				for (const c of m.candidates) if (yield* leq(c, ceiling)) eligible.push(c);
-				const sorted = yield* sortDesc(eligible);
 				let pick = null;
-				for (const c of sorted) if ((yield* violations(m.pkg, c, resolved, memberSet, fetchPeer)).length === 0) {
+				for (const c of eligibleOf.get(m.pkg) ?? []) if ((yield* violations(m.pkg, c, resolved, memberSet, fetchPeer)).length === 0) {
 					pick = c;
 					break;
 				}
@@ -124,20 +141,6 @@ function resolveGroup(members, fetchPeer) {
 		};
 	});
 }
-/** Sort version strings descending; unparseable ones sink to the end. */
-function sortDesc(versions) {
-	return Effect.gen(function* () {
-		const parsed = yield* Effect.forEach(versions, (v) => SemVer.parse(v).pipe(Effect.map((sv) => ({
-			v,
-			sv
-		})), Effect.catch(() => Effect.succeed({
-			v,
-			sv: null
-		}))));
-		parsed.sort((a, b) => a.sv && b.sv ? b.sv.compare(a.sv) : a.sv ? -1 : 1);
-		return parsed.map((p) => p.v);
-	});
-}
 /**
 * Fetch the peerDependencies needed to reconcile one catalog interop group,
 * then run the pure resolve + floor derivation. Failures degrade to empty
@@ -152,41 +155,28 @@ function sortDesc(versions) {
 * O(N × |candidates|) to O(N + |downgraded members| × depth).
 *
 * A `(pkg, version)` peerDeps lookup is immutable, so the optional `cache` may
-* be shared across the interactive re-entry rounds: each round only fetches the
-* keys a prior round did not, sparing the sequential `pnpm view` calls for
-* versions already seen. Omitting it yields a fresh per-call cache.
+* be shared across calls: each call only fetches the keys a prior one did not.
+* Omitting it yields a fresh per-call cache.
 *
 * @internal
 */
 function runInterop(members, resolver, cache = /* @__PURE__ */ new Map()) {
 	return Effect.gen(function* () {
-		const key = (pkg, v) => `${pkg}@${v}`;
-		const fetchPeer = (pkg, v) => {
-			const k = key(pkg, v);
-			const cached = cache.get(k);
-			if (cached !== void 0) return Effect.succeed(cached);
-			return resolver.peerDependencies(pkg, v).pipe(Effect.catch(() => Effect.succeed({}))).pipe(Effect.map((deps) => {
-				cache.set(k, deps);
-				return deps;
-			}));
-		};
+		const fetchPeer = makePeerFetcher(resolver, cache);
 		const seen = /* @__PURE__ */ new Set();
 		const toFetch = [];
 		for (const m of members) {
-			const k = key(m.pkg, m.ceiling);
+			const k = `${m.pkg}@${m.ceiling}`;
 			if (seen.has(k) || cache.has(k)) continue;
 			seen.add(k);
 			toFetch.push([m.pkg, m.ceiling]);
 		}
 		yield* Effect.forEach(toFetch, ([pkg, v]) => fetchPeer(pkg, v), { concurrency: 8 });
 		const { resolved, conflicts } = yield* resolveGroup(members, fetchPeer);
-		const peers = yield* deriveFloors(resolved, fetchPeer);
-		const peerDepsOf = (pkg, v) => cache.get(key(pkg, v)) ?? {};
 		return {
 			resolved,
-			peers,
-			conflicts,
-			peerDepsOf
+			peers: yield* deriveFloors(resolved, fetchPeer),
+			conflicts
 		};
 	});
 }
@@ -234,4 +224,4 @@ function buildInteropEdits(entries, result) {
 }
 
 //#endregion
-export { buildInteropEdits, deriveFloors, interopEntryChanged, resolveGroup, runInterop };
+export { buildInteropEdits, deriveFloors, interopEntryChanged, makePeerFetcher, resolveGroup, runInterop };

package/cli/load-config.js

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

package/cli/local-merge.js

@@ -1,3 +1,5 @@
+import { Predicate } from "effect";
+
 //#region src/cli/local-merge.ts
 /** Default protocols whose existing-file override entries are preserved. @internal */
 const DEFAULT_PRESERVE = [
@@ -19,13 +21,10 @@ const DIRECTIVE_KEYS = /* @__PURE__ */ new Set([
 * @internal
 */
 function isLocalDirective(v) {
-	if (v === null || typeof v !== "object" || Array.isArray(v)) return false;
+	if (!Predicate.isObject(v)) return false;
 	const keys = Object.keys(v);
 	return keys.length > 0 && keys.every((k) => DIRECTIVE_KEYS.has(k));
 }
-function isRecord(v) {
-	return v !== null && typeof v === "object" && !Array.isArray(v);
-}
 /** Union/difference two records or two arrays; managed is the left operand. */
 function combine(managed, value, strategy) {
 	if (Array.isArray(managed) || Array.isArray(value)) {
@@ -35,8 +34,8 @@ function combine(managed, value, strategy) {
 		const drop = new Set(v.map((x) => JSON.stringify(x)));
 		return m.filter((x) => !drop.has(JSON.stringify(x)));
 	}
-	const m = isRecord(managed) ? managed : {};
-	const v = isRecord(value) ? value : {};
+	const m = Predicate.isObject(managed) ? managed : {};
+	const v = Predicate.isObject(value) ? value : {};
 	if (strategy === "union") return {
 		...m,
 		...v
@@ -62,8 +61,8 @@ function applyLocalDirective(managed, raw, parsed, field) {
 	else result = managed;
 	if (field === "overrides") {
 		const protocols = directive.preserve ?? DEFAULT_PRESERVE;
-		const base = isRecord(result) ? { ...result } : {};
-		if (isRecord(parsed)) {
+		const base = Predicate.isObject(result) ? { ...result } : {};
+		if (Predicate.isObject(parsed)) {
 			for (const [k, val] of Object.entries(parsed)) if (typeof val === "string" && protocols.some((p) => val.startsWith(`${p}:`))) base[k] = val;
 		}
 		if (Object.keys(base).length === 0 && managed === void 0) return void 0;

package/cli/plan.js

@@ -1,10 +1,9 @@
+import { bareVersion, parseRange, parseVersion } from "../semver-util.js";
 import { derivePeerRange } from "./peer-range.js";
-import { Effect } from "effect";
+import { Effect, Option } from "effect";
 import { Range, SemVer } from "@effected/semver";
 
 //#region src/cli/plan.ts
-/** Parse a version, returning null instead of failing (filters junk tags). */
-const parseOrNull = (v) => SemVer.parse(v).pipe(Effect.catch(() => Effect.succeed(null)));
 /**
 * Compute the candidate versions for one catalog entry against the list of
 * published versions. Order: latest in-range (when newer than current), latest
@@ -16,71 +15,58 @@ const parseOrNull = (v) => SemVer.parse(v).pipe(Effect.catch(() => Effect.succee
 */
 function planEntry(entry, versions) {
 	return Effect.gen(function* () {
-		const range = yield* Range.parse(entry.currentRange).pipe(Effect.catch(() => Effect.succeed(null)));
-		const currentStripped = entry.currentRange.replace(/^[\^~]/, "");
-		const current = yield* parseOrNull(currentStripped);
+		const range = parseRange(entry.currentRange);
+		const current = parseVersion(bareVersion(entry.currentRange));
 		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 && (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 inRangeMax = range ? maxOf(parsed.filter((v) => range.test(v))) : null;
-		const sameMajorMax = maxOf(parsed.filter((v) => v.major === currentMajor));
-		const overallMax = maxOf(parsed);
+		const parsed = versions.map(parseVersion).filter((sv) => sv !== null && (sv.isStable || onTrack(sv)));
+		const inRangeMax = range ? Option.getOrNull(Range.maxSatisfying(parsed, range)) : null;
+		const sameMajorMax = Option.getOrNull(SemVer.max(parsed.filter((v) => v.major === currentMajor)));
+		const overallMax = Option.getOrNull(SemVer.max(parsed));
 		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 candidate = (kind, sv) => Effect.map(withPeer(sv.toString()), (peerRange) => ({
+			kind,
+			range: `${entry.operator}${sv}`,
+			version: sv.toString(),
+			isMajor: sv.major > currentMajor,
+			...peerRange ? { peerRange } : {}
+		}));
 		const candidates = [];
-		if (inRangeMax && (current === null || inRangeMax.gt(current))) {
-			const version = inRangeMax.toString();
-			const peerRange = yield* withPeer(version);
-			candidates.push({
-				kind: "in-range",
-				range: `${entry.operator}${version}`,
-				version,
-				isMajor: inRangeMax.major > currentMajor,
-				...peerRange ? { peerRange } : {}
-			});
-		}
+		if (inRangeMax && (current === null || inRangeMax.gt(current))) candidates.push(yield* candidate("in-range", inRangeMax));
 		if (sameMajorMax !== null) {
 			const beatsCurrent = current === null || sameMajorMax.gt(current);
 			const beatsInRange = inRangeMax === null || sameMajorMax.gt(inRangeMax);
 			const belowOverall = overallMax?.gt(sameMajorMax) ?? false;
-			if (beatsCurrent && beatsInRange && belowOverall) {
-				const version = sameMajorMax.toString();
-				const peerRange = yield* withPeer(version);
-				candidates.push({
-					kind: "minor",
-					range: `${entry.operator}${version}`,
-					version,
-					isMajor: sameMajorMax.major > currentMajor,
-					...peerRange ? { peerRange } : {}
-				});
-			}
-		}
-		if (overallMax && (current === null || overallMax.gt(current)) && (!inRangeMax || overallMax.gt(inRangeMax))) {
-			const version = overallMax.toString();
-			const peerRange = yield* withPeer(version);
-			candidates.push({
-				kind: "latest",
-				range: `${entry.operator}${version}`,
-				version,
-				isMajor: overallMax.major > currentMajor,
-				...peerRange ? { peerRange } : {}
-			});
+			if (beatsCurrent && beatsInRange && belowOverall) candidates.push(yield* candidate("minor", sameMajorMax));
 		}
+		if (overallMax && (current === null || overallMax.gt(current)) && (!inRangeMax || overallMax.gt(inRangeMax))) candidates.push(yield* candidate("latest", overallMax));
 		candidates.push({
 			kind: "keep",
 			range: entry.currentRange,
-			version: entry.currentRange.replace(/^[\^~]/, ""),
+			version: bareVersion(entry.currentRange),
 			isMajor: false
 		});
 		return candidates;
 	});
 }
+/**
+* The non-interactive default pick for an entry: the latest in-range
+* candidate, or — for a workspace-sourced entry — the sole non-keep
+* candidate. A workspace entry tracks its workspace's single next version,
+* which for a 0.x caret routinely falls OUTSIDE the current range (`^0.2.0`
+* does not contain 0.3.0); the never-cross-a-range rule protects against
+* surprise REGISTRY majors, and the workspace version is this repo's own
+* declared next release. Undefined when nothing but keep is on offer.
+*
+* Shared by `--yes`/`--check` (runUpgrade) and the `--preview` / non-TTY
+* projection (projectDecisions) so the three can never disagree.
+*
+* @internal
+*/
+function defaultPick(entry, candidates) {
+	return entry.source === "workspace" ? candidates.find((c) => c.kind !== "keep") : candidates.find((c) => c.kind === "in-range");
+}
 
 //#endregion
-export { planEntry };
+export { defaultPick, planEntry };

package/cli/release-age.js

@@ -1,3 +1,5 @@
+import { isWrappedField } from "../plugin/freeze.js";
+
 //#region src/cli/release-age.ts
 /**
 * Read a release-age gate from config and pnpm and combine it with
@@ -7,10 +9,7 @@
 * only turns this repo's two config sources into partial contributions.
 */
 /** Unwrap a managed field that may be a bare value or a `{ value, enforcement }` FieldInput. */
-function fieldValue(raw) {
-	if (raw && typeof raw === "object" && !Array.isArray(raw) && "value" in raw) return raw.value;
-	return raw;
-}
+const fieldValue = (raw) => isWrappedField(raw) ? raw.value : raw;
 /** Read the release-age gate declared in a statically-evaluated PnpmConfigPlugin config. @internal */
 function readConfigReleaseAge(config) {
 	if (!config) return null;