@atlaspack/core 2.16.2-dev.14 → 2.16.2-dev.1c70d50f9.99

package/lib/RequestTracker.js

@@ -6,9 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.RequestGraph = void 0;
 exports.cleanUpOrphans = cleanUpOrphans;
 exports.default = void 0;
+exports.getBiggestFSEventsInvalidations = getBiggestFSEventsInvalidations;
 exports.getWatcherOptions = getWatcherOptions;
+exports.invalidateRequestGraph = invalidateRequestGraph;
+exports.invalidateRequestGraphFSEvents = invalidateRequestGraphFSEvents;
 exports.readAndDeserializeRequestGraph = readAndDeserializeRequestGraph;
 exports.requestTypes = exports.requestGraphEdgeTypes = void 0;
+exports.runInvalidation = runInvalidation;
 function _assert() {
   const data = _interopRequireWildcard(require("assert"));
   _assert = function () {
@@ -84,6 +88,14 @@ var _projectPath = require("./projectPath");
 var _ReporterRunner = require("./ReporterRunner");
 var _ConfigRequest = require("./requests/ConfigRequest");
 var _utils2 = require("./utils");
+function _perf_hooks() {
+  const data = require("perf_hooks");
+  _perf_hooks = function () {
+    return data;
+  };
+  return data;
+}
+var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
@@ -151,7 +163,7 @@ const nodeFromOption = (option, value) => ({
   hash: (0, _utils2.hashFromOption)(value)
 });
 const nodeFromConfigKey = (fileName, configKey, contentHash) => ({
-  id: `config_key:${(0, _projectPath.fromProjectPathRelative)(fileName)}:${configKey}`,
+  id: `config_key:${(0, _projectPath.fromProjectPathRelative)(fileName)}:${JSON.stringify(configKey)}`,
   type: CONFIG_KEY,
   configKey,
   contentHash
@@ -279,6 +291,12 @@ class RequestGraph extends _graph().ContentGraph {
     // If the node is invalidated, the cached request chunk on disk needs to be re-written
     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 = (0, _nullthrows().default)(this.getNode(nodeId));
@@ -286,6 +304,10 @@ class RequestGraph extends _graph().ContentGraph {
       this.invalidateNode(nodeId, _constants.STARTUP);
     }
   }
+
+  /**
+   * Effectively uncacheable nodes.
+   */
   invalidateOnBuildNodes() {
     for (let nodeId of this.invalidateOnBuildNodeIds) {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
@@ -293,29 +315,45 @@ class RequestGraph extends _graph().ContentGraph {
       this.invalidateNode(nodeId, _constants.STARTUP);
     }
   }
+
+  /**
+   * Nodes invalidated by environment changes, corresponds to `env: ...` inputs.
+   */
   invalidateEnvNodes(env) {
+    const invalidatedKeys = [];
     for (let nodeId of this.envNodeIds) {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
       (0, _assert().default)(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);
         for (let parentNode of parentNodes) {
           this.invalidateNode(parentNode, _constants.ENV_CHANGE);
         }
       }
     }
+    return invalidatedKeys;
   }
+
+  /**
+   * Nodes invalidated by option changes.
+   */
   invalidateOptionNodes(options) {
+    const invalidatedKeys = [];
     for (let nodeId of this.optionNodeIds) {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
       (0, _assert().default)(node.type === OPTION);
-      if ((0, _utils2.hashFromOption)(options[keyFromOptionContentKey(node.id)]) !== node.hash) {
+      const key = keyFromOptionContentKey(node.id);
+      if ((0, _utils2.hashFromOption)(options[key]) !== node.hash) {
+        invalidatedKeys.push(key);
         let parentNodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update);
         for (let parentNode of parentNodes) {
           this.invalidateNode(parentNode, _constants.OPTION_CHANGE);
         }
       }
     }
+    return invalidatedKeys;
   }
   invalidateOnConfigKeyChange(requestNodeId, filePath, configKey, contentHash) {
     let configKeyNodeId = this.addNode(nodeFromConfigKey(filePath, configKey, contentHash));
@@ -408,8 +446,8 @@ class RequestGraph extends _graph().ContentGraph {
     this.invalidateOnBuildNodeIds.add(requestNodeId);
   }
   invalidateOnEnvChange(requestNodeId, env, value) {
-    let envNode = nodeFromEnv(env, value);
-    let envNodeId = this.addNode(envNode);
+    const envNode = nodeFromEnv(env, value);
+    const envNodeId = this.addNode(envNode);
     if (!this.hasEdge(requestNodeId, envNodeId, requestGraphEdgeTypes.invalidated_by_update)) {
       this.addEdge(requestNodeId, envNodeId, requestGraphEdgeTypes.invalidated_by_update);
     }
@@ -556,10 +594,12 @@ class RequestGraph extends _graph().ContentGraph {
       aboveCache.set(fileNameNodeId, above);
       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' && ++count === 256) {
         let duration = Date.now() - startTime;
         predictedTime = duration * (events.length >> 8);
@@ -596,7 +636,10 @@ class RequestGraph extends _graph().ContentGraph {
             this.invalidNodeIds.add(id);
           }
         }
-        return true;
+        return {
+          didInvalidate: true,
+          invalidationsByPath: new Map()
+        };
       }
 
       // sometimes mac os reports update events as create events.
@@ -653,10 +696,17 @@ class RequestGraph extends _graph().ContentGraph {
         this.removeNode(nodeId, removeOrphans);
       }
       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);
             (0, _assert().default)(node && node.type === CONFIG_KEY);
             let contentHash = await (0, _ConfigRequest.getConfigKeyContentHash)(_filePath, node.configKey, options);
@@ -671,6 +721,8 @@ class RequestGraph extends _graph().ContentGraph {
           }
         }
       }
+      const invalidationsAfter = this.getInvalidNodeCount();
+      invalidationsByPath.set(_path, (invalidationsByPath.get(_path) ?? 0) + (invalidationsAfter - invalidationsBefore));
     }
     if ((0, _featureFlags().getFeatureFlag)('fixQuadraticCacheInvalidation')) {
       cleanUpOrphans(this);
@@ -688,7 +740,10 @@ class RequestGraph extends _graph().ContentGraph {
         numberOfInvalidatedNodes: invalidatedNodes.size
       }
     });
-    return didInvalidate && this.invalidNodeIds.size > 0;
+    return {
+      didInvalidate,
+      invalidationsByPath
+    };
   }
   hasCachedRequestChunk(index) {
     return this.cachedRequestChunks.has(index);
@@ -699,6 +754,13 @@ class RequestGraph extends _graph().ContentGraph {
   removeCachedRequestChunkForNode(nodeId) {
     this.cachedRequestChunks.delete(Math.floor(nodeId / this.nodesPerBlob));
   }
+
+  /**
+   * Returns the number of invalidated nodes in the graph.
+   */
+  getInvalidNodeCount() {
+    return this.invalidNodeIds.size;
+  }
 }
 exports.RequestGraph = RequestGraph;
 class RequestTracker {
@@ -717,6 +779,9 @@ class RequestTracker {
 
   // TODO: refactor (abortcontroller should be created by RequestTracker)
   setSignal(signal) {
+    if ((0, _featureFlags().getFeatureFlag)('fixBuildAbortCorruption')) {
+      return;
+    }
     this.signal = signal;
   }
   startRequest(request) {
@@ -857,7 +922,9 @@ class RequestTracker {
         options: this.options,
         rustAtlaspack: this.rustAtlaspack
       });
-      (0, _utils2.assertSignalNotAborted)(this.signal);
+      if (!(0, _featureFlags().getFeatureFlag)('fixBuildAbortCorruption')) {
+        (0, _utils2.assertSignalNotAborted)(this.signal);
+      }
       this.completeRequest(requestNodeId);
       deferred.resolve(true);
       return result;
@@ -944,84 +1011,88 @@ class RequestTracker {
         return result;
       }
     }
-    await runCacheImprovements(async cache => {
-      await cache.getNativeRef().startWriteTransaction();
-    }, () => Promise.resolve());
     let cacheKey = getCacheKey(this.options);
-    let requestGraphKey = `requestGraph-${cacheKey}`;
+    let requestGraphKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/RequestGraph` : `requestGraph-${cacheKey}`;
+    let snapshotKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/snapshot` : `snapshot-${cacheKey}`;
     if (this.options.shouldDisableCache) {
       return;
     }
     let total = 0;
-    (0, _ReporterRunner.report)({
-      type: 'cache',
-      phase: 'start',
-      total,
-      size: this.graph.nodes.length
-    });
-    let serialisedGraph = this.graph.serialize();
-
-    // Delete an existing request graph cache, to prevent invalid states
-    await this.options.cache.deleteLargeBlob(requestGraphKey);
-    const serialiseAndSet = async (key, contents) => {
-      if (signal !== null && signal !== void 0 && signal.aborted) {
-        throw new Error('Serialization was aborted');
-      }
-      await runCacheImprovements(cache => {
-        (0, _logger().instrument)(`cache.put(${key})`, () => {
-          cache.getNativeRef().putNoConfirm(key, (0, _buildCache().serialize)(contents));
-        });
-        return Promise.resolve();
-      }, async () => {
-        await this.options.cache.setLargeBlob(key, (0, _buildCache().serialize)(contents), signal ? {
-          signal: signal
-        } : undefined);
-      });
-      total += 1;
+    await runCacheImprovements(async cache => {
+      await cache.getNativeRef().startWriteTransaction();
+    }, () => Promise.resolve());
+    try {
       (0, _ReporterRunner.report)({
         type: 'cache',
-        phase: 'write',
+        phase: 'start',
         total,
         size: this.graph.nodes.length
       });
-    };
-    let queue = new (_utils().PromiseQueue)({
-      maxConcurrent: 32
-    });
+      if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+        await (0, _EnvironmentManager.writeEnvironmentsToCache)(options.cache);
+      }
+      let serialisedGraph = this.graph.serialize();
 
-    // 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 === null || node === void 0 ? void 0 : node.resultCacheKey;
-      if ((node === null || node === void 0 ? void 0 : node.type) === REQUEST && resultCacheKey != null && (node === null || node === void 0 ? void 0 : node.result) != null) {
-        queue.add(() => serialiseAndSet(resultCacheKey, node.result));
+      // Delete an existing request graph cache, to prevent invalid states
+      await this.options.cache.deleteLargeBlob(requestGraphKey);
+      const serialiseAndSet = async (key, contents) => {
+        if (signal !== null && signal !== void 0 && signal.aborted) {
+          throw new Error('Serialization was aborted');
+        }
+        await runCacheImprovements(cache => {
+          (0, _logger().instrument)(`RequestTracker::writeToCache::cache.put(${key})`, () => {
+            cache.getNativeRef().putNoConfirm(key, (0, _buildCache().serialize)(contents));
+          });
+          return Promise.resolve();
+        }, async () => {
+          await this.options.cache.setLargeBlob(key, (0, _buildCache().serialize)(contents), signal ? {
+            signal: signal
+          } : undefined);
+        });
+        total += 1;
+        (0, _ReporterRunner.report)({
+          type: 'cache',
+          phase: 'write',
+          total,
+          size: this.graph.nodes.length
+        });
+      };
+      let queue = new (_utils().PromiseQueue)({
+        maxConcurrent: 32
+      });
 
-        // eslint-disable-next-line no-unused-vars
-        let {
-          result: _,
-          ...newNode
-        } = node;
-        cacheableNodes[i] = newNode;
-      } else {
-        cacheableNodes[i] = node;
+      // 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 === null || node === void 0 ? void 0 : node.resultCacheKey;
+        if ((node === null || node === void 0 ? void 0 : node.type) === REQUEST && resultCacheKey != null && (node === null || node === void 0 ? void 0 : 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 = [];
-    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);
-      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);
-        }));
+      let nodeCountsPerBlob = [];
+      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);
+        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);
+          }));
+        }
       }
-    }
-    try {
       await queue.run();
 
       // Set the request graph after the queue is flushed to avoid writing an invalid state
@@ -1030,7 +1101,7 @@ class RequestTracker {
         nodeCountsPerBlob,
         nodes: undefined
       });
-      await runCacheImprovements(() => serialiseAndSet(`request_tracker:cache_metadata:${cacheKey}`, {
+      await runCacheImprovements(() => serialiseAndSet(`${cacheKey}/cache_metadata`, {
         version: _constants.ATLASPACK_VERSION,
         entries: this.options.entries,
         mode: this.options.mode,
@@ -1038,15 +1109,16 @@ class RequestTracker {
         watchBackend: this.options.watchBackend
       }), () => Promise.resolve());
       let opts = getWatcherOptions(this.options);
-      let snapshotPath = _path2().default.join(this.options.cacheDir, `snapshot-${cacheKey}` + '.txt');
+      let snapshotPath = _path2().default.join(this.options.cacheDir, snapshotKey + '.txt');
       await this.options.outputFS.writeSnapshot(this.options.watchDir, snapshotPath, opts);
     } catch (err) {
       // If we have aborted, ignore the error and continue
       if (!(signal !== null && signal !== void 0 && 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());
     (0, _ReporterRunner.report)({
       type: 'cache',
       phase: 'end',
@@ -1083,17 +1155,30 @@ function getWatcherOptions({
   };
 }
 function getCacheKey(options) {
+  if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+    const hash = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${options.shouldBuildLazily ? 'lazy' : 'eager'}:${options.watchBackend ?? ''}`);
+    return `RequestTracker/${_constants.ATLASPACK_VERSION}/${hash}`;
+  }
   return (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${options.shouldBuildLazily ? 'lazy' : 'eager'}:${options.watchBackend ?? ''}`);
 }
 function getRequestGraphNodeKey(index, cacheKey) {
+  if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+    return `${cacheKey}/RequestGraph/nodes/${index}`;
+  }
   return `requestGraph-nodes-${index}-${cacheKey}`;
 }
 async function readAndDeserializeRequestGraph(cache, requestGraphKey, cacheKey) {
   let bufferLength = 0;
   const getAndDeserialize = async key => {
-    let buffer = await cache.getLargeBlob(key);
-    bufferLength += Buffer.byteLength(buffer);
-    return (0, _buildCache().deserialize)(buffer);
+    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      const buffer = await cache.getBlob(key);
+      bufferLength += Buffer.byteLength(buffer);
+      return (0, _buildCache().deserialize)(buffer);
+    } else {
+      const buffer = await cache.getLargeBlob(key);
+      bufferLength += Buffer.byteLength(buffer);
+      return (0, _buildCache().deserialize)(buffer);
+    }
   };
   let serializedRequestGraph = await getAndDeserialize(requestGraphKey);
   let nodePromises = serializedRequestGraph.nodeCountsPerBlob.map(async (nodesCount, i) => {
@@ -1115,19 +1200,33 @@ async function loadRequestGraph(options) {
     return new RequestGraph();
   }
   let cacheKey = getCacheKey(options);
-  let requestGraphKey = `requestGraph-${cacheKey}`;
+  let requestGraphKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/RequestGraph` : `requestGraph-${cacheKey}`;
   let timeout;
-  const snapshotKey = `snapshot-${cacheKey}`;
+  const snapshotKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/snapshot` : `snapshot-${cacheKey}`;
   const snapshotPath = _path2().default.join(options.cacheDir, snapshotKey + '.txt');
+  const commonMeta = {
+    cacheKey,
+    snapshotKey,
+    cacheKeyOptions: {
+      version: _constants.ATLASPACK_VERSION,
+      entries: options.entries,
+      mode: options.mode,
+      shouldBuildLazily: options.shouldBuildLazily,
+      watchBackend: options.watchBackend
+    }
+  };
   _logger().default.verbose({
     origin: '@atlaspack/core',
     message: 'Loading request graph',
     meta: {
-      cacheKey,
-      snapshotKey
+      ...commonMeta
     }
   });
-  if (await options.cache.hasLargeBlob(requestGraphKey)) {
+  if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+    await (0, _EnvironmentManager.loadEnvironmentsFromCache)(options.cache);
+  }
+  const hasRequestGraphInCache = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.has(requestGraphKey) : await options.cache.hasLargeBlob(requestGraphKey);
+  if (hasRequestGraphInCache) {
     try {
       let {
         requestGraph
@@ -1146,16 +1245,29 @@ async function loadRequestGraph(options) {
         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, options, 10000, true);
+      if ((0, _featureFlags().getFeatureFlag)('verboseRequestInvalidationStats')) {
+        const invalidationStats = await invalidateRequestGraph(requestGraph, options, events);
+        _logger().default.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);
+      }
       return requestGraph;
     } catch (e) {
       // Prevent logging fs events took too long warning
@@ -1170,12 +1282,104 @@ async function loadRequestGraph(options) {
     origin: '@atlaspack/core',
     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
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * Number of invalidations for a given file-system event.
+ */
+
+/**
+ * Information about a certain cache invalidation type.
+ */
+
+/**
+ * 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.
+ */
+async function invalidateRequestGraph(requestGraph, options, events) {
+  const invalidationFns = [{
+    key: 'unpredictable',
+    fn: () => requestGraph.invalidateUnpredictableNodes()
+  }, {
+    key: 'onBuild',
+    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 = [];
+  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 === null || node === void 0 ? void 0 : node.type) === REQUEST ? 1 : 0), 0);
+  const nodeCount = requestGraph.nodes.length;
+  return {
+    invalidations,
+    nodeCount,
+    requestCount,
+    invalidatedCount,
+    nodeInvalidationRatio: invalidatedCount / nodeCount,
+    requestInvalidationRatio: invalidatedCount / requestCount
+  };
+}
+/**
+ * Invalidate the request graph based on file-system events.
+ *
+ * Returns statistics about the invalidations.
+ */
+async function invalidateRequestGraphFSEvents(requestGraph, options, events) {
+  const {
+    invalidationsByPath
+  } = await requestGraph.respondToFSEvents(options.unstableFileInvalidations || events, options, 10000, true);
+  const biggestInvalidations = getBiggestFSEventsInvalidations(invalidationsByPath);
+  return {
+    biggestInvalidations
+  };
+}
+/**
+ * Runs an invalidation function and reports metrics.
+ */
+async function runInvalidation(requestGraph, invalidationFn) {
+  const start = _perf_hooks().performance.now();
+  const startInvalidationCount = requestGraph.getInvalidNodeCount();
+  const result = await invalidationFn.fn();
+  const count = requestGraph.getInvalidNodeCount() - startInvalidationCount;
+  const duration = _perf_hooks().performance.now() - start;
+  return {
+    key: invalidationFn.key,
+    count,
+    detail: result ?? null,
+    duration
+  };
+}
 function logErrorOnBailout(options, snapshotPath, e) {
   if (e.message && e.message.includes('invalid clockspec')) {
     const snapshotContents = options.inputFS.readFileSync(snapshotPath, 'utf-8');
@@ -1215,4 +1419,19 @@ function cleanUpOrphans(graph) {
     }
   });
   return removedNodeIds;
+}
+
+/**
+ * Returns paths that invalidated the most nodes
+ */
+function getBiggestFSEventsInvalidations(invalidationsByPath, limit = 10) {
+  const invalidations = [];
+  for (const [path, count] of invalidationsByPath) {
+    invalidations.push({
+      path,
+      count
+    });
+  }
+  invalidations.sort((a, b) => b.count - a.count);
+  return invalidations.slice(0, limit);
 }