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

package/dist/BundleGraph.js

@@ -0,0 +1,1906 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundleGraphEdgeTypes = void 0;
+const assert_1 = __importDefault(require("assert"));
+const assert_2 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const graph_1 = require("@atlaspack/graph");
+const rust_1 = require("@atlaspack/rust");
+const utils_1 = require("@atlaspack/utils");
+const types_1 = require("./types");
+const utils_2 = require("./utils");
+const Environment_1 = require("./public/Environment");
+const projectPath_1 = require("./projectPath");
+const constants_1 = require("./constants");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const EnvironmentManager_1 = require("./EnvironmentManager");
+exports.bundleGraphEdgeTypes = {
+    // A lack of an edge type indicates to follow the edge while traversing
+    // the bundle's contents, e.g. `bundle.traverse()` during packaging.
+    null: 1,
+    // Used for constant-time checks of presence of a dependency or asset in a bundle,
+    // avoiding bundle traversal in cases like `isAssetInAncestors`
+    contains: 2,
+    // Connections between bundles and bundle groups, for quick traversal of the
+    // bundle hierarchy.
+    bundle: 3,
+    // When dependency -> asset: Indicates that the asset a dependency references
+    //                           is contained in another bundle.
+    // When dependency -> bundle: Indicates the bundle is necessary for any bundles
+    //                           with the dependency.
+    // When bundle -> bundle:    Indicates the target bundle is necessary for the
+    //                           source bundle.
+    // This type prevents referenced assets from being traversed from dependencies
+    // along the untyped edge, and enables traversal to referenced bundles that are
+    // not directly connected to bundle group nodes.
+    references: 4,
+    // Signals that the dependency is internally resolvable via the bundle's ancestry,
+    // and that the bundle connected to the dependency is not necessary for the source bundle.
+    internal_async: 5,
+    // This type is used to mark an edge between a bundle and a conditional bundle.
+    // This allows efficient discovery of conditional bundles in packaging
+    conditional: 6,
+};
+function makeReadOnlySet(set) {
+    return new Proxy(set, {
+        get(target, property) {
+            if (property === 'delete' || property === 'add' || property === 'clear') {
+                return undefined;
+            }
+            else {
+                // @ts-expect-error TS7053
+                let value = target[property];
+                return typeof value === 'function' ? value.bind(target) : value;
+            }
+        },
+    });
+}
+/**
+ * Stores assets, dependencies, bundle groups, bundles, and the relationships between them.
+ * The BundleGraph is passed to the bundler plugin wrapped in a MutableBundleGraph,
+ * and is passed to packagers and optimizers wrapped in the public BundleGraph object, both
+ * of which implement public api for this structure. This is the internal structure.
+ */
+class BundleGraph {
+    constructor({ graph, publicIdByAssetId, assetPublicIds, bundleContentHashes, conditions, }) {
+        this._targetEntryRoots = new Map();
+        this._bundlePublicIds /*: Set<string> */ = new Set();
+        this._conditions /*: Map<string, Condition> */ = new Map();
+        this._graph = graph;
+        this._assetPublicIds = assetPublicIds;
+        this._publicIdByAssetId = publicIdByAssetId;
+        this._bundleContentHashes = bundleContentHashes;
+        this._conditions = conditions;
+    }
+    /**
+     * Produce a BundleGraph from an AssetGraph by removing asset groups and retargeting dependencies
+     * based on the symbol data (resolving side-effect free reexports).
+     */
+    static fromAssetGraph(assetGraph, isProduction, publicIdByAssetId = new Map(), assetPublicIds = new Set()) {
+        let graph = new graph_1.ContentGraph();
+        let assetGroupIds = new Map();
+        let dependencies = new Map();
+        let assetGraphNodeIdToBundleGraphNodeId = new Map();
+        let conditions = new Map();
+        let placeholderToDependency = new Map();
+        let assetGraphRootNode = assetGraph.rootNodeId != null
+            ? assetGraph.getNode(assetGraph.rootNodeId)
+            : null;
+        (0, assert_2.default)(assetGraphRootNode != null && assetGraphRootNode.type === 'root');
+        assetGraph.dfsFast((nodeId) => {
+            let node = assetGraph.getNode(nodeId);
+            if (node != null && node.type === 'asset') {
+                let { id: assetId } = node.value;
+                // Generate a new, short public id for this asset to use.
+                // If one already exists, use it.
+                let publicId = publicIdByAssetId.get(assetId);
+                if (publicId == null) {
+                    publicId = (0, utils_2.getPublicId)(assetId, (existing) => assetPublicIds.has(existing));
+                    publicIdByAssetId.set(assetId, publicId);
+                    assetPublicIds.add(publicId);
+                }
+            }
+            else if (node != null && node.type === 'asset_group') {
+                assetGroupIds.set(nodeId, assetGraph.getNodeIdsConnectedFrom(nodeId));
+            }
+            else if ((0, feature_flags_1.getFeatureFlag)('conditionalBundlingApi') &&
+                node != null &&
+                node.type === 'dependency') {
+                // The dependency placeholders in the `importCond` calls that will be in the transformed
+                // code need to be mapped to the "real" dependencies, so we need access to a map of placeholders
+                // to dependencies
+                const dep = node.value;
+                // @ts-expect-error TS2322
+                const placeholder = dep.meta?.placeholder;
+                if (placeholder != null) {
+                    placeholderToDependency.set(placeholder, dep);
+                }
+            }
+        });
+        let walkVisited = new Set();
+        function walk(nodeId) {
+            if (walkVisited.has(nodeId))
+                return;
+            walkVisited.add(nodeId);
+            let node = (0, nullthrows_1.default)(assetGraph.getNode(nodeId));
+            if ((0, feature_flags_1.getFeatureFlag)('conditionalBundlingApi') && node.type === 'asset') {
+                const asset = node.value;
+                if (Array.isArray(asset.meta.conditions)) {
+                    for (const condition of asset.meta.conditions) {
+                        // Resolve the placeholders that were attached to the asset in JSTransformer to dependencies,
+                        // as well as create a public id for the condition.
+                        const { key, ifTruePlaceholder, ifFalsePlaceholder, } = condition;
+                        const condHash = (0, rust_1.hashString)(`${key}:${ifTruePlaceholder}:${ifFalsePlaceholder}`);
+                        const condPublicId = (0, utils_2.getPublicId)(condHash, (v) => conditions.has(v));
+                        if (conditions.has(condHash)) {
+                            throw new Error('Unexpected duplicate asset');
+                        }
+                        else {
+                            conditions.set(condHash, {
+                                publicId: condPublicId,
+                                assets: new Set([asset]),
+                                key,
+                                ifTrueDependency: (0, nullthrows_1.default)(placeholderToDependency.get(ifTruePlaceholder), 'ifTruePlaceholder was undefined'),
+                                ifFalseDependency: (0, nullthrows_1.default)(placeholderToDependency.get(ifFalsePlaceholder), 'ifFalsePlaceholder was undefined'),
+                            });
+                        }
+                    }
+                }
+            }
+            if (node.type === 'dependency' &&
+                node.value.symbols != null &&
+                (0, EnvironmentManager_1.fromEnvironmentId)(node.value.env).shouldScopeHoist &&
+                // Disable in dev mode because this feature is at odds with safeToIncrementallyBundle
+                isProduction) {
+                let nodeValueSymbols = node.value.symbols;
+                // asset -> symbols that should be imported directly from that asset
+                let targets = new utils_1.DefaultMap(() => new Map());
+                let externalSymbols = new Set();
+                let hasAmbiguousSymbols = false;
+                for (let [symbol, resolvedSymbol] of node.usedSymbolsUp) {
+                    if (resolvedSymbol) {
+                        targets
+                            .get(resolvedSymbol.asset)
+                            .set(symbol, resolvedSymbol.symbol ?? symbol);
+                    }
+                    else if (resolvedSymbol === null) {
+                        externalSymbols.add(symbol);
+                    }
+                    else if (resolvedSymbol === undefined) {
+                        hasAmbiguousSymbols = true;
+                        break;
+                    }
+                }
+                if (
+                // Only perform retargeting when there is an imported symbol
+                // - If the target is side-effect-free, the symbols point to the actual target and removing
+                //   the original dependency resolution is fine
+                // - Otherwise, keep this dependency unchanged for its potential side effects
+                node.usedSymbolsUp.size > 0 &&
+                    // Only perform retargeting if the dependency only points to a single asset (e.g. CSS modules)
+                    !hasAmbiguousSymbols &&
+                    // It doesn't make sense to retarget dependencies where `*` is used, because the
+                    // retargeting won't enable any benefits in that case (apart from potentially even more
+                    // code being generated).
+                    !node.usedSymbolsUp.has('*') &&
+                    // TODO We currently can't rename imports in async imports, e.g. from
+                    //      (parcelRequire("...")).then(({ a }) => a);
+                    // to
+                    //      (parcelRequire("...")).then(({ a: b }) => a);
+                    // or
+                    //      (parcelRequire("...")).then((a)=>a);
+                    // if the reexporting asset did `export {a as b}` or `export * as a`
+                    node.value.priority === types_1.Priority.sync &&
+                    // For every asset, no symbol is imported multiple times (with a different local name).
+                    // Don't retarget because this cannot be resolved without also changing the asset symbols
+                    // (and the asset content itself).
+                    [...targets].every(([, t]) => new Set([...t.values()]).size === t.size)) {
+                    let isReexportAll = nodeValueSymbols.get('*')?.local === '*' ||
+                        node.value.meta?.hasExportStar;
+                    let reexportAllLoc = isReexportAll
+                        ? (0, nullthrows_1.default)(nodeValueSymbols.get('*')).loc
+                        : undefined;
+                    // TODO adjust sourceAssetIdNode.value.dependencies ?
+                    let deps = [
+                        // Keep the original dependency
+                        {
+                            asset: null,
+                            dep: graph.addNodeByContentKey(node.id, {
+                                ...node,
+                                value: {
+                                    ...node.value,
+                                    symbols: new Map(
+                                    // @ts-expect-error TS2769
+                                    [...nodeValueSymbols].filter(([k]) => externalSymbols.has(k))),
+                                },
+                                usedSymbolsUp: new Map(
+                                // @ts-expect-error TS2769
+                                [...node.usedSymbolsUp].filter(([k]) => externalSymbols.has(k))),
+                                usedSymbolsDown: new Set(),
+                                excluded: externalSymbols.size === 0,
+                            }),
+                        },
+                        ...[...targets].map(([asset, target]) => {
+                            let newNodeId = (0, rust_1.hashString)(node.id + [...target.keys()].join(','));
+                            let symbols = new Map();
+                            for (let [as, from] of target) {
+                                let existing = nodeValueSymbols.get(as);
+                                if (existing) {
+                                    symbols.set(from, existing);
+                                }
+                                else {
+                                    (0, assert_2.default)(isReexportAll);
+                                    if (as === from) {
+                                        // Keep the export-all for non-renamed reexports, this still correctly models
+                                        // ambiguous resolution with multiple export-alls.
+                                        symbols.set('*', {
+                                            isWeak: true,
+                                            local: '*',
+                                            loc: reexportAllLoc,
+                                        });
+                                    }
+                                    else {
+                                        let local = `${node.value.id}$rewrite$${asset}$${from}`;
+                                        symbols.set(from, {
+                                            isWeak: true,
+                                            local,
+                                            loc: reexportAllLoc,
+                                        });
+                                        if (node.value.sourceAssetId != null) {
+                                            let sourceAssetId;
+                                            if ((0, feature_flags_1.getFeatureFlag)('sourceAssetIdBundleGraphFix')) {
+                                                [sourceAssetId] =
+                                                    assetGraph.getNodeIdsConnectedTo(nodeId);
+                                            }
+                                            else {
+                                                sourceAssetId = assetGraph.getNodeIdByContentKey(node.value.sourceAssetId);
+                                            }
+                                            let sourceAsset = (0, nullthrows_1.default)(graph.getNode((0, nullthrows_1.default)(assetGraphNodeIdToBundleGraphNodeId.get(sourceAssetId))));
+                                            (0, assert_2.default)(sourceAsset.type === 'asset');
+                                            let sourceAssetSymbols = sourceAsset.value.symbols;
+                                            if (sourceAssetSymbols) {
+                                                // The `as == from` case above should handle multiple export-alls causing
+                                                // ambiguous resolution. So the current symbol is unambiguous and shouldn't
+                                                // already exist on the importer.
+                                                (0, assert_2.default)(!sourceAssetSymbols.has(as));
+                                                sourceAssetSymbols.set(as, {
+                                                    loc: reexportAllLoc,
+                                                    local: local,
+                                                });
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                            let usedSymbolsUp = new Map([...node.usedSymbolsUp]
+                                // @ts-expect-error TS2769
+                                .filter(([k]) => target.has(k) || k === '*')
+                                .map(([k, v]) => [target.get(k) ?? k, v]));
+                            return {
+                                asset,
+                                dep: graph.addNodeByContentKey(newNodeId, {
+                                    ...node,
+                                    id: newNodeId,
+                                    value: {
+                                        ...node.value,
+                                        id: newNodeId,
+                                        symbols,
+                                    },
+                                    usedSymbolsUp,
+                                    // This is only a temporary helper needed during symbol propagation and is never
+                                    // read afterwards (and also not exposed through the public API).
+                                    usedSymbolsDown: new Set(),
+                                }),
+                            };
+                        }),
+                    ];
+                    dependencies.set(nodeId, deps);
+                    // Jump to the dependencies that are used in this dependency
+                    for (let id of targets.keys()) {
+                        walk(assetGraph.getNodeIdByContentKey(id));
+                    }
+                    return;
+                }
+                else {
+                    // No special handling
+                    let bundleGraphNodeId = graph.addNodeByContentKey(node.id, node);
+                    assetGraphNodeIdToBundleGraphNodeId.set(nodeId, bundleGraphNodeId);
+                }
+            }
+            // Don't copy over asset groups into the bundle graph.
+            else if (node.type !== 'asset_group') {
+                let nodeToAdd = node.type === 'asset'
+                    ? {
+                        ...node,
+                        value: { ...node.value, symbols: new Map(node.value.symbols) },
+                    }
+                    : node;
+                let bundleGraphNodeId = graph.addNodeByContentKey(node.id, nodeToAdd);
+                if (node.id === assetGraphRootNode?.id) {
+                    graph.setRootNodeId(bundleGraphNodeId);
+                }
+                assetGraphNodeIdToBundleGraphNodeId.set(nodeId, bundleGraphNodeId);
+            }
+            for (let id of assetGraph.getNodeIdsConnectedFrom(nodeId)) {
+                walk(id);
+            }
+        }
+        walk((0, nullthrows_1.default)(assetGraph.rootNodeId));
+        // @ts-expect-error TS2488
+        for (let edge of assetGraph.getAllEdges()) {
+            if (assetGroupIds.has(edge.from)) {
+                continue;
+            }
+            if (dependencies.has(edge.from)) {
+                // Discard previous edge, insert outgoing edges for all split dependencies
+                for (let { asset, dep } of (0, nullthrows_1.default)(dependencies.get(edge.from))) {
+                    if (asset != null) {
+                        graph.addEdge(dep, (0, nullthrows_1.default)(assetGraphNodeIdToBundleGraphNodeId.get(assetGraph.getNodeIdByContentKey(asset))));
+                    }
+                }
+                continue;
+            }
+            if (!assetGraphNodeIdToBundleGraphNodeId.has(edge.from)) {
+                continue;
+            }
+            let to = dependencies.get(edge.to)?.map((v) => v.dep) ??
+                assetGroupIds
+                    .get(edge.to)
+                    ?.map((id) => (0, nullthrows_1.default)(assetGraphNodeIdToBundleGraphNodeId.get(id))) ?? [(0, nullthrows_1.default)(assetGraphNodeIdToBundleGraphNodeId.get(edge.to))];
+            for (let t of to) {
+                graph.addEdge((0, nullthrows_1.default)(assetGraphNodeIdToBundleGraphNodeId.get(edge.from)), t);
+            }
+        }
+        return new BundleGraph({
+            graph,
+            assetPublicIds,
+            bundleContentHashes: new Map(),
+            publicIdByAssetId,
+            conditions,
+        });
+    }
+    serialize() {
+        return {
+            $$raw: true,
+            graph: this._graph.serialize(),
+            assetPublicIds: this._assetPublicIds,
+            bundleContentHashes: this._bundleContentHashes,
+            publicIdByAssetId: this._publicIdByAssetId,
+            conditions: this._conditions,
+        };
+    }
+    static deserialize(serialized) {
+        return new BundleGraph({
+            graph: graph_1.ContentGraph.deserialize(serialized.graph),
+            assetPublicIds: serialized.assetPublicIds,
+            bundleContentHashes: serialized.bundleContentHashes,
+            publicIdByAssetId: serialized.publicIdByAssetId,
+            conditions: serialized.conditions,
+        });
+    }
+    /**
+     * Serialize the bundle graph for efficient transfer to native Rust code.
+     * Returns a JSON string of nodes, an array of edges, and a map of asset IDs to public IDs.
+     */
+    serializeForNative() {
+        const start = performance.now();
+        const nodes = this._graph.nodes;
+        const edges = [];
+        const edgeIterator = this._graph.getAllEdges();
+        let next = edgeIterator.next();
+        while (!next.done) {
+            const edge = next.value;
+            edges.push([edge.from, edge.to, edge.type]);
+            next = edgeIterator.next();
+        }
+        // Extract and deduplicate environments
+        const environmentMap = new Map();
+        const extractEnvironment = (envRef) => {
+            const env = (0, EnvironmentManager_1.fromEnvironmentId)(envRef);
+            const envId = env.id;
+            if (!environmentMap.has(envId)) {
+                environmentMap.set(envId, env);
+            }
+            return envId;
+        };
+        // Replace env objects with env IDs in nodes
+        const processedNodes = nodes.map((node) => {
+            const processedNode = { ...node };
+            if (node.type === 'asset' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            else if (node.type === 'dependency' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            else if (node.type === 'bundle' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            return processedNode;
+        });
+        // Optimize nodes by omitting null/undefined values to reduce JSON size
+        const optimizedNodes = processedNodes.map((node) => this._omitNulls(node));
+        const nodesJson = JSON.stringify(optimizedNodes);
+        // Serialize environments as array
+        const environments = Array.from(environmentMap.values());
+        const environmentsJson = JSON.stringify(environments);
+        // Convert Map to plain object for serialization
+        const publicIdByAssetId = {};
+        for (const [assetId, publicId] of this._publicIdByAssetId) {
+            publicIdByAssetId[assetId] = publicId;
+        }
+        const duration = performance.now() - start;
+        const nodesSizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+        const envsSizeMB = (environmentsJson.length / (1024 * 1024)).toFixed(2);
+        logger_1.default.verbose({
+            origin: '@atlaspack/core',
+            message: `serializeForNative: ${duration.toFixed(1)}ms, ${nodesSizeMB}MB nodes, ${envsSizeMB}MB envs (${environmentMap.size} unique), ${nodes.length} nodes, ${edges.length} edges`,
+        });
+        return { nodesJson, edges, publicIdByAssetId, environmentsJson };
+    }
+    /**
+     * Serialize only the given asset nodes for native incremental update.
+     * Same node shape and env/omit logic as serializeForNative.
+     */
+    serializeAssetNodesForNative(assetIds) {
+        const start = performance.now();
+        if (assetIds.length === 0) {
+            return '[]';
+        }
+        const nodes = [];
+        for (const assetId of assetIds) {
+            const node = this._graph.getNodeByContentKey(assetId);
+            if (node?.type !== 'asset') {
+                continue;
+            }
+            const processedNode = { ...node };
+            if (node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: (0, EnvironmentManager_1.fromEnvironmentId)(node.value.env).id,
+                };
+            }
+            nodes.push(processedNode);
+        }
+        const optimizedNodes = nodes.map((node) => this._omitNulls(node));
+        const nodesJson = JSON.stringify(optimizedNodes);
+        const duration = performance.now() - start;
+        const nodesSizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+        logger_1.default.verbose({
+            origin: '@atlaspack/core',
+            message: `serializeAssetNodesForNative: ${duration.toFixed(1)}ms, ${nodesSizeMB}MB nodes, ${nodes.length} nodes`,
+        });
+        return nodesJson;
+    }
+    /**
+     * Remove null and undefined values from an object to reduce JSON size.
+     * Preserves false, 0, empty strings, and arrays.
+     */
+    _omitNulls(obj) {
+        if (obj === null || obj === undefined)
+            return obj;
+        if (typeof obj !== 'object')
+            return obj;
+        if (Array.isArray(obj)) {
+            return obj.map((item) => this._omitNulls(item));
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            if (value === null || value === undefined) {
+                continue;
+            }
+            if (typeof value === 'object' &&
+                !Array.isArray(value) &&
+                Object.keys(value).length === 0) {
+                continue;
+            }
+            if (typeof value === 'object') {
+                const processed = this._omitNulls(value);
+                if (processed !== undefined) {
+                    result[key] = processed;
+                }
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+    createBundle(opts) {
+        // @ts-expect-error TS2339
+        let { entryAsset, target } = opts;
+        let bundleId = (0, rust_1.hashString)('bundle:' +
+            // @ts-expect-error TS2339
+            (opts.entryAsset ? opts.entryAsset.id : opts.uniqueKey) +
+            (0, projectPath_1.fromProjectPathRelative)(target.distDir) +
+            (opts.bundleBehavior ?? ''));
+        let existing = this._graph.getNodeByContentKey(bundleId);
+        if (existing != null) {
+            (0, assert_2.default)(existing.type === 'bundle');
+            return existing.value;
+        }
+        let publicId = (0, utils_2.getPublicId)(bundleId, (existing) => this._bundlePublicIds.has(existing));
+        this._bundlePublicIds.add(publicId);
+        let isPlaceholder = false;
+        if (entryAsset) {
+            let entryAssetNode = this._graph.getNodeByContentKey(entryAsset.id);
+            (0, assert_2.default)(entryAssetNode?.type === 'asset', 'Entry asset does not exist');
+            isPlaceholder = entryAssetNode.requested === false;
+        }
+        let bundleNode = {
+            type: 'bundle',
+            id: bundleId,
+            value: {
+                id: bundleId,
+                hashReference: opts.shouldContentHash
+                    ? constants_1.HASH_REF_PREFIX + bundleId
+                    : bundleId.slice(-8),
+                // @ts-expect-error TS2339
+                type: opts.entryAsset ? opts.entryAsset.type : opts.type,
+                env: opts.env,
+                entryAssetIds: entryAsset ? [entryAsset.id] : [],
+                mainEntryId: entryAsset?.id,
+                // @ts-expect-error TS2339
+                pipeline: opts.entryAsset ? opts.entryAsset.pipeline : opts.pipeline,
+                needsStableName: opts.needsStableName,
+                bundleBehavior: opts.bundleBehavior != null
+                    ? types_1.BundleBehavior[opts.bundleBehavior]
+                    : null,
+                // @ts-expect-error TS2339
+                isSplittable: opts.entryAsset
+                    ? // @ts-expect-error TS2339
+                        opts.entryAsset.isBundleSplittable
+                    : // @ts-expect-error TS2339
+                        opts.isSplittable,
+                isPlaceholder,
+                target,
+                name: null,
+                displayName: null,
+                publicId,
+            },
+        };
+        let bundleNodeId = this._graph.addNodeByContentKey(bundleId, bundleNode);
+        // @ts-expect-error TS2339
+        if (opts.entryAsset) {
+            this._graph.addEdge(bundleNodeId, 
+            // @ts-expect-error TS2339
+            this._graph.getNodeIdByContentKey(opts.entryAsset.id));
+        }
+        assert_2.default;
+        return bundleNode.value;
+    }
+    addAssetToBundle(asset, bundle) {
+        let bundleNodeId = this._graph.getNodeIdByContentKey(bundle.id);
+        this._graph.addEdge(bundleNodeId, this._graph.getNodeIdByContentKey(asset.id), exports.bundleGraphEdgeTypes.contains);
+        this._graph.addEdge(bundleNodeId, this._graph.getNodeIdByContentKey(asset.id));
+        let dependencies = this.getDependencies(asset);
+        for (let dependency of dependencies) {
+            let dependencyNodeId = this._graph.getNodeIdByContentKey(dependency.id);
+            this._graph.addEdge(bundleNodeId, dependencyNodeId, exports.bundleGraphEdgeTypes.contains);
+            for (let [bundleGroupNodeId, bundleGroupNode] of this._graph
+                .getNodeIdsConnectedFrom(dependencyNodeId)
+                .map((id) => [id, (0, nullthrows_1.default)(this._graph.getNode(id))])
+                // @ts-expect-error TS2769
+                .filter(([, node]) => node.type === 'bundle_group')) {
+                // @ts-expect-error TS2339
+                (0, assert_2.default)(bundleGroupNode.type === 'bundle_group');
+                this._graph.addEdge(bundleNodeId, 
+                // @ts-expect-error TS2345
+                bundleGroupNodeId, exports.bundleGraphEdgeTypes.bundle);
+            }
+            // If the dependency references a target bundle, add a reference edge from
+            // the source bundle to the dependency for easy traversal.
+            // TODO: Consider bundle being created from dependency
+            if (this._graph
+                .getNodeIdsConnectedFrom(dependencyNodeId, exports.bundleGraphEdgeTypes.references)
+                .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+                .some((node) => node.type === 'bundle')) {
+                this._graph.addEdge(bundleNodeId, dependencyNodeId, exports.bundleGraphEdgeTypes.references);
+            }
+        }
+    }
+    addAssetGraphToBundle(asset, bundle, shouldSkipDependency = (d) => this.isDependencySkipped(d)) {
+        let assetNodeId = this._graph.getNodeIdByContentKey(asset.id);
+        let bundleNodeId = this._graph.getNodeIdByContentKey(bundle.id);
+        // The root asset should be reached directly from the bundle in traversal.
+        // Its children will be traversed from there.
+        this._graph.addEdge(bundleNodeId, assetNodeId);
+        this._graph.traverse((nodeId, _, actions) => {
+            let node = (0, nullthrows_1.default)(this._graph.getNode(nodeId));
+            if (node.type === 'bundle_group') {
+                actions.skipChildren();
+                return;
+            }
+            if (node.type === 'dependency' && shouldSkipDependency(node.value)) {
+                actions.skipChildren();
+                return;
+            }
+            if (node.type === 'asset' || node.type === 'dependency') {
+                this._graph.addEdge(bundleNodeId, nodeId, exports.bundleGraphEdgeTypes.contains);
+            }
+            if (node.type === 'dependency') {
+                for (let [bundleGroupNodeId, bundleGroupNode] of this._graph
+                    .getNodeIdsConnectedFrom(nodeId)
+                    .map((id) => [id, (0, nullthrows_1.default)(this._graph.getNode(id))])
+                    // @ts-expect-error TS2769
+                    .filter(([, node]) => node.type === 'bundle_group')) {
+                    // @ts-expect-error TS2339
+                    (0, assert_2.default)(bundleGroupNode.type === 'bundle_group');
+                    this._graph.addEdge(bundleNodeId, 
+                    // @ts-expect-error TS2345
+                    bundleGroupNodeId, exports.bundleGraphEdgeTypes.bundle);
+                }
+                // If the dependency references a target bundle, add a reference edge from
+                // the source bundle to the dependency for easy traversal.
+                if (this._graph
+                    .getNodeIdsConnectedFrom(nodeId, exports.bundleGraphEdgeTypes.references)
+                    .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+                    .some((node) => node.type === 'bundle')) {
+                    this._graph.addEdge(bundleNodeId, nodeId, exports.bundleGraphEdgeTypes.references);
+                    this.markDependencyReferenceable(node.value);
+                    //all bundles that have this dependency need to have an edge from bundle to that dependency
+                }
+            }
+        }, assetNodeId);
+        this._bundleContentHashes.delete(bundle.id);
+    }
+    markDependencyReferenceable(dependency) {
+        for (let bundle of this.getBundlesWithDependency(dependency)) {
+            this._graph.addEdge(this._graph.getNodeIdByContentKey(bundle.id), this._graph.getNodeIdByContentKey(dependency.id), exports.bundleGraphEdgeTypes.references);
+        }
+    }
+    addEntryToBundle(asset, bundle, shouldSkipDependency) {
+        this.addAssetGraphToBundle(asset, bundle, shouldSkipDependency);
+        if (!bundle.entryAssetIds.includes(asset.id)) {
+            bundle.entryAssetIds.push(asset.id);
+        }
+    }
+    internalizeAsyncDependency(bundle, dependency) {
+        if (dependency.priority === types_1.Priority.sync) {
+            throw new Error('Expected an async dependency');
+        }
+        // It's possible for internalized async dependencies to not have
+        // reference edges and still have untyped edges.
+        // TODO: Maybe don't use internalized async edges at all?
+        let dependencyNodeId = this._graph.getNodeIdByContentKey(dependency.id);
+        let resolved = this.getResolvedAsset(dependency);
+        if (resolved) {
+            let resolvedNodeId = this._graph.getNodeIdByContentKey(resolved.id);
+            if (!this._graph.hasEdge(dependencyNodeId, resolvedNodeId, exports.bundleGraphEdgeTypes.references)) {
+                this._graph.addEdge(dependencyNodeId, resolvedNodeId, exports.bundleGraphEdgeTypes.references);
+                this._graph.removeEdge(dependencyNodeId, resolvedNodeId);
+            }
+        }
+        this._graph.addEdge(this._graph.getNodeIdByContentKey(bundle.id), this._graph.getNodeIdByContentKey(dependency.id), exports.bundleGraphEdgeTypes.internal_async);
+        this._removeExternalDependency(bundle, dependency);
+    }
+    isDependencySkipped(dependency) {
+        let node = this._graph.getNodeByContentKey(dependency.id);
+        (0, assert_2.default)(node && node.type === 'dependency');
+        return !!node.hasDeferred || node.excluded;
+    }
+    getParentBundlesOfBundleGroup(bundleGroup) {
+        return this._graph
+            .getNodeIdsConnectedTo(this._graph.getNodeIdByContentKey((0, utils_2.getBundleGroupId)(bundleGroup)), exports.bundleGraphEdgeTypes.bundle)
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .filter((node) => node.type === 'bundle')
+            .map((node) => {
+            (0, assert_2.default)(node.type === 'bundle');
+            return node.value;
+        });
+    }
+    resolveAsyncDependency(dependency, bundle) {
+        let depNodeId = this._graph.getNodeIdByContentKey(dependency.id);
+        let bundleNodeId = bundle != null ? this._graph.getNodeIdByContentKey(bundle.id) : null;
+        if (bundleNodeId != null &&
+            this._graph.hasEdge(bundleNodeId, depNodeId, exports.bundleGraphEdgeTypes.internal_async)) {
+            let referencedAssetNodeIds = this._graph.getNodeIdsConnectedFrom(depNodeId, exports.bundleGraphEdgeTypes.references);
+            let resolved;
+            if (referencedAssetNodeIds.length === 0) {
+                resolved = this.getResolvedAsset(dependency, bundle);
+            }
+            else if (referencedAssetNodeIds.length === 1) {
+                let referencedAssetNode = this._graph.getNode(referencedAssetNodeIds[0]);
+                // If a referenced asset already exists, resolve this dependency to it.
+                (0, assert_2.default)(referencedAssetNode?.type === 'asset');
+                resolved = referencedAssetNode.value;
+            }
+            else {
+                throw new Error('Dependencies can only reference one asset');
+            }
+            if (resolved == null) {
+                return;
+            }
+            else {
+                return {
+                    type: 'asset',
+                    value: resolved,
+                };
+            }
+        }
+        let node = this._graph
+            .getNodeIdsConnectedFrom(this._graph.getNodeIdByContentKey(dependency.id))
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .find((node) => node.type === 'bundle_group');
+        if (node == null) {
+            return;
+        }
+        (0, assert_2.default)(node.type === 'bundle_group');
+        return {
+            type: 'bundle_group',
+            value: node.value,
+        };
+    }
+    // eslint-disable-next-line no-unused-vars
+    getReferencedBundle(dependency, fromBundle) {
+        let dependencyNodeId = this._graph.getNodeIdByContentKey(dependency.id);
+        // Find an attached bundle via a reference edge (e.g. from createAssetReference).
+        let bundleNodes = this._graph
+            .getNodeIdsConnectedFrom(dependencyNodeId, exports.bundleGraphEdgeTypes.references)
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .filter((node) => node.type === 'bundle');
+        if (bundleNodes.length) {
+            let bundleNode = bundleNodes.find((b) => b.type === 'bundle' && b.value.type === fromBundle.type) || bundleNodes[0];
+            (0, assert_2.default)(bundleNode.type === 'bundle');
+            return bundleNode.value;
+        }
+        // If this dependency is async, there will be a bundle group attached to it.
+        let node = this._graph
+            .getNodeIdsConnectedFrom(dependencyNodeId)
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .find((node) => node.type === 'bundle_group');
+        if (node != null) {
+            (0, assert_2.default)(node.type === 'bundle_group');
+            return this.getBundlesInBundleGroup(node.value, {
+                includeInline: true,
+            }).find((b) => {
+                if ((0, feature_flags_1.getFeatureFlag)('supportWebpackChunkName')) {
+                    return b.entryAssetIds.some((id) => id === node.value.entryAssetId);
+                }
+                else {
+                    let mainEntryId = b.entryAssetIds[b.entryAssetIds.length - 1];
+                    return mainEntryId != null && node.value.entryAssetId === mainEntryId;
+                }
+            });
+        }
+    }
+    removeAssetGraphFromBundle(asset, bundle) {
+        let bundleNodeId = this._graph.getNodeIdByContentKey(bundle.id);
+        let assetNodeId = this._graph.getNodeIdByContentKey(asset.id);
+        // Remove all contains edges from the bundle to the nodes in the asset's
+        // subgraph.
+        this._graph.traverse((nodeId, context, actions) => {
+            let node = (0, nullthrows_1.default)(this._graph.getNode(nodeId));
+            if (node.type === 'bundle_group') {
+                actions.skipChildren();
+                return;
+            }
+            if (node.type !== 'dependency' && node.type !== 'asset') {
+                return;
+            }
+            if (this._graph.hasEdge(bundleNodeId, nodeId, exports.bundleGraphEdgeTypes.contains)) {
+                this._graph.removeEdge(bundleNodeId, nodeId, exports.bundleGraphEdgeTypes.contains, 
+                // Removing this contains edge should not orphan the connected node. This
+                // is disabled for performance reasons as these edges are removed as part
+                // of a traversal, and checking for orphans becomes quite expensive in
+                // aggregate.
+                false /* removeOrphans */);
+            }
+            else {
+                actions.skipChildren();
+            }
+            if (node.type === 'asset' && this._graph.hasEdge(bundleNodeId, nodeId)) {
+                // Remove the untyped edge from the bundle to the node (it's an entry)
+                this._graph.removeEdge(bundleNodeId, nodeId);
+                let entryIndex = bundle.entryAssetIds.indexOf(node.value.id);
+                if (entryIndex >= 0) {
+                    // Shared bundles have untyped edges to their asset graphs but don't
+                    // have entry assets. For those that have entry asset ids, remove them.
+                    bundle.entryAssetIds.splice(entryIndex, 1);
+                }
+            }
+            if (node.type === 'dependency') {
+                this._removeExternalDependency(bundle, node.value);
+                if (this._graph.hasEdge(bundleNodeId, nodeId, exports.bundleGraphEdgeTypes.references)) {
+                    this._graph.addEdge(bundleNodeId, nodeId, exports.bundleGraphEdgeTypes.references);
+                    this.markDependencyReferenceable(node.value);
+                }
+                if (this._graph.hasEdge(bundleNodeId, nodeId, exports.bundleGraphEdgeTypes.internal_async)) {
+                    this._graph.removeEdge(bundleNodeId, nodeId, exports.bundleGraphEdgeTypes.internal_async);
+                }
+            }
+        }, assetNodeId);
+        // Remove bundle node if it no longer has any entry assets
+        if (this._graph.getNodeIdsConnectedFrom(bundleNodeId).length === 0) {
+            this.removeBundle(bundle);
+        }
+        this._bundleContentHashes.delete(bundle.id);
+    }
+    /**
+     * Remove a bundle from the bundle graph. Remove its bundle group if it is
+     * the only bundle in the group.
+     */
+    removeBundle(bundle) {
+        // Remove bundle node if it no longer has any entry assets
+        let bundleNodeId = this._graph.getNodeIdByContentKey(bundle.id);
+        let bundleGroupNodeIds = this._graph.getNodeIdsConnectedTo(bundleNodeId, exports.bundleGraphEdgeTypes.bundle);
+        this._graph.removeNode(bundleNodeId);
+        let removedBundleGroups = new Set();
+        // Remove bundle group node if it no longer has any bundles
+        for (let bundleGroupNodeId of bundleGroupNodeIds) {
+            let bundleGroupNode = (0, nullthrows_1.default)(this._graph.getNode(bundleGroupNodeId));
+            (0, assert_2.default)(bundleGroupNode.type === 'bundle_group');
+            let bundleGroup = bundleGroupNode.value;
+            if (
+            // If the bundle group's entry asset belongs to this bundle, the group
+            // was created because of this bundle. Remove the group.
+            bundle.entryAssetIds.includes(bundleGroup.entryAssetId) ||
+                // If the bundle group is now empty, remove it.
+                this.getBundlesInBundleGroup(bundleGroup, { includeInline: true })
+                    .length === 0) {
+                removedBundleGroups.add(bundleGroup);
+                this.removeBundleGroup(bundleGroup);
+            }
+        }
+        this._bundleContentHashes.delete(bundle.id);
+        return removedBundleGroups;
+    }
+    removeBundleGroup(bundleGroup) {
+        let bundleGroupNode = (0, nullthrows_1.default)(this._graph.getNodeByContentKey((0, utils_2.getBundleGroupId)(bundleGroup)));
+        (0, assert_2.default)(bundleGroupNode.type === 'bundle_group');
+        let bundlesInGroup = this.getBundlesInBundleGroup(bundleGroupNode.value, {
+            includeInline: true,
+        });
+        for (let bundle of bundlesInGroup) {
+            if (this.getBundleGroupsContainingBundle(bundle).length === 1) {
+                let removedBundleGroups = this.removeBundle(bundle);
+                if (removedBundleGroups.has(bundleGroup)) {
+                    // This function can be reentered through removeBundle above. In the case this
+                    // bundle group has already been removed, stop.
+                    return;
+                }
+            }
+        }
+        // This function can be reentered through removeBundle above. In this case,
+        // the node may already been removed.
+        if (this._graph.hasContentKey(bundleGroupNode.id)) {
+            this._graph.removeNode(this._graph.getNodeIdByContentKey(bundleGroupNode.id));
+        }
+        (0, assert_1.default)(bundlesInGroup.every((bundle) => this.getBundleGroupsContainingBundle(bundle).length > 0));
+    }
+    _removeExternalDependency(bundle, dependency) {
+        let bundleNodeId = this._graph.getNodeIdByContentKey(bundle.id);
+        for (let bundleGroupNode of this._graph
+            .getNodeIdsConnectedFrom(this._graph.getNodeIdByContentKey(dependency.id))
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .filter((node) => node.type === 'bundle_group')) {
+            let bundleGroupNodeId = this._graph.getNodeIdByContentKey(bundleGroupNode.id);
+            if (!this._graph.hasEdge(bundleNodeId, bundleGroupNodeId, exports.bundleGraphEdgeTypes.bundle)) {
+                continue;
+            }
+            let inboundDependencies = this._graph
+                .getNodeIdsConnectedTo(bundleGroupNodeId)
+                .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+                .filter((node) => node.type === 'dependency')
+                .map((node) => {
+                (0, assert_2.default)(node.type === 'dependency');
+                return node.value;
+            });
+            // If every inbound dependency to this bundle group does not belong to this bundle,
+            // or the dependency is internal to the bundle, then the connection between
+            // this bundle and the group is safe to remove.
+            if (inboundDependencies.every((dependency) => dependency.specifierType !== types_1.SpecifierType.url &&
+                (!this.bundleHasDependency(bundle, dependency) ||
+                    this._graph.hasEdge(bundleNodeId, this._graph.getNodeIdByContentKey(dependency.id), exports.bundleGraphEdgeTypes.internal_async)))) {
+                this._graph.removeEdge(bundleNodeId, bundleGroupNodeId, exports.bundleGraphEdgeTypes.bundle);
+            }
+        }
+    }
+    createAssetReference(dependency, asset, bundle) {
+        let dependencyId = this._graph.getNodeIdByContentKey(dependency.id);
+        let assetId = this._graph.getNodeIdByContentKey(asset.id);
+        let bundleId = this._graph.getNodeIdByContentKey(bundle.id);
+        this._graph.addEdge(dependencyId, assetId, exports.bundleGraphEdgeTypes.references);
+        this._graph.addEdge(dependencyId, bundleId, exports.bundleGraphEdgeTypes.references);
+        this.markDependencyReferenceable(dependency);
+        if (this._graph.hasEdge(dependencyId, assetId)) {
+            this._graph.removeEdge(dependencyId, assetId);
+        }
+    }
+    createBundleReference(from, to) {
+        this._graph.addEdge(this._graph.getNodeIdByContentKey(from.id), this._graph.getNodeIdByContentKey(to.id), exports.bundleGraphEdgeTypes.references);
+    }
+    createBundleConditionalReference(from, to) {
+        this._graph.addEdge(this._graph.getNodeIdByContentKey(from.id), this._graph.getNodeIdByContentKey(to.id), exports.bundleGraphEdgeTypes.conditional);
+    }
+    getBundlesWithAsset(asset) {
+        return this._graph
+            .getNodeIdsConnectedTo(this._graph.getNodeIdByContentKey(asset.id), exports.bundleGraphEdgeTypes.contains)
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .filter((node) => node.type === 'bundle')
+            .map((node) => {
+            (0, assert_2.default)(node.type === 'bundle');
+            return node.value;
+        });
+    }
+    getBundlesWithDependency(dependency) {
+        return this._graph
+            .getNodeIdsConnectedTo((0, nullthrows_1.default)(this._graph.getNodeIdByContentKey(dependency.id)), exports.bundleGraphEdgeTypes.contains)
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .filter((node) => node.type === 'bundle')
+            .map((node) => {
+            (0, assert_2.default)(node.type === 'bundle');
+            return node.value;
+        });
+    }
+    getDependencyAssets(dependency) {
+        return this._graph
+            .getNodeIdsConnectedFrom(this._graph.getNodeIdByContentKey(dependency.id))
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .filter((node) => node.type === 'asset')
+            .map((node) => {
+            (0, assert_2.default)(node.type === 'asset');
+            return node.value;
+        });
+    }
+    getResolvedAsset(dep, bundle) {
+        let assets = this.getDependencyAssets(dep);
+        let firstAsset = assets[0];
+        let resolved = 
+        // If no bundle is specified, use the first concrete asset.
+        bundle == null
+            ? firstAsset
+            : // Otherwise, find the first asset that belongs to this bundle.
+                assets.find((asset) => this.bundleHasAsset(bundle, asset)) ||
+                    assets.find((a) => a.type === bundle.type) ||
+                    firstAsset;
+        // If a resolution still hasn't been found, return the first referenced asset.
+        if (resolved == null) {
+            let potential = [];
+            this._graph.traverse((nodeId, _, traversal) => {
+                let node = (0, nullthrows_1.default)(this._graph.getNode(nodeId));
+                if (node.type === 'asset') {
+                    potential.push(node.value);
+                }
+                else if (node.id !== dep.id) {
+                    traversal.skipChildren();
+                }
+            }, this._graph.getNodeIdByContentKey(dep.id), exports.bundleGraphEdgeTypes.references);
+            if (bundle) {
+                // @ts-expect-error TS2322
+                resolved = potential.find((a) => a.type === bundle.type);
+            }
+            resolved || (resolved = potential[0]);
+        }
+        return resolved;
+    }
+    getDependencies(asset) {
+        let nodeId = this._graph.getNodeIdByContentKey(asset.id);
+        return this._graph.getNodeIdsConnectedFrom(nodeId).map((id) => {
+            let node = (0, nullthrows_1.default)(this._graph.getNode(id));
+            (0, assert_2.default)(node.type === 'dependency');
+            return node.value;
+        });
+    }
+    traverseAssets(bundle, visit, startAsset) {
+        return this.traverseBundle(bundle, (0, graph_1.mapVisitor)((node) => (node.type === 'asset' ? node.value : null), visit), startAsset);
+    }
+    isAssetReferenced(bundle, asset) {
+        // If the asset is available in multiple bundles in the same target, it's referenced.
+        if (this.getBundlesWithAsset(asset).filter((b) => b.target.name === bundle.target.name &&
+            b.target.distDir === bundle.target.distDir).length > 1) {
+            return true;
+        }
+        let assetNodeId = (0, nullthrows_1.default)(this._graph.getNodeIdByContentKey(asset.id));
+        if (this._graph
+            .getNodeIdsConnectedTo(assetNodeId, exports.bundleGraphEdgeTypes.references)
+            .map((id) => this._graph.getNode(id))
+            .some((node) => node?.type === 'dependency' &&
+            (node.value.priority === types_1.Priority.lazy ||
+                node.value.priority === types_1.Priority.conditional) &&
+            node.value.specifierType !== types_1.SpecifierType.url)) {
+            // If this asset is referenced by any async dependency, it's referenced.
+            return true;
+        }
+        let dependencies = this._graph
+            .getNodeIdsConnectedTo(assetNodeId)
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .filter((node) => node.type === 'dependency')
+            .map((node) => {
+            (0, assert_2.default)(node.type === 'dependency');
+            return node.value;
+        });
+        const bundleHasReference = (bundle) => {
+            return (!this.bundleHasAsset(bundle, asset) &&
+                dependencies.some((dependency) => this.bundleHasDependency(bundle, dependency)));
+        };
+        let visitedBundles = new Set();
+        let siblingBundles = new Set(this.getBundleGroupsContainingBundle(bundle).flatMap((bundleGroup) => this.getBundlesInBundleGroup(bundleGroup, { includeInline: true })));
+        // Check if any of this bundle's descendants, referencers, bundles referenced
+        // by referencers, or descendants of its referencers use the asset without
+        // an explicit reference edge. This can happen if e.g. the asset has been
+        // deduplicated.
+        return [...siblingBundles].some((referencer) => {
+            let isReferenced = false;
+            this.traverseBundles((descendant, _, actions) => {
+                if (descendant.id === bundle.id) {
+                    return;
+                }
+                if (visitedBundles.has(descendant)) {
+                    actions.skipChildren();
+                    return;
+                }
+                visitedBundles.add(descendant);
+                if (descendant.type !== bundle.type ||
+                    (0, EnvironmentManager_1.fromEnvironmentId)(descendant.env).context !==
+                        (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env).context) {
+                    actions.skipChildren();
+                    return;
+                }
+                if (bundleHasReference(descendant)) {
+                    isReferenced = true;
+                    actions.stop();
+                    return;
+                }
+            }, referencer);
+            return isReferenced;
+        });
+    }
+    // New method: Fast checks only (no caching of results)
+    isAssetReferencedFastCheck(bundle, asset) {
+        // Fast Check #1: If asset is in multiple bundles in same target, it's referenced
+        let bundlesWithAsset = this.getBundlesWithAsset(asset).filter((b) => b.target.name === bundle.target.name &&
+            b.target.distDir === bundle.target.distDir);
+        if (bundlesWithAsset.length > 1) {
+            return true;
+        }
+        // Fast Check #2: If asset is referenced by any async/conditional dependency, it's referenced
+        let assetNodeId = (0, nullthrows_1.default)(this._graph.getNodeIdByContentKey(asset.id));
+        if (this._graph
+            .getNodeIdsConnectedTo(assetNodeId, exports.bundleGraphEdgeTypes.references)
+            .map((id) => this._graph.getNode(id))
+            .some((node) => node?.type === 'dependency' &&
+            (node.value.priority === types_1.Priority.lazy ||
+                node.value.priority === types_1.Priority.conditional) &&
+            node.value.specifierType !== types_1.SpecifierType.url)) {
+            return true;
+        }
+        // Fast checks failed - return null to indicate expensive computation needed
+        return null;
+    }
+    getReferencedAssets(bundle) {
+        let referencedAssets = new Set();
+        // Build a map of all assets in this bundle with their dependencies
+        // This allows us to check all assets in a single traversal
+        let assetDependenciesMap = new Map();
+        this.traverseAssets(bundle, (asset) => {
+            // Always do fast checks (no caching)
+            let fastCheckResult = this.isAssetReferencedFastCheck(bundle, asset);
+            if (fastCheckResult === true) {
+                referencedAssets.add(asset);
+                return;
+            }
+            // Fast checks failed (fastCheckResult === null), need expensive computation
+            // Check if it's actually referenced via traversal
+            // Store dependencies for later batch checking
+            let dependencies = this._graph
+                .getNodeIdsConnectedTo((0, nullthrows_1.default)(this._graph.getNodeIdByContentKey(asset.id)))
+                .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+                .filter((node) => node.type === 'dependency')
+                .map((node) => {
+                (0, assert_2.default)(node.type === 'dependency');
+                return node.value;
+            });
+            if (dependencies.length > 0) {
+                assetDependenciesMap.set(asset, dependencies);
+            }
+        });
+        // If no assets need the expensive check, return early
+        if (assetDependenciesMap.size === 0) {
+            return referencedAssets;
+        }
+        // Get the assets we need to check once
+        let assetsToCheck = Array.from(assetDependenciesMap.keys());
+        // Helper function to check if all assets from assetDependenciesMap are in referencedAssets
+        const allAssetsReferenced = () => assetsToCheck.length <= referencedAssets.size &&
+            assetsToCheck.every((asset) => referencedAssets.has(asset));
+        // Do ONE traversal to check all remaining assets
+        // We can share visitedBundles across all assets because we check every asset
+        // against every visited bundle, which matches the original per-asset behavior
+        let siblingBundles = new Set(this.getBundleGroupsContainingBundle(bundle).flatMap((bundleGroup) => this.getBundlesInBundleGroup(bundleGroup, { includeInline: true })));
+        let visitedBundles = new Set();
+        // Single traversal from all referencers
+        for (let referencer of siblingBundles) {
+            this.traverseBundles((descendant, _, actions) => {
+                if (descendant.id === bundle.id) {
+                    return;
+                }
+                if (visitedBundles.has(descendant)) {
+                    actions.skipChildren();
+                    return;
+                }
+                visitedBundles.add(descendant);
+                if (descendant.type !== bundle.type ||
+                    (0, EnvironmentManager_1.fromEnvironmentId)(descendant.env).context !==
+                        (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env).context) {
+                    // Don't skip children - they might be the right type!
+                    return;
+                }
+                // Check ALL assets at once in this descendant bundle
+                for (let [asset, dependencies] of assetDependenciesMap) {
+                    // Skip if already marked as referenced
+                    if (referencedAssets.has(asset)) {
+                        continue;
+                    }
+                    // Check if this descendant bundle references the asset
+                    if (!this.bundleHasAsset(descendant, asset) &&
+                        dependencies.some((dependency) => this.bundleHasDependency(descendant, dependency))) {
+                        referencedAssets.add(asset);
+                    }
+                }
+                // If all assets from assetDependenciesMap are now marked as referenced, we can stop early
+                if (allAssetsReferenced()) {
+                    actions.stop();
+                    return;
+                }
+            }, referencer);
+            // If all assets from assetDependenciesMap are referenced, no need to check more sibling bundles
+            if (allAssetsReferenced()) {
+                break;
+            }
+        }
+        return referencedAssets;
+    }
+    hasParentBundleOfType(bundle, type) {
+        let parents = this.getParentBundles(bundle);
+        return (parents.length > 0 && parents.every((parent) => parent.type === type));
+    }
+    getParentBundles(bundle) {
+        let parentBundles = new Set();
+        for (let bundleGroup of this.getBundleGroupsContainingBundle(bundle)) {
+            for (let parentBundle of this.getParentBundlesOfBundleGroup(bundleGroup)) {
+                parentBundles.add(parentBundle);
+            }
+        }
+        return [...parentBundles];
+    }
+    isAssetReachableFromBundle(asset, bundle) {
+        // If a bundle's environment is isolated, it can't access assets present
+        // in any ancestor bundles. Don't consider any assets reachable.
+        if (Environment_1.ISOLATED_ENVS.has((0, EnvironmentManager_1.fromEnvironmentId)(bundle.env).context) ||
+            !bundle.isSplittable ||
+            bundle.bundleBehavior === types_1.BundleBehavior.isolated ||
+            bundle.bundleBehavior === types_1.BundleBehavior.inline ||
+            bundle.bundleBehavior === types_1.BundleBehavior.inlineIsolated) {
+            return false;
+        }
+        // For an asset to be reachable from a bundle, it must either exist in a sibling bundle,
+        // or in an ancestor bundle group reachable from all parent bundles.
+        let bundleGroups = this.getBundleGroupsContainingBundle(bundle);
+        return bundleGroups.every((bundleGroup) => {
+            // If the asset is in any sibling bundles of the original bundle, it is reachable.
+            let bundles = this.getBundlesInBundleGroup(bundleGroup);
+            if (bundles.some((b) => b.id !== bundle.id &&
+                b.bundleBehavior !== types_1.BundleBehavior.isolated &&
+                b.bundleBehavior !== types_1.BundleBehavior.inline &&
+                b.bundleBehavior !== types_1.BundleBehavior.inlineIsolated &&
+                this.bundleHasAsset(b, asset))) {
+                return true;
+            }
+            // Get a list of parent bundle nodes pointing to the bundle group
+            let parentBundleNodes = this._graph.getNodeIdsConnectedTo(this._graph.getNodeIdByContentKey((0, utils_2.getBundleGroupId)(bundleGroup)), exports.bundleGraphEdgeTypes.bundle);
+            // Check that every parent bundle has a bundle group in its ancestry that contains the asset.
+            return parentBundleNodes.every((bundleNodeId) => {
+                let bundleNode = (0, nullthrows_1.default)(this._graph.getNode(bundleNodeId));
+                if (bundleNode.type !== 'bundle' ||
+                    bundleNode.value.bundleBehavior === types_1.BundleBehavior.isolated ||
+                    bundleNode.value.bundleBehavior === types_1.BundleBehavior.inline ||
+                    bundleNode.value.bundleBehavior === types_1.BundleBehavior.inlineIsolated) {
+                    return false;
+                }
+                let isReachable = true;
+                this._graph.traverseAncestors(bundleNodeId, (nodeId, ctx, actions) => {
+                    let node = (0, nullthrows_1.default)(this._graph.getNode(nodeId));
+                    // If we've reached the root or a context change without
+                    // finding this asset in the ancestry, it is not reachable.
+                    if (node.type === 'root' ||
+                        (node.type === 'bundle' &&
+                            (node.value.id === bundle.id ||
+                                (0, EnvironmentManager_1.fromEnvironmentId)(node.value.env).context !==
+                                    (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env).context))) {
+                        isReachable = false;
+                        actions.stop();
+                        return;
+                    }
+                    if (node.type === 'bundle_group') {
+                        let childBundles = this.getBundlesInBundleGroup(node.value);
+                        if (childBundles.some((b) => b.id !== bundle.id &&
+                            b.bundleBehavior !== types_1.BundleBehavior.isolated &&
+                            b.bundleBehavior !== types_1.BundleBehavior.inline &&
+                            b.bundleBehavior !== types_1.BundleBehavior.inlineIsolated &&
+                            this.bundleHasAsset(b, asset))) {
+                            actions.skipChildren();
+                            return;
+                        }
+                    }
+                }, [exports.bundleGraphEdgeTypes.references, exports.bundleGraphEdgeTypes.bundle]);
+                return isReachable;
+            });
+        });
+    }
+    /**
+     * Performs a depth-first traversal of all assets and dependencies contained
+     * within a bundle. Only visits nodes that are directly contained in the bundle
+     * (connected via a `contains` edge).
+     *
+     * Entry Asset Ordering:
+     * The traversal guarantees that entry assets are visited in the exact order they
+     * appear in `bundle.entryAssetIds`. This ordering is critical for several reasons:
+     *
+     * 1. **Code Execution Order in Packagers**: Packagers (ScopeHoistingPackager,
+     *    DevPackager) use this traversal to concatenate assets into the final bundle.
+     *    The traversal order determines the execution order of code in the output.
+     *    Entry assets must be processed in their defined order to ensure correct
+     *    initialization sequences.
+     *
+     * 2. **Runtime Injection**: Runtime assets (HMR, bundle manifests) are prepended
+     *    to `entryAssetIds` via `unshift()` in `applyRuntimes.ts`. By honoring the
+     *    array order, runtimes are guaranteed to be visited (and thus output) before
+     *    application entry points, ensuring the runtime infrastructure is available
+     *    when application code executes.
+     *
+     * 3. **Deterministic Builds**: Consistent traversal order ensures reproducible
+     *    bundle output, which is essential for caching and build verification.
+     *
+     * The sorting only applies at the first traversal level (direct children of the
+     * start node). Subsequent levels follow standard DFS order based on the graph's
+     * edge structure.
+     *
+     * @param bundle - The bundle to traverse
+     * @param visit - Visitor callback receiving asset or dependency nodes
+     * @param startAsset - Optional asset to start traversal from (defaults to bundle root)
+     */
+    traverseBundle(bundle, visit, startAsset) {
+        let entries = !startAsset;
+        let bundleNodeId = this._graph.getNodeIdByContentKey(bundle.id);
+        // A modified DFS traversal which traverses entry assets in the same order
+        // as their ids appear in `bundle.entryAssetIds`.
+        return this._graph.dfs({
+            visit: (0, graph_1.mapVisitor)((nodeId, actions) => {
+                let node = (0, nullthrows_1.default)(this._graph.getNode(nodeId));
+                if (nodeId === bundleNodeId) {
+                    return;
+                }
+                if (node.type === 'dependency' || node.type === 'asset') {
+                    if (this._graph.hasEdge(bundleNodeId, nodeId, exports.bundleGraphEdgeTypes.contains)) {
+                        return node;
+                    }
+                }
+                actions.skipChildren();
+            }, visit),
+            startNodeId: startAsset
+                ? this._graph.getNodeIdByContentKey(startAsset.id)
+                : bundleNodeId,
+            getChildren: (nodeId) => {
+                let children = this._graph
+                    .getNodeIdsConnectedFrom(nodeId)
+                    .map((id) => [id, (0, nullthrows_1.default)(this._graph.getNode(id))]);
+                let sorted = entries && bundle.entryAssetIds.length > 0
+                    ? // @ts-expect-error TS2345
+                        children.sort(([, a], [, b]) => {
+                            let aIndex = bundle.entryAssetIds.indexOf(a.id);
+                            let bIndex = bundle.entryAssetIds.indexOf(b.id);
+                            if (aIndex === bIndex) {
+                                // If both don't exist in the entry asset list, or
+                                // otherwise have the same index.
+                                return 0;
+                            }
+                            else if (aIndex === -1) {
+                                return 1;
+                            }
+                            else if (bIndex === -1) {
+                                return -1;
+                            }
+                            return aIndex - bIndex;
+                        })
+                    : children;
+                entries = false;
+                // @ts-expect-error TS2345
+                return sorted.map(([id]) => id);
+            },
+        });
+    }
+    traverse(visit, start) {
+        return this._graph.filteredTraverse((nodeId) => {
+            let node = (0, nullthrows_1.default)(this._graph.getNode(nodeId));
+            if (node.type === 'asset' || node.type === 'dependency') {
+                return node;
+            }
+        }, visit, start ? this._graph.getNodeIdByContentKey(start.id) : undefined, // start with root
+        graph_1.ALL_EDGE_TYPES);
+    }
+    getChildBundles(bundle) {
+        let siblings = new Set(this.getReferencedBundles(bundle));
+        let bundles = [];
+        this.traverseBundles((b, _, actions) => {
+            if (bundle.id === b.id) {
+                return;
+            }
+            if (!siblings.has(b)) {
+                bundles.push(b);
+            }
+            actions.skipChildren();
+        }, bundle);
+        return bundles;
+    }
+    traverseBundles(visit, startBundle) {
+        return this._graph.filteredTraverse((nodeId) => {
+            let node = (0, nullthrows_1.default)(this._graph.getNode(nodeId));
+            return node.type === 'bundle' ? node.value : null;
+        }, visit, startBundle ? this._graph.getNodeIdByContentKey(startBundle.id) : null, [exports.bundleGraphEdgeTypes.bundle, exports.bundleGraphEdgeTypes.references]);
+    }
+    getBundles(opts) {
+        let bundles = [];
+        this.traverseBundles((bundle) => {
+            if (opts?.includeInline ||
+                (bundle.bundleBehavior !== types_1.BundleBehavior.inline &&
+                    bundle.bundleBehavior !== types_1.BundleBehavior.inlineIsolated)) {
+                bundles.push(bundle);
+            }
+        });
+        return bundles;
+    }
+    getTotalSize(asset) {
+        let size = 0;
+        this._graph.traverse((nodeId, _, actions) => {
+            let node = (0, nullthrows_1.default)(this._graph.getNode(nodeId));
+            if (node.type === 'bundle_group') {
+                actions.skipChildren();
+                return;
+            }
+            if (node.type === 'asset') {
+                size += node.value.stats.size;
+            }
+        }, this._graph.getNodeIdByContentKey(asset.id));
+        return size;
+    }
+    getReferencingBundles(bundle) {
+        let referencingBundles = new Set();
+        this._graph.traverseAncestors(this._graph.getNodeIdByContentKey(bundle.id), (nodeId) => {
+            let node = (0, nullthrows_1.default)(this._graph.getNode(nodeId));
+            if (node.type === 'bundle' && node.value.id !== bundle.id) {
+                referencingBundles.add(node.value);
+            }
+        }, exports.bundleGraphEdgeTypes.references);
+        return [...referencingBundles];
+    }
+    getBundleGroupsContainingBundle(bundle) {
+        let bundleGroups = new Set();
+        for (let currentBundle of [bundle, ...this.getReferencingBundles(bundle)]) {
+            for (let bundleGroup of this.getDirectParentBundleGroups(currentBundle)) {
+                bundleGroups.add(bundleGroup);
+            }
+        }
+        return [...bundleGroups];
+    }
+    getDirectParentBundleGroups(bundle) {
+        return this._graph
+            .getNodeIdsConnectedTo((0, nullthrows_1.default)(this._graph.getNodeIdByContentKey(bundle.id)), exports.bundleGraphEdgeTypes.bundle)
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .filter((node) => node.type === 'bundle_group')
+            .map((node) => {
+            (0, assert_2.default)(node.type === 'bundle_group');
+            return node.value;
+        });
+    }
+    getBundlesInBundleGroup(bundleGroup, opts) {
+        let bundles = new Set();
+        for (let bundleNodeId of this._graph.getNodeIdsConnectedFrom(this._graph.getNodeIdByContentKey((0, utils_2.getBundleGroupId)(bundleGroup)), exports.bundleGraphEdgeTypes.bundle)) {
+            let bundleNode = (0, nullthrows_1.default)(this._graph.getNode(bundleNodeId));
+            (0, assert_2.default)(bundleNode.type === 'bundle');
+            let bundle = bundleNode.value;
+            if (opts?.includeInline ||
+                (bundle.bundleBehavior !== types_1.BundleBehavior.inline &&
+                    bundle.bundleBehavior !== types_1.BundleBehavior.inlineIsolated)) {
+                bundles.add(bundle);
+            }
+            for (let referencedBundle of this.getReferencedBundles(bundle, {
+                includeInline: opts?.includeInline,
+            })) {
+                bundles.add(referencedBundle);
+            }
+        }
+        return [...bundles];
+    }
+    getReferencedBundles(bundle, opts) {
+        let recursive = opts?.recursive ?? true;
+        let includeInline = opts?.includeInline ?? false;
+        let referencedBundles = new Set();
+        this._graph.dfs({
+            visit: (nodeId, _, actions) => {
+                let node = (0, nullthrows_1.default)(this._graph.getNode(nodeId));
+                if (node.type !== 'bundle') {
+                    return;
+                }
+                if (node.value.id === bundle.id) {
+                    return;
+                }
+                if (includeInline ||
+                    (node.value.bundleBehavior !== types_1.BundleBehavior.inline &&
+                        node.value.bundleBehavior !== types_1.BundleBehavior.inlineIsolated)) {
+                    referencedBundles.add(node.value);
+                }
+                if (!recursive) {
+                    actions.skipChildren();
+                }
+            },
+            startNodeId: this._graph.getNodeIdByContentKey(bundle.id),
+            getChildren: (nodeId) => 
+            // Shared bundles seem to depend on being used in the opposite order
+            // they were added.
+            // TODO: Should this be the case?
+            this._graph.getNodeIdsConnectedFrom(nodeId, exports.bundleGraphEdgeTypes.references),
+        });
+        // @ts-expect-error TS2322
+        return [...referencedBundles];
+    }
+    getIncomingDependencies(asset) {
+        if (!this._graph.hasContentKey(asset.id)) {
+            return [];
+        }
+        // Dependencies can be a a parent node via an untyped edge (like in the AssetGraph but without AssetGroups)
+        // or they can be parent nodes via a 'references' edge
+        return this._graph
+            .getNodeIdsConnectedTo(this._graph.getNodeIdByContentKey(asset.id), graph_1.ALL_EDGE_TYPES)
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .filter((n) => n.type === 'dependency')
+            .map((n) => {
+            (0, assert_2.default)(n.type === 'dependency');
+            return n.value;
+        });
+    }
+    getAssetWithDependency(dep) {
+        if (!this._graph.hasContentKey(dep.id)) {
+            return null;
+        }
+        let res = null;
+        let count = 0;
+        this._graph.forEachNodeIdConnectedTo(this._graph.getNodeIdByContentKey(dep.id), 
+        // @ts-expect-error TS2345
+        (node) => {
+            res = node;
+            count += 1;
+            if (count > 1) {
+                throw new Error('Expected a single asset to be connected to a dependency');
+            }
+        }, 1);
+        let resNode = res != null ? this._graph.getNode(res) : null;
+        if (resNode?.type === 'asset') {
+            return resNode.value;
+        }
+    }
+    bundleHasAsset(bundle, asset) {
+        let bundleNodeId = this._graph.getNodeIdByContentKey(bundle.id);
+        let assetNodeId = this._graph.getNodeIdByContentKey(asset.id);
+        return this._graph.hasEdge(bundleNodeId, assetNodeId, exports.bundleGraphEdgeTypes.contains);
+    }
+    bundleHasDependency(bundle, dependency) {
+        let bundleNodeId = this._graph.getNodeIdByContentKey(bundle.id);
+        let dependencyNodeId = this._graph.getNodeIdByContentKey(dependency.id);
+        return this._graph.hasEdge(bundleNodeId, dependencyNodeId, exports.bundleGraphEdgeTypes.contains);
+    }
+    filteredTraverse(bundleNodeId, filter, visit) {
+        return this._graph.filteredTraverse(filter, visit, bundleNodeId);
+    }
+    getSymbolResolution(asset, symbol, boundary) {
+        let assetOutside = boundary && !this.bundleHasAsset(boundary, asset);
+        let identifier = asset.symbols?.get(symbol)?.local;
+        if (symbol === '*') {
+            return {
+                asset,
+                exportSymbol: '*',
+                symbol: identifier ?? null,
+                loc: asset.symbols?.get(symbol)?.loc,
+            };
+        }
+        let found = false;
+        let nonStaticDependency = false;
+        let skipped = false;
+        let deps = this.getDependencies(asset).reverse();
+        let potentialResults = [];
+        for (let dep of deps) {
+            let depSymbols = dep.symbols;
+            if (!depSymbols) {
+                nonStaticDependency = true;
+                continue;
+            }
+            // If this is a re-export, find the original module.
+            let symbolLookup = new Map([...depSymbols].map(([key, val]) => [val.local, key]));
+            let depSymbol = symbolLookup.get(identifier);
+            if (depSymbol != null) {
+                let resolved = this.getResolvedAsset(dep, boundary);
+                if (!resolved || resolved.id === asset.id) {
+                    // External module or self-reference
+                    return {
+                        asset,
+                        exportSymbol: symbol,
+                        symbol: identifier,
+                        loc: asset.symbols?.get(symbol)?.loc,
+                    };
+                }
+                if (assetOutside) {
+                    // We found the symbol, but `asset` is outside, return `asset` and the original symbol
+                    found = true;
+                    break;
+                }
+                if (this.isDependencySkipped(dep)) {
+                    // We found the symbol and `dep` was skipped
+                    skipped = true;
+                    break;
+                }
+                let { asset: resolvedAsset, symbol: resolvedSymbol, exportSymbol, loc, } = this.getSymbolResolution(resolved, depSymbol, boundary);
+                if (!loc) {
+                    // Remember how we got there
+                    loc = asset.symbols?.get(symbol)?.loc;
+                }
+                return {
+                    asset: resolvedAsset,
+                    symbol: resolvedSymbol,
+                    exportSymbol,
+                    loc,
+                };
+            }
+            // If this module exports wildcards, resolve the original module.
+            // Default exports are excluded from wildcard exports.
+            // Wildcard reexports are never listed in the reexporting asset's symbols.
+            if (identifier == null &&
+                (depSymbols.get('*')?.local === '*' || dep.meta?.hasExportStar) &&
+                symbol !== 'default') {
+                let resolved = this.getResolvedAsset(dep, boundary);
+                if (!resolved) {
+                    continue;
+                }
+                let result = this.getSymbolResolution(resolved, symbol, boundary);
+                // We found the symbol
+                if (result.symbol != undefined) {
+                    if (assetOutside) {
+                        // ..., but `asset` is outside, return `asset` and the original symbol
+                        found = true;
+                        break;
+                    }
+                    if (this.isDependencySkipped(dep)) {
+                        // We found the symbol and `dep` was skipped
+                        skipped = true;
+                        break;
+                    }
+                    return {
+                        asset: result.asset,
+                        symbol: result.symbol,
+                        exportSymbol: result.exportSymbol,
+                        loc: resolved.symbols?.get(symbol)?.loc,
+                    };
+                }
+                if (result.symbol === null) {
+                    found = true;
+                    if (boundary && !this.bundleHasAsset(boundary, result.asset)) {
+                        // If the returned asset is outside (and it's the first asset that is outside), return it.
+                        if (!assetOutside) {
+                            return {
+                                asset: result.asset,
+                                symbol: result.symbol,
+                                exportSymbol: result.exportSymbol,
+                                loc: resolved.symbols?.get(symbol)?.loc,
+                            };
+                        }
+                        else {
+                            // Otherwise the original asset will be returned at the end.
+                            break;
+                        }
+                    }
+                    else {
+                        // We didn't find it in this dependency, but it might still be there: bailout.
+                        // Continue searching though, with the assumption that there are no conficting reexports
+                        // and there might be a another (re)export (where we might statically find the symbol).
+                        potentialResults.push({
+                            asset: result.asset,
+                            symbol: result.symbol,
+                            exportSymbol: result.exportSymbol,
+                            loc: resolved.symbols?.get(symbol)?.loc,
+                        });
+                    }
+                }
+            }
+        }
+        // We didn't find the exact symbol...
+        if (potentialResults.length == 1) {
+            // ..., but if it does exist, it has to be behind this one reexport.
+            return potentialResults[0];
+        }
+        else {
+            let result = identifier;
+            if (skipped) {
+                // ... and it was excluded (by symbol propagation) or deferred.
+                // @ts-expect-error TS2322
+                result = false;
+            }
+            else {
+                // ... and there is no single reexport, but it might still be exported:
+                if (found) {
+                    // Fallback to namespace access, because of a bundle boundary.
+                    // @ts-expect-error TS2322
+                    result = null;
+                }
+                else if (result === undefined) {
+                    // If not exported explicitly by the asset (= would have to be in * or a reexport-all) ...
+                    if (nonStaticDependency || asset.symbols?.has('*')) {
+                        // ... and if there are non-statically analyzable dependencies or it's a CJS asset,
+                        // fallback to namespace access.
+                        // @ts-expect-error TS2322
+                        result = null;
+                    }
+                    // (It shouldn't be possible for the symbol to be in a reexport-all and to end up here).
+                    // Otherwise return undefined to report that the symbol wasn't found.
+                }
+            }
+            return {
+                asset,
+                exportSymbol: symbol,
+                symbol: result,
+                loc: asset.symbols?.get(symbol)?.loc,
+            };
+        }
+    }
+    getAssetById(contentKey) {
+        let node = this._graph.getNodeByContentKey(contentKey);
+        if (node == null) {
+            throw new Error('Node not found');
+        }
+        else if (node.type !== 'asset') {
+            throw new Error('Node was not an asset');
+        }
+        return node.value;
+    }
+    getAssetPublicId(asset) {
+        let publicId = this._publicIdByAssetId.get(asset.id);
+        if (publicId == null) {
+            throw new Error("Asset or it's public id not found");
+        }
+        return publicId;
+    }
+    getExportedSymbols(asset, boundary) {
+        if (!asset.symbols) {
+            return [];
+        }
+        let symbols = [];
+        for (let symbol of asset.symbols.keys()) {
+            symbols.push({
+                ...this.getSymbolResolution(asset, symbol, boundary),
+                exportAs: symbol,
+            });
+        }
+        let deps = this.getDependencies(asset);
+        for (let dep of deps) {
+            let depSymbols = dep.symbols;
+            if (!depSymbols)
+                continue;
+            if (depSymbols.get('*')?.local === '*' || dep.meta?.hasExportStar) {
+                let resolved = this.getResolvedAsset(dep, boundary);
+                if (!resolved)
+                    continue;
+                let exported = this.getExportedSymbols(resolved, boundary)
+                    .filter((s) => s.exportSymbol !== 'default')
+                    .map((s) => s.exportSymbol !== '*' ? { ...s, exportAs: s.exportSymbol } : s);
+                symbols.push(...exported);
+            }
+        }
+        return symbols;
+    }
+    getContentHash(bundle) {
+        let existingHash = this._bundleContentHashes.get(bundle.id);
+        if (existingHash != null) {
+            return existingHash;
+        }
+        let hash = new rust_1.Hash();
+        // TODO: sort??
+        this.traverseAssets(bundle, (asset) => {
+            {
+                hash.writeString([this.getAssetPublicId(asset), asset.id, asset.outputHash].join(':'));
+            }
+        });
+        let hashHex = hash.finish();
+        this._bundleContentHashes.set(bundle.id, hashHex);
+        return hashHex;
+    }
+    getInlineBundles(bundle) {
+        let bundles = [];
+        let seen = new Set();
+        let addReferencedBundles = (bundle) => {
+            if (seen.has(bundle.id)) {
+                return;
+            }
+            seen.add(bundle.id);
+            let referencedBundles = this.getReferencedBundles(bundle, {
+                includeInline: true,
+            });
+            for (let referenced of referencedBundles) {
+                if (referenced.bundleBehavior === types_1.BundleBehavior.inline ||
+                    referenced.bundleBehavior === types_1.BundleBehavior.inlineIsolated) {
+                    bundles.push(referenced);
+                    addReferencedBundles(referenced);
+                }
+            }
+        };
+        addReferencedBundles(bundle);
+        this.traverseBundles((childBundle, _, traversal) => {
+            if (childBundle.bundleBehavior === types_1.BundleBehavior.inline ||
+                childBundle.bundleBehavior === types_1.BundleBehavior.inlineIsolated) {
+                bundles.push(childBundle);
+            }
+            else if (childBundle.id !== bundle.id) {
+                traversal.skipChildren();
+            }
+        }, bundle);
+        return bundles;
+    }
+    getHash(bundle) {
+        let hash = new rust_1.Hash();
+        hash.writeString(bundle.id + JSON.stringify(bundle.target) + this.getContentHash(bundle));
+        if (bundle.isPlaceholder) {
+            hash.writeString('placeholder');
+        }
+        let inlineBundles = this.getInlineBundles(bundle);
+        for (let inlineBundle of inlineBundles) {
+            hash.writeString(this.getContentHash(inlineBundle));
+        }
+        for (let referencedBundle of this.getReferencedBundles(bundle)) {
+            hash.writeString(referencedBundle.id);
+        }
+        hash.writeString(JSON.stringify((0, utils_1.objectSortedEntriesDeep)((0, EnvironmentManager_1.fromEnvironmentId)(bundle.env))));
+        return hash.finish();
+    }
+    getBundleGraphHash() {
+        let hashes = '';
+        for (let bundle of this.getBundles()) {
+            hashes += this.getHash(bundle);
+        }
+        return (0, rust_1.hashString)(hashes);
+    }
+    addBundleToBundleGroup(bundle, bundleGroup) {
+        let bundleGroupNodeId = this._graph.getNodeIdByContentKey((0, utils_2.getBundleGroupId)(bundleGroup));
+        let bundleNodeId = this._graph.getNodeIdByContentKey(bundle.id);
+        if (this._graph.hasEdge(bundleGroupNodeId, bundleNodeId, exports.bundleGraphEdgeTypes.bundle)) {
+            // Bundle group already has bundle
+            return;
+        }
+        this._graph.addEdge(bundleGroupNodeId, bundleNodeId);
+        this._graph.addEdge(bundleGroupNodeId, bundleNodeId, exports.bundleGraphEdgeTypes.bundle);
+        for (let entryAssetId of bundle.entryAssetIds) {
+            let entryAssetNodeId = this._graph.getNodeIdByContentKey(entryAssetId);
+            if (this._graph.hasEdge(bundleGroupNodeId, entryAssetNodeId)) {
+                this._graph.removeEdge(bundleGroupNodeId, entryAssetNodeId);
+            }
+        }
+    }
+    getUsedSymbolsAsset(asset) {
+        let node = this._graph.getNodeByContentKey(asset.id);
+        (0, assert_2.default)(node && node.type === 'asset');
+        return node.value.symbols
+            ? makeReadOnlySet(new Set(node.usedSymbols.keys()))
+            : null;
+    }
+    getUsedSymbolsDependency(dep) {
+        let node = this._graph.getNodeByContentKey(dep.id);
+        (0, assert_2.default)(node && node.type === 'dependency');
+        return node.value.symbols
+            ? makeReadOnlySet(new Set(node.usedSymbolsUp.keys()))
+            : null;
+    }
+    merge(other) {
+        let otherGraphIdToThisNodeId = new Map();
+        for (let [otherNodeId, otherNode] of other._graph.nodes.entries()) {
+            if (!otherNode)
+                continue;
+            if (this._graph.hasContentKey(otherNode.id)) {
+                let existingNodeId = this._graph.getNodeIdByContentKey(otherNode.id);
+                otherGraphIdToThisNodeId.set(otherNodeId, existingNodeId);
+                let existingNode = (0, nullthrows_1.default)(this._graph.getNode(existingNodeId));
+                // Merge symbols, recompute dep.excluded based on that
+                if (existingNode.type === 'asset') {
+                    (0, assert_2.default)(otherNode.type === 'asset');
+                    existingNode.usedSymbols = new Set([
+                        ...existingNode.usedSymbols,
+                        ...otherNode.usedSymbols,
+                    ]);
+                }
+                else if (existingNode.type === 'dependency') {
+                    (0, assert_2.default)(otherNode.type === 'dependency');
+                    existingNode.usedSymbolsDown = new Set([
+                        ...existingNode.usedSymbolsDown,
+                        ...otherNode.usedSymbolsDown,
+                    ]);
+                    existingNode.usedSymbolsUp = new Map([
+                        ...existingNode.usedSymbolsUp,
+                        ...otherNode.usedSymbolsUp,
+                    ]);
+                    existingNode.excluded =
+                        (existingNode.excluded || Boolean(existingNode.hasDeferred)) &&
+                            (otherNode.excluded || Boolean(otherNode.hasDeferred));
+                }
+            }
+            else {
+                let updateNodeId = this._graph.addNodeByContentKey(otherNode.id, otherNode);
+                otherGraphIdToThisNodeId.set(otherNodeId, updateNodeId);
+            }
+        }
+        // @ts-expect-error TS2488
+        for (let edge of other._graph.getAllEdges()) {
+            this._graph.addEdge((0, nullthrows_1.default)(otherGraphIdToThisNodeId.get(edge.from)), (0, nullthrows_1.default)(otherGraphIdToThisNodeId.get(edge.to)), edge.type);
+        }
+    }
+    isEntryBundleGroup(bundleGroup) {
+        return this._graph
+            .getNodeIdsConnectedTo((0, nullthrows_1.default)(this._graph.getNodeIdByContentKey((0, utils_2.getBundleGroupId)(bundleGroup))), exports.bundleGraphEdgeTypes.bundle)
+            .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+            .some((n) => n.type === 'root');
+    }
+    /**
+     * Update the asset in a Bundle Graph and clear the associated Bundle hash.
+     */
+    updateAsset(asset) {
+        this._graph.updateNode(this._graph.getNodeIdByContentKey(asset.id), asset);
+        let bundles = this.getBundlesWithAsset(asset.value);
+        for (let bundle of bundles) {
+            // the bundle content will change with a modified asset
+            this._bundleContentHashes.delete(bundle.id);
+        }
+    }
+    getEntryRoot(projectRoot, target) {
+        let cached = this._targetEntryRoots.get(target.distDir);
+        if (cached != null) {
+            return cached;
+        }
+        let entryBundleGroupIds = this._graph.getNodeIdsConnectedFrom((0, nullthrows_1.default)(this._graph.rootNodeId), exports.bundleGraphEdgeTypes.bundle);
+        let entries = [];
+        for (let bundleGroupId of entryBundleGroupIds) {
+            let bundleGroupNode = this._graph.getNode(bundleGroupId);
+            (0, assert_2.default)(bundleGroupNode?.type === 'bundle_group');
+            if (bundleGroupNode.value.target.distDir === target.distDir) {
+                let entryAssetNode = this._graph.getNodeByContentKey(bundleGroupNode.value.entryAssetId);
+                (0, assert_2.default)(entryAssetNode?.type === 'asset');
+                entries.push((0, projectPath_1.fromProjectPath)(projectRoot, entryAssetNode.value.filePath));
+            }
+        }
+        let root = (0, utils_1.getRootDir)(entries);
+        this._targetEntryRoots.set(target.distDir, root);
+        return root;
+    }
+    getReferencedConditionalBundles(bundle) {
+        let referencedBundles = new Set();
+        this._graph.dfs({
+            visit: (nodeId) => {
+                let node = (0, nullthrows_1.default)(this._graph.getNode(nodeId));
+                if (node.type !== 'bundle' || node.value.id === bundle.id) {
+                    return;
+                }
+                referencedBundles.add(node.value);
+            },
+            startNodeId: this._graph.getNodeIdByContentKey(bundle.id),
+            getChildren: (nodeId) => this._graph.getNodeIdsConnectedFrom(nodeId, exports.bundleGraphEdgeTypes.conditional),
+        });
+        // @ts-expect-error TS2322
+        return [...referencedBundles];
+    }
+}
+exports.default = BundleGraph;