@atlaspack/core 2.16.2-canary.431 → 2.16.2-canary.433

package/dist/requests/BundleGraphRequest.js

@@ -263,14 +263,17 @@ class BundlerRunner {
                     measurement = tracer.createMeasurement(plugin.name, 'bundling:bundle', measurementFilename);
                 }
                 // this the normal bundle workflow (bundle, optimizing, run-times, naming)
-                await bundler.bundle({
-                    bundleGraph: mutableBundleGraph,
-                    config: this.configs.get(plugin.name)?.result,
-                    options: this.pluginOptions,
-                    logger,
-                    tracer,
+                await (0, logger_1.instrumentAsync)('bundle (V2)', async () => {
+                    await bundler.bundle({
+                        bundleGraph: mutableBundleGraph,
+                        config: this.configs.get(plugin.name)?.result,
+                        options: this.pluginOptions,
+                        logger,
+                        tracer,
+                    });
                 });
                 measurement && measurement.end();
+                (0, BundleGraphRequestUtils_1.dumpBundleGraphSnapshot)(internalBundleGraph, 'js');
                 if (this.pluginOptions.mode === 'production') {
                     let optimizeMeasurement;
                     try {

package/dist/requests/BundleGraphRequestRust.js

@@ -71,6 +71,7 @@ function createBundleGraphRequestRust(input) {
             }
             // Don’t reuse previous JS result yet; we just rebuild from scratch.
             let { bundleGraph, changedAssets } = (0, logger_1.instrument)('atlaspack_v3_getBundleGraph', () => getBundleGraph(serializedBundleGraph));
+            (0, BundleGraphRequestUtils_1.dumpBundleGraphSnapshot)(bundleGraph, 'rust');
             const runner = new NativeBundlerRunner({ api, options }, input.optionsRef);
             await runner.loadConfigs();
             // Name all bundles

package/dist/requests/BundleGraphRequestUtils.js

@@ -37,15 +37,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateBundles = validateBundles;
+exports.dumpBundleGraphSnapshot = dumpBundleGraphSnapshot;
 exports.nameBundle = nameBundle;
 exports.loadPluginConfigWithDevDeps = loadPluginConfigWithDevDeps;
 exports.runDevDepRequest = runDevDepRequest;
 const assert_1 = __importDefault(require("assert"));
+const fs_1 = __importDefault(require("fs"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
+const path_1 = __importDefault(require("path"));
 const logger_1 = require("@atlaspack/logger");
 const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
 const utils_1 = require("@atlaspack/utils");
-const BundleGraph_1 = __importDefault(require("../public/BundleGraph"));
+const BundleGraph_1 = require("../BundleGraph");
+const BundleGraph_2 = __importDefault(require("../public/BundleGraph"));
 const Bundle_1 = require("../public/Bundle");
 const InternalConfig_1 = require("../InternalConfig");
 const DevDepRequest_1 = require("./DevDepRequest");
@@ -64,12 +68,139 @@ function validateBundles(bundleGraph) {
             ...(0, utils_1.setSymmetricDifference)(new Set(bundleNames), new Set((0, utils_1.unique)(bundleNames))),
         ].join());
 }
+/**
+ * Dump a canonical JSON snapshot of the bundle graph for parity comparison.
+ * Gated by ATLASPACK_DUMP_BUNDLE_GRAPH environment variable which specifies the output directory.
+ * The snapshot captures bundle identity, type, contained assets, and bundle group structure
+ * in a deterministic, sorted format suitable for diffing.
+ */
+function dumpBundleGraphSnapshot(bundleGraph, variant) {
+    let outDir = process.env.ATLASPACK_DUMP_BUNDLE_GRAPH;
+    if (!outDir)
+        return;
+    let filename = variant === 'js' ? 'bundle-graph-js.json' : 'bundle-graph-rust.json';
+    let outPath = path_1.default.join(outDir, filename);
+    fs_1.default.mkdirSync(outDir, { recursive: true });
+    let bundles = bundleGraph.getBundles();
+    let bundlesSnapshot = bundles
+        .map((bundle) => {
+        let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.id);
+        let containedAssetNodeIds = bundleGraph._graph.getNodeIdsConnectedFrom(bundleNodeId, BundleGraph_1.bundleGraphEdgeTypes.contains);
+        let containedAssets = containedAssetNodeIds
+            .map((nodeId) => bundleGraph._graph.getNode(nodeId))
+            .flatMap((node) => {
+            if (node?.type !== 'asset')
+                return [];
+            return [
+                {
+                    id: node.value.id,
+                    filePath: (0, projectPath_1.fromProjectPathRelative)(node.value.filePath),
+                },
+            ];
+        })
+            .sort((a, b) => a.filePath.localeCompare(b.filePath));
+        // Resolve mainEntry and entry asset file paths
+        let mainEntryPath = null;
+        let entryAssetPaths = [];
+        if (bundle.mainEntryId) {
+            let mainEntryNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.mainEntryId);
+            let mainEntryNode = bundleGraph._graph.getNode(mainEntryNodeId);
+            if (mainEntryNode?.type === 'asset') {
+                mainEntryPath = (0, projectPath_1.fromProjectPathRelative)(mainEntryNode.value.filePath);
+            }
+        }
+        for (let entryId of bundle.entryAssetIds) {
+            let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(entryId);
+            let entryNode = bundleGraph._graph.getNode(entryNodeId);
+            if (entryNode?.type === 'asset') {
+                entryAssetPaths.push((0, projectPath_1.fromProjectPathRelative)(entryNode.value.filePath));
+            }
+        }
+        entryAssetPaths.sort();
+        return {
+            id: bundle.id,
+            type: bundle.type,
+            bundleBehavior: bundle.bundleBehavior ?? null,
+            needsStableName: bundle.needsStableName,
+            isSplittable: bundle.isSplittable,
+            isPlaceholder: bundle.isPlaceholder,
+            mainEntryPath,
+            entryAssetPaths,
+            assets: containedAssets.map((a) => a.filePath),
+        };
+    })
+        .sort((a, b) => {
+        // Sort by mainEntryPath first, then by sorted assets as tiebreaker
+        let aKey = a.mainEntryPath || a.assets.join(',');
+        let bKey = b.mainEntryPath || b.assets.join(',');
+        return aKey.localeCompare(bKey);
+    });
+    let bundleGroupsSnapshot = bundleGraph._graph.nodes
+        .flatMap((node) => {
+        if (node?.type !== 'bundle_group')
+            return [];
+        let bundleGroup = node.value;
+        // Resolve entry asset file path
+        let entryAssetPath = null;
+        try {
+            let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(bundleGroup.entryAssetId);
+            let entryNode = bundleGraph._graph.getNode(entryNodeId);
+            if (entryNode?.type === 'asset') {
+                entryAssetPath = (0, projectPath_1.fromProjectPathRelative)(entryNode.value.filePath);
+            }
+        }
+        catch {
+            // Content key not found
+        }
+        let bundlesInGroup = bundleGraph.getBundlesInBundleGroup(bundleGroup);
+        let bundlePaths = bundlesInGroup
+            .map((b) => {
+            // Use mainEntry file path if available, otherwise bundle id as fallback
+            if (b.mainEntryId) {
+                try {
+                    let nodeId = bundleGraph._graph.getNodeIdByContentKey(b.mainEntryId);
+                    let node = bundleGraph._graph.getNode(nodeId);
+                    if (node?.type === 'asset') {
+                        return (0, projectPath_1.fromProjectPathRelative)(node.value.filePath);
+                    }
+                }
+                catch {
+                    // fallback
+                }
+            }
+            return `[bundle:${b.id}]`;
+        })
+            .sort();
+        return [
+            {
+                entryAssetPath: entryAssetPath ?? `[unknown:${bundleGroup.entryAssetId}]`,
+                bundlePaths,
+            },
+        ];
+    })
+        .sort((a, b) => a.entryAssetPath.localeCompare(b.entryAssetPath));
+    let totalAssets = bundleGraph._graph.nodes.filter((node) => node?.type === 'asset').length;
+    let snapshot = {
+        version: 1,
+        variant,
+        stats: {
+            totalBundles: bundlesSnapshot.length,
+            totalBundleGroups: bundleGroupsSnapshot.length,
+            totalAssets,
+        },
+        bundles: bundlesSnapshot,
+        bundleGroups: bundleGroupsSnapshot,
+    };
+    fs_1.default.writeFileSync(outPath, JSON.stringify(snapshot, null, 2), 'utf8');
+    // eslint-disable-next-line no-console
+    console.log(`[BundleGraphSnapshot] Wrote ${variant} snapshot to ${outPath}`);
+}
 /**
  * Names a bundle by running through the configured namers until one returns a name.
  */
 async function nameBundle(namers, internalBundle, internalBundleGraph, options, pluginOptions, configs) {
     const bundle = Bundle_1.Bundle.get(internalBundle, internalBundleGraph, options);
-    const bundleGraph = new BundleGraph_1.default(internalBundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), options);
+    const bundleGraph = new BundleGraph_2.default(internalBundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), options);
     for (const namer of namers) {
         let measurement;
         try {

package/lib/requests/BundleGraphRequest.js

@@ -293,7 +293,6 @@ class BundlerRunner {
         }
         didIncrementallyBundle = true;
       } else {
-        var _this$configs$get;
         internalBundleGraph = _BundleGraph.default.fromAssetGraph(graph, this.options.mode === 'production');
         (0, _assert().default)(internalBundleGraph != null); // ensures the graph was created
 
@@ -309,14 +308,18 @@ class BundlerRunner {
         }
 
         // this the normal bundle workflow (bundle, optimizing, run-times, naming)
-        await bundler.bundle({
-          bundleGraph: mutableBundleGraph,
-          config: (_this$configs$get = this.configs.get(plugin.name)) === null || _this$configs$get === void 0 ? void 0 : _this$configs$get.result,
-          options: this.pluginOptions,
-          logger,
-          tracer
+        await (0, _logger().instrumentAsync)('bundle (V2)', async () => {
+          var _this$configs$get;
+          await bundler.bundle({
+            bundleGraph: mutableBundleGraph,
+            config: (_this$configs$get = this.configs.get(plugin.name)) === null || _this$configs$get === void 0 ? void 0 : _this$configs$get.result,
+            options: this.pluginOptions,
+            logger,
+            tracer
+          });
         });
         measurement && measurement.end();
+        (0, _BundleGraphRequestUtils.dumpBundleGraphSnapshot)(internalBundleGraph, 'js');
         if (this.pluginOptions.mode === 'production') {
           let optimizeMeasurement;
           try {

package/lib/requests/BundleGraphRequestRust.js

@@ -96,6 +96,7 @@ function createBundleGraphRequestRust(input) {
         bundleGraph,
         changedAssets
       } = (0, _logger().instrument)('atlaspack_v3_getBundleGraph', () => getBundleGraph(serializedBundleGraph));
+      (0, _BundleGraphRequestUtils.dumpBundleGraphSnapshot)(bundleGraph, 'rust');
       const runner = new NativeBundlerRunner({
         api,
         options

package/lib/requests/BundleGraphRequestUtils.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.dumpBundleGraphSnapshot = dumpBundleGraphSnapshot;
 exports.loadPluginConfigWithDevDeps = loadPluginConfigWithDevDeps;
 exports.nameBundle = nameBundle;
 exports.runDevDepRequest = runDevDepRequest;
@@ -14,6 +15,13 @@ function _assert() {
   };
   return data;
 }
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
   _nullthrows = function () {
@@ -21,6 +29,13 @@ function _nullthrows() {
   };
   return data;
 }
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
 function _logger() {
   const data = require("@atlaspack/logger");
   _logger = function () {
@@ -42,7 +57,8 @@ function _utils() {
   };
   return data;
 }
-var _BundleGraph = _interopRequireDefault(require("../public/BundleGraph"));
+var _BundleGraph = require("../BundleGraph");
+var _BundleGraph2 = _interopRequireDefault(require("../public/BundleGraph"));
 var _Bundle = require("../public/Bundle");
 var _InternalConfig = require("../InternalConfig");
 var _DevDepRequest = require("./DevDepRequest");
@@ -75,12 +91,126 @@ function validateBundles(bundleGraph) {
   _assert().default.deepEqual(bundleNames, (0, _utils().unique)(bundleNames), 'Bundles must have unique name. Conflicting names: ' + [...(0, _utils().setSymmetricDifference)(new Set(bundleNames), new Set((0, _utils().unique)(bundleNames)))].join());
 }
 
+/**
+ * Dump a canonical JSON snapshot of the bundle graph for parity comparison.
+ * Gated by ATLASPACK_DUMP_BUNDLE_GRAPH environment variable which specifies the output directory.
+ * The snapshot captures bundle identity, type, contained assets, and bundle group structure
+ * in a deterministic, sorted format suitable for diffing.
+ */
+function dumpBundleGraphSnapshot(bundleGraph, variant) {
+  let outDir = process.env.ATLASPACK_DUMP_BUNDLE_GRAPH;
+  if (!outDir) return;
+  let filename = variant === 'js' ? 'bundle-graph-js.json' : 'bundle-graph-rust.json';
+  let outPath = _path().default.join(outDir, filename);
+  _fs().default.mkdirSync(outDir, {
+    recursive: true
+  });
+  let bundles = bundleGraph.getBundles();
+  let bundlesSnapshot = bundles.map(bundle => {
+    let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.id);
+    let containedAssetNodeIds = bundleGraph._graph.getNodeIdsConnectedFrom(bundleNodeId, _BundleGraph.bundleGraphEdgeTypes.contains);
+    let containedAssets = containedAssetNodeIds.map(nodeId => bundleGraph._graph.getNode(nodeId)).flatMap(node => {
+      if ((node === null || node === void 0 ? void 0 : node.type) !== 'asset') return [];
+      return [{
+        id: node.value.id,
+        filePath: (0, _projectPath.fromProjectPathRelative)(node.value.filePath)
+      }];
+    }).sort((a, b) => a.filePath.localeCompare(b.filePath));
+
+    // Resolve mainEntry and entry asset file paths
+    let mainEntryPath = null;
+    let entryAssetPaths = [];
+    if (bundle.mainEntryId) {
+      let mainEntryNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.mainEntryId);
+      let mainEntryNode = bundleGraph._graph.getNode(mainEntryNodeId);
+      if ((mainEntryNode === null || mainEntryNode === void 0 ? void 0 : mainEntryNode.type) === 'asset') {
+        mainEntryPath = (0, _projectPath.fromProjectPathRelative)(mainEntryNode.value.filePath);
+      }
+    }
+    for (let entryId of bundle.entryAssetIds) {
+      let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(entryId);
+      let entryNode = bundleGraph._graph.getNode(entryNodeId);
+      if ((entryNode === null || entryNode === void 0 ? void 0 : entryNode.type) === 'asset') {
+        entryAssetPaths.push((0, _projectPath.fromProjectPathRelative)(entryNode.value.filePath));
+      }
+    }
+    entryAssetPaths.sort();
+    return {
+      id: bundle.id,
+      type: bundle.type,
+      bundleBehavior: bundle.bundleBehavior ?? null,
+      needsStableName: bundle.needsStableName,
+      isSplittable: bundle.isSplittable,
+      isPlaceholder: bundle.isPlaceholder,
+      mainEntryPath,
+      entryAssetPaths,
+      assets: containedAssets.map(a => a.filePath)
+    };
+  }).sort((a, b) => {
+    // Sort by mainEntryPath first, then by sorted assets as tiebreaker
+    let aKey = a.mainEntryPath || a.assets.join(',');
+    let bKey = b.mainEntryPath || b.assets.join(',');
+    return aKey.localeCompare(bKey);
+  });
+  let bundleGroupsSnapshot = bundleGraph._graph.nodes.flatMap(node => {
+    if ((node === null || node === void 0 ? void 0 : node.type) !== 'bundle_group') return [];
+    let bundleGroup = node.value;
+
+    // Resolve entry asset file path
+    let entryAssetPath = null;
+    try {
+      let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(bundleGroup.entryAssetId);
+      let entryNode = bundleGraph._graph.getNode(entryNodeId);
+      if ((entryNode === null || entryNode === void 0 ? void 0 : entryNode.type) === 'asset') {
+        entryAssetPath = (0, _projectPath.fromProjectPathRelative)(entryNode.value.filePath);
+      }
+    } catch {
+      // Content key not found
+    }
+    let bundlesInGroup = bundleGraph.getBundlesInBundleGroup(bundleGroup);
+    let bundlePaths = bundlesInGroup.map(b => {
+      // Use mainEntry file path if available, otherwise bundle id as fallback
+      if (b.mainEntryId) {
+        try {
+          let nodeId = bundleGraph._graph.getNodeIdByContentKey(b.mainEntryId);
+          let node = bundleGraph._graph.getNode(nodeId);
+          if ((node === null || node === void 0 ? void 0 : node.type) === 'asset') {
+            return (0, _projectPath.fromProjectPathRelative)(node.value.filePath);
+          }
+        } catch {
+          // fallback
+        }
+      }
+      return `[bundle:${b.id}]`;
+    }).sort();
+    return [{
+      entryAssetPath: entryAssetPath ?? `[unknown:${bundleGroup.entryAssetId}]`,
+      bundlePaths
+    }];
+  }).sort((a, b) => a.entryAssetPath.localeCompare(b.entryAssetPath));
+  let totalAssets = bundleGraph._graph.nodes.filter(node => (node === null || node === void 0 ? void 0 : node.type) === 'asset').length;
+  let snapshot = {
+    version: 1,
+    variant,
+    stats: {
+      totalBundles: bundlesSnapshot.length,
+      totalBundleGroups: bundleGroupsSnapshot.length,
+      totalAssets
+    },
+    bundles: bundlesSnapshot,
+    bundleGroups: bundleGroupsSnapshot
+  };
+  _fs().default.writeFileSync(outPath, JSON.stringify(snapshot, null, 2), 'utf8');
+  // eslint-disable-next-line no-console
+  console.log(`[BundleGraphSnapshot] Wrote ${variant} snapshot to ${outPath}`);
+}
+
 /**
  * Names a bundle by running through the configured namers until one returns a name.
  */
 async function nameBundle(namers, internalBundle, internalBundleGraph, options, pluginOptions, configs) {
   const bundle = _Bundle.Bundle.get(internalBundle, internalBundleGraph, options);
-  const bundleGraph = new _BundleGraph.default(internalBundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), options);
+  const bundleGraph = new _BundleGraph2.default(internalBundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), options);
   for (const namer of namers) {
     let measurement;
     try {

package/lib/types/requests/BundleGraphRequestUtils.d.ts

@@ -17,6 +17,13 @@ import type { BundleGraphResult } from './BundleGraphRequest';
  * Throws an assertion error if duplicate bundle names are found.
  */
 export declare function validateBundles(bundleGraph: InternalBundleGraph): void;
+/**
+ * Dump a canonical JSON snapshot of the bundle graph for parity comparison.
+ * Gated by ATLASPACK_DUMP_BUNDLE_GRAPH environment variable which specifies the output directory.
+ * The snapshot captures bundle identity, type, contained assets, and bundle group structure
+ * in a deterministic, sorted format suitable for diffing.
+ */
+export declare function dumpBundleGraphSnapshot(bundleGraph: InternalBundleGraph, variant: 'js' | 'rust'): void;
 /**
  * Names a bundle by running through the configured namers until one returns a name.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.16.2-canary.431+de388ff76",
+  "version": "2.16.2-canary.433+f7878b2f1",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -22,22 +22,22 @@
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.499+de388ff76",
-    "@atlaspack/cache": "3.1.1-canary.431+de388ff76",
-    "@atlaspack/diagnostic": "2.14.1-canary.499+de388ff76",
-    "@atlaspack/events": "2.14.1-canary.499+de388ff76",
-    "@atlaspack/feature-flags": "2.14.1-canary.499+de388ff76",
-    "@atlaspack/fs": "2.14.5-canary.431+de388ff76",
-    "@atlaspack/graph": "3.4.1-canary.499+de388ff76",
-    "@atlaspack/logger": "2.14.5-canary.431+de388ff76",
-    "@atlaspack/package-manager": "2.14.5-canary.431+de388ff76",
-    "@atlaspack/plugin": "2.14.5-canary.431+de388ff76",
-    "@atlaspack/profiler": "2.14.1-canary.499+de388ff76",
-    "@atlaspack/rust": "3.2.1-canary.431+de388ff76",
-    "@atlaspack/source-map": "3.2.11-canary.4210+de388ff76",
-    "@atlaspack/types": "2.14.5-canary.431+de388ff76",
-    "@atlaspack/utils": "2.14.5-canary.431+de388ff76",
-    "@atlaspack/workers": "2.14.5-canary.431+de388ff76",
+    "@atlaspack/build-cache": "2.13.3-canary.501+f7878b2f1",
+    "@atlaspack/cache": "3.1.1-canary.433+f7878b2f1",
+    "@atlaspack/diagnostic": "2.14.1-canary.501+f7878b2f1",
+    "@atlaspack/events": "2.14.1-canary.501+f7878b2f1",
+    "@atlaspack/feature-flags": "2.14.1-canary.501+f7878b2f1",
+    "@atlaspack/fs": "2.14.5-canary.433+f7878b2f1",
+    "@atlaspack/graph": "3.4.1-canary.501+f7878b2f1",
+    "@atlaspack/logger": "2.14.5-canary.433+f7878b2f1",
+    "@atlaspack/package-manager": "2.14.5-canary.433+f7878b2f1",
+    "@atlaspack/plugin": "2.14.5-canary.433+f7878b2f1",
+    "@atlaspack/profiler": "2.14.1-canary.501+f7878b2f1",
+    "@atlaspack/rust": "3.2.1-canary.433+f7878b2f1",
+    "@atlaspack/source-map": "3.2.11-canary.4212+f7878b2f1",
+    "@atlaspack/types": "2.14.5-canary.433+f7878b2f1",
+    "@atlaspack/utils": "2.14.5-canary.433+f7878b2f1",
+    "@atlaspack/workers": "2.14.5-canary.433+f7878b2f1",
     "@mischnic/json-sourcemap": "^0.1.0",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
@@ -61,5 +61,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "de388ff76d39dece97ad475fcccdb6efb6283bfc"
+  "gitHead": "f7878b2f19a0a3bbd0e79d0b4a4e1479646043b7"
 }

package/src/requests/BundleGraphRequest.ts

@@ -43,6 +43,7 @@ import {
   nameBundle,
   loadPluginConfigWithDevDeps,
   runDevDepRequest as runDevDepRequestShared,
+  dumpBundleGraphSnapshot,
 } from './BundleGraphRequestUtils';
 import createAssetGraphRequestJS from './AssetGraphRequest';
 import {createAssetGraphRequestRust} from './AssetGraphRequestRust';
@@ -396,16 +397,20 @@ class BundlerRunner {
         }
 
         // this the normal bundle workflow (bundle, optimizing, run-times, naming)
-        await bundler.bundle({
-          bundleGraph: mutableBundleGraph,
-          config: this.configs.get(plugin.name)?.result,
-          options: this.pluginOptions,
-          logger,
-          tracer,
+        await instrumentAsync('bundle (V2)', async () => {
+          await bundler.bundle({
+            bundleGraph: mutableBundleGraph,
+            config: this.configs.get(plugin.name)?.result,
+            options: this.pluginOptions,
+            logger,
+            tracer,
+          });
         });
 
         measurement && measurement.end();
 
+        dumpBundleGraphSnapshot(internalBundleGraph, 'js');
+
         if (this.pluginOptions.mode === 'production') {
           let optimizeMeasurement;
           try {

package/src/requests/BundleGraphRequestRust.ts

@@ -32,6 +32,7 @@ import {
   nameBundle,
   loadPluginConfigWithDevDeps,
   runDevDepRequest,
+  dumpBundleGraphSnapshot,
 } from './BundleGraphRequestUtils';
 import {toEnvironmentRef} from '../EnvironmentManager';
 import {getEnvironmentHash} from '../Environment';
@@ -109,6 +110,8 @@ export default function createBundleGraphRequestRust(
         () => getBundleGraph(serializedBundleGraph),
       );
 
+      dumpBundleGraphSnapshot(bundleGraph, 'rust');
+
       const runner = new NativeBundlerRunner(
         {api, options} as any,
         input.optionsRef,