@pnpm/deps.inspection.tree-builder 1101.0.8 → 1101.0.10

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @pnpm/reviewing.dependencies-hierarchy
 
+## 1101.0.10
+
+### Patch Changes
+
+- `pnpm list` now reports the correct package paths when `nodeLinker` is `hoisted` [#9593](https://github.com/pnpm/pnpm/issues/9593).
+
+- Updated dependencies:
+  - @pnpm/config.normalize-registries@1101.0.3
+  - @pnpm/deps.path@1101.0.6
+  - @pnpm/fs.read-modules-dir@1100.0.4
+  - @pnpm/installing.modules-yaml@1101.0.6
+  - @pnpm/lockfile.detect-dep-types@1100.0.27
+  - @pnpm/lockfile.fs@1100.2.13
+  - @pnpm/lockfile.peer-edges@1100.0.2
+  - @pnpm/lockfile.utils@1102.1.6
+  - @pnpm/pkg-manifest.reader@1100.0.22
+  - @pnpm/store.cafs@1100.3.7
+  - @pnpm/store.index@1101.0.1
+
+## 1101.0.9
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/config.matcher@1100.0.3
+  - @pnpm/lockfile.fs@1100.2.12
+  - @pnpm/store.cafs@1100.3.6
+
 ## 1101.0.8
 
 ### Patch Changes

package/lib/buildDependenciesTree.d.ts

@@ -32,6 +32,7 @@ export interface BuildDependenciesTreeOptions {
     modulesDir?: string;
     resolvePeersFromWorkspaceRoot?: boolean;
     virtualStoreDirMaxLength: number;
+    nodeLinker?: 'hoisted' | 'isolated' | 'pnp';
 }
 export declare function buildDependenciesTree(projectPaths: string[] | undefined, maybeOpts: BuildDependenciesTreeOptions): Promise<{
     [projectDir: string]: DependenciesTree;

package/lib/buildDependenciesTree.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { normalizeRegistriesByScope } from '@pnpm/config.normalize-registries';
+import { withCollapsedVariants } from '@pnpm/deps.path';
 import { readModulesDir } from '@pnpm/fs.read-modules-dir';
 import { readModulesManifest } from '@pnpm/installing.modules-yaml';
 import { detectDepTypes } from '@pnpm/lockfile.detect-dep-types';
@@ -69,8 +70,8 @@ async function buildProjectsTrees(projectPaths, maybeOpts, linkedWalk) {
     return Object.fromEntries(pairs);
 }
 async function readLockfiles(modulesDir, lockfileDir) {
-    const internalPnpmDir = path.join(modulesDir, '.pnpm');
-    const currentLockfile = await readCurrentLockfile(internalPnpmDir, { ignoreIncompatible: false });
+    const installStateDir = path.join(modulesDir, '.pnpm');
+    const currentLockfile = await readCurrentLockfile(installStateDir, { ignoreIncompatible: false });
     const wantedLockfile = await readWantedLockfile(lockfileDir, { ignoreIncompatible: false });
     return { currentLockfile, wantedLockfile };
 }
@@ -134,6 +135,8 @@ function createTreeOptions({ treeOpts, modules, modulesDir, registriesByScope, s
         modulesDir,
         virtualStoreDir: modules?.virtualStoreDir,
         virtualStoreDirMaxLength: modules?.virtualStoreDirMaxLength ?? treeOpts.virtualStoreDirMaxLength,
+        nodeLinker: modules?.nodeLinker ?? treeOpts.nodeLinker,
+        hoistedLocations: modules?.hoistedLocations && withCollapsedVariants(modules.hoistedLocations),
     };
 }
 async function expandLinkedProjectsOfEach(pairs, opts) {
@@ -238,8 +241,6 @@ async function dependenciesHierarchyForPackage(opts, projectPath) {
         ? opts.modulesDir
         : path.join(projectPath, opts.modulesDir ?? 'node_modules');
     const { result, fieldMap } = initDependencyFields(projectSnapshot, opts.include);
-    // Materialize the tree rooted at this importer in a single getTree call.
-    // materializeChildren handles all dedup, search, and circular detection.
     // The depth is incremented by 1 because the importer itself is one level;
     // opts.depth controls how deep *below* the direct dependencies we go.
     const nodes = getTree({
@@ -251,7 +252,6 @@ async function dependenciesHierarchyForPackage(opts, projectPath) {
         wantedPackages: wantedLockfile?.packages ?? {},
         modulesDir,
     }, { type: 'importer', importerId });
-    // Categorize the materialized nodes into their dependency fields.
     for (const node of nodes) {
         const field = fieldMap.get(node.alias);
         if (field != null) {
@@ -268,7 +268,6 @@ async function dependenciesHierarchyForPackage(opts, projectPath) {
     return result;
 }
 function initDependencyFields(projectSnapshot, include) {
-    // Build a map from alias → dependency field for post-categorization.
     const result = {};
     const fieldMap = new Map();
     for (const field of DEPENDENCIES_FIELDS.sort().filter(f => include[f])) {

package/lib/buildDependentsTree.d.ts

@@ -46,6 +46,7 @@ interface BuildDependentsTreeOptions {
     lockfile: LockfileObject;
     nameFormatter?: NameFormatter;
     resolvePeersFromWorkspaceRoot?: boolean;
+    nodeLinker?: 'hoisted' | 'isolated' | 'pnp';
 }
 export declare function buildDependentsTree(packages: string[], projectPaths: string[], opts: BuildDependentsTreeOptions): Promise<DependentsTree[]>;
 export {};

package/lib/buildDependentsTree.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { normalizeRegistriesByScope } from '@pnpm/config.normalize-registries';
+import { withCollapsedVariants } from '@pnpm/deps.path';
 import { readModulesManifest } from '@pnpm/installing.modules-yaml';
 import { getLockfileImporterId, } from '@pnpm/lockfile.fs';
 import { getPeerSatisfactionEdgesToSkip } from '@pnpm/lockfile.peer-edges';
@@ -34,6 +35,9 @@ export async function buildDependentsTree(packages, projectPaths, opts) {
         wantedPackages: currentPackages,
         storeDir,
         storeIndex,
+        nodeLinker: modules?.nodeLinker ?? opts.nodeLinker,
+        hoistedLocations: modules?.hoistedLocations && withCollapsedVariants(modules.hoistedLocations),
+        lockfileDir: opts.lockfileDir,
     });
     const trees = collectMatchedTrees(search, {
         reverseMap,
@@ -56,7 +60,6 @@ function buildSelectedProjectsGraph(projectPaths, opts) {
         devDependencies: true,
         optionalDependencies: true,
     };
-    // Build root IDs from the selected project paths (respects --filter / --recursive)
     const allRootIds = [];
     for (const projectPath of projectPaths) {
         const importerId = getLockfileImporterId(opts.lockfileDir, projectPath);
@@ -125,7 +128,6 @@ function buildTreeIfMatched(search, { serialized, depPath }, ctx) {
 }
 function searchPackage(search, pkg, ctx) {
     const { name, version, readManifest } = pkg;
-    // Check canonical name first
     const matched = search({ alias: name, name, version, readManifest });
     if (matched)
         return matched;
@@ -179,7 +181,7 @@ function invertGraph(graph) {
  */
 function resolvePackageNodes(graph, currentPackages, opts) {
     const resolved = new Map();
-    function walk(serialized, parentDir) {
+    function walk(serialized, parentDir, importerDir) {
         const node = graph.nodes.get(serialized);
         if (!node)
             return;
@@ -196,18 +198,18 @@ function resolvePackageNodes(graph, currentPackages, opts) {
                 alias: edge.alias,
                 currentPackages,
                 depTypes: {},
-                linkedPathBaseDir: opts.modulesDir, // This might need adjustment for linked deps?
+                linkedPathBaseDir: importerDir,
                 parentDir,
                 ref: edge.target.nodeId.depPath,
                 skipped: new Set(),
             });
             resolved.set(childSerialized, { path: pkgInfo.path, readManifest });
-            walk(childSerialized, pkgInfo.path);
+            walk(childSerialized, pkgInfo.path, importerDir);
         }
     }
     for (const [serialized, node] of graph.nodes) {
         if (node.nodeId.type === 'importer') {
-            walk(serialized, undefined);
+            walk(serialized, undefined, path.join(opts.lockfileDir, node.nodeId.importerId));
         }
     }
     return resolved;

package/lib/getPkgInfo.d.ts

@@ -41,6 +41,9 @@ export interface GetPkgInfoOpts {
      * This is needed for subdependencies when using global virtual store.
      */
     readonly parentDir?: string;
+    readonly nodeLinker?: 'hoisted' | 'isolated' | 'pnp';
+    readonly hoistedLocations?: Record<string, string[]>;
+    readonly lockfileDir?: string;
 }
 export declare function getPkgInfo(opts: GetPkgInfoOpts): {
     pkgInfo: PackageInfo;

package/lib/getPkgInfo.js

@@ -21,6 +21,11 @@ export function getPkgInfo(opts) {
             virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
             modulesDir: opts.modulesDir,
             parentDir: opts.parentDir,
+            nodeLinker: opts.nodeLinker,
+            hoistedLocations: opts.hoistedLocations,
+            lockfileDir: opts.lockfileDir,
+            projectDir: opts.linkedPathBaseDir,
+            version: lockedInfo.version,
         })
         : resolveLinkedPath(opts);
     const version = rewriteLinkVersion(lockedInfo.version || opts.ref, fullPackagePath, opts.rewriteLinkVersionDir);

package/lib/getTree.d.ts

@@ -27,6 +27,8 @@ export interface BaseTreeOpts {
     showDedupedSearchMatches?: boolean;
     graph: DependencyGraph;
     materializationCache: MaterializationCache;
+    nodeLinker?: 'hoisted' | 'isolated' | 'pnp';
+    hoistedLocations?: Record<string, string[]>;
 }
 interface GetTreeOpts extends BaseTreeOpts {
     maxDepth: number;

package/lib/getTree.js

@@ -12,11 +12,6 @@ export function getTree(opts, parentId) {
         ancestors,
     };
     const result = materializeChildren(ctx, parentId, opts.maxDepth, opts.parentDir);
-    // Mark circular back-edges.  materializeChildren truncates dependencies
-    // at cycle boundaries but does not set the `circular` flag, so that cached
-    // subtrees stay context-independent.  fixCircularRefs walks the final tree
-    // and adds `circular: true` wherever a node's path matches an ancestor.
-    //
     // Seed the ancestors with parentDir (the filesystem path of parentId) so
     // that back-edges to the root of this subtree are detected — the root
     // itself does not appear as a node in the tree, only its children do.
@@ -154,7 +149,6 @@ function materializeTarget(ctx, { target, maxDepth, dir }) {
     ctx.ancestors.add(target.id);
     const childResult = materializeChildren(ctx, target.nodeId, maxDepth, dir);
     ctx.ancestors.delete(target.id);
-    // Always cache — even results with circular truncations.
     ctx.materializationCache.set(cacheKey, {
         count: childResult.count,
         hasSearchMatch: childResult.hasSearchMatch,
@@ -228,7 +222,6 @@ function markSearchMatch(newEntry, { searchMatch, subtree, result }) {
 function fixCircularRefs(nodes, ancestors) {
     let changed = false;
     const result = nodes.map(node => {
-        // A node whose path matches an ancestor is a circular back-edge.
         if (node.path && ancestors.has(node.path)) {
             changed = true;
             const { dependencies: _, deduped: _d, dedupedDependenciesCount: _c, ...rest } = node;

package/lib/resolvePackagePath.d.ts

@@ -4,8 +4,10 @@
  * For local virtual stores, the path is constructed directly.
  * For global virtual stores (where virtualStoreDir is outside modulesDir),
  * symlinks are resolved to find the actual store location.
+ * For hoisted linker (where virtual store is empty), packages live where the
+ * hoisted linker placed them, recorded in hoistedLocations.
  */
-export declare function resolvePackagePath(opts: {
+export interface ResolvePackagePathOptions {
     depPath: string;
     name: string;
     alias: string;
@@ -13,4 +15,10 @@ export declare function resolvePackagePath(opts: {
     virtualStoreDirMaxLength: number;
     modulesDir?: string;
     parentDir?: string;
-}): string;
+    nodeLinker?: 'hoisted' | 'isolated' | 'pnp';
+    hoistedLocations?: Record<string, string[]>;
+    lockfileDir?: string;
+    projectDir?: string;
+    version?: string;
+}
+export declare function resolvePackagePath(opts: ResolvePackagePathOptions): string;

package/lib/resolvePackagePath.js

@@ -1,14 +1,105 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { depPathToFilename } from '@pnpm/deps.path';
+import { depPathToFilename, findHoistedPackageDirs } from '@pnpm/deps.path';
+import { readPackageJsonFromDirSync } from '@pnpm/pkg-manifest.reader';
+export function resolvePackagePath(opts) {
+    if (isUnsafePathComponent(opts.name)) {
+        return opts.virtualStoreDir;
+    }
+    if (opts.nodeLinker === 'hoisted') {
+        const hoistedPath = resolveHoistedPackagePath(opts);
+        if (hoistedPath != null)
+            return hoistedPath;
+    }
+    return resolveVirtualStorePackagePath(opts);
+}
+function resolveHoistedPackagePath(opts) {
+    const lockfileDir = opts.lockfileDir ?? opts.projectDir;
+    if (!lockfileDir)
+        return undefined;
+    const hoistedPaths = findHoistedPackageDirs(opts.hoistedLocations, opts.depPath, lockfileDir);
+    if (hoistedPaths.length)
+        return pickHoistedDir(hoistedPaths, { ...opts, lockfileDir });
+    return findHoistedByAlias(opts, lockfileDir);
+}
 /**
- * Resolves the filesystem path for a package identified by its depPath.
- *
- * For local virtual stores, the path is constructed directly.
- * For global virtual stores (where virtualStoreDir is outside modulesDir),
- * symlinks are resolved to find the actual store location.
+ * Picks the copy that Node.js resolves from the parent package, or from the
+ * project for a direct dependency: the one in the closest modules directory
+ * above it. Copies on disk under the edge's alias are preferred, since one
+ * depPath gets a directory per alias it is installed under. Falls back to any
+ * copy on disk, then to the recorded one under the alias, then to the first
+ * recorded one.
  */
-export function resolvePackagePath(opts) {
+function pickHoistedDir(recordedDirs, opts) {
+    const existing = recordedDirs.filter((dir) => fs.existsSync(dir));
+    const existingUnderAlias = existing.filter((dir) => isInstalledUnder(dir, opts.alias));
+    const candidates = existingUnderAlias.length ? existingUnderAlias : existing;
+    const resolveFrom = opts.parentDir ?? opts.projectDir;
+    if (resolveFrom) {
+        const relativeModulesDir = getRelativeModulesDir(opts.lockfileDir, opts.modulesDir);
+        const closest = candidates
+            .map((dir) => ({ dir, ownerDir: getOwnerDir(dir, relativeModulesDir) }))
+            .filter(({ ownerDir }) => isSameOrSubdir(ownerDir, resolveFrom))
+            .sort((a, b) => b.ownerDir.length - a.ownerDir.length)[0];
+        if (closest)
+            return closest.dir;
+    }
+    return candidates[0] ??
+        recordedDirs.find((dir) => isInstalledUnder(dir, opts.alias)) ??
+        recordedDirs[0];
+}
+/**
+ * Whether `pkgDir` is `<modules dir>/<alias>`: its trailing segments spell the
+ * whole alias, not just the name of a scoped package.
+ */
+function isInstalledUnder(pkgDir, alias) {
+    const aliasSuffix = path.join(path.sep, alias);
+    return pkgDir.endsWith(aliasSuffix) &&
+        !path.basename(pkgDir.slice(0, -aliasSuffix.length)).startsWith('@');
+}
+/**
+ * The directory whose modules directory holds `pkgDir`.
+ */
+function getOwnerDir(pkgDir, relativeModulesDir) {
+    let modulesDir = path.dirname(pkgDir);
+    if (path.basename(modulesDir).startsWith('@'))
+        modulesDir = path.dirname(modulesDir);
+    const rootModulesDirSuffix = path.sep + relativeModulesDir;
+    return modulesDir.endsWith(rootModulesDirSuffix)
+        ? modulesDir.slice(0, -rootModulesDirSuffix.length)
+        : path.dirname(modulesDir);
+}
+function isSameOrSubdir(parent, dir) {
+    return dir === parent || dir.startsWith(parent.endsWith(path.sep) ? parent : parent + path.sep);
+}
+/**
+ * Probes `<alias>` in the modules directory of the project and of the root,
+ * because the hoisted linker places a dependency under its alias.
+ */
+function findHoistedByAlias(opts, lockfileDir) {
+    if (isUnsafePathComponent(opts.alias))
+        return undefined;
+    const relativeModulesDir = getRelativeModulesDir(lockfileDir, opts.modulesDir);
+    const rootModulesDir = opts.modulesDir ?? path.join(lockfileDir, 'node_modules');
+    const candidates = opts.projectDir ? [path.resolve(opts.projectDir, relativeModulesDir, opts.alias)] : [];
+    candidates.push(path.join(rootModulesDir, opts.alias));
+    return candidates.find((candidate) => candidateMatchesVersion(candidate, opts.version));
+}
+/**
+ * The modules directory relative to the lockfile directory, such as
+ * `node_modules` or `www/modules`. Falls back to its last segment when it
+ * lies outside the lockfile directory.
+ */
+function getRelativeModulesDir(lockfileDir, modulesDir) {
+    if (!modulesDir)
+        return 'node_modules';
+    const relative = path.relative(lockfileDir, modulesDir);
+    if (!relative || relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        return path.basename(modulesDir);
+    }
+    return relative;
+}
+function resolveVirtualStorePackagePath(opts) {
     const fullPackagePath = path.join(opts.virtualStoreDir, depPathToFilename(opts.depPath, opts.virtualStoreDirMaxLength), 'node_modules', opts.name);
     // Resolve symlink for global virtual store.
     if (!isGlobalVirtualStore(opts.virtualStoreDir, opts.modulesDir))
@@ -46,4 +137,21 @@ function getSymlinkNodeModulesDir(opts) {
         ? path.dirname(nodeModulesDir)
         : nodeModulesDir;
 }
+function candidateMatchesVersion(candidate, expectedVersion) {
+    if (!expectedVersion)
+        return fs.existsSync(candidate);
+    try {
+        const manifest = readPackageJsonFromDirSync(candidate);
+        return manifest.version === expectedVersion;
+    }
+    catch {
+        return false;
+    }
+}
+function isUnsafePathComponent(component) {
+    return (path.isAbsolute(component) ||
+        component.startsWith('\\') ||
+        component.includes(':') ||
+        component.split(/[/\\]/).some((part) => part === '..' || part === '.'));
+}
 //# sourceMappingURL=resolvePackagePath.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/deps.inspection.tree-builder",
-  "version": "1101.0.8",
+  "version": "1101.0.10",
   "description": "Creates a dependencies hierarchy for a symlinked `node_modules`",
   "keywords": [
     "pnpm",
@@ -30,19 +30,19 @@
     "!*.map"
   ],
   "dependencies": {
-    "@pnpm/config.matcher": "1100.0.2",
-    "@pnpm/config.normalize-registries": "1101.0.2",
-    "@pnpm/deps.path": "1101.0.5",
-    "@pnpm/fs.read-modules-dir": "1100.0.3",
-    "@pnpm/installing.modules-yaml": "1101.0.5",
-    "@pnpm/lockfile.detect-dep-types": "1100.0.26",
-    "@pnpm/lockfile.fs": "1100.2.11",
-    "@pnpm/lockfile.peer-edges": "1100.0.1",
-    "@pnpm/lockfile.utils": "1102.1.5",
+    "@pnpm/config.matcher": "1100.0.3",
+    "@pnpm/config.normalize-registries": "1101.0.3",
+    "@pnpm/deps.path": "1101.0.6",
+    "@pnpm/fs.read-modules-dir": "1100.0.4",
+    "@pnpm/installing.modules-yaml": "1101.0.6",
+    "@pnpm/lockfile.detect-dep-types": "1100.0.27",
+    "@pnpm/lockfile.fs": "1100.2.13",
+    "@pnpm/lockfile.peer-edges": "1100.0.2",
+    "@pnpm/lockfile.utils": "1102.1.6",
     "@pnpm/npm-package-arg": "^2.0.0",
-    "@pnpm/pkg-manifest.reader": "1100.0.21",
-    "@pnpm/store.cafs": "1100.3.5",
-    "@pnpm/store.index": "1101.0.0",
+    "@pnpm/pkg-manifest.reader": "1100.0.22",
+    "@pnpm/store.cafs": "1100.3.7",
+    "@pnpm/store.index": "1101.0.1",
     "@pnpm/text.ordinal-comparator": "1100.0.0",
     "@pnpm/types": "1102.1.1",
     "load-json-file": "^7.0.1",
@@ -55,8 +55,8 @@
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",
-    "@pnpm/constants": "1102.0.0",
-    "@pnpm/deps.inspection.tree-builder": "1101.0.8",
+    "@pnpm/constants": "1102.0.1",
+    "@pnpm/deps.inspection.tree-builder": "1101.0.10",
     "@pnpm/test-fixtures": "1100.0.1",
     "@types/normalize-path": "^3.0.2",
     "@types/semver": "7.8.0"