@atlaspack/core 2.34.0 → 2.35.0

package/dist/requests/AssetGraphRequestRust.js

@@ -203,14 +203,58 @@ 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_2.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;
@@ -257,7 +301,7 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
                 usedSymbolsUpDirty: true,
                 value: asset,
             };
-            updateNode(assetNode, isUpdateNode);
+            updateNode(assetNode, isUpdateNode, index);
         }
         else if (node.type === 'dependency') {
             let { dependency, id } = node.value;
@@ -274,12 +318,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,
                     });
                 }
             }
@@ -301,7 +345,7 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
                 usedSymbolsUpDirtyUp: true,
                 value: dependency,
             };
-            updateNode(depNode, isUpdateNode);
+            updateNode(depNode, isUpdateNode, index);
         }
     }
     if (!reuseEdges) {

package/dist/requests/AtlaspackBuildRequest.js

@@ -39,7 +39,7 @@ async function run({ input, api, options, rustAtlaspack, }) {
             requestedAssetIds,
             signal,
         });
-    let { bundleGraph, changedAssets, assetRequests } = await api.runRequest(bundleGraphRequest, {
+    let { bundleGraph, changedAssets, assetRequests, didIncrementallyBundle, } = await api.runRequest(bundleGraphRequest, {
         force: Boolean(rustAtlaspack) ||
             (options.shouldBuildLazily && requestedAssetIds.size > 0),
     });
@@ -55,7 +55,13 @@ async function run({ input, api, options, rustAtlaspack, }) {
             }
         });
         if (hasSupportedTarget) {
-            await rustAtlaspack.loadBundleGraph(bundleGraph);
+            if (didIncrementallyBundle) {
+                const changedAssetIds = Array.from(changedAssets.keys());
+                await rustAtlaspack.updateBundleGraph(bundleGraph, changedAssetIds);
+            }
+            else {
+                await rustAtlaspack.loadBundleGraph(bundleGraph);
+            }
         }
     }
     // @ts-expect-error TS2345

package/dist/requests/BundleGraphRequest.js

@@ -157,7 +157,6 @@ function createBundleGraphRequest(input) {
                     .some((req) => !input.api.canSkipSubrequest(req.id));
             if (subRequestsInvalid) {
                 assetGraph.safeToIncrementallyBundle = false;
-                assetGraph.setNeedsBundling();
             }
             let configResult = (0, nullthrows_1.default)(await input.api.runRequest((0, AtlaspackConfigRequest_1.default)()));
             (0, utils_1.assertSignalNotAborted)(signal);
@@ -193,14 +192,8 @@ class BundlerRunner {
         this.devDepRequests = new Map();
         this.configs = new Map();
         this.pluginOptions = new PluginOptions_1.default((0, utils_1.optionsProxy)(this.options, api.invalidateOnOptionChange));
-        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-            const key = (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
-            this.cacheKey = `BundleGraph/${constants_1.ATLASPACK_VERSION}/${options.mode}/${key}`;
-        }
-        else {
-            this.cacheKey =
-                (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-BundleGraph';
-        }
+        this.cacheKey =
+            (0, rust_1.hashString)(`${constants_1.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
@@ -226,16 +219,15 @@ class BundlerRunner {
             type: 'buildProgress',
             phase: 'bundling',
         });
+        let didIncrementallyBundle = false;
         await this.loadConfigs();
         let plugin = await this.config.getBundler();
         let { plugin: bundler, name, resolveFrom } = plugin;
         // 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?.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_1.PluginLogger({ origin: name });
@@ -252,6 +244,7 @@ class BundlerRunner {
                     (0, assert_1.default)(changedAssetNode.type === 'asset');
                     internalBundleGraph.updateAsset(changedAssetNode);
                 }
+                didIncrementallyBundle = true;
             }
             else {
                 internalBundleGraph = BundleGraph_1.default.fromAssetGraph(graph, this.options.mode === 'production');
@@ -318,9 +311,9 @@ class BundlerRunner {
             if (internalBundleGraph != null) {
                 this.api.storeResult({
                     bundleGraph: internalBundleGraph,
-                    assetGraphBundlingVersion: graph.getBundlingVersion(),
                     changedAssets: new Map(),
                     assetRequests: [],
+                    didIncrementallyBundle,
                 }, this.cacheKey);
             }
             throw new diagnostic_1.default({
@@ -371,15 +364,15 @@ class BundlerRunner {
         internalBundleGraph._graph, 'after_runtimes', BundleGraph_1.bundleGraphEdgeTypes);
         this.api.storeResult({
             bundleGraph: internalBundleGraph,
-            assetGraphBundlingVersion: graph.getBundlingVersion(),
             changedAssets: new Map(),
             assetRequests: [],
+            didIncrementallyBundle,
         }, this.cacheKey);
         return {
             bundleGraph: internalBundleGraph,
-            assetGraphBundlingVersion: graph.getBundlingVersion(),
             changedAssets: changedRuntimes,
             assetRequests,
+            didIncrementallyBundle,
         };
     }
 }

package/dist/requests/BundleGraphRequestRust.js

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

package/dist/requests/PackageRequest.js

@@ -34,7 +34,7 @@ async function run({ input, api, farm, rustAtlaspack }) {
         (0, EnvironmentManager_1.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/dist/requests/TargetRequest.js

@@ -227,6 +227,7 @@ class TargetResolver {
                         distDir: (0, projectPath_1.toProjectPath)(this.options.projectRoot, path_1.default.resolve(this.fs.cwd(), distDir)),
                         publicUrl: descriptor.publicUrl ??
                             this.options.defaultTargetOptions.publicUrl,
+                        inlineRequires: descriptor.inlineRequires ?? false,
                         env: (0, Environment_1.createEnvironment)({
                             engines: descriptor.engines,
                             context: descriptor.context,
@@ -299,6 +300,7 @@ class TargetResolver {
                         name: 'default',
                         distDir: (0, projectPath_1.toProjectPath)(this.options.projectRoot, this.options.serveOptions.distDir),
                         publicUrl: this.options.defaultTargetOptions.publicUrl ?? '/',
+                        inlineRequires: false,
                         env: (0, Environment_1.createEnvironment)({
                             context: 'browser',
                             engines: {
@@ -705,6 +707,7 @@ class TargetResolver {
                     distDir,
                     distEntry,
                     publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+                    inlineRequires: descriptor.inlineRequires ?? false,
                     env: (0, Environment_1.createEnvironment)({
                         engines: descriptor.engines ?? pkgEngines,
                         // @ts-expect-error TS2322
@@ -870,6 +873,7 @@ class TargetResolver {
                         : distDir),
                     distEntry,
                     publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+                    inlineRequires: descriptor.inlineRequires ?? false,
                     env: (0, Environment_1.createEnvironment)({
                         engines: descriptor.engines ?? pkgEngines,
                         context: descriptor.context,
@@ -932,6 +936,7 @@ class TargetResolver {
                 distDir: this.options.defaultTargetOptions.distDir ??
                     (0, projectPath_1.toProjectPath)(this.options.projectRoot, path_1.default.join(pkgDir, DEFAULT_DIST_DIRNAME)),
                 publicUrl: this.options.defaultTargetOptions.publicUrl,
+                inlineRequires: false,
                 env: (0, Environment_1.createEnvironment)({
                     engines: pkgEngines,
                     // @ts-expect-error TS2322

package/dist/requests/WriteBundleRequest.js

@@ -134,17 +134,13 @@ async function run({ input, options, api }) {
         ? []
         : undefined;
     await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements);
-    const hasSourceMap = (0, feature_flags_1.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, feature_flags_1.getFeatureFlag)('fixSourceMapHashRefs') &&
             bundleReplacements &&
             bundleReplacements.length > 0) {
-            const mapEntry = (0, feature_flags_1.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);
@@ -161,9 +157,7 @@ async function run({ input, options, api }) {
             mapStream = (0, utils_1.blobToStream)(Buffer.from(typeof mapJson === 'string' ? mapJson : JSON.stringify(mapJson), 'utf8'));
         }
         else {
-            const mapEntry = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
-                ? await options.cache.getLargeBlob(mapKey)
-                : await options.cache.getBlob(mapKey);
+            const mapEntry = await options.cache.getBlob(mapKey);
             mapStream = (0, utils_1.blobToStream)(mapEntry);
         }
         await writeFiles(mapStream, info, hashRefToNameHash, options, config, outputFS, (0, projectPath_1.toProjectPathUnsafe)((0, projectPath_1.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);

package/dist/resolveOptions.js

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

package/lib/AssetGraph.js

@@ -108,32 +108,16 @@ function nodeFromEntryFile(entry) {
 
 // @ts-expect-error TS2417
 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;
       // @ts-expect-error TS2345
       super(rest);
       this.hash = hash;
-      this.#bundlingVersion = bundlingVersion ?? 0;
-      this.#disableIncrementalBundling = disableIncrementalBundling ?? false;
     } else {
       super();
       this.setRootNodeId(this.addNode({
@@ -151,57 +135,16 @@ 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
+   * 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) {
-    if (!(0, _featureFlags().getFeatureFlag)('incrementalBundlingVersioning')) {
-      return this.safeToIncrementallyBundle && !this.#disableIncrementalBundling;
-    }
-    return this.safeToIncrementallyBundle && this.#bundlingVersion === lastVersion && !this.#disableIncrementalBundling;
+  canIncrementallyBundle() {
+    return this.safeToIncrementallyBundle;
   }
 
   // Deduplicates Environments by making them referentially equal
@@ -381,13 +324,11 @@ class AssetGraph extends _graph().ContentGraph {
         // @ts-expect-error TS2339
         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/BundleGraph.js

@@ -516,6 +516,44 @@ class BundleGraph {
     };
   }
 
+  /**
+   * Serialize only the given asset nodes for native incremental update.
+   * Same node shape and env/omit logic as serializeForNative.
+   */
+  serializeAssetNodesForNative(assetIds) {
+    const start = performance.now();
+    if (assetIds.length === 0) {
+      return '[]';
+    }
+    const nodes = [];
+    for (const assetId of assetIds) {
+      var _node$value4;
+      const node = this._graph.getNodeByContentKey(assetId);
+      if ((node === null || node === void 0 ? void 0 : node.type) !== 'asset') {
+        continue;
+      }
+      const processedNode = {
+        ...node
+      };
+      if ((_node$value4 = node.value) !== null && _node$value4 !== void 0 && _node$value4.env) {
+        processedNode.value = {
+          ...node.value,
+          env: (0, _EnvironmentManager.fromEnvironmentId)(node.value.env).id
+        };
+      }
+      nodes.push(processedNode);
+    }
+    const optimizedNodes = nodes.map(node => this._omitNulls(node));
+    const nodesJson = JSON.stringify(optimizedNodes);
+    const duration = performance.now() - start;
+    const nodesSizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+    _logger().default.verbose({
+      origin: '@atlaspack/core',
+      message: `serializeAssetNodesForNative: ${duration.toFixed(1)}ms, ${nodesSizeMB}MB nodes, ${nodes.length} nodes`
+    });
+    return nodesJson;
+  }
+
   /**
    * Remove null and undefined values from an object to reduce JSON size.
    * Preserves false, 0, empty strings, and arrays.

package/lib/PackagerRunner.js

@@ -87,13 +87,6 @@ function _profiler() {
   return data;
 }
 var _EnvironmentManager = require("./EnvironmentManager");
-function _featureFlags() {
-  const data = require("@atlaspack/feature-flags");
-  _featureFlags = function () {
-    return data;
-  };
-  return data;
-}
 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 }; }
@@ -437,10 +430,6 @@ class PackagerRunner {
       devDepHashes += await this.getDevDepHashes(inlineBundle);
     }
     let invalidationHash = await (0, _assetUtils.getInvalidationHash)(invalidations, this.options);
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      const hash = (0, _rust().hashString)(_constants.ATLASPACK_VERSION + devDepHashes + invalidationHash + bundle.target.publicUrl + bundleGraph.getHash(bundle) + JSON.stringify(configResults) + JSON.stringify(globalInfoResults) + this.options.mode + (this.options.shouldBuildLazily ? 'lazy' : 'eager'));
-      return _path().default.join(bundle.displayName ?? bundle.name ?? bundle.id, hash);
-    }
     return (0, _rust().hashString)(_constants.ATLASPACK_VERSION + devDepHashes + invalidationHash + bundle.target.publicUrl + bundleGraph.getHash(bundle) + JSON.stringify(configResults) + JSON.stringify(globalInfoResults) + this.options.mode + (this.options.shouldBuildLazily ? 'lazy' : 'eager'));
   }
   async getDevDepHashes(bundle) {
@@ -464,14 +453,14 @@ class PackagerRunner {
     let contentKey = PackagerRunner.getContentKey(cacheKey);
     let mapKey = PackagerRunner.getMapKey(cacheKey);
     let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? isLargeBlob : isLargeBlob || (await this.options.cache.has(contentKey));
+    let contentExists = isLargeBlob || (await this.options.cache.has(contentKey));
     if (!contentExists) {
       return null;
     }
-    let mapExists = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await this.options.cache.hasLargeBlob(mapKey) : await this.options.cache.has(mapKey);
+    let mapExists = await this.options.cache.has(mapKey);
     return {
       contents: isLargeBlob ? this.options.cache.getStream(contentKey) : (0, _utils().blobToStream)(await this.options.cache.getBlob(contentKey)),
-      map: mapExists ? (0, _utils().blobToStream)((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await this.options.cache.getLargeBlob(mapKey) : await this.options.cache.getBlob(mapKey)) : null
+      map: mapExists ? (0, _utils().blobToStream)(await this.options.cache.getBlob(mapKey)) : null
     };
   }
   async writeToCache(cacheKeys, type, contents, map) {
@@ -479,13 +468,11 @@ class PackagerRunner {
     let hash;
     // @ts-expect-error TS2702
     let hashReferences = [];
-    let isLargeBlob = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements');
+    let isLargeBlob = false;
 
     // TODO: don't replace hash references in binary files??
     if (contents instanceof _stream().Readable) {
-      if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-        isLargeBlob = true;
-      }
+      isLargeBlob = true;
       let boundaryStr = '';
       let h = new (_rust().Hash)();
       await this.options.cache.setStream(cacheKeys.content, (0, _utils().blobToStream)(contents).pipe(
@@ -503,27 +490,15 @@ class PackagerRunner {
       size = buffer.byteLength;
       hash = (0, _rust().hashBuffer)(buffer);
       hashReferences = contents.match(_constants.HASH_REF_REGEX) ?? [];
-      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.content, buffer);
-      }
+      await this.options.cache.setBlob(cacheKeys.content, buffer);
     } else {
       size = contents.length;
       hash = (0, _rust().hashBuffer)(contents);
       hashReferences = contents.toString().match(_constants.HASH_REF_REGEX) ?? [];
-      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.content, contents);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.content, contents);
-      }
+      await this.options.cache.setBlob(cacheKeys.content, contents);
     }
     if (map != null) {
-      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.map, map);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.map, map);
-      }
+      await this.options.cache.setBlob(cacheKeys.map, map);
     }
     let info = {
       type,
@@ -537,21 +512,12 @@ class PackagerRunner {
     return info;
   }
   static getContentKey(cacheKey) {
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      return `PackagerRunner/${_constants.ATLASPACK_VERSION}/${cacheKey}/content`;
-    }
     return (0, _rust().hashString)(`${cacheKey}:content`);
   }
   static getMapKey(cacheKey) {
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      return `PackagerRunner/${_constants.ATLASPACK_VERSION}/${cacheKey}/map`;
-    }
     return (0, _rust().hashString)(`${cacheKey}:map`);
   }
   static getInfoKey(cacheKey) {
-    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
-      return `PackagerRunner/${_constants.ATLASPACK_VERSION}/${cacheKey}/info`;
-    }
     return (0, _rust().hashString)(`${cacheKey}:info`);
   }
 }