@atlaspack/core 2.35.0 → 2.38.0

package/dist/requests/WriteBundleRequest.js

@@ -36,8 +36,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceMapHashRefRewriteStream = void 0;
 exports.default = createWriteBundleRequest;
 exports.applyReplacementsToSourceMap = applyReplacementsToSourceMap;
+exports.applyReplacementsToVLQMappings = applyReplacementsToVLQMappings;
 exports.computeSourceMapRoot = computeSourceMapRoot;
 const constants_1 = require("../constants");
 const nullthrows_1 = __importDefault(require("nullthrows"));
@@ -56,10 +58,12 @@ const profiler_1 = require("@atlaspack/profiler");
 const RequestTracker_1 = require("../RequestTracker");
 const feature_flags_1 = require("@atlaspack/feature-flags");
 const EnvironmentManager_1 = require("../EnvironmentManager");
-const source_map_1 = __importDefault(require("@atlaspack/source-map"));
+const source_map_1 = require("@atlaspack/source-map");
 const HASH_REF_PREFIX_LEN = constants_1.HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = constants_1.HASH_REF_PREFIX.length + 32 - 1;
 const HASH_REF_PLACEHOLDER_LEN = HASH_REF_PREFIX_LEN + constants_1.HASH_REF_HASH_LEN;
+// The JSON key prefix we scan for in the source map stream.
+const MAPPINGS_KEY_BUF = Buffer.from('"mappings":"');
 /**
  * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
  */
@@ -136,28 +140,14 @@ async function run({ input, options, api }) {
     await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api, bundleReplacements);
     const hasSourceMap = await options.cache.has(mapKey);
     if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
+        const mapEntry = await options.cache.getBlob(mapKey);
         let mapStream;
         if ((0, feature_flags_1.getFeatureFlag)('fixSourceMapHashRefs') &&
             bundleReplacements &&
             bundleReplacements.length > 0) {
-            const mapEntry = await options.cache.getBlob(mapKey);
-            const mapBuffer = Buffer.isBuffer(mapEntry)
-                ? mapEntry
-                : Buffer.from(mapEntry);
-            const projectRoot = typeof options.projectRoot === 'string'
-                ? options.projectRoot
-                : String(options.projectRoot);
-            const sourceMap = new source_map_1.default(projectRoot, mapBuffer);
-            applyReplacementsToSourceMap(sourceMap, bundleReplacements);
-            const mapJson = await sourceMap.stringify({
-                format: 'string',
-                file: name,
-                sourceRoot: computeSourceMapRoot(bundle, options),
-            });
-            mapStream = (0, utils_1.blobToStream)(Buffer.from(typeof mapJson === 'string' ? mapJson : JSON.stringify(mapJson), 'utf8'));
+            mapStream = (0, utils_1.blobToStream)(mapEntry).pipe(new SourceMapHashRefRewriteStream(bundleReplacements));
         }
         else {
-            const mapEntry = await options.cache.getBlob(mapKey);
             mapStream = (0, utils_1.blobToStream)(mapEntry);
         }
         await writeFiles(mapStream, info, hashRefToNameHash, options, config, outputFS, (0, projectPath_1.toProjectPathUnsafe)((0, projectPath_1.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
@@ -192,6 +182,167 @@ function applyReplacementsToSourceMap(sourceMap, replacements) {
         }
     }
 }
+/**
+ * Applies hash-ref replacement column offsets directly to a VLQ mappings
+ * string without deserializing the full source map into a native struct.
+ *
+ * Each replacement r describes a hash-ref that was substituted in the output
+ * file.  r.column is in the progressively-shifted post-replacement coordinate
+ * space (matching the already-shifted source map state after all previous
+ * offsetColumns calls), so thresholds are applied sequentially against the
+ * running absCol values exactly as the native offsetColumns implementation does.
+ */
+function applyReplacementsToVLQMappings(mappings, replacements) {
+    if (replacements.length === 0)
+        return mappings;
+    // Group replacements by line (0-indexed), sorted by column ascending.
+    const byLine = new Map();
+    for (const r of replacements) {
+        let arr = byLine.get(r.line);
+        if (!arr) {
+            arr = [];
+            byLine.set(r.line, arr);
+        }
+        arr.push(r);
+    }
+    for (const arr of byLine.values()) {
+        arr.sort((a, b) => a.column - b.column);
+    }
+    const lines = mappings.split(';');
+    const resultLines = [];
+    for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+        const lineReps = byLine.get(lineIdx);
+        if (!lineReps || lineReps.length === 0) {
+            resultLines.push(lines[lineIdx]);
+            continue;
+        }
+        const line = lines[lineIdx];
+        if (!line) {
+            resultLines.push('');
+            continue;
+        }
+        // Decode segment column deltas to absolute columns.
+        const segments = line.split(',');
+        const colVlqEnds = [];
+        const absCols = [];
+        let absCol = 0;
+        for (const seg of segments) {
+            const { value: colDelta, nextPos } = (0, source_map_1.decodeVLQ)(seg, 0);
+            absCol += colDelta;
+            colVlqEnds.push(nextPos);
+            absCols.push(absCol);
+        }
+        // Apply each replacement's column shift sequentially against the
+        // current absCol values (which have already been adjusted by previous
+        // replacements on this line), mirroring the sequential offsetColumns calls.
+        for (const r of lineReps) {
+            const delta = r.newLength - r.originalLength;
+            if (delta === 0)
+                continue;
+            const threshold = r.column + r.originalLength;
+            for (let i = 0; i < absCols.length; i++) {
+                if (absCols[i] >= threshold) {
+                    absCols[i] += delta;
+                }
+            }
+        }
+        // Re-encode with updated absolute columns; only the leading column VLQ
+        // field of each segment changes – the tail bytes are sliced unchanged.
+        const resultSegments = [];
+        let prevAbsCol = 0;
+        for (let i = 0; i < segments.length; i++) {
+            const newDelta = absCols[i] - prevAbsCol;
+            prevAbsCol = absCols[i];
+            resultSegments.push((0, source_map_1.encodeVLQ)(newDelta) + segments[i].slice(colVlqEnds[i]));
+        }
+        resultLines.push(resultSegments.join(','));
+    }
+    return resultLines.join(';');
+}
+/**
+ * A Transform stream that rewrites the "mappings" VLQ field of a source map
+ * JSON to account for hash-ref replacements, without ever loading the full
+ * JSON object or the native Rust SourceMapInner into memory.
+ *
+ * Field order in cached source maps (from partialVlqMapToSourceMap / toVLQ):
+ *   mappings → sources → sourcesContent → names → version → file → sourceRoot
+ *
+ * "mappings" is the very first field, so we scan only a tiny header before
+ * switching to zero-copy passthrough for the bulk sourcesContent bytes.
+ */
+class SourceMapHashRefRewriteStream extends stream_1.Transform {
+    constructor(replacements) {
+        super();
+        this.replacements = replacements;
+        this.state = 'scanning';
+        this.scanBuf = Buffer.alloc(0);
+        this.mappingsBufs = [];
+    }
+    // @ts-expect-error TS7006
+    _transform(chunk, _encoding, cb) {
+        if (this.state === 'passthrough') {
+            this.push(chunk);
+            cb();
+            return;
+        }
+        if (this.state === 'scanning') {
+            const combined = Buffer.concat([this.scanBuf, chunk]);
+            const idx = combined.indexOf(MAPPINGS_KEY_BUF);
+            if (idx === -1) {
+                // Key not yet found – hold back enough bytes to handle a split key.
+                const keepLen = Math.min(combined.length, MAPPINGS_KEY_BUF.length - 1);
+                if (combined.length > keepLen) {
+                    this.push(combined.slice(0, combined.length - keepLen));
+                }
+                this.scanBuf = combined.slice(combined.length - keepLen);
+                cb();
+                return;
+            }
+            // Emit everything up to and including the key.
+            const keyEnd = idx + MAPPINGS_KEY_BUF.length;
+            this.push(combined.slice(0, keyEnd));
+            this.scanBuf = Buffer.alloc(0);
+            this.state = 'buffering';
+            this._bufferingTransform(combined.slice(keyEnd), cb);
+            return;
+        }
+        // state === 'buffering'
+        this._bufferingTransform(chunk, cb);
+    }
+    // @ts-expect-error TS7006
+    _bufferingTransform(chunk, cb) {
+        // Mappings values contain only base64 chars, ';', and ',' – no escaping –
+        // so scanning for the closing '"' (0x22) is safe.
+        const closeIdx = chunk.indexOf(0x22);
+        if (closeIdx === -1) {
+            this.mappingsBufs.push(chunk);
+            cb();
+            return;
+        }
+        this.mappingsBufs.push(chunk.slice(0, closeIdx));
+        // VLQ chars are all ASCII (<128), so latin1 round-trips without loss.
+        const mappingsStr = Buffer.concat(this.mappingsBufs).toString('latin1');
+        const rewritten = applyReplacementsToVLQMappings(mappingsStr, this.replacements);
+        this.push(Buffer.from(rewritten, 'latin1'));
+        // Emit the closing '"' and everything remaining in one push.
+        this.push(chunk.slice(closeIdx));
+        this.state = 'passthrough';
+        this.mappingsBufs = [];
+        cb();
+    }
+    // @ts-expect-error TS7006
+    _flush(cb) {
+        if (this.state === 'scanning' && this.scanBuf.length > 0) {
+            this.push(this.scanBuf);
+        }
+        else if (this.state === 'buffering') {
+            // Malformed JSON – flush whatever we buffered as-is.
+            this.push(Buffer.concat(this.mappingsBufs));
+        }
+        cb();
+    }
+}
+exports.SourceMapHashRefRewriteStream = SourceMapHashRefRewriteStream;
 /**
  * Computes the sourceRoot for a source map file. This is the relative path from
  * the output directory back to the project root, so that source paths (stored

package/lib/Atlaspack.js

@@ -118,6 +118,7 @@ function _featureFlags() {
 var _atlaspackV = require("./atlaspack-v3");
 var _AssetGraphRequest = _interopRequireDefault(require("./requests/AssetGraphRequest"));
 var _AssetGraphRequestRust = require("./requests/AssetGraphRequestRust");
+var _BundleGraphRequestRust = require("./requests/BundleGraphRequestRust");
 var _rustWorkerThreadDylibHack = require("./rustWorkerThreadDylibHack");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
@@ -197,7 +198,7 @@ class Atlaspack {
     });
     this.#resolvedOptions = resolvedOptions;
     let rustAtlaspack;
-    if (resolvedOptions.featureFlags.atlaspackV3 || resolvedOptions.featureFlags.nativePackager) {
+    if (resolvedOptions.featureFlags.atlaspackV3 || resolvedOptions.featureFlags.fullNative || resolvedOptions.featureFlags.nativePackager) {
       // eslint-disable-next-line no-unused-vars
       let {
         entries,
@@ -428,20 +429,51 @@ class Atlaspack {
         type: 'buildStart'
       });
       this.#requestTracker.graph.invalidateOnBuildNodes();
-      let request = (0, _AtlaspackBuildRequest.default)({
-        optionsRef: this.#optionsRef,
-        requestedAssetIds: this.#requestedAssetIds,
-        signal
-      });
-      let {
-        bundleGraph,
-        bundleInfo,
-        changedAssets,
-        assetRequests,
-        scopeHoistingStats
-      } = await this.#requestTracker.runRequest(request, {
-        force: true
-      });
+      let bundleGraph;
+      let bundleInfo;
+      let changedAssets;
+      let assetRequests;
+      let scopeHoistingStats;
+      if ((0, _featureFlags().getFeatureFlag)('fullNative') && this.rustAtlaspack) {
+        let [result, error] = await this.rustAtlaspack.build(eventJson => {
+          let event = JSON.parse(eventJson);
+          this.#reporterRunner.report(event);
+        });
+        if (error) {
+          throw new (_diagnostic().default)({
+            diagnostic: error
+          });
+        }
+        ({
+          bundleGraph,
+          changedAssets
+        } = (0, _BundleGraphRequestRust.getBundleGraph)(result));
+        bundleInfo = new Map((result.bundleInfo ?? []).map(info => [info.bundleId, {
+          filePath: (0, _projectPath.toProjectPath)(options.projectRoot, info.filePath),
+          bundleId: info.bundleId,
+          type: info.type,
+          stats: {
+            size: info.size,
+            time: info.time
+          }
+        }]));
+        assetRequests = result.assetRequests ?? [];
+      } else {
+        let request = (0, _AtlaspackBuildRequest.default)({
+          optionsRef: this.#optionsRef,
+          requestedAssetIds: this.#requestedAssetIds,
+          signal
+        });
+        ({
+          bundleGraph,
+          bundleInfo,
+          changedAssets,
+          assetRequests,
+          scopeHoistingStats
+        } = await this.#requestTracker.runRequest(request, {
+          force: true
+        }));
+      }
       this.#requestedAssetIds.clear();
       await (0, _dumpGraphToGraphViz.default)(
       // @ts-expect-error TS2345

package/lib/atlaspack-v3/AtlaspackV3.js

@@ -69,11 +69,14 @@ class AtlaspackV3 {
       this._napiWorkerPool.shutdown();
     }
   }
-  buildAssetGraph() {
-    return (0, _rust().atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
+  buildAssetGraph(progressCallback) {
+    return (0, _rust().atlaspackNapiBuildAssetGraph)(this._atlaspack_napi, progressCallback);
   }
-  buildBundleGraph() {
-    return (0, _rust().atlaspackNapiBuildBundleGraph)(this._atlaspack_napi);
+  buildBundleGraph(progressCallback) {
+    return (0, _rust().atlaspackNapiBuildBundleGraph)(this._atlaspack_napi, progressCallback);
+  }
+  build(progressCallback) {
+    return (0, _rust().atlaspackNapiBuild)(this._atlaspack_napi, progressCallback);
   }
   loadBundleGraph(bundleGraph) {
     const {

package/lib/atlaspack-v3/fs.js

@@ -37,5 +37,6 @@ class FileSystemV3 {
       return this.#fs.readFileSync(path, encoding);
     }
   });
+  writeFile = (0, _jsCallable.jsCallable)((path, contents) => this.#fs.writeFile(path, Buffer.from(contents)));
 }
 exports.FileSystemV3 = FileSystemV3;

package/lib/atlaspack-v3/worker/worker.js

@@ -186,14 +186,25 @@ class AtlaspackWorker {
         }
       };
     }
+    // A resolver may return a result without filePath to indicate it didn't
+    // resolve the dependency (equivalent to returning null). The JS-side
+    // PathRequest treats this as "try the next resolver".
+    if (!result.filePath) {
+      return {
+        invalidations: [],
+        resolution: {
+          type: 'unresolved'
+        }
+      };
+    }
     return {
       invalidations: [],
       resolution: {
         type: 'resolved',
-        filePath: result.filePath || '',
+        filePath: result.filePath,
         canDefer: result.canDefer || false,
         sideEffects: result.sideEffects ?? true,
-        code: result.code || undefined,
+        code: result.code ?? undefined,
         meta: result.meta || undefined,
         pipeline: result.pipeline || undefined,
         priority: _compat.dependencyPriorityMap.intoNullable(result.priority),

package/lib/requests/AssetGraphRequestRust.js

@@ -34,6 +34,7 @@ function _featureFlags() {
   return data;
 }
 var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
+var _ReporterRunner = require("../ReporterRunner");
 var _RequestTracker = require("../RequestTracker");
 var _SymbolPropagation = require("../SymbolPropagation");
 var _EnvironmentManager = require("../EnvironmentManager");
@@ -51,7 +52,10 @@ function createAssetGraphRequestRust(rustAtlaspack) {
       let {
         assetGraphPromise,
         commitPromise
-      } = await rustAtlaspack.buildAssetGraph();
+      } = await rustAtlaspack.buildAssetGraph(eventJson => {
+        let event = JSON.parse(eventJson);
+        (0, _ReporterRunner.report)(event);
+      });
       let [serializedAssetGraph, assetGraphError] = await assetGraphPromise;
       if (assetGraphError) {
         throw new (_diagnostic().default)({

package/lib/requests/AtlaspackBuildRequest.js

@@ -30,6 +30,13 @@ function _featureFlags() {
   return data;
 }
 var _EnvironmentManager = require("../EnvironmentManager");
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAtlaspackBuildRequest(input) {
   return {
@@ -96,6 +103,7 @@ async function run({
     changedAssets: new Map(Array.from(changedAssets).map(([id, asset]) => [id, (0, _Asset.assetFromValue)(asset, options)]))
   });
   let packagingMeasurement = _profiler().tracer.createMeasurement('packaging');
+  const span = _logger().tracer.enter('writeBundles');
   let writeBundlesRequest = (0, _WriteBundlesRequest.default)({
     bundleGraph,
     optionsRef
@@ -105,6 +113,7 @@ async function run({
     scopeHoistingStats
   } = await api.runRequest(writeBundlesRequest);
   packagingMeasurement && packagingMeasurement.end();
+  _logger().tracer.exit(span);
   (0, _utils.assertSignalNotAborted)(signal);
   return {
     bundleGraph,

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

@@ -41,6 +41,7 @@ function _featureFlags() {
   return data;
 }
 var _BundleGraph = _interopRequireWildcard(require("../BundleGraph"));
+var _ReporterRunner = require("../ReporterRunner");
 var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
 function _nullthrows() {
   const data = _interopRequireDefault(require("nullthrows"));
@@ -83,7 +84,10 @@ function createBundleGraphRequestRust(input) {
       let {
         bundleGraphPromise,
         commitPromise
-      } = await rustAtlaspack.buildBundleGraph();
+      } = await rustAtlaspack.buildBundleGraph(eventJson => {
+        let event = JSON.parse(eventJson);
+        (0, _ReporterRunner.report)(event);
+      });
       let [serializedBundleGraph, bundleGraphError] = await bundleGraphPromise;
       if (bundleGraphError) {
         throw new (_diagnostic().default)({
@@ -96,6 +100,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 {