@atlaspack/core 2.16.2-canary.281 → 2.16.2-canary.283

package/CHANGELOG.md

@@ -1,5 +1,37 @@
 # @atlaspack/core
 
+## 2.27.0
+
+### Minor Changes
+
+- [#869](https://github.com/atlassian-labs/atlaspack/pull/869) [`cfb4707`](https://github.com/atlassian-labs/atlaspack/commit/cfb4707087498e4fa4dcf10753fe984a248d196b) Thanks [@benjervis](https://github.com/benjervis)! - Adds a feature to the V3 devloop that will minimise the amount of work done if the change is only a content change.
+
+### Patch Changes
+
+- [#873](https://github.com/atlassian-labs/atlaspack/pull/873) [`ec3abe4`](https://github.com/atlassian-labs/atlaspack/commit/ec3abe4dffc98560a850fd2f71fb566577e6c99c) Thanks [@vykimnguyen](https://github.com/vykimnguyen)! - cleanup deduplicateReporters flag
+
+- [#870](https://github.com/atlassian-labs/atlaspack/pull/870) [`33d4c26`](https://github.com/atlassian-labs/atlaspack/commit/33d4c261ceb8d585d56b0a446ed6e28cf7f1126d) Thanks [@matt-koko](https://github.com/matt-koko)! - Support Loading TypeScript Plugin Files in v3
+
+- [#856](https://github.com/atlassian-labs/atlaspack/pull/856) [`f31b041`](https://github.com/atlassian-labs/atlaspack/commit/f31b04107e9077c9946aadb99f6f91bb69703bb7) Thanks [@matt-koko](https://github.com/matt-koko)! - Handle Directory Entry Points in v3
+
+- [#859](https://github.com/atlassian-labs/atlaspack/pull/859) [`8180981`](https://github.com/atlassian-labs/atlaspack/commit/8180981be14c00f9570adb70d3f350bd91d6ec0a) Thanks [@benjervis](https://github.com/benjervis)! - Re-use asset graphs when building in Native, if we have one left over from a previous incremental build
+
+- [#883](https://github.com/atlassian-labs/atlaspack/pull/883) [`119210b`](https://github.com/atlassian-labs/atlaspack/commit/119210b597eb993c50445df87a36b70bd49cd414) Thanks [@matt-koko](https://github.com/matt-koko)! - Fix bitflags rust/js interop
+
+- Updated dependencies [[`ec3abe4`](https://github.com/atlassian-labs/atlaspack/commit/ec3abe4dffc98560a850fd2f71fb566577e6c99c), [`c7fe3f7`](https://github.com/atlassian-labs/atlaspack/commit/c7fe3f76f247e9e20299e205e2df0a16c418eaf2), [`cfb4707`](https://github.com/atlassian-labs/atlaspack/commit/cfb4707087498e4fa4dcf10753fe984a248d196b), [`1468695`](https://github.com/atlassian-labs/atlaspack/commit/1468695fc0c9d06f060a6da9e9b0e154f11dff34), [`f31b041`](https://github.com/atlassian-labs/atlaspack/commit/f31b04107e9077c9946aadb99f6f91bb69703bb7), [`8180981`](https://github.com/atlassian-labs/atlaspack/commit/8180981be14c00f9570adb70d3f350bd91d6ec0a), [`ae77e74`](https://github.com/atlassian-labs/atlaspack/commit/ae77e7452a466b43b3fa5bed24d4ba26345ed765), [`f0a496f`](https://github.com/atlassian-labs/atlaspack/commit/f0a496f70fc8652e090cf1b3f6260e8cfbb796e2), [`7d7a55d`](https://github.com/atlassian-labs/atlaspack/commit/7d7a55dd6395ec391a2e4c33b3dec0d1ea477d4c), [`540f253`](https://github.com/atlassian-labs/atlaspack/commit/540f253dfdcd1a5caebbdc0b197319d439404aae)]:
+  - @atlaspack/feature-flags@2.26.2
+  - @atlaspack/rust@3.10.0
+  - @atlaspack/graph@3.6.0
+  - @atlaspack/utils@3.1.2
+  - @atlaspack/cache@3.2.33
+  - @atlaspack/fs@2.15.33
+  - @atlaspack/logger@2.14.30
+  - @atlaspack/package-manager@2.14.38
+  - @atlaspack/workers@2.14.38
+  - @atlaspack/plugin@2.14.38
+  - @atlaspack/profiler@2.14.35
+  - @atlaspack/types@2.15.28
+
 ## 2.26.2
 
 ### Patch Changes

package/dist/BundleGraph.js

@@ -920,6 +920,111 @@ class BundleGraph {
             return isReferenced;
         });
     }
+    // New method: Fast checks only (no caching of results)
+    isAssetReferencedFastCheck(bundle, asset) {
+        // Fast Check #1: If asset is in multiple bundles in same target, it's referenced
+        let bundlesWithAsset = this.getBundlesWithAsset(asset).filter((b) => b.target.name === bundle.target.name &&
+            b.target.distDir === bundle.target.distDir);
+        if (bundlesWithAsset.length > 1) {
+            return true;
+        }
+        // Fast Check #2: If asset is referenced by any async/conditional dependency, it's referenced
+        let assetNodeId = (0, nullthrows_1.default)(this._graph.getNodeIdByContentKey(asset.id));
+        if (this._graph
+            .getNodeIdsConnectedTo(assetNodeId, exports.bundleGraphEdgeTypes.references)
+            .map((id) => this._graph.getNode(id))
+            .some((node) => node?.type === 'dependency' &&
+            (node.value.priority === types_1.Priority.lazy ||
+                node.value.priority === types_1.Priority.conditional) &&
+            node.value.specifierType !== types_1.SpecifierType.url)) {
+            return true;
+        }
+        // Fast checks failed - return null to indicate expensive computation needed
+        return null;
+    }
+    getReferencedAssets(bundle) {
+        let referencedAssets = new Set();
+        // Build a map of all assets in this bundle with their dependencies
+        // This allows us to check all assets in a single traversal
+        let assetDependenciesMap = new Map();
+        this.traverseAssets(bundle, (asset) => {
+            // Always do fast checks (no caching)
+            let fastCheckResult = this.isAssetReferencedFastCheck(bundle, asset);
+            if (fastCheckResult === true) {
+                referencedAssets.add(asset);
+                return;
+            }
+            // Fast checks failed (fastCheckResult === null), need expensive computation
+            // Check if it's actually referenced via traversal
+            // Store dependencies for later batch checking
+            let dependencies = this._graph
+                .getNodeIdsConnectedTo((0, nullthrows_1.default)(this._graph.getNodeIdByContentKey(asset.id)))
+                .map((id) => (0, nullthrows_1.default)(this._graph.getNode(id)))
+                .filter((node) => node.type === 'dependency')
+                .map((node) => {
+                (0, assert_2.default)(node.type === 'dependency');
+                return node.value;
+            });
+            if (dependencies.length > 0) {
+                assetDependenciesMap.set(asset, dependencies);
+            }
+        });
+        // If no assets need the expensive check, return early
+        if (assetDependenciesMap.size === 0) {
+            return referencedAssets;
+        }
+        // Get the assets we need to check once
+        let assetsToCheck = Array.from(assetDependenciesMap.keys());
+        // Helper function to check if all assets from assetDependenciesMap are in referencedAssets
+        const allAssetsReferenced = () => assetsToCheck.length <= referencedAssets.size &&
+            assetsToCheck.every((asset) => referencedAssets.has(asset));
+        // Do ONE traversal to check all remaining assets
+        // We can share visitedBundles across all assets because we check every asset
+        // against every visited bundle, which matches the original per-asset behavior
+        let siblingBundles = new Set(this.getBundleGroupsContainingBundle(bundle).flatMap((bundleGroup) => this.getBundlesInBundleGroup(bundleGroup, { includeInline: true })));
+        let visitedBundles = new Set();
+        // Single traversal from all referencers
+        for (let referencer of siblingBundles) {
+            this.traverseBundles((descendant, _, actions) => {
+                if (descendant.id === bundle.id) {
+                    return;
+                }
+                if (visitedBundles.has(descendant)) {
+                    actions.skipChildren();
+                    return;
+                }
+                visitedBundles.add(descendant);
+                if (descendant.type !== bundle.type ||
+                    (0, EnvironmentManager_1.fromEnvironmentId)(descendant.env).context !==
+                        (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env).context) {
+                    // Don't skip children - they might be the right type!
+                    return;
+                }
+                // Check ALL assets at once in this descendant bundle
+                for (let [asset, dependencies] of assetDependenciesMap) {
+                    // Skip if already marked as referenced
+                    if (referencedAssets.has(asset)) {
+                        continue;
+                    }
+                    // Check if this descendant bundle references the asset
+                    if (!this.bundleHasAsset(descendant, asset) &&
+                        dependencies.some((dependency) => this.bundleHasDependency(descendant, dependency))) {
+                        referencedAssets.add(asset);
+                    }
+                }
+                // If all assets from assetDependenciesMap are now marked as referenced, we can stop early
+                if (allAssetsReferenced()) {
+                    actions.stop();
+                    return;
+                }
+            }, referencer);
+            // If all assets from assetDependenciesMap are referenced, no need to check more sibling bundles
+            if (allAssetsReferenced()) {
+                break;
+            }
+        }
+        return referencedAssets;
+    }
     hasParentBundleOfType(bundle, type) {
         let parents = this.getParentBundles(bundle);
         return (parents.length > 0 && parents.every((parent) => parent.type === type));

package/dist/public/BundleGraph.js

@@ -148,6 +148,18 @@ class BundleGraph {
     isAssetReferenced(bundle, asset) {
         return __classPrivateFieldGet(this, _BundleGraph_graph, "f").isAssetReferenced((0, Bundle_1.bundleToInternalBundle)(bundle), (0, Asset_1.assetToAssetValue)(asset));
     }
+    isAssetReferencedFastCheck(bundle, asset) {
+        return __classPrivateFieldGet(this, _BundleGraph_graph, "f").isAssetReferencedFastCheck((0, Bundle_1.bundleToInternalBundle)(bundle), (0, Asset_1.assetToAssetValue)(asset));
+    }
+    getReferencedAssets(bundle) {
+        let internalReferencedAssets = __classPrivateFieldGet(this, _BundleGraph_graph, "f").getReferencedAssets((0, Bundle_1.bundleToInternalBundle)(bundle));
+        // Convert internal assets to public assets
+        let publicReferencedAssets = new Set();
+        for (let internalAsset of internalReferencedAssets) {
+            publicReferencedAssets.add((0, Asset_1.assetFromValue)(internalAsset, __classPrivateFieldGet(this, _BundleGraph_options, "f")));
+        }
+        return publicReferencedAssets;
+    }
     hasParentBundleOfType(bundle, type) {
         return __classPrivateFieldGet(this, _BundleGraph_graph, "f").hasParentBundleOfType((0, Bundle_1.bundleToInternalBundle)(bundle), type);
     }

package/lib/BundleGraph.js

@@ -914,6 +914,113 @@ class BundleGraph {
       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);

package/lib/public/BundleGraph.js

@@ -114,6 +114,19 @@ class BundleGraph {
   isAssetReferenced(bundle, asset) {
     return this.#graph.isAssetReferenced((0, _Bundle.bundleToInternalBundle)(bundle), (0, _Asset.assetToAssetValue)(asset));
   }
+  isAssetReferencedFastCheck(bundle, asset) {
+    return this.#graph.isAssetReferencedFastCheck((0, _Bundle.bundleToInternalBundle)(bundle), (0, _Asset.assetToAssetValue)(asset));
+  }
+  getReferencedAssets(bundle) {
+    let internalReferencedAssets = this.#graph.getReferencedAssets((0, _Bundle.bundleToInternalBundle)(bundle));
+
+    // Convert internal assets to public assets
+    let publicReferencedAssets = new Set();
+    for (let internalAsset of internalReferencedAssets) {
+      publicReferencedAssets.add((0, _Asset.assetFromValue)(internalAsset, this.#options));
+    }
+    return publicReferencedAssets;
+  }
   hasParentBundleOfType(bundle, type) {
     return this.#graph.hasParentBundleOfType((0, _Bundle.bundleToInternalBundle)(bundle), type);
   }

package/lib/types/BundleGraph.d.ts

@@ -129,6 +129,8 @@ export default class BundleGraph {
     getDependencies(asset: Asset): Array<Dependency>;
     traverseAssets<TContext>(bundle: Bundle, visit: GraphVisitor<Asset, TContext>, startAsset?: Asset): TContext | null | undefined;
     isAssetReferenced(bundle: Bundle, asset: Asset): boolean;
+    isAssetReferencedFastCheck(bundle: Bundle, asset: Asset): boolean | null;
+    getReferencedAssets(bundle: Bundle): Set<Asset>;
     hasParentBundleOfType(bundle: Bundle, type: string): boolean;
     getParentBundles(bundle: Bundle): Array<Bundle>;
     isAssetReachableFromBundle(asset: Asset, bundle: Bundle): boolean;

package/lib/types/public/BundleGraph.d.ts

@@ -30,6 +30,8 @@ export default class BundleGraph<TBundle extends IBundle> implements IBundleGrap
     getDependencies(asset: IAsset): Array<IDependency>;
     isAssetReachableFromBundle(asset: IAsset, bundle: IBundle): boolean;
     isAssetReferenced(bundle: IBundle, asset: IAsset): boolean;
+    isAssetReferencedFastCheck(bundle: IBundle, asset: IAsset): boolean | null;
+    getReferencedAssets(bundle: IBundle): Set<IAsset>;
     hasParentBundleOfType(bundle: IBundle, type: string): boolean;
     getBundlesInBundleGroup(bundleGroup: IBundleGroup, opts?: {
         includeInline: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.16.2-canary.281+119210b59",
+  "version": "2.16.2-canary.283+8eb84ee61",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -22,21 +22,21 @@
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.349+119210b59",
-    "@atlaspack/cache": "3.1.1-canary.281+119210b59",
-    "@atlaspack/diagnostic": "2.14.1-canary.349+119210b59",
-    "@atlaspack/events": "2.14.1-canary.349+119210b59",
-    "@atlaspack/feature-flags": "2.14.1-canary.349+119210b59",
-    "@atlaspack/fs": "2.14.5-canary.281+119210b59",
-    "@atlaspack/graph": "3.4.1-canary.349+119210b59",
-    "@atlaspack/logger": "2.14.5-canary.281+119210b59",
-    "@atlaspack/package-manager": "2.14.5-canary.281+119210b59",
-    "@atlaspack/plugin": "2.14.5-canary.281+119210b59",
-    "@atlaspack/profiler": "2.14.1-canary.349+119210b59",
-    "@atlaspack/rust": "3.2.1-canary.281+119210b59",
-    "@atlaspack/types": "2.14.5-canary.281+119210b59",
-    "@atlaspack/utils": "2.14.5-canary.281+119210b59",
-    "@atlaspack/workers": "2.14.5-canary.281+119210b59",
+    "@atlaspack/build-cache": "2.13.3-canary.351+8eb84ee61",
+    "@atlaspack/cache": "3.1.1-canary.283+8eb84ee61",
+    "@atlaspack/diagnostic": "2.14.1-canary.351+8eb84ee61",
+    "@atlaspack/events": "2.14.1-canary.351+8eb84ee61",
+    "@atlaspack/feature-flags": "2.14.1-canary.351+8eb84ee61",
+    "@atlaspack/fs": "2.14.5-canary.283+8eb84ee61",
+    "@atlaspack/graph": "3.4.1-canary.351+8eb84ee61",
+    "@atlaspack/logger": "2.14.5-canary.283+8eb84ee61",
+    "@atlaspack/package-manager": "2.14.5-canary.283+8eb84ee61",
+    "@atlaspack/plugin": "2.14.5-canary.283+8eb84ee61",
+    "@atlaspack/profiler": "2.14.1-canary.351+8eb84ee61",
+    "@atlaspack/rust": "3.2.1-canary.283+8eb84ee61",
+    "@atlaspack/types": "2.14.5-canary.283+8eb84ee61",
+    "@atlaspack/utils": "2.14.5-canary.283+8eb84ee61",
+    "@atlaspack/workers": "2.14.5-canary.283+8eb84ee61",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -61,5 +61,5 @@
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
   "type": "commonjs",
-  "gitHead": "119210b597eb993c50445df87a36b70bd49cd414"
+  "gitHead": "8eb84ee61a42bfe87c58079b610802b07a6a13e4"
 }

package/src/BundleGraph.ts

@@ -1435,6 +1435,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 (

package/src/public/BundleGraph.ts

@@ -198,6 +198,27 @@ export default class BundleGraph<TBundle extends IBundle>
     );
   }
 
+  isAssetReferencedFastCheck(bundle: IBundle, asset: IAsset): boolean | null {
+    return this.#graph.isAssetReferencedFastCheck(
+      bundleToInternalBundle(bundle),
+      assetToAssetValue(asset),
+    );
+  }
+
+  getReferencedAssets(bundle: IBundle): Set<IAsset> {
+    let internalReferencedAssets = this.#graph.getReferencedAssets(
+      bundleToInternalBundle(bundle),
+    );
+
+    // Convert internal assets to public assets
+    let publicReferencedAssets = new Set<IAsset>();
+    for (let internalAsset of internalReferencedAssets) {
+      publicReferencedAssets.add(assetFromValue(internalAsset, this.#options));
+    }
+
+    return publicReferencedAssets;
+  }
+
   hasParentBundleOfType(bundle: IBundle, type: string): boolean {
     return this.#graph.hasParentBundleOfType(
       bundleToInternalBundle(bundle),