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

package/lib/BundleGraph.js

@@ -51,7 +51,15 @@ function _featureFlags() {
   };
   return data;
 }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+var _EnvironmentManager = require("./EnvironmentManager");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const bundleGraphEdgeTypes = 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.
@@ -77,7 +85,7 @@ const bundleGraphEdgeTypes = exports.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
 };
 function makeReadOnlySet(set) {
   return new Proxy(set, {
@@ -85,7 +93,7 @@ function makeReadOnlySet(set) {
       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;
       }
@@ -167,7 +175,7 @@ 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
+        // @ts-expect-error TS2322
         const placeholder = (_dep$meta = dep.meta) === null || _dep$meta === void 0 ? void 0 : _dep$meta.placeholder;
         if (placeholder != null) {
           placeholderToDependency.set(placeholder, dep);
@@ -182,7 +190,6 @@ class BundleGraph {
       if ((0, _featureFlags().getFeatureFlag)('conditionalBundlingApi') && node.type === 'asset') {
         const asset = node.value;
         if (Array.isArray(asset.meta.conditions)) {
-          // $FlowFixMe
           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.
@@ -207,7 +214,7 @@ class BundleGraph {
           }
         }
       }
-      if (node.type === 'dependency' && node.value.symbols != null && node.value.env.shouldScopeHoist &&
+      if (node.type === 'dependency' && node.value.symbols != null && (0, _EnvironmentManager.fromEnvironmentId)(node.value.env).shouldScopeHoist &&
       // Disable in dev mode because this feature is at odds with safeToIncrementallyBundle
       isProduction) {
         let nodeValueSymbols = node.value.symbols;
@@ -250,8 +257,8 @@ 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)) {
-          var _nodeValueSymbols$get;
-          let isReexportAll = ((_nodeValueSymbols$get = nodeValueSymbols.get('*')) === null || _nodeValueSymbols$get === void 0 ? void 0 : _nodeValueSymbols$get.local) === '*';
+          var _nodeValueSymbols$get, _node$value$meta;
+          let isReexportAll = ((_nodeValueSymbols$get = nodeValueSymbols.get('*')) === null || _nodeValueSymbols$get === void 0 ? void 0 : _nodeValueSymbols$get.local) === '*' || ((_node$value$meta = node.value.meta) === null || _node$value$meta === void 0 ? void 0 : _node$value$meta.hasExportStar);
           let reexportAllLoc = isReexportAll ? (0, _nullthrows().default)(nodeValueSymbols.get('*')).loc : undefined;
 
           // TODO adjust sourceAssetIdNode.value.dependencies ?
@@ -263,9 +270,13 @@ class BundleGraph {
               ...node,
               value: {
                 ...node.value,
-                symbols: new Map([...nodeValueSymbols].filter(([k]) => externalSymbols.has(k)))
+                symbols: new Map(
+                // @ts-expect-error TS2769
+                [...nodeValueSymbols].filter(([k]) => externalSymbols.has(k)))
               },
-              usedSymbolsUp: new Map([...node.usedSymbolsUp].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
             })
@@ -294,8 +305,13 @@ class BundleGraph {
                     loc: reexportAllLoc
                   });
                   if (node.value.sourceAssetId != null) {
-                    let sourceAssetId = (0, _nullthrows().default)(assetGraphNodeIdToBundleGraphNodeId.get(assetGraph.getNodeIdByContentKey(node.value.sourceAssetId)));
-                    let sourceAsset = (0, _nullthrows().default)(graph.getNode(sourceAssetId));
+                    let sourceAssetId;
+                    if ((0, _featureFlags().getFeatureFlag)('sourceAssetIdBundleGraphFix')) {
+                      [sourceAssetId] = assetGraph.getNodeIdsConnectedTo(nodeId);
+                    } else {
+                      sourceAssetId = assetGraph.getNodeIdByContentKey(node.value.sourceAssetId);
+                    }
+                    let sourceAsset = (0, _nullthrows().default)(graph.getNode((0, _nullthrows().default)(assetGraphNodeIdToBundleGraphNodeId.get(sourceAssetId))));
                     (0, _assert().default)(sourceAsset.type === 'asset');
                     let sourceAssetSymbols = sourceAsset.value.symbols;
                     if (sourceAssetSymbols) {
@@ -312,7 +328,9 @@ class BundleGraph {
                 }
               }
             }
-            let usedSymbolsUp = new Map([...node.usedSymbolsUp].filter(([k]) => target.has(k) || k === '*').map(([k, v]) => [target.get(k) ?? k, v]));
+            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, {
@@ -363,6 +381,8 @@ class BundleGraph {
       }
     }
     walk((0, _nullthrows().default)(assetGraph.rootNodeId));
+
+    // @ts-expect-error TS2488
     for (let edge of assetGraph.getAllEdges()) {
       var _dependencies$get, _assetGroupIds$get;
       if (assetGroupIds.has(edge.from)) {
@@ -415,12 +435,163 @@ class BundleGraph {
       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.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 => {
+      var _node$value, _node$value2, _node$value3;
+      const processedNode = {
+        ...node
+      };
+      if (node.type === 'asset' && (_node$value = node.value) !== null && _node$value !== void 0 && _node$value.env) {
+        processedNode.value = {
+          ...node.value,
+          env: extractEnvironment(node.value.env)
+        };
+      } else if (node.type === 'dependency' && (_node$value2 = node.value) !== null && _node$value2 !== void 0 && _node$value2.env) {
+        processedNode.value = {
+          ...node.value,
+          env: extractEnvironment(node.value.env)
+        };
+      } else if (node.type === 'bundle' && (_node$value3 = node.value) !== null && _node$value3 !== void 0 && _node$value3.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().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) {
+      var _node$value4;
+      const node = this._graph.getNodeByContentKey(assetId);
+      if ((node === null || node === void 0 ? void 0 : node.type) !== 'asset') {
+        continue;
+      }
+      const processedNode = {
+        ...node
+      };
+      if ((_node$value4 = node.value) !== null && _node$value4 !== void 0 && _node$value4.env) {
+        processedNode.value = {
+          ...node.value,
+          env: (0, _EnvironmentManager.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().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().hashString)('bundle:' + (opts.entryAsset ? opts.entryAsset.id : opts.uniqueKey) + (0, _projectPath.fromProjectPathRelative)(target.distDir) + (opts.bundleBehavior ?? ''));
+    let bundleId = (0, _rust().hashString)('bundle:' + (
+    // @ts-expect-error TS2339
+    opts.entryAsset ? opts.entryAsset.id : opts.uniqueKey) + (0, _projectPath.fromProjectPathRelative)(target.distDir) + (opts.bundleBehavior ?? ''));
     let existing = this._graph.getNodeByContentKey(bundleId);
     if (existing != null) {
       (0, _assert().default)(existing.type === 'bundle');
@@ -440,14 +611,21 @@ class BundleGraph {
       value: {
         id: bundleId,
         hashReference: opts.shouldContentHash ? _constants.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 === null || entryAsset === void 0 ? void 0 : entryAsset.id,
+        // @ts-expect-error TS2339
         pipeline: opts.entryAsset ? opts.entryAsset.pipeline : opts.pipeline,
         needsStableName: opts.needsStableName,
         bundleBehavior: opts.bundleBehavior != null ? _types.BundleBehavior[opts.bundleBehavior] : null,
-        isSplittable: opts.entryAsset ? opts.entryAsset.isBundleSplittable : opts.isSplittable,
+        // @ts-expect-error TS2339
+        isSplittable: opts.entryAsset ?
+        // @ts-expect-error TS2339
+        opts.entryAsset.isBundleSplittable :
+        // @ts-expect-error TS2339
+        opts.isSplittable,
         isPlaceholder,
         target,
         name: null,
@@ -456,8 +634,12 @@ class BundleGraph {
       }
     };
     let bundleNodeId = this._graph.addNodeByContentKey(bundleId, bundleNode);
+
+    // @ts-expect-error TS2339
     if (opts.entryAsset) {
-      this._graph.addEdge(bundleNodeId, this._graph.getNodeIdByContentKey(opts.entryAsset.id));
+      this._graph.addEdge(bundleNodeId,
+      // @ts-expect-error TS2339
+      this._graph.getNodeIdByContentKey(opts.entryAsset.id));
     }
     _assert().default;
     return bundleNode.value;
@@ -470,9 +652,14 @@ class BundleGraph {
     for (let dependency of dependencies) {
       let dependencyNodeId = this._graph.getNodeIdByContentKey(dependency.id);
       this._graph.addEdge(bundleNodeId, dependencyNodeId, bundleGraphEdgeTypes.contains);
-      for (let [bundleGroupNodeId, bundleGroupNode] of this._graph.getNodeIdsConnectedFrom(dependencyNodeId).map(id => [id, (0, _nullthrows().default)(this._graph.getNode(id))]).filter(([, node]) => node.type === 'bundle_group')) {
+      for (let [bundleGroupNodeId, bundleGroupNode] of this._graph.getNodeIdsConnectedFrom(dependencyNodeId).map(id => [id, (0, _nullthrows().default)(this._graph.getNode(id))])
+      // @ts-expect-error TS2769
+      .filter(([, node]) => node.type === 'bundle_group')) {
+        // @ts-expect-error TS2339
         (0, _assert().default)(bundleGroupNode.type === 'bundle_group');
-        this._graph.addEdge(bundleNodeId, bundleGroupNodeId, bundleGraphEdgeTypes.bundle);
+        this._graph.addEdge(bundleNodeId,
+        // @ts-expect-error TS2345
+        bundleGroupNodeId, bundleGraphEdgeTypes.bundle);
       }
       // If the dependency references a target bundle, add a reference edge from
       // the source bundle to the dependency for easy traversal.
@@ -503,9 +690,14 @@ class BundleGraph {
         this._graph.addEdge(bundleNodeId, nodeId, bundleGraphEdgeTypes.contains);
       }
       if (node.type === 'dependency') {
-        for (let [bundleGroupNodeId, bundleGroupNode] of this._graph.getNodeIdsConnectedFrom(nodeId).map(id => [id, (0, _nullthrows().default)(this._graph.getNode(id))]).filter(([, node]) => node.type === 'bundle_group')) {
+        for (let [bundleGroupNodeId, bundleGroupNode] of this._graph.getNodeIdsConnectedFrom(nodeId).map(id => [id, (0, _nullthrows().default)(this._graph.getNode(id))])
+        // @ts-expect-error TS2769
+        .filter(([, node]) => node.type === 'bundle_group')) {
+          // @ts-expect-error TS2339
           (0, _assert().default)(bundleGroupNode.type === 'bundle_group');
-          this._graph.addEdge(bundleNodeId, bundleGroupNodeId, bundleGraphEdgeTypes.bundle);
+          this._graph.addEdge(bundleNodeId,
+          // @ts-expect-error TS2345
+          bundleGroupNodeId, bundleGraphEdgeTypes.bundle);
         }
 
         // If the dependency references a target bundle, add a reference edge from
@@ -616,8 +808,12 @@ 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 ((0, _featureFlags().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;
+        }
       });
     }
   }
@@ -805,6 +1001,7 @@ class BundleGraph {
         }
       }, this._graph.getNodeIdByContentKey(dep.id), bundleGraphEdgeTypes.references);
       if (bundle) {
+        // @ts-expect-error TS2322
         resolved = potential.find(a => a.type === bundle.type);
       }
       resolved ||= potential[0];
@@ -859,18 +1056,126 @@ class BundleGraph {
           return;
         }
         visitedBundles.add(descendant);
-        if (descendant.type !== bundle.type || descendant.env.context !== bundle.env.context) {
+        if (descendant.type !== bundle.type || (0, _EnvironmentManager.fromEnvironmentId)(descendant.env).context !== (0, _EnvironmentManager.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().default)(this._graph.getNodeIdByContentKey(asset.id));
+    if (this._graph.getNodeIdsConnectedTo(assetNodeId, bundleGraphEdgeTypes.references).map(id => this._graph.getNode(id)).some(node => (node === null || node === void 0 ? void 0 : node.type) === 'dependency' && (node.value.priority === _types.Priority.lazy || node.value.priority === _types.Priority.conditional) && node.value.specifierType !== _types.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().default)(this._graph.getNodeIdByContentKey(asset.id))).map(id => (0, _nullthrows().default)(this._graph.getNode(id))).filter(node => node.type === 'dependency').map(node => {
+        (0, _assert().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.fromEnvironmentId)(descendant.env).context !== (0, _EnvironmentManager.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);
@@ -887,7 +1192,7 @@ class BundleGraph {
   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.ISOLATED_ENVS.has(bundle.env.context) || !bundle.isSplittable || bundle.bundleBehavior === _types.BundleBehavior.isolated || bundle.bundleBehavior === _types.BundleBehavior.inline) {
+    if (_Environment.ISOLATED_ENVS.has((0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context) || !bundle.isSplittable || bundle.bundleBehavior === _types.BundleBehavior.isolated || bundle.bundleBehavior === _types.BundleBehavior.inline || bundle.bundleBehavior === _types.BundleBehavior.inlineIsolated) {
       return false;
     }
 
@@ -897,7 +1202,7 @@ class BundleGraph {
     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.BundleBehavior.isolated && b.bundleBehavior !== _types.BundleBehavior.inline && this.bundleHasAsset(b, asset))) {
+      if (bundles.some(b => b.id !== bundle.id && b.bundleBehavior !== _types.BundleBehavior.isolated && b.bundleBehavior !== _types.BundleBehavior.inline && b.bundleBehavior !== _types.BundleBehavior.inlineIsolated && this.bundleHasAsset(b, asset))) {
         return true;
       }
 
@@ -907,7 +1212,7 @@ class BundleGraph {
       // Check that every parent bundle has a bundle group in its ancestry that contains the asset.
       return parentBundleNodes.every(bundleNodeId => {
         let bundleNode = (0, _nullthrows().default)(this._graph.getNode(bundleNodeId));
-        if (bundleNode.type !== 'bundle' || bundleNode.value.bundleBehavior === _types.BundleBehavior.isolated || bundleNode.value.bundleBehavior === _types.BundleBehavior.inline) {
+        if (bundleNode.type !== 'bundle' || bundleNode.value.bundleBehavior === _types.BundleBehavior.isolated || bundleNode.value.bundleBehavior === _types.BundleBehavior.inline || bundleNode.value.bundleBehavior === _types.BundleBehavior.inlineIsolated) {
           return false;
         }
         let isReachable = true;
@@ -915,15 +1220,16 @@ class BundleGraph {
           let node = (0, _nullthrows().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 || node.value.env.context !== bundle.env.context)) {
+          if (node.type === 'root' || node.type === 'bundle' && (node.value.id === bundle.id || (0, _EnvironmentManager.fromEnvironmentId)(node.value.env).context !== (0, _EnvironmentManager.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.BundleBehavior.isolated && b.bundleBehavior !== _types.BundleBehavior.inline && this.bundleHasAsset(b, asset))) {
+            if (childBundles.some(b => b.id !== bundle.id && b.bundleBehavior !== _types.BundleBehavior.isolated && b.bundleBehavior !== _types.BundleBehavior.inline && b.bundleBehavior !== _types.BundleBehavior.inlineIsolated && this.bundleHasAsset(b, asset))) {
               actions.skipChildren();
+              return;
             }
           }
         }, [bundleGraphEdgeTypes.references, bundleGraphEdgeTypes.bundle]);
@@ -933,8 +1239,36 @@ 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(bundle, visit, startAsset) {
     let entries = !startAsset;
@@ -958,7 +1292,9 @@ class BundleGraph {
       startNodeId: startAsset ? this._graph.getNodeIdByContentKey(startAsset.id) : bundleNodeId,
       getChildren: nodeId => {
         let children = this._graph.getNodeIdsConnectedFrom(nodeId).map(id => [id, (0, _nullthrows().default)(this._graph.getNode(id))]);
-        let sorted = entries && bundle.entryAssetIds.length > 0 ? children.sort(([, a], [, b]) => {
+        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) {
@@ -973,6 +1309,7 @@ class BundleGraph {
           return aIndex - bIndex;
         }) : children;
         entries = false;
+        // @ts-expect-error TS2345
         return sorted.map(([id]) => id);
       }
     });
@@ -1010,7 +1347,7 @@ class BundleGraph {
   getBundles(opts) {
     let bundles = [];
     this.traverseBundles(bundle => {
-      if (opts !== null && opts !== void 0 && opts.includeInline || bundle.bundleBehavior !== _types.BundleBehavior.inline) {
+      if (opts !== null && opts !== void 0 && opts.includeInline || bundle.bundleBehavior !== _types.BundleBehavior.inline && bundle.bundleBehavior !== _types.BundleBehavior.inlineIsolated) {
         bundles.push(bundle);
       }
     });
@@ -1061,7 +1398,7 @@ class BundleGraph {
       let bundleNode = (0, _nullthrows().default)(this._graph.getNode(bundleNodeId));
       (0, _assert().default)(bundleNode.type === 'bundle');
       let bundle = bundleNode.value;
-      if (opts !== null && opts !== void 0 && opts.includeInline || bundle.bundleBehavior !== _types.BundleBehavior.inline) {
+      if (opts !== null && opts !== void 0 && opts.includeInline || bundle.bundleBehavior !== _types.BundleBehavior.inline && bundle.bundleBehavior !== _types.BundleBehavior.inlineIsolated) {
         bundles.add(bundle);
       }
       for (let referencedBundle of this.getReferencedBundles(bundle, {
@@ -1085,7 +1422,7 @@ class BundleGraph {
         if (node.value.id === bundle.id) {
           return;
         }
-        if (includeInline || node.value.bundleBehavior !== _types.BundleBehavior.inline) {
+        if (includeInline || node.value.bundleBehavior !== _types.BundleBehavior.inline && node.value.bundleBehavior !== _types.BundleBehavior.inlineIsolated) {
           referencedBundles.add(node.value);
         }
         if (!recursive) {
@@ -1099,6 +1436,8 @@ class BundleGraph {
       // TODO: Should this be the case?
       this._graph.getNodeIdsConnectedFrom(nodeId, bundleGraphEdgeTypes.references)
     });
+
+    // @ts-expect-error TS2322
     return [...referencedBundles];
   }
   getIncomingDependencies(asset) {
@@ -1118,7 +1457,9 @@ class BundleGraph {
     }
     let res = null;
     let count = 0;
-    this._graph.forEachNodeIdConnectedTo(this._graph.getNodeIdByContentKey(dep.id), node => {
+    this._graph.forEachNodeIdConnectedTo(this._graph.getNodeIdByContentKey(dep.id),
+    // @ts-expect-error TS2345
+    node => {
       res = node;
       count += 1;
       if (count > 1) {
@@ -1162,7 +1503,7 @@ class BundleGraph {
     let deps = this.getDependencies(asset).reverse();
     let potentialResults = [];
     for (let dep of deps) {
-      var _depSymbols$get;
+      var _depSymbols$get, _dep$meta2;
       let depSymbols = dep.symbols;
       if (!depSymbols) {
         nonStaticDependency = true;
@@ -1214,7 +1555,7 @@ class BundleGraph {
       // 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 = depSymbols.get('*')) === null || _depSymbols$get === void 0 ? void 0 : _depSymbols$get.local) === '*' && symbol !== 'default') {
+      if (identifier == null && (((_depSymbols$get = depSymbols.get('*')) === null || _depSymbols$get === void 0 ? void 0 : _depSymbols$get.local) === '*' || (_dep$meta2 = dep.meta) !== null && _dep$meta2 !== void 0 && _dep$meta2.hasExportStar) && symbol !== 'default') {
         let resolved = this.getResolvedAsset(dep, boundary);
         if (!resolved) {
           continue;
@@ -1282,11 +1623,13 @@ 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) {
           var _asset$symbols5;
@@ -1294,13 +1637,13 @@ class BundleGraph {
           if (nonStaticDependency || (_asset$symbols5 = asset.symbols) !== null && _asset$symbols5 !== void 0 && _asset$symbols5.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,
@@ -1338,10 +1681,10 @@ class BundleGraph {
     }
     let deps = this.getDependencies(asset);
     for (let dep of deps) {
-      var _depSymbols$get2;
+      var _depSymbols$get2, _dep$meta3;
       let depSymbols = dep.symbols;
       if (!depSymbols) continue;
-      if (((_depSymbols$get2 = depSymbols.get('*')) === null || _depSymbols$get2 === void 0 ? void 0 : _depSymbols$get2.local) === '*') {
+      if (((_depSymbols$get2 = depSymbols.get('*')) === null || _depSymbols$get2 === void 0 ? void 0 : _depSymbols$get2.local) === '*' || (_dep$meta3 = dep.meta) !== null && _dep$meta3 !== void 0 && _dep$meta3.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 !== '*' ? {
@@ -1381,7 +1724,7 @@ class BundleGraph {
         includeInline: true
       });
       for (let referenced of referencedBundles) {
-        if (referenced.bundleBehavior === _types.BundleBehavior.inline) {
+        if (referenced.bundleBehavior === _types.BundleBehavior.inline || referenced.bundleBehavior === _types.BundleBehavior.inlineIsolated) {
           bundles.push(referenced);
           addReferencedBundles(referenced);
         }
@@ -1389,7 +1732,7 @@ class BundleGraph {
     };
     addReferencedBundles(bundle);
     this.traverseBundles((childBundle, _, traversal) => {
-      if (childBundle.bundleBehavior === _types.BundleBehavior.inline) {
+      if (childBundle.bundleBehavior === _types.BundleBehavior.inline || childBundle.bundleBehavior === _types.BundleBehavior.inlineIsolated) {
         bundles.push(childBundle);
       } else if (childBundle.id !== bundle.id) {
         traversal.skipChildren();
@@ -1410,7 +1753,7 @@ class BundleGraph {
     for (let referencedBundle of this.getReferencedBundles(bundle)) {
       hash.writeString(referencedBundle.id);
     }
-    hash.writeString(JSON.stringify((0, _utils().objectSortedEntriesDeep)(bundle.env)));
+    hash.writeString(JSON.stringify((0, _utils().objectSortedEntriesDeep)((0, _EnvironmentManager.fromEnvironmentId)(bundle.env))));
     return hash.finish();
   }
   getBundleGraphHash() {
@@ -1469,6 +1812,8 @@ class BundleGraph {
         otherGraphIdToThisNodeId.set(otherNodeId, updateNodeId);
       }
     }
+
+    // @ts-expect-error TS2488
     for (let edge of other._graph.getAllEdges()) {
       this._graph.addEdge((0, _nullthrows().default)(otherGraphIdToThisNodeId.get(edge.from)), (0, _nullthrows().default)(otherGraphIdToThisNodeId.get(edge.to)), edge.type);
     }
@@ -1521,6 +1866,8 @@ class BundleGraph {
       startNodeId: this._graph.getNodeIdByContentKey(bundle.id),
       getChildren: nodeId => this._graph.getNodeIdsConnectedFrom(nodeId, bundleGraphEdgeTypes.conditional)
     });
+
+    // @ts-expect-error TS2322
     return [...referencedBundles];
   }
 }