react-native-reanimated 4.3.0-rc.0 → 4.3.1

package/Common/cpp/reanimated/AnimatedSensor/AnimatedSensorModule.cpp

@@ -11,7 +11,7 @@ AnimatedSensorModule::AnimatedSensorModule(const PlatformDepMethodsHolder &platf
       platformUnregisterSensorFunction_(platformDepMethodsHolder.unregisterSensor) {}
 
 jsi::Value AnimatedSensorModule::registerSensor(
-    jsi::Runtime &rt,
+    jsi::Runtime &rnRuntime,
     const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
     const jsi::Value &sensorTypeValue,
     const jsi::Value &interval,
@@ -19,8 +19,11 @@ jsi::Value AnimatedSensorModule::registerSensor(
     const jsi::Value &sensorDataHandler) {
   SensorType sensorType = static_cast<SensorType>(sensorTypeValue.asNumber());
 
-  auto serializableHandler = extractSerializableOrThrow<SerializableWorklet>(
-      rt, sensorDataHandler, "[Reanimated] Sensor event handler must be a worklet.");
+  auto serializableHandler = extractSerializable(
+      rnRuntime,
+      sensorDataHandler,
+      "[Reanimated] Sensor event handler must be a worklet.",
+      Serializable::ValueType::WorkletType);
 
   int sensorId = platformRegisterSensorFunction_(
       static_cast<int>(sensorType),
@@ -33,7 +36,7 @@ jsi::Value AnimatedSensorModule::registerSensor(
           return;
         }
 
-        jsi::Runtime &uiRuntime = uiWorkletRuntime->getJSIRuntime();
+        jsi::Runtime &uiRuntime = getJSIRuntimeFromWorkletRuntime(uiWorkletRuntime);
         jsi::Object value(uiRuntime);
         if (sensorType == SensorType::ROTATION_VECTOR) {
           // TODO: timestamp should be provided by the platform implementation
@@ -53,7 +56,7 @@ jsi::Value AnimatedSensorModule::registerSensor(
         }
         value.setProperty(uiRuntime, "interfaceOrientation", orientationDegrees);
 
-        uiWorkletRuntime->runSync(serializableHandler, value);
+        runSyncOnRuntime(uiWorkletRuntime, serializableHandler, jsi::Value(uiRuntime, value));
       });
   if (sensorId != -1) {
     sensorsIds_.insert(sensorId);

package/Common/cpp/reanimated/AnimatedSensor/AnimatedSensorModule.h

@@ -1,10 +1,8 @@
 #pragma once
 
+#include <reanimated/Compat/WorkletsApi.h>
 #include <reanimated/Tools/PlatformDepMethodsHolder.h>
 
-#include <worklets/SharedItems/Serializable.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
-
 #include <jsi/jsi.h>
 
 #include <memory>
@@ -32,8 +30,8 @@ class AnimatedSensorModule {
   explicit AnimatedSensorModule(const PlatformDepMethodsHolder &platformDepMethodsHolder);
 
   jsi::Value registerSensor(
-      jsi::Runtime &rt,
-      const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+      jsi::Runtime &rnRuntime,
+      const std::shared_ptr<WorkletRuntime> &uiRuntime,
       const jsi::Value &sensorType,
       const jsi::Value &interval,
       const jsi::Value &iosReferenceFrame,

package/Common/cpp/reanimated/CSS/common/values/CSSValueVariant.cpp

@@ -12,8 +12,7 @@
 #include <reanimated/CSS/svg/values/SVGPath.h>
 #include <reanimated/CSS/svg/values/SVGStops.h>
 #include <reanimated/CSS/svg/values/SVGStrokeDashArray.h>
-
-#include <worklets/Tools/JSISerializer.h>
+#include <reanimated/Compat/WorkletsApi.h>
 
 #include <string>
 #include <utility>
@@ -41,7 +40,7 @@ CSSValueVariant<AllowedTypes...>::CSSValueVariant(jsi::Runtime &rt, const jsi::V
   // Try constructing with each allowed type until one succeeds
   if (!(tryOne.template operator()<AllowedTypes>() || ...)) {
     throw std::runtime_error(
-        "[Reanimated] No compatible type found for construction from: " + worklets::stringifyJSIValue(rt, jsiValue));
+        "[Reanimated] No compatible type found for construction from: " + worklets::JSIValueToStdString(rt, jsiValue));
   }
 }
 

package/Common/cpp/reanimated/CSS/interpolation/PropertyInterpolator.cpp

@@ -1,6 +1,5 @@
 #include <reanimated/CSS/interpolation/PropertyInterpolator.h>
-
-#include <worklets/Tools/JSISerializer.h>
+#include <reanimated/Compat/WorkletsApi.h>
 
 #include <memory>
 #include <utility>
@@ -35,7 +34,7 @@ std::vector<std::pair<double, jsi::Value>> PropertyInterpolator::parseJSIKeyfram
     throw std::invalid_argument(
         "[Reanimated] Received invalid keyframes object for property: " + getPropertyPathString() +
         ".\n\nExpected an array of objects with 'offset' and 'value' properties, got: " +
-        worklets::stringifyJSIValue(rt, keyframes));
+        worklets::JSIValueToStdString(rt, keyframes));
   }
 
   const auto keyframeArray = keyframes.asObject(rt).asArray(rt);

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

@@ -9,12 +9,14 @@
 namespace reanimated::css {
 
 bool CSSAnimationsRegistry::isEmpty() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   // The registry is empty if has no registered animations and no updates
   // stored in the updates registry
-  return UpdatesRegistry::isEmpty() && registry_.empty();
+  return updatesRegistry_.empty() && registry_.empty();
 }
 
 bool CSSAnimationsRegistry::hasUpdates() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return !runningAnimationIndicesMap_.empty() || !delayedAnimationsManager_.empty() || !animationsToRevertMap_.empty();
 }
 
@@ -25,11 +27,13 @@ void CSSAnimationsRegistry::apply(
     const CSSAnimationsMap &newAnimations,
     const CSSAnimationSettingsUpdatesMap &settingsUpdates,
     double timestamp) {
+  std::lock_guard<std::mutex> lock{mutex_};
+
   auto animationsVector = buildAnimationsVector(rt, shadowNode, animationNames, newAnimations);
 
   const auto viewTag = shadowNode->getTag();
   if (animationsVector.empty()) {
-    remove(viewTag);
+    removeTag(viewTag);
     return;
   }
 
@@ -56,7 +60,7 @@ void CSSAnimationsRegistry::apply(
   applyViewAnimationsStyle(viewTag, timestamp);
 }
 
-void CSSAnimationsRegistry::remove(const Tag viewTag) {
+void CSSAnimationsRegistry::removeTag(const Tag viewTag) {
   removeViewAnimations(viewTag);
   removeFromUpdatesRegistry(viewTag);
   registry_.erase(viewTag);

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

@@ -7,6 +7,7 @@
 #include <reanimated/Fabric/updates/UpdatesRegistry.h>
 
 #include <memory>
+#include <mutex>
 #include <set>
 #include <string>
 #include <unordered_map>
@@ -33,9 +34,12 @@ class CSSAnimationsRegistry : public UpdatesRegistry, std::enable_shared_from_th
       const CSSAnimationsMap &newAnimations,
       const CSSAnimationSettingsUpdatesMap &settingsUpdates,
       double timestamp);
-  void remove(Tag viewTag) override;
 
-  void update(double timestamp);
+  void updateAndFlush(double timestamp, UpdatesBatch &updatesBatch) {
+    std::lock_guard<std::mutex> lock{mutex_};
+    update(timestamp);
+    flush(updatesBatch);
+  }
 
  private:
   using AnimationToIndexMap = std::unordered_map<std::shared_ptr<CSSAnimation>, size_t>;
@@ -54,6 +58,9 @@ class CSSAnimationsRegistry : public UpdatesRegistry, std::enable_shared_from_th
   AnimationsToRevertMap animationsToRevertMap_;
   DelayedItemsManager<std::shared_ptr<CSSAnimation>> delayedAnimationsManager_;
 
+  void removeTag(Tag viewTag) override;
+  void update(double timestamp);
+
   CSSAnimationsVector buildAnimationsVector(
       jsi::Runtime &rt,
       const std::shared_ptr<const ShadowNode> &shadowNode,

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

@@ -11,12 +11,14 @@ CSSTransitionsRegistry::CSSTransitionsRegistry(
     : getCurrentTimestamp_(getCurrentTimestamp), viewStylesRepository_(viewStylesRepository) {}
 
 bool CSSTransitionsRegistry::isEmpty() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   // The registry is empty if has no registered animations and no updates
   // stored in the updates registry
-  return UpdatesRegistry::isEmpty() && registry_.empty();
+  return updatesRegistry_.empty() && registry_.empty();
 }
 
 bool CSSTransitionsRegistry::hasUpdates() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return !runningTransitionTags_.empty() || !delayedTransitionsManager_.empty();
 }
 
@@ -24,6 +26,8 @@ void CSSTransitionsRegistry::run(
     jsi::Runtime &rt,
     const std::shared_ptr<const ShadowNode> &shadowNode,
     const CSSTransitionConfig &config) {
+  std::lock_guard<std::mutex> lock{mutex_};
+
   const auto viewTag = shadowNode->getTag();
 
   if (!registry_.contains(viewTag)) {
@@ -42,7 +46,7 @@ void CSSTransitionsRegistry::run(
   updateInUpdatesRegistry(transition, initialUpdate);
 }
 
-void CSSTransitionsRegistry::remove(const Tag viewTag) {
+void CSSTransitionsRegistry::removeTag(const Tag viewTag) {
   removeFromUpdatesRegistry(viewTag);
   delayedTransitionsManager_.remove(viewTag);
   runningTransitionTags_.erase(viewTag);

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

@@ -8,6 +8,7 @@
 #include <reanimated/Tools/PlatformDepMethodsHolder.h>
 
 #include <memory>
+#include <mutex>
 #include <set>
 #include <unordered_map>
 #include <unordered_set>
@@ -26,9 +27,12 @@ class CSSTransitionsRegistry : public UpdatesRegistry, public std::enable_shared
   bool hasUpdates() const;
 
   void run(jsi::Runtime &rt, const std::shared_ptr<const ShadowNode> &shadowNode, const CSSTransitionConfig &config);
-  void remove(Tag viewTag) override;
 
-  void update(double timestamp);
+  void updateAndFlush(double timestamp, UpdatesBatch &updatesBatch) {
+    std::lock_guard<std::mutex> lock{mutex_};
+    update(timestamp);
+    flush(updatesBatch);
+  }
 
  private:
   using Registry = std::unordered_map<Tag, std::shared_ptr<CSSTransition>>;
@@ -41,6 +45,8 @@ class CSSTransitionsRegistry : public UpdatesRegistry, public std::enable_shared
   std::unordered_set<Tag> runningTransitionTags_;
   DelayedItemsManager<Tag> delayedTransitionsManager_;
 
+  void removeTag(Tag viewTag) override;
+  void update(double timestamp);
   void activateDelayedTransitions(double timestamp);
   void scheduleOrActivateTransition(const std::shared_ptr<CSSTransition> &transition);
   void updateInUpdatesRegistry(const std::shared_ptr<CSSTransition> &transition, const folly::dynamic &updates);

package/Common/cpp/reanimated/CSS/utils/DelayedItemsManager.cpp

@@ -18,7 +18,7 @@ bool DelayedItemComparator<TValue>::operator()(const DelayedItem<TValue> &lhs, c
 }
 
 template <typename TValue>
-void DelayedItemsManager<TValue>::add(const double timestamp, const TValue value) {
+void DelayedItemsManager<TValue>::add(const double timestamp, const TValue &value) {
   auto result = itemsSet_.emplace(timestamp, value);
   if (result.second) {
     itemsMap_[result.first->value] = result.first;
@@ -38,7 +38,7 @@ typename DelayedItemsManager<TValue>::Item DelayedItemsManager<TValue>::pop() {
 }
 
 template <typename TValue>
-bool DelayedItemsManager<TValue>::remove(const TValue value) {
+bool DelayedItemsManager<TValue>::remove(const TValue &value) {
   auto it = itemsMap_.find(value);
 
   if (it == itemsMap_.end()) {

package/Common/cpp/reanimated/CSS/utils/DelayedItemsManager.h

@@ -34,9 +34,9 @@ class DelayedItemsManager {
   ItemMap itemsMap_;
 
  public:
-  void add(double timestamp, TValue value);
+  void add(double timestamp, const TValue &value);
   Item pop();
-  bool remove(TValue value);
+  bool remove(const TValue &value);
   const Item &top() const;
   bool empty() const;
   size_t size() const;

package/Common/cpp/reanimated/Compat/WorkletsApi.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <worklets/Compat/StableApi.h>
+#include <string>
+
+#define EXPECTED_WORKLETS_STABLE_API_VERSION "0.8.0"
+
+static_assert(
+    std::string(WORKLETS_STABLE_API_VERSION) == EXPECTED_WORKLETS_STABLE_API_VERSION,
+    "Incompatible worklets stable API version. Expected " EXPECTED_WORKLETS_STABLE_API_VERSION
+    ", but got " WORKLETS_STABLE_API_VERSION ".");
+
+#undef EXPECTED_WORKLETS_STABLE_API_VERSION

package/Common/cpp/reanimated/Events/UIEventHandler.cpp

@@ -11,7 +11,7 @@ void UIEventHandler::process(
     const std::shared_ptr<WorkletRuntime> &uiRuntime,
     const double eventTimestamp,
     const jsi::Value &eventValue) const {
-  uiRuntime->runSync(handlerFunction_, jsi::Value(eventTimestamp), eventValue);
+  runSyncOnRuntime(uiRuntime, handlerFunction_, jsi::Value(eventTimestamp), eventValue);
 }
 
 uint64_t UIEventHandler::getHandlerId() const {

package/Common/cpp/reanimated/Events/UIEventHandler.h

@@ -1,8 +1,7 @@
 #pragma once
 
 #include <jsi/jsi.h>
-#include <worklets/SharedItems/Serializable.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <reanimated/Compat/WorkletsApi.h>
 
 #include <memory>
 #include <string>
@@ -15,14 +14,14 @@ class UIEventHandler {
   const uint64_t handlerId_;
   const uint64_t emitterReactTag_;
   const std::string eventName_;
-  const std::shared_ptr<worklets::SerializableWorklet> handlerFunction_;
+  const std::shared_ptr<worklets::Serializable> handlerFunction_;
 
  public:
   UIEventHandler(
       const uint64_t handlerId,
       const std::string &eventName,
       const uint64_t emitterReactTag,
-      const std::shared_ptr<worklets::SerializableWorklet> &handlerFunction)
+      const std::shared_ptr<worklets::Serializable> &handlerFunction)
       : handlerId_(handlerId),
         emitterReactTag_(emitterReactTag),
         eventName_(eventName),

package/Common/cpp/reanimated/Events/UIEventHandlerRegistry.cpp

@@ -77,8 +77,9 @@ void UIEventHandlerRegistry::processEvent(
     }
   }
 
-  jsi::Runtime &rt = uiWorkletRuntime->getJSIRuntime();
-  eventPayload.asObject(rt).setProperty(rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
+  jsi::Runtime &uiRuntime = getJSIRuntimeFromWorkletRuntime(uiWorkletRuntime);
+  eventPayload.asObject(uiRuntime).setProperty(
+      uiRuntime, "eventName", jsi::String::createFromUtf8(uiRuntime, eventName));
   for (const auto &handler : handlersForEvent) {
     handler->process(uiWorkletRuntime, eventTimestamp, eventPayload);
   }

package/Common/cpp/reanimated/Events/UIEventHandlerRegistry.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <jsi/jsi.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <reanimated/Compat/WorkletsApi.h>
 
 #include <map>
 #include <memory>

package/Common/cpp/reanimated/Fabric/ReanimatedCommitHook.cpp

@@ -53,12 +53,8 @@ void ReanimatedCommitHook::maybeInitializeLayoutAnimations(SurfaceId surfaceId)
 RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
     ShadowTree const &,
     RootShadowNode::Shared const &,
-    RootShadowNode::Unshared const &newRootShadowNode
-#if REACT_NATIVE_MINOR_VERSION >= 80
-    ,
-    const ShadowTreeCommitOptions &commitOptions
-#endif
-    ) noexcept {
+    RootShadowNode::Unshared const &newRootShadowNode,
+    const ShadowTreeCommitOptions &commitOptions) noexcept {
   ReanimatedSystraceSection s("ReanimatedCommitHook::shadowTreeWillCommit");
 
   maybeInitializeLayoutAnimations(newRootShadowNode->getSurfaceId());
@@ -73,7 +69,6 @@ RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
     return newRootShadowNode;
   }
 
-#if REACT_NATIVE_MINOR_VERSION >= 80
   if constexpr (StaticFeatureFlags::getFlag("USE_COMMIT_HOOK_ONLY_FOR_REACT_COMMITS")) {
     // State updates are based on the currently committed ShadowTree,
     // which means that all animation changes are already included.
@@ -82,7 +77,6 @@ RootShadowNode::Unshared ReanimatedCommitHook::shadowTreeWillCommit(
       return newRootShadowNode;
     }
   }
-#endif
 
   // ShadowTree not commited by Reanimated, apply updates from the updates
   // registry manager

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

@@ -29,12 +29,8 @@ class ReanimatedCommitHook : public UIManagerCommitHook, public std::enable_shar
   RootShadowNode::Unshared shadowTreeWillCommit(
       ShadowTree const &shadowTree,
       RootShadowNode::Shared const &oldRootShadowNode,
-      RootShadowNode::Unshared const &newRootShadowNode
-#if REACT_NATIVE_MINOR_VERSION >= 80
-      ,
-      const ShadowTreeCommitOptions &commitOptions
-#endif
-      ) noexcept override;
+      RootShadowNode::Unshared const &newRootShadowNode,
+      const ShadowTreeCommitOptions &commitOptions) noexcept override;
 
  private:
   std::shared_ptr<UIManager> uiManager_;

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

@@ -20,12 +20,7 @@ ReanimatedMountHook::~ReanimatedMountHook() noexcept {
 
 void ReanimatedMountHook::shadowTreeDidMount(
     const RootShadowNode::Shared &rootShadowNode,
-#if REACT_NATIVE_MINOR_VERSION >= 81
-    HighResTimeStamp
-#else
-    double
-#endif // REACT_NATIVE_MINOR_VERSION >= 81
-    ) noexcept {
+    HighResTimeStamp mountTime) noexcept {
   ReanimatedSystraceSection s("ReanimatedMountHook::shadowTreeDidMount");
 
   auto reaShadowNode = std::reinterpret_pointer_cast<ReanimatedCommitShadowNode>(

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

@@ -19,14 +19,7 @@ class ReanimatedMountHook : public UIManagerMountHook {
       const std::function<void()> &requestFlush);
   ~ReanimatedMountHook() noexcept override;
 
-  void shadowTreeDidMount(
-      RootShadowNode::Shared const &rootShadowNode,
-#if REACT_NATIVE_MINOR_VERSION >= 81
-      HighResTimeStamp mountTime
-#else
-      double mountTime
-#endif // REACT_NATIVE_MINOR_VERSION >= 81
-      ) noexcept override;
+  void shadowTreeDidMount(RootShadowNode::Shared const &rootShadowNode, HighResTimeStamp mountTime) noexcept override;
 
  private:
   const std::shared_ptr<UIManager> uiManager_;

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

@@ -6,17 +6,16 @@
 
 namespace reanimated {
 
-#if REACT_NATIVE_MINOR_VERSION >= 81
 static inline std::shared_ptr<const ShadowNode> shadowNodeFromValue(
     jsi::Runtime &rt,
     const jsi::Value &shadowNodeWrapper) {
   return Bridging<std::shared_ptr<const ShadowNode>>::fromJs(rt, shadowNodeWrapper);
 }
-#endif
 
 void AnimatedPropsRegistry::update(jsi::Runtime &rt, const jsi::Value &operations, const double timestamp) {
   auto operationsArray = operations.asObject(rt).asArray(rt);
 
+  std::lock_guard<std::mutex> lock{mutex_};
   for (size_t i = 0, length = operationsArray.size(rt); i < length; ++i) {
     auto item = operationsArray.getValueAtIndex(rt, i).asObject(rt);
     auto shadowNodeWrapper = item.getProperty(rt, "shadowNodeWrapper");
@@ -31,12 +30,13 @@ void AnimatedPropsRegistry::update(jsi::Runtime &rt, const jsi::Value &operation
   }
 }
 
-void AnimatedPropsRegistry::remove(const Tag tag) {
-  updatesRegistry_.erase(tag);
-  timestampMap_.erase(tag);
-}
+jsi::Value AnimatedPropsRegistry::getUpdatesOlderThanTimestamp(
+    jsi::Runtime &rt,
+    const double timestamp,
+    const double cleanupTimestamp) {
+  std::lock_guard<std::mutex> lock{mutex_};
+  removeUpdatesOlderThanTimestamp(cleanupTimestamp);
 
-jsi::Value AnimatedPropsRegistry::getUpdatesOlderThanTimestamp(jsi::Runtime &rt, const double timestamp) {
   std::vector<std::pair<Tag, std::reference_wrapper<const folly::dynamic>>> updates;
 
   for (const auto &[viewTag, pair] : updatesRegistry_) {
@@ -71,4 +71,9 @@ void AnimatedPropsRegistry::removeUpdatesOlderThanTimestamp(const double timesta
   }
 }
 
+void AnimatedPropsRegistry::removeTag(const Tag tag) {
+  updatesRegistry_.erase(tag);
+  timestampMap_.erase(tag);
+}
+
 } // namespace reanimated

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

@@ -14,12 +14,15 @@ namespace reanimated {
 class AnimatedPropsRegistry : public UpdatesRegistry {
  public:
   void update(jsi::Runtime &rt, const jsi::Value &operations, double timestamp);
-  void remove(Tag tag) override;
-  jsi::Value getUpdatesOlderThanTimestamp(jsi::Runtime &rt, double timestamp);
-  void removeUpdatesOlderThanTimestamp(double timestamp);
+
+  /// Also removes updates older than `cleanupTimestamp` from the registry.
+  jsi::Value getUpdatesOlderThanTimestamp(jsi::Runtime &rt, double timestamp, double cleanupTimestamp);
 
  private:
   std::unordered_map<Tag, double> timestampMap_; // viewTag -> timestamp, protected by `mutex_`
+
+  void removeUpdatesOlderThanTimestamp(double timestamp);
+  void removeTag(Tag tag) override;
 };
 
 } // namespace reanimated

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

@@ -8,11 +8,8 @@
 
 namespace reanimated {
 
-std::lock_guard<std::mutex> UpdatesRegistry::lock() const {
-  return std::lock_guard<std::mutex>{mutex_};
-}
-
 bool UpdatesRegistry::isEmpty() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return updatesRegistry_.empty();
 }
 
@@ -26,7 +23,7 @@ folly::dynamic UpdatesRegistry::get(const Tag tag) const {
   return it->second.second;
 }
 
-void UpdatesRegistry::flushUpdates(UpdatesBatch &updatesBatch) {
+void UpdatesRegistry::flush(UpdatesBatch &updatesBatch) {
   auto copiedUpdatesBatch = std::move(updatesBatch_);
   updatesBatch_.clear();
 
@@ -39,7 +36,7 @@ void UpdatesRegistry::flushUpdates(UpdatesBatch &updatesBatch) {
 }
 
 UpdatesBatch UpdatesRegistry::getPendingUpdates() {
-  auto lock = std::lock_guard<std::mutex>{mutex_};
+  std::lock_guard<std::mutex> lock{mutex_};
   flushUpdatesToRegistry(updatesBatch_);
 
   UpdatesBatch updatesBatch;
@@ -116,6 +113,7 @@ void UpdatesRegistry::flushUpdatesToRegistry(const UpdatesBatch &updatesBatch) {
 #ifdef ANDROID
 
 bool UpdatesRegistry::hasPropsToRevert() const {
+  std::lock_guard<std::mutex> lock{mutex_};
   return !propsToRevertMap_.empty();
 }
 

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

@@ -1,11 +1,11 @@
 #pragma once
 
-#include <reanimated/Fabric/ShadowTreeCloner.h>
-
+#include <jsi/jsi.h>
 #include <react/renderer/core/ShadowNode.h>
+#include <reanimated/Fabric/ShadowTreeCloner.h>
 
-#include <jsi/jsi.h>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
@@ -33,18 +33,23 @@ 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) {
+    std::lock_guard<std::mutex> lock{mutex_};
+    removeTag(tag);
+  }
 
 #ifdef ANDROID
   bool hasPropsToRevert() const;
   void collectPropsToRevert(PropsToRevertMap &propsToRevertMap);
 #endif
 
-  void flushUpdates(UpdatesBatch &updatesBatch);
+  void flushUpdates(UpdatesBatch &updatesBatch) {
+    std::lock_guard<std::mutex> lock{mutex_};
+    flush(updatesBatch);
+  }
+
   void collectProps(PropsMap &propsMap);
   UpdatesBatch getPendingUpdates();
 
@@ -52,9 +57,22 @@ class UpdatesRegistry {
   mutable std::mutex mutex_;
   RegistryMap updatesRegistry_;
 
+  /// Assumes the caller already locked the registry.
+  void flush(UpdatesBatch &updatesBatch);
+
+  /// Assumes the caller already locked the registry.
+  virtual void removeTag(Tag tag) = 0;
+
+  /// Assumes the caller already locked the registry.
   void addUpdatesToBatch(const std::shared_ptr<const ShadowNode> &shadowNode, const folly::dynamic &props);
+
+  /// Assumes the caller already locked the registry.
   folly::dynamic getUpdatesFromRegistry(const Tag tag) const;
+
+  /// Assumes the caller already locked the registry.
   void setInUpdatesRegistry(const std::shared_ptr<const ShadowNode> &shadowNode, const folly::dynamic &props);
+
+  /// Assumes the caller already locked the registry.
   void removeFromUpdatesRegistry(Tag tag);
 
  private:

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

@@ -2,10 +2,9 @@
 
 #include <react/renderer/graphics/Transform.h>
 #include <react/renderer/mounting/ShadowView.h>
+#include <reanimated/Compat/WorkletsApi.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationType.h>
 
-#include <worklets/SharedItems/Serializable.h>
-
 #include <jsi/jsi.h>
 #include <stdio.h>
 #include <functional>

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

@@ -4,9 +4,9 @@
 #include <react/renderer/componentregistry/ComponentDescriptorFactory.h>
 #include <react/renderer/mounting/MountingOverrideDelegate.h>
 #include <react/renderer/uimanager/UIManager.h>
+#include <reanimated/Compat/WorkletsApi.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsManager.h>
 #include <reanimated/Tools/PlatformDepMethodsHolder.h>
-#include <worklets/Tools/UIScheduler.h>
 
 #include <memory>
 #include <optional>