@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

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 () {
@@ -30,13 +34,6 @@ function _buildCache() {
   };
   return data;
 }
-function _cache() {
-  const data = require("@atlaspack/cache");
-  _cache = function () {
-    return data;
-  };
-  return data;
-}
 function _featureFlags() {
   const data = require("@atlaspack/feature-flags");
   _featureFlags = function () {
@@ -52,7 +49,7 @@ function _graph() {
   return data;
 }
 function _logger() {
-  const data = _interopRequireWildcard(require("@atlaspack/logger"));
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
   _logger = function () {
     return data;
   };
@@ -84,9 +81,16 @@ var _projectPath = require("./projectPath");
 var _ReporterRunner = require("./ReporterRunner");
 var _ConfigRequest = require("./requests/ConfigRequest");
 var _utils2 = require("./utils");
-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; }
+function _perf_hooks() {
+  const data = require("perf_hooks");
+  _perf_hooks = function () {
+    return data;
+  };
+  return data;
+}
+var _EnvironmentManager = require("./EnvironmentManager");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const requestGraphEdgeTypes = exports.requestGraphEdgeTypes = {
   subrequest: 2,
   invalidated_by_update: 3,
@@ -151,7 +155,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
@@ -162,6 +166,8 @@ const keyFromOptionContentKey = contentKey => contentKey.slice('option:'.length)
 // This constant is chosen by local profiling the time to serialise n nodes and tuning until an average time of ~50 ms per blob.
 // 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
 class RequestGraph extends _graph().ContentGraph {
   invalidNodeIds = new Set();
   incompleteNodeIds = new Set();
@@ -176,10 +182,7 @@ class RequestGraph extends _graph().ContentGraph {
   cachedRequestChunks = new Set();
   configKeyNodes = new Map();
   nodesPerBlob = NODES_PER_BLOB;
-
-  // $FlowFixMe[prop-missing]
   static deserialize(opts) {
-    // $FlowFixMe[prop-missing]
     let deserialized = new RequestGraph(opts);
     deserialized.invalidNodeIds = opts.invalidNodeIds;
     deserialized.incompleteNodeIds = opts.incompleteNodeIds;
@@ -192,8 +195,6 @@ class RequestGraph extends _graph().ContentGraph {
     deserialized.configKeyNodes = opts.configKeyNodes;
     return deserialized;
   }
-
-  // $FlowFixMe[prop-missing]
   serialize() {
     return {
       ...super.serialize(),
@@ -333,6 +334,8 @@ class RequestGraph extends _graph().ContentGraph {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
       (0, _assert().default)(node.type === OPTION);
       const key = keyFromOptionContentKey(node.id);
+
+      // @ts-expect-error TS7053
       if ((0, _utils2.hashFromOption)(options[key]) !== node.hash) {
         invalidatedKeys.push(key);
         let parentNodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update);
@@ -371,9 +374,13 @@ class RequestGraph extends _graph().ContentGraph {
   }
   invalidateOnFileCreate(requestNodeId, input) {
     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.
@@ -381,6 +388,7 @@ class RequestGraph extends _graph().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) {
@@ -415,7 +423,9 @@ class RequestGraph extends _graph().ContentGraph {
       if (!this.hasEdge(lastNodeId, nodeId, requestGraphEdgeTypes.invalidated_by_create_above)) {
         this.addEdge(lastNodeId, nodeId, 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');
@@ -434,8 +444,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);
     }
@@ -461,6 +471,7 @@ class RequestGraph extends _graph().ContentGraph {
 
     // For now just handling updates. Could add creates/deletes later if needed.
     let invalidations = this.getNodeIdsConnectedFrom(requestNodeId, requestGraphEdgeTypes.invalidated_by_update);
+    // @ts-expect-error TS2322
     return invalidations.map(nodeId => {
       let node = (0, _nullthrows().default)(this.getNode(nodeId));
       switch (node.type) {
@@ -582,10 +593,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);
@@ -622,7 +635,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.
@@ -679,10 +695,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);
@@ -697,6 +720,9 @@ class RequestGraph extends _graph().ContentGraph {
           }
         }
       }
+      const invalidationsAfter = this.getInvalidNodeCount();
+      const invalidationsForEvent = invalidationsAfter - invalidationsBefore;
+      invalidationsByPath.set(_path, (invalidationsByPath.get(_path) ?? 0) + invalidationsForEvent);
     }
     if ((0, _featureFlags().getFeatureFlag)('fixQuadraticCacheInvalidation')) {
       cleanUpOrphans(this);
@@ -714,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);
@@ -725,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 {
@@ -740,11 +776,6 @@ class RequestTracker {
     this.options = options;
     this.rustAtlaspack = rustAtlaspack;
   }
-
-  // TODO: refactor (abortcontroller should be created by RequestTracker)
-  setSignal(signal) {
-    this.signal = signal;
-  }
   startRequest(request) {
     let didPreviouslyExist = this.graph.hasContentKey(request.id);
     let requestNodeId;
@@ -762,6 +793,7 @@ class RequestTracker {
       promise,
       deferred
     } = (0, _utils().makeDeferredWithPromise)();
+    // @ts-expect-error TS2345
     this.graph.incompleteNodePromises.set(requestNodeId, promise);
     return {
       requestNodeId,
@@ -787,15 +819,12 @@ class RequestTracker {
       return null;
     }
     if (node.result != undefined) {
-      // $FlowFixMe
       let result = node.result;
       return result;
     } else if (node.resultCacheKey != null && ifMatch == null) {
       let key = node.resultCacheKey;
-      if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-        (0, _assert().default)(this.options.cache.hasLargeBlob(key));
-      }
-      let cachedResult = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? (0, _nullthrows().default)(await this.options.cache.get(key)) : (0, _buildCache().deserialize)(await this.options.cache.getLargeBlob(key));
+      (0, _assert().default)(this.options.cache.hasLargeBlob(key));
+      let cachedResult = (0, _buildCache().deserialize)(await this.options.cache.getLargeBlob(key));
       node.result = cachedResult;
       return cachedResult;
     }
@@ -841,7 +870,7 @@ class RequestTracker {
     let requestId = hasKey ? this.graph.getNodeIdByContentKey(request.id) : undefined;
     let hasValidResult = requestId != null && this.hasValidResult(requestId);
     if (!(opts !== null && opts !== void 0 && opts.force) && hasValidResult) {
-      // $FlowFixMe[incompatible-type]
+      // @ts-expect-error TS2322
       return this.getRequestResult(request.id);
     }
     if (requestId != null) {
@@ -850,7 +879,7 @@ 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(request.id);
           }
         } catch (e) {
@@ -883,7 +912,6 @@ class RequestTracker {
         options: this.options,
         rustAtlaspack: this.rustAtlaspack
       });
-      (0, _utils2.assertSignalNotAborted)(this.signal);
       this.completeRequest(requestNodeId);
       deferred.resolve(true);
       return result;
@@ -921,65 +949,56 @@ class RequestTracker {
   }
   createAPI(requestId, previousInvalidations) {
     let subRequestContentKeys = new Set();
-    return {
-      api: {
-        invalidateOnFileCreate: input => this.graph.invalidateOnFileCreate(requestId, input),
-        invalidateOnConfigKeyChange: (filePath, configKey, contentHash) => this.graph.invalidateOnConfigKeyChange(requestId, filePath, configKey, contentHash),
-        invalidateOnFileDelete: filePath => this.graph.invalidateOnFileDelete(requestId, filePath),
-        invalidateOnFileUpdate: filePath => this.graph.invalidateOnFileUpdate(requestId, filePath),
-        invalidateOnStartup: () => this.graph.invalidateOnStartup(requestId),
-        invalidateOnBuild: () => this.graph.invalidateOnBuild(requestId),
-        invalidateOnEnvChange: env => this.graph.invalidateOnEnvChange(requestId, env, this.options.env[env]),
-        invalidateOnOptionChange: option => this.graph.invalidateOnOptionChange(requestId, option, this.options[option]),
-        getInvalidations: () => previousInvalidations,
-        storeResult: (result, cacheKey) => {
-          this.storeResult(requestId, result, cacheKey);
-        },
-        getSubRequests: () => this.graph.getSubRequests(requestId),
-        getInvalidSubRequests: () => this.graph.getInvalidSubRequests(requestId),
-        getPreviousResult: ifMatch => {
-          var _this$graph$getNode;
-          let contentKey = (0, _nullthrows().default)((_this$graph$getNode = this.graph.getNode(requestId)) === null || _this$graph$getNode === void 0 ? void 0 : _this$graph$getNode.id);
-          return this.getRequestResult(contentKey, ifMatch);
-        },
-        getRequestResult: id => this.getRequestResult(id),
-        canSkipSubrequest: contentKey => {
-          if (this.graph.hasContentKey(contentKey) && this.hasValidResult(this.graph.getNodeIdByContentKey(contentKey))) {
-            subRequestContentKeys.add(contentKey);
-            return true;
-          }
-          return false;
-        },
-        runRequest: (subRequest, opts) => {
-          subRequestContentKeys.add(subRequest.id);
-          return this.runRequest(subRequest, opts);
+    let api = {
+      invalidateOnFileCreate: input => this.graph.invalidateOnFileCreate(requestId, input),
+      invalidateOnConfigKeyChange: (filePath, configKey, contentHash) => this.graph.invalidateOnConfigKeyChange(requestId, filePath, configKey, contentHash),
+      invalidateOnFileDelete: filePath => this.graph.invalidateOnFileDelete(requestId, filePath),
+      invalidateOnFileUpdate: filePath => this.graph.invalidateOnFileUpdate(requestId, filePath),
+      invalidateOnStartup: () => this.graph.invalidateOnStartup(requestId),
+      invalidateOnBuild: () => this.graph.invalidateOnBuild(requestId),
+      invalidateOnEnvChange: env => this.graph.invalidateOnEnvChange(requestId, env, this.options.env[env]),
+      invalidateOnOptionChange: option => this.graph.invalidateOnOptionChange(requestId, option,
+      // @ts-expect-error TS7053
+      this.options[option]),
+      getInvalidations: () => previousInvalidations,
+      storeResult: (result, cacheKey) => {
+        this.storeResult(requestId, result, cacheKey);
+      },
+      getSubRequests: () => this.graph.getSubRequests(requestId),
+      getInvalidSubRequests: () => this.graph.getInvalidSubRequests(requestId),
+      getPreviousResult: ifMatch => {
+        var _this$graph$getNode;
+        let contentKey = (0, _nullthrows().default)((_this$graph$getNode = this.graph.getNode(requestId)) === null || _this$graph$getNode === void 0 ? void 0 : _this$graph$getNode.id);
+        return this.getRequestResult(contentKey, ifMatch);
+      },
+      getRequestResult: (
+      // @ts-expect-error TS7006
+      id) => this.getRequestResult(id),
+      canSkipSubrequest: contentKey => {
+        if (this.graph.hasContentKey(contentKey) && this.hasValidResult(this.graph.getNodeIdByContentKey(contentKey))) {
+          subRequestContentKeys.add(contentKey);
+          return true;
         }
+        return false;
       },
+      runRequest: (subRequest, opts) => {
+        subRequestContentKeys.add(subRequest.id);
+        return this.runRequest(subRequest, opts);
+      }
+    };
+    return {
+      api,
       subRequestContentKeys
     };
   }
   async writeToCache(signal) {
-    const options = this.options;
-    async function runCacheImprovements(newPath, oldPath) {
-      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-        (0, _assert().default)(options.cache instanceof _cache().LMDBLiteCache);
-        const result = await newPath(options.cache);
-        return result;
-      } else {
-        const result = await oldPath();
-        return result;
-      }
-    }
     let cacheKey = getCacheKey(this.options);
-    let requestGraphKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/RequestGraph` : `requestGraph-${cacheKey}`;
-    let snapshotKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/snapshot` : `snapshot-${cacheKey}`;
+    let requestGraphKey = `requestGraph-${cacheKey}`;
+    let snapshotKey = `snapshot-${cacheKey}`;
     if (this.options.shouldDisableCache) {
       return;
     }
     let total = 0;
-    await runCacheImprovements(async cache => {
-      await cache.getNativeRef().startWriteTransaction();
-    }, () => Promise.resolve());
     try {
       (0, _ReporterRunner.report)({
         type: 'cache',
@@ -987,6 +1006,9 @@ class RequestTracker {
         total,
         size: this.graph.nodes.length
       });
+      if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+        await (0, _EnvironmentManager.writeEnvironmentsToCache)(this.options.cache);
+      }
       let serialisedGraph = this.graph.serialize();
 
       // Delete an existing request graph cache, to prevent invalid states
@@ -995,16 +1017,9 @@ class RequestTracker {
         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);
-        });
+        await this.options.cache.setLargeBlob(key, (0, _buildCache().serialize)(contents), signal ? {
+          signal: signal
+        } : undefined);
         total += 1;
         (0, _ReporterRunner.report)({
           type: 'cache',
@@ -1021,6 +1036,8 @@ class RequestTracker {
       let cacheableNodes = new Array(serialisedGraph.nodes.length);
       for (let i = 0; i < serialisedGraph.nodes.length; i += 1) {
         let node = serialisedGraph.nodes[i];
+
+        // @ts-expect-error TS2339
         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));
@@ -1057,23 +1074,12 @@ class RequestTracker {
         nodeCountsPerBlob,
         nodes: undefined
       });
-      await runCacheImprovements(() => serialiseAndSet(`${cacheKey}/cache_metadata`, {
-        version: _constants.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 = _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());
     }
     (0, _ReporterRunner.report)({
       type: 'cache',
@@ -1103,7 +1109,8 @@ function getWatcherOptions({
   watchDir,
   watchBackend
 }) {
-  const uniqueDirs = [...new Set([...watchIgnore, ...['.git', '.hg'], cacheDir])];
+  const vcsDirs = ['.git', '.hg'];
+  const uniqueDirs = [...new Set([...watchIgnore, ...vcsDirs, cacheDir])];
   const ignore = uniqueDirs.map(dir => _path2().default.resolve(watchDir, dir));
   return {
     ignore,
@@ -1111,33 +1118,22 @@ 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 => {
-    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);
-    }
+    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) => {
+  let nodePromises = serializedRequestGraph.nodeCountsPerBlob.map(
+  // @ts-expect-error TS7006
+  async (nodesCount, i) => {
     let nodes = await getAndDeserialize(getRequestGraphNodeKey(i, cacheKey));
     _assert().default.equal(nodes.length, nodesCount, 'RequestTracker node chunk: invalid node count');
     return nodes;
@@ -1156,9 +1152,9 @@ async function loadRequestGraph(options) {
     return new RequestGraph();
   }
   let cacheKey = getCacheKey(options);
-  let requestGraphKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/RequestGraph` : `requestGraph-${cacheKey}`;
+  let requestGraphKey = `requestGraph-${cacheKey}`;
   let timeout;
-  const snapshotKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/snapshot` : `snapshot-${cacheKey}`;
+  const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = _path2().default.join(options.cacheDir, snapshotKey + '.txt');
   const commonMeta = {
     cacheKey,
@@ -1178,7 +1174,10 @@ async function loadRequestGraph(options) {
       ...commonMeta
     }
   });
-  const hasRequestGraphInCache = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.has(requestGraphKey) : await options.cache.hasLargeBlob(requestGraphKey);
+  if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+    await (0, _EnvironmentManager.loadEnvironmentsFromCache)(options.cache);
+  }
+  const hasRequestGraphInCache = await options.cache.hasLargeBlob(requestGraphKey);
   if (hasRequestGraphInCache) {
     try {
       let {
@@ -1204,23 +1203,16 @@ async function loadRequestGraph(options) {
           duration: Date.now() - startTime
         }
       });
-      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);
-      }
+      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
+        }
+      });
       return requestGraph;
     } catch (e) {
       // Prevent logging fs events took too long warning
@@ -1246,6 +1238,20 @@ async function loadRequestGraph(options) {
  * 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.
  */
@@ -1259,9 +1265,11 @@ async function loadRequestGraph(options) {
 async function invalidateRequestGraph(requestGraph, options, events) {
   const invalidationFns = [{
     key: 'unpredictable',
+    // @ts-expect-error TS2322
     fn: () => requestGraph.invalidateUnpredictableNodes()
   }, {
     key: 'onBuild',
+    // @ts-expect-error TS2322
     fn: () => requestGraph.invalidateOnBuildNodes()
   }, {
     key: 'env',
@@ -1271,9 +1279,7 @@ async function invalidateRequestGraph(requestGraph, options, events) {
     fn: () => requestGraph.invalidateOptionNodes(options)
   }, {
     key: 'fsEvents',
-    fn: async () => {
-      await requestGraph.respondToFSEvents(options.unstableFileInvalidations || events, options, 10000, true);
-    }
+    fn: () => invalidateRequestGraphFSEvents(requestGraph, options, events)
   }];
   const invalidations = [];
   for (const invalidation of invalidationFns) {
@@ -1282,27 +1288,45 @@ async function invalidateRequestGraph(requestGraph, options, events) {
   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;
+  const nodeInvalidationRatio = invalidatedCount / nodeCount;
+  const requestInvalidationRatio = invalidatedCount / requestCount;
   return {
     invalidations,
     nodeCount,
     requestCount,
     invalidatedCount,
-    nodeInvalidationRatio: invalidatedCount / nodeCount,
-    requestInvalidationRatio: invalidatedCount / requestCount
+    nodeInvalidationRatio,
+    requestInvalidationRatio
+  };
+}
+/**
+ * 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 startInvalidationCount = requestGraph.invalidNodeIds.size;
+  const start = _perf_hooks().performance.now();
+  const startInvalidationCount = requestGraph.getInvalidNodeCount();
   const result = await invalidationFn.fn();
-  const count = requestGraph.invalidNodeIds.size - startInvalidationCount;
+  const count = requestGraph.getInvalidNodeCount() - startInvalidationCount;
+  const duration = _perf_hooks().performance.now() - start;
   return {
     key: invalidationFn.key,
     count,
-    changes: typeof result === 'object' && Array.isArray(result) ? result : null
+    detail: result ?? null,
+    duration
   };
 }
 function logErrorOnBailout(options, snapshotPath, e) {
@@ -1344,4 +1368,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);
 }