@askrjs/cli 0.0.5 → 0.0.6

package/README.md

@@ -1,5 +1,8 @@
 # @askrjs/cli
 
+[![CI](https://github.com/askrjs/askr-cli/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/askrjs/askr-cli/actions/workflows/ci.yml)
+[![npm version](https://img.shields.io/npm/v/%40askrjs%2Fcli.svg)](https://www.npmjs.com/package/@askrjs/cli)
+
 Unified CLI for the Askr platform.
 
 `@askrjs/cli` bundles project scaffolding and static-site generation commands
@@ -117,15 +120,17 @@ and failed decisions without running an install.
 askr outdated
 askr update
 askr upgrade
+askr upgrade --force
 askr update vite "@types/*"
 askr update --workspace "@scope/app" --tag next --json
 ```
 
-`askr update` writes safe range changes. `askr upgrade` additionally permits next-version
-major changes for stable packages and breaking minor changes for `0.x`
-packages. Peer requirements from co-dependencies are still enforced: a target
-is left for manual review if it would move outside another selected package's
-published peer range. `askr upgrade` never bypasses that compatibility guard.
+`askr update` writes safe range changes. `askr upgrade` jointly selects the newest
+peer-compatible published versions up to each package's configured dist-tag,
+including breaking changes. Required peers must be present; optional peers may
+be absent. `askr upgrade --force` writes the dist-tag targets directly and skips
+peer checks. Positional selection is strict: unselected dependencies constrain
+the solution but are never rewritten.
 
 The updater preserves exact, caret, tilde, and x-range styles. It can widen one
 bounded interval, and it updates only the highest clause of a simple OR union.

package/dist/{discovery-Difb7Y4G.js → discovery-Djq8TxJu.js}

@@ -4,6 +4,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { load } from "js-yaml";
 import { minimatch } from "minimatch";
+import semver from "semver";
 //#region src/update/types.ts
 const DEPENDENCY_SECTIONS = [
 	"dependencies",
@@ -307,6 +308,7 @@ async function discoverProject(options) {
 	const selectedWorkspaces = options.workspacePatterns.length === 0 ? workspaces : workspaces.filter((workspace) => matchesAny(workspace.name, options.workspacePatterns));
 	if (selectedWorkspaces.length === 0) throw new Error("No discovered workspace matches the requested --workspace filters.");
 	const localNames = new Set(workspaces.map((workspace) => workspace.name));
+	const localVersions = new Map(workspaces.flatMap((workspace) => typeof workspace.manifest.version === "string" && semver.valid(workspace.manifest.version) ? [[workspace.name, workspace.manifest.version]] : []));
 	return {
 		root,
 		workspaces,
@@ -316,7 +318,8 @@ async function discoverProject(options) {
 		contextOccurrences: collectOccurrences(root, selectedWorkspaces, localNames, {
 			ignore: [],
 			tags: policy.tags
-		}, [])
+		}, []),
+		localVersions
 	};
 }
 //#endregion

package/dist/planner-ZAX9SFjY.js

@@ -0,0 +1,326 @@
+import { n as isBreakingChange, r as rewriteRange, t as analyzeRange } from "./range-YUs9eimn.js";
+import { t as parseDependencySpecification } from "./specification-DXnDOC-0.js";
+import semver from "semver";
+//#region src/update/planner.ts
+const STATUS_PRIORITY = {
+	current: 0,
+	local: 1,
+	safe: 2,
+	breaking: 3,
+	manual: 4,
+	error: 5
+};
+const publishedVersions = (packument) => Object.keys(packument.versions ?? {}).filter((version) => semver.valid(version) !== null).sort(semver.compare);
+function selectedTarget(packument, tag) {
+	const value = packument["dist-tags"]?.[tag];
+	return typeof value === "string" && semver.valid(value) ? value : null;
+}
+function resolveSpecificationVersion(specification, packument) {
+	const parsed = parseDependencySpecification(specification);
+	if (parsed.type === "tag") {
+		const value = packument["dist-tags"]?.[parsed.rawSpec];
+		return typeof value === "string" && semver.valid(value) ? value : null;
+	}
+	if (parsed.type === "version") return semver.valid(parsed.rawSpec);
+	if (parsed.type === "range") return semver.maxSatisfying(publishedVersions(packument), parsed.rawSpec);
+	return null;
+}
+function metadata(packument, version) {
+	const value = packument.versions?.[version];
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function baseOccurrence(occurrence) {
+	return {
+		workspace: occurrence.workspace,
+		manifestPath: occurrence.manifestPath,
+		relativeManifestPath: occurrence.relativeManifestPath,
+		section: occurrence.section,
+		currentSpecification: occurrence.currentSpecification,
+		proposedSpecification: null,
+		allowedVersion: null,
+		selectedVersion: null
+	};
+}
+function planOne(occurrence, packument, failure, tag, mode, chosen, blocker) {
+	const base = baseOccurrence(occurrence);
+	if (occurrence.kind === "local") return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "local",
+			reason: occurrence.reason
+		}
+	};
+	if (occurrence.kind === "manual") return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "manual",
+			reason: occurrence.reason
+		}
+	};
+	if (failure) return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "error",
+			reason: failure
+		}
+	};
+	if (!packument) return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "error",
+			reason: "package metadata is unavailable"
+		}
+	};
+	const target = selectedTarget(packument, tag);
+	if (!target) return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "error",
+			reason: `dist-tag '${tag}' is not published`
+		}
+	};
+	if (!publishedVersions(packument).includes(target)) return {
+		targetVersion: null,
+		occurrence: {
+			...base,
+			status: "error",
+			reason: `dist-tag '${tag}' does not identify a published version`
+		}
+	};
+	if (occurrence.kind === "current") return {
+		targetVersion: target,
+		occurrence: {
+			...base,
+			status: "current",
+			reason: occurrence.reason
+		}
+	};
+	const allowed = resolveSpecificationVersion(occurrence.currentSpecification, packument);
+	if (!allowed) return {
+		targetVersion: target,
+		occurrence: {
+			...base,
+			status: "manual",
+			reason: "no published version satisfies the current specification"
+		}
+	};
+	const selected = chosen ?? target;
+	const withVersions = {
+		...base,
+		allowedVersion: allowed,
+		selectedVersion: selected
+	};
+	if (blocker) return {
+		targetVersion: target,
+		occurrence: {
+			...withVersions,
+			status: "manual",
+			reason: blocker
+		}
+	};
+	if (semver.satisfies(selected, occurrence.currentSpecification) || !semver.gt(selected, allowed)) return {
+		targetVersion: target,
+		occurrence: {
+			...withVersions,
+			status: "current",
+			reason: blocker ?? "selected version is already covered by the current specification"
+		}
+	};
+	const analysis = analyzeRange(occurrence.currentSpecification);
+	if (!analysis.shape) return {
+		targetVersion: target,
+		occurrence: {
+			...withVersions,
+			status: "manual",
+			reason: analysis.reason
+		}
+	};
+	const breaking = isBreakingChange(allowed, selected);
+	if (mode === "update" && breaking) return {
+		targetVersion: target,
+		occurrence: {
+			...withVersions,
+			status: "breaking",
+			reason: "breaking update is available via askr upgrade"
+		}
+	};
+	return {
+		targetVersion: target,
+		occurrence: {
+			...withVersions,
+			proposedSpecification: rewriteRange(analysis.shape, selected, breaking),
+			status: breaking ? "breaking" : "safe",
+			reason: selected === target ? "selected tag target is eligible" : `compatible version ${selected} selected below ${tag}@${target}`
+		}
+	};
+}
+function optionalPeer(meta, peer) {
+	const value = meta.peerDependenciesMeta?.[peer];
+	return Boolean(value && typeof value === "object" && !Array.isArray(value) && value.optional === true);
+}
+function solveWorkspace(workspace, selectedOccurrences, context, packuments, tags, cliTag, localVersions, mode) {
+	const selectedNames = new Set(selectedOccurrences.filter((entry) => entry.kind === "fetch").map((entry) => entry.package));
+	const byName = /* @__PURE__ */ new Map();
+	for (const item of context.filter((entry) => entry.workspace === workspace)) if (!byName.has(item.package)) byName.set(item.package, item);
+	const states = /* @__PURE__ */ new Map();
+	for (const [name, occurrence] of byName) {
+		const packument = packuments.get(name);
+		const current = packument ? resolveSpecificationVersion(occurrence.currentSpecification, packument) : localVersions.get(name) ?? null;
+		let candidates = current ? [current] : [];
+		if (selectedNames.has(name) && packument && current) {
+			const target = selectedTarget(packument, cliTag ?? tags[name] ?? "latest");
+			if (target) candidates = publishedVersions(packument).filter((version) => semver.gte(version, current) && semver.lte(version, target) && (mode === "upgrade" || !isBreakingChange(current, version))).sort(semver.rcompare);
+		}
+		states.set(name, {
+			occurrence,
+			selected: selectedNames.has(name),
+			current,
+			candidates
+		});
+	}
+	const variables = [...states.entries()].filter(([, state]) => state.selected && state.candidates.length > 0).sort(([a], [b]) => a.localeCompare(b));
+	const fixed = new Map([...states].flatMap(([name, state]) => state.selected ? [] : state.current ? [[name, state.current]] : []));
+	let best = null;
+	let bestChanged = -1;
+	let firstFailure = "no jointly peer-compatible published version set exists";
+	const validate = (choices) => {
+		const installed = new Map([...fixed, ...choices]);
+		for (const [name, version] of installed) {
+			const packument = packuments.get(name);
+			if (!packument) continue;
+			const meta = metadata(packument, version);
+			if (!meta) continue;
+			for (const [peer, requirement] of Object.entries(meta.peerDependencies ?? {}).sort(([a], [b]) => a.localeCompare(b))) {
+				if (typeof requirement !== "string") continue;
+				const providerChanged = states.get(name)?.current !== version;
+				const peerChanged = states.get(peer)?.selected && states.get(peer)?.current !== installed.get(peer);
+				if (!providerChanged && !peerChanged) continue;
+				const peerVersion = installed.get(peer) ?? localVersions.get(peer);
+				if (!peerVersion) {
+					if (optionalPeer(meta, peer)) continue;
+					return `${name}@${version} requires missing peer ${peer}@${requirement}`;
+				}
+				if (!semver.satisfies(peerVersion, requirement, { includePrerelease: true })) return `${name}@${version} requires ${peer}@${requirement}`;
+			}
+		}
+		return null;
+	};
+	const visit = (index, choices) => {
+		if (index === variables.length) {
+			const failure = validate(choices);
+			if (failure) {
+				firstFailure = failure;
+				return;
+			}
+			const changed = variables.filter(([name, state]) => choices.get(name) !== state.current).length;
+			if (changed > bestChanged) {
+				best = new Map(choices);
+				bestChanged = changed;
+			}
+			return;
+		}
+		const [name, state] = variables[index];
+		for (const version of state.candidates) {
+			choices.set(name, version);
+			visit(index + 1, choices);
+		}
+	};
+	visit(0, /* @__PURE__ */ new Map());
+	const blockers = /* @__PURE__ */ new Map();
+	if (!best) for (const [name] of variables) blockers.set(name, firstFailure);
+	const choices = best ?? new Map(variables.flatMap(([name, state]) => state.current ? [[name, state.current]] : []));
+	for (const [name, state] of variables) {
+		if (choices.get(name) !== state.current || state.candidates[0] === state.current) continue;
+		const attempted = new Map(choices).set(name, state.candidates[0]);
+		blockers.set(name, validate(attempted) ?? "no jointly peer-compatible update advances this dependency");
+	}
+	return {
+		choices,
+		blockers
+	};
+}
+function aggregateStatus(occurrences) {
+	return occurrences.reduce((status, occurrence) => STATUS_PRIORITY[occurrence.status] > STATUS_PRIORITY[status] ? occurrence.status : status, "current");
+}
+function summarize(decisions) {
+	const summary = {
+		packages: decisions.length,
+		occurrences: 0,
+		changedOccurrences: 0,
+		current: 0,
+		safe: 0,
+		breaking: 0,
+		local: 0,
+		manual: 0,
+		error: 0
+	};
+	for (const decision of decisions) {
+		decision.status = aggregateStatus(decision.occurrences);
+		decision.reason = decision.occurrences.find((entry) => entry.status === decision.status)?.reason ?? "";
+		summary[decision.status] += 1;
+		summary.occurrences += decision.occurrences.length;
+		summary.changedOccurrences += decision.occurrences.filter((entry) => entry.proposedSpecification).length;
+	}
+	return summary;
+}
+function planUpdates(options) {
+	const failures = options.failures ?? /* @__PURE__ */ new Map();
+	const tags = options.tags ?? {};
+	const mode = options.mode ?? (options.force ? "upgrade" : "update");
+	const context = options.contextOccurrences ?? options.occurrences;
+	const workspaceSolutions = /* @__PURE__ */ new Map();
+	if (mode !== "force") for (const workspace of new Set(options.occurrences.map((entry) => entry.workspace))) workspaceSolutions.set(workspace, solveWorkspace(workspace, options.occurrences.filter((entry) => entry.workspace === workspace), context, options.packuments, tags, options.cliTag, options.localVersions ?? /* @__PURE__ */ new Map(), mode));
+	const grouped = /* @__PURE__ */ new Map();
+	for (const occurrence of options.occurrences) grouped.set(occurrence.package, [...grouped.get(occurrence.package) ?? [], occurrence]);
+	const decisions = [...grouped.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([packageName, occurrences]) => {
+		const selectedTag = options.cliTag ?? tags[packageName] ?? "latest";
+		const planned = occurrences.map((occurrence) => {
+			const solution = workspaceSolutions.get(occurrence.workspace);
+			const blocker = solution?.blockers.get(packageName);
+			const chosen = mode === "update" && !blocker ? void 0 : solution?.choices.get(packageName);
+			return planOne(occurrence, options.packuments.get(packageName), failures.get(packageName), selectedTag, mode, chosen, blocker);
+		});
+		const targetVersion = planned.find((entry) => entry.targetVersion)?.targetVersion ?? null;
+		const plannedOccurrences = planned.map((entry) => entry.occurrence);
+		const status = aggregateStatus(plannedOccurrences);
+		return {
+			package: packageName,
+			selectedTag,
+			targetVersion,
+			status,
+			reason: plannedOccurrences.find((entry) => entry.status === status)?.reason ?? "",
+			occurrences: plannedOccurrences
+		};
+	});
+	const selectedNames = new Set(grouped.keys());
+	for (const [packageName, failure] of [...failures].sort(([a], [b]) => a.localeCompare(b))) {
+		if (selectedNames.has(packageName)) continue;
+		const occurrences = context.filter((entry) => entry.package === packageName).map((entry) => ({
+			...baseOccurrence(entry),
+			status: "error",
+			reason: `peer compatibility lookup failed: ${failure}`
+		}));
+		decisions.push({
+			package: packageName,
+			selectedTag: options.cliTag ?? tags[packageName] ?? "latest",
+			targetVersion: null,
+			status: "error",
+			reason: `peer compatibility lookup failed: ${failure}`,
+			occurrences
+		});
+	}
+	decisions.sort((a, b) => a.package.localeCompare(b.package));
+	const summary = summarize(decisions);
+	return {
+		decisions,
+		summary,
+		hasErrors: summary.error > 0
+	};
+}
+//#endregion
+export { planUpdates };

package/dist/{registry-CyrRHRG5.js → registry-D2APi6x0.js}

@@ -130,6 +130,23 @@ function selectedVersions(packument, specifications) {
 	}
 	return [...selected].sort(semver.compare);
 }
+function candidateVersions(packument, specifications) {
+	const versions = Object.keys(packument.versions ?? {}).filter((version) => semver.valid(version) !== null);
+	const selected = selectedVersions(packument, specifications);
+	const lowerBounds = specifications.flatMap((specification) => {
+		const parsed = parseDependencySpecification(specification);
+		if (parsed.type === "version") return semver.valid(parsed.rawSpec) ? [parsed.rawSpec] : [];
+		if (parsed.type === "range") {
+			const current = semver.maxSatisfying(versions, parsed.rawSpec);
+			return current ? [current] : [];
+		}
+		return [];
+	});
+	if (lowerBounds.length === 0 || selected.length === 0) return selected;
+	const floor = lowerBounds.sort(semver.compare)[0];
+	const ceiling = selected.sort(semver.compare)[selected.length - 1];
+	return versions.filter((version) => semver.gte(version, floor) && semver.lte(version, ceiling));
+}
 function mergeVersionMetadata(packument, value, selected) {
 	const entries = Array.isArray(value) ? value : [value];
 	const merged = /* @__PURE__ */ new Set();
@@ -142,6 +159,7 @@ function mergeVersionMetadata(packument, value, selected) {
 		const metadata = packument.versions?.[entry.version];
 		if (!isRecord(metadata)) continue;
 		if (isRecord(entry.peerDependencies)) metadata.peerDependencies = entry.peerDependencies;
+		if (isRecord(entry.peerDependenciesMeta)) metadata.peerDependenciesMeta = entry.peerDependenciesMeta;
 		merged.add(entry.version);
 	}
 	return selected.every((version) => merged.has(version));
@@ -154,13 +172,14 @@ async function executeNpmView(packageName, configuration, specifications) {
 		"dist-tags"
 	], configuration, true));
 	if (!packument) return null;
-	const versions = selectedVersions(packument, specifications);
+	const versions = candidateVersions(packument, specifications);
 	if (versions.length === 0) return packument;
 	return mergeVersionMetadata(packument, await executeNpmJson([
 		"view",
 		`${packageName}@${versions.join(" || ")}`,
 		"version",
-		"peerDependencies"
+		"peerDependencies",
+		"peerDependenciesMeta"
 	], configuration, false), versions) ? packument : null;
 }
 function isPackument(value) {

package/dist/update.js

@@ -14,6 +14,7 @@ function helpText(command) {
 		"  --workspace <glob>      Select workspace names (repeatable)",
 		"  --tag <tag>             Use one registry dist-tag for selected packages",
 		"  --json                  Emit one deterministic JSON object on stdout",
+		...command === "upgrade" ? ["  --force, -f             Use tag targets without peer compatibility checks"] : [],
 		"  --help, -h              Show this help message",
 		"",
 		"Notes:",
@@ -29,11 +30,12 @@ function optionValue(args, index, option, errors) {
 	}
 	return args[index + 1];
 }
-function parseArgs(args) {
+function parseArgs(command, args) {
 	const parsed = {
 		cwd: process.cwd(),
 		help: false,
 		json: false,
+		force: false,
 		packagePatterns: [],
 		workspacePatterns: [],
 		errors: []
@@ -45,6 +47,8 @@ function parseArgs(args) {
 		else if (argument === "--") positionalOnly = true;
 		else if (argument === "--help" || argument === "-h") parsed.help = true;
 		else if (argument === "--json") parsed.json = true;
+		else if (argument === "--force" || argument === "-f") if (command === "upgrade") parsed.force = true;
+		else parsed.errors.push(`${argument} is only supported by askr upgrade`);
 		else if (argument === "--cwd") {
 			const value = optionValue(args, index, "--cwd", parsed.errors);
 			if (value !== null) {
@@ -101,6 +105,7 @@ function serializableDecision(decision) {
 			currentSpecification: occurrence.currentSpecification,
 			proposedSpecification: occurrence.proposedSpecification,
 			allowedVersion: occurrence.allowedVersion,
+			selectedVersion: occurrence.selectedVersion,
 			status: occurrence.status,
 			reason: occurrence.reason
 		}))
@@ -132,6 +137,7 @@ function renderTable(rows) {
 	const headings = [
 		"Package",
 		"Allowed",
+		"Chosen",
 		"Latest",
 		"Status",
 		"Range"
@@ -147,6 +153,7 @@ function emitHuman(io, decisions, summary, applied, command) {
 		const row = [
 			decision.package,
 			occurrence.allowedVersion ?? "-",
+			occurrence.selectedVersion ?? "-",
 			decision.targetVersion ?? "-",
 			occurrence.status,
 			rangeText(occurrence, command)
@@ -186,11 +193,11 @@ function collectEdits(decisions) {
 	}] : []));
 }
 async function defaultRegistry(root, packageNames, requirements) {
-	const { fetchPackuments, loadNpmConfiguration } = await import("./registry-CyrRHRG5.js");
+	const { fetchPackuments, loadNpmConfiguration } = await import("./registry-D2APi6x0.js");
 	return fetchPackuments(packageNames, await loadNpmConfiguration(root), { requirements });
 }
 async function runDependencyCli(command, args, io = console, runtime = {}) {
-	const parsed = parseArgs(args);
+	const parsed = parseArgs(command, args);
 	if (parsed.help && parsed.errors.length === 0) {
 		io.log(helpText(command));
 		return 0;
@@ -210,7 +217,7 @@ async function runDependencyCli(command, args, io = console, runtime = {}) {
 	let root = null;
 	let selectedWorkspaces = [];
 	try {
-		const [{ discoverProject }, { planUpdates }] = await Promise.all([import("./discovery-Difb7Y4G.js"), import("./planner-VAj7qlxr.js")]);
+		const [{ discoverProject }, { planUpdates }] = await Promise.all([import("./discovery-Djq8TxJu.js"), import("./planner-ZAX9SFjY.js")]);
 		const project = await discoverProject({
 			cwd: parsed.cwd,
 			packagePatterns: parsed.packagePatterns,
@@ -237,7 +244,8 @@ async function runDependencyCli(command, args, io = console, runtime = {}) {
 			failures: results.failures,
 			tags: project.policy.tags,
 			cliTag: parsed.tag,
-			force: command === "upgrade"
+			mode: command === "upgrade" ? parsed.force ? "force" : "upgrade" : "update",
+			localVersions: project.localVersions
 		});
 		let applied = 0;
 		const errors = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askrjs/cli",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Unified CLI for the Askr platform",
   "homepage": "https://github.com/askrjs/askr-cli#readme",
   "bugs": {

package/dist/planner-VAj7qlxr.js

@@ -1,285 +0,0 @@
-import { n as isBreakingChange, r as rewriteRange, t as analyzeRange } from "./range-YUs9eimn.js";
-import { t as parseDependencySpecification } from "./specification-DXnDOC-0.js";
-import semver from "semver";
-//#region src/update/planner.ts
-const STATUS_PRIORITY = {
-	current: 0,
-	local: 1,
-	safe: 2,
-	breaking: 3,
-	manual: 4,
-	error: 5
-};
-function publishedVersions(packument) {
-	return Object.keys(packument.versions ?? {}).filter((version) => semver.valid(version) !== null).sort(semver.compare);
-}
-function selectedTarget(packument, tag) {
-	const value = packument["dist-tags"]?.[tag];
-	return typeof value === "string" && semver.valid(value) ? value : null;
-}
-function plannedOccurrence(occurrence, packument, failure, selectedTag, force) {
-	const base = {
-		workspace: occurrence.workspace,
-		manifestPath: occurrence.manifestPath,
-		relativeManifestPath: occurrence.relativeManifestPath,
-		section: occurrence.section,
-		currentSpecification: occurrence.currentSpecification,
-		proposedSpecification: null,
-		allowedVersion: null
-	};
-	if (occurrence.kind === "local") return {
-		targetVersion: null,
-		occurrence: {
-			...base,
-			status: "local",
-			reason: occurrence.reason
-		}
-	};
-	if (occurrence.kind === "manual") return {
-		targetVersion: null,
-		occurrence: {
-			...base,
-			status: "manual",
-			reason: occurrence.reason
-		}
-	};
-	if (failure) return {
-		targetVersion: null,
-		occurrence: {
-			...base,
-			status: "error",
-			reason: failure
-		}
-	};
-	if (occurrence.kind === "current") return {
-		targetVersion: packument ? selectedTarget(packument, selectedTag) : null,
-		occurrence: {
-			...base,
-			status: "current",
-			reason: occurrence.reason
-		}
-	};
-	if (!packument) return {
-		targetVersion: null,
-		occurrence: {
-			...base,
-			status: "error",
-			reason: "package metadata is unavailable"
-		}
-	};
-	const targetVersion = selectedTarget(packument, selectedTag);
-	if (!targetVersion) return {
-		targetVersion: null,
-		occurrence: {
-			...base,
-			status: "error",
-			reason: `dist-tag '${selectedTag}' is not published`
-		}
-	};
-	const versions = publishedVersions(packument);
-	if (!versions.includes(targetVersion)) return {
-		targetVersion: null,
-		occurrence: {
-			...base,
-			status: "error",
-			reason: `dist-tag '${selectedTag}' does not identify a published version`
-		}
-	};
-	const allowedVersion = semver.maxSatisfying(versions, occurrence.currentSpecification);
-	if (!allowedVersion) return {
-		targetVersion,
-		occurrence: {
-			...base,
-			status: "manual",
-			reason: "no published version satisfies the current specification"
-		}
-	};
-	if (semver.satisfies(targetVersion, occurrence.currentSpecification) || !semver.gt(targetVersion, allowedVersion)) return {
-		targetVersion,
-		occurrence: {
-			...base,
-			allowedVersion,
-			status: "current",
-			reason: "selected target is already covered by the current specification"
-		}
-	};
-	const analysis = analyzeRange(occurrence.currentSpecification);
-	if (!analysis.shape) return {
-		targetVersion,
-		occurrence: {
-			...base,
-			allowedVersion,
-			status: "manual",
-			reason: analysis.reason
-		}
-	};
-	const breaking = isBreakingChange(allowedVersion, targetVersion);
-	const eligible = !breaking || force;
-	return {
-		targetVersion,
-		occurrence: {
-			...base,
-			allowedVersion,
-			proposedSpecification: eligible ? rewriteRange(analysis.shape, targetVersion, breaking) : null,
-			status: breaking ? "breaking" : "safe",
-			reason: breaking ? eligible ? "latest version is eligible for askr upgrade" : "breaking update is available via askr upgrade" : "compatible update is available"
-		}
-	};
-}
-function occurrenceKey(occurrence, packageName) {
-	return [
-		occurrence.manifestPath,
-		occurrence.section,
-		packageName ?? occurrence.package,
-		occurrence.currentSpecification
-	].join("\0");
-}
-function resolveSpecificationVersion(specification, packument) {
-	const versions = publishedVersions(packument);
-	const parsed = parseDependencySpecification(specification);
-	if (parsed.type === "tag") {
-		const tagged = packument["dist-tags"]?.[parsed.rawSpec];
-		return typeof tagged === "string" && semver.valid(tagged) ? tagged : null;
-	}
-	if (parsed.type === "version") return semver.valid(parsed.rawSpec);
-	if (parsed.type === "range") return semver.maxSatisfying(versions, parsed.rawSpec);
-	return null;
-}
-function versionMetadata(packument, version) {
-	const metadata = packument.versions?.[version];
-	return metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : null;
-}
-function applyPeerCompatibilityGuard(decisions, contextOccurrences, packuments) {
-	const plannedByKey = /* @__PURE__ */ new Map();
-	for (const decision of decisions) for (const occurrence of decision.occurrences) plannedByKey.set(occurrenceKey(occurrence, decision.package), occurrence);
-	const contextByWorkspace = /* @__PURE__ */ new Map();
-	for (const occurrence of contextOccurrences) {
-		const entries = contextByWorkspace.get(occurrence.workspace) ?? [];
-		entries.push(occurrence);
-		contextByWorkspace.set(occurrence.workspace, entries);
-	}
-	for (const [workspace, context] of contextByWorkspace) {
-		const states = context.flatMap((dependency) => {
-			if (!dependency.registryManaged) return [];
-			const packument = packuments.get(dependency.package);
-			if (!packument) return [];
-			const planned = plannedByKey.get(occurrenceKey(dependency));
-			const currentVersion = resolveSpecificationVersion(dependency.currentSpecification, packument);
-			const futureVersion = resolveSpecificationVersion(planned?.proposedSpecification ?? dependency.currentSpecification, packument);
-			return currentVersion && futureVersion ? [{
-				dependency,
-				packument,
-				planned,
-				currentVersion,
-				futureVersion,
-				changed: Boolean(planned?.proposedSpecification)
-			}] : [];
-		});
-		const blockers = /* @__PURE__ */ new Map();
-		for (const provider of states) {
-			const currentPeers = versionMetadata(provider.packument, provider.currentVersion)?.peerDependencies ?? {};
-			const futurePeers = versionMetadata(provider.packument, provider.futureVersion)?.peerDependencies ?? {};
-			const peerNames = /* @__PURE__ */ new Set([...Object.keys(currentPeers), ...Object.keys(futurePeers)]);
-			for (const peerName of peerNames) {
-				const currentRequirement = currentPeers[peerName];
-				const futureRequirement = futurePeers[peerName];
-				if (futureRequirement !== void 0 && typeof futureRequirement !== "string") continue;
-				for (const peer of states.filter((state) => state.dependency.package === peerName)) {
-					const currentAccepted = typeof currentRequirement !== "string" || semver.satisfies(peer.currentVersion, currentRequirement);
-					const futureAccepted = typeof futureRequirement !== "string" || semver.satisfies(peer.futureVersion, futureRequirement);
-					if (!currentAccepted || futureAccepted) continue;
-					const reason = `${provider.dependency.package}@${provider.futureVersion} requires ${peerName}@${futureRequirement}`;
-					if (provider.changed && provider.planned) blockers.set(provider.planned, reason);
-					if (peer.changed && peer.planned) blockers.set(peer.planned, reason);
-				}
-			}
-		}
-		for (const [planned, reason] of blockers) {
-			planned.status = "manual";
-			planned.proposedSpecification = null;
-			planned.reason = reason;
-		}
-	}
-}
-function aggregateStatus(occurrences) {
-	return occurrences.reduce((status, occurrence) => STATUS_PRIORITY[occurrence.status] > STATUS_PRIORITY[status] ? occurrence.status : status, "current");
-}
-function summarize(decisions) {
-	const summary = {
-		packages: decisions.length,
-		occurrences: 0,
-		changedOccurrences: 0,
-		current: 0,
-		safe: 0,
-		breaking: 0,
-		local: 0,
-		manual: 0,
-		error: 0
-	};
-	for (const decision of decisions) {
-		decision.status = aggregateStatus(decision.occurrences);
-		decision.reason = decision.occurrences.find((entry) => entry.status === decision.status)?.reason ?? "";
-		summary[decision.status] += 1;
-		summary.occurrences += decision.occurrences.length;
-		summary.changedOccurrences += decision.occurrences.filter((entry) => entry.proposedSpecification).length;
-	}
-	return summary;
-}
-function planUpdates(options) {
-	const failures = options.failures ?? /* @__PURE__ */ new Map();
-	const tags = options.tags ?? {};
-	const grouped = /* @__PURE__ */ new Map();
-	for (const occurrence of options.occurrences) {
-		const entries = grouped.get(occurrence.package) ?? [];
-		entries.push(occurrence);
-		grouped.set(occurrence.package, entries);
-	}
-	const decisions = [...grouped.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([packageName, occurrences]) => {
-		const selectedTag = options.cliTag ?? tags[packageName] ?? "latest";
-		const planned = occurrences.map((occurrence) => plannedOccurrence(occurrence, options.packuments.get(packageName), failures.get(packageName), selectedTag, options.force ?? false));
-		const targetVersion = planned.find((entry) => entry.targetVersion)?.targetVersion ?? null;
-		const plannedOccurrences = planned.map((entry) => entry.occurrence);
-		const status = aggregateStatus(plannedOccurrences);
-		return {
-			package: packageName,
-			selectedTag,
-			targetVersion,
-			status,
-			reason: plannedOccurrences.find((entry) => entry.status === status)?.reason ?? "",
-			occurrences: plannedOccurrences
-		};
-	});
-	const selectedNames = new Set(grouped.keys());
-	for (const [packageName, failure] of [...failures].sort(([left], [right]) => left.localeCompare(right))) {
-		if (selectedNames.has(packageName)) continue;
-		const context = (options.contextOccurrences ?? []).filter((occurrence) => occurrence.package === packageName).map((occurrence) => ({
-			workspace: occurrence.workspace,
-			manifestPath: occurrence.manifestPath,
-			relativeManifestPath: occurrence.relativeManifestPath,
-			section: occurrence.section,
-			currentSpecification: occurrence.currentSpecification,
-			proposedSpecification: null,
-			allowedVersion: null,
-			status: "error",
-			reason: `peer compatibility lookup failed: ${failure}`
-		}));
-		decisions.push({
-			package: packageName,
-			selectedTag: options.cliTag ?? tags[packageName] ?? "latest",
-			targetVersion: null,
-			status: "error",
-			reason: `peer compatibility lookup failed: ${failure}`,
-			occurrences: context
-		});
-	}
-	decisions.sort((left, right) => left.package.localeCompare(right.package));
-	applyPeerCompatibilityGuard(decisions, options.contextOccurrences ?? options.occurrences, options.packuments);
-	const summary = summarize(decisions);
-	return {
-		decisions,
-		summary,
-		hasErrors: summary.error > 0
-	};
-}
-//#endregion
-export { planUpdates };