@atlaspack/core 2.31.3 → 2.32.1

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # @atlaspack/core
 
+## 2.32.1
+
+### Patch Changes
+
+- [#988](https://github.com/atlassian-labs/atlaspack/pull/988) [`a631dcd`](https://github.com/atlassian-labs/atlaspack/commit/a631dcd961112db072b0f8de0831efd178f355a7) Thanks [@marcins](https://github.com/marcins)! - Implement a basic package() method for the native packager
+
+- [#990](https://github.com/atlassian-labs/atlaspack/pull/990) [`5755a11`](https://github.com/atlassian-labs/atlaspack/commit/5755a114903bbf660e2ada3ae2e7ff6ceac7565b) Thanks [@vykimnguyen](https://github.com/vykimnguyen)! - changes conditional bundleGraphEdgeType value
+
+- [#987](https://github.com/atlassian-labs/atlaspack/pull/987) [`fcaf517`](https://github.com/atlassian-labs/atlaspack/commit/fcaf517010d15c9300393bcad3f9b465689d9d16) Thanks [@vykimnguyen](https://github.com/vykimnguyen)! - add get_bundle_assets
+
+- Updated dependencies [[`a631dcd`](https://github.com/atlassian-labs/atlaspack/commit/a631dcd961112db072b0f8de0831efd178f355a7), [`e9dce31`](https://github.com/atlassian-labs/atlaspack/commit/e9dce3168a8e6727a994bf2a6ac6041eb29f6027), [`59e1345`](https://github.com/atlassian-labs/atlaspack/commit/59e1345f84f43e0632d434ab42c06bf748241985), [`783118c`](https://github.com/atlassian-labs/atlaspack/commit/783118c772f45a0cf6a3b6b447fb9a0e225b25a6), [`fcaf517`](https://github.com/atlassian-labs/atlaspack/commit/fcaf517010d15c9300393bcad3f9b465689d9d16)]:
+  - @atlaspack/rust@3.21.0
+  - @atlaspack/cache@3.2.46
+  - @atlaspack/fs@2.15.46
+  - @atlaspack/logger@2.14.43
+  - @atlaspack/source-map@3.2.6
+  - @atlaspack/utils@3.3.3
+  - @atlaspack/package-manager@2.14.51
+  - @atlaspack/profiler@2.15.12
+  - @atlaspack/workers@2.14.51
+  - @atlaspack/types@2.15.41
+  - @atlaspack/graph@3.6.13
+  - @atlaspack/plugin@2.14.51
+
+## 2.32.0
+
+### Minor Changes
+
+- [#976](https://github.com/atlassian-labs/atlaspack/pull/976) [`e8ea59b`](https://github.com/atlassian-labs/atlaspack/commit/e8ea59beabb4b4fef647dc9ebea3519b6d56d7b5) Thanks [@marcins](https://github.com/marcins)! - Initial implementation of loadBundleGraph to deserialise JS -> Rust BundleGraph.
+
+- [#970](https://github.com/atlassian-labs/atlaspack/pull/970) [`8826fd0`](https://github.com/atlassian-labs/atlaspack/commit/8826fd02c29c9c67cf0c80da41f424257fbdef93) Thanks [@marcins](https://github.com/marcins)! - Add initial plumbing for native packaging to core and Atlaspack V3 code
+
+### Patch Changes
+
+- [#984](https://github.com/atlassian-labs/atlaspack/pull/984) [`dbcaabb`](https://github.com/atlassian-labs/atlaspack/commit/dbcaabbf15d4fbc8ecd9c0be58cf7b2317eebfc4) Thanks [@marcins](https://github.com/marcins)! - Serialise to JSON on the JS side before sending bundle graph nodes to Rust for performance.
+
+- Updated dependencies [[`e8ea59b`](https://github.com/atlassian-labs/atlaspack/commit/e8ea59beabb4b4fef647dc9ebea3519b6d56d7b5), [`3753cb1`](https://github.com/atlassian-labs/atlaspack/commit/3753cb1bf9155eaf3a1a8f952886864682738647), [`8826fd0`](https://github.com/atlassian-labs/atlaspack/commit/8826fd02c29c9c67cf0c80da41f424257fbdef93), [`225683f`](https://github.com/atlassian-labs/atlaspack/commit/225683f7c59355da53b7004d2b8596701ce3af41), [`43adda0`](https://github.com/atlassian-labs/atlaspack/commit/43adda06bf3b6a404b54f8ba2a3b810d92e61d75), [`dbcaabb`](https://github.com/atlassian-labs/atlaspack/commit/dbcaabbf15d4fbc8ecd9c0be58cf7b2317eebfc4)]:
+  - @atlaspack/rust@3.20.0
+  - @atlaspack/feature-flags@2.28.0
+  - @atlaspack/cache@3.2.45
+  - @atlaspack/fs@2.15.45
+  - @atlaspack/logger@2.14.42
+  - @atlaspack/source-map@3.2.5
+  - @atlaspack/utils@3.3.2
+  - @atlaspack/build-cache@2.13.9
+  - @atlaspack/graph@3.6.12
+  - @atlaspack/package-manager@2.14.50
+  - @atlaspack/profiler@2.15.11
+  - @atlaspack/workers@2.14.50
+  - @atlaspack/plugin@2.14.50
+  - @atlaspack/types@2.15.40
+
 ## 2.31.3
 
 ### Patch Changes

package/dist/Atlaspack.js

@@ -157,7 +157,8 @@ class Atlaspack {
         });
         __classPrivateFieldSet(this, _Atlaspack_resolvedOptions, resolvedOptions, "f");
         let rustAtlaspack;
-        if (resolvedOptions.featureFlags.atlaspackV3) {
+        if (resolvedOptions.featureFlags.atlaspackV3 ||
+            resolvedOptions.featureFlags.nativePackager) {
             // eslint-disable-next-line no-unused-vars
             let { entries, inputFS, outputFS, ...options } = __classPrivateFieldGet(this, _Atlaspack_initialOptions, "f");
             if (!(resolvedOptions.cache instanceof cache_1.LMDBLiteCache)) {
@@ -487,7 +488,7 @@ class Atlaspack {
                 message: `File watch event emitted with ${events.length} events. Sample event: [${events[0]?.type}] ${events[0]?.path}`,
             });
             let nativeInvalid = false;
-            if (this.rustAtlaspack) {
+            if ((0, feature_flags_1.getFeatureFlag)('atlaspackV3') && this.rustAtlaspack) {
                 nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
             }
             let { didInvalidate: isInvalid } = await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").respondToFSEvents(events, Number.POSITIVE_INFINITY);
@@ -555,7 +556,7 @@ class Atlaspack {
             requestedAssetIds: __classPrivateFieldGet(this, _Atlaspack_requestedAssetIds, "f"),
         };
         const start = Date.now();
-        const result = await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").runRequest(this.rustAtlaspack != null
+        const result = await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").runRequest((0, feature_flags_1.getFeatureFlag)('atlaspackV3') && this.rustAtlaspack != null
             ? // @ts-expect-error TS2345
                 (0, AssetGraphRequestRust_1.createAssetGraphRequestRust)(this.rustAtlaspack)(input)
             : // @ts-expect-error TS2345

package/dist/BundleGraph.js

@@ -16,6 +16,7 @@ const Environment_1 = require("./public/Environment");
 const projectPath_1 = require("./projectPath");
 const constants_1 = require("./constants");
 const feature_flags_1 = require("@atlaspack/feature-flags");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
 const EnvironmentManager_1 = require("./EnvironmentManager");
 exports.bundleGraphEdgeTypes = {
     // A lack of an edge type indicates to follow the edge while traversing
@@ -42,7 +43,7 @@ exports.bundleGraphEdgeTypes = {
     internal_async: 5,
     // This type is used to mark an edge between a bundle and a conditional bundle.
     // This allows efficient discovery of conditional bundles in packaging
-    conditional: 5,
+    conditional: 6,
 };
 function makeReadOnlySet(set) {
     return new Proxy(set, {
@@ -380,6 +381,108 @@ class BundleGraph {
             conditions: serialized.conditions,
         });
     }
+    /**
+     * Serialize the bundle graph for efficient transfer to native Rust code.
+     * Returns a JSON string of nodes, an array of edges, and a map of asset IDs to public IDs.
+     */
+    serializeForNative() {
+        const start = performance.now();
+        const nodes = this._graph.nodes;
+        const edges = [];
+        const edgeIterator = this._graph.getAllEdges();
+        let next = edgeIterator.next();
+        while (!next.done) {
+            const edge = next.value;
+            edges.push([edge.from, edge.to, edge.type]);
+            next = edgeIterator.next();
+        }
+        // Extract and deduplicate environments
+        const environmentMap = new Map();
+        const extractEnvironment = (envRef) => {
+            const env = (0, EnvironmentManager_1.fromEnvironmentId)(envRef);
+            const envId = env.id;
+            if (!environmentMap.has(envId)) {
+                environmentMap.set(envId, env);
+            }
+            return envId;
+        };
+        // Replace env objects with env IDs in nodes
+        const processedNodes = nodes.map((node) => {
+            const processedNode = { ...node };
+            if (node.type === 'asset' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            else if (node.type === 'dependency' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            else if (node.type === 'bundle' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            return processedNode;
+        });
+        // Optimize nodes by omitting null/undefined values to reduce JSON size
+        const optimizedNodes = processedNodes.map((node) => this._omitNulls(node));
+        const nodesJson = JSON.stringify(optimizedNodes);
+        // Serialize environments as array
+        const environments = Array.from(environmentMap.values());
+        const environmentsJson = JSON.stringify(environments);
+        // Convert Map to plain object for serialization
+        const publicIdByAssetId = {};
+        for (const [assetId, publicId] of this._publicIdByAssetId) {
+            publicIdByAssetId[assetId] = publicId;
+        }
+        const duration = performance.now() - start;
+        const nodesSizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+        const envsSizeMB = (environmentsJson.length / (1024 * 1024)).toFixed(2);
+        logger_1.default.verbose({
+            origin: '@atlaspack/core',
+            message: `serializeForNative: ${duration.toFixed(1)}ms, ${nodesSizeMB}MB nodes, ${envsSizeMB}MB envs (${environmentMap.size} unique), ${nodes.length} nodes, ${edges.length} edges`,
+        });
+        return { nodesJson, edges, publicIdByAssetId, environmentsJson };
+    }
+    /**
+     * Remove null and undefined values from an object to reduce JSON size.
+     * Preserves false, 0, empty strings, and arrays.
+     */
+    _omitNulls(obj) {
+        if (obj === null || obj === undefined)
+            return obj;
+        if (typeof obj !== 'object')
+            return obj;
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this._omitNulls(item));
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (value === null || value === undefined) {
+                continue;
+            }
+            if (typeof value === 'object' &&
+                !Array.isArray(value) &&
+                Object.keys(value).length === 0) {
+                continue;
+            }
+            if (typeof value === 'object') {
+                const processed = this._omitNulls(value);
+                if (processed !== undefined) {
+                    result[key] = processed;
+                }
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
     createBundle(opts) {
         // @ts-expect-error TS2339
         let { entryAsset, target } = opts;
@@ -1103,8 +1206,36 @@ class BundleGraph {
         });
     }
     /**
-     * TODO: Document why this works like this & why visitor order matters
-     * on these use-cases.
+     * Performs a depth-first traversal of all assets and dependencies contained
+     * within a bundle. Only visits nodes that are directly contained in the bundle
+     * (connected via a `contains` edge).
+     *
+     * Entry Asset Ordering:
+     * The traversal guarantees that entry assets are visited in the exact order they
+     * appear in `bundle.entryAssetIds`. This ordering is critical for several reasons:
+     *
+     * 1. **Code Execution Order in Packagers**: Packagers (ScopeHoistingPackager,
+     *    DevPackager) use this traversal to concatenate assets into the final bundle.
+     *    The traversal order determines the execution order of code in the output.
+     *    Entry assets must be processed in their defined order to ensure correct
+     *    initialization sequences.
+     *
+     * 2. **Runtime Injection**: Runtime assets (HMR, bundle manifests) are prepended
+     *    to `entryAssetIds` via `unshift()` in `applyRuntimes.ts`. By honoring the
+     *    array order, runtimes are guaranteed to be visited (and thus output) before
+     *    application entry points, ensuring the runtime infrastructure is available
+     *    when application code executes.
+     *
+     * 3. **Deterministic Builds**: Consistent traversal order ensures reproducible
+     *    bundle output, which is essential for caching and build verification.
+     *
+     * The sorting only applies at the first traversal level (direct children of the
+     * start node). Subsequent levels follow standard DFS order based on the graph's
+     * edge structure.
+     *
+     * @param bundle - The bundle to traverse
+     * @param visit - Visitor callback receiving asset or dependency nodes
+     * @param startAsset - Optional asset to start traversal from (defaults to bundle root)
      */
     traverseBundle(bundle, visit, startAsset) {
         let entries = !startAsset;

package/dist/atlaspack-v3/AtlaspackV3.js

@@ -51,6 +51,13 @@ class AtlaspackV3 {
     buildAssetGraph() {
         return (0, rust_1.atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
     }
+    loadBundleGraph(bundleGraph) {
+        const { nodesJson, edges, publicIdByAssetId, environmentsJson } = bundleGraph.serializeForNative();
+        return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);
+    }
+    package(bundleId) {
+        return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi, bundleId);
+    }
     async respondToFsEvents(events) {
         // @ts-expect-error TS2488
         let [needsRebuild, error] = await (0, rust_1.atlaspackNapiRespondToFsEvents)(this._atlaspack_napi, events);

package/dist/requests/AtlaspackBuildRequest.js

@@ -15,6 +15,8 @@ const Bundle_1 = require("../public/Bundle");
 const Asset_1 = require("../public/Asset");
 const profiler_1 = require("@atlaspack/profiler");
 const RequestTracker_1 = require("../RequestTracker");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const EnvironmentManager_1 = require("../EnvironmentManager");
 function createAtlaspackBuildRequest(input) {
     return {
         type: RequestTracker_1.requestTypes.atlaspack_build_request,
@@ -34,6 +36,21 @@ async function run({ input, api, options, rustAtlaspack, }) {
         force: Boolean(rustAtlaspack) ||
             (options.shouldBuildLazily && requestedAssetIds.size > 0),
     });
+    if ((0, feature_flags_1.getFeatureFlag)('nativePackager') &&
+        (0, feature_flags_1.getFeatureFlag)('nativePackagerSSRDev') &&
+        rustAtlaspack) {
+        let hasSupportedTarget = false;
+        bundleGraph.traverseBundles((bundle, ctx, actions) => {
+            if ((0, EnvironmentManager_1.fromEnvironmentId)(bundle.env).context === 'tesseract' &&
+                bundle.type === 'js') {
+                hasSupportedTarget = true;
+                actions.stop();
+            }
+        });
+        if (hasSupportedTarget) {
+            await rustAtlaspack.loadBundleGraph(bundleGraph);
+        }
+    }
     // @ts-expect-error TS2345
     (0, dumpGraphToGraphViz_1.default)(bundleGraph._graph, 'BundleGraph', BundleGraph_1.bundleGraphEdgeTypes);
     await (0, ReporterRunner_1.report)({

package/dist/requests/BundleGraphRequest.js

@@ -104,7 +104,7 @@ function createBundleGraphRequest(input) {
             let { options, api, invalidateReason } = input;
             let { optionsRef, requestedAssetIds, signal } = input.input;
             let measurement = profiler_1.tracer.createMeasurement('building');
-            let createAssetGraphRequest = input.rustAtlaspack
+            let createAssetGraphRequest = (0, feature_flags_1.getFeatureFlag)('atlaspackV3') && input.rustAtlaspack
                 ? (0, AssetGraphRequestRust_1.createAssetGraphRequestRust)(input.rustAtlaspack)
                 : AssetGraphRequest_1.default;
             let request = createAssetGraphRequest({

package/dist/requests/PackageRequest.js

@@ -9,6 +9,10 @@ const nullthrows_1 = __importDefault(require("nullthrows"));
 const ConfigRequest_1 = require("./ConfigRequest");
 const DevDepRequest_1 = require("./DevDepRequest");
 const AtlaspackConfigRequest_1 = __importDefault(require("./AtlaspackConfigRequest"));
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
 function createPackageRequest(input) {
     return {
         type: RequestTracker_1.requestTypes.package_request,
@@ -17,21 +21,44 @@ function createPackageRequest(input) {
         input,
     };
 }
-async function run({ input, api, farm }) {
+async function run({ input, api, farm, rustAtlaspack }) {
     let { bundleGraphReference, optionsRef, bundle, useMainThread } = input;
     let runPackage = farm.createHandle('runPackage', useMainThread);
     let start = Date.now();
     let { devDeps, invalidDevDeps } = await (0, DevDepRequest_1.getDevDepRequests)(api);
     let { cachePath } = (0, nullthrows_1.default)(await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
-    let { devDepRequests, configRequests, bundleInfo, invalidations } = (await runPackage({
-        bundle,
-        bundleGraphReference,
-        optionsRef,
-        configCachePath: cachePath,
-        previousDevDeps: devDeps,
-        invalidDevDeps,
-        previousInvalidations: api.getInvalidations(),
-    }));
+    let packagingResult;
+    if ((0, feature_flags_1.getFeatureFlag)('nativePackager') &&
+        (0, feature_flags_1.getFeatureFlag)('nativePackagerSSRDev') &&
+        rustAtlaspack &&
+        (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env).context === 'tesseract' &&
+        bundle.type === 'js') {
+        // Once this actually does something, the code below will be in an `else` block (i.e. we'll only run one or the other)
+        let result = await rustAtlaspack.package(bundle.id);
+        let error = null;
+        [packagingResult, error] = result;
+        if (error) {
+            throw new diagnostic_1.default({
+                diagnostic: error,
+            });
+        }
+        logger_1.default.verbose({
+            message: JSON.stringify(packagingResult, null, 2),
+            origin: '@atlaspack/core',
+        });
+    }
+    else {
+        packagingResult = (await runPackage({
+            bundle,
+            bundleGraphReference,
+            optionsRef,
+            configCachePath: cachePath,
+            previousDevDeps: devDeps,
+            invalidDevDeps,
+            previousInvalidations: api.getInvalidations(),
+        }));
+    }
+    let { devDepRequests, configRequests, bundleInfo, invalidations } = packagingResult;
     for (let devDepRequest of devDepRequests) {
         await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
     }

package/dist/resolveOptions.js

@@ -132,7 +132,7 @@ async function resolveOptions(initialOptions) {
         if (initialOptions.cache) {
             return initialOptions.cache;
         }
-        const needsRustLmdbCache = (0, feature_flags_1.getFeatureFlag)('atlaspackV3');
+        const needsRustLmdbCache = (0, feature_flags_1.getFeatureFlag)('atlaspackV3') || (0, feature_flags_1.getFeatureFlag)('nativePackager');
         if (!(0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
             if (!needsRustLmdbCache && !(outputFS instanceof fs_1.NodeFS)) {
                 return new cache_1.FSCache(outputFS, cacheDir);

package/lib/Atlaspack.js

@@ -197,7 +197,7 @@ class Atlaspack {
     });
     this.#resolvedOptions = resolvedOptions;
     let rustAtlaspack;
-    if (resolvedOptions.featureFlags.atlaspackV3) {
+    if (resolvedOptions.featureFlags.atlaspackV3 || resolvedOptions.featureFlags.nativePackager) {
       // eslint-disable-next-line no-unused-vars
       let {
         entries,
@@ -553,7 +553,7 @@ class Atlaspack {
         message: `File watch event emitted with ${events.length} events. Sample event: [${(_events$ = events[0]) === null || _events$ === void 0 ? void 0 : _events$.type}] ${(_events$2 = events[0]) === null || _events$2 === void 0 ? void 0 : _events$2.path}`
       });
       let nativeInvalid = false;
-      if (this.rustAtlaspack) {
+      if ((0, _featureFlags().getFeatureFlag)('atlaspackV3') && this.rustAtlaspack) {
         nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
       }
       let {
@@ -634,7 +634,7 @@ class Atlaspack {
       requestedAssetIds: this.#requestedAssetIds
     };
     const start = Date.now();
-    const result = await this.#requestTracker.runRequest(this.rustAtlaspack != null ?
+    const result = await this.#requestTracker.runRequest((0, _featureFlags().getFeatureFlag)('atlaspackV3') && this.rustAtlaspack != null ?
     // @ts-expect-error TS2345
     (0, _AssetGraphRequestRust.createAssetGraphRequestRust)(this.rustAtlaspack)(input) :
     // @ts-expect-error TS2345

package/lib/BundleGraph.js

@@ -51,6 +51,13 @@ function _featureFlags() {
   };
   return data;
 }
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
 var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const bundleGraphEdgeTypes = exports.bundleGraphEdgeTypes = {
@@ -78,7 +85,7 @@ const bundleGraphEdgeTypes = exports.bundleGraphEdgeTypes = {
   internal_async: 5,
   // This type is used to mark an edge between a bundle and a conditional bundle.
   // This allows efficient discovery of conditional bundles in packaging
-  conditional: 5
+  conditional: 6
 };
 function makeReadOnlySet(set) {
   return new Proxy(set, {
@@ -428,6 +435,116 @@ class BundleGraph {
       conditions: serialized.conditions
     });
   }
+
+  /**
+   * Serialize the bundle graph for efficient transfer to native Rust code.
+   * Returns a JSON string of nodes, an array of edges, and a map of asset IDs to public IDs.
+   */
+  serializeForNative() {
+    const start = performance.now();
+    const nodes = this._graph.nodes;
+    const edges = [];
+    const edgeIterator = this._graph.getAllEdges();
+    let next = edgeIterator.next();
+    while (!next.done) {
+      const edge = next.value;
+      edges.push([edge.from, edge.to, edge.type]);
+      next = edgeIterator.next();
+    }
+
+    // Extract and deduplicate environments
+    const environmentMap = new Map();
+    const extractEnvironment = envRef => {
+      const env = (0, _EnvironmentManager.fromEnvironmentId)(envRef);
+      const envId = env.id;
+      if (!environmentMap.has(envId)) {
+        environmentMap.set(envId, env);
+      }
+      return envId;
+    };
+
+    // Replace env objects with env IDs in nodes
+    const processedNodes = nodes.map(node => {
+      var _node$value, _node$value2, _node$value3;
+      const processedNode = {
+        ...node
+      };
+      if (node.type === 'asset' && (_node$value = node.value) !== null && _node$value !== void 0 && _node$value.env) {
+        processedNode.value = {
+          ...node.value,
+          env: extractEnvironment(node.value.env)
+        };
+      } else if (node.type === 'dependency' && (_node$value2 = node.value) !== null && _node$value2 !== void 0 && _node$value2.env) {
+        processedNode.value = {
+          ...node.value,
+          env: extractEnvironment(node.value.env)
+        };
+      } else if (node.type === 'bundle' && (_node$value3 = node.value) !== null && _node$value3 !== void 0 && _node$value3.env) {
+        processedNode.value = {
+          ...node.value,
+          env: extractEnvironment(node.value.env)
+        };
+      }
+      return processedNode;
+    });
+
+    // Optimize nodes by omitting null/undefined values to reduce JSON size
+    const optimizedNodes = processedNodes.map(node => this._omitNulls(node));
+    const nodesJson = JSON.stringify(optimizedNodes);
+
+    // Serialize environments as array
+    const environments = Array.from(environmentMap.values());
+    const environmentsJson = JSON.stringify(environments);
+
+    // Convert Map to plain object for serialization
+    const publicIdByAssetId = {};
+    for (const [assetId, publicId] of this._publicIdByAssetId) {
+      publicIdByAssetId[assetId] = publicId;
+    }
+    const duration = performance.now() - start;
+    const nodesSizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+    const envsSizeMB = (environmentsJson.length / (1024 * 1024)).toFixed(2);
+    _logger().default.verbose({
+      origin: '@atlaspack/core',
+      message: `serializeForNative: ${duration.toFixed(1)}ms, ${nodesSizeMB}MB nodes, ${envsSizeMB}MB envs (${environmentMap.size} unique), ${nodes.length} nodes, ${edges.length} edges`
+    });
+    return {
+      nodesJson,
+      edges,
+      publicIdByAssetId,
+      environmentsJson
+    };
+  }
+
+  /**
+   * Remove null and undefined values from an object to reduce JSON size.
+   * Preserves false, 0, empty strings, and arrays.
+   */
+  _omitNulls(obj) {
+    if (obj === null || obj === undefined) return obj;
+    if (typeof obj !== 'object') return obj;
+    if (Array.isArray(obj)) {
+      return obj.map(item => this._omitNulls(item));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      if (value === null || value === undefined) {
+        continue;
+      }
+      if (typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length === 0) {
+        continue;
+      }
+      if (typeof value === 'object') {
+        const processed = this._omitNulls(value);
+        if (processed !== undefined) {
+          result[key] = processed;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
   createBundle(opts) {
     // @ts-expect-error TS2339
     let {
@@ -1084,8 +1201,36 @@ class BundleGraph {
   }
 
   /**
-   * TODO: Document why this works like this & why visitor order matters
-   * on these use-cases.
+   * Performs a depth-first traversal of all assets and dependencies contained
+   * within a bundle. Only visits nodes that are directly contained in the bundle
+   * (connected via a `contains` edge).
+   *
+   * Entry Asset Ordering:
+   * The traversal guarantees that entry assets are visited in the exact order they
+   * appear in `bundle.entryAssetIds`. This ordering is critical for several reasons:
+   *
+   * 1. **Code Execution Order in Packagers**: Packagers (ScopeHoistingPackager,
+   *    DevPackager) use this traversal to concatenate assets into the final bundle.
+   *    The traversal order determines the execution order of code in the output.
+   *    Entry assets must be processed in their defined order to ensure correct
+   *    initialization sequences.
+   *
+   * 2. **Runtime Injection**: Runtime assets (HMR, bundle manifests) are prepended
+   *    to `entryAssetIds` via `unshift()` in `applyRuntimes.ts`. By honoring the
+   *    array order, runtimes are guaranteed to be visited (and thus output) before
+   *    application entry points, ensuring the runtime infrastructure is available
+   *    when application code executes.
+   *
+   * 3. **Deterministic Builds**: Consistent traversal order ensures reproducible
+   *    bundle output, which is essential for caching and build verification.
+   *
+   * The sorting only applies at the first traversal level (direct children of the
+   * start node). Subsequent levels follow standard DFS order based on the graph's
+   * edge structure.
+   *
+   * @param bundle - The bundle to traverse
+   * @param visit - Visitor callback receiving asset or dependency nodes
+   * @param startAsset - Optional asset to start traversal from (defaults to bundle root)
    */
   traverseBundle(bundle, visit, startAsset) {
     let entries = !startAsset;

package/lib/atlaspack-v3/AtlaspackV3.js

@@ -72,6 +72,18 @@ class AtlaspackV3 {
   buildAssetGraph() {
     return (0, _rust().atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
   }
+  loadBundleGraph(bundleGraph) {
+    const {
+      nodesJson,
+      edges,
+      publicIdByAssetId,
+      environmentsJson
+    } = bundleGraph.serializeForNative();
+    return (0, _rust().atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);
+  }
+  package(bundleId) {
+    return (0, _rust().atlaspackNapiPackage)(this._atlaspack_napi, bundleId);
+  }
   async respondToFsEvents(events) {
     // @ts-expect-error TS2488
     let [needsRebuild, error] = await (0, _rust().atlaspackNapiRespondToFsEvents)(this._atlaspack_napi, events);

package/lib/requests/AtlaspackBuildRequest.js

@@ -21,6 +21,14 @@ function _profiler() {
   return data;
 }
 var _RequestTracker = require("../RequestTracker");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+var _EnvironmentManager = require("../EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAtlaspackBuildRequest(input) {
   return {
@@ -53,6 +61,18 @@ async function run({
   } = await api.runRequest(bundleGraphRequest, {
     force: Boolean(rustAtlaspack) || options.shouldBuildLazily && requestedAssetIds.size > 0
   });
+  if ((0, _featureFlags().getFeatureFlag)('nativePackager') && (0, _featureFlags().getFeatureFlag)('nativePackagerSSRDev') && rustAtlaspack) {
+    let hasSupportedTarget = false;
+    bundleGraph.traverseBundles((bundle, ctx, actions) => {
+      if ((0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context === 'tesseract' && bundle.type === 'js') {
+        hasSupportedTarget = true;
+        actions.stop();
+      }
+    });
+    if (hasSupportedTarget) {
+      await rustAtlaspack.loadBundleGraph(bundleGraph);
+    }
+  }
 
   // @ts-expect-error TS2345
   (0, _dumpGraphToGraphViz.default)(bundleGraph._graph, 'BundleGraph', _BundleGraph.bundleGraphEdgeTypes);

package/lib/requests/BundleGraphRequest.js

@@ -138,7 +138,7 @@ function createBundleGraphRequest(input) {
         signal
       } = input.input;
       let measurement = _profiler().tracer.createMeasurement('building');
-      let createAssetGraphRequest = input.rustAtlaspack ? (0, _AssetGraphRequestRust.createAssetGraphRequestRust)(input.rustAtlaspack) : _AssetGraphRequest.default;
+      let createAssetGraphRequest = (0, _featureFlags().getFeatureFlag)('atlaspackV3') && input.rustAtlaspack ? (0, _AssetGraphRequestRust.createAssetGraphRequestRust)(input.rustAtlaspack) : _AssetGraphRequest.default;
       let request = createAssetGraphRequest({
         name: 'Main',
         entries: options.entries,