@atlaspack/bundler-default 2.14.5-canary.2 → 2.14.5-canary.200

package/lib/idealGraph.js

@@ -12,6 +12,13 @@ function _path() {
   };
   return data;
 }
+function _sortedArrayFunctions() {
+  const data = _interopRequireDefault(require("sorted-array-functions"));
+  _sortedArrayFunctions = function () {
+    return data;
+  };
+  return data;
+}
 function _featureFlags() {
   const data = require("@atlaspack/feature-flags");
   _featureFlags = function () {
@@ -47,8 +54,11 @@ function _nullthrows() {
   };
   return data;
 }
+var _bundleMerge = require("./bundleMerge");
+var _stats = require("./stats");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /* BundleRoot - An asset that is the main entry of a Bundle. */
+
 const dependencyPriorityEdges = {
   sync: 1,
   parallel: 2,
@@ -64,12 +74,19 @@ const idealBundleGraphEdges = exports.idealBundleGraphEdges = Object.freeze({
 // which mutates the assetGraph into the bundleGraph we would
 // expect from default bundler
 
+function isNonRootBundle(bundle, message) {
+  let existingBundle = (0, _nullthrows().default)(bundle, message);
+  (0, _assert().default)(existingBundle !== 'root', "Bundle cannot be 'root'");
+  return existingBundle;
+}
 function createIdealGraph(assetGraph, config, entries, logger) {
+  var _config$sharedBundleM;
   // Asset to the bundle and group it's an entry of
   let bundleRoots = new Map();
   let bundles = new Map();
   let dependencyBundleGraph = new (_graph().ContentGraph)();
   let assetReference = new (_utils().DefaultMap)(() => []);
+  let stats = new _stats.Stats(config.projectRoot);
 
   // A Graph of Bundles and a root node (dummy string), which models only Bundles, and connections to their
   // referencing Bundle. There are no actual BundleGroup nodes, just bundles that take on that role.
@@ -107,15 +124,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
   }
   let assets = [];
   let assetToIndex = new Map();
-  //Manual is a map of the user-given name to the bundle node Id that corresponds to ALL the assets that match any glob in that user-specified array
-  let manualSharedMap = new Map();
-  // May need a map to be able to look up NON- bundle root assets which need special case instructions
-  // Use this when placing assets into bundles, to avoid duplication
-  let manualAssetToBundle = new Map();
-  let {
-    manualAssetToConfig,
-    constantModuleToMSB
-  } = function makeManualAssetToConfigLookup() {
+  function makeManualAssetToConfigLookup() {
     let manualAssetToConfig = new Map();
     let constantModuleToMSB = new (_utils().DefaultMap)(() => []);
     if (config.manualSharedBundles.length === 0) {
@@ -127,6 +136,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
     let parentsToConfig = new (_utils().DefaultMap)(() => []);
     for (let c of config.manualSharedBundles) {
       if (c.root != null) {
+        // @ts-expect-error TS2345
         parentsToConfig.get(_path().default.join(config.projectRoot, c.root)).push(c);
       }
     }
@@ -159,17 +169,16 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       assetGraph.traverse((node, _, actions) => {
         if (node.type === 'asset' && (!Array.isArray(c.types) || c.types.includes(node.value.type))) {
           let projectRelativePath = _path().default.relative(config.projectRoot, node.value.filePath);
-          if (!assetRegexes.some(regex => regex.test(projectRelativePath))) {
-            return;
-          }
 
           // We track all matching MSB's for constant modules as they are never duplicated
           // and need to be assigned to all matching bundles
           if (node.value.meta.isConstantModule === true) {
+            // @ts-expect-error TS2345
             constantModuleToMSB.get(node.value).push(c);
           }
-          manualAssetToConfig.set(node.value, c);
-          return;
+          if (assetRegexes.some(regex => regex.test(projectRelativePath))) {
+            manualAssetToConfig.set(node.value, c);
+          }
         }
         if (node.type === 'dependency' && (node.value.priority === 'lazy' || (0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node.value.priority === 'conditional') && parentAsset) {
           // Don't walk past the bundle group assets
@@ -181,8 +190,23 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       manualAssetToConfig,
       constantModuleToMSB
     };
-  }();
+  }
+
+  //Manual is a map of the user-given name to the bundle node Id that corresponds to ALL the assets that match any glob in that user-specified array
+  let manualSharedMap = new Map();
+  // May need a map to be able to look up NON- bundle root assets which need special case instructions
+  // Use this when placing assets into bundles, to avoid duplication
+  let manualAssetToBundle = new Map();
+  let {
+    manualAssetToConfig,
+    constantModuleToMSB
+  } = makeManualAssetToConfigLookup();
   let manualBundleToInternalizedAsset = new (_utils().DefaultMap)(() => []);
+  let mergeSourceBundleLookup = new Map();
+  let mergeSourceBundleAssets = new Set((_config$sharedBundleM = config.sharedBundleMerge) === null || _config$sharedBundleM === void 0 ? void 0 : _config$sharedBundleM.flatMap(c => {
+    var _c$sourceBundles;
+    return ((_c$sourceBundles = c.sourceBundles) === null || _c$sourceBundles === void 0 ? void 0 : _c$sourceBundles.map(assetMatch => _path().default.join(config.projectRoot, assetMatch))) ?? [];
+  }));
 
   /**
    * Step Create Bundles: Traverse the assetGraph (aka MutableBundleGraph) and create bundles
@@ -190,7 +214,9 @@ function createIdealGraph(assetGraph, config, entries, logger) {
    * adding only that asset to each bundle, not its entire subgraph.
    */
   assetGraph.traverse({
-    enter(node, context, actions) {
+    enter(node, context,
+    // @ts-expect-error TS2304
+    actions) {
       if (node.type === 'asset') {
         if ((context === null || context === void 0 ? void 0 : context.type) === 'dependency' && context !== null && context !== void 0 && context.value.isEntry && !entries.has(node.value)) {
           // Skip whole subtrees of other targets by skipping those entries
@@ -233,15 +259,16 @@ function createIdealGraph(assetGraph, config, entries, logger) {
           manualSharedBundleKey != null && manualSharedMap.has(manualSharedBundleKey)) {
             bundleId = (0, _nullthrows().default)(manualSharedMap.get(manualSharedBundleKey));
           }
-          if (dependency.priority === 'lazy' || (0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node.value.priority === 'conditional' || childAsset.bundleBehavior === 'isolated' // An isolated Dependency, or Bundle must contain all assets it needs to load.
-          ) {
+          if (dependency.priority === 'lazy' || (0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node.value.priority === 'conditional' || childAsset.bundleBehavior === 'isolated' ||
+          // An isolated Dependency, or Bundle must contain all assets it needs to load.
+          childAsset.bundleBehavior === 'inlineIsolated') {
             if (bundleId == null) {
               let firstBundleGroup = (0, _nullthrows().default)(bundleGraph.getNode(stack[0][1]));
               (0, _assert().default)(firstBundleGroup !== 'root');
               bundle = createBundle({
                 asset: childAsset,
                 bundleBehavior: dependency.bundleBehavior ?? childAsset.bundleBehavior,
-                needsStableName: dependency.bundleBehavior === 'inline' || childAsset.bundleBehavior === 'inline' ? false : dependency.isEntry || dependency.needsStableName,
+                needsStableName: dependency.bundleBehavior === 'inline' || childAsset.bundleBehavior === 'inline' || dependency.bundleBehavior === 'inlineIsolated' || childAsset.bundleBehavior === 'inlineIsolated' ? false : dependency.isEntry || dependency.needsStableName,
                 target: firstBundleGroup.target
               });
               bundleId = bundleGraph.addNode(bundle);
@@ -249,6 +276,11 @@ function createIdealGraph(assetGraph, config, entries, logger) {
               bundleRoots.set(childAsset, [bundleId, bundleId]);
               bundleGroupBundleIds.add(bundleId);
               bundleGraph.addEdge(bundleGraphRootNodeId, bundleId);
+              // If this asset is relevant for merging then track it's source
+              // bundle id for later
+              if (mergeSourceBundleAssets.has(childAsset.filePath)) {
+                mergeSourceBundleLookup.set(_path().default.relative(config.projectRoot, childAsset.filePath), bundleId);
+              }
               if (manualSharedObject) {
                 // MSB Step 4: If this was the first instance of a match, mark mainAsset for internalization
                 // since MSBs should not have main entry assets
@@ -260,7 +292,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
               if (
               // If this dependency requests isolated, but the bundle is not,
               // make the bundle isolated for all uses.
-              dependency.bundleBehavior === 'isolated' && bundle.bundleBehavior == null) {
+              (dependency.bundleBehavior === 'isolated' || dependency.bundleBehavior === 'inlineIsolated') && bundle.bundleBehavior == null) {
                 bundle.bundleBehavior = dependency.bundleBehavior;
               }
             }
@@ -270,7 +302,9 @@ function createIdealGraph(assetGraph, config, entries, logger) {
             }), dependencyBundleGraph.addNodeByContentKeyIfNeeded(String(bundleId), {
               value: bundle,
               type: 'bundle'
-            }), dependencyPriorityEdges[dependency.priority]);
+            }),
+            // @ts-expect-error TS7053
+            dependencyPriorityEdges[dependency.priority]);
             if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && dependency.priority === 'conditional') {
               let [referencingBundleRoot, bundleGroupNodeId] = (0, _nullthrows().default)(stack[stack.length - 1]);
               let referencingBundleId = (0, _nullthrows().default)(bundleRoots.get(referencingBundleRoot))[0];
@@ -299,7 +333,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
                 env: childAsset.env,
                 bundleBehavior: dependency.bundleBehavior ?? childAsset.bundleBehavior,
                 target: referencingBundle.target,
-                needsStableName: childAsset.bundleBehavior === 'inline' || dependency.bundleBehavior === 'inline' || dependency.priority === 'parallel' && !dependency.needsStableName ? false : referencingBundle.needsStableName
+                needsStableName: childAsset.bundleBehavior === 'inline' || dependency.bundleBehavior === 'inline' || dependency.bundleBehavior === 'inlineIsolated' || dependency.priority === 'parallel' && !dependency.needsStableName ? false : referencingBundle.needsStableName
               });
               bundleId = bundleGraph.addNode(bundle);
             } else {
@@ -308,7 +342,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
               if (
               // If this dependency requests isolated, but the bundle is not,
               // make the bundle isolated for all uses.
-              dependency.bundleBehavior === 'isolated' && bundle.bundleBehavior == null) {
+              (dependency.bundleBehavior === 'isolated' || dependency.bundleBehavior === 'inlineIsolated') && bundle.bundleBehavior == null) {
                 bundle.bundleBehavior = dependency.bundleBehavior;
               }
             }
@@ -330,13 +364,16 @@ function createIdealGraph(assetGraph, config, entries, logger) {
             }
             assetReference.get(childAsset).push([dependency, bundle]);
           } else {
+            // @ts-expect-error TS2322
             bundleId = null;
           }
           if (manualSharedObject && bundleId != null) {
             // MSB Step 5:  At this point we've either created or found an existing MSB bundle
             // add the asset if it doesn't already have it and set key
 
-            (0, _assert().default)(bundle !== 'root' && bundle != null && bundleId != null);
+            (0, _assert().default)(
+            // @ts-expect-error TS2367
+            bundle !== 'root' && bundle != null && bundleId != null);
             manualAssetToBundle.set(childAsset, bundleId);
             if (!bundle.assets.has(childAsset)) {
               // Add asset to bundle
@@ -357,6 +394,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       }
       return node;
     },
+    // @ts-expect-error TS2322
     exit(node) {
       var _stack;
       if (((_stack = stack[stack.length - 1]) === null || _stack === void 0 ? void 0 : _stack[0]) === node.value) {
@@ -494,7 +532,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
     // not true that a bundle's available assets = all assets of all the bundleGroups
     // it belongs to. It's the intersection of those sets.
     let available;
-    if (bundleRoot.bundleBehavior === 'isolated') {
+    if (bundleRoot.bundleBehavior === 'isolated' || bundleRoot.bundleBehavior === 'inlineIsolated') {
       available = new (_graph().BitSet)(assets.length);
     } else {
       available = (0, _nullthrows().default)(ancestorAssets[nodeId]).clone();
@@ -557,7 +595,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       continue;
     }
     let parentRoots = bundleRootGraph.getNodeIdsConnectedTo(id, _graph().ALL_EDGE_TYPES);
-    let canDelete = getBundleFromBundleRoot(bundleRoot).bundleBehavior !== 'isolated';
+    let canDelete = getBundleFromBundleRoot(bundleRoot).bundleBehavior !== 'isolated' && getBundleFromBundleRoot(bundleRoot).bundleBehavior !== 'inlineIsolated';
     if (parentRoots.length === 0) continue;
     for (let parentId of parentRoots) {
       var _ancestorAssets$paren;
@@ -585,8 +623,11 @@ function createIdealGraph(assetGraph, config, entries, logger) {
   }
   function assignInlineConstants(parentAsset, bundle) {
     for (let inlineConstant of inlineConstantDeps.get(parentAsset)) {
+      // @ts-expect-error TS2345
       if (!bundle.assets.has(inlineConstant)) {
+        // @ts-expect-error TS2345
         bundle.assets.add(inlineConstant);
+        // @ts-expect-error TS18046
         bundle.size += inlineConstant.stats.size;
       }
     }
@@ -622,7 +663,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       let assetId = bundleRootGraph.getNode(nodeId);
       if (assetId == null) return; // deleted
       let a = assets[assetId];
-      if (entries.has(a) || !a.isBundleSplittable || bundleRoots.get(a) && (getBundleFromBundleRoot(a).needsStableName || getBundleFromBundleRoot(a).bundleBehavior === 'isolated')) {
+      if (entries.has(a) || !a.isBundleSplittable || bundleRoots.get(a) && (getBundleFromBundleRoot(a).needsStableName || getBundleFromBundleRoot(a).bundleBehavior === 'isolated' || getBundleFromBundleRoot(a).bundleBehavior === 'inlineIsolated')) {
         // Add asset to non-splittable bundles.
         addAssetToBundleRoot(asset, a);
       } else if (!((_ancestorAssets$nodeI = ancestorAssets[nodeId]) !== null && _ancestorAssets$nodeI !== void 0 && _ancestorAssets$nodeI.has(i))) {
@@ -784,6 +825,8 @@ function createIdealGraph(assetGraph, config, entries, logger) {
     }
   }
   let manualSharedBundleIds = new Set([...manualSharedMap.values()]);
+  let modifiedSourceBundles = new Set();
+
   // Step split manual shared bundles for those that have the "split" property set
   let remainderMap = new (_utils().DefaultMap)(() => []);
   for (let id of manualSharedMap.values()) {
@@ -800,8 +843,9 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       if (modNum != null) {
         for (let a of [...manualBundle.assets]) {
           let numRep = getBigIntFromContentKey(a.id);
-          // $FlowFixMe Flow doesn't know about BigInt
           let r = Number(numRep % BigInt(modNum));
+
+          // @ts-expect-error TS2345
           remainderMap.get(r).push(a);
         }
         for (let i = 1; i < [...remainderMap.keys()].length; i++) {
@@ -823,8 +867,10 @@ function createIdealGraph(assetGraph, config, entries, logger) {
           }
           for (let sp of remainderMap.get(i)) {
             bundle.assets.add(sp);
+            // @ts-expect-error TS2339
             bundle.size += sp.stats.size;
             manualBundle.assets.delete(sp);
+            // @ts-expect-error TS2339
             manualBundle.size -= sp.stats.size;
           }
         }
@@ -837,16 +883,81 @@ function createIdealGraph(assetGraph, config, entries, logger) {
   // match multiple MSB's
   for (let [asset, msbs] of constantModuleToMSB.entries()) {
     for (let manualSharedObject of msbs) {
+      // @ts-expect-error TS2339
       let bundleId = manualSharedMap.get(manualSharedObject.name + ',js');
       if (bundleId == null) continue;
       let bundle = (0, _nullthrows().default)(bundleGraph.getNode(bundleId));
       (0, _assert().default)(bundle != null && bundle !== 'root', 'We tried to use the root incorrectly');
+
+      // @ts-expect-error TS2345
       if (!bundle.assets.has(asset)) {
+        // @ts-expect-error TS2345
         bundle.assets.add(asset);
+        // @ts-expect-error TS18046
         bundle.size += asset.stats.size;
       }
     }
   }
+  if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+    // Merge webpack chunk name bundles
+    let chunkNameBundles = new (_utils().DefaultMap)(() => new Set());
+    for (let [nodeId, node] of dependencyBundleGraph.nodes.entries()) {
+      var _bundleNode$value$mai;
+      // meta.chunkName is set by the Rust transformer, so we just need to find
+      // bundles that have a chunkName set.
+      if (!node || node.type !== 'dependency' || typeof node.value.meta.chunkName !== 'string') {
+        continue;
+      }
+      let connectedBundles = dependencyBundleGraph.getNodeIdsConnectedFrom(nodeId, dependencyPriorityEdges[node.value.priority]);
+      if (connectedBundles.length === 0) {
+        continue;
+      }
+      (0, _assert().default)(connectedBundles.length === 1, 'Expected webpackChunkName dependency to be connected to no more than one bundle');
+      let bundleId = connectedBundles[0];
+      let bundleNode = dependencyBundleGraph.getNode(bundleId);
+      (0, _assert().default)(bundleNode != null && bundleNode.type === 'bundle');
+
+      // If a bundle does not have a main entry asset, it's somehow just a
+      // shared bundle, and will be merged/deleted by other means.
+      if (bundleNode.value.mainEntryAsset == null) {
+        continue;
+      }
+      let bundleNodeId = null;
+      let mainEntryAssetId = (_bundleNode$value$mai = bundleNode.value.mainEntryAsset) === null || _bundleNode$value$mai === void 0 ? void 0 : _bundleNode$value$mai.id;
+      if (mainEntryAssetId != null) {
+        bundleNodeId = bundles.get(mainEntryAssetId);
+      }
+      if (bundleNodeId == null) {
+        continue;
+      }
+      chunkNameBundles.get(node.value.meta.chunkName)
+      // DependencyBundleGraph uses content keys as node ids, so we can use that
+      // to get the bundle id.
+      .add(bundleNodeId);
+    }
+    for (let [chunkName, bundleIds] of chunkNameBundles.entries()) {
+      // The `[request]` placeholder is not yet supported
+      if (bundleIds.size <= 1 || typeof chunkName === 'string' && chunkName.includes('[request]')) {
+        continue; // Nothing to merge
+      }
+
+      // Merge all bundles with the same chunk name into the first one.
+      let [firstBundleId, ...rest] = Array.from(bundleIds);
+      for (let bundleId of rest) {
+        mergeBundles(firstBundleId, bundleId, 'webpack-chunk-name');
+      }
+    }
+  }
+
+  // Step merge async bundles that meet the configured params
+  if (config.asyncBundleMerge) {
+    mergeAsyncBundles(config.asyncBundleMerge);
+  }
+
+  // Step merge shared bundles that meet the configured params
+  if (config.sharedBundleMerge && config.sharedBundleMerge.length > 0) {
+    mergeSharedBundles(config.sharedBundleMerge);
+  }
 
   // Step Merge Share Bundles: Merge any shared bundles under the minimum bundle size back into
   // their source bundles, and remove the bundle.
@@ -857,9 +968,9 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       removeBundle(bundleGraph, bundleNodeId, assetReference);
     }
   }
-  let modifiedSourceBundles = new Set();
 
   // Step Remove Shared Bundles: Remove shared bundles from bundle groups that hit the parallel request limit.
+
   if (config.disableSharedBundles === false) {
     for (let bundleGroupId of bundleGraph.getNodeIdsConnectedFrom(rootNodeId)) {
       // Find shared bundles in this bundle group.
@@ -872,7 +983,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       let numBundlesContributingToPRL = bundleIdsInGroup.reduce((count, b) => {
         let bundle = (0, _nullthrows().default)(bundleGraph.getNode(b));
         (0, _assert().default)(bundle !== 'root');
-        return count + (bundle.bundleBehavior !== 'inline');
+        return count + Number(bundle.bundleBehavior !== 'inline' && bundle.bundleBehavior !== 'inlineIsolated');
       }, 0);
       if (numBundlesContributingToPRL > config.maxParallelRequests) {
         let sharedBundleIdsInBundleGroup = bundleIdsInGroup.filter(b => {
@@ -901,7 +1012,9 @@ function createIdealGraph(assetGraph, config, entries, logger) {
         // Remove bundles until the bundle group is within the parallel request limit.
         while (sharedBundlesInGroup.length > 0 && numBundlesContributingToPRL > config.maxParallelRequests) {
           let bundleTuple = sharedBundlesInGroup.pop();
+          // @ts-expect-error TS18048
           let bundleToRemove = bundleTuple.bundle;
+          // @ts-expect-error TS18048
           let bundleIdToRemove = bundleTuple.id;
           //TODO add integration test where bundles in bunlde group > max parallel request limit & only remove a couple shared bundles
           // but total # bundles still exceeds limit due to non shared bundles
@@ -944,10 +1057,281 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       }
     }
   }
+  function mergeBundles(bundleToKeepId, bundleToRemoveId, reason) {
+    stats.trackMerge(bundleToKeepId, bundleToRemoveId, reason);
+    let bundleToKeep = isNonRootBundle(bundleGraph.getNode(bundleToKeepId), `Bundle ${bundleToKeepId} not found`);
+    let bundleToRemove = isNonRootBundle(bundleGraph.getNode(bundleToRemoveId), `Bundle ${bundleToRemoveId} not found`);
+    modifiedSourceBundles.add(bundleToKeep);
+    for (let asset of bundleToRemove.assets) {
+      bundleToKeep.assets.add(asset);
+      bundleToKeep.size += asset.stats.size;
+      let newAssetReference = assetReference.get(asset).map(([dep, bundle]) => bundle === bundleToRemove ? [dep, bundleToKeep] : [dep, bundle]);
+
+      // @ts-expect-error TS2345
+      assetReference.set(asset, newAssetReference);
+    }
+
+    // Merge any internalized assets
+    if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+      if (bundleToKeep.internalizedAssets != null) {
+        if (bundleToRemove.internalizedAssets != null) {
+          bundleToKeep.internalizedAssets.intersect(bundleToRemove.internalizedAssets);
+        } else {
+          bundleToKeep.internalizedAssets.clear();
+        }
+      }
+    } else {
+      (0, _assert().default)(bundleToKeep.internalizedAssets && bundleToRemove.internalizedAssets, 'All shared bundles should have internalized assets');
+      bundleToKeep.internalizedAssets.union(bundleToRemove.internalizedAssets);
+    }
+
+    // Merge and clean up source bundles
+    for (let sourceBundleId of bundleToRemove.sourceBundles) {
+      if (bundleToKeep.sourceBundles.has(sourceBundleId)) {
+        continue;
+      }
+      if (sourceBundleId !== bundleToKeepId) {
+        bundleToKeep.sourceBundles.add(sourceBundleId);
+        bundleGraph.addEdge(sourceBundleId, bundleToKeepId);
+      }
+    }
+    if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+      bundleToKeep.sourceBundles.delete(bundleToRemoveId);
+      for (let bundle of bundleGraph.getNodeIdsConnectedFrom(bundleToRemoveId)) {
+        let bundleNode = (0, _nullthrows().default)(bundleGraph.getNode(bundle));
+        if (bundleNode === 'root') {
+          continue;
+        }
+
+        // If the bundle is a source bundle, add it to the bundle to keep
+        if (bundleNode.sourceBundles.has(bundleToRemoveId)) {
+          bundleNode.sourceBundles.delete(bundleToRemoveId);
+          if (bundle !== bundleToKeepId) {
+            bundleNode.sourceBundles.add(bundleToKeepId);
+            bundleGraph.addEdge(bundleToKeepId, bundle);
+          }
+        }
+      }
+
+      // Merge bundle roots
+      for (let bundleRoot of bundleToRemove.bundleRoots) {
+        bundleToKeep.bundleRoots.add(bundleRoot);
+      }
+      if (bundleToRemove.mainEntryAsset != null) {
+        (0, _assert().default)(bundleToKeep.mainEntryAsset != null);
+
+        // Merge the bundles in bundle group
+        let bundlesInRemoveBundleGroup = getBundlesForBundleGroup(bundleToRemoveId);
+        let removedBundleSharedBundles = new Set();
+        for (let bundleIdInGroup of bundlesInRemoveBundleGroup) {
+          if (bundleIdInGroup === bundleToRemoveId) {
+            continue;
+          }
+          bundleGraph.addEdge(bundleToKeepId, bundleIdInGroup);
+          removedBundleSharedBundles.add(bundleIdInGroup);
+        }
+        if ((0, _featureFlags().getFeatureFlag)('removeRedundantSharedBundles')) {
+          // Merge any shared bundles that now have the same source bundles due to
+          // the current bundle merge
+          let sharedBundles = new (_utils().DefaultMap)(() => []);
+          for (let bundleId of removedBundleSharedBundles) {
+            let bundleNode = (0, _nullthrows().default)(bundleGraph.getNode(bundleId));
+            (0, _assert().default)(bundleNode !== 'root');
+            if (bundleNode.mainEntryAsset != null || bundleNode.manualSharedBundle != null) {
+              continue;
+            }
+            let key = Array.from(bundleNode.sourceBundles).filter(sourceBundle => sourceBundle !== bundleToRemoveId).sort().join(',') + '.' + bundleNode.type;
+            sharedBundles.get(key).push(bundleId);
+          }
+          for (let sharedBundlesToMerge of sharedBundles.values()) {
+            if (sharedBundlesToMerge.length > 1) {
+              let [firstBundleId, ...rest] = sharedBundlesToMerge;
+              for (let bundleId of rest) {
+                mergeBundles(firstBundleId, bundleId, 'redundant-shared');
+              }
+            }
+          }
+        }
+
+        // Remove old bundle group
+        bundleGroupBundleIds.delete(bundleToRemoveId);
+
+        // Clean up bundle roots
+        let bundleRootToRemoveNodeId = (0, _nullthrows().default)(assetToBundleRootNodeId.get((0, _nullthrows().default)(bundleToRemove.mainEntryAsset)));
+        let bundleRootToKeepNodeId = (0, _nullthrows().default)(assetToBundleRootNodeId.get((0, _nullthrows().default)(bundleToKeep.mainEntryAsset)));
+        for (let nodeId of bundleRootGraph.getNodeIdsConnectedTo(bundleRootToRemoveNodeId)) {
+          bundleRootGraph.addEdge(nodeId, bundleRootToKeepNodeId);
+          bundleRootGraph.removeEdge(nodeId, bundleRootToRemoveNodeId);
+        }
+        for (let nodeId of bundleRootGraph.getNodeIdsConnectedFrom(bundleRootToRemoveNodeId)) {
+          bundleRootGraph.addEdge(bundleRootToKeepNodeId, nodeId);
+          bundleRootGraph.removeEdge(bundleRootToRemoveNodeId, nodeId);
+        }
+        bundleRoots.set((0, _nullthrows().default)(bundleToRemove.mainEntryAsset), [bundleToKeepId, bundleToKeepId]);
+
+        // Merge dependency bundle graph
+        for (let dependencyNodeId of dependencyBundleGraph.getNodeIdsConnectedTo(dependencyBundleGraph.getNodeIdByContentKey(String(bundleToRemoveId)), _graph().ALL_EDGE_TYPES)) {
+          let dependencyNode = (0, _nullthrows().default)(dependencyBundleGraph.getNode(dependencyNodeId));
+          (0, _assert().default)(dependencyNode.type === 'dependency');
+
+          // Add dependency to the bundle to keep
+          dependencyBundleGraph.addEdge(dependencyNodeId, dependencyBundleGraph.getNodeIdByContentKey(String(bundleToKeepId)), dependencyPriorityEdges[dependencyNode.value.priority]);
+          // Remove dependency from the bundle to remove
+          dependencyBundleGraph.removeEdge(dependencyNodeId, dependencyBundleGraph.getNodeIdByContentKey(String(bundleToRemoveId)), dependencyPriorityEdges[dependencyNode.value.priority]);
+        }
+      }
+    }
+    bundleGraph.removeNode(bundleToRemoveId);
+  }
+  function mergeSharedBundles(mergeConfig) {
+    // Find all shared bundles
+    let sharedBundles = new Set();
+    bundleGraph.traverse(nodeId => {
+      let bundle = bundleGraph.getNode(nodeId);
+      if (!bundle) {
+        throw new Error(`Unable to find bundle ${nodeId} in bundle graph`);
+      }
+      if (bundle === 'root') {
+        return;
+      }
+
+      // Only consider JS shared bundles and non-reused bundles.
+      // These count potentially be considered for merging in future but they're
+      // more complicated to merge
+      if (bundle.sourceBundles.size > 0 && bundle.manualSharedBundle == null && !bundle.mainEntryAsset && bundle.type === 'js') {
+        sharedBundles.add(nodeId);
+      }
+    });
+    let clusters = (0, _bundleMerge.findMergeCandidates)(bundleGraph, Array.from(sharedBundles), mergeConfig.map(config => {
+      var _config$sourceBundles;
+      return {
+        ...config,
+        sourceBundles: (_config$sourceBundles = config.sourceBundles) === null || _config$sourceBundles === void 0 ? void 0 : _config$sourceBundles.map(assetMatch => {
+          let sourceBundleNodeId = mergeSourceBundleLookup.get(assetMatch);
+          if (sourceBundleNodeId == null) {
+            throw new Error(`Source bundle ${assetMatch} not found in merge source bundle lookup`);
+          }
+          return sourceBundleNodeId;
+        })
+      };
+    }));
+    let mergedBundles = new Set();
+    for (let cluster of clusters) {
+      let [mergeTarget, ...rest] = cluster;
+      for (let bundleIdToMerge of rest) {
+        mergeBundles(mergeTarget, bundleIdToMerge, 'shared-merge');
+      }
+      mergedBundles.add(mergeTarget);
+    }
+    if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
+      return mergedBundles;
+    }
+  }
+  function mergeAsyncBundles({
+    bundleSize,
+    maxOverfetchSize,
+    ignore
+  }) {
+    let mergeCandidates = [];
+    let ignoreRegexes = (ignore === null || ignore === void 0 ? void 0 : ignore.map(glob => (0, _utils().globToRegex)(glob))) ?? [];
+    let isIgnored = bundle => {
+      if (!bundle.mainEntryAsset) {
+        return false;
+      }
+      let mainEntryFilePath = _path().default.relative(config.projectRoot, (0, _nullthrows().default)(bundle.mainEntryAsset).filePath);
+      return ignoreRegexes.some(regex => regex.test(mainEntryFilePath));
+    };
+    for (let [_bundleRootAsset, [bundleRootBundleId]] of bundleRoots) {
+      let bundleRootBundle = (0, _nullthrows().default)(bundleGraph.getNode(bundleRootBundleId));
+      (0, _assert().default)(bundleRootBundle !== 'root');
+      if (bundleRootBundle.type === 'js' && bundleRootBundle.bundleBehavior !== 'inline' && bundleRootBundle.bundleBehavior !== 'inlineIsolated' && bundleRootBundle.size <= bundleSize && !isIgnored(bundleRootBundle)) {
+        mergeCandidates.push(bundleRootBundleId);
+      }
+    }
+    let candidates = [];
+    for (let i = 0; i < mergeCandidates.length; i++) {
+      for (let j = i + 1; j < mergeCandidates.length; j++) {
+        let a = mergeCandidates[i];
+        let b = mergeCandidates[j];
+        if (a === b) continue; // Skip self-comparison
+
+        candidates.push(scoreAsyncMerge(a, b, maxOverfetchSize));
+      }
+    }
+    let sortByScore = (a, b) => {
+      let diff = a.score - b.score;
+      if (diff > 0) {
+        return 1;
+      } else if (diff < 0) {
+        return -1;
+      }
+      return 0;
+    };
+    candidates = candidates.filter(({
+      overfetchSize,
+      score
+    }) => overfetchSize <= maxOverfetchSize && score > 0).sort(sortByScore);
+
+    // Tracks the bundles that have been merged
+    let merged = new Set();
+    // Tracks the deleted bundles to the bundle they were merged into.
+    let mergeRemap = new Map();
+    // Tracks the bundles that have been rescored and added back into the
+    // candidates.
+    let rescored = new (_utils().DefaultMap)(() => new Set());
+    do {
+      let [a, b] = (0, _nullthrows().default)(candidates.pop()).bundleIds;
+      if (bundleGraph.hasNode(a) && bundleGraph.hasNode(b) && (!merged.has(a) && !merged.has(b) || rescored.get(a).has(b))) {
+        mergeRemap.set(b, a);
+        merged.add(a);
+        rescored.get(a).clear();
+        mergeBundles(a, b, 'async-merge');
+        continue;
+      }
+
+      // One or both of the bundles have been previously merged, so we'll
+      // rescore and add the result back into the list of candidates.
+      let getMergedBundleId = bundleId => {
+        let seen = new Set();
+        while (!bundleGraph.hasNode(bundleId) && !seen.has(bundleId)) {
+          seen.add(bundleId);
+          bundleId = (0, _nullthrows().default)(mergeRemap.get(bundleId));
+        }
+        if (!bundleGraph.hasNode(bundleId)) {
+          return;
+        }
+        return bundleId;
+      };
+
+      // Map a and b to their merged bundle ids if they've already been merged
+      let currentA = getMergedBundleId(a);
+      let currentB = getMergedBundleId(b);
+      if (!currentA || !currentB ||
+      // Bundles are already merged
+      currentA === currentB) {
+        // This combiniation is not valid, so we skip it.
+        continue;
+      }
+      let candidate = scoreAsyncMerge(currentA, currentB, maxOverfetchSize);
+      if (candidate.overfetchSize <= maxOverfetchSize && candidate.score > 0) {
+        _sortedArrayFunctions().default.add(candidates, candidate, sortByScore);
+        rescored.get(currentA).add(currentB);
+      }
+    } while (candidates.length > 0);
+  }
+  function getBundle(bundleId) {
+    let bundle = bundleGraph.getNode(bundleId);
+    if (bundle === 'root') {
+      throw new Error(`Cannot access root bundle`);
+    }
+    if (bundle == null) {
+      throw new Error(`Bundle ${bundleId} not found in bundle graph`);
+    }
+    return bundle;
+  }
   function getBigIntFromContentKey(contentKey) {
     let b = Buffer.alloc(64);
     b.write(contentKey);
-    // $FlowFixMe Flow doesn't have BigInt types in this version
     return b.readBigInt64BE();
   }
   // Fix asset order in source bundles as they are likely now incorrect after shared bundle deletion
@@ -977,6 +1361,53 @@ function createIdealGraph(assetGraph, config, entries, logger) {
     }, bundleGroupId);
     return bundlesInABundleGroup;
   }
+  function scoreAsyncMerge(bundleAId, bundleBId, maxOverfetchSize) {
+    let bundleGroupA = new Set(getBundlesForBundleGroup(bundleAId));
+    let bundleGroupB = new Set(getBundlesForBundleGroup(bundleBId));
+    let overlapSize = 0;
+    let overfetchSize = 0;
+    for (let bundleId of new Set([...bundleGroupA, ...bundleGroupB])) {
+      let bundle = getBundle(bundleId);
+      if (bundleGroupA.has(bundleId) && bundleGroupB.has(bundleId)) {
+        overlapSize += bundle.size;
+      } else {
+        overfetchSize += bundle.size;
+      }
+    }
+    let overlapPercent = overlapSize / (overfetchSize + overlapSize);
+    let bundleAParents = getBundleParents(bundleAId);
+    let bundleBParents = getBundleParents(bundleBId);
+    let sharedParentOverlap = 0;
+    let sharedParentMismatch = 0;
+    for (let bundleId of new Set([...bundleAParents, ...bundleBParents])) {
+      if (bundleAParents.has(bundleId) && bundleBParents.has(bundleId)) {
+        sharedParentOverlap++;
+      } else {
+        sharedParentMismatch++;
+      }
+    }
+    let overfetchScore = overfetchSize / maxOverfetchSize;
+    let sharedParentPercent = sharedParentOverlap / (sharedParentOverlap + sharedParentMismatch);
+    let score = sharedParentPercent + overlapPercent + overfetchScore;
+    return {
+      overfetchSize,
+      score,
+      bundleIds: [bundleAId, bundleBId]
+    };
+  }
+  function getBundleParents(bundleId) {
+    let parents = new Set();
+    let {
+      bundleRoots
+    } = getBundle(bundleId);
+    for (let bundleRoot of bundleRoots) {
+      let bundleRootNodeId = (0, _nullthrows().default)(assetToBundleRootNodeId.get(bundleRoot));
+      for (let parentId of bundleRootGraph.getNodeIdsConnectedTo(bundleRootNodeId, _graph().ALL_EDGE_TYPES)) {
+        parents.add(parentId);
+      }
+    }
+    return parents;
+  }
   function getBundleFromBundleRoot(bundleRoot) {
     let bundle = bundleGraph.getNode((0, _nullthrows().default)(bundleRoots.get(bundleRoot))[0]);
     (0, _assert().default)(bundle !== 'root' && bundle != null);
@@ -1026,6 +1457,11 @@ function createIdealGraph(assetGraph, config, entries, logger) {
     }
     bundleGraph.removeNode(bundleId);
   }
+  stats.report(bundleId => {
+    let bundle = bundleGraph.getNode(bundleId);
+    (0, _assert().default)(bundle !== 'root');
+    return bundle;
+  });
   return {
     assets,
     bundleGraph,
@@ -1042,6 +1478,7 @@ function createBundle(opts) {
       bundleBehavior: opts.bundleBehavior,
       env: (0, _nullthrows().default)(opts.env),
       mainEntryAsset: null,
+      bundleRoots: new Set(),
       manualSharedBundle: opts.manualSharedBundle,
       needsStableName: Boolean(opts.needsStableName),
       size: 0,
@@ -1057,6 +1494,7 @@ function createBundle(opts) {
     bundleBehavior: opts.bundleBehavior ?? asset.bundleBehavior,
     env: opts.env ?? asset.env,
     mainEntryAsset: asset,
+    bundleRoots: new Set([asset]),
     manualSharedBundle: opts.manualSharedBundle,
     needsStableName: Boolean(opts.needsStableName),
     size: asset.stats.size,