@atlaspack/core 2.32.0 → 2.33.0

package/lib/requests/BundleGraphRequestUtils.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadPluginConfigWithDevDeps = loadPluginConfigWithDevDeps;
+exports.nameBundle = nameBundle;
+exports.runDevDepRequest = runDevDepRequest;
+exports.validateBundles = validateBundles;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+var _BundleGraph = _interopRequireDefault(require("../public/BundleGraph"));
+var _Bundle = require("../public/Bundle");
+var _InternalConfig = require("../InternalConfig");
+var _DevDepRequest = require("./DevDepRequest");
+var _ConfigRequest = require("./ConfigRequest");
+var _projectPath = require("../projectPath");
+function _profiler() {
+  const data = require("@atlaspack/profiler");
+  _profiler = function () {
+    return data;
+  };
+  return data;
+}
+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; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Shared utilities for BundleGraphRequest and BundleGraphRequestRust.
+ *
+ * This module contains common functionality used by both the JS and native
+ * bundling paths, such as bundle validation, naming, and configuration loading.
+ */
+
+/**
+ * Validates that all bundles have unique names.
+ * Throws an assertion error if duplicate bundle names are found.
+ */
+function validateBundles(bundleGraph) {
+  const bundles = bundleGraph.getBundles();
+  const bundleNames = bundles.map(b => (0, _projectPath.joinProjectPath)(b.target.distDir, (0, _nullthrows().default)(b.name)));
+  _assert().default.deepEqual(bundleNames, (0, _utils().unique)(bundleNames), 'Bundles must have unique name. Conflicting names: ' + [...(0, _utils().setSymmetricDifference)(new Set(bundleNames), new Set((0, _utils().unique)(bundleNames)))].join());
+}
+
+/**
+ * Names a bundle by running through the configured namers until one returns a name.
+ */
+async function nameBundle(namers, internalBundle, internalBundleGraph, options, pluginOptions, configs) {
+  const bundle = _Bundle.Bundle.get(internalBundle, internalBundleGraph, options);
+  const bundleGraph = new _BundleGraph.default(internalBundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), options);
+  for (const namer of namers) {
+    let measurement;
+    try {
+      var _configs$get;
+      measurement = _profiler().tracer.createMeasurement(namer.name, 'namer', bundle.id);
+      const name = await namer.plugin.name({
+        bundle,
+        bundleGraph,
+        config: (_configs$get = configs.get(namer.name)) === null || _configs$get === void 0 ? void 0 : _configs$get.result,
+        options: pluginOptions,
+        logger: new (_logger().PluginLogger)({
+          origin: namer.name
+        }),
+        tracer: new (_profiler().PluginTracer)({
+          origin: namer.name,
+          category: 'namer'
+        })
+      });
+      if (name != null) {
+        internalBundle.name = name;
+        const {
+          hashReference
+        } = internalBundle;
+        internalBundle.displayName = name.includes(hashReference) ? name.replace(hashReference, '[hash]') : name;
+        return;
+      }
+    } catch (e) {
+      throw new (_diagnostic().default)({
+        diagnostic: (0, _diagnostic().errorToDiagnostic)(e, {
+          origin: namer.name
+        })
+      });
+    } finally {
+      measurement && measurement.end();
+    }
+  }
+  throw new Error('Unable to name bundle');
+}
+
+/**
+ * Loads configuration for a plugin and tracks its dev dependencies.
+ */
+async function loadPluginConfigWithDevDeps(plugin, options, api, previousDevDeps, devDepRequests, configs) {
+  const config = (0, _InternalConfig.createConfig)({
+    plugin: plugin.name,
+    searchPath: (0, _projectPath.toProjectPathUnsafe)('index')
+  });
+  await (0, _ConfigRequest.loadPluginConfig)(plugin, config, options);
+  await (0, _ConfigRequest.runConfigRequest)(api, config);
+  for (const devDep of config.devDeps) {
+    const devDepRequest = await (0, _DevDepRequest.createDevDependency)(devDep, previousDevDeps, options);
+    await runDevDepRequest(api, devDepRequest, devDepRequests);
+  }
+  configs.set(plugin.name, config);
+}
+
+/**
+ * Runs a dev dependency request and tracks it in the devDepRequests map.
+ */
+async function runDevDepRequest(api, devDepRequest, devDepRequests) {
+  const {
+    specifier,
+    resolveFrom
+  } = devDepRequest;
+  const key = `${specifier}:${(0, _projectPath.fromProjectPathRelative)(resolveFrom)}`;
+  devDepRequests.set(key, devDepRequest);
+  await (0, _DevDepRequest.runDevDepRequest)(api, devDepRequest);
+}

package/lib/requests/PackageRequest.js

@@ -23,6 +23,20 @@ function _featureFlags() {
   };
   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 {
@@ -53,24 +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)
-    await rustAtlaspack.package();
+    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/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 = {
@@ -79,11 +79,13 @@ export default class BundleGraph {
     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.
+     * 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.
@@ -148,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,7 +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'];
@@ -23,8 +25,9 @@ export declare class AtlaspackV3 {
     static create({ fs, packageManager, threads, lmdb, napiWorkerPool, ...options }: AtlaspackV3Options): Promise<AtlaspackV3>;
     end(): void;
     buildAssetGraph(): Promise<any>;
+    buildBundleGraph(): Promise<any>;
     loadBundleGraph(bundleGraph: BundleGraph): Promise<void>;
-    package(): Promise<any>;
+    package(bundleId: string): Promise<[RunPackagerRunnerResult, Diagnostic | null]>;
     respondToFsEvents(events: Array<Event>): Promise<boolean>;
     completeCacheSession(): Promise<CacheStats>;
 }

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

@@ -23,6 +23,7 @@ export declare class AtlaspackWorker {
         env: {
             [k: string]: string | undefined;
         };
+        disableCache: boolean | undefined;
     } | undefined>;
 }
 type LoadPluginOptions = {

package/lib/types/requests/BundleGraphRequestRust.d.ts

@@ -0,0 +1,34 @@
+import type { Async } from '@atlaspack/types';
+import InternalBundleGraph from '../BundleGraph';
+import { requestTypes, StaticRunOpts } from '../RequestTracker';
+import type { BundleGraphResult } from './BundleGraphRequest';
+import type { Asset } from '../types';
+type BundleGraphRequestInput = {
+    requestedAssetIds: Set<string>;
+    signal?: AbortSignal;
+    optionsRef: any;
+};
+type RunInput = {
+    input: BundleGraphRequestInput;
+} & StaticRunOpts<BundleGraphResult>;
+type BundleGraphRequestRust = {
+    id: string;
+    readonly type: typeof requestTypes.bundle_graph_request;
+    run: (arg1: RunInput) => Async<BundleGraphResult>;
+    input: BundleGraphRequestInput;
+};
+type SerializedBundleGraph = {
+    nodes: Array<any>;
+    edges: Array<number>;
+    publicIdByAssetId: {
+        [k: string]: string;
+    };
+    assetPublicIds: Array<string>;
+    hadPreviousGraph: boolean;
+};
+export default function createBundleGraphRequestRust(input: BundleGraphRequestInput): BundleGraphRequestRust;
+export declare function getBundleGraph(serializedGraph: SerializedBundleGraph): {
+    bundleGraph: InternalBundleGraph;
+    changedAssets: Map<string, Asset>;
+};
+export {};

package/lib/types/requests/BundleGraphRequestUtils.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared utilities for BundleGraphRequest and BundleGraphRequestRust.
+ *
+ * This module contains common functionality used by both the JS and native
+ * bundling paths, such as bundle validation, naming, and configuration loading.
+ */
+import type { Namer } from '@atlaspack/types';
+import type { LoadedPlugin } from '../AtlaspackConfig';
+import type { RunAPI } from '../RequestTracker';
+import type { Bundle as InternalBundle, Config, DevDepRequest, AtlaspackOptions, DevDepRequestRef } from '../types';
+import InternalBundleGraph from '../BundleGraph';
+import PluginOptions from '../public/PluginOptions';
+import { PluginWithLoadConfig } from './ConfigRequest';
+import type { BundleGraphResult } from './BundleGraphRequest';
+/**
+ * Validates that all bundles have unique names.
+ * Throws an assertion error if duplicate bundle names are found.
+ */
+export declare function validateBundles(bundleGraph: InternalBundleGraph): void;
+/**
+ * Names a bundle by running through the configured namers until one returns a name.
+ */
+export declare function nameBundle(namers: Array<LoadedPlugin<Namer<unknown>>>, internalBundle: InternalBundle, internalBundleGraph: InternalBundleGraph, options: AtlaspackOptions, pluginOptions: PluginOptions, configs: Map<string, Config>): Promise<void>;
+/**
+ * Loads configuration for a plugin and tracks its dev dependencies.
+ */
+export declare function loadPluginConfigWithDevDeps<T extends PluginWithLoadConfig>(plugin: LoadedPlugin<T>, options: AtlaspackOptions, api: RunAPI<BundleGraphResult>, previousDevDeps: Map<string, string>, devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>, configs: Map<string, Config>): Promise<void>;
+/**
+ * Runs a dev dependency request and tracks it in the devDepRequests map.
+ */
+export declare function runDevDepRequest(api: RunAPI<BundleGraphResult>, devDepRequest: DevDepRequest | DevDepRequestRef, devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.32.0",
+  "version": "2.33.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.9",
-    "@atlaspack/cache": "3.2.45",
+    "@atlaspack/build-cache": "2.13.10",
+    "@atlaspack/cache": "3.2.47",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@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",
+    "@atlaspack/feature-flags": "2.29.0",
+    "@atlaspack/fs": "2.15.47",
+    "@atlaspack/graph": "3.6.14",
+    "@atlaspack/logger": "2.14.44",
+    "@atlaspack/package-manager": "2.14.52",
+    "@atlaspack/plugin": "2.14.52",
+    "@atlaspack/profiler": "2.15.13",
+    "@atlaspack/rust": "3.22.0",
+    "@atlaspack/types": "2.15.42",
+    "@atlaspack/utils": "3.3.4",
+    "@atlaspack/workers": "2.14.52",
+    "@atlaspack/source-map": "3.2.7",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",

package/src/BundleGraph.ts

@@ -22,6 +22,7 @@ import type {
   BundleNode,
   Dependency,
   DependencyNode,
+  Environment,
   InternalSourceLocation,
   Target,
   Condition,
@@ -75,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 =
@@ -574,11 +575,13 @@ 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.
+   * 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();
 
@@ -593,18 +596,62 @@ export default class BundleGraph {
       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 = nodes.map((node) => this._omitNulls(node));
+    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 sizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+    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, ${sizeMB}MB JSON, ${nodes.length} nodes, ${edges.length} edges`,
+      message: `serializeForNative: ${duration.toFixed(1)}ms, ${nodesSizeMB}MB nodes, ${envsSizeMB}MB envs (${environmentMap.size} unique), ${nodes.length} nodes, ${edges.length} edges`,
     });
 
-    return {nodesJson, edges};
+    return {nodesJson, edges, publicIdByAssetId, environmentsJson};
   }
 
   /**
@@ -1773,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

@@ -1,6 +1,7 @@
 import {
   atlaspackNapiCreate,
   atlaspackNapiBuildAssetGraph,
+  atlaspackNapiBuildBundleGraph,
   atlaspackNapiRespondToFsEvents,
   atlaspackNapiCompleteSession,
   atlaspackNapiLoadBundleGraph,
@@ -11,11 +12,11 @@ import {
   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 invariant from 'assert';
 import type BundleGraph from '../BundleGraph';
+import {RunPackagerRunnerResult} from '../PackagerRunner';
 
 export type AtlaspackV3Options = {
   fs?: AtlaspackNapiOptions['fs'];
@@ -101,18 +102,29 @@ export class AtlaspackV3 {
     return atlaspackNapiBuildAssetGraph(this._atlaspack_napi) as Promise<any>;
   }
 
+  buildBundleGraph(): Promise<any> {
+    return atlaspackNapiBuildBundleGraph(this._atlaspack_napi) as Promise<any>;
+  }
+
   loadBundleGraph(bundleGraph: BundleGraph): Promise<void> {
-    const {nodesJson, edges} = bundleGraph.serializeForNative();
+    const {nodesJson, edges, publicIdByAssetId, environmentsJson} =
+      bundleGraph.serializeForNative();
 
     return atlaspackNapiLoadBundleGraph(
       this._atlaspack_napi,
       nodesJson,
       edges,
+      publicIdByAssetId,
+      environmentsJson,
     ) as Promise<void>;
   }
 
-  package(): Promise<any> {
-    return atlaspackNapiPackage(this._atlaspack_napi) as Promise<any>;
+  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> {

package/src/atlaspack-v3/worker/worker.ts

@@ -424,6 +424,7 @@ export class AtlaspackWorker {
         conditions: setupResult?.conditions,
         config,
         env: allowedEnv,
+        disableCache: setupResult?.disableCache,
       };
     }
 

package/src/requests/AtlaspackBuildRequest.ts

@@ -9,6 +9,7 @@ import type BundleGraph from '../BundleGraph';
 import createBundleGraphRequest, {
   BundleGraphResult,
 } from './BundleGraphRequest';
+import createBundleGraphRequestRust from './BundleGraphRequestRust';
 import createWriteBundlesRequest from './WriteBundlesRequest';
 import {assertSignalNotAborted} from '../utils';
 import dumpGraphToGraphViz from '../dumpGraphToGraphViz';
@@ -73,11 +74,18 @@ async function run({
 }: RunInput<AtlaspackBuildRequestResult>) {
   let {optionsRef, requestedAssetIds, signal} = input;
 
-  let bundleGraphRequest = createBundleGraphRequest({
-    optionsRef,
-    requestedAssetIds,
-    signal,
-  });
+  let bundleGraphRequest =
+    getFeatureFlag('nativeBundling') && rustAtlaspack
+      ? createBundleGraphRequestRust({
+          optionsRef,
+          requestedAssetIds,
+          signal,
+        })
+      : createBundleGraphRequest({
+          optionsRef,
+          requestedAssetIds,
+          signal,
+        });
 
   let {bundleGraph, changedAssets, assetRequests}: BundleGraphResult =
     await api.runRequest(bundleGraphRequest, {