@npmcli/arborist 2.2.8 → 2.4.1

package/lib/arborist/load-actual.js

@@ -32,6 +32,7 @@ const _loadActual = Symbol('loadActual')
 const _loadActualVirtually = Symbol('loadActualVirtually')
 const _loadActualActually = Symbol('loadActualActually')
 const _loadWorkspaces = Symbol.for('loadWorkspaces')
+const _loadWorkspaceTargets = Symbol('loadWorkspaceTargets')
 const _actualTreePromise = Symbol('actualTreePromise')
 const _actualTree = Symbol('actualTree')
 const _transplant = Symbol('transplant')
@@ -150,18 +151,22 @@ module.exports = cls => class ActualLoader extends cls {
     await new this.constructor({...this.options}).loadVirtual({
       root: this[_actualTree],
     })
+    await this[_loadWorkspaces](this[_actualTree])
+    if (this[_actualTree].workspaces && this[_actualTree].workspaces.size)
+      calcDepFlags(this[_actualTree], !root)
     this[_transplant](root)
     return this[_actualTree]
   }
 
   async [_loadActualActually] ({ root, ignoreMissing, global }) {
     await this[_loadFSTree](this[_actualTree])
+    await this[_loadWorkspaces](this[_actualTree])
+    await this[_loadWorkspaceTargets](this[_actualTree])
     if (!ignoreMissing)
       await this[_findMissingEdges]()
     this[_findFSParents]()
     this[_transplant](root)
 
-    await this[_loadWorkspaces](this[_actualTree])
     if (global) {
       // need to depend on the children, or else all of them
       // will end up being flagged as extraneous, since the
@@ -178,16 +183,37 @@ module.exports = cls => class ActualLoader extends cls {
     return this[_actualTree]
   }
 
+  // if there are workspace targets without Link nodes created, load
+  // the targets, so that we know what they are.
+  async [_loadWorkspaceTargets] (tree) {
+    if (!tree.workspaces || !tree.workspaces.size)
+      return
+
+    const promises = []
+    for (const path of tree.workspaces.values()) {
+      if (!this[_cache].has(path)) {
+        const p = this[_loadFSNode]({ path, root: this[_actualTree] })
+          .then(node => this[_loadFSTree](node))
+        promises.push(p)
+      }
+    }
+    await Promise.all(promises)
+  }
+
   [_transplant] (root) {
     if (!root || root === this[_actualTree])
       return
+
     this[_actualTree][_changePath](root.path)
     for (const node of this[_actualTree].children.values()) {
       if (!this[_transplantFilter](node))
-        node.parent = null
+        node.root = null
     }
 
     root.replace(this[_actualTree])
+    for (const node of this[_actualTree].fsChildren)
+      node.root = this[_transplantFilter](node) ? root : null
+
     this[_actualTree] = root
   }
 

package/lib/arborist/load-virtual.js

@@ -93,7 +93,8 @@ module.exports = cls => class VirtualLoader extends cls {
     this.virtualTree = root
     const {links, nodes} = this[resolveNodes](s, root)
     await this[resolveLinks](links, nodes)
-    this[assignBundles](nodes)
+    if (!(s.originalLockfileVersion >= 2))
+      this[assignBundles](nodes)
     if (this[flagsSuspect])
       this[reCalcDepFlags](nodes.values())
     return root
@@ -220,22 +221,24 @@ module.exports = cls => class VirtualLoader extends cls {
   [assignBundles] (nodes) {
     for (const [location, node] of nodes) {
       // Skip assignment of parentage for the root package
-      if (!location)
+      if (!location || node.target && !node.target.location)
         continue
       const { name, parent, package: { inBundle }} = node
+
       if (!parent)
         continue
 
       // read inBundle from package because 'package' here is
       // actually a v2 lockfile metadata entry.
-      // If the *parent* is also bundled, though, then we assume
-      // that it's being pulled in just by virtue of that.
+      // If the *parent* is also bundled, though, or if the parent has
+      // no dependency on it, then we assume that it's being pulled in
+      // just by virtue of its parent or a transitive dep being bundled.
       const { package: ppkg } = parent
       const { inBundle: parentBundled } = ppkg
-      if (inBundle && !parentBundled) {
+      if (inBundle && !parentBundled && parent.edgesOut.has(node.name)) {
         if (!ppkg.bundleDependencies)
           ppkg.bundleDependencies = [name]
-        else if (!ppkg.bundleDependencies.includes(name))
+        else
           ppkg.bundleDependencies.push(name)
       }
     }

package/lib/arborist/rebuild.js

@@ -115,10 +115,6 @@ module.exports = cls => class Builder extends cls {
       await this[_runScripts]('preinstall')
     if (this[_binLinks] && type !== 'links')
       await this[_linkAllBins]()
-    if (!this[_ignoreScripts]) {
-      await this[_runScripts]('install')
-      await this[_runScripts]('postinstall')
-    }
 
     // links should also run prepare scripts and only link bins after that
     if (type === 'links') {
@@ -128,6 +124,11 @@ module.exports = cls => class Builder extends cls {
         await this[_linkAllBins]()
     }
 
+    if (!this[_ignoreScripts]) {
+      await this[_runScripts]('install')
+      await this[_runScripts]('postinstall')
+    }
+
     process.emit('timeEnd', `build:${type}`)
   }
 

package/lib/arborist/reify.js

@@ -14,6 +14,7 @@ const fs = require('fs')
 const {promisify} = require('util')
 const symlink = promisify(fs.symlink)
 const mkdirp = require('mkdirp-infer-owner')
+const justMkdirp = require('mkdirp')
 const moveFile = require('@npmcli/move-file')
 const rimraf = promisify(require('rimraf'))
 const packageContents = require('@npmcli/installed-package-contents')
@@ -26,6 +27,7 @@ const retirePath = require('../retire-path.js')
 const promiseAllRejectLate = require('promise-all-reject-late')
 const optionalSet = require('../optional-set.js')
 const updateRootPackageJson = require('../update-root-package-json.js')
+const calcDepFlags = require('../calc-dep-flags.js')
 
 const _retiredPaths = Symbol('retiredPaths')
 const _retiredUnchanged = Symbol('retiredUnchanged')
@@ -36,6 +38,8 @@ const _retireShallowNodes = Symbol.for('retireShallowNodes')
 const _getBundlesByDepth = Symbol('getBundlesByDepth')
 const _registryResolved = Symbol('registryResolved')
 const _addNodeToTrashList = Symbol('addNodeToTrashList')
+const _workspaces = Symbol.for('workspaces')
+
 // shared by rebuild mixin
 const _trashList = Symbol.for('trashList')
 const _handleOptionalFailure = Symbol.for('handleOptionalFailure')
@@ -45,7 +49,8 @@ const _loadTrees = Symbol.for('loadTrees')
 const _diffTrees = Symbol.for('diffTrees')
 const _createSparseTree = Symbol.for('createSparseTree')
 const _loadShrinkwrapsAndUpdateTrees = Symbol.for('loadShrinkwrapsAndUpdateTrees')
-const _shrinkwrapUnpacked = Symbol('shrinkwrapUnpacked')
+const _shrinkwrapInflated = Symbol('shrinkwrapInflated')
+const _bundleUnpacked = Symbol('bundleUnpacked')
 const _reifyNode = Symbol.for('reifyNode')
 const _extractOrLink = Symbol('extractOrLink')
 // defined by rebuild mixin
@@ -82,7 +87,6 @@ const _global = Symbol.for('global')
 
 // defined by Ideal mixin
 const _pruneBundledMetadeps = Symbol.for('pruneBundledMetadeps')
-const _explicitRequests = Symbol.for('explicitRequests')
 const _resolvedAdd = Symbol.for('resolvedAdd')
 const _usePackageLock = Symbol.for('usePackageLock')
 const _formatPackageLock = Symbol.for('formatPackageLock')
@@ -105,7 +109,7 @@ module.exports = cls => class Reifier extends cls {
 
     this.diff = null
     this[_retiredPaths] = {}
-    this[_shrinkwrapUnpacked] = new Set()
+    this[_shrinkwrapInflated] = new Set()
     this[_retiredUnchanged] = {}
     this[_sparseTreeDirs] = new Set()
     this[_sparseTreeRoots] = new Set()
@@ -146,7 +150,10 @@ module.exports = cls => class Reifier extends cls {
     if (this[_packageLockOnly] || this[_dryRun])
       return
 
-    await mkdirp(resolve(this.path))
+    // we do NOT want to set ownership on this folder, especially
+    // recursively, because it can have other side effects to do that
+    // in a project directory.  We just want to make it if it's missing.
+    await justMkdirp(resolve(this.path))
   }
 
   async [_reifyPackages] () {
@@ -237,9 +244,25 @@ module.exports = cls => class Reifier extends cls {
     const actualOpt = this[_global] ? {
       ignoreMissing: true,
       global: true,
-      filter: (node, kid) =>
-        this[_explicitRequests].size === 0 || !node.isProjectRoot ? true
-        : (this.idealTree.edgesOut.has(kid) || this[_explicitRequests].has(kid)),
+      filter: (node, kid) => {
+        // if it's not the project root, and we have no explicit requests,
+        // then we're already into a nested dep, so we keep it
+        if (this.explicitRequests.size === 0 || !node.isProjectRoot)
+          return true
+
+        // if we added it as an edgeOut, then we want it
+        if (this.idealTree.edgesOut.has(kid))
+          return true
+
+        // if it's an explicit request, then we want it
+        const hasExplicit = [...this.explicitRequests]
+          .some(edge => edge.name === kid)
+        if (hasExplicit)
+          return true
+
+        // ignore the rest of the global install folder
+        return false
+      },
     } : { ignoreMissing: true }
 
     if (!this[_global]) {
@@ -266,9 +289,36 @@ module.exports = cls => class Reifier extends cls {
     // to just invalidate the parts that changed, but avoid walking the
     // whole tree again.
 
+    const filterNodes = []
+    if (this[_global] && this.explicitRequests.size) {
+      const idealTree = this.idealTree.target || this.idealTree
+      const actualTree = this.actualTree.target || this.actualTree
+      // we ONLY are allowed to make changes in the global top-level
+      // children where there's an explicit request.
+      for (const { name } of this.explicitRequests) {
+        const ideal = idealTree.children.get(name)
+        if (ideal)
+          filterNodes.push(ideal)
+        const actual = actualTree.children.get(name)
+        if (actual)
+          filterNodes.push(actual)
+      }
+    } else {
+      for (const ws of this[_workspaces]) {
+        const ideal = this.idealTree.children.get(ws)
+        if (ideal)
+          filterNodes.push(ideal)
+        const actual = this.actualTree.children.get(ws)
+        if (actual)
+          filterNodes.push(actual)
+      }
+    }
+
     // find all the nodes that need to change between the actual
     // and ideal trees.
     this.diff = Diff.calculate({
+      shrinkwrapInflated: this[_shrinkwrapInflated],
+      filterNodes,
       actual: this.actualTree,
       ideal: this.idealTree,
     })
@@ -375,7 +425,8 @@ module.exports = cls => class Reifier extends cls {
     const dirs = this.diff.leaves
       .filter(diff => {
         return (diff.action === 'ADD' || diff.action === 'CHANGE') &&
-          !this[_sparseTreeDirs].has(diff.ideal.path)
+          !this[_sparseTreeDirs].has(diff.ideal.path) &&
+          !diff.ideal.isLink
       })
       .map(diff => diff.ideal.path)
 
@@ -409,9 +460,9 @@ module.exports = cls => class Reifier extends cls {
   // we need to unpack them, read that shrinkwrap file, and then update
   // the tree by calling loadVirtual with the node as the root.
   [_loadShrinkwrapsAndUpdateTrees] () {
-    const seen = this[_shrinkwrapUnpacked]
+    const seen = this[_shrinkwrapInflated]
     const shrinkwraps = this.diff.leaves
-      .filter(d => (d.action === 'CHANGE' || d.action === 'ADD') &&
+      .filter(d => (d.action === 'CHANGE' || d.action === 'ADD' || !d.action) &&
         d.ideal.hasShrinkwrap && !seen.has(d.ideal) &&
         !this[_trashList].has(d.ideal.path))
 
@@ -424,7 +475,7 @@ module.exports = cls => class Reifier extends cls {
     return promiseAllRejectLate(shrinkwraps.map(diff => {
       const node = diff.ideal
       seen.add(node)
-      return this[_reifyNode](node)
+      return diff.action ? this[_reifyNode](node) : node
     }))
       .then(nodes => promiseAllRejectLate(nodes.map(node => new Arborist({
         ...this.options,
@@ -455,7 +506,7 @@ module.exports = cls => class Reifier extends cls {
 
     const { npmVersion, nodeVersion } = this.options
     const p = Promise.resolve()
-      .then(() => {
+      .then(async () => {
         // when we reify an optional node, check the engine and platform
         // first. be sure to ignore the --force and --engine-strict flags,
         // since we always want to skip any optional packages we can't install.
@@ -465,11 +516,11 @@ module.exports = cls => class Reifier extends cls {
           checkEngine(node.package, npmVersion, nodeVersion, false)
           checkPlatform(node.package, false)
         }
+        await this[_checkBins](node)
+        await this[_extractOrLink](node)
+        await this[_warnDeprecated](node)
+        await this[_loadAncientPackageDetails](node)
       })
-      .then(() => this[_checkBins](node))
-      .then(() => this[_extractOrLink](node))
-      .then(() => this[_warnDeprecated](node))
-      .then(() => this[_loadAncientPackageDetails](node))
 
     return this[_handleOptionalFailure](node, p)
       .then(() => {
@@ -515,10 +566,11 @@ module.exports = cls => class Reifier extends cls {
       })
   }
 
-  [_symlink] (node) {
+  async [_symlink] (node) {
     const dir = dirname(node.path)
     const target = node.realpath
     const rel = relative(dir, target)
+    await mkdirp(dir)
     return symlink(rel, node.path, 'junction')
   }
 
@@ -585,8 +637,10 @@ module.exports = cls => class Reifier extends cls {
   [_loadBundlesAndUpdateTrees] (
     depth = 0, bundlesByDepth = this[_getBundlesByDepth]()
   ) {
-    if (depth === 0)
+    if (depth === 0) {
+      this[_bundleUnpacked] = new Set()
       process.emit('time', 'reify:loadBundles')
+    }
     const maxBundleDepth = bundlesByDepth.get('maxBundleDepth')
     if (depth > maxBundleDepth) {
       // if we did something, then prune the tree and update the diffs
@@ -602,13 +656,17 @@ module.exports = cls => class Reifier extends cls {
     // shallower bundle overwriting them with a bundled meta-dep.
     const set = (bundlesByDepth.get(depth) || [])
       .filter(node => node.root === this.idealTree &&
+        node.target !== node.root &&
         !this[_trashList].has(node.path))
 
     if (!set.length)
       return this[_loadBundlesAndUpdateTrees](depth + 1, bundlesByDepth)
 
     // extract all the nodes with bundles
-    return promiseAllRejectLate(set.map(node => this[_reifyNode](node)))
+    return promiseAllRejectLate(set.map(node => {
+      this[_bundleUnpacked].add(node)
+      return this[_reifyNode](node)
+    }))
     // then load their unpacked children and move into the ideal tree
       .then(nodes =>
         promiseAllRejectLate(nodes.map(node => new this.constructor({
@@ -630,8 +688,13 @@ module.exports = cls => class Reifier extends cls {
       tree: this.diff,
       visit: diff => {
         const node = diff.ideal
-        if (node && !node.isProjectRoot && node.package.bundleDependencies &&
-            node.package.bundleDependencies.length) {
+        if (!node)
+          return
+        if (node.isProjectRoot || (node.target && node.target.isProjectRoot))
+          return
+
+        const { bundleDependencies } = node.package
+        if (bundleDependencies && bundleDependencies.length) {
           maxBundleDepth = Math.max(maxBundleDepth, node.depth)
           if (!bundlesByDepth.has(node.depth))
             bundlesByDepth.set(node.depth, [node])
@@ -736,14 +799,14 @@ module.exports = cls => class Reifier extends cls {
           return
 
         const node = diff.ideal
-        const bd = node.package.bundleDependencies
-        const sw = this[_shrinkwrapUnpacked].has(node)
+        const bd = this[_bundleUnpacked].has(node)
+        const sw = this[_shrinkwrapInflated].has(node)
 
         // check whether we still need to unpack this one.
         // test the inDepBundle last, since that's potentially a tree walk.
         const doUnpack = node && // can't unpack if removed!
           !node.isRoot && // root node already exists
-          !(bd && bd.length) && // already unpacked to read bundle
+          !bd && // already unpacked to read bundle
           !sw && // already unpacked to read sw
           !node.inDepBundle // already unpacked by another dep's bundle
 
@@ -886,11 +949,11 @@ module.exports = cls => class Reifier extends cls {
     // to things like git repos and tarball file/urls.  However, if the
     // user requested 'foo@', and we have a foo@file:../foo, then we should
     // end up saving the spec we actually used, not whatever they gave us.
-    if (this[_resolvedAdd]) {
+    if (this[_resolvedAdd].length) {
       const root = this.idealTree
       const pkg = root.package
       for (const { name } of this[_resolvedAdd]) {
-        const req = npa(root.edgesOut.get(name).spec, root.realpath)
+        const req = npa.resolve(name, root.edgesOut.get(name).spec, root.realpath)
         const {rawSpec, subSpec} = req
 
         const spec = subSpec ? subSpec.rawSpec : rawSpec
@@ -966,20 +1029,85 @@ module.exports = cls => class Reifier extends cls {
     return meta.save(saveOpt)
   }
 
-  [_copyIdealToActual] () {
+  async [_copyIdealToActual] () {
+    // clean up any trash that is still in the tree
+    for (const path of this[_trashList]) {
+      const loc = relpath(this.idealTree.realpath, path)
+      const node = this.idealTree.inventory.get(loc)
+      if (node && node.root === this.idealTree)
+        node.parent = null
+    }
+
+    // if we filtered to only certain nodes, then anything ELSE needs
+    // to be untouched in the resulting actual tree, even if it differs
+    // in the idealTree.  Copy over anything that was in the actual and
+    // was not changed, delete anything in the ideal and not actual.
+    // Then we move the entire idealTree over to this.actualTree, and
+    // save the hidden lockfile.
+    if (this.diff && this.diff.filterSet.size) {
+      const { filterSet } = this.diff
+      const seen = new Set()
+      for (const [loc, ideal] of this.idealTree.inventory.entries()) {
+        if (seen.has(loc))
+          continue
+        seen.add(loc)
+
+        // if it's an ideal node from the filter set, then skip it
+        // because we already made whatever changes were necessary
+        if (filterSet.has(ideal))
+          continue
+
+        // otherwise, if it's not in the actualTree, then it's not a thing
+        // that we actually added.  And if it IS in the actualTree, then
+        // it's something that we left untouched, so we need to record
+        // that.
+        const actual = this.actualTree.inventory.get(loc)
+        if (!actual)
+          ideal.root = null
+        else {
+          if ([...actual.linksIn].some(link => filterSet.has(link))) {
+            seen.add(actual.location)
+            continue
+          }
+          const { realpath, isLink } = actual
+          if (isLink && ideal.isLink && ideal.realpath === realpath)
+            continue
+          else
+            actual.root = this.idealTree
+        }
+      }
+
+      // now find any actual nodes that may not be present in the ideal
+      // tree, but were left behind by virtue of not being in the filter
+      for (const [loc, actual] of this.actualTree.inventory.entries()) {
+        if (seen.has(loc))
+          continue
+        seen.add(loc)
+        if (filterSet.has(actual))
+          continue
+        actual.root = this.idealTree
+      }
+
+      // prune out any tops that lack a linkIn
+      for (const top of this.idealTree.tops) {
+        if (top.linksIn.size === 0)
+          top.root = null
+      }
+
+      // need to calculate dep flags, since nodes may have been marked
+      // as extraneous or otherwise incorrect during transit.
+      calcDepFlags(this.idealTree)
+    }
+
     // save the ideal's meta as a hidden lockfile after we actualize it
     this.idealTree.meta.filename =
-      this.path + '/node_modules/.package-lock.json'
+      this.idealTree.realpath + '/node_modules/.package-lock.json'
     this.idealTree.meta.hiddenLockfile = true
+
     this.actualTree = this.idealTree
     this.idealTree = null
-    for (const path of this[_trashList]) {
-      const loc = relpath(this.path, path)
-      const node = this.actualTree.inventory.get(loc)
-      if (node && node.root === this.actualTree)
-        node.parent = null
-    }
 
-    return !this[_global] && this.actualTree.meta.save()
+    if (!this[_global])
+      await this.actualTree.meta.save()
   }
 }

package/lib/debug.js

@@ -12,6 +12,7 @@
 
 // run in debug mode if explicitly requested, running arborist tests,
 // or working in the arborist project directory.
+
 const debug = process.env.ARBORIST_DEBUG !== '0' && (
   process.env.ARBORIST_DEBUG === '1' ||
   /\barborist\b/.test(process.env.NODE_DEBUG || '') ||
@@ -21,4 +22,10 @@ const debug = process.env.ARBORIST_DEBUG !== '0' && (
 )
 
 module.exports = debug ? fn => fn() : () => {}
-module.exports.log = (...msg) => module.exports(() => console.error(...msg))
+const red = process.stderr.isTTY ? msg => `\x1B[31m${msg}\x1B[39m` : m => m
+module.exports.log = (...msg) => module.exports(() => {
+  const { format } = require('util')
+  const prefix = `\n${process.pid} ${red(format(msg.shift()))} `
+  msg = (prefix + format(...msg).trim().split('\n').join(prefix)).trim()
+  console.error(msg)
+})

package/lib/diff.js

@@ -11,7 +11,9 @@ const {existsSync} = require('fs')
 const ssri = require('ssri')
 
 class Diff {
-  constructor ({actual, ideal}) {
+  constructor ({actual, ideal, filterSet, shrinkwrapInflated}) {
+    this.filterSet = filterSet
+    this.shrinkwrapInflated = shrinkwrapInflated
     this.children = []
     this.actual = actual
     this.ideal = ideal
@@ -29,9 +31,54 @@ class Diff {
     this.removed = []
   }
 
-  static calculate ({actual, ideal}) {
+  static calculate ({actual, ideal, filterNodes = [], shrinkwrapInflated = new Set()}) {
+    // if there's a filterNode, then:
+    // - get the path from the root to the filterNode.  The root or
+    //   root.target should have an edge either to the filterNode or
+    //   a link to the filterNode.  If not, abort.  Add the path to the
+    //   filterSet.
+    // - Add set of Nodes depended on by the filterNode to filterSet.
+    // - Anything outside of that set should be ignored by getChildren
+    const filterSet = new Set()
+    for (const filterNode of filterNodes) {
+      const { root } = filterNode
+      if (root !== ideal && root !== actual)
+        throw new Error('invalid filterNode: outside idealTree/actualTree')
+      const { target } = root
+      const rootTarget = target || root
+      const edge = [...rootTarget.edgesOut.values()].filter(e => {
+        return e.to && (e.to === filterNode || e.to.target === filterNode)
+      })[0]
+      filterSet.add(root)
+      filterSet.add(rootTarget)
+      filterSet.add(ideal)
+      filterSet.add(actual)
+      if (edge && edge.to) {
+        filterSet.add(edge.to)
+        if (edge.to.target)
+          filterSet.add(edge.to.target)
+      }
+      filterSet.add(filterNode)
+
+      depth({
+        tree: filterNode,
+        visit: node => filterSet.add(node),
+        getChildren: node => {
+          node = node.target || node
+          const loc = node.location
+          const idealNode = ideal.inventory.get(loc)
+          const ideals = !idealNode ? []
+            : [...idealNode.edgesOut.values()].filter(e => e.to).map(e => e.to)
+          const actualNode = actual.inventory.get(loc)
+          const actuals = !actualNode ? []
+            : [...actualNode.edgesOut.values()].filter(e => e.to).map(e => e.to)
+          return ideals.concat(actuals)
+        },
+      })
+    }
+
     return depth({
-      tree: new Diff({actual, ideal}),
+      tree: new Diff({actual, ideal, filterSet, shrinkwrapInflated}),
       getChildren,
       leave,
     })
@@ -89,20 +136,29 @@ const allChildren = node => {
 // to create the diff tree
 const getChildren = diff => {
   const children = []
-  const {unchanged, removed} = diff
+  const {actual, ideal, unchanged, removed, filterSet, shrinkwrapInflated} = diff
 
   // Note: we DON'T diff fsChildren themselves, because they are either
   // included in the package contents, or part of some other project, and
   // will never appear in legacy shrinkwraps anyway.  but we _do_ include the
   // child nodes of fsChildren, because those are nodes that we are typically
   // responsible for installing.
-  const actualKids = allChildren(diff.actual)
-  const idealKids = allChildren(diff.ideal)
+  const actualKids = allChildren(actual)
+  const idealKids = allChildren(ideal)
+
+  if (ideal && ideal.hasShrinkwrap && !shrinkwrapInflated.has(ideal)) {
+    // Guaranteed to get a diff.leaves here, because we always
+    // be called with a proper Diff object when ideal has a shrinkwrap
+    // that has not been inflated.
+    diff.leaves.push(diff)
+    return children
+  }
+
   const paths = new Set([...actualKids.keys(), ...idealKids.keys()])
   for (const path of paths) {
     const actual = actualKids.get(path)
     const ideal = idealKids.get(path)
-    diffNode(actual, ideal, children, unchanged, removed)
+    diffNode(actual, ideal, children, unchanged, removed, filterSet, shrinkwrapInflated)
   }
 
   if (diff.leaves && !children.length)
@@ -111,15 +167,18 @@ const getChildren = diff => {
   return children
 }
 
-const diffNode = (actual, ideal, children, unchanged, removed) => {
+const diffNode = (actual, ideal, children, unchanged, removed, filterSet, shrinkwrapInflated) => {
+  if (filterSet.size && !(filterSet.has(ideal) || filterSet.has(actual)))
+    return
+
   const action = getAction({actual, ideal})
 
   // if it's a match, then get its children
   // otherwise, this is the child diff node
-  if (action) {
+  if (action || (!shrinkwrapInflated.has(ideal) && ideal.hasShrinkwrap)) {
     if (action === 'REMOVE')
       removed.push(actual)
-    children.push(new Diff({actual, ideal}))
+    children.push(new Diff({actual, ideal, filterSet, shrinkwrapInflated}))
   } else {
     unchanged.push(ideal)
     // !*! Weird dirty hack warning !*!
@@ -150,7 +209,7 @@ const diffNode = (actual, ideal, children, unchanged, removed) => {
       for (const node of bundledChildren)
         node.parent = ideal
     }
-    children.push(...getChildren({actual, ideal, unchanged, removed}))
+    children.push(...getChildren({actual, ideal, unchanged, removed, filterSet, shrinkwrapInflated}))
   }
 }
 

package/lib/index.js

@@ -3,5 +3,6 @@ module.exports.Arborist = module.exports
 module.exports.Node = require('./node.js')
 module.exports.Link = require('./link.js')
 module.exports.Edge = require('./edge.js')
+module.exports.Shrinkwrap = require('./shrinkwrap.js')
 // XXX export the other classes, too.  shrinkwrap, diff, etc.
 // they're handy!