@atlaspack/core 2.19.0 → 2.19.2

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @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
+
+- Updated dependencies [[`13aef17`](https://github.com/atlassian-labs/atlaspack/commit/13aef177eea289a6e40d2113b5ec1ac9be18a33d)]:
+  - @atlaspack/feature-flags@2.19.1
+  - @atlaspack/cache@3.2.14
+  - @atlaspack/fs@2.15.14
+  - @atlaspack/graph@3.5.8
+  - @atlaspack/utils@2.17.1
+  - @atlaspack/package-manager@2.14.19
+  - @atlaspack/profiler@2.14.16
+  - @atlaspack/types@2.15.9
+  - @atlaspack/workers@2.14.19
+  - @atlaspack/plugin@2.14.19
+
 ## 2.19.0
 
 ### Minor 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/Atlaspack.js

@@ -128,32 +128,23 @@ const INTERNAL_TRANSFORM = exports.INTERNAL_TRANSFORM = Symbol('internal_transfo
 const INTERNAL_RESOLVE = exports.INTERNAL_RESOLVE = Symbol('internal_resolve');
 const WORKER_PATH = exports.WORKER_PATH = _path().default.join(__dirname, 'worker.js');
 class Atlaspack {
-  #requestTracker /*: RequestTracker*/;
-  #config /*: AtlaspackConfig*/;
-  #farm /*: WorkerFarm*/;
-  #initialized /*: boolean*/ = false;
-  #disposable /*: Disposable */;
-  #initialOptions /*: InitialAtlaspackOptions */;
-  #reporterRunner /*: ReporterRunner*/;
-  #resolvedOptions /*: ?AtlaspackOptions*/ = null;
-  #optionsRef /*: SharedReference */;
-  #watchAbortController /*: AbortController*/;
-  #watchQueue /*: PromiseQueue<?BuildEvent>*/ = new (_utils2().PromiseQueue)({
+  #requestTracker;
+  #config;
+  #farm;
+  #initialized = false;
+  #disposable;
+  #initialOptions;
+  #reporterRunner;
+  #resolvedOptions = null;
+  #optionsRef;
+  #watchAbortController;
+  #watchQueue = new (_utils2().PromiseQueue)({
     maxConcurrent: 1
   });
-  #watchEvents /*: ValueEmitter<
-               | {|
-               +error: Error,
-               +buildEvent?: void,
-               |}
-               | {|
-               +buildEvent: BuildEvent,
-               +error?: void,
-               |},
-               > */;
-  #watcherSubscription /*: ?AsyncSubscription*/;
-  #watcherCount /*: number*/ = 0;
-  #requestedAssetIds /*: Set<string>*/ = new Set();
+  #watchEvents;
+  #watcherSubscription;
+  #watcherCount = 0;
+  #requestedAssetIds = new Set();
   constructor(options) {
     this.#initialOptions = options;
   }

package/lib/public/Asset.js

@@ -45,8 +45,7 @@ function assetFromValue(value, options) {
 }
 class BaseAsset {
   #asset;
-  #query /*: ?URLSearchParams */;
-
+  #query;
   constructor(asset) {
     this.#asset = asset;
     _assetToAssetValue.set(this, asset.value);
@@ -128,9 +127,8 @@ class BaseAsset {
   }
 }
 class Asset extends BaseAsset {
-  #asset /*: CommittedAsset | UncommittedAsset */;
-  #env /*: ?Environment */;
-
+  #asset;
+  #env;
   constructor(asset) {
     let assetValueToAsset = asset.value.committed ? committedAssetValueToAsset : uncommittedAssetValueToAsset;
     let existing = assetValueToAsset.get(asset.value);
@@ -152,8 +150,7 @@ class Asset extends BaseAsset {
 }
 exports.Asset = Asset;
 class MutableAsset extends BaseAsset {
-  #asset /*: UncommittedAsset */;
-
+  #asset;
   constructor(asset) {
     let existing = assetValueToMutableAsset.get(asset.value);
     if (existing != null) {

package/lib/public/Bundle.js

@@ -62,9 +62,9 @@ function bundleToInternalBundleGraph(bundle) {
 // preventing others from using them. They should use the static `get` method.
 let _private = {};
 class Bundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
+  #bundle;
+  #bundleGraph;
+  #options;
 
   // $FlowFixMe
   [inspect]() {
@@ -159,10 +159,9 @@ class Bundle {
 }
 exports.Bundle = Bundle;
 class NamedBundle extends Bundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
-
+  #bundle;
+  #bundleGraph;
+  #options;
   constructor(sentinel, bundle, bundleGraph, options) {
     super(sentinel, bundle, bundleGraph, options);
     this.#bundle = bundle; // Repeating for flow
@@ -193,11 +192,10 @@ class NamedBundle extends Bundle {
 }
 exports.NamedBundle = NamedBundle;
 class PackagedBundle extends NamedBundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
-  #bundleInfo /*: ?PackagedBundleInfo */;
-
+  #bundle;
+  #bundleGraph;
+  #options;
+  #bundleInfo;
   constructor(sentinel, bundle, bundleGraph, options) {
     super(sentinel, bundle, bundleGraph, options);
     this.#bundle = bundle; // Repeating for flow

package/lib/public/BundleGroup.js

@@ -21,9 +21,8 @@ function bundleGroupToInternalBundleGroup(target) {
 }
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 class BundleGroup {
-  #bundleGroup /*: InternalBundleGroup */;
-  #options /*: AtlaspackOptions */;
-
+  #bundleGroup;
+  #options;
   constructor(bundleGroup, options) {
     let existing = internalBundleGroupToBundleGroup.get(bundleGroup);
     if (existing != null) {

package/lib/public/Config.js

@@ -97,11 +97,10 @@ function makeConfigProxy(onRead, config) {
   return makeProxy(config, []);
 }
 class PublicConfig {
-  #config /*: Config */;
-  #pkg /*: ?PackageJSON */;
-  #pkgFilePath /*: ?FilePath */;
-  #options /*: AtlaspackOptions */;
-
+  #config;
+  #pkg;
+  #pkgFilePath;
+  #options;
   constructor(config, options) {
     let existing = internalConfigToConfig.get(options).get(config);
     if (existing != null) {

package/lib/public/Dependency.js

@@ -37,9 +37,8 @@ function getPublicDependency(dep, options) {
   return new Dependency(dep, options);
 }
 class Dependency {
-  #dep /*: InternalDependency */;
-  #options /*: AtlaspackOptions */;
-
+  #dep;
+  #options;
   constructor(dep, options) {
     this.#dep = dep;
     this.#options = options;

package/lib/public/Environment.js

@@ -127,9 +127,8 @@ function environmentToInternalEnvironment(environment) {
   return (0, _nullthrows().default)(_environmentToInternalEnvironment.get(environment));
 }
 class Environment {
-  #environment /*: InternalEnvironment */;
-  #options /*: AtlaspackOptions */;
-
+  #environment;
+  #options;
   constructor(env, options) {
     let existing = internalEnvironmentToEnvironment.get(env);
     if (existing != null) {

package/lib/public/MutableBundleGraph.js

@@ -54,9 +54,9 @@ function createBundleId(data) {
   return id;
 }
 class MutableBundleGraph extends _BundleGraph.default {
-  #graph /*: InternalBundleGraph */;
-  #options /*: AtlaspackOptions */;
-  #bundlePublicIds /*: Set<string> */ = new Set();
+  #graph;
+  #options;
+  #bundlePublicIds = new Set();
   constructor(graph, options) {
     super(graph, _Bundle.Bundle.get.bind(_Bundle.Bundle), options);
     this.#graph = graph;

package/lib/public/PluginOptions.js

@@ -6,8 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 let parcelOptionsToPluginOptions = new WeakMap();
 class PluginOptions {
-  #options /*: AtlaspackOptions */;
-
+  #options;
   constructor(options) {
     let existing = parcelOptionsToPluginOptions.get(options);
     if (existing != null) {

package/lib/public/Target.js

@@ -24,9 +24,8 @@ function targetToInternalTarget(target) {
   return (0, _nullthrows().default)(_targetToInternalTarget.get(target));
 }
 class Target {
-  #target /*: TargetValue */;
-  #options /*: AtlaspackOptions */;
-
+  #target;
+  #options;
   constructor(target, options) {
     let existing = internalTargetToTarget.get(target);
     if (existing != null) {

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.0",
+  "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.13",
+    "@atlaspack/cache": "3.2.15",
     "@atlaspack/diagnostic": "2.14.1",
     "@atlaspack/events": "2.14.1",
-    "@atlaspack/feature-flags": "2.19.0",
-    "@atlaspack/fs": "2.15.13",
-    "@atlaspack/graph": "3.5.7",
+    "@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.18",
-    "@atlaspack/plugin": "2.14.18",
-    "@atlaspack/profiler": "2.14.15",
+    "@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.8",
-    "@atlaspack/utils": "2.17.0",
-    "@atlaspack/workers": "2.14.18",
+    "@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/Atlaspack.js

@@ -72,20 +72,20 @@ export const INTERNAL_RESOLVE: symbol = Symbol('internal_resolve');
 export const WORKER_PATH: string = path.join(__dirname, 'worker.js');
 
 export default class Atlaspack {
-  #requestTracker /*: RequestTracker*/;
-  #config /*: AtlaspackConfig*/;
-  #farm /*: WorkerFarm*/;
-  #initialized /*: boolean*/ = false;
-  #disposable /*: Disposable */;
-  #initialOptions /*: InitialAtlaspackOptions */;
-  #reporterRunner /*: ReporterRunner*/;
-  #resolvedOptions /*: ?AtlaspackOptions*/ = null;
-  #optionsRef /*: SharedReference */;
-  #watchAbortController /*: AbortController*/;
-  #watchQueue /*: PromiseQueue<?BuildEvent>*/ = new PromiseQueue<?BuildEvent>({
+  #requestTracker: RequestTracker;
+  #config: AtlaspackConfig;
+  #farm: WorkerFarm;
+  #initialized: boolean = false;
+  #disposable: Disposable;
+  #initialOptions: InitialAtlaspackOptions;
+  #reporterRunner: ReporterRunner;
+  #resolvedOptions: ?AtlaspackOptions = null;
+  #optionsRef: SharedReference;
+  #watchAbortController: AbortController;
+  #watchQueue: PromiseQueue<?BuildEvent> = new PromiseQueue<?BuildEvent>({
     maxConcurrent: 1,
   });
-  #watchEvents /*: ValueEmitter<
+  #watchEvents: ValueEmitter<
     | {|
         +error: Error,
         +buildEvent?: void,
@@ -94,14 +94,14 @@ export default class Atlaspack {
         +buildEvent: BuildEvent,
         +error?: void,
       |},
-  > */;
-  #watcherSubscription /*: ?AsyncSubscription*/;
-  #watcherCount /*: number*/ = 0;
-  #requestedAssetIds /*: Set<string>*/ = new Set();
+  >;
+  #watcherSubscription: ?AsyncSubscription;
+  #watcherCount: number = 0;
+  #requestedAssetIds: Set<string> = new Set();
 
   rustAtlaspack: AtlaspackV3 | null | void;
 
-  isProfiling /*: boolean */;
+  isProfiling: boolean;
 
   constructor(options: InitialAtlaspackOptions) {
     this.#initialOptions = options;

package/src/public/Asset.js

@@ -81,7 +81,7 @@ export function assetFromValue(
 
 class BaseAsset {
   #asset: CommittedAsset | UncommittedAsset;
-  #query /*: ?URLSearchParams */;
+  #query: ?URLSearchParams;
 
   constructor(asset: CommittedAsset | UncommittedAsset) {
     this.#asset = asset;
@@ -195,8 +195,8 @@ class BaseAsset {
 }
 
 export class Asset extends BaseAsset implements IAsset {
-  #asset /*: CommittedAsset | UncommittedAsset */;
-  #env /*: ?Environment */;
+  #asset: CommittedAsset | UncommittedAsset;
+  #env: ?Environment;
 
   constructor(asset: CommittedAsset | UncommittedAsset): Asset {
     let assetValueToAsset = asset.value.committed
@@ -227,7 +227,7 @@ export class Asset extends BaseAsset implements IAsset {
 }
 
 export class MutableAsset extends BaseAsset implements IMutableAsset {
-  #asset /*: UncommittedAsset */;
+  #asset: UncommittedAsset;
 
   constructor(asset: UncommittedAsset): MutableAsset {
     let existing = assetValueToMutableAsset.get(asset.value);

package/src/public/Bundle.js

@@ -68,9 +68,9 @@ export function bundleToInternalBundleGraph(bundle: IBundle): BundleGraph {
 let _private = {};
 
 export class Bundle implements IBundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
+  #bundle: InternalBundle;
+  #bundleGraph: BundleGraph;
+  #options: AtlaspackOptions;
 
   // $FlowFixMe
   [inspect]() {
@@ -214,9 +214,9 @@ export class Bundle implements IBundle {
 }
 
 export class NamedBundle extends Bundle implements INamedBundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
+  #bundle: InternalBundle;
+  #bundleGraph: BundleGraph;
+  #options: AtlaspackOptions;
 
   constructor(
     sentinel: mixed,
@@ -268,10 +268,10 @@ export class NamedBundle extends Bundle implements INamedBundle {
 }
 
 export class PackagedBundle extends NamedBundle implements IPackagedBundle {
-  #bundle /*: InternalBundle */;
-  #bundleGraph /*: BundleGraph */;
-  #options /*: AtlaspackOptions */;
-  #bundleInfo /*: ?PackagedBundleInfo */;
+  #bundle: InternalBundle;
+  #bundleGraph: BundleGraph;
+  #options: AtlaspackOptions;
+  #bundleInfo: ?PackagedBundleInfo;
 
   constructor(
     sentinel: mixed,

package/src/public/BundleGroup.js

@@ -28,8 +28,8 @@ export function bundleGroupToInternalBundleGroup(
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
 export default class BundleGroup implements IBundleGroup {
-  #bundleGroup /*: InternalBundleGroup */;
-  #options /*: AtlaspackOptions */;
+  #bundleGroup: InternalBundleGroup;
+  #options: AtlaspackOptions;
 
   constructor(
     bundleGroup: InternalBundleGroup,

package/src/public/Config.js

@@ -104,10 +104,10 @@ export function makeConfigProxy<T>(
 }
 
 export default class PublicConfig implements IConfig {
-  #config /*: Config */;
-  #pkg /*: ?PackageJSON */;
-  #pkgFilePath /*: ?FilePath */;
-  #options /*: AtlaspackOptions */;
+  #config: Config;
+  #pkg: ?PackageJSON;
+  #pkgFilePath: ?FilePath;
+  #options: AtlaspackOptions;
 
   constructor(config: Config, options: AtlaspackOptions): PublicConfig {
     let existing = internalConfigToConfig.get(options).get(config);

package/src/public/Dependency.js

@@ -59,8 +59,8 @@ export function getPublicDependency(
 }
 
 export default class Dependency implements IDependency {
-  #dep /*: InternalDependency */;
-  #options /*: AtlaspackOptions */;
+  #dep: InternalDependency;
+  #options: AtlaspackOptions;
 
   constructor(dep: InternalDependency, options: AtlaspackOptions): Dependency {
     this.#dep = dep;

package/src/public/Environment.js

@@ -156,8 +156,8 @@ export function environmentToInternalEnvironment(
 }
 
 export default class Environment implements IEnvironment {
-  #environment /*: InternalEnvironment */;
-  #options /*: AtlaspackOptions */;
+  #environment: InternalEnvironment;
+  #options: AtlaspackOptions;
 
   constructor(
     env: InternalEnvironment,

package/src/public/MutableBundleGraph.js

@@ -55,9 +55,9 @@ export default class MutableBundleGraph
   extends BundleGraph<IBundle>
   implements IMutableBundleGraph
 {
-  #graph /*: InternalBundleGraph */;
-  #options /*: AtlaspackOptions */;
-  #bundlePublicIds /*: Set<string> */ = new Set<string>();
+  #graph: InternalBundleGraph;
+  #options: AtlaspackOptions;
+  #bundlePublicIds: Set<string> = new Set<string>();
 
   constructor(graph: InternalBundleGraph, options: AtlaspackOptions) {
     super(graph, Bundle.get.bind(Bundle), options);

package/src/public/PluginOptions.js

@@ -18,7 +18,7 @@ let parcelOptionsToPluginOptions: WeakMap<AtlaspackOptions, PluginOptions> =
   new WeakMap();
 
 export default class PluginOptions implements IPluginOptions {
-  #options /*: AtlaspackOptions */;
+  #options: AtlaspackOptions;
 
   constructor(options: AtlaspackOptions): PluginOptions {
     let existing = parcelOptionsToPluginOptions.get(options);

package/src/public/Target.js

@@ -22,8 +22,8 @@ export function targetToInternalTarget(target: ITarget): TargetValue {
 }
 
 export default class Target implements ITarget {
-  #target /*: TargetValue */;
-  #options /*: AtlaspackOptions */;
+  #target: TargetValue;
+  #options: AtlaspackOptions;
 
   constructor(target: TargetValue, options: AtlaspackOptions): Target {
     let existing = internalTargetToTarget.get(target);

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', () => {