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

package/lib/requests/AssetGraphRequestRust.js

@@ -20,47 +20,62 @@ function _diagnostic() {
   return data;
 }
 function _logger() {
-  const data = require("@atlaspack/logger");
+  const data = _interopRequireWildcard(require("@atlaspack/logger"));
   _logger = function () {
     return data;
   };
   return data;
 }
-var _AssetGraph = _interopRequireWildcard(require("../AssetGraph"));
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
+var _ReporterRunner = require("../ReporterRunner");
 var _RequestTracker = require("../RequestTracker");
 var _SymbolPropagation = require("../SymbolPropagation");
-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 }; }
+var _EnvironmentManager = require("../EnvironmentManager");
+var _Environment = require("../Environment");
+var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function createAssetGraphRequestRust(rustAtlaspack) {
   return input => ({
     type: _RequestTracker.requestTypes.asset_graph_request,
     id: input.name,
-    run: async input => {
-      let options = input.options;
-      let serializedAssetGraph = await rustAtlaspack.buildAssetGraph();
-      serializedAssetGraph.nodes = serializedAssetGraph.nodes.map(node => JSON.parse(node));
+    run: async runInput => {
+      let options = runInput.options;
       let {
-        assetGraph,
-        changedAssets
-      } = (0, _logger().instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph));
-      let changedAssetsPropagation = new Set(changedAssets.keys());
-      let errors = (0, _SymbolPropagation.propagateSymbols)({
-        options,
-        assetGraph,
-        changedAssetsPropagation,
-        assetGroupsWithRemovedParents: new Set(),
-        previousErrors: new Map() //this.previousSymbolPropagationErrors,
+        assetGraphPromise,
+        commitPromise
+      } = await rustAtlaspack.buildAssetGraph(eventJson => {
+        let event = JSON.parse(eventJson);
+        (0, _ReporterRunner.report)(event);
       });
-
-      if (errors.size > 0) {
-        // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
-        // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+      let [serializedAssetGraph, assetGraphError] = await assetGraphPromise;
+      if (assetGraphError) {
         throw new (_diagnostic().default)({
-          diagnostic: [...errors.values()][0]
+          diagnostic: assetGraphError
         });
       }
-      return {
+
+      // Don't reuse a previous asset graph result if Rust didn't have one too
+      let prevResult = null;
+      if (serializedAssetGraph.hadPreviousGraph) {
+        prevResult = await runInput.api.getPreviousResult();
+      }
+      let {
+        assetGraph,
+        changedAssets
+      } = (0, _logger().instrument)('atlaspack_v3_getAssetGraph', () => {
+        var _prevResult;
+        return getAssetGraph(serializedAssetGraph, (_prevResult = prevResult) === null || _prevResult === void 0 ? void 0 : _prevResult.assetGraph);
+      });
+      let changedAssetsPropagation = new Set(changedAssets.keys());
+      let result = {
         assetGraph,
         assetRequests: [],
         assetGroupsWithRemovedParents: new Set(),
@@ -68,19 +83,126 @@ function createAssetGraphRequestRust(rustAtlaspack) {
         changedAssetsPropagation,
         previousSymbolPropagationErrors: undefined
       };
+
+      // When v3AssetGraphSyncImprovements is enabled, wrap downstream steps
+      // in try/catch and store the result even on error. This prevents Rust/JS
+      // divergence when symbol propagation or commit_assets fails.
+      let storeResultOnError = (0, _featureFlags().getFeatureFlag)('v3AssetGraphSyncImprovements');
+      try {
+        // Skip symbol propagation for runtime assets - they have pre-computed symbol data
+        if (input.skipSymbolProp) {
+          _logger().default.verbose({
+            origin: '@atlaspack/core',
+            message: 'Skipping symbol propagation for runtime asset graph'
+          });
+        } else {
+          let errors = (0, _SymbolPropagation.propagateSymbols)({
+            options,
+            assetGraph,
+            changedAssetsPropagation,
+            assetGroupsWithRemovedParents: new Set(),
+            previousErrors: new Map() //this.previousSymbolPropagationErrors,
+          });
+          if (errors.size > 0) {
+            // Just throw the first error. Since errors can bubble (e.g. reexporting a reexported symbol also fails),
+            // determining which failing export is the root cause is nontrivial (because of circular dependencies).
+            throw new (_diagnostic().default)({
+              diagnostic: [...errors.values()][0]
+            });
+          }
+        }
+        await (0, _dumpGraphToGraphViz.default)(assetGraph, 'AssetGraphV3');
+        let [_commitResult, commitError] = await commitPromise;
+        if (commitError) {
+          throw new (_diagnostic().default)({
+            diagnostic: {
+              message: 'Error committing asset graph in Rust: ' + commitError.message
+            }
+          });
+        }
+        await runInput.api.storeResult(result);
+        runInput.api.invalidateOnBuild();
+      } catch (e) {
+        if (storeResultOnError) {
+          // Store the graph even on error to prevent Rust/JS divergence.
+          // The graph from getAssetGraph is structurally correct — only
+          // downstream processing (symbols, commit) failed.
+          await runInput.api.storeResult(result);
+          runInput.api.invalidateOnBuild();
+        }
+        throw e;
+      }
+      return result;
     },
     input
   });
 }
+function getAssetGraph(serializedGraph, prevAssetGraph) {
+  let graph;
+  let reuseEdges = false;
+  let clonePrevGraph = (0, _featureFlags().getFeatureFlag)('v3AssetGraphSyncImprovements');
+  if (prevAssetGraph && serializedGraph.safeToSkipBundling) {
+    if (clonePrevGraph) {
+      graph = new _AssetGraph.default({
+        _contentKeyToNodeId: new Map(prevAssetGraph._contentKeyToNodeId),
+        _nodeIdToContentKey: new Map(prevAssetGraph._nodeIdToContentKey),
+        nodes: [...prevAssetGraph.nodes],
+        rootNodeId: prevAssetGraph.rootNodeId,
+        adjacencyList: prevAssetGraph.adjacencyList
+      });
+    } else {
+      graph = new _AssetGraph.default({
+        _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+        _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+        nodes: prevAssetGraph.nodes,
+        rootNodeId: prevAssetGraph.rootNodeId,
+        adjacencyList: prevAssetGraph.adjacencyList
+      });
+    }
+    reuseEdges = true;
+  } else if (prevAssetGraph && (serializedGraph.updates.length > 0 || serializedGraph.nodes.length > 0)) {
+    if (clonePrevGraph) {
+      graph = new _AssetGraph.default({
+        _contentKeyToNodeId: new Map(prevAssetGraph._contentKeyToNodeId),
+        _nodeIdToContentKey: new Map(prevAssetGraph._nodeIdToContentKey),
+        nodes: [...prevAssetGraph.nodes],
+        initialCapacity: serializedGraph.edges.length,
+        // Accomodate the root node
+        initialNodeCapacity: prevAssetGraph.nodes.length + 1,
+        rootNodeId: prevAssetGraph.rootNodeId
+      });
+    } else {
+      graph = new _AssetGraph.default({
+        _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
+        _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
+        nodes: prevAssetGraph.nodes,
+        initialCapacity: serializedGraph.edges.length,
+        // Accomodate the root node
+        initialNodeCapacity: prevAssetGraph.nodes.length + 1,
+        rootNodeId: prevAssetGraph.rootNodeId
+      });
+    }
+    graph.safeToIncrementallyBundle = false;
+  } else {
+    graph = new _AssetGraph.default({
+      _contentKeyToNodeId: new Map(),
+      _nodeIdToContentKey: new Map(),
+      initialCapacity: serializedGraph.edges.length,
+      // Accomodate the root node
+      initialNodeCapacity: serializedGraph.nodes.length + 1
+    });
+    let rootNodeId = graph.addNodeByContentKey('@@root', {
+      id: '@@root',
+      type: 'root',
+      value: null
+    });
+    graph.setRootNodeId(rootNodeId);
+    graph.safeToIncrementallyBundle = false;
+  }
+  (0, _assert().default)(graph, 'Asset graph not initialized');
+  (0, _assert().default)(graph.rootNodeId != null, 'Asset graph has no root node');
 
-// $FlowFixMe
-function getAssetGraph(serializedGraph) {
-  let graph = new _AssetGraph.default({
-    _contentKeyToNodeId: new Map(),
-    _nodeIdToContentKey: new Map(),
-    initialCapacity: serializedGraph.edges.length
-  });
-  graph.safeToIncrementallyBundle = false;
+  // @ts-expect-error TS7031
   function mapSymbols({
     exported,
     ...symbol
@@ -88,19 +210,16 @@ function getAssetGraph(serializedGraph) {
     let jsSymbol = {
       local: symbol.local ?? undefined,
       loc: symbol.loc ?? undefined,
-      meta: undefined,
-      isWeak: symbol.isWeak
+      isWeak: symbol.isWeak,
+      meta: {
+        isEsm: symbol.isEsmExport,
+        isStaticBindingSafe: symbol.isStaticBindingSafe
+      }
     };
     if (symbol.exported) {
-      // $FlowFixMe
+      // @ts-expect-error TS2339
       jsSymbol.exported = symbol.exported;
     }
-    if (symbol.isEsmExport) {
-      // $FlowFixMe
-      jsSymbol.meta = {
-        isEsm: true
-      };
-    }
     return [exported, jsSymbol];
   }
 
@@ -112,20 +231,121 @@ function getAssetGraph(serializedGraph) {
     let envKey = [env.context, env.engines.atlaspack, env.engines.browsers, env.engines.electron, env.engines.node, env.includeNodeModules, env.isLibrary, env.outputFormat, env.shouldScopeHoist, env.shouldOptimize, env.sourceType].join(':');
     let envId = envs.get(envKey);
     if (envId == null) {
-      envId = envs.size;
+      envId = (0, _Environment.getEnvironmentHash)(env);
       envs.set(envKey, envId);
     }
     return envId;
   };
-  for (let node of serializedGraph.nodes) {
-    if (node.type === 'root') {
-      let index = graph.addNodeByContentKey('@@root', {
-        id: '@@root',
-        type: 'root',
-        value: null
-      });
-      graph.setRootNodeId(index);
-    } else if (node.type === 'entry') {
+  function describeNode(node) {
+    const base = {
+      type: node.type,
+      id: node.id
+    };
+    if (node.type === 'asset') {
+      return {
+        ...base,
+        filePath: node.value.filePath,
+        fileType: node.value.type,
+        pipeline: node.value.pipeline
+      };
+    } else if (node.type === 'dependency') {
+      return {
+        ...base,
+        specifier: node.value.specifier,
+        specifierType: node.value.specifierType,
+        sourceAssetId: node.value.sourceAssetId,
+        sourcePath: node.value.sourcePath
+      };
+    }
+    return base;
+  }
+  function buildDivergenceDiagnostics(divergenceType, newNode, existingNode, index) {
+    return {
+      contentKey: newNode.id,
+      divergenceType,
+      newNode: describeNode(newNode),
+      existingNode: existingNode ? describeNode(existingNode) : null,
+      iterationIndex: index,
+      totalSerializedNodes: nodesCount,
+      newNodesCount: serializedGraph.nodes.length,
+      updatesCount: serializedGraph.updates.length,
+      edgesCount: serializedGraph.edges.length,
+      hadPreviousGraph: !!prevAssetGraph,
+      safeToSkipBundling: serializedGraph.safeToSkipBundling,
+      graphNodeCount: graph._contentKeyToNodeId.size
+    };
+  }
+  function updateNode(newNode, isUpdateNode, index) {
+    let healDivergence = (0, _featureFlags().getFeatureFlag)('v3AssetGraphSyncImprovements');
+    if (isUpdateNode) {
+      let existingNode = graph.getNodeByContentKey(newNode.id);
+      if (healDivergence) {
+        if (existingNode) {
+          (0, _assert().default)(existingNode.type === newNode.type);
+          Object.assign(existingNode, newNode);
+        } else {
+          // Rust sent an update for a node JS doesn't have.
+          // This means JS's graph is stale. Add the node as new instead.
+          // This handles the "undefined == true" error class.
+          let diagnostics = buildDivergenceDiagnostics('update_node_not_found', newNode, existingNode, index);
+          _logger().default.warn({
+            origin: '@atlaspack/core',
+            message: `Rust/JS asset graph divergence healed: update node not found, ` + `adding as new. contentKey=${newNode.id} type=${newNode.type} iterationIndex=${index}`,
+            meta: {
+              trackableEvent: 'asset_graph_divergence_healed',
+              ...diagnostics
+            }
+          });
+          graph.addNodeByContentKey(newNode.id, newNode);
+        }
+      } else {
+        (0, _assert().default)(existingNode && existingNode.type === newNode.type);
+        Object.assign(existingNode, newNode);
+      }
+    } else {
+      if (healDivergence) {
+        if (graph.hasContentKey(newNode.id)) {
+          // Rust sent a "new" node that JS already has.
+          // This means JS's graph has nodes that Rust considers new.
+          // Treat as an update instead of throwing.
+          // This handles the "Graph already has content key" error class.
+          let existingNode = graph.getNodeByContentKey(newNode.id);
+          let diagnostics = buildDivergenceDiagnostics('new_node_already_exists', newNode, existingNode, index);
+          _logger().default.warn({
+            origin: '@atlaspack/core',
+            message: `Rust/JS asset graph divergence healed: new node already exists, ` + `treating as update. contentKey=${newNode.id} type=${newNode.type} iterationIndex=${index}`,
+            meta: {
+              trackableEvent: 'asset_graph_divergence_healed',
+              ...diagnostics
+            }
+          });
+          if (existingNode) {
+            Object.assign(existingNode, newNode);
+          }
+        } else {
+          graph.addNodeByContentKey(newNode.id, newNode);
+        }
+      } else {
+        try {
+          graph.addNodeByContentKey(newNode.id, newNode);
+        } catch (e) {
+          if (e instanceof Error && e.message.includes('already has content key')) {
+            let existingNode = graph.getNodeByContentKey(newNode.id);
+            let diagnostics = buildDivergenceDiagnostics('new_node_already_exists', newNode, existingNode, index);
+            throw new Error(`Graph already has content key '${newNode.id}'. Diagnostics: ${JSON.stringify(diagnostics, null, 2)}`);
+          }
+          throw e;
+        }
+      }
+    }
+  }
+  let nodeTypeSwitchoverIndex = serializedGraph.nodes.length;
+  let nodesCount = serializedGraph.nodes.length + serializedGraph.updates.length;
+  for (let index = 0; index < nodesCount; index++) {
+    let isUpdateNode = index >= nodeTypeSwitchoverIndex;
+    let node = isUpdateNode ? serializedGraph.updates[index - nodeTypeSwitchoverIndex] : serializedGraph.nodes[index];
+    node = JSON.parse(node);
+    if (node.type === 'entry') {
       let id = 'entry:' + ++entry;
       graph.addNodeByContentKey(id, {
         id: id,
@@ -137,8 +357,11 @@ function getAssetGraph(serializedGraph) {
       let id = asset.id;
       asset.committed = true;
       asset.contentKey = id;
-      asset.env.id = getEnvId(asset.env);
+      asset.env.id = (0, _featureFlags().getFeatureFlag)('environmentDeduplication') ?
+      // TODO: Rust can do this and avoid copying a significant amount of data over
+      (0, _Environment.getEnvironmentHash)(asset.env) : getEnvId(asset.env);
       asset.mapKey = `map:${asset.id}`;
+      asset.env = (0, _EnvironmentManager.toEnvironmentRef)(asset.env);
 
       // This is populated later when we map the edges between assets and dependencies
       asset.dependencies = new Map();
@@ -150,66 +373,75 @@ function getAssetGraph(serializedGraph) {
         asset.symbols = new Map(asset.symbols.map(mapSymbols));
       }
       changedAssets.set(id, asset);
-      graph.addNodeByContentKey(id, {
+      let assetNode = {
         id,
         type: 'asset',
         usedSymbols: new Set(),
         usedSymbolsDownDirty: true,
         usedSymbolsUpDirty: true,
         value: asset
-      });
+      };
+      updateNode(assetNode, isUpdateNode, index);
     } else if (node.type === 'dependency') {
-      let id = node.value.id;
-      let dependency = node.value.dependency;
+      let {
+        dependency,
+        id
+      } = node.value;
       dependency.id = id;
-      dependency.env.id = getEnvId(dependency.env);
+      dependency.env.id = (0, _featureFlags().getFeatureFlag)('environmentDeduplication') ?
+      // TODO: Rust can do this and avoid copying a significant amount of data over
+      (0, _Environment.getEnvironmentHash)(dependency.env) : getEnvId(dependency.env);
+      dependency.env = (0, _EnvironmentManager.toEnvironmentRef)(dependency.env);
       if (dependency.symbols != null) {
         var _dependency$symbols;
         dependency.symbols = new Map((_dependency$symbols = dependency.symbols) === null || _dependency$symbols === void 0 ? void 0 : _dependency$symbols.map(mapSymbols));
       }
       let usedSymbolsDown = new Set();
       let usedSymbolsUp = new Map();
+      if (node.used_symbols_up) {
+        for (let usedSymbol of node.used_symbols_up) {
+          // Transform Rust UsedSymbol { symbol: Symbol, asset: string, resolved_symbol: string }
+          // to JS format { symbol: string, asset: string } where symbol is the resolved name
+          const exportedName = usedSymbol.symbol.exported;
+          usedSymbolsUp.set(exportedName, {
+            asset: usedSymbol.asset,
+            symbol: usedSymbol.resolved_symbol ?? exportedName
+          });
+        }
+      }
       if (dependency.isEntry && dependency.isLibrary) {
         usedSymbolsDown.add('*');
         usedSymbolsUp.set('*', undefined);
       }
-      graph.addNodeByContentKey(id, {
+      let depNode = {
         id,
         type: 'dependency',
         deferred: false,
         excluded: false,
         hasDeferred: node.has_deferred,
+        // @ts-expect-error TS2322
         usedSymbolsDown,
         usedSymbolsDownDirty: true,
         usedSymbolsUp,
         usedSymbolsUpDirtyDown: true,
         usedSymbolsUpDirtyUp: true,
         value: dependency
-      });
+      };
+      updateNode(depNode, isUpdateNode, index);
     }
   }
-  for (let i = 0; i < serializedGraph.edges.length; i += 2) {
-    let from = serializedGraph.edges[i];
-    let to = serializedGraph.edges[i + 1];
-    let fromNode = graph.getNode(from);
-    let toNode = graph.getNode(to);
-    if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'dependency') {
-      (0, _assert().default)((toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'asset');
-
-      // For backwards compatibility, create asset group node if needed.
-      let assetGroupNode = (0, _AssetGraph.nodeFromAssetGroup)({
-        filePath: toNode.value.filePath,
-        env: fromNode.value.env,
-        pipeline: toNode.value.pipeline,
-        sideEffects: Boolean(toNode.value.sideEffects)
-      });
-      let index = graph.addNodeByContentKeyIfNeeded(assetGroupNode.id, assetGroupNode);
-      graph.addEdge(from, index);
-      graph.addEdge(index, to);
-    } else if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'asset' && (toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'dependency') {
-      fromNode.value.dependencies.set(toNode.value.id, toNode.value);
-      graph.addEdge(from, to);
-    } else {
+  if (!reuseEdges) {
+    for (let i = 0; i < serializedGraph.edges.length; i += 2) {
+      let from = serializedGraph.edges[i];
+      let to = serializedGraph.edges[i + 1];
+      let fromNode = graph.getNode(from);
+      let toNode = graph.getNode(to);
+      if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'dependency') {
+        (0, _assert().default)((toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'asset');
+      }
+      if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'asset' && (toNode === null || toNode === void 0 ? void 0 : toNode.type) === 'dependency') {
+        fromNode.value.dependencies.set(toNode.value.id, toNode.value);
+      }
       graph.addEdge(from, to);
     }
   }

package/lib/requests/AssetRequest.js

@@ -31,7 +31,8 @@ var _ConfigRequest = require("./ConfigRequest");
 var _projectPath = require("../projectPath");
 var _ReporterRunner = require("../ReporterRunner");
 var _RequestTracker = require("../RequestTracker");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _EnvironmentManager = require("../EnvironmentManager");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function createAssetRequest(input) {
   return {
     type: _RequestTracker.requestTypes.asset_request,
@@ -42,8 +43,10 @@ function createAssetRequest(input) {
 }
 const type = 'asset_request';
 function getId(input) {
-  return (0, _rust().hashString)(type + (0, _projectPath.fromProjectPathRelative)(input.filePath) + input.env.id + String(input.isSource) + String(input.sideEffects) + (input.code ?? '') + ':' + (input.pipeline ?? '') + ':' + (input.query ?? ''));
+  return (0, _rust().hashString)(type + (0, _projectPath.fromProjectPathRelative)(input.filePath) + (0, _EnvironmentManager.toEnvironmentId)(input.env) + String(input.isSource) + String(input.sideEffects) + (input.code ?? '') + ':' + (input.pipeline ?? '') + ':' + (input.query ?? ''));
 }
+
+// @ts-expect-error TS7031
 async function run({
   input,
   api,
@@ -64,17 +67,31 @@ async function run({
   } = input;
   let {
     cachePath
-  } = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
-  let previousDevDepRequests = new Map(await Promise.all(api.getSubRequests().filter(req => req.requestType === _RequestTracker.requestTypes.dev_dep_request).map(async req => [req.id, (0, _nullthrows().default)(await api.getRequestResult(req.id))])));
+  } = (0, _nullthrows().default)(
+  // @ts-expect-error TS2347
+  await api.runRequest((0, _AtlaspackConfigRequest.default)()));
+  let previousDevDepRequests = new Map(await Promise.all(api.getSubRequests()
+  // @ts-expect-error TS7006
+  .filter(req => req.requestType === _RequestTracker.requestTypes.dev_dep_request)
+  // @ts-expect-error TS7006
+  .map(async req => [req.id,
+  // @ts-expect-error TS2347
+  (0, _nullthrows().default)(await api.getRequestResult(req.id))])));
   let request = {
     ...rest,
     invalidateReason,
-    devDeps: new Map([...previousDevDepRequests.entries()].filter(([id]) => api.canSkipSubrequest(id)).map(([, req]) => [`${req.specifier}:${(0, _projectPath.fromProjectPathRelative)(req.resolveFrom)}`, req.hash])),
-    invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()].filter(([id]) => !api.canSkipSubrequest(id)).flatMap(([, req]) => {
+    devDeps: new Map([...previousDevDepRequests.entries()]
+    // @ts-expect-error TS2769
+    .filter(([id]) => api.canSkipSubrequest(id)).map(([, req]) => [`${req.specifier}:${(0, _projectPath.fromProjectPathRelative)(req.resolveFrom)}`, req.hash])),
+    invalidDevDeps: await Promise.all([...previousDevDepRequests.entries()]
+    // @ts-expect-error TS2769
+    .filter(([id]) => !api.canSkipSubrequest(id)).flatMap(([, req]) => {
       return [{
         specifier: req.specifier,
         resolveFrom: req.resolveFrom
-      }, ...(req.additionalInvalidations ?? []).map(i => ({
+      },
+      // @ts-expect-error TS7006
+      ...(req.additionalInvalidations ?? []).map(i => ({
         specifier: i.specifier,
         resolveFrom: i.resolveFrom
       }))];

package/lib/requests/AtlaspackBuildRequest.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = createAtlaspackBuildRequest;
 var _BundleGraphRequest = _interopRequireDefault(require("./BundleGraphRequest"));
+var _BundleGraphRequestRust = _interopRequireDefault(require("./BundleGraphRequestRust"));
 var _WriteBundlesRequest = _interopRequireDefault(require("./WriteBundlesRequest"));
 var _utils = require("../utils");
 var _dumpGraphToGraphViz = _interopRequireDefault(require("../dumpGraphToGraphViz"));
@@ -21,7 +22,22 @@ function _profiler() {
   return data;
 }
 var _RequestTracker = require("../RequestTracker");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
+var _EnvironmentManager = require("../EnvironmentManager");
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function createAtlaspackBuildRequest(input) {
   return {
     type: _RequestTracker.requestTypes.atlaspack_build_request,
@@ -41,7 +57,11 @@ async function run({
     requestedAssetIds,
     signal
   } = input;
-  let bundleGraphRequest = (0, _BundleGraphRequest.default)({
+  let bundleGraphRequest = (0, _featureFlags().getFeatureFlag)('nativeBundling') && rustAtlaspack ? (0, _BundleGraphRequestRust.default)({
+    optionsRef,
+    requestedAssetIds,
+    signal
+  }) : (0, _BundleGraphRequest.default)({
     optionsRef,
     requestedAssetIds,
     signal
@@ -49,31 +69,57 @@ async function run({
   let {
     bundleGraph,
     changedAssets,
-    assetRequests
+    assetRequests,
+    didIncrementallyBundle
   } = await api.runRequest(bundleGraphRequest, {
     force: Boolean(rustAtlaspack) || options.shouldBuildLazily && requestedAssetIds.size > 0
   });
+  if ((0, _featureFlags().getFeatureFlag)('nativePackager') && (0, _featureFlags().getFeatureFlag)('nativePackagerSSRDev') && rustAtlaspack) {
+    let hasSupportedTarget = false;
+    bundleGraph.traverseBundles((bundle, ctx, actions) => {
+      if ((0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context === 'tesseract' && bundle.type === 'js') {
+        hasSupportedTarget = true;
+        actions.stop();
+      }
+    });
+    if (hasSupportedTarget) {
+      if (didIncrementallyBundle) {
+        const changedAssetIds = Array.from(changedAssets.keys());
+        await rustAtlaspack.updateBundleGraph(bundleGraph, changedAssetIds);
+      } else {
+        await rustAtlaspack.loadBundleGraph(bundleGraph);
+      }
+    }
+  }
 
-  // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381 (Windows only)
+  // @ts-expect-error TS2345
   (0, _dumpGraphToGraphViz.default)(bundleGraph._graph, 'BundleGraph', _BundleGraph.bundleGraphEdgeTypes);
   await (0, _ReporterRunner.report)({
     type: 'buildProgress',
     phase: 'bundled',
-    bundleGraph: new _BundleGraph2.default(bundleGraph, (bundle, bundleGraph, options) => _Bundle.NamedBundle.get(bundle, bundleGraph, options), options),
+    bundleGraph: new _BundleGraph2.default(bundleGraph,
+    // @ts-expect-error TS2304
+    (bundle, bundleGraph, options) => _Bundle.NamedBundle.get(bundle, bundleGraph, options), options),
     changedAssets: new Map(Array.from(changedAssets).map(([id, asset]) => [id, (0, _Asset.assetFromValue)(asset, options)]))
   });
   let packagingMeasurement = _profiler().tracer.createMeasurement('packaging');
+  const span = _logger().tracer.enter('writeBundles');
   let writeBundlesRequest = (0, _WriteBundlesRequest.default)({
     bundleGraph,
     optionsRef
   });
-  let bundleInfo = await api.runRequest(writeBundlesRequest);
+  let {
+    bundleInfo,
+    scopeHoistingStats
+  } = await api.runRequest(writeBundlesRequest);
   packagingMeasurement && packagingMeasurement.end();
+  _logger().tracer.exit(span);
   (0, _utils.assertSignalNotAborted)(signal);
   return {
     bundleGraph,
     bundleInfo,
     changedAssets,
-    assetRequests
+    assetRequests,
+    scopeHoistingStats
   };
 }