@pnpm/installing.deps-resolver 1008.3.1

package/lib/index.js

@@ -0,0 +1,335 @@
+import path from 'node:path';
+import { packageManifestLogger, } from '@pnpm/core-loggers';
+import { iterateHashedGraphNodes } from '@pnpm/deps.graph-hasher';
+import { isRuntimeDepPath } from '@pnpm/deps.path';
+import { verifyPatches } from '@pnpm/patching.config';
+import { safeReadPackageJsonFromDir } from '@pnpm/pkg-manifest.reader';
+import { getAllDependenciesFromManifest, getSpecFromPackageManifest, } from '@pnpm/pkg-manifest.utils';
+import { DEPENDENCIES_FIELDS, } from '@pnpm/types';
+import { isSubdir } from 'is-subdir';
+import { difference, zipWith } from 'ramda';
+import { depPathToRef } from './depPathToRef.js';
+import { getCatalogSnapshots } from './getCatalogSnapshots.js';
+import { getWantedDependencies } from './getWantedDependencies.js';
+import { createNodeIdForLinkedLocalPkg } from './resolveDependencies.js';
+import { resolveDependencyTree, } from './resolveDependencyTree.js';
+import { resolvePeers, } from './resolvePeers.js';
+import { toResolveImporter } from './toResolveImporter.js';
+import { updateLockfile } from './updateLockfile.js';
+import { updateProjectManifest } from './updateProjectManifest.js';
+export { getWantedDependencies, };
+export async function resolveDependencies(importers, opts) {
+    const _toResolveImporter = toResolveImporter.bind(null, {
+        defaultUpdateDepth: opts.defaultUpdateDepth,
+        lockfileOnly: opts.dryRun,
+        preferredVersions: opts.preferredVersions,
+        virtualStoreDir: opts.virtualStoreDir,
+        globalVirtualStoreDir: opts.globalVirtualStoreDir,
+        workspacePackages: opts.workspacePackages,
+        noDependencySelectors: importers.every(({ wantedDependencies }) => wantedDependencies.length === 0),
+    });
+    const projectsToResolve = await Promise.all(importers.map(async (project) => _toResolveImporter(project)));
+    const { dependenciesTree, outdatedDependencies, resolvedImporters, resolvedPkgsById, wantedToBeSkippedPackageIds, appliedPatches, time, allPeerDepNames, } = await resolveDependencyTree(projectsToResolve, opts);
+    opts.storeController.clearResolutionCache();
+    // We only check whether patches were applied in cases when the whole lockfile was reanalyzed.
+    if (opts.patchedDependencies &&
+        (opts.forceFullResolution || !Object.keys(opts.wantedLockfile.packages ?? {})?.length) &&
+        Object.keys(opts.wantedLockfile.importers).length === importers.length) {
+        verifyPatches({
+            patchedDependencies: opts.patchedDependencies,
+            appliedPatches,
+            allowUnusedPatches: opts.allowUnusedPatches,
+        });
+    }
+    const projectsToLink = await Promise.all(projectsToResolve.map(async (project) => {
+        const resolvedImporter = resolvedImporters[project.id];
+        const topParents = project.manifest
+            ? await getTopParents(difference(Object.keys(getAllDependenciesFromManifest(project.manifest)), resolvedImporter.directDependencies.map(({ alias }) => alias) || []), project.modulesDir)
+            : [];
+        for (const linkedDependency of resolvedImporter.linkedDependencies) {
+            // The location of the external link may vary on different machines, so it is better not to include it in the lockfile.
+            // As a workaround, we symlink to the root of node_modules, which is a symlink to the actual location of the external link.
+            const target = !opts.excludeLinksFromLockfile || isSubdir(opts.lockfileDir, linkedDependency.resolution.directory)
+                ? linkedDependency.resolution.directory
+                : path.join(project.modulesDir, linkedDependency.alias);
+            const linkedDir = createNodeIdForLinkedLocalPkg(opts.lockfileDir, target);
+            topParents.push({
+                name: linkedDependency.alias,
+                version: linkedDependency.version,
+                linkedDir,
+            });
+        }
+        return {
+            binsDir: project.binsDir,
+            directNodeIdsByAlias: resolvedImporter.directNodeIdsByAlias,
+            id: project.id,
+            linkedDependencies: resolvedImporter.linkedDependencies,
+            manifest: project.manifest,
+            modulesDir: project.modulesDir,
+            rootDir: project.rootDir,
+            topParents,
+        };
+    }));
+    const { dependenciesGraph, dependenciesByProjectId, peerDependencyIssuesByProjects, } = await resolvePeers({
+        allPeerDepNames,
+        dependenciesTree,
+        dedupePeerDependents: opts.dedupePeerDependents,
+        dedupeInjectedDeps: opts.dedupeInjectedDeps,
+        lockfileDir: opts.lockfileDir,
+        projects: projectsToLink,
+        virtualStoreDir: opts.virtualStoreDir,
+        virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+        resolvePeersFromWorkspaceRoot: Boolean(opts.resolvePeersFromWorkspaceRoot),
+        resolvedImporters,
+        peersSuffixMaxLength: opts.peersSuffixMaxLength,
+        workspaceProjectIds: new Set([...opts.allProjectIds, ...Object.keys(opts.wantedLockfile.importers)]),
+    });
+    const linkedDependenciesByProjectId = {};
+    await Promise.all(projectsToResolve.map(async (project, index) => {
+        const resolvedImporter = resolvedImporters[project.id];
+        linkedDependenciesByProjectId[project.id] = resolvedImporter.linkedDependencies;
+        let updatedManifest;
+        let updatedOriginalManifest;
+        if (project.updatePackageManifest) {
+            [updatedManifest, updatedOriginalManifest] = await updateProjectManifest(project, {
+                directDependencies: resolvedImporter.directDependencies,
+                preserveWorkspaceProtocol: opts.preserveWorkspaceProtocol,
+                saveWorkspaceProtocol: opts.saveWorkspaceProtocol,
+            });
+        }
+        else {
+            updatedManifest = project.manifest;
+            updatedOriginalManifest = project.originalManifest;
+            packageManifestLogger.debug({
+                prefix: project.rootDir,
+                updated: project.manifest,
+            });
+        }
+        if (updatedManifest != null) {
+            if (opts.autoInstallPeers) {
+                if (updatedManifest.peerDependencies) {
+                    const allDeps = getAllDependenciesFromManifest(updatedManifest);
+                    for (const [peerName, peerRange] of Object.entries(updatedManifest.peerDependencies)) {
+                        if (allDeps[peerName])
+                            continue;
+                        updatedManifest.dependencies ??= {};
+                        updatedManifest.dependencies[peerName] = peerRange;
+                    }
+                }
+            }
+            const projectSnapshot = opts.wantedLockfile.importers[project.id];
+            opts.wantedLockfile.importers[project.id] = addDirectDependenciesToLockfile(updatedManifest, projectSnapshot, resolvedImporter.linkedDependencies, resolvedImporter.directDependencies, opts.excludeLinksFromLockfile);
+        }
+        importers[index].manifest = updatedOriginalManifest ?? project.originalManifest ?? project.manifest;
+        for (const [alias, depPath] of dependenciesByProjectId[project.id].entries()) {
+            const projectSnapshot = opts.wantedLockfile.importers[project.id];
+            if (project.manifest.dependenciesMeta != null) {
+                projectSnapshot.dependenciesMeta = project.manifest.dependenciesMeta;
+            }
+            const depNode = dependenciesGraph[depPath];
+            const ref = depPathToRef(depPath, {
+                alias,
+                realName: depNode.name,
+            });
+            if (projectSnapshot.dependencies?.[alias]) {
+                projectSnapshot.dependencies[alias] = ref;
+            }
+            else if (projectSnapshot.devDependencies?.[alias]) {
+                projectSnapshot.devDependencies[alias] = ref;
+            }
+            else if (projectSnapshot.optionalDependencies?.[alias]) {
+                projectSnapshot.optionalDependencies[alias] = ref;
+            }
+        }
+    }));
+    let updatedCatalogs;
+    for (const project of projectsToResolve) {
+        if (!project.updatePackageManifest)
+            continue;
+        const resolvedImporter = resolvedImporters[project.id];
+        for (let i = 0; i < resolvedImporter.directDependencies.length; i++) {
+            const updateSpec = project.wantedDependencies[i]?.updateSpec ?? false;
+            if (!updateSpec)
+                continue;
+            const dep = resolvedImporter.directDependencies[i];
+            if (dep.catalogLookup == null)
+                continue;
+            // If normalizedBareSpecifier isn't defined, this catalog entry was resolved from cache.
+            // Avoid updating the updatedCatalogs map since it is likely unchanged.
+            if (dep.normalizedBareSpecifier == null)
+                continue;
+            updatedCatalogs ??= {};
+            updatedCatalogs[dep.catalogLookup.catalogName] ??= {};
+            updatedCatalogs[dep.catalogLookup.catalogName][dep.alias] = dep.normalizedBareSpecifier;
+        }
+    }
+    if (opts.dedupeDirectDeps) {
+        const rootDeps = dependenciesByProjectId['.'];
+        if (rootDeps) {
+            for (const [id, deps] of Object.entries(dependenciesByProjectId)) {
+                if (id === '.')
+                    continue;
+                for (const [alias, depPath] of deps.entries()) {
+                    if (depPath === rootDeps.get(alias)) {
+                        deps.delete(alias);
+                    }
+                }
+            }
+        }
+    }
+    const newLockfile = updateLockfile({
+        dependenciesGraph,
+        lockfile: opts.wantedLockfile,
+        prefix: opts.virtualStoreDir,
+        registries: opts.registries,
+        lockfileIncludeTarballUrl: opts.lockfileIncludeTarballUrl,
+    });
+    if (time) {
+        newLockfile.time = {
+            ...opts.wantedLockfile.time,
+            ...time,
+        };
+    }
+    newLockfile.catalogs = getCatalogSnapshots(Object.values(resolvedImporters).flatMap(({ directDependencies }) => directDependencies), updatedCatalogs);
+    // waiting till package requests are finished
+    async function waitTillAllFetchingsFinish() {
+        await Promise.all(Object.values(resolvedPkgsById).map(async ({ fetching }) => {
+            try {
+                await fetching?.();
+            }
+            catch { }
+        }));
+    }
+    return {
+        dependenciesByProjectId,
+        dependenciesGraph: extendGraph(dependenciesGraph, opts),
+        outdatedDependencies,
+        linkedDependenciesByProjectId,
+        updatedCatalogs,
+        newLockfile,
+        peerDependencyIssuesByProjects,
+        waitTillAllFetchingsFinish,
+        wantedToBeSkippedPackageIds,
+    };
+}
+function addDirectDependenciesToLockfile(newManifest, projectSnapshot, linkedPackages, directDependencies, excludeLinksFromLockfile) {
+    const newProjectSnapshot = {
+        dependencies: {},
+        devDependencies: {},
+        optionalDependencies: {},
+        specifiers: {},
+    };
+    if (newManifest.publishConfig?.directory) {
+        newProjectSnapshot.publishDirectory = newManifest.publishConfig.directory;
+    }
+    for (const linkedPkg of linkedPackages) {
+        newProjectSnapshot.specifiers[linkedPkg.alias] = getSpecFromPackageManifest(newManifest, linkedPkg.alias);
+    }
+    const directDependenciesByAlias = {};
+    for (const directDependency of directDependencies) {
+        directDependenciesByAlias[directDependency.alias] = directDependency;
+    }
+    const allDeps = Array.from(new Set(Object.keys(getAllDependenciesFromManifest(newManifest))));
+    for (const alias of allDeps) {
+        const dep = directDependenciesByAlias[alias];
+        const spec = dep && getSpecFromPackageManifest(newManifest, dep.alias);
+        if (dep &&
+            (!excludeLinksFromLockfile ||
+                !dep.isLinkedDependency ||
+                spec.startsWith('workspace:'))) {
+            const ref = depPathToRef(dep.pkgId, {
+                alias: dep.alias,
+                realName: dep.name,
+            });
+            if (dep.dev) {
+                newProjectSnapshot.devDependencies[dep.alias] = ref;
+            }
+            else if (dep.optional) {
+                newProjectSnapshot.optionalDependencies[dep.alias] = ref;
+            }
+            else {
+                newProjectSnapshot.dependencies[dep.alias] = ref;
+            }
+            newProjectSnapshot.specifiers[dep.alias] = spec;
+        }
+        else if (projectSnapshot.specifiers[alias]) {
+            newProjectSnapshot.specifiers[alias] = projectSnapshot.specifiers[alias];
+            if (projectSnapshot.dependencies?.[alias]) {
+                newProjectSnapshot.dependencies[alias] = projectSnapshot.dependencies[alias];
+            }
+            else if (projectSnapshot.optionalDependencies?.[alias]) {
+                newProjectSnapshot.optionalDependencies[alias] = projectSnapshot.optionalDependencies[alias];
+            }
+            else if (projectSnapshot.devDependencies?.[alias]) {
+                newProjectSnapshot.devDependencies[alias] = projectSnapshot.devDependencies[alias];
+            }
+        }
+    }
+    alignDependencyTypes(newManifest, newProjectSnapshot);
+    return newProjectSnapshot;
+}
+function alignDependencyTypes(manifest, projectSnapshot) {
+    const depTypesOfAliases = getAliasToDependencyTypeMap(manifest);
+    // Aligning the dependency types in pnpm-lock.yaml
+    for (const depType of DEPENDENCIES_FIELDS) {
+        if (projectSnapshot[depType] == null)
+            continue;
+        for (const [alias, ref] of Object.entries(projectSnapshot[depType] ?? {})) {
+            if (depType === depTypesOfAliases[alias] || !depTypesOfAliases[alias])
+                continue;
+            projectSnapshot[depTypesOfAliases[alias]][alias] = ref;
+            delete projectSnapshot[depType][alias];
+        }
+    }
+}
+function getAliasToDependencyTypeMap(manifest) {
+    const depTypesOfAliases = {};
+    for (const depType of DEPENDENCIES_FIELDS) {
+        if (manifest[depType] == null)
+            continue;
+        for (const alias of Object.keys(manifest[depType] ?? {})) {
+            if (!depTypesOfAliases[alias]) {
+                depTypesOfAliases[alias] = depType;
+            }
+        }
+    }
+    return depTypesOfAliases;
+}
+async function getTopParents(pkgAliases, modulesDir) {
+    const pkgs = await Promise.all(pkgAliases.map((alias) => path.join(modulesDir, alias)).map(safeReadPackageJsonFromDir));
+    return zipWith((manifest, alias) => {
+        if (!manifest)
+            return null;
+        return {
+            alias,
+            name: manifest.name,
+            version: manifest.version,
+        };
+    }, pkgs, pkgAliases)
+        .filter(Boolean);
+}
+function* iterateGraphPkgMetaEntries(graph, runtimeOnly) {
+    for (const depPath in graph) {
+        if (Object.hasOwn(graph, depPath)) {
+            if (runtimeOnly && !isRuntimeDepPath(depPath))
+                continue;
+            const { name, version, pkgIdWithPatchHash } = graph[depPath];
+            yield { depPath: depPath, name, version, pkgIdWithPatchHash };
+        }
+    }
+}
+function extendGraph(graph, opts) {
+    const pkgMetaIter = iterateGraphPkgMetaEntries(graph, !opts.enableGlobalVirtualStore);
+    // Only use allowBuild for engine-agnostic hash optimization when GVS is on
+    const allowBuild = opts.enableGlobalVirtualStore ? opts.allowBuild : undefined;
+    for (const { pkgMeta: { depPath }, hash } of iterateHashedGraphNodes(graph, pkgMetaIter, allowBuild)) {
+        const modules = path.join(opts.globalVirtualStoreDir, hash, 'node_modules');
+        const node = graph[depPath];
+        Object.assign(node, {
+            modules,
+            dir: path.join(modules, node.name),
+        });
+    }
+    return graph;
+}
+//# sourceMappingURL=index.js.map

package/lib/mergePeers.d.ts

@@ -0,0 +1,7 @@
+import type { MissingPeerIssuesByPeerName } from '@pnpm/types';
+export interface MergePeersResult {
+    conflicts: string[];
+    intersections: Record<string, string>;
+}
+export declare function mergePeers(missingPeers: MissingPeerIssuesByPeerName): MergePeersResult;
+export declare function safeIntersect(ranges: string[]): null | string;

package/lib/mergePeers.js

@@ -0,0 +1,30 @@
+import { intersect } from 'semver-range-intersect';
+export function mergePeers(missingPeers) {
+    const conflicts = [];
+    const intersections = {};
+    for (const [peerName, ranges] of Object.entries(missingPeers)) {
+        if (ranges.every(({ optional }) => optional))
+            continue;
+        if (ranges.length === 1) {
+            intersections[peerName] = ranges[0].wantedRange;
+            continue;
+        }
+        const intersection = safeIntersect(ranges.map(({ wantedRange }) => wantedRange));
+        if (intersection === null) {
+            conflicts.push(peerName);
+        }
+        else {
+            intersections[peerName] = intersection;
+        }
+    }
+    return { conflicts, intersections };
+}
+export function safeIntersect(ranges) {
+    try {
+        return intersect(...ranges);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=mergePeers.js.map

package/lib/nextNodeId.d.ts

@@ -0,0 +1,6 @@
+type Brand<K, T> = K & {
+    __brand: T;
+};
+export type NodeId = Brand<string | number, 'nodeId'>;
+export declare function nextNodeId(): NodeId;
+export {};

package/lib/nextNodeId.js

@@ -0,0 +1,5 @@
+let nodeIdCounter = 0;
+export function nextNodeId() {
+    return ++nodeIdCounter;
+}
+//# sourceMappingURL=nextNodeId.js.map

package/lib/parentIdsContainSequence.d.ts

@@ -0,0 +1,2 @@
+import type { PkgResolutionId } from '@pnpm/types';
+export declare function parentIdsContainSequence(pkgIds: PkgResolutionId[], pkgId1: PkgResolutionId, pkgId2: PkgResolutionId): boolean;

package/lib/parentIdsContainSequence.js

@@ -0,0 +1,9 @@
+export function parentIdsContainSequence(pkgIds, pkgId1, pkgId2) {
+    const pkg1Index = pkgIds.indexOf(pkgId1);
+    if (pkg1Index === -1 || pkg1Index === pkgIds.length - 1) {
+        return false;
+    }
+    const pkg2Index = pkgIds.lastIndexOf(pkgId2);
+    return pkg1Index < pkg2Index && pkg2Index !== pkgIds.length - 1;
+}
+//# sourceMappingURL=parentIdsContainSequence.js.map

package/lib/replaceVersionInBareSpecifier.d.ts

@@ -0,0 +1 @@
+export declare function replaceVersionInBareSpecifier(bareSpecifier: string, version: string): string;

package/lib/replaceVersionInBareSpecifier.js

@@ -0,0 +1,15 @@
+import semver from 'semver';
+export function replaceVersionInBareSpecifier(bareSpecifier, version) {
+    if (semver.validRange(bareSpecifier)) {
+        return version;
+    }
+    if (!bareSpecifier.startsWith('npm:')) {
+        return bareSpecifier;
+    }
+    const versionDelimiter = bareSpecifier.lastIndexOf('@');
+    if (versionDelimiter === -1 || bareSpecifier.indexOf('/') > versionDelimiter) {
+        return `${bareSpecifier}@${version}`;
+    }
+    return `${bareSpecifier.substring(0, versionDelimiter + 1)}${version}`;
+}
+//# sourceMappingURL=replaceVersionInBareSpecifier.js.map

package/lib/resolveDependencies.d.ts

@@ -0,0 +1,248 @@
+import { type CatalogResolver } from '@pnpm/catalogs.resolver';
+import type { LockfileObject, PackageSnapshot, ResolvedDependencies } from '@pnpm/lockfile.types';
+import { type PatchGroupRecord } from '@pnpm/patching.config';
+import type { PatchInfo } from '@pnpm/patching.types';
+import { type DirectoryResolution, type PkgResolutionId, type PreferredVersions, type Resolution, type WorkspacePackages } from '@pnpm/resolving.resolver-base';
+import type { PackageResponse, PkgRequestFetchResult, StoreController } from '@pnpm/store.controller-types';
+import type { AllowBuild, AllowedDeprecatedVersions, PackageManifest, PackageVersionPolicy, PinnedVersion, PkgIdWithPatchHash, ReadPackageHook, Registries, SupportedArchitectures, TrustPolicy } from '@pnpm/types';
+import { type WantedDependency } from './getNonDevWantedDependencies.js';
+import { type NodeId } from './nextNodeId.js';
+import type { CatalogLookupMetadata } from './resolveDependencyTree.js';
+export type { WantedDependency };
+export declare function getPkgsInfoFromIds(ids: PkgResolutionId[], resolvedPkgsById: ResolvedPkgsById): Array<{
+    id: PkgResolutionId;
+    name: string;
+    version: string;
+}>;
+export interface ChildrenMap {
+    [alias: string]: NodeId;
+}
+export type DependenciesTreeNode<T> = {
+    children: (() => ChildrenMap) | ChildrenMap;
+    installable: boolean;
+} & ({
+    resolvedPackage: T & {
+        name: string;
+        version: string;
+    };
+    depth: number;
+} | {
+    resolvedPackage: {
+        name: string;
+        version: string;
+    };
+    depth: -1;
+});
+export type DependenciesTree<T> = Map<NodeId, DependenciesTreeNode<T>>;
+export type ResolvedPkgsById = Record<PkgResolutionId, ResolvedPackage>;
+export interface PkgAddressOrLinkBase {
+    alias: string;
+    catalogLookup?: CatalogLookupMetadata;
+    normalizedBareSpecifier?: string;
+    optional: boolean;
+    pkg: PackageManifest;
+    pkgId: PkgResolutionId;
+}
+export interface LinkedDependency extends PkgAddressOrLinkBase {
+    isLinkedDependency: true;
+    dev: boolean;
+    resolution: DirectoryResolution;
+    version: string;
+    name: string;
+}
+export interface PendingNode {
+    alias: string;
+    nodeId: NodeId;
+    resolvedPackage: ResolvedPackage;
+    depth: number;
+    installable: boolean;
+    parentIds: PkgResolutionId[];
+}
+export interface ChildrenByParentId {
+    [id: PkgResolutionId]: Array<{
+        alias: string;
+        id: PkgResolutionId;
+    }>;
+}
+export interface ResolutionContext {
+    allowBuild?: AllowBuild;
+    allPeerDepNames: Set<string>;
+    autoInstallPeers: boolean;
+    autoInstallPeersFromHighestMatch: boolean;
+    allowedDeprecatedVersions: AllowedDeprecatedVersions;
+    allPreferredVersions?: PreferredVersions;
+    appliedPatches: Set<string>;
+    updatedSet: Set<string>;
+    catalogResolver: CatalogResolver;
+    defaultTag: string;
+    dryRun: boolean;
+    forceFullResolution: boolean;
+    ignoreScripts?: boolean;
+    resolvedPkgsById: ResolvedPkgsById;
+    resolvePeersFromWorkspaceRoot?: boolean;
+    outdatedDependencies: Record<PkgResolutionId, string>;
+    childrenByParentId: ChildrenByParentId;
+    patchedDependencies?: PatchGroupRecord;
+    pendingNodes: PendingNode[];
+    wantedLockfile: LockfileObject;
+    currentLockfile: LockfileObject;
+    injectWorkspacePackages?: boolean;
+    linkWorkspacePackagesDepth: number;
+    lockfileDir: string;
+    storeController: StoreController;
+    skipped: Set<PkgResolutionId>;
+    dependenciesTree: DependenciesTree<ResolvedPackage>;
+    force: boolean;
+    preferWorkspacePackages?: boolean;
+    readPackageHook?: ReadPackageHook;
+    engineStrict: boolean;
+    nodeVersion?: string;
+    pnpmVersion: string;
+    registries: Registries;
+    resolutionMode?: 'highest' | 'time-based' | 'lowest-direct';
+    virtualStoreDir: string;
+    virtualStoreDirMaxLength: number;
+    workspacePackages?: WorkspacePackages;
+    missingPeersOfChildrenByPkgId: Record<PkgResolutionId, {
+        depth: number;
+        missingPeersOfChildren: MissingPeersOfChildren;
+    }>;
+    hoistPeers?: boolean;
+    maximumPublishedBy?: Date;
+    publishedByExclude?: PackageVersionPolicy;
+    trustPolicy?: TrustPolicy;
+    trustPolicyExclude?: PackageVersionPolicy;
+    trustPolicyIgnoreAfter?: number;
+    blockExoticSubdeps?: boolean;
+}
+export interface MissingPeerInfo {
+    range: string;
+    optional: boolean;
+}
+export type MissingPeers = Record<string, MissingPeerInfo>;
+export type ResolvedPeers = Record<string, PkgAddress>;
+interface MissingPeersOfChildren {
+    resolve: (missingPeers: MissingPeers) => void;
+    reject: (err: Error) => void;
+    get: () => Promise<MissingPeers>;
+    resolved?: boolean;
+}
+export interface PkgAddress extends PkgAddressOrLinkBase {
+    depIsLinked: boolean;
+    isNew: boolean;
+    isLinkedDependency?: false;
+    resolvedVia?: string;
+    nodeId: NodeId;
+    installable: boolean;
+    version?: string;
+    updated: boolean;
+    rootDir: string;
+    missingPeers: MissingPeers;
+    missingPeersOfChildren?: MissingPeersOfChildren;
+    publishedAt?: string;
+    saveCatalogName?: string;
+}
+export type PkgAddressOrLink = PkgAddress | LinkedDependency;
+export interface PeerDependency {
+    version: string;
+    optional?: boolean;
+}
+export type PeerDependencies = Record<string, PeerDependency>;
+export interface ResolvedPackage {
+    id: PkgResolutionId;
+    isLeaf: boolean;
+    resolution: Resolution;
+    prod: boolean;
+    dev: boolean;
+    optional: boolean;
+    fetching: () => Promise<PkgRequestFetchResult>;
+    filesIndexFile: string;
+    name: string;
+    version: string;
+    peerDependencies: PeerDependencies;
+    optionalDependencies: Set<string>;
+    hasBin: boolean;
+    hasBundledDependencies: boolean;
+    patch?: PatchInfo;
+    prepare: boolean;
+    pkgIdWithPatchHash: PkgIdWithPatchHash;
+    requiresBuild?: boolean;
+    additionalInfo: {
+        deprecated?: string;
+        bundleDependencies?: string[] | boolean;
+        bundledDependencies?: string[] | boolean;
+        engines?: {
+            node?: string;
+            npm?: string;
+        };
+        cpu?: string[];
+        os?: string[];
+        libc?: string[];
+    };
+}
+type ParentPkg = Pick<PkgAddress, 'nodeId' | 'installable' | 'rootDir' | 'optional' | 'pkgId' | 'resolvedVia'>;
+export type ParentPkgAliases = Record<string, PkgAddress | true>;
+export type UpdateMatchingFunction = (pkgName: string, version?: string) => boolean;
+interface ResolvedDependenciesOptions {
+    currentDepth: number;
+    parentIds: PkgResolutionId[];
+    parentPkg: ParentPkg;
+    parentPkgAliases: ParentPkgAliases;
+    preferredDependencies?: ResolvedDependencies;
+    proceed: boolean;
+    publishedBy?: Date;
+    pickLowestVersion?: boolean;
+    resolvedDependencies?: ResolvedDependencies;
+    updateMatching?: UpdateMatchingFunction;
+    updateDepth: number;
+    prefix: string;
+    supportedArchitectures?: SupportedArchitectures;
+    updateToLatest?: boolean;
+    pinnedVersion?: PinnedVersion;
+}
+interface PeersResolutionResult {
+    missingPeers: MissingPeers;
+    resolvedPeers: ResolvedPeers;
+}
+interface ResolvedRootDependenciesResult {
+    pkgAddressesByImporters: PkgAddressOrLink[][];
+    time?: Record<string, string>;
+}
+export declare function resolveRootDependencies(ctx: ResolutionContext, importers: ImporterToResolve[]): Promise<ResolvedRootDependenciesResult>;
+interface ResolvedDependenciesResult {
+    pkgAddresses: PkgAddressOrLink[];
+    resolvingPeers: Promise<PeersResolutionResult>;
+}
+export type ImporterToResolveOptions = Omit<ResolvedDependenciesOptions, 'parentPkgAliases' | 'publishedBy'>;
+export interface ImporterToResolve {
+    updatePackageManifest: boolean;
+    preferredVersions: PreferredVersions;
+    parentPkgAliases: ParentPkgAliases;
+    wantedDependencies: Array<WantedDependency & {
+        updateDepth?: number;
+    }>;
+    options: ImporterToResolveOptions;
+    pinnedVersion?: PinnedVersion;
+}
+export interface ResolveDependenciesOfImporterDependencyOpts {
+    readonly ctx: ResolutionContext;
+    readonly importer: ImporterToResolve;
+    readonly pickLowestVersion: boolean;
+}
+export declare function resolveDependencies(ctx: ResolutionContext, preferredVersions: PreferredVersions, wantedDependencies: Array<WantedDependency & {
+    updateDepth?: number;
+}>, options: ResolvedDependenciesOptions): Promise<ResolvedDependenciesResult>;
+export declare function createNodeIdForLinkedLocalPkg(lockfileDir: string, pkgDir: string): NodeId;
+type InfoFromLockfile = {
+    pkgId: PkgResolutionId;
+    dependencyLockfile?: PackageSnapshot;
+    name?: string;
+    version?: string;
+    resolution?: Resolution;
+} & ({
+    dependencyLockfile: PackageSnapshot;
+    name: string;
+    version: string;
+    resolution: Resolution;
+} | unknown);
+export declare function getManifestFromResponse(pkgResponse: PackageResponse, wantedDependency: WantedDependency, currentPkg?: Partial<InfoFromLockfile>): PackageManifest;