@atlaspack/core 2.16.2-canary.13 → 2.16.2-canary.131

package/lib/public/Dependency.js

@@ -19,6 +19,7 @@ var _Target = _interopRequireDefault(require("./Target"));
 var _Symbols = require("./Symbols");
 var _projectPath = require("../projectPath");
 var _utils = require("../utils");
+var _EnvironmentManager = require("../EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const SpecifierTypeNames = Object.keys(_types.SpecifierType);
 const PriorityNames = Object.keys(_types.Priority);
@@ -36,9 +37,8 @@ function getPublicDependency(dep, options) {
   return new Dependency(dep, options);
 }
 class Dependency {
-  #dep /*: InternalDependency */;
-  #options /*: AtlaspackOptions */;
-
+  #dep;
+  #options;
   constructor(dep, options) {
     this.#dep = dep;
     this.#options = options;
@@ -80,7 +80,7 @@ class Dependency {
     return (0, _utils.fromInternalSourceLocation)(this.#options.projectRoot, this.#dep.loc);
   }
   get env() {
-    return new _Environment.default(this.#dep.env, this.#options);
+    return new _Environment.default((0, _EnvironmentManager.fromEnvironmentId)(this.#dep.env), this.#options);
   }
   get packageConditions() {
     // Merge custom conditions with conditions stored as bitflags.

package/lib/public/Environment.js

@@ -127,9 +127,8 @@ function environmentToInternalEnvironment(environment) {
   return (0, _nullthrows().default)(_environmentToInternalEnvironment.get(environment));
 }
 class Environment {
-  #environment /*: InternalEnvironment */;
-  #options /*: AtlaspackOptions */;
-
+  #environment;
+  #options;
   constructor(env, options) {
     let existing = internalEnvironmentToEnvironment.get(env);
     if (existing != null) {

package/lib/public/MutableBundleGraph.js

@@ -38,6 +38,7 @@ var _projectPath = require("../projectPath");
 var _types = require("../types");
 var _BundleGroup = _interopRequireWildcard(require("./BundleGroup"));
 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; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -53,9 +54,9 @@ function createBundleId(data) {
   return id;
 }
 class MutableBundleGraph extends _BundleGraph.default {
-  #graph /*: InternalBundleGraph */;
-  #options /*: AtlaspackOptions */;
-  #bundlePublicIds /*: Set<string> */ = new Set();
+  #graph;
+  #options;
+  #bundlePublicIds = new Set();
   constructor(graph, options) {
     super(graph, _Bundle.Bundle.get.bind(_Bundle.Bundle), options);
     this.#graph = graph;
@@ -149,7 +150,7 @@ class MutableBundleGraph extends _BundleGraph.default {
         id: bundleId,
         hashReference: this.#options.shouldContentHash ? _constants.HASH_REF_PREFIX + bundleId : bundleId.slice(-8),
         type: opts.entryAsset ? opts.entryAsset.type : opts.type,
-        env: opts.env ? (0, _Environment.environmentToInternalEnvironment)(opts.env) : (0, _nullthrows().default)(entryAsset).env,
+        env: opts.env ? (0, _EnvironmentManager.toEnvironmentRef)((0, _Environment.environmentToInternalEnvironment)(opts.env)) : (0, _nullthrows().default)(entryAsset).env,
         entryAssetIds: entryAsset ? [entryAsset.id] : [],
         mainEntryId: entryAsset === null || entryAsset === void 0 ? void 0 : entryAsset.id,
         pipeline: opts.entryAsset ? opts.entryAsset.pipeline : opts.pipeline,

package/lib/public/PluginOptions.js

@@ -6,8 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 let parcelOptionsToPluginOptions = new WeakMap();
 class PluginOptions {
-  #options /*: AtlaspackOptions */;
-
+  #options;
   constructor(options) {
     let existing = parcelOptionsToPluginOptions.get(options);
     if (existing != null) {

package/lib/public/Target.js

@@ -15,6 +15,7 @@ function _nullthrows() {
 var _Environment = _interopRequireDefault(require("./Environment"));
 var _projectPath = require("../projectPath");
 var _utils = require("../utils");
+var _EnvironmentManager = require("../EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 const internalTargetToTarget = new WeakMap();
@@ -23,9 +24,8 @@ function targetToInternalTarget(target) {
   return (0, _nullthrows().default)(_targetToInternalTarget.get(target));
 }
 class Target {
-  #target /*: TargetValue */;
-  #options /*: AtlaspackOptions */;
-
+  #target;
+  #options;
   constructor(target, options) {
     let existing = internalTargetToTarget.get(target);
     if (existing != null) {
@@ -44,7 +44,7 @@ class Target {
     return (0, _projectPath.fromProjectPath)(this.#options.projectRoot, this.#target.distDir);
   }
   get env() {
-    return new _Environment.default(this.#target.env, this.#options);
+    return new _Environment.default((0, _EnvironmentManager.fromEnvironmentId)(this.#target.env), this.#options);
   }
   get name() {
     return this.#target.name;

package/lib/requests/AssetGraphRequest.js

@@ -26,6 +26,13 @@ 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 () {
@@ -116,7 +123,12 @@ class AssetGraphBuilder {
     this.shouldBuildLazily = shouldBuildLazily ?? false;
     this.lazyIncludes = lazyIncludes ?? [];
     this.lazyExcludes = lazyExcludes ?? [];
-    this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-AssetGraph';
+    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.isSingleChangeRebuild = api.getInvalidSubRequests().filter(req => req.requestType === 'asset_request').length === 1;
     this.queue = new (_utils().PromiseQueue)();
     assetGraph.onNodeRemoved = nodeId => {

package/lib/requests/AssetGraphRequestRust.js

@@ -26,9 +26,18 @@ function _logger() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 var _AssetGraph = _interopRequireWildcard(require("../AssetGraph"));
 var _RequestTracker = require("../RequestTracker");
 var _SymbolPropagation = require("../SymbolPropagation");
+var _EnvironmentManager = require("../EnvironmentManager");
+var _Environment = require("../Environment");
 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 }; }
@@ -137,8 +146,11 @@ function getAssetGraph(serializedGraph) {
       let id = asset.id;
       asset.committed = true;
       asset.contentKey = id;
-      asset.env.id = getEnvId(asset.env);
+      asset.env.id = (0, _featureFlags().getFeatureFlag)('environmentDeduplication') ?
+      // TODO: Rust can do this and avoid copying a significant amount of data over
+      (0, _Environment.getEnvironmentHash)(asset.env) : getEnvId(asset.env);
       asset.mapKey = `map:${asset.id}`;
+      asset.env = (0, _EnvironmentManager.toEnvironmentRef)(asset.env);
 
       // This is populated later when we map the edges between assets and dependencies
       asset.dependencies = new Map();
@@ -162,7 +174,10 @@ function getAssetGraph(serializedGraph) {
       let id = node.value.id;
       let dependency = node.value.dependency;
       dependency.id = id;
-      dependency.env.id = getEnvId(dependency.env);
+      dependency.env.id = (0, _featureFlags().getFeatureFlag)('environmentDeduplication') ?
+      // TODO: Rust can do this and avoid copying a significant amount of data over
+      (0, _Environment.getEnvironmentHash)(dependency.env) : getEnvId(dependency.env);
+      dependency.env = (0, _EnvironmentManager.toEnvironmentRef)(dependency.env);
       if (dependency.symbols != null) {
         var _dependency$symbols;
         dependency.symbols = new Map((_dependency$symbols = dependency.symbols) === null || _dependency$symbols === void 0 ? void 0 : _dependency$symbols.map(mapSymbols));

package/lib/requests/AssetRequest.js

@@ -31,6 +31,7 @@ var _ConfigRequest = require("./ConfigRequest");
 var _projectPath = require("../projectPath");
 var _ReporterRunner = require("../ReporterRunner");
 var _RequestTracker = require("../RequestTracker");
+var _EnvironmentManager = require("../EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAssetRequest(input) {
   return {
@@ -42,7 +43,7 @@ function createAssetRequest(input) {
 }
 const type = 'asset_request';
 function getId(input) {
-  return (0, _rust().hashString)(type + (0, _projectPath.fromProjectPathRelative)(input.filePath) + input.env.id + String(input.isSource) + String(input.sideEffects) + (input.code ?? '') + ':' + (input.pipeline ?? '') + ':' + (input.query ?? ''));
+  return (0, _rust().hashString)(type + (0, _projectPath.fromProjectPathRelative)(input.filePath) + (0, _EnvironmentManager.toEnvironmentId)(input.env) + String(input.isSource) + String(input.sideEffects) + (input.code ?? '') + ':' + (input.pipeline ?? '') + ':' + (input.query ?? ''));
 }
 async function run({
   input,

package/lib/requests/BundleGraphRequest.js

@@ -32,6 +32,13 @@ function _logger() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _diagnostic() {
   const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
   _diagnostic = function () {
@@ -225,7 +232,12 @@ class BundlerRunner {
     this.devDepRequests = new Map();
     this.configs = new Map();
     this.pluginOptions = new _PluginOptions.default((0, _utils2.optionsProxy)(this.options, api.invalidateOnOptionChange));
-    this.cacheKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-BundleGraph';
+    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';
+    }
   }
   async loadConfigs() {
     // Load all configs up front so we can use them in the cache key

package/lib/requests/ConfigRequest.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.getConfigHash = getConfigHash;
 exports.getConfigKeyContentHash = getConfigKeyContentHash;
 exports.getConfigRequests = getConfigRequests;
+exports.getValueAtPath = getValueAtPath;
 exports.loadPluginConfig = loadPluginConfig;
 exports.runConfigRequest = runConfigRequest;
 function _utils() {
@@ -86,19 +87,41 @@ async function loadPluginConfig(loadedPlugin, config, options) {
     });
   }
 }
+
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+function getValueAtPath(obj, key) {
+  let current = obj;
+  for (let part of key) {
+    if (current == null) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
 const configKeyCache = (0, _buildCache().createBuildCache)();
 async function getConfigKeyContentHash(filePath, configKey, options) {
-  let cacheKey = `${(0, _projectPath.fromProjectPathRelative)(filePath)}:${configKey}`;
+  let cacheKey = `${(0, _projectPath.fromProjectPathRelative)(filePath)}:${JSON.stringify(configKey)}`;
   let cachedValue = configKeyCache.get(cacheKey);
   if (cachedValue) {
     return cachedValue;
   }
-  let conf = await (0, _utils().readConfig)(options.inputFS, (0, _projectPath.fromProjectPath)(options.projectRoot, filePath));
-  if (conf == null || conf.config[configKey] == null) {
+  const conf = await (0, _utils().readConfig)(options.inputFS, (0, _projectPath.fromProjectPath)(options.projectRoot, filePath));
+  const value = getValueAtPath(conf === null || conf === void 0 ? void 0 : conf.config, configKey);
+  if (conf == null || value == null) {
     // This can occur when a config key has been removed entirely during `respondToFSEvents`
     return '';
   }
-  let contentHash = typeof conf.config[configKey] === 'object' ? (0, _utils().hashObject)(conf.config[configKey]) : (0, _rust().hashString)(JSON.stringify(conf.config[configKey]));
+  const contentHash = typeof value === 'object' ? (0, _utils().hashObject)(value) : (0, _rust().hashString)(JSON.stringify(value));
   configKeyCache.set(cacheKey, contentHash);
   return contentHash;
 }

package/lib/requests/DevDepRequest.js

@@ -89,7 +89,17 @@ async function createDevDependency(opts, requestDevDeps, options) {
   return devDepRequest;
 }
 async function getDevDepRequests(api) {
-  let previousDevDepRequests = new Map(await Promise.all(api.getSubRequests().filter(req => req.requestType === _RequestTracker.requestTypes.dev_dep_request).map(async req => [req.id, (0, _nullthrows().default)(await api.getRequestResult(req.id))])));
+  async function getPreviousDevDepRequests() {
+    const allDevDepRequests = await Promise.all(api.getSubRequests().filter(req => req.requestType === _RequestTracker.requestTypes.dev_dep_request).map(async req => [req.id, await api.getRequestResult(req.id)]));
+    const nonNullDevDepRequests = [];
+    for (const [id, result] of allDevDepRequests) {
+      if (result != null) {
+        nonNullDevDepRequests.push([id, result]);
+      }
+    }
+    return new Map(nonNullDevDepRequests);
+  }
+  const previousDevDepRequests = await getPreviousDevDepRequests();
   return {
     devDeps: new Map([...previousDevDepRequests.entries()].filter(([id]) => api.canSkipSubrequest(id)).map(([, req]) => [`${req.specifier}:${(0, _projectPath.fromProjectPathRelative)(req.resolveFrom)}`, req.hash])),
     invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()].filter(([id]) => !api.canSkipSubrequest(id)).flatMap(([, req]) => {

package/lib/requests/PathRequest.js

@@ -26,6 +26,13 @@ function _logger() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
   _nullthrows = function () {
@@ -259,6 +266,9 @@ class ResolverRunner {
           }
           if (result.priority != null) {
             dependency.priority = _types.Priority[result.priority];
+            if ((0, _featureFlags().getFeatureFlag)('hmrImprovements')) {
+              dependency.resolverPriority = dependency.priority;
+            }
           }
           if (result.invalidateOnEnvChange) {
             invalidateOnEnvChange.push(...result.invalidateOnEnvChange);

package/lib/requests/TargetRequest.js

@@ -69,6 +69,7 @@ var _Environment2 = require("../public/Environment");
 var _utils2 = require("../utils");
 var _projectPath = require("../projectPath");
 var _RequestTracker = require("../RequestTracker");
+var _EnvironmentManager = require("../EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 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; }
@@ -245,7 +246,7 @@ class TargetResolver {
             }
           });
         }
-        if (!_Environment2.BROWSER_ENVS.has(targets[0].env.context)) {
+        if (!_Environment2.BROWSER_ENVS.has((0, _EnvironmentManager.fromEnvironmentId)(targets[0].env).context)) {
           throw new (_diagnostic().default)({
             diagnostic: {
               message: `Only browser targets are supported in serve mode`,
@@ -1073,22 +1074,23 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
 
     // Resolve relevant engines for context.
     let engines;
-    switch (target.env.context) {
+    const env = (0, _EnvironmentManager.fromEnvironmentId)(target.env);
+    switch (env.context) {
       case 'browser':
       case 'web-worker':
       case 'service-worker':
       case 'worklet':
         {
-          let browsers = target.env.engines.browsers;
+          let browsers = env.engines.browsers;
           engines = Array.isArray(browsers) ? browsers.join(', ') : browsers;
           break;
         }
       case 'node':
-        engines = target.env.engines.node;
+        engines = env.engines.node;
         break;
       case 'electron-main':
       case 'electron-renderer':
-        engines = target.env.engines.electron;
+        engines = env.engines.electron;
         break;
     }
     let highlights = [];
@@ -1124,7 +1126,7 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
         highlight.defined = (0, _diagnostic().md)`${key} defined here`;
       }
       if (keyInfo.inferred) {
-        highlight.inferred.push((0, _diagnostic().md)`${key} to be ${JSON.stringify(target.env[key])}`);
+        highlight.inferred.push((0, _diagnostic().md)`${key} to be ${JSON.stringify(env[key])}`);
       }
     }
 
@@ -1150,12 +1152,12 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
 
     // Format includeNodeModules to be human readable.
     let includeNodeModules;
-    if (typeof target.env.includeNodeModules === 'boolean') {
-      includeNodeModules = String(target.env.includeNodeModules);
-    } else if (Array.isArray(target.env.includeNodeModules)) {
-      includeNodeModules = 'only ' + listFormat.format(target.env.includeNodeModules.map(m => JSON.stringify(m)));
-    } else if (target.env.includeNodeModules && typeof target.env.includeNodeModules === 'object') {
-      includeNodeModules = 'all except ' + listFormat.format(Object.entries(target.env.includeNodeModules).filter(([, v]) => v === false).map(([k]) => JSON.stringify(k)));
+    if (typeof env.includeNodeModules === 'boolean') {
+      includeNodeModules = String(env.includeNodeModules);
+    } else if (Array.isArray(env.includeNodeModules)) {
+      includeNodeModules = 'only ' + listFormat.format(env.includeNodeModules.map(m => JSON.stringify(m)));
+    } else if (env.includeNodeModules && typeof env.includeNodeModules === 'object') {
+      includeNodeModules = 'all except ' + listFormat.format(Object.entries(env.includeNodeModules).filter(([, v]) => v === false).map(([k]) => JSON.stringify(k)));
     }
     let format = v => v.message != null ? _diagnostic().md.italic(v.message) : '';
     _logger().default.verbose({
@@ -1164,12 +1166,12 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
 
                **Entry**: ${_path().default.relative(process.cwd(), (0, _projectPath.fromProjectPath)(options.projectRoot, input.filePath))}
               **Output**: ${_path().default.relative(process.cwd(), output)}
-              **Format**: ${target.env.outputFormat} ${format(info.outputFormat)}
-             **Context**: ${target.env.context} ${format(info.context)}
+              **Format**: ${env.outputFormat} ${format(info.outputFormat)}
+             **Context**: ${env.context} ${format(info.context)}
              **Engines**: ${engines || ''} ${format(info.engines)}
-        **Library Mode**: ${String(target.env.isLibrary)} ${format(info.isLibrary)}
+        **Library Mode**: ${String(env.isLibrary)} ${format(info.isLibrary)}
 **Include Node Modules**: ${includeNodeModules} ${format(info.includeNodeModules)}
-            **Optimize**: ${String(target.env.shouldOptimize)} ${format(info.shouldOptimize)}`,
+            **Optimize**: ${String(env.shouldOptimize)} ${format(info.shouldOptimize)}`,
       codeFrames: target.loc ? [{
         filePath: targetFilePath,
         codeHighlights: highlights

package/lib/requests/WriteBundleRequest.js

@@ -61,6 +61,14 @@ function _profiler() {
   return data;
 }
 var _RequestTracker = require("../RequestTracker");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+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; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -114,7 +122,8 @@ async function run({
   let cacheKeys = info.cacheKeys;
   let mapKey = cacheKeys.map;
   let fullPath = (0, _projectPath.fromProjectPath)(options.projectRoot, filePath);
-  if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline) {
+  const env = (0, _EnvironmentManager.fromEnvironmentId)(bundle.env);
+  if (mapKey && env.sourceMap && !env.sourceMap.inline) {
     api.invalidateOnFileDelete((0, _projectPath.toProjectPath)(options.projectRoot, fullPath + '.map'));
   }
   let dir = _path().default.dirname(fullPath);
@@ -145,11 +154,14 @@ async function run({
   } = await (0, _DevDepRequest.getDevDepRequests)(api);
   (0, _DevDepRequest.invalidateDevDeps)(invalidDevDeps, options, config);
   await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api);
-  if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline && (await options.cache.has(mapKey))) {
-    await writeFiles((0, _utils().blobToStream)(await options.cache.getBlob(mapKey)), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
+  const hasSourceMap = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.hasLargeBlob(mapKey) : await options.cache.has(mapKey);
+  if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
+    const mapEntry = (0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements') ? await options.cache.getLargeBlob(mapKey) : await options.cache.getBlob(mapKey);
+    await writeFiles((0, _utils().blobToStream)(mapEntry), info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
   }
   let res = {
     filePath,
+    bundleId: bundle.id,
     type: info.type,
     stats: {
       size,

package/lib/requests/WriteBundlesRequest.js

@@ -12,6 +12,7 @@ function _featureFlags() {
   return data;
 }
 var _RequestTracker = require("../RequestTracker");
+var _ReporterRunner = require("../ReporterRunner");
 var _constants = require("../constants");
 var _projectPath = require("../projectPath");
 function _nullthrows() {
@@ -31,6 +32,18 @@ function _rust() {
 var _PackageRequest = require("./PackageRequest");
 var _WriteBundleRequest = _interopRequireDefault(require("./WriteBundleRequest"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function reportPackagingProgress(completeBundles, totalBundles) {
+  if (!(0, _featureFlags().getFeatureFlag)('cliProgressReportingImprovements')) {
+    return;
+  }
+  (0, _ReporterRunner.report)({
+    type: 'buildProgress',
+    phase: 'packagingAndOptimizing',
+    totalBundles,
+    completeBundles
+  });
+}
+
 /**
  * Packages, optimizes, and writes all bundles to the dist directory.
  */
@@ -76,6 +89,7 @@ async function run({
       let name = (0, _nullthrows().default)(bundle.name, `Expected ${bundle.type} bundle to have a name`).replace(bundle.hashReference, hash);
       res.set(bundle.id, {
         filePath: (0, _projectPath.joinProjectPath)(bundle.target.distDir, name),
+        bundleId: bundle.id,
         type: bundle.type,
         // FIXME: this is wrong if the packager changes the type...
         stats: {
@@ -87,11 +101,14 @@ async function run({
     }
     return true;
   });
+  let cachedBundles = new Set(bundles.filter(b => api.canSkipSubrequest(bundleGraph.getHash(b))));
 
   // Package on the main thread if there is only one bundle to package.
   // This avoids the cost of serializing the bundle graph for single file change builds.
-  let useMainThread = bundles.length === 1 || bundles.filter(b => !api.canSkipSubrequest(bundleGraph.getHash(b))).length === 1;
+  let useMainThread = bundles.length === 1 || bundles.length - cachedBundles.size <= 1;
   try {
+    let completeBundles = cachedBundles.size;
+    reportPackagingProgress(completeBundles, bundles.length);
     await Promise.all(bundles.map(async bundle => {
       let request = (0, _PackageRequest.createPackageRequest)({
         bundle,
@@ -101,6 +118,10 @@ async function run({
         useMainThread
       });
       let info = await api.runRequest(request);
+      if (!cachedBundles.has(bundle)) {
+        completeBundles++;
+        reportPackagingProgress(completeBundles, bundles.length);
+      }
       if (!useMainThread) {
         // Force a refresh of the cache to avoid a race condition
         // between threaded reads and writes that can result in an LMDB cache miss:

package/lib/resolveOptions.js

@@ -139,16 +139,19 @@ async function resolveOptions(initialOptions) {
   // where symlinked dependencies outside the project root need to trigger HMR
   // updates. Default to the project root if not provided.
   let watchDir = initialOptions.watchDir != null ? _path().default.resolve(initialOptions.watchDir) : projectRoot;
-  let cache = function createCache() {
+  function createCache() {
     if (initialOptions.cache) {
       return initialOptions.cache;
     }
     const needsRustLmdbCache = (0, _featureFlags().getFeatureFlag)('atlaspackV3');
-    if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
-      return new (_cache().FSCache)(outputFS, cacheDir);
+    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
+        return new (_cache().FSCache)(outputFS, cacheDir);
+      }
     }
     return new (_cache().LMDBLiteCache)(cacheDir);
-  }();
+  }
+  let cache = createCache();
   let mode = initialOptions.mode ?? 'development';
   let shouldOptimize = (initialOptions === null || initialOptions === void 0 || (_initialOptions$defau = initialOptions.defaultTargetOptions) === null || _initialOptions$defau === void 0 ? void 0 : _initialOptions$defau.shouldOptimize) ?? mode === 'production';
   let publicUrl = (initialOptions === null || initialOptions === void 0 || (_initialOptions$defau2 = initialOptions.defaultTargetOptions) === null || _initialOptions$defau2 === void 0 ? void 0 : _initialOptions$defau2.publicUrl) ?? '/';

package/lib/worker.js

@@ -172,7 +172,24 @@ async function childInit() {
   await (_rust().init === null || _rust().init === void 0 ? void 0 : (0, _rust().init)());
 }
 const PKG_RE = /node_modules[/\\]((?:@[^/\\]+[/\\][^/\\]+)|[^/\\]+)(?!.*[/\\]node_modules[/\\])/;
-function invalidateRequireCache() {
+function invalidateRequireCache(workerApi, file) {
+  if (process.env.ATLASPACK_BUILD_ENV === 'test') {
+    // Delete this module and all children in the same node_modules folder
+    let module = require.cache[file];
+    if (module) {
+      var _file$match;
+      delete require.cache[file];
+      let pkg = (_file$match = file.match(PKG_RE)) === null || _file$match === void 0 ? void 0 : _file$match[1];
+      for (let child of module.children) {
+        var _child$id$match;
+        if (pkg === ((_child$id$match = child.id.match(PKG_RE)) === null || _child$id$match === void 0 ? void 0 : _child$id$match[1])) {
+          invalidateRequireCache(workerApi, child.id);
+        }
+      }
+    }
+    atlaspackConfigCache.clear();
+    return;
+  }
   throw new Error('invalidateRequireCache is only for tests');
 }