@atlaspack/bundler-default 2.14.5-canary.5 → 2.14.5-canary.51

package/CHANGELOG.md

@@ -1,5 +1,73 @@
 # @atlaspack/bundler-default
 
+## 2.16.1
+
+### Patch Changes
+
+- Updated dependencies [[`30f6017`](https://github.com/atlassian-labs/atlaspack/commit/30f60175ba4d272c5fc193973c63bc298584775b), [`1ab0a27`](https://github.com/atlassian-labs/atlaspack/commit/1ab0a275aeca40350415e2b03e7440d1dddc6228), [`b8a4ae8`](https://github.com/atlassian-labs/atlaspack/commit/b8a4ae8f83dc0a83d8b145c5f729936ce52080a3)]:
+  - @atlaspack/feature-flags@2.15.1
+  - @atlaspack/rust@3.3.3
+  - @atlaspack/graph@3.4.6
+  - @atlaspack/utils@2.14.8
+  - @atlaspack/plugin@2.14.8
+
+## 2.16.0
+
+### Minor Changes
+
+- [#547](https://github.com/atlassian-labs/atlaspack/pull/547) [`a1773d2`](https://github.com/atlassian-labs/atlaspack/commit/a1773d2a62d0ef7805ac7524621dcabcc1afe929) Thanks [@benjervis](https://github.com/benjervis)! - Add a feature flag for resolving the configuration for `@atlaspack/bundler-default` from CWD, rather than exclusively from the project root.
+
+### Patch Changes
+
+- Updated dependencies [[`a1773d2`](https://github.com/atlassian-labs/atlaspack/commit/a1773d2a62d0ef7805ac7524621dcabcc1afe929), [`556d6ab`](https://github.com/atlassian-labs/atlaspack/commit/556d6ab8ede759fa7f37fcd3f4da336ef1c55e8f)]:
+  - @atlaspack/feature-flags@2.15.0
+  - @atlaspack/rust@3.3.2
+  - @atlaspack/graph@3.4.5
+  - @atlaspack/utils@2.14.7
+  - @atlaspack/plugin@2.14.7
+
+## 2.15.1
+
+### Patch Changes
+
+- Updated dependencies [[`e0f5337`](https://github.com/atlassian-labs/atlaspack/commit/e0f533757bd1019dbd108a04952c87da15286e09)]:
+  - @atlaspack/feature-flags@2.14.4
+  - @atlaspack/rust@3.3.1
+  - @atlaspack/graph@3.4.4
+  - @atlaspack/utils@2.14.6
+  - @atlaspack/plugin@2.14.6
+
+## 2.15.0
+
+### Minor Changes
+
+- [#535](https://github.com/atlassian-labs/atlaspack/pull/535) [`a4bc259`](https://github.com/atlassian-labs/atlaspack/commit/a4bc2590196b6c1e743e4edcb0337e8c4c240ab4) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Add `sharedBundleMergeThreshold` config option
+
+  In apps with lots of dynamic imports, many shared bundles are often removed
+  from the output to prevent an overload in network requests according to the
+  `maxParallelRequests` config. In these cases, setting `sharedBundleMergeThreshold` can
+  merge shared bundles with a high overlap in their source bundles (bundles that share the bundle).
+  This config trades-off potential overfetching to reduce asset duplication.
+
+  The following config would merge shared bundles that have a 75% or higher overlap in source bundles.
+
+  ```json
+  {
+    "@atlaspack/bundler-default": {
+      "sharedBundleMergeThreshold": 0.75
+    }
+  }
+  ```
+
+### Patch Changes
+
+- Updated dependencies [[`11d6f16`](https://github.com/atlassian-labs/atlaspack/commit/11d6f16b6397dee2f217167e5c98b39edb63f7a7), [`e2ba0f6`](https://github.com/atlassian-labs/atlaspack/commit/e2ba0f69702656f3d1ce95ab1454e35062b13b39), [`d2c50c2`](https://github.com/atlassian-labs/atlaspack/commit/d2c50c2c020888b33bb25b8690d9320c2b69e2a6), [`46a90dc`](https://github.com/atlassian-labs/atlaspack/commit/46a90dccd019a26b222c878a92d23acc75dc67c5)]:
+  - @atlaspack/feature-flags@2.14.3
+  - @atlaspack/rust@3.3.0
+  - @atlaspack/graph@3.4.3
+  - @atlaspack/utils@2.14.5
+  - @atlaspack/plugin@2.14.5
+
 ## 2.14.4
 
 ### Patch Changes

package/lib/bundleMerge.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findMergeCandidates = findMergeCandidates;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _graph() {
+  const data = require("@atlaspack/graph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// Returns a decimal showing the proportion source bundles are common to
+// both bundles versus the total number of source bundles.
+function scoreBundleMerge(bundleA, bundleB) {
+  let sharedSourceBundles = 0;
+  let allSourceBundles = new Set([...bundleA.sourceBundles, ...bundleB.sourceBundles]);
+  for (let bundle of bundleB.sourceBundles) {
+    if (bundleA.sourceBundles.has(bundle)) {
+      sharedSourceBundles++;
+    }
+  }
+  return sharedSourceBundles / allSourceBundles.size;
+}
+function getMergeClusters(graph, candidates) {
+  let clusters = [];
+  for (let candidate of candidates) {
+    let cluster = [];
+    graph.traverse(nodeId => {
+      cluster.push((0, _nullthrows().default)(graph.getNode(nodeId)));
+      // Remove node from candidates as it has already been processed
+      candidates.delete(nodeId);
+    }, candidate);
+    clusters.push(cluster);
+  }
+  return clusters;
+}
+function findMergeCandidates(bundleGraph, bundles, threshold) {
+  let graph = new (_graph().ContentGraph)();
+  let seen = new Set();
+  let candidates = new Set();
+
+  // Build graph of clustered merge candidates
+  for (let bundleId of bundles) {
+    let bundle = bundleGraph.getNode(bundleId);
+    (0, _assert().default)(bundle && bundle !== 'root');
+    if (bundle.type !== 'js') {
+      continue;
+    }
+    for (let otherBundleId of bundles) {
+      if (bundleId === otherBundleId) {
+        continue;
+      }
+      let key = [bundleId, otherBundleId].sort().join(':');
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      let otherBundle = bundleGraph.getNode(otherBundleId);
+      (0, _assert().default)(otherBundle && otherBundle !== 'root');
+      let score = scoreBundleMerge(bundle, otherBundle);
+      if (score >= threshold) {
+        let bundleNode = graph.addNodeByContentKeyIfNeeded(bundleId.toString(), bundleId);
+        let otherBundleNode = graph.addNodeByContentKeyIfNeeded(otherBundleId.toString(), otherBundleId);
+
+        // Add edge in both directions
+        graph.addEdge(bundleNode, otherBundleNode);
+        graph.addEdge(otherBundleNode, bundleNode);
+        candidates.add(bundleNode);
+        candidates.add(otherBundleNode);
+      }
+    }
+  }
+  return getMergeClusters(graph, candidates);
+}

package/lib/bundlerConfig.js

@@ -11,6 +11,13 @@ function _diagnostic() {
   };
   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 () {
@@ -53,14 +60,16 @@ const HTTP_OPTIONS = {
     manualSharedBundles: [],
     minBundleSize: 30000,
     maxParallelRequests: 6,
-    disableSharedBundles: false
+    disableSharedBundles: false,
+    sharedBundleMergeThreshold: 1
   },
   '2': {
     minBundles: 1,
     manualSharedBundles: [],
     minBundleSize: 20000,
     maxParallelRequests: 25,
-    disableSharedBundles: false
+    disableSharedBundles: false,
+    sharedBundleMergeThreshold: 1
   }
 };
 const CONFIG_SCHEMA = {
@@ -115,14 +124,25 @@ const CONFIG_SCHEMA = {
     },
     loadConditionalBundlesInParallel: {
       type: 'boolean'
+    },
+    sharedBundleMergeThreshold: {
+      type: 'number'
     }
   },
   additionalProperties: false
 };
 async function loadBundlerConfig(config, options, logger) {
-  let conf = await config.getConfig([], {
-    packageKey: '@atlaspack/bundler-default'
-  });
+  var _conf;
+  let conf;
+  if ((0, _featureFlags().getFeatureFlag)('resolveBundlerConfigFromCwd')) {
+    conf = await config.getConfigFrom(`${process.cwd()}/index`, [], {
+      packageKey: '@atlaspack/bundler-default'
+    });
+  } else {
+    conf = await config.getConfig([], {
+      packageKey: '@atlaspack/bundler-default'
+    });
+  }
   if (!conf) {
     const modDefault = {
       ...HTTP_OPTIONS['2'],
@@ -130,7 +150,7 @@ async function loadBundlerConfig(config, options, logger) {
     };
     return modDefault;
   }
-  (0, _assert().default)((conf === null || conf === void 0 ? void 0 : conf.contents) != null);
+  (0, _assert().default)(((_conf = conf) === null || _conf === void 0 ? void 0 : _conf.contents) != null);
   let modeConfig = resolveModeConfig(conf.contents, options.mode);
 
   // minBundles will be ignored if shared bundles are disabled
@@ -172,6 +192,7 @@ async function loadBundlerConfig(config, options, logger) {
   return {
     minBundles: modeConfig.minBundles ?? defaults.minBundles,
     minBundleSize: modeConfig.minBundleSize ?? defaults.minBundleSize,
+    sharedBundleMergeThreshold: modeConfig.sharedBundleMergeThreshold ?? defaults.sharedBundleMergeThreshold,
     maxParallelRequests: modeConfig.maxParallelRequests ?? defaults.maxParallelRequests,
     projectRoot: options.projectRoot,
     disableSharedBundles: modeConfig.disableSharedBundles ?? defaults.disableSharedBundles,

package/lib/idealGraph.js

@@ -47,6 +47,7 @@ function _nullthrows() {
   };
   return data;
 }
+var _bundleMerge = require("./bundleMerge");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /* BundleRoot - An asset that is the main entry of a Bundle. */
 const dependencyPriorityEdges = {
@@ -848,6 +849,12 @@ function createIdealGraph(assetGraph, config, entries, logger) {
     }
   }
 
+  // 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();
+  }
+
   // Step Merge Share Bundles: Merge any shared bundles under the minimum bundle size back into
   // their source bundles, and remove the bundle.
   // We should include "bundle reuse" as shared bundles that may be removed but the bundle itself would have to be retained
@@ -857,9 +864,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.
+  let modifiedSourceBundles = new Set();
   if (config.disableSharedBundles === false) {
     for (let bundleGroupId of bundleGraph.getNodeIdsConnectedFrom(rootNodeId)) {
       // Find shared bundles in this bundle group.
@@ -944,6 +951,61 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       }
     }
   }
+  function mergeBundles(bundleGraph, bundleToKeepId, bundleToRemoveId, assetReference) {
+    let bundleToKeep = (0, _nullthrows().default)(bundleGraph.getNode(bundleToKeepId));
+    let bundleToRemove = (0, _nullthrows().default)(bundleGraph.getNode(bundleToRemoveId));
+    (0, _assert().default)(bundleToKeep !== 'root' && bundleToRemove !== 'root');
+    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]);
+      assetReference.set(asset, newAssetReference);
+    }
+    for (let sourceBundleId of bundleToRemove.sourceBundles) {
+      if (bundleToKeep.sourceBundles.has(sourceBundleId)) {
+        continue;
+      }
+      bundleToKeep.sourceBundles.add(sourceBundleId);
+      bundleGraph.addEdge(sourceBundleId, bundleToKeepId);
+    }
+
+    // Merge any internalized assets
+    if (bundleToRemove.internalizedAssets) {
+      if (bundleToKeep.internalizedAssets) {
+        bundleToKeep.internalizedAssets.union(bundleToRemove.internalizedAssets);
+      } else {
+        bundleToKeep.internalizedAssets = bundleToRemove.internalizedAssets;
+      }
+    }
+    bundleGraph.removeNode(bundleToRemoveId);
+  }
+  function mergeOverlapBundles() {
+    // 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), config.sharedBundleMergeThreshold);
+    for (let cluster of clusters) {
+      let [mergeTarget, ...rest] = cluster;
+      for (let bundleIdToMerge of rest) {
+        mergeBundles(bundleGraph, mergeTarget, bundleIdToMerge, assetReference);
+      }
+    }
+  }
   function getBigIntFromContentKey(contentKey) {
     let b = Buffer.alloc(64);
     b.write(contentKey);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/bundler-default",
-  "version": "2.14.5-canary.5+11d6f16b6",
+  "version": "2.14.5-canary.51+15b61556e",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -16,13 +16,13 @@
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.1-canary.73+11d6f16b6",
-    "@atlaspack/feature-flags": "2.14.1-canary.73+11d6f16b6",
-    "@atlaspack/graph": "3.4.1-canary.73+11d6f16b6",
-    "@atlaspack/plugin": "2.14.5-canary.5+11d6f16b6",
-    "@atlaspack/rust": "3.2.1-canary.5+11d6f16b6",
-    "@atlaspack/utils": "2.14.5-canary.5+11d6f16b6",
+    "@atlaspack/diagnostic": "2.14.1-canary.119+15b61556e",
+    "@atlaspack/feature-flags": "2.14.1-canary.119+15b61556e",
+    "@atlaspack/graph": "3.4.1-canary.119+15b61556e",
+    "@atlaspack/plugin": "2.14.5-canary.51+15b61556e",
+    "@atlaspack/rust": "3.2.1-canary.51+15b61556e",
+    "@atlaspack/utils": "2.14.5-canary.51+15b61556e",
     "nullthrows": "^1.1.1"
   },
-  "gitHead": "11d6f16b6397dee2f217167e5c98b39edb63f7a7"
+  "gitHead": "15b61556e9114203ebbc9de94b864118ca764598"
 }

package/src/bundleMerge.js

@@ -0,0 +1,103 @@
+// @flow strict-local
+
+import invariant from 'assert';
+import nullthrows from 'nullthrows';
+import type {NodeId} from '@atlaspack/graph';
+import type {Bundle, IdealBundleGraph} from './idealGraph';
+import {ContentGraph} from '@atlaspack/graph';
+
+// Returns a decimal showing the proportion source bundles are common to
+// both bundles versus the total number of source bundles.
+function scoreBundleMerge(bundleA: Bundle, bundleB: Bundle): number {
+  let sharedSourceBundles = 0;
+  let allSourceBundles = new Set([
+    ...bundleA.sourceBundles,
+    ...bundleB.sourceBundles,
+  ]);
+
+  for (let bundle of bundleB.sourceBundles) {
+    if (bundleA.sourceBundles.has(bundle)) {
+      sharedSourceBundles++;
+    }
+  }
+
+  return sharedSourceBundles / allSourceBundles.size;
+}
+
+function getMergeClusters(
+  graph: ContentGraph<NodeId>,
+  candidates: Set<NodeId>,
+): Array<Array<NodeId>> {
+  let clusters = [];
+
+  for (let candidate of candidates) {
+    let cluster: Array<NodeId> = [];
+
+    graph.traverse((nodeId) => {
+      cluster.push(nullthrows(graph.getNode(nodeId)));
+      // Remove node from candidates as it has already been processed
+      candidates.delete(nodeId);
+    }, candidate);
+
+    clusters.push(cluster);
+  }
+
+  return clusters;
+}
+
+export function findMergeCandidates(
+  bundleGraph: IdealBundleGraph,
+  bundles: Array<NodeId>,
+  threshold: number,
+): Array<Array<NodeId>> {
+  let graph = new ContentGraph<NodeId>();
+  let seen = new Set<string>();
+  let candidates = new Set<NodeId>();
+
+  // Build graph of clustered merge candidates
+  for (let bundleId of bundles) {
+    let bundle = bundleGraph.getNode(bundleId);
+    invariant(bundle && bundle !== 'root');
+    if (bundle.type !== 'js') {
+      continue;
+    }
+
+    for (let otherBundleId of bundles) {
+      if (bundleId === otherBundleId) {
+        continue;
+      }
+
+      let key = [bundleId, otherBundleId].sort().join(':');
+
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+
+      let otherBundle = bundleGraph.getNode(otherBundleId);
+      invariant(otherBundle && otherBundle !== 'root');
+
+      let score = scoreBundleMerge(bundle, otherBundle);
+
+      if (score >= threshold) {
+        let bundleNode = graph.addNodeByContentKeyIfNeeded(
+          bundleId.toString(),
+          bundleId,
+        );
+        let otherBundleNode = graph.addNodeByContentKeyIfNeeded(
+          otherBundleId.toString(),
+          otherBundleId,
+        );
+
+        // Add edge in both directions
+        graph.addEdge(bundleNode, otherBundleNode);
+        graph.addEdge(otherBundleNode, bundleNode);
+
+        candidates.add(bundleNode);
+        candidates.add(otherBundleNode);
+      }
+    }
+  }
+
+  return getMergeClusters(graph, candidates);
+}

package/src/bundlerConfig.js

@@ -7,6 +7,7 @@ import type {
   BuildMode,
   PluginLogger,
 } from '@atlaspack/types';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {type SchemaEntity, validateSchema} from '@atlaspack/utils';
 import invariant from 'assert';
 
@@ -28,6 +29,7 @@ type BaseBundlerConfig = {|
   disableSharedBundles?: boolean,
   manualSharedBundles?: ManualSharedBundles,
   loadConditionalBundlesInParallel?: boolean,
+  sharedBundleMergeThreshold?: number,
 |};
 
 type BundlerConfig = {|
@@ -42,6 +44,7 @@ export type ResolvedBundlerConfig = {|
   disableSharedBundles: boolean,
   manualSharedBundles: ManualSharedBundles,
   loadConditionalBundlesInParallel?: boolean,
+  sharedBundleMergeThreshold: number,
 |};
 
 function resolveModeConfig(
@@ -76,6 +79,7 @@ const HTTP_OPTIONS = {
     minBundleSize: 30000,
     maxParallelRequests: 6,
     disableSharedBundles: false,
+    sharedBundleMergeThreshold: 1,
   },
   '2': {
     minBundles: 1,
@@ -83,6 +87,7 @@ const HTTP_OPTIONS = {
     minBundleSize: 20000,
     maxParallelRequests: 25,
     disableSharedBundles: false,
+    sharedBundleMergeThreshold: 1,
   },
 };
 
@@ -139,6 +144,9 @@ const CONFIG_SCHEMA: SchemaEntity = {
     loadConditionalBundlesInParallel: {
       type: 'boolean',
     },
+    sharedBundleMergeThreshold: {
+      type: 'number',
+    },
   },
   additionalProperties: false,
 };
@@ -148,9 +156,17 @@ export async function loadBundlerConfig(
   options: PluginOptions,
   logger: PluginLogger,
 ): Promise<ResolvedBundlerConfig> {
-  let conf = await config.getConfig<BundlerConfig>([], {
-    packageKey: '@atlaspack/bundler-default',
-  });
+  let conf;
+
+  if (getFeatureFlag('resolveBundlerConfigFromCwd')) {
+    conf = await config.getConfigFrom(`${process.cwd()}/index`, [], {
+      packageKey: '@atlaspack/bundler-default',
+    });
+  } else {
+    conf = await config.getConfig<BundlerConfig>([], {
+      packageKey: '@atlaspack/bundler-default',
+    });
+  }
 
   if (!conf) {
     const modDefault = {
@@ -224,6 +240,9 @@ export async function loadBundlerConfig(
   return {
     minBundles: modeConfig.minBundles ?? defaults.minBundles,
     minBundleSize: modeConfig.minBundleSize ?? defaults.minBundleSize,
+    sharedBundleMergeThreshold:
+      modeConfig.sharedBundleMergeThreshold ??
+      defaults.sharedBundleMergeThreshold,
     maxParallelRequests:
       modeConfig.maxParallelRequests ?? defaults.maxParallelRequests,
     projectRoot: options.projectRoot,

package/src/idealGraph.js

@@ -23,6 +23,7 @@ import {DefaultMap, globToRegex} from '@atlaspack/utils';
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
 
+import {findMergeCandidates} from './bundleMerge';
 import type {ResolvedBundlerConfig} from './bundlerConfig';
 
 /* BundleRoot - An asset that is the main entry of a Bundle. */
@@ -67,7 +68,7 @@ export const idealBundleGraphEdges = Object.freeze({
   conditional: 2,
 });
 
-type IdealBundleGraph = Graph<
+export type IdealBundleGraph = Graph<
   Bundle | 'root',
   $Values<typeof idealBundleGraphEdges>,
 >;
@@ -1128,6 +1129,12 @@ export function createIdealGraph(
     }
   }
 
+  // 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();
+  }
+
   // Step Merge Share Bundles: Merge any shared bundles under the minimum bundle size back into
   // their source bundles, and remove the bundle.
   // We should include "bundle reuse" as shared bundles that may be removed but the bundle itself would have to be retained
@@ -1143,9 +1150,9 @@ export function createIdealGraph(
     }
   }
 
+  // Step Remove Shared Bundles: Remove shared bundles from bundle groups that hit the parallel request limit.
   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.
@@ -1249,6 +1256,93 @@ 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');
+    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],
+        );
+
+      assetReference.set(asset, newAssetReference);
+    }
+
+    for (let sourceBundleId of bundleToRemove.sourceBundles) {
+      if (bundleToKeep.sourceBundles.has(sourceBundleId)) {
+        continue;
+      }
+
+      bundleToKeep.sourceBundles.add(sourceBundleId);
+      bundleGraph.addEdge(sourceBundleId, bundleToKeepId);
+    }
+
+    // Merge any internalized assets
+    if (bundleToRemove.internalizedAssets) {
+      if (bundleToKeep.internalizedAssets) {
+        bundleToKeep.internalizedAssets.union(
+          bundleToRemove.internalizedAssets,
+        );
+      } else {
+        bundleToKeep.internalizedAssets = bundleToRemove.internalizedAssets;
+      }
+    }
+
+    bundleGraph.removeNode(bundleToRemoveId);
+  }
+
+  function mergeOverlapBundles() {
+    // Find all shared bundles
+    let sharedBundles = new Set<NodeId>();
+    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 = findMergeCandidates(
+      bundleGraph,
+      Array.from(sharedBundles),
+      config.sharedBundleMergeThreshold,
+    );
+
+    for (let cluster of clusters) {
+      let [mergeTarget, ...rest] = cluster;
+
+      for (let bundleIdToMerge of rest) {
+        mergeBundles(bundleGraph, mergeTarget, bundleIdToMerge, assetReference);
+      }
+    }
+  }
+
   function getBigIntFromContentKey(contentKey) {
     let b = Buffer.alloc(64);
     b.write(contentKey);