metro 0.80.2 → 0.80.3

package/src/DeltaBundler/Graph.js.flow

@@ -37,17 +37,14 @@ import type {
   GraphInputOptions,
   MixedOutput,
   Module,
+  ModuleData,
   Options,
   TransformInputOptions,
-  TransformResultDependency,
 } from './types.flow';
 
-import {
-  deriveAbsolutePathFromContext,
-  fileMatchesContext,
-} from '../lib/contextModule';
+import {fileMatchesContext} from '../lib/contextModule';
 import CountingSet from '../lib/CountingSet';
-import * as path from 'path';
+import {buildSubgraph} from './buildSubgraph';
 
 const invariant = require('invariant');
 const nullthrows = require('nullthrows');
@@ -80,17 +77,18 @@ export type Result<T> = {
  * files have been modified. This allows to return the added modules before the
  * modified ones (which is useful for things like Hot Module Reloading).
  **/
-type Delta = $ReadOnly<{
+type Delta<T> = $ReadOnly<{
   // `added` and `deleted` are mutually exclusive.
-  // Internally, a module can be in both `modified` and (either) `added` or
-  // `deleted`. We fix this up before returning the delta to the client.
+  // Internally, a module can be in both `touched` and (either) `added` or
+  // `deleted`. Before returning the result, we'll calculate
+  // modified = touched - added - deleted.
   added: Set<string>,
-  modified: Set<string>,
+  touched: Set<string>,
   deleted: Set<string>,
 
-  // A place to temporarily track inverse dependencies for a module while it is
-  // being processed but has not been added to `graph.dependencies` yet.
-  earlyInverseDependencies: Map<string, CountingSet<string>>,
+  updatedModuleData: $ReadOnlyMap<string, ModuleData<T>>,
+  baseModuleData: Map<string, ModuleData<T>>,
+  errors: $ReadOnlyMap<string, Error>,
 }>;
 
 type InternalOptions<T> = $ReadOnly<{
@@ -122,6 +120,14 @@ function getInternalOptions<T>({
   };
 }
 
+function isWeakOrLazy<T>(
+  dependency: Dependency,
+  options: InternalOptions<T>,
+): boolean {
+  const asyncType = dependency.data.data.asyncType;
+  return asyncType === 'weak' || (asyncType != null && options.lazy);
+}
+
 export class Graph<T = MixedOutput> {
   +entryPoints: $ReadOnlySet<string>;
   +transformOptions: TransformInputOptions;
@@ -165,87 +171,124 @@ export class Graph<T = MixedOutput> {
     paths: $ReadOnlyArray<string>,
     options: Options<T>,
   ): Promise<Result<T>> {
-    const delta = {
-      added: new Set<string>(),
-      modified: new Set<string>(),
-      deleted: new Set<string>(),
-      earlyInverseDependencies: new Map<string, CountingSet<string>>(),
-    };
-
     const internalOptions = getInternalOptions(options);
 
-    // Record the paths that are part of the dependency graph before we start
-    // traversing - we'll use this to ensure we don't report modules modified
-    // that only exist as part of the graph mid-traversal, and to eliminate
-    // modules that end up in the same state that they started from the delta.
-    const originalModules = new Map<string, Module<T>>();
-    for (const path of paths) {
-      const originalModule = this.dependencies.get(path);
-      if (originalModule) {
-        originalModules.set(path, originalModule);
+    const modifiedPathsInBaseGraph = new Set(
+      paths.filter(path => this.dependencies.has(path)),
+    );
+
+    const allModifiedPaths = new Set(paths);
+
+    const delta = await this._buildDelta(
+      modifiedPathsInBaseGraph,
+      internalOptions,
+      // Traverse new or modified paths
+      absolutePath =>
+        !this.dependencies.has(absolutePath) ||
+        allModifiedPaths.has(absolutePath),
+    );
+
+    // If we have errors we might need to roll back any changes - take
+    // snapshots of all modified modules at the base state. We'll also snapshot
+    // unmodified modules that become unreachable as they are released, so that
+    // we have everything we need to restore the graph to base.
+    if (delta.errors.size > 0) {
+      for (const modified of modifiedPathsInBaseGraph) {
+        delta.baseModuleData.set(
+          modified,
+          this._moduleSnapshot(nullthrows(this.dependencies.get(modified))),
+        );
       }
     }
 
-    for (const [path] of originalModules) {
-      // Traverse over modules that are part of the dependency graph.
-      //
-      // Note: A given path may not be part of the graph *at this time*, in
-      // particular it may have been removed since we started traversing, but
-      // in that case the path will be visited if and when we add it back to
-      // the graph in a subsequent iteration.
-      if (this.dependencies.has(path)) {
-        await this._traverseDependenciesForSingleFile(
-          path,
-          delta,
-          internalOptions,
-        );
+    // Commit changes in a subtractive pass and then an additive pass - this
+    // ensures that any errors encountered on the additive pass would also be
+    // encountered on a fresh build (implying legitimate errors in the graph,
+    // rather than an error in a module that's no longer reachable).
+    for (const modified of modifiedPathsInBaseGraph) {
+      // Skip this module if it has errors. Hopefully it will be removed -
+      // if not, we'll throw during the additive pass.
+      if (delta.errors.has(modified)) {
+        continue;
+      }
+      const module = this.dependencies.get(modified);
+      // The module may have already been released from the graph - we'll readd
+      // it if necessary later.
+      if (module == null) {
+        continue;
       }
+      // Process the transform result and dependency removals. This should
+      // never encounter an error.
+      this._recursivelyCommitModule(modified, delta, internalOptions, {
+        onlyRemove: true,
+      });
     }
 
+    // Ensure we have released any unreachable modules before the additive
+    // pass.
     this._collectCycles(delta, internalOptions);
 
+    // Additive pass - any errors we encounter here should be thrown after
+    // rolling back the commit.
+    try {
+      for (const modified of modifiedPathsInBaseGraph) {
+        const module = this.dependencies.get(modified);
+        // The module may have already been released from the graph (it may yet
+        // be readded via another dependency).
+        if (module == null) {
+          continue;
+        }
+
+        this._recursivelyCommitModule(modified, delta, internalOptions);
+      }
+    } catch (error) {
+      // Roll back to base before re-throwing.
+      const rollbackDelta: Delta<T> = {
+        added: delta.added,
+        deleted: delta.deleted,
+        touched: new Set(),
+        updatedModuleData: delta.baseModuleData,
+        baseModuleData: new Map(),
+        errors: new Map(),
+      };
+      for (const modified of modifiedPathsInBaseGraph) {
+        const module = this.dependencies.get(modified);
+        // The module may have already been released from the graph (it may yet
+        // be readded via another dependency).
+        if (module == null) {
+          continue;
+        }
+        // Set the module and descendants back to base state.
+        this._recursivelyCommitModule(modified, rollbackDelta, internalOptions);
+      }
+      // Collect cycles again after rolling back. There's no need if we're
+      // not rolling back, because we have not removed any edges.
+      this._collectCycles(delta, internalOptions);
+
+      // Cheap check to validate the rollback.
+      invariant(
+        rollbackDelta.added.size === 0 && rollbackDelta.deleted.size === 0,
+        'attempted to roll back a graph commit but there were still changes',
+      );
+
+      // Re-throw the transform or resolution error originally seen by
+      // `buildSubgraph`.
+      throw error;
+    }
+
     const added = new Map<string, Module<T>>();
     for (const path of delta.added) {
       added.set(path, nullthrows(this.dependencies.get(path)));
     }
 
     const modified = new Map<string, Module<T>>();
-
-    // A path in delta.modified has been processed during this traversal,
-    // but may not actually differ, may be new, or may have been deleted after
-    // processing. The actually-modified modules are the intersection of
-    // delta.modified with the pre-existing paths, minus modules deleted.
-    for (const [path, originalModule] of originalModules) {
-      invariant(
-        !delta.added.has(path),
-        'delta.added has %s, but this path was already in the graph.',
-        path,
-      );
-      if (delta.modified.has(path)) {
-        // It's expected that a module may be both modified and subsequently
-        // deleted - we'll only return it as deleted.
-        if (!delta.deleted.has(path)) {
-          // If a module existed before and has not been deleted, it must be
-          // in the dependencies map.
-          const newModule = nullthrows(this.dependencies.get(path));
-          if (
-            // Module.dependencies is mutable, so it's not obviously the case
-            // that referential equality implies no modification. However, we
-            // only mutate dependencies in two cases:
-            // 1. Within _processModule. In that case, we always mutate a new
-            //    module and set a new reference in this.dependencies.
-            // 2. During _releaseModule, when recursively removing
-            //    dependencies. In that case, we immediately discard the module
-            //    object.
-            // TODO: Refactor for more explicit immutability
-            newModule !== originalModule ||
-            transfromOutputMayDiffer(newModule, originalModule) ||
-            // $FlowFixMe[incompatible-call]
-            !allDependenciesEqual(newModule, originalModule)
-          ) {
-            modified.set(path, newModule);
-          }
-        }
+    for (const path of modifiedPathsInBaseGraph) {
+      if (
+        delta.touched.has(path) &&
+        !delta.deleted.has(path) &&
+        !delta.added.has(path)
+      ) {
+        modified.set(path, nullthrows(this.dependencies.get(path)));
       }
     }
 
@@ -257,13 +300,6 @@ export class Graph<T = MixedOutput> {
   }
 
   async initialTraverseDependencies(options: Options<T>): Promise<Result<T>> {
-    const delta = {
-      added: new Set<string>(),
-      modified: new Set<string>(),
-      deleted: new Set<string>(),
-      earlyInverseDependencies: new Map<string, CountingSet<string>>(),
-    };
-
     const internalOptions = getInternalOptions(options);
 
     invariant(
@@ -280,11 +316,20 @@ export class Graph<T = MixedOutput> {
       this.#gc.color.set(path, 'black');
     }
 
-    await Promise.all(
-      [...this.entryPoints].map((path: string) =>
-        this._traverseDependenciesForSingleFile(path, delta, internalOptions),
-      ),
-    );
+    const delta = await this._buildDelta(this.entryPoints, internalOptions);
+
+    if (delta.errors.size > 0) {
+      // If we encountered any errors during traversal, throw one of them.
+      // Since errors are encountered in a non-deterministic order, even on
+      // fresh builds, it's valid to arbitrarily pick the first.
+      throw delta.errors.values().next().value;
+    }
+
+    for (const path of this.entryPoints) {
+      // We have already thrown on userland errors in the delta, so any error
+      // encountered here would be exceptional and fatal.
+      this._recursivelyCommitModule(path, delta, internalOptions);
+    }
 
     this.reorderGraph({
       shallow: options.shallow,
@@ -297,56 +342,85 @@ export class Graph<T = MixedOutput> {
     };
   }
 
-  async _traverseDependenciesForSingleFile(
-    path: string,
-    delta: Delta,
+  async _buildDelta(
+    pathsToVisit: $ReadOnlySet<string>,
     options: InternalOptions<T>,
-  ): Promise<void> {
-    options.onDependencyAdd();
-
-    await this._processModule(path, delta, options);
+    moduleFilter?: (path: string) => boolean,
+  ): Promise<Delta<T>> {
+    const subGraph = await buildSubgraph(pathsToVisit, this.#resolvedContexts, {
+      resolve: options.resolve,
+      transform: async (absolutePath, requireContext) => {
+        options.onDependencyAdd();
+        const result = await options.transform(absolutePath, requireContext);
+        options.onDependencyAdded();
+        return result;
+      },
+      shouldTraverse: (dependency: Dependency) => {
+        if (options.shallow || isWeakOrLazy(dependency, options)) {
+          return false;
+        }
+        return moduleFilter == null || moduleFilter(dependency.absolutePath);
+      },
+    });
 
-    options.onDependencyAdded();
+    return {
+      added: new Set(),
+      touched: new Set(),
+      deleted: new Set(),
+      updatedModuleData: subGraph.moduleData,
+      baseModuleData: new Map(),
+      errors: subGraph.errors,
+    };
   }
 
-  async _processModule(
+  _recursivelyCommitModule(
     path: string,
-    delta: Delta,
+    delta: Delta<T>,
     options: InternalOptions<T>,
-  ): Promise<Module<T>> {
-    const resolvedContext = this.#resolvedContexts.get(path);
-
-    // Transform the file via the given option.
-    // TODO: Unbind the transform method from options
-    const result = await options.transform(path, resolvedContext);
-
-    // Get the absolute path of all sub-dependencies (some of them could have been
-    // moved but maintain the same relative path).
-    const currentDependencies = this._resolveDependencies(
-      path,
-      result.dependencies,
-      options,
-    );
+    commitOptions: $ReadOnly<{
+      onlyRemove: boolean,
+    }> = {onlyRemove: false},
+  ): Module<T> {
+    if (delta.errors.has(path)) {
+      throw delta.errors.get(path);
+    }
 
     const previousModule = this.dependencies.get(path);
+    const currentModule: ModuleData<T> = nullthrows(
+      delta.updatedModuleData.get(path) ?? delta.baseModuleData.get(path),
+    );
 
     const previousDependencies = previousModule?.dependencies ?? new Map();
+    const {
+      dependencies: currentDependencies,
+      resolvedContexts,
+      ...transformResult
+    } = currentModule;
 
     const nextModule = {
       ...(previousModule ?? {
-        inverseDependencies:
-          delta.earlyInverseDependencies.get(path) ?? new CountingSet(),
+        inverseDependencies: new CountingSet(),
         path,
       }),
+      ...transformResult,
       dependencies: new Map(previousDependencies),
-      getSource: result.getSource,
-      output: result.output,
-      unstable_transformResultKey: result.unstable_transformResultKey,
     };
 
     // Update the module information.
     this.dependencies.set(nextModule.path, nextModule);
 
+    if (previousModule == null) {
+      // If the module is not currently in the graph, it is either new or was
+      // released earlier in the commit.
+      if (delta.deleted.has(path)) {
+        // Mark the addition by clearing a prior deletion.
+        delta.deleted.delete(path);
+      } else {
+        // Mark the addition in the added set.
+        delta.added.add(path);
+      }
+    }
+
     // Diff dependencies (1/2): remove dependencies that have changed or been removed.
     let dependenciesRemoved = false;
     for (const [key, prevDependency] of previousDependencies) {
@@ -361,40 +435,51 @@ export class Graph<T = MixedOutput> {
     }
 
     // Diff dependencies (2/2): add dependencies that have changed or been added.
-    const addDependencyPromises = [];
-    for (const [key, curDependency] of currentDependencies) {
-      const prevDependency = previousDependencies.get(key);
-      if (
-        !prevDependency ||
-        !dependenciesEqual(prevDependency, curDependency, options)
-      ) {
-        addDependencyPromises.push(
-          this._addDependency(nextModule, key, curDependency, delta, options),
-        );
+    let dependenciesAdded = false;
+    if (!commitOptions.onlyRemove) {
+      for (const [key, curDependency] of currentDependencies) {
+        const prevDependency = previousDependencies.get(key);
+        if (
+          !prevDependency ||
+          !dependenciesEqual(prevDependency, curDependency, options)
+        ) {
+          dependenciesAdded = true;
+          this._addDependency(
+            nextModule,
+            key,
+            curDependency,
+            resolvedContexts.get(key),
+            delta,
+            options,
+          );
+        }
       }
     }
 
     if (
-      previousModule &&
-      !transfromOutputMayDiffer(previousModule, nextModule) &&
+      previousModule != null &&
+      !transformOutputMayDiffer(previousModule, nextModule) &&
       !dependenciesRemoved &&
-      addDependencyPromises.length === 0
+      !dependenciesAdded
     ) {
       // We have not operated on nextModule, so restore previousModule
-      // to aid diffing.
+      // to aid diffing. Don't add this path to delta.touched.
       this.dependencies.set(previousModule.path, previousModule);
       return previousModule;
     }
 
-    delta.modified.add(path);
+    delta.touched.add(path);
 
-    await Promise.all(addDependencyPromises);
+    // Replace dependencies with the correctly-ordered version, matching the
+    // transform output. Because this assignment does not add or remove edges,
+    // it does NOT invalidate any of the garbage collection state.
 
-    // Replace dependencies with the correctly-ordered version. As long as all
-    // the above promises have resolved, this will be the same map but without
-    // the added nondeterminism of promise resolution order. Because this
-    // assignment does not add or remove edges, it does NOT invalidate any of the
-    // garbage collection state.
+    // A subtractive pass only partially commits modules, so our dependencies
+    // are not generally complete yet. We'll address ordering in the next pass
+    // after processing additions.
+    if (commitOptions.onlyRemove) {
+      return nextModule;
+    }
 
     // Catch obvious errors with a cheap assertion.
     invariant(
@@ -402,18 +487,19 @@ export class Graph<T = MixedOutput> {
       'Failed to add the correct dependencies',
     );
 
-    nextModule.dependencies = currentDependencies;
+    nextModule.dependencies = new Map(currentDependencies);
 
     return nextModule;
   }
 
-  async _addDependency(
+  _addDependency(
     parentModule: Module<T>,
     key: string,
     dependency: Dependency,
-    delta: Delta,
+    requireContext: ?RequireContext,
+    delta: Delta<T>,
     options: InternalOptions<T>,
-  ): Promise<void> {
+  ): void {
     const path = dependency.absolutePath;
 
     // The module may already exist, in which case we just need to update some
@@ -431,38 +517,38 @@ export class Graph<T = MixedOutput> {
       this._incrementImportBundleReference(dependency, parentModule);
     } else {
       if (!module) {
-        // Add a new node to the graph.
-        const earlyInverseDependencies =
-          delta.earlyInverseDependencies.get(path);
-        if (earlyInverseDependencies) {
-          // This module is being transformed at the moment in parallel, so we
-          // should only mark its parent as an inverse dependency.
-          earlyInverseDependencies.add(parentModule.path);
-        } else {
-          if (delta.deleted.has(path)) {
-            // Mark the addition by clearing a prior deletion.
-            delta.deleted.delete(path);
-          } else {
-            // Mark the addition in the added set.
-            delta.added.add(path);
+        try {
+          module = this._recursivelyCommitModule(path, delta, options);
+        } catch (error) {
+          // If we couldn't add this module but it was added to the graph
+          // before failing on a sub-dependency, it may be orphaned. Mark it as
+          // a possible garbage root.
+          const module = this.dependencies.get(path);
+          if (module) {
+            if (module.inverseDependencies.size > 0) {
+              this._markAsPossibleCycleRoot(module);
+            } else {
+              this._releaseModule(module, delta, options);
+            }
           }
-          delta.earlyInverseDependencies.set(path, new CountingSet());
-
-          options.onDependencyAdd();
-          module = await this._processModule(path, delta, options);
-          options.onDependencyAdded();
-
-          this.dependencies.set(module.path, module);
+          throw error;
         }
       }
-      if (module) {
-        // We either added a new node to the graph, or we're updating an existing one.
-        module.inverseDependencies.add(parentModule.path);
-        this._markModuleInUse(module);
-      }
+
+      // We either added a new node to the graph, or we're updating an existing one.
+      module.inverseDependencies.add(parentModule.path);
+      this._markModuleInUse(module);
     }
 
-    // Always update the parent's dependency map.
+    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.
     // This means the parent's dependencies can get desynced from
     // inverseDependencies and the other fields in the case of lazy edges.
     // Not an optimal representation :(
@@ -473,7 +559,7 @@ export class Graph<T = MixedOutput> {
     parentModule: Module<T>,
     key: string,
     dependency: Dependency,
-    delta: Delta,
+    delta: Delta<T>,
     options: InternalOptions<T>,
   ): void {
     parentModule.dependencies.delete(key);
@@ -538,84 +624,6 @@ export class Graph<T = MixedOutput> {
     yield* this.#importBundleNodes.get(filePath)?.inverseDependencies ?? [];
   }
 
-  _resolveDependencies(
-    parentPath: string,
-    dependencies: $ReadOnlyArray<TransformResultDependency>,
-    options: InternalOptions<T>,
-  ): Map<string, Dependency> {
-    const maybeResolvedDeps = new Map<
-      string,
-      void | {absolutePath: string, data: TransformResultDependency},
-    >();
-    for (const dep of dependencies) {
-      let resolvedDep;
-
-      // `require.context`
-      const {contextParams} = dep.data;
-      if (contextParams) {
-        // Ensure the filepath has uniqueness applied to ensure multiple `require.context`
-        // statements can be used to target the same file with different properties.
-        const from = path.join(parentPath, '..', dep.name);
-        const absolutePath = deriveAbsolutePathFromContext(from, contextParams);
-
-        const resolvedContext: RequireContext = {
-          from,
-          mode: contextParams.mode,
-          recursive: contextParams.recursive,
-          filter: new RegExp(
-            contextParams.filter.pattern,
-            contextParams.filter.flags,
-          ),
-        };
-
-        this.#resolvedContexts.set(absolutePath, resolvedContext);
-
-        resolvedDep = {
-          absolutePath,
-          data: dep,
-        };
-      } else {
-        try {
-          resolvedDep = {
-            absolutePath: options.resolve(parentPath, dep).filePath,
-            data: dep,
-          };
-
-          // This dependency may have existed previously as a require.context -
-          // clean it up.
-          this.#resolvedContexts.delete(resolvedDep.absolutePath);
-        } catch (error) {
-          // Ignore unavailable optional dependencies. They are guarded
-          // with a try-catch block and will be handled during runtime.
-          if (dep.data.isOptional !== true) {
-            throw error;
-          }
-        }
-      }
-
-      const key = dep.data.key;
-      if (maybeResolvedDeps.has(key)) {
-        throw new Error(
-          `resolveDependencies: Found duplicate dependency key '${key}' in ${parentPath}`,
-        );
-      }
-      maybeResolvedDeps.set(key, resolvedDep);
-    }
-
-    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 resolvedDeps;
-  }
-
   /**
    * Re-traverse the dependency graph in DFS order to reorder the modules and
    * guarantee the same order between runs. This method mutates the passed graph.
@@ -716,18 +724,54 @@ export class Graph<T = MixedOutput> {
     options: InternalOptions<T>,
   ): Iterator<Module<T>> {
     for (const dependency of module.dependencies.values()) {
-      const asyncType = dependency.data.data.asyncType;
-      if (asyncType === 'weak' || (options.lazy && asyncType != null)) {
+      if (isWeakOrLazy(dependency, options)) {
         continue;
       }
       yield nullthrows(this.dependencies.get(dependency.absolutePath));
     }
   }
 
+  _moduleSnapshot(module: Module<T>): ModuleData<T> {
+    const {dependencies, getSource, output, unstable_transformResultKey} =
+      module;
+
+    const resolvedContexts: Map<string, RequireContext> = new Map();
+    for (const [key, dependency] of dependencies) {
+      const resolvedContext = this.#resolvedContexts.get(
+        dependency.absolutePath,
+      );
+      if (resolvedContext != null) {
+        resolvedContexts.set(key, resolvedContext);
+      }
+    }
+    return {
+      dependencies: new Map(dependencies),
+      resolvedContexts,
+      getSource,
+      output,
+      unstable_transformResultKey,
+    };
+  }
+
   // Delete an unreachable module (and its outbound edges) from the graph
   // immediately.
   // Called when the reference count of a module has reached 0.
-  _releaseModule(module: Module<T>, delta: Delta, options: InternalOptions<T>) {
+  _releaseModule(
+    module: Module<T>,
+    delta: Delta<T>,
+    options: InternalOptions<T>,
+  ) {
+    if (
+      !delta.updatedModuleData.has(module.path) &&
+      !delta.baseModuleData.has(module.path)
+    ) {
+      // Before releasing a module, take a snapshot of the data we might need
+      // to reintroduce it to the graph later in this commit. As it is not
+      // already present in updatedModuleData we can infer it has not been modified,
+      // so the transform output and dependencies we copy here are current.
+      delta.baseModuleData.set(module.path, this._moduleSnapshot(module));
+    }
+
     for (const [key, dependency] of module.dependencies) {
       this._removeDependency(module, key, dependency, delta, options);
     }
@@ -736,7 +780,7 @@ export class Graph<T = MixedOutput> {
   }
 
   // Delete an unreachable module from the graph.
-  _freeModule(module: Module<T>, delta: Delta) {
+  _freeModule(module: Module<T>, delta: Delta<T>) {
     if (delta.added.has(module.path)) {
       // Mark the deletion by clearing a prior addition.
       delta.added.delete(module.path);
@@ -749,7 +793,6 @@ export class Graph<T = MixedOutput> {
     // Clean up all the state associated with this module in order to correctly
     // re-add it if we encounter it again.
     this.dependencies.delete(module.path);
-    delta.earlyInverseDependencies.delete(module.path);
     this.#gc.possibleCycleRoots.delete(module.path);
     this.#gc.color.delete(module.path);
     this.#resolvedContexts.delete(module.path);
@@ -757,14 +800,14 @@ export class Graph<T = MixedOutput> {
 
   // Mark a module as a possible cycle root
   _markAsPossibleCycleRoot(module: Module<T>) {
-    if (nullthrows(this.#gc.color.get(module.path)) !== 'purple') {
+    if (this.#gc.color.get(module.path) !== 'purple') {
       this.#gc.color.set(module.path, 'purple');
       this.#gc.possibleCycleRoots.add(module.path);
     }
   }
 
   // Collect any unreachable cycles in the graph.
-  _collectCycles(delta: Delta, options: InternalOptions<T>) {
+  _collectCycles(delta: Delta<T>, options: InternalOptions<T>) {
     // Mark recursively from roots (trial deletion)
     for (const path of this.#gc.possibleCycleRoots) {
       const module = nullthrows(this.dependencies.get(path));
@@ -836,7 +879,7 @@ export class Graph<T = MixedOutput> {
     }
   }
 
-  _collectWhite(module: Module<T>, delta: Delta) {
+  _collectWhite(module: Module<T>, delta: Delta<T>) {
     const color = nullthrows(this.#gc.color.get(module.path));
     if (color === 'white' && !this.#gc.possibleCycleRoots.has(module.path)) {
       this.#gc.color.set(module.path, 'black');
@@ -867,23 +910,6 @@ function dependenciesEqual(
   );
 }
 
-function allDependenciesEqual<T>(
-  a: Module<T>,
-  b: Module<T>,
-  options: $ReadOnly<{lazy: boolean, ...}>,
-): boolean {
-  if (a.dependencies.size !== b.dependencies.size) {
-    return false;
-  }
-  for (const [key, depA] of a.dependencies) {
-    const depB = b.dependencies.get(key);
-    if (!depB || !dependenciesEqual(depA, depB, options)) {
-      return false;
-    }
-  }
-  return true;
-}
-
 function contextParamsEqual(
   a: ?RequireContextParams,
   b: ?RequireContextParams,
@@ -900,7 +926,7 @@ function contextParamsEqual(
   );
 }
 
-function transfromOutputMayDiffer<T>(a: Module<T>, b: Module<T>): boolean {
+function transformOutputMayDiffer<T>(a: Module<T>, b: Module<T>): boolean {
   return (
     a.unstable_transformResultKey == null ||
     a.unstable_transformResultKey !== b.unstable_transformResultKey