@atlaspack/core 2.17.3 → 2.18.0

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # @atlaspack/core
 
+## 2.18.0
+
+### Minor Changes
+
+- [#601](https://github.com/atlassian-labs/atlaspack/pull/601) [`1e32d4e`](https://github.com/atlassian-labs/atlaspack/commit/1e32d4eae6b3af3968e8a0ef97d35b4347fd4196) Thanks [@yamadapc](https://github.com/yamadapc)! - Improve granular configuration file invalidations
+
+- [#599](https://github.com/atlassian-labs/atlaspack/pull/599) [`0b2f6f5`](https://github.com/atlassian-labs/atlaspack/commit/0b2f6f55794d3ff6e2f5a41f963e7e5dd8ad9f8d) Thanks [@pancaspe87](https://github.com/pancaspe87)! - load and write env to cache - change is feature flagged
+
+### Patch Changes
+
+- [#595](https://github.com/atlassian-labs/atlaspack/pull/595) [`51aba5f`](https://github.com/atlassian-labs/atlaspack/commit/51aba5fc0e49235ee06bbc3c376f48c3e7da5c4b) Thanks [@yamadapc](https://github.com/yamadapc)! - Add bundleId to write bundle request results
+
+- [#572](https://github.com/atlassian-labs/atlaspack/pull/572) [`6dd4ccb`](https://github.com/atlassian-labs/atlaspack/commit/6dd4ccb753541de32322d881f973d571dd57e4ca) Thanks [@yamadapc](https://github.com/yamadapc)! - Add feature-flagged change which removes all environment duplication around objects
+
+- Updated dependencies [[`0999fb7`](https://github.com/atlassian-labs/atlaspack/commit/0999fb78da519a6c7582d212883e515fcf6c1252), [`51aba5f`](https://github.com/atlassian-labs/atlaspack/commit/51aba5fc0e49235ee06bbc3c376f48c3e7da5c4b), [`1e32d4e`](https://github.com/atlassian-labs/atlaspack/commit/1e32d4eae6b3af3968e8a0ef97d35b4347fd4196), [`35fdd4b`](https://github.com/atlassian-labs/atlaspack/commit/35fdd4b52da0af20f74667f7b8adfb2f90279b7c), [`6dd4ccb`](https://github.com/atlassian-labs/atlaspack/commit/6dd4ccb753541de32322d881f973d571dd57e4ca)]:
+  - @atlaspack/fs@2.15.5
+  - @atlaspack/types@2.15.0
+  - @atlaspack/rust@3.3.5
+  - @atlaspack/cache@3.2.5
+  - @atlaspack/package-manager@2.14.10
+  - @atlaspack/profiler@2.14.8
+  - @atlaspack/workers@2.14.10
+  - @atlaspack/plugin@2.14.10
+  - @atlaspack/logger@2.14.10
+  - @atlaspack/utils@2.14.10
+
+## 2.17.4
+
+### Patch Changes
+
+- [#588](https://github.com/atlassian-labs/atlaspack/pull/588) [`1940859`](https://github.com/atlassian-labs/atlaspack/commit/194085942f0e86532e9d039fc3f8039badce4594) Thanks [@yamadapc](https://github.com/yamadapc)! - Do not invalidate all javascript files when tsconfig files change
+
+- [#592](https://github.com/atlassian-labs/atlaspack/pull/592) [`15b6155`](https://github.com/atlassian-labs/atlaspack/commit/15b61556e9114203ebbc9de94b864118ca764598) Thanks [@yamadapc](https://github.com/yamadapc)! - Report large file invalidations
+
+- [#503](https://github.com/atlassian-labs/atlaspack/pull/503) [`209692f`](https://github.com/atlassian-labs/atlaspack/commit/209692ffb11eae103a0d65c5e1118a5aa1625818) Thanks [@JakeLane](https://github.com/JakeLane)! - Fix conditional bundling reporter when condition is reused
+
+- [#562](https://github.com/atlassian-labs/atlaspack/pull/562) [`d04de26`](https://github.com/atlassian-labs/atlaspack/commit/d04de26af684d7abfba5091fbe3df16a12cd0ebc) Thanks [@yamadapc](https://github.com/yamadapc)! - Update with feature-flagged change to write packages into files rather than LMDB
+
+- Updated dependencies [[`124b7ff`](https://github.com/atlassian-labs/atlaspack/commit/124b7fff44f71aac9fbad289a9a9509b3dfc9aaa), [`e052521`](https://github.com/atlassian-labs/atlaspack/commit/e0525210850ed1606146eb86991049cf567c5dec), [`15c6d70`](https://github.com/atlassian-labs/atlaspack/commit/15c6d7000bd89da876bc590aa75b17a619a41896), [`e4d966c`](https://github.com/atlassian-labs/atlaspack/commit/e4d966c3c9c4292c5013372ae65b10d19d4bacc6), [`209692f`](https://github.com/atlassian-labs/atlaspack/commit/209692ffb11eae103a0d65c5e1118a5aa1625818), [`42a775d`](https://github.com/atlassian-labs/atlaspack/commit/42a775de8eec638ad188f3271964170d8c04d84b), [`29c2f10`](https://github.com/atlassian-labs/atlaspack/commit/29c2f106de9679adfb5afa04e1910471dc65a427), [`f4da1e1`](https://github.com/atlassian-labs/atlaspack/commit/f4da1e120e73eeb5e8b8927f05e88f04d6148c7b), [`1ef91fc`](https://github.com/atlassian-labs/atlaspack/commit/1ef91fcc863fdd2831511937083dbbc1263b3d9d)]:
+  - @atlaspack/cache@3.2.4
+  - @atlaspack/rust@3.3.4
+  - @atlaspack/fs@2.15.4
+  - @atlaspack/feature-flags@2.16.0
+  - @atlaspack/logger@2.14.9
+  - @atlaspack/utils@2.14.9
+  - @atlaspack/package-manager@2.14.9
+  - @atlaspack/graph@3.4.7
+  - @atlaspack/workers@2.14.9
+  - @atlaspack/profiler@2.14.7
+  - @atlaspack/types@2.14.9
+  - @atlaspack/plugin@2.14.9
+
 ## 2.17.3
 
 ### Patch Changes

package/lib/AssetGraph.js

@@ -46,6 +46,14 @@ function _graph() {
 }
 var _Dependency = require("./Dependency");
 var _projectPath = require("./projectPath");
+var _EnvironmentManager = require("./EnvironmentManager");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function nodeFromDep(dep) {
   return {
@@ -63,7 +71,7 @@ function nodeFromDep(dep) {
 }
 function nodeFromAssetGroup(assetGroup) {
   return {
-    id: (0, _rust().hashString)((0, _projectPath.fromProjectPathRelative)(assetGroup.filePath) + assetGroup.env.id + String(assetGroup.isSource) + String(assetGroup.sideEffects) + (assetGroup.code ?? '') + ':' + (assetGroup.pipeline ?? '') + ':' + (assetGroup.query ?? '')),
+    id: (0, _rust().hashString)((0, _projectPath.fromProjectPathRelative)(assetGroup.filePath) + (0, _EnvironmentManager.toEnvironmentId)(assetGroup.env) + String(assetGroup.isSource) + String(assetGroup.sideEffects) + (assetGroup.code ?? '') + ':' + (assetGroup.pipeline ?? '') + ':' + (assetGroup.query ?? '')),
     type: 'asset_group',
     value: assetGroup,
     usedSymbolsDownDirty: true
@@ -130,16 +138,19 @@ class AssetGraph extends _graph().ContentGraph {
 
   // Deduplicates Environments by making them referentially equal
   normalizeEnvironment(input) {
+    if ((0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+      return;
+    }
     let {
       id,
       context
-    } = input.env;
+    } = (0, _EnvironmentManager.fromEnvironmentId)(input.env);
     let idAndContext = `${id}-${context}`;
     let env = this.envCache.get(idAndContext);
     if (env) {
       input.env = env;
     } else {
-      this.envCache.set(idAndContext, input.env);
+      this.envCache.set(idAndContext, (0, _EnvironmentManager.fromEnvironmentId)(input.env));
     }
   }
   setRootConnections({
@@ -199,13 +210,13 @@ class AssetGraph extends _graph().ContentGraph {
         env: target.env,
         isEntry: true,
         needsStableName: true,
-        symbols: target.env.isLibrary ? new Map([['*', {
+        symbols: (0, _EnvironmentManager.fromEnvironmentId)(target.env).isLibrary ? new Map([['*', {
           local: '*',
           isWeak: true,
           loc: null
         }]]) : undefined
       }));
-      if (node.value.env.isLibrary) {
+      if ((0, _EnvironmentManager.fromEnvironmentId)(node.value.env).isLibrary) {
         // in library mode, all of the entry's symbols are "used"
         node.usedSymbolsDown.add('*');
         node.usedSymbolsUp.set('*', undefined);
@@ -348,7 +359,7 @@ class AssetGraph extends _graph().ContentGraph {
       if (this.undeferredDependencies.has(d)) {
         return false;
       }
-      let depIsDeferrable = d.symbols && !(d.env.isLibrary && d.isEntry) && !d.symbols.has('*') && ![...d.symbols.keys()].some(symbol => {
+      let depIsDeferrable = d.symbols && !((0, _EnvironmentManager.fromEnvironmentId)(d.env).isLibrary && d.isEntry) && !d.symbols.has('*') && ![...d.symbols.keys()].some(symbol => {
         var _resolvedAsset$symbol;
         let assetSymbol = (_resolvedAsset$symbol = resolvedAsset.symbols) === null || _resolvedAsset$symbol === void 0 || (_resolvedAsset$symbol = _resolvedAsset$symbol.get(symbol)) === null || _resolvedAsset$symbol === void 0 ? void 0 : _resolvedAsset$symbol.local;
         return assetSymbol != null && symbols.has(assetSymbol);

package/lib/Atlaspack.js

@@ -510,7 +510,9 @@ class Atlaspack {
       if (this.rustAtlaspack) {
         nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
       }
-      let isInvalid = await this.#requestTracker.respondToFSEvents(events, Number.POSITIVE_INFINITY);
+      let {
+        didInvalidate: isInvalid
+      } = await this.#requestTracker.respondToFSEvents(events, Number.POSITIVE_INFINITY);
       if ((nativeInvalid || isInvalid) && this.#watchQueue.getNumWaiting() === 0) {
         if (this.#watchAbortController) {
           this.#watchAbortController.abort();

package/lib/BundleGraph.js

@@ -51,6 +51,7 @@ function _featureFlags() {
   };
   return data;
 }
+var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const bundleGraphEdgeTypes = exports.bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -207,7 +208,7 @@ class BundleGraph {
           }
         }
       }
-      if (node.type === 'dependency' && node.value.symbols != null && node.value.env.shouldScopeHoist &&
+      if (node.type === 'dependency' && node.value.symbols != null && (0, _EnvironmentManager.fromEnvironmentId)(node.value.env).shouldScopeHoist &&
       // Disable in dev mode because this feature is at odds with safeToIncrementallyBundle
       isProduction) {
         let nodeValueSymbols = node.value.symbols;
@@ -859,7 +860,7 @@ class BundleGraph {
           return;
         }
         visitedBundles.add(descendant);
-        if (descendant.type !== bundle.type || descendant.env.context !== bundle.env.context) {
+        if (descendant.type !== bundle.type || (0, _EnvironmentManager.fromEnvironmentId)(descendant.env).context !== (0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context) {
           actions.skipChildren();
           return;
         }
@@ -887,7 +888,7 @@ class BundleGraph {
   isAssetReachableFromBundle(asset, bundle) {
     // If a bundle's environment is isolated, it can't access assets present
     // in any ancestor bundles. Don't consider any assets reachable.
-    if (_Environment.ISOLATED_ENVS.has(bundle.env.context) || !bundle.isSplittable || bundle.bundleBehavior === _types.BundleBehavior.isolated || bundle.bundleBehavior === _types.BundleBehavior.inline) {
+    if (_Environment.ISOLATED_ENVS.has((0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context) || !bundle.isSplittable || bundle.bundleBehavior === _types.BundleBehavior.isolated || bundle.bundleBehavior === _types.BundleBehavior.inline) {
       return false;
     }
 
@@ -915,7 +916,7 @@ class BundleGraph {
           let node = (0, _nullthrows().default)(this._graph.getNode(nodeId));
           // If we've reached the root or a context change without
           // finding this asset in the ancestry, it is not reachable.
-          if (node.type === 'root' || node.type === 'bundle' && (node.value.id === bundle.id || node.value.env.context !== bundle.env.context)) {
+          if (node.type === 'root' || node.type === 'bundle' && (node.value.id === bundle.id || (0, _EnvironmentManager.fromEnvironmentId)(node.value.env).context !== (0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context)) {
             isReachable = false;
             actions.stop();
             return;
@@ -1410,7 +1411,7 @@ class BundleGraph {
     for (let referencedBundle of this.getReferencedBundles(bundle)) {
       hash.writeString(referencedBundle.id);
     }
-    hash.writeString(JSON.stringify((0, _utils().objectSortedEntriesDeep)(bundle.env)));
+    hash.writeString(JSON.stringify((0, _utils().objectSortedEntriesDeep)((0, _EnvironmentManager.fromEnvironmentId)(bundle.env))));
     return hash.finish();
   }
   getBundleGraphHash() {

package/lib/Dependency.js

@@ -24,6 +24,7 @@ function _assert() {
   return data;
 }
 var _IdentifierRegistry = require("./IdentifierRegistry");
+var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createDependencyId({
   sourceAssetId,
@@ -41,8 +42,11 @@ function createDependencyId({
   const params = {
     sourceAssetId,
     specifier,
-    environmentId: env.id,
-    target,
+    environmentId: (0, _EnvironmentManager.toEnvironmentId)(env),
+    target: target != null ? {
+      ...target,
+      env: (0, _EnvironmentManager.fromEnvironmentId)(target.env)
+    } : null,
     pipeline,
     specifierType: _types.SpecifierType[specifierType],
     bundleBehavior,

package/lib/Environment.js

@@ -15,6 +15,7 @@ function _rust() {
 var _utils = require("./utils");
 var _Environment = _interopRequireWildcard(require("./public/Environment"));
 var _IdentifierRegistry = require("./IdentifierRegistry");
+var _EnvironmentManager = require("./EnvironmentManager");
 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; }
 const DEFAULT_ENGINES = {
@@ -108,15 +109,15 @@ function createEnvironment({
     loc
   };
   res.id = getEnvironmentHash(res);
-  return Object.freeze(res);
+  return (0, _EnvironmentManager.toEnvironmentRef)(Object.freeze(res));
 }
 function mergeEnvironments(projectRoot, a, b) {
   // If merging the same object, avoid copying.
   if (a === b || !b) {
-    return a;
+    return (0, _EnvironmentManager.toEnvironmentRef)(a);
   }
   if (b instanceof _Environment.default) {
-    return (0, _Environment.environmentToInternalEnvironment)(b);
+    return (0, _EnvironmentManager.toEnvironmentRef)((0, _Environment.environmentToInternalEnvironment)(b));
   }
 
   // $FlowFixMe - ignore the `id` that is already on a

package/lib/EnvironmentManager.js

@@ -0,0 +1,137 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fromEnvironmentId = fromEnvironmentId;
+exports.loadEnvironmentsFromCache = loadEnvironmentsFromCache;
+exports.toEnvironmentId = toEnvironmentId;
+exports.toEnvironmentRef = toEnvironmentRef;
+exports.writeEnvironmentsToCache = writeEnvironmentsToCache;
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+var _constants = require("./constants");
+/*!
+ * At the moment we're doing this change for `CoreEnvironment`,
+ * but the same change must be made for `TypesEnvironment` in @atlaspack/types.
+ */
+const localEnvironmentCache = new Map();
+
+/**
+ * When deduplication is cleaned-up this will always be a string.
+ */
+
+/**
+ * Convert environment to a ref.
+ * This is what we should be using to store environments.
+ */
+function toEnvironmentRef(env) {
+  if (!(0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+    return env;
+  }
+  const id = toEnvironmentId(env);
+  return id;
+}
+
+/**
+ * Convert environment to a string ID
+ */
+function toEnvironmentId(
+/**
+ * Redundant type during roll-out
+ */
+env) {
+  if (!(0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+    return typeof env === 'string' ? env : env.id;
+  }
+  if (typeof env === 'string') {
+    return env;
+  }
+  (0, _rust().addEnvironment)(env);
+  return env.id;
+}
+function fromEnvironmentId(id) {
+  if (!(0, _featureFlags().getFeatureFlag)('environmentDeduplication')) {
+    if (typeof id === 'string') {
+      throw new Error('This should never happen when environmentDeduplication feature-flag is off');
+    } else {
+      return id;
+    }
+  }
+  if (typeof id !== 'string') {
+    return id;
+  }
+  const localEnv = localEnvironmentCache.get(id);
+  if (localEnv) {
+    return localEnv;
+  }
+  const env = Object.freeze((0, _rust().getEnvironment)(id));
+  localEnvironmentCache.set(id, env);
+  return env;
+}
+
+/**
+ * Writes all environments and their IDs to the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+async function writeEnvironmentsToCache(cache) {
+  const environments = (0, _rust().getAllEnvironments)();
+  const environmentIds = new Set();
+
+  // Store each environment individually
+  for (const env of environments) {
+    environmentIds.add(env.id);
+    const envKey = `Environment/${_constants.ATLASPACK_VERSION}/${env.id}`;
+    await (0, _logger().instrument)(`RequestTracker::writeToCache::cache.put(${envKey})`, async () => {
+      await cache.set(envKey, env);
+    });
+  }
+
+  // Store the list of environment IDs
+  await (0, _logger().instrument)(`RequestTracker::writeToCache::cache.put(${`EnvironmentManager/${_constants.ATLASPACK_VERSION}`})`, async () => {
+    await cache.set(`EnvironmentManager/${_constants.ATLASPACK_VERSION}`, Array.from(environmentIds));
+  });
+}
+
+/**
+ * Loads all environments and their IDs from the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+async function loadEnvironmentsFromCache(cache) {
+  const cachedEnvIds = await cache.get(`EnvironmentManager/${_constants.ATLASPACK_VERSION}`);
+  if (cachedEnvIds == null) {
+    return;
+  }
+  const environments = [];
+  for (const envId of cachedEnvIds) {
+    const envKey = `Environment/${_constants.ATLASPACK_VERSION}/${envId}`;
+    const cachedEnv = await cache.get(envKey);
+    if (cachedEnv != null) {
+      environments.push(cachedEnv);
+    }
+  }
+  if (environments.length > 0) {
+    (0, _rust().setAllEnvironments)(environments);
+  }
+}

package/lib/InternalConfig.js

@@ -14,6 +14,7 @@ function _rust() {
   return data;
 }
 var _IdentifierRegistry = require("./IdentifierRegistry");
+var _EnvironmentManager = require("./EnvironmentManager");
 function createConfig({
   plugin,
   isSource,
@@ -30,11 +31,11 @@ function createConfig({
   invalidateOnBuild
 }) {
   let environment = env ?? (0, _Environment.createEnvironment)();
-  const configId = (0, _rust().hashString)(plugin + (0, _projectPath.fromProjectPathRelative)(searchPath) + environment.id + String(isSource));
+  const configId = (0, _rust().hashString)(plugin + (0, _projectPath.fromProjectPathRelative)(searchPath) + (0, _EnvironmentManager.toEnvironmentId)(environment) + String(isSource));
   _IdentifierRegistry.identifierRegistry.addIdentifier('config_request', configId, {
     plugin,
     searchPath,
-    environmentId: environment.id,
+    environmentId: (0, _EnvironmentManager.toEnvironmentId)(environment),
     isSource
   });
   return {

package/lib/PackagerRunner.js

@@ -92,6 +92,14 @@ 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 }; }
@@ -390,20 +398,22 @@ class PackagerRunner {
     let fullPath = (0, _projectPath.fromProjectPath)(this.options.projectRoot, filePath);
     let sourceRoot = _path().default.relative(_path().default.dirname(fullPath), this.options.projectRoot);
     let inlineSources = false;
+    const bundleEnv = (0, _EnvironmentManager.fromEnvironmentId)(bundle.env);
     if (bundle.target) {
-      if (bundle.env.sourceMap && bundle.env.sourceMap.sourceRoot !== undefined) {
-        sourceRoot = bundle.env.sourceMap.sourceRoot;
-      } else if (this.options.serveOptions && bundle.target.env.context === 'browser') {
+      const bundleTargetEnv = (0, _EnvironmentManager.fromEnvironmentId)(bundle.target.env);
+      if (bundleEnv.sourceMap && bundleEnv.sourceMap.sourceRoot !== undefined) {
+        sourceRoot = bundleEnv.sourceMap.sourceRoot;
+      } else if (this.options.serveOptions && bundleTargetEnv.context === 'browser') {
         sourceRoot = '/__parcel_source_root';
       }
-      if (bundle.env.sourceMap && bundle.env.sourceMap.inlineSources !== undefined) {
-        inlineSources = bundle.env.sourceMap.inlineSources;
-      } else if (bundle.target.env.context !== 'node') {
+      if (bundleEnv.sourceMap && bundleEnv.sourceMap.inlineSources !== undefined) {
+        inlineSources = bundleEnv.sourceMap.inlineSources;
+      } else if (bundleTargetEnv.context !== 'node') {
         // inlining should only happen in production for browser targets by default
         inlineSources = this.options.mode === 'production';
       }
     }
-    let isInlineMap = bundle.env.sourceMap && bundle.env.sourceMap.inline;
+    let isInlineMap = bundleEnv.sourceMap && bundleEnv.sourceMap.inline;
     let stringified = await map.stringify({
       file: _path().default.basename(fullPath + '.map'),
       // $FlowFixMe
@@ -434,6 +444,10 @@ 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) {
@@ -457,25 +471,27 @@ class PackagerRunner {
     let contentKey = PackagerRunner.getContentKey(cacheKey);
     let mapKey = PackagerRunner.getMapKey(cacheKey);
     let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists = isLargeBlob || (await this.options.cache.has(contentKey));
+    let contentExists = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? isLargeBlob : isLargeBlob || (await this.options.cache.has(contentKey));
     if (!contentExists) {
       return null;
     }
-    let mapExists = await this.options.cache.has(mapKey);
+    let mapExists = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await this.options.cache.hasLargeBlob(mapKey) : 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)(await this.options.cache.getBlob(mapKey)) : null
+      map: mapExists ? (0, _utils().blobToStream)((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await this.options.cache.getLargeBlob(mapKey) : await this.options.cache.getBlob(mapKey)) : null
     };
   }
   async writeToCache(cacheKeys, type, contents, map) {
     let size = 0;
     let hash;
     let hashReferences = [];
-    let isLargeBlob = false;
+    let isLargeBlob = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements');
 
     // TODO: don't replace hash references in binary files??
     if (contents instanceof _stream().Readable) {
-      isLargeBlob = true;
+      if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+        isLargeBlob = true;
+      }
       let boundaryStr = '';
       let h = new (_rust().Hash)();
       await this.options.cache.setStream(cacheKeys.content, (0, _utils().blobToStream)(contents).pipe(new (_utils().TapStream)(buf => {
@@ -491,15 +507,27 @@ class PackagerRunner {
       size = buffer.byteLength;
       hash = (0, _rust().hashBuffer)(buffer);
       hashReferences = contents.match(_constants.HASH_REF_REGEX) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, buffer);
+      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
+      } else {
+        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) ?? [];
-      await this.options.cache.setBlob(cacheKeys.content, contents);
+      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.content, contents);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.content, contents);
+      }
     }
     if (map != null) {
-      await this.options.cache.setBlob(cacheKeys.map, map);
+      if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+        await this.options.cache.setLargeBlob(cacheKeys.map, map);
+      } else {
+        await this.options.cache.setBlob(cacheKeys.map, map);
+      }
     }
     let info = {
       type,
@@ -513,12 +541,21 @@ 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`);
   }
 }