@atlaspack/core 2.34.0 → 2.36.0

package/lib/RequestTracker.js

@@ -34,13 +34,6 @@ function _buildCache() {
   };
   return data;
 }
-function _cache() {
-  const data = require("@atlaspack/cache");
-  _cache = function () {
-    return data;
-  };
-  return data;
-}
 function _featureFlags() {
   const data = require("@atlaspack/feature-flags");
   _featureFlags = function () {
@@ -56,7 +49,7 @@ function _graph() {
   return data;
 }
 function _logger() {
-  const data = _interopRequireWildcard(require("@atlaspack/logger"));
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
   _logger = function () {
     return data;
   };
@@ -831,10 +824,8 @@ class RequestTracker {
       return result;
     } else if (node.resultCacheKey != null && ifMatch == null) {
       let key = node.resultCacheKey;
-      if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-        (0, _assert().default)(this.options.cache.hasLargeBlob(key));
-      }
-      let cachedResult = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? (0, _nullthrows().default)(await this.options.cache.get(key)) : (0, _buildCache().deserialize)(await this.options.cache.getLargeBlob(key));
+      (0, _assert().default)(this.options.cache.hasLargeBlob(key));
+      let cachedResult = (0, _buildCache().deserialize)(await this.options.cache.getLargeBlob(key));
       node.result = cachedResult;
       return cachedResult;
     }
@@ -1002,27 +993,13 @@ 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;
-      }
-    }
     let cacheKey = getCacheKey(this.options);
-    let requestGraphKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/RequestGraph` : `requestGraph-${cacheKey}`;
-    let snapshotKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/snapshot` : `snapshot-${cacheKey}`;
+    let requestGraphKey = `requestGraph-${cacheKey}`;
+    let snapshotKey = `snapshot-${cacheKey}`;
     if (this.options.shouldDisableCache) {
       return;
     }
     let total = 0;
-    await runCacheImprovements(async cache => {
-      await cache.getNativeRef().startWriteTransaction();
-    }, () => Promise.resolve());
     try {
       (0, _ReporterRunner.report)({
         type: 'cache',
@@ -1031,7 +1008,7 @@ class RequestTracker {
         size: this.graph.nodes.length
       });
       if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
-        await (0, _EnvironmentManager.writeEnvironmentsToCache)(options.cache);
+        await (0, _EnvironmentManager.writeEnvironmentsToCache)(this.options.cache);
       }
       let serialisedGraph = this.graph.serialize();
 
@@ -1041,16 +1018,9 @@ class RequestTracker {
         if (signal !== null && signal !== void 0 && signal.aborted) {
           throw new Error('Serialization was aborted');
         }
-        await runCacheImprovements(cache => {
-          (0, _logger().instrument)(`RequestTracker::writeToCache::cache.put(${key})`, () => {
-            cache.getNativeRef().putNoConfirm(key, (0, _buildCache().serialize)(contents));
-          });
-          return Promise.resolve();
-        }, async () => {
-          await this.options.cache.setLargeBlob(key, (0, _buildCache().serialize)(contents), signal ? {
-            signal: signal
-          } : undefined);
-        });
+        await this.options.cache.setLargeBlob(key, (0, _buildCache().serialize)(contents), signal ? {
+          signal: signal
+        } : undefined);
         total += 1;
         (0, _ReporterRunner.report)({
           type: 'cache',
@@ -1105,23 +1075,12 @@ class RequestTracker {
         nodeCountsPerBlob,
         nodes: undefined
       });
-      await runCacheImprovements(() => serialiseAndSet(`${cacheKey}/cache_metadata`, {
-        version: _constants.ATLASPACK_VERSION,
-        entries: this.options.entries,
-        mode: this.options.mode,
-        shouldBuildLazily: this.options.shouldBuildLazily,
-        watchBackend: this.options.watchBackend
-      }), () => Promise.resolve());
       let opts = getWatcherOptions(this.options);
       let snapshotPath = _path2().default.join(this.options.cacheDir, snapshotKey + '.txt');
       await this.options.outputFS.writeSnapshot(this.options.watchDir, snapshotPath, opts);
     } catch (err) {
       // If we have aborted, ignore the error and continue
       if (!(signal !== null && signal !== void 0 && signal.aborted)) throw err;
-    } finally {
-      await runCacheImprovements(async cache => {
-        await cache.getNativeRef().commitWriteTransaction();
-      }, () => Promise.resolve());
     }
     (0, _ReporterRunner.report)({
       type: 'cache',
@@ -1160,30 +1119,17 @@ function getWatcherOptions({
   };
 }
 function getCacheKey(options) {
-  if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-    const hash = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${options.shouldBuildLazily ? 'lazy' : 'eager'}:${options.watchBackend ?? ''}`);
-    return `RequestTracker/${_constants.ATLASPACK_VERSION}/${hash}`;
-  }
   return (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${options.shouldBuildLazily ? 'lazy' : 'eager'}:${options.watchBackend ?? ''}`);
 }
 function getRequestGraphNodeKey(index, cacheKey) {
-  if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-    return `${cacheKey}/RequestGraph/nodes/${index}`;
-  }
   return `requestGraph-nodes-${index}-${cacheKey}`;
 }
 async function readAndDeserializeRequestGraph(cache, requestGraphKey, cacheKey) {
   let bufferLength = 0;
   const getAndDeserialize = async key => {
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      const buffer = await cache.getBlob(key);
-      bufferLength += Buffer.byteLength(buffer);
-      return (0, _buildCache().deserialize)(buffer);
-    } else {
-      const buffer = await cache.getLargeBlob(key);
-      bufferLength += Buffer.byteLength(buffer);
-      return (0, _buildCache().deserialize)(buffer);
-    }
+    const buffer = await cache.getLargeBlob(key);
+    bufferLength += Buffer.byteLength(buffer);
+    return (0, _buildCache().deserialize)(buffer);
   };
   let serializedRequestGraph = await getAndDeserialize(requestGraphKey);
   let nodePromises = serializedRequestGraph.nodeCountsPerBlob.map(
@@ -1207,9 +1153,9 @@ async function loadRequestGraph(options) {
     return new RequestGraph();
   }
   let cacheKey = getCacheKey(options);
-  let requestGraphKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/RequestGraph` : `requestGraph-${cacheKey}`;
+  let requestGraphKey = `requestGraph-${cacheKey}`;
   let timeout;
-  const snapshotKey = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? `${cacheKey}/snapshot` : `snapshot-${cacheKey}`;
+  const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = _path2().default.join(options.cacheDir, snapshotKey + '.txt');
   const commonMeta = {
     cacheKey,
@@ -1232,7 +1178,7 @@ async function loadRequestGraph(options) {
   if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
     await (0, _EnvironmentManager.loadEnvironmentsFromCache)(options.cache);
   }
-  const hasRequestGraphInCache = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.has(requestGraphKey) : await options.cache.hasLargeBlob(requestGraphKey);
+  const hasRequestGraphInCache = await options.cache.hasLargeBlob(requestGraphKey);
   if (hasRequestGraphInCache) {
     try {
       let {

package/lib/TargetDescriptor.schema.js

@@ -104,6 +104,9 @@ const PACKAGE_DESCRIPTOR_SCHEMA = exports.PACKAGE_DESCRIPTOR_SCHEMA = {
       additionalProperties: {
         type: 'string'
       }
+    },
+    inlineRequires: {
+      type: 'boolean'
     }
   },
   additionalProperties: false

package/lib/UncommittedAsset.js

@@ -53,13 +53,6 @@ var _assetUtils = require("./assetUtils");
 var _types = require("./types");
 var _utils2 = require("./utils");
 var _projectPath = require("./projectPath");
-function _featureFlags() {
-  const data = require("@atlaspack/feature-flags");
-  _featureFlags = function () {
-    return data;
-  };
-  return data;
-}
 var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class UncommittedAsset {
@@ -265,10 +258,6 @@ class UncommittedAsset {
     this.value.astGenerator = null;
   }
   getCacheKey(key) {
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      const filePath = (0, _projectPath.fromProjectPathRelative)(this.value.filePath);
-      return `Asset/${_constants.ATLASPACK_VERSION}/${filePath}/${this.value.id}/${key}`;
-    }
     return (0, _rust().hashString)(_constants.ATLASPACK_VERSION + key + this.value.id);
   }
   addDependency(opts) {

package/lib/atlaspack-v3/AtlaspackV3.js

@@ -84,8 +84,12 @@ class AtlaspackV3 {
     } = bundleGraph.serializeForNative();
     return (0, _rust().atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);
   }
-  package(bundleId) {
-    return (0, _rust().atlaspackNapiPackage)(this._atlaspack_napi, bundleId);
+  updateBundleGraph(bundleGraph, changedAssetIds) {
+    const nodesJson = bundleGraph.serializeAssetNodesForNative(changedAssetIds);
+    return (0, _rust().atlaspackNapiUpdateBundleGraph)(this._atlaspack_napi, nodesJson);
+  }
+  package(bundleId, options) {
+    return (0, _rust().atlaspackNapiPackage)(this._atlaspack_napi, bundleId, options);
   }
   async respondToFsEvents(events) {
     // @ts-expect-error TS2488

package/lib/requests/AssetGraphRequest.js

@@ -26,13 +26,6 @@ function _nullthrows() {
   };
   return data;
 }
-function _featureFlags() {
-  const data = require("@atlaspack/feature-flags");
-  _featureFlags = function () {
-    return data;
-  };
-  return data;
-}
 function _utils() {
   const data = require("@atlaspack/utils");
   _utils = function () {
@@ -76,7 +69,9 @@ function createAssetGraphRequest(requestInput) {
       let assetGraphRequest = 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;
+      }
       if (!input.options.shouldBundleIncrementally || input.options.mode === 'production') {
         assetGraphRequest.assetGraph.safeToIncrementallyBundle = false;
       }
@@ -125,12 +120,7 @@ class AssetGraphBuilder {
     this.lazyIncludes = lazyIncludes ?? [];
     this.lazyExcludes = lazyExcludes ?? [];
     this.skipSymbolProp = input.skipSymbolProp ?? false;
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      const key = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
-      this.cacheKey = `AssetGraph/${_constants.ATLASPACK_VERSION}/${options.mode}/${key}`;
-    } else {
-      this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-AssetGraph';
-    }
+    this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-AssetGraph';
     this.isSingleChangeRebuild = api.getInvalidSubRequests()
     // @ts-expect-error TS2367
     .filter(req => req.requestType === 'asset_request').length === 1;
@@ -390,7 +380,6 @@ class AssetGraphBuilder {
       let didEntriesChange = prevEntries.length !== currentEntries.length || prevEntries.every((entryId, index) => entryId === currentEntries[index]);
       if (didEntriesChange) {
         this.assetGraph.safeToIncrementallyBundle = false;
-        this.assetGraph.setNeedsBundling();
       }
     }
   }
@@ -439,12 +428,10 @@ 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);
@@ -453,7 +440,6 @@ class AssetGraphBuilder {
       this.assetGraph.resolveAssetGroup(input, assets, request.id);
     } else {
       this.assetGraph.safeToIncrementallyBundle = false;
-      this.assetGraph.setNeedsBundling();
     }
     this.isSingleChangeRebuild = false;
   }

package/lib/requests/AssetGraphRequestRust.js

@@ -195,13 +195,57 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
     }
     return envId;
   };
-  function updateNode(newNode, isUpdateNode) {
+  function describeNode(node) {
+    const base = {
+      type: node.type,
+      id: node.id
+    };
+    if (node.type === 'asset') {
+      return {
+        ...base,
+        filePath: node.value.filePath,
+        fileType: node.value.type,
+        pipeline: node.value.pipeline
+      };
+    } else if (node.type === 'dependency') {
+      return {
+        ...base,
+        specifier: node.value.specifier,
+        specifierType: node.value.specifierType,
+        sourceAssetId: node.value.sourceAssetId,
+        sourcePath: node.value.sourcePath
+      };
+    }
+    return base;
+  }
+  function updateNode(newNode, isUpdateNode, index) {
     if (isUpdateNode) {
       let existingNode = graph.getNodeByContentKey(newNode.id);
       (0, _assert().default)(existingNode && existingNode.type === newNode.type);
       Object.assign(existingNode, newNode);
     } else {
-      graph.addNodeByContentKey(newNode.id, newNode);
+      try {
+        graph.addNodeByContentKey(newNode.id, newNode);
+      } catch (e) {
+        if (e instanceof Error && e.message.includes('already has content key')) {
+          let existingNode = graph.getNodeByContentKey(newNode.id);
+          let diagnostics = {
+            contentKey: newNode.id,
+            newNode: describeNode(newNode),
+            existingNode: existingNode ? describeNode(existingNode) : null,
+            iterationIndex: index,
+            totalSerializedNodes: nodesCount,
+            newNodesCount: serializedGraph.nodes.length,
+            updatesCount: serializedGraph.updates.length,
+            edgesCount: serializedGraph.edges.length,
+            hadPreviousGraph: !!prevAssetGraph,
+            safeToSkipBundling: serializedGraph.safeToSkipBundling,
+            graphNodeCount: graph._contentKeyToNodeId.size
+          };
+          throw new Error(`Graph already has content key '${newNode.id}'. Diagnostics: ${JSON.stringify(diagnostics, null, 2)}`);
+        }
+        throw e;
+      }
     }
   }
   let nodeTypeSwitchoverIndex = serializedGraph.nodes.length;
@@ -246,7 +290,7 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
         usedSymbolsUpDirty: true,
         value: asset
       };
-      updateNode(assetNode, isUpdateNode);
+      updateNode(assetNode, isUpdateNode, index);
     } else if (node.type === 'dependency') {
       let {
         dependency,
@@ -265,12 +309,12 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
       let usedSymbolsUp = new Map();
       if (node.used_symbols_up) {
         for (let usedSymbol of node.used_symbols_up) {
-          // Transform Rust UsedSymbol { symbol: Symbol, asset: string }
-          // to JS format { symbol: string, asset: string } where symbol is the exported name
+          // Transform Rust UsedSymbol { symbol: Symbol, asset: string, resolved_symbol: string }
+          // to JS format { symbol: string, asset: string } where symbol is the resolved name
           const exportedName = usedSymbol.symbol.exported;
           usedSymbolsUp.set(exportedName, {
             asset: usedSymbol.asset,
-            symbol: exportedName
+            symbol: usedSymbol.resolved_symbol ?? exportedName
           });
         }
       }
@@ -292,7 +336,7 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
         usedSymbolsUpDirtyUp: true,
         value: dependency
       };
-      updateNode(depNode, isUpdateNode);
+      updateNode(depNode, isUpdateNode, index);
     }
   }
   if (!reuseEdges) {

package/lib/requests/AtlaspackBuildRequest.js

@@ -62,7 +62,8 @@ async function run({
   let {
     bundleGraph,
     changedAssets,
-    assetRequests
+    assetRequests,
+    didIncrementallyBundle
   } = await api.runRequest(bundleGraphRequest, {
     force: Boolean(rustAtlaspack) || options.shouldBuildLazily && requestedAssetIds.size > 0
   });
@@ -75,7 +76,12 @@ async function run({
       }
     });
     if (hasSupportedTarget) {
-      await rustAtlaspack.loadBundleGraph(bundleGraph);
+      if (didIncrementallyBundle) {
+        const changedAssetIds = Array.from(changedAssets.keys());
+        await rustAtlaspack.updateBundleGraph(bundleGraph, changedAssetIds);
+      } else {
+        await rustAtlaspack.loadBundleGraph(bundleGraph);
+      }
     }
   }
 

package/lib/requests/BundleGraphRequest.js

@@ -187,7 +187,6 @@ 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, _utils.assertSignalNotAborted)(signal);
@@ -230,12 +229,7 @@ class BundlerRunner {
     this.devDepRequests = new Map();
     this.configs = new Map();
     this.pluginOptions = new _PluginOptions.default((0, _utils.optionsProxy)(this.options, api.invalidateOnOptionChange));
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      const key = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
-      this.cacheKey = `BundleGraph/${_constants.ATLASPACK_VERSION}/${options.mode}/${key}`;
-    } else {
-      this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-BundleGraph';
-    }
+    this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-BundleGraph';
   }
   async loadConfigs() {
     // Load all configs up front so we can use them in the cache key
@@ -265,6 +259,7 @@ class BundlerRunner {
       type: 'buildProgress',
       phase: 'bundling'
     });
+    let didIncrementallyBundle = false;
     await this.loadConfigs();
     let plugin = await this.config.getBundler();
     let {
@@ -275,10 +270,9 @@ class BundlerRunner {
 
     // if a previous asset graph hash is passed in, check if the bundle graph is also available
     const previousBundleGraphResult = await this.api.getPreviousResult();
-    const canIncrementallyBundle = (previousBundleGraphResult === null || previousBundleGraphResult === void 0 ? void 0 : previousBundleGraphResult.assetGraphBundlingVersion) != null && graph.canIncrementallyBundle(previousBundleGraphResult.assetGraphBundlingVersion);
+    const canIncrementallyBundle = previousBundleGraphResult != null && graph.canIncrementallyBundle();
     if (graph.safeToIncrementallyBundle && previousBundleGraphResult == null) {
       graph.safeToIncrementallyBundle = false;
-      graph.setNeedsBundling();
     }
     let internalBundleGraph;
     let logger = new (_logger().PluginLogger)({
@@ -297,8 +291,8 @@ class BundlerRunner {
           (0, _assert().default)(changedAssetNode.type === 'asset');
           internalBundleGraph.updateAsset(changedAssetNode);
         }
+        didIncrementallyBundle = true;
       } else {
-        var _this$configs$get;
         internalBundleGraph = _BundleGraph.default.fromAssetGraph(graph, this.options.mode === 'production');
         (0, _assert().default)(internalBundleGraph != null); // ensures the graph was created
 
@@ -314,14 +308,18 @@ class BundlerRunner {
         }
 
         // this the normal bundle workflow (bundle, optimizing, run-times, naming)
-        await bundler.bundle({
-          bundleGraph: mutableBundleGraph,
-          config: (_this$configs$get = this.configs.get(plugin.name)) === null || _this$configs$get === void 0 ? void 0 : _this$configs$get.result,
-          options: this.pluginOptions,
-          logger,
-          tracer
+        await (0, _logger().instrumentAsync)('bundle (V2)', async () => {
+          var _this$configs$get;
+          await bundler.bundle({
+            bundleGraph: mutableBundleGraph,
+            config: (_this$configs$get = this.configs.get(plugin.name)) === null || _this$configs$get === void 0 ? void 0 : _this$configs$get.result,
+            options: this.pluginOptions,
+            logger,
+            tracer
+          });
         });
         measurement && measurement.end();
+        (0, _BundleGraphRequestUtils.dumpBundleGraphSnapshot)(internalBundleGraph, 'js');
         if (this.pluginOptions.mode === 'production') {
           let optimizeMeasurement;
           try {
@@ -361,9 +359,9 @@ class BundlerRunner {
       if (internalBundleGraph != null) {
         this.api.storeResult({
           bundleGraph: internalBundleGraph,
-          assetGraphBundlingVersion: graph.getBundlingVersion(),
           changedAssets: new Map(),
-          assetRequests: []
+          assetRequests: [],
+          didIncrementallyBundle
         }, this.cacheKey);
       }
       throw new (_diagnostic().default)({
@@ -417,15 +415,15 @@ class BundlerRunner {
     internalBundleGraph._graph, 'after_runtimes', _BundleGraph.bundleGraphEdgeTypes);
     this.api.storeResult({
       bundleGraph: internalBundleGraph,
-      assetGraphBundlingVersion: graph.getBundlingVersion(),
       changedAssets: new Map(),
-      assetRequests: []
+      assetRequests: [],
+      didIncrementallyBundle
     }, this.cacheKey);
     return {
       bundleGraph: internalBundleGraph,
-      assetGraphBundlingVersion: graph.getBundlingVersion(),
       changedAssets: changedRuntimes,
-      assetRequests
+      assetRequests,
+      didIncrementallyBundle
     };
   }
 }

package/lib/requests/BundleGraphRequestRust.js

@@ -96,6 +96,7 @@ function createBundleGraphRequestRust(input) {
         bundleGraph,
         changedAssets
       } = (0, _logger().instrument)('atlaspack_v3_getBundleGraph', () => getBundleGraph(serializedBundleGraph));
+      (0, _BundleGraphRequestUtils.dumpBundleGraphSnapshot)(bundleGraph, 'rust');
       const runner = new NativeBundlerRunner({
         api,
         options
@@ -145,10 +146,9 @@ function createBundleGraphRequestRust(input) {
       }
       return {
         bundleGraph,
-        // Not accurate yet — ok for now.
-        assetGraphBundlingVersion: 0,
         changedAssets: changedRuntimes,
-        assetRequests: []
+        assetRequests: [],
+        didIncrementallyBundle: false
       };
     },
     input