@atlaspack/core 2.36.0 → 2.38.0

package/CHANGELOG.md

@@ -1,5 +1,88 @@
 # @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

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/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,7 +65,10 @@ 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 });

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/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)({

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.36.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.51",
+    "@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.51",
-    "@atlaspack/graph": "3.6.18",
-    "@atlaspack/logger": "2.14.48",
-    "@atlaspack/package-manager": "2.14.56",
-    "@atlaspack/plugin": "2.14.56",
-    "@atlaspack/profiler": "2.15.17",
-    "@atlaspack/rust": "3.24.1",
-    "@atlaspack/types": "2.15.46",
-    "@atlaspack/utils": "3.3.8",
-    "@atlaspack/workers": "2.14.56",
-    "@atlaspack/source-map": "3.3.0",
+    "@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();