@atlaspack/core 2.35.0 → 2.38.0

package/lib/requests/WriteBundleRequest.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.SourceMapHashRefRewriteStream = void 0;
 exports.applyReplacementsToSourceMap = applyReplacementsToSourceMap;
+exports.applyReplacementsToVLQMappings = applyReplacementsToVLQMappings;
 exports.computeSourceMapRoot = computeSourceMapRoot;
 exports.default = createWriteBundleRequest;
 var _constants = require("../constants");
@@ -78,7 +80,7 @@ function _featureFlags() {
 }
 var _EnvironmentManager = require("../EnvironmentManager");
 function _sourceMap() {
-  const data = _interopRequireDefault(require("@atlaspack/source-map"));
+  const data = require("@atlaspack/source-map");
   _sourceMap = function () {
     return data;
   };
@@ -90,6 +92,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 const HASH_REF_PREFIX_LEN = _constants.HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = _constants.HASH_REF_PREFIX.length + 32 - 1;
 const HASH_REF_PLACEHOLDER_LEN = HASH_REF_PREFIX_LEN + _constants.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.
  */
@@ -179,21 +184,11 @@ async function run({
   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, _featureFlags().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 (_sourceMap().default)(projectRoot, mapBuffer);
-      applyReplacementsToSourceMap(sourceMap, bundleReplacements);
-      const mapJson = await sourceMap.stringify({
-        format: 'string',
-        file: name,
-        sourceRoot: computeSourceMapRoot(bundle, options)
-      });
-      mapStream = (0, _utils().blobToStream)(Buffer.from(typeof mapJson === 'string' ? mapJson : JSON.stringify(mapJson), 'utf8'));
+      mapStream = (0, _utils().blobToStream)(mapEntry).pipe(new SourceMapHashRefRewriteStream(bundleReplacements));
     } else {
-      const mapEntry = await options.cache.getBlob(mapKey);
       mapStream = (0, _utils().blobToStream)(mapEntry);
     }
     await writeFiles(mapStream, info, hashRefToNameHash, options, config, outputFS, (0, _projectPath.toProjectPathUnsafe)((0, _projectPath.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
@@ -228,6 +223,178 @@ 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, _sourceMap().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, _sourceMap().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().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();
+  }
+}
+
 /**
  * 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
@@ -238,6 +405,7 @@ function applyReplacementsToSourceMap(sourceMap, replacements) {
  *
  * This logic must stay in sync with PackagerRunner.generateSourceMap.
  */
+exports.SourceMapHashRefRewriteStream = SourceMapHashRefRewriteStream;
 function computeSourceMapRoot(bundle, options) {
   let name = (0, _nullthrows().default)(bundle.name);
   let filePath = (0, _projectPath.joinProjectPath)(bundle.target.distDir, name);

package/lib/types/atlaspack-v3/AtlaspackV3.d.ts

@@ -24,8 +24,9 @@ export declare class AtlaspackV3 {
     constructor(atlaspack_napi: AtlaspackNapi, napiWorkerPool: INapiWorkerPool, isDefaultNapiWorkerPool: boolean);
     static create({ fs, packageManager, threads, lmdb, napiWorkerPool, ...options }: AtlaspackV3Options): Promise<AtlaspackV3>;
     end(): void;
-    buildAssetGraph(): Promise<any>;
-    buildBundleGraph(): Promise<any>;
+    buildAssetGraph(progressCallback?: (eventJson: string) => void): Promise<any>;
+    buildBundleGraph(progressCallback?: (eventJson: string) => void): Promise<any>;
+    build(progressCallback: (eventJson: string) => void): Promise<any>;
     loadBundleGraph(bundleGraph: BundleGraph): Promise<void>;
     updateBundleGraph(bundleGraph: BundleGraph, changedAssetIds: string[]): Promise<void>;
     package(bundleId: string, options?: PackageOptions): Promise<[RunPackagerRunnerResult, Diagnostic | null]>;

package/lib/types/atlaspack-v3/fs.d.ts

@@ -9,4 +9,5 @@ export declare class FileSystemV3 implements FileSystem {
     isFile: JsCallable<[FilePath], boolean>;
     isDir: JsCallable<[FilePath], boolean>;
     readFile: JsCallable<[FilePath, Encoding], string>;
+    writeFile: JsCallable<[FilePath, number[]], Promise<void>>;
 }

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/lib/types/requests/WriteBundleRequest.d.ts

@@ -4,6 +4,7 @@ import type { StaticRunOpts } from '../RequestTracker';
 import type { Bundle, PackagedBundleInfo, AtlaspackOptions } from '../types';
 import type BundleGraph from '../BundleGraph';
 import type { BundleInfo } from '../PackagerRunner';
+import { Transform } from 'stream';
 import { requestTypes } from '../RequestTracker';
 import SourceMap from '@atlaspack/source-map';
 export type HashRefReplacement = {
@@ -33,6 +34,38 @@ export type WriteBundleRequest = {
  */
 export default function createWriteBundleRequest(input: WriteBundleRequestInput): WriteBundleRequest;
 export declare function applyReplacementsToSourceMap(sourceMap: SourceMap, replacements: HashRefReplacement[]): void;
+/**
+ * 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.
+ */
+export declare function applyReplacementsToVLQMappings(mappings: string, replacements: HashRefReplacement[]): string;
+/**
+ * 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.
+ */
+export declare class SourceMapHashRefRewriteStream extends Transform {
+    private replacements;
+    private state;
+    private scanBuf;
+    private mappingsBufs;
+    constructor(replacements: HashRefReplacement[]);
+    _transform(chunk: Buffer, _encoding: string, cb: any): void;
+    private _bufferingTransform;
+    _flush(cb: any): void;
+}
 /**
  * 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.35.0",
+  "version": "2.38.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -23,22 +23,22 @@
   },
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
-    "@atlaspack/build-cache": "2.13.13",
-    "@atlaspack/cache": "3.2.50",
+    "@atlaspack/build-cache": "2.13.14",
+    "@atlaspack/cache": "3.2.53",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.30.1",
-    "@atlaspack/fs": "2.15.50",
-    "@atlaspack/graph": "3.6.17",
-    "@atlaspack/logger": "2.14.47",
-    "@atlaspack/package-manager": "2.14.55",
-    "@atlaspack/plugin": "2.14.55",
-    "@atlaspack/profiler": "2.15.16",
-    "@atlaspack/rust": "3.24.0",
-    "@atlaspack/types": "2.15.45",
-    "@atlaspack/utils": "3.3.7",
-    "@atlaspack/workers": "2.14.55",
-    "@atlaspack/source-map": "3.2.10",
+    "@atlaspack/feature-flags": "2.31.0",
+    "@atlaspack/fs": "2.15.53",
+    "@atlaspack/graph": "3.6.20",
+    "@atlaspack/logger": "2.14.50",
+    "@atlaspack/package-manager": "2.14.58",
+    "@atlaspack/plugin": "2.14.58",
+    "@atlaspack/profiler": "2.15.19",
+    "@atlaspack/rust": "3.26.0",
+    "@atlaspack/types": "2.15.48",
+    "@atlaspack/utils": "3.4.0",
+    "@atlaspack/workers": "2.14.58",
+    "@atlaspack/source-map": "3.3.2",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",

package/src/Atlaspack.ts

@@ -67,6 +67,7 @@ import {AtlaspackV3, FileSystemV3} from './atlaspack-v3';
 import createAssetGraphRequestJS from './requests/AssetGraphRequest';
 import {createAssetGraphRequestRust} from './requests/AssetGraphRequestRust';
 import type {AssetGraphRequestResult} from './requests/AssetGraphRequest';
+import {getBundleGraph} from './requests/BundleGraphRequestRust';
 import {loadRustWorkerThreadDylibHack} from './rustWorkerThreadDylibHack';
 
 registerCoreWithSerializer();
@@ -171,6 +172,7 @@ export default class Atlaspack {
     let rustAtlaspack: AtlaspackV3;
     if (
       resolvedOptions.featureFlags.atlaspackV3 ||
+      resolvedOptions.featureFlags.fullNative ||
       resolvedOptions.featureFlags.nativePackager
     ) {
       // eslint-disable-next-line no-unused-vars
@@ -433,19 +435,59 @@ export default class Atlaspack {
 
       this.#requestTracker.graph.invalidateOnBuildNodes();
 
-      let request = createAtlaspackBuildRequest({
-        optionsRef: this.#optionsRef,
-        requestedAssetIds: this.#requestedAssetIds,
-        signal,
-      });
+      let bundleGraph: any;
+      let bundleInfo: Map<any, any>;
+      let changedAssets: Map<any, any>;
+      let assetRequests: Array<any>;
+      let scopeHoistingStats: any;
+
+      if (getFeatureFlag('fullNative') && this.rustAtlaspack) {
+        let [result, error] = await this.rustAtlaspack.build(
+          (eventJson: string) => {
+            let event = JSON.parse(eventJson);
+            this.#reporterRunner.report(event);
+          },
+        );
+
+        if (error) {
+          throw new ThrowableDiagnostic({diagnostic: error});
+        }
+        ({bundleGraph, changedAssets} = getBundleGraph(result));
+        bundleInfo = new Map(
+          (result.bundleInfo ?? []).map(
+            (info: {
+              bundleId: string;
+              filePath: string;
+              type: string;
+              size: number;
+              time: number;
+            }) => [
+              info.bundleId,
+              {
+                filePath: toProjectPath(options.projectRoot, info.filePath),
+                bundleId: info.bundleId,
+                type: info.type,
+                stats: {size: info.size, time: info.time},
+              },
+            ],
+          ),
+        );
+        assetRequests = result.assetRequests ?? [];
+      } else {
+        let request = createAtlaspackBuildRequest({
+          optionsRef: this.#optionsRef,
+          requestedAssetIds: this.#requestedAssetIds,
+          signal,
+        });
 
-      let {
-        bundleGraph,
-        bundleInfo,
-        changedAssets,
-        assetRequests,
-        scopeHoistingStats,
-      } = await this.#requestTracker.runRequest(request, {force: true});
+        ({
+          bundleGraph,
+          bundleInfo,
+          changedAssets,
+          assetRequests,
+          scopeHoistingStats,
+        } = await this.#requestTracker.runRequest(request, {force: true}));
+      }
 
       this.#requestedAssetIds.clear();
 

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -1,5 +1,6 @@
 import {
   atlaspackNapiCreate,
+  atlaspackNapiBuild,
   atlaspackNapiBuildAssetGraph,
   atlaspackNapiBuildBundleGraph,
   atlaspackNapiRespondToFsEvents,
@@ -100,12 +101,29 @@ export class AtlaspackV3 {
     }
   }
 
-  buildAssetGraph(): Promise<any> {
-    return atlaspackNapiBuildAssetGraph(this._atlaspack_napi) as Promise<any>;
+  buildAssetGraph(
+    progressCallback?: (eventJson: string) => void,
+  ): Promise<any> {
+    return atlaspackNapiBuildAssetGraph(
+      this._atlaspack_napi,
+      progressCallback,
+    ) as Promise<any>;
   }
 
-  buildBundleGraph(): Promise<any> {
-    return atlaspackNapiBuildBundleGraph(this._atlaspack_napi) as Promise<any>;
+  buildBundleGraph(
+    progressCallback?: (eventJson: string) => void,
+  ): Promise<any> {
+    return atlaspackNapiBuildBundleGraph(
+      this._atlaspack_napi,
+      progressCallback,
+    ) as Promise<any>;
+  }
+
+  build(progressCallback: (eventJson: string) => void): Promise<any> {
+    return atlaspackNapiBuild(
+      this._atlaspack_napi,
+      progressCallback,
+    ) as Promise<any>;
   }
 
   loadBundleGraph(bundleGraph: BundleGraph): Promise<void> {

package/src/atlaspack-v3/fs.ts

@@ -51,4 +51,9 @@ export class FileSystemV3 implements FileSystem {
       }
     },
   );
+
+  writeFile: JsCallable<[FilePath, number[]], Promise<void>> = jsCallable(
+    (path: FilePath, contents: number[]) =>
+      this.#fs.writeFile(path, Buffer.from(contents)),
+  );
 }

package/src/atlaspack-v3/worker/worker.ts

@@ -173,15 +173,24 @@ export 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: dependencyPriorityMap.intoNullable(result.priority),

package/src/requests/AssetGraphRequestRust.ts

@@ -7,6 +7,7 @@ import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 import AssetGraph from '../AssetGraph';
 import type {AtlaspackV3} from '../atlaspack-v3';
+import {report} from '../ReporterRunner';
 import {requestTypes, StaticRunOpts} from '../RequestTracker';
 import {propagateSymbols} from '../SymbolPropagation';
 import type {
@@ -54,7 +55,10 @@ export function createAssetGraphRequestRust(
     run: async (runInput) => {
       let options = runInput.options;
       let {assetGraphPromise, commitPromise} =
-        await rustAtlaspack.buildAssetGraph();
+        await rustAtlaspack.buildAssetGraph((eventJson: string) => {
+          let event = JSON.parse(eventJson);
+          report(event);
+        });
 
       let [serializedAssetGraph, assetGraphError] =
         (await assetGraphPromise) as [SerializedAssetGraphDelta, Error | null];

package/src/requests/AtlaspackBuildRequest.ts

@@ -23,6 +23,7 @@ import {tracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {fromEnvironmentId} from '../EnvironmentManager';
+import {tracer as atlaspackTracer} from '@atlaspack/logger';
 
 type AtlaspackBuildRequestInput = {
   optionsRef: SharedReference;
@@ -144,6 +145,8 @@ async function run({
   });
 
   let packagingMeasurement = tracer.createMeasurement('packaging');
+  const span = atlaspackTracer.enter('writeBundles');
+
   let writeBundlesRequest = createWriteBundlesRequest({
     bundleGraph,
     optionsRef,
@@ -152,6 +155,7 @@ async function run({
   let {bundleInfo, scopeHoistingStats} =
     await api.runRequest(writeBundlesRequest);
   packagingMeasurement && packagingMeasurement.end();
+  atlaspackTracer.exit(span);
   assertSignalNotAborted(signal);
 
   return {

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

@@ -7,6 +7,7 @@ import {instrument, instrumentAsync, PluginLogger} from '@atlaspack/logger';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 import InternalBundleGraph, {bundleGraphEdgeTypes} from '../BundleGraph';
+import {report} from '../ReporterRunner';
 import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
 import nullthrows from 'nullthrows';
 import {hashString} from '@atlaspack/rust';
@@ -32,6 +33,7 @@ import {
   nameBundle,
   loadPluginConfigWithDevDeps,
   runDevDepRequest,
+  dumpBundleGraphSnapshot,
 } from './BundleGraphRequestUtils';
 import {toEnvironmentRef} from '../EnvironmentManager';
 import {getEnvironmentHash} from '../Environment';
@@ -95,7 +97,10 @@ export default function createBundleGraphRequestRust(
       invariant(rustAtlaspack, 'BundleGraphRequestRust requires rustAtlaspack');
 
       let {bundleGraphPromise, commitPromise} =
-        await rustAtlaspack.buildBundleGraph();
+        await rustAtlaspack.buildBundleGraph((eventJson: string) => {
+          let event = JSON.parse(eventJson);
+          report(event);
+        });
       let [serializedBundleGraph, bundleGraphError] =
         (await bundleGraphPromise) as [SerializedBundleGraph, Error | null];
 
@@ -109,6 +114,8 @@ export default function createBundleGraphRequestRust(
         () => getBundleGraph(serializedBundleGraph),
       );
 
+      dumpBundleGraphSnapshot(bundleGraph, 'rust');
+
       const runner = new NativeBundlerRunner(
         {api, options} as any,
         input.optionsRef,