@teambit/dependency-resolver 1.0.1097 → 1.0.1098

package/dist/hoisted-resolution-bridge.d.ts

@@ -27,19 +27,51 @@ export declare function parseRecordedVirtualStoreDir(modulesManifest: string): s
  * the root has not escaped it.
  */
 export declare function isPathInsideOrEqual(child: string, parent: string): boolean;
+/**
+ * Whether two spellings name the same directory. `path.relative` normalizes both sides first, so a
+ * trailing separator, a redundant `.`, a relative spelling and - on Windows - a difference in case
+ * all compare equal, which string equality would miss. Anything written by hand into `NODE_PATH`
+ * arrives in whatever spelling its author chose.
+ */
+export declare function isSamePath(one: string, other: string): boolean;
 export declare function isGlobalVirtualStoreLayout(workspaceRoot: string): boolean;
 /**
- * Bridge the *running installation's* own hoisted directory when that installation is itself
- * linked to the global virtual store - its packages then live in store slots and their phantom
- * requires need the installation's private hoist exactly like a workspace's do. Judged by the
- * same `.modules.yaml` record, read at the installation root. A conventional project-local
+ * The root of the installation this module runs from: the nearest ancestor that owns a
+ * `node_modules/.modules.yaml`. For a bvm-installed bit that is the bvm version directory; for a
+ * workspace-provided bit it is the workspace.
+ *
+ * Two candidate starting points, because Node realpaths module filenames: under the global
+ * virtual store this module's `__dirname` is the *store slot* - a dead end with no
+ * `.modules.yaml` and no physical path back to the installation. The entry script's
+ * `process.argv[1]` is the path *as invoked*, unresolved through symlinks, so for a store-linked
+ * installation it still sits inside the installation tree. `__dirname` remains the fallback for
+ * setups that invoke bit through a resolved path (and for the copy-shaped installations where it
+ * works fine). `undefined` when neither leads to an installation (e.g. running from source).
+ */
+export declare function selfInstallationRoot(): string | undefined;
+/**
+ * Bridge the *running installation's* own directories when that installation is itself linked to
+ * the global virtual store - its packages then live in store slots and their phantom requires
+ * need the installation's private hoist exactly like a workspace's do. Judged by the same
+ * `.modules.yaml` record, read at the installation root. A conventional project-local
  * installation (bvm's default) reads project-local and stays unbridged, so nothing changes for
  * it or for the processes it spawns.
  */
 export declare function ensureSelfInstallationBridge(): void;
 /**
- * Put the given root's hoisted directory on the resolution path of this process and its children.
- * Idempotent; a no-op when the hoisted directory doesn't exist. Callers decide *whether* the
+ * The directories a package resolved from `<root>` used to reach by walking up, in the order the
+ * walk reached them: the hoisted `node_modules/.pnpm/node_modules` first, then the root's own
+ * `node_modules`. Both are lost under the global virtual store, and they hold disjoint sets -
+ * pnpm hoists only *non-direct* dependencies, so a direct dependency of the root exists solely in
+ * the second. Missing directories are dropped; a root with neither yields an empty list.
+ *
+ * Shared with the type-resolution side of the bridge, which has to reach the same two directories
+ * through the mechanism TypeScript offers instead of `NODE_PATH`.
+ */
+export declare function hoistedResolutionDirs(root: string): string[];
+/**
+ * Put the given root's {@link hoistedResolutionDirs} on the resolution path of this process and
+ * its children. Idempotent; a no-op when neither directory exists. Callers decide *whether* the
  * root needs the bridge ({@link isGlobalVirtualStoreLayout} for the pre-aspect gate, the
  * dependency-resolver's own config after an install).
  */

package/dist/hoisted-resolution-bridge.js

@@ -5,9 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.ensureHoistedDependencyResolution = ensureHoistedDependencyResolution;
 exports.ensureSelfInstallationBridge = ensureSelfInstallationBridge;
+exports.hoistedResolutionDirs = hoistedResolutionDirs;
 exports.isGlobalVirtualStoreLayout = isGlobalVirtualStoreLayout;
 exports.isPathInsideOrEqual = isPathInsideOrEqual;
+exports.isSamePath = isSamePath;
 exports.parseRecordedVirtualStoreDir = parseRecordedVirtualStoreDir;
+exports.selfInstallationRoot = selfInstallationRoot;
 function fs() {
   const data = _interopRequireWildcard(require("fs"));
   fs = function () {
@@ -42,15 +45,22 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
  * This covers phantom dependencies generally, not one class of them. Bit's core aspects are the
  * case that motivated it - `@teambit/*` is required by every published env and aspect without
  * being declared, because it has to be the single copy from the running installation - but any
- * under-declared package in the graph resolves the same way, which is why the whole hoisted
- * directory goes on the path rather than a hand-picked list.
+ * under-declared package in the graph resolves the same way, which is why whole directories go on
+ * the path rather than a hand-picked list.
+ *
+ * Both directories the walk reached are restored ({@link hoistedResolutionDirs}), because they
+ * hold disjoint sets: pnpm hoists only *non-direct* dependencies, so a direct dependency of the
+ * root - the workspace's own `mocha`, `react`, `@types/react` - is reachable through the root's
+ * `node_modules` and nowhere else.
  *
  * pnpm's answer for this layout is `NODE_PATH` pointing at the hoisted directory, which stays
  * project-local under the global virtual store. pnpm sets it in the command shims it writes, but
  * bit runs from bvm rather than through a shim and loads aspects in its own process, so it has to
  * do this itself. `NODE_PATH` only covers CommonJS; an ESM loader (adapted from pnpm's
  * `@pnpm/plugin-esm-node-path`, MIT) handles the ESM side, registered both in-process via
- * `module.register` and for child processes via a `NODE_OPTIONS --import` flag.
+ * `module.register` and for child processes via a `NODE_OPTIONS --import` flag. TypeScript reads
+ * neither, so the type-resolution half lives in `@teambit/typescript` and builds its `paths` from
+ * the same directories.
  *
  * Two call sites, and both matter:
  * - `bootstrap()` in `@teambit/bit`, before any aspect loads, gated on the layout the last
@@ -61,10 +71,18 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
  *   old layout, yet the same process goes on to reload envs and compile from store slots. The
  *   installer re-applies the bridge the moment the target layout is known.
  *
- * Everything here is idempotent, so calling it again is always safe: the `NODE_PATH` entry is
- * added once, the ESM loader re-registers only when the entry set grows (the previous, subset
- * loader keeps chaining harmlessly), and the process's own `NODE_OPTIONS` flag is replaced
- * rather than stacked.
+ * Everything here is idempotent, so calling it again is always safe: `NODE_PATH` is rebuilt to the
+ * same value, the ESM loader re-registers only when the ordered entry list changes, and the
+ * process's own `NODE_OPTIONS` flag is replaced rather than stacked.
+ *
+ * One asymmetry to know about when reading the ESM half. Node runs the *last* registered loader
+ * first and it delegates through `defaultResolve` before its own fallback, so an earlier
+ * registration resolves anything it can before a later one is consulted. A re-registration
+ * therefore corrects what child processes inherit - the `--import` flag carries the current list -
+ * while in-process the earlier registration keeps its precedence for the entries it already had.
+ * That only diverges from CommonJS for a specifier resolvable from more than one entry across two
+ * registrations with different orders, which needs a process bridging two roots in alternating
+ * order; the CommonJS half, rebuilt on every call, is always right.
  */
 
 /**
@@ -72,8 +90,9 @@ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r
  * The entries cannot be read from `NODE_PATH` inside the loader: on modern Node the hooks run on
  * a separate thread whose `process.env` is a snapshot taken at registration, so late additions -
  * an install switching the workspace onto the global virtual store mid-process - would never be
- * seen. Injecting the list makes each registration self-contained; when the set grows, a new
- * loader is registered and chains after the previous (whose entries are a subset - harmless).
+ * seen. Injecting the list makes each registration self-contained, at the cost of needing a new
+ * registration whenever the list changes - by order as much as by membership, since the loader
+ * searches these entries in the order given.
  */
 const esmNodePathLoaderSource = dirs => `
 import { createRequire } from 'node:module'
@@ -98,9 +117,10 @@ export async function resolve (specifier, context, defaultResolve) {
     }
     // createRequire anchored inside the entry searches the entry itself: Node skips appending
     // /node_modules to a directory already named node_modules, and the parent step re-yields it
-    // (.pnpm -> .pnpm/node_modules). Exact for the hoisted-dir entries this loader exists for;
-    // an entry not named node_modules would be searched one level deeper than CommonJS NODE_PATH
-    // does - those entries are already covered by the CommonJS side and are not ours to fix.
+    // (.pnpm -> .pnpm/node_modules). Exact for the entries this loader exists for, both of which
+    // are named node_modules; an entry not named node_modules would be searched one level deeper
+    // than CommonJS NODE_PATH does - those entries are already covered by the CommonJS side and
+    // are not ours to fix.
     for (const basePath of extraNodePaths) {
       try {
         const require = createRequire(pathToFileURL(basePath + '/').href)
@@ -111,7 +131,7 @@ export async function resolve (specifier, context, defaultResolve) {
   }
 }
 `;
-const registeredEsmDirs = new Set();
+let lastRegisteredEntries;
 let lastImportFlag;
 
 /**
@@ -156,6 +176,16 @@ function isPathInsideOrEqual(child, parent) {
   // component-aware traversal check: a child legitimately named `..foo` also starts with `..`
   return !path().isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${path().sep}`);
 }
+
+/**
+ * Whether two spellings name the same directory. `path.relative` normalizes both sides first, so a
+ * trailing separator, a redundant `.`, a relative spelling and - on Windows - a difference in case
+ * all compare equal, which string equality would miss. Anything written by hand into `NODE_PATH`
+ * arrives in whatever spelling its author chose.
+ */
+function isSamePath(one, other) {
+  return path().relative(one, other) === '';
+}
 function isGlobalVirtualStoreLayout(workspaceRoot) {
   let modulesManifest;
   try {
@@ -209,10 +239,10 @@ function selfInstallationRoot() {
 }
 
 /**
- * Bridge the *running installation's* own hoisted directory when that installation is itself
- * linked to the global virtual store - its packages then live in store slots and their phantom
- * requires need the installation's private hoist exactly like a workspace's do. Judged by the
- * same `.modules.yaml` record, read at the installation root. A conventional project-local
+ * Bridge the *running installation's* own directories when that installation is itself linked to
+ * the global virtual store - its packages then live in store slots and their phantom requires
+ * need the installation's private hoist exactly like a workspace's do. Judged by the same
+ * `.modules.yaml` record, read at the installation root. A conventional project-local
  * installation (bvm's default) reads project-local and stays unbridged, so nothing changes for
  * it or for the processes it spawns.
  */
@@ -224,17 +254,41 @@ function ensureSelfInstallationBridge() {
 }
 
 /**
- * Put the given root's hoisted directory on the resolution path of this process and its children.
- * Idempotent; a no-op when the hoisted directory doesn't exist. Callers decide *whether* the
+ * The directories a package resolved from `<root>` used to reach by walking up, in the order the
+ * walk reached them: the hoisted `node_modules/.pnpm/node_modules` first, then the root's own
+ * `node_modules`. Both are lost under the global virtual store, and they hold disjoint sets -
+ * pnpm hoists only *non-direct* dependencies, so a direct dependency of the root exists solely in
+ * the second. Missing directories are dropped; a root with neither yields an empty list.
+ *
+ * Shared with the type-resolution side of the bridge, which has to reach the same two directories
+ * through the mechanism TypeScript offers instead of `NODE_PATH`.
+ */
+function hoistedResolutionDirs(root) {
+  return [path().join(root, 'node_modules', '.pnpm', 'node_modules'), path().join(root, 'node_modules')].filter(dir => fs().existsSync(dir));
+}
+
+/**
+ * Put the given root's {@link hoistedResolutionDirs} on the resolution path of this process and
+ * its children. Idempotent; a no-op when neither directory exists. Callers decide *whether* the
  * root needs the bridge ({@link isGlobalVirtualStoreLayout} for the pre-aspect gate, the
  * dependency-resolver's own config after an install).
  */
 function ensureHoistedDependencyResolution(workspaceRoot) {
-  const hoistedDir = path().join(workspaceRoot, 'node_modules', '.pnpm', 'node_modules');
-  if (!fs().existsSync(hoistedDir)) return;
+  const dirs = hoistedResolutionDirs(workspaceRoot);
+  if (!dirs.length) return;
   const existing = process.env.NODE_PATH;
-  if (!existing?.split(path().delimiter).includes(hoistedDir)) {
-    process.env.NODE_PATH = existing ? `${hoistedDir}${path().delimiter}${existing}` : hoistedDir;
+  const untouched = (existing?.split(path().delimiter).filter(Boolean) ?? []).filter(
+  // by path rather than by spelling, so an entry naming a directory this bridge owns is replaced
+  // by the canonical one instead of being kept alongside it as a redundant search base
+  dir => !dirs.some(owned => isSamePath(dir, owned)));
+  // rebuilt rather than prepended, because order is resolution order and an entry already present
+  // is not necessarily in front of the one it has to beat: a bit that bridged the hoisted
+  // directory alone leaves it in `NODE_PATH` for its children, and adding the root's node_modules
+  // in front of it there would invert the walk the bridge exists to reproduce. Everything this
+  // bridge does not own keeps its relative order, behind what the walk reached first.
+  const next = [...dirs, ...untouched].join(path().delimiter);
+  if (next !== existing) {
+    process.env.NODE_PATH = next;
     // `NODE_PATH` is read once when the module system initializes, so a later assignment only
     // takes effect after re-deriving the global paths.
     require('module')._initPaths();
@@ -261,10 +315,13 @@ function ensureHoistedDependencyResolution(workspaceRoot) {
 function registerEsmNodePathLoader() {
   const nodeModule = require('module');
   if (typeof nodeModule.register !== 'function') return;
-  // mirror the CommonJS side exactly: every current NODE_PATH entry participates
+  // mirror the CommonJS side exactly: every current NODE_PATH entry participates, in its order
   const dirs = (process.env.NODE_PATH || '').split(path().delimiter).filter(Boolean);
   if (!dirs.length) return;
-  if (lastImportFlag && dirs.every(dir => registeredEsmDirs.has(dir))) return;
+  const entries = dirs.join(path().delimiter);
+  // ordered, not a set: the loader inlines the list, so a reordering leaves a registration whose
+  // precedence no longer matches the one CommonJS now uses
+  if (lastImportFlag && entries === lastRegisteredEntries) return;
   const loaderUrl = `data:text/javascript,${encodeURIComponent(esmNodePathLoaderSource(dirs))}`;
   const parentUrl = (0, _url().pathToFileURL)(path().join(process.cwd(), '/')).href;
   try {
@@ -274,7 +331,7 @@ function registerEsmNodePathLoader() {
     // half of the workaround is unaffected, and only ESM packages relying on hoisting are lost.
     return;
   }
-  dirs.forEach(dir => registeredEsmDirs.add(dir));
+  lastRegisteredEntries = entries;
   const registration = `import{register}from'node:module';register(${JSON.stringify(loaderUrl)},${JSON.stringify(parentUrl)});`;
   const importFlag = `--import=data:text/javascript,${encodeURIComponent(registration)}`;
   // children get one flag carrying the full current set: replace our previous flag rather than

package/dist/hoisted-resolution-bridge.js.map

@@ -1 +1 @@
-{"version":3,"names":["fs","data","_interopRequireWildcard","require","path","_url","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","esmNodePathLoaderSource","dirs","JSON","stringify","registeredEsmDirs","Set","lastImportFlag","parseRecordedVirtualStoreDir","modulesManifest","parsed","parse","virtualStoreDir","undefined","match","isPathInsideOrEqual","child","parent","rel","relative","isAbsolute","startsWith","sep","isGlobalVirtualStoreLayout","workspaceRoot","readFileSync","join","workspaceRealpath","realpathSync","resolved","resolve","storeRealpath","selfInstallationRoot","candidates","process","argv","__dirname","filter","Boolean","candidate","dir","dirname","existsSync","ensureSelfInstallationBridge","installationRoot","ensureHoistedDependencyResolution","hoistedDir","existing","env","NODE_PATH","split","delimiter","includes","_initPaths","registerEsmNodePathLoader","nodeModule","register","length","every","loaderUrl","encodeURIComponent","parentUrl","pathToFileURL","cwd","href","forEach","add","registration","importFlag","NODE_OPTIONS","replace"],"sources":["hoisted-resolution-bridge.ts"],"sourcesContent":["/**\n * Make a workspace's privately hoisted dependencies resolvable from pnpm's global virtual store.\n *\n * Under the project-local virtual store, a package in `node_modules/.pnpm` resolves anything it\n * requires without declaring it by walking *up* into the workspace - the hoisted\n * `node_modules/.pnpm/node_modules` first, then the workspace root. Under the global virtual\n * store the package lives in a store shared with every other project on the machine, with no\n * workspace above it, so every such require fails.\n *\n * This covers phantom dependencies generally, not one class of them. Bit's core aspects are the\n * case that motivated it - `@teambit/*` is required by every published env and aspect without\n * being declared, because it has to be the single copy from the running installation - but any\n * under-declared package in the graph resolves the same way, which is why the whole hoisted\n * directory goes on the path rather than a hand-picked list.\n *\n * pnpm's answer for this layout is `NODE_PATH` pointing at the hoisted directory, which stays\n * project-local under the global virtual store. pnpm sets it in the command shims it writes, but\n * bit runs from bvm rather than through a shim and loads aspects in its own process, so it has to\n * do this itself. `NODE_PATH` only covers CommonJS; an ESM loader (adapted from pnpm's\n * `@pnpm/plugin-esm-node-path`, MIT) handles the ESM side, registered both in-process via\n * `module.register` and for child processes via a `NODE_OPTIONS --import` flag.\n *\n * Two call sites, and both matter:\n * - `bootstrap()` in `@teambit/bit`, before any aspect loads, gated on the layout the last\n *   install recorded ({@link isGlobalVirtualStoreLayout}). It deep-requires this module's dist\n *   file directly so CLI startup never pays for the dependency-resolver barrel.\n * - the install flow, right after the package manager finishes: the first install that switches\n *   a workspace onto the global virtual store runs with `bootstrap`'s gate still reflecting the\n *   old layout, yet the same process goes on to reload envs and compile from store slots. The\n *   installer re-applies the bridge the moment the target layout is known.\n *\n * Everything here is idempotent, so calling it again is always safe: the `NODE_PATH` entry is\n * added once, the ESM loader re-registers only when the entry set grows (the previous, subset\n * loader keeps chaining harmlessly), and the process's own `NODE_OPTIONS` flag is replaced\n * rather than stacked.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { pathToFileURL } from 'url';\n\n/**\n * Source of the registered ESM loader, with the resolution entries injected at registration time.\n * The entries cannot be read from `NODE_PATH` inside the loader: on modern Node the hooks run on\n * a separate thread whose `process.env` is a snapshot taken at registration, so late additions -\n * an install switching the workspace onto the global virtual store mid-process - would never be\n * seen. Injecting the list makes each registration self-contained; when the set grows, a new\n * loader is registered and chains after the previous (whose entries are a subset - harmless).\n */\nconst esmNodePathLoaderSource = (dirs: string[]) => `\nimport { createRequire } from 'node:module'\nimport { pathToFileURL } from 'node:url'\n\nconst extraNodePaths = ${JSON.stringify(dirs)}\n\nexport async function resolve (specifier, context, defaultResolve) {\n  try {\n    return await defaultResolve(specifier, context, defaultResolve)\n  } catch (originalError) {\n    // Only bare specifiers can come from the hoisted directory; the rest are already anchored.\n    // Windows absolute (drive-letter) and UNC paths are path specifiers too.\n    if (\n      specifier.startsWith('.') ||\n      specifier.startsWith('/') ||\n      specifier.startsWith('node:') ||\n      specifier.startsWith('\\\\\\\\') ||\n      /^[a-zA-Z]:[\\\\\\\\/]/.test(specifier)\n    ) {\n      throw originalError\n    }\n    // createRequire anchored inside the entry searches the entry itself: Node skips appending\n    // /node_modules to a directory already named node_modules, and the parent step re-yields it\n    // (.pnpm -> .pnpm/node_modules). Exact for the hoisted-dir entries this loader exists for;\n    // an entry not named node_modules would be searched one level deeper than CommonJS NODE_PATH\n    // does - those entries are already covered by the CommonJS side and are not ours to fix.\n    for (const basePath of extraNodePaths) {\n      try {\n        const require = createRequire(pathToFileURL(basePath + '/').href)\n        return { url: pathToFileURL(require.resolve(specifier)).href, shortCircuit: true }\n      } catch {}\n    }\n    throw originalError\n  }\n}\n`;\n\nconst registeredEsmDirs = new Set<string>();\nlet lastImportFlag: string | undefined;\n\n/**\n * The `virtualStoreDir` pnpm recorded in a `node_modules/.modules.yaml`, or undefined when the\n * manifest records none.\n *\n * Current pnpm writes this manifest as JSON (YAML 1.2 being a superset of it), so the structured\n * read is a plain `JSON.parse` - no dependency, and correct for every value the writer can emit.\n * Older versions wrote block YAML, which the line match handles. A full YAML parser is\n * deliberately avoided: this runs in `bootstrap`, before any command does its work, and parsing\n * the whole manifest costs ~40ms on this repo's own 415KB one against ~0.2ms for the line match\n * (the manifest carries the entire hoisted alias map, so it grows with the dependency graph).\n * Taking a package dependency here would also make the earliest, least recoverable step of CLI\n * startup depend on module resolution - the very thing this module exists to repair.\n */\nexport function parseRecordedVirtualStoreDir(modulesManifest: string): string | undefined {\n  try {\n    const parsed = JSON.parse(modulesManifest) as { virtualStoreDir?: unknown };\n    return typeof parsed.virtualStoreDir === 'string' ? parsed.virtualStoreDir : undefined;\n  } catch {\n    // not JSON - a block-YAML manifest from an older pnpm\n  }\n  return modulesManifest.match(/^\\s*\"?virtualStoreDir\"?:\\s*\"?([^\"\\n]+?)\"?,?\\s*$/m)?.[1];\n}\n\n/**\n * Whether the workspace's last install used pnpm's global virtual store, judged by the\n * `virtualStoreDir` the engine records in `node_modules/.modules.yaml`: `.pnpm` (or any path\n * inside the workspace) means project-local; a path escaping the workspace means the global\n * store. No manifest or no recorded value reads as project-local - a workspace that never\n * installed under the global store has nothing to bridge.\n */\n/**\n * Platform-safe path containment: `path.relative` is case-insensitive on Windows (where the\n * filesystem is) and case-sensitive on posix, which a bare `startsWith` prefix check gets wrong\n * for drive-letter casing differences between realpath results and given spellings. Equality\n * counts as inside - every caller asks \"does this path escape that root\", and a path equal to\n * the root has not escaped it.\n */\nexport function isPathInsideOrEqual(child: string, parent: string): boolean {\n  const rel = path.relative(parent, child);\n  // component-aware traversal check: a child legitimately named `..foo` also starts with `..`\n  return !path.isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${path.sep}`);\n}\n\nexport function isGlobalVirtualStoreLayout(workspaceRoot: string): boolean {\n  let modulesManifest: string;\n  try {\n    modulesManifest = fs.readFileSync(path.join(workspaceRoot, 'node_modules', '.modules.yaml'), 'utf8');\n  } catch {\n    return false;\n  }\n  const virtualStoreDir = parseRecordedVirtualStoreDir(modulesManifest);\n  if (!virtualStoreDir) return false;\n  let workspaceRealpath = workspaceRoot;\n  try {\n    workspaceRealpath = fs.realpathSync(workspaceRoot);\n  } catch {\n    // fall back to the given spelling\n  }\n  const resolved = path.resolve(workspaceRealpath, 'node_modules', virtualStoreDir);\n  let storeRealpath = resolved;\n  try {\n    storeRealpath = fs.realpathSync(resolved);\n  } catch {\n    // dangling recorded dir - judge by the lexical resolution\n  }\n  return !isPathInsideOrEqual(storeRealpath, workspaceRealpath);\n}\n\n/**\n * The root of the installation this module runs from: the nearest ancestor that owns a\n * `node_modules/.modules.yaml`. For a bvm-installed bit that is the bvm version directory; for a\n * workspace-provided bit it is the workspace.\n *\n * Two candidate starting points, because Node realpaths module filenames: under the global\n * virtual store this module's `__dirname` is the *store slot* - a dead end with no\n * `.modules.yaml` and no physical path back to the installation. The entry script's\n * `process.argv[1]` is the path *as invoked*, unresolved through symlinks, so for a store-linked\n * installation it still sits inside the installation tree. `__dirname` remains the fallback for\n * setups that invoke bit through a resolved path (and for the copy-shaped installations where it\n * works fine). `undefined` when neither leads to an installation (e.g. running from source).\n */\nfunction selfInstallationRoot(): string | undefined {\n  const candidates = [process.argv[1], __dirname].filter(Boolean) as string[];\n  for (const candidate of candidates) {\n    let dir = path.dirname(path.resolve(candidate));\n    for (;;) {\n      if (fs.existsSync(path.join(dir, 'node_modules', '.modules.yaml'))) return dir;\n      const parent = path.dirname(dir);\n      if (parent === dir) break;\n      dir = parent;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Bridge the *running installation's* own hoisted directory when that installation is itself\n * linked to the global virtual store - its packages then live in store slots and their phantom\n * requires need the installation's private hoist exactly like a workspace's do. Judged by the\n * same `.modules.yaml` record, read at the installation root. A conventional project-local\n * installation (bvm's default) reads project-local and stays unbridged, so nothing changes for\n * it or for the processes it spawns.\n */\nexport function ensureSelfInstallationBridge(): void {\n  const installationRoot = selfInstallationRoot();\n  if (!installationRoot) return;\n  if (!isGlobalVirtualStoreLayout(installationRoot)) return;\n  ensureHoistedDependencyResolution(installationRoot);\n}\n\n/**\n * Put the given root's hoisted directory on the resolution path of this process and its children.\n * Idempotent; a no-op when the hoisted directory doesn't exist. Callers decide *whether* the\n * root needs the bridge ({@link isGlobalVirtualStoreLayout} for the pre-aspect gate, the\n * dependency-resolver's own config after an install).\n */\nexport function ensureHoistedDependencyResolution(workspaceRoot: string): void {\n  const hoistedDir = path.join(workspaceRoot, 'node_modules', '.pnpm', 'node_modules');\n  if (!fs.existsSync(hoistedDir)) return;\n  const existing = process.env.NODE_PATH;\n  if (!existing?.split(path.delimiter).includes(hoistedDir)) {\n    process.env.NODE_PATH = existing ? `${hoistedDir}${path.delimiter}${existing}` : hoistedDir;\n    // `NODE_PATH` is read once when the module system initializes, so a later assignment only\n    // takes effect after re-deriving the global paths.\n    (require('module') as { _initPaths(): void })._initPaths();\n  }\n  registerEsmNodePathLoader();\n}\n\n/**\n * The ESM half of {@link ensureHoistedDependencyResolution}.\n *\n * Node consults `NODE_PATH` only for CommonJS; ESM resolution ignores it entirely. Bit supports\n * ESM components, so without this an ESM package in the store cannot reach the hoisted directory\n * at all and the CommonJS half would only cover part of the problem.\n *\n * Registered two ways, because both matter:\n * - `module.register` for bit's own process, which is where aspects and envs are loaded.\n * - `NODE_OPTIONS`, so the processes bit spawns - env build steps, app servers, test workers -\n *   inherit it. They resolve their own dependencies and hit the same wall.\n *\n * The loader is inlined as a data URL rather than taken as a dependency so there is no file to\n * ship and no install step to depend on. `module.register` needs Node 20.6, so this is skipped\n * on older runtimes - the CommonJS half still applies there.\n */\nfunction registerEsmNodePathLoader(): void {\n  const nodeModule = require('module') as {\n    register?: (specifier: string, parentURL: string) => void;\n  };\n  if (typeof nodeModule.register !== 'function') return;\n  // mirror the CommonJS side exactly: every current NODE_PATH entry participates\n  const dirs = (process.env.NODE_PATH || '').split(path.delimiter).filter(Boolean);\n  if (!dirs.length) return;\n  if (lastImportFlag && dirs.every((dir) => registeredEsmDirs.has(dir))) return;\n  const loaderUrl = `data:text/javascript,${encodeURIComponent(esmNodePathLoaderSource(dirs))}`;\n  const parentUrl = pathToFileURL(path.join(process.cwd(), '/')).href;\n  try {\n    nodeModule.register(loaderUrl, parentUrl);\n  } catch {\n    // A runtime that rejects the loader must not take the whole CLI down with it - the CommonJS\n    // half of the workaround is unaffected, and only ESM packages relying on hoisting are lost.\n    return;\n  }\n  dirs.forEach((dir) => registeredEsmDirs.add(dir));\n  const registration = `import{register}from'node:module';register(${JSON.stringify(loaderUrl)},${JSON.stringify(parentUrl)});`;\n  const importFlag = `--import=data:text/javascript,${encodeURIComponent(registration)}`;\n  // children get one flag carrying the full current set: replace our previous flag rather than\n  // stacking loaders, and match our own flag exactly - a user's `--require ts-node/register`\n  // in NODE_OPTIONS must not suppress the loader's propagation\n  if (lastImportFlag && process.env.NODE_OPTIONS?.includes(lastImportFlag)) {\n    process.env.NODE_OPTIONS = process.env.NODE_OPTIONS.replace(lastImportFlag, importFlag);\n  } else if (!process.env.NODE_OPTIONS?.includes(importFlag)) {\n    process.env.NODE_OPTIONS = process.env.NODE_OPTIONS\n      ? `${process.env.NODE_OPTIONS} ${importFlag}`\n      : importFlag;\n  }\n  lastImportFlag = importFlag;\n}\n"],"mappings":";;;;;;;;;;AAoCA,SAAAA,GAAA;EAAA,MAAAC,IAAA,GAAAC,uBAAA,CAAAC,OAAA;EAAAH,EAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,KAAA;EAAA,MAAAH,IAAA,GAAAC,uBAAA,CAAAC,OAAA;EAAAC,IAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,KAAA;EAAA,MAAAJ,IAAA,GAAAE,OAAA;EAAAE,IAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAoC,SAAAC,wBAAAI,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAN,uBAAA,YAAAA,CAAAI,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AAtCpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMkB,uBAAuB,GAAIC,IAAc,IAAK;AACpD;AACA;AACA;AACA,yBAAyBC,IAAI,CAACC,SAAS,CAACF,IAAI,CAAC;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AAED,MAAMG,iBAAiB,GAAG,IAAIC,GAAG,CAAS,CAAC;AAC3C,IAAIC,cAAkC;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,4BAA4BA,CAACC,eAAuB,EAAsB;EACxF,IAAI;IACF,MAAMC,MAAM,GAAGP,IAAI,CAACQ,KAAK,CAACF,eAAe,CAAkC;IAC3E,OAAO,OAAOC,MAAM,CAACE,eAAe,KAAK,QAAQ,GAAGF,MAAM,CAACE,eAAe,GAAGC,SAAS;EACxF,CAAC,CAAC,MAAM;IACN;EAAA;EAEF,OAAOJ,eAAe,CAACK,KAAK,CAAC,kDAAkD,CAAC,GAAG,CAAC,CAAC;AACvF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,mBAAmBA,CAACC,KAAa,EAAEC,MAAc,EAAW;EAC1E,MAAMC,GAAG,GAAGtC,IAAI,CAAD,CAAC,CAACuC,QAAQ,CAACF,MAAM,EAAED,KAAK,CAAC;EACxC;EACA,OAAO,CAACpC,IAAI,CAAD,CAAC,CAACwC,UAAU,CAACF,GAAG,CAAC,IAAIA,GAAG,KAAK,IAAI,IAAI,CAACA,GAAG,CAACG,UAAU,CAAC,KAAKzC,IAAI,CAAD,CAAC,CAAC0C,GAAG,EAAE,CAAC;AAClF;AAEO,SAAS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","ignoreList":[]}
+{"version":3,"names":["fs","data","_interopRequireWildcard","require","path","_url","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","esmNodePathLoaderSource","dirs","JSON","stringify","lastRegisteredEntries","lastImportFlag","parseRecordedVirtualStoreDir","modulesManifest","parsed","parse","virtualStoreDir","undefined","match","isPathInsideOrEqual","child","parent","rel","relative","isAbsolute","startsWith","sep","isSamePath","one","other","isGlobalVirtualStoreLayout","workspaceRoot","readFileSync","join","workspaceRealpath","realpathSync","resolved","resolve","storeRealpath","selfInstallationRoot","candidates","process","argv","__dirname","filter","Boolean","candidate","dir","dirname","existsSync","ensureSelfInstallationBridge","installationRoot","ensureHoistedDependencyResolution","hoistedResolutionDirs","root","length","existing","env","NODE_PATH","untouched","split","delimiter","some","owned","next","_initPaths","registerEsmNodePathLoader","nodeModule","register","entries","loaderUrl","encodeURIComponent","parentUrl","pathToFileURL","cwd","href","registration","importFlag","NODE_OPTIONS","includes","replace"],"sources":["hoisted-resolution-bridge.ts"],"sourcesContent":["/**\n * Make a workspace's privately hoisted dependencies resolvable from pnpm's global virtual store.\n *\n * Under the project-local virtual store, a package in `node_modules/.pnpm` resolves anything it\n * requires without declaring it by walking *up* into the workspace - the hoisted\n * `node_modules/.pnpm/node_modules` first, then the workspace root. Under the global virtual\n * store the package lives in a store shared with every other project on the machine, with no\n * workspace above it, so every such require fails.\n *\n * This covers phantom dependencies generally, not one class of them. Bit's core aspects are the\n * case that motivated it - `@teambit/*` is required by every published env and aspect without\n * being declared, because it has to be the single copy from the running installation - but any\n * under-declared package in the graph resolves the same way, which is why whole directories go on\n * the path rather than a hand-picked list.\n *\n * Both directories the walk reached are restored ({@link hoistedResolutionDirs}), because they\n * hold disjoint sets: pnpm hoists only *non-direct* dependencies, so a direct dependency of the\n * root - the workspace's own `mocha`, `react`, `@types/react` - is reachable through the root's\n * `node_modules` and nowhere else.\n *\n * pnpm's answer for this layout is `NODE_PATH` pointing at the hoisted directory, which stays\n * project-local under the global virtual store. pnpm sets it in the command shims it writes, but\n * bit runs from bvm rather than through a shim and loads aspects in its own process, so it has to\n * do this itself. `NODE_PATH` only covers CommonJS; an ESM loader (adapted from pnpm's\n * `@pnpm/plugin-esm-node-path`, MIT) handles the ESM side, registered both in-process via\n * `module.register` and for child processes via a `NODE_OPTIONS --import` flag. TypeScript reads\n * neither, so the type-resolution half lives in `@teambit/typescript` and builds its `paths` from\n * the same directories.\n *\n * Two call sites, and both matter:\n * - `bootstrap()` in `@teambit/bit`, before any aspect loads, gated on the layout the last\n *   install recorded ({@link isGlobalVirtualStoreLayout}). It deep-requires this module's dist\n *   file directly so CLI startup never pays for the dependency-resolver barrel.\n * - the install flow, right after the package manager finishes: the first install that switches\n *   a workspace onto the global virtual store runs with `bootstrap`'s gate still reflecting the\n *   old layout, yet the same process goes on to reload envs and compile from store slots. The\n *   installer re-applies the bridge the moment the target layout is known.\n *\n * Everything here is idempotent, so calling it again is always safe: `NODE_PATH` is rebuilt to the\n * same value, the ESM loader re-registers only when the ordered entry list changes, and the\n * process's own `NODE_OPTIONS` flag is replaced rather than stacked.\n *\n * One asymmetry to know about when reading the ESM half. Node runs the *last* registered loader\n * first and it delegates through `defaultResolve` before its own fallback, so an earlier\n * registration resolves anything it can before a later one is consulted. A re-registration\n * therefore corrects what child processes inherit - the `--import` flag carries the current list -\n * while in-process the earlier registration keeps its precedence for the entries it already had.\n * That only diverges from CommonJS for a specifier resolvable from more than one entry across two\n * registrations with different orders, which needs a process bridging two roots in alternating\n * order; the CommonJS half, rebuilt on every call, is always right.\n */\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport { pathToFileURL } from 'url';\n\n/**\n * Source of the registered ESM loader, with the resolution entries injected at registration time.\n * The entries cannot be read from `NODE_PATH` inside the loader: on modern Node the hooks run on\n * a separate thread whose `process.env` is a snapshot taken at registration, so late additions -\n * an install switching the workspace onto the global virtual store mid-process - would never be\n * seen. Injecting the list makes each registration self-contained, at the cost of needing a new\n * registration whenever the list changes - by order as much as by membership, since the loader\n * searches these entries in the order given.\n */\nconst esmNodePathLoaderSource = (dirs: string[]) => `\nimport { createRequire } from 'node:module'\nimport { pathToFileURL } from 'node:url'\n\nconst extraNodePaths = ${JSON.stringify(dirs)}\n\nexport async function resolve (specifier, context, defaultResolve) {\n  try {\n    return await defaultResolve(specifier, context, defaultResolve)\n  } catch (originalError) {\n    // Only bare specifiers can come from the hoisted directory; the rest are already anchored.\n    // Windows absolute (drive-letter) and UNC paths are path specifiers too.\n    if (\n      specifier.startsWith('.') ||\n      specifier.startsWith('/') ||\n      specifier.startsWith('node:') ||\n      specifier.startsWith('\\\\\\\\') ||\n      /^[a-zA-Z]:[\\\\\\\\/]/.test(specifier)\n    ) {\n      throw originalError\n    }\n    // createRequire anchored inside the entry searches the entry itself: Node skips appending\n    // /node_modules to a directory already named node_modules, and the parent step re-yields it\n    // (.pnpm -> .pnpm/node_modules). Exact for the entries this loader exists for, both of which\n    // are named node_modules; an entry not named node_modules would be searched one level deeper\n    // than CommonJS NODE_PATH does - those entries are already covered by the CommonJS side and\n    // are not ours to fix.\n    for (const basePath of extraNodePaths) {\n      try {\n        const require = createRequire(pathToFileURL(basePath + '/').href)\n        return { url: pathToFileURL(require.resolve(specifier)).href, shortCircuit: true }\n      } catch {}\n    }\n    throw originalError\n  }\n}\n`;\n\nlet lastRegisteredEntries: string | undefined;\nlet lastImportFlag: string | undefined;\n\n/**\n * The `virtualStoreDir` pnpm recorded in a `node_modules/.modules.yaml`, or undefined when the\n * manifest records none.\n *\n * Current pnpm writes this manifest as JSON (YAML 1.2 being a superset of it), so the structured\n * read is a plain `JSON.parse` - no dependency, and correct for every value the writer can emit.\n * Older versions wrote block YAML, which the line match handles. A full YAML parser is\n * deliberately avoided: this runs in `bootstrap`, before any command does its work, and parsing\n * the whole manifest costs ~40ms on this repo's own 415KB one against ~0.2ms for the line match\n * (the manifest carries the entire hoisted alias map, so it grows with the dependency graph).\n * Taking a package dependency here would also make the earliest, least recoverable step of CLI\n * startup depend on module resolution - the very thing this module exists to repair.\n */\nexport function parseRecordedVirtualStoreDir(modulesManifest: string): string | undefined {\n  try {\n    const parsed = JSON.parse(modulesManifest) as { virtualStoreDir?: unknown };\n    return typeof parsed.virtualStoreDir === 'string' ? parsed.virtualStoreDir : undefined;\n  } catch {\n    // not JSON - a block-YAML manifest from an older pnpm\n  }\n  return modulesManifest.match(/^\\s*\"?virtualStoreDir\"?:\\s*\"?([^\"\\n]+?)\"?,?\\s*$/m)?.[1];\n}\n\n/**\n * Whether the workspace's last install used pnpm's global virtual store, judged by the\n * `virtualStoreDir` the engine records in `node_modules/.modules.yaml`: `.pnpm` (or any path\n * inside the workspace) means project-local; a path escaping the workspace means the global\n * store. No manifest or no recorded value reads as project-local - a workspace that never\n * installed under the global store has nothing to bridge.\n */\n/**\n * Platform-safe path containment: `path.relative` is case-insensitive on Windows (where the\n * filesystem is) and case-sensitive on posix, which a bare `startsWith` prefix check gets wrong\n * for drive-letter casing differences between realpath results and given spellings. Equality\n * counts as inside - every caller asks \"does this path escape that root\", and a path equal to\n * the root has not escaped it.\n */\nexport function isPathInsideOrEqual(child: string, parent: string): boolean {\n  const rel = path.relative(parent, child);\n  // component-aware traversal check: a child legitimately named `..foo` also starts with `..`\n  return !path.isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${path.sep}`);\n}\n\n/**\n * Whether two spellings name the same directory. `path.relative` normalizes both sides first, so a\n * trailing separator, a redundant `.`, a relative spelling and - on Windows - a difference in case\n * all compare equal, which string equality would miss. Anything written by hand into `NODE_PATH`\n * arrives in whatever spelling its author chose.\n */\nexport function isSamePath(one: string, other: string): boolean {\n  return path.relative(one, other) === '';\n}\n\nexport function isGlobalVirtualStoreLayout(workspaceRoot: string): boolean {\n  let modulesManifest: string;\n  try {\n    modulesManifest = fs.readFileSync(path.join(workspaceRoot, 'node_modules', '.modules.yaml'), 'utf8');\n  } catch {\n    return false;\n  }\n  const virtualStoreDir = parseRecordedVirtualStoreDir(modulesManifest);\n  if (!virtualStoreDir) return false;\n  let workspaceRealpath = workspaceRoot;\n  try {\n    workspaceRealpath = fs.realpathSync(workspaceRoot);\n  } catch {\n    // fall back to the given spelling\n  }\n  const resolved = path.resolve(workspaceRealpath, 'node_modules', virtualStoreDir);\n  let storeRealpath = resolved;\n  try {\n    storeRealpath = fs.realpathSync(resolved);\n  } catch {\n    // dangling recorded dir - judge by the lexical resolution\n  }\n  return !isPathInsideOrEqual(storeRealpath, workspaceRealpath);\n}\n\n/**\n * The root of the installation this module runs from: the nearest ancestor that owns a\n * `node_modules/.modules.yaml`. For a bvm-installed bit that is the bvm version directory; for a\n * workspace-provided bit it is the workspace.\n *\n * Two candidate starting points, because Node realpaths module filenames: under the global\n * virtual store this module's `__dirname` is the *store slot* - a dead end with no\n * `.modules.yaml` and no physical path back to the installation. The entry script's\n * `process.argv[1]` is the path *as invoked*, unresolved through symlinks, so for a store-linked\n * installation it still sits inside the installation tree. `__dirname` remains the fallback for\n * setups that invoke bit through a resolved path (and for the copy-shaped installations where it\n * works fine). `undefined` when neither leads to an installation (e.g. running from source).\n */\nexport function selfInstallationRoot(): string | undefined {\n  const candidates = [process.argv[1], __dirname].filter(Boolean) as string[];\n  for (const candidate of candidates) {\n    let dir = path.dirname(path.resolve(candidate));\n    for (;;) {\n      if (fs.existsSync(path.join(dir, 'node_modules', '.modules.yaml'))) return dir;\n      const parent = path.dirname(dir);\n      if (parent === dir) break;\n      dir = parent;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Bridge the *running installation's* own directories when that installation is itself linked to\n * the global virtual store - its packages then live in store slots and their phantom requires\n * need the installation's private hoist exactly like a workspace's do. Judged by the same\n * `.modules.yaml` record, read at the installation root. A conventional project-local\n * installation (bvm's default) reads project-local and stays unbridged, so nothing changes for\n * it or for the processes it spawns.\n */\nexport function ensureSelfInstallationBridge(): void {\n  const installationRoot = selfInstallationRoot();\n  if (!installationRoot) return;\n  if (!isGlobalVirtualStoreLayout(installationRoot)) return;\n  ensureHoistedDependencyResolution(installationRoot);\n}\n\n/**\n * The directories a package resolved from `<root>` used to reach by walking up, in the order the\n * walk reached them: the hoisted `node_modules/.pnpm/node_modules` first, then the root's own\n * `node_modules`. Both are lost under the global virtual store, and they hold disjoint sets -\n * pnpm hoists only *non-direct* dependencies, so a direct dependency of the root exists solely in\n * the second. Missing directories are dropped; a root with neither yields an empty list.\n *\n * Shared with the type-resolution side of the bridge, which has to reach the same two directories\n * through the mechanism TypeScript offers instead of `NODE_PATH`.\n */\nexport function hoistedResolutionDirs(root: string): string[] {\n  return [path.join(root, 'node_modules', '.pnpm', 'node_modules'), path.join(root, 'node_modules')].filter((dir) =>\n    fs.existsSync(dir)\n  );\n}\n\n/**\n * Put the given root's {@link hoistedResolutionDirs} on the resolution path of this process and\n * its children. Idempotent; a no-op when neither directory exists. Callers decide *whether* the\n * root needs the bridge ({@link isGlobalVirtualStoreLayout} for the pre-aspect gate, the\n * dependency-resolver's own config after an install).\n */\nexport function ensureHoistedDependencyResolution(workspaceRoot: string): void {\n  const dirs = hoistedResolutionDirs(workspaceRoot);\n  if (!dirs.length) return;\n  const existing = process.env.NODE_PATH;\n  const untouched = (existing?.split(path.delimiter).filter(Boolean) ?? []).filter(\n    // by path rather than by spelling, so an entry naming a directory this bridge owns is replaced\n    // by the canonical one instead of being kept alongside it as a redundant search base\n    (dir) => !dirs.some((owned) => isSamePath(dir, owned))\n  );\n  // rebuilt rather than prepended, because order is resolution order and an entry already present\n  // is not necessarily in front of the one it has to beat: a bit that bridged the hoisted\n  // directory alone leaves it in `NODE_PATH` for its children, and adding the root's node_modules\n  // in front of it there would invert the walk the bridge exists to reproduce. Everything this\n  // bridge does not own keeps its relative order, behind what the walk reached first.\n  const next = [...dirs, ...untouched].join(path.delimiter);\n  if (next !== existing) {\n    process.env.NODE_PATH = next;\n    // `NODE_PATH` is read once when the module system initializes, so a later assignment only\n    // takes effect after re-deriving the global paths.\n    (require('module') as { _initPaths(): void })._initPaths();\n  }\n  registerEsmNodePathLoader();\n}\n\n/**\n * The ESM half of {@link ensureHoistedDependencyResolution}.\n *\n * Node consults `NODE_PATH` only for CommonJS; ESM resolution ignores it entirely. Bit supports\n * ESM components, so without this an ESM package in the store cannot reach the hoisted directory\n * at all and the CommonJS half would only cover part of the problem.\n *\n * Registered two ways, because both matter:\n * - `module.register` for bit's own process, which is where aspects and envs are loaded.\n * - `NODE_OPTIONS`, so the processes bit spawns - env build steps, app servers, test workers -\n *   inherit it. They resolve their own dependencies and hit the same wall.\n *\n * The loader is inlined as a data URL rather than taken as a dependency so there is no file to\n * ship and no install step to depend on. `module.register` needs Node 20.6, so this is skipped\n * on older runtimes - the CommonJS half still applies there.\n */\nfunction registerEsmNodePathLoader(): void {\n  const nodeModule = require('module') as {\n    register?: (specifier: string, parentURL: string) => void;\n  };\n  if (typeof nodeModule.register !== 'function') return;\n  // mirror the CommonJS side exactly: every current NODE_PATH entry participates, in its order\n  const dirs = (process.env.NODE_PATH || '').split(path.delimiter).filter(Boolean);\n  if (!dirs.length) return;\n  const entries = dirs.join(path.delimiter);\n  // ordered, not a set: the loader inlines the list, so a reordering leaves a registration whose\n  // precedence no longer matches the one CommonJS now uses\n  if (lastImportFlag && entries === lastRegisteredEntries) return;\n  const loaderUrl = `data:text/javascript,${encodeURIComponent(esmNodePathLoaderSource(dirs))}`;\n  const parentUrl = pathToFileURL(path.join(process.cwd(), '/')).href;\n  try {\n    nodeModule.register(loaderUrl, parentUrl);\n  } catch {\n    // A runtime that rejects the loader must not take the whole CLI down with it - the CommonJS\n    // half of the workaround is unaffected, and only ESM packages relying on hoisting are lost.\n    return;\n  }\n  lastRegisteredEntries = entries;\n  const registration = `import{register}from'node:module';register(${JSON.stringify(loaderUrl)},${JSON.stringify(parentUrl)});`;\n  const importFlag = `--import=data:text/javascript,${encodeURIComponent(registration)}`;\n  // children get one flag carrying the full current set: replace our previous flag rather than\n  // stacking loaders, and match our own flag exactly - a user's `--require ts-node/register`\n  // in NODE_OPTIONS must not suppress the loader's propagation\n  if (lastImportFlag && process.env.NODE_OPTIONS?.includes(lastImportFlag)) {\n    process.env.NODE_OPTIONS = process.env.NODE_OPTIONS.replace(lastImportFlag, importFlag);\n  } else if (!process.env.NODE_OPTIONS?.includes(importFlag)) {\n    process.env.NODE_OPTIONS = process.env.NODE_OPTIONS ? `${process.env.NODE_OPTIONS} ${importFlag}` : importFlag;\n  }\n  lastImportFlag = importFlag;\n}\n"],"mappings":";;;;;;;;;;;;;AAmDA,SAAAA,GAAA;EAAA,MAAAC,IAAA,GAAAC,uBAAA,CAAAC,OAAA;EAAAH,EAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,KAAA;EAAA,MAAAH,IAAA,GAAAC,uBAAA,CAAAC,OAAA;EAAAC,IAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,KAAA;EAAA,MAAAJ,IAAA,GAAAE,OAAA;EAAAE,IAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAoC,SAAAC,wBAAAI,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAN,uBAAA,YAAAA,CAAAI,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;AArDpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMkB,uBAAuB,GAAIC,IAAc,IAAK;AACpD;AACA;AACA;AACA,yBAAyBC,IAAI,CAACC,SAAS,CAACF,IAAI,CAAC;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AAED,IAAIG,qBAAyC;AAC7C,IAAIC,cAAkC;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,4BAA4BA,CAACC,eAAuB,EAAsB;EACxF,IAAI;IACF,MAAMC,MAAM,GAAGN,IAAI,CAACO,KAAK,CAACF,eAAe,CAAkC;IAC3E,OAAO,OAAOC,MAAM,CAACE,eAAe,KAAK,QAAQ,GAAGF,MAAM,CAACE,eAAe,GAAGC,SAAS;EACxF,CAAC,CAAC,MAAM;IACN;EAAA;EAEF,OAAOJ,eAAe,CAACK,KAAK,CAAC,kDAAkD,CAAC,GAAG,CAAC,CAAC;AACvF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,mBAAmBA,CAACC,KAAa,EAAEC,MAAc,EAAW;EAC1E,MAAMC,GAAG,GAAGrC,IAAI,CAAD,CAAC,CAACsC,QAAQ,CAACF,MAAM,EAAED,KAAK,CAAC;EACxC;EACA,OAAO,CAACnC,IAAI,CAAD,CAAC,CAACuC,UAAU,CAACF,GAAG,CAAC,IAAIA,GAAG,KAAK,IAAI,IAAI,CAACA,GAAG,CAACG,UAAU,CA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","ignoreList":[]}

package/dist/hoisted-resolution-bridge.spec.js

@@ -7,6 +7,27 @@ function _chai() {
   };
   return data;
 }
+function _fsExtra() {
+  const data = _interopRequireDefault(require("fs-extra"));
+  _fsExtra = function () {
+    return data;
+  };
+  return data;
+}
+function _module() {
+  const data = _interopRequireDefault(require("module"));
+  _module = function () {
+    return data;
+  };
+  return data;
+}
+function _os() {
+  const data = _interopRequireDefault(require("os"));
+  _os = function () {
+    return data;
+  };
+  return data;
+}
 function _path() {
   const data = _interopRequireDefault(require("path"));
   _path = function () {
@@ -60,5 +81,153 @@ describe('parseRecordedVirtualStoreDir()', () => {
     }))).to.eq(undefined);
   });
 });
+describe('hoistedResolutionDirs()', () => {
+  let root;
+  const hoisted = () => _path().default.join(root, 'node_modules', '.pnpm', 'node_modules');
+  const rootModules = () => _path().default.join(root, 'node_modules');
+  beforeEach(() => {
+    root = _fsExtra().default.mkdtempSync(_path().default.join(_os().default.tmpdir(), 'hoisted-resolution-dirs-'));
+  });
+  afterEach(() => _fsExtra().default.removeSync(root));
+  it('should return both directories in the order the walk reached them', () => {
+    _fsExtra().default.ensureDirSync(hoisted());
+    (0, _chai().expect)((0, _hoistedResolutionBridge().hoistedResolutionDirs)(root)).to.deep.eq([hoisted(), rootModules()]);
+  });
+  it('should keep the root node_modules when nothing was hoisted', () => {
+    _fsExtra().default.ensureDirSync(rootModules());
+    (0, _chai().expect)((0, _hoistedResolutionBridge().hoistedResolutionDirs)(root)).to.deep.eq([rootModules()]);
+  });
+  it('should return nothing for a root that was never installed', () => {
+    (0, _chai().expect)((0, _hoistedResolutionBridge().hoistedResolutionDirs)(root)).to.deep.eq([]);
+  });
+});
+describe('ensureHoistedDependencyResolution()', () => {
+  let root;
+  let nodePath;
+  let nodeOptions;
+  let register;
+  // the two process-global side effects of the function under test, neither of them scoped to a
+  // test: `_initPaths()` rederives Module.globalPaths from NODE_PATH, and `module.register()`
+  // installs an ESM loader that cannot be removed for the life of the process
+  const nodeModule = _module().default;
+  const hoisted = () => _path().default.join(root, 'node_modules', '.pnpm', 'node_modules');
+  const rootModules = () => _path().default.join(root, 'node_modules');
+  const entries = () => (process.env.NODE_PATH ?? '').split(_path().default.delimiter).filter(Boolean);
+  beforeEach(() => {
+    root = _fsExtra().default.mkdtempSync(_path().default.join(_os().default.tmpdir(), 'ensure-hoisted-resolution-'));
+    _fsExtra().default.ensureDirSync(hoisted());
+    nodePath = process.env.NODE_PATH;
+    nodeOptions = process.env.NODE_OPTIONS;
+    // these cases are about NODE_PATH order; taking `register` away keeps the ESM half - the
+    // irreversible half - out of the test process, through the same guard that carries older
+    // runtimes
+    register = nodeModule.register;
+    nodeModule.register = undefined;
+  });
+  afterEach(() => {
+    if (nodePath === undefined) delete process.env.NODE_PATH;else process.env.NODE_PATH = nodePath;
+    if (nodeOptions === undefined) delete process.env.NODE_OPTIONS;else process.env.NODE_OPTIONS = nodeOptions;
+    nodeModule.register = register;
+    // restoring the variable is not enough: the resolver reads the paths derived from it, which
+    // would otherwise still point into the directory removed on the next line
+    nodeModule._initPaths();
+    _fsExtra().default.removeSync(root);
+  });
+  it('should put both directories in walk order', () => {
+    delete process.env.NODE_PATH;
+    (0, _hoistedResolutionBridge().ensureHoistedDependencyResolution)(root);
+    (0, _chai().expect)(entries()).to.deep.eq([hoisted(), rootModules()]);
+  });
+  it('should reorder entries a previous bridge left in the wrong order', () => {
+    // a bit that bridged the hoisted directory alone leaves it in NODE_PATH for its children;
+    // adding the root's node_modules in front of it there would invert the walk
+    process.env.NODE_PATH = hoisted();
+    (0, _hoistedResolutionBridge().ensureHoistedDependencyResolution)(root);
+    (0, _chai().expect)(entries()).to.deep.eq([hoisted(), rootModules()]);
+  });
+  it('should keep entries it does not own, behind its own', () => {
+    const foreign = _path().default.join(root, 'somewhere-else');
+    process.env.NODE_PATH = [rootModules(), foreign].join(_path().default.delimiter);
+    (0, _hoistedResolutionBridge().ensureHoistedDependencyResolution)(root);
+    (0, _chai().expect)(entries()).to.deep.eq([hoisted(), rootModules(), foreign]);
+  });
+  it('should replace an entry that names an owned directory in another spelling', () => {
+    process.env.NODE_PATH = [`${rootModules()}${_path().default.sep}`, `${hoisted()}${_path().default.sep}.`].join(_path().default.delimiter);
+    (0, _hoistedResolutionBridge().ensureHoistedDependencyResolution)(root);
+    (0, _chai().expect)(entries()).to.deep.eq([hoisted(), rootModules()]);
+  });
+  it('should leave NODE_PATH untouched when it already reads correctly', () => {
+    process.env.NODE_PATH = [hoisted(), rootModules()].join(_path().default.delimiter);
+    const before = process.env.NODE_PATH;
+    (0, _hoistedResolutionBridge().ensureHoistedDependencyResolution)(root);
+    (0, _chai().expect)(process.env.NODE_PATH).to.eq(before);
+  });
+  it('should do nothing for a root that was never installed', () => {
+    const bare = _fsExtra().default.mkdtempSync(_path().default.join(_os().default.tmpdir(), 'ensure-hoisted-resolution-bare-'));
+    delete process.env.NODE_PATH;
+    try {
+      (0, _hoistedResolutionBridge().ensureHoistedDependencyResolution)(bare);
+      (0, _chai().expect)(process.env.NODE_PATH).to.eq(undefined);
+    } finally {
+      _fsExtra().default.removeSync(bare);
+    }
+  });
+});
+describe('ensureHoistedDependencyResolution() esm registration', () => {
+  let first;
+  let second;
+  let nodePath;
+  let nodeOptions;
+  let register;
+  const nodeModule = _module().default;
+  const flag = () => (process.env.NODE_OPTIONS ?? '').match(/--import=\S+/)?.[0];
+  beforeEach(() => {
+    first = _fsExtra().default.mkdtempSync(_path().default.join(_os().default.tmpdir(), 'esm-registration-first-'));
+    second = _fsExtra().default.mkdtempSync(_path().default.join(_os().default.tmpdir(), 'esm-registration-second-'));
+    [first, second].forEach(root => _fsExtra().default.ensureDirSync(_path().default.join(root, 'node_modules', '.pnpm', 'node_modules')));
+    nodePath = process.env.NODE_PATH;
+    nodeOptions = process.env.NODE_OPTIONS;
+    delete process.env.NODE_PATH;
+    delete process.env.NODE_OPTIONS;
+    register = nodeModule.register;
+    // a no-op keeps the body running - the flag is what these cases are about - without leaving a
+    // loader registered on the process
+    nodeModule.register = () => {};
+  });
+  afterEach(() => {
+    if (nodePath === undefined) delete process.env.NODE_PATH;else process.env.NODE_PATH = nodePath;
+    if (nodeOptions === undefined) delete process.env.NODE_OPTIONS;else process.env.NODE_OPTIONS = nodeOptions;
+    nodeModule.register = register;
+    nodeModule._initPaths();
+    [first, second].forEach(root => _fsExtra().default.removeSync(root));
+  });
+  it('should hand children a flag carrying the order NODE_PATH now reads', () => {
+    (0, _hoistedResolutionBridge().ensureHoistedDependencyResolution)(first);
+    (0, _hoistedResolutionBridge().ensureHoistedDependencyResolution)(second);
+    const beforeReorder = flag();
+    // bridging the first root again moves its directories back to the front, so the list the
+    // loader was registered with no longer matches the one CommonJS resolves through
+    (0, _hoistedResolutionBridge().ensureHoistedDependencyResolution)(first);
+    (0, _chai().expect)(flag()).to.not.eq(beforeReorder);
+  });
+  it('should leave the flag alone when nothing about the list changed', () => {
+    (0, _hoistedResolutionBridge().ensureHoistedDependencyResolution)(first);
+    const unchanged = flag();
+    (0, _hoistedResolutionBridge().ensureHoistedDependencyResolution)(first);
+    (0, _chai().expect)(flag()).to.eq(unchanged);
+  });
+});
+describe('isSamePath()', () => {
+  const dir = _path().default.resolve('/base', 'node_modules');
+  it('should ignore a trailing separator', () => {
+    (0, _chai().expect)((0, _hoistedResolutionBridge().isSamePath)(`${dir}${_path().default.sep}`, dir)).to.eq(true);
+  });
+  it('should ignore a redundant current-directory segment', () => {
+    (0, _chai().expect)((0, _hoistedResolutionBridge().isSamePath)(_path().default.join(dir, '.'), dir)).to.eq(true);
+  });
+  it('should separate genuinely different directories', () => {
+    (0, _chai().expect)((0, _hoistedResolutionBridge().isSamePath)(_path().default.join(dir, 'nested'), dir)).to.eq(false);
+  });
+});
 
 //# sourceMappingURL=hoisted-resolution-bridge.spec.js.map

package/dist/hoisted-resolution-bridge.spec.js.map

@@ -1 +1 @@
-{"version":3,"names":["_chai","data","require","_path","_interopRequireDefault","_hoistedResolutionBridge","e","__esModule","default","describe","base","path","resolve","it","expect","isPathInsideOrEqual","join","to","eq","dirname","manifest","JSON","stringify","hoistedDependencies","virtualStoreDir","parseRecordedVirtualStoreDir","undefined","layoutVersion"],"sources":["hoisted-resolution-bridge.spec.ts"],"sourcesContent":["import { expect } from 'chai';\nimport path from 'path';\nimport { isPathInsideOrEqual, parseRecordedVirtualStoreDir } from './hoisted-resolution-bridge';\n\ndescribe('isPathInsideOrEqual()', () => {\n  const base = path.resolve('/base');\n  it('should count a descendant as inside', () => {\n    expect(isPathInsideOrEqual(path.join(base, 'child'), base)).to.eq(true);\n  });\n  it('should count a descendant whose name starts with dots as inside', () => {\n    expect(isPathInsideOrEqual(path.join(base, '..foo', 'child'), base)).to.eq(true);\n  });\n  it('should count the parent itself as inside', () => {\n    expect(isPathInsideOrEqual(base, base)).to.eq(true);\n  });\n  it('should count an ancestor as outside', () => {\n    expect(isPathInsideOrEqual(path.dirname(base), base)).to.eq(false);\n  });\n  it('should count a sibling as outside', () => {\n    expect(isPathInsideOrEqual(path.join(path.dirname(base), 'sibling'), base)).to.eq(false);\n  });\n});\n\ndescribe('parseRecordedVirtualStoreDir()', () => {\n  it('should read the JSON manifest current pnpm writes', () => {\n    const manifest = JSON.stringify({ hoistedDependencies: {}, virtualStoreDir: '../../store/v11/links' }, null, 2);\n    expect(parseRecordedVirtualStoreDir(manifest)).to.eq('../../store/v11/links');\n  });\n  it('should read a block-YAML manifest from an older pnpm', () => {\n    expect(parseRecordedVirtualStoreDir('layoutVersion: 5\\nvirtualStoreDir: .pnpm\\n')).to.eq('.pnpm');\n  });\n  it('should not confuse virtualStoreDirMaxLength for the store dir', () => {\n    expect(parseRecordedVirtualStoreDir('virtualStoreDirMaxLength: 120\\n')).to.eq(undefined);\n  });\n  it('should return undefined when the manifest records no store dir', () => {\n    expect(parseRecordedVirtualStoreDir(JSON.stringify({ layoutVersion: 5 }))).to.eq(undefined);\n  });\n});\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_chai","data","require","_fsExtra","_interopRequireDefault","_module","_os","_path","_hoistedResolutionBridge","e","__esModule","default","describe","base","path","resolve","it","expect","isPathInsideOrEqual","join","to","eq","dirname","manifest","JSON","stringify","hoistedDependencies","virtualStoreDir","parseRecordedVirtualStoreDir","undefined","layoutVersion","root","hoisted","rootModules","beforeEach","fs","mkdtempSync","os","tmpdir","afterEach","removeSync","ensureDirSync","hoistedResolutionDirs","deep","nodePath","nodeOptions","register","nodeModule","Module","entries","process","env","NODE_PATH","split","delimiter","filter","Boolean","NODE_OPTIONS","_initPaths","ensureHoistedDependencyResolution","foreign","sep","before","bare","first","second","flag","match","forEach","beforeReorder","not","unchanged","dir","isSamePath"],"sources":["hoisted-resolution-bridge.spec.ts"],"sourcesContent":["import { expect } from 'chai';\nimport fs from 'fs-extra';\nimport Module from 'module';\nimport os from 'os';\nimport path from 'path';\nimport {\n  ensureHoistedDependencyResolution,\n  hoistedResolutionDirs,\n  isPathInsideOrEqual,\n  isSamePath,\n  parseRecordedVirtualStoreDir,\n} from './hoisted-resolution-bridge';\n\ndescribe('isPathInsideOrEqual()', () => {\n  const base = path.resolve('/base');\n  it('should count a descendant as inside', () => {\n    expect(isPathInsideOrEqual(path.join(base, 'child'), base)).to.eq(true);\n  });\n  it('should count a descendant whose name starts with dots as inside', () => {\n    expect(isPathInsideOrEqual(path.join(base, '..foo', 'child'), base)).to.eq(true);\n  });\n  it('should count the parent itself as inside', () => {\n    expect(isPathInsideOrEqual(base, base)).to.eq(true);\n  });\n  it('should count an ancestor as outside', () => {\n    expect(isPathInsideOrEqual(path.dirname(base), base)).to.eq(false);\n  });\n  it('should count a sibling as outside', () => {\n    expect(isPathInsideOrEqual(path.join(path.dirname(base), 'sibling'), base)).to.eq(false);\n  });\n});\n\ndescribe('parseRecordedVirtualStoreDir()', () => {\n  it('should read the JSON manifest current pnpm writes', () => {\n    const manifest = JSON.stringify({ hoistedDependencies: {}, virtualStoreDir: '../../store/v11/links' }, null, 2);\n    expect(parseRecordedVirtualStoreDir(manifest)).to.eq('../../store/v11/links');\n  });\n  it('should read a block-YAML manifest from an older pnpm', () => {\n    expect(parseRecordedVirtualStoreDir('layoutVersion: 5\\nvirtualStoreDir: .pnpm\\n')).to.eq('.pnpm');\n  });\n  it('should not confuse virtualStoreDirMaxLength for the store dir', () => {\n    expect(parseRecordedVirtualStoreDir('virtualStoreDirMaxLength: 120\\n')).to.eq(undefined);\n  });\n  it('should return undefined when the manifest records no store dir', () => {\n    expect(parseRecordedVirtualStoreDir(JSON.stringify({ layoutVersion: 5 }))).to.eq(undefined);\n  });\n});\n\ndescribe('hoistedResolutionDirs()', () => {\n  let root: string;\n  const hoisted = () => path.join(root, 'node_modules', '.pnpm', 'node_modules');\n  const rootModules = () => path.join(root, 'node_modules');\n\n  beforeEach(() => {\n    root = fs.mkdtempSync(path.join(os.tmpdir(), 'hoisted-resolution-dirs-'));\n  });\n  afterEach(() => fs.removeSync(root));\n\n  it('should return both directories in the order the walk reached them', () => {\n    fs.ensureDirSync(hoisted());\n    expect(hoistedResolutionDirs(root)).to.deep.eq([hoisted(), rootModules()]);\n  });\n  it('should keep the root node_modules when nothing was hoisted', () => {\n    fs.ensureDirSync(rootModules());\n    expect(hoistedResolutionDirs(root)).to.deep.eq([rootModules()]);\n  });\n  it('should return nothing for a root that was never installed', () => {\n    expect(hoistedResolutionDirs(root)).to.deep.eq([]);\n  });\n});\n\ndescribe('ensureHoistedDependencyResolution()', () => {\n  let root: string;\n  let nodePath: string | undefined;\n  let nodeOptions: string | undefined;\n  let register: unknown;\n  // the two process-global side effects of the function under test, neither of them scoped to a\n  // test: `_initPaths()` rederives Module.globalPaths from NODE_PATH, and `module.register()`\n  // installs an ESM loader that cannot be removed for the life of the process\n  const nodeModule = Module as unknown as { register?: unknown; _initPaths(): void };\n  const hoisted = () => path.join(root, 'node_modules', '.pnpm', 'node_modules');\n  const rootModules = () => path.join(root, 'node_modules');\n  const entries = () => (process.env.NODE_PATH ?? '').split(path.delimiter).filter(Boolean);\n\n  beforeEach(() => {\n    root = fs.mkdtempSync(path.join(os.tmpdir(), 'ensure-hoisted-resolution-'));\n    fs.ensureDirSync(hoisted());\n    nodePath = process.env.NODE_PATH;\n    nodeOptions = process.env.NODE_OPTIONS;\n    // these cases are about NODE_PATH order; taking `register` away keeps the ESM half - the\n    // irreversible half - out of the test process, through the same guard that carries older\n    // runtimes\n    register = nodeModule.register;\n    nodeModule.register = undefined;\n  });\n  afterEach(() => {\n    if (nodePath === undefined) delete process.env.NODE_PATH;\n    else process.env.NODE_PATH = nodePath;\n    if (nodeOptions === undefined) delete process.env.NODE_OPTIONS;\n    else process.env.NODE_OPTIONS = nodeOptions;\n    nodeModule.register = register;\n    // restoring the variable is not enough: the resolver reads the paths derived from it, which\n    // would otherwise still point into the directory removed on the next line\n    nodeModule._initPaths();\n    fs.removeSync(root);\n  });\n\n  it('should put both directories in walk order', () => {\n    delete process.env.NODE_PATH;\n    ensureHoistedDependencyResolution(root);\n    expect(entries()).to.deep.eq([hoisted(), rootModules()]);\n  });\n\n  it('should reorder entries a previous bridge left in the wrong order', () => {\n    // a bit that bridged the hoisted directory alone leaves it in NODE_PATH for its children;\n    // adding the root's node_modules in front of it there would invert the walk\n    process.env.NODE_PATH = hoisted();\n    ensureHoistedDependencyResolution(root);\n    expect(entries()).to.deep.eq([hoisted(), rootModules()]);\n  });\n\n  it('should keep entries it does not own, behind its own', () => {\n    const foreign = path.join(root, 'somewhere-else');\n    process.env.NODE_PATH = [rootModules(), foreign].join(path.delimiter);\n    ensureHoistedDependencyResolution(root);\n    expect(entries()).to.deep.eq([hoisted(), rootModules(), foreign]);\n  });\n\n  it('should replace an entry that names an owned directory in another spelling', () => {\n    process.env.NODE_PATH = [`${rootModules()}${path.sep}`, `${hoisted()}${path.sep}.`].join(path.delimiter);\n    ensureHoistedDependencyResolution(root);\n    expect(entries()).to.deep.eq([hoisted(), rootModules()]);\n  });\n\n  it('should leave NODE_PATH untouched when it already reads correctly', () => {\n    process.env.NODE_PATH = [hoisted(), rootModules()].join(path.delimiter);\n    const before = process.env.NODE_PATH;\n    ensureHoistedDependencyResolution(root);\n    expect(process.env.NODE_PATH).to.eq(before);\n  });\n\n  it('should do nothing for a root that was never installed', () => {\n    const bare = fs.mkdtempSync(path.join(os.tmpdir(), 'ensure-hoisted-resolution-bare-'));\n    delete process.env.NODE_PATH;\n    try {\n      ensureHoistedDependencyResolution(bare);\n      expect(process.env.NODE_PATH).to.eq(undefined);\n    } finally {\n      fs.removeSync(bare);\n    }\n  });\n});\n\ndescribe('ensureHoistedDependencyResolution() esm registration', () => {\n  let first: string;\n  let second: string;\n  let nodePath: string | undefined;\n  let nodeOptions: string | undefined;\n  let register: unknown;\n  const nodeModule = Module as unknown as { register?: unknown; _initPaths(): void };\n  const flag = () => (process.env.NODE_OPTIONS ?? '').match(/--import=\\S+/)?.[0];\n\n  beforeEach(() => {\n    first = fs.mkdtempSync(path.join(os.tmpdir(), 'esm-registration-first-'));\n    second = fs.mkdtempSync(path.join(os.tmpdir(), 'esm-registration-second-'));\n    [first, second].forEach((root) => fs.ensureDirSync(path.join(root, 'node_modules', '.pnpm', 'node_modules')));\n    nodePath = process.env.NODE_PATH;\n    nodeOptions = process.env.NODE_OPTIONS;\n    delete process.env.NODE_PATH;\n    delete process.env.NODE_OPTIONS;\n    register = nodeModule.register;\n    // a no-op keeps the body running - the flag is what these cases are about - without leaving a\n    // loader registered on the process\n    nodeModule.register = () => {};\n  });\n  afterEach(() => {\n    if (nodePath === undefined) delete process.env.NODE_PATH;\n    else process.env.NODE_PATH = nodePath;\n    if (nodeOptions === undefined) delete process.env.NODE_OPTIONS;\n    else process.env.NODE_OPTIONS = nodeOptions;\n    nodeModule.register = register;\n    nodeModule._initPaths();\n    [first, second].forEach((root) => fs.removeSync(root));\n  });\n\n  it('should hand children a flag carrying the order NODE_PATH now reads', () => {\n    ensureHoistedDependencyResolution(first);\n    ensureHoistedDependencyResolution(second);\n    const beforeReorder = flag();\n    // bridging the first root again moves its directories back to the front, so the list the\n    // loader was registered with no longer matches the one CommonJS resolves through\n    ensureHoistedDependencyResolution(first);\n    expect(flag()).to.not.eq(beforeReorder);\n  });\n\n  it('should leave the flag alone when nothing about the list changed', () => {\n    ensureHoistedDependencyResolution(first);\n    const unchanged = flag();\n    ensureHoistedDependencyResolution(first);\n    expect(flag()).to.eq(unchanged);\n  });\n});\n\ndescribe('isSamePath()', () => {\n  const dir = path.resolve('/base', 'node_modules');\n  it('should ignore a trailing separator', () => {\n    expect(isSamePath(`${dir}${path.sep}`, dir)).to.eq(true);\n  });\n  it('should ignore a redundant current-directory segment', () => {\n    expect(isSamePath(path.join(dir, '.'), dir)).to.eq(true);\n  });\n  it('should separate genuinely different directories', () => {\n    expect(isSamePath(path.join(dir, 'nested'), dir)).to.eq(false);\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/index.d.ts

@@ -22,5 +22,5 @@ export { extendWithComponentsFromDir } from './extend-with-components-from-dir';
 export { isRange } from './manifest/deduping/hoist-dependencies';
 export type { DependencyEnv } from './dependency-env';
 export { DetectorHook, DependencyDetector, FileContext } from './detector-hook';
-export { ensureHoistedDependencyResolution, ensureSelfInstallationBridge, isGlobalVirtualStoreLayout } from './hoisted-resolution-bridge';
+export { ensureHoistedDependencyResolution, ensureSelfInstallationBridge, hoistedResolutionDirs, isGlobalVirtualStoreLayout, selfInstallationRoot, } from './hoisted-resolution-bridge';
 export { DependencyResolverAspect as default, DependencyResolverAspect };

package/dist/index.js

@@ -141,6 +141,12 @@ Object.defineProperty(exports, "extendWithComponentsFromDir", {
     return _extendWithComponentsFromDir().extendWithComponentsFromDir;
   }
 });
+Object.defineProperty(exports, "hoistedResolutionDirs", {
+  enumerable: true,
+  get: function () {
+    return _hoistedResolutionBridge().hoistedResolutionDirs;
+  }
+});
 Object.defineProperty(exports, "isGlobalVirtualStoreLayout", {
   enumerable: true,
   get: function () {
@@ -153,6 +159,12 @@ Object.defineProperty(exports, "isRange", {
     return _hoistDependencies().isRange;
   }
 });
+Object.defineProperty(exports, "selfInstallationRoot", {
+  enumerable: true,
+  get: function () {
+    return _hoistedResolutionBridge().selfInstallationRoot;
+  }
+});
 function _dependencyResolver() {
   const data = require("./dependency-resolver.aspect");
   _dependencyResolver = function () {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_dependencyResolver","data","require","_manifest","_dependencyResolverMain","_dependencies","_policy","_dependencyLinker","_dependencyInstaller","_extendWithComponentsFromDir","_hoistDependencies","_detectorHook","_hoistedResolutionBridge"],"sources":["index.ts"],"sourcesContent":["import { DependencyResolverAspect } from './dependency-resolver.aspect';\n\nexport type { UpdatedComponent } from './apply-updates';\nexport type { RawComponentState, ComponentsManifestsMap, RegistriesMap } from './types';\nexport { WorkspaceManifest, ComponentManifest } from './manifest';\nexport type { CreateFromComponentsOptions, ManifestDependenciesObject } from './manifest';\nexport type {\n  InstallationContext,\n  PackageImportMethod,\n  PackageExtension,\n  PackageManager,\n  PackageManagerInstallOptions,\n  PackageManagerResolveRemoteVersionOptions,\n  ResolvedPackageVersion,\n  CalcDepsGraphOptions,\n  CalcDepsGraphForComponentOptions,\n  ComponentIdByPkgName,\n} from './package-manager';\nexport type {\n  DependencyResolverWorkspaceConfig,\n  NodeLinker,\n  ComponentRangePrefix,\n} from './dependency-resolver-workspace-config';\nexport type {\n  DependencyResolverMain,\n  DependencyResolverVariantConfig,\n  MergedOutdatedPkg,\n} from './dependency-resolver.main.runtime';\nexport { NPM_REGISTRY, BIT_CLOUD_REGISTRY } from './dependency-resolver.main.runtime';\nexport type {\n  ProxyConfig as PackageManagerProxyConfig,\n  NetworkConfig as PackageManagerNetworkConfig,\n} from './dependency-resolver.main.runtime';\nexport {\n  DependencyList,\n  BaseDependency,\n  ComponentDependency,\n  KEY_NAME_BY_LIFECYCLE_TYPE,\n  COMPONENT_DEP_TYPE,\n} from './dependencies';\nexport type {\n  DependencyLifecycleType,\n  WorkspaceDependencyLifecycleType,\n  DependencyFactory,\n  SerializedDependency,\n  Dependency,\n  SemverVersion,\n  DependenciesManifest,\n} from './dependencies';\nexport { WorkspacePolicy, VariantPolicy, EnvPolicy, EnvPolicyEnvJsoncConfigObject } from './policy';\nexport type {\n  WorkspacePolicyEntry,\n  WorkspacePolicyConfigObject,\n  VariantPolicyConfigObject,\n  Policy,\n  PolicySemver,\n  PolicyConfigKeys,\n  PolicyConfigKeysNames,\n  PolicyEntry,\n  SerializedVariantPolicy,\n  WorkspacePolicyConfigKeysNames,\n  EnvPolicyConfigObject,\n  VariantPolicyConfigArr,\n} from './policy';\nexport { DependencyLinker } from './dependency-linker';\nexport type {\n  CoreAspectLinkResult,\n  LinkDetail,\n  LinkResults,\n  LinkingOptions,\n  DepsLinkedToEnvResult,\n  NestedNMDepsLinksResult,\n  LinkToDirResult,\n} from './dependency-linker';\nexport { DependencyInstaller } from './dependency-installer';\nexport type { GetComponentManifestsOptions, InstallOptions, InstallArgs } from './dependency-installer';\nexport type { DependencySource, VariantPolicyEntry } from './policy/variant-policy/variant-policy';\nexport type { OutdatedPkg, CurrentPkg } from './get-all-policy-pkgs';\nexport { extendWithComponentsFromDir } from './extend-with-components-from-dir';\nexport { isRange } from './manifest/deduping/hoist-dependencies';\nexport type { DependencyEnv } from './dependency-env';\nexport { DetectorHook, DependencyDetector, FileContext } from './detector-hook';\nexport { ensureHoistedDependencyResolution, ensureSelfInstallationBridge, isGlobalVirtualStoreLayout } from './hoisted-resolution-bridge';\nexport { DependencyResolverAspect as default, DependencyResolverAspect };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAAA,oBAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,mBAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAIA,SAAAE,UAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,SAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAwBA,SAAAG,wBAAA;EAAA,MAAAH,IAAA,GAAAC,OAAA;EAAAE,uBAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAKA,SAAAI,cAAA;EAAA,MAAAJ,IAAA,GAAAC,OAAA;EAAAG,aAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAgBA,SAAAK,QAAA;EAAA,MAAAL,IAAA,GAAAC,OAAA;EAAAI,OAAA,YAAAA,CAAA;IAAA,OAAAL,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAeA,SAAAM,kBAAA;EAAA,MAAAN,IAAA,GAAAC,OAAA;EAAAK,iBAAA,YAAAA,CAAA;IAAA,OAAAN,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAUA,SAAAO,qBAAA;EAAA,MAAAP,IAAA,GAAAC,OAAA;EAAAM,oBAAA,YAAAA,CAAA;IAAA,OAAAP,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAIA,SAAAQ,6BAAA;EAAA,MAAAR,IAAA,GAAAC,OAAA;EAAAO,4BAAA,YAAAA,CAAA;IAAA,OAAAR,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAS,mBAAA;EAAA,MAAAT,IAAA,GAAAC,OAAA;EAAAQ,kBAAA,YAAAA,CAAA;IAAA,OAAAT,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAU,cAAA;EAAA,MAAAV,IAAA,GAAAC,OAAA;EAAAS,aAAA,YAAAA,CAAA;IAAA,OAAAV,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAW,yBAAA;EAAA,MAAAX,IAAA,GAAAC,OAAA;EAAAU,wBAAA,YAAAA,CAAA;IAAA,OAAAX,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA","ignoreList":[]}
+{"version":3,"names":["_dependencyResolver","data","require","_manifest","_dependencyResolverMain","_dependencies","_policy","_dependencyLinker","_dependencyInstaller","_extendWithComponentsFromDir","_hoistDependencies","_detectorHook","_hoistedResolutionBridge"],"sources":["index.ts"],"sourcesContent":["import { DependencyResolverAspect } from './dependency-resolver.aspect';\n\nexport type { UpdatedComponent } from './apply-updates';\nexport type { RawComponentState, ComponentsManifestsMap, RegistriesMap } from './types';\nexport { WorkspaceManifest, ComponentManifest } from './manifest';\nexport type { CreateFromComponentsOptions, ManifestDependenciesObject } from './manifest';\nexport type {\n  InstallationContext,\n  PackageImportMethod,\n  PackageExtension,\n  PackageManager,\n  PackageManagerInstallOptions,\n  PackageManagerResolveRemoteVersionOptions,\n  ResolvedPackageVersion,\n  CalcDepsGraphOptions,\n  CalcDepsGraphForComponentOptions,\n  ComponentIdByPkgName,\n} from './package-manager';\nexport type {\n  DependencyResolverWorkspaceConfig,\n  NodeLinker,\n  ComponentRangePrefix,\n} from './dependency-resolver-workspace-config';\nexport type {\n  DependencyResolverMain,\n  DependencyResolverVariantConfig,\n  MergedOutdatedPkg,\n} from './dependency-resolver.main.runtime';\nexport { NPM_REGISTRY, BIT_CLOUD_REGISTRY } from './dependency-resolver.main.runtime';\nexport type {\n  ProxyConfig as PackageManagerProxyConfig,\n  NetworkConfig as PackageManagerNetworkConfig,\n} from './dependency-resolver.main.runtime';\nexport {\n  DependencyList,\n  BaseDependency,\n  ComponentDependency,\n  KEY_NAME_BY_LIFECYCLE_TYPE,\n  COMPONENT_DEP_TYPE,\n} from './dependencies';\nexport type {\n  DependencyLifecycleType,\n  WorkspaceDependencyLifecycleType,\n  DependencyFactory,\n  SerializedDependency,\n  Dependency,\n  SemverVersion,\n  DependenciesManifest,\n} from './dependencies';\nexport { WorkspacePolicy, VariantPolicy, EnvPolicy, EnvPolicyEnvJsoncConfigObject } from './policy';\nexport type {\n  WorkspacePolicyEntry,\n  WorkspacePolicyConfigObject,\n  VariantPolicyConfigObject,\n  Policy,\n  PolicySemver,\n  PolicyConfigKeys,\n  PolicyConfigKeysNames,\n  PolicyEntry,\n  SerializedVariantPolicy,\n  WorkspacePolicyConfigKeysNames,\n  EnvPolicyConfigObject,\n  VariantPolicyConfigArr,\n} from './policy';\nexport { DependencyLinker } from './dependency-linker';\nexport type {\n  CoreAspectLinkResult,\n  LinkDetail,\n  LinkResults,\n  LinkingOptions,\n  DepsLinkedToEnvResult,\n  NestedNMDepsLinksResult,\n  LinkToDirResult,\n} from './dependency-linker';\nexport { DependencyInstaller } from './dependency-installer';\nexport type { GetComponentManifestsOptions, InstallOptions, InstallArgs } from './dependency-installer';\nexport type { DependencySource, VariantPolicyEntry } from './policy/variant-policy/variant-policy';\nexport type { OutdatedPkg, CurrentPkg } from './get-all-policy-pkgs';\nexport { extendWithComponentsFromDir } from './extend-with-components-from-dir';\nexport { isRange } from './manifest/deduping/hoist-dependencies';\nexport type { DependencyEnv } from './dependency-env';\nexport { DetectorHook, DependencyDetector, FileContext } from './detector-hook';\nexport {\n  ensureHoistedDependencyResolution,\n  ensureSelfInstallationBridge,\n  hoistedResolutionDirs,\n  isGlobalVirtualStoreLayout,\n  selfInstallationRoot,\n} from './hoisted-resolution-bridge';\nexport { DependencyResolverAspect as default, DependencyResolverAspect };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,SAAAA,oBAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,mBAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAIA,SAAAE,UAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,SAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAwBA,SAAAG,wBAAA;EAAA,MAAAH,IAAA,GAAAC,OAAA;EAAAE,uBAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAKA,SAAAI,cAAA;EAAA,MAAAJ,IAAA,GAAAC,OAAA;EAAAG,aAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAgBA,SAAAK,QAAA;EAAA,MAAAL,IAAA,GAAAC,OAAA;EAAAI,OAAA,YAAAA,CAAA;IAAA,OAAAL,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAeA,SAAAM,kBAAA;EAAA,MAAAN,IAAA,GAAAC,OAAA;EAAAK,iBAAA,YAAAA,CAAA;IAAA,OAAAN,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAUA,SAAAO,qBAAA;EAAA,MAAAP,IAAA,GAAAC,OAAA;EAAAM,oBAAA,YAAAA,CAAA;IAAA,OAAAP,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAIA,SAAAQ,6BAAA;EAAA,MAAAR,IAAA,GAAAC,OAAA;EAAAO,4BAAA,YAAAA,CAAA;IAAA,OAAAR,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAS,mBAAA;EAAA,MAAAT,IAAA,GAAAC,OAAA;EAAAQ,kBAAA,YAAAA,CAAA;IAAA,OAAAT,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEA,SAAAU,cAAA;EAAA,MAAAV,IAAA,GAAAC,OAAA;EAAAS,aAAA,YAAAA,CAAA;IAAA,OAAAV,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAW,yBAAA;EAAA,MAAAX,IAAA,GAAAC,OAAA;EAAAU,wBAAA,YAAAA,CAAA;IAAA,OAAAX,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA","ignoreList":[]}

package/dist/{preview-1786219819000.js → preview-1786365057144.js}

@@ -1,5 +1,5 @@
-import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.dependencies_dependency-resolver@1.0.1097/dist/dependency-resolver.composition.js';
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.dependencies_dependency-resolver@1.0.1097/dist/dependency-resolver.docs.mdx';
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.dependencies_dependency-resolver@1.0.1098/dist/dependency-resolver.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad/teambit.dependencies_dependency-resolver@1.0.1098/dist/dependency-resolver.docs.mdx';
 
 export const compositions = [compositions_0];
 export const overview = [overview_0];

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@teambit/dependency-resolver",
-  "version": "1.0.1097",
+  "version": "1.0.1098",
   "homepage": "https://bit.cloud/teambit/dependencies/dependency-resolver",
   "main": "dist/index.js",
   "componentId": {
     "scope": "teambit.dependencies",
     "name": "dependency-resolver",
-    "version": "1.0.1097"
+    "version": "1.0.1098"
   },
   "dependencies": {
     "chalk": "4.1.2",
@@ -25,42 +25,42 @@
     "@pnpm/napi": "12.0.0-rc.1",
     "semver-intersect": "1.4.0",
     "semver-range-intersect": "0.3.1",
+    "@teambit/logger": "0.0.1457",
     "@teambit/toolbox.path.path": "0.0.21",
     "@teambit/bit-error": "0.0.404",
     "@teambit/bvm.path": "1.0.0",
+    "@teambit/dependencies.fs.linked-dependencies": "0.0.71",
+    "@teambit/pkg.modules.component-package-name": "0.0.152",
     "@teambit/harmony": "0.4.12",
     "@pnpm/network.ca-file": "3.0.3",
     "@teambit/bit.get-bit-version": "0.0.26",
+    "@teambit/cli": "0.0.1364",
     "@teambit/component-id": "1.2.4",
     "@teambit/component-version": "1.0.4",
-    "@teambit/harmony.modules.requireable-component": "0.0.524",
-    "@teambit/pkg.entities.registry": "0.0.4",
-    "@teambit/pkg.modules.semver-helper": "0.0.33",
-    "@teambit/workspace.root-components": "1.0.1",
-    "@teambit/component-issues": "0.0.183",
-    "@teambit/component-package-version": "0.0.460",
-    "@teambit/legacy-bit-id": "1.1.3",
-    "@teambit/toolbox.crypto.sha1": "0.0.20",
-    "@teambit/toolbox.object.sorter": "0.0.2",
-    "@teambit/component": "1.0.1097",
-    "@teambit/envs": "1.0.1097",
-    "@teambit/aspect-loader": "1.0.1097",
-    "@teambit/logger": "0.0.1457",
-    "@teambit/objects": "0.0.604",
-    "@teambit/dependencies.fs.linked-dependencies": "0.0.71",
-    "@teambit/pkg.modules.component-package-name": "0.0.152",
-    "@teambit/graphql": "1.0.1097",
-    "@teambit/cli": "0.0.1364",
     "@teambit/component.sources": "0.0.197",
     "@teambit/config-store": "0.0.245",
     "@teambit/config": "0.0.1539",
     "@teambit/harmony.modules.feature-toggle": "0.0.53",
+    "@teambit/harmony.modules.requireable-component": "0.0.524",
     "@teambit/legacy.constants": "0.0.41",
     "@teambit/legacy.consumer-component": "0.0.146",
     "@teambit/legacy.extension-data": "0.0.147",
+    "@teambit/pkg.entities.registry": "0.0.4",
+    "@teambit/pkg.modules.semver-helper": "0.0.33",
     "@teambit/scope.network": "0.0.145",
     "@teambit/workspace.modules.node-modules-linker": "0.0.376",
-    "@teambit/legacy.consumer-config": "0.0.145"
+    "@teambit/workspace.root-components": "1.0.1",
+    "@teambit/component-issues": "0.0.183",
+    "@teambit/component-package-version": "0.0.460",
+    "@teambit/legacy-bit-id": "1.1.3",
+    "@teambit/legacy.consumer-config": "0.0.145",
+    "@teambit/toolbox.crypto.sha1": "0.0.20",
+    "@teambit/toolbox.object.sorter": "0.0.2",
+    "@teambit/component": "1.0.1098",
+    "@teambit/envs": "1.0.1098",
+    "@teambit/aspect-loader": "1.0.1098",
+    "@teambit/objects": "0.0.605",
+    "@teambit/graphql": "1.0.1098"
   },
   "devDependencies": {
     "@types/fs-extra": "9.0.7",
@@ -68,8 +68,8 @@
     "sinon": "17.0.1",
     "@types/semver": "7.5.8",
     "@types/mocha": "9.1.0",
-    "@teambit/harmony.envs.core-aspect-env": "2.0.6",
-    "@teambit/dependencies.aspect-docs.dependency-resolver": "0.0.191"
+    "@teambit/dependencies.aspect-docs.dependency-resolver": "0.0.191",
+    "@teambit/harmony.envs.core-aspect-env": "2.0.6"
   },
   "peerDependencies": {
     "react": "^17.0.0 || ^18.0.0 || ^19.0.0",