@atlaspack/bundler-default 2.14.5-canary.14 → 2.14.5-canary.141

package/src/{idealGraph.js → idealGraph.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import path from 'path';
 
 import {getFeatureFlag} from '@atlaspack/feature-flags';
@@ -8,7 +6,7 @@ import {
   BitSet,
   ContentGraph,
   Graph,
-  type NodeId,
+  NodeId,
 } from '@atlaspack/graph';
 import type {
   Asset,
@@ -23,37 +21,38 @@ import {DefaultMap, globToRegex} from '@atlaspack/utils';
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
 
-import {findMergeCandidates} from './bundleMerge';
-import type {ResolvedBundlerConfig} from './bundlerConfig';
+import {findMergeCandidates, MergeGroup} from './bundleMerge';
+import type {ResolvedBundlerConfig, MergeCandidates} from './bundlerConfig';
 
 /* BundleRoot - An asset that is the main entry of a Bundle. */
 type BundleRoot = Asset;
 
-export type Bundle = {|
-  uniqueKey: ?string,
-  assets: Set<Asset>,
-  internalizedAssets?: BitSet,
-  bundleBehavior?: ?BundleBehavior,
-  needsStableName: boolean,
-  mainEntryAsset: ?Asset,
-  size: number,
-  sourceBundles: Set<NodeId>,
-  target: Target,
-  env: Environment,
-  type: string,
-  manualSharedBundle: ?string, // for naming purposes
-|};
+export type Bundle = {
+  uniqueKey: string | null | undefined;
+  assets: Set<Asset>;
+  internalizedAssets?: BitSet;
+  bundleBehavior?: BundleBehavior | null | undefined;
+  needsStableName: boolean;
+  mainEntryAsset: Asset | null | undefined;
+  bundleRoots: Set<Asset>;
+  size: number;
+  sourceBundles: Set<NodeId>;
+  target: Target;
+  env: Environment;
+  type: string;
+  manualSharedBundle: string | null | undefined; // for naming purposes;
+};
 
 export type DependencyBundleGraph = ContentGraph<
-  | {|
-      value: Bundle,
-      type: 'bundle',
-    |}
-  | {|
-      value: Dependency,
-      type: 'dependency',
-    |},
-  number,
+  | {
+      value: Bundle;
+      type: 'bundle';
+    }
+  | {
+      value: Dependency;
+      type: 'dependency';
+    },
+  number
 >;
 
 const dependencyPriorityEdges = {
@@ -61,7 +60,7 @@ const dependencyPriorityEdges = {
   parallel: 2,
   lazy: 3,
   conditional: 4,
-};
+} as const;
 
 export const idealBundleGraphEdges = Object.freeze({
   default: 1,
@@ -70,20 +69,30 @@ export const idealBundleGraphEdges = Object.freeze({
 
 export type IdealBundleGraph = Graph<
   Bundle | 'root',
-  $Values<typeof idealBundleGraphEdges>,
+  (typeof idealBundleGraphEdges)[keyof typeof idealBundleGraphEdges]
 >;
 
 // IdealGraph is the structure we will pass to decorate,
 // which mutates the assetGraph into the bundleGraph we would
 // expect from default bundler
-export type IdealGraph = {|
-  assetReference: DefaultMap<Asset, Array<[Dependency, Bundle]>>,
-  assets: Array<Asset>,
-  bundleGraph: IdealBundleGraph,
-  bundleGroupBundleIds: Set<NodeId>,
-  dependencyBundleGraph: DependencyBundleGraph,
-  manualAssetToBundle: Map<Asset, NodeId>,
-|};
+export type IdealGraph = {
+  assetReference: DefaultMap<Asset, Array<[Dependency, Bundle]>>;
+  assets: Array<Asset>;
+  bundleGraph: IdealBundleGraph;
+  bundleGroupBundleIds: Set<NodeId>;
+  dependencyBundleGraph: DependencyBundleGraph;
+  manualAssetToBundle: Map<Asset, NodeId>;
+};
+
+function isNonRootBundle(
+  bundle?: Bundle | 'root' | null,
+  message?: string,
+): Bundle {
+  let existingBundle = nullthrows(bundle, message);
+  invariant(existingBundle !== 'root', "Bundle cannot be 'root'");
+
+  return existingBundle;
+}
 
 export function createIdealGraph(
   assetGraph: MutableBundleGraph,
@@ -97,7 +106,7 @@ export function createIdealGraph(
   let dependencyBundleGraph: DependencyBundleGraph = new ContentGraph();
   let assetReference: DefaultMap<
     Asset,
-    Array<[Dependency, Bundle]>,
+    Array<[Dependency, Bundle]>
   > = new DefaultMap(() => []);
 
   // A Graph of Bundles and a root node (dummy string), which models only Bundles, and connections to their
@@ -111,8 +120,9 @@ export function createIdealGraph(
   };
   // Graph that models bundleRoots, with parallel & async deps only to inform reachability
   let bundleRootGraph: Graph<
-    number, // asset index
-    $Values<typeof bundleRootEdgeTypes>,
+    // asset index
+    number,
+    (typeof bundleRootEdgeTypes)[keyof typeof bundleRootEdgeTypes]
   > = new Graph();
   let assetToBundleRootNodeId = new Map<BundleRoot, number>();
 
@@ -146,7 +156,7 @@ export function createIdealGraph(
     bundleGroupBundleIds.add(nodeId);
   }
 
-  let assets = [];
+  let assets: Array<Asset> = [];
   let assetToIndex = new Map<Asset, number>();
 
   function makeManualAssetToConfigLookup() {
@@ -161,6 +171,7 @@ export function createIdealGraph(
 
     for (let c of config.manualSharedBundles) {
       if (c.root != null) {
+        // @ts-expect-error TS2345
         parentsToConfig.get(path.join(config.projectRoot, c.root)).push(c);
       }
     }
@@ -204,17 +215,17 @@ export function createIdealGraph(
             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 (
@@ -242,9 +253,19 @@ export function createIdealGraph(
     makeManualAssetToConfigLookup();
   let manualBundleToInternalizedAsset: DefaultMap<
     NodeId,
-    Array<Asset>,
+    Array<Asset>
   > = new DefaultMap(() => []);
 
+  let mergeSourceBundleLookup = new Map<string, NodeId>();
+  let mergeSourceBundleAssets = new Set(
+    config.sharedBundleMerge?.flatMap(
+      (c) =>
+        c.sourceBundles?.map((assetMatch: string) =>
+          path.join(config.projectRoot, assetMatch),
+        ) ?? [],
+    ),
+  );
+
   /**
    * Step Create Bundles: Traverse the assetGraph (aka MutableBundleGraph) and create bundles
    * for asset type changes, parallel, inline, and async or lazy dependencies,
@@ -252,7 +273,27 @@ export function createIdealGraph(
    */
   assetGraph.traverse(
     {
-      enter(node, context, actions) {
+      enter(
+        node: // @ts-expect-error TS2304
+        | BundleGraphTraversable
+          | {
+              readonly type: 'dependency';
+              value: Dependency;
+            },
+        context:
+          | {
+              readonly type: 'asset';
+              value: Asset;
+            }
+          | null
+          | undefined
+          | {
+              readonly type: 'dependency';
+              value: Dependency;
+            },
+        // @ts-expect-error TS2304
+        actions: TraversalActions,
+      ) {
         if (node.type === 'asset') {
           if (
             context?.type === 'dependency' &&
@@ -335,6 +376,14 @@ export function createIdealGraph(
                 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.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
@@ -371,6 +420,7 @@ export function createIdealGraph(
                     type: 'bundle',
                   },
                 ),
+                // @ts-expect-error TS7053
                 dependencyPriorityEdges[dependency.priority],
               );
 
@@ -482,6 +532,7 @@ export function createIdealGraph(
 
               assetReference.get(childAsset).push([dependency, bundle]);
             } else {
+              // @ts-expect-error TS2322
               bundleId = null;
             }
             if (manualSharedObject && bundleId != null) {
@@ -489,6 +540,7 @@ export function createIdealGraph(
               // add the asset if it doesn't already have it and set key
 
               invariant(
+                // @ts-expect-error TS2367
                 bundle !== 'root' && bundle != null && bundleId != null,
               );
 
@@ -515,7 +567,8 @@ export function createIdealGraph(
         }
         return node;
       },
-      exit(node) {
+      // @ts-expect-error TS2322
+      exit(node: BundleGraphTraversable) {
         if (stack[stack.length - 1]?.[0] === node.value) {
           stack.pop();
         }
@@ -564,20 +617,20 @@ export function createIdealGraph(
 
   // reachableRoots is an array of bit sets for each asset. Each bit set
   // indicates which bundle roots are reachable from that asset synchronously.
-  let reachableRoots = [];
+  let reachableRoots: Array<BitSet> = [];
   for (let i = 0; i < assets.length; i++) {
     reachableRoots.push(new BitSet(bundleRootGraph.nodes.length));
   }
 
   // reachableAssets is the inverse mapping of reachableRoots. For each bundle root,
   // it contains a bit set that indicates which assets are reachable from it.
-  let reachableAssets = [];
+  let reachableAssets: Array<BitSet> = [];
 
   // ancestorAssets maps bundle roots to the set of all assets available to it at runtime,
   // including in earlier parallel bundles. These are intersected through all paths to
   // the bundle to ensure that the available assets are always present no matter in which
   // order the bundles are loaded.
-  let ancestorAssets = [];
+  let ancestorAssets: Array<null | BitSet> = [];
 
   let inlineConstantDeps = new DefaultMap(() => new Set());
 
@@ -806,8 +859,11 @@ export function createIdealGraph(
 
   function assignInlineConstants(parentAsset: Asset, bundle: 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;
       }
     }
@@ -867,7 +923,7 @@ export function createIdealGraph(
       let bundle;
       let bundleId;
       let manualSharedBundleKey = manualSharedObject.name + ',' + asset.type;
-      let sourceBundles = [];
+      let sourceBundles: Array<NodeId> = [];
       reachable.forEach((id) => {
         sourceBundles.push(nullthrows(bundleRoots.get(assets[id]))[0]);
       });
@@ -982,7 +1038,7 @@ export function createIdealGraph(
       });
     }
 
-    let reachableArray = [];
+    let reachableArray: Array<Asset> = [];
     reachable.forEach((id) => {
       reachableArray.push(assets[id]);
     });
@@ -1057,6 +1113,8 @@ export function createIdealGraph(
   }
 
   let manualSharedBundleIds = new Set([...manualSharedMap.values()]);
+  let modifiedSourceBundles = new Set<Bundle>();
+
   // Step split manual shared bundles for those that have the "split" property set
   let remainderMap = new DefaultMap(() => []);
   for (let id of manualSharedMap.values()) {
@@ -1075,9 +1133,9 @@ export function createIdealGraph(
       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);
         }
 
@@ -1100,8 +1158,10 @@ export function createIdealGraph(
           }
           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;
           }
         }
@@ -1114,6 +1174,7 @@ export function createIdealGraph(
   // 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 = nullthrows(bundleGraph.getNode(bundleId));
@@ -1122,17 +1183,94 @@ export function createIdealGraph(
         '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 (getFeatureFlag('supportWebpackChunkName')) {
+    // Merge webpack chunk name bundles
+    let chunkNameBundles = new DefaultMap(() => new Set());
+    for (let [nodeId, node] of dependencyBundleGraph.nodes.entries()) {
+      // 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' ||
+        node.value.meta.chunkName == null
+      ) {
+        continue;
+      }
+
+      let connectedBundles = dependencyBundleGraph.getNodeIdsConnectedFrom(
+        nodeId,
+        dependencyPriorityEdges[node.value.priority],
+      );
+
+      if (connectedBundles.length === 0) {
+        continue;
+      }
+
+      invariant(
+        connectedBundles.length === 1,
+        'Expected webpackChunkName dependency to be connected to no more than one bundle',
+      );
+
+      let bundleId = connectedBundles[0];
+      let bundleNode = dependencyBundleGraph.getNode(bundleId);
+      invariant(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.mainEntryAsset?.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) {
+        // @ts-expect-error TS2345
+        mergeBundles(firstBundleId, bundleId);
+      }
+    }
+  }
+
   // Step merge shared bundles that meet the overlap threshold
   // This step is skipped by default as the threshold defaults to 1
-  if (config.sharedBundleMergeThreshold < 1) {
-    mergeOverlapBundles();
+  if (config.sharedBundleMerge && config.sharedBundleMerge.length > 0) {
+    mergeOverlapBundles(config.sharedBundleMerge);
   }
 
   // Step Merge Share Bundles: Merge any shared bundles under the minimum bundle size back into
@@ -1151,7 +1289,6 @@ export function createIdealGraph(
   }
 
   // Step Remove Shared Bundles: Remove shared bundles from bundle groups that hit the parallel request limit.
-  let modifiedSourceBundles = new Set();
 
   if (config.disableSharedBundles === false) {
     for (let bundleGroupId of bundleGraph.getNodeIdsConnectedFrom(rootNodeId)) {
@@ -1165,6 +1302,7 @@ export function createIdealGraph(
       let numBundlesContributingToPRL = bundleIdsInGroup.reduce((count, b) => {
         let bundle = nullthrows(bundleGraph.getNode(b));
         invariant(bundle !== 'root');
+        // @ts-expect-error TS2365
         return count + (bundle.bundleBehavior !== 'inline');
       }, 0);
 
@@ -1200,7 +1338,9 @@ export function createIdealGraph(
           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
@@ -1256,28 +1396,50 @@ export function createIdealGraph(
     }
   }
 
-  function mergeBundles(
-    bundleGraph: IdealBundleGraph,
-    bundleToKeepId: NodeId,
-    bundleToRemoveId: NodeId,
-    assetReference: DefaultMap<Asset, Array<[Dependency, Bundle]>>,
-  ) {
-    let bundleToKeep = nullthrows(bundleGraph.getNode(bundleToKeepId));
-    let bundleToRemove = nullthrows(bundleGraph.getNode(bundleToRemoveId));
-    invariant(bundleToKeep !== 'root' && bundleToRemove !== 'root');
+  function mergeBundles(bundleToKeepId: NodeId, bundleToRemoveId: NodeId) {
+    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]) =>
+        .map(([dep, bundle]: [any, any]) =>
           bundle === bundleToRemove ? [dep, bundleToKeep] : [dep, bundle],
         );
 
+      // @ts-expect-error TS2345
       assetReference.set(asset, newAssetReference);
     }
 
+    // Merge any internalized assets
+    if (getFeatureFlag('supportWebpackChunkName')) {
+      if (bundleToKeep.internalizedAssets != null) {
+        if (bundleToRemove.internalizedAssets != null) {
+          bundleToKeep.internalizedAssets.intersect(
+            bundleToRemove.internalizedAssets,
+          );
+        } else {
+          bundleToKeep.internalizedAssets.clear();
+        }
+      }
+    } else {
+      invariant(
+        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;
@@ -1287,21 +1449,108 @@ export function createIdealGraph(
       bundleGraph.addEdge(sourceBundleId, bundleToKeepId);
     }
 
-    // Merge any internalized assets
-    if (bundleToRemove.internalizedAssets) {
-      if (bundleToKeep.internalizedAssets) {
-        bundleToKeep.internalizedAssets.union(
-          bundleToRemove.internalizedAssets,
+    if (getFeatureFlag('supportWebpackChunkName')) {
+      bundleToKeep.sourceBundles.delete(bundleToRemoveId);
+
+      for (let bundle of bundleGraph.getNodeIdsConnectedFrom(
+        bundleToRemoveId,
+      )) {
+        let bundleNode = nullthrows(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.add(bundleToKeepId);
+          bundleNode.sourceBundles.delete(bundleToRemoveId);
+          bundleGraph.addEdge(bundleToKeepId, bundle);
+        }
+      }
+
+      // Merge bundle roots
+      for (let bundleRoot of bundleToRemove.bundleRoots) {
+        bundleToKeep.bundleRoots.add(bundleRoot);
+      }
+
+      if (bundleToRemove.mainEntryAsset != null) {
+        invariant(bundleToKeep.mainEntryAsset != null);
+
+        // Merge the bundles in bundle group
+        let bundlesInRemoveBundleGroup =
+          getBundlesForBundleGroup(bundleToRemoveId);
+
+        for (let bundleIdInGroup of bundlesInRemoveBundleGroup) {
+          if (bundleIdInGroup === bundleToRemoveId) {
+            continue;
+          }
+          bundleGraph.addEdge(bundleToKeepId, bundleIdInGroup);
+        }
+
+        // Remove old bundle group
+        bundleGroupBundleIds.delete(bundleToRemoveId);
+
+        // Clean up bundle roots
+        let bundleRootToRemoveNodeId = nullthrows(
+          assetToBundleRootNodeId.get(
+            nullthrows(bundleToRemove.mainEntryAsset),
+          ),
         );
-      } else {
-        bundleToKeep.internalizedAssets = bundleToRemove.internalizedAssets;
+        let bundleRootToKeepNodeId = nullthrows(
+          assetToBundleRootNodeId.get(nullthrows(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(nullthrows(bundleToRemove.mainEntryAsset), [
+          bundleToKeepId,
+          bundleToKeepId,
+        ]);
+
+        // Merge dependency bundle graph
+        for (let dependencyNodeId of dependencyBundleGraph.getNodeIdsConnectedTo(
+          dependencyBundleGraph.getNodeIdByContentKey(String(bundleToRemoveId)),
+          ALL_EDGE_TYPES,
+        )) {
+          let dependencyNode = nullthrows(
+            dependencyBundleGraph.getNode(dependencyNodeId),
+          );
+          invariant(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 mergeOverlapBundles() {
+  function mergeOverlapBundles(mergeConfig: MergeCandidates) {
     // Find all shared bundles
     let sharedBundles = new Set<NodeId>();
     bundleGraph.traverse((nodeId) => {
@@ -1331,22 +1580,44 @@ export function createIdealGraph(
     let clusters = findMergeCandidates(
       bundleGraph,
       Array.from(sharedBundles),
-      config.sharedBundleMergeThreshold,
+      mergeConfig.map(
+        (config): MergeGroup => ({
+          ...config,
+          sourceBundles: config.sourceBundles?.map((assetMatch: string) => {
+            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(bundleGraph, mergeTarget, bundleIdToMerge, assetReference);
+        mergeBundles(mergeTarget, bundleIdToMerge);
       }
+
+      mergedBundles.add(mergeTarget);
+    }
+
+    if (getFeatureFlag('supportWebpackChunkName')) {
+      return mergedBundles;
     }
   }
 
-  function getBigIntFromContentKey(contentKey) {
+  function getBigIntFromContentKey(contentKey: string) {
     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
@@ -1373,8 +1644,8 @@ export function createIdealGraph(
       bundleRootGraph.removeNode(bundleRootId);
     }
   }
-  function getBundlesForBundleGroup(bundleGroupId) {
-    let bundlesInABundleGroup = [];
+  function getBundlesForBundleGroup(bundleGroupId: NodeId) {
+    let bundlesInABundleGroup: Array<NodeId> = [];
     bundleGraph.traverse((nodeId) => {
       bundlesInABundleGroup.push(nodeId);
     }, bundleGroupId);
@@ -1455,23 +1726,24 @@ export function createIdealGraph(
   };
 }
 
-function createBundle(opts: {|
-  asset?: Asset,
-  bundleBehavior?: ?BundleBehavior,
-  env?: Environment,
-  manualSharedBundle?: ?string,
-  needsStableName?: boolean,
-  sourceBundles?: Set<NodeId>,
-  target: Target,
-  type?: string,
-  uniqueKey?: string,
-|}): Bundle {
+function createBundle(opts: {
+  asset?: Asset;
+  bundleBehavior?: BundleBehavior | null | undefined;
+  env?: Environment;
+  manualSharedBundle?: string | null | undefined;
+  needsStableName?: boolean;
+  sourceBundles?: Set<NodeId>;
+  target: Target;
+  type?: string;
+  uniqueKey?: string;
+}): Bundle {
   if (opts.asset == null) {
     return {
       assets: new Set(),
       bundleBehavior: opts.bundleBehavior,
       env: nullthrows(opts.env),
       mainEntryAsset: null,
+      bundleRoots: new Set(),
       manualSharedBundle: opts.manualSharedBundle,
       needsStableName: Boolean(opts.needsStableName),
       size: 0,
@@ -1488,6 +1760,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,