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

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @atlaspack/core
 
+## 2.38.3
+
+### Patch Changes
+
+- [#1065](https://github.com/atlassian-labs/atlaspack/pull/1065) [`e898fda`](https://github.com/atlassian-labs/atlaspack/commit/e898fda7511d98e5597d847c4a32c028a8a24d6c) Thanks [@at-nathan](https://github.com/at-nathan)! - Update third-party dependencies to align with AFM
+
+- [#1073](https://github.com/atlassian-labs/atlaspack/pull/1073) [`3ff901a`](https://github.com/atlassian-labs/atlaspack/commit/3ff901a222d5e077a3bb96031a89c3b5173ece69) Thanks [@matt-koko](https://github.com/matt-koko)! - Improve Rust/JS asset graph interop for atlaspack v3 by reducing scenarios where Rust/JS can diverge their respective previous asset graphs.
+
+- Updated dependencies [[`07edc83`](https://github.com/atlassian-labs/atlaspack/commit/07edc83079f6a752b09b28a9fe8b45f6523f0f81), [`e898fda`](https://github.com/atlassian-labs/atlaspack/commit/e898fda7511d98e5597d847c4a32c028a8a24d6c), [`3ff901a`](https://github.com/atlassian-labs/atlaspack/commit/3ff901a222d5e077a3bb96031a89c3b5173ece69), [`e8fe5c0`](https://github.com/atlassian-labs/atlaspack/commit/e8fe5c0070f0d92d68f98902edcc96dc82c1e52d), [`ff7e3f0`](https://github.com/atlassian-labs/atlaspack/commit/ff7e3f08c3977b0d9b9edfe739a8e596abbdd729), [`508e15c`](https://github.com/atlassian-labs/atlaspack/commit/508e15c7acd187703bade4d613ca7f5739ae3af7), [`34c7cec`](https://github.com/atlassian-labs/atlaspack/commit/34c7cecebae240f11f36971b4eeaeaaf579531c9), [`5256d37`](https://github.com/atlassian-labs/atlaspack/commit/5256d37a88334554ae78456622389c97f66a2196)]:
+  - @atlaspack/rust@3.29.0
+  - @atlaspack/cache@3.2.56
+  - @atlaspack/utils@3.4.3
+  - @atlaspack/feature-flags@2.31.1
+  - @atlaspack/fs@2.15.56
+  - @atlaspack/logger@2.14.53
+  - @atlaspack/source-map@3.3.5
+  - @atlaspack/package-manager@2.14.61
+  - @atlaspack/profiler@2.15.22
+  - @atlaspack/workers@2.14.61
+  - @atlaspack/build-cache@2.13.15
+  - @atlaspack/graph@3.6.23
+  - @atlaspack/types@2.15.51
+  - @atlaspack/plugin@2.14.61
+
 ## 2.38.2
 
 ### Patch Changes

package/dist/requests/AssetGraphRequestRust.js

@@ -74,30 +74,6 @@ function createAssetGraphRequestRust(rustAtlaspack) {
             }
             let { assetGraph, changedAssets } = (0, logger_1.instrument)('atlaspack_v3_getAssetGraph', () => getAssetGraph(serializedAssetGraph, prevResult?.assetGraph));
             let changedAssetsPropagation = new Set(changedAssets.keys());
-            // Skip symbol propagation for runtime assets - they have pre-computed symbol data
-            if (input.skipSymbolProp) {
-                logger_1.default.verbose({
-                    origin: '@atlaspack/core',
-                    message: 'Skipping symbol propagation for runtime asset graph',
-                });
-            }
-            else {
-                let errors = (0, SymbolPropagation_1.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_1.default({
-                        diagnostic: [...errors.values()][0],
-                    });
-                }
-            }
-            await (0, dumpGraphToGraphViz_1.default)(assetGraph, 'AssetGraphV3');
             let result = {
                 assetGraph,
                 assetRequests: [],
@@ -106,16 +82,56 @@ function createAssetGraphRequestRust(rustAtlaspack) {
                 changedAssetsPropagation,
                 previousSymbolPropagationErrors: undefined,
             };
-            let [_commitResult, commitError] = await commitPromise;
-            if (commitError) {
-                throw new diagnostic_1.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, feature_flags_1.getFeatureFlag)('v3AssetGraphSyncImprovements');
+            try {
+                // Skip symbol propagation for runtime assets - they have pre-computed symbol data
+                if (input.skipSymbolProp) {
+                    logger_1.default.verbose({
+                        origin: '@atlaspack/core',
+                        message: 'Skipping symbol propagation for runtime asset graph',
+                    });
+                }
+                else {
+                    let errors = (0, SymbolPropagation_1.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_1.default({
+                            diagnostic: [...errors.values()][0],
+                        });
+                    }
+                }
+                await (0, dumpGraphToGraphViz_1.default)(assetGraph, 'AssetGraphV3');
+                let [_commitResult, commitError] = await commitPromise;
+                if (commitError) {
+                    throw new diagnostic_1.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,27 +140,52 @@ function createAssetGraphRequestRust(rustAtlaspack) {
 function getAssetGraph(serializedGraph, prevAssetGraph) {
     let graph;
     let reuseEdges = false;
+    let clonePrevGraph = (0, feature_flags_1.getFeatureFlag)('v3AssetGraphSyncImprovements');
     if (prevAssetGraph && serializedGraph.safeToSkipBundling) {
-        graph = new AssetGraph_1.default({
-            _contentKeyToNodeId: prevAssetGraph._contentKeyToNodeId,
-            _nodeIdToContentKey: prevAssetGraph._nodeIdToContentKey,
-            nodes: prevAssetGraph.nodes,
-            rootNodeId: prevAssetGraph.rootNodeId,
-            adjacencyList: prevAssetGraph.adjacencyList,
-        });
+        if (clonePrevGraph) {
+            graph = new AssetGraph_1.default({
+                _contentKeyToNodeId: new Map(prevAssetGraph._contentKeyToNodeId),
+                _nodeIdToContentKey: new Map(prevAssetGraph._nodeIdToContentKey),
+                nodes: [...prevAssetGraph.nodes],
+                rootNodeId: prevAssetGraph.rootNodeId,
+                adjacencyList: prevAssetGraph.adjacencyList,
+            });
+        }
+        else {
+            graph = new AssetGraph_1.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_1.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_1.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_1.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 {
@@ -228,36 +269,92 @@ 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, feature_flags_1.getFeatureFlag)('v3AssetGraphSyncImprovements');
         if (isUpdateNode) {
             let existingNode = graph.getNodeByContentKey(newNode.id);
-            (0, assert_2.default)(existingNode && existingNode.type === newNode.type);
-            Object.assign(existingNode, newNode);
+            if (healDivergence) {
+                if (existingNode) {
+                    (0, assert_2.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_1.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_2.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_1.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/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.3",
   "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.15",
+    "@atlaspack/cache": "3.2.56",
+    "@atlaspack/diagnostic": "2.14.4",
+    "@atlaspack/events": "2.14.4",
+    "@atlaspack/feature-flags": "2.31.1",
+    "@atlaspack/fs": "2.15.56",
+    "@atlaspack/graph": "3.6.23",
+    "@atlaspack/logger": "2.14.53",
+    "@atlaspack/package-manager": "2.14.61",
+    "@atlaspack/plugin": "2.14.61",
+    "@atlaspack/profiler": "2.15.22",
+    "@atlaspack/rust": "3.29.0",
+    "@atlaspack/types": "2.15.51",
+    "@atlaspack/utils": "3.4.3",
+    "@atlaspack/workers": "2.14.61",
+    "@atlaspack/source-map": "3.3.5",
     "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"
 }