@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/lib/requests/BundleGraphRequestRust.js

@@ -0,0 +1,381 @@
+"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 _ReporterRunner = require("../ReporterRunner");
+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 _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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(eventJson => {
+        let event = JSON.parse(eventJson);
+        (0, _ReporterRunner.report)(event);
+      });
+      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));
+      (0, _BundleGraphRequestUtils.dumpBundleGraphSnapshot)(bundleGraph, 'rust');
+      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,
+        changedAssets: changedRuntimes,
+        assetRequests: [],
+        didIncrementallyBundle: false
+      };
+    },
+    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);
+  }
+}

package/lib/requests/BundleGraphRequestUtils.js

@@ -0,0 +1,280 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dumpBundleGraphSnapshot = dumpBundleGraphSnapshot;
+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 _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = 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 = require("../BundleGraph");
+var _BundleGraph2 = _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 _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * 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());
+}
+
+/**
+ * Dump a canonical JSON snapshot of the bundle graph for parity comparison.
+ * Gated by ATLASPACK_DUMP_BUNDLE_GRAPH environment variable which specifies the output directory.
+ * The snapshot captures bundle identity, type, contained assets, and bundle group structure
+ * in a deterministic, sorted format suitable for diffing.
+ */
+function dumpBundleGraphSnapshot(bundleGraph, variant) {
+  let outDir = process.env.ATLASPACK_DUMP_BUNDLE_GRAPH;
+  if (!outDir) return;
+  let filename = variant === 'js' ? 'bundle-graph-js.json' : 'bundle-graph-rust.json';
+  let outPath = _path().default.join(outDir, filename);
+  _fs().default.mkdirSync(outDir, {
+    recursive: true
+  });
+  let bundles = bundleGraph.getBundles();
+  let bundlesSnapshot = bundles.map(bundle => {
+    let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.id);
+    let containedAssetNodeIds = bundleGraph._graph.getNodeIdsConnectedFrom(bundleNodeId, _BundleGraph.bundleGraphEdgeTypes.contains);
+    let containedAssets = containedAssetNodeIds.map(nodeId => bundleGraph._graph.getNode(nodeId)).flatMap(node => {
+      if ((node === null || node === void 0 ? void 0 : node.type) !== 'asset') return [];
+      return [{
+        id: node.value.id,
+        filePath: (0, _projectPath.fromProjectPathRelative)(node.value.filePath)
+      }];
+    }).sort((a, b) => a.filePath.localeCompare(b.filePath));
+
+    // Resolve mainEntry and entry asset file paths
+    let mainEntryPath = null;
+    let entryAssetPaths = [];
+    if (bundle.mainEntryId) {
+      let mainEntryNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.mainEntryId);
+      let mainEntryNode = bundleGraph._graph.getNode(mainEntryNodeId);
+      if ((mainEntryNode === null || mainEntryNode === void 0 ? void 0 : mainEntryNode.type) === 'asset') {
+        mainEntryPath = (0, _projectPath.fromProjectPathRelative)(mainEntryNode.value.filePath);
+      }
+    }
+    for (let entryId of bundle.entryAssetIds) {
+      let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(entryId);
+      let entryNode = bundleGraph._graph.getNode(entryNodeId);
+      if ((entryNode === null || entryNode === void 0 ? void 0 : entryNode.type) === 'asset') {
+        entryAssetPaths.push((0, _projectPath.fromProjectPathRelative)(entryNode.value.filePath));
+      }
+    }
+    entryAssetPaths.sort();
+    return {
+      id: bundle.id,
+      type: bundle.type,
+      bundleBehavior: bundle.bundleBehavior ?? null,
+      needsStableName: bundle.needsStableName,
+      isSplittable: bundle.isSplittable,
+      isPlaceholder: bundle.isPlaceholder,
+      mainEntryPath,
+      entryAssetPaths,
+      assets: containedAssets.map(a => a.filePath)
+    };
+  }).sort((a, b) => {
+    // Sort by mainEntryPath first, then by sorted assets as tiebreaker
+    let aKey = a.mainEntryPath || a.assets.join(',');
+    let bKey = b.mainEntryPath || b.assets.join(',');
+    return aKey.localeCompare(bKey);
+  });
+  let bundleGroupsSnapshot = bundleGraph._graph.nodes.flatMap(node => {
+    if ((node === null || node === void 0 ? void 0 : node.type) !== 'bundle_group') return [];
+    let bundleGroup = node.value;
+
+    // Resolve entry asset file path
+    let entryAssetPath = null;
+    try {
+      let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(bundleGroup.entryAssetId);
+      let entryNode = bundleGraph._graph.getNode(entryNodeId);
+      if ((entryNode === null || entryNode === void 0 ? void 0 : entryNode.type) === 'asset') {
+        entryAssetPath = (0, _projectPath.fromProjectPathRelative)(entryNode.value.filePath);
+      }
+    } catch {
+      // Content key not found
+    }
+    let bundlesInGroup = bundleGraph.getBundlesInBundleGroup(bundleGroup);
+    let bundlePaths = bundlesInGroup.map(b => {
+      // Use mainEntry file path if available, otherwise bundle id as fallback
+      if (b.mainEntryId) {
+        try {
+          let nodeId = bundleGraph._graph.getNodeIdByContentKey(b.mainEntryId);
+          let node = bundleGraph._graph.getNode(nodeId);
+          if ((node === null || node === void 0 ? void 0 : node.type) === 'asset') {
+            return (0, _projectPath.fromProjectPathRelative)(node.value.filePath);
+          }
+        } catch {
+          // fallback
+        }
+      }
+      return `[bundle:${b.id}]`;
+    }).sort();
+    return [{
+      entryAssetPath: entryAssetPath ?? `[unknown:${bundleGroup.entryAssetId}]`,
+      bundlePaths
+    }];
+  }).sort((a, b) => a.entryAssetPath.localeCompare(b.entryAssetPath));
+  let totalAssets = bundleGraph._graph.nodes.filter(node => (node === null || node === void 0 ? void 0 : node.type) === 'asset').length;
+  let snapshot = {
+    version: 1,
+    variant,
+    stats: {
+      totalBundles: bundlesSnapshot.length,
+      totalBundleGroups: bundleGroupsSnapshot.length,
+      totalAssets
+    },
+    bundles: bundlesSnapshot,
+    bundleGroups: bundleGroupsSnapshot
+  };
+  _fs().default.writeFileSync(outPath, JSON.stringify(snapshot, null, 2), 'utf8');
+  // eslint-disable-next-line no-console
+  console.log(`[BundleGraphSnapshot] Wrote ${variant} snapshot to ${outPath}`);
+}
+
+/**
+ * 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 _BundleGraph2.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);
+}