@depup/react-native 0.86.2-depup.0 → 0.87.0-depup.0

package/ReactCommon/react/renderer/mounting/Differentiator.cpp

@@ -11,9 +11,8 @@
 #include <react/debug/react_native_assert.h>
 #include <react/featureflags/ReactNativeFeatureFlags.h>
 #include <algorithm>
+#include <unordered_map>
 #include "internal/CullingContext.h"
-#include "internal/DiffMap.h"
-#include "internal/LongestIncreasingSubsequence.h"
 #include "internal/ShadowViewNodePair.h"
 #include "internal/sliceChildShadowNodeViewPairs.h"
 
@@ -59,7 +58,9 @@ static std::ostream& operator<<(
 
 #ifdef DEBUG_LOGS_DIFFER
 template <typename KeyT, typename ValueT>
-static std::ostream& operator<<(std::ostream& out, DiffMap<KeyT, ValueT>& map) {
+static std::ostream& operator<<(
+    std::ostream& out,
+    const std::unordered_map<KeyT, ValueT>& map) {
   auto it = map.begin();
   if (it != map.end()) {
     out << *it->second;
@@ -144,7 +145,7 @@ struct OrderedMutationInstructionContainer {
 static void updateMatchedPairSubtrees(
     ViewNodePairScope& scope,
     OrderedMutationInstructionContainer& mutationContainer,
-    DiffMap<Tag, ShadowViewNodePair*>& newRemainingPairs,
+    std::unordered_map<Tag, ShadowViewNodePair*>& newRemainingPairs,
     std::vector<ShadowViewNodePair*>& oldChildPairs,
     Tag parentTag,
     const ShadowViewNodePair& oldPair,
@@ -165,11 +166,11 @@ static void calculateShadowViewMutationsFlattener(
     ReparentMode reparentMode,
     OrderedMutationInstructionContainer& mutationContainer,
     Tag parentTag,
-    DiffMap<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
     const ShadowViewNodePair& node,
     Tag parentTagForUpdate,
-    DiffMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
-    DiffMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
     const CullingContext& cullingContextForUnvisitedOtherNodes,
     const CullingContext& cullingContext);
 
@@ -184,7 +185,7 @@ static void calculateShadowViewMutationsFlattener(
 static void updateMatchedPairSubtrees(
     ViewNodePairScope& scope,
     OrderedMutationInstructionContainer& mutationContainer,
-    DiffMap<Tag, ShadowViewNodePair*>& newRemainingPairs,
+    std::unordered_map<Tag, ShadowViewNodePair*>& newRemainingPairs,
     std::vector<ShadowViewNodePair*>& oldChildPairs,
     Tag parentTag,
     const ShadowViewNodePair& oldPair,
@@ -240,8 +241,8 @@ static void updateMatchedPairSubtrees(
       // interwoven with children from other nodes, etc.
       auto oldFlattenedNodes = sliceChildShadowNodeViewPairsFromViewNodePair(
           oldPair, scope, true, oldCullingContextCopy);
-      auto unvisitedOldChildPairs =
-          DiffMap<Tag, ShadowViewNodePair*>(oldFlattenedNodes.size());
+      std::unordered_map<Tag, ShadowViewNodePair*> unvisitedOldChildPairs;
+      unvisitedOldChildPairs.reserve(oldFlattenedNodes.size());
       for (size_t i = 0, j = 0;
            i < oldChildPairs.size() && j < oldFlattenedNodes.size();
            i++) {
@@ -424,11 +425,11 @@ static void calculateShadowViewMutationsFlattener(
     ReparentMode reparentMode,
     OrderedMutationInstructionContainer& mutationContainer,
     Tag parentTag,
-    DiffMap<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>& unvisitedOtherNodes,
     const ShadowViewNodePair& node,
     Tag parentTagForUpdate,
-    DiffMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
-    DiffMap<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>* parentSubVisitedOtherNewNodes,
+    std::unordered_map<Tag, ShadowViewNodePair*>* parentSubVisitedOtherOldNodes,
     const CullingContext& cullingContextForUnvisitedOtherNodes,
     const CullingContext& cullingContext) {
   // Step 1: iterate through entire tree
@@ -447,8 +448,8 @@ static void calculateShadowViewMutationsFlattener(
 
   // Views in other tree that are visited by sub-flattening or
   // sub-unflattening
-  DiffMap<Tag, ShadowViewNodePair*> subVisitedOtherNewNodes{};
-  DiffMap<Tag, ShadowViewNodePair*> subVisitedOtherOldNodes{};
+  std::unordered_map<Tag, ShadowViewNodePair*> subVisitedOtherNewNodes{};
+  std::unordered_map<Tag, ShadowViewNodePair*> subVisitedOtherOldNodes{};
   auto subVisitedNewMap =
       (parentSubVisitedOtherNewNodes != nullptr ? parentSubVisitedOtherNewNodes
                                                 : &subVisitedOtherNewNodes);
@@ -457,8 +458,9 @@ static void calculateShadowViewMutationsFlattener(
                                                 : &subVisitedOtherOldNodes);
 
   // Candidates for full tree creation or deletion at the end of this function
-  auto deletionCreationCandidatePairs =
-      DiffMap<Tag, const ShadowViewNodePair*>(treeChildren.size());
+  std::unordered_map<Tag, const ShadowViewNodePair*>
+      deletionCreationCandidatePairs;
+  deletionCreationCandidatePairs.reserve(treeChildren.size());
 
   for (size_t index = 0;
        index < treeChildren.size() && index < treeChildren.size();
@@ -701,8 +703,9 @@ static void calculateShadowViewMutationsFlattener(
                   ? adjustedNewCullingContext
                   : adjustedOldCullingContext);
           // Construct unvisited nodes map
-          auto unvisitedRecursiveChildPairs =
-              DiffMap<Tag, ShadowViewNodePair*>(flattenedNodes.size());
+          std::unordered_map<Tag, ShadowViewNodePair*>
+              unvisitedRecursiveChildPairs;
+          unvisitedRecursiveChildPairs.reserve(flattenedNodes.size());
           for (auto& flattenedNode : flattenedNodes) {
             auto& newChild = *flattenedNode;
 
@@ -889,20 +892,6 @@ static void calculateShadowViewMutations(
   // Lists of mutations
   auto mutationContainer = OrderedMutationInstructionContainer{};
 
-  if (ReactNativeFeatureFlags::
-          enableDifferentiatorMutationVectorPreallocation()) {
-    // Pre-allocate mutation sub-vectors based on expected child count to avoid
-    // repeated reallocations during diffing.
-    size_t estimatedSize = std::max(oldChildPairs.size(), newChildPairs.size());
-    mutationContainer.createMutations.reserve(estimatedSize);
-    mutationContainer.deleteMutations.reserve(estimatedSize);
-    mutationContainer.insertMutations.reserve(estimatedSize);
-    mutationContainer.removeMutations.reserve(estimatedSize);
-    mutationContainer.updateMutations.reserve(estimatedSize);
-    mutationContainer.downwardMutations.reserve(estimatedSize);
-    mutationContainer.destructiveDownwardMutations.reserve(estimatedSize);
-  }
-
   DEBUG_LOGS({
     LOG(ERROR) << "Differ Entry: Child Pairs of node: [" << parentTag << "]";
     LOG(ERROR) << "> Old Child Pairs: " << oldChildPairs;
@@ -1053,273 +1042,15 @@ static void calculateShadowViewMutations(
           oldCullingContext,
           newCullingContextCopy);
     }
-  } else if (ReactNativeFeatureFlags::useLISAlgorithmInDifferentiator()) {
-    // LIS-based Stage 4: find the Longest Increasing Subsequence of
-    // new-list positions among old children to minimize REMOVE/INSERT
-    // mutations. Items in the LIS maintain their relative order and
-    // don't need REMOVE+INSERT — only items outside the LIS are moved.
-    auto remainingOldCount = oldChildPairs.size() - lastIndexAfterFirstStage;
-    auto remainingNewCount = newChildPairs.size() - lastIndexAfterFirstStage;
-
-    // Build newRemainingPairs (required by updateMatchedPairSubtrees for
-    // flattening logic) and tag→index map for O(1) lookups in Step 1.
-    auto newRemainingPairs =
-        DiffMap<Tag, ShadowViewNodePair*>(remainingNewCount);
-    auto newTagToIndex = DiffMap<Tag, size_t>(remainingNewCount);
-    for (size_t i = lastIndexAfterFirstStage; i < newChildPairs.size(); i++) {
-      auto& newChildPair = *newChildPairs[i];
-      newRemainingPairs.insert({newChildPair.shadowView.tag, &newChildPair});
-      newTagToIndex.insert({newChildPair.shadowView.tag, i});
-    }
-
-    // Step 1: Map old children to their positions in the new list.
-    std::vector<size_t> oldToNewPos(remainingOldCount);
-    std::vector<bool> oldExistsInNew(remainingOldCount, false);
-
-    for (size_t i = 0; i < remainingOldCount; i++) {
-      auto oldIdx = lastIndexAfterFirstStage + i;
-      Tag oldTag = oldChildPairs[oldIdx]->shadowView.tag;
-      auto it = newTagToIndex.find(oldTag);
-      if (it != newTagToIndex.end()) {
-        oldToNewPos[i] = it->second;
-        oldExistsInNew[i] = true;
-      }
-    }
-
-    // Step 2: Compute LIS of new-list positions.
-    auto inLIS = longestIncreasingSubsequence(oldToNewPos, oldExistsInNew);
-
-    auto deletionCandidatePairs = std::vector<const ShadowViewNodePair*>{};
-    deletionCandidatePairs.reserve(remainingOldCount);
-
-    // New-child-indexed flag: true = LIS match that stays in place.
-    auto isLISMatch = std::vector<bool>(remainingNewCount, false);
-
-    // Step 4: Process old children.
-    // CRITICAL: check newRemainingPairs at runtime (not the pre-computed
-    // oldExistsInNew). The flattener erases entries from newRemainingPairs
-    // as it consumes them during flatten/unflatten — using the pre-computed
-    // snapshot would cause double-processing of flattened nodes.
-    react_native_assert(inLIS.size() == remainingOldCount);
-    for (size_t i = 0; i < remainingOldCount; i++) {
-      auto oldIdx = lastIndexAfterFirstStage + i;
-      auto& oldChildPair = *oldChildPairs[oldIdx];
-      Tag oldTag = oldChildPair.shadowView.tag;
-
-      auto newIt = newRemainingPairs.find(oldTag);
-      if (newIt == newRemainingPairs.end()) {
-        // Not in new list or consumed by flattening -> REMOVE.
-        if (!oldChildPair.isConcreteView) {
-          continue;
-        }
-
-        DEBUG_LOGS({
-          LOG(ERROR) << "Differ LIS Branch: Removing deleted tag: "
-                     << oldChildPair << " with parent: [" << parentTag << "]";
-        });
-
-        // Edge case: complex (un)flattening — node exists in other tree.
-        if (oldChildPair.inOtherTree() &&
-            oldChildPair.otherTreePair->isConcreteView) {
-          const ShadowView& otherTreeView =
-              oldChildPair.otherTreePair->shadowView;
-          mutationContainer.removeMutations.push_back(
-              ShadowViewMutation::RemoveMutation(
-                  parentTag,
-                  otherTreeView,
-                  static_cast<int>(oldChildPair.mountIndex)));
-          continue;
-        }
-
-        mutationContainer.removeMutations.push_back(
-            ShadowViewMutation::RemoveMutation(
-                parentTag,
-                oldChildPair.shadowView,
-                static_cast<int>(oldChildPair.mountIndex)));
-        deletionCandidatePairs.push_back(&oldChildPair);
-
-      } else if (inLIS[i]) {
-        // In LIS -> stays in place, just UPDATE + subtree recursion.
-        auto& newChildPair = *newIt->second;
-
-        DEBUG_LOGS({
-          LOG(ERROR) << "Differ LIS Branch: Matched in-order (LIS) at old "
-                     << oldIdx << ": " << oldChildPair << " with parent: ["
-                     << parentTag << "]";
-        });
-
-        // For LIS matches with concrete-ness changes, we must use
-        // (true, false) to avoid generating INSERT in updateMatchedPair.
-        // INSERT mutations must be in new-child order (Step 5), not
-        // old-child order (Step 4). Generating INSERT here would put it
-        // out of order relative to Step 5's INSERTs.
-        bool concreteChanged =
-            oldChildPair.isConcreteView != newChildPair.isConcreteView;
-
-        updateMatchedPair(
-            mutationContainer,
-            true,
-            !concreteChanged,
-            parentTag,
-            oldChildPair,
-            newChildPair);
-
-        updateMatchedPairSubtrees(
-            scope,
-            mutationContainer,
-            newRemainingPairs,
-            oldChildPairs,
-            parentTag,
-            oldChildPair,
-            newChildPair,
-            oldCullingContext,
-            newCullingContext);
-
-        if (!concreteChanged) {
-          // Check if this LIS match was consumed by flattening.
-          // updateMatchedPairSubtrees may erase entries from
-          // newRemainingPairs during flatten/unflatten transitions.
-          // If consumed, the node was reparented elsewhere and needs
-          // REMOVE from this parent.
-          if (newRemainingPairs.find(oldTag) != newRemainingPairs.end()) {
-            isLISMatch[oldToNewPos[i] - lastIndexAfterFirstStage] = true;
-          } else if (oldChildPair.isConcreteView) {
-            if (oldChildPair.inOtherTree() &&
-                oldChildPair.otherTreePair->isConcreteView) {
-              mutationContainer.removeMutations.push_back(
-                  ShadowViewMutation::RemoveMutation(
-                      parentTag,
-                      oldChildPair.otherTreePair->shadowView,
-                      static_cast<int>(oldChildPair.mountIndex)));
-            } else {
-              mutationContainer.removeMutations.push_back(
-                  ShadowViewMutation::RemoveMutation(
-                      parentTag,
-                      oldChildPair.shadowView,
-                      static_cast<int>(oldChildPair.mountIndex)));
-              deletionCandidatePairs.push_back(&oldChildPair);
-            }
-          }
-        }
-        // concreteChanged: not in isLISMatch, Step 5 handles INSERT.
-
-      } else {
-        // In new list but NOT in LIS -> REMOVE from old position.
-        // Will be re-inserted at new position in Step 5.
-        auto& newChildPair = *newIt->second;
-
-        DEBUG_LOGS({
-          LOG(ERROR)
-              << "Differ LIS Branch: Matched out-of-order (not in LIS) at old "
-              << oldIdx << ": " << oldChildPair << " with parent: ["
-              << parentTag << "]";
-        });
-
-        updateMatchedPair(
-            mutationContainer,
-            true,
-            false,
-            parentTag,
-            oldChildPair,
-            newChildPair);
-
-        updateMatchedPairSubtrees(
-            scope,
-            mutationContainer,
-            newRemainingPairs,
-            oldChildPairs,
-            parentTag,
-            oldChildPair,
-            newChildPair,
-            oldCullingContext,
-            newCullingContext);
-      }
-    }
-
-    // Step 5: Process new children — INSERT + CREATE.
-    // Generate INSERT for every non-LIS-matched concrete new child.
-    // Only generate CREATE for genuinely new children (not in other tree
-    // from flattening).
-    for (size_t i = lastIndexAfterFirstStage; i < newChildPairs.size(); i++) {
-      auto& newChildPair = *newChildPairs[i];
-
-      if (!newChildPair.isConcreteView) {
-        continue;
-      }
-
-      // LIS matches stay in place — no INSERT needed.
-      if (isLISMatch[i - lastIndexAfterFirstStage]) {
-        continue;
-      }
-
-      DEBUG_LOGS({
-        LOG(ERROR) << "Differ LIS Branch: Inserting tag: " << newChildPair
-                   << " with parent: [" << parentTag << "]"
-                   << (newChildPair.inOtherTree() ? " (in other tree)" : "");
-      });
-
-      mutationContainer.insertMutations.push_back(
-          ShadowViewMutation::InsertMutation(
-              parentTag,
-              newChildPair.shadowView,
-              static_cast<int>(newChildPair.mountIndex)));
-
-      // Only CREATE genuinely new children (not matched by flattening).
-      if (!newChildPair.inOtherTree()) {
-        mutationContainer.createMutations.push_back(
-            ShadowViewMutation::CreateMutation(newChildPair.shadowView));
-
-        auto newCullingContextCopy =
-            newCullingContext.adjustCullingContextIfNeeded(newChildPair);
-
-        ViewNodePairScope innerScope{};
-        calculateShadowViewMutations(
-            innerScope,
-            mutationContainer.downwardMutations,
-            newChildPair.shadowView.tag,
-            {},
-            sliceChildShadowNodeViewPairsFromViewNodePair(
-                newChildPair, innerScope, false, newCullingContextCopy),
-            oldCullingContext,
-            newCullingContextCopy);
-      }
-    }
-
-    // Step 6: Generate DELETE for deletion candidates.
-    for (const auto* deletionCandidatePtr : deletionCandidatePairs) {
-      const auto& oldChildPair = *deletionCandidatePtr;
-
-      DEBUG_LOGS({
-        LOG(ERROR) << "Differ LIS Branch: Deleting removed tag: "
-                   << oldChildPair << " with parent: [" << parentTag << "]";
-      });
-
-      if (!oldChildPair.inOtherTree() && oldChildPair.isConcreteView) {
-        mutationContainer.deleteMutations.push_back(
-            ShadowViewMutation::DeleteMutation(oldChildPair.shadowView));
-        auto oldCullingContextCopy =
-            oldCullingContext.adjustCullingContextIfNeeded(oldChildPair);
-
-        ViewNodePairScope innerScope{};
-        auto grandChildPairs = sliceChildShadowNodeViewPairsFromViewNodePair(
-            oldChildPair, innerScope, false, oldCullingContextCopy);
-        calculateShadowViewMutations(
-            innerScope,
-            mutationContainer.destructiveDownwardMutations,
-            oldChildPair.shadowView.tag,
-            std::move(grandChildPairs),
-            {},
-            oldCullingContextCopy,
-            newCullingContext);
-      }
-    }
   } else {
-    // Existing greedy Stage 4 algorithm.
+    // Greedy Stage 4 algorithm.
     // Collect map of tags in the new list
     auto remainingCount = newChildPairs.size() - lastIndexAfterFirstStage;
-    auto newRemainingPairs = DiffMap<Tag, ShadowViewNodePair*>(remainingCount);
-    auto newInsertedPairs = DiffMap<Tag, ShadowViewNodePair*>(remainingCount);
-    auto deletionCandidatePairs = DiffMap<Tag, const ShadowViewNodePair*>{};
+    std::unordered_map<Tag, ShadowViewNodePair*> newRemainingPairs;
+    newRemainingPairs.reserve(remainingCount);
+    std::unordered_map<Tag, ShadowViewNodePair*> newInsertedPairs;
+    newInsertedPairs.reserve(remainingCount);
+    std::unordered_map<Tag, const ShadowViewNodePair*> deletionCandidatePairs{};
     for (index = lastIndexAfterFirstStage; index < newChildPairs.size();
          index++) {
       auto& newChildPair = *newChildPairs[index];
@@ -1594,19 +1325,6 @@ static void calculateShadowViewMutations(
     }
   }
 
-  if (ReactNativeFeatureFlags::
-          enableDifferentiatorMutationVectorPreallocation()) {
-    mutations.reserve(
-        mutations.size() +
-        mutationContainer.destructiveDownwardMutations.size() +
-        mutationContainer.updateMutations.size() +
-        mutationContainer.removeMutations.size() +
-        mutationContainer.deleteMutations.size() +
-        mutationContainer.createMutations.size() +
-        mutationContainer.downwardMutations.size() +
-        mutationContainer.insertMutations.size());
-  }
-
   // All mutations in an optimal order:
   std::move(
       mutationContainer.destructiveDownwardMutations.begin(),
@@ -1675,14 +1393,7 @@ ShadowViewMutation::List calculateShadowViewMutations(
       {} /* layoutOffset */,
       {} /* cullingContext */);
 
-  if (ReactNativeFeatureFlags::
-          enableDifferentiatorMutationVectorPreallocation()) {
-    // Estimate ~2 mutations per view (create + insert or remove + delete).
-    mutations.reserve(
-        std::max(size_t(256), (sliceOne.size() + sliceTwo.size()) * 2));
-  } else {
-    mutations.reserve(256);
-  }
+  mutations.reserve(256);
 
   calculateShadowViewMutations(
       innerViewNodePairScope,

package/ReactCommon/react/renderer/mounting/ShadowTree.cpp

@@ -38,6 +38,14 @@ std::string getShadowTreeCommitSourceName(ShadowTreeCommitSource source) {
       return "ReactRevisionMerge";
   }
 }
+
+inline bool isPropsUpdatesAccumulationGuaranteed() {
+#ifdef __ANDROID__
+  return ReactNativeFeatureFlags::enableAccumulatedUpdatesInRawPropsAndroid();
+#else
+  return true;
+#endif
+}
 } // namespace
 
 using CommitStatus = ShadowTree::CommitStatus;
@@ -420,7 +428,9 @@ CommitStatus ShadowTree::tryCommit(
       return CommitStatus::Failed;
     }
 
-    auto newRevisionNumber = currentRevision_.number + 1;
+    auto newRevisionNumber = isReactBranch
+        ? oldRevisionForStateProgression.number + 1
+        : currentRevision_.number + 1;
 
     {
       std::scoped_lock dispatchLock(EventEmitter::DispatchMutex());
@@ -482,31 +492,66 @@ void ShadowTree::mount(ShadowTreeRevision revision, bool mountSynchronously)
 
 void ShadowTree::mergeReactRevision() const {
   ShadowTreeRevision promotedRevision;
+  std::vector<ShadowTreeRevision> promotedRevisions;
+  // If props updates accumulation is guaranteed, we can merge the promoted
+  // react revision, otherwise we need to merge all queued revisions.
 
   {
     UniqueLock lock = uniqueRevisionLock(false);
 
-    if (!reactRevisionToBePromoted_.has_value()) {
-      return;
-    }
+    if (isPropsUpdatesAccumulationGuaranteed()) {
+      if (!reactRevisionToBePromoted_.has_value()) {
+        return;
+      }
 
-    promotedRevision =
-        std::exchange(reactRevisionToBePromoted_, std::nullopt).value();
-  }
+      promotedRevision =
+          std::exchange(reactRevisionToBePromoted_, std::nullopt).value();
+    } else {
+      if (promotedReactRevisions_.empty()) {
+        return;
+      }
 
-  const auto mergedRevisionNumber = promotedRevision.number;
+      promotedReactRevisions_.swap(promotedRevisions);
+    }
+  }
 
-  this->commit(
-      [revision = std::move(promotedRevision)](
-          const RootShadowNode& /*oldRootShadowNode*/) {
-        return std::make_shared<RootShadowNode>(
-            *revision.rootShadowNode, ShadowNodeFragment{});
-      },
-      {
-          .enableStateReconciliation = true,
-          .mountSynchronously = true,
-          .source = CommitSource::ReactRevisionMerge,
-      });
+  RootShadowNode::Shared lastMergedRootShadowNode;
+  bool lastMergeSucceeded = false;
+
+  if (isPropsUpdatesAccumulationGuaranteed()) {
+    lastMergedRootShadowNode = promotedRevision.rootShadowNode;
+    auto status = this->commit(
+        [revision = std::move(promotedRevision)](
+            const RootShadowNode& /*oldRootShadowNode*/) {
+          return std::make_shared<RootShadowNode>(
+              *revision.rootShadowNode, ShadowNodeFragment{});
+        },
+        {
+            .enableStateReconciliation = true,
+            .mountSynchronously = true,
+            .source = CommitSource::ReactRevisionMerge,
+        });
+    lastMergeSucceeded = status == CommitStatus::Succeeded;
+  } else {
+    for (size_t i = 0; i < promotedRevisions.size(); ++i) {
+      auto& revision = promotedRevisions[i];
+      bool isLast = i == promotedRevisions.size() - 1;
+      lastMergedRootShadowNode = revision.rootShadowNode;
+
+      auto status = this->commit(
+          [revision = std::move(revision)](
+              const RootShadowNode& /*oldRootShadowNode*/) {
+            return std::make_shared<RootShadowNode>(
+                *revision.rootShadowNode, ShadowNodeFragment{});
+          },
+          {
+              .enableStateReconciliation = isLast,
+              .mountSynchronously = true,
+              .source = CommitSource::ReactRevisionMerge,
+          });
+      lastMergeSucceeded = status == CommitStatus::Succeeded;
+    }
+  }
 
   {
     UniqueLock commitLock = uniqueRevisionLock(
@@ -514,35 +559,62 @@ void ShadowTree::mergeReactRevision() const {
 
     // If the current react revision is the same as the one that was just
     // merged, clear it.
-    if (currentReactRevision_.has_value() &&
-        mergedRevisionNumber == currentReactRevision_.value().number) {
+    if (lastMergeSucceeded && currentReactRevision_.has_value() &&
+        currentReactRevision_.value().rootShadowNode ==
+            lastMergedRootShadowNode) {
       currentReactRevision_.reset();
     }
   }
 }
 
 void ShadowTree::promoteReactRevision() const {
-  ShadowTreeRevision currentReactRevision;
-  {
-    SharedLock lock = sharedRevisionLock();
-    // Promotion happens at the end of the event loop tick, it's possible to
-    // have more than one promotion in a row. In this case, all but the first
-    // one should no-op.
-    if (!currentReactRevision_.has_value()) {
-      return;
+  // Promote only when props updates accumulation is guaranteed. Otherwise,
+  // queuedReactRevisions_ will be used instead.
+  if (isPropsUpdatesAccumulationGuaranteed()) {
+    ShadowTreeRevision currentReactRevision;
+    {
+      SharedLock lock = sharedRevisionLock();
+      // Promotion happens at the end of the event loop tick, it's possible to
+      // have more than one promotion in a row. In this case, all but the first
+      // one should no-op.
+      if (!currentReactRevision_.has_value()) {
+        return;
+      }
+      currentReactRevision = currentReactRevision_.value();
     }
-    currentReactRevision = currentReactRevision_.value();
-  }
 
-  {
+    {
+      UniqueLock lock = uniqueRevisionLock(false);
+      reactRevisionToBePromoted_ = std::move(currentReactRevision);
+    }
+  } else {
     UniqueLock lock = uniqueRevisionLock(false);
-    reactRevisionToBePromoted_ = std::move(currentReactRevision);
+
+    if (queuedReactRevisions_.empty()) {
+      return;
+    }
+
+    // Move all queued revisions to the promoted revisions.
+    promotedReactRevisions_.insert(
+        promotedReactRevisions_.end(),
+        std::make_move_iterator(queuedReactRevisions_.begin()),
+        std::make_move_iterator(queuedReactRevisions_.end()));
+    queuedReactRevisions_.clear();
   }
 
   delegate_.shadowTreeDidPromoteReactRevision(*this);
 }
 
 void ShadowTree::scheduleReactRevisionPromotion() const {
+  if (!isPropsUpdatesAccumulationGuaranteed()) {
+    // If props updates accumulation is not guaranteed, we need to store each
+    // revision to be merged separately.
+    UniqueLock lock = uniqueRevisionLock(false);
+    if (currentReactRevision_.has_value()) {
+      queuedReactRevisions_.push_back(currentReactRevision_.value());
+    }
+  }
+
   delegate_.shadowTreeDidFinishReactCommit(*this);
 }
 

package/ReactCommon/react/renderer/mounting/ShadowTree.h

@@ -173,6 +173,8 @@ class ShadowTree final {
   mutable ShadowTreeRevision currentRevision_; // Protected by `revisionMutex_`.
   mutable std::optional<ShadowTreeRevision> currentReactRevision_; // Protected by `revisionMutex_`.
   mutable std::optional<ShadowTreeRevision> reactRevisionToBePromoted_; // Protected by `revisionMutex_`.
+  mutable std::vector<ShadowTreeRevision> queuedReactRevisions_; // Protected by `revisionMutex_`.
+  mutable std::vector<ShadowTreeRevision> promotedReactRevisions_; // Protected by `revisionMutex_`.
   std::shared_ptr<const MountingCoordinator> mountingCoordinator_;
 
   using UniqueLock = std::variant<std::unique_lock<std::shared_mutex>, std::unique_lock<std::recursive_mutex>>;

package/ReactCommon/react/renderer/mounting/internal/CullingContext.cpp

@@ -52,7 +52,7 @@ CullingContext CullingContext::adjustCullingContextIfNeeded(
           // In RTL, content offset is flipped horizontally.
           // We need to flip the culling context frame to match.
           // See:
-          // https://github.com/react/react-native/blob/c2f39cfdd87c32b9a59efe8a788b8a03f02b0ea0/packages/react-native/React/Fabric/Mounting/ComponentViews/ScrollView/RCTScrollViewComponentView.mm#L579
+          // https://github.com/facebook/react-native/blob/c2f39cfdd87c32b9a59efe8a788b8a03f02b0ea0/packages/react-native/React/Fabric/Mounting/ComponentViews/ScrollView/RCTScrollViewComponentView.mm#L579
           auto stateData = scrollViewShadowNode->getStateData();
           cullingContext.frame.origin.x =
               stateData.contentBoundingRect.size.width -