@atlaspack/core 2.31.2 → 2.32.0

package/src/BundleGraph.ts

@@ -46,6 +46,7 @@ import {ISOLATED_ENVS} from './public/Environment';
 import {fromProjectPath, fromProjectPathRelative} from './projectPath';
 import {HASH_REF_PREFIX} from './constants';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+import logger from '@atlaspack/logger';
 import {fromEnvironmentId} from './EnvironmentManager';
 import type {EnvironmentRef} from './EnvironmentManager';
 
@@ -571,6 +572,76 @@ export default class 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][];
+  } {
+    const start = performance.now();
+
+    const nodes = this._graph.nodes as BundleGraphNode[];
+    const edges: [number, number, BundleGraphEdgeType][] = [];
+
+    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.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.
+   */
+  private _omitNulls(obj: unknown): unknown {
+    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: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+      if (value === null || value === undefined) {
+        continue;
+      }
+      if (
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        Object.keys(value as object).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:
       | {

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -3,6 +3,8 @@ import {
   atlaspackNapiBuildAssetGraph,
   atlaspackNapiRespondToFsEvents,
   atlaspackNapiCompleteSession,
+  atlaspackNapiLoadBundleGraph,
+  atlaspackNapiPackage,
   AtlaspackNapi,
   Lmdb,
   AtlaspackNapiOptions,
@@ -12,6 +14,8 @@ import {NapiWorkerPool} from './NapiWorkerPool';
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
 import type {Event} from '@parcel/watcher';
 import type {NapiWorkerPool as INapiWorkerPool} from '@atlaspack/types';
+import invariant from 'assert';
+import type BundleGraph from '../BundleGraph';
 
 export type AtlaspackV3Options = {
   fs?: AtlaspackNapiOptions['fs'];
@@ -97,6 +101,20 @@ export class AtlaspackV3 {
     return atlaspackNapiBuildAssetGraph(this._atlaspack_napi) as Promise<any>;
   }
 
+  loadBundleGraph(bundleGraph: BundleGraph): Promise<void> {
+    const {nodesJson, edges} = bundleGraph.serializeForNative();
+
+    return atlaspackNapiLoadBundleGraph(
+      this._atlaspack_napi,
+      nodesJson,
+      edges,
+    ) as Promise<void>;
+  }
+
+  package(): Promise<any> {
+    return atlaspackNapiPackage(this._atlaspack_napi) as Promise<any>;
+  }
+
   async respondToFsEvents(events: Array<Event>): Promise<boolean> {
     // @ts-expect-error TS2488
     let [needsRebuild, error] = await atlaspackNapiRespondToFsEvents(

package/src/requests/AtlaspackBuildRequest.ts

@@ -20,6 +20,9 @@ import {assetFromValue} from '../public/Asset';
 
 import {tracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {fromEnvironmentId} from '../EnvironmentManager';
+import invariant from 'assert';
 
 type AtlaspackBuildRequestInput = {
   optionsRef: SharedReference;
@@ -83,6 +86,26 @@ async function run({
         (options.shouldBuildLazily && requestedAssetIds.size > 0),
     });
 
+  if (
+    getFeatureFlag('nativePackager') &&
+    getFeatureFlag('nativePackagerSSRDev') &&
+    rustAtlaspack
+  ) {
+    let hasSupportedTarget = false;
+    bundleGraph.traverseBundles((bundle, ctx, actions) => {
+      if (
+        fromEnvironmentId(bundle.env).context === 'tesseract' &&
+        bundle.type === 'js'
+      ) {
+        hasSupportedTarget = true;
+        actions.stop();
+      }
+    });
+    if (hasSupportedTarget) {
+      await rustAtlaspack.loadBundleGraph(bundleGraph);
+    }
+  }
+
   // @ts-expect-error TS2345
   dumpGraphToGraphViz(bundleGraph._graph, 'BundleGraph', bundleGraphEdgeTypes);
 

package/src/requests/BundleGraphRequest.ts

@@ -141,9 +141,10 @@ export default function createBundleGraphRequest(
       let {optionsRef, requestedAssetIds, signal} = input.input;
       let measurement = tracer.createMeasurement('building');
 
-      let createAssetGraphRequest = input.rustAtlaspack
-        ? createAssetGraphRequestRust(input.rustAtlaspack)
-        : createAssetGraphRequestJS;
+      let createAssetGraphRequest =
+        getFeatureFlag('atlaspackV3') && input.rustAtlaspack
+          ? createAssetGraphRequestRust(input.rustAtlaspack)
+          : createAssetGraphRequestJS;
 
       let request = createAssetGraphRequest({
         name: 'Main',

package/src/requests/PackageRequest.ts

@@ -13,6 +13,8 @@ import nullthrows from 'nullthrows';
 import {runConfigRequest} from './ConfigRequest';
 import {getDevDepRequests, runDevDepRequest} from './DevDepRequest';
 import createAtlaspackConfigRequest from './AtlaspackConfigRequest';
+import {fromEnvironmentId} from '../EnvironmentManager';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type PackageRequestInput = {
   bundleGraph: BundleGraph;
@@ -46,8 +48,9 @@ export function createPackageRequest(
   };
 }
 
-async function run({input, api, farm}: RunInput<BundleInfo>) {
+async function run({input, api, farm, rustAtlaspack}: RunInput<BundleInfo>) {
   let {bundleGraphReference, optionsRef, bundle, useMainThread} = input;
+
   let runPackage = farm.createHandle('runPackage', useMainThread);
 
   let start = Date.now();
@@ -58,6 +61,17 @@ async function run({input, api, farm}: RunInput<BundleInfo>) {
     ),
   );
 
+  if (
+    getFeatureFlag('nativePackager') &&
+    getFeatureFlag('nativePackagerSSRDev') &&
+    rustAtlaspack &&
+    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,

package/src/resolveOptions.ts

@@ -181,7 +181,8 @@ export default async function resolveOptions(
       return initialOptions.cache;
     }
 
-    const needsRustLmdbCache = getFeatureFlag('atlaspackV3');
+    const needsRustLmdbCache =
+      getFeatureFlag('atlaspackV3') || getFeatureFlag('nativePackager');
 
     if (!getFeatureFlag('cachePerformanceImprovements')) {
       if (!needsRustLmdbCache && !(outputFS instanceof NodeFS)) {