@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

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 {LMDBLiteCache, Cache} from '@atlaspack/cache';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {ContentGraph} from '@atlaspack/graph';
 import type {
@@ -18,7 +16,7 @@ import logger, {instrument} 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));
@@ -474,7 +499,7 @@ export class RequestGraph extends ContentGraph<
    * Nodes invalidated by environment changes, corresponds to `env: ...` inputs.
    */
   invalidateEnvNodes(env: EnvMap): string[] {
-    const invalidatedKeys = [];
+    const invalidatedKeys: Array<string> = [];
 
     for (let nodeId of this.envNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
@@ -501,13 +526,14 @@ export class RequestGraph extends ContentGraph<
    * Nodes invalidated by option changes.
    */
   invalidateOptionNodes(options: AtlaspackOptions): string[] {
-    const invalidatedKeys = [];
+    const invalidatedKeys: Array<string> = [];
 
     for (let nodeId of this.optionNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
       invariant(node.type === OPTION);
       const key = keyFromOptionContentKey(node.id);
 
+      // @ts-expect-error TS7053
       if (hashFromOption(options[key]) !== node.hash) {
         invalidatedKeys.push(key);
         let parentNodes = this.getNodeIdsConnectedTo(
@@ -526,7 +552,7 @@ export class RequestGraph extends ContentGraph<
   invalidateOnConfigKeyChange(
     requestNodeId: NodeId,
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
     contentHash: string,
   ) {
     let configKeyNodeId = this.addNode(
@@ -598,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.
@@ -608,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) {
@@ -676,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');
@@ -708,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(
@@ -734,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);
@@ -787,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));
@@ -845,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
@@ -934,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;
@@ -943,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;
       }
@@ -951,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,
@@ -972,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' &&
@@ -1018,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.
@@ -1099,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);
 
@@ -1131,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')) {
@@ -1151,7 +1207,10 @@ export class RequestGraph extends ContentGraph<
       },
     });
 
-    return didInvalidate && this.invalidNodeIds.size > 0;
+    return {
+      didInvalidate,
+      invalidationsByPath,
+    };
   }
 
   hasCachedRequestChunk(index: number): boolean {
@@ -1165,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({
@@ -1180,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) {
@@ -1216,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;
@@ -1238,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);
 
@@ -1250,8 +1311,7 @@ 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;
@@ -1288,7 +1348,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);
   }
 
@@ -1297,7 +1363,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);
@@ -1313,9 +1379,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
@@ -1324,7 +1390,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);
     }
 
@@ -1334,10 +1400,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
         }
       }
@@ -1371,12 +1437,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
@@ -1400,14 +1465,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];
@@ -1419,10 +1486,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) =>
@@ -1446,6 +1516,7 @@ export default class RequestTracker {
         this.graph.invalidateOnOptionChange(
           requestId,
           option,
+          // @ts-expect-error TS7053
           this.options[option],
         ),
       getInvalidations: () => previousInvalidations,
@@ -1454,12 +1525,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) &&
@@ -1471,7 +1546,7 @@ export default class RequestTracker {
 
         return false;
       },
-      runRequest: <TInput, TResult: RequestResult>(
+      runRequest: <TInput, TResult extends RequestResult>(
         subRequest: Request<TInput, TResult>,
         opts?: RunRequestOpts,
       ): Promise<TResult> => {
@@ -1499,130 +1574,143 @@ export default class RequestTracker {
       }
     }
 
+    let cacheKey = getCacheKey(this.options);
+    let requestGraphKey = getFeatureFlag('cachePerformanceImprovements')
+      ? `${cacheKey}/RequestGraph`
+      : `requestGraph-${cacheKey}`;
+    let snapshotKey = getFeatureFlag('cachePerformanceImprovements')
+      ? `${cacheKey}/snapshot`
+      : `snapshot-${cacheKey}`;
+
+    if (this.options.shouldDisableCache) {
+      return;
+    }
+
+    let total = 0;
     await runCacheImprovements(
       async (cache) => {
         await cache.getNativeRef().startWriteTransaction();
       },
       () => Promise.resolve(),
     );
+    try {
+      report({
+        type: 'cache',
+        phase: 'start',
+        total,
+        size: this.graph.nodes.length,
+      });
 
-    let cacheKey = getCacheKey(this.options);
-    let requestGraphKey = `requestGraph-${cacheKey}`;
-    let snapshotKey = `snapshot-${cacheKey}`;
-
-    if (this.options.shouldDisableCache) {
-      return;
-    }
+      if (getFeatureFlag('environmentDeduplication')) {
+        await writeEnvironmentsToCache(options.cache);
+      }
 
-    let total = 0;
-    report({
-      type: 'cache',
-      phase: 'start',
-      total,
-      size: this.graph.nodes.length,
-    });
+      let serialisedGraph = this.graph.serialize();
 
-    let serialisedGraph = this.graph.serialize();
+      // Delete an existing request graph cache, to prevent invalid states
+      await this.options.cache.deleteLargeBlob(requestGraphKey);
 
-    // Delete an existing request graph cache, to prevent invalid states
-    await this.options.cache.deleteLargeBlob(requestGraphKey);
+      const serialiseAndSet = async (
+        key: string,
+        contents: any,
+      ): Promise<void> => {
+        if (signal?.aborted) {
+          throw new Error('Serialization was aborted');
+        }
 
-    const serialiseAndSet = async (
-      key: string,
-      // $FlowFixMe serialise input is any type
-      contents: any,
-    ): Promise<void> => {
-      if (signal?.aborted) {
-        throw new Error('Serialization was aborted');
-      }
+        await runCacheImprovements(
+          (cache) => {
+            instrument(
+              `RequestTracker::writeToCache::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,
+            );
+          },
+        );
 
-      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,
-          );
-        },
-      );
+        total += 1;
 
-      total += 1;
+        report({
+          type: 'cache',
+          phase: 'write',
+          total,
+          size: this.graph.nodes.length,
+        });
+      };
 
-      report({
-        type: 'cache',
-        phase: 'write',
-        total,
-        size: this.graph.nodes.length,
+      let queue = new PromiseQueue({
+        maxConcurrent: 32,
       });
-    };
-
-    let queue = new PromiseQueue({
-      maxConcurrent: 32,
-    });
 
-    // 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];
+      // 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 resultCacheKey = node?.resultCacheKey;
-      if (
-        node?.type === REQUEST &&
-        resultCacheKey != null &&
-        node?.result != null
-      ) {
-        queue.add(() => serialiseAndSet(resultCacheKey, node.result));
+        // @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;
+          // 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
@@ -1634,7 +1722,7 @@ export default class RequestTracker {
 
       await runCacheImprovements(
         () =>
-          serialiseAndSet(`request_tracker:cache_metadata:${cacheKey}`, {
+          serialiseAndSet(`${cacheKey}/cache_metadata`, {
             version: ATLASPACK_VERSION,
             entries: this.options.entries,
             mode: this.options.mode,
@@ -1652,18 +1740,18 @@ 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;
+    } finally {
+      await runCacheImprovements(
+        async (cache) => {
+          await cache.getNativeRef().commitWriteTransaction();
+        },
+        () => Promise.resolve(),
+      );
     }
 
-    await runCacheImprovements(
-      async (cache) => {
-        await cache.getNativeRef().commitWriteTransaction();
-      },
-      () => Promise.resolve(),
-    );
-
     report({type: 'cache', phase: 'end', total, size: this.graph.nodes.length});
   }
 
@@ -1671,11 +1759,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});
   }
@@ -1694,7 +1782,19 @@ export function getWatcherOptions({
   return {ignore, backend: watchBackend};
 }
 
-function getCacheKey(options) {
+function getCacheKey(options: AtlaspackOptions) {
+  if (getFeatureFlag('cachePerformanceImprovements')) {
+    const hash = hashString(
+      `${ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${
+        options.mode
+      }:${options.shouldBuildLazily ? 'lazy' : 'eager'}:${
+        options.watchBackend ?? ''
+      }`,
+    );
+
+    return `RequestTracker/${ATLASPACK_VERSION}/${hash}`;
+  }
+
   return hashString(
     `${ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${
       options.shouldBuildLazily ? 'lazy' : 'eager'
@@ -1703,6 +1803,10 @@ function getCacheKey(options) {
 }
 
 function getRequestGraphNodeKey(index: number, cacheKey: string) {
+  if (getFeatureFlag('cachePerformanceImprovements')) {
+    return `${cacheKey}/RequestGraph/nodes/${index}`;
+  }
+
   return `requestGraph-nodes-${index}-${cacheKey}`;
 }
 
@@ -1710,18 +1814,30 @@ 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);
-    bufferLength += Buffer.byteLength(buffer);
-    return deserialize(buffer);
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const buffer = await cache.getBlob(key);
+      bufferLength += Buffer.byteLength(buffer);
+      return deserialize(buffer);
+    } else {
+      const buffer = await cache.getLargeBlob(key);
+      bufferLength += Buffer.byteLength(buffer);
+      return deserialize(buffer);
+    }
   };
 
   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(
@@ -1743,15 +1859,22 @@ 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 requestGraphKey = getFeatureFlag('cachePerformanceImprovements')
+    ? `${cacheKey}/RequestGraph`
+    : `requestGraph-${cacheKey}`;
+
   let timeout;
-  const snapshotKey = `snapshot-${cacheKey}`;
+  const snapshotKey = getFeatureFlag('cachePerformanceImprovements')
+    ? `${cacheKey}/snapshot`
+    : `snapshot-${cacheKey}`;
   const snapshotPath = path.join(options.cacheDir, snapshotKey + '.txt');
 
   const commonMeta = {
@@ -1764,7 +1887,7 @@ async function loadRequestGraph(options): Async<RequestGraph> {
       shouldBuildLazily: options.shouldBuildLazily,
       watchBackend: options.watchBackend,
     },
-  };
+  } as const;
 
   logger.verbose({
     origin: '@atlaspack/core',
@@ -1774,7 +1897,15 @@ async function loadRequestGraph(options): Async<RequestGraph> {
     },
   });
 
-  if (await options.cache.hasLargeBlob(requestGraphKey)) {
+  if (getFeatureFlag('environmentDeduplication')) {
+    await loadEnvironmentsFromCache(options.cache);
+  }
+
+  const hasRequestGraphInCache = getFeatureFlag('cachePerformanceImprovements')
+    ? await options.cache.has(requestGraphKey)
+    : await options.cache.hasLargeBlob(requestGraphKey);
+
+  if (hasRequestGraphInCache) {
     try {
       let {requestGraph} = await readAndDeserializeRequestGraph(
         options.cache,
@@ -1812,31 +1943,24 @@ async function loadRequestGraph(options): Async<RequestGraph> {
         },
       });
 
-      if (getFeatureFlag('verboseRequestInvalidationStats')) {
-        const invalidationStats = await invalidateRequestGraph(
-          requestGraph,
-          options,
-          events,
-        );
+      const invalidationStats = await invalidateRequestGraph(
+        requestGraph,
+        options,
+        events,
+      );
 
-        logger.verbose({
-          origin: '@atlaspack/core',
-          message: 'Request track loaded from cache',
-          meta: {
-            ...commonMeta,
-            trackableEvent: 'request_tracker_cache_key_hit',
-            invalidationStats,
-          },
-        });
-      } else {
-        requestGraph.invalidateUnpredictableNodes();
-        requestGraph.invalidateOnBuildNodes();
-        requestGraph.invalidateEnvNodes(options.env);
-        requestGraph.invalidateOptionNodes(options);
-      }
+      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);
@@ -1861,42 +1985,73 @@ async function loadRequestGraph(options): Async<RequestGraph> {
 /**
  * A wrapper around an invalidation type / method
  */
-type InvalidationFn = {|
-  key: string,
-  fn: () => string[] | void | Promise<void>,
-|};
+type InvalidationFn = {
+  key: string;
+  fn: () =>
+    | InvalidationDetail
+    | Promise<InvalidationDetail>
+    | undefined
+    | Promise<undefined>;
+};
 
-type InvalidationStats = {|
+type InvalidationStats = {
   /**
    * Total number of request graph nodes
    */
-  nodeCount: number,
+  nodeCount: number;
   /**
    * Number of requests in RequestGraph
    */
-  requestCount: number,
+  requestCount: number;
   /**
    * Number of nodes that have been invalidated.
    */
-  invalidatedCount: number,
+  invalidatedCount: number;
   /**
    * Percentage of requests that have been invalidated
    */
-  requestInvalidationRatio: number,
+  requestInvalidationRatio: number;
   /**
    * Percentage of nodes that have been invalidated
    */
-  nodeInvalidationRatio: number,
+  nodeInvalidationRatio: number;
   /**
    * Details for each invalidation type
    */
-  invalidations: InvalidationFnStats[],
-|};
+  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 = {|
+type InvalidationFnStats = {
   /**
    * Invalidation type, one of:
    *
@@ -1906,16 +2061,22 @@ type InvalidationFnStats = {|
    * - option
    * - fsEvents
    */
-  key: string,
+  key: string;
   /**
    * Number of invalidated nodes coming from this invalidation type.
    */
-  count: number,
+  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.
    */
-  changes: null | string[],
-|};
+  duration: number;
+};
 
 /**
  * Respond to unpredictable, build, environment changes, option changes and file-system events
@@ -1923,7 +2084,7 @@ type InvalidationFnStats = {|
  *
  * Returns the count of nodes invalidated by each invalidation type.
  */
-async function invalidateRequestGraph(
+export async function invalidateRequestGraph(
   requestGraph: RequestGraph,
   options: AtlaspackOptions,
   events: Event[],
@@ -1931,10 +2092,12 @@ async function invalidateRequestGraph(
   const invalidationFns: InvalidationFn[] = [
     {
       key: 'unpredictable',
+      // @ts-expect-error TS2322
       fn: () => requestGraph.invalidateUnpredictableNodes(),
     },
     {
       key: 'onBuild',
+      // @ts-expect-error TS2322
       fn: () => requestGraph.invalidateOnBuildNodes(),
     },
     {
@@ -1947,18 +2110,11 @@ async function invalidateRequestGraph(
     },
     {
       key: 'fsEvents',
-      fn: async () => {
-        await requestGraph.respondToFSEvents(
-          options.unstableFileInvalidations || events,
-          options,
-          10000,
-          true,
-        );
-      },
+      fn: () => invalidateRequestGraphFSEvents(requestGraph, options, events),
     },
   ];
 
-  const invalidations = [];
+  const invalidations: Array<InvalidationFnStats> = [];
   for (const invalidation of invalidationFns) {
     invalidations.push(await runInvalidation(requestGraph, invalidation));
   }
@@ -1984,22 +2140,63 @@ async function invalidateRequestGraph(
   };
 }
 
+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.
  */
-async function runInvalidation(
-  requestGraph: RequestGraph,
+export async function runInvalidation(
+  requestGraph: RunInvalidationInput,
   invalidationFn: InvalidationFn,
 ): Promise<InvalidationFnStats> {
-  const startInvalidationCount = requestGraph.invalidNodeIds.size;
+  const start = performance.now();
+  const startInvalidationCount = requestGraph.getInvalidNodeCount();
   const result = await invalidationFn.fn();
-  const count = requestGraph.invalidNodeIds.size - startInvalidationCount;
+  const count = requestGraph.getInvalidNodeCount() - startInvalidationCount;
+  const duration = performance.now() - start;
 
   return {
     key: invalidationFn.key,
     count,
-    changes:
-      typeof result === 'object' && Array.isArray(result) ? result : null,
+    detail: result ?? null,
+    duration,
   };
 }
 
@@ -2034,7 +2231,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 [];
   }
@@ -2044,7 +2243,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);
@@ -2054,3 +2253,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);
+}