@atlaspack/core 2.35.0 → 2.38.0

package/CHANGELOG.md

@@ -1,5 +1,112 @@
 # @atlaspack/core
 
+## 2.38.0
+
+### Minor Changes
+
+- [#1054](https://github.com/atlassian-labs/atlaspack/pull/1054) [`ffa1e42`](https://github.com/atlassian-labs/atlaspack/commit/ffa1e4276c22cc48b6be45ac81df8adde85f2237) Thanks [@marcins](https://github.com/marcins)! - - Implement plumbing to ensure data flows back out of build request that JS expects
+  - Implement a temporary namer to get an end-to-end test working
+
+- [#1057](https://github.com/atlassian-labs/atlaspack/pull/1057) [`939d5bd`](https://github.com/atlassian-labs/atlaspack/commit/939d5bd41b3bcb5508f58ca41165d48122762e26) Thanks [@marcins](https://github.com/marcins)! - Set `SyntaxError` as the diagnostic name for parse/syntax errors from the JS and Tokens transformers.
+
+  Parse and syntax errors from the JS Transformer and Tokens Transformer now set `diagnostic.name` to `"SyntaxError"`, so consumers can reliably detect syntax/parse failures (e.g. for reporting or error handling). The Rust diagnostic type and NAPI `JsDiagnostic` include an optional `name` field; `error_buffer_to_diagnostics` sets it to `"SyntaxError"` for SWC parse errors, and both transformers pass it through to the thrown diagnostic. Integration tests assert that the first diagnostic has `name === 'SyntaxError'` for tokens and JS parse-error cases.
+
+- [#1053](https://github.com/atlassian-labs/atlaspack/pull/1053) [`71981ea`](https://github.com/atlassian-labs/atlaspack/commit/71981eac258f7e6dfb40ec4b202d194f71c64ff1) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Add native build progress reporting.
+
+  Fires `BuildProgressEvent` from Rust requests back to JS reporters via a fire-and-forget
+  `ThreadsafeFunction` callback. Works in both `atlaspackV3` and `fullNative` build paths.
+
+  Events:
+  - `building` — per-asset progress from AssetGraphRequest (completeAssets / totalAssets)
+  - `bundling` — once from BuildRequest before bundle graph creation
+  - `packagingAndOptimizing` — ready for when native packaging is wired up
+
+  Adds `BuildingProgressEvent` type and CLI reporter handling.
+
+### Patch Changes
+
+- [#1056](https://github.com/atlassian-labs/atlaspack/pull/1056) [`0bb5830`](https://github.com/atlassian-labs/atlaspack/commit/0bb5830d1a7800e673f21ab020cd86bef873df9c) Thanks [@marcins](https://github.com/marcins)! - Fix native config loader rejecting TypeScript entry points in package.json.
+
+  The Rust package.json deserializer rejected `.ts` and `.tsx` extensions in builtin target fields
+  (`main`, `browser`, `module`), causing builds to fail with "Unexpected file type" errors when a
+  package.json uses TypeScript source entry points (e.g. `"main": "index.ts"`).
+
+  Additionally fixes EntryRequest to resolve the package path using `cwd()` instead of `project_root`,
+  matching the JS-side behavior for correct target resolution in monorepo setups.
+
+- Updated dependencies [[`ffa1e42`](https://github.com/atlassian-labs/atlaspack/commit/ffa1e4276c22cc48b6be45ac81df8adde85f2237), [`ea9730d`](https://github.com/atlassian-labs/atlaspack/commit/ea9730dd953d0512c2ab97cbba810e7a297a29a6), [`939d5bd`](https://github.com/atlassian-labs/atlaspack/commit/939d5bd41b3bcb5508f58ca41165d48122762e26), [`71981ea`](https://github.com/atlassian-labs/atlaspack/commit/71981eac258f7e6dfb40ec4b202d194f71c64ff1), [`0bb5830`](https://github.com/atlassian-labs/atlaspack/commit/0bb5830d1a7800e673f21ab020cd86bef873df9c), [`cba96b1`](https://github.com/atlassian-labs/atlaspack/commit/cba96b1a15c07703ee104bf2a2888cc715575cbd)]:
+  - @atlaspack/rust@3.26.0
+  - @atlaspack/utils@3.4.0
+  - @atlaspack/cache@3.2.53
+  - @atlaspack/fs@2.15.53
+  - @atlaspack/logger@2.14.50
+  - @atlaspack/source-map@3.3.2
+  - @atlaspack/graph@3.6.20
+  - @atlaspack/plugin@2.14.58
+  - @atlaspack/profiler@2.15.19
+  - @atlaspack/types@2.15.48
+  - @atlaspack/workers@2.14.58
+  - @atlaspack/package-manager@2.14.58
+
+## 2.37.0
+
+### Minor Changes
+
+- [#1050](https://github.com/atlassian-labs/atlaspack/pull/1050) [`c80be61`](https://github.com/atlassian-labs/atlaspack/commit/c80be618e42014208fed60b7a2dccc2e47d53aed) Thanks [@marcins](https://github.com/marcins)! - Add native PackagingRequest, implement temporary JS version for testing.
+
+### Patch Changes
+
+- [#1051](https://github.com/atlassian-labs/atlaspack/pull/1051) [`2d3c616`](https://github.com/atlassian-labs/atlaspack/commit/2d3c616bb2ebef55d6850e8ca9eedf13c72f5386) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Add native end-to-end build pipeline via BuildRequest.
+
+  When the `fullNative` feature flag is enabled, the entire build pipeline (asset graph, bundle graph,
+  packaging) runs natively in Rust via a single NAPI call, bypassing the JS request tracker.
+
+  Key changes:
+  - Add `BuildRequest` composing `AssetGraphRequest` and `BundleGraphRequest` with a packaging stub
+  - Add `Atlaspack::build()` method and `atlaspack_napi_build` NAPI binding
+  - Add `fullNative` feature flag gating the native path in `Atlaspack.ts._build()`
+  - Packaging step is a no-op pending PackagingRequest implementation
+
+- Updated dependencies [[`c80be61`](https://github.com/atlassian-labs/atlaspack/commit/c80be618e42014208fed60b7a2dccc2e47d53aed), [`2d3c616`](https://github.com/atlassian-labs/atlaspack/commit/2d3c616bb2ebef55d6850e8ca9eedf13c72f5386)]:
+  - @atlaspack/feature-flags@2.31.0
+  - @atlaspack/rust@3.25.0
+  - @atlaspack/build-cache@2.13.14
+  - @atlaspack/cache@3.2.52
+  - @atlaspack/fs@2.15.52
+  - @atlaspack/graph@3.6.19
+  - @atlaspack/utils@3.3.9
+  - @atlaspack/logger@2.14.49
+  - @atlaspack/source-map@3.3.1
+  - @atlaspack/package-manager@2.14.57
+  - @atlaspack/workers@2.14.57
+  - @atlaspack/plugin@2.14.57
+  - @atlaspack/profiler@2.15.18
+  - @atlaspack/types@2.15.47
+
+## 2.36.0
+
+### Minor Changes
+
+- [#1047](https://github.com/atlassian-labs/atlaspack/pull/1047) [`de388ff`](https://github.com/atlassian-labs/atlaspack/commit/de388ff76d39dece97ad475fcccdb6efb6283bfc) Thanks [@marcins](https://github.com/marcins)! - Change approach to source map offset for hashRefs - use a streaming approach to avoid loading large sourcemaps into memory.
+
+### Patch Changes
+
+- [#1025](https://github.com/atlassian-labs/atlaspack/pull/1025) [`f7878b2`](https://github.com/atlassian-labs/atlaspack/commit/f7878b2f19a0a3bbd0e79d0b4a4e1479646043b7) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Add native ideal graph bundling algorithm behind nativeBundling feature flag
+
+- Updated dependencies [[`f7878b2`](https://github.com/atlassian-labs/atlaspack/commit/f7878b2f19a0a3bbd0e79d0b4a4e1479646043b7), [`22bb49c`](https://github.com/atlassian-labs/atlaspack/commit/22bb49c5708798d259f98c8b5c10850b2f4f5f1b), [`bddd21a`](https://github.com/atlassian-labs/atlaspack/commit/bddd21a5313974ca333c02b2da1c6f85d1afaaea), [`de388ff`](https://github.com/atlassian-labs/atlaspack/commit/de388ff76d39dece97ad475fcccdb6efb6283bfc)]:
+  - @atlaspack/rust@3.24.1
+  - @atlaspack/source-map@3.3.0
+  - @atlaspack/cache@3.2.51
+  - @atlaspack/fs@2.15.51
+  - @atlaspack/logger@2.14.48
+  - @atlaspack/utils@3.3.8
+  - @atlaspack/package-manager@2.14.56
+  - @atlaspack/profiler@2.15.17
+  - @atlaspack/workers@2.14.56
+  - @atlaspack/graph@3.6.18
+  - @atlaspack/plugin@2.14.56
+  - @atlaspack/types@2.15.46
+
 ## 2.35.0
 
 ### Minor Changes

package/dist/Atlaspack.js

@@ -85,6 +85,7 @@ const feature_flags_1 = require("@atlaspack/feature-flags");
 const atlaspack_v3_1 = require("./atlaspack-v3");
 const AssetGraphRequest_1 = __importDefault(require("./requests/AssetGraphRequest"));
 const AssetGraphRequestRust_1 = require("./requests/AssetGraphRequestRust");
+const BundleGraphRequestRust_1 = require("./requests/BundleGraphRequestRust");
 const rustWorkerThreadDylibHack_1 = require("./rustWorkerThreadDylibHack");
 (0, registerCoreWithSerializer_1.registerCoreWithSerializer)();
 exports.INTERNAL_TRANSFORM = Symbol('internal_transform');
@@ -158,6 +159,7 @@ class Atlaspack {
         __classPrivateFieldSet(this, _Atlaspack_resolvedOptions, resolvedOptions, "f");
         let rustAtlaspack;
         if (resolvedOptions.featureFlags.atlaspackV3 ||
+            resolvedOptions.featureFlags.fullNative ||
             resolvedOptions.featureFlags.nativePackager) {
             // eslint-disable-next-line no-unused-vars
             let { entries, inputFS, outputFS, ...options } = __classPrivateFieldGet(this, _Atlaspack_initialOptions, "f");
@@ -374,12 +376,45 @@ class Atlaspack {
                 type: 'buildStart',
             });
             __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").graph.invalidateOnBuildNodes();
-            let request = (0, AtlaspackBuildRequest_1.default)({
-                optionsRef: __classPrivateFieldGet(this, _Atlaspack_optionsRef, "f"),
-                requestedAssetIds: __classPrivateFieldGet(this, _Atlaspack_requestedAssetIds, "f"),
-                signal,
-            });
-            let { bundleGraph, bundleInfo, changedAssets, assetRequests, scopeHoistingStats, } = await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").runRequest(request, { force: true });
+            let bundleGraph;
+            let bundleInfo;
+            let changedAssets;
+            let assetRequests;
+            let scopeHoistingStats;
+            if ((0, feature_flags_1.getFeatureFlag)('fullNative') && this.rustAtlaspack) {
+                let [result, error] = await this.rustAtlaspack.build((eventJson) => {
+                    let event = JSON.parse(eventJson);
+                    __classPrivateFieldGet(this, _Atlaspack_reporterRunner, "f").report(event);
+                });
+                if (error) {
+                    throw new diagnostic_1.default({ diagnostic: error });
+                }
+                ({ bundleGraph, changedAssets } = (0, BundleGraphRequestRust_1.getBundleGraph)(result));
+                bundleInfo = new Map((result.bundleInfo ?? []).map((info) => [
+                    info.bundleId,
+                    {
+                        filePath: (0, projectPath_1.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_1.default)({
+                    optionsRef: __classPrivateFieldGet(this, _Atlaspack_optionsRef, "f"),
+                    requestedAssetIds: __classPrivateFieldGet(this, _Atlaspack_requestedAssetIds, "f"),
+                    signal,
+                });
+                ({
+                    bundleGraph,
+                    bundleInfo,
+                    changedAssets,
+                    assetRequests,
+                    scopeHoistingStats,
+                } = await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").runRequest(request, { force: true }));
+            }
             __classPrivateFieldGet(this, _Atlaspack_requestedAssetIds, "f").clear();
             await (0, dumpGraphToGraphViz_1.default)(
             // @ts-expect-error TS2345

package/dist/atlaspack-v3/AtlaspackV3.js

@@ -48,11 +48,14 @@ class AtlaspackV3 {
             this._napiWorkerPool.shutdown();
         }
     }
-    buildAssetGraph() {
-        return (0, rust_1.atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
+    buildAssetGraph(progressCallback) {
+        return (0, rust_1.atlaspackNapiBuildAssetGraph)(this._atlaspack_napi, progressCallback);
     }
-    buildBundleGraph() {
-        return (0, rust_1.atlaspackNapiBuildBundleGraph)(this._atlaspack_napi);
+    buildBundleGraph(progressCallback) {
+        return (0, rust_1.atlaspackNapiBuildBundleGraph)(this._atlaspack_napi, progressCallback);
+    }
+    build(progressCallback) {
+        return (0, rust_1.atlaspackNapiBuild)(this._atlaspack_napi, progressCallback);
     }
     loadBundleGraph(bundleGraph) {
         const { nodesJson, edges, publicIdByAssetId, environmentsJson } = bundleGraph.serializeForNative();

package/dist/atlaspack-v3/fs.js

@@ -45,6 +45,7 @@ class FileSystemV3 {
                 return __classPrivateFieldGet(this, _FileSystemV3_fs, "f").readFileSync(path, encoding);
             }
         });
+        this.writeFile = (0, jsCallable_1.jsCallable)((path, contents) => __classPrivateFieldGet(this, _FileSystemV3_fs, "f").writeFile(path, Buffer.from(contents)));
         __classPrivateFieldSet(this, _FileSystemV3_fs, fs, "f");
     }
 }

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

@@ -157,14 +157,23 @@ class AtlaspackWorker {
                     resolution: { type: 'excluded' },
                 };
             }
+            // 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_1.dependencyPriorityMap.intoNullable(result.priority),

package/dist/requests/AssetGraphRequestRust.js

@@ -43,6 +43,7 @@ const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
 const logger_1 = __importStar(require("@atlaspack/logger"));
 const feature_flags_1 = require("@atlaspack/feature-flags");
 const AssetGraph_1 = __importDefault(require("../AssetGraph"));
+const ReporterRunner_1 = require("../ReporterRunner");
 const RequestTracker_1 = require("../RequestTracker");
 const SymbolPropagation_1 = require("../SymbolPropagation");
 const EnvironmentManager_1 = require("../EnvironmentManager");
@@ -55,7 +56,10 @@ function createAssetGraphRequestRust(rustAtlaspack) {
         id: input.name,
         run: async (runInput) => {
             let options = runInput.options;
-            let { assetGraphPromise, commitPromise } = await rustAtlaspack.buildAssetGraph();
+            let { assetGraphPromise, commitPromise } = await rustAtlaspack.buildAssetGraph((eventJson) => {
+                let event = JSON.parse(eventJson);
+                (0, ReporterRunner_1.report)(event);
+            });
             let [serializedAssetGraph, assetGraphError] = (await assetGraphPromise);
             if (assetGraphError) {
                 throw new diagnostic_1.default({

package/dist/requests/AtlaspackBuildRequest.js

@@ -18,6 +18,7 @@ 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 logger_1 = require("@atlaspack/logger");
 function createAtlaspackBuildRequest(input) {
     return {
         type: RequestTracker_1.requestTypes.atlaspack_build_request,
@@ -78,12 +79,14 @@ async function run({ input, api, options, rustAtlaspack, }) {
         ])),
     });
     let packagingMeasurement = profiler_1.tracer.createMeasurement('packaging');
+    const span = logger_1.tracer.enter('writeBundles');
     let writeBundlesRequest = (0, WriteBundlesRequest_1.default)({
         bundleGraph,
         optionsRef,
     });
     let { bundleInfo, scopeHoistingStats } = await api.runRequest(writeBundlesRequest);
     packagingMeasurement && packagingMeasurement.end();
+    logger_1.tracer.exit(span);
     (0, utils_1.assertSignalNotAborted)(signal);
     return {
         bundleGraph,

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

@@ -44,6 +44,7 @@ const graph_1 = require("@atlaspack/graph");
 const logger_1 = require("@atlaspack/logger");
 const feature_flags_1 = require("@atlaspack/feature-flags");
 const BundleGraph_1 = __importStar(require("../BundleGraph"));
+const ReporterRunner_1 = require("../ReporterRunner");
 const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
 const rust_1 = require("@atlaspack/rust");
@@ -64,13 +65,17 @@ function createBundleGraphRequestRust(input) {
         run: async (runInput) => {
             const { api, options, rustAtlaspack } = runInput;
             (0, assert_1.default)(rustAtlaspack, 'BundleGraphRequestRust requires rustAtlaspack');
-            let { bundleGraphPromise, commitPromise } = await rustAtlaspack.buildBundleGraph();
+            let { bundleGraphPromise, commitPromise } = await rustAtlaspack.buildBundleGraph((eventJson) => {
+                let event = JSON.parse(eventJson);
+                (0, ReporterRunner_1.report)(event);
+            });
             let [serializedBundleGraph, bundleGraphError] = (await bundleGraphPromise);
             if (bundleGraphError) {
                 throw new diagnostic_1.default({ diagnostic: bundleGraphError });
             }
             // 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 {