react-native-reanimated 4.5.3 → 4.5.5

package/Common/cpp/reanimated/Fabric/ShadowTreeCloner.cpp

@@ -25,7 +25,7 @@ mergeProps(const ShadowNode &shadowNode, const PropsMap &propsMap, const ShadowN
   if (propsVector.size() > 1) {
     folly::dynamic newPropsDynamic = folly::dynamic::object;
     for (const auto &props : propsVector) {
-      newPropsDynamic = folly::dynamic::merge(props.operator folly::dynamic(), newPropsDynamic);
+      newPropsDynamic = folly::dynamic::merge(newPropsDynamic, props.operator folly::dynamic());
     }
     return shadowNode.getComponentDescriptor().cloneProps(propsParserContext, newProps, RawProps(newPropsDynamic));
   }

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h

@@ -62,11 +62,11 @@ class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDele
       const SharedComponentDescriptorRegistry &componentDescriptorRegistry,
       const std::shared_ptr<const ContextContainer> &contextContainer,
       jsi::Runtime &uiRuntime,
-      const std::shared_ptr<UIScheduler> &uiScheduler
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      const std::shared_ptr<facebook::react::UIManager> &uiManager
 #ifdef ANDROID
       ,
       const PreserveMountedTagsFunction &filterUnmountedTagsFunction,
-      const std::shared_ptr<facebook::react::UIManager> &uiManager,
       const std::shared_ptr<facebook::react::CallInvoker> &jsInvoker
 #endif
       )
@@ -74,11 +74,11 @@ class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDele
         contextContainer_(contextContainer),
         componentDescriptorRegistry_(componentDescriptorRegistry),
         uiRuntime_(uiRuntime),
-        uiScheduler_(uiScheduler)
+        uiScheduler_(uiScheduler),
+        uiManager_(uiManager)
 #ifdef ANDROID
         ,
         preserveMountedTags_(filterUnmountedTagsFunction),
-        uiManager_(uiManager),
         jsInvoker_(jsInvoker)
 #endif
   {
@@ -98,10 +98,10 @@ class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDele
   SharedComponentDescriptorRegistry componentDescriptorRegistry_;
   jsi::Runtime &uiRuntime_;
   const std::shared_ptr<UIScheduler> uiScheduler_;
+  std::shared_ptr<facebook::react::UIManager> uiManager_;
   PreserveMountedTagsFunction preserveMountedTags_;
 
 #ifdef ANDROID
-  std::shared_ptr<facebook::react::UIManager> uiManager_;
   std::shared_ptr<facebook::react::CallInvoker> jsInvoker_;
 
   void restoreOpacityInCaseOfFlakyEnteringAnimation(SurfaceId surfaceId) const;

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.cpp

@@ -30,6 +30,8 @@ std::optional<MountingTransaction> LayoutAnimationsProxy_Experimental::pullTrans
   const std::vector<std::shared_ptr<MutationNode>> roots;
   const bool isInTransition = static_cast<bool>(transitionState_);
 
+  reconcileContradictedRemovals(mutations, filteredMutations);
+
   if (isInTransition) {
     updateLightTree(propsParserContext, mutations, filteredMutations);
     handleProgressTransition(filteredMutations, mutations, propsParserContext, surfaceId);
@@ -107,6 +109,67 @@ std::optional<MountingTransaction> LayoutAnimationsProxy_Experimental::pullTrans
   return MountingTransaction{surfaceId, transactionNumber, std::move(filteredMutations), telemetry};
 }
 
+// If React re-creates or re-inserts a tag whose exiting removal we are still
+// withholding, it has contradicted that withheld removal. Flush it now instead
+// of letting the stale node linger: updateLightTree would overwrite its
+// lightNodes_ entry (the "LightNode already exists" assert is compiled out in
+// release), orphaning the still-mounted exiting view, and the eventual
+// endLayoutAnimation would then remove the wrong, live view and crash the
+// mounting layer.
+//
+// This must run before updateLightTree (so the tag is re-registered cleanly)
+// and before addOngoingAnimations (which would otherwise emit an Update for a
+// tag we are about to Delete this frame).
+void LayoutAnimationsProxy_Experimental::reconcileContradictedRemovals(
+    const ShadowViewMutationList &mutations,
+    ShadowViewMutationList &filteredMutations) const {
+  for (const auto &mutation : mutations) {
+    if (mutation.type != ShadowViewMutation::Type::Create && mutation.type != ShadowViewMutation::Type::Insert) {
+      continue;
+    }
+    const auto tag = mutation.newChildShadowView.tag;
+    std::shared_ptr<LightNode> node;
+    if (const auto it = lightNodes_.find(tag); it != lightNodes_.end() && it->second->state != UNDEFINED) {
+      node = it->second;
+      lightNodes_.erase(it);
+      if (node->state == DELETED) {
+        // already unmounted — only the stale map entry had to go
+        continue;
+      }
+    } else {
+      // A settled exiting view (state DEAD) has already left lightNodes_ but is
+      // still mounted, awaiting the deadNodes cleanup in handleRemovals. That
+      // cleanup runs at the end of the transaction — after this Create would
+      // have re-registered the tag in the mounting layer's view registry — so
+      // it must be flushed now instead.
+      const auto deadIt = std::find_if(
+          deadNodes.begin(), deadNodes.end(), [tag](const auto &deadNode) { return deadNode->current.tag == tag; });
+      if (deadIt == deadNodes.end()) {
+        continue;
+      }
+      node = *deadIt;
+      deadNodes.erase(deadIt);
+      if (node->state == DELETED) {
+        continue;
+      }
+    }
+    // Flush the withheld removal for this tag (and its withheld subtree) right
+    // now, mirroring the deadNodes cleanup in handleRemovals.
+    const auto parent = node->parent.lock();
+    react_native_assert(parent && "Parent node is nullptr");
+    if (!parent) {
+      continue;
+    }
+    const auto index = parent->removeChild(node);
+    react_native_assert(index != -1 && "Exiting node not found");
+    if (index == -1) {
+      continue;
+    }
+    endAnimationsRecursively(node, index, filteredMutations);
+    maybeDropAncestors(parent, filteredMutations);
+  }
+}
+
 bool LayoutAnimationsProxy_Experimental::shouldOverridePullTransaction() const {
   // we need to listen to every possible mutation to keep the light tree updated
   return true;
@@ -305,11 +368,18 @@ std::optional<SurfaceId> LayoutAnimationsProxy_Experimental::endLayoutAnimation(
     return surfaceId;
   }
 
-  auto node = lightNodes_[tag];
-  react_native_assert(node && "LightNode not found");
+  const auto nodeIt = lightNodes_.find(tag);
+  // the withheld removal may have already been flushed (e.g. reconciled after
+  // React re-created the tag) — the assert alone is compiled out in release
+  // and operator[] would insert a null node here
+  if (nodeIt == lightNodes_.end() || !nodeIt->second) {
+    react_native_assert(false && "LightNode not found");
+    return surfaceId;
+  }
+  auto node = nodeIt->second;
 
   node->state = DEAD;
-  lightNodes_.erase(tag);
+  lightNodes_.erase(nodeIt);
   deadNodes.insert(node);
 
   return surfaceId;
@@ -349,6 +419,7 @@ void LayoutAnimationsProxy_Experimental::handleRemovals(
       parent->children.push_back(node);
       if (node->state == UNDEFINED) {
         node->state = WAITING;
+        lightNodes_[node->current.tag] = node;
       }
     } else {
       maybeCancelAnimation(node->current.tag);
@@ -432,6 +503,10 @@ void LayoutAnimationsProxy_Experimental::endAnimationsRecursively(
     ShadowViewMutationList &mutations) const {
   maybeCancelAnimation(node->current.tag);
   node->state = DELETED;
+  // drop the tag mapping unless it was already re-registered for a new node
+  if (const auto it = lightNodes_.find(node->current.tag); it != lightNodes_.end() && it->second == node) {
+    lightNodes_.erase(it);
+  }
   // iterate from the end, so that children
   // with higher indices appear first in the mutations list
 
@@ -463,6 +538,9 @@ void LayoutAnimationsProxy_Experimental::maybeDropAncestors(
   react_native_assert(index != -1 && "Child node not found");
 
   node->state = DELETED;
+  if (const auto it = lightNodes_.find(node->current.tag); it != lightNodes_.end() && it->second == node) {
+    lightNodes_.erase(it);
+  }
   maybeCancelAnimation(node->current.tag);
   cleanupMutations.push_back(ShadowViewMutation::RemoveMutation(parent->current.tag, node->current, index));
   cleanupMutations.push_back(ShadowViewMutation::DeleteMutation(node->current));
@@ -515,6 +593,9 @@ bool LayoutAnimationsProxy_Experimental::startAnimationsRecursively(
       mutations.push_back(ShadowViewMutation::DeleteMutation(subNode->current));
     } else {
       subNode->state = WAITING;
+      // register withheld subtree members, so that reconcileContradictedRemovals
+      // can find them when React re-creates their tags
+      lightNodes_[subNode->current.tag] = subNode;
     }
   }
 

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.h

@@ -67,11 +67,11 @@ struct LayoutAnimationsProxy_Experimental : public LayoutAnimationsProxyCommon,
       const SharedComponentDescriptorRegistry &componentDescriptorRegistry,
       const std::shared_ptr<const ContextContainer> &contextContainer,
       jsi::Runtime &uiRuntime,
-      const std::shared_ptr<UIScheduler> &uiScheduler
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      const std::shared_ptr<UIManager> &uiManager
 #ifdef ANDROID
       ,
       const PreserveMountedTagsFunction &filterUnmountedTagsFunction,
-      const std::shared_ptr<UIManager> &uiManager,
       const std::shared_ptr<CallInvoker> &jsInvoker
 #endif
       )
@@ -80,11 +80,11 @@ struct LayoutAnimationsProxy_Experimental : public LayoutAnimationsProxyCommon,
             componentDescriptorRegistry,
             contextContainer,
             uiRuntime,
-            uiScheduler
+            uiScheduler,
+            uiManager
 #ifdef ANDROID
             ,
             filterUnmountedTagsFunction,
-            uiManager,
             jsInvoker
 #endif
             ),
@@ -109,6 +109,9 @@ struct LayoutAnimationsProxy_Experimental : public LayoutAnimationsProxyCommon,
       const ShadowViewMutationList &mutations,
       ShadowViewMutationList &filteredMutations) const;
 
+  void reconcileContradictedRemovals(const ShadowViewMutationList &mutations, ShadowViewMutationList &filteredMutations)
+      const;
+
   void handleSharedTransitionsStart(
       const std::shared_ptr<LightNode> &afterTopScreen,
       const std::shared_ptr<LightNode> &beforeTopScreen,

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.cpp

@@ -1,12 +1,15 @@
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.h>
 
+#include <ReactCommon/CallInvoker.h>
 #include <react/debug/react_native_assert.h>
+#include <react/renderer/mounting/ShadowTree.h>
 #include <react/renderer/mounting/ShadowViewMutation.h>
 
 #include <memory>
 #include <ranges>
 #include <set>
 #include <string>
+#include <thread>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -33,7 +36,8 @@ std::optional<MountingTransaction> LayoutAnimationsProxy_Legacy::pullTransaction
   auto lock = std::unique_lock<std::recursive_mutex>(mutex);
   PropsParserContext propsParserContext{surfaceId, *contextContainer_};
   ShadowViewMutationList filteredMutations;
-  auto &[deadNodes] = surfaceContext_[surfaceId];
+  auto &surfaceCtx = getSurfaceContext(surfaceId);
+  auto &deadNodes = surfaceCtx.deadNodes;
 
   std::vector<std::shared_ptr<MutationNode>> roots;
   std::unordered_map<Tag, Tag> movedViews;
@@ -60,17 +64,47 @@ std::optional<MountingTransaction> LayoutAnimationsProxy_Legacy::pullTransaction
 
   parseRemoveMutations(movedViews, mutations, roots);
 
-  auto shouldAnimate = !surfacesToRemove_.contains(surfaceId);
-  surfacesToRemove_.erase(surfaceId);
-  handleRemovals(filteredMutations, roots, deadNodes, shouldAnimate);
+  // We recognize dropped surfaces by the presence of a Remove mutation for a root child. This can produce false
+  // positives. Ideal solution will be to introduce an appropriate API in RN
+  auto surfaceDropped = false;
+  const auto removesRootChildren = std::ranges::any_of(mutations, [surfaceId](const auto &mutation) {
+    return mutation.type == ShadowViewMutation::Remove && mutation.parentTag == surfaceId;
+  });
+  if (removesRootChildren) {
+    surfaceDropped = surfacesToRemove_.erase(surfaceId) != 0;
+  }
+  const bool flushDeadNodes = shouldFlushDeadNodes(surfaceDropped);
+  handleRemovals(filteredMutations, roots, deadNodes, surfaceDropped, flushDeadNodes);
+#ifdef ANDROID
+  maybeScheduleCleanupPull(surfaceCtx, surfaceId, flushDeadNodes);
+#endif // ANDROID
 
   handleUpdatesAndEnterings(filteredMutations, movedViews, mutations, propsParserContext, surfaceId);
 
   addOngoingAnimations(surfaceId, filteredMutations);
 
+  dropUpdatesForDeletedViews(filteredMutations);
+
   return MountingTransaction{surfaceId, transactionNumber, std::move(filteredMutations), telemetry};
 }
 
+// The LayoutAnimationDriver can pair a final keyframe update with the withheld
+// Remove/Delete it replays in the same transaction; we emit removals first, so
+// the update would reach the mounting layer after its view was deleted.
+void LayoutAnimationsProxy_Legacy::dropUpdatesForDeletedViews(ShadowViewMutationList &filteredMutations) const {
+  std::unordered_set<Tag> deletedTags;
+  for (const auto &mutation : filteredMutations) {
+    if (mutation.type == ShadowViewMutation::Delete) {
+      deletedTags.insert(mutation.oldChildShadowView.tag);
+    }
+  }
+  if (!deletedTags.empty()) {
+    std::erase_if(filteredMutations, [&deletedTags](const auto &mutation) {
+      return mutation.type == ShadowViewMutation::Update && deletedTags.contains(mutation.newChildShadowView.tag);
+    });
+  }
+}
+
 // If React re-creates or re-inserts a tag whose exiting removal we are still
 // withholding, it has contradicted that withheld Remove/Delete. Flush it now
 // instead of letting it fire later against a stale hierarchy (which would
@@ -83,7 +117,7 @@ void LayoutAnimationsProxy_Legacy::reconcileContradictedRemovals(
     ShadowViewMutationList &mutations,
     ShadowViewMutationList &filteredMutations,
     SurfaceId surfaceId) const {
-  auto &[deadNodes] = surfaceContext_[surfaceId];
+  auto &deadNodes = getSurfaceContext(surfaceId).deadNodes;
   for (auto &mutation : mutations) {
     if (mutation.type != ShadowViewMutation::Type::Create && mutation.type != ShadowViewMutation::Type::Insert) {
       continue;
@@ -105,6 +139,45 @@ void LayoutAnimationsProxy_Legacy::reconcileContradictedRemovals(
   }
 }
 
+// On android mutations that alter the view hierarchy are only produced on the JS thread (the push model), so to not
+// race with those, we apply the dead nodes cleanup only on the JS thread, unless there is a surface drop, in which case
+// we can safely cleanup on the UI thread since the surface is gone and no more mutations will be produced for it.
+bool LayoutAnimationsProxy_Legacy::shouldFlushDeadNodes([[maybe_unused]] const bool surfaceDropped) const {
+#ifdef ANDROID
+  return surfaceDropped || std::this_thread::get_id() != uiThreadId_;
+#else
+  return true;
+#endif
+}
+
+#ifdef ANDROID
+// We schedule a pullTransaction call to happen on the JS thread so it can safely remove dead nodes after exiting
+// finished
+void LayoutAnimationsProxy_Legacy::maybeScheduleCleanupPull(
+    SurfaceContext &surfaceCtx,
+    const SurfaceId surfaceId,
+    const bool flushedDeadNodes) const {
+  if (flushedDeadNodes) {
+    surfaceCtx.cleanupPullScheduled = false;
+  } else if (!surfaceCtx.deadNodes.empty() && !surfaceCtx.cleanupPullScheduled) {
+    surfaceCtx.cleanupPullScheduled = true;
+    scheduleDeferredCleanupPull(surfaceId);
+  }
+}
+
+void LayoutAnimationsProxy_Legacy::scheduleDeferredCleanupPull(SurfaceId surfaceId) const {
+  const std::weak_ptr<UIManager> weakUiManager = uiManager_;
+  jsInvoker_->invokeAsync([weakUiManager, surfaceId](jsi::Runtime &) {
+    auto uiManager = weakUiManager.lock();
+    if (!uiManager) {
+      return;
+    }
+    uiManager->getShadowTreeRegistry().visit(
+        surfaceId, [](ShadowTree const &shadowTree) { shadowTree.notifyDelegatesOfUpdates(); });
+  });
+}
+#endif
+
 std::optional<SurfaceId> LayoutAnimationsProxy_Legacy::progressLayoutAnimation(int tag, const jsi::Object &newStyle) {
 #ifdef LAYOUT_ANIMATIONS_LOGS
   LOG(INFO) << "progress layout animation for tag " << tag << std::endl;
@@ -169,7 +242,7 @@ std::optional<SurfaceId> LayoutAnimationsProxy_Legacy::endLayoutAnimation(int ta
   }
   auto mutationNode = std::static_pointer_cast<MutationNode>(node);
   mutationNode->state = ExitingState_Legacy::DEAD;
-  auto &[deadNodes] = surfaceContext_[surfaceId];
+  auto &deadNodes = getSurfaceContext(surfaceId).deadNodes;
   deadNodes.insert(mutationNode);
 
   return surfaceId;
@@ -281,12 +354,13 @@ void LayoutAnimationsProxy_Legacy::handleRemovals(
     ShadowViewMutationList &filteredMutations,
     std::vector<std::shared_ptr<MutationNode>> &roots,
     std::unordered_set<std::shared_ptr<MutationNode>> &deadNodes,
-    bool shouldAnimate) const {
+    bool surfaceDropped,
+    bool flushDeadNodes) const {
   // iterate from the end, so that children
   // with higher indices appear first in the mutations list
   for (auto it = roots.rbegin(); it != roots.rend(); it++) {
     auto &node = *it;
-    if (!startAnimationsRecursively(node, true, shouldAnimate, false, filteredMutations)) {
+    if (!startAnimationsRecursively(node, true, !surfaceDropped, false, filteredMutations)) {
       filteredMutations.push_back(node->mutation);
       node->unflattenedParent->removeChildFromUnflattenedTree(node); //???
       if (node->state != ExitingState_Legacy::MOVED) {
@@ -301,6 +375,10 @@ void LayoutAnimationsProxy_Legacy::handleRemovals(
     }
   }
 
+  if (!flushDeadNodes) {
+    // Deferred - the host still has these views mounted, bookkeeping stays.
+    return;
+  }
   for (const auto &node : deadNodes) {
     if (node->state != ExitingState_Legacy::DELETED) {
       endAnimationsRecursively(node, filteredMutations);
@@ -713,6 +791,7 @@ void LayoutAnimationsProxy_Legacy::startEnteringAnimation(const int tag, ShadowV
           auto &mutex = strongThis->mutex;
           auto lock = std::unique_lock<std::recursive_mutex>(mutex);
 #ifdef ANDROID
+          strongThis->uiThreadId_ = std::this_thread::get_id();
           if (consumeIsCancelled(strongThis->pendingStarts_, tag, handle)) {
             // the view was removed before this start could run
             return;
@@ -773,12 +852,12 @@ void LayoutAnimationsProxy_Legacy::startExitingAnimation(const int tag, ShadowVi
           auto &mutex = strongThis->mutex;
           auto lock = std::unique_lock<std::recursive_mutex>(mutex);
 #ifdef ANDROID
+          strongThis->uiThreadId_ = std::this_thread::get_id();
           if (consumeIsCancelled(strongThis->pendingStarts_, tag, handle)) {
-            // the view was removed (e.g. its subtree was force-ended by a screen
-            // pop) before this start could run — its Remove+Delete are already on
-            // their way to the mounting layer, so starting the animation now
-            // would emit updates for a view that's about to be deleted
-            strongThis->layoutAnimationsManager_->clearLayoutAnimationConfig(tag);
+            // The view was removed before this start could run. Deliberately no
+            // clearLayoutAnimationConfig: with tag reuse the config maps already
+            // describe the re-created view, and wiping them would leave it mounted
+            // at opacity 0. A dead tag's stale configs can never fire again.
             return;
           }
 #endif
@@ -836,6 +915,7 @@ void LayoutAnimationsProxy_Legacy::startLayoutAnimation(const int tag, const Sha
           auto &mutex = strongThis->mutex;
           auto lock = std::unique_lock<std::recursive_mutex>(mutex);
 #ifdef ANDROID
+          strongThis->uiThreadId_ = std::this_thread::get_id();
           if (consumeIsCancelled(strongThis->pendingStarts_, tag, handle)) {
             // the view was removed before this start could run
             return;
@@ -998,23 +1078,37 @@ inline bool MutationNode::isMutationNode() {
   return true;
 }
 
-// UIManagerAnimationDelegate
-
-void LayoutAnimationsProxy_Legacy::uiManagerDidConfigureNextLayoutAnimation(
-    jsi::Runtime &runtime,
-    const RawValue &config,
-    const jsi::Value &successCallbackValue,
-    const jsi::Value &failureCallbackValue) const {}
-
-void LayoutAnimationsProxy_Legacy::setComponentDescriptorRegistry(
-    const SharedComponentDescriptorRegistry &componentDescriptorRegistry) {}
+void LayoutAnimationsProxy_Legacy::startSurface(const SurfaceId surfaceId) {
+  auto lock = std::unique_lock<std::recursive_mutex>(mutex);
+  surfaceContext_.try_emplace(surfaceId);
+}
 
-bool LayoutAnimationsProxy_Legacy::shouldAnimateFrame() const {
-  return false;
+SurfaceContext &LayoutAnimationsProxy_Legacy::getSurfaceContext(const SurfaceId surfaceId) const {
+  // startSurface() creates the entry for a surface before any other method
+  // uses it. The proxy does not remove entries during its lifetime. Thus a
+  // missing entry is an initialization bug, not a stopped surface.
+  const auto it = surfaceContext_.find(surfaceId);
+  react_native_assert(it != surfaceContext_.end() && "surface must be registered by startSurface");
+  return it->second;
 }
 
-void LayoutAnimationsProxy_Legacy::stopSurface(SurfaceId surfaceId) {
-  surfacesToRemove_.insert(surfaceId);
+// UIManagerCommitHook
+
+// Surface teardown commits an empty root (SurfaceHandler::stop) before the
+// teardown transaction is pulled — mark it so pullTransaction skips exit
+// animations. Reading the ShadowTreeRegistry here instead would deadlock.
+RootShadowNode::Unshared LayoutAnimationsProxy_Legacy::shadowTreeWillCommit(
+    const ShadowTree &shadowTree,
+    const RootShadowNode::Shared & /*oldRootShadowNode*/,
+    const RootShadowNode::Unshared &newRootShadowNode) noexcept {
+  const auto surfaceId = shadowTree.getSurfaceId();
+  auto lock = std::unique_lock<std::recursive_mutex>(mutex);
+  if (newRootShadowNode->getChildren().empty()) {
+    surfacesToRemove_.insert(surfaceId);
+  } else {
+    surfacesToRemove_.erase(surfaceId);
+  }
+  return newRootShadowNode;
 }
 
 } // namespace reanimated

package/Common/cpp/reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.h

@@ -3,8 +3,8 @@
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/scheduler/Scheduler.h>
-#include <react/renderer/uimanager/UIManagerAnimationDelegate.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/UIManagerCommitHook.h>
 #include <reanimated/Compat/WorkletsApi.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxyCommon.h>
@@ -13,6 +13,7 @@
 
 #include <memory>
 #include <string>
+#include <thread>
 #include <unordered_map>
 #include <unordered_set>
 #include <utility>
@@ -97,12 +98,17 @@ static inline void mergeAndSwap(
   std::swap(A, merged);
 }
 
+// Created by startSurface before the proxy can pull for that surface.
+// Entries are never erased, so stray pulls after teardown always find state.
 struct SurfaceContext {
   mutable std::unordered_set<std::shared_ptr<MutationNode>> deadNodes;
+#ifdef ANDROID
+  mutable bool cleanupPullScheduled = false;
+#endif
 };
 
 struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
-                                      public UIManagerAnimationDelegate,
+                                      public UIManagerCommitHook,
                                       public std::enable_shared_from_this<LayoutAnimationsProxy_Legacy> {
   mutable std::unordered_map<Tag, std::shared_ptr<Node>> nodeForTag_;
   mutable std::recursive_mutex mutex;
@@ -110,17 +116,24 @@ struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
   mutable std::unordered_map<SurfaceId, SurfaceContext> surfaceContext_;
   mutable std::unordered_map<Tag, int> leastRemoved;
   mutable std::unordered_set<SurfaceId> surfacesToRemove_;
+  bool shouldFlushDeadNodes(bool surfaceDropped) const;
+#ifdef ANDROID
+  mutable std::thread::id uiThreadId_;
+
+  void maybeScheduleCleanupPull(SurfaceContext &surfaceCtx, SurfaceId surfaceId, bool flushedDeadNodes) const;
+  void scheduleDeferredCleanupPull(SurfaceId surfaceId) const;
+#endif
 
   LayoutAnimationsProxy_Legacy(
       const std::shared_ptr<LayoutAnimationsManager> &layoutAnimationsManager,
       const SharedComponentDescriptorRegistry &componentDescriptorRegistry,
       const std::shared_ptr<const ContextContainer> &contextContainer,
       jsi::Runtime &uiRuntime,
-      const std::shared_ptr<UIScheduler> &uiScheduler
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      const std::shared_ptr<UIManager> &uiManager
 #ifdef ANDROID
       ,
       const PreserveMountedTagsFunction &filterUnmountedTagsFunction,
-      const std::shared_ptr<UIManager> &uiManager,
       const std::shared_ptr<CallInvoker> &jsInvoker
 #endif
       )
@@ -129,14 +142,19 @@ struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
             componentDescriptorRegistry,
             contextContainer,
             uiRuntime,
-            uiScheduler
+            uiScheduler,
+            uiManager
 #ifdef ANDROID
             ,
             filterUnmountedTagsFunction,
-            uiManager,
             jsInvoker
 #endif
         ) {
+    uiManager->registerCommitHook(*this);
+  }
+
+  ~LayoutAnimationsProxy_Legacy() override {
+    uiManager_->unregisterCommitHook(*this);
   }
 
   void startEnteringAnimation(const int tag, ShadowViewMutation &mutation) const;
@@ -146,6 +164,8 @@ struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
   void transferConfigFromNativeID(const std::string &nativeId, const int tag) const;
   std::optional<SurfaceId> progressLayoutAnimation(int tag, const jsi::Object &newStyle) override;
   std::optional<SurfaceId> endLayoutAnimation(int tag, bool shouldRemove) override;
+  void startSurface(const SurfaceId surfaceId) override;
+  SurfaceContext &getSurfaceContext(SurfaceId surfaceId) const;
   void maybeCancelAnimation(const int tag) const;
 
   void reconcileContradictedRemovals(
@@ -160,7 +180,8 @@ struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
       ShadowViewMutationList &filteredMutations,
       std::vector<std::shared_ptr<MutationNode>> &roots,
       std::unordered_set<std::shared_ptr<MutationNode>> &deadNodes,
-      bool shouldAnimate) const;
+      bool surfaceDropped,
+      bool flushDeadNodes) const;
 
   void handleUpdatesAndEnterings(
       ShadowViewMutationList &filteredMutations,
@@ -169,6 +190,7 @@ struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
       const PropsParserContext &propsParserContext,
       SurfaceId surfaceId) const;
   void addOngoingAnimations(SurfaceId surfaceId, ShadowViewMutationList &mutations) const;
+  void dropUpdatesForDeletedViews(ShadowViewMutationList &filteredMutations) const;
   void updateOngoingAnimationTarget(const int tag, const ShadowViewMutation &mutation) const;
   std::shared_ptr<ShadowView> cloneViewWithoutOpacity(
       facebook::react::ShadowViewMutation &mutation,
@@ -206,19 +228,15 @@ struct LayoutAnimationsProxy_Legacy : public LayoutAnimationsProxyCommon,
       const TransactionTelemetry &telemetry,
       ShadowViewMutationList mutations) const override;
 
-  // UIManagerAnimationDelegate
-
-  void uiManagerDidConfigureNextLayoutAnimation(
-      jsi::Runtime &runtime,
-      const RawValue &config,
-      const jsi::Value &successCallbackValue,
-      const jsi::Value &failureCallbackValue) const override;
-
-  void setComponentDescriptorRegistry(const SharedComponentDescriptorRegistry &componentDescriptorRegistry) override;
+  // UIManagerCommitHook
 
-  bool shouldAnimateFrame() const override;
+  void commitHookWasRegistered(const UIManager &) noexcept override {}
+  void commitHookWasUnregistered(const UIManager &) noexcept override {}
 
-  void stopSurface(SurfaceId surfaceId) override;
+  RootShadowNode::Unshared shadowTreeWillCommit(
+      const ShadowTree &shadowTree,
+      const RootShadowNode::Shared &oldRootShadowNode,
+      const RootShadowNode::Unshared &newRootShadowNode) noexcept override;
 };
 
 } // namespace reanimated

package/Common/cpp/reanimated/NativeModules/ReanimatedModuleProxy.cpp

@@ -688,7 +688,19 @@ bool ReanimatedModuleProxy::handleRawEvent(const RawEvent &rawEvent, double curr
     return false;
   }
 
-  int tag = eventTarget->getTag();
+#if REACT_NATIVE_VERSION_MINOR >= 87
+  const auto tag = eventTarget->getTag();
+#else
+  // A stale event dispatched during unmount may carry an EventTarget with a null
+  // InstanceHandle which getTag() would dereference (see #9925).
+  // Fixed in React Native 0.87 by https://github.com/facebook/react-native/pull/56763.
+  const auto shadowNodeFamily = rawEvent.shadowNodeFamily.lock();
+  if (shadowNodeFamily == nullptr) {
+    return false;
+  }
+  const auto tag = shadowNodeFamily->getTag();
+#endif
+
   auto eventType = rawEvent.type;
   if (eventType.rfind("top", 0) == 0) {
     eventType = "on" + eventType.substr(3);
@@ -1222,11 +1234,11 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxy() {
           componentDescriptorRegistry,
           scheduler->getContextContainer(),
           getJSIRuntimeFromWorkletRuntime(uiRuntime_),
-          uiScheduler_
+          uiScheduler_,
+          uiManager_
 #ifdef ANDROID
           ,
           filterUnmountedTagsFunction_,
-          uiManager_,
           jsInvoker_
 #endif
       );
@@ -1235,22 +1247,19 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxy() {
 #endif
       layoutAnimationsProxy_ = std::move(layoutAnimationsProxyExperimental);
     } else {
-      auto layoutAnimationsProxyLegacy = std::make_shared<LayoutAnimationsProxy_Legacy>(
+      layoutAnimationsProxy_ = std::make_shared<LayoutAnimationsProxy_Legacy>(
           layoutAnimationsManager_,
           componentDescriptorRegistry,
           scheduler->getContextContainer(),
           getJSIRuntimeFromWorkletRuntime(uiRuntime_),
-          uiScheduler_
+          uiScheduler_,
+          uiManager_
 #ifdef ANDROID
           ,
           filterUnmountedTagsFunction_,
-          uiManager_,
           jsInvoker_
 #endif
       );
-      // TODO (future): support in experimental
-      uiManager_->setAnimationDelegate(layoutAnimationsProxyLegacy.get());
-      layoutAnimationsProxy_ = std::move(layoutAnimationsProxyLegacy);
     }
   }
 }

package/apple/reanimated/apple/REANodesManager.mm

@@ -125,7 +125,11 @@ using namespace facebook::react;
 - (void)performOperations
 {
   RCTAssertMainQueue();
-  _performOperations(); // calls ReanimatedModuleProxy::performOperations
+  REAPerformOperations performOperations = _performOperations;
+  if (performOperations == nil) {
+    return;
+  }
+  performOperations(); // calls ReanimatedModuleProxy::performOperations
 }
 
 - (void)dispatchEvent:(id<RCTEvent>)event

package/lib/module/platform-specific/jsVersion.js

@@ -5,5 +5,5 @@
  * version used to build the native part of the library in runtime. Remember to
  * keep this in sync with the version declared in `package.json`
  */
-export const jsVersion = '4.5.3';
+export const jsVersion = '4.5.5';
 //# sourceMappingURL=jsVersion.js.map

package/lib/typescript/platform-specific/jsVersion.d.ts

@@ -3,5 +3,5 @@
  * version used to build the native part of the library in runtime. Remember to
  * keep this in sync with the version declared in `package.json`
  */
-export declare const jsVersion = "4.5.3";
+export declare const jsVersion = "4.5.5";
 //# sourceMappingURL=jsVersion.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-reanimated",
-  "version": "4.5.3",
+  "version": "4.5.5",
   "description": "More powerful alternative to Animated library for React Native.",
   "keywords": [
     "react-native",

package/src/platform-specific/jsVersion.ts

@@ -4,4 +4,4 @@
  * version used to build the native part of the library in runtime. Remember to
  * keep this in sync with the version declared in `package.json`
  */
-export const jsVersion = '4.5.3';
+export const jsVersion = '4.5.5';