@atlaspack/core 2.31.2 → 2.32.0

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @atlaspack/core
 
+## 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
+
+- Updated dependencies [[`fc3adc0`](https://github.com/atlassian-labs/atlaspack/commit/fc3adc098f583e40d6d7687412cac6dde7cbb3f3), [`f33f9c4`](https://github.com/atlassian-labs/atlaspack/commit/f33f9c48dd24b319df352d197e4a83cbb1b053bc), [`e15fb6c`](https://github.com/atlassian-labs/atlaspack/commit/e15fb6c885c6354c6c02283de35ce18abc8c9e18), [`53da216`](https://github.com/atlassian-labs/atlaspack/commit/53da216320e19c9b71b001386eb420d05f111db8)]:
+  - @atlaspack/rust@3.19.0
+  - @atlaspack/feature-flags@2.27.7
+  - @atlaspack/cache@3.2.44
+  - @atlaspack/fs@2.15.44
+  - @atlaspack/logger@2.14.41
+  - @atlaspack/source-map@3.2.4
+  - @atlaspack/utils@3.3.1
+  - @atlaspack/build-cache@2.13.8
+  - @atlaspack/graph@3.6.11
+  - @atlaspack/package-manager@2.14.49
+  - @atlaspack/profiler@2.15.10
+  - @atlaspack/workers@2.14.49
+  - @atlaspack/plugin@2.14.49
+  - @atlaspack/types@2.15.39
+
 ## 2.31.2
 
 ### 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
@@ -380,6 +381,66 @@ class BundleGraph {
             conditions: serialized.conditions,
         });
     }
+    /**
+     * Serialize the bundle graph for efficient transfer to native Rust code.
+     * Returns a JSON string of nodes and an array of edges.
+     */
+    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();
+        }
+        // Optimize nodes by omitting null/undefined values to reduce JSON size
+        const optimizedNodes = nodes.map((node) => this._omitNulls(node));
+        const nodesJson = JSON.stringify(optimizedNodes);
+        const duration = performance.now() - start;
+        const sizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+        logger_1.default.verbose({
+            origin: '@atlaspack/core',
+            message: `serializeForNative: ${duration.toFixed(1)}ms, ${sizeMB}MB JSON, ${nodes.length} nodes, ${edges.length} edges`,
+        });
+        return { nodesJson, edges };
+    }
+    /**
+     * 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;

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 } = bundleGraph.serializeForNative();
+        return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges);
+    }
+    package() {
+        return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi);
+    }
     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,8 @@ 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");
 function createPackageRequest(input) {
     return {
         type: RequestTracker_1.requestTypes.package_request,
@@ -17,12 +19,20 @@ 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)()));
+    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)
+        await rustAtlaspack.package();
+    }
     let { devDepRequests, configRequests, bundleInfo, invalidations } = (await runPackage({
         bundle,
         bundleGraphReference,

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 = {
@@ -428,6 +435,67 @@ class BundleGraph {
       conditions: serialized.conditions
     });
   }
+
+  /**
+   * Serialize the bundle graph for efficient transfer to native Rust code.
+   * Returns a JSON string of nodes and an array of edges.
+   */
+  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();
+    }
+
+    // Optimize nodes by omitting null/undefined values to reduce JSON size
+    const optimizedNodes = nodes.map(node => this._omitNulls(node));
+    const nodesJson = JSON.stringify(optimizedNodes);
+    const duration = performance.now() - start;
+    const sizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+    _logger().default.verbose({
+      origin: '@atlaspack/core',
+      message: `serializeForNative: ${duration.toFixed(1)}ms, ${sizeMB}MB JSON, ${nodes.length} nodes, ${edges.length} edges`
+    });
+    return {
+      nodesJson,
+      edges
+    };
+  }
+
+  /**
+   * 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 {

package/lib/atlaspack-v3/AtlaspackV3.js

@@ -72,6 +72,16 @@ class AtlaspackV3 {
   buildAssetGraph() {
     return (0, _rust().atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
   }
+  loadBundleGraph(bundleGraph) {
+    const {
+      nodesJson,
+      edges
+    } = bundleGraph.serializeForNative();
+    return (0, _rust().atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges);
+  }
+  package() {
+    return (0, _rust().atlaspackNapiPackage)(this._atlaspack_napi);
+  }
   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,

package/lib/requests/PackageRequest.js

@@ -15,6 +15,14 @@ function _nullthrows() {
 var _ConfigRequest = require("./ConfigRequest");
 var _DevDepRequest = require("./DevDepRequest");
 var _AtlaspackConfigRequest = _interopRequireDefault(require("./AtlaspackConfigRequest"));
+var _EnvironmentManager = require("../EnvironmentManager");
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createPackageRequest(input) {
   return {
@@ -27,7 +35,8 @@ function createPackageRequest(input) {
 async function run({
   input,
   api,
-  farm
+  farm,
+  rustAtlaspack
 }) {
   let {
     bundleGraphReference,
@@ -44,6 +53,10 @@ async function run({
   let {
     cachePath
   } = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
+  if ((0, _featureFlags().getFeatureFlag)('nativePackager') && (0, _featureFlags().getFeatureFlag)('nativePackagerSSRDev') && rustAtlaspack && (0, _EnvironmentManager.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)
+    await rustAtlaspack.package();
+  }
   let {
     devDepRequests,
     configRequests,

package/lib/resolveOptions.js

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

package/lib/types/BundleGraph.d.ts

@@ -77,6 +77,19 @@ export default class BundleGraph {
     static fromAssetGraph(assetGraph: AssetGraph, isProduction: boolean, publicIdByAssetId?: Map<string, string>, assetPublicIds?: Set<string>): BundleGraph;
     serialize(): SerializedBundleGraph;
     static deserialize(serialized: BundleGraphOpts): BundleGraph;
+    /**
+     * Serialize the bundle graph for efficient transfer to native Rust code.
+     * Returns a JSON string of nodes and an array of edges.
+     */
+    serializeForNative(): {
+        nodesJson: string;
+        edges: [number, number, BundleGraphEdgeType][];
+    };
+    /**
+     * Remove null and undefined values from an object to reduce JSON size.
+     * Preserves false, 0, empty strings, and arrays.
+     */
+    private _omitNulls;
     createBundle(opts: {
         readonly entryAsset: Asset;
         readonly bundleRoots?: Array<Asset>;

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

@@ -1,6 +1,7 @@
 import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions, CacheStats } from '@atlaspack/rust';
 import type { Event } from '@parcel/watcher';
 import type { NapiWorkerPool as INapiWorkerPool } from '@atlaspack/types';
+import type BundleGraph from '../BundleGraph';
 export type AtlaspackV3Options = {
     fs?: AtlaspackNapiOptions['fs'];
     packageManager?: AtlaspackNapiOptions['packageManager'];
@@ -22,6 +23,8 @@ export declare class AtlaspackV3 {
     static create({ fs, packageManager, threads, lmdb, napiWorkerPool, ...options }: AtlaspackV3Options): Promise<AtlaspackV3>;
     end(): void;
     buildAssetGraph(): Promise<any>;
+    loadBundleGraph(bundleGraph: BundleGraph): Promise<void>;
+    package(): Promise<any>;
     respondToFsEvents(events: Array<Event>): Promise<boolean>;
     completeCacheSession(): Promise<CacheStats>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.31.2",
+  "version": "2.32.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.7",
-    "@atlaspack/cache": "3.2.43",
+    "@atlaspack/build-cache": "2.13.9",
+    "@atlaspack/cache": "3.2.45",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.27.6",
-    "@atlaspack/fs": "2.15.43",
-    "@atlaspack/graph": "3.6.10",
-    "@atlaspack/logger": "2.14.40",
-    "@atlaspack/package-manager": "2.14.48",
-    "@atlaspack/plugin": "2.14.48",
-    "@atlaspack/profiler": "2.15.9",
-    "@atlaspack/rust": "3.18.0",
-    "@atlaspack/types": "2.15.38",
-    "@atlaspack/utils": "3.3.0",
-    "@atlaspack/workers": "2.14.48",
-    "@atlaspack/source-map": "3.2.3",
+    "@atlaspack/feature-flags": "2.28.0",
+    "@atlaspack/fs": "2.15.45",
+    "@atlaspack/graph": "3.6.12",
+    "@atlaspack/logger": "2.14.42",
+    "@atlaspack/package-manager": "2.14.50",
+    "@atlaspack/plugin": "2.14.50",
+    "@atlaspack/profiler": "2.15.11",
+    "@atlaspack/rust": "3.20.0",
+    "@atlaspack/types": "2.15.40",
+    "@atlaspack/utils": "3.3.2",
+    "@atlaspack/workers": "2.14.50",
+    "@atlaspack/source-map": "3.2.5",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",

package/src/Atlaspack.ts

@@ -58,7 +58,11 @@ import {
   fromProjectPathRelative,
 } from './projectPath';
 import {tracer, NativeProfiler} from '@atlaspack/profiler';
-import {setFeatureFlags, DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
+import {
+  setFeatureFlags,
+  DEFAULT_FEATURE_FLAGS,
+  getFeatureFlag,
+} from '@atlaspack/feature-flags';
 import {AtlaspackV3, FileSystemV3} from './atlaspack-v3';
 import createAssetGraphRequestJS from './requests/AssetGraphRequest';
 import {createAssetGraphRequestRust} from './requests/AssetGraphRequestRust';
@@ -165,7 +169,10 @@ export default class Atlaspack {
     this.#resolvedOptions = resolvedOptions;
 
     let rustAtlaspack: AtlaspackV3;
-    if (resolvedOptions.featureFlags.atlaspackV3) {
+    if (
+      resolvedOptions.featureFlags.atlaspackV3 ||
+      resolvedOptions.featureFlags.nativePackager
+    ) {
       // eslint-disable-next-line no-unused-vars
       let {entries, inputFS, outputFS, ...options} = this.#initialOptions;
 
@@ -585,7 +592,7 @@ export default class Atlaspack {
         });
 
         let nativeInvalid = false;
-        if (this.rustAtlaspack) {
+        if (getFeatureFlag('atlaspackV3') && this.rustAtlaspack) {
           nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
         }
 
@@ -681,7 +688,7 @@ export default class Atlaspack {
 
     const start = Date.now();
     const result = await this.#requestTracker.runRequest(
-      this.rustAtlaspack != null
+      getFeatureFlag('atlaspackV3') && this.rustAtlaspack != null
         ? // @ts-expect-error TS2345
           createAssetGraphRequestRust(this.rustAtlaspack)(input)
         : // @ts-expect-error TS2345