@pnpm/deps.inspection.tree-builder 1101.0.4 → 1101.0.6

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @pnpm/reviewing.dependencies-hierarchy
 
+## 1101.0.6
+
+### Patch Changes
+
+- `pnpm list --only-projects` now lists the workspace projects when `sharedWorkspaceLockfile` is `false` [#7151](https://github.com/pnpm/pnpm/issues/7151).
+
+- `pnpm list --only-projects` now lists a workspace project that sets `publishConfig.directory`. Dependents link such a project through its publish directory, which `--only-projects` did not recognize as a project [#10635](https://github.com/pnpm/pnpm/issues/10635).
+
+- `pnpm list --only-projects` now prints every project selected with `--filter` or `--recursive`, including a project that has no workspace dependencies [#9770](https://github.com/pnpm/pnpm/issues/9770).
+
+  `pnpm list --only-projects` no longer reports packages in `node_modules` that are missing from the lockfile [#9528](https://github.com/pnpm/pnpm/issues/9528).
+
+- `pnpm install --prod`, `pnpm fetch --prod` and `pnpm deploy --prod` no longer install a devDependency that is only there to satisfy an optional peer dependency of a production dependency. `pnpm list`, `pnpm why`, `pnpm licenses`, `pnpm sbom` and `pnpm audit` leave it out of `--prod` results too. The same applies to `--dev`. A peer that is not optional is still installed and audited [#15344](https://github.com/pnpm/pnpm/issues/15344).
+
+- Updated dependencies:
+  - @pnpm/config.normalize-registries@1101.0.2
+  - @pnpm/deps.path@1101.0.4
+  - @pnpm/installing.modules-yaml@1101.0.4
+  - @pnpm/lockfile.detect-dep-types@1100.0.25
+  - @pnpm/lockfile.fs@1100.2.9
+  - @pnpm/lockfile.utils@1102.1.4
+  - @pnpm/pkg-manifest.reader@1100.0.20
+  - @pnpm/store.cafs@1100.3.4
+  - @pnpm/store.index@1100.3.2
+  - @pnpm/types@1102.1.1
+
+## 1101.0.5
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/deps.path@1101.0.3
+  - @pnpm/installing.modules-yaml@1101.0.3
+  - @pnpm/lockfile.detect-dep-types@1100.0.24
+  - @pnpm/lockfile.fs@1100.2.8
+  - @pnpm/lockfile.utils@1102.1.3
+  - @pnpm/store.cafs@1100.3.3
+
 ## 1101.0.4
 
 ### Patch Changes

package/lib/buildDependenciesTree.d.ts

@@ -6,7 +6,7 @@ export interface DependenciesTree {
     optionalDependencies?: DependencyNode[];
     unsavedDependencies?: DependencyNode[];
 }
-export declare function buildDependenciesTree(projectPaths: string[] | undefined, maybeOpts: {
+export interface BuildDependenciesTreeOptions {
     depth: number;
     excludePeerDependencies?: boolean;
     include?: {
@@ -15,12 +15,24 @@ export declare function buildDependenciesTree(projectPaths: string[] | undefined
     registriesByScope?: RegistriesByScope;
     registriesByPrefix?: Record<string, string>;
     onlyProjects?: boolean;
+    /**
+     * The workspace projects that `onlyProjects` follows through their own
+     * lockfiles when the lockfile being read has no importer for them.
+     */
+    workspaceProjectDirs?: string[];
+    /**
+     * The workspace projects that dependents link through their publish
+     * directory (`publishConfig.directory`), keyed by that directory.
+     */
+    workspaceProjectPublishDirs?: Record<string, string>;
     search?: Finder;
     showDedupedSearchMatches?: boolean;
     lockfileDir: string;
     checkWantedLockfileOnly?: boolean;
     modulesDir?: string;
+    resolvePeersFromWorkspaceRoot?: boolean;
     virtualStoreDirMaxLength: number;
-}): Promise<{
+}
+export declare function buildDependenciesTree(projectPaths: string[] | undefined, maybeOpts: BuildDependenciesTreeOptions): Promise<{
     [projectDir: string]: DependenciesTree;
 }>;

package/lib/buildDependenciesTree.js

@@ -4,6 +4,7 @@ import { readModulesDir } from '@pnpm/fs.read-modules-dir';
 import { readModulesManifest } from '@pnpm/installing.modules-yaml';
 import { detectDepTypes } from '@pnpm/lockfile.detect-dep-types';
 import { getLockfileImporterId, readCurrentLockfile, readWantedLockfile, } from '@pnpm/lockfile.fs';
+import { getPeerSatisfactionEdgesToSkip } from '@pnpm/lockfile.peer-edges';
 import { safeReadPackageJsonFromDir } from '@pnpm/pkg-manifest.reader';
 import { StoreIndex } from '@pnpm/store.index';
 import { DEPENDENCIES_FIELDS } from '@pnpm/types';
@@ -16,6 +17,16 @@ import { buildDependencyGraph } from './buildDependencyGraph.js';
 import { getTree } from './getTree.js';
 const limitUnsavedReads = pLimit(4);
 export async function buildDependenciesTree(projectPaths, maybeOpts) {
+    return buildProjectsTrees(projectPaths, maybeOpts, {
+        ancestors: new Set(),
+        expanded: new Map(),
+        linkedProjectDirs: new Map([
+            ...Object.entries(maybeOpts.workspaceProjectPublishDirs ?? {}),
+            ...(maybeOpts.workspaceProjectDirs ?? []).map((dir) => [dir, dir]),
+        ]),
+    });
+}
+async function buildProjectsTrees(projectPaths, maybeOpts, linkedWalk) {
     if (!maybeOpts?.lockfileDir) {
         throw new TypeError('opts.lockfileDir is required');
     }
@@ -76,9 +87,13 @@ export async function buildDependenciesTree(projectPaths, maybeOpts) {
         include: opts.include,
         lockfileDir: opts.lockfileDir,
         onlyProjects: opts.onlyProjects,
+        peerSatisfactionEdges: getPeerSatisfactionEdgesToSkip(lockfileToUse, {
+            include: opts.include,
+            resolvePeersFromWorkspaceRoot: maybeOpts.resolvePeersFromWorkspaceRoot,
+        }),
     });
     const sharedMaterializationCache = new Map();
-    const sharedDepTypes = detectDepTypes(lockfileToUse);
+    const sharedDepTypes = detectDepTypes(lockfileToUse, maybeOpts);
     const ctx = {
         currentLockfile: lockfileToUse,
         wantedLockfile,
@@ -94,12 +109,106 @@ export async function buildDependenciesTree(projectPaths, maybeOpts) {
             await getHierarchy(projectPath),
         ];
     }));
+    storeIndex?.close();
     for (const [projectPath, dependenciesHierarchy] of pairs) {
         result[projectPath] = dependenciesHierarchy;
     }
-    storeIndex?.close();
+    if (opts.onlyProjects) {
+        // Sequential, so that the first occurrence of a linked project is the
+        // one expanded, as with the deduplication of a shared lockfile.
+        for (const [projectPath, dependenciesHierarchy] of pairs) {
+            // eslint-disable-next-line no-await-in-loop
+            await expandLinkedProjects(dependenciesHierarchy, {
+                importers: lockfileToUse.importers,
+                lockfileDir: opts.lockfileDir,
+                depth: opts.depth,
+                treeOpts: maybeOpts,
+                walk: { ...linkedWalk, ancestors: new Set([...linkedWalk.ancestors, projectPath]) },
+                rewriteLinkVersionDir: projectPath,
+            });
+        }
+    }
     return result;
 }
+/**
+ * Attaches the project dependencies of every linked workspace project that
+ * the lockfile has no importer for. With `sharedWorkspaceLockfile: false`,
+ * the lockfile that the tree was built from knows nothing about the
+ * dependencies of the other workspace projects.
+ */
+async function expandLinkedProjects(tree, ctx) {
+    for (const field of DEPENDENCIES_FIELDS) {
+        if (tree[field] != null) {
+            // eslint-disable-next-line no-await-in-loop
+            tree[field] = await expandLinkedProjectNodes(tree[field], 0, ctx);
+        }
+    }
+}
+async function expandLinkedProjectNodes(nodes, level, ctx) {
+    const expanded = [];
+    for (const node of nodes) {
+        let expandedNode = node;
+        if (node.dependencies != null) {
+            // eslint-disable-next-line no-await-in-loop
+            expandedNode = keepSearched({ ...node, dependencies: await expandLinkedProjectNodes(node.dependencies, level + 1, ctx) }, ctx);
+        }
+        else if (!node.circular && ctx.importers[getLockfileImporterId(ctx.lockfileDir, node.path)] == null) {
+            // eslint-disable-next-line no-await-in-loop
+            expandedNode = await expandLinkedProject(node, level, ctx);
+        }
+        if (expandedNode != null)
+            expanded.push(expandedNode);
+    }
+    return expanded;
+}
+async function expandLinkedProject(linkedNode, level, ctx) {
+    const projectDir = ctx.walk.linkedProjectDirs.get(linkedNode.path);
+    if (projectDir == null)
+        return undefined;
+    const node = { ...linkedNode, path: projectDir };
+    if (ctx.walk.ancestors.has(node.path))
+        return keepSearched({ ...node, circular: true }, ctx);
+    if (level >= ctx.depth)
+        return keepSearched(node, ctx);
+    const depth = ctx.depth - level - 1;
+    const key = `${node.path}@${depth}`;
+    const previousCount = ctx.walk.expanded.get(key);
+    if (previousCount != null) {
+        return previousCount > 0
+            ? { ...node, deduped: true, dedupedDependenciesCount: previousCount }
+            : keepSearched(node, ctx);
+    }
+    const linkedTrees = await buildProjectsTrees([node.path], {
+        ...ctx.treeOpts,
+        lockfileDir: node.path,
+        depth,
+    }, ctx.walk);
+    const linkedTree = linkedTrees[node.path];
+    const dependencies = DEPENDENCIES_FIELDS.flatMap((field) => linkedTree[field] ?? []);
+    ctx.walk.expanded.set(key, countNodes(dependencies));
+    return keepSearched(dependencies.length > 0
+        ? { ...node, dependencies: rewriteLinkVersions(dependencies, node.path, ctx.rewriteLinkVersionDir) }
+        : node, ctx);
+}
+function countNodes(nodes) {
+    return nodes.reduce((count, node) => count + 1 + countNodes(node.dependencies ?? []), 0);
+}
+function keepSearched(node, ctx) {
+    return ctx.treeOpts.search == null || node.searched || node.dependencies?.length ? node : undefined;
+}
+/**
+ * Rebases the `link:` versions of a linked project's dependencies, which are
+ * relative to `linkedProjectDir`, onto `rewriteLinkVersionDir`.
+ */
+function rewriteLinkVersions(nodes, linkedProjectDir, rewriteLinkVersionDir) {
+    return nodes.map((node) => ({
+        ...node,
+        version: node.version.startsWith('link:')
+            ? `link:${normalizePath(path.relative(rewriteLinkVersionDir, path.resolve(linkedProjectDir, node.version.slice('link:'.length))))}`
+            : node.version,
+        ...(node.dependencies && { dependencies: rewriteLinkVersions(node.dependencies, linkedProjectDir, rewriteLinkVersionDir) }),
+    }));
+}
 async function dependenciesHierarchyForPackage(opts, projectPath) {
     const { currentLockfile, wantedLockfile } = opts;
     const importerId = getLockfileImporterId(opts.lockfileDir, projectPath);
@@ -144,7 +253,8 @@ async function dependenciesHierarchyForPackage(opts, projectPath) {
     // Handle unsaved dependencies (packages in node_modules but not in lockfile).
     // When searching, unsaved deps are irrelevant — they aren't in the lockfile
     // graph and can't have dependency subtrees showing paths to the search target.
-    if (!opts.search) {
+    // They aren't workspace projects either, which is all onlyProjects lists.
+    if (!opts.search && !opts.onlyProjects) {
         const savedDeps = getAllDirectDependencies(currentLockfile.importers[importerId]);
         const unsavedDeps = ((await readModulesDir(modulesDir)) ?? []).filter((directDep) => !savedDeps[directDep]);
         if (unsavedDeps.length > 0)

package/lib/buildDependencyGraph.d.ts

@@ -1,6 +1,7 @@
 import type { PackageSnapshots, ProjectSnapshot } from '@pnpm/lockfile.fs';
+import { type PeerSatisfactionEdges } from '@pnpm/lockfile.peer-edges';
 import { type TreeNodeId } from './TreeNodeId.js';
-interface DependencyEdge {
+export interface DependencyEdge {
     alias: string;
     ref: string;
     target?: {
@@ -26,5 +27,15 @@ export declare function buildDependencyGraph(rootIds: TreeNodeId[], opts: {
     };
     lockfileDir: string;
     onlyProjects?: boolean;
+    /** Edges left out of the graph, from `getPeerSatisfactionEdgesToSkip`. */
+    peerSatisfactionEdges?: PeerSatisfactionEdges;
 }): DependencyGraph;
+/**
+ * Whether an edge may lead to a project. Besides the importers of the lockfile,
+ * this includes a project's `link:` dependency on a directory outside the
+ * lockfile: with a dedicated lockfile per project, every other workspace
+ * project is such a directory. `buildDependenciesTree` keeps those only when
+ * the directory is a workspace project.
+ */
+export declare function isProjectEdge(parentId: TreeNodeId, edge: DependencyEdge): boolean;
 export {};

package/lib/buildDependencyGraph.js

@@ -1,3 +1,4 @@
+import { isPeerSatisfactionEdge } from '@pnpm/lockfile.peer-edges';
 import { getTreeNodeChildId } from './getTreeNodeChildId.js';
 import { serializeTreeNodeId } from './TreeNodeId.js';
 export function buildDependencyGraph(rootIds, opts) {
@@ -43,20 +44,22 @@ export function buildDependencyGraph(rootIds, opts) {
                     : rawRef?.version;
                 if (ref == null)
                     continue;
+                if (nodeId.type === 'package' && isPeerSatisfactionEdge(opts.peerSatisfactionEdges, nodeId.depPath, alias))
+                    continue;
                 const targetNodeId = getTreeNodeChildId({
                     parentId: nodeId,
                     dep: { alias, ref },
                     lockfileDir: opts.lockfileDir,
                     importers: opts.importers,
                 });
-                // When onlyProjects is true, only follow edges to workspace importers
-                if (opts.onlyProjects && targetNodeId?.type !== 'importer') {
-                    continue;
-                }
                 const target = targetNodeId != null
                     ? { id: serializeTreeNodeId(targetNodeId), nodeId: targetNodeId }
                     : undefined;
-                edges.push({ alias, ref, target });
+                const edge = { alias, ref, target };
+                if (opts.onlyProjects && !isProjectEdge(nodeId, edge)) {
+                    continue;
+                }
+                edges.push(edge);
                 if (target && !visited.has(target.id)) {
                     queue.push(target.nodeId);
                 }
@@ -66,6 +69,18 @@ export function buildDependencyGraph(rootIds, opts) {
     }
     return graph;
 }
+/**
+ * Whether an edge may lead to a project. Besides the importers of the lockfile,
+ * this includes a project's `link:` dependency on a directory outside the
+ * lockfile: with a dedicated lockfile per project, every other workspace
+ * project is such a directory. `buildDependenciesTree` keeps those only when
+ * the directory is a workspace project.
+ */
+export function isProjectEdge(parentId, edge) {
+    if (edge.target != null)
+        return edge.target.nodeId.type === 'importer';
+    return parentId.type === 'importer' && edge.ref.startsWith('link:');
+}
 function getSnapshot(treeNodeId, opts) {
     switch (treeNodeId.type) {
         case 'importer':

package/lib/buildDependentsTree.d.ts

@@ -44,4 +44,5 @@ export declare function buildDependentsTree(packages: string[], projectPaths: st
         version: string;
         manifest: DependencyManifest;
     }) => string | undefined;
+    resolvePeersFromWorkspaceRoot?: boolean;
 }): Promise<DependentsTree[]>;

package/lib/buildDependentsTree.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { normalizeRegistriesByScope } from '@pnpm/config.normalize-registries';
 import { readModulesManifest } from '@pnpm/installing.modules-yaml';
 import { getLockfileImporterId, } from '@pnpm/lockfile.fs';
+import { getPeerSatisfactionEdgesToSkip } from '@pnpm/lockfile.peer-edges';
 import { nameVerFromPkgSnapshot } from '@pnpm/lockfile.utils';
 import { StoreIndex } from '@pnpm/store.index';
 import { lexCompare } from '@pnpm/text.ordinal-comparator';
@@ -37,6 +38,10 @@ export async function buildDependentsTree(packages, projectPaths, opts) {
         importers: opts.lockfile.importers,
         include,
         lockfileDir: opts.lockfileDir,
+        peerSatisfactionEdges: getPeerSatisfactionEdgesToSkip(opts.lockfile, {
+            include,
+            resolvePeersFromWorkspaceRoot: opts.resolvePeersFromWorkspaceRoot,
+        }),
     });
     const reverseMap = invertGraph(graph);
     const search = createPackagesSearcher(packages, opts.finders);

package/lib/getTree.d.ts

@@ -2,7 +2,7 @@ import type { DepTypes } from '@pnpm/lockfile.detect-dep-types';
 import type { PackageSnapshots, ProjectSnapshot } from '@pnpm/lockfile.fs';
 import type { StoreIndex } from '@pnpm/store.index';
 import type { Finder, RegistriesByScope } from '@pnpm/types';
-import type { DependencyGraph } from './buildDependencyGraph.js';
+import { type DependencyGraph } from './buildDependencyGraph.js';
 import type { DependencyNode } from './DependencyNode.js';
 import { type TreeNodeId } from './TreeNodeId.js';
 export interface BaseTreeOpts {

package/lib/getTree.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { lexCompare } from '@pnpm/text.ordinal-comparator';
+import { isProjectEdge } from './buildDependencyGraph.js';
 import { getPkgInfo } from './getPkgInfo.js';
 import { peersSuffixHashFromDepPath } from './peersSuffixHash.js';
 import { serializeTreeNodeId } from './TreeNodeId.js';
@@ -65,7 +66,7 @@ function materializeChildren(ctx, parentId, maxDepth, parentDir) {
     // the alphabetically-first dependency always gets fully expanded.
     const sortedEdges = [...graphNode.edges].sort((a, b) => lexCompare(a.alias, b.alias));
     for (const edge of sortedEdges) {
-        if (ctx.onlyProjects && edge.target?.nodeId.type !== 'importer') {
+        if (ctx.onlyProjects && !isProjectEdge(parentId, edge)) {
             continue;
         }
         const { pkgInfo: packageInfo, readManifest } = getPkgInfo({
@@ -76,6 +77,11 @@ function materializeChildren(ctx, parentId, maxDepth, parentDir) {
             linkedPathBaseDir,
             parentDir,
         });
+        // A project linked through its publish directory is listed at its own
+        // directory.
+        if (ctx.onlyProjects && edge.target?.nodeId.type === 'importer') {
+            packageInfo.path = path.join(ctx.lockfileDir, edge.target.nodeId.importerId);
+        }
         const searchMatch = ctx.search?.({
             alias: edge.alias,
             name: packageInfo.name,
@@ -87,8 +93,10 @@ function materializeChildren(ctx, parentId, maxDepth, parentDir) {
         let dedupedHasSearchMatch = false;
         let dedupedSearchMessages = [];
         if (edge.target == null) {
-            // External link or unresolvable — no traversal possible
-            if (ctx.search == null || searchMatch) {
+            // External link or unresolvable — no traversal possible. With
+            // onlyProjects, this is a link to a project outside the lockfile, which
+            // buildDependenciesTree walks and prunes for the search afterwards.
+            if (ctx.search == null || searchMatch || ctx.onlyProjects) {
                 newEntry = packageInfo;
             }
             else {

package/lib/getTreeNodeChildId.js

@@ -18,13 +18,16 @@ export function getTreeNodeChildId(opts) {
             // importerId is created by reusing the getLockfileImporterId function.
             const absoluteLinkedPath = path.join(opts.lockfileDir, opts.parentId.importerId, linkValue);
             const childImporterId = getLockfileImporterId(opts.lockfileDir, absoluteLinkedPath);
+            if (opts.importers[childImporterId] != null) {
+                return { type: 'importer', importerId: childImporterId };
+            }
             // A 'link:' reference may refer to a package outside of the pnpm workspace.
             // Return undefined in that case since it would be difficult to list/traverse
             // that package outside of the pnpm workspace.
-            const isLinkOutsideWorkspace = opts.importers[childImporterId] == null;
-            return isLinkOutsideWorkspace
+            const publishingImporterId = getPublishDirectoryImporters(opts.lockfileDir, opts.importers).get(childImporterId);
+            return publishingImporterId == null
                 ? undefined
-                : { type: 'importer', importerId: childImporterId };
+                : { type: 'importer', importerId: publishingImporterId };
         }
         case 'package':
             // In theory an external package could be overridden to link to a
@@ -33,4 +36,24 @@ export function getTreeNodeChildId(opts) {
             return undefined;
     }
 }
+const publishDirectoryImportersCache = new WeakMap();
+/**
+ * The importer each publish directory belongs to, keyed like an importer id.
+ * Dependents link a project with `publishConfig.directory` there unless
+ * `publishConfig.linkDirectory` is false.
+ */
+function getPublishDirectoryImporters(lockfileDir, importers) {
+    let publishDirectoryImporters = publishDirectoryImportersCache.get(importers);
+    if (publishDirectoryImporters == null) {
+        publishDirectoryImporters = new Map();
+        for (const [importerId, { publishDirectory, linkDirectory }] of Object.entries(importers)) {
+            if (publishDirectory != null && linkDirectory !== false) {
+                const linkedImporterId = getLockfileImporterId(lockfileDir, path.join(lockfileDir, importerId, publishDirectory));
+                publishDirectoryImporters.set(linkedImporterId, importerId);
+            }
+        }
+        publishDirectoryImportersCache.set(importers, publishDirectoryImporters);
+    }
+    return publishDirectoryImporters;
+}
 //# sourceMappingURL=getTreeNodeChildId.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/deps.inspection.tree-builder",
-  "version": "1101.0.4",
+  "version": "1101.0.6",
   "description": "Creates a dependencies hierarchy for a symlinked `node_modules`",
   "keywords": [
     "pnpm",
@@ -31,22 +31,23 @@
   ],
   "dependencies": {
     "@pnpm/config.matcher": "1100.0.2",
-    "@pnpm/config.normalize-registries": "1101.0.1",
-    "@pnpm/deps.path": "1101.0.2",
+    "@pnpm/config.normalize-registries": "1101.0.2",
+    "@pnpm/deps.path": "1101.0.4",
     "@pnpm/fs.read-modules-dir": "1100.0.2",
-    "@pnpm/installing.modules-yaml": "1101.0.2",
-    "@pnpm/lockfile.detect-dep-types": "1100.0.23",
-    "@pnpm/lockfile.fs": "1100.2.7",
-    "@pnpm/lockfile.utils": "1102.1.2",
+    "@pnpm/installing.modules-yaml": "1101.0.4",
+    "@pnpm/lockfile.detect-dep-types": "1100.0.25",
+    "@pnpm/lockfile.fs": "1100.2.9",
+    "@pnpm/lockfile.peer-edges": "1100.0.0",
+    "@pnpm/lockfile.utils": "1102.1.4",
     "@pnpm/npm-package-arg": "^2.0.0",
-    "@pnpm/pkg-manifest.reader": "1100.0.19",
-    "@pnpm/store.cafs": "1100.3.2",
-    "@pnpm/store.index": "1100.3.1",
+    "@pnpm/pkg-manifest.reader": "1100.0.20",
+    "@pnpm/store.cafs": "1100.3.4",
+    "@pnpm/store.index": "1100.3.2",
     "@pnpm/text.ordinal-comparator": "1100.0.0",
-    "@pnpm/types": "1102.1.0",
+    "@pnpm/types": "1102.1.1",
     "load-json-file": "^7.0.1",
     "normalize-path": "^3.0.0",
-    "p-limit": "^7.3.2",
+    "p-limit": "^7.3.3",
     "path-absolute": "^2.0.0",
     "realpath-missing": "^2.0.0",
     "resolve-link-target": "^3.0.0",
@@ -55,7 +56,7 @@
   "devDependencies": {
     "@jest/globals": "30.4.1",
     "@pnpm/constants": "1102.0.0",
-    "@pnpm/deps.inspection.tree-builder": "1101.0.4",
+    "@pnpm/deps.inspection.tree-builder": "1101.0.6",
     "@pnpm/test-fixtures": "1100.0.1",
     "@types/normalize-path": "^3.0.2",
     "@types/semver": "7.8.0"