@atlaspack/core 2.38.3-dev-862af7d26.0 → 2.38.4

package/lib/requests/AssetGraphRequestRust.js

@@ -75,29 +75,6 @@ function createAssetGraphRequestRust(rustAtlaspack) {
         return getAssetGraph(serializedAssetGraph, (_prevResult = prevResult) === null || _prevResult === void 0 ? void 0 : _prevResult.assetGraph);
       });
       let changedAssetsPropagation = new Set(changedAssets.keys());
-      // 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 result = {
         assetGraph,
         assetRequests: [],
@@ -106,16 +83,55 @@ function createAssetGraphRequestRust(rustAtlaspack) {
         changedAssetsPropagation,
         previousSymbolPropagationErrors: undefined
       };
-      let [_commitResult, commitError] = await commitPromise;
-      if (commitError) {
-        throw new (_diagnostic().default)({
-          diagnostic: {
-            message: 'Error committing asset graph in Rust: ' + commitError.message
+
+      // 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;
       }
-      await runInput.api.storeResult(result);
-      runInput.api.invalidateOnBuild();
       return result;
     },
     input
@@ -124,25 +140,48 @@ function createAssetGraphRequestRust(rustAtlaspack) {
 function getAssetGraph(serializedGraph, prevAssetGraph) {
   let graph;
   let reuseEdges = false;
+  let clonePrevGraph = (0, _featureFlags().getFeatureFlag)('v3AssetGraphSyncImprovements');
   if (prevAssetGraph && serializedGraph.safeToSkipBundling) {
-    graph = new _AssetGraph.default({
-      _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
-      _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
-      nodes: prevAssetGraph.nodes,
-      rootNodeId: prevAssetGraph.rootNodeId,
-      adjacencyList: prevAssetGraph.adjacencyList
-    });
+    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)) {
-    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
-    });
+    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({
@@ -220,33 +259,83 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
     }
     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);
-      (0, _assert().default)(existingNode && existingNode.type === newNode.type);
-      Object.assign(existingNode, newNode);
+      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 {
-      try {
-        graph.addNodeByContentKey(newNode.id, newNode);
-      } catch (e) {
-        if (e instanceof Error && e.message.includes('already has content key')) {
+      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 = {
-            contentKey: newNode.id,
-            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
-          };
-          throw new Error(`Graph already has content key '${newNode.id}'. Diagnostics: ${JSON.stringify(diagnostics, null, 2)}`);
+          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;
         }
-        throw e;
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.38.3-dev-862af7d26.0",
+  "version": "2.38.4",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -22,23 +22,23 @@
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.15-dev-862af7d26.0",
-    "@atlaspack/cache": "3.2.56-dev-862af7d26.0",
-    "@atlaspack/diagnostic": "2.14.5-dev-862af7d26.0",
-    "@atlaspack/events": "2.14.5-dev-862af7d26.0",
-    "@atlaspack/feature-flags": "2.31.1-dev-862af7d26.0",
-    "@atlaspack/fs": "2.15.56-dev-862af7d26.0",
-    "@atlaspack/graph": "3.6.23-dev-862af7d26.0",
-    "@atlaspack/logger": "2.14.53-dev-862af7d26.0",
-    "@atlaspack/package-manager": "2.14.61-dev-862af7d26.0",
-    "@atlaspack/plugin": "2.14.61-dev-862af7d26.0",
-    "@atlaspack/profiler": "2.15.22-dev-862af7d26.0",
-    "@atlaspack/rust": "3.28.1-dev-862af7d26.0",
-    "@atlaspack/source-map": "3.3.5-dev-862af7d26.0",
-    "@atlaspack/types": "2.15.51-dev-862af7d26.0",
-    "@atlaspack/utils": "3.4.3-dev-862af7d26.0",
-    "@atlaspack/workers": "2.14.61-dev-862af7d26.0",
     "@mischnic/json-sourcemap": "^0.1.0",
+    "@atlaspack/build-cache": "2.13.16",
+    "@atlaspack/cache": "3.2.57",
+    "@atlaspack/diagnostic": "2.14.4",
+    "@atlaspack/events": "2.14.4",
+    "@atlaspack/feature-flags": "2.31.2",
+    "@atlaspack/fs": "2.15.57",
+    "@atlaspack/graph": "3.6.24",
+    "@atlaspack/logger": "2.14.54",
+    "@atlaspack/package-manager": "2.14.62",
+    "@atlaspack/plugin": "2.14.62",
+    "@atlaspack/profiler": "2.15.23",
+    "@atlaspack/rust": "3.29.1",
+    "@atlaspack/types": "2.15.52",
+    "@atlaspack/utils": "3.4.4",
+    "@atlaspack/workers": "2.14.62",
+    "@atlaspack/source-map": "3.3.6",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",
@@ -50,16 +50,15 @@
     "semver": "^7.5.2"
   },
   "devDependencies": {
-    "@atlaspack/babel-register": "2.14.5-dev-862af7d26.0",
+    "@atlaspack/babel-register": "2.14.5",
     "@types/node": ">= 18",
-    "graphviz": "^0.0.9",
-    "jest-diff": "*",
     "rfdc": "1",
+    "jest-diff": "*",
+    "graphviz": "^0.0.9",
     "tempy": "^0.2.1"
   },
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "type": "commonjs",
-  "gitHead": "862af7d26148df894cc5217b53d6cfac1bdc1026"
+  "type": "commonjs"
 }

package/src/BundleGraph.ts

@@ -335,7 +335,9 @@ export default class BundleGraph {
             ([, t]: [any, any]) => new Set([...t.values()]).size === t.size,
           )
         ) {
-          let isReexportAll = nodeValueSymbols.get('*')?.local === '*';
+          let isReexportAll =
+            nodeValueSymbols.get('*')?.local === '*' ||
+            node.value.meta?.hasExportStar;
           let reexportAllLoc = isReexportAll
             ? nullthrows(nodeValueSymbols.get('*')).loc
             : undefined;
@@ -2317,7 +2319,7 @@ export default class BundleGraph {
       // Wildcard reexports are never listed in the reexporting asset's symbols.
       if (
         identifier == null &&
-        depSymbols.get('*')?.local === '*' &&
+        (depSymbols.get('*')?.local === '*' || dep.meta?.hasExportStar) &&
         symbol !== 'default'
       ) {
         let resolved = this.getResolvedAsset(dep, boundary);
@@ -2455,7 +2457,7 @@ export default class BundleGraph {
       let depSymbols = dep.symbols;
       if (!depSymbols) continue;
 
-      if (depSymbols.get('*')?.local === '*') {
+      if (depSymbols.get('*')?.local === '*' || dep.meta?.hasExportStar) {
         let resolved = this.getResolvedAsset(dep, boundary);
         if (!resolved) continue;
         let exported = this.getExportedSymbols(resolved, boundary)

package/src/SymbolPropagation.ts

@@ -1,7 +1,6 @@
 import type {ContentKey, NodeId} from '@atlaspack/graph';
 import type {Meta, Symbol} from '@atlaspack/types';
 import type {Diagnostic} from '@atlaspack/diagnostic';
-import {getFeatureFlag} from '@atlaspack/feature-flags';
 import type {
   AssetNode,
   DependencyNode,
@@ -95,7 +94,9 @@ export function propagateSymbols({
           }
         }
         let hasNamespaceOutgoingDeps = outgoingDeps.some(
-          (d) => d.value.symbols?.get('*')?.local === '*',
+          (d) =>
+            d.value.symbols?.get('*')?.local === '*' ||
+            d.value.meta?.hasExportStar,
         );
 
         // 1) Determine what the incomingDeps requests from the asset
@@ -192,7 +193,10 @@ export function propagateSymbols({
             let depSymbols = dep.value.symbols;
             if (!depSymbols) continue;
 
-            if (depSymbols.get('*')?.local === '*') {
+            if (
+              depSymbols.get('*')?.local === '*' ||
+              dep.value.meta?.hasExportStar
+            ) {
               if (addAll) {
                 depUsedSymbolsDown.add('*');
               } else {
@@ -335,7 +339,10 @@ export function propagateSymbols({
             );
           }
 
-          if (outgoingDepSymbols.get('*')?.local === '*') {
+          if (
+            outgoingDepSymbols.get('*')?.local === '*' ||
+            outgoingDep.value.meta?.hasExportStar
+          ) {
             outgoingDep.usedSymbolsUp.forEach((sResolved, s) => {
               if (s === 'default') {
                 return;
@@ -453,7 +460,9 @@ export function propagateSymbols({
           let incomingDepSymbols = incomingDep.value.symbols;
           if (!incomingDepSymbols) continue;
 
-          let hasNamespaceReexport = incomingDepSymbols.get('*')?.local === '*';
+          let hasNamespaceReexport =
+            incomingDepSymbols.get('*')?.local === '*' ||
+            incomingDep.value.meta?.hasExportStar;
           for (let s of incomingDep.usedSymbolsDown) {
             if (
               assetSymbols == null || // Assume everything could be provided if symbols are cleared