@atlaspack/core 2.32.0 → 2.33.0

package/lib/requests/AtlaspackBuildRequest.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = createAtlaspackBuildRequest;
 var _BundleGraphRequest = _interopRequireDefault(require("./BundleGraphRequest"));
+var _BundleGraphRequestRust = _interopRequireDefault(require("./BundleGraphRequestRust"));
 var _WriteBundlesRequest = _interopRequireDefault(require("./WriteBundlesRequest"));
 var _utils = require("../utils");
 var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
@@ -49,7 +50,11 @@ async function run({
     requestedAssetIds,
     signal
   } = input;
-  let bundleGraphRequest = (0, _BundleGraphRequest.default)({
+  let bundleGraphRequest = (0, _featureFlags().getFeatureFlag)('nativeBundling') && rustAtlaspack ? (0, _BundleGraphRequestRust.default)({
+    optionsRef,
+    requestedAssetIds,
+    signal
+  }) : (0, _BundleGraphRequest.default)({
     optionsRef,
     requestedAssetIds,
     signal

package/lib/requests/BundleGraphRequest.js

@@ -46,19 +46,10 @@ function _diagnostic() {
   };
   return data;
 }
-var _BundleGraph = _interopRequireDefault(require("../public/BundleGraph"));
-var _BundleGraph2 = _interopRequireWildcard(require("../BundleGraph"));
+var _BundleGraph = _interopRequireWildcard(require("../BundleGraph"));
 var _MutableBundleGraph = _interopRequireDefault(require("../public/MutableBundleGraph"));
-var _Bundle = require("../public/Bundle");
 var _ReporterRunner = require("../ReporterRunner");
 var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
-function _utils() {
-  const data = require("@atlaspack/utils");
-  _utils = function () {
-    return data;
-  };
-  return data;
-}
 function _rust() {
   const data = require("@atlaspack/rust");
   _rust = function () {
@@ -69,12 +60,11 @@ function _rust() {
 var _PluginOptions = _interopRequireDefault(require("../public/PluginOptions"));
 var _applyRuntimes = _interopRequireDefault(require("../applyRuntimes"));
 var _constants = require("../constants");
-var _utils2 = require("../utils");
+var _utils = require("../utils");
 var _AtlaspackConfigRequest = _interopRequireWildcard(require("./AtlaspackConfigRequest"));
 var _DevDepRequest = require("./DevDepRequest");
-var _InternalConfig = require("../InternalConfig");
-var _ConfigRequest = require("./ConfigRequest");
 var _projectPath = require("../projectPath");
+var _BundleGraphRequestUtils = require("./BundleGraphRequestUtils");
 var _AssetGraphRequest = _interopRequireDefault(require("./AssetGraphRequest"));
 var _AssetGraphRequestRust = require("./AssetGraphRequestRust");
 function _profiler() {
@@ -188,7 +178,7 @@ function createBundleGraphRequest(input) {
       // }
 
       measurement && measurement.end();
-      (0, _utils2.assertSignalNotAborted)(signal);
+      (0, _utils.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,
@@ -199,7 +189,7 @@ function createBundleGraphRequest(input) {
         assetGraph.setNeedsBundling();
       }
       let configResult = (0, _nullthrows().default)(await input.api.runRequest((0, _AtlaspackConfigRequest.default)()));
-      (0, _utils2.assertSignalNotAborted)(signal);
+      (0, _utils.assertSignalNotAborted)(signal);
       let atlaspackConfig = (0, _AtlaspackConfigRequest.getCachedAtlaspackConfig)(configResult, input.options);
       let {
         devDeps,
@@ -219,7 +209,7 @@ function createBundleGraphRequest(input) {
       }
       await (0, _dumpGraphToGraphViz.default)(
       // @ts-expect-error TS2345
-      res.bundleGraph._graph, 'BundleGraph', _BundleGraph2.bundleGraphEdgeTypes);
+      res.bundleGraph._graph, 'BundleGraph', _BundleGraph.bundleGraphEdgeTypes);
       return res;
     },
     input
@@ -238,7 +228,7 @@ class BundlerRunner {
     this.previousDevDeps = previousDevDeps;
     this.devDepRequests = new Map();
     this.configs = new Map();
-    this.pluginOptions = new _PluginOptions.default((0, _utils2.optionsProxy)(this.options, api.invalidateOnOptionChange));
+    this.pluginOptions = new _PluginOptions.default((0, _utils.optionsProxy)(this.options, api.invalidateOnOptionChange));
     if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
       const key = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
       this.cacheKey = `BundleGraph/${_constants.ATLASPACK_VERSION}/${options.mode}/${key}`;
@@ -260,26 +250,10 @@ class BundlerRunner {
     }
   }
   async loadConfig(plugin) {
-    let config = (0, _InternalConfig.createConfig)({
-      plugin: plugin.name,
-      searchPath: (0, _projectPath.toProjectPathUnsafe)('index')
-    });
-    await (0, _ConfigRequest.loadPluginConfig)(plugin, config, this.options);
-    await (0, _ConfigRequest.runConfigRequest)(this.api, config);
-    for (let devDep of config.devDeps) {
-      let devDepRequest = await (0, _DevDepRequest.createDevDependency)(devDep, this.previousDevDeps, this.options);
-      await this.runDevDepRequest(devDepRequest);
-    }
-    this.configs.set(plugin.name, config);
+    await (0, _BundleGraphRequestUtils.loadPluginConfigWithDevDeps)(plugin, this.options, this.api, this.previousDevDeps, this.devDepRequests, this.configs);
   }
   async runDevDepRequest(devDepRequest) {
-    let {
-      specifier,
-      resolveFrom
-    } = devDepRequest;
-    let key = `${specifier}:${(0, _projectPath.fromProjectPathRelative)(resolveFrom)}`;
-    this.devDepRequests.set(key, devDepRequest);
-    await (0, _DevDepRequest.runDevDepRequest)(this.api, devDepRequest);
+    await (0, _BundleGraphRequestUtils.runDevDepRequest)(this.api, devDepRequest, this.devDepRequests);
   }
   async bundle({
     graph,
@@ -324,12 +298,12 @@ class BundlerRunner {
         }
       } else {
         var _this$configs$get;
-        internalBundleGraph = _BundleGraph2.default.fromAssetGraph(graph, this.options.mode === 'production');
+        internalBundleGraph = _BundleGraph.default.fromAssetGraph(graph, this.options.mode === 'production');
         (0, _assert().default)(internalBundleGraph != null); // ensures the graph was created
 
         await (0, _dumpGraphToGraphViz.default)(
         // @ts-expect-error TS2345
-        internalBundleGraph._graph, 'before_bundle', _BundleGraph2.bundleGraphEdgeTypes);
+        internalBundleGraph._graph, 'before_bundle', _BundleGraph.bundleGraphEdgeTypes);
         let mutableBundleGraph = new _MutableBundleGraph.default(internalBundleGraph, this.options);
         let measurement;
         let measurementFilename;
@@ -400,7 +374,7 @@ class BundlerRunner {
       if (internalBundleGraph != null) {
         await (0, _dumpGraphToGraphViz.default)(
         // @ts-expect-error TS2345
-        internalBundleGraph._graph, 'after_bundle', _BundleGraph2.bundleGraphEdgeTypes);
+        internalBundleGraph._graph, 'after_bundle', _BundleGraph.bundleGraphEdgeTypes);
       }
     }
     let changedRuntimes = new Map();
@@ -411,7 +385,7 @@ class BundlerRunner {
       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.nameBundle)(namers, bundle, internalBundleGraph, this.options, this.pluginOptions, this.configs)));
       changedRuntimes = await (0, _logger().instrumentAsync)('applyRuntimes', () => (0, _applyRuntimes.default)({
         bundleGraph: internalBundleGraph,
         api: this.api,
@@ -432,14 +406,14 @@ class BundlerRunner {
         }, this.previousDevDeps, this.options);
         await this.runDevDepRequest(devDepRequest);
       }
-      this.validateBundles(internalBundleGraph);
+      (0, _BundleGraphRequestUtils.validateBundles)(internalBundleGraph);
 
       // Pre-compute the hashes for each bundle so they are only computed once and shared between workers.
       internalBundleGraph.getBundleGraphHash();
     }
     await (0, _dumpGraphToGraphViz.default)(
     // @ts-expect-error TS2345
-    internalBundleGraph._graph, 'after_runtimes', _BundleGraph2.bundleGraphEdgeTypes);
+    internalBundleGraph._graph, 'after_runtimes', _BundleGraph.bundleGraphEdgeTypes);
     this.api.storeResult({
       bundleGraph: internalBundleGraph,
       assetGraphBundlingVersion: graph.getBundlingVersion(),
@@ -453,50 +427,4 @@ class BundlerRunner {
       assetRequests
     };
   }
-  validateBundles(bundleGraph) {
-    let bundles = bundleGraph.getBundles();
-    let 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());
-  }
-  async nameBundle(namers, internalBundle, internalBundleGraph) {
-    let bundle = _Bundle.Bundle.get(internalBundle, internalBundleGraph, this.options);
-    let bundleGraph = new _BundleGraph.default(internalBundleGraph, _Bundle.NamedBundle.get.bind(_Bundle.NamedBundle), this.options);
-    for (let namer of namers) {
-      let measurement;
-      try {
-        var _this$configs$get3;
-        measurement = _profiler().tracer.createMeasurement(namer.name, 'namer', bundle.id);
-        let name = await namer.plugin.name({
-          bundle,
-          bundleGraph,
-          config: (_this$configs$get3 = this.configs.get(namer.name)) === null || _this$configs$get3 === void 0 ? void 0 : _this$configs$get3.result,
-          options: this.pluginOptions,
-          logger: new (_logger().PluginLogger)({
-            origin: namer.name
-          }),
-          tracer: new (_profiler().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().default)({
-          diagnostic: (0, _diagnostic().errorToDiagnostic)(e, {
-            origin: namer.name
-          })
-        });
-      } finally {
-        measurement && measurement.end();
-      }
-    }
-    throw new Error('Unable to name bundle');
-  }
 }

package/lib/requests/BundleGraphRequestRust.js

@@ -0,0 +1,378 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createBundleGraphRequestRust;
+exports.getBundleGraph = getBundleGraph;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _graph() {
+  const data = require("@atlaspack/graph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+var _BundleGraph = _interopRequireWildcard(require("../BundleGraph"));
+var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+var _PluginOptions = _interopRequireDefault(require("../public/PluginOptions"));
+var _applyRuntimes = _interopRequireDefault(require("../applyRuntimes"));
+var _constants = require("../constants");
+var _utils = require("../utils");
+var _DevDepRequest = require("./DevDepRequest");
+var _RequestTracker = require("../RequestTracker");
+var _AtlaspackConfigRequest = _interopRequireWildcard(require("./AtlaspackConfigRequest"));
+var _BundleGraphRequestUtils = require("./BundleGraphRequestUtils");
+var _EnvironmentManager = require("../EnvironmentManager");
+var _Environment = require("../Environment");
+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 }; }
+function createBundleGraphRequestRust(input) {
+  return {
+    type: _RequestTracker.requestTypes.bundle_graph_request,
+    id: 'BundleGraphRust',
+    run: async runInput => {
+      const {
+        api,
+        options,
+        rustAtlaspack
+      } = runInput;
+      (0, _assert().default)(rustAtlaspack, 'BundleGraphRequestRust requires rustAtlaspack');
+      let {
+        bundleGraphPromise,
+        commitPromise
+      } = await rustAtlaspack.buildBundleGraph();
+      let [serializedBundleGraph, bundleGraphError] = await bundleGraphPromise;
+      if (bundleGraphError) {
+        throw new (_diagnostic().default)({
+          diagnostic: bundleGraphError
+        });
+      }
+
+      // Don’t reuse previous JS result yet; we just rebuild from scratch.
+      let {
+        bundleGraph,
+        changedAssets
+      } = (0, _logger().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.nameBundle)(namers, b, bundleGraph, options, runner.pluginOptions, runner.configs)));
+
+      // Apply runtimes
+      const changedRuntimes = await (0, _logger().instrumentAsync)('applyRuntimes', () => (0, _applyRuntimes.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.createDevDependency)({
+          specifier: namer.name,
+          resolveFrom: namer.resolveFrom
+        }, runner.previousDevDeps, options);
+        await (0, _BundleGraphRequestUtils.runDevDepRequest)(api, devDepRequest, runner.devDepRequests);
+      }
+      (0, _BundleGraphRequestUtils.validateBundles)(bundleGraph);
+      bundleGraph.getBundleGraphHash();
+      await (0, _dumpGraphToGraphViz.default)(
+      // @ts-expect-error Accessing internal graph for debug output
+      bundleGraph._graph, 'after_runtimes_native', _BundleGraph.bundleGraphEdgeTypes);
+      let [_commitResult, commitError] = await commitPromise;
+      if (commitError) {
+        throw new (_diagnostic().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.getEnvironmentHash)(env);
+  return (0, _EnvironmentManager.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.default({
+    // We intentionally start with an empty graph and add nodes/edges from the Rust payload.
+    // `ContentGraph` will allocate as needed.
+    graph: new (_graph().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, _featureFlags().getFeatureFlag)('environmentDeduplication') ? (0, _Environment.getEnvironmentHash)(asset.env) : (0, _Environment.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.getEnvironmentHash)(dependency.env);
+      dependency.env = normalizeEnv(dependency.env);
+      if (dependency.symbols != null) {
+        var _dependency$symbols;
+        dependency.symbols = new Map((_dependency$symbols = dependency.symbols) === null || _dependency$symbols === void 0 ? void 0 : _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 === null || fromNode === void 0 ? void 0 : fromNode.type) === 'asset' && (toNode === null || toNode === void 0 ? void 0 : 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.bundleGraphEdgeTypes.references && graph._graph.hasEdge(from, to, _BundleGraph.bundleGraphEdgeTypes.null)) {
+      graph._graph.removeEdge(from, to, _BundleGraph.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.default((0, _utils.optionsProxy)(this.options, api.invalidateOnOptionChange));
+    const key = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
+    this.cacheKey = `BundleGraph/${_constants.ATLASPACK_VERSION}/${options.mode}/${key}`;
+  }
+  async loadConfigs() {
+    const configResult = (0, _nullthrows().default)(await this.api.runRequest((0, _AtlaspackConfigRequest.default)()));
+    this.config = (0, _AtlaspackConfigRequest.getCachedAtlaspackConfig)(configResult, this.options);
+    const {
+      devDeps,
+      invalidDevDeps
+    } = await (0, _DevDepRequest.getDevDepRequests)(this.api);
+    this.previousDevDeps = devDeps;
+    (0, _DevDepRequest.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.loadPluginConfigWithDevDeps)(plugin, this.options, this.api, this.previousDevDeps, this.devDepRequests, this.configs);
+  }
+}