@atlaspack/core 2.32.1 → 2.33.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @atlaspack/core
 
+## 2.33.0
+
+### Minor Changes
+
+- [#993](https://github.com/atlassian-labs/atlaspack/pull/993) [`e058f0e`](https://github.com/atlassian-labs/atlaspack/commit/e058f0e7a0423ba9373e85a7dbd5c1dd43b47916) Thanks [@matt-koko](https://github.com/matt-koko)! - Add disableCache option to TransformerSetup API
+
+### Patch Changes
+
+- [#998](https://github.com/atlassian-labs/atlaspack/pull/998) [`349b19c`](https://github.com/atlassian-labs/atlaspack/commit/349b19c3aca2ccb1ffb5cdcdc74890f4b62228be) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Add initial native bundler boilerplate and single file bundler
+
+- Updated dependencies [[`e058f0e`](https://github.com/atlassian-labs/atlaspack/commit/e058f0e7a0423ba9373e85a7dbd5c1dd43b47916), [`053e375`](https://github.com/atlassian-labs/atlaspack/commit/053e3754c08c5b5dc239e9f7267df289cbbf31ab), [`25c976e`](https://github.com/atlassian-labs/atlaspack/commit/25c976e01c30e536fb1027eab5b17594c604efff), [`1a86b65`](https://github.com/atlassian-labs/atlaspack/commit/1a86b657868ee881ca5acc68661cca208ac37779), [`349b19c`](https://github.com/atlassian-labs/atlaspack/commit/349b19c3aca2ccb1ffb5cdcdc74890f4b62228be), [`9959efe`](https://github.com/atlassian-labs/atlaspack/commit/9959efe30699a2de3b69275be7ecb47afe81c0b6)]:
+  - @atlaspack/rust@3.22.0
+  - @atlaspack/feature-flags@2.29.0
+  - @atlaspack/fs@2.15.47
+  - @atlaspack/graph@3.6.14
+  - @atlaspack/logger@2.14.44
+  - @atlaspack/plugin@2.14.52
+  - @atlaspack/profiler@2.15.13
+  - @atlaspack/types@2.15.42
+  - @atlaspack/utils@3.3.4
+  - @atlaspack/workers@2.14.52
+  - @atlaspack/cache@3.2.47
+  - @atlaspack/source-map@3.2.7
+  - @atlaspack/build-cache@2.13.10
+  - @atlaspack/package-manager@2.14.52
+
 ## 2.32.1
 
 ### Patch Changes

package/dist/atlaspack-v3/AtlaspackV3.js

@@ -51,6 +51,9 @@ class AtlaspackV3 {
     buildAssetGraph() {
         return (0, rust_1.atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
     }
+    buildBundleGraph() {
+        return (0, rust_1.atlaspackNapiBuildBundleGraph)(this._atlaspack_napi);
+    }
     loadBundleGraph(bundleGraph) {
         const { nodesJson, edges, publicIdByAssetId, environmentsJson } = bundleGraph.serializeForNative();
         return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);

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

@@ -355,6 +355,7 @@ class AtlaspackWorker {
                 conditions: setupResult?.conditions,
                 config,
                 env: allowedEnv,
+                disableCache: setupResult?.disableCache,
             };
         }
         __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").set(specifier, {

package/dist/requests/AtlaspackBuildRequest.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = createAtlaspackBuildRequest;
 const BundleGraphRequest_1 = __importDefault(require("./BundleGraphRequest"));
+const BundleGraphRequestRust_1 = __importDefault(require("./BundleGraphRequestRust"));
 const WriteBundlesRequest_1 = __importDefault(require("./WriteBundlesRequest"));
 const utils_1 = require("../utils");
 const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
@@ -27,11 +28,17 @@ function createAtlaspackBuildRequest(input) {
 }
 async function run({ input, api, options, rustAtlaspack, }) {
     let { optionsRef, requestedAssetIds, signal } = input;
-    let bundleGraphRequest = (0, BundleGraphRequest_1.default)({
-        optionsRef,
-        requestedAssetIds,
-        signal,
-    });
+    let bundleGraphRequest = (0, feature_flags_1.getFeatureFlag)('nativeBundling') && rustAtlaspack
+        ? (0, BundleGraphRequestRust_1.default)({
+            optionsRef,
+            requestedAssetIds,
+            signal,
+        })
+        : (0, BundleGraphRequest_1.default)({
+            optionsRef,
+            requestedAssetIds,
+            signal,
+        });
     let { bundleGraph, changedAssets, assetRequests } = await api.runRequest(bundleGraphRequest, {
         force: Boolean(rustAtlaspack) ||
             (options.shouldBuildLazily && requestedAssetIds.size > 0),

package/dist/requests/BundleGraphRequest.js

@@ -39,28 +39,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = createBundleGraphRequest;
 const fs_1 = __importDefault(require("fs"));
 const assert_1 = __importDefault(require("assert"));
-const assert_2 = __importDefault(require("assert"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
 const logger_1 = require("@atlaspack/logger");
 const feature_flags_1 = require("@atlaspack/feature-flags");
 const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
-const BundleGraph_1 = __importDefault(require("../public/BundleGraph"));
-const BundleGraph_2 = __importStar(require("../BundleGraph"));
+const BundleGraph_1 = __importStar(require("../BundleGraph"));
 const MutableBundleGraph_1 = __importDefault(require("../public/MutableBundleGraph"));
-const Bundle_1 = require("../public/Bundle");
 const ReporterRunner_1 = require("../ReporterRunner");
 const dumpGraphToGraphViz_1 = __importDefault(require("../dumpGraphToGraphViz"));
-const utils_1 = require("@atlaspack/utils");
 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_2 = require("../utils");
+const utils_1 = require("../utils");
 const AtlaspackConfigRequest_1 = __importStar(require("./AtlaspackConfigRequest"));
 const DevDepRequest_1 = require("./DevDepRequest");
-const InternalConfig_1 = require("../InternalConfig");
-const ConfigRequest_1 = require("./ConfigRequest");
 const projectPath_1 = require("../projectPath");
+const BundleGraphRequestUtils_1 = require("./BundleGraphRequestUtils");
 const AssetGraphRequest_1 = __importDefault(require("./AssetGraphRequest"));
 const AssetGraphRequestRust_1 = require("./AssetGraphRequestRust");
 const profiler_1 = require("@atlaspack/profiler");
@@ -151,7 +146,7 @@ function createBundleGraphRequest(input) {
             //   );
             // }
             measurement && measurement.end();
-            (0, utils_2.assertSignalNotAborted)(signal);
+            (0, utils_1.assertSignalNotAborted)(signal);
             // If any subrequests are invalid (e.g. dev dep requests or config requests),
             // bail on incremental bundling. We also need to invalidate for option changes,
             // which are hoisted to direct invalidations on the bundle graph request.
@@ -164,7 +159,7 @@ function createBundleGraphRequest(input) {
                 assetGraph.setNeedsBundling();
             }
             let configResult = (0, nullthrows_1.default)(await input.api.runRequest((0, AtlaspackConfigRequest_1.default)()));
-            (0, utils_2.assertSignalNotAborted)(signal);
+            (0, utils_1.assertSignalNotAborted)(signal);
             let atlaspackConfig = (0, AtlaspackConfigRequest_1.getCachedAtlaspackConfig)(configResult, input.options);
             let { devDeps, invalidDevDeps } = await (0, DevDepRequest_1.getDevDepRequests)(input.api);
             (0, DevDepRequest_1.invalidateDevDeps)(invalidDevDeps, input.options, atlaspackConfig);
@@ -181,7 +176,7 @@ function createBundleGraphRequest(input) {
             }
             await (0, dumpGraphToGraphViz_1.default)(
             // @ts-expect-error TS2345
-            res.bundleGraph._graph, 'BundleGraph', BundleGraph_2.bundleGraphEdgeTypes);
+            res.bundleGraph._graph, 'BundleGraph', BundleGraph_1.bundleGraphEdgeTypes);
             return res;
         },
         input,
@@ -196,7 +191,7 @@ class BundlerRunner {
         this.previousDevDeps = previousDevDeps;
         this.devDepRequests = new Map();
         this.configs = new Map();
-        this.pluginOptions = new PluginOptions_1.default((0, utils_2.optionsProxy)(this.options, api.invalidateOnOptionChange));
+        this.pluginOptions = new PluginOptions_1.default((0, utils_1.optionsProxy)(this.options, api.invalidateOnOptionChange));
         if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
             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}`;
@@ -220,23 +215,10 @@ class BundlerRunner {
         }
     }
     async loadConfig(plugin) {
-        let config = (0, InternalConfig_1.createConfig)({
-            plugin: plugin.name,
-            searchPath: (0, projectPath_1.toProjectPathUnsafe)('index'),
-        });
-        await (0, ConfigRequest_1.loadPluginConfig)(plugin, config, this.options);
-        await (0, ConfigRequest_1.runConfigRequest)(this.api, config);
-        for (let devDep of config.devDeps) {
-            let devDepRequest = await (0, DevDepRequest_1.createDevDependency)(devDep, this.previousDevDeps, this.options);
-            await this.runDevDepRequest(devDepRequest);
-        }
-        this.configs.set(plugin.name, config);
+        await (0, BundleGraphRequestUtils_1.loadPluginConfigWithDevDeps)(plugin, this.options, this.api, this.previousDevDeps, this.devDepRequests, this.configs);
     }
     async runDevDepRequest(devDepRequest) {
-        let { specifier, resolveFrom } = devDepRequest;
-        let key = `${specifier}:${(0, projectPath_1.fromProjectPathRelative)(resolveFrom)}`;
-        this.devDepRequests.set(key, devDepRequest);
-        await (0, DevDepRequest_1.runDevDepRequest)(this.api, devDepRequest);
+        await (0, BundleGraphRequestUtils_1.runDevDepRequest)(this.api, devDepRequest, this.devDepRequests);
     }
     async bundle({ graph, changedAssets, assetRequests, }) {
         (0, ReporterRunner_1.report)({
@@ -271,11 +253,11 @@ class BundlerRunner {
                 }
             }
             else {
-                internalBundleGraph = BundleGraph_2.default.fromAssetGraph(graph, this.options.mode === 'production');
+                internalBundleGraph = BundleGraph_1.default.fromAssetGraph(graph, this.options.mode === 'production');
                 (0, assert_1.default)(internalBundleGraph != null); // ensures the graph was created
                 await (0, dumpGraphToGraphViz_1.default)(
                 // @ts-expect-error TS2345
-                internalBundleGraph._graph, 'before_bundle', BundleGraph_2.bundleGraphEdgeTypes);
+                internalBundleGraph._graph, 'before_bundle', BundleGraph_1.bundleGraphEdgeTypes);
                 let mutableBundleGraph = new MutableBundleGraph_1.default(internalBundleGraph, this.options);
                 let measurement;
                 let measurementFilename;
@@ -350,7 +332,7 @@ class BundlerRunner {
             if (internalBundleGraph != null) {
                 await (0, dumpGraphToGraphViz_1.default)(
                 // @ts-expect-error TS2345
-                internalBundleGraph._graph, 'after_bundle', BundleGraph_2.bundleGraphEdgeTypes);
+                internalBundleGraph._graph, 'after_bundle', BundleGraph_1.bundleGraphEdgeTypes);
             }
         }
         let changedRuntimes = new Map();
@@ -359,7 +341,7 @@ class BundlerRunner {
             // inline bundles must still be named so the PackagerRunner
             // can match them to the correct packager/optimizer plugins.
             let bundles = internalBundleGraph.getBundles({ includeInline: true });
-            await Promise.all(bundles.map((bundle) => this.nameBundle(namers, bundle, internalBundleGraph)));
+            await Promise.all(bundles.map((bundle) => (0, BundleGraphRequestUtils_1.nameBundle)(namers, bundle, internalBundleGraph, this.options, this.pluginOptions, this.configs)));
             changedRuntimes = await (0, logger_1.instrumentAsync)('applyRuntimes', () => (0, applyRuntimes_1.default)({
                 bundleGraph: internalBundleGraph,
                 api: this.api,
@@ -379,13 +361,13 @@ class BundlerRunner {
                 }, this.previousDevDeps, this.options);
                 await this.runDevDepRequest(devDepRequest);
             }
-            this.validateBundles(internalBundleGraph);
+            (0, BundleGraphRequestUtils_1.validateBundles)(internalBundleGraph);
             // Pre-compute the hashes for each bundle so they are only computed once and shared between workers.
             internalBundleGraph.getBundleGraphHash();
         }
         await (0, dumpGraphToGraphViz_1.default)(
         // @ts-expect-error TS2345
-        internalBundleGraph._graph, 'after_runtimes', BundleGraph_2.bundleGraphEdgeTypes);
+        internalBundleGraph._graph, 'after_runtimes', BundleGraph_1.bundleGraphEdgeTypes);
         this.api.storeResult({
             bundleGraph: internalBundleGraph,
             assetGraphBundlingVersion: graph.getBundlingVersion(),
@@ -399,49 +381,4 @@ class BundlerRunner {
             assetRequests,
         };
     }
-    validateBundles(bundleGraph) {
-        let bundles = bundleGraph.getBundles();
-        let bundleNames = bundles.map((b) => (0, projectPath_1.joinProjectPath)(b.target.distDir, (0, nullthrows_1.default)(b.name)));
-        assert_2.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());
-    }
-    async nameBundle(namers, internalBundle, internalBundleGraph) {
-        let bundle = Bundle_1.Bundle.get(internalBundle, internalBundleGraph, this.options);
-        let bundleGraph = new BundleGraph_1.default(internalBundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), this.options);
-        for (let namer of namers) {
-            let measurement;
-            try {
-                measurement = profiler_1.tracer.createMeasurement(namer.name, 'namer', bundle.id);
-                let name = await namer.plugin.name({
-                    bundle,
-                    bundleGraph,
-                    config: this.configs.get(namer.name)?.result,
-                    options: this.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;
-                    let { 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');
-    }
 }

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);
+    }
+}