@atlaspack/core 2.32.0 → 2.33.0

package/dist/requests/BundleGraphRequestRust.js

@@ -0,0 +1,320 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createBundleGraphRequestRust;
+exports.getBundleGraph = getBundleGraph;
+const assert_1 = __importDefault(require("assert"));
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
+const graph_1 = require("@atlaspack/graph");
+const logger_1 = require("@atlaspack/logger");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const BundleGraph_1 = __importStar(require("../BundleGraph"));
+const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const rust_1 = require("@atlaspack/rust");
+const PluginOptions_1 = __importDefault(require("../public/PluginOptions"));
+const applyRuntimes_1 = __importDefault(require("../applyRuntimes"));
+const constants_1 = require("../constants");
+const utils_1 = require("../utils");
+const DevDepRequest_1 = require("./DevDepRequest");
+const RequestTracker_1 = require("../RequestTracker");
+const AtlaspackConfigRequest_1 = __importStar(require("./AtlaspackConfigRequest"));
+const BundleGraphRequestUtils_1 = require("./BundleGraphRequestUtils");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const Environment_1 = require("../Environment");
+function createBundleGraphRequestRust(input) {
+    return {
+        type: RequestTracker_1.requestTypes.bundle_graph_request,
+        id: 'BundleGraphRust',
+        run: async (runInput) => {
+            const { api, options, rustAtlaspack } = runInput;
+            (0, assert_1.default)(rustAtlaspack, 'BundleGraphRequestRust requires rustAtlaspack');
+            let { bundleGraphPromise, commitPromise } = await rustAtlaspack.buildBundleGraph();
+            let [serializedBundleGraph, bundleGraphError] = (await bundleGraphPromise);
+            if (bundleGraphError) {
+                throw new diagnostic_1.default({ diagnostic: bundleGraphError });
+            }
+            // Don’t reuse previous JS result yet; we just rebuild from scratch.
+            let { bundleGraph, changedAssets } = (0, logger_1.instrument)('atlaspack_v3_getBundleGraph', () => getBundleGraph(serializedBundleGraph));
+            const runner = new NativeBundlerRunner({ api, options }, input.optionsRef);
+            await runner.loadConfigs();
+            // Name all bundles
+            const namers = await runner.config.getNamers();
+            const bundles = bundleGraph.getBundles({ includeInline: true });
+            await Promise.all(bundles.map((b) => (0, BundleGraphRequestUtils_1.nameBundle)(namers, b, bundleGraph, options, runner.pluginOptions, runner.configs)));
+            // Apply runtimes
+            const changedRuntimes = await (0, logger_1.instrumentAsync)('applyRuntimes', () => (0, applyRuntimes_1.default)({
+                bundleGraph,
+                api,
+                config: runner.config,
+                options,
+                optionsRef: input.optionsRef,
+                pluginOptions: runner.pluginOptions,
+                previousDevDeps: runner.previousDevDeps,
+                devDepRequests: runner.devDepRequests,
+                configs: runner.configs,
+            }));
+            // Add dev deps for namers
+            for (const namer of namers) {
+                const devDepRequest = await (0, DevDepRequest_1.createDevDependency)({
+                    specifier: namer.name,
+                    resolveFrom: namer.resolveFrom,
+                }, runner.previousDevDeps, options);
+                await (0, BundleGraphRequestUtils_1.runDevDepRequest)(api, devDepRequest, runner.devDepRequests);
+            }
+            (0, BundleGraphRequestUtils_1.validateBundles)(bundleGraph);
+            bundleGraph.getBundleGraphHash();
+            await (0, dumpGraphToGraphViz_1.default)(
+            // @ts-expect-error Accessing internal graph for debug output
+            bundleGraph._graph, 'after_runtimes_native', BundleGraph_1.bundleGraphEdgeTypes);
+            let [_commitResult, commitError] = await commitPromise;
+            if (commitError) {
+                throw new diagnostic_1.default({
+                    diagnostic: {
+                        message: 'Error committing bundle graph in Rust: ' + commitError.message,
+                    },
+                });
+            }
+            return {
+                bundleGraph,
+                // Not accurate yet — ok for now.
+                assetGraphBundlingVersion: 0,
+                changedAssets: changedRuntimes,
+                assetRequests: [],
+            };
+        },
+        input,
+    };
+}
+function mapSymbols({ exported, ...symbol }) {
+    let jsSymbol = {
+        local: symbol.local ?? undefined,
+        loc: symbol.loc ?? undefined,
+        isWeak: symbol.isWeak,
+        meta: {
+            isEsm: symbol.isEsmExport,
+            isStaticBindingSafe: symbol.isStaticBindingSafe,
+        },
+    };
+    if (symbol.exported) {
+        jsSymbol.exported = symbol.exported;
+    }
+    return [exported, jsSymbol];
+}
+function normalizeEnv(env) {
+    if (!env)
+        return env;
+    env.id = env.id || (0, Environment_1.getEnvironmentHash)(env);
+    return (0, EnvironmentManager_1.toEnvironmentRef)(env);
+}
+function getBundleGraph(serializedGraph) {
+    // Build a fresh internal bundle graph.
+    const publicIdByAssetId = new Map(Object.entries(serializedGraph.publicIdByAssetId ?? {}));
+    const assetPublicIds = new Set(serializedGraph.assetPublicIds ?? []);
+    // BundleGraph constructor expects a ContentGraph under `_graph`.
+    // We reuse the internal graph class by creating an empty instance and then adding nodes.
+    const graph = new BundleGraph_1.default({
+        // We intentionally start with an empty graph and add nodes/edges from the Rust payload.
+        // `ContentGraph` will allocate as needed.
+        graph: new graph_1.ContentGraph(),
+        bundleContentHashes: new Map(),
+        publicIdByAssetId,
+        assetPublicIds,
+        conditions: new Map(),
+    });
+    // Root must exist at node id 0.
+    const rootNodeId = graph._graph.addNodeByContentKey('@@root', {
+        id: '@@root',
+        type: 'root',
+        value: null,
+    });
+    graph._graph.setRootNodeId(rootNodeId);
+    let entry = 0;
+    const changedAssets = new Map();
+    const decoder = new TextDecoder();
+    // Create nodes in order.
+    for (let i = 0; i < serializedGraph.nodes.length; i++) {
+        // Nodes come back as buffers (same as AssetGraphRequestRust)
+        let node = JSON.parse(decoder.decode(serializedGraph.nodes[i]));
+        if (node.type === 'root') {
+            continue;
+        }
+        if (node.type === 'entry') {
+            let id = 'entry:' + ++entry;
+            graph._graph.addNodeByContentKey(id, { id, type: 'root', value: null });
+            continue;
+        }
+        if (node.type === 'asset') {
+            let asset = node.value;
+            let id = asset.id;
+            asset.committed = true;
+            asset.contentKey = id;
+            asset.env = { ...asset.env };
+            asset.env.id = (0, feature_flags_1.getFeatureFlag)('environmentDeduplication')
+                ? (0, Environment_1.getEnvironmentHash)(asset.env)
+                : (0, Environment_1.getEnvironmentHash)(asset.env);
+            asset.env = normalizeEnv(asset.env);
+            asset.mapKey = `map:${asset.id}`;
+            asset.dependencies = new Map();
+            asset.meta.isV3 = true;
+            if (asset.symbols != null) {
+                asset.symbols = new Map(asset.symbols.map(mapSymbols));
+            }
+            changedAssets.set(id, asset);
+            const assetNode = {
+                id,
+                type: 'asset',
+                usedSymbols: new Set(),
+                usedSymbolsDownDirty: true,
+                usedSymbolsUpDirty: true,
+                value: asset,
+            };
+            graph._graph.addNodeByContentKey(id, assetNode);
+            continue;
+        }
+        if (node.type === 'dependency') {
+            let { dependency, id } = node.value;
+            dependency.id = id;
+            dependency.env = { ...dependency.env };
+            dependency.env.id = (0, Environment_1.getEnvironmentHash)(dependency.env);
+            dependency.env = normalizeEnv(dependency.env);
+            if (dependency.symbols != null) {
+                dependency.symbols = new Map(dependency.symbols?.map(mapSymbols));
+            }
+            let usedSymbolsDown = new Set();
+            let usedSymbolsUp = new Map();
+            if (dependency.isEntry && dependency.isLibrary) {
+                usedSymbolsDown.add('*');
+                usedSymbolsUp.set('*', undefined);
+            }
+            const depNode = {
+                id,
+                type: 'dependency',
+                deferred: false,
+                excluded: false,
+                hasDeferred: node.has_deferred,
+                // @ts-expect-error Flow types expect a more specific symbol set type
+                usedSymbolsDown,
+                usedSymbolsDownDirty: true,
+                usedSymbolsUp,
+                usedSymbolsUpDirtyDown: true,
+                usedSymbolsUpDirtyUp: true,
+                value: dependency,
+            };
+            graph._graph.addNodeByContentKey(id, depNode);
+            continue;
+        }
+        if (node.type === 'bundle') {
+            node.value.env = normalizeEnv(node.value.env);
+            node.value.target.env = normalizeEnv(node.value.target.env);
+            graph._graph.addNodeByContentKey(node.id, node);
+            continue;
+        }
+        if (node.type === 'bundle_group' || node.type === 'bundleGroup') {
+            // Rust serializer may emit bundleGroup nodes either as `{id,type,value:{...}}`
+            // or as `{type:"bundleGroup", id, target, entryAssetId}`.
+            if (node.value == null) {
+                node.value = {
+                    target: node.target,
+                    entryAssetId: node.entryAssetId ?? node.entry_asset_id,
+                };
+            }
+            // Normalize entry asset id field naming
+            if (node.value.entryAssetId == null &&
+                node.value.entry_asset_id != null) {
+                node.value.entryAssetId = node.value.entry_asset_id;
+            }
+            node.value.target.env = normalizeEnv(node.value.target.env);
+            // Normalise to the expected snake_case type
+            node.type = 'bundle_group';
+            graph._graph.addNodeByContentKey(node.id, node);
+            continue;
+        }
+    }
+    // Apply edges
+    for (let i = 0; i < serializedGraph.edges.length; i += 3) {
+        const from = serializedGraph.edges[i];
+        const to = serializedGraph.edges[i + 1];
+        const type = serializedGraph.edges[i + 2];
+        const fromNode = graph._graph.getNode(from);
+        const toNode = graph._graph.getNode(to);
+        if (fromNode?.type === 'asset' && toNode?.type === 'dependency') {
+            fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+        }
+        // If we are adding a references edge, remove existing null edge.
+        if (type === BundleGraph_1.bundleGraphEdgeTypes.references &&
+            graph._graph.hasEdge(from, to, BundleGraph_1.bundleGraphEdgeTypes.null)) {
+            graph._graph.removeEdge(from, to, BundleGraph_1.bundleGraphEdgeTypes.null);
+        }
+        graph._graph.addEdge(from, to, type);
+    }
+    return { bundleGraph: graph, changedAssets };
+}
+class NativeBundlerRunner {
+    constructor({ api, options }, optionsRef) {
+        this.options = options;
+        this.api = api;
+        this.optionsRef = optionsRef;
+        this.previousDevDeps = new Map();
+        this.devDepRequests = new Map();
+        this.configs = new Map();
+        this.pluginOptions = new PluginOptions_1.default((0, utils_1.optionsProxy)(this.options, api.invalidateOnOptionChange));
+        const key = (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
+        this.cacheKey = `BundleGraph/${constants_1.ATLASPACK_VERSION}/${options.mode}/${key}`;
+    }
+    async loadConfigs() {
+        const configResult = (0, nullthrows_1.default)(await this.api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+        this.config = (0, AtlaspackConfigRequest_1.getCachedAtlaspackConfig)(configResult, this.options);
+        const { devDeps, invalidDevDeps } = await (0, DevDepRequest_1.getDevDepRequests)(this.api);
+        this.previousDevDeps = devDeps;
+        (0, DevDepRequest_1.invalidateDevDeps)(invalidDevDeps, this.options, this.config);
+        const bundler = await this.config.getBundler();
+        await this.loadPluginConfig(bundler);
+        const namers = await this.config.getNamers();
+        for (const namer of namers) {
+            await this.loadPluginConfig(namer);
+        }
+        const runtimes = await this.config.getRuntimes();
+        for (const runtime of runtimes) {
+            await this.loadPluginConfig(runtime);
+        }
+    }
+    async loadPluginConfig(plugin) {
+        await (0, BundleGraphRequestUtils_1.loadPluginConfigWithDevDeps)(plugin, this.options, this.api, this.previousDevDeps, this.devDepRequests, this.configs);
+    }
+}

package/dist/requests/BundleGraphRequestUtils.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBundles = validateBundles;
+exports.nameBundle = nameBundle;
+exports.loadPluginConfigWithDevDeps = loadPluginConfigWithDevDeps;
+exports.runDevDepRequest = runDevDepRequest;
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const logger_1 = require("@atlaspack/logger");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const utils_1 = require("@atlaspack/utils");
+const BundleGraph_1 = __importDefault(require("../public/BundleGraph"));
+const Bundle_1 = require("../public/Bundle");
+const InternalConfig_1 = require("../InternalConfig");
+const DevDepRequest_1 = require("./DevDepRequest");
+const ConfigRequest_1 = require("./ConfigRequest");
+const projectPath_1 = require("../projectPath");
+const profiler_1 = require("@atlaspack/profiler");
+/**
+ * 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_1.joinProjectPath)(b.target.distDir, (0, nullthrows_1.default)(b.name)));
+    assert_1.default.deepEqual(bundleNames, (0, utils_1.unique)(bundleNames), 'Bundles must have unique name. Conflicting names: ' +
+        [
+            ...(0, utils_1.setSymmetricDifference)(new Set(bundleNames), new Set((0, utils_1.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_1.Bundle.get(internalBundle, internalBundleGraph, options);
+    const bundleGraph = new BundleGraph_1.default(internalBundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), options);
+    for (const namer of namers) {
+        let measurement;
+        try {
+            measurement = profiler_1.tracer.createMeasurement(namer.name, 'namer', bundle.id);
+            const name = await namer.plugin.name({
+                bundle,
+                bundleGraph,
+                config: configs.get(namer.name)?.result,
+                options: pluginOptions,
+                logger: new logger_1.PluginLogger({ origin: namer.name }),
+                tracer: new profiler_1.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_1.default({
+                diagnostic: (0, diagnostic_1.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_1.createConfig)({
+        plugin: plugin.name,
+        searchPath: (0, projectPath_1.toProjectPathUnsafe)('index'),
+    });
+    await (0, ConfigRequest_1.loadPluginConfig)(plugin, config, options);
+    await (0, ConfigRequest_1.runConfigRequest)(api, config);
+    for (const devDep of config.devDeps) {
+        const devDepRequest = await (0, DevDepRequest_1.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_1.fromProjectPathRelative)(resolveFrom)}`;
+    devDepRequests.set(key, devDepRequest);
+    await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
+}

package/dist/requests/PackageRequest.js

@@ -11,6 +11,8 @@ 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,
@@ -25,23 +27,38 @@ async function run({ input, api, farm, rustAtlaspack }) {
     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 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)
-        await rustAtlaspack.package();
+        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 } = (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/lib/BundleGraph.js

@@ -85,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, {
@@ -438,7 +438,7 @@ 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() {
     const start = performance.now();
@@ -452,18 +452,67 @@ class BundleGraph {
       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 = 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 = {};
+    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().default.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
+      edges,
+      publicIdByAssetId,
+      environmentsJson
     };
   }
 
@@ -1152,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,15 +72,20 @@ class AtlaspackV3 {
   buildAssetGraph() {
     return (0, _rust().atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
   }
+  buildBundleGraph() {
+    return (0, _rust().atlaspackNapiBuildBundleGraph)(this._atlaspack_napi);
+  }
   loadBundleGraph(bundleGraph) {
     const {
       nodesJson,
-      edges
+      edges,
+      publicIdByAssetId,
+      environmentsJson
     } = bundleGraph.serializeForNative();
-    return (0, _rust().atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges);
+    return (0, _rust().atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);
   }
-  package() {
-    return (0, _rust().atlaspackNapiPackage)(this._atlaspack_napi);
+  package(bundleId) {
+    return (0, _rust().atlaspackNapiPackage)(this._atlaspack_napi, bundleId);
   }
   async respondToFsEvents(events) {
     // @ts-expect-error TS2488

package/lib/atlaspack-v3/worker/worker.js

@@ -381,7 +381,8 @@ class AtlaspackWorker {
       setup = {
         conditions: setupResult === null || setupResult === void 0 ? void 0 : setupResult.conditions,
         config,
-        env: allowedEnv
+        env: allowedEnv,
+        disableCache: setupResult === null || setupResult === void 0 ? void 0 : setupResult.disableCache
       };
     }
     this.#transformers.set(specifier, {