@dbx-tools/core 0.9.12 → 0.9.18

package/lib/src/dependency-resolver.js

@@ -0,0 +1,515 @@
+/**
+ * Resolve npm dependency specifiers against a registry.
+ *
+ * Callers pass an already-parsed `package.json`. The functions never write that
+ * project and never run an installer: they GET packuments over HTTP and walk
+ * declared plus transitive `dependencies`. Exact versions stay exact when they
+ * exist; ranges stay ranges when a published version satisfies them.
+ *
+ * `registryUrl` defaults to {@link npmRegistry} from `project-utils`.
+ *
+ * @module
+ */
+import { json, object } from "@dbx-tools/shared-core";
+import { maxSatisfying, satisfies, valid, validRange } from "semver";
+import { npmRegistry } from "./project-utils.js";
+const DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org/";
+const PACKUMENT_TIMEOUT_MS = 30_000;
+const DEPENDENCY_FIELDS = [
+    "dependencies",
+    "devDependencies",
+    "optionalDependencies",
+    "peerDependencies",
+];
+const DEFAULT_MAX_ITERATIONS = 100;
+/**
+ * Return packages the configured registry cannot satisfy for this manifest.
+ *
+ * Walks declared registry specifiers and each reachable packument
+ * `dependencies` map. The input object is not mutated.
+ */
+export async function missingDependencies(manifest, options = {}) {
+    const packageInfo = options.packageInfo ?? createPackageInfoLookup(options.registryUrl);
+    const overrides = overrideMap(manifest);
+    const missing = new Map();
+    const visited = new Set();
+    const consider = async (dep) => {
+        if (!isRegistrySpecifier(toNpmSpecifier(dep)))
+            return;
+        const request = overrides[dep.name] ?? dep;
+        const resolved = await matchingPublishedVersion(request, packageInfo);
+        if (resolved) {
+            await walk(resolved, packageInfo, visited, consider, options.registryUrl);
+            return;
+        }
+        if (!missing.has(dep.name))
+            missing.set(dep.name, request);
+    };
+    await Promise.all(Object.values(declaredDependencies(manifest)).map(consider));
+    return [...missing.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+/**
+ * Return a registry version for one package.
+ *
+ * `request` may be a package name, `name@version` / `name@range`, or a
+ * structured `{ name, version?, range? }` object. A second string argument is
+ * treated as the specifier. An exact version that exists is returned
+ * unchanged. A range is retained when a published version satisfies it.
+ */
+export async function resolveVersion(request, specifierOrOptions, maybeOptions) {
+    const { dependency, options } = resolveVersionArgs(request, specifierOrOptions, maybeOptions);
+    if (dependency.version && !isRegistrySpecifier(dependency.version)) {
+        return {
+            name: dependency.name,
+            version: dependency.version,
+            ...(dependency.range === undefined ? {} : { range: dependency.range }),
+        };
+    }
+    if (dependency.range && !isRegistrySpecifier(dependency.range)) {
+        return { name: dependency.name, version: dependency.range, range: dependency.range };
+    }
+    const packageInfo = options.packageInfo ?? createPackageInfoLookup(options.registryUrl);
+    const info = await packageInfo(dependency.name);
+    if (!info)
+        return undefined;
+    return pickVersion(info, dependency, options.skip);
+}
+function resolveVersionArgs(request, specifierOrOptions, maybeOptions) {
+    if (typeof specifierOrOptions === "string") {
+        const name = typeof request === "string" ? request : request.name;
+        return {
+            dependency: specifierToDependency(name, specifierOrOptions),
+            options: maybeOptions ?? {},
+        };
+    }
+    return {
+        dependency: parseDependencyRequest(request),
+        options: specifierOrOptions ?? maybeOptions ?? {},
+    };
+}
+/**
+ * Return resolvable dependency specifiers for an in-memory `package.json`.
+ *
+ * The input object is not mutated. Unavailable registry packages (or their
+ * parents) are pinned until the packument graph is complete.
+ */
+export async function resolveDependencies(manifest, options = {}) {
+    const working = structuredClone(manifest);
+    const packageInfo = options.packageInfo ?? createPackageInfoLookup(options.registryUrl);
+    const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+    const attempted = new Set();
+    const shared = {
+        packageInfo,
+        ...(options.registryUrl === undefined ? {} : { registryUrl: options.registryUrl }),
+    };
+    for (let iteration = 1; iteration <= maxIterations; iteration += 1) {
+        const missing = await missingDependencies(working, shared);
+        if (missing.length === 0)
+            return snapshot(working, packageInfo);
+        let changed = false;
+        for (const entry of missing) {
+            const pin = await pinForMissing(entry, working, packageInfo, attempted);
+            if (pin)
+                changed = pinPackage(working, pin) || changed;
+        }
+        if (!changed) {
+            throw new Error(`No remaining registry pin for: ${missing.map((entry) => entry.name).join(", ")}`);
+        }
+    }
+    throw new Error(`Reached ${maxIterations} pin attempts without a complete registry graph.`);
+}
+async function matchingPublishedVersion(request, packageInfo) {
+    const info = await packageInfo(request.name);
+    if (!info)
+        return undefined;
+    const version = publishedMatch(info, request);
+    if (!version)
+        return undefined;
+    return request.range === undefined
+        ? { name: info.name, version }
+        : { name: info.name, version, range: request.range };
+}
+function publishedMatch(info, request) {
+    if (request.range && validRange(request.range)) {
+        if (request.version &&
+            info.versions.includes(request.version) &&
+            satisfies(request.version, request.range)) {
+            return request.version;
+        }
+        return maxSatisfying(info.versions, request.range) ?? undefined;
+    }
+    if (request.version) {
+        if (info.versions.includes(request.version))
+            return request.version;
+        if (validRange(request.version)) {
+            return maxSatisfying(info.versions, request.version) ?? undefined;
+        }
+        return undefined;
+    }
+    return newestPublished(info, info.versions);
+}
+async function walk(resolved, packageInfo, visited, consider, registryUrl) {
+    const key = `${resolved.name}@${resolved.version}`;
+    if (visited.has(key))
+        return;
+    visited.add(key);
+    const info = await packageInfo(resolved.name);
+    let deps = info?.dependencies[resolved.version];
+    if (deps === undefined && info) {
+        deps = await loadVersionDependencies(resolved.name, resolved.version, registryUrl);
+        info.dependencies[resolved.version] = deps;
+    }
+    await Promise.all(Object.entries(deps ?? {}).map(([name, spec]) => consider(specifierToDependency(name, spec))));
+}
+async function snapshot(manifest, packageInfo) {
+    return {
+        dependencies: await specifierMap(manifest, "dependencies", packageInfo),
+        devDependencies: await specifierMap(manifest, "devDependencies", packageInfo),
+        optionalDependencies: await specifierMap(manifest, "optionalDependencies", packageInfo),
+        peerDependencies: await specifierMap(manifest, "peerDependencies", packageInfo),
+        overrides: await structuredMap(overrideMap(manifest), packageInfo),
+    };
+}
+async function specifierMap(manifest, field, packageInfo) {
+    return structuredMap(dependencyMap(manifest, field), packageInfo);
+}
+async function structuredMap(specs, packageInfo) {
+    const out = {};
+    for (const [name, spec] of Object.entries(specs)) {
+        out[name] = await structuredSpecifier(spec, packageInfo);
+    }
+    return out;
+}
+async function structuredSpecifier(spec, packageInfo) {
+    const resolved = await resolveVersion(spec, { packageInfo });
+    if (resolved)
+        return resolved;
+    const fallback = spec.version ?? spec.range ?? spec.semver;
+    return fallback === undefined
+        ? { name: spec.name, version: "*" }
+        : { name: spec.name, version: fallback };
+}
+function parseDependencyRequest(request) {
+    if (typeof request !== "string")
+        return normalizeDependency(request);
+    const name = stripVersion(request);
+    if (name === request)
+        return { name };
+    if (!request.startsWith(`${name}@`))
+        return { name };
+    return specifierToDependency(name, request.slice(name.length + 1));
+}
+function specifierToDependency(name, spec) {
+    if (!spec || spec === "latest")
+        return { name };
+    if (!isRegistrySpecifier(spec))
+        return { name, version: spec };
+    if (valid(spec))
+        return { name, version: spec };
+    if (validRange(spec))
+        return { name, range: spec };
+    return { name, version: spec };
+}
+function normalizeDependency(request) {
+    const version = request.version ?? request.semver;
+    const range = request.range;
+    const out = { name: request.name };
+    if (version && !valid(version) && !range && validRange(version) && isRegistrySpecifier(version)) {
+        out.range = version;
+        return out;
+    }
+    if (version)
+        out.version = version;
+    if (range)
+        out.range = range;
+    return out;
+}
+function parseSpecifierInput(name, value) {
+    if (typeof value === "string")
+        return specifierToDependency(name, value);
+    if (!object.isRecord(value))
+        return undefined;
+    const version = typeof value.version === "string" ? value.version : undefined;
+    const semverValue = typeof value.semver === "string" ? value.semver : undefined;
+    const range = typeof value.range === "string" ? value.range : undefined;
+    const entryName = typeof value.name === "string" ? value.name : name;
+    if (!version && !semverValue && !range)
+        return undefined;
+    return normalizeDependency({ name: entryName, version, semver: semverValue, range });
+}
+function dependencyMap(manifest, field) {
+    return parseDependencyField(manifest[field]);
+}
+function parseDependencyField(value) {
+    if (!object.isRecord(value))
+        return {};
+    const out = {};
+    for (const [name, spec] of Object.entries(value)) {
+        const parsed = parseSpecifierInput(name, spec);
+        if (parsed)
+            out[name] = parsed;
+    }
+    return out;
+}
+function declaredDependencies(manifest) {
+    const out = {};
+    for (const field of DEPENDENCY_FIELDS)
+        Object.assign(out, dependencyMap(manifest, field));
+    return out;
+}
+function isRegistrySpecifier(spec) {
+    return !/^(workspace:|catalog:|file:|link:|git\+|github:|https?:|npm:)/i.test(spec);
+}
+function overrideMap(manifest) {
+    return parseDependencyField(manifest.overrides);
+}
+function toNpmSpecifier(dependency) {
+    if (dependency.range && dependency.version && isRegistrySpecifier(dependency.range)) {
+        if (valid(dependency.version) && satisfies(dependency.version, dependency.range)) {
+            return dependency.range;
+        }
+    }
+    if (dependency.range)
+        return dependency.range;
+    if (dependency.version)
+        return dependency.version;
+    return "*";
+}
+function pinPackage(manifest, resolved) {
+    let changed = false;
+    const overrides = overrideMap(manifest);
+    const overridePin = { name: resolved.name, version: resolved.version };
+    if (toNpmSpecifier(overrides[resolved.name] ?? { name: resolved.name }) !== resolved.version) {
+        overrides[resolved.name] = overridePin;
+        manifest.overrides = Object.fromEntries(Object.entries(overrides).map(([name, dependency]) => [name, dependency]));
+        changed = true;
+    }
+    const depPin = {
+        name: resolved.name,
+        version: resolved.version,
+        ...(resolved.range === undefined ? {} : { range: resolved.range }),
+    };
+    for (const field of DEPENDENCY_FIELDS) {
+        const deps = dependencyMap(manifest, field);
+        const current = deps[resolved.name];
+        if (!current)
+            continue;
+        if (!isRegistrySpecifier(toNpmSpecifier(current)))
+            continue;
+        if (sameDependency(current, depPin))
+            continue;
+        deps[resolved.name] = depPin;
+        manifest[field] = deps;
+        changed = true;
+    }
+    return changed;
+}
+function sameDependency(left, right) {
+    return left.version === right.version && left.range === right.range;
+}
+function newestFirst(versions) {
+    return [...versions].sort((left, right) => right.localeCompare(left, undefined, { numeric: true, sensitivity: "base" }));
+}
+function pickVersion(info, request, skip) {
+    const versions = info.versions.filter((version) => !skip?.has(version));
+    if (versions.length === 0)
+        return undefined;
+    const fallback = newestPublished(info, versions);
+    if (!fallback)
+        return undefined;
+    if (request.range && validRange(request.range)) {
+        const matched = maxSatisfying(versions, request.range);
+        if (request.version &&
+            versions.includes(request.version) &&
+            satisfies(request.version, request.range)) {
+            return { name: info.name, version: request.version, range: request.range };
+        }
+        return matched
+            ? { name: info.name, version: matched, range: request.range }
+            : { name: info.name, version: fallback, range: request.range };
+    }
+    if (request.version) {
+        return {
+            name: info.name,
+            version: versions.includes(request.version) ? request.version : fallback,
+        };
+    }
+    return { name: info.name, version: fallback };
+}
+function newestPublished(info, versions) {
+    if (info.latest && versions.includes(info.latest))
+        return info.latest;
+    return newestFirst(versions)[0];
+}
+function skippedVersions(name, attempted) {
+    const prefix = `${name}@`;
+    const skipped = new Set();
+    for (const key of attempted) {
+        if (key.startsWith(prefix))
+            skipped.add(key.slice(prefix.length));
+    }
+    return skipped;
+}
+function stripVersion(value) {
+    if (value.startsWith("@")) {
+        const slash = value.indexOf("/");
+        const at = value.indexOf("@", slash + 1);
+        return at === -1 ? value : value.slice(0, at);
+    }
+    const at = value.indexOf("@");
+    return at === -1 ? value : value.slice(0, at);
+}
+async function pinForMissing(missing, manifest, packageInfo, attempted) {
+    const resolved = await resolveVersion(missing, {
+        packageInfo,
+        skip: skippedVersions(missing.name, attempted),
+    });
+    if (resolved) {
+        attempted.add(`${missing.name}@${resolved.version}`);
+        return resolved;
+    }
+    for (const parent of await parentPackages(missing.name, manifest, packageInfo)) {
+        const info = await packageInfo(parent);
+        if (!info)
+            continue;
+        const version = compatibleParentVersion(missing.name, info, attempted);
+        if (!version)
+            continue;
+        attempted.add(`${parent}@${version}`);
+        const declared = declaredDependencies(manifest)[parent] ?? { name: parent };
+        return pickVersion({ ...info, versions: [version], latest: version }, declared);
+    }
+    return undefined;
+}
+function compatibleParentVersion(missing, info, attempted) {
+    for (const version of newestFirst(info.versions)) {
+        if (attempted.has(`${info.name}@${version}`))
+            continue;
+        if (!(missing in (info.dependencies[version] ?? {})))
+            return version;
+    }
+    return undefined;
+}
+async function parentPackages(missing, manifest, packageInfo) {
+    const declared = declaredDependencies(manifest);
+    const declaredSpec = declared[missing];
+    if (declaredSpec && isRegistrySpecifier(toNpmSpecifier(declaredSpec)))
+        return [];
+    const parents = [];
+    for (const name of Object.keys(declared)) {
+        if (name === missing || !isRegistrySpecifier(toNpmSpecifier(declared[name] ?? { name }))) {
+            continue;
+        }
+        const info = await packageInfo(name);
+        if (!info)
+            continue;
+        if (Object.values(info.dependencies).some((map) => missing in map))
+            parents.push(name);
+    }
+    return parents;
+}
+function resolveRegistryUrl(registryUrl) {
+    const raw = registryUrl?.toString() ||
+        npmRegistry(null, { envVars: true })?.toString() ||
+        DEFAULT_NPM_REGISTRY;
+    return raw.replace(/\/+$/, "");
+}
+function encodePackageName(name) {
+    if (name.startsWith("@")) {
+        const slash = name.indexOf("/");
+        if (slash !== -1) {
+            return `${name.slice(0, slash)}%2f${encodeURIComponent(name.slice(slash + 1))}`;
+        }
+    }
+    return encodeURIComponent(name);
+}
+function packumentUrl(name, registryUrl) {
+    return `${resolveRegistryUrl(registryUrl)}/${encodePackageName(name)}`;
+}
+async function fetchRegistryJson(url) {
+    const response = await fetch(url, {
+        headers: { accept: "application/json" },
+        signal: AbortSignal.timeout(PACKUMENT_TIMEOUT_MS),
+    }).catch(() => undefined);
+    if (!response?.ok)
+        return undefined;
+    const text = await response.text();
+    return json.parse(text);
+}
+function createPackageInfoLookup(registryUrl) {
+    const cache = new Map();
+    return (name) => {
+        const cached = cache.get(name);
+        if (cached)
+            return cached;
+        const pending = loadPackageInfo(name, registryUrl);
+        cache.set(name, pending);
+        void pending.then(undefined, () => {
+            cache.delete(name);
+        });
+        return pending;
+    };
+}
+async function loadPackageInfo(name, registryUrl) {
+    const packument = await fetchRegistryJson(packumentUrl(name, registryUrl));
+    if (!object.isRecord(packument))
+        return undefined;
+    const versions = publishedVersions(packument);
+    if (versions.length === 0)
+        return undefined;
+    return {
+        name,
+        versions,
+        latest: latestTag(packument) ?? versions.at(-1),
+        dependencies: versionDependencies(packument),
+    };
+}
+async function loadVersionDependencies(name, version, registryUrl) {
+    const doc = await fetchRegistryJson(`${packumentUrl(name, registryUrl)}/${encodeURIComponent(version)}`);
+    if (!object.isRecord(doc))
+        return {};
+    return stringMap(doc.dependencies);
+}
+function publishedVersions(packument) {
+    if (typeof packument.version === "string" && !packument.versions) {
+        return [packument.version];
+    }
+    const versions = packument.versions;
+    if (Array.isArray(versions)) {
+        return versions.filter((value) => typeof value === "string");
+    }
+    if (object.isRecord(versions))
+        return Object.keys(versions);
+    return [];
+}
+function latestTag(packument) {
+    const tags = packument["dist-tags"];
+    if (!object.isRecord(tags) || typeof tags.latest !== "string")
+        return undefined;
+    return tags.latest;
+}
+function versionDependencies(packument) {
+    const versions = packument.versions;
+    if (!object.isRecord(versions)) {
+        return typeof packument.version === "string"
+            ? { [packument.version]: stringMap(packument.dependencies) }
+            : {};
+    }
+    const out = {};
+    for (const [version, value] of Object.entries(versions)) {
+        if (object.isRecord(value))
+            out[version] = stringMap(value.dependencies);
+    }
+    return out;
+}
+function stringMap(value) {
+    if (!object.isRecord(value))
+        return {};
+    const out = {};
+    for (const [name, spec] of Object.entries(value)) {
+        if (typeof spec === "string")
+            out[name] = spec;
+    }
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dependency-resolver.js","sourceRoot":"","sources":["../../src/dependency-resolver.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Resolve npm dependency specifiers against a registry.\n *\n * Callers pass an already-parsed `package.json`. The functions never write that\n * project and never run an installer: they GET packuments over HTTP and walk\n * declared plus transitive `dependencies`. Exact versions stay exact when they\n * exist; ranges stay ranges when a published version satisfies them.\n *\n * `registryUrl` defaults to {@link npmRegistry} from `project-utils`.\n *\n * @module\n */\n\nimport { json, object } from \"@dbx-tools/shared-core\";\nimport { maxSatisfying, satisfies, valid, validRange } from \"semver\";\n\nimport { npmRegistry } from \"./project-utils.ts\";\n\nconst DEFAULT_NPM_REGISTRY = \"https://registry.npmjs.org/\";\nconst PACKUMENT_TIMEOUT_MS = 30_000;\n\nconst DEPENDENCY_FIELDS = [\n  \"dependencies\",\n  \"devDependencies\",\n  \"optionalDependencies\",\n  \"peerDependencies\",\n] as const;\n\nconst DEFAULT_MAX_ITERATIONS = 100;\n\ntype DependencyField = (typeof DEPENDENCY_FIELDS)[number];\n\ntype PackageInfo = {\n  name: string;\n  versions: string[];\n  latest?: string;\n  dependencies: Record<string, Record<string, string>>;\n};\n\n/** Registry and traversal policy for dependency resolution. */\nexport type DependencyResolverOptions = {\n  /** Graph-walk attempts before giving up. Defaults to 100. */\n  maxIterations?: number;\n  /**\n   * Registry origin used for packument GETs. Defaults to\n   * `projectUtils.npmRegistry()` (env, npmrc, bunfig, pnpm yaml, then public npm).\n   */\n  registryUrl?: string | URL;\n  packageInfo?: (name: string) => Promise<PackageInfo | undefined>;\n  skip?: ReadonlySet<string>;\n};\n\n/**\n * Package identity plus optional exact version and/or semver range.\n *\n * `semver` is accepted as an input alias for `version`.\n */\nexport type DependencyInfo = {\n  name: string;\n  version?: string;\n  semver?: string;\n  range?: string;\n};\n\n/** Concrete registry version, plus the original range when one was requested. */\nexport type ResolvedNpmVersion = {\n  name: string;\n  version: string;\n  range?: string;\n};\n\n/** String specifier or structured `{ version, range, name? }` value. */\nexport type NpmSpecifierInput = string | Omit<DependencyInfo, \"name\"> | DependencyInfo;\n\n/** Registry dependency maps with resolved versions and retained ranges. */\nexport type ResolvedNpmDependencies = {\n  dependencies: Record<string, ResolvedNpmVersion>;\n  devDependencies: Record<string, ResolvedNpmVersion>;\n  optionalDependencies: Record<string, ResolvedNpmVersion>;\n  peerDependencies: Record<string, ResolvedNpmVersion>;\n  overrides: Record<string, ResolvedNpmVersion>;\n};\n\n/** A package whose requested specifier is not in the configured registry. */\nexport type MissingDependencyInfo = DependencyInfo;\n\n/**\n * Return packages the configured registry cannot satisfy for this manifest.\n *\n * Walks declared registry specifiers and each reachable packument\n * `dependencies` map. The input object is not mutated.\n */\nexport async function missingDependencies(\n  manifest: Record<string, unknown>,\n  options: DependencyResolverOptions = {},\n): Promise<MissingDependencyInfo[]> {\n  const packageInfo = options.packageInfo ?? createPackageInfoLookup(options.registryUrl);\n  const overrides = overrideMap(manifest);\n  const missing = new Map<string, DependencyInfo>();\n  const visited = new Set<string>();\n\n  const consider = async (dep: DependencyInfo): Promise<void> => {\n    if (!isRegistrySpecifier(toNpmSpecifier(dep))) return;\n    const request = overrides[dep.name] ?? dep;\n    const resolved = await matchingPublishedVersion(request, packageInfo);\n    if (resolved) {\n      await walk(resolved, packageInfo, visited, consider, options.registryUrl);\n      return;\n    }\n    if (!missing.has(dep.name)) missing.set(dep.name, request);\n  };\n\n  await Promise.all(Object.values(declaredDependencies(manifest)).map(consider));\n  return [...missing.values()].sort((left, right) => left.name.localeCompare(right.name));\n}\n\n/**\n * Return a registry version for one package.\n *\n * `request` may be a package name, `name@version` / `name@range`, or a\n * structured `{ name, version?, range? }` object. A second string argument is\n * treated as the specifier. An exact version that exists is returned\n * unchanged. A range is retained when a published version satisfies it.\n */\nexport async function resolveVersion(\n  request: string | DependencyInfo,\n  specifierOrOptions?: string | DependencyResolverOptions,\n  maybeOptions?: DependencyResolverOptions,\n): Promise<ResolvedNpmVersion | undefined> {\n  const { dependency, options } = resolveVersionArgs(request, specifierOrOptions, maybeOptions);\n  if (dependency.version && !isRegistrySpecifier(dependency.version)) {\n    return {\n      name: dependency.name,\n      version: dependency.version,\n      ...(dependency.range === undefined ? {} : { range: dependency.range }),\n    };\n  }\n  if (dependency.range && !isRegistrySpecifier(dependency.range)) {\n    return { name: dependency.name, version: dependency.range, range: dependency.range };\n  }\n  const packageInfo = options.packageInfo ?? createPackageInfoLookup(options.registryUrl);\n  const info = await packageInfo(dependency.name);\n  if (!info) return undefined;\n  return pickVersion(info, dependency, options.skip);\n}\n\nfunction resolveVersionArgs(\n  request: string | DependencyInfo,\n  specifierOrOptions?: string | DependencyResolverOptions,\n  maybeOptions?: DependencyResolverOptions,\n): { dependency: DependencyInfo; options: DependencyResolverOptions } {\n  if (typeof specifierOrOptions === \"string\") {\n    const name = typeof request === \"string\" ? request : request.name;\n    return {\n      dependency: specifierToDependency(name, specifierOrOptions),\n      options: maybeOptions ?? {},\n    };\n  }\n  return {\n    dependency: parseDependencyRequest(request),\n    options: specifierOrOptions ?? maybeOptions ?? {},\n  };\n}\n\n/**\n * Return resolvable dependency specifiers for an in-memory `package.json`.\n *\n * The input object is not mutated. Unavailable registry packages (or their\n * parents) are pinned until the packument graph is complete.\n */\nexport async function resolveDependencies(\n  manifest: Record<string, unknown>,\n  options: DependencyResolverOptions = {},\n): Promise<ResolvedNpmDependencies> {\n  const working = structuredClone(manifest);\n  const packageInfo = options.packageInfo ?? createPackageInfoLookup(options.registryUrl);\n  const maxIterations = options.maxIterations ?? DEFAULT_MAX_ITERATIONS;\n  const attempted = new Set<string>();\n  const shared: DependencyResolverOptions = {\n    packageInfo,\n    ...(options.registryUrl === undefined ? {} : { registryUrl: options.registryUrl }),\n  };\n\n  for (let iteration = 1; iteration <= maxIterations; iteration += 1) {\n    const missing = await missingDependencies(working, shared);\n    if (missing.length === 0) return snapshot(working, packageInfo);\n\n    let changed = false;\n    for (const entry of missing) {\n      const pin = await pinForMissing(entry, working, packageInfo, attempted);\n      if (pin) changed = pinPackage(working, pin) || changed;\n    }\n    if (!changed) {\n      throw new Error(\n        `No remaining registry pin for: ${missing.map((entry) => entry.name).join(\", \")}`,\n      );\n    }\n  }\n\n  throw new Error(`Reached ${maxIterations} pin attempts without a complete registry graph.`);\n}\n\nasync function matchingPublishedVersion(\n  request: DependencyInfo,\n  packageInfo: (name: string) => Promise<PackageInfo | undefined>,\n): Promise<ResolvedNpmVersion | undefined> {\n  const info = await packageInfo(request.name);\n  if (!info) return undefined;\n  const version = publishedMatch(info, request);\n  if (!version) return undefined;\n  return request.range === undefined\n    ? { name: info.name, version }\n    : { name: info.name, version, range: request.range };\n}\n\nfunction publishedMatch(info: PackageInfo, request: DependencyInfo): string | undefined {\n  if (request.range && validRange(request.range)) {\n    if (\n      request.version &&\n      info.versions.includes(request.version) &&\n      satisfies(request.version, request.range)\n    ) {\n      return request.version;\n    }\n    return maxSatisfying(info.versions, request.range) ?? undefined;\n  }\n  if (request.version) {\n    if (info.versions.includes(request.version)) return request.version;\n    if (validRange(request.version)) {\n      return maxSatisfying(info.versions, request.version) ?? undefined;\n    }\n    return undefined;\n  }\n  return newestPublished(info, info.versions);\n}\n\nasync function walk(\n  resolved: ResolvedNpmVersion,\n  packageInfo: (name: string) => Promise<PackageInfo | undefined>,\n  visited: Set<string>,\n  consider: (dep: DependencyInfo) => Promise<void>,\n  registryUrl?: string | URL,\n): Promise<void> {\n  const key = `${resolved.name}@${resolved.version}`;\n  if (visited.has(key)) return;\n  visited.add(key);\n  const info = await packageInfo(resolved.name);\n  let deps = info?.dependencies[resolved.version];\n  if (deps === undefined && info) {\n    deps = await loadVersionDependencies(resolved.name, resolved.version, registryUrl);\n    info.dependencies[resolved.version] = deps;\n  }\n  await Promise.all(\n    Object.entries(deps ?? {}).map(([name, spec]) => consider(specifierToDependency(name, spec))),\n  );\n}\n\nasync function snapshot(\n  manifest: Record<string, unknown>,\n  packageInfo: (name: string) => Promise<PackageInfo | undefined>,\n): Promise<ResolvedNpmDependencies> {\n  return {\n    dependencies: await specifierMap(manifest, \"dependencies\", packageInfo),\n    devDependencies: await specifierMap(manifest, \"devDependencies\", packageInfo),\n    optionalDependencies: await specifierMap(manifest, \"optionalDependencies\", packageInfo),\n    peerDependencies: await specifierMap(manifest, \"peerDependencies\", packageInfo),\n    overrides: await structuredMap(overrideMap(manifest), packageInfo),\n  };\n}\n\nasync function specifierMap(\n  manifest: Record<string, unknown>,\n  field: DependencyField,\n  packageInfo: (name: string) => Promise<PackageInfo | undefined>,\n): Promise<Record<string, ResolvedNpmVersion>> {\n  return structuredMap(dependencyMap(manifest, field), packageInfo);\n}\n\nasync function structuredMap(\n  specs: Record<string, DependencyInfo>,\n  packageInfo: (name: string) => Promise<PackageInfo | undefined>,\n): Promise<Record<string, ResolvedNpmVersion>> {\n  const out: Record<string, ResolvedNpmVersion> = {};\n  for (const [name, spec] of Object.entries(specs)) {\n    out[name] = await structuredSpecifier(spec, packageInfo);\n  }\n  return out;\n}\n\nasync function structuredSpecifier(\n  spec: DependencyInfo,\n  packageInfo: (name: string) => Promise<PackageInfo | undefined>,\n): Promise<ResolvedNpmVersion> {\n  const resolved = await resolveVersion(spec, { packageInfo });\n  if (resolved) return resolved;\n  const fallback = spec.version ?? spec.range ?? spec.semver;\n  return fallback === undefined\n    ? { name: spec.name, version: \"*\" }\n    : { name: spec.name, version: fallback };\n}\n\nfunction parseDependencyRequest(request: string | DependencyInfo): DependencyInfo {\n  if (typeof request !== \"string\") return normalizeDependency(request);\n  const name = stripVersion(request);\n  if (name === request) return { name };\n  if (!request.startsWith(`${name}@`)) return { name };\n  return specifierToDependency(name, request.slice(name.length + 1));\n}\n\nfunction specifierToDependency(name: string, spec: string): DependencyInfo {\n  if (!spec || spec === \"latest\") return { name };\n  if (!isRegistrySpecifier(spec)) return { name, version: spec };\n  if (valid(spec)) return { name, version: spec };\n  if (validRange(spec)) return { name, range: spec };\n  return { name, version: spec };\n}\n\nfunction normalizeDependency(request: DependencyInfo): DependencyInfo {\n  const version = request.version ?? request.semver;\n  const range = request.range;\n  const out: DependencyInfo = { name: request.name };\n  if (version && !valid(version) && !range && validRange(version) && isRegistrySpecifier(version)) {\n    out.range = version;\n    return out;\n  }\n  if (version) out.version = version;\n  if (range) out.range = range;\n  return out;\n}\n\nfunction parseSpecifierInput(name: string, value: unknown): DependencyInfo | undefined {\n  if (typeof value === \"string\") return specifierToDependency(name, value);\n  if (!object.isRecord(value)) return undefined;\n  const version = typeof value.version === \"string\" ? value.version : undefined;\n  const semverValue = typeof value.semver === \"string\" ? value.semver : undefined;\n  const range = typeof value.range === \"string\" ? value.range : undefined;\n  const entryName = typeof value.name === \"string\" ? value.name : name;\n  if (!version && !semverValue && !range) return undefined;\n  return normalizeDependency({ name: entryName, version, semver: semverValue, range });\n}\n\nfunction dependencyMap(\n  manifest: Record<string, unknown>,\n  field: DependencyField,\n): Record<string, DependencyInfo> {\n  return parseDependencyField(manifest[field]);\n}\n\nfunction parseDependencyField(value: unknown): Record<string, DependencyInfo> {\n  if (!object.isRecord(value)) return {};\n  const out: Record<string, DependencyInfo> = {};\n  for (const [name, spec] of Object.entries(value)) {\n    const parsed = parseSpecifierInput(name, spec);\n    if (parsed) out[name] = parsed;\n  }\n  return out;\n}\n\nfunction declaredDependencies(manifest: Record<string, unknown>): Record<string, DependencyInfo> {\n  const out: Record<string, DependencyInfo> = {};\n  for (const field of DEPENDENCY_FIELDS) Object.assign(out, dependencyMap(manifest, field));\n  return out;\n}\n\nfunction isRegistrySpecifier(spec: string): boolean {\n  return !/^(workspace:|catalog:|file:|link:|git\\+|github:|https?:|npm:)/i.test(spec);\n}\n\nfunction overrideMap(manifest: Record<string, unknown>): Record<string, DependencyInfo> {\n  return parseDependencyField(manifest.overrides);\n}\n\nfunction toNpmSpecifier(dependency: DependencyInfo): string {\n  if (dependency.range && dependency.version && isRegistrySpecifier(dependency.range)) {\n    if (valid(dependency.version) && satisfies(dependency.version, dependency.range)) {\n      return dependency.range;\n    }\n  }\n  if (dependency.range) return dependency.range;\n  if (dependency.version) return dependency.version;\n  return \"*\";\n}\n\nfunction pinPackage(manifest: Record<string, unknown>, resolved: ResolvedNpmVersion): boolean {\n  let changed = false;\n  const overrides = overrideMap(manifest);\n  const overridePin: DependencyInfo = { name: resolved.name, version: resolved.version };\n  if (toNpmSpecifier(overrides[resolved.name] ?? { name: resolved.name }) !== resolved.version) {\n    overrides[resolved.name] = overridePin;\n    manifest.overrides = Object.fromEntries(\n      Object.entries(overrides).map(([name, dependency]) => [name, dependency]),\n    );\n    changed = true;\n  }\n  const depPin: DependencyInfo = {\n    name: resolved.name,\n    version: resolved.version,\n    ...(resolved.range === undefined ? {} : { range: resolved.range }),\n  };\n  for (const field of DEPENDENCY_FIELDS) {\n    const deps = dependencyMap(manifest, field);\n    const current = deps[resolved.name];\n    if (!current) continue;\n    if (!isRegistrySpecifier(toNpmSpecifier(current))) continue;\n    if (sameDependency(current, depPin)) continue;\n    deps[resolved.name] = depPin;\n    manifest[field] = deps;\n    changed = true;\n  }\n  return changed;\n}\n\nfunction sameDependency(left: DependencyInfo, right: DependencyInfo): boolean {\n  return left.version === right.version && left.range === right.range;\n}\n\nfunction newestFirst(versions: readonly string[]): string[] {\n  return [...versions].sort((left, right) =>\n    right.localeCompare(left, undefined, { numeric: true, sensitivity: \"base\" }),\n  );\n}\n\nfunction pickVersion(\n  info: PackageInfo,\n  request: DependencyInfo,\n  skip?: ReadonlySet<string>,\n): ResolvedNpmVersion | undefined {\n  const versions = info.versions.filter((version) => !skip?.has(version));\n  if (versions.length === 0) return undefined;\n  const fallback = newestPublished(info, versions);\n  if (!fallback) return undefined;\n  if (request.range && validRange(request.range)) {\n    const matched = maxSatisfying(versions, request.range);\n    if (\n      request.version &&\n      versions.includes(request.version) &&\n      satisfies(request.version, request.range)\n    ) {\n      return { name: info.name, version: request.version, range: request.range };\n    }\n    return matched\n      ? { name: info.name, version: matched, range: request.range }\n      : { name: info.name, version: fallback, range: request.range };\n  }\n  if (request.version) {\n    return {\n      name: info.name,\n      version: versions.includes(request.version) ? request.version : fallback,\n    };\n  }\n  return { name: info.name, version: fallback };\n}\n\nfunction newestPublished(info: PackageInfo, versions: readonly string[]): string | undefined {\n  if (info.latest && versions.includes(info.latest)) return info.latest;\n  return newestFirst(versions)[0];\n}\n\nfunction skippedVersions(name: string, attempted: ReadonlySet<string>): Set<string> {\n  const prefix = `${name}@`;\n  const skipped = new Set<string>();\n  for (const key of attempted) {\n    if (key.startsWith(prefix)) skipped.add(key.slice(prefix.length));\n  }\n  return skipped;\n}\n\nfunction stripVersion(value: string): string {\n  if (value.startsWith(\"@\")) {\n    const slash = value.indexOf(\"/\");\n    const at = value.indexOf(\"@\", slash + 1);\n    return at === -1 ? value : value.slice(0, at);\n  }\n  const at = value.indexOf(\"@\");\n  return at === -1 ? value : value.slice(0, at);\n}\n\nasync function pinForMissing(\n  missing: MissingDependencyInfo,\n  manifest: Record<string, unknown>,\n  packageInfo: (name: string) => Promise<PackageInfo | undefined>,\n  attempted: Set<string>,\n): Promise<ResolvedNpmVersion | undefined> {\n  const resolved = await resolveVersion(missing, {\n    packageInfo,\n    skip: skippedVersions(missing.name, attempted),\n  });\n  if (resolved) {\n    attempted.add(`${missing.name}@${resolved.version}`);\n    return resolved;\n  }\n\n  for (const parent of await parentPackages(missing.name, manifest, packageInfo)) {\n    const info = await packageInfo(parent);\n    if (!info) continue;\n    const version = compatibleParentVersion(missing.name, info, attempted);\n    if (!version) continue;\n    attempted.add(`${parent}@${version}`);\n    const declared = declaredDependencies(manifest)[parent] ?? { name: parent };\n    return pickVersion({ ...info, versions: [version], latest: version }, declared);\n  }\n  return undefined;\n}\n\nfunction compatibleParentVersion(\n  missing: string,\n  info: PackageInfo,\n  attempted: Set<string>,\n): string | undefined {\n  for (const version of newestFirst(info.versions)) {\n    if (attempted.has(`${info.name}@${version}`)) continue;\n    if (!(missing in (info.dependencies[version] ?? {}))) return version;\n  }\n  return undefined;\n}\n\nasync function parentPackages(\n  missing: string,\n  manifest: Record<string, unknown>,\n  packageInfo: (name: string) => Promise<PackageInfo | undefined>,\n): Promise<string[]> {\n  const declared = declaredDependencies(manifest);\n  const declaredSpec = declared[missing];\n  if (declaredSpec && isRegistrySpecifier(toNpmSpecifier(declaredSpec))) return [];\n  const parents: string[] = [];\n  for (const name of Object.keys(declared)) {\n    if (name === missing || !isRegistrySpecifier(toNpmSpecifier(declared[name] ?? { name }))) {\n      continue;\n    }\n    const info = await packageInfo(name);\n    if (!info) continue;\n    if (Object.values(info.dependencies).some((map) => missing in map)) parents.push(name);\n  }\n  return parents;\n}\n\nfunction resolveRegistryUrl(registryUrl?: string | URL): string {\n  const raw =\n    registryUrl?.toString() ||\n    npmRegistry(null, { envVars: true })?.toString() ||\n    DEFAULT_NPM_REGISTRY;\n  return raw.replace(/\\/+$/, \"\");\n}\n\nfunction encodePackageName(name: string): string {\n  if (name.startsWith(\"@\")) {\n    const slash = name.indexOf(\"/\");\n    if (slash !== -1) {\n      return `${name.slice(0, slash)}%2f${encodeURIComponent(name.slice(slash + 1))}`;\n    }\n  }\n  return encodeURIComponent(name);\n}\n\nfunction packumentUrl(name: string, registryUrl?: string | URL): string {\n  return `${resolveRegistryUrl(registryUrl)}/${encodePackageName(name)}`;\n}\n\nasync function fetchRegistryJson(url: string): Promise<unknown> {\n  const response = await fetch(url, {\n    headers: { accept: \"application/json\" },\n    signal: AbortSignal.timeout(PACKUMENT_TIMEOUT_MS),\n  }).catch(() => undefined);\n  if (!response?.ok) return undefined;\n  const text = await response.text();\n  return json.parse(text);\n}\n\nfunction createPackageInfoLookup(\n  registryUrl?: string | URL,\n): (name: string) => Promise<PackageInfo | undefined> {\n  const cache = new Map<string, Promise<PackageInfo | undefined>>();\n  return (name) => {\n    const cached = cache.get(name);\n    if (cached) return cached;\n    const pending = loadPackageInfo(name, registryUrl);\n    cache.set(name, pending);\n    void pending.then(undefined, () => {\n      cache.delete(name);\n    });\n    return pending;\n  };\n}\n\nasync function loadPackageInfo(\n  name: string,\n  registryUrl?: string | URL,\n): Promise<PackageInfo | undefined> {\n  const packument = await fetchRegistryJson(packumentUrl(name, registryUrl));\n  if (!object.isRecord(packument)) return undefined;\n  const versions = publishedVersions(packument);\n  if (versions.length === 0) return undefined;\n  return {\n    name,\n    versions,\n    latest: latestTag(packument) ?? versions.at(-1),\n    dependencies: versionDependencies(packument),\n  };\n}\n\nasync function loadVersionDependencies(\n  name: string,\n  version: string,\n  registryUrl?: string | URL,\n): Promise<Record<string, string>> {\n  const doc = await fetchRegistryJson(\n    `${packumentUrl(name, registryUrl)}/${encodeURIComponent(version)}`,\n  );\n  if (!object.isRecord(doc)) return {};\n  return stringMap(doc.dependencies);\n}\n\nfunction publishedVersions(packument: Record<string, unknown>): string[] {\n  if (typeof packument.version === \"string\" && !packument.versions) {\n    return [packument.version];\n  }\n  const versions = packument.versions;\n  if (Array.isArray(versions)) {\n    return versions.filter((value): value is string => typeof value === \"string\");\n  }\n  if (object.isRecord(versions)) return Object.keys(versions);\n  return [];\n}\n\nfunction latestTag(packument: Record<string, unknown>): string | undefined {\n  const tags = packument[\"dist-tags\"];\n  if (!object.isRecord(tags) || typeof tags.latest !== \"string\") return undefined;\n  return tags.latest;\n}\n\nfunction versionDependencies(\n  packument: Record<string, unknown>,\n): Record<string, Record<string, string>> {\n  const versions = packument.versions;\n  if (!object.isRecord(versions)) {\n    return typeof packument.version === \"string\"\n      ? { [packument.version]: stringMap(packument.dependencies) }\n      : {};\n  }\n  const out: Record<string, Record<string, string>> = {};\n  for (const [version, value] of Object.entries(versions)) {\n    if (object.isRecord(value)) out[version] = stringMap(value.dependencies);\n  }\n  return out;\n}\n\nfunction stringMap(value: unknown): Record<string, string> {\n  if (!object.isRecord(value)) return {};\n  const out: Record<string, string> = {};\n  for (const [name, spec] of Object.entries(value)) {\n    if (typeof spec === \"string\") out[name] = spec;\n  }\n  return out;\n}\n"]}