@atlaspack/core 2.31.3 → 2.32.1

package/lib/requests/PackageRequest.js

@@ -15,6 +15,28 @@ 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 _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createPackageRequest(input) {
   return {
@@ -27,7 +49,8 @@ function createPackageRequest(input) {
 async function run({
   input,
   api,
-  farm
+  farm,
+  rustAtlaspack
 }) {
   let {
     bundleGraphReference,
@@ -44,20 +67,38 @@ async function run({
   let {
     cachePath
   } = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
+  let packagingResult;
+  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)
+    let result = await rustAtlaspack.package(bundle.id);
+    let error = null;
+    [packagingResult, error] = result;
+    if (error) {
+      throw new (_diagnostic().default)({
+        diagnostic: error
+      });
+    }
+    _logger().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
-  } = await runPackage({
-    bundle,
-    bundleGraphReference,
-    optionsRef,
-    configCachePath: cachePath,
-    previousDevDeps: devDeps,
-    invalidDevDeps,
-    previousInvalidations: api.getInvalidations()
-  });
+  } = packagingResult;
   for (let devDepRequest of devDepRequests) {
     await (0, _DevDepRequest.runDevDepRequest)(api, devDepRequest);
   }

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

@@ -11,7 +11,7 @@ export declare const bundleGraphEdgeTypes: {
     readonly bundle: 3;
     readonly references: 4;
     readonly internal_async: 5;
-    readonly conditional: 5;
+    readonly conditional: 6;
 };
 export type BundleGraphEdgeType = (typeof bundleGraphEdgeTypes)[keyof typeof bundleGraphEdgeTypes];
 type InternalSymbolResolution = {
@@ -77,6 +77,21 @@ 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, an array of edges, and a map of asset IDs to public IDs.
+     */
+    serializeForNative(): {
+        nodesJson: string;
+        edges: [number, number, BundleGraphEdgeType][];
+        publicIdByAssetId: Record<string, string>;
+        environmentsJson: string;
+    };
+    /**
+     * 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>;
@@ -135,8 +150,36 @@ export default class BundleGraph {
     getParentBundles(bundle: Bundle): Array<Bundle>;
     isAssetReachableFromBundle(asset: Asset, bundle: Bundle): boolean;
     /**
-     * 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<TContext>(bundle: Bundle, visit: GraphVisitor<AssetNode | DependencyNode, TContext>, startAsset?: Asset): TContext | null | undefined;
     traverse<TContext>(visit: GraphVisitor<AssetNode | DependencyNode, TContext>, start?: Asset): TContext | null | undefined;

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

@@ -1,6 +1,9 @@
 import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions, CacheStats } from '@atlaspack/rust';
+import { Diagnostic } from '@atlaspack/diagnostic';
 import type { Event } from '@parcel/watcher';
 import type { NapiWorkerPool as INapiWorkerPool } from '@atlaspack/types';
+import type BundleGraph from '../BundleGraph';
+import { RunPackagerRunnerResult } from '../PackagerRunner';
 export type AtlaspackV3Options = {
     fs?: AtlaspackNapiOptions['fs'];
     packageManager?: AtlaspackNapiOptions['packageManager'];
@@ -22,6 +25,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(bundleId: string): Promise<[RunPackagerRunnerResult, Diagnostic | null]>;
     respondToFsEvents(events: Array<Event>): Promise<boolean>;
     completeCacheSession(): Promise<CacheStats>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.31.3",
+  "version": "2.32.1",
   "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.8",
-    "@atlaspack/cache": "3.2.44",
+    "@atlaspack/build-cache": "2.13.9",
+    "@atlaspack/cache": "3.2.46",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.27.7",
-    "@atlaspack/fs": "2.15.44",
-    "@atlaspack/graph": "3.6.11",
-    "@atlaspack/logger": "2.14.41",
-    "@atlaspack/package-manager": "2.14.49",
-    "@atlaspack/plugin": "2.14.49",
-    "@atlaspack/profiler": "2.15.10",
-    "@atlaspack/rust": "3.19.0",
-    "@atlaspack/types": "2.15.39",
-    "@atlaspack/utils": "3.3.1",
-    "@atlaspack/workers": "2.14.49",
-    "@atlaspack/source-map": "3.2.4",
+    "@atlaspack/feature-flags": "2.28.0",
+    "@atlaspack/fs": "2.15.46",
+    "@atlaspack/graph": "3.6.13",
+    "@atlaspack/logger": "2.14.43",
+    "@atlaspack/package-manager": "2.14.51",
+    "@atlaspack/plugin": "2.14.51",
+    "@atlaspack/profiler": "2.15.12",
+    "@atlaspack/rust": "3.21.0",
+    "@atlaspack/types": "2.15.41",
+    "@atlaspack/utils": "3.3.3",
+    "@atlaspack/workers": "2.14.51",
+    "@atlaspack/source-map": "3.2.6",
     "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

package/src/BundleGraph.ts

@@ -22,6 +22,7 @@ import type {
   BundleNode,
   Dependency,
   DependencyNode,
+  Environment,
   InternalSourceLocation,
   Target,
   Condition,
@@ -46,6 +47,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';
 
@@ -74,7 +76,7 @@ export const 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,
 } as const;
 
 export type BundleGraphEdgeType =
@@ -571,6 +573,122 @@ export default class BundleGraph {
     });
   }
 
+  /**
+   * 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(): {
+    nodesJson: string;
+    edges: [number, number, BundleGraphEdgeType][];
+    publicIdByAssetId: Record<string, string>;
+    environmentsJson: string;
+  } {
+    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();
+    }
+
+    // Extract and deduplicate environments
+    const environmentMap = new Map<string, Environment>();
+    const extractEnvironment = (envRef: EnvironmentRef): string => {
+      const env = 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: Record<string, string> = {};
+    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.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.
+   */
+  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:
       | {
@@ -1702,8 +1820,36 @@ export default 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<TContext>(
     bundle: Bundle,

package/src/atlaspack-v3/AtlaspackV3.ts

@@ -3,15 +3,19 @@ import {
   atlaspackNapiBuildAssetGraph,
   atlaspackNapiRespondToFsEvents,
   atlaspackNapiCompleteSession,
+  atlaspackNapiLoadBundleGraph,
+  atlaspackNapiPackage,
   AtlaspackNapi,
   Lmdb,
   AtlaspackNapiOptions,
   CacheStats,
 } from '@atlaspack/rust';
 import {NapiWorkerPool} from './NapiWorkerPool';
-import ThrowableDiagnostic from '@atlaspack/diagnostic';
+import ThrowableDiagnostic, {Diagnostic} from '@atlaspack/diagnostic';
 import type {Event} from '@parcel/watcher';
 import type {NapiWorkerPool as INapiWorkerPool} from '@atlaspack/types';
+import type BundleGraph from '../BundleGraph';
+import {RunPackagerRunnerResult} from '../PackagerRunner';
 
 export type AtlaspackV3Options = {
   fs?: AtlaspackNapiOptions['fs'];
@@ -97,6 +101,27 @@ export class AtlaspackV3 {
     return atlaspackNapiBuildAssetGraph(this._atlaspack_napi) as Promise<any>;
   }
 
+  loadBundleGraph(bundleGraph: BundleGraph): Promise<void> {
+    const {nodesJson, edges, publicIdByAssetId, environmentsJson} =
+      bundleGraph.serializeForNative();
+
+    return atlaspackNapiLoadBundleGraph(
+      this._atlaspack_napi,
+      nodesJson,
+      edges,
+      publicIdByAssetId,
+      environmentsJson,
+    ) as Promise<void>;
+  }
+
+  package(
+    bundleId: string,
+  ): Promise<[RunPackagerRunnerResult, Diagnostic | null]> {
+    return atlaspackNapiPackage(this._atlaspack_napi, bundleId) as Promise<
+      [RunPackagerRunnerResult, Diagnostic | null]
+    >;
+  }
+
   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,10 @@ 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';
+import logger from '@atlaspack/logger';
+import ThrowableDiagnostic, {Diagnostic} from '@atlaspack/diagnostic';
 
 type PackageRequestInput = {
   bundleGraph: BundleGraph;
@@ -46,8 +50,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,8 +63,29 @@ async function run({input, api, farm}: RunInput<BundleInfo>) {
     ),
   );
 
-  let {devDepRequests, configRequests, bundleInfo, invalidations} =
-    (await runPackage({
+  let packagingResult: RunPackagerRunnerResult;
+  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)
+    let result = await rustAtlaspack.package(bundle.id);
+    let error: Diagnostic | null = null;
+    [packagingResult, error] = result;
+    if (error) {
+      throw new ThrowableDiagnostic({
+        diagnostic: error,
+      });
+    }
+    logger.verbose({
+      message: JSON.stringify(packagingResult, null, 2),
+      origin: '@atlaspack/core',
+    });
+  } else {
+    packagingResult = (await runPackage({
       bundle,
       bundleGraphReference,
       optionsRef,
@@ -68,7 +94,10 @@ async function run({input, api, farm}: RunInput<BundleInfo>) {
       invalidDevDeps,
       previousInvalidations: api.getInvalidations(),
     })) as RunPackagerRunnerResult;
+  }
 
+  let {devDepRequests, configRequests, bundleInfo, invalidations} =
+    packagingResult;
   for (let devDepRequest of devDepRequests) {
     await runDevDepRequest(api, devDepRequest);
   }

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