@atlaspack/core 2.14.1-dev.142 → 2.14.1-dev.145

package/CHANGELOG.md

@@ -1,5 +1,147 @@
 # @atlaspack/core
 
+## 2.17.3
+
+### Patch Changes
+
+- [#551](https://github.com/atlassian-labs/atlaspack/pull/551) [`30f6017`](https://github.com/atlassian-labs/atlaspack/commit/30f60175ba4d272c5fc193973c63bc298584775b) Thanks [@yamadapc](https://github.com/yamadapc)! - Log request tracker invalidation counts on start-up
+
+- [#550](https://github.com/atlassian-labs/atlaspack/pull/550) [`3a3e8e7`](https://github.com/atlassian-labs/atlaspack/commit/3a3e8e7be9e2dffd7304436d792f0f595d59665a) Thanks [@yamadapc](https://github.com/yamadapc)! - Fix typescript declaration files
+
+- [#555](https://github.com/atlassian-labs/atlaspack/pull/555) [`15c1e3c`](https://github.com/atlassian-labs/atlaspack/commit/15c1e3c0628bae4c768d76cf3afc53d6d0d7ce7c) Thanks [@alshdavid](https://github.com/alshdavid)! - Added ATLASPACK_NATIVE_THREADS env variable to control the number of threads used by the native thread schedular
+
+- Updated dependencies [[`30f6017`](https://github.com/atlassian-labs/atlaspack/commit/30f60175ba4d272c5fc193973c63bc298584775b), [`3a3e8e7`](https://github.com/atlassian-labs/atlaspack/commit/3a3e8e7be9e2dffd7304436d792f0f595d59665a), [`1ab0a27`](https://github.com/atlassian-labs/atlaspack/commit/1ab0a275aeca40350415e2b03e7440d1dddc6228), [`b8a4ae8`](https://github.com/atlassian-labs/atlaspack/commit/b8a4ae8f83dc0a83d8b145c5f729936ce52080a3)]:
+  - @atlaspack/feature-flags@2.15.1
+  - @atlaspack/fs@2.15.3
+  - @atlaspack/rust@3.3.3
+  - @atlaspack/cache@3.2.3
+  - @atlaspack/graph@3.4.6
+  - @atlaspack/utils@2.14.8
+  - @atlaspack/package-manager@2.14.8
+  - @atlaspack/logger@2.14.8
+  - @atlaspack/profiler@2.14.6
+  - @atlaspack/types@2.14.8
+  - @atlaspack/workers@2.14.8
+  - @atlaspack/plugin@2.14.8
+
+## 2.17.2
+
+### Patch Changes
+
+- Updated dependencies [[`a1773d2`](https://github.com/atlassian-labs/atlaspack/commit/a1773d2a62d0ef7805ac7524621dcabcc1afe929), [`556d6ab`](https://github.com/atlassian-labs/atlaspack/commit/556d6ab8ede759fa7f37fcd3f4da336ef1c55e8f)]:
+  - @atlaspack/feature-flags@2.15.0
+  - @atlaspack/logger@2.14.7
+  - @atlaspack/rust@3.3.2
+  - @atlaspack/cache@3.2.2
+  - @atlaspack/fs@2.15.2
+  - @atlaspack/graph@3.4.5
+  - @atlaspack/utils@2.14.7
+  - @atlaspack/package-manager@2.14.7
+  - @atlaspack/workers@2.14.7
+  - @atlaspack/profiler@2.14.5
+  - @atlaspack/types@2.14.7
+  - @atlaspack/plugin@2.14.7
+
+## 2.17.1
+
+### Patch Changes
+
+- Updated dependencies [[`e0f5337`](https://github.com/atlassian-labs/atlaspack/commit/e0f533757bd1019dbd108a04952c87da15286e09)]:
+  - @atlaspack/feature-flags@2.14.4
+  - @atlaspack/rust@3.3.1
+  - @atlaspack/cache@3.2.1
+  - @atlaspack/fs@2.15.1
+  - @atlaspack/graph@3.4.4
+  - @atlaspack/utils@2.14.6
+  - @atlaspack/logger@2.14.6
+  - @atlaspack/package-manager@2.14.6
+  - @atlaspack/profiler@2.14.4
+  - @atlaspack/types@2.14.6
+  - @atlaspack/workers@2.14.6
+  - @atlaspack/plugin@2.14.6
+
+## 2.17.0
+
+### Minor Changes
+
+- [#541](https://github.com/atlassian-labs/atlaspack/pull/541) [`e2ba0f6`](https://github.com/atlassian-labs/atlaspack/commit/e2ba0f69702656f3d1ce95ab1454e35062b13b39) Thanks [@yamadapc](https://github.com/yamadapc)! - Add database compaction debug command
+
+### Patch Changes
+
+- [#530](https://github.com/atlassian-labs/atlaspack/pull/530) [`2e90c9b`](https://github.com/atlassian-labs/atlaspack/commit/2e90c9bd07d7eb52645f9d84ccbb7f82685cbc8c) Thanks [@yamadapc](https://github.com/yamadapc)! - Write metadata about the cache in a new entry
+
+- [#511](https://github.com/atlassian-labs/atlaspack/pull/511) [`11d6f16`](https://github.com/atlassian-labs/atlaspack/commit/11d6f16b6397dee2f217167e5c98b39edb63f7a7) Thanks [@yamadapc](https://github.com/yamadapc)! - Clean-up dylib worker threads segmentation fault bug fix feature-flag
+
+- Updated dependencies [[`11d6f16`](https://github.com/atlassian-labs/atlaspack/commit/11d6f16b6397dee2f217167e5c98b39edb63f7a7), [`e2ba0f6`](https://github.com/atlassian-labs/atlaspack/commit/e2ba0f69702656f3d1ce95ab1454e35062b13b39), [`d2c50c2`](https://github.com/atlassian-labs/atlaspack/commit/d2c50c2c020888b33bb25b8690d9320c2b69e2a6), [`46a90dc`](https://github.com/atlassian-labs/atlaspack/commit/46a90dccd019a26b222c878a92d23acc75dc67c5), [`4c17141`](https://github.com/atlassian-labs/atlaspack/commit/4c1714103dab2aa9039c488f381551d2b65d1d01)]:
+  - @atlaspack/feature-flags@2.14.3
+  - @atlaspack/rust@3.3.0
+  - @atlaspack/cache@3.2.0
+  - @atlaspack/fs@2.15.0
+  - @atlaspack/graph@3.4.3
+  - @atlaspack/utils@2.14.5
+  - @atlaspack/logger@2.14.5
+  - @atlaspack/package-manager@2.14.5
+  - @atlaspack/profiler@2.14.3
+  - @atlaspack/types@2.14.5
+  - @atlaspack/workers@2.14.5
+  - @atlaspack/plugin@2.14.5
+
+## 2.16.1
+
+### Patch Changes
+
+- [#525](https://github.com/atlassian-labs/atlaspack/pull/525) [`cb9da16`](https://github.com/atlassian-labs/atlaspack/commit/cb9da16fb2648e7f53c64df0313f60d5fb8970cc) Thanks [@yamadapc](https://github.com/yamadapc)! - Fix issues with large blob cache writes, run cache writes in a write transaction
+
+- Updated dependencies [[`1a2c14c`](https://github.com/atlassian-labs/atlaspack/commit/1a2c14c3cd4587551cc12e94d0680c8b71ea12bf), [`cb9da16`](https://github.com/atlassian-labs/atlaspack/commit/cb9da16fb2648e7f53c64df0313f60d5fb8970cc)]:
+  - @atlaspack/rust@3.2.0
+  - @atlaspack/cache@3.1.0
+  - @atlaspack/fs@2.14.4
+  - @atlaspack/logger@2.14.4
+  - @atlaspack/utils@2.14.4
+  - @atlaspack/package-manager@2.14.4
+  - @atlaspack/workers@2.14.4
+  - @atlaspack/types@2.14.4
+  - @atlaspack/plugin@2.14.4
+
+## 2.16.0
+
+### Minor Changes
+
+- [#520](https://github.com/atlassian-labs/atlaspack/pull/520) [`90150df`](https://github.com/atlassian-labs/atlaspack/commit/90150dfb68236e1d1c11813108ecabd92cff9366) Thanks [@pancaspe87](https://github.com/pancaspe87)! - Modify "large blobs" to be written to the LMDB cache
+
+### Patch Changes
+
+- Updated dependencies [[`f27d39e`](https://github.com/atlassian-labs/atlaspack/commit/f27d39e767b06def059944b3bc5fd50797eaea96)]:
+  - @atlaspack/rust@3.1.1
+  - @atlaspack/cache@3.0.1
+  - @atlaspack/fs@2.14.3
+  - @atlaspack/logger@2.14.3
+  - @atlaspack/utils@2.14.3
+  - @atlaspack/package-manager@2.14.3
+  - @atlaspack/workers@2.14.3
+  - @atlaspack/types@2.14.3
+  - @atlaspack/plugin@2.14.3
+
+## 2.15.1
+
+### Patch Changes
+
+- [#512](https://github.com/atlassian-labs/atlaspack/pull/512) [`8f4e6c1`](https://github.com/atlassian-labs/atlaspack/commit/8f4e6c1b0e7c1fd48624afda48c1dcc599f1460f) Thanks [@yamadapc](https://github.com/yamadapc)! - Remove LMDB cache back-end
+
+- Updated dependencies [[`9b85d3e`](https://github.com/atlassian-labs/atlaspack/commit/9b85d3e645b10bd027eed2304afc970a5ba40062), [`a891d65`](https://github.com/atlassian-labs/atlaspack/commit/a891d652bc4eb3d757d381adf65c5083f706effc), [`d02eab9`](https://github.com/atlassian-labs/atlaspack/commit/d02eab95eb60bf7457e0869af0b773608592c0e6), [`fb87a90`](https://github.com/atlassian-labs/atlaspack/commit/fb87a901973776b33ca4ce530e9d71669a9bd36d), [`7b9e8cf`](https://github.com/atlassian-labs/atlaspack/commit/7b9e8cf29e01a98e72e46b2b2fb74ccc514f4463), [`17b9579`](https://github.com/atlassian-labs/atlaspack/commit/17b9579484eced0ed8f23e2aba6d23b3c7238c39), [`8f4e6c1`](https://github.com/atlassian-labs/atlaspack/commit/8f4e6c1b0e7c1fd48624afda48c1dcc599f1460f)]:
+  - @atlaspack/feature-flags@2.14.2
+  - @atlaspack/rust@3.1.0
+  - @atlaspack/cache@3.0.0
+  - @atlaspack/fs@2.14.2
+  - @atlaspack/graph@3.4.2
+  - @atlaspack/utils@2.14.2
+  - @atlaspack/logger@2.14.2
+  - @atlaspack/package-manager@2.14.2
+  - @atlaspack/profiler@2.14.2
+  - @atlaspack/types@2.14.2
+  - @atlaspack/workers@2.14.2
+  - @atlaspack/plugin@2.14.2
+
 ## 2.15.0
 
 ### Minor Changes

package/lib/Atlaspack.js

@@ -166,9 +166,7 @@ class Atlaspack {
       ...this.#initialOptions.featureFlags
     };
     (0, _featureFlags().setFeatureFlags)(featureFlags);
-    if ((0, _featureFlags().getFeatureFlag)('enableRustWorkerThreadDylibHack')) {
-      (0, _rustWorkerThreadDylibHack.loadRustWorkerThreadDylibHack)();
-    }
+    (0, _rustWorkerThreadDylibHack.loadRustWorkerThreadDylibHack)();
     await _sourceMap().init;
     await (_rust().init === null || _rust().init === void 0 ? void 0 : (0, _rust().init)());
     this.#disposable = new (_events().Disposable)();
@@ -209,9 +207,15 @@ class Atlaspack {
       // $FlowFixMe
       const version = require('../package.json').version;
       await lmdb.put('current_session_version', Buffer.from(version));
+      let threads = undefined;
+      if (process.env.ATLASPACK_NATIVE_THREADS !== undefined) {
+        threads = parseInt(process.env.ATLASPACK_NATIVE_THREADS, 10);
+      } else if (process.env.NODE_ENV === 'test') {
+        threads = 2;
+      }
       rustAtlaspack = await _atlaspackV.AtlaspackV3.create({
         ...options,
-        threads: process.env.NODE_ENV === 'test' ? 2 : undefined,
+        threads,
         entries: Array.isArray(entries) ? entries : entries == null ? undefined : [entries],
         env: resolvedOptions.env,
         fs: inputFS && new _atlaspackV.FileSystemV3(inputFS),
@@ -602,6 +606,19 @@ class Atlaspack {
     }
     return result;
   }
+
+  /**
+   * Copy the cache to a new directory and compact it.
+   */
+  async unstable_compactCache() {
+    await this._init();
+    const cache = (0, _nullthrows().default)(this.#resolvedOptions).cache;
+    if (cache instanceof _cache().LMDBLiteCache) {
+      await cache.compact('parcel-cache-compacted');
+    } else {
+      throw new Error('Cache is not an LMDBLiteCache');
+    }
+  }
   async unstable_transform(options) {
     var _options$env;
     if (!this.#initialized) {

package/lib/RequestTracker.js

@@ -30,6 +30,13 @@ 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 () {
@@ -45,7 +52,7 @@ function _graph() {
   return data;
 }
 function _logger() {
-  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  const data = _interopRequireWildcard(require("@atlaspack/logger"));
   _logger = function () {
     return data;
   };
@@ -272,6 +279,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));
@@ -279,6 +292,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));
@@ -286,29 +303,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));
@@ -759,8 +792,10 @@ class RequestTracker {
       return result;
     } else if (node.resultCacheKey != null && ifMatch == null) {
       let key = node.resultCacheKey;
-      (0, _assert().default)(this.options.cache.hasLargeBlob(key));
-      let cachedResult = (0, _buildCache().deserialize)(await this.options.cache.getLargeBlob(key));
+      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));
       node.result = cachedResult;
       return cachedResult;
     }
@@ -924,6 +959,20 @@ class RequestTracker {
     };
   }
   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;
+      }
+    }
+    await runCacheImprovements(async cache => {
+      await cache.getNativeRef().startWriteTransaction();
+    }, () => Promise.resolve());
     let cacheKey = getCacheKey(this.options);
     let requestGraphKey = `requestGraph-${cacheKey}`;
     if (this.options.shouldDisableCache) {
@@ -944,9 +993,16 @@ class RequestTracker {
       if (signal !== null && signal !== void 0 && signal.aborted) {
         throw new Error('Serialization was aborted');
       }
-      await this.options.cache.setLargeBlob(key, (0, _buildCache().serialize)(contents), signal ? {
-        signal: signal
-      } : undefined);
+      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;
       (0, _ReporterRunner.report)({
         type: 'cache',
@@ -1000,6 +1056,13 @@ class RequestTracker {
         nodeCountsPerBlob,
         nodes: undefined
       });
+      await runCacheImprovements(() => serialiseAndSet(`request_tracker:cache_metadata:${cacheKey}`, {
+        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, `snapshot-${cacheKey}` + '.txt');
       await this.options.outputFS.writeSnapshot(this.options.watchDir, snapshotPath, opts);
@@ -1007,6 +1070,9 @@ class RequestTracker {
       // If we have aborted, ignore the error and continue
       if (!(signal !== null && signal !== void 0 && signal.aborted)) throw err;
     }
+    await runCacheImprovements(async cache => {
+      await cache.getNativeRef().commitWriteTransaction();
+    }, () => Promise.resolve());
     (0, _ReporterRunner.report)({
       type: 'cache',
       phase: 'end',
@@ -1079,12 +1145,22 @@ async function loadRequestGraph(options) {
   let timeout;
   const snapshotKey = `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)) {
@@ -1106,16 +1182,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
@@ -1130,12 +1219,76 @@ 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
+ */
+
+/**
+ * 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: async () => {
+      await requestGraph.respondToFSEvents(options.unstableFileInvalidations || events, options, 10000, true);
+    }
+  }];
+  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
+  };
+}
+
+/**
+ * Runs an invalidation function and reports metrics.
+ */
+async function runInvalidation(requestGraph, invalidationFn) {
+  const startInvalidationCount = requestGraph.invalidNodeIds.size;
+  const result = await invalidationFn.fn();
+  const count = requestGraph.invalidNodeIds.size - startInvalidationCount;
+  return {
+    key: invalidationFn.key,
+    count,
+    changes: typeof result === 'object' && Array.isArray(result) ? result : null
+  };
+}
 function logErrorOnBailout(options, snapshotPath, e) {
   if (e.message && e.message.includes('invalid clockspec')) {
     const snapshotContents = options.inputFS.readFileSync(snapshotPath, 'utf-8');

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

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

package/lib/public/BundleGraph.js

@@ -32,6 +32,13 @@ var _Dependency = _interopRequireWildcard(require("./Dependency"));
 var _Target = require("./Target");
 var _utils = require("../utils");
 var _BundleGroup = _interopRequireWildcard(require("./BundleGroup"));
+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 }; }
@@ -263,11 +270,20 @@ class BundleGraph {
       }
       for (let bundle of bundles) {
         const conditions = bundleConditions.get(bundle.id) ?? new Map();
-        conditions.set(cond.key, {
-          bundle,
-          ifTrueBundles,
-          ifFalseBundles
-        });
+        const currentCondition = conditions.get(cond.key);
+        if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingReporterSameConditionFix')) {
+          conditions.set(cond.key, {
+            bundle,
+            ifTrueBundles: [...((currentCondition === null || currentCondition === void 0 ? void 0 : currentCondition.ifTrueBundles) ?? []), ...ifTrueBundles],
+            ifFalseBundles: [...((currentCondition === null || currentCondition === void 0 ? void 0 : currentCondition.ifFalseBundles) ?? []), ...ifFalseBundles]
+          });
+        } else {
+          conditions.set(cond.key, {
+            bundle,
+            ifTrueBundles,
+            ifFalseBundles
+          });
+        }
         bundleConditions.set(bundle.id, conditions);
       }
     }

package/lib/resolveOptions.js

@@ -148,10 +148,7 @@ async function resolveOptions(initialOptions) {
     if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
       return new (_cache().FSCache)(outputFS, cacheDir);
     }
-    if (needsRustLmdbCache || (0, _featureFlags().getFeatureFlag)('useLmdbJsLite')) {
-      return new (_cache().LMDBLiteCache)(cacheDir);
-    }
-    return new (_cache().LMDBCache)(cacheDir);
+    return new (_cache().LMDBLiteCache)(cacheDir);
   }();
   let mode = initialOptions.mode ?? 'development';
   let shouldOptimize = (initialOptions === null || initialOptions === void 0 || (_initialOptions$defau = initialOptions.defaultTargetOptions) === null || _initialOptions$defau === void 0 ? void 0 : _initialOptions$defau.shouldOptimize) ?? mode === 'production';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.14.1-dev.142+529a21a40",
+  "version": "2.14.1-dev.145+fa4d24840",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -10,6 +10,7 @@
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
   "main": "lib/index.js",
+  "types": "index.d.ts",
   "source": "src/index.js",
   "engines": {
     "node": ">= 16.0.0"
@@ -20,21 +21,21 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-dev.142+529a21a40",
-    "@atlaspack/cache": "2.13.3-dev.142+529a21a40",
-    "@atlaspack/diagnostic": "2.14.1-dev.142+529a21a40",
-    "@atlaspack/events": "2.14.1-dev.142+529a21a40",
-    "@atlaspack/feature-flags": "2.14.1-dev.142+529a21a40",
-    "@atlaspack/fs": "2.14.1-dev.142+529a21a40",
-    "@atlaspack/graph": "3.4.1-dev.142+529a21a40",
-    "@atlaspack/logger": "2.14.1-dev.142+529a21a40",
-    "@atlaspack/package-manager": "2.14.1-dev.142+529a21a40",
-    "@atlaspack/plugin": "2.14.1-dev.142+529a21a40",
-    "@atlaspack/profiler": "2.14.1-dev.142+529a21a40",
-    "@atlaspack/rust": "3.0.1-dev.142+529a21a40",
-    "@atlaspack/types": "2.14.1-dev.142+529a21a40",
-    "@atlaspack/utils": "2.14.1-dev.142+529a21a40",
-    "@atlaspack/workers": "2.14.1-dev.142+529a21a40",
+    "@atlaspack/build-cache": "2.13.3-dev.145+fa4d24840",
+    "@atlaspack/cache": "2.13.3-dev.145+fa4d24840",
+    "@atlaspack/diagnostic": "2.14.1-dev.145+fa4d24840",
+    "@atlaspack/events": "2.14.1-dev.145+fa4d24840",
+    "@atlaspack/feature-flags": "2.14.1-dev.145+fa4d24840",
+    "@atlaspack/fs": "2.14.1-dev.145+fa4d24840",
+    "@atlaspack/graph": "3.4.1-dev.145+fa4d24840",
+    "@atlaspack/logger": "2.14.1-dev.145+fa4d24840",
+    "@atlaspack/package-manager": "2.14.1-dev.145+fa4d24840",
+    "@atlaspack/plugin": "2.14.1-dev.145+fa4d24840",
+    "@atlaspack/profiler": "2.14.1-dev.145+fa4d24840",
+    "@atlaspack/rust": "3.0.1-dev.145+fa4d24840",
+    "@atlaspack/types": "2.14.1-dev.145+fa4d24840",
+    "@atlaspack/utils": "2.14.1-dev.145+fa4d24840",
+    "@atlaspack/workers": "2.14.1-dev.145+fa4d24840",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -57,7 +58,10 @@
   },
   "exports": {
     "./*": "./*",
-    ".": "./lib/index.js",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./worker": {
       "@atlaspack::sources": "./src/worker.js",
       "default": "./lib/worker.js"
@@ -70,5 +74,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "529a21a40d655a8a92dbc8a4a91e0992d0e9e60e"
+  "gitHead": "fa4d24840815e7048a21d74caf01e2df633fabe3"
 }

package/src/Atlaspack.js

@@ -58,11 +58,7 @@ import {
   fromProjectPathRelative,
 } from './projectPath';
 import {tracer} from '@atlaspack/profiler';
-import {
-  getFeatureFlag,
-  setFeatureFlags,
-  DEFAULT_FEATURE_FLAGS,
-} from '@atlaspack/feature-flags';
+import {setFeatureFlags, DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
 import {AtlaspackV3, FileSystemV3} from './atlaspack-v3';
 import createAssetGraphRequestJS from './requests/AssetGraphRequest';
 import {createAssetGraphRequestRust} from './requests/AssetGraphRequestRust';
@@ -125,9 +121,7 @@ export default class Atlaspack {
     };
     setFeatureFlags(featureFlags);
 
-    if (getFeatureFlag('enableRustWorkerThreadDylibHack')) {
-      loadRustWorkerThreadDylibHack();
-    }
+    loadRustWorkerThreadDylibHack();
 
     await initSourcemaps;
     await initRust?.();
@@ -174,9 +168,16 @@ export default class Atlaspack {
       const version = require('../package.json').version;
       await lmdb.put('current_session_version', Buffer.from(version));
 
+      let threads = undefined;
+      if (process.env.ATLASPACK_NATIVE_THREADS !== undefined) {
+        threads = parseInt(process.env.ATLASPACK_NATIVE_THREADS, 10);
+      } else if (process.env.NODE_ENV === 'test') {
+        threads = 2;
+      }
+
       rustAtlaspack = await AtlaspackV3.create({
         ...options,
-        threads: process.env.NODE_ENV === 'test' ? 2 : undefined,
+        threads,
         entries: Array.isArray(entries)
           ? entries
           : entries == null
@@ -647,6 +648,20 @@ export default class Atlaspack {
     return result;
   }
 
+  /**
+   * Copy the cache to a new directory and compact it.
+   */
+  async unstable_compactCache(): Promise<void> {
+    await this._init();
+
+    const cache = nullthrows(this.#resolvedOptions).cache;
+    if (cache instanceof LMDBLiteCache) {
+      await cache.compact('parcel-cache-compacted');
+    } else {
+      throw new Error('Cache is not an LMDBLiteCache');
+    }
+  }
+
   async unstable_transform(
     options: AtlaspackTransformOptions,
   ): Promise<Array<Asset>> {

package/src/RequestTracker.js

@@ -4,7 +4,7 @@ import invariant, {AssertionError} from 'assert';
 import path from 'path';
 
 import {deserialize, serialize} from '@atlaspack/build-cache';
-import type {Cache} from '@atlaspack/cache';
+import {LMDBLiteCache, type Cache} from '@atlaspack/cache';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {ContentGraph} from '@atlaspack/graph';
 import type {
@@ -14,7 +14,7 @@ import type {
   SerializedContentGraph,
   Graph,
 } from '@atlaspack/graph';
-import logger from '@atlaspack/logger';
+import logger, {instrument} from '@atlaspack/logger';
 import {hashString} from '@atlaspack/rust';
 import type {Async, EnvMap} from '@atlaspack/types';
 import {
@@ -446,6 +446,11 @@ export class RequestGraph extends ContentGraph<
     this.removeCachedRequestChunkForNode(nodeId);
   }
 
+  /**
+   * Nodes that are invalidated on start-up, such as JavaScript babel configuration files which are
+   * imported when the build kicks-off and might doing arbitrary work such as reading from the file
+   * system.
+   */
   invalidateUnpredictableNodes() {
     for (let nodeId of this.unpredicatableNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
@@ -454,6 +459,9 @@ export class RequestGraph extends ContentGraph<
     }
   }
 
+  /**
+   * Effectively uncacheable nodes.
+   */
   invalidateOnBuildNodes() {
     for (let nodeId of this.invalidateOnBuildNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
@@ -462,11 +470,20 @@ export class RequestGraph extends ContentGraph<
     }
   }
 
-  invalidateEnvNodes(env: EnvMap) {
+  /**
+   * Nodes invalidated by environment changes, corresponds to `env: ...` inputs.
+   */
+  invalidateEnvNodes(env: EnvMap): string[] {
+    const invalidatedKeys = [];
+
     for (let nodeId of this.envNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
       invariant(node.type === ENV);
-      if (env[keyFromEnvContentKey(node.id)] !== node.value) {
+
+      const key = keyFromEnvContentKey(node.id);
+      if (env[key] !== node.value) {
+        invalidatedKeys.push(key);
+
         let parentNodes = this.getNodeIdsConnectedTo(
           nodeId,
           requestGraphEdgeTypes.invalidated_by_update,
@@ -476,15 +493,23 @@ export class RequestGraph extends ContentGraph<
         }
       }
     }
+
+    return invalidatedKeys;
   }
 
-  invalidateOptionNodes(options: AtlaspackOptions) {
+  /**
+   * Nodes invalidated by option changes.
+   */
+  invalidateOptionNodes(options: AtlaspackOptions): string[] {
+    const invalidatedKeys = [];
+
     for (let nodeId of this.optionNodeIds) {
       let node = nullthrows(this.getNode(nodeId));
       invariant(node.type === OPTION);
-      if (
-        hashFromOption(options[keyFromOptionContentKey(node.id)]) !== node.hash
-      ) {
+      const key = keyFromOptionContentKey(node.id);
+
+      if (hashFromOption(options[key]) !== node.hash) {
+        invalidatedKeys.push(key);
         let parentNodes = this.getNodeIdsConnectedTo(
           nodeId,
           requestGraphEdgeTypes.invalidated_by_update,
@@ -494,6 +519,8 @@ export class RequestGraph extends ContentGraph<
         }
       }
     }
+
+    return invalidatedKeys;
   }
 
   invalidateOnConfigKeyChange(
@@ -1228,10 +1255,13 @@ export default class RequestTracker {
       return result;
     } else if (node.resultCacheKey != null && ifMatch == null) {
       let key = node.resultCacheKey;
-      invariant(this.options.cache.hasLargeBlob(key));
-      let cachedResult: T = deserialize(
-        await this.options.cache.getLargeBlob(key),
-      );
+      if (!getFeatureFlag('cachePerformanceImprovements')) {
+        invariant(this.options.cache.hasLargeBlob(key));
+      }
+
+      let cachedResult: T = getFeatureFlag('cachePerformanceImprovements')
+        ? nullthrows(await this.options.cache.get<T>(key))
+        : deserialize(await this.options.cache.getLargeBlob(key));
       node.result = cachedResult;
       return cachedResult;
     }
@@ -1454,6 +1484,28 @@ export default class RequestTracker {
   }
 
   async writeToCache(signal?: AbortSignal) {
+    const options = this.options;
+    async function runCacheImprovements<T>(
+      newPath: (cache: LMDBLiteCache) => Promise<T>,
+      oldPath: () => Promise<T>,
+    ): Promise<T> {
+      if (getFeatureFlag('cachePerformanceImprovements')) {
+        invariant(options.cache instanceof LMDBLiteCache);
+        const result = await newPath(options.cache);
+        return result;
+      } else {
+        const result = await oldPath();
+        return result;
+      }
+    }
+
+    await runCacheImprovements(
+      async (cache) => {
+        await cache.getNativeRef().startWriteTransaction();
+      },
+      () => Promise.resolve(),
+    );
+
     let cacheKey = getCacheKey(this.options);
     let requestGraphKey = `requestGraph-${cacheKey}`;
     let snapshotKey = `snapshot-${cacheKey}`;
@@ -1484,14 +1536,24 @@ export default class RequestTracker {
         throw new Error('Serialization was aborted');
       }
 
-      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;
@@ -1570,6 +1632,18 @@ export default class RequestTracker {
         nodes: undefined,
       });
 
+      await runCacheImprovements(
+        () =>
+          serialiseAndSet(`request_tracker:cache_metadata:${cacheKey}`, {
+            version: ATLASPACK_VERSION,
+            entries: this.options.entries,
+            mode: this.options.mode,
+            shouldBuildLazily: this.options.shouldBuildLazily,
+            watchBackend: this.options.watchBackend,
+          }),
+        () => Promise.resolve(),
+      );
+
       let opts = getWatcherOptions(this.options);
       let snapshotPath = path.join(this.options.cacheDir, snapshotKey + '.txt');
 
@@ -1583,6 +1657,13 @@ export default class RequestTracker {
       if (!signal?.aborted) throw err;
     }
 
+    await runCacheImprovements(
+      async (cache) => {
+        await cache.getNativeRef().commitWriteTransaction();
+      },
+      () => Promise.resolve(),
+    );
+
     report({type: 'cache', phase: 'end', total, size: this.graph.nodes.length});
   }
 
@@ -1631,6 +1712,7 @@ export async function readAndDeserializeRequestGraph(
   cacheKey: string,
 ): Async<{|requestGraph: RequestGraph, bufferLength: number|}> {
   let bufferLength = 0;
+
   const getAndDeserialize = async (key: string) => {
     let buffer = await cache.getLargeBlob(key);
     bufferLength += Buffer.byteLength(buffer);
@@ -1672,14 +1754,26 @@ async function loadRequestGraph(options): Async<RequestGraph> {
   const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = path.join(options.cacheDir, snapshotKey + '.txt');
 
+  const commonMeta = {
+    cacheKey,
+    snapshotKey,
+    cacheKeyOptions: {
+      version: ATLASPACK_VERSION,
+      entries: options.entries,
+      mode: options.mode,
+      shouldBuildLazily: options.shouldBuildLazily,
+      watchBackend: options.watchBackend,
+    },
+  };
+
   logger.verbose({
     origin: '@atlaspack/core',
     message: 'Loading request graph',
     meta: {
-      cacheKey,
-      snapshotKey,
+      ...commonMeta,
     },
   });
+
   if (await options.cache.hasLargeBlob(requestGraphKey)) {
     try {
       let {requestGraph} = await readAndDeserializeRequestGraph(
@@ -1711,23 +1805,36 @@ async function loadRequestGraph(options): Async<RequestGraph> {
         origin: '@atlaspack/core',
         message: `File system event count: ${events.length}`,
         meta: {
+          ...commonMeta,
           trackableEvent: 'watcher_events_count',
           watcherEventCount: events.length,
           duration: Date.now() - startTime,
         },
       });
 
-      requestGraph.invalidateUnpredictableNodes();
-      requestGraph.invalidateOnBuildNodes();
-      requestGraph.invalidateEnvNodes(options.env);
-      requestGraph.invalidateOptionNodes(options);
+      if (getFeatureFlag('verboseRequestInvalidationStats')) {
+        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);
+      }
 
-      await requestGraph.respondToFSEvents(
-        options.unstableFileInvalidations || events,
-        options,
-        10000,
-        true,
-      );
       return requestGraph;
     } catch (e) {
       // Prevent logging fs events took too long warning
@@ -1744,13 +1851,158 @@ async function loadRequestGraph(options): Async<RequestGraph> {
     message:
       'Cache entry for request tracker was not found, initializing a clean cache.',
     meta: {
-      cacheKey,
-      snapshotKey,
+      ...commonMeta,
+      trackableEvent: 'request_tracker_cache_key_miss',
     },
   });
   return new RequestGraph();
 }
 
+/**
+ * A wrapper around an invalidation type / method
+ */
+type InvalidationFn = {|
+  key: string,
+  fn: () => string[] | void | Promise<void>,
+|};
+
+type InvalidationStats = {|
+  /**
+   * Total number of request graph nodes
+   */
+  nodeCount: number,
+  /**
+   * Number of requests in RequestGraph
+   */
+  requestCount: number,
+  /**
+   * Number of nodes that have been invalidated.
+   */
+  invalidatedCount: number,
+  /**
+   * Percentage of requests that have been invalidated
+   */
+  requestInvalidationRatio: number,
+  /**
+   * Percentage of nodes that have been invalidated
+   */
+  nodeInvalidationRatio: number,
+  /**
+   * Details for each invalidation type
+   */
+  invalidations: InvalidationFnStats[],
+|};
+
+/**
+ * Information about a certain cache invalidation type.
+ */
+type InvalidationFnStats = {|
+  /**
+   * Invalidation type, one of:
+   *
+   * - unpredictable
+   * - onBuild
+   * - env
+   * - option
+   * - fsEvents
+   */
+  key: string,
+  /**
+   * Number of invalidated nodes coming from this invalidation type.
+   */
+  count: number,
+  /**
+   * If this is a env or option invalidation, this key will contain the list of changed values.
+   */
+  changes: null | string[],
+|};
+
+/**
+ * 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: RequestGraph,
+  options: AtlaspackOptions,
+  events: Event[],
+): Promise<InvalidationStats> {
+  const invalidationFns: InvalidationFn[] = [
+    {
+      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: async () => {
+        await requestGraph.respondToFSEvents(
+          options.unstableFileInvalidations || events,
+          options,
+          10000,
+          true,
+        );
+      },
+    },
+  ];
+
+  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?.type === REQUEST ? 1 : 0),
+    0,
+  );
+  const nodeCount = requestGraph.nodes.length;
+  const nodeInvalidationRatio = invalidatedCount / nodeCount;
+  const requestInvalidationRatio = invalidatedCount / requestCount;
+
+  return {
+    invalidations,
+    nodeCount,
+    requestCount,
+    invalidatedCount,
+    nodeInvalidationRatio,
+    requestInvalidationRatio,
+  };
+}
+
+/**
+ * Runs an invalidation function and reports metrics.
+ */
+async function runInvalidation(
+  requestGraph: RequestGraph,
+  invalidationFn: InvalidationFn,
+): Promise<InvalidationFnStats> {
+  const startInvalidationCount = requestGraph.invalidNodeIds.size;
+  const result = await invalidationFn.fn();
+  const count = requestGraph.invalidNodeIds.size - startInvalidationCount;
+
+  return {
+    key: invalidationFn.key,
+    count,
+    changes:
+      typeof result === 'object' && Array.isArray(result) ? result : null,
+  };
+}
+
 function logErrorOnBailout(
   options: AtlaspackOptions,
   snapshotPath: string,

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

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

package/src/public/BundleGraph.js

@@ -31,6 +31,7 @@ import Dependency, {
 import {targetToInternalTarget} from './Target';
 import {fromInternalSourceLocation} from '../utils';
 import BundleGroup, {bundleGroupToInternalBundleGroup} from './BundleGroup';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 // Friendly access for other modules within this package that need access
 // to the internal bundle.
@@ -489,11 +490,27 @@ export default class BundleGraph<TBundle: IBundle>
       for (let bundle of bundles) {
         const conditions = bundleConditions.get(bundle.id) ?? new Map();
 
-        conditions.set(cond.key, {
-          bundle,
-          ifTrueBundles,
-          ifFalseBundles,
-        });
+        const currentCondition = conditions.get(cond.key);
+
+        if (getFeatureFlag('conditionalBundlingReporterSameConditionFix')) {
+          conditions.set(cond.key, {
+            bundle,
+            ifTrueBundles: [
+              ...(currentCondition?.ifTrueBundles ?? []),
+              ...ifTrueBundles,
+            ],
+            ifFalseBundles: [
+              ...(currentCondition?.ifFalseBundles ?? []),
+              ...ifFalseBundles,
+            ],
+          });
+        } else {
+          conditions.set(cond.key, {
+            bundle,
+            ifTrueBundles,
+            ifFalseBundles,
+          });
+        }
 
         bundleConditions.set(bundle.id, conditions);
       }

package/src/resolveOptions.js

@@ -12,7 +12,7 @@ import type {AtlaspackOptions} from './types';
 import path from 'path';
 import {hashString} from '@atlaspack/rust';
 import {NodeFS, NodeVCSAwareFS} from '@atlaspack/fs';
-import {LMDBCache, LMDBLiteCache, FSCache} from '@atlaspack/cache';
+import {LMDBLiteCache, FSCache} from '@atlaspack/cache';
 import {getFeatureFlag, getFeatureFlagValue} from '@atlaspack/feature-flags';
 import {NodePackageManager} from '@atlaspack/package-manager';
 import {
@@ -158,11 +158,7 @@ export default async function resolveOptions(
       return new FSCache(outputFS, cacheDir);
     }
 
-    if (needsRustLmdbCache || getFeatureFlag('useLmdbJsLite')) {
-      return new LMDBLiteCache(cacheDir);
-    }
-
-    return new LMDBCache(cacheDir);
+    return new LMDBLiteCache(cacheDir);
   }
 
   let cache = createCache();