@atlaspack/core 2.19.1 → 2.19.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @atlaspack/core
 
+## 2.19.2
+
+### Patch Changes
+
+- [#707](https://github.com/atlassian-labs/atlaspack/pull/707) [`a0b959f`](https://github.com/atlassian-labs/atlaspack/commit/a0b959fbf61fc3f820ff03c7e8988945fe40a91a) Thanks [@yamadapc](https://github.com/yamadapc)! - Fix content key not found exceptions when bundling is aborted after a unsafe to incrementally bundle asset graph request
+
+- Updated dependencies [[`daaa768`](https://github.com/atlassian-labs/atlaspack/commit/daaa7688786772d7e3713b71c5bba6b89ec704aa), [`1c7865a`](https://github.com/atlassian-labs/atlaspack/commit/1c7865a64451116d94015e248302435839d347c0), [`a0b959f`](https://github.com/atlassian-labs/atlaspack/commit/a0b959fbf61fc3f820ff03c7e8988945fe40a91a)]:
+  - @atlaspack/plugin@2.14.20
+  - @atlaspack/feature-flags@2.19.2
+  - @atlaspack/cache@3.2.15
+  - @atlaspack/fs@2.15.15
+  - @atlaspack/graph@3.5.9
+  - @atlaspack/utils@2.17.2
+  - @atlaspack/package-manager@2.14.20
+  - @atlaspack/profiler@2.14.17
+  - @atlaspack/types@2.15.10
+  - @atlaspack/workers@2.14.20
+
 ## 2.19.1
 
 ### Patch Changes

package/lib/AssetGraph.js

@@ -102,15 +102,31 @@ function nodeFromEntryFile(entry) {
   };
 }
 class AssetGraph extends _graph().ContentGraph {
+  /**
+   * Incremented when the asset graph is modified such that it requires a bundling pass.
+   */
+  #bundlingVersion = 0;
+  /**
+   * Force incremental bundling to be disabled.
+   */
+  #disableIncrementalBundling = false;
+
+  /**
+   * @deprecated
+   */
   safeToIncrementallyBundle = true;
   constructor(opts) {
     if (opts) {
       let {
         hash,
+        bundlingVersion,
+        disableIncrementalBundling,
         ...rest
       } = opts;
       super(rest);
       this.hash = hash;
+      this.#bundlingVersion = bundlingVersion ?? 0;
+      this.#disableIncrementalBundling = disableIncrementalBundling ?? false;
     } else {
       super();
       this.setRootNodeId(this.addNode({
@@ -132,10 +148,59 @@ class AssetGraph extends _graph().ContentGraph {
   serialize() {
     return {
       ...super.serialize(),
+      bundlingVersion: this.#bundlingVersion,
+      disableIncrementalBundling: this.#disableIncrementalBundling,
       hash: this.hash
     };
   }
 
+  /**
+   * Force incremental bundling to be disabled.
+   */
+  setDisableIncrementalBundling(disable) {
+    this.#disableIncrementalBundling = disable;
+  }
+  testing_getDisableIncrementalBundling() {
+    return this.#disableIncrementalBundling;
+  }
+
+  /**
+   * Make sure this asset graph is marked as needing a full bundling pass.
+   */
+  setNeedsBundling() {
+    if (!(0, _featureFlags().getFeatureFlag)('incrementalBundlingVersioning')) {
+      // In legacy mode, we rely solely on safeToIncrementallyBundle to
+      // invalidate incremental bundling, so we skip bumping the version.
+      return;
+    }
+    this.#bundlingVersion += 1;
+  }
+
+  /**
+   * Get the current bundling version.
+   *
+   * Each bundle pass should keep this version around. Whenever an asset graph has a new version,
+   * bundling should be re-run.
+   */
+  getBundlingVersion() {
+    if (!(0, _featureFlags().getFeatureFlag)('incrementalBundlingVersioning')) {
+      return 0;
+    }
+    return this.#bundlingVersion;
+  }
+
+  /**
+   * If the `bundlingVersion` has not changed since the last bundling pass,
+   * we can incrementally bundle, which will not require a full bundling pass
+   * but just update assets into the bundle graph output.
+   */
+  canIncrementallyBundle(lastVersion) {
+    if (!(0, _featureFlags().getFeatureFlag)('incrementalBundlingVersioning')) {
+      return this.safeToIncrementallyBundle && !this.#disableIncrementalBundling;
+    }
+    return this.safeToIncrementallyBundle && this.#bundlingVersion === lastVersion && !this.#disableIncrementalBundling;
+  }
+
   // Deduplicates Environments by making them referentially equal
   normalizeEnvironment(input) {
     if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
@@ -307,11 +372,13 @@ class AssetGraph extends _graph().ContentGraph {
       } else if (traversedNode.type === 'asset_group' && nodeId !== traversedNodeId) {
         if (!(ctx !== null && ctx !== void 0 && ctx.hasDeferred)) {
           this.safeToIncrementallyBundle = false;
+          this.setNeedsBundling();
           delete traversedNode.hasDeferred;
         }
         actions.skipChildren();
       } else if (traversedNode.type === 'dependency') {
         this.safeToIncrementallyBundle = false;
+        this.setNeedsBundling();
         traversedNode.hasDeferred = false;
       } else if (nodeId !== traversedNodeId) {
         actions.skipChildren();

package/lib/requests/AssetGraphRequest.js

@@ -76,6 +76,7 @@ function createAssetGraphRequest(requestInput) {
       let assetGraphRequest = await await builder.build();
 
       // early break for incremental bundling if production or flag is off;
+      assetGraphRequest.assetGraph.setDisableIncrementalBundling(!input.options.shouldBundleIncrementally || input.options.mode === 'production');
       if (!input.options.shouldBundleIncrementally || input.options.mode === 'production') {
         assetGraphRequest.assetGraph.safeToIncrementallyBundle = false;
       }
@@ -368,6 +369,7 @@ class AssetGraphBuilder {
       let didEntriesChange = prevEntries.length !== currentEntries.length || prevEntries.every((entryId, index) => entryId === currentEntries[index]);
       if (didEntriesChange) {
         this.assetGraph.safeToIncrementallyBundle = false;
+        this.assetGraph.setNeedsBundling();
       }
     }
   }
@@ -407,10 +409,12 @@ class AssetGraphBuilder {
             (0, _assert().default)(otherAsset.type === 'asset');
             if (!this._areDependenciesEqualForAssets(asset, otherAsset.value)) {
               this.assetGraph.safeToIncrementallyBundle = false;
+              this.assetGraph.setNeedsBundling();
             }
           } else {
             // adding a new entry or dependency
             this.assetGraph.safeToIncrementallyBundle = false;
+            this.assetGraph.setNeedsBundling();
           }
         }
         this.changedAssets.set(asset.id, asset);
@@ -419,6 +423,7 @@ class AssetGraphBuilder {
       this.assetGraph.resolveAssetGroup(input, assets, request.id);
     } else {
       this.assetGraph.safeToIncrementallyBundle = false;
+      this.assetGraph.setNeedsBundling();
     }
     this.isSingleChangeRebuild = false;
   }

package/lib/requests/BundleGraphRequest.js

@@ -190,6 +190,7 @@ function createBundleGraphRequest(input) {
       let subRequestsInvalid = Boolean(invalidateReason & _constants.OPTION_CHANGE) || input.api.getSubRequests().some(req => !input.api.canSkipSubrequest(req.id));
       if (subRequestsInvalid) {
         assetGraph.safeToIncrementallyBundle = false;
+        assetGraph.setNeedsBundling();
       }
       let configResult = (0, _nullthrows().default)(await input.api.runRequest((0, _AtlaspackConfigRequest.default)()));
       (0, _utils2.assertSignalNotAborted)(signal);
@@ -292,16 +293,11 @@ class BundlerRunner {
     } = plugin;
 
     // if a previous asset graph hash is passed in, check if the bundle graph is also available
-    let previousBundleGraphResult;
-    if (graph.safeToIncrementallyBundle) {
-      try {
-        previousBundleGraphResult = await this.api.getPreviousResult();
-      } catch {
-        // if the bundle graph had an error or was removed, don't fail the build
-      }
-    }
-    if (previousBundleGraphResult == null) {
+    const previousBundleGraphResult = await this.api.getPreviousResult();
+    const canIncrementallyBundle = (previousBundleGraphResult === null || previousBundleGraphResult === void 0 ? void 0 : previousBundleGraphResult.assetGraphBundlingVersion) != null && graph.canIncrementallyBundle(previousBundleGraphResult.assetGraphBundlingVersion);
+    if (graph.safeToIncrementallyBundle && previousBundleGraphResult == null) {
       graph.safeToIncrementallyBundle = false;
+      graph.setNeedsBundling();
     }
     let internalBundleGraph;
     let logger = new (_logger().PluginLogger)({
@@ -312,7 +308,7 @@ class BundlerRunner {
       category: 'bundle'
     });
     try {
-      if (previousBundleGraphResult) {
+      if (canIncrementallyBundle && previousBundleGraphResult) {
         internalBundleGraph = previousBundleGraphResult.bundleGraph;
         for (let changedAssetId of changedAssets.keys()) {
           // Copy over the whole node to also have correct symbol data
@@ -384,6 +380,7 @@ class BundlerRunner {
       if (internalBundleGraph != null) {
         this.api.storeResult({
           bundleGraph: internalBundleGraph,
+          assetGraphBundlingVersion: graph.getBundlingVersion(),
           changedAssets: new Map(),
           assetRequests: []
         }, this.cacheKey);
@@ -401,7 +398,7 @@ class BundlerRunner {
       }
     }
     let changedRuntimes = new Map();
-    if (!previousBundleGraphResult) {
+    if (!previousBundleGraphResult || !canIncrementallyBundle) {
       let namers = await this.config.getNamers();
       // inline bundles must still be named so the PackagerRunner
       // can match them to the correct packager/optimizer plugins.
@@ -439,11 +436,13 @@ class BundlerRunner {
     internalBundleGraph._graph, 'after_runtimes', _BundleGraph2.bundleGraphEdgeTypes);
     this.api.storeResult({
       bundleGraph: internalBundleGraph,
+      assetGraphBundlingVersion: graph.getBundlingVersion(),
       changedAssets: new Map(),
       assetRequests: []
     }, this.cacheKey);
     return {
       bundleGraph: internalBundleGraph,
+      assetGraphBundlingVersion: graph.getBundlingVersion(),
       changedAssets: changedRuntimes,
       assetRequests
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.19.1",
+  "version": "2.19.2",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -23,20 +23,20 @@
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
     "@atlaspack/build-cache": "2.13.3",
-    "@atlaspack/cache": "3.2.14",
+    "@atlaspack/cache": "3.2.15",
     "@atlaspack/diagnostic": "2.14.1",
     "@atlaspack/events": "2.14.1",
-    "@atlaspack/feature-flags": "2.19.1",
-    "@atlaspack/fs": "2.15.14",
-    "@atlaspack/graph": "3.5.8",
+    "@atlaspack/feature-flags": "2.19.2",
+    "@atlaspack/fs": "2.15.15",
+    "@atlaspack/graph": "3.5.9",
     "@atlaspack/logger": "2.14.13",
-    "@atlaspack/package-manager": "2.14.19",
-    "@atlaspack/plugin": "2.14.19",
-    "@atlaspack/profiler": "2.14.16",
+    "@atlaspack/package-manager": "2.14.20",
+    "@atlaspack/plugin": "2.14.20",
+    "@atlaspack/profiler": "2.14.17",
     "@atlaspack/rust": "3.4.1",
-    "@atlaspack/types": "2.15.9",
-    "@atlaspack/utils": "2.17.1",
-    "@atlaspack/workers": "2.14.19",
+    "@atlaspack/types": "2.15.10",
+    "@atlaspack/utils": "2.17.2",
+    "@atlaspack/workers": "2.14.20",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",

package/src/AssetGraph.js

@@ -44,11 +44,15 @@ type InitOpts = {|
 
 type AssetGraphOpts = {|
   ...ContentGraphOpts<AssetGraphNode>,
+  bundlingVersion?: number,
+  disableIncrementalBundling?: boolean,
   hash?: ?string,
 |};
 
 type SerializedAssetGraph = {|
   ...SerializedContentGraph<AssetGraphNode>,
+  bundlingVersion: number,
+  disableIncrementalBundling: boolean,
   hash?: ?string,
 |};
 
@@ -117,14 +121,30 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   onNodeRemoved: ?(nodeId: NodeId) => mixed;
   hash: ?string;
   envCache: Map<string, Environment>;
+
+  /**
+   * Incremented when the asset graph is modified such that it requires a bundling pass.
+   */
+  #bundlingVersion: number = 0;
+  /**
+   * Force incremental bundling to be disabled.
+   */
+  #disableIncrementalBundling: boolean = false;
+
+  /**
+   * @deprecated
+   */
   safeToIncrementallyBundle: boolean = true;
+
   undeferredDependencies: Set<Dependency>;
 
   constructor(opts: ?AssetGraphOpts) {
     if (opts) {
-      let {hash, ...rest} = opts;
+      let {hash, bundlingVersion, disableIncrementalBundling, ...rest} = opts;
       super(rest);
       this.hash = hash;
+      this.#bundlingVersion = bundlingVersion ?? 0;
+      this.#disableIncrementalBundling = disableIncrementalBundling ?? false;
     } else {
       super();
       this.setRootNodeId(
@@ -149,10 +169,66 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   serialize(): SerializedAssetGraph {
     return {
       ...super.serialize(),
+      bundlingVersion: this.#bundlingVersion,
+      disableIncrementalBundling: this.#disableIncrementalBundling,
       hash: this.hash,
     };
   }
 
+  /**
+   * Force incremental bundling to be disabled.
+   */
+  setDisableIncrementalBundling(disable: boolean) {
+    this.#disableIncrementalBundling = disable;
+  }
+
+  testing_getDisableIncrementalBundling(): boolean {
+    return this.#disableIncrementalBundling;
+  }
+
+  /**
+   * Make sure this asset graph is marked as needing a full bundling pass.
+   */
+  setNeedsBundling() {
+    if (!getFeatureFlag('incrementalBundlingVersioning')) {
+      // In legacy mode, we rely solely on safeToIncrementallyBundle to
+      // invalidate incremental bundling, so we skip bumping the version.
+      return;
+    }
+    this.#bundlingVersion += 1;
+  }
+
+  /**
+   * Get the current bundling version.
+   *
+   * Each bundle pass should keep this version around. Whenever an asset graph has a new version,
+   * bundling should be re-run.
+   */
+  getBundlingVersion(): number {
+    if (!getFeatureFlag('incrementalBundlingVersioning')) {
+      return 0;
+    }
+    return this.#bundlingVersion;
+  }
+
+  /**
+   * If the `bundlingVersion` has not changed since the last bundling pass,
+   * we can incrementally bundle, which will not require a full bundling pass
+   * but just update assets into the bundle graph output.
+   */
+  canIncrementallyBundle(lastVersion: number): boolean {
+    if (!getFeatureFlag('incrementalBundlingVersioning')) {
+      return (
+        this.safeToIncrementallyBundle && !this.#disableIncrementalBundling
+      );
+    }
+    return (
+      this.safeToIncrementallyBundle &&
+      this.#bundlingVersion === lastVersion &&
+      !this.#disableIncrementalBundling
+    );
+  }
+
   // Deduplicates Environments by making them referentially equal
   normalizeEnvironment(input: Asset | Dependency | AssetGroup) {
     if (getFeatureFlag('environmentDeduplication')) {
@@ -369,11 +445,13 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
       ) {
         if (!ctx?.hasDeferred) {
           this.safeToIncrementallyBundle = false;
+          this.setNeedsBundling();
           delete traversedNode.hasDeferred;
         }
         actions.skipChildren();
       } else if (traversedNode.type === 'dependency') {
         this.safeToIncrementallyBundle = false;
+        this.setNeedsBundling();
         traversedNode.hasDeferred = false;
       } else if (nodeId !== traversedNodeId) {
         actions.skipChildren();

package/src/requests/AssetGraphRequest.js

@@ -84,6 +84,11 @@ export default function createAssetGraphRequest(
       let assetGraphRequest = await await builder.build();
 
       // early break for incremental bundling if production or flag is off;
+      assetGraphRequest.assetGraph.setDisableIncrementalBundling(
+        !input.options.shouldBundleIncrementally ||
+          input.options.mode === 'production',
+      );
+
       if (
         !input.options.shouldBundleIncrementally ||
         input.options.mode === 'production'
@@ -511,6 +516,7 @@ export class AssetGraphBuilder {
 
       if (didEntriesChange) {
         this.assetGraph.safeToIncrementallyBundle = false;
+        this.assetGraph.setNeedsBundling();
       }
     }
   }
@@ -554,10 +560,12 @@ export class AssetGraphBuilder {
             invariant(otherAsset.type === 'asset');
             if (!this._areDependenciesEqualForAssets(asset, otherAsset.value)) {
               this.assetGraph.safeToIncrementallyBundle = false;
+              this.assetGraph.setNeedsBundling();
             }
           } else {
             // adding a new entry or dependency
             this.assetGraph.safeToIncrementallyBundle = false;
+            this.assetGraph.setNeedsBundling();
           }
         }
         this.changedAssets.set(asset.id, asset);
@@ -566,6 +574,7 @@ export class AssetGraphBuilder {
       this.assetGraph.resolveAssetGroup(input, assets, request.id);
     } else {
       this.assetGraph.safeToIncrementallyBundle = false;
+      this.assetGraph.setNeedsBundling();
     }
 
     this.isSingleChangeRebuild = false;

package/src/requests/BundleGraphRequest.js

@@ -72,10 +72,6 @@ type BundleGraphRequestInput = {|
   optionsRef: SharedReference,
 |};
 
-type BundleGraphRequestResult = {|
-  bundleGraph: InternalBundleGraph,
-|};
-
 type RunInput = {|
   input: BundleGraphRequestInput,
   ...StaticRunOpts<BundleGraphResult>,
@@ -84,6 +80,7 @@ type RunInput = {|
 // TODO: Rename to BundleGraphRequestResult
 export type BundleGraphResult = {|
   bundleGraph: InternalBundleGraph,
+  assetGraphBundlingVersion: number,
   changedAssets: Map<string, Asset>,
   assetRequests: Array<AssetGroup>,
 |};
@@ -215,6 +212,7 @@ export default function createBundleGraphRequest(
 
       if (subRequestsInvalid) {
         assetGraph.safeToIncrementallyBundle = false;
+        assetGraph.setNeedsBundling();
       }
 
       let configResult = nullthrows(
@@ -363,16 +361,17 @@ class BundlerRunner {
     let {plugin: bundler, name, resolveFrom} = plugin;
 
     // if a previous asset graph hash is passed in, check if the bundle graph is also available
-    let previousBundleGraphResult: ?BundleGraphRequestResult;
-    if (graph.safeToIncrementallyBundle) {
-      try {
-        previousBundleGraphResult = await this.api.getPreviousResult();
-      } catch {
-        // if the bundle graph had an error or was removed, don't fail the build
-      }
-    }
-    if (previousBundleGraphResult == null) {
+    const previousBundleGraphResult: ?BundleGraphResult =
+      await this.api.getPreviousResult();
+    const canIncrementallyBundle =
+      previousBundleGraphResult?.assetGraphBundlingVersion != null &&
+      graph.canIncrementallyBundle(
+        previousBundleGraphResult.assetGraphBundlingVersion,
+      );
+
+    if (graph.safeToIncrementallyBundle && previousBundleGraphResult == null) {
       graph.safeToIncrementallyBundle = false;
+      graph.setNeedsBundling();
     }
 
     let internalBundleGraph;
@@ -383,7 +382,7 @@ class BundlerRunner {
       category: 'bundle',
     });
     try {
-      if (previousBundleGraphResult) {
+      if (canIncrementallyBundle && previousBundleGraphResult) {
         internalBundleGraph = previousBundleGraphResult.bundleGraph;
         for (let changedAssetId of changedAssets.keys()) {
           // Copy over the whole node to also have correct symbol data
@@ -485,6 +484,7 @@ class BundlerRunner {
         this.api.storeResult(
           {
             bundleGraph: internalBundleGraph,
+            assetGraphBundlingVersion: graph.getBundlingVersion(),
             changedAssets: new Map(),
             assetRequests: [],
           },
@@ -509,7 +509,7 @@ class BundlerRunner {
     }
 
     let changedRuntimes = new Map();
-    if (!previousBundleGraphResult) {
+    if (!previousBundleGraphResult || !canIncrementallyBundle) {
       let namers = await this.config.getNamers();
       // inline bundles must still be named so the PackagerRunner
       // can match them to the correct packager/optimizer plugins.
@@ -561,6 +561,7 @@ class BundlerRunner {
     this.api.storeResult(
       {
         bundleGraph: internalBundleGraph,
+        assetGraphBundlingVersion: graph.getBundlingVersion(),
         changedAssets: new Map(),
         assetRequests: [],
       },
@@ -569,6 +570,7 @@ class BundlerRunner {
 
     return {
       bundleGraph: internalBundleGraph,
+      assetGraphBundlingVersion: graph.getBundlingVersion(),
       changedAssets: changedRuntimes,
       assetRequests,
     };

package/test/AssetGraph.test.js

@@ -2,6 +2,7 @@
 import assert from 'assert';
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
+import {serialize, deserialize} from '@atlaspack/build-cache';
 import AssetGraph, {
   nodeFromAssetGroup,
   nodeFromDep,
@@ -690,4 +691,36 @@ describe('AssetGraph', () => {
     invariant(node.type === 'asset_group');
     assert(!node.hasDeferred);
   });
+
+  it('should serialize the bundling version and incremental bundling flag', () => {
+    const graph = new AssetGraph();
+    graph.setDisableIncrementalBundling(true);
+    graph.setNeedsBundling();
+    const serialized = serialize(graph);
+    const deserialized = deserialize(serialized);
+
+    assert.equal(deserialized.getBundlingVersion(), 1);
+    assert.equal(deserialized.testing_getDisableIncrementalBundling(), true);
+  });
+
+  describe('setNeedsBundling', () => {
+    it('should increment the bundling version', () => {
+      const graph = new AssetGraph();
+      assert.equal(graph.getBundlingVersion(), 0);
+      graph.setNeedsBundling();
+      assert.equal(graph.getBundlingVersion(), 1);
+      graph.setNeedsBundling();
+      assert.equal(graph.getBundlingVersion(), 2);
+    });
+  });
+
+  describe('canIncrementallyBundle', () => {
+    it('should return true if the bundling version has changed', () => {
+      const graph = new AssetGraph();
+      const lastVersion = graph.getBundlingVersion();
+      assert.equal(graph.canIncrementallyBundle(lastVersion), true);
+      graph.setNeedsBundling();
+      assert.equal(graph.canIncrementallyBundle(lastVersion), false);
+    });
+  });
 });

package/test/RequestTracker.test.js

@@ -8,6 +8,7 @@ import RequestTracker, {
   runInvalidation,
   getBiggestFSEventsInvalidations,
   invalidateRequestGraphFSEvents,
+  requestTypes,
 } from '../src/RequestTracker';
 import {Graph} from '@atlaspack/graph';
 import {LMDBLiteCache} from '@atlaspack/cache';
@@ -19,6 +20,12 @@ import {toProjectPath} from '../src/projectPath';
 import {DEFAULT_FEATURE_FLAGS, setFeatureFlags} from '../../feature-flags/src';
 import sinon from 'sinon';
 import type {AtlaspackOptions} from '../src/types';
+import createAtlaspackBuildRequest from '../src/requests/AtlaspackBuildRequest';
+import Atlaspack from '../src/Atlaspack';
+import {MemoryFS, NodeFS} from '@atlaspack/fs';
+import {OverlayFS} from '../../fs/src/OverlayFS';
+import path from 'path';
+import createAssetGraphRequest from '../src/requests/AssetGraphRequest';
 
 const options = {
   ...DEFAULT_OPTIONS,
@@ -542,6 +549,169 @@ describe('RequestTracker', () => {
       });
     });
   });
+
+  describe('incremental bundling', () => {
+    async function runIncrementalBundlingScenario(
+      incrementalBundlingVersioning: boolean,
+    ) {
+      const fs = new OverlayFS(new MemoryFS(farm), new NodeFS());
+      const appRoot = __dirname;
+      await fs.mkdirp(path.join(appRoot, 'app'));
+      await fs.writeFile(path.join(appRoot, 'app', 'package.json'), '{}');
+      await fs.writeFile(path.join(appRoot, 'app', '.git'), '');
+      await fs.writeFile(
+        path.join(appRoot, 'app', '.parcelrc'),
+        '{"extends":"@atlaspack/config-default"}',
+      );
+      await fs.writeFile(
+        path.join(appRoot, 'app', 'target.js'),
+        'console.log("hello")',
+      );
+
+      const atlaspack = new Atlaspack({
+        featureFlags: {
+          incrementalBundlingVersioning,
+        },
+        workerFarm: farm,
+        entries: [path.join(appRoot, 'app', 'target.js')],
+        cache: new LMDBLiteCache(DEFAULT_OPTIONS.cacheDir),
+        inputFS: fs,
+        outputFS: fs,
+      });
+      await atlaspack._init();
+      const options = atlaspack._getResolvedAtlaspackOptions();
+      const tracker = new RequestTracker({farm, options});
+      let {ref: optionsRef} = await farm.createSharedReference(options, false);
+
+      const getAssetRequests = () =>
+        runRequestSpy
+          .getCalls()
+          .map((call) => call.args[0])
+          .filter((request) => request.type === requestTypes.asset_request);
+
+      // Running the build once builds one asset
+      const runRequestSpy = sinon.spy(tracker, 'runRequest');
+      await tracker.runRequest(
+        createAtlaspackBuildRequest({
+          optionsRef,
+          requestedAssetIds: new Set(),
+        }),
+      );
+      assert.equal(getAssetRequests().length, 1);
+      runRequestSpy.resetHistory();
+
+      // Running the build again with no invalidations does not build any assets
+      await tracker.runRequest(
+        createAtlaspackBuildRequest({
+          optionsRef,
+          requestedAssetIds: new Set(),
+        }),
+      );
+      assert.equal(getAssetRequests().length, 0);
+      runRequestSpy.resetHistory();
+
+      // Running the build again with a file change builds the asset again
+      tracker.respondToFSEvents(
+        [
+          {
+            type: 'update',
+            path: path.join(appRoot, 'app', 'target.js'),
+          },
+        ],
+        Number.MAX_VALUE,
+      );
+      await tracker.runRequest(
+        createAtlaspackBuildRequest({
+          optionsRef,
+          requestedAssetIds: new Set(),
+        }),
+      );
+      assert.equal(getAssetRequests().length, 1);
+      runRequestSpy.resetHistory();
+
+      // Run the asset graph request, but not bundling
+      await fs.writeFile(
+        path.join(appRoot, 'app', 'target.js'),
+        'require("./dep.js")',
+      );
+      await fs.writeFile(
+        path.join(appRoot, 'app', 'dep.js'),
+        'console.log("dep")',
+      );
+      tracker.respondToFSEvents(
+        [
+          {
+            type: 'update',
+            path: path.join(appRoot, 'app', 'target.js'),
+          },
+        ],
+        Number.MAX_VALUE,
+      );
+      const assetGraphRequestResult = await tracker.runRequest(
+        createAssetGraphRequest({
+          name: 'Main',
+          entries: [
+            toProjectPath(
+              path.join(appRoot, 'app'),
+              path.join(appRoot, 'app', 'target.js'),
+            ),
+          ],
+          optionsRef,
+          shouldBuildLazily: false,
+          lazyIncludes: [],
+          lazyExcludes: [],
+          requestedAssetIds: new Set(),
+        }),
+      );
+      assert.equal(getAssetRequests().length, 2);
+      assert.equal(
+        assetGraphRequestResult.assetGraph.safeToIncrementallyBundle,
+        false,
+      );
+
+      // Now make another change
+      tracker.respondToFSEvents(
+        [
+          {
+            type: 'update',
+            path: path.join(appRoot, 'app', 'target.js'),
+          },
+          {
+            type: 'update',
+            path: path.join(appRoot, 'app', 'dep.js'),
+          },
+        ],
+        Number.MAX_VALUE,
+      );
+      // And run the build again
+
+      if (!incrementalBundlingVersioning) {
+        await assert.rejects(async () => {
+          await tracker.runRequest(
+            createAtlaspackBuildRequest({
+              optionsRef,
+              requestedAssetIds: new Set(),
+            }),
+          );
+        });
+      } else {
+        await tracker.runRequest(
+          createAtlaspackBuildRequest({
+            optionsRef,
+            requestedAssetIds: new Set(),
+          }),
+        );
+      }
+    }
+
+    it('throws a content key not found exception without bundling versioning', async () => {
+      await runIncrementalBundlingScenario(false);
+    });
+
+    it('works fine with bundling versioning', async () => {
+      await runIncrementalBundlingScenario(true);
+    });
+  });
 });
 
 describe('cleanUpOrphans', () => {