@atlaspack/core 2.12.1-dev.3401 → 2.12.1-dev.3443

package/lib/RequestTracker.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.RequestGraph = void 0;
+exports.RequestGraph = void 0;
+exports.cleanUpOrphans = cleanUpOrphans;
+exports.default = void 0;
 exports.getWatcherOptions = getWatcherOptions;
 exports.readAndDeserializeRequestGraph = readAndDeserializeRequestGraph;
 exports.requestTypes = exports.requestGraphEdgeTypes = void 0;
@@ -21,6 +23,13 @@ function _path2() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _graph() {
   const data = require("@atlaspack/graph");
   _graph = function () {
@@ -204,7 +213,7 @@ class RequestGraph extends _graph().ContentGraph {
     this.removeCachedRequestChunkForNode(nodeId);
     return nodeId;
   }
-  removeNode(nodeId) {
+  removeNode(nodeId, removeOrphans = true) {
     this.invalidNodeIds.delete(nodeId);
     this.incompleteNodeIds.delete(nodeId);
     this.incompleteNodePromises.delete(nodeId);
@@ -222,7 +231,7 @@ class RequestGraph extends _graph().ContentGraph {
         configKeyNodes.delete(nodeId);
       }
     }
-    return super.removeNode(nodeId);
+    return super.removeNode(nodeId, removeOrphans);
   }
   getRequestNode(nodeId) {
     let node = (0, _nullthrows().default)(this.getNode(nodeId));
@@ -456,18 +465,32 @@ class RequestGraph extends _graph().ContentGraph {
       return node;
     });
   }
-  invalidateFileNameNode(node, filePath, matchNodes) {
+  invalidateFileNameNode(node, filePath, matchNodes, invalidateNode) {
     // If there is an edge between this file_name node and one of the original file nodes pointed to
     // by the original file_name node, and the matched node is inside the current directory, invalidate
     // all connected requests pointed to by the file node.
-    let dirname = _path2().default.dirname((0, _projectPath.fromProjectPathRelative)(filePath));
+
     let nodeId = this.getNodeIdByContentKey(node.id);
-    for (let matchNode of matchNodes) {
-      let matchNodeId = this.getNodeIdByContentKey(matchNode.id);
-      if (this.hasEdge(nodeId, matchNodeId, requestGraphEdgeTypes.invalidated_by_create_above) && (0, _utils().isDirectoryInside)((0, _projectPath.fromProjectPathRelative)((0, _projectPath.toProjectPathUnsafe)(matchNode.id)), dirname)) {
-        let connectedNodes = this.getNodeIdsConnectedTo(matchNodeId, requestGraphEdgeTypes.invalidated_by_create);
+    let dirname = _path2().default.dirname((0, _projectPath.fromProjectPathRelative)(filePath));
+    if ((0, _featureFlags().getFeatureFlag)('fixQuadraticCacheInvalidation')) {
+      while (dirname !== '/') {
+        if (!this.hasContentKey(dirname)) break;
+        const matchNodeId = this.getNodeIdByContentKey(dirname);
+        if (!this.hasEdge(nodeId, matchNodeId, requestGraphEdgeTypes.invalidated_by_create_above)) break;
+        const connectedNodes = this.getNodeIdsConnectedTo(matchNodeId, requestGraphEdgeTypes.invalidated_by_create);
         for (let connectedNode of connectedNodes) {
-          this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+          invalidateNode(connectedNode, _constants.FILE_CREATE);
+        }
+        dirname = _path2().default.dirname(dirname);
+      }
+    } else {
+      for (let matchNode of matchNodes) {
+        let matchNodeId = this.getNodeIdByContentKey(matchNode.id);
+        if (this.hasEdge(nodeId, matchNodeId, requestGraphEdgeTypes.invalidated_by_create_above) && (0, _utils().isDirectoryInside)((0, _projectPath.fromProjectPathRelative)((0, _projectPath.toProjectPathUnsafe)(matchNode.id)), dirname)) {
+          let connectedNodes = this.getNodeIdsConnectedTo(matchNodeId, requestGraphEdgeTypes.invalidated_by_create);
+          for (let connectedNode of connectedNodes) {
+            this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+          }
         }
       }
     }
@@ -480,7 +503,7 @@ class RequestGraph extends _graph().ContentGraph {
       if (this.hasEdge(nodeId, this.getNodeIdByContentKey(contentKey), requestGraphEdgeTypes.dirname)) {
         let parent = (0, _nullthrows().default)(this.getNodeByContentKey(contentKey));
         (0, _assert().default)(parent.type === FILE_NAME);
-        this.invalidateFileNameNode(parent, (0, _projectPath.toProjectPathUnsafe)(dirname), matchNodes);
+        this.invalidateFileNameNode(parent, (0, _projectPath.toProjectPathUnsafe)(dirname), matchNodes, invalidateNode);
       }
     }
   }
@@ -489,11 +512,38 @@ class RequestGraph extends _graph().ContentGraph {
     let count = 0;
     let predictedTime = 0;
     let startTime = Date.now();
+    const enableOptimization = (0, _featureFlags().getFeatureFlag)('fixQuadraticCacheInvalidation');
+    const removeOrphans = !enableOptimization;
+    const invalidatedNodes = new Set();
+    const invalidateNode = (nodeId, reason) => {
+      if (enableOptimization && invalidatedNodes.has(nodeId)) {
+        return;
+      }
+      invalidatedNodes.add(nodeId);
+      this.invalidateNode(nodeId, reason);
+    };
+    const aboveCache = new Map();
+    const getAbove = fileNameNodeId => {
+      const cachedResult = aboveCache.get(fileNameNodeId);
+      if (enableOptimization && cachedResult) {
+        return cachedResult;
+      }
+      let above = [];
+      const children = this.getNodeIdsConnectedTo(fileNameNodeId, requestGraphEdgeTypes.invalidated_by_create_above);
+      for (const nodeId of children) {
+        let node = (0, _nullthrows().default)(this.getNode(nodeId));
+        if (node.type === FILE) {
+          above.push(node);
+        }
+      }
+      aboveCache.set(fileNameNodeId, above);
+      return above;
+    };
     for (let {
       path: _path,
       type
     } of events) {
-      if (++count === 256) {
+      if (!enableOptimization && process.env.ATLASPACK_DISABLE_CACHE_TIMEOUT !== 'true' && ++count === 256) {
         let duration = Date.now() - startTime;
         predictedTime = duration * (events.length >> 8);
         if (predictedTime > threshold) {
@@ -540,13 +590,13 @@ class RequestGraph extends _graph().ContentGraph {
         let nodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update);
         for (let connectedNode of nodes) {
           didInvalidate = true;
-          this.invalidateNode(connectedNode, _constants.FILE_UPDATE);
+          invalidateNode(connectedNode, _constants.FILE_UPDATE);
         }
         if (type === 'create') {
           let nodes = this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_create);
           for (let connectedNode of nodes) {
             didInvalidate = true;
-            this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+            invalidateNode(connectedNode, _constants.FILE_CREATE);
           }
         }
       } else if (type === 'create') {
@@ -556,17 +606,10 @@ class RequestGraph extends _graph().ContentGraph {
           let fileNameNodeId = this.getNodeIdByContentKey('file_name:' + basename);
 
           // Find potential file nodes to be invalidated if this file name pattern matches
-          let above = [];
-          for (const nodeId of this.getNodeIdsConnectedTo(fileNameNodeId, requestGraphEdgeTypes.invalidated_by_create_above)) {
-            let node = (0, _nullthrows().default)(this.getNode(nodeId));
-            // these might also be `glob` nodes which get handled below, we only care about files here.
-            if (node.type === FILE) {
-              above.push(node);
-            }
-          }
+          let above = getAbove(fileNameNodeId);
           if (above.length > 0) {
             didInvalidate = true;
-            this.invalidateFileNameNode(fileNameNode, _filePath, above);
+            this.invalidateFileNameNode(fileNameNode, _filePath, above, invalidateNode);
           }
         }
         for (let globeNodeId of this.globNodeIds) {
@@ -576,7 +619,7 @@ class RequestGraph extends _graph().ContentGraph {
             let connectedNodes = this.getNodeIdsConnectedTo(globeNodeId, requestGraphEdgeTypes.invalidated_by_create);
             for (let connectedNode of connectedNodes) {
               didInvalidate = true;
-              this.invalidateNode(connectedNode, _constants.FILE_CREATE);
+              invalidateNode(connectedNode, _constants.FILE_CREATE);
             }
           }
         }
@@ -584,13 +627,13 @@ class RequestGraph extends _graph().ContentGraph {
         let nodeId = this.getNodeIdByContentKey(filePath);
         for (let connectedNode of this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_delete)) {
           didInvalidate = true;
-          this.invalidateNode(connectedNode, _constants.FILE_DELETE);
+          invalidateNode(connectedNode, _constants.FILE_DELETE);
         }
 
         // Delete the file node since it doesn't exist anymore.
         // This ensures that files that don't exist aren't sent
         // to requests as invalidations for future requests.
-        this.removeNode(nodeId);
+        this.removeNode(nodeId, removeOrphans);
       }
       let configKeyNodes = this.configKeyNodes.get(_filePath);
       if (configKeyNodes && (type === 'delete' || type === 'update')) {
@@ -604,14 +647,17 @@ class RequestGraph extends _graph().ContentGraph {
           }
           if (isInvalid) {
             for (let connectedNode of this.getNodeIdsConnectedTo(nodeId, requestGraphEdgeTypes.invalidated_by_update)) {
-              this.invalidateNode(connectedNode, type === 'delete' ? _constants.FILE_DELETE : _constants.FILE_UPDATE);
+              invalidateNode(connectedNode, type === 'delete' ? _constants.FILE_DELETE : _constants.FILE_UPDATE);
             }
             didInvalidate = true;
-            this.removeNode(nodeId);
+            this.removeNode(nodeId, removeOrphans);
           }
         }
       }
     }
+    if ((0, _featureFlags().getFeatureFlag)('fixQuadraticCacheInvalidation')) {
+      cleanUpOrphans(this);
+    }
     let duration = Date.now() - startTime;
     _logger().default.verbose({
       origin: '@atlaspack/core',
@@ -619,7 +665,9 @@ class RequestGraph extends _graph().ContentGraph {
       meta: {
         trackableEvent: 'fsevent_response_time',
         duration,
-        predictedTime
+        predictedTime,
+        numberOfEvents: events.length,
+        numberOfInvalidatedNodes: invalidatedNodes.size
       }
     });
     return didInvalidate && this.invalidNodeIds.size > 0;
@@ -1022,7 +1070,16 @@ async function loadRequestGraph(options) {
   let cacheKey = getCacheKey(options);
   let requestGraphKey = `requestGraph-${cacheKey}`;
   let timeout;
-  const snapshotPath = _path2().default.join(options.cacheDir, `snapshot-${cacheKey}` + '.txt');
+  const snapshotKey = `snapshot-${cacheKey}`;
+  const snapshotPath = _path2().default.join(options.cacheDir, snapshotKey + '.txt');
+  _logger().default.verbose({
+    origin: '@atlaspack/core',
+    message: 'Loading request graph',
+    meta: {
+      cacheKey,
+      snapshotKey
+    }
+  });
   if (await options.cache.hasLargeBlob(requestGraphKey)) {
     try {
       let {
@@ -1062,6 +1119,14 @@ async function loadRequestGraph(options) {
       return new RequestGraph();
     }
   }
+  _logger().default.verbose({
+    origin: '@atlaspack/core',
+    message: 'Cache entry for request tracker was not found, initializing a clean cache.',
+    meta: {
+      cacheKey,
+      snapshotKey
+    }
+  });
   return new RequestGraph();
 }
 function logErrorOnBailout(options, snapshotPath, e) {
@@ -1086,4 +1151,21 @@ function logErrorOnBailout(options, snapshotPath, e) {
       }
     });
   }
+}
+function cleanUpOrphans(graph) {
+  if (graph.rootNodeId == null) {
+    return [];
+  }
+  const reachableNodes = new Set();
+  graph.traverse(nodeId => {
+    reachableNodes.add(nodeId);
+  });
+  const removedNodeIds = [];
+  graph.nodes.forEach((_node, nodeId) => {
+    if (!reachableNodes.has(nodeId)) {
+      removedNodeIds.push(nodeId);
+      graph.removeNode(nodeId);
+    }
+  });
+  return removedNodeIds;
 }

package/lib/SymbolPropagation.js

@@ -108,7 +108,7 @@ function propagateSymbols({
       namespaceReexportedSymbols.add('*');
     } else {
       for (let incomingDep of incomingDeps) {
-        if (incomingDep.value.symbols == null) {
+        if (incomingDep.value.symbols == null || incomingDep.value.priority === _types.Priority.conditional) {
           if (incomingDep.value.sourceAssetId == null) {
             // The root dependency on non-library builds
             isEntry = true;

package/lib/Transformation.js

@@ -46,13 +46,6 @@ function _utils() {
   };
   return data;
 }
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
 var _Dependency = require("./Dependency");
 var _AtlaspackConfig = _interopRequireDefault(require("./AtlaspackConfig"));
 var _PathRequest = require("./requests/PathRequest");
@@ -181,16 +174,9 @@ class Transformation {
 
     // Prefer `isSource` originating from the AssetRequest.
 
-    // If the transformer request passed code, use a hash in addition
-    // to the filename as the base for the id to ensure it is unique.
-    let idBase = (0, _projectPath.fromProjectPathRelative)(filePath);
-    if (code != null) {
-      idBase += (0, _rust().hashString)(code);
-    }
     return new _UncommittedAsset.default({
-      idBase,
       value: (0, _assetUtils.createAsset)(this.options.projectRoot, {
-        idBase,
+        code,
         filePath,
         isSource: isSourceOverride ?? summarizedIsSource,
         type: _path().default.extname((0, _projectPath.fromProjectPathRelative)(filePath)).slice(1),

package/lib/UncommittedAsset.js

@@ -56,7 +56,7 @@ class UncommittedAsset {
     mapBuffer,
     ast,
     isASTDirty,
-    idBase,
+    code,
     invalidations
   }) {
     this.value = value;
@@ -65,7 +65,7 @@ class UncommittedAsset {
     this.mapBuffer = mapBuffer;
     this.ast = ast;
     this.isASTDirty = isASTDirty || false;
-    this.idBase = idBase;
+    this.code = code;
     this.invalidations = invalidations || (0, _utils2.createInvalidations)();
   }
 
@@ -289,7 +289,7 @@ class UncommittedAsset {
     let content = result.content ?? null;
     let asset = new UncommittedAsset({
       value: (0, _assetUtils.createAsset)(this.options.projectRoot, {
-        idBase: this.idBase,
+        code: this.code,
         filePath: this.value.filePath,
         type: result.type,
         bundleBehavior: result.bundleBehavior ?? (this.value.bundleBehavior == null ? null : _types.BundleBehaviorNames[this.value.bundleBehavior]),
@@ -323,7 +323,7 @@ class UncommittedAsset {
       ast: result.ast,
       isASTDirty: result.ast === this.ast ? this.isASTDirty : true,
       mapBuffer: result.map ? result.map.toBuffer() : null,
-      idBase: this.idBase,
+      code: this.code,
       invalidations: this.invalidations
     });
     let dependencies = result.dependencies;

package/lib/Validation.js

@@ -46,13 +46,6 @@ function _profiler() {
   };
   return data;
 }
-function _rust() {
-  const data = require("@atlaspack/rust");
-  _rust = function () {
-    return data;
-  };
-  return data;
-}
 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; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -188,14 +181,9 @@ class Validation {
     } = await (0, _summarizeRequest.default)(this.options.inputFS, {
       filePath: (0, _projectPath.fromProjectPath)(this.options.projectRoot, request.filePath)
     });
-
-    // If the transformer request passed code rather than a filename,
-    // use a hash as the base for the id to ensure it is unique.
-    let idBase = code != null ? (0, _rust().hashString)(code) : (0, _projectPath.fromProjectPathRelative)(filePath);
     return new _UncommittedAsset.default({
-      idBase,
       value: (0, _assetUtils.createAsset)(this.options.projectRoot, {
-        idBase,
+        code,
         filePath: filePath,
         isSource,
         type: _path().default.extname((0, _projectPath.fromProjectPathRelative)(filePath)).slice(1),

package/lib/applyRuntimes.js

@@ -62,6 +62,13 @@ function _profiler() {
   };
   return data;
 }
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
 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; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -81,6 +88,15 @@ function nameRuntimeBundle(bundle, siblingBundle) {
   bundle.name = name;
   bundle.displayName = name.replace(hashReference, '[hash]');
 }
+
+/**
+ * The applyRuntimes function is responsible for generating all the runtimes
+ * (assets created during the build that don't actually exist on disk) and then
+ * linking them into the bundle graph.
+ *
+ * Introduction of manifest bundles: https://github.com/parcel-bundler/parcel/pull/8837
+ * Introduction of reverse topology: https://github.com/parcel-bundler/parcel/pull/8981
+ */
 async function applyRuntimes({
   bundleGraph,
   config,
@@ -93,17 +109,27 @@ async function applyRuntimes({
   configs
 }) {
   let runtimes = await config.getRuntimes();
-  let connections = [];
 
-  // As manifest bundles may be added during runtimes we process them in reverse topological
-  // sort order. This allows bundles to be added to their bundle groups before they are referenced
-  // by other bundle groups by loader runtimes
+  /**
+   * Usually, the assets returned from a runtime will go in the same bundle. It is
+   * possible though, for a runtime to return an asset with a `parallel` priority,
+   * which allows it to be moved to a separate bundle. In practice, this is
+   * usually used to generate application manifest files.
+   *
+   * When adding a manifest bundle (a whole new separate bundle) during a runtime,
+   * it needs to be added to a bundle group which will be potentially referenced
+   * by another bundle group. To avoid trying to reference a manifest entry which
+   * hasn't been created yet, we process the bundles from the bottom up (topological
+   * order), so that children will always be available when parents try to reference
+   * them.
+   */
   let bundles = [];
   bundleGraph.traverseBundles({
     exit(bundle) {
       bundles.push(bundle);
     }
   });
+  let connectionMap = new (_utils().DefaultMap)(() => []);
   for (let bundle of bundles) {
     for (let runtime of runtimes) {
       let measurement;
@@ -144,6 +170,12 @@ async function applyRuntimes({
               isSource: true
             };
             let connectionBundle = bundle;
+
+            /**
+             * If a runtime asset is marked with a priority of `parallel` this
+             * means we need to create a new bundle for the asset and add it to
+             * all the same bundle groups.
+             */
             if (priority === 'parallel' && !bundle.needsStableName) {
               let bundleGroups = bundleGraph.getBundleGroupsContainingBundle(bundle);
               connectionBundle = (0, _nullthrows().default)(bundleGraph.createBundle({
@@ -158,9 +190,12 @@ async function applyRuntimes({
                 bundleGraph.addBundleToBundleGroup(connectionBundle, bundleGroup);
               }
               bundleGraph.createBundleReference(bundle, connectionBundle);
+
+              // Ensure we name the bundle now as all other bundles have already
+              // been named as this point.
               nameRuntimeBundle(connectionBundle, bundle);
             }
-            connections.push({
+            connectionMap.get(connectionBundle).push({
               bundle: connectionBundle,
               assetGroup,
               dependency,
@@ -180,8 +215,28 @@ async function applyRuntimes({
     }
   }
 
-  // Correct connection order after generating runtimes in reverse order
-  connections.reverse();
+  /**
+   * When merging the connections in to the bundle graph, the topological
+   * order can create module not found errors in some situations, often when HMR
+   * is enabled. To fix this, we put the connections into DFS order.
+   *
+   * Note: While DFS order seems to be the most reliable order to process the
+   * connections, this is likely due to it being close to the order that the bundles were
+   * inserted into the graph. There is a known issue where runtime assets marked
+   * as `isEntry` can create scenarios where there is no correct load order that
+   * won't error, as the entry runtime assets are added to many bundles in a
+   * single bundle group but their dependencies are not.
+   *
+   * This issue is almost exclusive to HMR scenarios as the two HMR runtime
+   * plugins (@atlaspack/runtime-browser-hmr and @atlaspack/runtime-react-refresh)
+   * are the only known cases where a runtime asset is marked as `isEntry`.
+   */
+  let connections = [];
+  bundleGraph.traverseBundles({
+    enter(bundle) {
+      connections.push(...connectionMap.get(bundle));
+    }
+  });
 
   // Add dev deps for runtime plugins AFTER running them, to account for lazy require().
   for (let runtime of runtimes) {
@@ -192,18 +247,29 @@ async function applyRuntimes({
     devDepRequests.set(`${devDepRequest.specifier}:${(0, _projectPath.fromProjectPathRelative)(devDepRequest.resolveFrom)}`, devDepRequest);
     await (0, _DevDepRequest.runDevDepRequest)(api, devDepRequest);
   }
+
+  // Create a new AssetGraph from the generated runtime assets which also runs
+  // transforms and resolves all dependencies.
   let {
     assetGraph: runtimesAssetGraph,
     changedAssets
   } = await reconcileNewRuntimes(api, connections, optionsRef);
-  let runtimesGraph = _BundleGraph2.default.fromAssetGraph(runtimesAssetGraph, options.mode === 'production', bundleGraph._publicIdByAssetId, bundleGraph._assetPublicIds);
 
-  // Merge the runtimes graph into the main bundle graph.
-  bundleGraph.merge(runtimesGraph);
-  for (let [assetId, publicId] of runtimesGraph._publicIdByAssetId) {
+  // Convert the runtime AssetGraph into a BundleGraph, this includes assigning
+  // the assets their public ids
+  let runtimesBundleGraph = _BundleGraph2.default.fromAssetGraph(runtimesAssetGraph, options.mode === 'production', bundleGraph._publicIdByAssetId, bundleGraph._assetPublicIds);
+
+  // Merge the runtimes bundle graph into the main bundle graph.
+  bundleGraph.merge(runtimesBundleGraph);
+
+  // Add the public id mappings from the runtumes bundlegraph to the main bundle graph
+  for (let [assetId, publicId] of runtimesBundleGraph._publicIdByAssetId) {
     bundleGraph._publicIdByAssetId.set(assetId, publicId);
     bundleGraph._assetPublicIds.add(publicId);
   }
+
+  // Connect each of the generated runtime assets to bundles in the main bundle
+  // graph. This is like a mini-bundling algorithm for runtime assets.
   for (let {
     bundle,
     assetGroup,
@@ -216,16 +282,24 @@ async function applyRuntimes({
     let runtimeNodeId = assetGroupAssetNodeIds[0];
     let runtimeNode = (0, _nullthrows().default)(runtimesAssetGraph.getNode(runtimeNodeId));
     (0, _assert().default)(runtimeNode.type === 'asset');
+
+    // Find the asset that the runtime asset should be connected from by resolving
+    // it's dependency.
     let resolution = dependency && bundleGraph.getResolvedAsset((0, _Dependency.dependencyToInternalDependency)(dependency), bundle);
-    let runtimesGraphRuntimeNodeId = runtimesGraph._graph.getNodeIdByContentKey(runtimeNode.id);
+
+    // Walk all the dependencies of the runtime assets and check if they are
+    // already reachable from the bundle that the runtime asset is assigned to.
+    // If so, we add them to `duplicatedContentKeys` to be skipped when assigning
+    // assets to bundles.
+    let runtimesBundleGraphRuntimeNodeId = runtimesBundleGraph._graph.getNodeIdByContentKey(runtimeNode.id);
     let duplicatedContentKeys = new Set();
-    runtimesGraph._graph.traverse((nodeId, _, actions) => {
-      let node = (0, _nullthrows().default)(runtimesGraph._graph.getNode(nodeId));
+    runtimesBundleGraph._graph.traverse((nodeId, _, actions) => {
+      let node = (0, _nullthrows().default)(runtimesBundleGraph._graph.getNode(nodeId));
       if (node.type !== 'dependency') {
         return;
       }
-      let assets = runtimesGraph._graph.getNodeIdsConnectedFrom(nodeId).map(assetNodeId => {
-        let assetNode = (0, _nullthrows().default)(runtimesGraph._graph.getNode(assetNodeId));
+      let assets = runtimesBundleGraph._graph.getNodeIdsConnectedFrom(nodeId).map(assetNodeId => {
+        let assetNode = (0, _nullthrows().default)(runtimesBundleGraph._graph.getNode(assetNodeId));
         (0, _assert().default)(assetNode.type === 'asset');
         return assetNode.value;
       });
@@ -235,12 +309,14 @@ async function applyRuntimes({
           actions.skipChildren();
         }
       }
-    }, runtimesGraphRuntimeNodeId);
+    }, runtimesBundleGraphRuntimeNodeId);
     let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.id);
     let bundleGraphRuntimeNodeId = bundleGraph._graph.getNodeIdByContentKey(runtimeNode.id); // the node id is not constant between graphs
 
-    runtimesGraph._graph.traverse((nodeId, _, actions) => {
-      let node = (0, _nullthrows().default)(runtimesGraph._graph.getNode(nodeId));
+    // Assign the runtime assets and all of it's depepdencies to the bundle unless
+    // we have detected it as already being reachable from this bundle via `duplicatedContentKeys`.
+    runtimesBundleGraph._graph.traverse((nodeId, _, actions) => {
+      let node = (0, _nullthrows().default)(runtimesBundleGraph._graph.getNode(nodeId));
       if (node.type === 'asset' || node.type === 'dependency') {
         if (duplicatedContentKeys.has(node.id)) {
           actions.skipChildren();
@@ -249,7 +325,7 @@ async function applyRuntimes({
         const bundleGraphNodeId = bundleGraph._graph.getNodeIdByContentKey(node.id); // the node id is not constant between graphs
         bundleGraph._graph.addEdge(bundleNodeId, bundleGraphNodeId, _BundleGraph2.bundleGraphEdgeTypes.contains);
       }
-    }, runtimesGraphRuntimeNodeId);
+    }, runtimesBundleGraphRuntimeNodeId);
     if (isEntry) {
       bundleGraph._graph.addEdge(bundleNodeId, bundleGraphRuntimeNodeId);
       bundle.entryAssetIds.unshift(runtimeNode.id);

package/lib/assetUtils.js

@@ -61,9 +61,15 @@ function _profiler() {
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createAssetIdFromOptions(options) {
-  let uniqueKey = options.uniqueKey ?? '';
-  let idBase = options.idBase != null ? options.idBase : (0, _projectPath.fromProjectPathRelative)(options.filePath);
-  return (0, _rust().hashString)(idBase + options.type + options.env.id + uniqueKey + ':' + (options.pipeline ?? '') + ':' + (options.query ?? ''));
+  return (0, _rust().createAssetId)({
+    env: options.env,
+    filePath: options.filePath,
+    code: options.code,
+    pipeline: options.pipeline,
+    query: options.query,
+    uniqueKey: options.uniqueKey,
+    fileType: options.type
+  });
 }
 function createAsset(projectRoot, options) {
   return {

package/lib/atlaspack-v3/AtlaspackV3.js

@@ -35,6 +35,12 @@ class AtlaspackV3 {
     threads,
     ...options
   }) {
+    options.logLevel = options.logLevel || 'error';
+    options.defaultTargetOptions = options.defaultTargetOptions || {};
+    // $FlowFixMe "engines" are readonly
+    options.defaultTargetOptions.engines = options.defaultTargetOptions.engines || {
+      browsers: []
+    };
     this._internal = new (_rust().AtlaspackNapi)({
       fs,
       nodeWorkers,
@@ -43,14 +49,6 @@ class AtlaspackV3 {
       options
     });
   }
-  async build() {
-    const [workers, registerWorker] = this.#createWorkers();
-    let result = await this._internal.build({
-      registerWorker
-    });
-    for (const worker of workers) worker.terminate();
-    return result;
-  }
   async buildAssetGraph() {
     const [workers, registerWorker] = this.#createWorkers();
     let result = await this._internal.buildAssetGraph({

package/lib/atlaspack-v3/fs.js

@@ -11,7 +11,14 @@ function toFileSystemV3(fs) {
     canonicalize: (0, _jsCallable.jsCallable)(path => fs.realpathSync(path)),
     createDirectory: (0, _jsCallable.jsCallable)(path => fs.mkdirp(path)),
     cwd: (0, _jsCallable.jsCallable)(() => fs.cwd()),
-    readFile: (0, _jsCallable.jsCallable)((path, encoding) => fs.readFileSync(path, encoding ?? 'utf8')),
+    readFile: (0, _jsCallable.jsCallable)((path, encoding) => {
+      if (!encoding) {
+        // $FlowFixMe
+        return [...fs.readFileSync(path)];
+      } else {
+        return fs.readFileSync(path, encoding);
+      }
+    }),
     isFile: path => {
       try {
         return fs.statSync(path).isFile();