@atlaspack/core 2.36.0 → 2.38.2

package/CHANGELOG.md

@@ -1,5 +1,126 @@
 # @atlaspack/core
 
+## 2.38.2
+
+### Patch Changes
+
+- Updated dependencies [[`7d1839c`](https://github.com/atlassian-labs/atlaspack/commit/7d1839cc7cf0225dd35afecb68109a11fd931f2b)]:
+  - @atlaspack/rust@3.28.0
+  - @atlaspack/cache@3.2.55
+  - @atlaspack/fs@2.15.55
+  - @atlaspack/logger@2.14.52
+  - @atlaspack/source-map@3.3.4
+  - @atlaspack/utils@3.4.2
+  - @atlaspack/package-manager@2.14.60
+  - @atlaspack/profiler@2.15.21
+  - @atlaspack/workers@2.14.60
+  - @atlaspack/types@2.15.50
+  - @atlaspack/graph@3.6.22
+  - @atlaspack/plugin@2.14.60
+
+## 2.38.1
+
+### Patch Changes
+
+- [#1059](https://github.com/atlassian-labs/atlaspack/pull/1059) [`1c767e4`](https://github.com/atlassian-labs/atlaspack/commit/1c767e4907664dd490a56276d6562f79dbeea3fb) Thanks [@OscarCookeAbbott](https://github.com/OscarCookeAbbott)! - Improve multithreaded logging
+
+- Updated dependencies [[`a958853`](https://github.com/atlassian-labs/atlaspack/commit/a958853ae3de2812bfd032357e9fa7cab6a1ddb6), [`0f5c1ef`](https://github.com/atlassian-labs/atlaspack/commit/0f5c1eff9138728168231efa66202a8d844c33ef)]:
+  - @atlaspack/rust@3.27.0
+  - @atlaspack/cache@3.2.54
+  - @atlaspack/fs@2.15.54
+  - @atlaspack/logger@2.14.51
+  - @atlaspack/source-map@3.3.3
+  - @atlaspack/utils@3.4.1
+  - @atlaspack/package-manager@2.14.59
+  - @atlaspack/profiler@2.15.20
+  - @atlaspack/workers@2.14.59
+  - @atlaspack/types@2.15.49
+  - @atlaspack/graph@3.6.21
+  - @atlaspack/plugin@2.14.59
+
+## 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/NapiWorkerPool.js

@@ -20,6 +20,7 @@ const worker_threads_1 = require("worker_threads");
 const path_1 = __importDefault(require("path"));
 const process_1 = __importDefault(require("process"));
 const rust_1 = require("@atlaspack/rust");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
 const WORKER_PATH = path_1.default.join(__dirname, 'worker', 'index.js');
 const ATLASPACK_NAPI_WORKERS = process_1.default.env.ATLASPACK_NAPI_WORKERS &&
     parseInt(process_1.default.env.ATLASPACK_NAPI_WORKERS, 10);
@@ -43,6 +44,32 @@ class NapiWorkerPool {
             let worker = new worker_threads_1.Worker(WORKER_PATH);
             __classPrivateFieldGet(this, _NapiWorkerPool_workers, "f").push(worker);
             __classPrivateFieldGet(this, _NapiWorkerPool_napiWorkers, "f").push(new Promise((res) => worker.once('message', res)));
+            // Re-emit log events from the worker thread into the main-thread logger
+            // so they reach reporters and are subject to log-level filtering.
+            worker.on('message', (message) => {
+                if (message != null &&
+                    typeof message === 'object' &&
+                    message.type === 'logEvent') {
+                    const event = message.event;
+                    switch (event.level) {
+                        case 'verbose':
+                            logger_1.default.verbose(event.diagnostics);
+                            break;
+                        case 'info':
+                            logger_1.default.info(event.diagnostics);
+                            break;
+                        case 'warn':
+                            logger_1.default.warn(event.diagnostics);
+                            break;
+                        case 'error':
+                            logger_1.default.error(event.diagnostics);
+                            break;
+                        case 'progress':
+                            logger_1.default.progress(event.message);
+                            break;
+                    }
+                }
+            });
         }
     }
     clearAllWorkerState() {
@@ -55,6 +82,12 @@ class NapiWorkerPool {
                     worker.removeListener('message', messageHandler);
                     res();
                 }
+                else if (message != null &&
+                    typeof message === 'object' &&
+                    message.type === 'logEvent') {
+                    // logEvent messages are forwarded asynchronously from the worker
+                    // logger bridge and are expected at any time; ignore them here.
+                }
                 else {
                     // Log unexpected messages for debugging
                     // eslint-disable-next-line no-console

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/compat/index.js

@@ -20,6 +20,5 @@ __exportStar(require("./environment"), exports);
 __exportStar(require("./target"), exports);
 __exportStar(require("./plugin-config"), exports);
 __exportStar(require("./plugin-tracer"), exports);
-__exportStar(require("./plugin-logger"), exports);
 __exportStar(require("./plugin-options"), exports);
 __exportStar(require("./mutable-asset"), exports);

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

@@ -59,8 +59,10 @@ const napi = __importStar(require("@atlaspack/rust"));
 const fs_1 = require("@atlaspack/fs");
 const package_manager_1 = require("@atlaspack/package-manager");
 const worker_threads_1 = require("worker_threads");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
 const module = __importStar(require("module"));
 const jsCallable_1 = require("../jsCallable");
+const logger_2 = require("@atlaspack/logger");
 const compat_1 = require("./compat");
 const CONFIG = Symbol.for('parcel-plugin-config');
 class AtlaspackWorker {
@@ -121,7 +123,7 @@ class AtlaspackWorker {
             const env = new compat_1.Environment(napiDependency.env);
             const dependency = new compat_1.Dependency(napiDependency, env);
             const defaultOptions = {
-                logger: new compat_1.PluginLogger(),
+                logger: new logger_2.PluginLogger({ origin: key }),
                 tracer: new compat_1.PluginTracer(),
                 options: new compat_1.PluginOptions(this.options),
             };
@@ -157,14 +159,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),
@@ -192,7 +203,7 @@ class AtlaspackWorker {
             contents, env, __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), map, this.options.projectRoot);
             const pluginOptions = new compat_1.PluginOptions(this.options);
             const defaultOptions = {
-                logger: new compat_1.PluginLogger(),
+                logger: new logger_2.PluginLogger({ origin: key }),
                 tracer: new compat_1.PluginTracer(),
                 options: pluginOptions,
             };
@@ -332,7 +343,7 @@ class AtlaspackWorker {
         let packageManager = new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), this.options.projectRoot);
         if (transformer.setup) {
             let setupResult = await transformer.setup({
-                logger: new compat_1.PluginLogger(),
+                logger: new logger_2.PluginLogger({ origin: specifier }),
                 options: new compat_1.PluginOptions({
                     ...this.options,
                     shouldAutoInstall: false,
@@ -369,6 +380,11 @@ class AtlaspackWorker {
 }
 exports.AtlaspackWorker = AtlaspackWorker;
 _AtlaspackWorker_resolvers = new WeakMap(), _AtlaspackWorker_transformers = new WeakMap(), _AtlaspackWorker_fs = new WeakMap(), _AtlaspackWorker_packageManager = new WeakMap(), _AtlaspackWorker_options = new WeakMap(), _AtlaspackWorker_sideEffectDetector = new WeakMap();
+// Forward all logger events from this worker thread to the main thread so
+// they are re-emitted into the main-thread logger and reach reporters.
+logger_1.default.onLog((event) => {
+    worker_threads_1.parentPort?.postMessage({ type: 'logEvent', event });
+});
 // Create napi worker and send it back to main thread
 const worker = new AtlaspackWorker();
 const napiWorker = napi.newNodejsWorker(worker);

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/NapiWorkerPool.js

@@ -32,6 +32,13 @@ function _rust() {
   };
   return data;
 }
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // @ts-expect-error TS2724
 
@@ -60,6 +67,31 @@ class NapiWorkerPool {
       let worker = new (_worker_threads().Worker)(WORKER_PATH);
       this.#workers.push(worker);
       this.#napiWorkers.push(new Promise(res => worker.once('message', res)));
+
+      // Re-emit log events from the worker thread into the main-thread logger
+      // so they reach reporters and are subject to log-level filtering.
+      worker.on('message', message => {
+        if (message != null && typeof message === 'object' && message.type === 'logEvent') {
+          const event = message.event;
+          switch (event.level) {
+            case 'verbose':
+              _logger().default.verbose(event.diagnostics);
+              break;
+            case 'info':
+              _logger().default.info(event.diagnostics);
+              break;
+            case 'warn':
+              _logger().default.warn(event.diagnostics);
+              break;
+            case 'error':
+              _logger().default.error(event.diagnostics);
+              break;
+            case 'progress':
+              _logger().default.progress(event.message);
+              break;
+          }
+        }
+      });
     }
   }
   clearAllWorkerState() {
@@ -72,6 +104,9 @@ class NapiWorkerPool {
         if (message === 'stateCleared') {
           worker.removeListener('message', messageHandler);
           res();
+        } else if (message != null && typeof message === 'object' && message.type === 'logEvent') {
+          // logEvent messages are forwarded asynchronously from the worker
+          // logger bridge and are expected at any time; ignore them here.
         } else {
           // Log unexpected messages for debugging
           // eslint-disable-next-line no-console

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/compat/index.js

@@ -69,17 +69,6 @@ Object.keys(_pluginTracer).forEach(function (key) {
     }
   });
 });
-var _pluginLogger = require("./plugin-logger");
-Object.keys(_pluginLogger).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _pluginLogger[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _pluginLogger[key];
-    }
-  });
-});
 var _pluginOptions = require("./plugin-options");
 Object.keys(_pluginOptions).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;