@atlaspack/bundler-default 2.14.5-canary.170 → 2.14.5-canary.172

package/lib/MonolithicBundler.js

@@ -4,6 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.addJSMonolithBundle = addJSMonolithBundle;
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
   _nullthrows = function () {
@@ -18,7 +25,8 @@ function addJSMonolithBundle(bundleGraph, entryAsset, entryDep) {
   // Create a single bundle to hold all JS assets
   let bundle = bundleGraph.createBundle({
     entryAsset,
-    target
+    target,
+    needsStableName: (0, _featureFlags().getFeatureFlag)('singleFileOutputStableName')
   });
   bundleGraph.traverse((node, _, actions) => {
     // JS assets can be added to the bundle, but the rest are ignored

package/lib/bundlerConfig.js

@@ -133,6 +133,26 @@ const CONFIG_SCHEMA = {
         additionalProperties: false
       }
     },
+    asyncBundleMerge: {
+      type: 'object',
+      properties: {
+        bundleSize: {
+          type: 'number',
+          required: true
+        },
+        maxOverfetchSize: {
+          type: 'number',
+          required: true
+        },
+        ignore: {
+          type: 'array',
+          items: {
+            type: 'string'
+          }
+        }
+      },
+      additionalProperties: false
+    },
     minBundles: {
       type: 'number'
     },
@@ -218,6 +238,7 @@ async function loadBundlerConfig(config, options, logger) {
     minBundles: modeConfig.minBundles ?? defaults.minBundles,
     minBundleSize: modeConfig.minBundleSize ?? defaults.minBundleSize,
     sharedBundleMerge: modeConfig.sharedBundleMerge ?? defaults.sharedBundleMerge,
+    asyncBundleMerge: modeConfig.asyncBundleMerge,
     maxParallelRequests: modeConfig.maxParallelRequests ?? defaults.maxParallelRequests,
     projectRoot: options.projectRoot,
     disableSharedBundles: modeConfig.disableSharedBundles ?? defaults.disableSharedBundles,

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 () {
@@ -48,6 +55,7 @@ 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. */
 
@@ -78,6 +86,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
   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.
@@ -896,7 +905,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       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' || node.value.meta.chunkName == null) {
+      if (!node || node.type !== 'dependency' || typeof node.value.meta.chunkName !== 'string') {
         continue;
       }
       let connectedBundles = dependencyBundleGraph.getNodeIdsConnectedFrom(nodeId, dependencyPriorityEdges[node.value.priority]);
@@ -935,16 +944,19 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       // 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);
+        mergeBundles(firstBundleId, bundleId, 'webpack-chunk-name');
       }
     }
   }
 
-  // Step merge shared bundles that meet the overlap threshold
-  // This step is skipped by default as the threshold defaults to 1
+  // 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) {
-    mergeOverlapBundles(config.sharedBundleMerge);
+    mergeSharedBundles(config.sharedBundleMerge);
   }
 
   // Step Merge Share Bundles: Merge any shared bundles under the minimum bundle size back into
@@ -1045,7 +1057,8 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       }
     }
   }
-  function mergeBundles(bundleToKeepId, bundleToRemoveId) {
+  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);
@@ -1077,8 +1090,10 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       if (bundleToKeep.sourceBundles.has(sourceBundleId)) {
         continue;
       }
-      bundleToKeep.sourceBundles.add(sourceBundleId);
-      bundleGraph.addEdge(sourceBundleId, bundleToKeepId);
+      if (sourceBundleId !== bundleToKeepId) {
+        bundleToKeep.sourceBundles.add(sourceBundleId);
+        bundleGraph.addEdge(sourceBundleId, bundleToKeepId);
+      }
     }
     if ((0, _featureFlags().getFeatureFlag)('supportWebpackChunkName')) {
       bundleToKeep.sourceBundles.delete(bundleToRemoveId);
@@ -1090,9 +1105,11 @@ function createIdealGraph(assetGraph, config, entries, logger) {
 
         // 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);
+          if (bundle !== bundleToKeepId) {
+            bundleNode.sourceBundles.add(bundleToKeepId);
+            bundleGraph.addEdge(bundleToKeepId, bundle);
+          }
         }
       }
 
@@ -1105,11 +1122,35 @@ function createIdealGraph(assetGraph, config, entries, logger) {
 
         // 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
@@ -1142,7 +1183,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
     }
     bundleGraph.removeNode(bundleToRemoveId);
   }
-  function mergeOverlapBundles(mergeConfig) {
+  function mergeSharedBundles(mergeConfig) {
     // Find all shared bundles
     let sharedBundles = new Set();
     bundleGraph.traverse(nodeId => {
@@ -1178,7 +1219,7 @@ function createIdealGraph(assetGraph, config, entries, logger) {
     for (let cluster of clusters) {
       let [mergeTarget, ...rest] = cluster;
       for (let bundleIdToMerge of rest) {
-        mergeBundles(mergeTarget, bundleIdToMerge);
+        mergeBundles(mergeTarget, bundleIdToMerge, 'shared-merge');
       }
       mergedBundles.add(mergeTarget);
     }
@@ -1186,6 +1227,108 @@ function createIdealGraph(assetGraph, config, entries, logger) {
       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);
@@ -1218,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);
@@ -1267,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,

package/lib/stats.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Stats = void 0;
+function _path() {
+  const data = require("path");
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+class Stats {
+  merges = new (_utils().DefaultMap)(() => []);
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+  trackMerge(bundleToKeep, bundleToRemove, reason) {
+    if (!_utils().debugTools['bundle-stats']) {
+      return;
+    }
+    this.merges.get(bundleToKeep).push(...this.merges.get(bundleToRemove), {
+      id: bundleToRemove,
+      reason
+    });
+    this.merges.delete(bundleToRemove);
+  }
+  getBundleLabel(bundle) {
+    if (bundle.manualSharedBundle) {
+      return bundle.manualSharedBundle;
+    }
+    if (bundle.mainEntryAsset) {
+      let relativePath = (0, _path().relative)(this.projectRoot, bundle.mainEntryAsset.filePath);
+      if (relativePath.length > 100) {
+        relativePath = relativePath.slice(0, 50) + '...' + relativePath.slice(-50);
+      }
+      return relativePath;
+    }
+    return `shared`;
+  }
+  report(getBundle) {
+    if (!_utils().debugTools['bundle-stats']) {
+      return;
+    }
+    let mergeResults = [];
+    let totals = {
+      label: 'Totals',
+      merges: 0
+    };
+    for (let [bundleId, mergedBundles] of this.merges) {
+      let bundle = getBundle(bundleId);
+      if (!bundle) {
+        continue;
+      }
+      let result = {
+        label: this.getBundleLabel(bundle),
+        size: bundle.size,
+        merges: mergedBundles.length
+      };
+      for (let merged of mergedBundles) {
+        result[merged.reason] = (result[merged.reason] || 0) + 1;
+        totals[merged.reason] = (totals[merged.reason] || 0) + 1;
+      }
+      totals.merges += mergedBundles.length;
+      mergeResults.push(result);
+    }
+    mergeResults.sort((a, b) => {
+      // Sort by bundle size descending
+      return b.size - a.size;
+    });
+    mergeResults.push(totals);
+
+    // eslint-disable-next-line no-console
+    console.table(mergeResults);
+  }
+}
+exports.Stats = Stats;

package/lib/types/bundlerConfig.d.ts

@@ -7,12 +7,20 @@ type ManualSharedBundles = Array<{
     root?: string;
     split?: number;
 }>;
-export type MergeCandidates = Array<{
+export type SharedBundleMergeCandidates = Array<{
     overlapThreshold?: number;
     maxBundleSize?: number;
     sourceBundles?: Array<string>;
     minBundlesInGroup?: number;
 }>;
+export interface AsyncBundleMerge {
+    /** Consider all async bundles smaller than this for merging */
+    bundleSize: number;
+    /** The max bytes allowed to be potentially overfetched due to a merge  */
+    maxOverfetchSize: number;
+    /** Bundles to ignore from merging */
+    ignore?: Array<Glob>;
+}
 export type ResolvedBundlerConfig = {
     minBundles: number;
     minBundleSize: number;
@@ -21,7 +29,8 @@ export type ResolvedBundlerConfig = {
     disableSharedBundles: boolean;
     manualSharedBundles: ManualSharedBundles;
     loadConditionalBundlesInParallel?: boolean;
-    sharedBundleMerge?: MergeCandidates;
+    sharedBundleMerge?: SharedBundleMergeCandidates;
+    asyncBundleMerge?: AsyncBundleMerge;
 };
 export declare function loadBundlerConfig(config: Config, options: PluginOptions, logger: PluginLogger): Promise<ResolvedBundlerConfig>;
 export {};

package/lib/types/stats.d.ts

@@ -0,0 +1,16 @@
+import { NodeId } from '@atlaspack/graph';
+import { DefaultMap } from '@atlaspack/utils';
+import { Bundle } from './idealGraph';
+interface MergedBundle {
+    id: NodeId;
+    reason: string;
+}
+export declare class Stats {
+    projectRoot: string;
+    merges: DefaultMap<NodeId, MergedBundle[]>;
+    constructor(projectRoot: string);
+    trackMerge(bundleToKeep: NodeId, bundleToRemove: NodeId, reason: string): void;
+    getBundleLabel(bundle: Bundle): string;
+    report(getBundle: (bundleId: NodeId) => Bundle | null | undefined): void;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/bundler-default",
-  "version": "2.14.5-canary.170+c940954d2",
+  "version": "2.14.5-canary.172+88439807b",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -17,19 +17,21 @@
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.1-canary.238+c940954d2",
-    "@atlaspack/feature-flags": "2.14.1-canary.238+c940954d2",
-    "@atlaspack/graph": "3.4.1-canary.238+c940954d2",
-    "@atlaspack/plugin": "2.14.5-canary.170+c940954d2",
-    "@atlaspack/rust": "3.2.1-canary.170+c940954d2",
-    "@atlaspack/types-internal": "2.14.1-canary.238+c940954d2",
-    "@atlaspack/utils": "2.14.5-canary.170+c940954d2",
+    "@atlaspack/diagnostic": "2.14.1-canary.240+88439807b",
+    "@atlaspack/feature-flags": "2.14.1-canary.240+88439807b",
+    "@atlaspack/graph": "3.4.1-canary.240+88439807b",
+    "@atlaspack/plugin": "2.14.5-canary.172+88439807b",
+    "@atlaspack/rust": "3.2.1-canary.172+88439807b",
+    "@atlaspack/types-internal": "2.14.1-canary.240+88439807b",
+    "@atlaspack/utils": "2.14.5-canary.172+88439807b",
+    "@types/sorted-array-functions": "^1.0.0",
     "many-keys-map": "^1.0.3",
-    "nullthrows": "^1.1.1"
+    "nullthrows": "^1.1.1",
+    "sorted-array-functions": "^1.0.0"
   },
   "scripts": {
     "check-ts": "tsc --emitDeclarationOnly --rootDir src",
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
-  "gitHead": "c940954d27d657c3c93cd328dfb394778da46eab"
+  "gitHead": "88439807be20025fd3433380204ff1205079729e"
 }

package/src/MonolithicBundler.ts

@@ -3,6 +3,8 @@ import type {
   Dependency,
   MutableBundleGraph,
 } from '@atlaspack/types-internal';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+
 import nullthrows from 'nullthrows';
 
 export function addJSMonolithBundle(
@@ -16,7 +18,11 @@ export function addJSMonolithBundle(
   );
 
   // Create a single bundle to hold all JS assets
-  let bundle = bundleGraph.createBundle({entryAsset, target});
+  let bundle = bundleGraph.createBundle({
+    entryAsset,
+    target,
+    needsStableName: getFeatureFlag('singleFileOutputStableName'),
+  });
 
   bundleGraph.traverse(
     (node, _, actions) => {

package/src/bundlerConfig.ts

@@ -19,13 +19,22 @@ type ManualSharedBundles = Array<{
   split?: number;
 }>;
 
-export type MergeCandidates = Array<{
+export type SharedBundleMergeCandidates = Array<{
   overlapThreshold?: number;
   maxBundleSize?: number;
   sourceBundles?: Array<string>;
   minBundlesInGroup?: number;
 }>;
 
+export interface AsyncBundleMerge {
+  /** Consider all async bundles smaller than this for merging */
+  bundleSize: number;
+  /** The max bytes allowed to be potentially overfetched due to a merge  */
+  maxOverfetchSize: number;
+  /** Bundles to ignore from merging */
+  ignore?: Array<Glob>;
+}
+
 type BaseBundlerConfig = {
   http?: number;
   minBundles?: number;
@@ -34,7 +43,8 @@ type BaseBundlerConfig = {
   disableSharedBundles?: boolean;
   manualSharedBundles?: ManualSharedBundles;
   loadConditionalBundlesInParallel?: boolean;
-  sharedBundleMerge?: MergeCandidates;
+  sharedBundleMerge?: SharedBundleMergeCandidates;
+  asyncBundleMerge?: AsyncBundleMerge;
 };
 
 type BundlerConfig = Partial<Record<BuildMode, BaseBundlerConfig>> &
@@ -48,7 +58,8 @@ export type ResolvedBundlerConfig = {
   disableSharedBundles: boolean;
   manualSharedBundles: ManualSharedBundles;
   loadConditionalBundlesInParallel?: boolean;
-  sharedBundleMerge?: MergeCandidates;
+  sharedBundleMerge?: SharedBundleMergeCandidates;
+  asyncBundleMerge?: AsyncBundleMerge;
 };
 
 function resolveModeConfig(
@@ -157,6 +168,26 @@ const CONFIG_SCHEMA: SchemaEntity = {
         additionalProperties: false,
       },
     },
+    asyncBundleMerge: {
+      type: 'object',
+      properties: {
+        bundleSize: {
+          type: 'number',
+          required: true,
+        },
+        maxOverfetchSize: {
+          type: 'number',
+          required: true,
+        },
+        ignore: {
+          type: 'array',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      additionalProperties: false,
+    },
     minBundles: {
       type: 'number',
     },
@@ -272,6 +303,7 @@ export async function loadBundlerConfig(
     minBundleSize: modeConfig.minBundleSize ?? defaults.minBundleSize,
     sharedBundleMerge:
       modeConfig.sharedBundleMerge ?? defaults.sharedBundleMerge,
+    asyncBundleMerge: modeConfig.asyncBundleMerge,
     maxParallelRequests:
       modeConfig.maxParallelRequests ?? defaults.maxParallelRequests,
     projectRoot: options.projectRoot,

package/src/idealGraph.ts

@@ -1,4 +1,5 @@
 import path from 'path';
+import sortedArray from 'sorted-array-functions';
 
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {
@@ -22,7 +23,12 @@ import invariant from 'assert';
 import nullthrows from 'nullthrows';
 
 import {findMergeCandidates, MergeGroup} from './bundleMerge';
-import type {ResolvedBundlerConfig, MergeCandidates} from './bundlerConfig';
+import type {
+  ResolvedBundlerConfig,
+  SharedBundleMergeCandidates,
+  AsyncBundleMerge,
+} from './bundlerConfig';
+import {Stats} from './stats';
 
 /* BundleRoot - An asset that is the main entry of a Bundle. */
 type BundleRoot = Asset;
@@ -108,6 +114,7 @@ export function createIdealGraph(
     Asset,
     Array<[Dependency, Bundle]>
   > = new DefaultMap(() => []);
+  let stats = new 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.
@@ -1206,14 +1213,14 @@ export function createIdealGraph(
 
   if (getFeatureFlag('supportWebpackChunkName')) {
     // Merge webpack chunk name bundles
-    let chunkNameBundles = new DefaultMap(() => new Set());
+    let chunkNameBundles = new DefaultMap<string, Set<NodeId>>(() => 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
+        typeof node.value.meta.chunkName !== 'string'
       ) {
         continue;
       }
@@ -1272,16 +1279,19 @@ export function createIdealGraph(
       // 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);
+        mergeBundles(firstBundleId, bundleId, 'webpack-chunk-name');
       }
     }
   }
 
-  // Step merge shared bundles that meet the overlap threshold
-  // This step is skipped by default as the threshold defaults to 1
+  // 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) {
-    mergeOverlapBundles(config.sharedBundleMerge);
+    mergeSharedBundles(config.sharedBundleMerge);
   }
 
   // Step Merge Share Bundles: Merge any shared bundles under the minimum bundle size back into
@@ -1412,7 +1422,12 @@ export function createIdealGraph(
     }
   }
 
-  function mergeBundles(bundleToKeepId: NodeId, bundleToRemoveId: NodeId) {
+  function mergeBundles(
+    bundleToKeepId: NodeId,
+    bundleToRemoveId: NodeId,
+    reason: string,
+  ) {
+    stats.trackMerge(bundleToKeepId, bundleToRemoveId, reason);
     let bundleToKeep = isNonRootBundle(
       bundleGraph.getNode(bundleToKeepId),
       `Bundle ${bundleToKeepId} not found`,
@@ -1461,8 +1476,10 @@ export function createIdealGraph(
         continue;
       }
 
-      bundleToKeep.sourceBundles.add(sourceBundleId);
-      bundleGraph.addEdge(sourceBundleId, bundleToKeepId);
+      if (sourceBundleId !== bundleToKeepId) {
+        bundleToKeep.sourceBundles.add(sourceBundleId);
+        bundleGraph.addEdge(sourceBundleId, bundleToKeepId);
+      }
     }
 
     if (getFeatureFlag('supportWebpackChunkName')) {
@@ -1478,9 +1495,11 @@ export function createIdealGraph(
 
         // 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);
+          if (bundle !== bundleToKeepId) {
+            bundleNode.sourceBundles.add(bundleToKeepId);
+            bundleGraph.addEdge(bundleToKeepId, bundle);
+          }
         }
       }
 
@@ -1496,11 +1515,48 @@ export function createIdealGraph(
         let bundlesInRemoveBundleGroup =
           getBundlesForBundleGroup(bundleToRemoveId);
 
+        let removedBundleSharedBundles = new Set<NodeId>();
         for (let bundleIdInGroup of bundlesInRemoveBundleGroup) {
           if (bundleIdInGroup === bundleToRemoveId) {
             continue;
           }
           bundleGraph.addEdge(bundleToKeepId, bundleIdInGroup);
+          removedBundleSharedBundles.add(bundleIdInGroup);
+        }
+
+        if (getFeatureFlag('removeRedundantSharedBundles')) {
+          // Merge any shared bundles that now have the same source bundles due to
+          // the current bundle merge
+          let sharedBundles = new DefaultMap<string, Array<NodeId>>(() => []);
+          for (let bundleId of removedBundleSharedBundles) {
+            let bundleNode = nullthrows(bundleGraph.getNode(bundleId));
+            invariant(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
@@ -1566,7 +1622,7 @@ export function createIdealGraph(
     bundleGraph.removeNode(bundleToRemoveId);
   }
 
-  function mergeOverlapBundles(mergeConfig: MergeCandidates) {
+  function mergeSharedBundles(mergeConfig: SharedBundleMergeCandidates) {
     // Find all shared bundles
     let sharedBundles = new Set<NodeId>();
     bundleGraph.traverse((nodeId) => {
@@ -1620,7 +1676,7 @@ export function createIdealGraph(
       let [mergeTarget, ...rest] = cluster;
 
       for (let bundleIdToMerge of rest) {
-        mergeBundles(mergeTarget, bundleIdToMerge);
+        mergeBundles(mergeTarget, bundleIdToMerge, 'shared-merge');
       }
 
       mergedBundles.add(mergeTarget);
@@ -1631,6 +1687,150 @@ export function createIdealGraph(
     }
   }
 
+  function mergeAsyncBundles({
+    bundleSize,
+    maxOverfetchSize,
+    ignore,
+  }: AsyncBundleMerge) {
+    let mergeCandidates = [];
+    let ignoreRegexes = ignore?.map((glob) => globToRegex(glob)) ?? [];
+
+    let isIgnored = (bundle: Bundle) => {
+      if (!bundle.mainEntryAsset) {
+        return false;
+      }
+
+      let mainEntryFilePath = path.relative(
+        config.projectRoot,
+        nullthrows(bundle.mainEntryAsset).filePath,
+      );
+
+      return ignoreRegexes.some((regex) => regex.test(mainEntryFilePath));
+    };
+
+    for (let [_bundleRootAsset, [bundleRootBundleId]] of bundleRoots) {
+      let bundleRootBundle = nullthrows(
+        bundleGraph.getNode(bundleRootBundleId),
+      );
+      invariant(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: AsyncBundleMergeCandidate,
+      b: AsyncBundleMergeCandidate,
+    ) => {
+      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<NodeId>();
+    // Tracks the deleted bundles to the bundle they were merged into.
+    let mergeRemap = new Map<NodeId, NodeId>();
+    // Tracks the bundles that have been rescored and added back into the
+    // candidates.
+    let rescored = new DefaultMap<NodeId, Set<NodeId>>(() => new Set());
+
+    do {
+      let [a, b] = nullthrows(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: NodeId): NodeId | undefined => {
+        let seen = new Set<NodeId>();
+        while (!bundleGraph.hasNode(bundleId) && !seen.has(bundleId)) {
+          seen.add(bundleId);
+          bundleId = nullthrows(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) {
+        sortedArray.add(candidates, candidate, sortByScore);
+        rescored.get(currentA).add(currentB);
+      }
+    } while (candidates.length > 0);
+  }
+
+  function getBundle(bundleId: NodeId): Bundle {
+    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: string) {
     let b = Buffer.alloc(64);
     b.write(contentKey);
@@ -1668,6 +1868,78 @@ export function createIdealGraph(
     return bundlesInABundleGroup;
   }
 
+  interface AsyncBundleMergeCandidate {
+    overfetchSize: number;
+    score: number;
+    bundleIds: number[];
+  }
+  function scoreAsyncMerge(
+    bundleAId: NodeId,
+    bundleBId: NodeId,
+    maxOverfetchSize: number,
+  ): AsyncBundleMergeCandidate {
+    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: NodeId): Set<NodeId> {
+    let parents = new Set<NodeId>();
+    let {bundleRoots} = getBundle(bundleId);
+
+    for (let bundleRoot of bundleRoots) {
+      let bundleRootNodeId = nullthrows(
+        assetToBundleRootNodeId.get(bundleRoot),
+      );
+      for (let parentId of bundleRootGraph.getNodeIdsConnectedTo(
+        bundleRootNodeId,
+        ALL_EDGE_TYPES,
+      )) {
+        parents.add(parentId);
+      }
+    }
+    return parents;
+  }
+
   function getBundleFromBundleRoot(bundleRoot: BundleRoot): Bundle {
     let bundle = bundleGraph.getNode(
       nullthrows(bundleRoots.get(bundleRoot))[0],
@@ -1732,6 +2004,12 @@ export function createIdealGraph(
     bundleGraph.removeNode(bundleId);
   }
 
+  stats.report((bundleId) => {
+    let bundle = bundleGraph.getNode(bundleId);
+    invariant(bundle !== 'root');
+    return bundle;
+  });
+
   return {
     assets,
     bundleGraph,

package/src/stats.ts

@@ -0,0 +1,97 @@
+import {relative} from 'path';
+import {NodeId} from '@atlaspack/graph';
+import {DefaultMap, debugTools} from '@atlaspack/utils';
+
+import {Bundle} from './idealGraph';
+
+interface MergedBundle {
+  id: NodeId;
+  reason: string;
+}
+
+export class Stats {
+  projectRoot: string;
+  merges: DefaultMap<NodeId, MergedBundle[]> = new DefaultMap(() => []);
+
+  constructor(projectRoot: string) {
+    this.projectRoot = projectRoot;
+  }
+
+  trackMerge(bundleToKeep: NodeId, bundleToRemove: NodeId, reason: string) {
+    if (!debugTools['bundle-stats']) {
+      return;
+    }
+
+    this.merges
+      .get(bundleToKeep)
+      .push(...this.merges.get(bundleToRemove), {id: bundleToRemove, reason});
+    this.merges.delete(bundleToRemove);
+  }
+
+  getBundleLabel(bundle: Bundle): string {
+    if (bundle.manualSharedBundle) {
+      return bundle.manualSharedBundle;
+    }
+
+    if (bundle.mainEntryAsset) {
+      let relativePath = relative(
+        this.projectRoot,
+        bundle.mainEntryAsset.filePath,
+      );
+
+      if (relativePath.length > 100) {
+        relativePath =
+          relativePath.slice(0, 50) + '...' + relativePath.slice(-50);
+      }
+
+      return relativePath;
+    }
+
+    return `shared`;
+  }
+
+  report(getBundle: (bundleId: NodeId) => Bundle | null | undefined): void {
+    if (!debugTools['bundle-stats']) {
+      return;
+    }
+
+    type MergeResult = Record<string, string | number>;
+    let mergeResults: Array<MergeResult> = [];
+
+    let totals: Record<string, string | number> = {
+      label: 'Totals',
+      merges: 0,
+    };
+
+    for (let [bundleId, mergedBundles] of this.merges) {
+      let bundle = getBundle(bundleId);
+      if (!bundle) {
+        continue;
+      }
+
+      let result: MergeResult = {
+        label: this.getBundleLabel(bundle),
+        size: bundle.size,
+        merges: mergedBundles.length,
+      };
+
+      for (let merged of mergedBundles) {
+        result[merged.reason] = ((result[merged.reason] as number) || 0) + 1;
+        totals[merged.reason] = ((totals[merged.reason] as number) || 0) + 1;
+      }
+
+      (totals.merges as number) += mergedBundles.length;
+      mergeResults.push(result);
+    }
+
+    mergeResults.sort((a, b) => {
+      // Sort by bundle size descending
+      return (b.size as number) - (a.size as number);
+    });
+
+    mergeResults.push(totals);
+
+    // eslint-disable-next-line no-console
+    console.table(mergeResults);
+  }
+}