@atlaspack/core 2.16.2-canary.37 → 2.16.2-canary.371

package/lib/BundleGraph.js

@@ -51,6 +51,7 @@ function _featureFlags() {
   };
   return data;
 }
+var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const bundleGraphEdgeTypes = exports.bundleGraphEdgeTypes = {
   // A lack of an edge type indicates to follow the edge while traversing
@@ -85,7 +86,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 +168,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 +183,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 +207,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;
@@ -263,9 +263,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 +298,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 +321,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 +374,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)) {
@@ -416,11 +429,14 @@ class BundleGraph {
     });
   }
   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 +456,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 +479,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 +497,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 +535,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 +653,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 +846,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 +901,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 +1037,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 +1047,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 +1057,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 +1065,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]);
@@ -958,7 +1109,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 +1126,7 @@ class BundleGraph {
           return aIndex - bIndex;
         }) : children;
         entries = false;
+        // @ts-expect-error TS2345
         return sorted.map(([id]) => id);
       }
     });
@@ -1010,7 +1164,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 +1215,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 +1239,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 +1253,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 +1274,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) {
@@ -1282,11 +1440,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,6 +1454,7 @@ 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).
@@ -1381,7 +1542,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 +1550,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 +1571,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 +1630,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 +1684,8 @@ class BundleGraph {
       startNodeId: this._graph.getNodeIdByContentKey(bundle.id),
       getChildren: nodeId => this._graph.getNodeIdsConnectedFrom(nodeId, bundleGraphEdgeTypes.conditional)
     });
+
+    // @ts-expect-error TS2322
     return [...referencedBundles];
   }
 }

package/lib/CommittedAsset.js

@@ -26,7 +26,7 @@ function _utils() {
   return data;
 }
 function _sourceMap() {
-  const data = _interopRequireDefault(require("@parcel/source-map"));
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
   _sourceMap = function () {
     return data;
   };
@@ -74,6 +74,7 @@ class CommittedAsset {
     if (typeof content === 'string' || content instanceof Buffer) {
       return content.toString();
     } else if (content != null) {
+      // @ts-expect-error TS2345
       this.content = (0, _utils().bufferStream)(content);
       return (await this.content).toString();
     }
@@ -86,7 +87,10 @@ class CommittedAsset {
     } else if (typeof content === 'string' || content instanceof Buffer) {
       return Buffer.from(content);
     }
+
+    // @ts-expect-error TS2345
     this.content = (0, _utils().bufferStream)(content);
+    // @ts-expect-error TS2322
     return this.content;
   }
   getStream() {
@@ -125,6 +129,8 @@ class CommittedAsset {
         }
       })();
     }
+
+    // @ts-expect-error TS2322
     return this.mapBuffer ?? Promise.resolve();
   }
   getMap() {

package/lib/Dependency.js

@@ -24,6 +24,7 @@ function _assert() {
   return data;
 }
 var _IdentifierRegistry = require("./IdentifierRegistry");
+var _EnvironmentManager = require("./EnvironmentManager");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createDependencyId({
   sourceAssetId,
@@ -41,8 +42,11 @@ function createDependencyId({
   const params = {
     sourceAssetId,
     specifier,
-    environmentId: env.id,
-    target,
+    environmentId: (0, _EnvironmentManager.toEnvironmentId)(env),
+    target: target != null ? {
+      ...target,
+      env: (0, _EnvironmentManager.fromEnvironmentId)(target.env)
+    } : null,
     pipeline,
     specifierType: _types.SpecifierType[specifierType],
     bundleBehavior,
@@ -121,7 +125,9 @@ function convertConditions(conditions, dep) {
   let packageConditions = 0;
   let customConditions = [];
   for (let condition of conditions) {
+    // @ts-expect-error TS7053
     if (_types.ExportsCondition[condition]) {
+      // @ts-expect-error TS7053
       packageConditions |= _types.ExportsCondition[condition];
     } else {
       customConditions.push(condition);

package/lib/Environment.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createEnvironment = createEnvironment;
+exports.getEnvironmentHash = getEnvironmentHash;
 exports.mergeEnvironments = mergeEnvironments;
 function _rust() {
   const data = require("@atlaspack/rust");
@@ -15,6 +16,7 @@ function _rust() {
 var _utils = require("./utils");
 var _Environment = _interopRequireWildcard(require("./public/Environment"));
 var _IdentifierRegistry = require("./IdentifierRegistry");
+var _EnvironmentManager = require("./EnvironmentManager");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 const DEFAULT_ENGINES = {
@@ -32,7 +34,8 @@ function createEnvironment({
   shouldScopeHoist = false,
   sourceMap,
   unstableSingleFileOutput = false,
-  loc
+  loc,
+  customEnv
 } = {
   /*::...null*/
 }) {
@@ -57,8 +60,10 @@ function createEnvironment({
       case 'browser':
       case 'web-worker':
       case 'service-worker':
+      case 'tesseract':
       case 'electron-renderer':
         engines = {
+          // @ts-expect-error TS2322
           browsers: DEFAULT_ENGINES.browsers
         };
         break;
@@ -76,6 +81,7 @@ function createEnvironment({
       case 'browser':
       case 'web-worker':
       case 'service-worker':
+      case 'tesseract':
       default:
         includeNodeModules = true;
         break;
@@ -96,6 +102,7 @@ function createEnvironment({
   let res = {
     id: '',
     context,
+    // @ts-expect-error TS2322
     engines,
     includeNodeModules,
     outputFormat,
@@ -105,21 +112,20 @@ function createEnvironment({
     shouldScopeHoist,
     sourceMap,
     unstableSingleFileOutput,
-    loc
+    loc,
+    customEnv
   };
   res.id = getEnvironmentHash(res);
-  return Object.freeze(res);
+  return (0, _EnvironmentManager.toEnvironmentRef)(Object.freeze(res));
 }
 function mergeEnvironments(projectRoot, a, b) {
   // If merging the same object, avoid copying.
   if (a === b || !b) {
-    return a;
+    return (0, _EnvironmentManager.toEnvironmentRef)(a);
   }
   if (b instanceof _Environment.default) {
-    return (0, _Environment.environmentToInternalEnvironment)(b);
+    return (0, _EnvironmentManager.toEnvironmentRef)((0, _Environment.environmentToInternalEnvironment)(b));
   }
-
-  // $FlowFixMe - ignore the `id` that is already on a
   return createEnvironment({
     ...a,
     ...b,
@@ -136,7 +142,8 @@ function getEnvironmentHash(env) {
     isLibrary: env.isLibrary,
     shouldOptimize: env.shouldOptimize,
     shouldScopeHoist: env.shouldScopeHoist,
-    sourceMap: env.sourceMap
+    sourceMap: env.sourceMap,
+    customEnv: env.customEnv
   };
   const id = (0, _rust().createEnvironmentId)(data);
   _IdentifierRegistry.identifierRegistry.addIdentifier('environment', id, data);