@atlaspack/core 2.33.1 → 2.35.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/applyRuntimes.js

@@ -437,7 +437,7 @@ function reconcileNewRuntimes(api, connections, optionsRef) {
     name: 'Runtimes',
     assetGroups,
     optionsRef,
-    skipSymbolProp: (0, _featureFlags().getFeatureFlag)('skipRuntimeSymbolProp')
+    skipSymbolProp: (0, _featureFlags().getFeatureFlag)('skipRuntimeSymbolProp') || (0, _featureFlags().getFeatureFlag)('rustSymbolTracker')
   });
 
   // rebuild the graph

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

@@ -20,7 +20,7 @@ function _diagnostic() {
   return data;
 }
 function _logger() {
-  const data = require("@atlaspack/logger");
+  const data = _interopRequireWildcard(require("@atlaspack/logger"));
   _logger = function () {
     return data;
   };
@@ -39,13 +39,15 @@ var _SymbolPropagation = require("../SymbolPropagation");
 var _EnvironmentManager = require("../EnvironmentManager");
 var _Environment = require("../Environment");
 var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAssetGraphRequestRust(rustAtlaspack) {
   return input => ({
     type: _RequestTracker.requestTypes.asset_graph_request,
     id: input.name,
-    run: async input => {
-      let options = input.options;
+    run: async runInput => {
+      let options = runInput.options;
       let {
         assetGraphPromise,
         commitPromise
@@ -60,7 +62,7 @@ function createAssetGraphRequestRust(rustAtlaspack) {
       // Don't reuse a previous asset graph result if Rust didn't have one too
       let prevResult = null;
       if (serializedAssetGraph.hadPreviousGraph) {
-        prevResult = await input.api.getPreviousResult();
+        prevResult = await runInput.api.getPreviousResult();
       }
       let {
         assetGraph,
@@ -70,20 +72,28 @@ function createAssetGraphRequestRust(rustAtlaspack) {
         return getAssetGraph(serializedAssetGraph, (_prevResult = prevResult) === null || _prevResult === void 0 ? void 0 : _prevResult.assetGraph);
       });
       let changedAssetsPropagation = new Set(changedAssets.keys());
-      let errors = (0, _SymbolPropagation.propagateSymbols)({
-        options,
-        assetGraph,
-        changedAssetsPropagation,
-        assetGroupsWithRemovedParents: new Set(),
-        previousErrors: new Map() //this.previousSymbolPropagationErrors,
-      });
-
-      if (errors.size > 0) {
-        // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
-        // determining which failing export is the root cause is nontrivial (because of circular dependencies).
-        throw new (_diagnostic().default)({
-          diagnostic: [...errors.values()][0]
+      // Skip symbol propagation for runtime assets - they have pre-computed symbol data
+      if (input.skipSymbolProp) {
+        _logger().default.verbose({
+          origin: '@atlaspack/core',
+          message: 'Skipping symbol propagation for runtime asset graph'
         });
+      } else {
+        let errors = (0, _SymbolPropagation.propagateSymbols)({
+          options,
+          assetGraph,
+          changedAssetsPropagation,
+          assetGroupsWithRemovedParents: new Set(),
+          previousErrors: new Map() //this.previousSymbolPropagationErrors,
+        });
+
+        if (errors.size > 0) {
+          // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+          // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+          throw new (_diagnostic().default)({
+            diagnostic: [...errors.values()][0]
+          });
+        }
       }
       await (0, _dumpGraphToGraphViz.default)(assetGraph, 'AssetGraphV3');
       let result = {
@@ -102,8 +112,8 @@ function createAssetGraphRequestRust(rustAtlaspack) {
           }
         });
       }
-      await input.api.storeResult(result);
-      input.api.invalidateOnBuild();
+      await runInput.api.storeResult(result);
+      runInput.api.invalidateOnBuild();
       return result;
     },
     input
@@ -185,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;
@@ -236,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,
@@ -253,6 +307,17 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
       }
       let usedSymbolsDown = new Set();
       let usedSymbolsUp = new Map();
+      if (node.used_symbols_up) {
+        for (let usedSymbol of node.used_symbols_up) {
+          // 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: usedSymbol.resolved_symbol ?? exportedName
+          });
+        }
+      }
       if (dependency.isEntry && dependency.isLibrary) {
         usedSymbolsDown.add('*');
         usedSymbolsUp.set('*', undefined);
@@ -271,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

@@ -136,7 +136,8 @@ function createBundleGraphRequest(input) {
         shouldBuildLazily: options.shouldBuildLazily,
         lazyIncludes: options.lazyIncludes,
         lazyExcludes: options.lazyExcludes,
-        requestedAssetIds
+        requestedAssetIds,
+        skipSymbolProp: (0, _featureFlags().getFeatureFlag)('rustSymbolTracker')
       });
       let {
         assetGraph,
@@ -186,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);
@@ -229,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
@@ -264,6 +259,7 @@ class BundlerRunner {
       type: 'buildProgress',
       phase: 'bundling'
     });
+    let didIncrementallyBundle = false;
     await this.loadConfigs();
     let plugin = await this.config.getBundler();
     let {
@@ -274,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)({
@@ -296,6 +291,7 @@ 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');
@@ -360,9 +356,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)({
@@ -416,15 +412,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

@@ -145,10 +145,9 @@ function createBundleGraphRequestRust(input) {
       }
       return {
         bundleGraph,
-        // Not accurate yet — ok for now.
-        assetGraphBundlingVersion: 0,
         changedAssets: changedRuntimes,
-        assetRequests: []
+        assetRequests: [],
+        didIncrementallyBundle: false
       };
     },
     input

package/lib/requests/PackageRequest.js

@@ -70,7 +70,9 @@ async function run({
   let packagingResult;
   if ((0, _featureFlags().getFeatureFlag)('nativePackager') && (0, _featureFlags().getFeatureFlag)('nativePackagerSSRDev') && rustAtlaspack && (0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context === 'tesseract' && bundle.type === 'js') {
     // Once this actually does something, the code below will be in an `else` block (i.e. we'll only run one or the other)
-    let result = await rustAtlaspack.package(bundle.id);
+    let result = await rustAtlaspack.package(bundle.id, {
+      inlineRequires: true
+    });
     let error = null;
     [packagingResult, error] = result;
     if (error) {

package/lib/requests/TargetRequest.js

@@ -247,6 +247,7 @@ class TargetResolver {
             name,
             distDir: (0, _projectPath.toProjectPath)(this.options.projectRoot, _path().default.resolve(this.fs.cwd(), distDir)),
             publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+            inlineRequires: descriptor.inlineRequires ?? false,
             env: (0, _Environment.createEnvironment)({
               engines: descriptor.engines,
               context: descriptor.context,
@@ -311,6 +312,7 @@ class TargetResolver {
           name: 'default',
           distDir: (0, _projectPath.toProjectPath)(this.options.projectRoot, this.options.serveOptions.distDir),
           publicUrl: this.options.defaultTargetOptions.publicUrl ?? '/',
+          inlineRequires: false,
           env: (0, _Environment.createEnvironment)({
             context: 'browser',
             engines: {
@@ -670,6 +672,7 @@ class TargetResolver {
           distDir,
           distEntry,
           publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+          inlineRequires: descriptor.inlineRequires ?? false,
           env: (0, _Environment.createEnvironment)({
             engines: descriptor.engines ?? pkgEngines,
             // @ts-expect-error TS2322
@@ -819,6 +822,7 @@ class TargetResolver {
           distDir: (0, _projectPath.toProjectPath)(this.options.projectRoot, descriptor.distDir != null ? _path().default.resolve(pkgDir, descriptor.distDir) : distDir),
           distEntry,
           publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+          inlineRequires: descriptor.inlineRequires ?? false,
           env: (0, _Environment.createEnvironment)({
             engines: descriptor.engines ?? pkgEngines,
             context: descriptor.context,
@@ -889,6 +893,7 @@ class TargetResolver {
         name: 'default',
         distDir: this.options.defaultTargetOptions.distDir ?? (0, _projectPath.toProjectPath)(this.options.projectRoot, _path().default.join(pkgDir, DEFAULT_DIST_DIRNAME)),
         publicUrl: this.options.defaultTargetOptions.publicUrl,
+        inlineRequires: false,
         env: (0, _Environment.createEnvironment)({
           engines: pkgEngines,
           // @ts-expect-error TS2322