@react-native-ohos/react-native-reanimated 4.0.2 → 4.1.0-beta.1

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.cpp

@@ -1,5 +1,11 @@
 #include <reanimated/Fabric/updates/UpdatesRegistry.h>
 
+#include <reanimated/Fabric/updates/PropsLayoutFilter.h>
+#include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
+
+#include <react/debug/react_native_assert.h>
+
+#include <jsi/jsi.h>
 #include <memory>
 #include <string>
 #include <unordered_set>
@@ -8,17 +14,13 @@
 
 namespace reanimated {
 
-std::lock_guard<std::mutex> UpdatesRegistry::lock() const {
-  return std::lock_guard<std::mutex>{mutex_};
-}
-
 bool UpdatesRegistry::isEmpty() const {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
   return updatesRegistry_.empty();
 }
 
 folly::dynamic UpdatesRegistry::get(const Tag tag) const {
-  std::lock_guard<std::mutex> lock{mutex_};
-
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
   auto it = updatesRegistry_.find(tag);
   if (it == updatesRegistry_.cend()) {
     return nullptr;
@@ -26,51 +28,182 @@ folly::dynamic UpdatesRegistry::get(const Tag tag) const {
   return it->second.second;
 }
 
+void UpdatesRegistry::remove(const Tag tag) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  removeTag(tag);
+}
+
 void UpdatesRegistry::flushUpdates(UpdatesBatch &updatesBatch) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  flush(updatesBatch);
+}
+
+void UpdatesRegistry::flush(UpdatesBatch &updatesBatch) {
   auto copiedUpdatesBatch = std::move(updatesBatch_);
   updatesBatch_.clear();
 
   // Store all updates in the registry for later use in the commit hook
   flushUpdatesToRegistry(copiedUpdatesBatch);
   // Flush the updates to the updatesBatch used to apply current changes
-  for (auto &[shadowNode, props] : copiedUpdatesBatch) {
-    updatesBatch.emplace_back(shadowNode, std::move(props));
+  for (auto &[shadowNodeFamily, props] : copiedUpdatesBatch) {
+    updatesBatch.emplace_back(shadowNodeFamily, std::move(props));
   }
 }
 
+#if REACT_NATIVE_VERSION_MINOR >= 85
+void UpdatesRegistry::flushUpdates(UpdatesBatchAnimatedProps &updatesBatch) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  flush(updatesBatch);
+}
+
+void UpdatesRegistry::flush(UpdatesBatchAnimatedProps &updatesBatch) {
+  auto copiedUpdatesBatch = std::move(updatesBatchAnimatedProps_);
+  updatesBatchAnimatedProps_.clear();
+
+  for (auto &entry : copiedUpdatesBatch) {
+    updatesBatch.push_back(std::move(entry));
+  }
+}
+
+void UpdatesRegistry::flushNonLayoutUpdates(jsi::Runtime &rt, AnimationMutations &mutations) {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+
+  UpdatesBatchAnimatedProps remaining;
+
+  for (auto &[shadowNodeFamily, animatedProp, _hasLayout] : updatesBatchAnimatedProps_) {
+    // Split typed props by layout vs non-layout.
+    std::vector<std::unique_ptr<AnimatedPropBase>> nonLayoutTypedProps;
+    std::vector<std::unique_ptr<AnimatedPropBase>> layoutTypedProps;
+    for (auto &prop : animatedProp.props) {
+      if (isLayoutProp(prop->propName)) {
+        layoutTypedProps.push_back(std::move(prop));
+      } else {
+        nonLayoutTypedProps.push_back(std::move(prop));
+      }
+    }
+
+    // Split rawProps by layout vs non-layout.
+    std::unique_ptr<RawProps> nonLayoutRawProps;
+    std::unique_ptr<RawProps> layoutRawProps;
+    if (animatedProp.rawProps) {
+      auto propsDyn = animatedProp.rawProps->toDynamic();
+      folly::dynamic nonLayoutDyn = folly::dynamic::object();
+      folly::dynamic layoutDyn = folly::dynamic::object();
+      for (const auto &key : propsDyn.keys()) {
+        const auto keyStr = key.asString();
+        const auto propName = propNameFromString(keyStr);
+        if (propName.has_value() && isLayoutProp(propName.value())) {
+          layoutDyn[keyStr] = propsDyn[key];
+        } else {
+          nonLayoutDyn[keyStr] = propsDyn[key];
+        }
+      }
+      if (!nonLayoutDyn.empty()) {
+        nonLayoutRawProps = std::make_unique<RawProps>(rt, jsi::valueFromDynamic(rt, nonLayoutDyn));
+      }
+      if (!layoutDyn.empty()) {
+        layoutRawProps = std::make_unique<RawProps>(rt, jsi::valueFromDynamic(rt, layoutDyn));
+      }
+    }
+
+    // Non-layout part → apply now.
+    if (!nonLayoutTypedProps.empty() || nonLayoutRawProps) {
+      AnimatedProps nonLayoutProps{std::move(nonLayoutTypedProps), std::move(nonLayoutRawProps)};
+      mutations.batch.push_back(
+          AnimationMutation{shadowNodeFamily->getTag(), shadowNodeFamily, std::move(nonLayoutProps), false});
+    }
+
+    // Layout part → defer to next full flush.
+    if (!layoutTypedProps.empty() || layoutRawProps) {
+      AnimatedProps layoutProps{std::move(layoutTypedProps), std::move(layoutRawProps)};
+      remaining.push_back(AnimatedPropsEntry{shadowNodeFamily, std::move(layoutProps), true});
+    }
+  }
+
+  updatesBatchAnimatedProps_ = std::move(remaining);
+}
+
+bool UpdatesRegistry::hasPendingAnimatedPropsUpdates() const {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  return !updatesBatchAnimatedProps_.empty();
+}
+
+void UpdatesRegistry::addAnimatedPropsToBatch(
+    const ShadowNodeFamily::Shared &shadowNodeFamily,
+    AnimatedProps animatedProps,
+    bool hasLayoutUpdates) {
+  if (!hasLayoutUpdates) {
+    for (const auto &prop : animatedProps.props) {
+      if (isLayoutProp(prop->propName)) {
+        hasLayoutUpdates = true;
+        break;
+      }
+    }
+  }
+  updatesBatchAnimatedProps_.push_back(
+      AnimatedPropsEntry{shadowNodeFamily, std::move(animatedProps), hasLayoutUpdates});
+}
+
+void UpdatesRegistry::addRawPropsToAnimatedPropsBatch(
+    const ShadowNodeFamily::Shared &shadowNodeFamily,
+    folly::dynamic props) {
+  const bool hasLayoutUpdates = hasLayoutProps(props);
+  animatedPropsBuilder_.storeDynamic(props);
+  addAnimatedPropsToBatch(shadowNodeFamily, animatedPropsBuilder_.get(), hasLayoutUpdates);
+}
+
+void UpdatesRegistry::addJSIPropsToAnimatedPropsBatch(
+    const ShadowNodeFamily::Shared &shadowNodeFamily,
+    jsi::Runtime &rt,
+    jsi::Value &props) {
+  const bool hasLayoutUpdates = hasLayoutProps(rt, props);
+  animatedPropsBuilder_.storeJSI(rt, props);
+  addAnimatedPropsToBatch(shadowNodeFamily, animatedPropsBuilder_.get(), hasLayoutUpdates);
+}
+#endif
+
+UpdatesBatch UpdatesRegistry::getPendingUpdates() {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
+  flushUpdatesToRegistry(updatesBatch_);
+
+  UpdatesBatch updatesBatch;
+  for (const auto &[tag, pair] : updatesRegistry_) {
+    const auto &[shadowNodeFamily, props] = pair;
+    updatesBatch.emplace_back(shadowNodeFamily, props);
+  }
+  return updatesBatch;
+}
+
 void UpdatesRegistry::collectProps(PropsMap &propsMap) {
-  std::lock_guard<std::mutex> lock{mutex_};
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
 
   auto copiedRegistry = updatesRegistry_;
   for (const auto &[tag, pair] : copiedRegistry) {
-    const auto &[shadowNode, props] = pair;
-    auto &family = shadowNode->getFamily();
-    auto it = propsMap.find(&family);
+    const auto &[shadowNodeFamily, props] = pair;
+    const auto it = propsMap.find(shadowNodeFamily);
 
     if (it == propsMap.cend()) {
       auto propsVector = std::vector<RawProps>{};
       propsVector.emplace_back(RawProps(props));
-      propsMap.emplace(&family, propsVector);
+      propsMap.emplace(shadowNodeFamily, propsVector);
     } else {
       it->second.push_back(RawProps(props));
     }
   }
 }
 
-void UpdatesRegistry::addUpdatesToBatch(
-    const std::shared_ptr<const ShadowNode> &shadowNode,
-    const folly::dynamic &props) {
-  updatesBatch_.emplace_back(shadowNode, props);
+void UpdatesRegistry::addUpdatesToBatch(const ShadowNodeFamily::Shared &shadowNodeFamily, const folly::dynamic &props) {
+  updatesBatch_.emplace_back(shadowNodeFamily, props);
 }
 
 void UpdatesRegistry::setInUpdatesRegistry(
-    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const ShadowNodeFamily::Shared &shadowNodeFamily,
     const folly::dynamic &props) {
-  const auto tag = shadowNode->getTag();
+  const auto tag = shadowNodeFamily->getTag();
 #ifdef ANDROID
   updatePropsToRevert(tag, &props);
 #endif
-  updatesRegistry_[tag] = std::make_pair(shadowNode, props);
+  updatesRegistry_[tag] = std::make_pair(shadowNodeFamily, props);
 }
 
 folly::dynamic UpdatesRegistry::getUpdatesFromRegistry(const Tag tag) const {
@@ -89,12 +222,12 @@ void UpdatesRegistry::removeFromUpdatesRegistry(const Tag tag) {
 }
 
 void UpdatesRegistry::flushUpdatesToRegistry(const UpdatesBatch &updatesBatch) {
-  for (auto &[shadowNode, props] : updatesBatch) {
-    const auto tag = shadowNode->getTag();
+  for (auto &[shadowNodeFamily, props] : updatesBatch) {
+    const auto tag = shadowNodeFamily->getTag();
     auto it = updatesRegistry_.find(tag);
 
     if (it == updatesRegistry_.cend()) {
-      updatesRegistry_[tag] = std::make_pair(shadowNode, props);
+      updatesRegistry_[tag] = std::make_pair(shadowNodeFamily, props);
     } else {
       it->second.second.update(props);
     }
@@ -104,17 +237,18 @@ void UpdatesRegistry::flushUpdatesToRegistry(const UpdatesBatch &updatesBatch) {
 #ifdef ANDROID
 
 bool UpdatesRegistry::hasPropsToRevert() const {
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
   return !propsToRevertMap_.empty();
 }
 
 void UpdatesRegistry::collectPropsToRevert(PropsToRevertMap &propsToRevertMap) {
-  std::lock_guard<std::mutex> lock{mutex_};
+  react_native_assert(UpdatesRegistryManager::isLockedByCurrentThread());
 
   for (const auto &[tag, pair] : propsToRevertMap_) {
-    const auto &[shadowNode, props] = pair;
+    const auto &[shadowNodeFamily, props] = pair;
     const auto it = propsToRevertMap.find(tag);
     if (it == propsToRevertMap.end()) {
-      propsToRevertMap[tag] = {shadowNode, props};
+      propsToRevertMap[tag] = {shadowNodeFamily, props};
     } else {
       it->second.props.insert(props.begin(), props.end());
     }
@@ -129,10 +263,10 @@ void UpdatesRegistry::updatePropsToRevert(const Tag tag, const folly::dynamic *n
     return;
   }
 
-  const auto &shadowNode = it->second.first;
+  const auto &shadowNodeFamily = it->second.first;
   const auto &registryProps = it->second.second;
   if (propsToRevertMap_.find(tag) == propsToRevertMap_.end()) {
-    propsToRevertMap_[tag] = {shadowNode, std::unordered_set<std::string>()};
+    propsToRevertMap_[tag] = {shadowNodeFamily, std::unordered_set<std::string>()};
   }
 
   if (newProps == nullptr) {

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/UpdatesRegistry.h

@@ -1,10 +1,16 @@
 #pragma once
 
+#include <cxxreact/ReactNativeVersion.h>
+#include <jsi/jsi.h>
+#include <react/renderer/core/ShadowNode.h>
 #include <reanimated/Fabric/ShadowTreeCloner.h>
 
-#include <react/renderer/core/ShadowNode.h>
+#if REACT_NATIVE_VERSION_MINOR >= 85
+#include <react/renderer/animationbackend/AnimatedProps.h>
+#include <react/renderer/animationbackend/AnimatedPropsBuilder.h>
+#include <react/renderer/animationbackend/AnimationBackend.h>
+#endif
 
-#include <jsi/jsi.h>
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -17,48 +23,100 @@ namespace reanimated {
 using namespace facebook;
 using namespace react;
 
-using UpdatesBatch = std::vector<std::pair<std::shared_ptr<const ShadowNode>, folly::dynamic>>;
-using RegistryMap = std::unordered_map<Tag, std::pair<std::shared_ptr<const ShadowNode>, folly::dynamic>>;
+using UpdatesBatch = std::vector<std::pair<ShadowNodeFamily::Shared, folly::dynamic>>;
+
+#if REACT_NATIVE_VERSION_MINOR >= 85
+struct AnimatedPropsEntry {
+  const ShadowNodeFamily::Shared shadowNodeFamily;
+  AnimatedProps animatedProps;
+  const bool hasLayoutUpdates;
+};
+using UpdatesBatchAnimatedProps = std::vector<AnimatedPropsEntry>;
+#endif
+
+using RegistryMap = std::unordered_map<Tag, std::pair<ShadowNodeFamily::Shared, folly::dynamic>>;
 
 #ifdef ANDROID
 struct PropsToRevert {
-  std::shared_ptr<const ShadowNode> shadowNode;
+  ShadowNodeFamily::Shared shadowNodeFamily;
   std::unordered_set<std::string> props;
 };
 
 using PropsToRevertMap = std::unordered_map<Tag, PropsToRevert>;
 #endif
 
+// All public methods require `UpdatesRegistryManager::lock()` to be held.
 class UpdatesRegistry {
  public:
   virtual ~UpdatesRegistry() {}
 
-  std::lock_guard<std::mutex> lock() const;
-
   virtual bool isEmpty() const;
   folly::dynamic get(Tag tag) const;
-  virtual void remove(Tag tag) = 0;
+  void remove(Tag tag);
 
 #ifdef ANDROID
   bool hasPropsToRevert() const;
   void collectPropsToRevert(PropsToRevertMap &propsToRevertMap);
 #endif
 
+  // Drains pending style updates as folly::dynamic.
   void flushUpdates(UpdatesBatch &updatesBatch);
+
+#if REACT_NATIVE_VERSION_MINOR >= 85
+  // Drains pending typed animated props.
+  void flushUpdates(UpdatesBatchAnimatedProps &updatesBatch);
+
+  // Get only non-layout updates (for android event handling) in the animation backend path.
+  void flushNonLayoutUpdates(jsi::Runtime &rt, facebook::react::AnimationMutations &mutations);
+  bool hasPendingAnimatedPropsUpdates() const;
+  void addAnimatedPropsToBatch(
+      const ShadowNodeFamily::Shared &shadowNodeFamily,
+      AnimatedProps animatedProps,
+      bool hasLayoutUpdates = false);
+  void addRawPropsToAnimatedPropsBatch(const ShadowNodeFamily::Shared &shadowNodeFamily, folly::dynamic props);
+  void addJSIPropsToAnimatedPropsBatch(
+      const ShadowNodeFamily::Shared &shadowNodeFamily,
+      jsi::Runtime &rt,
+      jsi::Value &props);
+#endif
+
   void collectProps(PropsMap &propsMap);
+  UpdatesBatch getPendingUpdates();
 
  protected:
-  mutable std::mutex mutex_;
   RegistryMap updatesRegistry_;
 
-  void addUpdatesToBatch(const std::shared_ptr<const ShadowNode> &shadowNode, const folly::dynamic &props);
+  /// Assumes the caller already locked the registry.
+  void flush(UpdatesBatch &updatesBatch);
+
+#if REACT_NATIVE_VERSION_MINOR >= 85
+  // Assumes the caller already locked the registry.
+  void flush(UpdatesBatchAnimatedProps &updatesBatch);
+#endif
+
+  /// Assumes the caller already locked the registry.
+  virtual void removeTag(Tag tag) = 0;
+
+  /// Assumes the caller already locked the registry.
+  void addUpdatesToBatch(const ShadowNodeFamily::Shared &shadowNodeFamily, const folly::dynamic &props);
+
+  /// Assumes the caller already locked the registry.
   folly::dynamic getUpdatesFromRegistry(const Tag tag) const;
-  void setInUpdatesRegistry(const std::shared_ptr<const ShadowNode> &shadowNode, const folly::dynamic &props);
+
+  /// Assumes the caller already locked the registry.
+  void setInUpdatesRegistry(const ShadowNodeFamily::Shared &shadowNodeFamily, const folly::dynamic &props);
+
+  /// Assumes the caller already locked the registry.
   void removeFromUpdatesRegistry(Tag tag);
 
  private:
   UpdatesBatch updatesBatch_;
 
+#if REACT_NATIVE_VERSION_MINOR >= 85
+  UpdatesBatchAnimatedProps updatesBatchAnimatedProps_;
+  AnimatedPropsBuilder animatedPropsBuilder_;
+#endif
+
   void flushUpdatesToRegistry(const UpdatesBatch &updatesBatch);
 
 #ifdef ANDROID

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/UpdatesRegistryManager.cpp

@@ -1,17 +1,35 @@
 #include <reanimated/Fabric/updates/UpdatesRegistryManager.h>
 #include <reanimated/Tools/FeatureFlags.h>
 
+#include <react/debug/react_native_assert.h>
+
 #include <memory>
 #include <utility>
 #include <vector>
 
 namespace reanimated {
 
+namespace {
+thread_local bool tCurrentThreadHoldsLock = false;
+} // namespace
+
+UpdatesRegistryManager::ScopedLock::ScopedLock(std::mutex &mutex) : guard_(mutex) {
+  tCurrentThreadHoldsLock = true;
+}
+
+UpdatesRegistryManager::ScopedLock::~ScopedLock() {
+  tCurrentThreadHoldsLock = false;
+}
+
 UpdatesRegistryManager::UpdatesRegistryManager(const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry)
     : staticPropsRegistry_(staticPropsRegistry) {}
 
-std::lock_guard<std::mutex> UpdatesRegistryManager::lock() const {
-  return std::lock_guard<std::mutex>{mutex_};
+UpdatesRegistryManager::ScopedLock UpdatesRegistryManager::lock() const {
+  return ScopedLock{mutex_};
+}
+
+bool UpdatesRegistryManager::isLockedByCurrentThread() {
+  return tCurrentThreadHoldsLock;
 }
 
 void UpdatesRegistryManager::addRegistry(const std::shared_ptr<UpdatesRegistry> &registry) {
@@ -48,28 +66,31 @@ bool UpdatesRegistryManager::shouldCommitAfterPause() {
 }
 
 void UpdatesRegistryManager::markNodeAsRemovable(const std::shared_ptr<const ShadowNode> &shadowNode) {
-  removableShadowNodes_[shadowNode->getTag()] = shadowNode;
+  react_native_assert(isLockedByCurrentThread());
+  removableShadowNodes_[shadowNode->getTag()] = shadowNode->getFamilyShared();
 }
 
 void UpdatesRegistryManager::unmarkNodeAsRemovable(Tag viewTag) {
+  react_native_assert(isLockedByCurrentThread());
   removableShadowNodes_.erase(viewTag);
 }
 
 void UpdatesRegistryManager::handleNodeRemovals(const RootShadowNode &rootShadowNode) {
+  react_native_assert(isLockedByCurrentThread());
   RemovableShadowNodes remainingShadowNodes;
 
-  for (const auto &[tag, shadowNode] : removableShadowNodes_) {
-    if (!shadowNode) {
+  for (const auto &[tag, shadowNodeFamily] : removableShadowNodes_) {
+    if (!shadowNodeFamily) {
       continue;
     }
 
-    if (shadowNode->getFamily().getAncestors(rootShadowNode).empty()) {
+    if (shadowNodeFamily->getAncestors(rootShadowNode).empty()) {
       for (auto &registry : registries_) {
         registry->remove(tag);
       }
       staticPropsRegistry_->remove(tag);
     } else {
-      remainingShadowNodes.emplace(tag, shadowNode);
+      remainingShadowNodes.emplace(tag, shadowNodeFamily);
     }
   }
 
@@ -77,6 +98,7 @@ void UpdatesRegistryManager::handleNodeRemovals(const RootShadowNode &rootShadow
 }
 
 PropsMap UpdatesRegistryManager::collectProps() {
+  react_native_assert(isLockedByCurrentThread());
   PropsMap propsMap;
   for (auto &registry : registries_) {
     registry->collectProps(propsMap);
@@ -87,6 +109,7 @@ PropsMap UpdatesRegistryManager::collectProps() {
 #ifdef ANDROID
 
 bool UpdatesRegistryManager::hasPropsToRevert() {
+  react_native_assert(isLockedByCurrentThread());
   for (auto &registry : registries_) {
     if (registry->hasPropsToRevert()) {
       return true;
@@ -97,27 +120,27 @@ bool UpdatesRegistryManager::hasPropsToRevert() {
 
 void UpdatesRegistryManager::addToPropsMap(
     PropsMap &propsMap,
-    const std::shared_ptr<const ShadowNode> &shadowNode,
+    const ShadowNodeFamily::Shared &shadowNodeFamily,
     const folly::dynamic &props) {
-  auto &family = shadowNode->getFamily();
-  auto it = propsMap.find(&family);
+  auto it = propsMap.find(shadowNodeFamily);
 
   if (it == propsMap.cend()) {
     auto propsVector = std::vector<RawProps>{};
     propsVector.emplace_back(props);
-    propsMap.emplace(&family, propsVector);
+    propsMap.emplace(shadowNodeFamily, propsVector);
   } else {
     it->second.emplace_back(props);
   }
 }
 
 void UpdatesRegistryManager::collectPropsToRevertBySurface(std::unordered_map<SurfaceId, PropsMap> &propsMapBySurface) {
+  react_native_assert(isLockedByCurrentThread());
   for (const auto &registry : registries_) {
     registry->collectPropsToRevert(propsToRevertMap_);
   }
 
   for (const auto &[tag, pair] : propsToRevertMap_) {
-    const auto &[shadowNode, props] = pair;
+    const auto &[shadowNodeFamily, props] = pair;
     const auto &staticStyle = staticPropsRegistry_->get(tag);
     folly::dynamic filteredStyle = folly::dynamic::object;
 
@@ -127,8 +150,8 @@ void UpdatesRegistryManager::collectPropsToRevertBySurface(std::unordered_map<Su
         continue;
       }
 
-      const auto &componentName = shadowNode->getComponentName();
-      const auto &interpolators = getComponentInterpolators(componentName);
+      const auto &nativeComponentName = shadowNodeFamily->getComponentName();
+      const auto &interpolators = getComponentInterpolators(nativeComponentName);
       const auto &it = interpolators.find(propName);
 
       if (it != interpolators.end()) {
@@ -139,16 +162,17 @@ void UpdatesRegistryManager::collectPropsToRevertBySurface(std::unordered_map<Su
       filteredStyle[propName] = nullptr;
     }
 
-    const auto &surfaceId = shadowNode->getSurfaceId();
+    const auto &surfaceId = shadowNodeFamily->getSurfaceId();
     auto &propsMap = propsMapBySurface[surfaceId];
 
-    addToPropsMap(propsMap, shadowNode, filteredStyle);
+    addToPropsMap(propsMap, shadowNodeFamily, filteredStyle);
   }
 }
 
 void UpdatesRegistryManager::clearPropsToRevert(const SurfaceId surfaceId) {
+  react_native_assert(isLockedByCurrentThread());
   for (auto it = propsToRevertMap_.begin(); it != propsToRevertMap_.end();) {
-    if (it->second.shadowNode->getSurfaceId() == surfaceId) {
+    if (it->second.shadowNodeFamily->getSurfaceId() == surfaceId) {
       it = propsToRevertMap_.erase(it);
     } else {
       ++it;

package/harmony/reanimated/src/main/cpp/Common/cpp/reanimated/Fabric/updates/UpdatesRegistryManager.h

@@ -6,6 +6,7 @@
 #include <reanimated/Fabric/ShadowTreeCloner.h>
 #include <reanimated/Fabric/updates/UpdatesRegistry.h>
 
+#include <atomic>
 #include <memory>
 #include <unordered_map>
 #include <utility>
@@ -17,9 +18,19 @@ using namespace css;
 
 class UpdatesRegistryManager {
  public:
+  class [[nodiscard]] ScopedLock {
+   public:
+    explicit ScopedLock(std::mutex &mutex);
+    ~ScopedLock();
+
+   private:
+    std::lock_guard<std::mutex> guard_;
+  };
+
   explicit UpdatesRegistryManager(const std::shared_ptr<StaticPropsRegistry> &staticPropsRegistry);
 
-  std::lock_guard<std::mutex> lock() const;
+  ScopedLock lock() const;
+  static bool isLockedByCurrentThread();
 
   // TODO - ensure that other sublibraries can easily hook into this registry
   // manager (e.g. add priority to registries)
@@ -45,7 +56,7 @@ class UpdatesRegistryManager {
 #endif
 
  private:
-  using RemovableShadowNodes = std::unordered_map<Tag, std::shared_ptr<const ShadowNode>>;
+  using RemovableShadowNodes = std::unordered_map<Tag, ShadowNodeFamily::Shared>;
 
   mutable std::mutex mutex_;
   std::atomic<bool> isPaused_;
@@ -58,7 +69,7 @@ class UpdatesRegistryManager {
   PropsToRevertMap propsToRevertMap_;
 
   static void
-  addToPropsMap(PropsMap &propsMap, const std::shared_ptr<const ShadowNode> &shadowNode, const folly::dynamic &props);
+  addToPropsMap(PropsMap &propsMap, const ShadowNodeFamily::Shared &shadowNodeFamily, const folly::dynamic &props);
 #endif
 };