@teambit/pnpm 1.0.1169 → 1.0.1171

package/dist/pnpm-prune-modules.js

@@ -25,6 +25,13 @@ function _lodash() {
   };
   return data;
 }
+function nodeApi() {
+  const data = _interopRequireWildcard(require("@pnpm/napi"));
+  nodeApi = function () {
+    return data;
+  };
+  return data;
+}
 function _dependenciesPnpm() {
   const data = require("@teambit/dependencies.pnpm.dep-path");
   _dependenciesPnpm = function () {
@@ -39,21 +46,8 @@ function _preserveLoadedVirtualStoreDirs() {
   };
   return data;
 }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-let lockfileFsPromise;
-function loadLockfileFs() {
-  lockfileFsPromise ??= (async () => {
-    const {
-      loadEsm
-    } = require('./load-pnpm-esm.cjs');
-    const {
-      lockfileFs
-    } = await loadEsm();
-    return lockfileFs;
-  })();
-  return lockfileFsPromise;
-}
-
 /**
  * Reads the private lockfile at node_modules/.pnpm/lock.yaml
  * and removes any directories from node_modules/.pnpm that are not listed in the lockfile.
@@ -62,13 +56,19 @@ async function pnpmPruneModules(rootDir) {
   const virtualStoreDir = _path().default.join(rootDir, 'node_modules/.pnpm');
   const pkgDirs = await readPackageDirsFromVirtualStore(virtualStoreDir);
   if (pkgDirs.length === 0) return;
-  const {
-    readCurrentLockfile
-  } = await loadLockfileFs();
-  const lockfile = await readCurrentLockfile(virtualStoreDir, {
-    ignoreIncompatible: false
+  const lockfile = await nodeApi().readLockfile({
+    dir: rootDir,
+    kind: 'current'
   });
-  const dirsShouldBePresent = Object.keys(lockfile?.packages ?? {}).map(depPath => (0, _dependenciesPnpm().depPathToDirName)(depPath));
+  // No current lockfile means nothing is known about what was materialized,
+  // not that nothing belongs here — pruning against an empty set would empty
+  // the virtual store and leave the workspace needing a reinstall.
+  if (lockfile == null) return;
+  // The virtual store's directory names come from the peer-suffixed dep
+  // paths, which is what `snapshots` is keyed by; `packages` is keyed
+  // without the suffix and would not match.
+  const snapshots = lockfile.snapshots ?? {};
+  const dirsShouldBePresent = Object.keys(snapshots).map(depPath => (0, _dependenciesPnpm().depPathToDirName)(depPath));
   const extraneous = (0, _lodash().difference)(pkgDirs, dirsShouldBePresent);
   // the usual case, and the one worth keeping cheap: scanning the loaded modules below is
   // proportional to how much this process has loaded, and with nothing to remove it decides nothing

package/dist/pnpm-prune-modules.js.map

@@ -1 +1 @@
-{"version":3,"names":["_fsExtra","data","_interopRequireDefault","require","_path","_lodash","_dependenciesPnpm","_preserveLoadedVirtualStoreDirs","e","__esModule","default","lockfileFsPromise","loadLockfileFs","loadEsm","lockfileFs","pnpmPruneModules","rootDir","virtualStoreDir","path","join","pkgDirs","readPackageDirsFromVirtualStore","length","readCurrentLockfile","lockfile","ignoreIncompatible","dirsShouldBePresent","Object","keys","packages","map","depPath","depPathToDirName","extraneous","difference","loadedByThisProcess","loadedVirtualStoreDirNames","Promise","all","filter","dir","has","fs","remove","allDirs","readdir","err","code"],"sources":["pnpm-prune-modules.ts"],"sourcesContent":["import fs from 'fs-extra';\nimport path from 'path';\nimport { difference } from 'lodash';\nimport type * as LockfileFs from '@pnpm/lockfile.fs';\nimport { depPathToDirName } from '@teambit/dependencies.pnpm.dep-path';\nimport { loadedVirtualStoreDirNames } from './preserve-loaded-virtual-store-dirs';\n\ntype LockfileFsModule = typeof LockfileFs;\nlet lockfileFsPromise: Promise<LockfileFsModule> | undefined;\n\nfunction loadLockfileFs(): Promise<LockfileFsModule> {\n  lockfileFsPromise ??= (async () => {\n    const { loadEsm } = require('./load-pnpm-esm.cjs') as {\n      loadEsm: () => Promise<{ lockfileFs: LockfileFsModule }>;\n    };\n    const { lockfileFs } = await loadEsm();\n    return lockfileFs;\n  })();\n  return lockfileFsPromise;\n}\n\n/**\n * Reads the private lockfile at node_modules/.pnpm/lock.yaml\n * and removes any directories from node_modules/.pnpm that are not listed in the lockfile.\n */\nexport async function pnpmPruneModules(rootDir: string): Promise<void> {\n  const virtualStoreDir = path.join(rootDir, 'node_modules/.pnpm');\n  const pkgDirs = await readPackageDirsFromVirtualStore(virtualStoreDir);\n  if (pkgDirs.length === 0) return;\n  const { readCurrentLockfile } = await loadLockfileFs();\n  const lockfile = await readCurrentLockfile(virtualStoreDir, { ignoreIncompatible: false });\n  const dirsShouldBePresent = Object.keys(lockfile?.packages ?? {}).map((depPath) => depPathToDirName(depPath));\n  const extraneous = difference(pkgDirs, dirsShouldBePresent);\n  // the usual case, and the one worth keeping cheap: scanning the loaded modules below is\n  // proportional to how much this process has loaded, and with nothing to remove it decides nothing\n  if (extraneous.length === 0) return;\n  // never remove a directory the running process has loaded modules from. an install that re-keys\n  // a loaded package to a new peer hash restores the old directory so deferred requires keep\n  // working (see preserve-loaded-virtual-store-dirs.ts); that directory is intentionally absent\n  // from the lockfile, and deleting it here would re-break exactly what the restore fixed. a later\n  // command's prune, whose process has nothing loaded from it, cleans it up.\n  const loadedByThisProcess = loadedVirtualStoreDirNames(virtualStoreDir);\n  await Promise.all(\n    extraneous\n      .filter((dir) => !loadedByThisProcess.has(dir))\n      .map((dir) => fs.remove(path.join(virtualStoreDir, dir)))\n  );\n}\n\n/**\n * The project-local virtual store may hold no package directories at all: with the global virtual\n * store enabled the packages live under `<storeDir>/links` (pruned by the engine itself) and only\n * `lock.yaml` and the hoisted `node_modules` remain here. A `lockfileOnly` install leaves the\n * directory missing entirely. Both cases mean \"nothing for us to prune\".\n */\nasync function readPackageDirsFromVirtualStore(virtualStoreDir: string): Promise<string[]> {\n  let allDirs: string[];\n  try {\n    allDirs = await fs.readdir(virtualStoreDir);\n  } catch (err: any) {\n    if (err.code === 'ENOENT') return [];\n    throw err;\n  }\n  return allDirs.filter((dir) => dir !== 'lock.yaml' && dir !== 'node_modules');\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_fsExtra","data","_interopRequireDefault","require","_path","_lodash","nodeApi","_interopRequireWildcard","_dependenciesPnpm","_preserveLoadedVirtualStoreDirs","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","pnpmPruneModules","rootDir","virtualStoreDir","path","join","pkgDirs","readPackageDirsFromVirtualStore","length","lockfile","readLockfile","dir","kind","snapshots","dirsShouldBePresent","keys","map","depPath","depPathToDirName","extraneous","difference","loadedByThisProcess","loadedVirtualStoreDirNames","Promise","all","filter","fs","remove","allDirs","readdir","err","code"],"sources":["pnpm-prune-modules.ts"],"sourcesContent":["import fs from 'fs-extra';\nimport path from 'path';\nimport { difference } from 'lodash';\nimport * as nodeApi from '@pnpm/napi';\nimport { depPathToDirName } from '@teambit/dependencies.pnpm.dep-path';\nimport { loadedVirtualStoreDirNames } from './preserve-loaded-virtual-store-dirs';\n\n/**\n * Reads the private lockfile at node_modules/.pnpm/lock.yaml\n * and removes any directories from node_modules/.pnpm that are not listed in the lockfile.\n */\nexport async function pnpmPruneModules(rootDir: string): Promise<void> {\n  const virtualStoreDir = path.join(rootDir, 'node_modules/.pnpm');\n  const pkgDirs = await readPackageDirsFromVirtualStore(virtualStoreDir);\n  if (pkgDirs.length === 0) return;\n  const lockfile = await nodeApi.readLockfile({ dir: rootDir, kind: 'current' });\n  // No current lockfile means nothing is known about what was materialized,\n  // not that nothing belongs here — pruning against an empty set would empty\n  // the virtual store and leave the workspace needing a reinstall.\n  if (lockfile == null) return;\n  // The virtual store's directory names come from the peer-suffixed dep\n  // paths, which is what `snapshots` is keyed by; `packages` is keyed\n  // without the suffix and would not match.\n  const snapshots = (lockfile.snapshots ?? {}) as Record<string, unknown>;\n  const dirsShouldBePresent = Object.keys(snapshots).map((depPath) => depPathToDirName(depPath));\n  const extraneous = difference(pkgDirs, dirsShouldBePresent);\n  // the usual case, and the one worth keeping cheap: scanning the loaded modules below is\n  // proportional to how much this process has loaded, and with nothing to remove it decides nothing\n  if (extraneous.length === 0) return;\n  // never remove a directory the running process has loaded modules from. an install that re-keys\n  // a loaded package to a new peer hash restores the old directory so deferred requires keep\n  // working (see preserve-loaded-virtual-store-dirs.ts); that directory is intentionally absent\n  // from the lockfile, and deleting it here would re-break exactly what the restore fixed. a later\n  // command's prune, whose process has nothing loaded from it, cleans it up.\n  const loadedByThisProcess = loadedVirtualStoreDirNames(virtualStoreDir);\n  await Promise.all(\n    extraneous\n      .filter((dir) => !loadedByThisProcess.has(dir))\n      .map((dir) => fs.remove(path.join(virtualStoreDir, dir)))\n  );\n}\n\n/**\n * The project-local virtual store may hold no package directories at all: with the global virtual\n * store enabled the packages live under `<storeDir>/links` (pruned by the engine itself) and only\n * `lock.yaml` and the hoisted `node_modules` remain here. A `lockfileOnly` install leaves the\n * directory missing entirely. Both cases mean \"nothing for us to prune\".\n */\nasync function readPackageDirsFromVirtualStore(virtualStoreDir: string): Promise<string[]> {\n  let allDirs: string[];\n  try {\n    allDirs = await fs.readdir(virtualStoreDir);\n  } catch (err: any) {\n    if (err.code === 'ENOENT') return [];\n    throw err;\n  }\n  return allDirs.filter((dir) => dir !== 'lock.yaml' && dir !== 'node_modules');\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/pnpm.package-manager.d.ts

@@ -4,7 +4,6 @@ import { Registries } from '@teambit/pkg.entities.registry';
 import type { Logger } from '@teambit/logger';
 import type { PeerDependencyIssuesByProjects, ResolvedConfig } from '@pnpm/napi';
 import { type ProjectManifest, type DepPath } from '@pnpm/types';
-import type { Modules } from '@pnpm/installing.modules-yaml';
 import type { RebuildFn } from './lynx';
 import { type DependenciesGraph } from '@teambit/objects';
 export type { RebuildFn };
@@ -18,12 +17,19 @@ type ReadConfigResult = Promise<{
     config: ResolvedConfig;
     warnings: string[];
 }>;
+/**
+ * The `.modules.yaml` fields Bit reads. The engine returns the whole
+ * manifest; only these are consumed here.
+ */
+interface ModulesManifest {
+    injectedDeps?: Record<string, string[]>;
+}
 export declare class PnpmPackageManager implements PackageManager {
     private depResolver;
     private logger;
     private cloud;
     readonly name = "pnpm";
-    readonly modulesManifestCache: Map<string, Modules>;
+    readonly modulesManifestCache: Map<string, ModulesManifest>;
     private username;
     private _readConfig;
     readConfig: (dir?: string) => ReadConfigResult;
@@ -43,7 +49,7 @@ export declare class PnpmPackageManager implements PackageManager {
     getNetworkConfig?(): Promise<PackageManagerNetworkConfig>;
     getRegistries(): Promise<Registries>;
     getInjectedDirs(rootDir: string, componentDir: string, packageName: string): Promise<string[]>;
-    _readModulesManifest(lockfileDir: string): Promise<Modules | undefined>;
+    _readModulesManifest(lockfileDir: string): Promise<ModulesManifest | undefined>;
     getWorkspaceDepsOfBitRoots(manifests: ProjectManifest[]): Record<string, string>;
     /**
      * pnpm's own shared `<storeDir>/links`.

package/dist/pnpm.package-manager.js

@@ -25,13 +25,6 @@ function _harmonyModules() {
   };
   return data;
 }
-function _fs() {
-  const data = _interopRequireDefault(require("fs"));
-  _fs = function () {
-    return data;
-  };
-  return data;
-}
 function _lodash() {
   const data = require("lodash");
   _lodash = function () {
@@ -39,27 +32,6 @@ function _lodash() {
   };
   return data;
 }
-function _lockfile() {
-  const data = require("@pnpm/lockfile.filtering");
-  _lockfile = function () {
-    return data;
-  };
-  return data;
-}
-function _depsInspection() {
-  const data = require("@pnpm/deps.inspection.tree-builder");
-  _depsInspection = function () {
-    return data;
-  };
-  return data;
-}
-function _depsInspection2() {
-  const data = require("@pnpm/deps.inspection.list");
-  _depsInspection2 = function () {
-    return data;
-  };
-  return data;
-}
 function _legacy() {
   const data = require("@teambit/legacy.constants");
   _legacy = function () {
@@ -109,28 +81,25 @@ function _preserveLoadedVirtualStoreDirs() {
   };
   return data;
 }
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-let pnpmEsmPromise;
-function loadPnpmEsm() {
-  pnpmEsmPromise ??= (async () => {
-    const {
-      loadEsm
-    } = require('./load-pnpm-esm.cjs');
-    const {
-      lockfileFs,
-      modulesYaml
-    } = await loadEsm();
-    return {
-      lockfileFs,
-      modulesYaml
-    };
-  })();
-  return pnpmEsmPromise;
+/**
+ * The `.modules.yaml` fields Bit reads. The engine returns the whole
+ * manifest; only these are consumed here.
+ */
+
+/** One importer entry of a lockfile, in the file's own shape. */
+
+/**
+ * Required lazily so the native engine binary is not mapped into every
+ * `bit` process at startup (same convention as the `./lynx` require sites).
+ */
+function loadNodeApi() {
+  // eslint-disable-next-line global-require, import/no-dynamic-require
+  return require('@pnpm/napi');
 }
 class PnpmPackageManager {
   constructor(depResolver, logger, cloud) {
@@ -174,29 +143,26 @@ class PnpmPackageManager {
     const graphLockfile = await (0, _lockfileDepsGraphConverter().convertGraphToLockfile)(dependenciesGraph, _objectSpread(_objectSpread({}, opts), {}, {
       resolve
     }));
-    const {
-      lockfileFs: {
-        readWantedLockfile,
-        writeLockfileFile,
-        convertToLockfileFile: convertLockfileObjectToLockfileFile
-      }
-    } = await loadPnpmEsm();
+    const nodeApi = loadNodeApi();
     // Merge the graph-derived subset into any existing wanted lockfile rather than
     // overwriting. Only the importers, packages, and snapshots referenced by the
     // imported components' subgraph are re-stated here; every other workspace dep's
     // locked version must be preserved so pnpm doesn't re-resolve it to a newer
     // registry version.
-    const existingLockfile = await readWantedLockfile(opts.rootDir, {
-      ignoreIncompatible: true
+    const existingLockfile = await nodeApi.readLockfile({
+      dir: opts.rootDir
     });
-    const mergedLockfile = existingLockfile ? mergeGraphLockfileIntoExisting(convertLockfileObjectToLockfileFile(existingLockfile), graphLockfile) : graphLockfile;
+    const mergedLockfile = existingLockfile ? mergeGraphLockfileIntoExisting(existingLockfile, graphLockfile) : graphLockfile;
     Object.assign(mergedLockfile, {
       bit: _objectSpread(_objectSpread({}, mergedLockfile.bit), {}, {
         restoredFromModel: true
       })
     });
+    await nodeApi.writeLockfile({
+      dir: opts.rootDir,
+      lockfile: mergedLockfile
+    });
     const lockfilePath = (0, _path().join)(opts.rootDir, 'pnpm-lock.yaml');
-    await writeLockfileFile(lockfilePath, mergedLockfile);
     this.logger.debug(`generated a lockfile from dependencies graph at ${lockfilePath}`);
     if (process.env.DEPS_GRAPH_LOG) {
       // eslint-disable-next-line no-console
@@ -301,9 +267,7 @@ class PnpmPackageManager {
       hidePackageManagerOutput: installOptions.hidePackageManagerOutput,
       reportOptions: {
         appendOnly: installOptions.optimizeReportForNonTerminal,
-        process: process.env.BIT_CLI_SERVER_NO_TTY ? _objectSpread(_objectSpread({}, process), {}, {
-          stdout: new (_legacy2().ServerSendOutStream)()
-        }) : undefined,
+        outputStream: process.env.BIT_CLI_SERVER_NO_TTY ? new (_legacy2().ServerSendOutStream)() : undefined,
         throttleProgress: installOptions.throttleProgress,
         hideProgressPrefix: installOptions.hideProgressPrefix,
         hideLifecycleOutput: installOptions.hideLifecycleOutput,
@@ -463,12 +427,8 @@ class PnpmPackageManager {
     if (this.modulesManifestCache.has(lockfileDir)) {
       return this.modulesManifestCache.get(lockfileDir);
     }
-    const {
-      modulesYaml: {
-        readModulesManifest
-      }
-    } = await loadPnpmEsm();
-    const modulesManifest = await readModulesManifest((0, _path().join)(lockfileDir, 'node_modules'));
+    const nodeApi = loadNodeApi();
+    const modulesManifest = await nodeApi.readModulesManifest((0, _path().join)(lockfileDir, 'node_modules'));
     if (modulesManifest) {
       this.modulesManifestCache.set(lockfileDir, modulesManifest);
     }
@@ -501,52 +461,21 @@ class PnpmPackageManager {
     return (0, _pnpmPruneModules().pnpmPruneModules)(rootDir);
   }
   async findUsages(depName, opts) {
-    const {
-      lockfileFs: {
-        readWantedLockfile
-      }
-    } = await loadPnpmEsm();
-    const lockfile = await readWantedLockfile(opts.lockfileDir, {
-      ignoreIncompatible: false
+    const nodeApi = loadNodeApi();
+    const trees = await nodeApi.getDependents({
+      dir: opts.lockfileDir,
+      packages: [depName],
+      // The generated importers under `.bit_roots` wire the workspace
+      // together; they are not somewhere a user's dependency comes from.
+      excludeProjectPatterns: [`*${_legacy().BIT_ROOTS_DIR}/*`],
+      // The engine walks the lockfile, which knows package names. Ask it
+      // for the field that carries the component id so the tree can be
+      // rendered in Bit's terms instead.
+      manifestFields: ['componentId']
     });
-    if (!lockfile) return '';
-    const importerIds = Object.keys(lockfile.importers ?? {}).filter(id => !id.includes(`${_legacy().BIT_ROOTS_DIR}/`));
-    const projectPaths = importerIds.map(id => (0, _path().join)(opts.lockfileDir, id));
-    const importerInfoMap = new Map();
-    for (const importerId of importerIds) {
-      const pkgJson = tryReadPackageJson((0, _path().join)(opts.lockfileDir, importerId));
-      importerInfoMap.set(importerId, {
-        name: pkgJson?.name ?? importerId,
-        version: pkgJson?.version ?? ''
-      });
-    }
-    const trees = await (0, _depsInspection().buildDependentsTree)([depName], projectPaths, {
-      include: {
-        dependencies: true,
-        devDependencies: true,
-        optionalDependencies: true
-      },
-      lockfileDir: opts.lockfileDir,
-      registries: {
-        default: 'https://registry.npmjs.org'
-      },
-      importerInfoMap,
-      lockfile,
-      nameFormatter({
-        manifest
-      }) {
-        if ('componentId' in manifest) {
-          const {
-            scope,
-            name
-          } = manifest.componentId;
-          return `${scope}/${name}`;
-        }
-        return manifest.name;
-      }
-    });
-    return (0, _depsInspection2().renderDependentsTree)(trees, {
-      depth: opts.depth ?? Infinity,
+    applyComponentIdNames(trees);
+    return nodeApi.renderDependents(trees, {
+      depth: opts.depth,
       long: false
     });
   }
@@ -556,18 +485,14 @@ class PnpmPackageManager {
    */
   async calcDependenciesGraph(opts) {
     await (0, _lockfileDepsGraphConverter().init)();
-    const {
-      lockfileFs: {
-        readWantedLockfile,
-        convertToLockfileFile: convertLockfileObjectToLockfileFile
-      }
-    } = await loadPnpmEsm();
-    const originalLockfile = await readWantedLockfile(opts.rootDir, {
-      ignoreIncompatible: false
+    const nodeApi = loadNodeApi();
+    const originalLockfile = await nodeApi.readLockfile({
+      dir: opts.rootDir
     });
-    if (!originalLockfile) {
+    if (!originalLockfile?.importers) {
       return;
     }
+    const originalImporters = originalLockfile.importers;
     for (const {
       componentRootDir,
       componentRelativeDir,
@@ -576,15 +501,15 @@ class PnpmPackageManager {
     } of opts.components) {
       const componentImporterId = componentRelativeDir || '.';
       let compRootDir;
-      if (componentRootDir && !originalLockfile.importers[componentRootDir] && componentRootDir.includes('@')) {
+      if (componentRootDir && !originalImporters[componentRootDir] && componentRootDir.includes('@')) {
         compRootDir = componentRootDir.split('@')[0];
       } else {
         compRootDir = componentRootDir;
       }
-      if (!originalLockfile.importers[componentImporterId]) {
+      if (!originalImporters[componentImporterId]) {
         continue;
       }
-      const hasComponentRootImporter = compRootDir != null && Boolean(originalLockfile.importers[compRootDir]);
+      const hasComponentRootImporter = compRootDir != null && Boolean(originalImporters[compRootDir]);
       const filterByImporterIds = [componentImporterId];
       if (hasComponentRootImporter && compRootDir !== componentImporterId) {
         filterByImporterIds.push(compRootDir);
@@ -592,12 +517,12 @@ class PnpmPackageManager {
       // Only clone the importers that will be mutated, reuse the rest of the lockfile as-is
       const clonedImporters = {};
       for (const importerId of filterByImporterIds) {
-        if (originalLockfile.importers[importerId]) {
-          clonedImporters[importerId] = structuredClone(originalLockfile.importers[importerId]);
+        if (originalImporters[importerId]) {
+          clonedImporters[importerId] = structuredClone(originalImporters[importerId]);
         }
       }
       const lockfile = _objectSpread(_objectSpread({}, originalLockfile), {}, {
-        importers: _objectSpread(_objectSpread({}, originalLockfile.importers), clonedImporters)
+        importers: _objectSpread(_objectSpread({}, originalImporters), clonedImporters)
       });
       for (const importerId of filterByImporterIds) {
         const importer = lockfile.importers[importerId];
@@ -612,23 +537,15 @@ class PnpmPackageManager {
           // component's graph.
           if (importerId === componentImporterId) {
             const ref = importer.dependencies?.[workspacePkgName] ?? importer.devDependencies?.[workspacePkgName] ?? importer.optionalDependencies?.[workspacePkgName];
-            if (typeof ref === 'string' && ref.startsWith('file:')) continue;
+            if (ref?.version?.startsWith('file:')) continue;
           }
-          for (const depType of ['dependencies', 'devDependencies', 'optionalDependencies', 'specifiers', 'dependenciesMeta']) {
+          for (const depType of ['dependencies', 'devDependencies', 'optionalDependencies', 'dependenciesMeta']) {
             delete importer[depType]?.[workspacePkgName];
           }
         }
       }
       // Filters the lockfile so that it only includes packages related to the given component.
-      const partialLockfile = convertLockfileObjectToLockfileFile((0, _lockfile().filterLockfileByImporters)(lockfile, filterByImporterIds, {
-        include: {
-          dependencies: true,
-          devDependencies: true,
-          optionalDependencies: true
-        },
-        failOnMissingDependencies: false,
-        skipped: new Set()
-      }));
+      const partialLockfile = nodeApi.filterLockfileByImporters(lockfile, filterByImporterIds);
       const graph = (0, _lockfileDepsGraphConverter().convertLockfileToGraph)(partialLockfile, _objectSpread(_objectSpread({}, opts), {}, {
         componentRootDir: hasComponentRootImporter ? compRootDir : undefined,
         componentRelativeDir: componentImporterId,
@@ -649,12 +566,23 @@ function resolveHoistPattern(hoistPatternsFromBitConfig, hoistPatternFromPnpmCon
 function isDefaultHoistPattern(hoistPattern) {
   return hoistPattern.length === 1 && hoistPattern[0] === '*';
 }
-function tryReadPackageJson(pkgDir) {
-  try {
-    return JSON.parse(_fs().default.readFileSync((0, _path().join)(pkgDir, 'package.json'), 'utf8'));
-  } catch {
-    return undefined;
-  }
+
+/**
+ * Rename every node the engine resolved to a Bit component after its
+ * component id, in place. The engine has no notion of one — it reports the
+ * package name from the lockfile — so it is asked for the `componentId`
+ * field of each node's manifest and Bit turns that into the display name,
+ * which the renderer then prefers over the package name.
+ */
+function applyComponentIdNames(trees) {
+  const rename = node => {
+    const componentId = node.manifest?.componentId;
+    if (componentId?.scope && componentId.name) {
+      node.displayName = `${componentId.scope}/${componentId.name}`;
+    }
+    node.dependents?.forEach(rename);
+  };
+  trees.forEach(rename);
 }
 
 // Merge a graph-derived lockfile into an existing wanted lockfile. The graph lockfile is