@yanglaofish/fishtools 0.5.2 → 0.6.0

package/node_modules/@npmcli/agent/lib/agents.js

@@ -161,16 +161,6 @@ module.exports = class Agent extends AgentBase {
     return socket
   }
 
-  keepSocketAlive (socket) {
-    const keepAlive = super.keepSocketAlive(socket)
-
-    if (keepAlive && this.#timeouts.idle) {
-      socket.setTimeout(this.#timeouts.idle)
-    }
-
-    return keepAlive
-  }
-
   addRequest (request, options) {
     const proxy = this.#getProxy(options)
     // it would be better to call proxy.addRequest here but this causes the

package/node_modules/@npmcli/agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@npmcli/agent",
-  "version": "5.0.2",
+  "version": "4.0.2",
   "description": "the http/https agent used by the npm cli",
   "main": "lib/index.js",
   "scripts": {
@@ -25,26 +25,27 @@
     "lib/"
   ],
   "engines": {
-    "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
+    "node": "^20.17.0 || >=22.9.0"
   },
   "templateOSS": {
     "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
-    "version": "5.1.1",
+    "version": "4.30.0",
     "publish": "true",
-    "updateNpm": false
+    "updateNpm": false,
+    "latestCiVersion": 24
   },
   "dependencies": {
-    "agent-base": "^9.0.0",
-    "http-proxy-agent": "^9.0.0",
-    "https-proxy-agent": "^9.0.0",
+    "agent-base": "^7.1.0",
+    "http-proxy-agent": "^7.0.0",
+    "https-proxy-agent": "^7.0.1",
     "lru-cache": "^11.2.1",
-    "socks-proxy-agent": "^10.0.0"
+    "socks-proxy-agent": "^8.0.3"
   },
   "devDependencies": {
-    "@npmcli/eslint-config": "^7.0.0",
-    "@npmcli/template-oss": "5.1.1",
+    "@npmcli/eslint-config": "^6.0.0",
+    "@npmcli/template-oss": "4.30.0",
     "ip-address": "^10.1.0",
-    "minipass-fetch": "^6.0.0",
+    "minipass-fetch": "^5.0.0",
     "nock": "^14.0.3",
     "tap": "^16.3.0"
   },

package/node_modules/@npmcli/arborist/README.md

@@ -60,7 +60,7 @@ arb.loadActual().then(tree => {
   // tree is also stored at arb.virtualTree
 })
 
-// read just what the package-lock.json says
+// read just what the package-lock.json/npm-shrinkwrap says
 // This *also* loads the yarn.lock file, but that's only relevant
 // when building the ideal tree.
 arb.loadVirtual().then(tree => {
@@ -301,7 +301,7 @@ pruning nodes from the tree.
   that the dep is brought in by a peer dep at some point, rather than a
   normal non-peer dependency.
 
-Note: `devOptional` is only set in the package-lock file if
+Note: `devOptional` is only set in the shrinkwrap/package-lock file if
 _neither_ `dev` nor `optional` are set, as it would be redundant.
 
 ## BIN

package/node_modules/@npmcli/arborist/bin/index.js

@@ -20,7 +20,8 @@ ${message && '\n' + message + '\n'}
   * prune: prune the ideal tree and reify (like npm prune)
   * ideal: generate and print the ideal tree
   * actual: read and print the actual tree in node_modules
-  * virtual: read and print the virtual tree in the local package-lock.json
+  * virtual: read and print the virtual tree in the local shrinkwrap file
+  * shrinkwrap: load a local shrinkwrap and print its data
   * audit: perform a security audit on project dependencies
   * funding: query funding information in the local package tree.  A second
     positional argument after the path name can limit to a package name.

package/node_modules/@npmcli/arborist/bin/shrinkwrap.js

@@ -0,0 +1,7 @@
+const Shrinkwrap = require('../lib/shrinkwrap.js')
+
+module.exports = (options, time) => Shrinkwrap
+  .load(options)
+  .then((s) => s.commit())
+  .then(time)
+  .then(({ result: s }) => JSON.stringify(s, 0, 2))

package/node_modules/@npmcli/arborist/lib/arborist/build-ideal-tree.js

@@ -25,10 +25,6 @@ const debug = require('../debug.js')
 const fromPath = require('../from-path.js')
 const calcDepFlags = require('../calc-dep-flags.js')
 const { isReleaseAgeExcluded, trustedSpecName } = require('../release-age-exclude.js')
-const { resolvePatchedDependencies } = require('../patched-dependencies.js')
-const PackageExtensions = require('../package-extensions.js')
-const NpmExtension = require('../npm-extension.js')
-const { hasExtensionFile } = require('../npm-extension.js')
 const Shrinkwrap = require('../shrinkwrap.js')
 const { defaultLockfileVersion } = Shrinkwrap
 const Node = require('../node.js')
@@ -101,8 +97,6 @@ module.exports = cls => class IdealTreeBuilder extends cls {
   #loadFailures = new Set()
   #manifests = new Map()
   #mutateTree = false
-  #packageExtensions = null
-  #npmExtension = null
   #requestedTreeMutation = false
   // a map of each module in a peer set to the thing that depended on
   // that set of peers in the first place.  Use a WeakMap so that we
@@ -181,21 +175,12 @@ module.exports = cls => class IdealTreeBuilder extends cls {
 
     try {
       await this.#initTree()
-      await this.#loadNpmExtension()
-      this.#loadPackageExtensions()
       await this.#inflateAncientLockfile()
       await this.#applyUserRequests(options)
       await this.#buildDeps()
       await this.#fixDepFlags()
       await this.#pruneFailedOptional()
       await this.#checkEngineAndPlatform()
-      await resolvePatchedDependencies(this.idealTree, {
-        path: this.path,
-        allowUnusedPatches: this.options.allowUnusedPatches,
-        rm: options.rm || [],
-      })
-      this.#warnWorkspacePackageExtensions()
-      this.#warnWorkspaceNpmExtension()
     } finally {
       timeEnd()
       this.finishTracker('idealTree')
@@ -243,131 +228,6 @@ module.exports = cls => class IdealTreeBuilder extends cls {
     }
   }
 
-  // Load the root project's packageExtensions rule set.
-  // Only the workspace root is authoritative, matching the root-only model of overrides.
-  // The canonical hash is stashed on the lockfile meta so commit() can persist it.
-  #loadPackageExtensions () {
-    const rootPkg = this.idealTree.target.package
-    const lockedHash = this.idealTree.meta.packageExtensionsHash
-    this.#packageExtensions = new PackageExtensions(rootPkg.packageExtensions)
-    this.idealTree.meta.packageExtensionsHash = this.#packageExtensions.hash
-
-    // When the rule set has changed since the lockfile was written, the locked manifests for affected packages are stale.
-    // The locked manifest is the effective, already-extended manifest, so detach those nodes and rebuild them from fresh manifests under the current rules.
-    if (this.idealTree.meta.loadedFromDisk && lockedHash !== this.#packageExtensions.hash) {
-      for (const node of [...this.idealTree.inventory.values()]) {
-        if (node.isProjectRoot || node.isWorkspace || node.isTop) {
-          continue
-        }
-        // a node is affected if it carries provenance from the old rules or matches a current selector
-        const affected = node.packageExtensionsApplied ||
-          this.#packageExtensions.wouldMatch(node.packageName, node.version)
-        if (affected) {
-          for (const edge of node.edgesIn) {
-            this.#depsQueue.push(edge.from)
-          }
-          node.parent = null
-        }
-      }
-    }
-  }
-
-  // Apply a matching root packageExtension to a copy of a candidate manifest.
-  // Returns the possibly-extended manifest and the provenance to attach to the node.
-  // Workspace candidates are never extended; that warning is emitted separately.
-  #applyPackageExtension (pkg) {
-    if (!this.#packageExtensions?.present) {
-      return { pkg, applied: null }
-    }
-    const res = this.#packageExtensions.apply(pkg)
-    return res ? { pkg: res.pkg, applied: res.applied } : { pkg, applied: null }
-  }
-
-  // Load the root project's .npm-extension file and its transformManifest export.
-  // ignore-extension (and, via flatten, ignore-scripts) disables discovery and execution; the lockfile then carries no extension state.
-  // The selected file's hash is stashed on the lockfile meta so commit() can persist it and npm ci can detect stale extension state.
-  async #loadNpmExtension () {
-    const lockedHash = this.idealTree.meta.npmExtensionHash
-    // ignore-extension (and, via flatten, ignore-scripts) disables discovery and execution.
-    // Leave any locked extension state untouched so npm ci reifies the locked graph as-is and the lockfile stays internally consistent.
-    if (this.options.ignoreExtension) {
-      return
-    }
-    const ext = new NpmExtension({
-      root: this.idealTree.realpath,
-      extensionFile: this.options.extensionFile,
-    })
-    this.#npmExtension = ext
-    this.idealTree.meta.npmExtensionHash = ext.hash
-    if (ext.present) {
-      await ext.load()
-    }
-
-    // When the extension file changed since the lockfile was written, locked manifests may no longer reflect its output.
-    // This also covers removal: a now-absent file hashes to null, which differs from the locked hash and reverts the previously transformed nodes.
-    // Arbitrary code has no selector to predict which packages it affects, so re-resolve any node that carried old provenance or that the current file now transforms.
-    if (this.idealTree.meta.loadedFromDisk && lockedHash !== ext.hash) {
-      for (const node of [...this.idealTree.inventory.values()]) {
-        if (node.isProjectRoot || node.isWorkspace || node.isTop || node.isLink) {
-          continue
-        }
-        // A node with old provenance carries an already-transformed manifest, so always refetch it.
-        // Otherwise probe the locked manifest (without caching, so the authoritative full-manifest fetch is not pre-seeded).
-        // The locked manifest carries every resolution-relevant field (name, version, dependencies, peer metadata); a transform that newly targets a node by a field not persisted in the lockfile is the documented edge that may need a manual re-lock.
-        const affected = node.npmExtensionApplied || ext.apply(node.package, { memoize: false })
-        if (affected) {
-          for (const edge of node.edgesIn) {
-            this.#depsQueue.push(edge.from)
-          }
-          node.parent = null
-        }
-      }
-    }
-  }
-
-  // Apply the root transformManifest to a copy of a candidate manifest, before any packageExtensions rule.
-  // Returns the possibly-transformed manifest and the provenance to attach to the node.
-  #applyNpmExtension (pkg) {
-    const res = this.#npmExtension?.apply(pkg)
-    return res ? { pkg: res.pkg, applied: res.applied } : { pkg, applied: null }
-  }
-
-  // Warn when packageExtensions appears in a non-root workspace, or when a root selector matches a workspace member.
-  // Workspace package manifests are edited directly and are never extension targets.
-  #warnWorkspacePackageExtensions () {
-    if (!this.#packageExtensions?.present) {
-      return
-    }
-    for (const node of this.idealTree.inventory.values()) {
-      // a workspace is in the inventory as both a Link and its target node; warn once by skipping the link
-      if (!node.isWorkspace || node.isLink) {
-        continue
-      }
-      if (node.package.packageExtensions !== undefined) {
-        log.warn('packageExtensions',
-          `"packageExtensions" in workspace ${node.name} is ignored; it is only honored at the workspace root`)
-      }
-      if (this.#packageExtensions.wouldMatch(node.name, node.version)) {
-        log.warn('packageExtensions',
-          `selector matches workspace package ${node.name}@${node.version}; edit its package.json directly instead of using packageExtensions`)
-      }
-    }
-  }
-
-  // Warn when a non-root workspace package contains a .npm-extension file; only the workspace root's file is honored.
-  #warnWorkspaceNpmExtension () {
-    for (const node of this.idealTree.inventory.values()) {
-      // a workspace is in the inventory as both a Link and its target node; warn once by skipping the link
-      if (!node.isWorkspace || node.isLink || node.isProjectRoot) {
-        continue
-      }
-      if (hasExtensionFile(node.realpath)) {
-        log.warn('npm-extension',
-          `".npm-extension" in workspace ${node.name} is ignored; it is only honored at the workspace root`)
-      }
-    }
-  }
-
   #parseSettings (options) {
     const update = options.update === true ? { all: true }
       : Array.isArray(options.update) ? { names: options.update }
@@ -887,7 +747,7 @@ module.exports = cls => class IdealTreeBuilder extends cls {
     for (const node of this.idealTree.inventory.values()) {
       // XXX add any invalid edgesOut to the queue
       if (this[_updateNames].includes(node.name) &&
-        !node.isTop && !node.inDepBundle) {
+        !node.isTop && !node.inDepBundle && !node.inShrinkwrap) {
         for (const edge of node.edgesIn) {
           this.addTracker('idealTree', edge.from.name, edge.from.location)
           this.#depsQueue.push(edge.from)
@@ -1011,11 +871,15 @@ This is a one-time fix-up, please be patient...
     const node = this.#depsQueue.pop()
     const bd = node.package.bundleDependencies
     const hasBundle = bd && Array.isArray(bd) && bd.length
+    const { hasShrinkwrap } = node
 
     // if the node was already visited, or has since been removed from the
-    // tree, skip over it and process the rest of the queue.
+    // tree, skip over it and process the rest of the queue.  If a node has
+    // a shrinkwrap, also skip it, because it's going to get its deps
+    // satisfied by whatever's in that file anyway.
     if (this.#depsSeen.has(node) ||
-        node.root !== this.idealTree) {
+        node.root !== this.idealTree ||
+        hasShrinkwrap && !this.#complete) {
       return this.#buildDepStep()
     }
 
@@ -1025,15 +889,15 @@ This is a one-time fix-up, please be patient...
 
     // if we're loading a _complete_ ideal tree, for a --package-lock-only
     // installation for example, we have to crack open the tarball and
-    // look inside if it has bundle deps.  note that this is
+    // look inside if it has bundle deps or shrinkwraps.  note that this is
     // not necessary during a reification, because we just update the
-    // ideal tree by reading bundles in place.
+    // ideal tree by reading bundles/shrinkwraps in place.
     // Don't bother if the node is from the actual tree and hasn't
     // been resolved, because we can't fetch it anyway, could be anything!
     const crackOpen = this.#complete &&
       node !== this.idealTree &&
       node.resolved &&
-      hasBundle &&
+      (hasBundle || hasShrinkwrap) &&
       !node.inert
     if (crackOpen) {
       const Arborist = this.constructor
@@ -1046,8 +910,15 @@ This is a one-time fix-up, please be patient...
           integrity: node.integrity,
         })
 
-        await new Arborist({ ...this.options, path })
-          .loadActual({ root: node, ignoreMissing: true })
+        if (hasShrinkwrap) {
+          await new Arborist({ ...this.options, path })
+            .loadVirtual({ root: node, subtreeOnly: true })
+        }
+
+        if (hasBundle) {
+          await new Arborist({ ...this.options, path })
+            .loadActual({ root: node, ignoreMissing: true })
+        }
       })
     }
 
@@ -1401,6 +1272,11 @@ This is a one-time fix-up, please be patient...
         continue
       }
 
+      // If it's shrinkwrapped, we use what the shrinkwap wants.
+      if (edge.to && edge.to.inShrinkwrap) {
+        continue
+      }
+
       // If the edge has no destination, that's a problem, unless
       // if it's peerOptional and not explicitly requested.
       if (!edge.to) {
@@ -1568,17 +1444,7 @@ This is a one-time fix-up, please be patient...
             )
             return this.#failureNode(name, parent, error, edge)
           }
-          // Transform the manifest copy before any packageExtensions rule and before the Node reads its dependency and peer edges.
-          const transformed = this.#applyNpmExtension(pkg)
-          const { pkg: extended, applied } = this.#applyPackageExtension(transformed.pkg)
-          const node = new Node({ name, pkg: extended, parent, installLinks, legacyPeerDeps })
-          if (transformed.applied) {
-            node.npmExtensionApplied = transformed.applied
-          }
-          if (applied) {
-            node.packageExtensionsApplied = applied
-          }
-          return node
+          return new Node({ name, pkg, parent, installLinks, legacyPeerDeps })
         },
         error => this.#failureNode(name, parent, error, edge)
       )

package/node_modules/@npmcli/arborist/lib/arborist/isolated-reifier.js

@@ -1,3 +1,5 @@
+const { mkdirSync } = require('node:fs')
+const pacote = require('pacote')
 const { join } = require('node:path')
 const { depth } = require('treeverse')
 const crypto = require('node:crypto')
@@ -13,10 +15,7 @@ const getKey = (startNode) => {
     getChildren: node => node.dependencies,
     visit: node => {
       branch.push(`${node.packageName}@${node.version}`)
-      // a patch changes the materialized contents, so it must change the store key.
-      // the patch segment is only appended when present, so unpatched keys are unchanged.
-      const patch = node.patched ? `::patch:${node.patched.integrity}` : ''
-      deps.push(`${branch.join('->')}::${node.resolved}${patch}`)
+      deps.push(`${branch.join('->')}::${node.resolved}`)
     },
     leave: () => {
       branch.pop()
@@ -31,9 +30,7 @@ const getKey = (startNode) => {
     .replace(/\+/g, '-')
     .replace(/\//g, '_')
     .replace(/=+$/m, '')
-  // a patched entry gets a distinct, identifiable side-store key so unpatched consumers keep sharing the original
-  const patchSuffix = startNode.patched ? '+patch' : ''
-  return `${startNode.packageName}@${startNode.version}-${hash}${patchSuffix}`
+  return `${startNode.packageName}@${startNode.version}-${hash}`
 }
 
 module.exports = cls => class IsolatedReifier extends cls {
@@ -54,7 +51,6 @@ module.exports = cls => class IsolatedReifier extends cls {
       optional: node.optional,
       package: pkg,
       parent: root,
-      patched: node.patched,
       path: join(this.idealGraph.localPath, location),
       resolved: node.resolved,
       root,
@@ -157,7 +153,46 @@ module.exports = cls => class IsolatedReifier extends cls {
     const result = {}
     // XXX this goes recursive if we don't set here because assignCommonProperties also calls this.#externalProxy
     this.#externalProxies.set(node, result)
-    await this.#assignCommonProperties(node, result)
+    await this.#assignCommonProperties(node, result, !node.hasShrinkwrap)
+    if (node.hasShrinkwrap) {
+      // strip any path traversal from package.json name fields before they hit path.join below
+      /* istanbul ignore next - packageName is always set for real packages */
+      const safeName = nameFromFolder(node.packageName || node.path)
+      const dir = join(
+        node.root.path,
+        'node_modules',
+        '.store',
+        `${safeName}@${node.version}`
+      )
+      mkdirSync(dir, { recursive: true })
+      // TODO this approach feels wrong and shouldn't be necessary for shrinkwraps
+      await pacote.extract(node.resolved, dir, {
+        ...this.options,
+        resolved: node.resolved,
+        integrity: node.integrity,
+        // TODO _isRoot
+      })
+      const Arborist = this.constructor
+      const arb = new Arborist({ ...this.options, path: dir })
+      // Make sure that the ideal tree is build as the rest of the algorithm depends on it.
+      await arb.buildIdealTree({
+        complete: false,
+        dev: false,
+      })
+      await arb.makeIdealGraph()
+      this.idealGraph.external.push(...arb.idealGraph.external)
+      for (const edge of arb.idealGraph.external) {
+        edge.root = this.idealGraph
+        edge.id = `${node.id}=>${edge.id}`
+      }
+      result.localDependencies = []
+      result.externalDependencies = arb.idealGraph.externalDependencies
+      result.externalOptionalDependencies = arb.idealGraph.externalOptionalDependencies
+      result.dependencies = [
+        ...result.externalDependencies,
+        ...result.externalOptionalDependencies,
+      ]
+    }
     result.optional = node.optional
     result.resolved = node.resolved
     result.version = node.version
@@ -171,7 +206,7 @@ module.exports = cls => class IsolatedReifier extends cls {
     return result
   }
 
-  async #assignCommonProperties (node, result) {
+  async #assignCommonProperties (node, result, populateDeps = true) {
     result.root = this.idealGraph
     // XXX does anything need this?
     result.id = this.counter++
@@ -179,10 +214,13 @@ module.exports = cls => class IsolatedReifier extends cls {
     result.name = result.isWorkspace ? (node.packageName || node.name) : node.name
     // strip any path traversal from package.json name fields before they hit path.join below
     result.packageName = nameFromFolder(node.packageName || node.path)
-    result.patched = node.patched
     result.package = { ...node.package }
     result.package.bundleDependencies = undefined
 
+    if (!populateDeps) {
+      return
+    }
+
     let edges = [...node.edgesOut.values()].filter(edge =>
       edge.to?.target &&
       !(node.package.bundledDependencies || node.package.bundleDependencies)?.includes(edge.to.name)

package/node_modules/@npmcli/arborist/lib/arborist/load-actual.js

@@ -13,8 +13,6 @@ const calcDepFlags = require('../calc-dep-flags.js')
 const Node = require('../node.js')
 const Link = require('../link.js')
 const realpath = require('../realpath.js')
-const PackageExtensions = require('../package-extensions.js')
-const NpmExtension = require('../npm-extension.js')
 
 // public symbols
 const _changePath = Symbol.for('_changePath')
@@ -179,10 +177,6 @@ module.exports = cls => class ActualLoader extends cls {
 
     this.#linkActualWorkspaces()
 
-    // .npm-extension runs before packageExtensions, matching the ideal-tree resolution order
-    await this.#applyNpmExtension()
-    this.#applyPackageExtensions()
-
     if (!ignoreMissing) {
       await this.#findMissingEdges()
     }
@@ -407,34 +401,6 @@ module.exports = cls => class ActualLoader extends cls {
     }
   }
 
-  // packageExtensions never rewrite a package's package.json, so a filesystem-scanned actual tree lacks the extension-created edges and provenance.
-  // Re-derive them from the root rule set, as buildIdealTree does.
-  // This is always required under the linked strategy, whose store layout forces the filesystem-scan path.
-  #applyPackageExtensions () {
-    const rootPkg = this.#actualTree.target?.package
-    const pe = new PackageExtensions(rootPkg?.packageExtensions)
-    if (!pe.present || !pe.selectors.length) {
-      return
-    }
-    for (const node of this.#actualTree.inventory.values()) {
-      // only installed dependencies are extended, never the root or a workspace
-      if (node.isLink || node.isProjectRoot || !node.name || !node.inNodeModules()) {
-        continue
-      }
-      const res = pe.apply(node.package)
-      if (res) {
-        node.package = res.pkg
-        node.packageExtensionsApplied = res.applied
-      }
-    }
-    // mirror the provenance onto links so the logical tree location reports it too
-    for (const node of this.#actualTree.inventory.values()) {
-      if (node.isLink && node.target?.packageExtensionsApplied) {
-        node.packageExtensionsApplied = node.target.packageExtensionsApplied
-      }
-    }
-  }
-
   // Re-forward overrides through links once all edges are resolved, since a Link may forward before its subtree resolves and miss a transitive match (npm/cli#9619, #9659).
   #repropagateOverrides () {
     if (!this.#actualTree.overrides) {
@@ -447,39 +413,6 @@ module.exports = cls => class ActualLoader extends cls {
     }
   }
 
-  // .npm-extension transformManifest, like packageExtensions, never rewrites a package's package.json, so re-derive its edges and provenance on a filesystem-scanned actual tree.
-  // This executes the root extension code; ignore-extension (and ignore-scripts via flatten) disables it.
-  async #applyNpmExtension () {
-    if (this.options.ignoreExtension) {
-      return
-    }
-    const ext = new NpmExtension({
-      root: this.#actualTree.realpath,
-      extensionFile: this.options.extensionFile,
-    })
-    if (!ext.present) {
-      return
-    }
-    await ext.load()
-    for (const node of this.#actualTree.inventory.values()) {
-      // only installed dependencies are transformed, never the root or a workspace
-      if (node.isLink || node.isProjectRoot || !node.name || !node.inNodeModules()) {
-        continue
-      }
-      const res = ext.apply(node.package)
-      if (res) {
-        node.package = res.pkg
-        node.npmExtensionApplied = res.applied
-      }
-    }
-    // mirror the provenance onto links so the logical tree location reports it too
-    for (const node of this.#actualTree.inventory.values()) {
-      if (node.isLink && node.target?.npmExtensionApplied) {
-        node.npmExtensionApplied = node.target.npmExtensionApplied
-      }
-    }
-  }
-
   async #findMissingEdges () {
     // try to resolve any missing edges by walking up the directory tree,
     // checking for the package in each node_modules folder.  stop at the

package/node_modules/@npmcli/arborist/lib/arborist/load-virtual.js

@@ -1,4 +1,4 @@
-const { resolve } = require('node:path')
+const { isAbsolute, resolve } = require('node:path')
 // mixin providing the loadVirtual method
 const mapWorkspaces = require('@npmcli/map-workspaces')
 const PackageJson = require('@npmcli/package-json')
@@ -17,6 +17,8 @@ const setWorkspaces = Symbol.for('setWorkspaces')
 
 module.exports = cls => class VirtualLoader extends cls {
   #rootOptionProvided
+  // when true, lockfile entries must stay inside `this.path`
+  #subtreeOnly = false
 
   // public method
   async loadVirtual (options = {}) {
@@ -28,6 +30,8 @@ module.exports = cls => class VirtualLoader extends cls {
     // XXX: deprecate separate reify() options object.
     options = { ...this.options, ...options }
 
+    this.#subtreeOnly = !!options.subtreeOnly
+
     if (options.root && options.root.meta) {
       await this.#loadFromShrinkwrap(options.root.meta, options.root)
       return treeCheck(this.virtualTree)
@@ -39,7 +43,7 @@ module.exports = cls => class VirtualLoader extends cls {
       resolveOptions: this.options,
     })
     if (!s.loadedFromDisk && !options.root) {
-      const er = new Error('loadVirtual requires existing package-lock.json file')
+      const er = new Error('loadVirtual requires existing shrinkwrap file')
       throw Object.assign(er, { code: 'ENOLOCK' })
     }
 
@@ -166,12 +170,40 @@ module.exports = cls => class VirtualLoader extends cls {
     }
   }
 
+  // throw if the resolved path is outside `base`, only in subtreeOnly mode
+  #assertContained (base, resolvedPath, location) {
+    if (!this.#subtreeOnly) {
+      return
+    }
+    if (isAbsolute(location)) {
+      throw Object.assign(
+        new Error(`invalid lockfile entry: "${location}" must be a relative location`),
+        { code: 'EINVALIDLOCATION', location, base }
+      )
+    }
+    const rel = relpath(base, resolvedPath)
+    if (
+      rel === '..' ||
+      rel.startsWith('../') ||
+      isAbsolute(rel) ||
+      // non-root key that collapses back to base (e.g. 'node_modules/..')
+      (rel === '' && location !== '')
+    ) {
+      throw Object.assign(
+        new Error(`invalid lockfile entry: "${location}" resolves outside of "${base}"`),
+        { code: 'EINVALIDLOCATION', location, base, resolvedPath }
+      )
+    }
+  }
+
   // links is the set of metadata, and nodes is the map of non-Link nodes
   // Set the targets to nodes in the set, if we have them (we might not)
   // XXX build-ideal-tree also has a #resolveLinks, is there overlap?
   async #resolveLinks (links, nodes) {
     for (const [location, meta] of links.entries()) {
       const targetPath = resolve(this.path, meta.resolved)
+      // check before nodes.get so we surface EINVALIDLOCATION instead of EMISSINGTARGET
+      this.#assertContained(this.path, targetPath, meta.resolved || location)
       const targetLoc = relpath(this.path, targetPath)
       const target = nodes.get(targetLoc)
 
@@ -230,6 +262,7 @@ To fix:
   #loadNode (location, sw, loadOverrides) {
     const p = this.virtualTree ? this.virtualTree.realpath : this.path
     const path = resolve(p, location)
+    this.#assertContained(p, path, location)
     // shrinkwrap doesn't include package name unless necessary
     if (!sw.name) {
       sw.name = nameFromFolder(path)
@@ -242,11 +275,9 @@ To fix:
       path,
       realpath: path,
       integrity: sw.integrity,
-      patched: sw.patched,
-      packageExtensionsApplied: sw.packageExtensionsApplied,
-      npmExtensionApplied: sw.npmExtensionApplied,
       resolved: consistentResolve(sw.resolved, this.path, path),
       pkg: sw,
+      hasShrinkwrap: sw.hasShrinkwrap,
       loadOverrides,
       // cast to boolean because they're undefined in the lock file when false
       extraneous: !!sw.extraneous,
@@ -261,6 +292,7 @@ To fix:
 
   #loadLink (location, targetLoc, target) {
     const path = resolve(this.path, location)
+    this.#assertContained(this.path, path, location)
     const link = new Link({
       installLinks: this.installLinks,
       legacyPeerDeps: this.legacyPeerDeps,