metro 0.82.3 → 0.82.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.82.3",
+  "version": "0.82.5",
   "description": "🚇 The JavaScript bundler for React Native.",
   "main": "src/index.js",
   "bin": "src/cli.js",
@@ -36,24 +36,24 @@
     "error-stack-parser": "^2.0.6",
     "flow-enums-runtime": "^0.0.6",
     "graceful-fs": "^4.2.4",
-    "hermes-parser": "0.28.1",
+    "hermes-parser": "0.29.1",
     "image-size": "^1.0.2",
     "invariant": "^2.2.4",
     "jest-worker": "^29.7.0",
     "jsc-safe-url": "^0.2.2",
     "lodash.throttle": "^4.1.1",
-    "metro-babel-transformer": "0.82.3",
-    "metro-cache": "0.82.3",
-    "metro-cache-key": "0.82.3",
-    "metro-config": "0.82.3",
-    "metro-core": "0.82.3",
-    "metro-file-map": "0.82.3",
-    "metro-resolver": "0.82.3",
-    "metro-runtime": "0.82.3",
-    "metro-source-map": "0.82.3",
-    "metro-symbolicate": "0.82.3",
-    "metro-transform-plugins": "0.82.3",
-    "metro-transform-worker": "0.82.3",
+    "metro-babel-transformer": "0.82.5",
+    "metro-cache": "0.82.5",
+    "metro-cache-key": "0.82.5",
+    "metro-config": "0.82.5",
+    "metro-core": "0.82.5",
+    "metro-file-map": "0.82.5",
+    "metro-resolver": "0.82.5",
+    "metro-runtime": "0.82.5",
+    "metro-source-map": "0.82.5",
+    "metro-symbolicate": "0.82.5",
+    "metro-transform-plugins": "0.82.5",
+    "metro-transform-worker": "0.82.5",
     "mime-types": "^2.1.27",
     "nullthrows": "^1.1.1",
     "serialize-error": "^2.1.0",
@@ -72,8 +72,8 @@
     "dedent": "^0.7.0",
     "jest-snapshot": "^29.7.0",
     "jest-snapshot-serializer-raw": "^1.2.0",
-    "metro-babel-register": "0.82.3",
-    "metro-memory-fs": "0.82.3",
+    "metro-babel-register": "0.82.5",
+    "metro-memory-fs": "0.82.5",
     "mock-req": "^0.2.0",
     "mock-res": "^0.6.0",
     "stack-trace": "^0.0.10"

package/src/DeltaBundler/Graph.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.Graph = void 0;
 var _contextModule = require("../lib/contextModule");
 var _CountingSet = _interopRequireDefault(require("../lib/CountingSet"));
+var _isResolvedDependency = require("../lib/isResolvedDependency");
 var _buildSubgraph = require("./buildSubgraph");
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
@@ -285,13 +286,14 @@ class Graph {
     delta,
     options
   ) {
-    const path = dependency.absolutePath;
-    let module = this.dependencies.get(path);
     if (options.shallow) {
+    } else if (!(0, _isResolvedDependency.isResolvedDependency)(dependency)) {
     } else if (dependency.data.data.asyncType === "weak") {
     } else if (options.lazy && dependency.data.data.asyncType != null) {
       this._incrementImportBundleReference(dependency, parentModule);
     } else {
+      const path = dependency.absolutePath;
+      let module = this.dependencies.get(path);
       if (!module) {
         try {
           module = this._recursivelyCommitModule(path, delta, options);
@@ -310,19 +312,25 @@ class Graph {
       module.inverseDependencies.add(parentModule.path);
       this._markModuleInUse(module);
     }
-    if (requireContext) {
-      this.#resolvedContexts.set(path, requireContext);
-    } else {
-      this.#resolvedContexts.delete(path);
+    if ((0, _isResolvedDependency.isResolvedDependency)(dependency)) {
+      const path = dependency.absolutePath;
+      if (requireContext) {
+        this.#resolvedContexts.set(path, requireContext);
+      } else {
+        this.#resolvedContexts.delete(path);
+      }
     }
     parentModule.dependencies.set(key, dependency);
   }
   _removeDependency(parentModule, key, dependency, delta, options) {
     parentModule.dependencies.delete(key);
-    const { absolutePath } = dependency;
-    if (dependency.data.data.asyncType === "weak") {
+    if (
+      !(0, _isResolvedDependency.isResolvedDependency)(dependency) ||
+      dependency.data.data.asyncType === "weak"
+    ) {
       return;
     }
+    const { absolutePath } = dependency;
     const module = this.dependencies.get(absolutePath);
     if (options.lazy && dependency.data.data.asyncType != null) {
       this._decrementImportBundleReference(dependency, parentModule);
@@ -380,6 +388,9 @@ class Graph {
     }
     module.dependencies.forEach((dependency) => {
       const path = dependency.absolutePath;
+      if (path == null) {
+        return;
+      }
       const childModule = this.dependencies.get(path);
       if (!childModule) {
         if (dependency.data.data.asyncType != null || options.shallow) {
@@ -418,7 +429,10 @@ class Graph {
   }
   *_children(module, options) {
     for (const dependency of module.dependencies.values()) {
-      if (isWeakOrLazy(dependency, options)) {
+      if (
+        !(0, _isResolvedDependency.isResolvedDependency)(dependency) ||
+        isWeakOrLazy(dependency, options)
+      ) {
         continue;
       }
       yield nullthrows(this.dependencies.get(dependency.absolutePath));
@@ -429,6 +443,9 @@ class Graph {
       module;
     const resolvedContexts = new Map();
     for (const [key, dependency] of dependencies) {
+      if (!(0, _isResolvedDependency.isResolvedDependency)(dependency)) {
+        continue;
+      }
       const resolvedContext = this.#resolvedContexts.get(
         dependency.absolutePath
       );
@@ -452,6 +469,9 @@ class Graph {
       delta.baseModuleData.set(module.path, this._moduleSnapshot(module));
     }
     for (const [key, dependency] of module.dependencies) {
+      if (!(0, _isResolvedDependency.isResolvedDependency)(dependency)) {
+        continue;
+      }
       this._removeDependency(module, key, dependency, delta, options);
     }
     this.#gc.color.set(module.path, "black");
@@ -542,6 +562,9 @@ class Graph {
     if (color === "white" && !this.#gc.possibleCycleRoots.has(module.path)) {
       this.#gc.color.set(module.path, "black");
       for (const dependency of module.dependencies.values()) {
+        if (!(0, _isResolvedDependency.isResolvedDependency)(dependency)) {
+          continue;
+        }
         const childModule = this.dependencies.get(dependency.absolutePath);
         if (childModule) {
           this._collectWhite(childModule, delta);

package/src/DeltaBundler/Graph.js.flow

@@ -39,11 +39,13 @@ import type {
   Module,
   ModuleData,
   Options,
+  ResolvedDependency,
   TransformInputOptions,
 } from './types.flow';
 
 import {fileMatchesContext} from '../lib/contextModule';
 import CountingSet from '../lib/CountingSet';
+import {isResolvedDependency} from '../lib/isResolvedDependency';
 import {buildSubgraph} from './buildSubgraph';
 
 const invariant = require('invariant');
@@ -121,7 +123,7 @@ function getInternalOptions<T>({
 }
 
 function isWeakOrLazy<T>(
-  dependency: Dependency,
+  dependency: ResolvedDependency,
   options: InternalOptions<T>,
 ): boolean {
   const asyncType = dependency.data.data.asyncType;
@@ -355,7 +357,7 @@ export class Graph<T = MixedOutput> {
         options.onDependencyAdded();
         return result;
       },
-      shouldTraverse: (dependency: Dependency) => {
+      shouldTraverse: (dependency: ResolvedDependency) => {
         if (options.shallow || isWeakOrLazy(dependency, options)) {
           return false;
         }
@@ -510,14 +512,11 @@ export class Graph<T = MixedOutput> {
     delta: Delta<T>,
     options: InternalOptions<T>,
   ): void {
-    const path = dependency.absolutePath;
-
-    // The module may already exist, in which case we just need to update some
-    // bookkeeping instead of adding a new node to the graph.
-    let module = this.dependencies.get(path);
-
     if (options.shallow) {
       // Don't add a node for the module if the graph is shallow (single-module).
+    } else if (!isResolvedDependency(dependency)) {
+      // If the dependency is a missing optional dependency, it has no node of
+      // its own. We just need to add it to the parent's dependency map.
     } else if (dependency.data.data.asyncType === 'weak') {
       // Exclude weak dependencies from the bundle.
     } else if (options.lazy && dependency.data.data.asyncType != null) {
@@ -526,6 +525,11 @@ export class Graph<T = MixedOutput> {
       // importBundleNodes.
       this._incrementImportBundleReference(dependency, parentModule);
     } else {
+      // The module may already exist, in which case we just need to update some
+      // bookkeeping instead of adding a new node to the graph.
+      const path = dependency.absolutePath;
+      let module = this.dependencies.get(path);
+
       if (!module) {
         try {
           module = this._recursivelyCommitModule(path, delta, options);
@@ -550,12 +554,15 @@ export class Graph<T = MixedOutput> {
       this._markModuleInUse(module);
     }
 
-    if (requireContext) {
-      this.#resolvedContexts.set(path, requireContext);
-    } else {
-      // This dependency may have existed previously as a require.context -
-      // clean it up.
-      this.#resolvedContexts.delete(path);
+    if (isResolvedDependency(dependency)) {
+      const path = dependency.absolutePath;
+      if (requireContext) {
+        this.#resolvedContexts.set(path, requireContext);
+      } else {
+        // This dependency may have existed previously as a require.context -
+        // clean it up.
+        this.#resolvedContexts.delete(path);
+      }
     }
 
     // Update the parent's dependency map unless we failed to add a dependency.
@@ -574,13 +581,16 @@ export class Graph<T = MixedOutput> {
   ): void {
     parentModule.dependencies.delete(key);
 
-    const {absolutePath} = dependency;
-
-    if (dependency.data.data.asyncType === 'weak') {
-      // Weak dependencies are excluded from the bundle.
+    if (
+      !isResolvedDependency(dependency) ||
+      dependency.data.data.asyncType === 'weak'
+    ) {
+      // Weak and unresolved dependencies are excluded from the bundle.
       return;
     }
 
+    const {absolutePath} = dependency;
+
     const module = this.dependencies.get(absolutePath);
 
     if (options.lazy && dependency.data.data.asyncType != null) {
@@ -671,8 +681,12 @@ export class Graph<T = MixedOutput> {
       orderedDependencies.set(module.path, module);
     }
 
-    module.dependencies.forEach((dependency: Dependency) => {
+    module.dependencies.forEach(dependency => {
       const path = dependency.absolutePath;
+      if (path == null) {
+        // If the dependency is not a missing optional dependency, it has no children to reorder.
+        return;
+      }
       const childModule = this.dependencies.get(path);
 
       if (!childModule) {
@@ -691,7 +705,7 @@ export class Graph<T = MixedOutput> {
 
   // Add an entry to importBundleNodes (or record an inverse dependency of an existing one)
   _incrementImportBundleReference(
-    dependency: Dependency,
+    dependency: ResolvedDependency,
     parentModule: Module<T>,
   ) {
     const {absolutePath} = dependency;
@@ -704,7 +718,7 @@ export class Graph<T = MixedOutput> {
 
   // Decrease the reference count of an entry in importBundleNodes (and delete it if necessary)
   _decrementImportBundleReference(
-    dependency: Dependency,
+    dependency: ResolvedDependency,
     parentModule: Module<T>,
   ) {
     const {absolutePath} = dependency;
@@ -734,7 +748,10 @@ export class Graph<T = MixedOutput> {
     options: InternalOptions<T>,
   ): Iterator<Module<T>> {
     for (const dependency of module.dependencies.values()) {
-      if (isWeakOrLazy(dependency, options)) {
+      if (
+        !isResolvedDependency(dependency) ||
+        isWeakOrLazy(dependency, options)
+      ) {
         continue;
       }
       yield nullthrows(this.dependencies.get(dependency.absolutePath));
@@ -747,6 +764,9 @@ export class Graph<T = MixedOutput> {
 
     const resolvedContexts: Map<string, RequireContext> = new Map();
     for (const [key, dependency] of dependencies) {
+      if (!isResolvedDependency(dependency)) {
+        continue;
+      }
       const resolvedContext = this.#resolvedContexts.get(
         dependency.absolutePath,
       );
@@ -783,6 +803,10 @@ export class Graph<T = MixedOutput> {
     }
 
     for (const [key, dependency] of module.dependencies) {
+      if (!isResolvedDependency(dependency)) {
+        // If the dependency is not a missing optional dependency, it has no children to remove.
+        continue;
+      }
       this._removeDependency(module, key, dependency, delta, options);
     }
     this.#gc.color.set(module.path, 'black');
@@ -894,6 +918,9 @@ export class Graph<T = MixedOutput> {
     if (color === 'white' && !this.#gc.possibleCycleRoots.has(module.path)) {
       this.#gc.color.set(module.path, 'black');
       for (const dependency of module.dependencies.values()) {
+        if (!isResolvedDependency(dependency)) {
+          continue;
+        }
         const childModule = this.dependencies.get(dependency.absolutePath);
         // The child may already have been collected.
         if (childModule) {

package/src/DeltaBundler/Serializers/getRamBundleInfo.js.flow

@@ -169,6 +169,7 @@ async function _getRamOptions(
   );
 
   return {
+    // $FlowFixMe[sketchy-null-bool]
     preloadedModules: preloadedModules || {},
     ramGroups: ramGroups || [],
   };

package/src/DeltaBundler/Serializers/helpers/getTransitiveDependencies.js

@@ -1,5 +1,6 @@
 "use strict";
 
+var _isResolvedDependency = require("../../../lib/isResolvedDependency");
 function getTransitiveDependencies(path, graph) {
   const dependencies = _getDeps(path, graph, new Set());
   dependencies.delete(path);
@@ -15,7 +16,9 @@ function _getDeps(path, graph, deps) {
   }
   deps.add(path);
   for (const dependency of module.dependencies.values()) {
-    _getDeps(dependency.absolutePath, graph, deps);
+    if ((0, _isResolvedDependency.isResolvedDependency)(dependency)) {
+      _getDeps(dependency.absolutePath, graph, deps);
+    }
   }
   return deps;
 }

package/src/DeltaBundler/Serializers/helpers/getTransitiveDependencies.js.flow

@@ -13,6 +13,8 @@
 
 import type {ReadOnlyGraph} from '../../types.flow';
 
+import {isResolvedDependency} from '../../../lib/isResolvedDependency';
+
 function getTransitiveDependencies<T>(
   path: string,
   graph: ReadOnlyGraph<T>,
@@ -44,7 +46,9 @@ function _getDeps<T>(
   deps.add(path);
 
   for (const dependency of module.dependencies.values()) {
-    _getDeps(dependency.absolutePath, graph, deps);
+    if (isResolvedDependency(dependency)) {
+      _getDeps(dependency.absolutePath, graph, deps);
+    }
   }
 
   return deps;

package/src/DeltaBundler/Serializers/helpers/js.js

@@ -1,5 +1,6 @@
 "use strict";
 
+const { isResolvedDependency } = require("../../../lib/isResolvedDependency");
 const invariant = require("invariant");
 const jscSafeUrl = require("jsc-safe-url");
 const { addParamsToDefineCall } = require("metro-transform-plugins");
@@ -18,6 +19,9 @@ function getModuleParams(module, options) {
   let hasPaths = false;
   const dependencyMapArray = Array.from(module.dependencies.values()).map(
     (dependency) => {
+      if (!isResolvedDependency(dependency)) {
+        return null;
+      }
       const id = options.createModuleId(dependency.absolutePath);
       if (options.includeAsyncPaths && dependency.data.data.asyncType != null) {
         hasPaths = true;

package/src/DeltaBundler/Serializers/helpers/js.js.flow

@@ -14,6 +14,7 @@
 import type {MixedOutput, Module} from '../../types.flow';
 import type {JsOutput} from 'metro-transform-worker';
 
+const {isResolvedDependency} = require('../../../lib/isResolvedDependency');
 const invariant = require('invariant');
 const jscSafeUrl = require('jsc-safe-url');
 const {addParamsToDefineCall} = require('metro-transform-plugins');
@@ -47,6 +48,11 @@ function getModuleParams(module: Module<>, options: Options): Array<mixed> {
   let hasPaths = false;
   const dependencyMapArray = Array.from(module.dependencies.values()).map(
     dependency => {
+      if (!isResolvedDependency(dependency)) {
+        // An unresolved dependency, which should cause a runtime error
+        // when required.
+        return null;
+      }
       const id = options.createModuleId(dependency.absolutePath);
       if (options.includeAsyncPaths && dependency.data.data.asyncType != null) {
         hasPaths = true;

package/src/DeltaBundler/Transformer.js

@@ -7,6 +7,7 @@ function _interopRequireDefault(e) {
 const getTransformCacheKey = require("./getTransformCacheKey");
 const WorkerFarm = require("./WorkerFarm");
 const assert = require("assert");
+const debug = require("debug")("Metro:Transformer");
 const fs = require("fs");
 const { Cache, stableHash } = require("metro-cache");
 const path = require("path");
@@ -35,7 +36,9 @@ class Transformer {
           projectRoot: this._config.projectRoot,
           transformerConfig: transformerOptions,
         });
-    this._baseHash = stableHash([globalCacheKey]).toString("binary");
+    const baseHashBuffer = stableHash([globalCacheKey]);
+    this._baseHash = baseHashBuffer.toString("binary");
+    debug("Base hash: %s", baseHashBuffer.toString("hex"));
   }
   async transformFile(filePath, transformerOptions, fileBuffer) {
     const cache = this._cache;

package/src/DeltaBundler/Transformer.js.flow

@@ -20,11 +20,14 @@ import crypto from 'crypto';
 const getTransformCacheKey = require('./getTransformCacheKey');
 const WorkerFarm = require('./WorkerFarm');
 const assert = require('assert');
+const debug = require('debug')('Metro:Transformer');
 const fs = require('fs');
 const {Cache, stableHash} = require('metro-cache');
 const path = require('path');
 
-type GetOrComputeSha1Fn = string => Promise<{content?: Buffer, sha1: string}>;
+type GetOrComputeSha1Fn = string => Promise<
+  $ReadOnly<{content?: Buffer, sha1: string}>,
+>;
 
 class Transformer {
   _config: ConfigT;
@@ -69,7 +72,9 @@ class Transformer {
           transformerConfig: transformerOptions,
         });
 
-    this._baseHash = stableHash([globalCacheKey]).toString('binary');
+    const baseHashBuffer = stableHash([globalCacheKey]);
+    this._baseHash = baseHashBuffer.toString('binary');
+    debug('Base hash: %s', baseHashBuffer.toString('hex'));
   }
 
   async transformFile(

package/src/DeltaBundler/Worker.flow.js.flow

@@ -109,7 +109,7 @@ async function transformFile(
     transformerConfig.transformerPath,
   );
 
-  const transformFileStartLogEntry = {
+  const transformFileStartLogEntry: LogEntry = {
     action_name: 'Transforming file',
     action_phase: 'start',
     file_name: filename,

package/src/DeltaBundler/buildSubgraph.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.buildSubgraph = buildSubgraph;
 var _contextModule = require("../lib/contextModule");
+var _isResolvedDependency = require("../lib/isResolvedDependency");
 var _path = _interopRequireDefault(require("path"));
 function _interopRequireDefault(e) {
   return e && e.__esModule ? e : { default: e };
@@ -13,7 +14,7 @@ function resolveDependencies(parentPath, dependencies, resolve) {
   const maybeResolvedDeps = new Map();
   const resolvedContexts = new Map();
   for (const dep of dependencies) {
-    let resolvedDep;
+    let maybeResolvedDep;
     const key = dep.data.key;
     const { contextParams } = dep.data;
     if (contextParams) {
@@ -32,13 +33,13 @@ function resolveDependencies(parentPath, dependencies, resolve) {
         ),
       };
       resolvedContexts.set(key, resolvedContext);
-      resolvedDep = {
+      maybeResolvedDep = {
         absolutePath,
         data: dep,
       };
     } else {
       try {
-        resolvedDep = {
+        maybeResolvedDep = {
           absolutePath: resolve(parentPath, dep).filePath,
           data: dep,
         };
@@ -46,6 +47,9 @@ function resolveDependencies(parentPath, dependencies, resolve) {
         if (dep.data.isOptional !== true) {
           throw error;
         }
+        maybeResolvedDep = {
+          data: dep,
+        };
       }
     }
     if (maybeResolvedDeps.has(key)) {
@@ -53,16 +57,10 @@ function resolveDependencies(parentPath, dependencies, resolve) {
         `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`
       );
     }
-    maybeResolvedDeps.set(key, resolvedDep);
-  }
-  const resolvedDeps = new Map();
-  for (const [key, resolvedDep] of maybeResolvedDeps) {
-    if (resolvedDep) {
-      resolvedDeps.set(key, resolvedDep);
-    }
+    maybeResolvedDeps.set(key, maybeResolvedDep);
   }
   return {
-    dependencies: resolvedDeps,
+    dependencies: maybeResolvedDeps,
     resolvedContexts,
   };
 }
@@ -90,9 +88,13 @@ async function buildSubgraph(
       ...resolutionResult,
     });
     await Promise.all(
-      [...resolutionResult.dependencies]
-        .filter(([key, dependency]) => shouldTraverse(dependency))
-        .map(([key, dependency]) =>
+      [...resolutionResult.dependencies.values()]
+        .filter(
+          (dependency) =>
+            (0, _isResolvedDependency.isResolvedDependency)(dependency) &&
+            shouldTraverse(dependency)
+        )
+        .map((dependency) =>
           visit(
             dependency.absolutePath,
             resolutionResult.resolvedContexts.get(dependency.data.data.key)

package/src/DeltaBundler/buildSubgraph.js.flow

@@ -12,18 +12,20 @@ import type {RequireContext} from '../lib/contextModule';
 import type {
   Dependency,
   ModuleData,
+  ResolvedDependency,
   ResolveFn,
   TransformFn,
   TransformResultDependency,
 } from './types.flow';
 
 import {deriveAbsolutePathFromContext} from '../lib/contextModule';
+import {isResolvedDependency} from '../lib/isResolvedDependency';
 import path from 'path';
 
 type Parameters<T> = $ReadOnly<{
   resolve: ResolveFn,
   transform: TransformFn<T>,
-  shouldTraverse: Dependency => boolean,
+  shouldTraverse: ResolvedDependency => boolean,
 }>;
 
 function resolveDependencies(
@@ -34,11 +36,11 @@ function resolveDependencies(
   dependencies: Map<string, Dependency>,
   resolvedContexts: Map<string, RequireContext>,
 } {
-  const maybeResolvedDeps = new Map<string, void | Dependency>();
+  const maybeResolvedDeps = new Map<string, Dependency>();
   const resolvedContexts = new Map<string, RequireContext>();
 
   for (const dep of dependencies) {
-    let resolvedDep;
+    let maybeResolvedDep: Dependency;
     const key = dep.data.key;
 
     // `require.context`
@@ -61,13 +63,13 @@ function resolveDependencies(
 
       resolvedContexts.set(key, resolvedContext);
 
-      resolvedDep = {
+      maybeResolvedDep = {
         absolutePath,
         data: dep,
       };
     } else {
       try {
-        resolvedDep = {
+        maybeResolvedDep = {
           absolutePath: resolve(parentPath, dep).filePath,
           data: dep,
         };
@@ -77,6 +79,9 @@ function resolveDependencies(
         if (dep.data.isOptional !== true) {
           throw error;
         }
+        maybeResolvedDep = {
+          data: dep,
+        };
       }
     }
 
@@ -85,21 +90,13 @@ function resolveDependencies(
         `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`,
       );
     }
-    maybeResolvedDeps.set(key, resolvedDep);
+    maybeResolvedDeps.set(key, maybeResolvedDep);
   }
 
-  const resolvedDeps = new Map<string, Dependency>();
-  // Return just the dependencies we successfully resolved.
-  // FIXME: This has a bad bug affecting all dependencies *after* an unresolved
-  // optional dependency. We'll need to propagate the nulls all the way to the
-  // serializer and the require() runtime to keep the dependency map from being
-  // desynced from the contents of the module.
-  for (const [key, resolvedDep] of maybeResolvedDeps) {
-    if (resolvedDep) {
-      resolvedDeps.set(key, resolvedDep);
-    }
-  }
-  return {dependencies: resolvedDeps, resolvedContexts};
+  return {
+    dependencies: maybeResolvedDeps,
+    resolvedContexts,
+  };
 }
 
 export async function buildSubgraph<T>(
@@ -138,9 +135,12 @@ export async function buildSubgraph<T>(
     });
 
     await Promise.all(
-      [...resolutionResult.dependencies]
-        .filter(([key, dependency]) => shouldTraverse(dependency))
-        .map(([key, dependency]) =>
+      [...resolutionResult.dependencies.values()]
+        .filter(
+          dependency =>
+            isResolvedDependency(dependency) && shouldTraverse(dependency),
+        )
+        .map(dependency =>
           visit(
             dependency.absolutePath,
             resolutionResult.resolvedContexts.get(dependency.data.data.key),