@atlaspack/core 2.16.2-canary.5 → 2.16.2-canary.500

package/src/{RequestTracker.js → RequestTracker.ts}

@@ -1,10 +1,8 @@
-// @flow strict-local
-
 import invariant, {AssertionError} from 'assert';
 import path from 'path';
 
 import {deserialize, serialize} from '@atlaspack/build-cache';
-import {LMDBLiteCache, type Cache} from '@atlaspack/cache';
+import {Cache} from '@atlaspack/cache';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {ContentGraph} from '@atlaspack/graph';
 import type {
@@ -14,11 +12,11 @@ import type {
   SerializedContentGraph,
   Graph,
 } from '@atlaspack/graph';
-import logger, {instrument} from '@atlaspack/logger';
+import logger from '@atlaspack/logger';
 import {hashString} from '@atlaspack/rust';
 import type {Async, EnvMap} from '@atlaspack/types';
 import {
-  type Deferred,
+  Deferred,
   isGlobMatch,
   isDirectoryInside,
   makeDeferredWithPromise,
@@ -30,19 +28,19 @@ import nullthrows from 'nullthrows';
 
 import {
   ATLASPACK_VERSION,
-  VALID,
-  INITIAL_BUILD,
   FILE_CREATE,
-  FILE_UPDATE,
   FILE_DELETE,
+  FILE_UPDATE,
   ENV_CHANGE,
+  ERROR,
+  INITIAL_BUILD,
   OPTION_CHANGE,
   STARTUP,
-  ERROR,
+  VALID,
 } from './constants';
 import type {AtlaspackV3} from './atlaspack-v3/AtlaspackV3';
 import {
-  type ProjectPath,
+  ProjectPath,
   fromProjectPathRelative,
   toProjectPathUnsafe,
   toProjectPath,
@@ -68,7 +66,13 @@ import type {
   InternalFileCreateInvalidation,
   InternalGlob,
 } from './types';
-import {BuildAbortError, assertSignalNotAborted, hashFromOption} from './utils';
+import {BuildAbortError, hashFromOption} from './utils';
+import {performance} from 'perf_hooks';
+
+import {
+  loadEnvironmentsFromCache,
+  writeEnvironmentsToCache,
+} from './EnvironmentManager';
 
 export const requestGraphEdgeTypes = {
   subrequest: 2,
@@ -77,39 +81,44 @@ export const requestGraphEdgeTypes = {
   invalidated_by_create: 5,
   invalidated_by_create_above: 6,
   dirname: 7,
-};
+} as const;
 
 class FSBailoutError extends Error {
   name: string = 'FSBailoutError';
 }
 
-export type RequestGraphEdgeType = $Values<typeof requestGraphEdgeTypes>;
-
-type RequestGraphOpts = {|
-  ...ContentGraphOpts<RequestGraphNode, RequestGraphEdgeType>,
-  invalidNodeIds: Set<NodeId>,
-  incompleteNodeIds: Set<NodeId>,
-  globNodeIds: Set<NodeId>,
-  envNodeIds: Set<NodeId>,
-  optionNodeIds: Set<NodeId>,
-  unpredicatableNodeIds: Set<NodeId>,
-  invalidateOnBuildNodeIds: Set<NodeId>,
-  cachedRequestChunks: Set<number>,
-  configKeyNodes: Map<ProjectPath, Set<NodeId>>,
-|};
-
-type SerializedRequestGraph = {|
-  ...SerializedContentGraph<RequestGraphNode, RequestGraphEdgeType>,
-  invalidNodeIds: Set<NodeId>,
-  incompleteNodeIds: Set<NodeId>,
-  globNodeIds: Set<NodeId>,
-  envNodeIds: Set<NodeId>,
-  optionNodeIds: Set<NodeId>,
-  unpredicatableNodeIds: Set<NodeId>,
-  invalidateOnBuildNodeIds: Set<NodeId>,
-  cachedRequestChunks: Set<number>,
-  configKeyNodes: Map<ProjectPath, Set<NodeId>>,
-|};
+export type RequestGraphEdgeType =
+  (typeof requestGraphEdgeTypes)[keyof typeof requestGraphEdgeTypes];
+
+type RequestGraphOpts = ContentGraphOpts<
+  RequestGraphNode,
+  RequestGraphEdgeType
+> & {
+  invalidNodeIds: Set<NodeId>;
+  incompleteNodeIds: Set<NodeId>;
+  globNodeIds: Set<NodeId>;
+  envNodeIds: Set<NodeId>;
+  optionNodeIds: Set<NodeId>;
+  unpredicatableNodeIds: Set<NodeId>;
+  invalidateOnBuildNodeIds: Set<NodeId>;
+  cachedRequestChunks: Set<number>;
+  configKeyNodes: Map<ProjectPath, Set<NodeId>>;
+};
+
+type SerializedRequestGraph = SerializedContentGraph<
+  RequestGraphNode,
+  RequestGraphEdgeType
+> & {
+  invalidNodeIds: Set<NodeId>;
+  incompleteNodeIds: Set<NodeId>;
+  globNodeIds: Set<NodeId>;
+  envNodeIds: Set<NodeId>;
+  optionNodeIds: Set<NodeId>;
+  unpredicatableNodeIds: Set<NodeId>;
+  invalidateOnBuildNodeIds: Set<NodeId>;
+  cachedRequestChunks: Set<number>;
+  configKeyNodes: Map<ProjectPath, Set<NodeId>>;
+};
 
 const FILE: 0 = 0;
 const REQUEST: 1 = 1;
@@ -119,40 +128,51 @@ const OPTION: 4 = 4;
 const GLOB: 5 = 5;
 const CONFIG_KEY: 6 = 6;
 
-type FileNode = {|id: ContentKey, +type: typeof FILE|};
+type FileNode = {
+  id: ContentKey;
+  readonly type: typeof FILE;
+};
 
-type GlobNode = {|id: ContentKey, +type: typeof GLOB, value: InternalGlob|};
+type GlobNode = {
+  id: ContentKey;
+  readonly type: typeof GLOB;
+  value: InternalGlob;
+};
 
-type FileNameNode = {|
-  id: ContentKey,
-  +type: typeof FILE_NAME,
-|};
+type FileNameNode = {
+  id: ContentKey;
+  readonly type: typeof FILE_NAME;
+};
 
-type EnvNode = {|
-  id: ContentKey,
-  +type: typeof ENV,
-  value: string | void,
-|};
+type EnvNode = {
+  id: ContentKey;
+  readonly type: typeof ENV;
+  value: string | undefined;
+};
 
-type OptionNode = {|
-  id: ContentKey,
-  +type: typeof OPTION,
-  hash: string,
-|};
+type OptionNode = {
+  id: ContentKey;
+  readonly type: typeof OPTION;
+  hash: string;
+};
 
-type ConfigKeyNode = {|
-  id: ContentKey,
-  +type: typeof CONFIG_KEY,
-  configKey: string,
-  contentHash: string,
-|};
+type ConfigKeyNode = {
+  id: ContentKey;
+  readonly type: typeof CONFIG_KEY;
+  configKey: string[];
+  contentHash: string;
+};
 
-type Request<TInput, TResult> = {|
-  id: string,
-  +type: RequestType,
-  input: TInput,
-  run: ({|input: TInput, ...StaticRunOpts<TResult>|}) => Async<TResult>,
-|};
+type Request<TInput, TResult> = {
+  id: string;
+  readonly type: RequestType;
+  input: TInput;
+  run: (
+    arg1: {
+      input: TInput;
+    } & StaticRunOpts<TResult>,
+  ) => Async<TResult>;
+};
 
 export type RequestResult =
   | AssetGraphRequestResult
@@ -170,15 +190,15 @@ export type RequestResult =
   | AssetRequestResult;
 
 type InvalidateReason = number;
-type RequestNode = {|
-  id: ContentKey,
-  +type: typeof REQUEST,
-  +requestType: RequestType,
-  invalidateReason: InvalidateReason,
-  result?: RequestResult,
-  resultCacheKey?: ?string,
-  hash?: string,
-|};
+type RequestNode = {
+  id: ContentKey;
+  readonly type: typeof REQUEST;
+  readonly requestType: RequestType;
+  invalidateReason: InvalidateReason;
+  result?: RequestResult;
+  resultCacheKey?: string | null | undefined;
+  hash?: string;
+};
 
 export const requestTypes = {
   atlaspack_build_request: 1,
@@ -195,10 +215,10 @@ export const requestTypes = {
   package_request: 12,
   write_bundle_request: 13,
   validation_request: 14,
-};
+} as const;
 
-type RequestType = $Values<typeof requestTypes>;
-type RequestTypeName = $Keys<typeof requestTypes>;
+type RequestType = (typeof requestTypes)[keyof typeof requestTypes];
+type RequestTypeName = keyof typeof requestTypes;
 
 type RequestGraphNode =
   | RequestNode
@@ -209,43 +229,48 @@ type RequestGraphNode =
   | OptionNode
   | ConfigKeyNode;
 
-export type RunAPI<TResult: RequestResult> = {|
-  invalidateOnFileCreate: (InternalFileCreateInvalidation) => void,
-  invalidateOnFileDelete: (ProjectPath) => void,
-  invalidateOnFileUpdate: (ProjectPath) => void,
+export type RunAPI<TResult extends RequestResult> = {
+  invalidateOnFileCreate: (arg1: InternalFileCreateInvalidation) => void;
+  invalidateOnFileDelete: (arg1: ProjectPath) => void;
+  invalidateOnFileUpdate: (arg1: ProjectPath) => void;
   invalidateOnConfigKeyChange: (
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
     contentHash: string,
-  ) => void,
-  invalidateOnStartup: () => void,
-  invalidateOnBuild: () => void,
-  invalidateOnEnvChange: (string) => void,
-  invalidateOnOptionChange: (string) => void,
-  getInvalidations(): Array<RequestInvalidation>,
-  storeResult(result: TResult, cacheKey?: string): void,
-  getRequestResult<T: RequestResult>(contentKey: ContentKey): Async<?T>,
-  getPreviousResult<T: RequestResult>(ifMatch?: string): Async<?T>,
-  getSubRequests(): Array<RequestNode>,
-  getInvalidSubRequests(): Array<RequestNode>,
-  canSkipSubrequest(ContentKey): boolean,
-  runRequest: <TInput, TResult: RequestResult>(
+  ) => void;
+  invalidateOnStartup: () => void;
+  invalidateOnBuild: () => void;
+  invalidateOnEnvChange: (arg1: string) => void;
+  invalidateOnOptionChange: (arg1: string) => void;
+  getInvalidations(): Array<RequestInvalidation>;
+  storeResult(result: TResult, cacheKey?: string): void;
+  getRequestResult<T extends RequestResult>(
+    contentKey: ContentKey,
+  ): Async<T | null | undefined>;
+  getPreviousResult<T extends RequestResult>(
+    ifMatch?: string,
+  ): Async<T | null | undefined>;
+  getSubRequests(): Array<RequestNode>;
+  getInvalidSubRequests(): Array<RequestNode>;
+  canSkipSubrequest(arg1: ContentKey): boolean;
+  runRequest: <TInput, TResult extends RequestResult>(
     subRequest: Request<TInput, TResult>,
     opts?: RunRequestOpts,
-  ) => Promise<TResult>,
-|};
+  ) => Promise<TResult>;
+};
 
-type RunRequestOpts = {|
-  force: boolean,
-|};
+type RunRequestOpts = {
+  force: boolean;
+};
 
-export type StaticRunOpts<TResult> = {|
-  api: RunAPI<TResult>,
-  farm: WorkerFarm,
-  invalidateReason: InvalidateReason,
-  options: AtlaspackOptions,
-  rustAtlaspack: ?AtlaspackV3,
-|};
+export type StaticRunOpts<TResult> = {
+  // @ts-expect-error TS2344
+  api: RunAPI<TResult>;
+  farm: WorkerFarm;
+  invalidateReason: InvalidateReason;
+  options: AtlaspackOptions;
+  rustAtlaspack: AtlaspackV3 | null | undefined;
+};
 
 const nodeFromFilePath = (filePath: ProjectPath): RequestGraphNode => ({
   id: fromProjectPathRelative(filePath),
@@ -268,13 +293,13 @@ const nodeFromRequest = (request: RequestNode): RequestGraphNode => ({
   invalidateReason: INITIAL_BUILD,
 });
 
-const nodeFromEnv = (env: string, value: string | void): RequestGraphNode => ({
+const nodeFromEnv = (env: string, value?: string): RequestGraphNode => ({
   id: 'env:' + env,
   type: ENV,
   value,
 });
 
-const nodeFromOption = (option: string, value: mixed): RequestGraphNode => ({
+const nodeFromOption = (option: string, value: unknown): RequestGraphNode => ({
   id: 'option:' + option,
   type: OPTION,
   hash: hashFromOption(value),
@@ -282,10 +307,12 @@ const nodeFromOption = (option: string, value: mixed): RequestGraphNode => ({
 
 const nodeFromConfigKey = (
   fileName: ProjectPath,
-  configKey: string,
+  configKey: string[],
   contentHash: string,
 ): RequestGraphNode => ({
-  id: `config_key:${fromProjectPathRelative(fileName)}:${configKey}`,
+  id: `config_key:${fromProjectPathRelative(fileName)}:${JSON.stringify(
+    configKey,
+  )}`,
   type: CONFIG_KEY,
   configKey,
   contentHash,
@@ -301,9 +328,10 @@ const keyFromOptionContentKey = (contentKey: ContentKey): string =>
 // The goal is to free up the event loop periodically to allow interruption by the user.
 const NODES_PER_BLOB = 2 ** 14;
 
+// @ts-expect-error TS2417
 export class RequestGraph extends ContentGraph<
   RequestGraphNode,
-  RequestGraphEdgeType,
+  RequestGraphEdgeType
 > {
   invalidNodeIds: Set<NodeId> = new Set();
   incompleteNodeIds: Set<NodeId> = new Set();
@@ -319,9 +347,7 @@ export class RequestGraph extends ContentGraph<
   configKeyNodes: Map<ProjectPath, Set<NodeId>> = new Map();
   nodesPerBlob: number = NODES_PER_BLOB;
 
-  // $FlowFixMe[prop-missing]
   static deserialize(opts: RequestGraphOpts): RequestGraph {
-    // $FlowFixMe[prop-missing]
     let deserialized = new RequestGraph(opts);
     deserialized.invalidNodeIds = opts.invalidNodeIds;
     deserialized.incompleteNodeIds = opts.incompleteNodeIds;
@@ -335,7 +361,6 @@ export class RequestGraph extends ContentGraph<
     return deserialized;
   }
 
-  // $FlowFixMe[prop-missing]
   serialize(): SerializedRequestGraph {
     return {
       ...super.serialize(),
@@ -413,7 +438,7 @@ export class RequestGraph extends ContentGraph<
     requestNodeId: NodeId,
     subrequestContentKeys: Array<ContentKey>,
   ) {
-    let subrequestNodeIds = [];
+    let subrequestNodeIds: Array<NodeId> = [];
     for (let key of subrequestContentKeys) {
       if (this.hasContentKey(key)) {
         subrequestNodeIds.push(this.getNodeIdByContentKey(key));
@@ -446,6 +471,11 @@ export class RequestGraph extends ContentGraph<
     this.removeCachedRequestChunkForNode(nodeId);
   }
 
+  /**
+   * Nodes that are invalidated on start-up, such as JavaScript babel configuration files which are
+   * imported when the build kicks-off and might doing arbitrary work such as reading from the file
+   * system.
+   */
   invalidateUnpredictableNodes() {
     for (let nodeId of this.unpredicatableNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
@@ -454,6 +484,9 @@ export class RequestGraph extends ContentGraph<
     }
   }
 
+  /**
+   * Effectively uncacheable nodes.
+   */
   invalidateOnBuildNodes() {
     for (let nodeId of this.invalidateOnBuildNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
@@ -462,11 +495,20 @@ export class RequestGraph extends ContentGraph<
     }
   }
 
-  invalidateEnvNodes(env: EnvMap) {
+  /**
+   * Nodes invalidated by environment changes, corresponds to `env: ...` inputs.
+   */
+  invalidateEnvNodes(env: EnvMap): string[] {
+    const invalidatedKeys: Array<string> = [];
+
     for (let nodeId of this.envNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
       invariant(node.type === ENV);
-      if (env[keyFromEnvContentKey(node.id)] !== node.value) {
+
+      const key = keyFromEnvContentKey(node.id);
+      if (env[key] !== node.value) {
+        invalidatedKeys.push(key);
+
         let parentNodes = this.getNodeIdsConnectedTo(
           nodeId,
           requestGraphEdgeTypes.invalidated_by_update,
@@ -476,15 +518,24 @@ export class RequestGraph extends ContentGraph<
         }
       }
     }
+
+    return invalidatedKeys;
   }
 
-  invalidateOptionNodes(options: AtlaspackOptions) {
+  /**
+   * Nodes invalidated by option changes.
+   */
+  invalidateOptionNodes(options: AtlaspackOptions): string[] {
+    const invalidatedKeys: Array<string> = [];
+
     for (let nodeId of this.optionNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
       invariant(node.type === OPTION);
-      if (
-        hashFromOption(options[keyFromOptionContentKey(node.id)]) !== node.hash
-      ) {
+      const key = keyFromOptionContentKey(node.id);
+
+      // @ts-expect-error TS7053
+      if (hashFromOption(options[key]) !== node.hash) {
+        invalidatedKeys.push(key);
         let parentNodes = this.getNodeIdsConnectedTo(
           nodeId,
           requestGraphEdgeTypes.invalidated_by_update,
@@ -494,12 +545,14 @@ export class RequestGraph extends ContentGraph<
         }
       }
     }
+
+    return invalidatedKeys;
   }
 
   invalidateOnConfigKeyChange(
     requestNodeId: NodeId,
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
     contentHash: string,
   ) {
     let configKeyNodeId = this.addNode(
@@ -571,9 +624,13 @@ export class RequestGraph extends ContentGraph<
     input: InternalFileCreateInvalidation,
   ) {
     let node;
+    // @ts-expect-error TS2339
     if (input.glob != null) {
+      // @ts-expect-error TS2339
       node = nodeFromGlob(input.glob);
+      // @ts-expect-error TS2339
     } else if (input.fileName != null && input.aboveFilePath != null) {
+      // @ts-expect-error TS2339
       let aboveFilePath = input.aboveFilePath;
 
       // Create nodes and edges for each part of the filename pattern.
@@ -581,6 +638,7 @@ export class RequestGraph extends ContentGraph<
       // This creates a sort of trie structure within the graph that can be
       // quickly matched by following the edges. This is also memory efficient
       // since common sub-paths (e.g. 'node_modules') are deduplicated.
+      // @ts-expect-error TS2339
       let parts = input.fileName.split('/').reverse();
       let lastNodeId;
       for (let part of parts) {
@@ -649,7 +707,9 @@ export class RequestGraph extends ContentGraph<
           requestGraphEdgeTypes.invalidated_by_create_above,
         );
       }
+      // @ts-expect-error TS2339
     } else if (input.filePath != null) {
+      // @ts-expect-error TS2339
       node = nodeFromFilePath(input.filePath);
     } else {
       throw new Error('Invalid invalidation');
@@ -681,13 +741,9 @@ export class RequestGraph extends ContentGraph<
     this.invalidateOnBuildNodeIds.add(requestNodeId);
   }
 
-  invalidateOnEnvChange(
-    requestNodeId: NodeId,
-    env: string,
-    value: string | void,
-  ) {
-    let envNode = nodeFromEnv(env, value);
-    let envNodeId = this.addNode(envNode);
+  invalidateOnEnvChange(requestNodeId: NodeId, env: string, value?: string) {
+    const envNode = nodeFromEnv(env, value);
+    const envNodeId = this.addNode(envNode);
 
     if (
       !this.hasEdge(
@@ -707,7 +763,7 @@ export class RequestGraph extends ContentGraph<
   invalidateOnOptionChange(
     requestNodeId: NodeId,
     option: string,
-    value: mixed,
+    value: unknown,
   ) {
     let optionNode = nodeFromOption(option, value);
     let optionNodeId = this.addNode(optionNode);
@@ -760,6 +816,7 @@ export class RequestGraph extends ContentGraph<
       requestNodeId,
       requestGraphEdgeTypes.invalidated_by_update,
     );
+    // @ts-expect-error TS2322
     return invalidations
       .map((nodeId) => {
         let node = nullthrows(this.getNode(nodeId));
@@ -818,7 +875,7 @@ export class RequestGraph extends ContentGraph<
     node: FileNameNode,
     filePath: ProjectPath,
     matchNodes: Array<FileNode>,
-    invalidateNode: (NodeId, InvalidateReason) => void,
+    invalidateNode: (arg1: NodeId, arg2: InvalidateReason) => void,
   ) {
     // If there is an edge between this file_name node and one of the original file nodes pointed to
     // by the original file_name node, and the matched node is inside the current directory, invalidate
@@ -907,7 +964,10 @@ export class RequestGraph extends ContentGraph<
      * True if this is the start-up (loading phase) invalidation.
      */
     isInitialBuild: boolean = false,
-  ): Async<boolean> {
+  ): Promise<{
+    didInvalidate: boolean;
+    invalidationsByPath: Map<string, number>;
+  }> {
     let didInvalidate = false;
     let count = 0;
     let predictedTime = 0;
@@ -916,7 +976,10 @@ export class RequestGraph extends ContentGraph<
     const removeOrphans = !enableOptimization;
 
     const invalidatedNodes = new Set();
-    const invalidateNode = (nodeId, reason) => {
+    const invalidateNode = (
+      nodeId: NodeId,
+      reason: InvalidateReason | number,
+    ) => {
       if (enableOptimization && invalidatedNodes.has(nodeId)) {
         return;
       }
@@ -924,13 +987,13 @@ export class RequestGraph extends ContentGraph<
       this.invalidateNode(nodeId, reason);
     };
     const aboveCache = new Map();
-    const getAbove = (fileNameNodeId) => {
+    const getAbove = (fileNameNodeId: NodeId) => {
       const cachedResult = aboveCache.get(fileNameNodeId);
       if (enableOptimization && cachedResult) {
         return cachedResult;
       }
 
-      let above = [];
+      let above: Array<FileNode> = [];
       const children = this.getNodeIdsConnectedTo(
         fileNameNodeId,
         requestGraphEdgeTypes.invalidated_by_create_above,
@@ -945,7 +1008,10 @@ export class RequestGraph extends ContentGraph<
       return above;
     };
 
+    const invalidationsByPath = new Map();
     for (let {path: _path, type} of events) {
+      const invalidationsBefore = this.getInvalidNodeCount();
+
       if (
         !enableOptimization &&
         process.env.ATLASPACK_DISABLE_CACHE_TIMEOUT !== 'true' &&
@@ -991,7 +1057,10 @@ export class RequestGraph extends ContentGraph<
             this.invalidNodeIds.add(id);
           }
         }
-        return true;
+        return {
+          didInvalidate: true,
+          invalidationsByPath: new Map(),
+        };
       }
 
       // sometimes mac os reports update events as create events.
@@ -1072,11 +1141,18 @@ export class RequestGraph extends ContentGraph<
       }
 
       let configKeyNodes = this.configKeyNodes.get(_filePath);
-      if (configKeyNodes && (type === 'delete' || type === 'update')) {
+
+      // With granular invalidations we will always run this block,
+      // so even if we get a create event (for whatever reason), we will still
+      // try to limit invalidations from config key changes through hashing.
+      //
+      // Currently create events can invalidate a large number of nodes due to
+      // "create above" invalidations.
+      if (configKeyNodes) {
         for (let nodeId of configKeyNodes) {
           let isInvalid = type === 'delete';
 
-          if (type === 'update') {
+          if (type !== 'delete') {
             let node = this.getNode(nodeId);
             invariant(node && node.type === CONFIG_KEY);
 
@@ -1104,6 +1180,13 @@ export class RequestGraph extends ContentGraph<
           }
         }
       }
+
+      const invalidationsAfter = this.getInvalidNodeCount();
+      const invalidationsForEvent = invalidationsAfter - invalidationsBefore;
+      invalidationsByPath.set(
+        _path,
+        (invalidationsByPath.get(_path) ?? 0) + invalidationsForEvent,
+      );
     }
 
     if (getFeatureFlag('fixQuadraticCacheInvalidation')) {
@@ -1124,7 +1207,10 @@ export class RequestGraph extends ContentGraph<
       },
     });
 
-    return didInvalidate && this.invalidNodeIds.size > 0;
+    return {
+      didInvalidate,
+      invalidationsByPath,
+    };
   }
 
   hasCachedRequestChunk(index: number): boolean {
@@ -1138,14 +1224,20 @@ export class RequestGraph extends ContentGraph<
   removeCachedRequestChunkForNode(nodeId: number): void {
     this.cachedRequestChunks.delete(Math.floor(nodeId / this.nodesPerBlob));
   }
+
+  /**
+   * Returns the number of invalidated nodes in the graph.
+   */
+  getInvalidNodeCount(): number {
+    return this.invalidNodeIds.size;
+  }
 }
 
 export default class RequestTracker {
   graph: RequestGraph;
   farm: WorkerFarm;
   options: AtlaspackOptions;
-  rustAtlaspack: ?AtlaspackV3;
-  signal: ?AbortSignal;
+  rustAtlaspack: AtlaspackV3 | null | undefined;
   stats: Map<RequestType, number> = new Map();
 
   constructor({
@@ -1153,27 +1245,22 @@ export default class RequestTracker {
     farm,
     options,
     rustAtlaspack,
-  }: {|
-    graph?: RequestGraph,
-    farm: WorkerFarm,
-    options: AtlaspackOptions,
-    rustAtlaspack?: AtlaspackV3,
-  |}) {
+  }: {
+    graph?: RequestGraph;
+    farm: WorkerFarm;
+    options: AtlaspackOptions;
+    rustAtlaspack?: AtlaspackV3;
+  }) {
     this.graph = graph || new RequestGraph();
     this.farm = farm;
     this.options = options;
     this.rustAtlaspack = rustAtlaspack;
   }
 
-  // TODO: refactor (abortcontroller should be created by RequestTracker)
-  setSignal(signal?: AbortSignal) {
-    this.signal = signal;
-  }
-
-  startRequest(request: RequestNode): {|
-    requestNodeId: NodeId,
-    deferred: Deferred<boolean>,
-  |} {
+  startRequest(request: RequestNode): {
+    requestNodeId: NodeId;
+    deferred: Deferred<boolean>;
+  } {
     let didPreviouslyExist = this.graph.hasContentKey(request.id);
     let requestNodeId;
     if (didPreviouslyExist) {
@@ -1189,13 +1276,14 @@ export default class RequestTracker {
     this.graph.invalidNodeIds.delete(requestNodeId);
 
     let {promise, deferred} = makeDeferredWithPromise();
+    // @ts-expect-error TS2345
     this.graph.incompleteNodePromises.set(requestNodeId, promise);
 
     return {requestNodeId, deferred};
   }
 
   // If a cache key is provided, the result will be removed from the node and stored in a separate cache entry
-  storeResult(nodeId: NodeId, result: RequestResult, cacheKey: ?string) {
+  storeResult(nodeId: NodeId, result: RequestResult, cacheKey?: string | null) {
     let node = this.graph.getNode(nodeId);
     if (node && node.type === REQUEST) {
       node.result = result;
@@ -1211,10 +1299,10 @@ export default class RequestTracker {
     );
   }
 
-  async getRequestResult<T: RequestResult>(
+  async getRequestResult<T extends RequestResult>(
     contentKey: ContentKey,
     ifMatch?: string,
-  ): Promise<?T> {
+  ): Promise<T | null | undefined> {
     let node = nullthrows(this.graph.getNodeByContentKey(contentKey));
     invariant(node.type === REQUEST);
 
@@ -1223,18 +1311,15 @@ export default class RequestTracker {
     }
 
     if (node.result != undefined) {
-      // $FlowFixMe
-      let result: T = (node.result: any);
+      let result: T = node.result as any;
       return result;
     } else if (node.resultCacheKey != null && ifMatch == null) {
       let key = node.resultCacheKey;
-      if (!getFeatureFlag('cachePerformanceImprovements')) {
-        invariant(this.options.cache.hasLargeBlob(key));
-      }
+      invariant(this.options.cache.hasLargeBlob(key));
 
-      let cachedResult: T = getFeatureFlag('cachePerformanceImprovements')
-        ? nullthrows(await this.options.cache.get<T>(key))
-        : deserialize(await this.options.cache.getLargeBlob(key));
+      let cachedResult: T = deserialize(
+        await this.options.cache.getLargeBlob(key),
+      );
       node.result = cachedResult;
       return cachedResult;
     }
@@ -1261,7 +1346,13 @@ export default class RequestTracker {
     }
   }
 
-  respondToFSEvents(events: Array<Event>, threshold: number): Async<boolean> {
+  respondToFSEvents(
+    events: Array<Event>,
+    threshold: number,
+  ): Promise<{
+    didInvalidate: boolean;
+    invalidationsByPath: Map<string, number>;
+  }> {
     return this.graph.respondToFSEvents(events, this.options, threshold);
   }
 
@@ -1270,7 +1361,7 @@ export default class RequestTracker {
   }
 
   getInvalidRequests(): Array<RequestNode> {
-    let invalidRequests = [];
+    let invalidRequests: Array<RequestNode> = [];
     for (let id of this.graph.invalidNodeIds) {
       let node = nullthrows(this.graph.getNode(id));
       invariant(node.type === REQUEST);
@@ -1286,9 +1377,9 @@ export default class RequestTracker {
     this.graph.replaceSubrequests(requestNodeId, subrequestContextKeys);
   }
 
-  async runRequest<TInput, TResult: RequestResult>(
+  async runRequest<TInput, TResult extends RequestResult>(
     request: Request<TInput, TResult>,
-    opts?: ?RunRequestOpts,
+    opts?: RunRequestOpts | null,
   ): Promise<TResult> {
     let hasKey = this.graph.hasContentKey(request.id);
     let requestId = hasKey
@@ -1297,7 +1388,7 @@ export default class RequestTracker {
     let hasValidResult = requestId != null && this.hasValidResult(requestId);
 
     if (!opts?.force && hasValidResult) {
-      // $FlowFixMe[incompatible-type]
+      // @ts-expect-error TS2322
       return this.getRequestResult<TResult>(request.id);
     }
 
@@ -1307,10 +1398,10 @@ export default class RequestTracker {
         // There is a another instance of this request already running, wait for its completion and reuse its result
         try {
           if (await incompletePromise) {
-            // $FlowFixMe[incompatible-type]
+            // @ts-expect-error TS2322
             return this.getRequestResult<TResult>(request.id);
           }
-        } catch (e) {
+        } catch (e: any) {
           // Rerun this request
         }
       }
@@ -1344,12 +1435,11 @@ export default class RequestTracker {
         rustAtlaspack: this.rustAtlaspack,
       });
 
-      assertSignalNotAborted(this.signal);
       this.completeRequest(requestNodeId);
 
       deferred.resolve(true);
       return result;
-    } catch (err) {
+    } catch (err: any) {
       if (
         !(err instanceof BuildAbortError) &&
         request.type === requestTypes.dev_dep_request
@@ -1373,14 +1463,16 @@ export default class RequestTracker {
     }
   }
 
-  flushStats(): {[requestType: string]: number} {
-    let requestTypeEntries = {};
+  flushStats(): {
+    [requestType: string]: number;
+  } {
+    let requestTypeEntries: Record<string, any> = {};
 
-    for (let key of (Object.keys(requestTypes): RequestTypeName[])) {
+    for (let key of Object.keys(requestTypes) as RequestTypeName[]) {
       requestTypeEntries[requestTypes[key]] = key;
     }
 
-    let formattedStats = {};
+    let formattedStats: Record<string, any> = {};
 
     for (let [requestType, count] of this.stats.entries()) {
       let requestTypeName = requestTypeEntries[requestType];
@@ -1392,10 +1484,13 @@ export default class RequestTracker {
     return formattedStats;
   }
 
-  createAPI<TResult: RequestResult>(
+  createAPI<TResult extends RequestResult>(
     requestId: NodeId,
     previousInvalidations: Array<RequestInvalidation>,
-  ): {|api: RunAPI<TResult>, subRequestContentKeys: Set<ContentKey>|} {
+  ): {
+    api: RunAPI<TResult>;
+    subRequestContentKeys: Set<ContentKey>;
+  } {
     let subRequestContentKeys = new Set<ContentKey>();
     let api: RunAPI<TResult> = {
       invalidateOnFileCreate: (input) =>
@@ -1419,6 +1514,7 @@ export default class RequestTracker {
         this.graph.invalidateOnOptionChange(
           requestId,
           option,
+          // @ts-expect-error TS7053
           this.options[option],
         ),
       getInvalidations: () => previousInvalidations,
@@ -1427,12 +1523,16 @@ export default class RequestTracker {
       },
       getSubRequests: () => this.graph.getSubRequests(requestId),
       getInvalidSubRequests: () => this.graph.getInvalidSubRequests(requestId),
-      getPreviousResult: <T: RequestResult>(ifMatch?: string): Async<?T> => {
+      getPreviousResult: <T extends RequestResult>(
+        ifMatch?: string,
+      ): Async<T | null | undefined> => {
         let contentKey = nullthrows(this.graph.getNode(requestId)?.id);
         return this.getRequestResult<T>(contentKey, ifMatch);
       },
-      getRequestResult: <T: RequestResult>(id): Async<?T> =>
-        this.getRequestResult<T>(id),
+      getRequestResult: <T extends RequestResult>(
+        // @ts-expect-error TS7006
+        id,
+      ): Async<T | null | undefined> => this.getRequestResult<T>(id),
       canSkipSubrequest: (contentKey) => {
         if (
           this.graph.hasContentKey(contentKey) &&
@@ -1444,7 +1544,7 @@ export default class RequestTracker {
 
         return false;
       },
-      runRequest: <TInput, TResult: RequestResult>(
+      runRequest: <TInput, TResult extends RequestResult>(
         subRequest: Request<TInput, TResult>,
         opts?: RunRequestOpts,
       ): Promise<TResult> => {
@@ -1457,28 +1557,6 @@ export default class RequestTracker {
   }
 
   async writeToCache(signal?: AbortSignal) {
-    const options = this.options;
-    async function runCacheImprovements<T>(
-      newPath: (cache: LMDBLiteCache) => Promise<T>,
-      oldPath: () => Promise<T>,
-    ): Promise<T> {
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        invariant(options.cache instanceof LMDBLiteCache);
-        const result = await newPath(options.cache);
-        return result;
-      } else {
-        const result = await oldPath();
-        return result;
-      }
-    }
-
-    await runCacheImprovements(
-      async (cache) => {
-        await cache.getNativeRef().startWriteTransaction();
-      },
-      () => Promise.resolve(),
-    );
-
     let cacheKey = getCacheKey(this.options);
     let requestGraphKey = `requestGraph-${cacheKey}`;
     let snapshotKey = `snapshot-${cacheKey}`;
@@ -1488,114 +1566,111 @@ export default class RequestTracker {
     }
 
     let total = 0;
-    report({
-      type: 'cache',
-      phase: 'start',
-      total,
-      size: this.graph.nodes.length,
-    });
+    try {
+      report({
+        type: 'cache',
+        phase: 'start',
+        total,
+        size: this.graph.nodes.length,
+      });
 
-    let serialisedGraph = this.graph.serialize();
+      if (getFeatureFlag('environmentDeduplication')) {
+        await writeEnvironmentsToCache(this.options.cache);
+      }
 
-    // Delete an existing request graph cache, to prevent invalid states
-    await this.options.cache.deleteLargeBlob(requestGraphKey);
+      let serialisedGraph = this.graph.serialize();
 
-    const serialiseAndSet = async (
-      key: string,
-      // $FlowFixMe serialise input is any type
-      contents: any,
-    ): Promise<void> => {
-      if (signal?.aborted) {
-        throw new Error('Serialization was aborted');
-      }
+      // Delete an existing request graph cache, to prevent invalid states
+      await this.options.cache.deleteLargeBlob(requestGraphKey);
 
-      await runCacheImprovements(
-        (cache) => {
-          instrument(`cache.put(${key})`, () => {
-            cache.getNativeRef().putNoConfirm(key, serialize(contents));
-          });
-          return Promise.resolve();
-        },
-        async () => {
-          await this.options.cache.setLargeBlob(
-            key,
-            serialize(contents),
-            signal
-              ? {
-                  signal: signal,
-                }
-              : undefined,
-          );
-        },
-      );
+      const serialiseAndSet = async (
+        key: string,
+        contents: any,
+      ): Promise<void> => {
+        if (signal?.aborted) {
+          throw new Error('Serialization was aborted');
+        }
 
-      total += 1;
+        await this.options.cache.setLargeBlob(
+          key,
+          serialize(contents),
+          signal
+            ? {
+                signal: signal,
+              }
+            : undefined,
+        );
 
-      report({
-        type: 'cache',
-        phase: 'write',
-        total,
-        size: this.graph.nodes.length,
-      });
-    };
+        total += 1;
 
-    let queue = new PromiseQueue({
-      maxConcurrent: 32,
-    });
+        report({
+          type: 'cache',
+          phase: 'write',
+          total,
+          size: this.graph.nodes.length,
+        });
+      };
 
-    // Preallocating a sparse array is faster than pushing when N is high enough
-    let cacheableNodes = new Array(serialisedGraph.nodes.length);
-    for (let i = 0; i < serialisedGraph.nodes.length; i += 1) {
-      let node = serialisedGraph.nodes[i];
+      let queue = new PromiseQueue({
+        maxConcurrent: 32,
+      });
 
-      let resultCacheKey = node?.resultCacheKey;
-      if (
-        node?.type === REQUEST &&
-        resultCacheKey != null &&
-        node?.result != null
-      ) {
-        queue.add(() => serialiseAndSet(resultCacheKey, node.result));
+      // Preallocating a sparse array is faster than pushing when N is high enough
+      let cacheableNodes = new Array(serialisedGraph.nodes.length);
+      for (let i = 0; i < serialisedGraph.nodes.length; i += 1) {
+        let node = serialisedGraph.nodes[i];
 
-        // eslint-disable-next-line no-unused-vars
-        let {result: _, ...newNode} = node;
-        cacheableNodes[i] = newNode;
-      } else {
-        cacheableNodes[i] = node;
+        // @ts-expect-error TS2339
+        let resultCacheKey = node?.resultCacheKey;
+        if (
+          node?.type === REQUEST &&
+          resultCacheKey != null &&
+          node?.result != null
+        ) {
+          queue.add(() => serialiseAndSet(resultCacheKey, node.result));
+
+          // eslint-disable-next-line no-unused-vars
+          let {result: _, ...newNode} = node;
+          cacheableNodes[i] = newNode;
+        } else {
+          cacheableNodes[i] = node;
+        }
       }
-    }
 
-    let nodeCountsPerBlob = [];
+      let nodeCountsPerBlob: Array<number> = [];
 
-    for (
-      let i = 0;
-      i * this.graph.nodesPerBlob < cacheableNodes.length;
-      i += 1
-    ) {
-      let nodesStartIndex = i * this.graph.nodesPerBlob;
-      let nodesEndIndex = Math.min(
-        (i + 1) * this.graph.nodesPerBlob,
-        cacheableNodes.length,
-      );
+      for (
+        let i = 0;
+        i * this.graph.nodesPerBlob < cacheableNodes.length;
+        i += 1
+      ) {
+        let nodesStartIndex = i * this.graph.nodesPerBlob;
+        let nodesEndIndex = Math.min(
+          (i + 1) * this.graph.nodesPerBlob,
+          cacheableNodes.length,
+        );
 
-      nodeCountsPerBlob.push(nodesEndIndex - nodesStartIndex);
+        nodeCountsPerBlob.push(nodesEndIndex - nodesStartIndex);
 
-      if (!this.graph.hasCachedRequestChunk(i)) {
-        // We assume the request graph nodes are immutable and won't change
-        let nodesToCache = cacheableNodes.slice(nodesStartIndex, nodesEndIndex);
+        if (!this.graph.hasCachedRequestChunk(i)) {
+          // We assume the request graph nodes are immutable and won't change
+          let nodesToCache = cacheableNodes.slice(
+            nodesStartIndex,
+            nodesEndIndex,
+          );
 
-        queue.add(() =>
-          serialiseAndSet(
-            getRequestGraphNodeKey(i, cacheKey),
-            nodesToCache,
-          ).then(() => {
-            // Succeeded in writing to disk, save that we have completed this chunk
-            this.graph.setCachedRequestChunk(i);
-          }),
-        );
+          queue.add(() =>
+            serialiseAndSet(
+              getRequestGraphNodeKey(i, cacheKey),
+              nodesToCache,
+            ).then(() => {
+              // Succeeded in writing to disk, save that we have completed this chunk
+              this.graph.setCachedRequestChunk(i);
+            }),
+          );
+        }
       }
-    }
 
-    try {
       await queue.run();
 
       // Set the request graph after the queue is flushed to avoid writing an invalid state
@@ -1605,18 +1680,6 @@ export default class RequestTracker {
         nodes: undefined,
       });
 
-      await runCacheImprovements(
-        () =>
-          serialiseAndSet(`request_tracker:cache_metadata:${cacheKey}`, {
-            version: ATLASPACK_VERSION,
-            entries: this.options.entries,
-            mode: this.options.mode,
-            shouldBuildLazily: this.options.shouldBuildLazily,
-            watchBackend: this.options.watchBackend,
-          }),
-        () => Promise.resolve(),
-      );
-
       let opts = getWatcherOptions(this.options);
       let snapshotPath = path.join(this.options.cacheDir, snapshotKey + '.txt');
 
@@ -1625,18 +1688,11 @@ export default class RequestTracker {
         snapshotPath,
         opts,
       );
-    } catch (err) {
+    } catch (err: any) {
       // If we have aborted, ignore the error and continue
       if (!signal?.aborted) throw err;
     }
 
-    await runCacheImprovements(
-      async (cache) => {
-        await cache.getNativeRef().commitWriteTransaction();
-      },
-      () => Promise.resolve(),
-    );
-
     report({type: 'cache', phase: 'end', total, size: this.graph.nodes.length});
   }
 
@@ -1644,11 +1700,11 @@ export default class RequestTracker {
     farm,
     options,
     rustAtlaspack,
-  }: {|
-    farm: WorkerFarm,
-    options: AtlaspackOptions,
-    rustAtlaspack?: AtlaspackV3,
-  |}): Async<RequestTracker> {
+  }: {
+    farm: WorkerFarm;
+    options: AtlaspackOptions;
+    rustAtlaspack?: AtlaspackV3;
+  }): Promise<Async<RequestTracker>> {
     let graph = await loadRequestGraph(options);
     return new RequestTracker({farm, graph, options, rustAtlaspack});
   }
@@ -1667,7 +1723,7 @@ export function getWatcherOptions({
   return {ignore, backend: watchBackend};
 }
 
-function getCacheKey(options) {
+function getCacheKey(options: AtlaspackOptions) {
   return hashString(
     `${ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${
       options.shouldBuildLazily ? 'lazy' : 'eager'
@@ -1683,11 +1739,16 @@ export async function readAndDeserializeRequestGraph(
   cache: Cache,
   requestGraphKey: string,
   cacheKey: string,
-): Async<{|requestGraph: RequestGraph, bufferLength: number|}> {
+): Promise<
+  Async<{
+    requestGraph: RequestGraph;
+    bufferLength: number;
+  }>
+> {
   let bufferLength = 0;
 
   const getAndDeserialize = async (key: string) => {
-    let buffer = await cache.getLargeBlob(key);
+    const buffer = await cache.getLargeBlob(key);
     bufferLength += Buffer.byteLength(buffer);
     return deserialize(buffer);
   };
@@ -1695,6 +1756,7 @@ export async function readAndDeserializeRequestGraph(
   let serializedRequestGraph = await getAndDeserialize(requestGraphKey);
 
   let nodePromises = serializedRequestGraph.nodeCountsPerBlob.map(
+    // @ts-expect-error TS7006
     async (nodesCount, i) => {
       let nodes = await getAndDeserialize(getRequestGraphNodeKey(i, cacheKey));
       invariant.equal(
@@ -1716,27 +1778,48 @@ export async function readAndDeserializeRequestGraph(
   };
 }
 
-async function loadRequestGraph(options): Async<RequestGraph> {
+async function loadRequestGraph(
+  options: AtlaspackOptions,
+): Promise<Async<RequestGraph>> {
   if (options.shouldDisableCache) {
     return new RequestGraph();
   }
 
   let cacheKey = getCacheKey(options);
   let requestGraphKey = `requestGraph-${cacheKey}`;
+
   let timeout;
   const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = path.join(options.cacheDir, snapshotKey + '.txt');
 
+  const commonMeta = {
+    cacheKey,
+    snapshotKey,
+    cacheKeyOptions: {
+      version: ATLASPACK_VERSION,
+      entries: options.entries,
+      mode: options.mode,
+      shouldBuildLazily: options.shouldBuildLazily,
+      watchBackend: options.watchBackend,
+    },
+  } as const;
+
   logger.verbose({
     origin: '@atlaspack/core',
     message: 'Loading request graph',
     meta: {
-      cacheKey,
-      snapshotKey,
+      ...commonMeta,
     },
   });
 
-  if (await options.cache.hasLargeBlob(requestGraphKey)) {
+  if (getFeatureFlag('environmentDeduplication')) {
+    await loadEnvironmentsFromCache(options.cache);
+  }
+
+  const hasRequestGraphInCache =
+    await options.cache.hasLargeBlob(requestGraphKey);
+
+  if (hasRequestGraphInCache) {
     try {
       let {requestGraph} = await readAndDeserializeRequestGraph(
         options.cache,
@@ -1767,25 +1850,31 @@ async function loadRequestGraph(options): Async<RequestGraph> {
         origin: '@atlaspack/core',
         message: `File system event count: ${events.length}`,
         meta: {
+          ...commonMeta,
           trackableEvent: 'watcher_events_count',
           watcherEventCount: events.length,
           duration: Date.now() - startTime,
         },
       });
 
-      requestGraph.invalidateUnpredictableNodes();
-      requestGraph.invalidateOnBuildNodes();
-      requestGraph.invalidateEnvNodes(options.env);
-      requestGraph.invalidateOptionNodes(options);
-
-      await requestGraph.respondToFSEvents(
-        options.unstableFileInvalidations || events,
+      const invalidationStats = await invalidateRequestGraph(
+        requestGraph,
         options,
-        10000,
-        true,
+        events,
       );
+
+      logger.verbose({
+        origin: '@atlaspack/core',
+        message: 'Request track loaded from cache',
+        meta: {
+          ...commonMeta,
+          trackableEvent: 'request_tracker_cache_key_hit',
+          invalidationStats,
+        },
+      });
+
       return requestGraph;
-    } catch (e) {
+    } catch (e: any) {
       // Prevent logging fs events took too long warning
       clearTimeout(timeout);
       logErrorOnBailout(options, snapshotPath, e);
@@ -1800,13 +1889,231 @@ async function loadRequestGraph(options): Async<RequestGraph> {
     message:
       'Cache entry for request tracker was not found, initializing a clean cache.',
     meta: {
-      cacheKey,
-      snapshotKey,
+      ...commonMeta,
+      trackableEvent: 'request_tracker_cache_key_miss',
     },
   });
   return new RequestGraph();
 }
 
+/**
+ * A wrapper around an invalidation type / method
+ */
+type InvalidationFn = {
+  key: string;
+  fn: () =>
+    | InvalidationDetail
+    | Promise<InvalidationDetail>
+    | undefined
+    | Promise<undefined>;
+};
+
+type InvalidationStats = {
+  /**
+   * Total number of request graph nodes
+   */
+  nodeCount: number;
+  /**
+   * Number of requests in RequestGraph
+   */
+  requestCount: number;
+  /**
+   * Number of nodes that have been invalidated.
+   */
+  invalidatedCount: number;
+  /**
+   * Percentage of requests that have been invalidated
+   */
+  requestInvalidationRatio: number;
+  /**
+   * Percentage of nodes that have been invalidated
+   */
+  nodeInvalidationRatio: number;
+  /**
+   * Details for each invalidation type
+   */
+  invalidations: InvalidationFnStats[];
+};
+
+/**
+ * Details about an invalidation.
+ *
+ * If this is a fs events invalidation, this key will contain statistics about invalidations
+ * by path.
+ *
+ * If this is a env or option invalidation, this key will contain the list of changed environment
+ * variables or options.
+ */
+type InvalidationDetail = string[] | FSInvalidationStats;
+
+/**
+ * Number of invalidations for a given file-system event.
+ */
+type FSInvalidation = {
+  path: string;
+  count: number;
+};
+
+type FSInvalidationStats = {
+  /**
+   * This list will be sorted by the number of nodes invalidated and only the top 10 will be
+   * included.
+   */
+  biggestInvalidations: FSInvalidation[];
+};
+
+/**
+ * Information about a certain cache invalidation type.
+ */
+type InvalidationFnStats = {
+  /**
+   * Invalidation type, one of:
+   *
+   * - unpredictable
+   * - onBuild
+   * - env
+   * - option
+   * - fsEvents
+   */
+  key: string;
+  /**
+   * Number of invalidated nodes coming from this invalidation type.
+   */
+  count: number;
+  /**
+   * If this is a env or option invalidation, this key will contain the list of changed values.
+   *
+   * If this is a fs events invalidation, this key will contain statistics about invalidations
+   */
+  detail: null | InvalidationDetail;
+  /**
+   * Time in milliseconds it took to run the invalidation.
+   */
+  duration: number;
+};
+
+/**
+ * Respond to unpredictable, build, environment changes, option changes and file-system events
+ * invalidating RequestGraph nodes.
+ *
+ * Returns the count of nodes invalidated by each invalidation type.
+ */
+export async function invalidateRequestGraph(
+  requestGraph: RequestGraph,
+  options: AtlaspackOptions,
+  events: Event[],
+): Promise<InvalidationStats> {
+  const invalidationFns: InvalidationFn[] = [
+    {
+      key: 'unpredictable',
+      // @ts-expect-error TS2322
+      fn: () => requestGraph.invalidateUnpredictableNodes(),
+    },
+    {
+      key: 'onBuild',
+      // @ts-expect-error TS2322
+      fn: () => requestGraph.invalidateOnBuildNodes(),
+    },
+    {
+      key: 'env',
+      fn: () => requestGraph.invalidateEnvNodes(options.env),
+    },
+    {
+      key: 'option',
+      fn: () => requestGraph.invalidateOptionNodes(options),
+    },
+    {
+      key: 'fsEvents',
+      fn: () => invalidateRequestGraphFSEvents(requestGraph, options, events),
+    },
+  ];
+
+  const invalidations: Array<InvalidationFnStats> = [];
+  for (const invalidation of invalidationFns) {
+    invalidations.push(await runInvalidation(requestGraph, invalidation));
+  }
+  const invalidatedCount = invalidations.reduce(
+    (acc, invalidation) => acc + invalidation.count,
+    0,
+  );
+  const requestCount = requestGraph.nodes.reduce(
+    (acc, node) => acc + (node?.type === REQUEST ? 1 : 0),
+    0,
+  );
+  const nodeCount = requestGraph.nodes.length;
+  const nodeInvalidationRatio = invalidatedCount / nodeCount;
+  const requestInvalidationRatio = invalidatedCount / requestCount;
+
+  return {
+    invalidations,
+    nodeCount,
+    requestCount,
+    invalidatedCount,
+    nodeInvalidationRatio,
+    requestInvalidationRatio,
+  };
+}
+
+interface InvalidateRequestGraphFSEventsInput {
+  respondToFSEvents(
+    events: Event[],
+    options: AtlaspackOptions,
+    timeout: number,
+    shouldLog: boolean,
+  ): Promise<{
+    invalidationsByPath: Map<string, number>;
+  }>;
+}
+
+/**
+ * Invalidate the request graph based on file-system events.
+ *
+ * Returns statistics about the invalidations.
+ */
+export async function invalidateRequestGraphFSEvents(
+  requestGraph: InvalidateRequestGraphFSEventsInput,
+  options: AtlaspackOptions,
+  events: Event[],
+): Promise<FSInvalidationStats> {
+  const {invalidationsByPath} = await requestGraph.respondToFSEvents(
+    options.unstableFileInvalidations || events,
+    options,
+    10000,
+    true,
+  );
+  const biggestInvalidations =
+    getBiggestFSEventsInvalidations(invalidationsByPath);
+
+  return {
+    biggestInvalidations,
+  };
+}
+
+interface RunInvalidationInput {
+  getInvalidNodeCount(): number;
+}
+
+/**
+ * Runs an invalidation function and reports metrics.
+ */
+export async function runInvalidation(
+  requestGraph: RunInvalidationInput,
+  invalidationFn: InvalidationFn,
+): Promise<InvalidationFnStats> {
+  const start = performance.now();
+  const startInvalidationCount = requestGraph.getInvalidNodeCount();
+  const result = await invalidationFn.fn();
+  const count = requestGraph.getInvalidNodeCount() - startInvalidationCount;
+  const duration = performance.now() - start;
+
+  return {
+    key: invalidationFn.key,
+    count,
+    detail: result ?? null,
+    duration,
+  };
+}
+
 function logErrorOnBailout(
   options: AtlaspackOptions,
   snapshotPath: string,
@@ -1838,7 +2145,9 @@ function logErrorOnBailout(
   }
 }
 
-export function cleanUpOrphans<N, E: number>(graph: Graph<N, E>): NodeId[] {
+export function cleanUpOrphans<N, E extends number>(
+  graph: Graph<N, E>,
+): NodeId[] {
   if (graph.rootNodeId == null) {
     return [];
   }
@@ -1848,7 +2157,7 @@ export function cleanUpOrphans<N, E: number>(graph: Graph<N, E>): NodeId[] {
     reachableNodes.add(nodeId);
   });
 
-  const removedNodeIds = [];
+  const removedNodeIds: Array<NodeId> = [];
   graph.nodes.forEach((_node, nodeId) => {
     if (!reachableNodes.has(nodeId)) {
       removedNodeIds.push(nodeId);
@@ -1858,3 +2167,19 @@ export function cleanUpOrphans<N, E: number>(graph: Graph<N, E>): NodeId[] {
 
   return removedNodeIds;
 }
+
+/**
+ * Returns paths that invalidated the most nodes
+ */
+export function getBiggestFSEventsInvalidations(
+  invalidationsByPath: Map<string, number>,
+  limit: number = 10,
+): Array<FSInvalidation> {
+  const invalidations: Array<FSInvalidation> = [];
+  for (const [path, count] of invalidationsByPath) {
+    invalidations.push({path, count});
+  }
+  invalidations.sort((a, b) => b.count - a.count);
+
+  return invalidations.slice(0, limit);
+}