react-native-reanimated 4.3.1 → 4.3.3

package/Common/cpp/reanimated/CSS/interpolation/transforms/TransformOperationInterpolator.cpp

@@ -5,6 +5,8 @@
 #include <reanimated/CSS/interpolation/transforms/operations/skew.h>
 #include <reanimated/CSS/interpolation/transforms/operations/translate.h>
 
+#include <cmath>
+#include <limits>
 #include <utility>
 
 namespace reanimated::css {
@@ -31,14 +33,19 @@ std::unique_ptr<StyleOperation> TransformOperationInterpolator<PerspectiveOperat
     const std::shared_ptr<StyleOperation> &from,
     const std::shared_ptr<StyleOperation> &to,
     const StyleOperationsInterpolationContext & /* context */) const {
-  // TODO - check if this implementation is correct
   const auto &fromValue = std::static_pointer_cast<PerspectiveOperation>(from)->value;
   const auto &toValue = std::static_pointer_cast<PerspectiveOperation>(to)->value;
 
-  if (fromValue.value == 0)
-    return std::make_unique<PerspectiveOperation>(toValue);
-  if (toValue.value == 0)
-    return std::make_unique<PerspectiveOperation>(fromValue);
+  // The default "no perspective" is infinity, so interpolating the distance
+  // directly gives inf + t*(d - inf) = NaN. Interpolate in reciprocal space
+  // instead (1/inf = 0, matching how perspective enters the matrix as -1/d).
+  if (std::isinf(fromValue.value) || std::isinf(toValue.value)) {
+    const double fromReciprocal = 1.0 / fromValue.value;
+    const double toReciprocal = 1.0 / toValue.value;
+    const double reciprocal = fromReciprocal + progress * (toReciprocal - fromReciprocal);
+    return std::make_unique<PerspectiveOperation>(
+        reciprocal == 0.0 ? std::numeric_limits<double>::infinity() : 1.0 / reciprocal);
+  }
 
   return std::make_unique<PerspectiveOperation>(fromValue.interpolate(progress, toValue));
 }

package/Common/cpp/reanimated/CSS/misc/ViewStylesRepository.cpp

@@ -13,13 +13,11 @@ ViewStylesRepository::ViewStylesRepository(
 jsi::Value ViewStylesRepository::getNodeProp(
     const std::shared_ptr<const ShadowNode> &shadowNode,
     const std::string &propName) {
-  int tag = shadowNode->getTag();
-
-  auto &cachedNode = shadowNodeCache_[tag];
-  updateCacheIfNeeded(cachedNode, shadowNode);
+  const auto resolvedNode = getNewestNode(shadowNode);
+  const auto *layoutableShadowNode = dynamic_cast<const LayoutableShadowNode *>(resolvedNode.get());
 
   if (propName == "width" || propName == "height" || propName == "top" || propName == "left") {
-    const auto &layoutMetrics = cachedNode.layoutMetrics;
+    const auto layoutMetrics = layoutableShadowNode ? layoutableShadowNode->layoutMetrics_ : LayoutMetrics{};
 
     if (propName == "width") {
       return {layoutMetrics.frame.size.width};
@@ -31,7 +29,13 @@ jsi::Value ViewStylesRepository::getNodeProp(
       return {layoutMetrics.frame.origin.x};
     }
   } else {
-    const auto &viewProps = cachedNode.viewProps;
+    if (!layoutableShadowNode) {
+      return jsi::Value::undefined();
+    }
+    const auto viewProps = std::static_pointer_cast<const ViewProps>(resolvedNode->getProps());
+    if (!viewProps) {
+      return jsi::Value::undefined();
+    }
 
     if (propName == "opacity") {
       return {viewProps->opacity};
@@ -48,15 +52,7 @@ jsi::Value ViewStylesRepository::getNodeProp(
 jsi::Value ViewStylesRepository::getParentNodeProp(
     const std::shared_ptr<const ShadowNode> &shadowNode,
     const std::string &propName) {
-  const auto surfaceId = shadowNode->getSurfaceId();
-  const auto &shadowTreeRegistry = uiManager_->getShadowTreeRegistry();
-
-  std::shared_ptr<const ShadowNode> parentNode = nullptr;
-
-  shadowTreeRegistry.visit(surfaceId, [&](ShadowTree const &shadowTree) {
-    auto currentRevision = shadowTree.getCurrentRevision();
-    parentNode = dom::getParentNode(currentRevision.rootShadowNode, *shadowNode);
-  });
+  const auto parentNode = getParentNode(shadowNode);
 
   if (!parentNode) {
     return jsi::Value::undefined();
@@ -65,37 +61,63 @@ jsi::Value ViewStylesRepository::getParentNodeProp(
   return getNodeProp(parentNode, propName);
 }
 
-folly::dynamic ViewStylesRepository::getStyleProp(const Tag tag, const PropertyPath &propertyPath) {
-  auto animatedValue = getPropertyValue(animatedPropsRegistry_->get(tag), propertyPath);
-  if (!animatedValue.isNull()) {
-    return animatedValue;
+std::shared_ptr<const ShadowNode> ViewStylesRepository::getNewestNode(
+    const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  // Resolve shadowNode against the last mounted root instead of reading the live
+  // ShadowTree: uiManager_->getNewestCloneOfShadowNode takes the ShadowTree commit
+  // lock, and this method runs under the updates-registry lock while a concurrent
+  // Fabric commit takes the same two locks in the opposite order (the ANR
+  // deadlock). Falls back to the passed node. Mirrors RN's getShadowNodeInSubtree:
+  // https://github.com/facebook/react-native/blob/v0.86.0-rc.3/packages/react-native/ReactCommon/react/renderer/uimanager/UIManager.cpp#L339
+  RootShadowNode::Shared root;
+  {
+    const std::lock_guard<std::mutex> lock{lastMountedRootMutex_};
+    const auto it = lastMountedRootBySurface_.find(shadowNode->getSurfaceId());
+    if (it == lastMountedRootBySurface_.end()) {
+      return shadowNode;
+    }
+    root = it->second;
   }
 
-  return getPropertyValue(staticPropsRegistry_->get(tag), propertyPath);
-}
+  if (ShadowNode::sameFamily(*root, *shadowNode)) {
+    return root;
+  }
 
-void ViewStylesRepository::clearNodesCache() {
-  shadowNodeCache_.clear();
-}
+  const auto ancestors = shadowNode->getFamily().getAncestors(*root);
+  if (ancestors.empty()) {
+    return shadowNode;
+  }
 
-void ViewStylesRepository::updateCacheIfNeeded(
-    CachedShadowNode &cachedNode,
-    const std::shared_ptr<const ShadowNode> &shadowNode) {
-  auto newestCloneOfShadowNode = uiManager_->getNewestCloneOfShadowNode(*shadowNode);
+  const auto &deepest = ancestors.back();
+  return deepest.first.get().getChildren().at(deepest.second);
+}
 
-  // Check if newestCloneOfShadowNode is valid (is already mounted / not
-  // yet unmounted)
-  if (!newestCloneOfShadowNode) {
-    return;
+std::shared_ptr<const ShadowNode> ViewStylesRepository::getParentNode(
+    const std::shared_ptr<const ShadowNode> &shadowNode) const {
+  RootShadowNode::Shared root;
+  {
+    const std::lock_guard<std::mutex> lock{lastMountedRootMutex_};
+    const auto it = lastMountedRootBySurface_.find(shadowNode->getSurfaceId());
+    if (it == lastMountedRootBySurface_.end()) {
+      return nullptr;
+    }
+    root = it->second;
   }
+  return dom::getParentNode(root, *shadowNode);
+}
+
+void ViewStylesRepository::setLastMountedRoot(const RootShadowNode::Shared &rootShadowNode) {
+  const std::lock_guard<std::mutex> lock{lastMountedRootMutex_};
+  lastMountedRootBySurface_[rootShadowNode->getSurfaceId()] = rootShadowNode;
+}
 
-  auto layoutableShadowNode = dynamic_cast<const LayoutableShadowNode *>(newestCloneOfShadowNode.get());
-  if (!layoutableShadowNode) {
-    return;
+folly::dynamic ViewStylesRepository::getStyleProp(const Tag tag, const PropertyPath &propertyPath) {
+  auto animatedValue = getPropertyValue(animatedPropsRegistry_->get(tag), propertyPath);
+  if (!animatedValue.isNull()) {
+    return animatedValue;
   }
 
-  cachedNode.layoutMetrics = layoutableShadowNode->layoutMetrics_;
-  cachedNode.viewProps = std::static_pointer_cast<const ViewProps>(newestCloneOfShadowNode->getProps());
+  return getPropertyValue(staticPropsRegistry_->get(tag), propertyPath);
 }
 
 folly::dynamic ViewStylesRepository::getPropertyValue(const folly::dynamic &value, const PropertyPath &propertyPath) {

package/Common/cpp/reanimated/CSS/misc/ViewStylesRepository.h

@@ -4,11 +4,14 @@
 #include <reanimated/CSS/registries/StaticPropsRegistry.h>
 #include <reanimated/Fabric/updates/AnimatedPropsRegistry.h>
 
+#include <react/renderer/components/root/RootShadowNode.h>
 #include <react/renderer/components/view/ViewProps.h>
 #include <react/renderer/core/LayoutableShadowNode.h>
 #include <react/renderer/dom/DOM.h>
+#include <react/renderer/uimanager/UIManager.h>
 
 #include <memory>
+#include <mutex>
 #include <string>
 #include <unordered_map>
 
@@ -17,11 +20,6 @@ namespace reanimated::css {
 using namespace facebook;
 using namespace react;
 
-struct CachedShadowNode {
-  LayoutMetrics layoutMetrics;
-  std::shared_ptr<const ViewProps> viewProps;
-};
-
 class ViewStylesRepository {
  public:
   ViewStylesRepository(
@@ -36,16 +34,21 @@ class ViewStylesRepository {
   jsi::Value getParentNodeProp(const std::shared_ptr<const ShadowNode> &shadowNode, const std::string &propName);
   folly::dynamic getStyleProp(Tag tag, const PropertyPath &propertyPath);
 
-  void clearNodesCache();
+  void setLastMountedRoot(const RootShadowNode::Shared &rootShadowNode);
 
  private:
   std::shared_ptr<UIManager> uiManager_;
   std::shared_ptr<StaticPropsRegistry> staticPropsRegistry_;
   std::shared_ptr<AnimatedPropsRegistry> animatedPropsRegistry_;
 
-  std::unordered_map<int, CachedShadowNode> shadowNodeCache_;
+  // Transition setup resolves relative lengths on the JS thread without the
+  // updates-registry lock, while the mount hook records roots under it, so the
+  // map needs its own guard.
+  mutable std::mutex lastMountedRootMutex_;
+  std::unordered_map<SurfaceId, RootShadowNode::Shared> lastMountedRootBySurface_;
 
-  void updateCacheIfNeeded(CachedShadowNode &cachedNode, const std::shared_ptr<const ShadowNode> &shadowNode);
+  std::shared_ptr<const ShadowNode> getNewestNode(const std::shared_ptr<const ShadowNode> &shadowNode) const;
+  std::shared_ptr<const ShadowNode> getParentNode(const std::shared_ptr<const ShadowNode> &shadowNode) const;
 
   static folly::dynamic getPropertyValue(const folly::dynamic &value, const PropertyPath &propertyPath);
 };

package/Common/cpp/reanimated/CSS/registries/CSSAnimationsRegistry.cpp

@@ -293,6 +293,10 @@ void CSSAnimationsRegistry::applyViewAnimationsStyle(const Tag viewTag, const do
   }
 
   setInUpdatesRegistry(shadowNode, updatedStyle);
+
+  if (shadowNode && !updatedStyle.empty()) {
+    addUpdatesToBatch(shadowNode, updatedStyle);
+  }
 }
 
 void CSSAnimationsRegistry::activateDelayedAnimations(const double timestamp) {

package/Common/cpp/reanimated/CSS/registries/StaticPropsRegistry.cpp

@@ -7,16 +7,26 @@ namespace reanimated::css {
 void StaticPropsRegistry::set(jsi::Runtime &rt, const Tag viewTag, const jsi::Value &props) {
   if (props.isNull() || props.isUndefined()) {
     remove(viewTag);
-  } else {
-    const auto newProps = dynamicFromValue(rt, props);
-    if (has(viewTag)) {
-      notifyObservers(viewTag, get(viewTag), newProps);
+    return;
+  }
+
+  const auto newProps = dynamicFromValue(rt, props);
+  folly::dynamic oldProps;
+  {
+    std::lock_guard<std::mutex> lock{mutex_};
+    const auto it = registry_.find(viewTag);
+    if (it != registry_.end()) {
+      oldProps = it->second;
     }
     registry_[viewTag] = newProps;
   }
+  if (!oldProps.isNull()) {
+    notifyObservers(viewTag, oldProps, newProps);
+  }
 }
 
 folly::dynamic StaticPropsRegistry::get(const Tag viewTag) const {
+  std::lock_guard<std::mutex> lock{mutex_};
   auto it = registry_.find(viewTag);
   if (it == registry_.end()) {
     return nullptr;
@@ -25,14 +35,17 @@ folly::dynamic StaticPropsRegistry::get(const Tag viewTag) const {
 }
 
 bool StaticPropsRegistry::has(const Tag viewTag) const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return registry_.find(viewTag) != registry_.end();
 }
 
 void StaticPropsRegistry::remove(const Tag viewTag) {
+  std::lock_guard<std::mutex> lock{mutex_};
   registry_.erase(viewTag);
 }
 
 bool StaticPropsRegistry::isEmpty() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return registry_.empty() && observers_.empty();
 }
 

package/Common/cpp/reanimated/CSS/registries/StaticPropsRegistry.h

@@ -2,6 +2,7 @@
 
 #include <react/renderer/core/ShadowNode.h>
 
+#include <mutex>
 #include <unordered_map>
 
 namespace reanimated::css {
@@ -24,6 +25,10 @@ class StaticPropsRegistry {
   void removeObserver(Tag viewTag);
 
  private:
+  /// registry_ is written on the JS thread (setViewStyle) and read on the UI
+  /// thread during interpolation and on the commit/mount thread during node
+  /// removals, so it needs its own guard. observers_ is JS-thread-only.
+  mutable std::mutex mutex_;
   std::unordered_map<Tag, folly::dynamic> registry_;
   std::unordered_map<Tag, PropsObserver> observers_;
 

package/Common/cpp/reanimated/CSS/svg/values/SVGStrokeDashArray.cpp

@@ -43,6 +43,11 @@ bool SVGStrokeDashArray::canConstruct(const folly::dynamic &value) {
 }
 
 folly::dynamic SVGStrokeDashArray::toDynamic() const {
+  // Empty means "no dashing" - emit null instead of [], which react-native-svg
+  // would feed to Android's DashPathEffect that requires at least 2 intervals.
+  if (values.empty()) {
+    return nullptr;
+  }
   folly::dynamic array = folly::dynamic::array;
   array.reserve(values.size());
   for (const auto &value : values) {

package/Common/cpp/reanimated/Fabric/ReanimatedMountHook.cpp

@@ -9,8 +9,12 @@ namespace reanimated {
 ReanimatedMountHook::ReanimatedMountHook(
     const std::shared_ptr<UIManager> &uiManager,
     const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+    const std::shared_ptr<css::ViewStylesRepository> &viewStylesRepository,
     const std::function<void()> &requestFlush)
-    : uiManager_(uiManager), updatesRegistryManager_(updatesRegistryManager), requestFlush_(requestFlush) {
+    : uiManager_(uiManager),
+      updatesRegistryManager_(updatesRegistryManager),
+      viewStylesRepository_(viewStylesRepository),
+      requestFlush_(requestFlush) {
   uiManager_->registerMountHook(*this);
 }
 
@@ -26,24 +30,33 @@ void ReanimatedMountHook::shadowTreeDidMount(
   auto reaShadowNode = std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(
       std::const_pointer_cast<RootShadowNode>(rootShadowNode));
 
-  if (reaShadowNode->hasReanimatedMountTrait()) {
-    // We mark reanimated commits with ReanimatedMountTrait. We don't want other
-    // shadow nodes to use this trait, but since this rootShadowNode is Shared,
-    // we don't have that guarantee. That's why we also unset this trait in the
-    // commit hook. We remove it here mainly for the sake of cleanliness.
+  // We mark reanimated commits with ReanimatedMountTrait. We don't want other
+  // shadow nodes to use this trait, but since this rootShadowNode is Shared,
+  // we don't have that guarantee. That's why we also unset this trait in the
+  // commit hook. We remove it here mainly for the sake of cleanliness.
+  const bool isReanimatedMount = reaShadowNode->hasReanimatedMountTrait();
+  if (isReanimatedMount) {
     reaShadowNode->unsetReanimatedMountTrait();
-    return;
   }
 
   {
     auto lock = updatesRegistryManager_->lock();
+    // Record the mounted tree for relative-length resolution.
+    viewStylesRepository_->setLastMountedRoot(rootShadowNode);
+
+    // Always drain removable nodes, even on Reanimated's own commits. While CSS
+    // animations run every mount carries the mount trait, so returning early here
+    // would skip removals for the whole animation and leak unmounted nodes if the
+    // tree is torn down mid-animation.
     updatesRegistryManager_->handleNodeRemovals(*rootShadowNode);
 
-    // When commit from React Native has finished, we reset the skip commit flag
-    // in order to allow Reanimated to commit its tree
-    updatesRegistryManager_->unpauseReanimatedCommits();
-    if (updatesRegistryManager_->shouldCommitAfterPause()) {
-      requestFlush_();
+    if (!isReanimatedMount) {
+      // When a commit from React Native has finished, we reset the skip commit
+      // flag in order to allow Reanimated to commit its tree.
+      updatesRegistryManager_->unpauseReanimatedCommits();
+      if (updatesRegistryManager_->shouldCommitAfterPause()) {
+        requestFlush_();
+      }
     }
   }
 }

package/Common/cpp/reanimated/Fabric/ReanimatedMountHook.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <reanimated/CSS/misc/ViewStylesRepository.h>
 #include <reanimated/Fabric/ShadowTreeCloner.h>
 #include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
 
@@ -16,6 +17,7 @@ class ReanimatedMountHook : public UIManagerMountHook {
   ReanimatedMountHook(
       const std::shared_ptr<UIManager> &uiManager,
       const std::shared_ptr<UpdatesRegistryManager> &updatesRegistryManager,
+      const std::shared_ptr<css::ViewStylesRepository> &viewStylesRepository,
       const std::function<void()> &requestFlush);
   ~ReanimatedMountHook() noexcept override;
 
@@ -24,6 +26,7 @@ class ReanimatedMountHook : public UIManagerMountHook {
  private:
   const std::shared_ptr<UIManager> uiManager_;
   const std::shared_ptr<UpdatesRegistryManager> updatesRegistryManager_;
+  const std::shared_ptr<css::ViewStylesRepository> viewStylesRepository_;
   const std::function<void()> requestFlush_;
 };
 

package/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.cpp

@@ -1,8 +1,10 @@
 #include <reanimated/Fabric/updates/AnimatedPropsRegistry.h>
 #include <reanimated/Tools/FeatureFlags.h>
 
+#include <functional>
 #include <memory>
 #include <utility>
+#include <vector>
 
 namespace reanimated {
 
@@ -25,25 +27,59 @@ void AnimatedPropsRegistry::update(jsi::Runtime &rt, const jsi::Value &operation
     addUpdatesToBatch(shadowNode, jsi::dynamicFromValue(rt, updates));
 
     if constexpr (StaticFeatureFlags::getFlag("FORCE_REACT_RENDER_FOR_SETTLED_ANIMATIONS")) {
-      timestampMap_[shadowNode->getTag()] = timestamp;
+      const auto tag = shadowNode->getTag();
+      timestampMap_[tag] = timestamp;
+      // If JS already has a `settledProps` snapshot for this tag, it is now
+      // stale — schedule a refresh on the next `collectSettledUpdates`.
+      if (syncedTags_.erase(tag) > 0) {
+        invalidatedTags_.insert(tag);
+      }
     }
   }
 }
 
-jsi::Value AnimatedPropsRegistry::getUpdatesOlderThanTimestamp(
-    jsi::Runtime &rt,
-    const double timestamp,
-    const double cleanupTimestamp) {
+jsi::Value AnimatedPropsRegistry::collectSettledUpdates(jsi::Runtime &rt, const double settledTimestamp) {
   std::lock_guard<std::mutex> lock{mutex_};
-  removeUpdatesOlderThanTimestamp(cleanupTimestamp);
 
   std::vector<std::pair<Tag, std::reference_wrapper<const folly::dynamic>>> updates;
 
-  for (const auto &[viewTag, pair] : updatesRegistry_) {
-    auto it = timestampMap_.find(viewTag);
-    if (it != timestampMap_.end() && it->second < timestamp) {
-      updates.emplace_back(viewTag, std::cref(pair.second));
+  for (auto it = updatesRegistry_.begin(); it != updatesRegistry_.end();) {
+    const auto viewTag = it->first;
+
+    if (syncedTags_.contains(viewTag)) {
+      // React already has the latest value for this tag (synced on a previous
+      // call, so the `settledProps` state is committed by now) — the registry
+      // entry is redundant. `syncedTags_` is intentionally retained to detect
+      // re-animation staleness. Note that `syncedTags_` and `invalidatedTags_`
+      // are disjoint — `update()` moves tags from the former to the latter.
+      timestampMap_.erase(viewTag);
+      it = updatesRegistry_.erase(it);
+      continue;
+    }
+
+    const auto timestampIt = timestampMap_.find(viewTag);
+    if (timestampIt == timestampMap_.end()) {
+      ++it;
+      continue;
+    }
+    const bool isSettled = timestampIt->second < settledTimestamp;
+    const auto invalidatedIt = invalidatedTags_.find(viewTag);
+    const bool isInvalidated = invalidatedIt != invalidatedTags_.end();
+    if (isSettled || isInvalidated) {
+      updates.emplace_back(viewTag, std::cref(it->second.second));
+      if (isSettled) {
+        // Only settled-path tags are tracked as "synced" so that an ongoing
+        // animation doesn't re-trigger an invalidation/sync on every GC tick.
+        syncedTags_.insert(viewTag);
+      }
+      if (isInvalidated) {
+        // Only erase serviced invalidations; if a tag was invalidated but the
+        // matching update batch hasn't been flushed into updatesRegistry_ yet,
+        // we leave the entry so the next sync picks it up.
+        invalidatedTags_.erase(invalidatedIt);
+      }
     }
+    ++it;
   }
 
   const jsi::Array array(rt, updates.size());
@@ -58,22 +94,11 @@ jsi::Value AnimatedPropsRegistry::getUpdatesOlderThanTimestamp(
   return jsi::Value(rt, array);
 }
 
-void AnimatedPropsRegistry::removeUpdatesOlderThanTimestamp(const double timestamp) {
-  for (auto it = timestampMap_.begin(); it != timestampMap_.end();) {
-    const auto viewTag = it->first;
-    const auto viewTimestamp = it->second;
-    if (viewTimestamp < timestamp) {
-      it = timestampMap_.erase(it);
-      updatesRegistry_.erase(viewTag);
-    } else {
-      it++;
-    }
-  }
-}
-
 void AnimatedPropsRegistry::removeTag(const Tag tag) {
   updatesRegistry_.erase(tag);
   timestampMap_.erase(tag);
+  syncedTags_.erase(tag);
+  invalidatedTags_.erase(tag);
 }
 
 } // namespace reanimated

package/Common/cpp/reanimated/Fabric/updates/AnimatedPropsRegistry.h

@@ -4,10 +4,8 @@
 
 #include <react/renderer/uimanager/UIManager.h>
 
-#include <memory>
-#include <string>
 #include <unordered_map>
-#include <vector>
+#include <unordered_set>
 
 namespace reanimated {
 
@@ -15,13 +13,22 @@ class AnimatedPropsRegistry : public UpdatesRegistry {
  public:
   void update(jsi::Runtime &rt, const jsi::Value &operations, double timestamp);
 
-  /// Also removes updates older than `cleanupTimestamp` from the registry.
-  jsi::Value getUpdatesOlderThanTimestamp(jsi::Runtime &rt, double timestamp, double cleanupTimestamp);
+  /// Returns updates that settled (received no update since `settledTimestamp`)
+  /// or whose synced `settledProps` snapshot was invalidated by a fresh update.
+  /// Also evicts entries that have already been synced to React — by the time
+  /// of the next call, the corresponding `settledProps` state is guaranteed to
+  /// be committed, so the registry entries are redundant.
+  jsi::Value collectSettledUpdates(jsi::Runtime &rt, double settledTimestamp);
 
  private:
   std::unordered_map<Tag, double> timestampMap_; // viewTag -> timestamp, protected by `mutex_`
+  // Tags whose latest values have already been pushed to React `settledProps`.
+  // Intentionally retained after eviction to detect re-animation staleness.
+  std::unordered_set<Tag> syncedTags_;
+  // Tags that were synced to React but received a fresh worklet update since;
+  // their `settledProps` are stale and need to be refreshed on the next sync.
+  std::unordered_set<Tag> invalidatedTags_;
 
-  void removeUpdatesOlderThanTimestamp(double timestamp);
   void removeTag(Tag tag) override;
 };
 

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

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/uimanager/UIManager.h>
@@ -24,6 +25,31 @@ struct LayoutAnimation {
   LayoutAnimation &operator=(const LayoutAnimation &other) = default;
 };
 
+#ifdef ANDROID
+// Bookkeeping for animation starts that were scheduled onto the UI thread but
+// haven't run yet — see `pendingStarts_` below.
+struct PendingStart {
+  int count = 0;
+  uint64_t handle = 0;
+};
+
+// Removes one pending start for the given tag and returns whether it was
+// cancelled since it was scheduled (i.e. its handle is no longer current).
+// Call under the proxy mutex.
+inline bool
+consumeIsCancelled(std::unordered_map<Tag, PendingStart> &pendingStarts, const Tag tag, const uint64_t handle) {
+  const auto it = pendingStarts.find(tag);
+  // every scheduled start keeps its entry alive until it is consumed —
+  // cancellations only bump the handle, they never erase
+  react_native_assert(it != pendingStarts.end() && "PendingStart not found");
+  const bool isCancelled = it->second.handle != handle;
+  if (--it->second.count == 0) {
+    pendingStarts.erase(it);
+  }
+  return isCancelled;
+}
+#endif
+
 class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDelegate {
  public:
   LayoutAnimationsProxyCommon(
@@ -75,6 +101,18 @@ class LayoutAnimationsProxyCommon : public facebook::react::MountingOverrideDele
 
   void restoreOpacityInCaseOfFlakyEnteringAnimation(SurfaceId surfaceId) const;
 
+  // On Android pullTransaction can run on the JS thread, so animation starts
+  // are scheduled onto the UI thread. If `maybeCancelAnimation` is called between the
+  // start was scheduled and the lambda runs, it
+  // finds no `layoutAnimations_` entry to erase (the start lambda hasn't created it
+  // yet) and the cancellation is lost — the stale start would later
+  // "resurrect" the animation for a view whose Remove+Delete are already on
+  // their way to the mounting layer
+  // (https://github.com/software-mansion/react-native-reanimated/issues/7493).
+
+  // To work around this, we keep a separate `pendingStarts_` map that tracks scheduled starts by tag,
+  //  with a generation counter to detect cancellations.
+  mutable std::unordered_map<Tag, PendingStart> pendingStarts_;
 #endif
 };