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

package/src/{BundleGraph.js → BundleGraph.ts}

@@ -1,12 +1,10 @@
-// @flow strict-local
-
 import type {
   GraphVisitor,
   FilePath,
-  Symbol,
   TraversalActions,
   BundleBehavior as IBundleBehavior,
   ConditionMeta,
+  Symbol,
 } from '@atlaspack/types';
 import type {
   ContentKey,
@@ -49,6 +47,9 @@ import {ISOLATED_ENVS} from './public/Environment';
 import {fromProjectPath, fromProjectPathRelative} from './projectPath';
 import {HASH_REF_PREFIX} from './constants';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+import logger from '@atlaspack/logger';
+import {fromEnvironmentId} from './EnvironmentManager';
+import type {EnvironmentRef} from './EnvironmentManager';
 
 export const bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -75,47 +76,47 @@ export const bundleGraphEdgeTypes = {
   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: 5,
+  conditional: 6,
+} as const;
+
+export type BundleGraphEdgeType =
+  (typeof bundleGraphEdgeTypes)[keyof typeof bundleGraphEdgeTypes];
+
+type InternalSymbolResolution = {
+  asset: Asset;
+  exportSymbol: string;
+  symbol: Symbol | null | undefined | false;
+  loc: InternalSourceLocation | null | undefined;
+};
+
+type InternalExportSymbolResolution = InternalSymbolResolution & {
+  readonly exportAs: Symbol | string;
+};
+
+type BundleGraphOpts = {
+  graph: ContentGraphOpts<BundleGraphNode, BundleGraphEdgeType>;
+  bundleContentHashes: Map<string, string>;
+  assetPublicIds: Set<string>;
+  publicIdByAssetId: Map<string, string>;
+  conditions: Map<string, Condition>;
 };
 
-export type BundleGraphEdgeType = $Values<typeof bundleGraphEdgeTypes>;
-
-type InternalSymbolResolution = {|
-  asset: Asset,
-  exportSymbol: string,
-  symbol: ?Symbol | false,
-  loc: ?InternalSourceLocation,
-|};
-
-type InternalExportSymbolResolution = {|
-  ...InternalSymbolResolution,
-  +exportAs: Symbol | string,
-|};
-
-type BundleGraphOpts = {|
-  graph: ContentGraphOpts<BundleGraphNode, BundleGraphEdgeType>,
-  bundleContentHashes: Map<string, string>,
-  assetPublicIds: Set<string>,
-  publicIdByAssetId: Map<string, string>,
-  conditions: Map<string, Condition>,
-|};
-
-type SerializedBundleGraph = {|
-  $$raw: true,
-  graph: SerializedContentGraph<BundleGraphNode, BundleGraphEdgeType>,
-  bundleContentHashes: Map<string, string>,
-  assetPublicIds: Set<string>,
-  publicIdByAssetId: Map<string, string>,
-  conditions: Map<string, Condition>,
-|};
-
-function makeReadOnlySet<T>(set: Set<T>): $ReadOnlySet<T> {
+type SerializedBundleGraph = {
+  $$raw: true;
+  graph: SerializedContentGraph<BundleGraphNode, BundleGraphEdgeType>;
+  bundleContentHashes: Map<string, string>;
+  assetPublicIds: Set<string>;
+  publicIdByAssetId: Map<string, string>;
+  conditions: Map<string, Condition>;
+};
+
+function makeReadOnlySet<T>(set: Set<T>): ReadonlySet<T> {
   return new Proxy(set, {
-    get(target, property) {
+    get(target: Set<T>, property: string) {
       if (property === 'delete' || property === 'add' || property === 'clear') {
         return undefined;
       } else {
-        // $FlowFixMe[incompatible-type]
+        // @ts-expect-error TS7053
         let value = target[property];
         return typeof value === 'function' ? value.bind(target) : value;
       }
@@ -155,13 +156,13 @@ export default class BundleGraph {
     assetPublicIds,
     bundleContentHashes,
     conditions,
-  }: {|
-    graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>,
-    publicIdByAssetId: Map<string, string>,
-    assetPublicIds: Set<string>,
-    bundleContentHashes: Map<string, string>,
-    conditions: Map<string, Condition>,
-  |}) {
+  }: {
+    graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>;
+    publicIdByAssetId: Map<string, string>;
+    assetPublicIds: Set<string>;
+    bundleContentHashes: Map<string, string>;
+    conditions: Map<string, Condition>;
+  }) {
     this._graph = graph;
     this._assetPublicIds = assetPublicIds;
     this._publicIdByAssetId = publicIdByAssetId;
@@ -219,8 +220,8 @@ export default class BundleGraph {
         // code need to be mapped to the "real" dependencies, so we need access to a map of placeholders
         // to dependencies
         const dep = node.value;
-        // $FlowFixMe[incompatible-type] Meta is untyped
-        const placeholder: string | void = dep.meta?.placeholder;
+        // @ts-expect-error TS2322
+        const placeholder: string | undefined = dep.meta?.placeholder;
         if (placeholder != null) {
           placeholderToDependency.set(placeholder, dep);
         }
@@ -228,7 +229,7 @@ export default class BundleGraph {
     });
 
     let walkVisited = new Set();
-    function walk(nodeId) {
+    function walk(nodeId: NodeId) {
       if (walkVisited.has(nodeId)) return;
       walkVisited.add(nodeId);
 
@@ -237,8 +238,7 @@ export default class BundleGraph {
       if (getFeatureFlag('conditionalBundlingApi') && node.type === 'asset') {
         const asset = node.value;
         if (Array.isArray(asset.meta.conditions)) {
-          // $FlowFixMe
-          for (const condition of (asset.meta.conditions: ConditionMeta[])) {
+          for (const condition of asset.meta.conditions as ConditionMeta[]) {
             // Resolve the placeholders that were attached to the asset in JSTransformer to dependencies,
             // as well as create a public id for the condition.
             const {
@@ -246,10 +246,9 @@ export default class BundleGraph {
               ifTruePlaceholder,
               ifFalsePlaceholder,
             }: {
-              key: string,
-              ifTruePlaceholder: string,
-              ifFalsePlaceholder: string,
-              ...
+              key: string;
+              ifTruePlaceholder: string;
+              ifFalsePlaceholder: string;
             } = condition;
 
             const condHash = hashString(
@@ -283,7 +282,7 @@ export default class BundleGraph {
       if (
         node.type === 'dependency' &&
         node.value.symbols != null &&
-        node.value.env.shouldScopeHoist &&
+        fromEnvironmentId(node.value.env).shouldScopeHoist &&
         // Disable in dev mode because this feature is at odds with safeToIncrementallyBundle
         isProduction
       ) {
@@ -333,10 +332,12 @@ export default class BundleGraph {
           // 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,
+            ([, t]: [any, any]) => new Set([...t.values()]).size === t.size,
           )
         ) {
-          let isReexportAll = nodeValueSymbols.get('*')?.local === '*';
+          let isReexportAll =
+            nodeValueSymbols.get('*')?.local === '*' ||
+            node.value.meta?.hasExportStar;
           let reexportAllLoc = isReexportAll
             ? nullthrows(nodeValueSymbols.get('*')).loc
             : undefined;
@@ -351,13 +352,15 @@ export default class BundleGraph {
                 value: {
                   ...node.value,
                   symbols: new Map(
-                    [...nodeValueSymbols].filter(([k]) =>
+                    // @ts-expect-error TS2769
+                    [...nodeValueSymbols].filter(([k]: [any]) =>
                       externalSymbols.has(k),
                     ),
                   ),
                 },
                 usedSymbolsUp: new Map(
-                  [...node.usedSymbolsUp].filter(([k]) =>
+                  // @ts-expect-error TS2769
+                  [...node.usedSymbolsUp].filter(([k]: [any]) =>
                     externalSymbols.has(k),
                   ),
                 ),
@@ -365,7 +368,7 @@ export default class BundleGraph {
                 excluded: externalSymbols.size === 0,
               }),
             },
-            ...[...targets].map(([asset, target]) => {
+            ...[...targets].map(([asset, target]: [any, any]) => {
               let newNodeId = hashString(
                 node.id + [...target.keys()].join(','),
               );
@@ -392,17 +395,28 @@ export default class BundleGraph {
                       local,
                       loc: reexportAllLoc,
                     });
+
                     if (node.value.sourceAssetId != null) {
-                      let sourceAssetId = nullthrows(
-                        assetGraphNodeIdToBundleGraphNodeId.get(
-                          assetGraph.getNodeIdByContentKey(
-                            node.value.sourceAssetId,
+                      let sourceAssetId: NodeId;
+
+                      if (getFeatureFlag('sourceAssetIdBundleGraphFix')) {
+                        [sourceAssetId] =
+                          assetGraph.getNodeIdsConnectedTo(nodeId);
+                      } else {
+                        sourceAssetId = assetGraph.getNodeIdByContentKey(
+                          node.value.sourceAssetId,
+                        );
+                      }
+
+                      let sourceAsset = nullthrows(
+                        graph.getNode(
+                          nullthrows(
+                            assetGraphNodeIdToBundleGraphNodeId.get(
+                              sourceAssetId,
+                            ),
                           ),
                         ),
                       );
-                      let sourceAsset = nullthrows(
-                        graph.getNode(sourceAssetId),
-                      );
                       invariant(sourceAsset.type === 'asset');
                       let sourceAssetSymbols = sourceAsset.value.symbols;
                       if (sourceAssetSymbols) {
@@ -421,8 +435,9 @@ export default class BundleGraph {
               }
               let usedSymbolsUp = new Map(
                 [...node.usedSymbolsUp]
-                  .filter(([k]) => target.has(k) || k === '*')
-                  .map(([k, v]) => [target.get(k) ?? k, v]),
+                  // @ts-expect-error TS2769
+                  .filter(([k]: [any]) => target.has(k) || k === '*')
+                  .map(([k, v]: [any, any]) => [target.get(k) ?? k, v]),
               );
               return {
                 asset,
@@ -478,6 +493,7 @@ export default class BundleGraph {
     }
     walk(nullthrows(assetGraph.rootNodeId));
 
+    // @ts-expect-error TS2488
     for (let edge of assetGraph.getAllEdges()) {
       if (assetGroupIds.has(edge.from)) {
         continue;
@@ -502,10 +518,22 @@ export default class BundleGraph {
         continue;
       }
 
-      let to: Array<NodeId> = dependencies.get(edge.to)?.map((v) => v.dep) ??
+      let to: Array<NodeId> = dependencies.get(edge.to)?.map(
+        (
+          v:
+            | {
+                asset: null;
+                dep: NodeId;
+              }
+            | {
+                asset: ContentKey;
+                dep: NodeId;
+              },
+        ) => v.dep,
+      ) ??
         assetGroupIds
           .get(edge.to)
-          ?.map((id) =>
+          ?.map((id: NodeId) =>
             nullthrows(assetGraphNodeIdToBundleGraphNodeId.get(id)),
           ) ?? [nullthrows(assetGraphNodeIdToBundleGraphNodeId.get(edge.to))];
 
@@ -547,31 +575,189 @@ export default class BundleGraph {
     });
   }
 
+  /**
+   * 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(): {
+    nodesJson: string;
+    edges: [number, number, BundleGraphEdgeType][];
+    publicIdByAssetId: Record<string, string>;
+    environmentsJson: string;
+  } {
+    const start = performance.now();
+
+    const nodes = this._graph.nodes as BundleGraphNode[];
+    const edges: [number, number, BundleGraphEdgeType][] = [];
+
+    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<string, Environment>();
+    const extractEnvironment = (envRef: EnvironmentRef): string => {
+      const env = 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: Record<string, string> = {};
+    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.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: Array<string>): string {
+    const start = performance.now();
+
+    if (assetIds.length === 0) {
+      return '[]';
+    }
+
+    const nodes: Array<BundleGraphNode> = [];
+    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: 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.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.
+   */
+  private _omitNulls(obj: unknown): unknown {
+    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: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+      if (value === null || value === undefined) {
+        continue;
+      }
+      if (
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        Object.keys(value as object).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:
-      | {|
-          +entryAsset: Asset,
-          +target: Target,
-          +needsStableName?: ?boolean,
-          +bundleBehavior?: ?IBundleBehavior,
-          +shouldContentHash: boolean,
-          +env: Environment,
-        |}
-      | {|
-          +type: string,
-          +env: Environment,
-          +uniqueKey: string,
-          +target: Target,
-          +needsStableName?: ?boolean,
-          +bundleBehavior?: ?IBundleBehavior,
-          +isSplittable?: ?boolean,
-          +pipeline?: ?string,
-          +shouldContentHash: boolean,
-        |},
+      | {
+          readonly entryAsset: Asset;
+          readonly bundleRoots?: Array<Asset>;
+          readonly target: Target;
+          readonly needsStableName?: boolean | null | undefined;
+          readonly bundleBehavior?: IBundleBehavior | null | undefined;
+          readonly shouldContentHash: boolean;
+          readonly env: EnvironmentRef;
+        }
+      | {
+          readonly type: string;
+          readonly env: EnvironmentRef;
+          readonly uniqueKey: string;
+          readonly target: Target;
+          readonly needsStableName?: boolean | null | undefined;
+          readonly bundleBehavior?: IBundleBehavior | null | undefined;
+          readonly isSplittable?: boolean | null | undefined;
+          readonly pipeline?: string | null | undefined;
+          readonly shouldContentHash: boolean;
+        },
   ): Bundle {
+    // @ts-expect-error TS2339
     let {entryAsset, target} = opts;
     let bundleId = hashString(
       'bundle:' +
+        // @ts-expect-error TS2339
         (opts.entryAsset ? opts.entryAsset.id : opts.uniqueKey) +
         fromProjectPathRelative(target.distDir) +
         (opts.bundleBehavior ?? ''),
@@ -603,19 +789,24 @@ export default class BundleGraph {
         hashReference: opts.shouldContentHash
           ? 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
             ? BundleBehavior[opts.bundleBehavior]
             : null,
+        // @ts-expect-error TS2339
         isSplittable: opts.entryAsset
-          ? opts.entryAsset.isBundleSplittable
-          : opts.isSplittable,
+          ? // @ts-expect-error TS2339
+            opts.entryAsset.isBundleSplittable
+          : // @ts-expect-error TS2339
+            opts.isSplittable,
         isPlaceholder,
         target,
         name: null,
@@ -626,9 +817,11 @@ export default class BundleGraph {
 
     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),
       );
     }
@@ -661,10 +854,13 @@ export default class BundleGraph {
       for (let [bundleGroupNodeId, bundleGroupNode] of this._graph
         .getNodeIdsConnectedFrom(dependencyNodeId)
         .map((id) => [id, nullthrows(this._graph.getNode(id))])
-        .filter(([, node]) => node.type === 'bundle_group')) {
+        // @ts-expect-error TS2769
+        .filter(([, node]: [any, any]) => node.type === 'bundle_group')) {
+        // @ts-expect-error TS2339
         invariant(bundleGroupNode.type === 'bundle_group');
         this._graph.addEdge(
           bundleNodeId,
+          // @ts-expect-error TS2345
           bundleGroupNodeId,
           bundleGraphEdgeTypes.bundle,
         );
@@ -693,7 +889,7 @@ export default class BundleGraph {
   addAssetGraphToBundle(
     asset: Asset,
     bundle: Bundle,
-    shouldSkipDependency: (Dependency) => boolean = (d) =>
+    shouldSkipDependency: (arg1: Dependency) => boolean = (d: Dependency) =>
       this.isDependencySkipped(d),
   ) {
     let assetNodeId = this._graph.getNodeIdByContentKey(asset.id);
@@ -726,10 +922,13 @@ export default class BundleGraph {
         for (let [bundleGroupNodeId, bundleGroupNode] of this._graph
           .getNodeIdsConnectedFrom(nodeId)
           .map((id) => [id, nullthrows(this._graph.getNode(id))])
-          .filter(([, node]) => node.type === 'bundle_group')) {
+          // @ts-expect-error TS2769
+          .filter(([, node]: [any, any]) => node.type === 'bundle_group')) {
+          // @ts-expect-error TS2339
           invariant(bundleGroupNode.type === 'bundle_group');
           this._graph.addEdge(
             bundleNodeId,
+            // @ts-expect-error TS2345
             bundleGroupNodeId,
             bundleGraphEdgeTypes.bundle,
           );
@@ -769,7 +968,7 @@ export default class BundleGraph {
   addEntryToBundle(
     asset: Asset,
     bundle: Bundle,
-    shouldSkipDependency?: (Dependency) => boolean,
+    shouldSkipDependency?: (arg1: Dependency) => boolean,
   ) {
     this.addAssetGraphToBundle(asset, bundle, shouldSkipDependency);
     if (!bundle.entryAssetIds.includes(asset.id)) {
@@ -836,11 +1035,18 @@ export default class BundleGraph {
 
   resolveAsyncDependency(
     dependency: Dependency,
-    bundle: ?Bundle,
-  ): ?(
-    | {|type: 'bundle_group', value: BundleGroup|}
-    | {|type: 'asset', value: Asset|}
-  ) {
+    bundle?: Bundle | null,
+  ):
+    | {
+        type: 'bundle_group';
+        value: BundleGroup;
+      }
+    | {
+        type: 'asset';
+        value: Asset;
+      }
+    | null
+    | undefined {
     let depNodeId = this._graph.getNodeIdByContentKey(dependency.id);
     let bundleNodeId =
       bundle != null ? this._graph.getNodeIdByContentKey(bundle.id) : null;
@@ -899,7 +1105,10 @@ export default class BundleGraph {
   }
 
   // eslint-disable-next-line no-unused-vars
-  getReferencedBundle(dependency: Dependency, fromBundle: Bundle): ?Bundle {
+  getReferencedBundle(
+    dependency: Dependency,
+    fromBundle: Bundle,
+  ): Bundle | null | undefined {
     let dependencyNodeId = this._graph.getNodeIdByContentKey(dependency.id);
 
     // Find an attached bundle via a reference edge (e.g. from createAssetReference).
@@ -931,8 +1140,12 @@ export default class BundleGraph {
       return this.getBundlesInBundleGroup(node.value, {
         includeInline: true,
       }).find((b) => {
-        let mainEntryId = b.entryAssetIds[b.entryAssetIds.length - 1];
-        return mainEntryId != null && node.value.entryAssetId === mainEntryId;
+        if (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;
+        }
       });
     }
   }
@@ -1226,7 +1439,10 @@ export default class BundleGraph {
       });
   }
 
-  getResolvedAsset(dep: Dependency, bundle: ?Bundle): ?Asset {
+  getResolvedAsset(
+    dep: Dependency,
+    bundle?: Bundle | null,
+  ): Asset | null | undefined {
     let assets = this.getDependencyAssets(dep);
     let firstAsset = assets[0];
     let resolved =
@@ -1240,7 +1456,7 @@ export default class BundleGraph {
 
     // If a resolution still hasn't been found, return the first referenced asset.
     if (resolved == null) {
-      let potential = [];
+      let potential: Array<Asset> = [];
       this._graph.traverse(
         (nodeId, _, traversal) => {
           let node = nullthrows(this._graph.getNode(nodeId));
@@ -1255,6 +1471,7 @@ export default class BundleGraph {
       );
 
       if (bundle) {
+        // @ts-expect-error TS2322
         resolved = potential.find((a) => a.type === bundle.type);
       }
       resolved ||= potential[0];
@@ -1276,7 +1493,7 @@ export default class BundleGraph {
     bundle: Bundle,
     visit: GraphVisitor<Asset, TContext>,
     startAsset?: Asset,
-  ): ?TContext {
+  ): TContext | null | undefined {
     return this.traverseBundle(
       bundle,
       mapVisitor((node) => (node.type === 'asset' ? node.value : null), visit),
@@ -1359,7 +1576,8 @@ export default class BundleGraph {
 
         if (
           descendant.type !== bundle.type ||
-          descendant.env.context !== bundle.env.context
+          fromEnvironmentId(descendant.env).context !==
+            fromEnvironmentId(bundle.env).context
         ) {
           actions.skipChildren();
           return;
@@ -1376,6 +1594,158 @@ export default class BundleGraph {
     });
   }
 
+  // New method: Fast checks only (no caching of results)
+  isAssetReferencedFastCheck(bundle: Bundle, asset: Asset): boolean | null {
+    // 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 = nullthrows(this._graph.getNodeIdByContentKey(asset.id));
+
+    if (
+      this._graph
+        .getNodeIdsConnectedTo(assetNodeId, bundleGraphEdgeTypes.references)
+        .map((id) => this._graph.getNode(id))
+        .some(
+          (node) =>
+            node?.type === 'dependency' &&
+            (node.value.priority === Priority.lazy ||
+              node.value.priority === Priority.conditional) &&
+            node.value.specifierType !== SpecifierType.url,
+        )
+    ) {
+      return true;
+    }
+
+    // Fast checks failed - return null to indicate expensive computation needed
+    return null;
+  }
+
+  getReferencedAssets(bundle: Bundle): Set<Asset> {
+    let referencedAssets = new Set<Asset>();
+
+    // 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<Asset, Array<Dependency>>();
+
+    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(
+          nullthrows(this._graph.getNodeIdByContentKey(asset.id)),
+        )
+        .map((id) => nullthrows(this._graph.getNode(id)))
+        .filter((node) => node.type === 'dependency')
+        .map((node) => {
+          invariant(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 = (): boolean =>
+      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: Set<Bundle> = 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 ||
+          fromEnvironmentId(descendant.env).context !==
+            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: Bundle, type: string): boolean {
     let parents = this.getParentBundles(bundle);
     return (
@@ -1400,10 +1770,11 @@ export default class BundleGraph {
     // If a bundle's environment is isolated, it can't access assets present
     // in any ancestor bundles. Don't consider any assets reachable.
     if (
-      ISOLATED_ENVS.has(bundle.env.context) ||
+      ISOLATED_ENVS.has(fromEnvironmentId(bundle.env).context) ||
       !bundle.isSplittable ||
       bundle.bundleBehavior === BundleBehavior.isolated ||
-      bundle.bundleBehavior === BundleBehavior.inline
+      bundle.bundleBehavior === BundleBehavior.inline ||
+      bundle.bundleBehavior === BundleBehavior.inlineIsolated
     ) {
       return false;
     }
@@ -1420,6 +1791,7 @@ export default class BundleGraph {
             b.id !== bundle.id &&
             b.bundleBehavior !== BundleBehavior.isolated &&
             b.bundleBehavior !== BundleBehavior.inline &&
+            b.bundleBehavior !== BundleBehavior.inlineIsolated &&
             this.bundleHasAsset(b, asset),
         )
       ) {
@@ -1438,7 +1810,8 @@ export default class BundleGraph {
         if (
           bundleNode.type !== 'bundle' ||
           bundleNode.value.bundleBehavior === BundleBehavior.isolated ||
-          bundleNode.value.bundleBehavior === BundleBehavior.inline
+          bundleNode.value.bundleBehavior === BundleBehavior.inline ||
+          bundleNode.value.bundleBehavior === BundleBehavior.inlineIsolated
         ) {
           return false;
         }
@@ -1454,7 +1827,8 @@ export default class BundleGraph {
               node.type === 'root' ||
               (node.type === 'bundle' &&
                 (node.value.id === bundle.id ||
-                  node.value.env.context !== bundle.env.context))
+                  fromEnvironmentId(node.value.env).context !==
+                    fromEnvironmentId(bundle.env).context))
             ) {
               isReachable = false;
               actions.stop();
@@ -1469,6 +1843,7 @@ export default class BundleGraph {
                     b.id !== bundle.id &&
                     b.bundleBehavior !== BundleBehavior.isolated &&
                     b.bundleBehavior !== BundleBehavior.inline &&
+                    b.bundleBehavior !== BundleBehavior.inlineIsolated &&
                     this.bundleHasAsset(b, asset),
                 )
               ) {
@@ -1486,14 +1861,42 @@ export default class BundleGraph {
   }
 
   /**
-   * TODO: Document why this works like this & why visitor order matters
-   * on these use-cases.
+   * 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<TContext>(
     bundle: Bundle,
     visit: GraphVisitor<AssetNode | DependencyNode, TContext>,
     startAsset?: Asset,
-  ): ?TContext {
+  ): TContext | null | undefined {
     let entries = !startAsset;
     let bundleNodeId = this._graph.getNodeIdByContentKey(bundle.id);
 
@@ -1531,7 +1934,8 @@ export default class BundleGraph {
 
         let sorted =
           entries && bundle.entryAssetIds.length > 0
-            ? children.sort(([, a], [, b]) => {
+            ? // @ts-expect-error TS2345
+              children.sort(([, a]: [any, any], [, b]: [any, any]) => {
                 let aIndex = bundle.entryAssetIds.indexOf(a.id);
                 let bIndex = bundle.entryAssetIds.indexOf(b.id);
 
@@ -1550,7 +1954,8 @@ export default class BundleGraph {
             : children;
 
         entries = false;
-        return sorted.map(([id]) => id);
+        // @ts-expect-error TS2345
+        return sorted.map(([id]: [any]) => id);
       },
     });
   }
@@ -1558,7 +1963,7 @@ export default class BundleGraph {
   traverse<TContext>(
     visit: GraphVisitor<AssetNode | DependencyNode, TContext>,
     start?: Asset,
-  ): ?TContext {
+  ): TContext | null | undefined {
     return this._graph.filteredTraverse(
       (nodeId) => {
         let node = nullthrows(this._graph.getNode(nodeId));
@@ -1574,7 +1979,7 @@ export default class BundleGraph {
 
   getChildBundles(bundle: Bundle): Array<Bundle> {
     let siblings = new Set(this.getReferencedBundles(bundle));
-    let bundles = [];
+    let bundles: Array<Bundle> = [];
     this.traverseBundles((b, _, actions) => {
       if (bundle.id === b.id) {
         return;
@@ -1591,8 +1996,8 @@ export default class BundleGraph {
 
   traverseBundles<TContext>(
     visit: GraphVisitor<Bundle, TContext>,
-    startBundle: ?Bundle,
-  ): ?TContext {
+    startBundle?: Bundle | null,
+  ): TContext | null | undefined {
     return this._graph.filteredTraverse(
       (nodeId) => {
         let node = nullthrows(this._graph.getNode(nodeId));
@@ -1604,12 +2009,13 @@ export default class BundleGraph {
     );
   }
 
-  getBundles(opts?: {|includeInline: boolean|}): Array<Bundle> {
-    let bundles = [];
+  getBundles(opts?: {includeInline: boolean}): Array<Bundle> {
+    let bundles: Array<Bundle> = [];
     this.traverseBundles((bundle) => {
       if (
         opts?.includeInline ||
-        bundle.bundleBehavior !== BundleBehavior.inline
+        (bundle.bundleBehavior !== BundleBehavior.inline &&
+          bundle.bundleBehavior !== BundleBehavior.inlineIsolated)
       ) {
         bundles.push(bundle);
       }
@@ -1679,7 +2085,9 @@ export default class BundleGraph {
 
   getBundlesInBundleGroup(
     bundleGroup: BundleGroup,
-    opts?: {|includeInline: boolean|},
+    opts?: {
+      includeInline: boolean;
+    },
   ): Array<Bundle> {
     let bundles: Set<Bundle> = new Set();
     for (let bundleNodeId of this._graph.getNodeIdsConnectedFrom(
@@ -1691,7 +2099,8 @@ export default class BundleGraph {
       let bundle = bundleNode.value;
       if (
         opts?.includeInline ||
-        bundle.bundleBehavior !== BundleBehavior.inline
+        (bundle.bundleBehavior !== BundleBehavior.inline &&
+          bundle.bundleBehavior !== BundleBehavior.inlineIsolated)
       ) {
         bundles.add(bundle);
       }
@@ -1708,7 +2117,10 @@ export default class BundleGraph {
 
   getReferencedBundles(
     bundle: Bundle,
-    opts?: {|recursive?: boolean, includeInline?: boolean|},
+    opts?: {
+      recursive?: boolean;
+      includeInline?: boolean;
+    },
   ): Array<Bundle> {
     let recursive = opts?.recursive ?? true;
     let includeInline = opts?.includeInline ?? false;
@@ -1726,7 +2138,8 @@ export default class BundleGraph {
 
         if (
           includeInline ||
-          node.value.bundleBehavior !== BundleBehavior.inline
+          (node.value.bundleBehavior !== BundleBehavior.inline &&
+            node.value.bundleBehavior !== BundleBehavior.inlineIsolated)
         ) {
           referencedBundles.add(node.value);
         }
@@ -1746,6 +2159,7 @@ export default class BundleGraph {
         ),
     });
 
+    // @ts-expect-error TS2322
     return [...referencedBundles];
   }
 
@@ -1768,7 +2182,7 @@ export default class BundleGraph {
       });
   }
 
-  getAssetWithDependency(dep: Dependency): ?Asset {
+  getAssetWithDependency(dep: Dependency): Asset | null | undefined {
     if (!this._graph.hasContentKey(dep.id)) {
       return null;
     }
@@ -1777,6 +2191,7 @@ export default class BundleGraph {
     let count = 0;
     this._graph.forEachNodeIdConnectedTo(
       this._graph.getNodeIdByContentKey(dep.id),
+      // @ts-expect-error TS2345
       (node) => {
         res = node;
         count += 1;
@@ -1817,16 +2232,16 @@ export default class BundleGraph {
 
   filteredTraverse<TValue, TContext>(
     bundleNodeId: NodeId,
-    filter: (NodeId, TraversalActions) => ?TValue,
+    filter: (arg1: NodeId, arg2: TraversalActions) => TValue | null | undefined,
     visit: GraphVisitor<TValue, TContext>,
-  ): ?TContext {
+  ): TContext | null | undefined {
     return this._graph.filteredTraverse(filter, visit, bundleNodeId);
   }
 
   getSymbolResolution(
     asset: Asset,
     symbol: Symbol,
-    boundary: ?Bundle,
+    boundary?: Bundle | null,
   ): InternalSymbolResolution {
     let assetOutside = boundary && !this.bundleHasAsset(boundary, asset);
 
@@ -1853,7 +2268,7 @@ export default class BundleGraph {
       }
       // If this is a re-export, find the original module.
       let symbolLookup = new Map(
-        [...depSymbols].map(([key, val]) => [val.local, key]),
+        [...depSymbols].map(([key, val]: [any, any]) => [val.local, key]),
       );
       let depSymbol = symbolLookup.get(identifier);
       if (depSymbol != null) {
@@ -1904,7 +2319,7 @@ export default class BundleGraph {
       // Wildcard reexports are never listed in the reexporting asset's symbols.
       if (
         identifier == null &&
-        depSymbols.get('*')?.local === '*' &&
+        (depSymbols.get('*')?.local === '*' || dep.meta?.hasExportStar) &&
         symbol !== 'default'
       ) {
         let resolved = this.getResolvedAsset(dep, boundary);
@@ -1971,17 +2386,20 @@ export default class BundleGraph {
       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).
@@ -2019,13 +2437,13 @@ export default class BundleGraph {
 
   getExportedSymbols(
     asset: Asset,
-    boundary: ?Bundle,
+    boundary?: Bundle | null,
   ): Array<InternalExportSymbolResolution> {
     if (!asset.symbols) {
       return [];
     }
 
-    let symbols = [];
+    let symbols: Array<InternalExportSymbolResolution> = [];
 
     for (let symbol of asset.symbols.keys()) {
       symbols.push({
@@ -2039,7 +2457,7 @@ export default class BundleGraph {
       let depSymbols = dep.symbols;
       if (!depSymbols) continue;
 
-      if (depSymbols.get('*')?.local === '*') {
+      if (depSymbols.get('*')?.local === '*' || dep.meta?.hasExportStar) {
         let resolved = this.getResolvedAsset(dep, boundary);
         if (!resolved) continue;
         let exported = this.getExportedSymbols(resolved, boundary)
@@ -2076,9 +2494,9 @@ export default class BundleGraph {
   }
 
   getInlineBundles(bundle: Bundle): Array<Bundle> {
-    let bundles = [];
+    let bundles: Array<Bundle> = [];
     let seen = new Set();
-    let addReferencedBundles = (bundle) => {
+    let addReferencedBundles = (bundle: Bundle) => {
       if (seen.has(bundle.id)) {
         return;
       }
@@ -2089,7 +2507,10 @@ export default class BundleGraph {
         includeInline: true,
       });
       for (let referenced of referencedBundles) {
-        if (referenced.bundleBehavior === BundleBehavior.inline) {
+        if (
+          referenced.bundleBehavior === BundleBehavior.inline ||
+          referenced.bundleBehavior === BundleBehavior.inlineIsolated
+        ) {
           bundles.push(referenced);
           addReferencedBundles(referenced);
         }
@@ -2099,7 +2520,10 @@ export default class BundleGraph {
     addReferencedBundles(bundle);
 
     this.traverseBundles((childBundle, _, traversal) => {
-      if (childBundle.bundleBehavior === BundleBehavior.inline) {
+      if (
+        childBundle.bundleBehavior === BundleBehavior.inline ||
+        childBundle.bundleBehavior === BundleBehavior.inlineIsolated
+      ) {
         bundles.push(childBundle);
       } else if (childBundle.id !== bundle.id) {
         traversal.skipChildren();
@@ -2128,7 +2552,9 @@ export default class BundleGraph {
       hash.writeString(referencedBundle.id);
     }
 
-    hash.writeString(JSON.stringify(objectSortedEntriesDeep(bundle.env)));
+    hash.writeString(
+      JSON.stringify(objectSortedEntriesDeep(fromEnvironmentId(bundle.env))),
+    );
     return hash.finish();
   }
 
@@ -2172,7 +2598,7 @@ export default class BundleGraph {
     }
   }
 
-  getUsedSymbolsAsset(asset: Asset): ?$ReadOnlySet<Symbol> {
+  getUsedSymbolsAsset(asset: Asset): ReadonlySet<Symbol> | null | undefined {
     let node = this._graph.getNodeByContentKey(asset.id);
     invariant(node && node.type === 'asset');
     return node.value.symbols
@@ -2180,7 +2606,9 @@ export default class BundleGraph {
       : null;
   }
 
-  getUsedSymbolsDependency(dep: Dependency): ?$ReadOnlySet<Symbol> {
+  getUsedSymbolsDependency(
+    dep: Dependency,
+  ): ReadonlySet<Symbol> | null | undefined {
     let node = this._graph.getNodeByContentKey(dep.id);
     invariant(node && node.type === 'dependency');
     return node.value.symbols
@@ -2228,6 +2656,7 @@ export default class BundleGraph {
       }
     }
 
+    // @ts-expect-error TS2488
     for (let edge of other._graph.getAllEdges()) {
       this._graph.addEdge(
         nullthrows(otherGraphIdToThisNodeId.get(edge.from)),
@@ -2272,7 +2701,7 @@ export default class BundleGraph {
       bundleGraphEdgeTypes.bundle,
     );
 
-    let entries = [];
+    let entries: Array<FilePath> = [];
     for (let bundleGroupId of entryBundleGroupIds) {
       let bundleGroupNode = this._graph.getNode(bundleGroupId);
       invariant(bundleGroupNode?.type === 'bundle_group');
@@ -2312,6 +2741,7 @@ export default class BundleGraph {
         ),
     });
 
+    // @ts-expect-error TS2322
     return [...referencedBundles];
   }
 }