@askrjs/cli 0.0.2 → 0.0.4

package/dist/planner-VAj7qlxr.js

@@ -0,0 +1,285 @@
+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 };

package/dist/range-YUs9eimn.js

@@ -0,0 +1,125 @@
+import semver from "semver";
+//#region src/update/range.ts
+const FULL_VERSION = String.raw`\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?`;
+const PARTIAL_VERSION = String.raw`\d+(?:\.\d+){0,2}`;
+function analyzeAtomicRange(specification) {
+	const value = specification.trim();
+	if (/^(?:\*|x|X)$/.test(value)) return {
+		shape: null,
+		tracking: true,
+		reason: "wildcard range tracks the selected tag"
+	};
+	if (new RegExp(`^${FULL_VERSION}$`).test(value) && semver.valid(value)) return {
+		shape: { kind: "exact" },
+		tracking: false,
+		reason: ""
+	};
+	const operator = value.match(new RegExp(`^([~^])\\s*(${FULL_VERSION}|${PARTIAL_VERSION})$`));
+	if (operator && semver.validRange(value)) return {
+		shape: {
+			kind: "operator",
+			operator: operator[1]
+		},
+		tracking: false,
+		reason: ""
+	};
+	const bounded = value.match(/^((?:>=|>)\s*\d+(?:\.\d+){0,2})\s+(?:<|<=)\s*\d+(?:\.\d+){0,2}$/);
+	if (bounded && semver.validRange(value)) return {
+		shape: {
+			kind: "bounded",
+			lower: bounded[1].replace(/\s+/g, "")
+		},
+		tracking: false,
+		reason: ""
+	};
+	const xRange = value.match(/^(\d+|[xX*])(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?$/);
+	if (xRange && semver.validRange(value)) {
+		const parts = xRange.slice(1).filter((part) => part !== void 0);
+		return {
+			shape: {
+				kind: "x",
+				parts,
+				wildcard: parts.find((part) => /^[xX*]$/.test(part)) ?? null
+			},
+			tracking: false,
+			reason: ""
+		};
+	}
+	return {
+		shape: null,
+		tracking: false,
+		reason: "unsupported complex semver range"
+	};
+}
+function analyzeRange(specification) {
+	const clauses = specification.split("||").map((clause) => clause.trim());
+	if (clauses.length === 1) return analyzeAtomicRange(specification);
+	if (clauses.some((clause) => clause.length === 0)) return {
+		shape: null,
+		tracking: false,
+		reason: "unsupported complex semver range"
+	};
+	const analyzed = clauses.map(analyzeAtomicRange);
+	if (analyzed.some((entry) => !entry.shape || entry.shape.kind === "union" || entry.tracking)) return {
+		shape: null,
+		tracking: false,
+		reason: "unsupported complex semver union"
+	};
+	const minimums = clauses.map((clause) => semver.minVersion(clause));
+	if (minimums.some((version) => version === null)) return {
+		shape: null,
+		tracking: false,
+		reason: "unsupported complex semver union"
+	};
+	let highestIndex = 0;
+	for (let index = 1; index < minimums.length; index += 1) if (semver.gt(minimums[index], minimums[highestIndex])) highestIndex = index;
+	return {
+		shape: {
+			kind: "union",
+			clauses: analyzed.map((entry) => entry.shape),
+			sourceClauses: clauses,
+			highestIndex
+		},
+		tracking: false,
+		reason: ""
+	};
+}
+function isBreakingChange(allowedVersion, targetVersion) {
+	const allowed = new semver.SemVer(allowedVersion);
+	const target = new semver.SemVer(targetVersion);
+	if (allowed.major !== target.major) return true;
+	return allowed.major === 0 && allowed.minor !== target.minor;
+}
+function nextBreakingBoundary(version) {
+	const parsed = new semver.SemVer(version);
+	return parsed.major === 0 ? `0.${parsed.minor + 1}.0` : `${parsed.major + 1}.0.0`;
+}
+function rewriteXRange(shape, target) {
+	const parsed = new semver.SemVer(target);
+	const count = shape.parts.length;
+	if (shape.wildcard) {
+		const wildcardIndex = shape.parts.findIndex((part) => /^[xX*]$/.test(part));
+		if (wildcardIndex === 0) return shape.wildcard;
+		if (wildcardIndex === 1) return `${parsed.major}.${shape.wildcard}`;
+		return `${parsed.major}.${parsed.minor}.${shape.wildcard}`;
+	}
+	if (count === 1) return String(parsed.major);
+	return `${parsed.major}.${parsed.minor}`;
+}
+function rewriteAtomic(shape, target, forcedBreaking) {
+	if (shape.kind === "exact") return target;
+	if (shape.kind === "operator") return `${shape.operator}${target}`;
+	if (shape.kind === "x") return rewriteXRange(shape, target);
+	const boundary = nextBreakingBoundary(target);
+	return forcedBreaking ? `>=${target} <${boundary}` : `${shape.lower} <${boundary}`;
+}
+function rewriteRange(shape, target, forcedBreaking) {
+	if (shape.kind !== "union") return rewriteAtomic(shape, target, forcedBreaking);
+	const highestShape = shape.clauses[shape.highestIndex];
+	if (forcedBreaking) return rewriteAtomic(highestShape, target, true);
+	const rewritten = [...shape.sourceClauses];
+	rewritten[shape.highestIndex] = rewriteAtomic(highestShape, target, false);
+	return rewritten.join(" || ");
+}
+//#endregion
+export { isBreakingChange as n, rewriteRange as r, analyzeRange as t };

package/dist/registry-CyrRHRG5.js

@@ -0,0 +1,209 @@
+import { t as parseDependencySpecification } from "./specification-DXnDOC-0.js";
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { execFile } from "node:child_process";
+import semver from "semver";
+//#region src/update/registry.ts
+function installedNpmCli(executable) {
+	const directories = /* @__PURE__ */ new Set([path.dirname(process.execPath)]);
+	if (executable && path.isAbsolute(executable)) directories.add(path.dirname(executable));
+	for (const directory of directories) for (const candidate of [path.join(directory, "node_modules", "npm", "bin", "npm-cli.js"), path.resolve(directory, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")]) if (existsSync(candidate)) return candidate;
+	return null;
+}
+function npmInvocation(env) {
+	const executable = env.npm_execpath;
+	const executableName = executable ? path.basename(executable).toLowerCase() : "";
+	const isNpmExecutable = executableName === "npm" || executableName === "npm.cmd" || /^npm(?:-cli)?\.(?:cjs|js|mjs)$/.test(executableName);
+	if (executable && isNpmExecutable) {
+		const extension = path.extname(executable).toLowerCase();
+		if ([
+			".cjs",
+			".js",
+			".mjs"
+		].includes(extension)) return {
+			executable: process.execPath,
+			prefix: [executable]
+		};
+		const npmCli = installedNpmCli(executable);
+		return npmCli ? {
+			executable: process.execPath,
+			prefix: [npmCli]
+		} : {
+			executable,
+			prefix: []
+		};
+	}
+	const npmCli = installedNpmCli();
+	if (npmCli) return {
+		executable: process.execPath,
+		prefix: [npmCli]
+	};
+	return {
+		executable: process.platform === "win32" ? "npm.cmd" : "npm",
+		prefix: []
+	};
+}
+function executionEnvironment(env) {
+	if (env === process.env) return { ...process.env };
+	const inherited = { ...process.env };
+	for (const name of Object.keys(inherited)) if (/^npm_config_/i.test(name)) delete inherited[name];
+	return {
+		...inherited,
+		...env
+	};
+}
+async function loadNpmConfiguration(root, env = process.env) {
+	const effectiveEnvironment = executionEnvironment(env);
+	return {
+		cwd: root,
+		env: effectiveEnvironment,
+		invocation: npmInvocation(effectiveEnvironment)
+	};
+}
+function npmError(error, stderr) {
+	const details = `${String(error.code ?? "")}\n${stderr}`;
+	const safe = /* @__PURE__ */ new Error("npm registry lookup failed");
+	safe.code = (details.match(/\bE(?:401|403|404|CONNRESET|TIMEDOUT|TIMEOUT)\b/i)?.[0])?.toUpperCase() ?? (typeof error.code === "string" ? error.code : "");
+	if (safe.code === "E401") safe.statusCode = 401;
+	if (safe.code === "E403") safe.statusCode = 403;
+	if (safe.code === "E404") safe.statusCode = 404;
+	return safe;
+}
+function executeNpmJson(args, configuration, preferOnline) {
+	const [command, ...positionals] = args;
+	return new Promise((resolve, reject) => {
+		execFile(configuration.invocation.executable, [
+			...configuration.invocation.prefix,
+			command,
+			"--json",
+			preferOnline ? "--prefer-online" : "--prefer-offline",
+			"--offline=false",
+			"--loglevel=error",
+			"--update-notifier=false",
+			"--",
+			...positionals
+		], {
+			cwd: configuration.cwd,
+			encoding: "utf8",
+			env: configuration.env,
+			maxBuffer: 64 * 1024 * 1024,
+			windowsHide: true
+		}, (error, stdout, stderr) => {
+			if (error) {
+				reject(npmError(error, stderr));
+				return;
+			}
+			try {
+				resolve(JSON.parse(stdout));
+			} catch {
+				reject(/* @__PURE__ */ new Error("npm registry returned malformed JSON"));
+			}
+		});
+	});
+}
+function isRecord(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function basePackument(value) {
+	if (!isRecord(value) || !Array.isArray(value.versions) || !isRecord(value["dist-tags"])) return null;
+	const versions = value.versions.filter((version) => typeof version === "string");
+	if (versions.length === 0) return null;
+	return {
+		"dist-tags": value["dist-tags"],
+		versions: Object.fromEntries(versions.map((version) => [version, { version }]))
+	};
+}
+function selectedVersions(packument, specifications) {
+	const versions = Object.keys(packument.versions ?? {}).filter((version) => semver.valid(version) !== null);
+	const selected = new Set(Object.values(packument["dist-tags"] ?? {}).filter((version) => typeof version === "string" && semver.valid(version) !== null && versions.includes(version)));
+	for (const specification of specifications) {
+		const parsed = parseDependencySpecification(specification);
+		if (parsed.type === "tag") {
+			const tagged = packument["dist-tags"]?.[parsed.rawSpec];
+			if (typeof tagged === "string" && versions.includes(tagged)) selected.add(tagged);
+		} else if (parsed.type === "version") {
+			if (versions.includes(parsed.rawSpec)) selected.add(parsed.rawSpec);
+		} else if (parsed.type === "range") {
+			const matching = semver.maxSatisfying(versions, parsed.rawSpec);
+			if (matching) selected.add(matching);
+		}
+	}
+	return [...selected].sort(semver.compare);
+}
+function mergeVersionMetadata(packument, value, selected) {
+	const entries = Array.isArray(value) ? value : [value];
+	const merged = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (typeof entry === "string") {
+			if (packument.versions?.[entry]) merged.add(entry);
+			continue;
+		}
+		if (!isRecord(entry) || typeof entry.version !== "string") continue;
+		const metadata = packument.versions?.[entry.version];
+		if (!isRecord(metadata)) continue;
+		if (isRecord(entry.peerDependencies)) metadata.peerDependencies = entry.peerDependencies;
+		merged.add(entry.version);
+	}
+	return selected.every((version) => merged.has(version));
+}
+async function executeNpmView(packageName, configuration, specifications) {
+	const packument = basePackument(await executeNpmJson([
+		"view",
+		packageName,
+		"versions",
+		"dist-tags"
+	], configuration, true));
+	if (!packument) return null;
+	const versions = selectedVersions(packument, specifications);
+	if (versions.length === 0) return packument;
+	return mergeVersionMetadata(packument, await executeNpmJson([
+		"view",
+		`${packageName}@${versions.join(" || ")}`,
+		"version",
+		"peerDependencies"
+	], configuration, false), versions) ? packument : null;
+}
+function isPackument(value) {
+	return isRecord(value) && isRecord(value["dist-tags"]) && isRecord(value.versions);
+}
+function sanitizeRegistryError(error) {
+	const value = error && typeof error === "object" ? error : {};
+	if (value.statusCode === 404 || value.code === "E404") return "package was not found in the selected registry";
+	if (value.statusCode === 401 || value.statusCode === 403 || value.code === "E401" || value.code === "E403") return "registry authentication or authorization failed";
+	const code = typeof value.code === "string" ? value.code.toUpperCase() : "";
+	if ([
+		"ETIMEDOUT",
+		"ETIMEOUT",
+		"FETCH_ERROR",
+		"ECONNRESET"
+	].includes(code)) return "registry request timed out or was interrupted";
+	if (/^[A-Z][A-Z0-9_]{1,30}$/.test(code)) return `registry request failed (${code})`;
+	return "registry request failed";
+}
+async function fetchPackuments(packageNames, configuration, options = {}) {
+	const names = [...new Set(packageNames)].sort((left, right) => left.localeCompare(right));
+	const packuments = /* @__PURE__ */ new Map();
+	const failures = /* @__PURE__ */ new Map();
+	const viewPackage = options.viewPackage ?? executeNpmView;
+	let nextIndex = 0;
+	const worker = async () => {
+		while (nextIndex < names.length) {
+			const packageName = names[nextIndex];
+			nextIndex += 1;
+			try {
+				const result = await viewPackage(packageName, configuration, options.requirements?.specifications?.get(packageName) ?? []);
+				if (isPackument(result)) packuments.set(packageName, result);
+				else failures.set(packageName, "registry returned malformed package metadata");
+			} catch (error) {
+				failures.set(packageName, sanitizeRegistryError(error));
+			}
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(8, names.length) }, worker));
+	return {
+		packuments,
+		failures
+	};
+}
+//#endregion
+export { fetchPackuments, loadNpmConfiguration };