@atlaspack/core 2.34.0 → 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/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,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');
@@ -361,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)({
@@ -417,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

package/lib/requests/WriteBundleRequest.js

@@ -177,11 +177,11 @@ async function run({
   (0, _DevDepRequest.invalidateDevDeps)(invalidDevDeps, options, config);
   const bundleReplacements = (0, _featureFlags().getFeatureFlag)('fixSourceMapHashRefs') ? [] : undefined;
   await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements);
-  const hasSourceMap = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.hasLargeBlob(mapKey) : await options.cache.has(mapKey);
+  const hasSourceMap = await options.cache.has(mapKey);
   if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
     let mapStream;
     if ((0, _featureFlags().getFeatureFlag)('fixSourceMapHashRefs') && bundleReplacements && bundleReplacements.length > 0) {
-      const mapEntry = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.getLargeBlob(mapKey) : await options.cache.getBlob(mapKey);
+      const mapEntry = await options.cache.getBlob(mapKey);
       const mapBuffer = Buffer.isBuffer(mapEntry) ? mapEntry : Buffer.from(mapEntry);
       const projectRoot = typeof options.projectRoot === 'string' ? options.projectRoot : String(options.projectRoot);
       const sourceMap = new (_sourceMap().default)(projectRoot, mapBuffer);
@@ -193,7 +193,7 @@ async function run({
       });
       mapStream = (0, _utils().blobToStream)(Buffer.from(typeof mapJson === 'string' ? mapJson : JSON.stringify(mapJson), 'utf8'));
     } else {
-      const mapEntry = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.getLargeBlob(mapKey) : await options.cache.getBlob(mapKey);
+      const mapEntry = await options.cache.getBlob(mapKey);
       mapStream = (0, _utils().blobToStream)(mapEntry);
     }
     await writeFiles(mapStream, info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);

package/lib/resolveOptions.js

@@ -167,10 +167,8 @@ async function resolveOptions(initialOptions) {
       return initialOptions.cache;
     }
     const needsRustLmdbCache = (0, _featureFlags().getFeatureFlag)('atlaspackV3') || (0, _featureFlags().getFeatureFlag)('nativePackager');
-    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
-        return new (_cache().FSCache)(outputFS, cacheDir);
-      }
+    if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
+      return new (_cache().FSCache)(outputFS, cacheDir);
     }
     return new (_cache().LMDBLiteCache)(cacheDir);
   }

package/lib/types/AssetGraph.d.ts

@@ -9,13 +9,9 @@ type InitOpts = {
     assetGroups?: Array<AssetGroup>;
 };
 type AssetGraphOpts = ContentGraphOpts<AssetGraphNode> & {
-    bundlingVersion?: number;
-    disableIncrementalBundling?: boolean;
     hash?: string | null | undefined;
 };
 type SerializedAssetGraph = SerializedContentGraph<AssetGraphNode> & {
-    bundlingVersion: number;
-    disableIncrementalBundling: boolean;
     hash?: string | null | undefined;
 };
 export declare function nodeFromDep(dep: Dependency): DependencyNode;
@@ -24,40 +20,19 @@ export declare function nodeFromAsset(asset: Asset): AssetNode;
 export declare function nodeFromEntrySpecifier(entry: ProjectPath): EntrySpecifierNode;
 export declare function nodeFromEntryFile(entry: Entry): EntryFileNode;
 export default class AssetGraph extends ContentGraph<AssetGraphNode> {
-    #private;
     onNodeRemoved: ((nodeId: NodeId) => unknown) | null | undefined;
     hash: string | null | undefined;
     envCache: Map<string, Environment>;
-    /**
-     * @deprecated
-     */
     safeToIncrementallyBundle: boolean;
     undeferredDependencies: Set<Dependency>;
     constructor(opts?: AssetGraphOpts | null);
     static deserialize(opts: AssetGraphOpts): AssetGraph;
     serialize(): SerializedAssetGraph;
     /**
-     * Force incremental bundling to be disabled.
-     */
-    setDisableIncrementalBundling(disable: boolean): void;
-    testing_getDisableIncrementalBundling(): boolean;
-    /**
-     * Make sure this asset graph is marked as needing a full bundling pass.
-     */
-    setNeedsBundling(): void;
-    /**
-     * 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 the `bundlingVersion` has not changed since the last bundling pass,
-     * we can incrementally bundle, which will not require a full bundling pass
+     * Determine if 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;
+    canIncrementallyBundle(): boolean;
     normalizeEnvironment(input: Asset | Dependency | AssetGroup): void;
     setRootConnections({ entries, assetGroups }: InitOpts): void;
     addNode(node: AssetGraphNode): NodeId;

package/lib/types/BundleGraph.d.ts

@@ -87,6 +87,11 @@ export default class BundleGraph {
         publicIdByAssetId: Record<string, string>;
         environmentsJson: string;
     };
+    /**
+     * Serialize only the given asset nodes for native incremental update.
+     * Same node shape and env/omit logic as serializeForNative.
+     */
+    serializeAssetNodesForNative(assetIds: Array<string>): string;
     /**
      * Remove null and undefined values from an object to reduce JSON size.
      * Preserves false, 0, empty strings, and arrays.