rolldown-pnpm-config 0.4.1 → 0.5.0

package/bin/rolldown-pnpm-config.js

@@ -12,7 +12,7 @@ const root = Command.make("rolldown-pnpm-config").pipe(Command.withSubcommands([
 	exportCommand,
 	previewCommand
 ]));
-Command.run(root, { version: "0.4.1" }).pipe(Effect.provide(NodeServices.layer), NodeRuntime.runMain);
+Command.run(root, { version: "0.5.0" }).pipe(Effect.provide(NodeServices.layer), NodeRuntime.runMain);
 
 //#endregion
 export {  };

package/catalogs.js

@@ -2,9 +2,11 @@
 /**
 * Normalize declarative catalog input into the resolved `{ catalog → pkg → range }`
 * map consumed by the runtime. Pure: the base catalog uses each package's
-* `range` (or bare string); a `<name>Peers` catalog is emitted only for packages
-* carrying a materialized `peer`, using that value verbatim. `strategy` is
-* CLI-only and ignored here.
+* `range` (or bare string); a peers catalog is emitted only for packages
+* carrying a materialized `peer`, using that value verbatim. The peers map is
+* emitted under BOTH `<name>Peers` (camelCase, legacy) and `<name>:peers`
+* (colon-delimited, preferred) during this transition; the camelCase form is
+* removed in a later branch. `strategy` is CLI-only and ignored here.
 *
 * @internal
 */
@@ -18,7 +20,10 @@ function normalizeCatalogs(input) {
 			if (typeof spec === "object" && spec.peer !== void 0) peers[pkg] = spec.peer;
 		}
 		out[name] = base;
-		if (Object.keys(peers).length > 0) out[`${name}Peers`] = peers;
+		if (Object.keys(peers).length > 0) {
+			out[`${name}Peers`] = peers;
+			out[`${name}:peers`] = peers;
+		}
 	}
 	return out;
 }

package/cli/commands/export.js

@@ -11,6 +11,7 @@ import { evaluatePluginConfig } from "../evaluate.js";
 import { findConfigFiles, pickConfigCandidate } from "../select-file.js";
 import { toAnsi } from "../ui/ansi.js";
 import { detectCapabilities } from "../ui/env.js";
+import { legendLines } from "../ui/legend.js";
 import { canonicalize, findWorkspaceFile, parseWorkspace, renderWorkspace } from "../workspace-file.js";
 import { overlayWorkspace } from "../workspace-overlay.js";
 import { Data, Effect, Option } from "effect";
@@ -139,8 +140,8 @@ const exportCommand = Command.make("export", {
 		if (dryRun) {
 			const caps = detectCapabilities();
 			process.stdout.write(`${result.path} (dry run — not written)\n\n`);
-			process.stdout.write(`${toAnsi(result.diff, { color: caps.color })}\n`);
-			process.stdout.write("\n+ added  ~ changed  - removed   (local) local override  (unmanaged) not managed\n");
+			const legend = caps.color ? `${toAnsi(legendLines(), { color: caps.color })}\n\n` : "";
+			process.stdout.write(`${legend}${toAnsi(result.diff, { color: caps.color })}\n`);
 		} else process.stdout.write(`Exported to ${result.path}\n`);
 		for (const k of result.report.staleEntries) process.stderr.write(`warning: patch entry "${k}" has no file on disk\n`);
 		for (const k of result.report.keyMismatches) process.stderr.write(`warning: patch entry "${k}" does not match its filename\n`);

package/cli/commands/preview.js

@@ -4,6 +4,7 @@ import { evaluatePluginConfig } from "../evaluate.js";
 import { findConfigFiles, pickConfigCandidate } from "../select-file.js";
 import { toAnsi } from "../ui/ansi.js";
 import { detectCapabilities } from "../ui/env.js";
+import { legendLines } from "../ui/legend.js";
 import { findWorkspaceFile, parseWorkspace } from "../workspace-file.js";
 import { WORKSPACE_FIELDS } from "./export.js";
 import { buildPreviewViews } from "../preview-views.js";
@@ -66,7 +67,10 @@ const previewCommand = Command.make("preview", { path: pathArg }, ({ path }) =>
 	});
 	const caps = detectCapabilities();
 	if (caps.interactive) yield* runPreview(views);
-	else yield* Effect.sync(() => process.stdout.write(`${toAnsi(views.changes, { color: caps.color })}\n`));
+	else yield* Effect.sync(() => {
+		const legend = caps.color ? `${toAnsi(legendLines(), { color: caps.color })}\n\n` : "";
+		process.stdout.write(`${legend}${toAnsi(views.changes, { color: caps.color })}\n`);
+	});
 })).pipe(Command.withDescription("Interactively preview how pnpm-workspace.yaml would change"));
 
 //#endregion

package/cli/commands/upgrade.js

@@ -5,7 +5,8 @@ import { detectCapabilities } from "../ui/env.js";
 import { derivePeerRange } from "../peer-range.js";
 import { detectPeerDrift } from "../drift.js";
 import { buildEdits } from "../edits.js";
-import { buildInteropEdits, capVersions, interopEntryChanged, reentryCandidates, runInterop } from "../interop.js";
+import { buildInteropEdits, interopEntryChanged, runInterop } from "../interop.js";
+import { buildGroupModel, computeGroupPeers } from "../interop-live.js";
 import { planEntry } from "../plan.js";
 import { combineReleaseAge, filterByReleaseAge, parsePnpmGate, readConfigReleaseAge } from "../release-age.js";
 import { RegistryResolver, RegistryResolverLive } from "../resolve.js";
@@ -256,19 +257,6 @@ function applyInteropAndDecisions(file, source, nonInteropEdits, interopEdits) {
 	});
 }
 /**
-* 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.
@@ -420,13 +408,11 @@ const upgradeCommand = Command.make("upgrade", {
 		yield* Effect.sync(() => process.stdout.write(`${text}${warn}\n\n${note}\n`));
 		return;
 	}
-	const actionable = actionableWalkItems(items, full);
-	if (actionable.length === 0) {
+	if (items.length === 0) {
 		const warn = versions.unresolved.length > 0 ? `⚠ ${unresolvedMessage(versions.unresolved)}\n\n` : "";
-		yield* Effect.sync(() => process.stdout.write(`${warn}${nothingToUpgradeMessage(items.length)}`));
+		yield* Effect.sync(() => process.stdout.write(`${warn}${nothingToUpgradeMessage(0)}`));
 		return;
 	}
-	const decisions = yield* runWalk(actionable, dryRun, versions.unresolved);
 	const interopByCatalog = /* @__PURE__ */ new Map();
 	for (const e of entries) {
 		if (e.strategy !== "interop") continue;
@@ -434,67 +420,64 @@ const upgradeCommand = Command.make("upgrade", {
 		list.push(e);
 		interopByCatalog.set(e.catalog, list);
 	}
+	const peerCache = /* @__PURE__ */ new Map();
+	const fetchPeer = (pkg, v) => {
+		const k = `${pkg}@${v}`;
+		const cached = peerCache.get(k);
+		if (cached !== void 0) return Effect.succeed(cached);
+		return resolver.peerDependencies(pkg, v).pipe(Effect.catch(() => Effect.succeed({})), Effect.map((deps) => {
+			peerCache.set(k, deps);
+			return deps;
+		}));
+	};
+	if (interopByCatalog.size > 0) yield* Effect.sync(() => process.stderr.write("Resolving peer dependencies…\n"));
+	const interopModels = /* @__PURE__ */ new Map();
+	for (const [catalog, group] of interopByCatalog) {
+		const candByPkg = /* @__PURE__ */ new Map();
+		for (const e of group) {
+			const it = items.find((i) => i.entry.catalog === catalog && i.entry.pkg === e.pkg);
+			candByPkg.set(e.pkg, it ? it.candidates.map((c) => c.version) : [e.currentRange.replace(/^[\^~]/, "")]);
+		}
+		interopModels.set(catalog, yield* buildGroupModel(candByPkg, fetchPeer));
+	}
+	const decisions = yield* runWalk(items, dryRun, versions.unresolved, interopModels);
 	const nonInteropDecisions = decisions.filter((d) => d.item.entry.strategy !== "interop");
 	const interopEdits = [];
-	const adjustments = [];
 	const allConflicts = [];
 	let interopChanged = 0;
-	for (const [, group] of interopByCatalog) {
-		const pickOf = (pkg) => {
-			const d = decisions.find((dd) => dd.item.entry.pkg === pkg);
-			if (d) return d.chosen.version;
-			const ge = group.find((g) => g.pkg === pkg);
-			return ge ? ge.currentRange.replace(/^[\^~]/, "") : "";
-		};
-		let members = group.map((e) => ({
-			pkg: e.pkg,
-			ceiling: pickOf(e.pkg),
-			candidates: versions.gated.get(e.pkg) ?? []
-		}));
-		const originalPick = new Map(members.map((m) => [m.pkg, m.ceiling]));
-		const peerCache = /* @__PURE__ */ new Map();
-		let result = yield* runInterop(members, resolver, peerCache);
-		for (let round = 0; round < members.length + 1; round++) {
-			const reentry = reentryCandidates(members, result);
-			if (reentry.length === 0) break;
-			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.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.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);
-				return rd ? {
-					...m,
-					ceiling: rd.chosen.version
-				} : m;
-			});
-			if (!members.some((m) => before.get(m.pkg) !== m.ceiling)) break;
-			result = yield* runInterop(members, resolver, peerCache);
+	for (const [catalog, group] of interopByCatalog) {
+		const model = interopModels.get(catalog);
+		if (model === void 0) continue;
+		const selected = /* @__PURE__ */ new Map();
+		for (const e of group) {
+			const d = decisions.find((dd) => dd.item.entry.catalog === catalog && dd.item.entry.pkg === e.pkg);
+			selected.set(e.pkg, d ? d.chosen.version : e.currentRange.replace(/^[\^~]/, ""));
 		}
-		interopEdits.push(...buildInteropEdits(group, result));
-		allConflicts.push(...result.conflicts);
+		const { peer, conflict } = computeGroupPeers(model, selected);
+		interopEdits.push(...buildInteropEdits(group, {
+			resolved: selected,
+			peers: peer,
+			conflicts: [],
+			peerDepsOf: () => ({})
+		}));
+		for (const [pkg, blockedBy] of conflict) allConflicts.push({
+			pkg,
+			ceiling: selected.get(pkg) ?? "",
+			blockedBy
+		});
 		for (const e of group) {
-			if (interopEntryChanged(e, result)) interopChanged++;
-			const version = result.resolved.get(e.pkg);
-			const original = originalPick.get(e.pkg);
-			if (version === void 0 || original === void 0 || version === original) continue;
-			adjustments.push({
-				catalog: e.catalog,
-				pkg: e.pkg,
-				from: `${e.operator}${original}`,
-				to: `${e.operator}${version}`,
-				peer: result.peers.get(e.pkg) ?? `^${version}`
-			});
+			const version = selected.get(e.pkg);
+			if (version === void 0) continue;
+			const rangeChanged = `${e.operator}${version}` !== e.currentRange;
+			const newPeer = peer.get(e.pkg);
+			const peerChanged = newPeer !== void 0 && (e.peer ? newPeer !== e.peer.value : true);
+			if (rangeChanged || peerChanged) interopChanged++;
 		}
 	}
 	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,
+		adjustments: [],
 		conflicts: allConflicts
 	}, { color: caps.color }, rejected)}\n`));
 	if (!dryRun) yield* applyInteropAndDecisions(file, source, accepted, interopEdits);
@@ -504,4 +487,4 @@ const upgradeCommand = Command.make("upgrade", {
 }).pipe(Effect.provide(RegistryResolverLive), Effect.provide(NodeServices.layer))).pipe(Command.withDescription("Upgrade catalog versions in a config file"));
 
 //#endregion
-export { UpgradeError, actionableWalkItems, applyInteropAndDecisions, computeGate, countChangedDecisions, nothingToUpgradeMessage, projectDecisions, resolveGatedVersions, resolveTargetFile, runUpgrade, runUpgradePreview, unresolvedMessage, upgradeCommand, writeResolveProgress };
+export { UpgradeError, applyInteropAndDecisions, computeGate, countChangedDecisions, nothingToUpgradeMessage, projectDecisions, resolveGatedVersions, resolveTargetFile, runUpgrade, runUpgradePreview, unresolvedMessage, upgradeCommand, writeResolveProgress };

package/cli/diff/render.js

@@ -15,12 +15,13 @@ const STYLE = {
 function scalarText(v) {
 	return typeof v === "string" ? v : JSON.stringify(v);
 }
-function flatten(node, depth) {
+function flatten(node, depth, inheritedUnmanaged = false) {
 	const indent = depth;
 	const gutter = GUTTER[node.kind];
-	const style = STYLE[node.kind];
 	const tag = node.tag;
 	const changed = node.kind !== "unchanged";
+	const unmanaged = inheritedUnmanaged || node.tag === "unmanaged" && node.kind === "unchanged";
+	const style = node.kind === "unchanged" && unmanaged ? "unmanaged" : STYLE[node.kind];
 	const isArrayEl = node.arrayElement === true;
 	if (node.children) return [{
 		line: {
@@ -33,7 +34,7 @@ function flatten(node, depth) {
 			...tag ? { tag } : {}
 		},
 		changed
-	}, ...node.children.flatMap((c) => flatten(c, depth + 1))];
+	}, ...node.children.flatMap((c) => flatten(c, depth + 1, unmanaged))];
 	let text;
 	if (node.kind === "changed") text = `${node.key}: ${scalarText(node.before)} → ${scalarText(node.after)}`;
 	else if (isArrayEl) text = `- ${node.key}`;

package/cli/interop-live.js

@@ -0,0 +1,117 @@
+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`
+* (peer floor is the LOWEST floor any in-group member declares for a package,
+* else `^<its selected version>`) and `violations` (a member conflicts when its
+* selected version's in-group peer requirement is not satisfied by the current
+* pick of that dep). Never changes a selection — detection only.
+*
+* @internal
+*/
+function computeGroupPeers(model, selected) {
+	const declaredFloors = /* @__PURE__ */ new Map();
+	for (const m of model.members) {
+		const v = selected.get(m);
+		if (v === void 0) continue;
+		for (const { dep, range } of model.peerReqs.get(`${m}@${v}`) ?? []) {
+			const list = declaredFloors.get(dep) ?? [];
+			list.push(floorOf(range));
+			declaredFloors.set(dep, list);
+		}
+	}
+	const peer = /* @__PURE__ */ new Map();
+	for (const m of model.members) {
+		const v = selected.get(m);
+		if (v === void 0) continue;
+		const declared = declaredFloors.get(m);
+		if (declared?.length) {
+			let minStr = declared[0];
+			let minSv = model.ver.get(minStr) ?? null;
+			for (const f of declared.slice(1)) {
+				const sv = model.ver.get(f) ?? null;
+				if (sv && (minSv === null || sv.compare(minSv) < 0)) {
+					minSv = sv;
+					minStr = f;
+				}
+			}
+			peer.set(m, `^${minStr}`);
+		} else peer.set(m, `^${v}`);
+	}
+	const conflict = /* @__PURE__ */ new Map();
+	for (const m of model.members) {
+		const v = selected.get(m);
+		if (v === void 0) continue;
+		const bad = [];
+		for (const { dep, range } of model.peerReqs.get(`${m}@${v}`) ?? []) {
+			const dv = selected.get(dep);
+			if (dv === void 0) continue;
+			const r = model.rng.get(range) ?? null;
+			const sv = model.ver.get(dv) ?? null;
+			if (!(r && sv && r.test(sv))) bad.push(`${dep} ${range}`);
+		}
+		if (bad.length) conflict.set(m, bad.join(", "));
+	}
+	return {
+		peer,
+		conflict
+	};
+}
+/**
+* Build a {@link GroupModel} for one interop catalog group: fetch the
+* peerDependencies of every member's candidate version (in-group deps only) via
+* the shared memoized `fetchPeer`, then pre-parse every version and range string
+* so the table can recompute floors/conflicts without further Effects.
+*
+* @internal
+*/
+function buildGroupModel(candidatesByPkg, fetchPeer) {
+	return Effect.gen(function* () {
+		const members = new Set(candidatesByPkg.keys());
+		const peerReqs = /* @__PURE__ */ new Map();
+		const verStrings = /* @__PURE__ */ new Set();
+		const rngStrings = /* @__PURE__ */ new Set();
+		const pairs = [];
+		for (const [pkg, versions] of candidatesByPkg) for (const v of versions) pairs.push([pkg, v]);
+		const fetched = yield* Effect.forEach(pairs, ([pkg, v]) => fetchPeer(pkg, v).pipe(Effect.map((deps) => [
+			pkg,
+			v,
+			deps
+		])), { concurrency: 8 });
+		for (const [pkg, v, deps] of fetched) {
+			verStrings.add(v);
+			const reqs = [];
+			for (const [dep, range] of Object.entries(deps)) {
+				if (!members.has(dep)) continue;
+				reqs.push({
+					dep,
+					range
+				});
+				rngStrings.add(range);
+				verStrings.add(floorOf(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
+		};
+	});
+}
+
+//#endregion
+export { buildGroupModel, computeGroupPeers };

package/cli/interop.js

@@ -190,35 +190,6 @@ function runInterop(members, resolver, cache = /* @__PURE__ */ new Map()) {
 		};
 	});
 }
-/**
-* The members to re-prompt in the interactive re-entry: each downgraded or
-* conflicted dependent (capped at its resolved version) PLUS the in-group peer
-* targets those dependents depend on (uncapped, so the user can RAISE the anchor
-* instead of accepting the downgrade). `cap` is the version to cap candidates at,
-* or null for an uncapped anchor.
-*
-* @internal
-*/
-function reentryCandidates(members, result) {
-	const memberSet = new Set(members.map((m) => m.pkg));
-	const byPkg = new Map(members.map((m) => [m.pkg, m]));
-	const conflicted = new Set(result.conflicts.map((c) => c.pkg));
-	const out = /* @__PURE__ */ new Map();
-	for (const m of members) {
-		const r = result.resolved.get(m.pkg);
-		if (r === void 0) continue;
-		if (r !== m.ceiling || conflicted.has(m.pkg)) out.set(m.pkg, r);
-	}
-	for (const pkg of [...out.keys()]) {
-		const m = byPkg.get(pkg);
-		if (!m) continue;
-		for (const dep of Object.keys(result.peerDepsOf(pkg, m.ceiling))) if (memberSet.has(dep) && !out.has(dep)) out.set(dep, null);
-	}
-	return [...out].map(([pkg, cap]) => ({
-		pkg,
-		cap
-	}));
-}
 /** True when an interop member's resolved version/peer differs from what's in source. @internal */
 function interopEntryChanged(e, result) {
 	const version = result.resolved.get(e.pkg);
@@ -261,25 +232,6 @@ function buildInteropEdits(entries, result) {
 	}
 	return edits;
 }
-/**
-* Keep only the versions less than or equal to `max` (SemVer comparison). Used
-* to cap the candidate list of a re-prompted interop member. An unparseable
-* `max` leaves the list unchanged.
-*
-* @internal
-*/
-function capVersions(list, max) {
-	return Effect.gen(function* () {
-		const mv = yield* SemVer.parse(max).pipe(Effect.catch(() => Effect.succeed(null)));
-		if (!mv) return [...list];
-		const out = [];
-		for (const v of list) {
-			const sv = yield* SemVer.parse(v).pipe(Effect.catch(() => Effect.succeed(null)));
-			if (sv && sv.compare(mv) <= 0) out.push(v);
-		}
-		return out;
-	});
-}
 
 //#endregion
-export { buildInteropEdits, capVersions, deriveFloors, interopEntryChanged, reentryCandidates, resolveGroup, runInterop };
+export { buildInteropEdits, deriveFloors, interopEntryChanged, resolveGroup, runInterop };

package/cli/plan.js

@@ -30,6 +30,7 @@ function planEntry(entry, versions) {
 		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 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 = [];
@@ -44,6 +45,22 @@ function planEntry(entry, versions) {
 				...peerRange ? { peerRange } : {}
 			});
 		}
+		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);

package/cli/preview-views.js

@@ -4,12 +4,14 @@ import { effectiveManaged, vanillaManaged } from "./effective.js";
 import { canonicalize } from "./workspace-file.js";
 import { overlayWorkspace } from "./workspace-overlay.js";
 import { WORKSPACE_FIELDS } from "./commands/export.js";
+import { renderSimulated } from "./simulated-view.js";
 
 //#region src/cli/preview-views.ts
 /**
-* Build the three preview views as styled lines: Changes (parsed→merged, with
-* local + preserve + excludeByRepo), Full (same tree, full verbosity), and
-* Simulated (parsed→vanilla fresh-consumer output, no local/overlay).
+* Build the three preview views as styled lines: Changes (parsed→merged diff,
+* with local + preserve + excludeByRepo), Full (same tree, full verbosity), and
+* Simulated (the fresh-consumer output rendered as a plain calculated file — not
+* a diff — with per-field merge/overwrite + enforcement annotations).
 *
 * @internal
 */
@@ -20,13 +22,11 @@ function buildPreviewViews(input) {
 	};
 	const merged = overlayWorkspace(effectiveManaged(input.managed, input.local, input.parsed, input.manifest, input.rootName), input.parsed);
 	const vanilla = vanillaManaged(input.managed, input.manifest, input.rootName);
-	const before = canonicalize(input.parsed);
-	const changesTree = buildDiff(before, canonicalize(merged), meta);
-	const simulatedTree = buildDiff(before, canonicalize(vanilla), meta);
+	const changesTree = buildDiff(canonicalize(input.parsed), canonicalize(merged), meta);
 	return {
 		changes: renderExportDiff(changesTree, { full: false }),
 		full: renderExportDiff(changesTree, { full: true }),
-		simulated: renderExportDiff(simulatedTree, { full: false })
+		simulated: renderSimulated(vanilla, input.manifest)
 	};
 }
 

package/cli/simulated-view.js

@@ -0,0 +1,105 @@
+import { canonicalize } from "./workspace-file.js";
+
+//#region src/cli/simulated-view.ts
+/**
+* How each merge strategy combines a managed field with the consumer's local
+* value, in the vocabulary the Simulated view shows: `merge` (values combined)
+* or `overwrite` (the plugin value replaces the local one). Keyed by manifest
+* strategy name; a new strategy defaults to `merge` and should be classified here.
+*/
+const STRATEGY_VERB = {
+	scalar: "overwrite",
+	securityFlag: "overwrite",
+	securityMin: "overwrite",
+	catalogs: "merge",
+	mapChildWins: "merge",
+	arrayUnion: "merge",
+	arrayRecordUnion: "merge",
+	overrides: "merge",
+	peerDependencyRules: "merge",
+	allowBuilds: "merge"
+};
+/** The enforcement suffix, e.g. " · warn" / " · error"; empty when silent. */
+function enforcementSegs(e) {
+	if (e === "warn") return [{
+		text: " · warn",
+		style: "changed"
+	}];
+	if (e === "error") return [{
+		text: " · error",
+		style: "warn"
+	}];
+	return [];
+}
+/** The trailing "(merge)" / "(overwrite · error)" annotation for one field. */
+function annotation(entry) {
+	if (!entry) return [];
+	const verb = STRATEGY_VERB[entry.strategy] ?? "merge";
+	return [
+		{
+			text: "  (",
+			style: "unchanged"
+		},
+		{
+			text: verb,
+			style: verb
+		},
+		...enforcementSegs(entry.enforcement),
+		{
+			text: ")",
+			style: "unchanged"
+		}
+	];
+}
+function scalarText(v) {
+	return typeof v === "string" ? v : JSON.stringify(v);
+}
+/** Flatten one key/value into YAML-shaped plain lines; `ann` annotates the head. */
+function flatten(key, value, depth, ann) {
+	if (Array.isArray(value)) return [{
+		indent: depth,
+		gutter: " ",
+		segments: [{
+			text: `${key}:`,
+			style: "plain"
+		}, ...ann]
+	}, ...value.map((el) => ({
+		indent: depth + 1,
+		gutter: " ",
+		segments: [{
+			text: `- ${scalarText(el)}`,
+			style: "plain"
+		}]
+	}))];
+	if (value !== null && typeof value === "object") return [{
+		indent: depth,
+		gutter: " ",
+		segments: [{
+			text: `${key}:`,
+			style: "plain"
+		}, ...ann]
+	}, ...Object.entries(value).flatMap(([k, v]) => flatten(k, v, depth + 1, []))];
+	return [{
+		indent: depth,
+		gutter: " ",
+		segments: [{
+			text: `${key}: ${scalarText(value)}`,
+			style: "plain"
+		}, ...ann]
+	}];
+}
+/**
+* Render the Simulated view: the calculated fresh-consumer config as a plain
+* pnpm-workspace.yaml listing (NOT a diff against the local file — nothing is
+* added or removed), each top-level field annotated with how the plugin would
+* combine it (`merge`/`overwrite`) and its enforcement (`warn`/`error`).
+*
+* @internal
+*/
+function renderSimulated(vanilla, manifest) {
+	const canon = canonicalize(vanilla);
+	return Object.entries(canon).flatMap(([k, v]) => flatten(k, v, 0, annotation(manifest[k])));
+}
+
+//#endregion
+export { renderSimulated };

package/cli/ui/Preview.js

@@ -1,29 +1,31 @@
+import { legendLines, simulatedLegendLines } from "./legend.js";
 import { Box, Text, useApp, useInput } from "ink";
 import { createElement, useState } from "react";
 import { Tab, Tabs } from "ink-tab";
 
 //#region src/cli/ui/Preview.ts
-const INK_COLOR = {
-	added: "green",
-	removed: "red",
-	changed: "yellow",
-	warn: "red",
-	local: "magenta",
-	unmanaged: "gray",
-	unchanged: "gray",
-	plain: void 0
+const INK_PROPS = {
+	added: { color: "green" },
+	removed: { color: "red" },
+	changed: { color: "yellow" },
+	warn: { color: "red" },
+	local: { color: "magenta" },
+	unmanaged: { color: "#585858" },
+	unchanged: { dimColor: true },
+	plain: {},
+	merge: { color: "cyan" },
+	overwrite: { color: "magenta" }
 };
 const TabC = Tab;
 const TabsC = Tabs;
 function renderLines(lines) {
 	return createElement(Box, { flexDirection: "column" }, ...lines.map((l, i) => {
 		const indent = "  ".repeat(l.indent);
-		const tag = l.tag ? `  (${l.tag})` : "";
+		const tag = l.tag === "local" ? "  (local)" : "";
 		const body = l.segments.map((s, j) => {
-			const color = INK_COLOR[s.style];
 			return createElement(Text, {
 				key: j,
-				...color ? { color } : {}
+				...INK_PROPS[s.style] ?? {}
 			}, s.text);
 		});
 		return createElement(Text, { key: i }, `${l.gutter} ${indent}`, ...body, tag);
@@ -39,7 +41,7 @@ function Preview({ views, onExit }) {
 	const app = useApp();
 	const [active, setActive] = useState("changes");
 	useInput((input, key) => {
-		if (input === "q" || key.escape) {
+		if (input === "q" || key.escape || key.return) {
 			onExit();
 			app.exit();
 		}
@@ -53,7 +55,7 @@ function Preview({ views, onExit }) {
 	}, "Full"), createElement(TabC, {
 		name: "simulated",
 		key: "simulated"
-	}, "Simulated")), renderLines(views[active]));
+	}, "Simulated")), renderLines(active === "simulated" ? simulatedLegendLines() : legendLines()), renderLines(views[active]));
 }
 
 //#endregion

package/cli/ui/Walk.js

@@ -1,4 +1,5 @@
-import { cellColor, displayCandidates, initTable, peerFor, tableDecisions, tableStep } from "../walk-reducer.js";
+import { computeGroupPeers } from "../interop-live.js";
+import { cellColor, displayCandidates, initTable, peerFor, tableDecisions, tableStep, truncateEnd } from "../walk-reducer.js";
 import { Box, Text, useApp, useInput } from "ink";
 import { createElement, useEffect, useState } from "react";
 
@@ -15,7 +16,7 @@ const VIEWPORT = 20;
 *
 * @internal
 */
-function Walk({ items, onDone, dryRun = false, unresolved = [] }) {
+function Walk({ items, onDone, dryRun = false, unresolved = [], interopModels = /* @__PURE__ */ new Map() }) {
 	const app = useApp();
 	const [state, setState] = useState(() => initTable(items));
 	useEffect(() => {
@@ -43,8 +44,20 @@ function Walk({ items, onDone, dryRun = false, unresolved = [] }) {
 	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 termCols = process.stdout.columns ?? 100;
+	const fixedPrefix = 2 + (pkgWidth + 2) + maxCells * (cellWidth + 4) + 2;
 	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 interopPeers = /* @__PURE__ */ new Map();
+	for (const [catalog, model] of interopModels) {
+		const selected = /* @__PURE__ */ new Map();
+		items.forEach((it, idx) => {
+			if (it.entry.catalog !== catalog) return;
+			const cand = displayCandidates(it)[state.picks[idx] ?? 0];
+			if (cand) selected.set(it.entry.pkg, cand.version);
+		});
+		interopPeers.set(catalog, computeGroupPeers(model, selected));
+	}
 	const rows = [];
 	let lastCatalog = null;
 	visible.forEach((item, offset) => {
@@ -72,7 +85,11 @@ function Walk({ items, onDone, dryRun = false, unresolved = [] }) {
 		});
 		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));
+		const gp = interopPeers.get(item.entry.catalog);
+		const peerText = gp?.peer.get(item.entry.pkg) ?? (chosen === void 0 ? "—" : peerFor(item, chosen));
+		const conflict = gp?.conflict.get(item.entry.pkg);
+		const room = Math.max(8, termCols - fixedPrefix - peerText.length - 3);
+		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 }, `│ ${peerText}`), conflict ? createElement(Text, { color: "red" }, truncateEnd(`  ⚠ needs ${conflict}`, room)) : null, item.peerWarning ? createElement(Text, { color: "red" }, truncateEnd(`  ⚠ ${item.peerWarning.message}`, room)) : 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);
 }

package/cli/ui/ansi.js

@@ -12,7 +12,7 @@ function toAnsi(lines, opts) {
 	return lines.map((l) => {
 		const indent = "  ".repeat(l.indent);
 		const body = l.segments.map((s) => paint(s.text, s.style, opts.color)).join("");
-		return `${l.gutter} ${indent}${body}${tagSuffix(l.tag)}`;
+		return `${l.gutter} ${indent}${body}${tagSuffix(l.tag, opts.color)}`;
 	}).join("\n");
 }
 

package/cli/ui/legend.js

@@ -0,0 +1,80 @@
+//#region src/cli/ui/legend.ts
+/**
+* The color legend for the config diff (the `preview` command and
+* `export --dry-run`). A single styled line whose swatches each carry the
+* matching `ChangeStyle`, so the legend automatically tracks the palette.
+* Callers prepend it only when color is on — with color off the swatches are
+* indistinguishable and the legend is just noise.
+*
+* @internal
+*/
+function legendLines() {
+	return [{
+		indent: 0,
+		gutter: " ",
+		segments: [
+			{
+				text: "Legend:  ",
+				style: "plain"
+			},
+			{
+				text: "■ added  ",
+				style: "added"
+			},
+			{
+				text: "■ removed  ",
+				style: "removed"
+			},
+			{
+				text: "■ modified  ",
+				style: "changed"
+			},
+			{
+				text: "■ unchanged  ",
+				style: "unchanged"
+			},
+			{
+				text: "■ unmanaged",
+				style: "unmanaged"
+			}
+		]
+	}];
+}
+/**
+* The legend for the Simulated view. That view is not a diff — nothing is added
+* or removed — so it gets its own vocabulary: how each field is combined
+* (`merge`/`overwrite`) and how divergence is enforced (`warn`/`error`).
+*
+* @internal
+*/
+function simulatedLegendLines() {
+	return [{
+		indent: 0,
+		gutter: " ",
+		segments: [
+			{
+				text: "Legend:  ",
+				style: "plain"
+			},
+			{
+				text: "■ merge  ",
+				style: "merge"
+			},
+			{
+				text: "■ overwrite  ",
+				style: "overwrite"
+			},
+			{
+				text: "■ warn  ",
+				style: "changed"
+			},
+			{
+				text: "■ error",
+				style: "warn"
+			}
+		]
+	}];
+}
+
+//#endregion
+export { legendLines, simulatedLegendLines };

package/cli/ui/run-preview.js

@@ -15,7 +15,7 @@ function runPreview(views) {
 		render(createElement(Preview, {
 			views,
 			onExit: () => {}
-		})).waitUntilExit().then(() => resume(Effect.void));
+		})).waitUntilExit().then(() => resume(Effect.void)).catch((err) => resume(Effect.die(err)));
 	});
 }
 

package/cli/ui/run-walk.js

@@ -11,19 +11,18 @@ import { createElement } from "react";
 *
 * @internal
 */
-function runWalk(items, dryRun = false, unresolved = []) {
+function runWalk(items, dryRun = false, unresolved = [], interopModels = /* @__PURE__ */ new Map()) {
 	return Effect.callback((resume) => {
 		let collected = [];
 		render(createElement(Walk, {
 			items,
 			dryRun,
 			unresolved,
+			interopModels,
 			onDone: (d) => {
 				collected = d;
 			}
-		})).waitUntilExit().then(() => {
-			resume(Effect.succeed([...collected]));
-		});
+		})).waitUntilExit().then(() => resume(Effect.succeed([...collected]))).catch((err) => resume(Effect.die(err)));
 	});
 }
 

package/cli/ui/styled.js

@@ -6,9 +6,11 @@ const ANSI_OPEN = {
 	changed: "\x1B[33m",
 	warn: "\x1B[31m",
 	local: "\x1B[35m",
-	unmanaged: "\x1B[2m",
+	unmanaged: "\x1B[38;5;240m",
 	unchanged: "\x1B[2m",
-	plain: ""
+	plain: "",
+	merge: "\x1B[36m",
+	overwrite: "\x1B[35m"
 };
 const ANSI_RESET = "\x1B[0m";
 /** Apply (or omit) the SGR code for a style. @internal */
@@ -16,10 +18,17 @@ function paint(text, style, color) {
 	if (!color || style === "plain" || ANSI_OPEN[style] === "") return text;
 	return `${ANSI_OPEN[style]}${text}${ANSI_RESET}`;
 }
-/** The trailing annotation for a tag, e.g. "  (local)". @internal */
-function tagSuffix(tag) {
+/**
+* The trailing annotation for a tag, e.g. "  (local)". With color on, the
+* `unmanaged` tag is dropped — the dedicated gray shade plus the legend already
+* convey it — but it is kept when color is off, where the shade is invisible and
+* the tag is the only signal (the tags-stay-meaningful-without-color contract).
+*
+* @internal
+*/
+function tagSuffix(tag, color) {
 	if (tag === "local") return "  (local)";
-	if (tag === "unmanaged") return "  (unmanaged)";
+	if (tag === "unmanaged") return color ? "" : "  (unmanaged)";
 	return "";
 }
 

package/cli/walk-reducer.js

@@ -2,9 +2,22 @@
 const ORDER = {
 	keep: 0,
 	"in-range": 1,
-	latest: 2
+	minor: 2,
+	latest: 3
 };
 /**
+* Truncate `s` to at most `max` display columns, appending `…` when clipped.
+* Keeps a long peer-conflict annotation from wrapping and breaking the table's
+* column alignment. A `max` of 1 or less yields just the ellipsis.
+*
+* @internal
+*/
+function truncateEnd(s, max) {
+	if (s.length <= max) return s;
+	if (max <= 1) return "…";
+	return `${s.slice(0, max - 1)}…`;
+}
+/**
 * 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.
@@ -15,14 +28,18 @@ function displayCandidates(item) {
 	return [...item.candidates].sort((a, b) => ORDER[a.kind] - ORDER[b.kind]);
 }
 /**
-* Initialize the table: cursor on the first row, keep selected on every row, so
-* the default state applies nothing.
+* Initialize the table: keep selected on every row (so the default state applies
+* nothing), and the cursor on the first actionable row. Since every discovered
+* row is shown — up-to-date rows included, as context — the cursor skips past any
+* leading inert keep-only rows to land where the user can act; it falls back to
+* row 0 when nothing is actionable.
 *
 * @internal
 */
 function initTable(items) {
+	const first = items.findIndex((i) => !i.upToDate);
 	return {
-		cursor: 0,
+		cursor: first === -1 ? 0 : first,
 		picks: items.map(() => 0),
 		done: false,
 		cancelled: false
@@ -113,4 +130,4 @@ function cellColor(candidate, selected) {
 }
 
 //#endregion
-export { cellColor, displayCandidates, initTable, peerFor, tableDecisions, tableStep };
+export { cellColor, displayCandidates, initTable, peerFor, tableDecisions, tableStep, truncateEnd };

package/index.d.ts

@@ -29,6 +29,33 @@ interface CatalogDeclaration {
   readonly packages: Record<string, CatalogPackageSpec>;
 }
 //#endregion
+//#region src/plugin/allowed-versions.d.ts
+/**
+ * A directive that derives `peerDependencyRules.allowedVersions` rules from a
+ * catalog. For each catalog entry with an exact pinned version, a version-
+ * qualified rule `"<name>@<pin>><peer>"` is emitted, valued at the `peer`
+ * package's own catalog version (optionally re-prefixed) — retiring the "unmet
+ * peer on a fast prerelease line" warning class without ever masking a
+ * genuinely-unmet range: pnpm applies a qualified rule only when the parent
+ * instance's version satisfies the exact qualifier, so a same-named satellite on
+ * a different version line keeps its real complaint.
+ *
+ * @public
+ */
+interface AllowedVersionsFromCatalogs {
+  /** The catalog whose entries supply the rules. */
+  readonly catalog: string;
+  /** The peer package each rule targets; its own version becomes the rule value and it gets no rule of its own. */
+  readonly peer: string;
+  /**
+   * Operator applied to the derived peer value. Omit to use the peer's catalog
+   * value verbatim (`4.0.0-beta.99` stays exact, `^3.0.0` stays `^3.0.0`); set
+   * `"^"` / `"~"` / `">="` etc. to strip the existing operator and apply this
+   * one; set `null` or `""` to strip to an exact version.
+   */
+  readonly prefix?: string | null;
+}
+//#endregion
 //#region src/runtime/types.d.ts
 /**
  * How a field's divergences are enforced: silent, console warning, or a thrown
@@ -130,6 +157,12 @@ interface PluginConfig {
     readonly allowedVersions?: Record<string, string>;
     readonly ignoreMissing?: string[];
     readonly allowAny?: string[];
+    /**
+     * Derive version-qualified `allowedVersions` rules from a catalog (or several).
+     * Resolved and merged into `allowedVersions` at build time, then stripped; a
+     * manually authored `allowedVersions` entry wins on a key clash.
+     */
+    readonly allowedVersionsFromCatalogs?: AllowedVersionsFromCatalogs | readonly AllowedVersionsFromCatalogs[];
   }>;
   /** Whether dependency build scripts are blocked unless explicitly allowed. */
   readonly strictDepBuilds?: FieldInput<boolean>;
@@ -373,5 +406,5 @@ interface PluginConfig {
  */
 declare function PnpmConfigPlugin(config: PluginConfig): Plugin;
 //#endregion
-export { type CatalogDeclaration, type CatalogPackageSpec, type Enforcement, type FieldInput, type LocalDirective, type PeerStrategy, type PluginConfig, PnpmConfigPlugin };
+export { type AllowedVersionsFromCatalogs, type CatalogDeclaration, type CatalogPackageSpec, type Enforcement, type FieldInput, type LocalDirective, type PeerStrategy, type PluginConfig, PnpmConfigPlugin };
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rolldown-pnpm-config",
-	"version": "0.4.1",
+	"version": "0.5.0",
 	"private": false,
 	"description": "A dogfooding example of our plugin",
 	"repository": {
@@ -35,10 +35,10 @@
 		"rolldown-pnpm-config": "bin/rolldown-pnpm-config.js"
 	},
 	"dependencies": {
-		"@effect/platform-node": "4.0.0-beta.98",
-		"@effected/semver": "^0.1.0",
-		"@effected/yaml": "^0.3.1",
-		"effect": "4.0.0-beta.98",
+		"@effect/platform-node": "4.0.0-beta.99",
+		"@effected/semver": "^0.2.0",
+		"@effected/yaml": "^0.5.0",
+		"effect": "4.0.0-beta.99",
 		"ink": "^7.1.1",
 		"ink-tab": "^5.2.0",
 		"oxc-parser": "^0.140.0",

package/plugin/allowed-versions.js

@@ -0,0 +1,60 @@
+//#region src/plugin/allowed-versions.ts
+/** An exact version: no range operator, no wildcard — `X.Y.Z` with an optional prerelease. */
+const EXACT_VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+/** The install range of a catalog spec (bare string or `{ range }` object). */
+const rangeOf = (spec) => typeof spec === "string" ? spec : spec.range;
+/** Strip a leading range operator to the bare version digits (e.g. `^3.17.0` → `3.17.0`). */
+const bareVersion = (range) => range.replace(/^[\^~>=<\s]+/, "").split(/\s/)[0] ?? range;
+/** Apply the `prefix` transform to a peer value: verbatim, re-prefixed, or stripped to exact. */
+function applyPrefix(peerValue, prefix) {
+	if (prefix === void 0) return peerValue;
+	const bare = bareVersion(peerValue);
+	return prefix === null || prefix === "" ? bare : `${prefix}${bare}`;
+}
+/** Derive the rules for one directive. Pure; throws when the catalog or peer is absent. */
+function deriveOne(catalogs, { catalog, peer, prefix }) {
+	const decl = catalogs[catalog];
+	if (decl === void 0) throw new Error(`allowedVersionsFromCatalogs: catalog "${catalog}" is not declared`);
+	const peerSpec = decl.packages[peer];
+	if (peerSpec === void 0) throw new Error(`allowedVersionsFromCatalogs: peer "${peer}" is not in catalog "${catalog}"`);
+	const value = applyPrefix(rangeOf(peerSpec), prefix);
+	const table = {};
+	for (const [name, spec] of Object.entries(decl.packages)) {
+		if (name === peer) continue;
+		const range = rangeOf(spec);
+		if (!EXACT_VERSION.test(range)) continue;
+		table[`${name}@${range}>${peer}`] = value;
+	}
+	return table;
+}
+/** Merge the derived rules for one or more directives (later directives win on a key clash). */
+function deriveAllowedVersions(catalogs, directives) {
+	const list = Array.isArray(directives) ? directives : [directives];
+	const out = {};
+	for (const d of list) Object.assign(out, deriveOne(catalogs, d));
+	return out;
+}
+/**
+* Resolve a `peerDependencyRules` value carrying an `allowedVersionsFromCatalogs`
+* directive: derive the rules from the catalogs, merge them into `allowedVersions`
+* (an explicitly authored entry wins on a key clash), and strip the directive so
+* the cleaned value passes the `peerDependencyRules` schema. Any value without the
+* directive passes through untouched.
+*
+* @internal
+*/
+function resolvePeerDependencyRules(value, catalogs) {
+	if (value === null || typeof value !== "object" || !("allowedVersionsFromCatalogs" in value)) return value;
+	const { allowedVersionsFromCatalogs, ...rest } = value;
+	const merged = {
+		...deriveAllowedVersions(catalogs, allowedVersionsFromCatalogs),
+		...rest.allowedVersions ?? {}
+	};
+	return {
+		...rest,
+		...Object.keys(merged).length > 0 ? { allowedVersions: merged } : {}
+	};
+}
+
+//#endregion
+export { deriveAllowedVersions, resolvePeerDependencyRules };

package/plugin/freeze.js

@@ -1,6 +1,7 @@
 import { normalizeCatalogs } from "../catalogs.js";
 import { DESCRIPTORS, deriveSchemas } from "../descriptors/index.js";
 import { FIELD_REGISTRY } from "../registry.js";
+import { resolvePeerDependencyRules } from "./allowed-versions.js";
 import { Data, Effect, Schema } from "effect";
 
 //#region src/plugin/freeze.ts
@@ -60,7 +61,11 @@ function freeze(config) {
 			if (raw === void 0) continue;
 			const decl = normalizeField(raw);
 			const schema = FIELD_SCHEMAS[field];
-			base[field] = schema ? yield* Schema.decodeUnknownEffect(schema)(decl.value).pipe(Effect.mapError((error) => new ConfigError({ message: `Invalid ${field}: ${String(error)}` }))) : decl.value;
+			const value = field === "peerDependencyRules" ? yield* Effect.try({
+				try: () => resolvePeerDependencyRules(decl.value, config.catalogs),
+				catch: (error) => new ConfigError({ message: error instanceof Error ? error.message : String(error) })
+			}) : decl.value;
+			base[field] = schema ? yield* Schema.decodeUnknownEffect(schema)(value).pipe(Effect.mapError((error) => new ConfigError({ message: `Invalid ${field}: ${String(error)}` }))) : value;
 			manifest[field] = {
 				strategy: reg.strategy,
 				enforcement: decl.enforcement ?? reg.enforcement,