@atlaspack/core 2.17.3 → 2.17.4

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @atlaspack/core
 
+## 2.17.4
+
+### Patch Changes
+
+- [#588](https://github.com/atlassian-labs/atlaspack/pull/588) [`1940859`](https://github.com/atlassian-labs/atlaspack/commit/194085942f0e86532e9d039fc3f8039badce4594) Thanks [@yamadapc](https://github.com/yamadapc)! - Do not invalidate all javascript files when tsconfig files change
+
+- [#592](https://github.com/atlassian-labs/atlaspack/pull/592) [`15b6155`](https://github.com/atlassian-labs/atlaspack/commit/15b61556e9114203ebbc9de94b864118ca764598) Thanks [@yamadapc](https://github.com/yamadapc)! - Report large file invalidations
+
+- [#503](https://github.com/atlassian-labs/atlaspack/pull/503) [`209692f`](https://github.com/atlassian-labs/atlaspack/commit/209692ffb11eae103a0d65c5e1118a5aa1625818) Thanks [@JakeLane](https://github.com/JakeLane)! - Fix conditional bundling reporter when condition is reused
+
+- [#562](https://github.com/atlassian-labs/atlaspack/pull/562) [`d04de26`](https://github.com/atlassian-labs/atlaspack/commit/d04de26af684d7abfba5091fbe3df16a12cd0ebc) Thanks [@yamadapc](https://github.com/yamadapc)! - Update with feature-flagged change to write packages into files rather than LMDB
+
+- Updated dependencies [[`124b7ff`](https://github.com/atlassian-labs/atlaspack/commit/124b7fff44f71aac9fbad289a9a9509b3dfc9aaa), [`e052521`](https://github.com/atlassian-labs/atlaspack/commit/e0525210850ed1606146eb86991049cf567c5dec), [`15c6d70`](https://github.com/atlassian-labs/atlaspack/commit/15c6d7000bd89da876bc590aa75b17a619a41896), [`e4d966c`](https://github.com/atlassian-labs/atlaspack/commit/e4d966c3c9c4292c5013372ae65b10d19d4bacc6), [`209692f`](https://github.com/atlassian-labs/atlaspack/commit/209692ffb11eae103a0d65c5e1118a5aa1625818), [`42a775d`](https://github.com/atlassian-labs/atlaspack/commit/42a775de8eec638ad188f3271964170d8c04d84b), [`29c2f10`](https://github.com/atlassian-labs/atlaspack/commit/29c2f106de9679adfb5afa04e1910471dc65a427), [`f4da1e1`](https://github.com/atlassian-labs/atlaspack/commit/f4da1e120e73eeb5e8b8927f05e88f04d6148c7b), [`1ef91fc`](https://github.com/atlassian-labs/atlaspack/commit/1ef91fcc863fdd2831511937083dbbc1263b3d9d)]:
+  - @atlaspack/cache@3.2.4
+  - @atlaspack/rust@3.3.4
+  - @atlaspack/fs@2.15.4
+  - @atlaspack/feature-flags@2.16.0
+  - @atlaspack/logger@2.14.9
+  - @atlaspack/utils@2.14.9
+  - @atlaspack/package-manager@2.14.9
+  - @atlaspack/graph@3.4.7
+  - @atlaspack/workers@2.14.9
+  - @atlaspack/profiler@2.14.7
+  - @atlaspack/types@2.14.9
+  - @atlaspack/plugin@2.14.9
+
 ## 2.17.3
 
 ### Patch Changes

package/lib/Atlaspack.js

@@ -510,7 +510,9 @@ class Atlaspack {
       if (this.rustAtlaspack) {
         nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
       }
-      let isInvalid = await this.#requestTracker.respondToFSEvents(events, Number.POSITIVE_INFINITY);
+      let {
+        didInvalidate: isInvalid
+      } = await this.#requestTracker.respondToFSEvents(events, Number.POSITIVE_INFINITY);
       if ((nativeInvalid || isInvalid) && this.#watchQueue.getNumWaiting() === 0) {
         if (this.#watchAbortController) {
           this.#watchAbortController.abort();

package/lib/PackagerRunner.js

@@ -92,6 +92,13 @@ function _profiler() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -434,6 +441,10 @@ class PackagerRunner {
       devDepHashes += await this.getDevDepHashes(inlineBundle);
     }
     let invalidationHash = await (0, _assetUtils.getInvalidationHash)(invalidations, this.options);
+    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      const hash = (0, _rust().hashString)(_constants.ATLASPACK_VERSION + devDepHashes + invalidationHash + bundle.target.publicUrl + bundleGraph.getHash(bundle) + JSON.stringify(configResults) + JSON.stringify(globalInfoResults) + this.options.mode + (this.options.shouldBuildLazily ? 'lazy' : 'eager'));
+      return _path().default.join(bundle.displayName ?? bundle.name ?? bundle.id, hash);
+    }
     return (0, _rust().hashString)(_constants.ATLASPACK_VERSION + devDepHashes + invalidationHash + bundle.target.publicUrl + bundleGraph.getHash(bundle) + JSON.stringify(configResults) + JSON.stringify(globalInfoResults) + this.options.mode + (this.options.shouldBuildLazily ? 'lazy' : 'eager'));
   }
   async getDevDepHashes(bundle) {
@@ -457,25 +468,27 @@ class PackagerRunner {
     let contentKey = PackagerRunner.getContentKey(cacheKey);
     let mapKey = PackagerRunner.getMapKey(cacheKey);
     let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists = isLargeBlob || (await this.options.cache.has(contentKey));
+    let contentExists = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? isLargeBlob : isLargeBlob || (await this.options.cache.has(contentKey));
     if (!contentExists) {
       return null;
     }
-    let mapExists = await this.options.cache.has(mapKey);
+    let mapExists = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await this.options.cache.hasLargeBlob(mapKey) : await this.options.cache.has(mapKey);
     return {
       contents: isLargeBlob ? this.options.cache.getStream(contentKey) : (0, _utils().blobToStream)(await this.options.cache.getBlob(contentKey)),
-      map: mapExists ? (0, _utils().blobToStream)(await this.options.cache.getBlob(mapKey)) : null
+      map: mapExists ? (0, _utils().blobToStream)((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await this.options.cache.getLargeBlob(mapKey) : await this.options.cache.getBlob(mapKey)) : null
     };
   }
   async writeToCache(cacheKeys, type, contents, map) {
     let size = 0;
     let hash;
     let hashReferences = [];
-    let isLargeBlob = false;
+    let isLargeBlob = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements');
 
     // TODO: don't replace hash references in binary files??
     if (contents instanceof _stream().Readable) {
-      isLargeBlob = true;
+      if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+        isLargeBlob = true;
+      }
       let boundaryStr = '';
       let h = new (_rust().Hash)();
       await this.options.cache.setStream(cacheKeys.content, (0, _utils().blobToStream)(contents).pipe(new (_utils().TapStream)(buf => {
@@ -491,15 +504,27 @@ class PackagerRunner {
       size = buffer.byteLength;
       hash = (0, _rust().hashBuffer)(buffer);
       hashReferences = contents.match(_constants.HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, buffer);
+      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.content, buffer);
+      }
     } else {
       size = contents.length;
       hash = (0, _rust().hashBuffer)(contents);
       hashReferences = contents.toString().match(_constants.HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, contents);
+      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, contents);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.content, contents);
+      }
     }
     if (map != null) {
-      await this.options.cache.setBlob(cacheKeys.map, map);
+      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.map, map);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.map, map);
+      }
     }
     let info = {
       type,
@@ -513,12 +538,21 @@ class PackagerRunner {
     return info;
   }
   static getContentKey(cacheKey) {
+    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      return `PackagerRunner/${_constants.ATLASPACK_VERSION}/${cacheKey}/content`;
+    }
     return (0, _rust().hashString)(`${cacheKey}:content`);
   }
   static getMapKey(cacheKey) {
+    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      return `PackagerRunner/${_constants.ATLASPACK_VERSION}/${cacheKey}/map`;
+    }
     return (0, _rust().hashString)(`${cacheKey}:map`);
   }
   static getInfoKey(cacheKey) {
+    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      return `PackagerRunner/${_constants.ATLASPACK_VERSION}/${cacheKey}/info`;
+    }
     return (0, _rust().hashString)(`${cacheKey}:info`);
   }
 }

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,13 @@ 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;
+}
 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; }
@@ -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.
@@ -697,6 +713,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);
@@ -714,7 +732,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 +746,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 {
@@ -970,84 +998,85 @@ 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
-    });
+      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)(`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
+      });
 
-    // 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));
+      // 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;
+          // 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
@@ -1056,7 +1085,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,
@@ -1064,15 +1093,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',
@@ -1109,17 +1139,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) => {
@@ -1141,9 +1184,9 @@ 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,
@@ -1163,7 +1206,8 @@ async function loadRequestGraph(options) {
       ...commonMeta
     }
   });
-  if (await options.cache.hasLargeBlob(requestGraphKey)) {
+  const hasRequestGraphInCache = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.has(requestGraphKey) : await options.cache.hasLargeBlob(requestGraphKey);
+  if (hasRequestGraphInCache) {
     try {
       let {
         requestGraph
@@ -1230,6 +1274,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.
  */
@@ -1255,9 +1313,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) {
@@ -1275,18 +1331,34 @@ async function invalidateRequestGraph(requestGraph, options, events) {
     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 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) {
@@ -1328,4 +1400,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);
 }

package/lib/UncommittedAsset.js

@@ -53,6 +53,13 @@ var _assetUtils = require("./assetUtils");
 var _types = require("./types");
 var _utils2 = require("./utils");
 var _projectPath = require("./projectPath");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class UncommittedAsset {
   constructor({
@@ -133,6 +140,8 @@ class UncommittedAsset {
       hash = (0, _rust().hashBuffer)(content);
       size = content.length;
     }
+
+    // Maybe we should just store this in a file instead of LMDB
     await this.options.cache.setBlob(contentKey, content);
     return {
       size,
@@ -184,6 +193,10 @@ class UncommittedAsset {
     this.content = buffer;
     this.clearAST();
   }
+
+  /**
+   * @deprecated This has been broken on any cache other than FSCache for a long time.
+   */
   setStream(stream) {
     this.content = stream;
     this.clearAST();
@@ -248,6 +261,10 @@ class UncommittedAsset {
     this.value.astGenerator = null;
   }
   getCacheKey(key) {
+    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      const filePath = (0, _projectPath.fromProjectPathRelative)(this.value.filePath);
+      return `Asset/${_constants.ATLASPACK_VERSION}/${filePath}/${this.value.id}/${key}`;
+    }
     return (0, _rust().hashString)(_constants.ATLASPACK_VERSION + key + this.value.id);
   }
   addDependency(opts) {

package/lib/atlaspack-v3/worker/worker.js

@@ -149,6 +149,14 @@ class AtlaspackWorker {
         }
       };
     }
+    if (result.isExcluded) {
+      return {
+        invalidations: [],
+        resolution: {
+          type: 'excluded'
+        }
+      };
+    }
     return {
       invalidations: [],
       resolution: {