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

package/dist/requests/BundleGraphRequestRust.js

@@ -0,0 +1,324 @@
+"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 ReporterRunner_1 = require("../ReporterRunner");
+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((eventJson) => {
+                let event = JSON.parse(eventJson);
+                (0, ReporterRunner_1.report)(event);
+            });
+            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));
+            (0, BundleGraphRequestUtils_1.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_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,
+                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_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,262 @@
+"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.dumpBundleGraphSnapshot = dumpBundleGraphSnapshot;
+exports.nameBundle = nameBundle;
+exports.loadPluginConfigWithDevDeps = loadPluginConfigWithDevDeps;
+exports.runDevDepRequest = runDevDepRequest;
+const assert_1 = __importDefault(require("assert"));
+const fs_1 = __importDefault(require("fs"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("@atlaspack/logger");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const utils_1 = require("@atlaspack/utils");
+const BundleGraph_1 = require("../BundleGraph");
+const BundleGraph_2 = __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());
+}
+/**
+ * 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_1.default.join(outDir, filename);
+    fs_1.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_1.bundleGraphEdgeTypes.contains);
+        let containedAssets = containedAssetNodeIds
+            .map((nodeId) => bundleGraph._graph.getNode(nodeId))
+            .flatMap((node) => {
+            if (node?.type !== 'asset')
+                return [];
+            return [
+                {
+                    id: node.value.id,
+                    filePath: (0, projectPath_1.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?.type === 'asset') {
+                mainEntryPath = (0, projectPath_1.fromProjectPathRelative)(mainEntryNode.value.filePath);
+            }
+        }
+        for (let entryId of bundle.entryAssetIds) {
+            let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(entryId);
+            let entryNode = bundleGraph._graph.getNode(entryNodeId);
+            if (entryNode?.type === 'asset') {
+                entryAssetPaths.push((0, projectPath_1.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?.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?.type === 'asset') {
+                entryAssetPath = (0, projectPath_1.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?.type === 'asset') {
+                        return (0, projectPath_1.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?.type === 'asset').length;
+    let snapshot = {
+        version: 1,
+        variant,
+        stats: {
+            totalBundles: bundlesSnapshot.length,
+            totalBundleGroups: bundleGroupsSnapshot.length,
+            totalAssets,
+        },
+        bundles: bundlesSnapshot,
+        bundleGroups: bundleGroupsSnapshot,
+    };
+    fs_1.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_1.Bundle.get(internalBundle, internalBundleGraph, options);
+    const bundleGraph = new BundleGraph_2.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);
+}