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

package/Common/cpp/reanimated/LayoutAnimations/SharedTransitions.cpp

@@ -1,5 +1,6 @@
 #include <react/renderer/components/scrollview/ScrollViewState.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.h>
+#include <reanimated/LayoutAnimations/LayoutAnimationsUtils.h>
 #include <reanimated/Tools/ReanimatedSystraceSection.h>
 #ifndef ANDROID
 #if __has_include(<react/renderer/components/rnscreens/Props.h>)
@@ -62,9 +63,11 @@ void LayoutAnimationsProxy_Experimental::findSharedElementsOnScreen(
     auto newTransform = parseParentTransforms(node, absolutePositions);
     const auto &parent = node->parent.lock();
     react_native_assert(parent && "Parent node is nullptr");
-    transform[index] = std::move(newTransform);
-    snapshot[index] = copy;
-    parentTag[index] = parent->current.tag;
+
+    int indexNum = static_cast<int>(index);
+    transform[indexNum] = std::move(newTransform);
+    snapshot[indexNum] = copy;
+    parentTag[indexNum] = parent->current.tag;
 
     if (parentTag[BEFORE] && parentTag[AFTER]) {
       transitions_.emplace_back(sharedTag, transition);
@@ -88,11 +91,11 @@ void LayoutAnimationsProxy_Experimental::handleProgressTransition(
   }
   transitionUpdated_ = false;
 
-  if (!mutations.empty() || !transitionState_) {
+  if (!mutations.empty() || !static_cast<bool>(transitionState_)) {
     return;
   }
 
-  if (transitionState_ == START) {
+  if (transitionState_ == TransitionState::START) {
     auto root = lightNodes_[surfaceId];
     auto beforeTopScreen = topScreen[surfaceId];
     auto afterTopScreen = lightNodes_[transitionTag_];
@@ -119,7 +122,7 @@ void LayoutAnimationsProxy_Experimental::handleProgressTransition(
         startProgressTransition(containerTag, before, after, surfaceId);
       }
     }
-  } else if (transitionState_ == ACTIVE) {
+  } else if (transitionState_ == TransitionState::ACTIVE) {
     for (auto tag : activeTransitions_) {
       auto layoutAnimation = layoutAnimations_[tag];
       auto &updateMap = surfaceManager.getUpdateMap(layoutAnimation.finalView.surfaceId);
@@ -153,23 +156,23 @@ void LayoutAnimationsProxy_Experimental::handleProgressTransition(
     }
   }
 
-  if (transitionState_ == START) {
-    transitionState_ = ACTIVE;
-  } else if (transitionState_ == END || transitionState_ == CANCELLED) {
+  if (transitionState_ == TransitionState::START) {
+    transitionState_ = TransitionState::ACTIVE;
+  } else if (transitionState_ == TransitionState::END || transitionState_ == TransitionState::CANCELLED) {
     for (auto tag : activeTransitions_) {
       sharedContainersToRemove_.push_back(tag);
       tagsToRestore_.push_back(restoreMap_[tag][AFTER]);
-      if (transitionState_ == CANCELLED) {
+      if (transitionState_ == TransitionState::CANCELLED) {
         tagsToRestore_.push_back(restoreMap_[tag][BEFORE]);
       }
     }
-    if (transitionState_ == END) {
+    if (transitionState_ == TransitionState::END) {
       topScreen[surfaceId] = lightNodes_[transitionTag_];
       synchronized_ = false;
     }
     sharedTransitionManager_->containerTags_.clear();
     activeTransitions_.clear();
-    transitionState_ = NONE;
+    transitionState_ = TransitionState::NONE;
   }
 }
 
@@ -278,8 +281,9 @@ void LayoutAnimationsProxy_Experimental::hideTransitioningViews(
     ShadowViewMutationList &filteredMutations,
     const PropsParserContext &propsParserContext) const {
   for (auto &[sharedTag, transition] : transitions_) {
-    const auto &shadowView = transition.snapshot[index];
-    const auto &parentTag = transition.parentTag[index];
+    int indexNum = static_cast<int>(index);
+    const auto &shadowView = transition.snapshot[indexNum];
+    const auto &parentTag = transition.parentTag[indexNum];
     auto m = ShadowViewMutation::UpdateMutation(
         shadowView, cloneViewWithoutOpacity(shadowView, propsParserContext), parentTag);
     filteredMutations.push_back(m);
@@ -303,11 +307,11 @@ std::optional<SurfaceId> LayoutAnimationsProxy_Experimental::onTransitionProgres
   // transitions (maybe that's ok?)
   if (!isClosing && !isGoingForward && !isAndroid) {
     transitionProgress_ = progress;
-    if (transitionState_ == NONE && progress < 1) {
-      transitionState_ = START;
+    if (transitionState_ == TransitionState::NONE && progress < 1) {
+      transitionState_ = TransitionState::START;
       transitionTag_ = tag;
-    } else if (transitionState_ == ACTIVE && progress == 1) {
-      transitionState_ = END;
+    } else if (transitionState_ == TransitionState::ACTIVE && progress == 1) {
+      transitionState_ = TransitionState::END;
     }
     const auto &node = lightNodes_[tag];
     react_native_assert(node && "LightNode is nullptr");
@@ -320,8 +324,8 @@ std::optional<SurfaceId> LayoutAnimationsProxy_Experimental::onTransitionProgres
 
 std::optional<SurfaceId> LayoutAnimationsProxy_Experimental::onGestureCancel() {
   auto lock = std::unique_lock<std::recursive_mutex>(mutex);
-  if (transitionState_) {
-    transitionState_ = CANCELLED;
+  if (static_cast<bool>(transitionState_)) {
+    transitionState_ = TransitionState::CANCELLED;
     transitionUpdated_ = true;
     react_native_assert(transitioningSurfaceId_ != -1 && "Cancelling non-observed transition");
 

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

@@ -1,5 +1,6 @@
 #include <react/renderer/scheduler/Scheduler.h>
 #include <react/renderer/uimanager/UIManagerBinding.h>
+#include <reanimated/Compat/WorkletsApi.h>
 #include <reanimated/Events/UIEventHandler.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxy_Experimental.h>
 #include <reanimated/LayoutAnimations/LayoutAnimationsProxy_Legacy.h>
@@ -8,7 +9,6 @@
 #include <reanimated/RuntimeDecorators/UIRuntimeDecorator.h>
 #include <reanimated/Tools/FeatureFlags.h>
 #include <reanimated/Tools/ReanimatedSystraceSection.h>
-#include <worklets/SharedItems/Serializable.h>
 
 #ifdef __ANDROID__
 #include <fbjni/fbjni.h>
@@ -26,13 +26,11 @@ namespace reanimated {
 
 using namespace worklets;
 
-#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
 
 namespace {
 
@@ -69,7 +67,7 @@ std::pair<UpdatesBatch, UpdatesBatch> partitionUpdates(
         const auto keyStr = key.asString();
         const bool isColorProp = keyStr == "color" || keyStr.find("Color") != std::string::npos;
         const bool isSynchronous =
-            synchronousPropNames.contains(keyStr) && (!shouldRequireIntegerColors || !isColorProp || value.isInt());
+            synchronousPropNames.contains(keyStr) && (!shouldRequireIntegerColors || !isColorProp || value.isNumber());
         if (isSynchronous) {
           synchronousProps[keyStr] = value;
         } else {
@@ -91,7 +89,7 @@ std::pair<UpdatesBatch, UpdatesBatch> partitionUpdates(
         const auto keyStr = key.asString();
         const bool isColorProp = keyStr == "color" || keyStr.find("Color") != std::string::npos;
         const bool isSynchronous =
-            synchronousPropNames.contains(keyStr) && (!shouldRequireIntegerColors || !isColorProp || value.isInt());
+            synchronousPropNames.contains(keyStr) && (!shouldRequireIntegerColors || !isColorProp || value.isNumber());
         if (!isSynchronous) {
           hasOnlySynchronousProps = false;
           break;
@@ -249,7 +247,7 @@ void ReanimatedModuleProxy::init(const PlatformDepMethodsHolder &platformDepMeth
     return strongThis->obtainProp(rt, shadowNodeWrapper, propName);
   };
 
-  jsi::Runtime &uiRuntime = uiRuntime_->getJSIRuntime();
+  jsi::Runtime &uiRuntime = getJSIRuntimeFromWorkletRuntime(uiRuntime_);
   UIRuntimeDecorator::decorate(
       uiRuntime,
       obtainProp,
@@ -278,11 +276,11 @@ jsi::Value ReanimatedModuleProxy::registerEventHandler(
 
   uint64_t newRegistrationId = NEXT_EVENT_HANDLER_ID++;
   auto eventNameStr = eventName.asString(rt).utf8(rt);
-  auto handlerSerializable = extractSerializableOrThrow<SerializableWorklet>(
-      rt, worklet, "[Reanimated] Event handler must be a serializable worklet.");
+  auto handlerSerializable = extractSerializable(
+      rt, worklet, "[Reanimated] Event handler must be a serializable worklet.", Serializable::ValueType::WorkletType);
   int emitterReactTagInt = emitterReactTag.asNumber();
 
-  uiScheduler_->scheduleOnUI([=, weakThis = weak_from_this()]() {
+  scheduleOnUI(uiScheduler_, [=, weakThis = weak_from_this()]() {
     auto strongThis = weakThis.lock();
     if (!strongThis) {
       return;
@@ -297,7 +295,7 @@ jsi::Value ReanimatedModuleProxy::registerEventHandler(
 
 void ReanimatedModuleProxy::unregisterEventHandler(jsi::Runtime &, const jsi::Value &registrationId) {
   uint64_t id = registrationId.asNumber();
-  uiScheduler_->scheduleOnUI([=, weakThis = weak_from_this()]() {
+  scheduleOnUI(uiScheduler_, [=, weakThis = weak_from_this()]() {
     auto strongThis = weakThis.lock();
     if (!strongThis) {
       return;
@@ -323,12 +321,12 @@ jsi::Value ReanimatedModuleProxy::getViewProp(
   const auto propNameStr = propName.asString(rnRuntime).utf8(rnRuntime);
   const auto funPtr = std::make_shared<jsi::Function>(callback.getObject(rnRuntime).asFunction(rnRuntime));
   const auto shadowNode = shadowNodeFromValue(rnRuntime, shadowNodeWrapper);
-  uiScheduler_->scheduleOnUI([=, weakThis = weak_from_this()]() {
+  scheduleOnUI(uiScheduler_, [=, weakThis = weak_from_this()]() {
     auto strongThis = weakThis.lock();
     if (!strongThis) {
       return;
     }
-    jsi::Runtime &uiRuntime = strongThis->uiRuntime_->getJSIRuntime();
+    jsi::Runtime &uiRuntime = getJSIRuntimeFromWorkletRuntime(strongThis->uiRuntime_);
     const auto resultStr = strongThis->obtainPropFromShadowNode(uiRuntime, propNameStr, shadowNode);
 
     strongThis->jsInvoker_->invokeAsync([=](jsi::Runtime &rnRuntime) {
@@ -364,8 +362,8 @@ jsi::Value ReanimatedModuleProxy::configureLayoutAnimationBatch(
     if (config.isUndefined()) {
       batchItem.config = nullptr;
     } else {
-      batchItem.config = extractSerializableOrThrow<SerializableObject>(
-          rt, config, "[Reanimated] Layout animation config must be an object.");
+      batchItem.config = extractSerializable(
+          rt, config, "[Reanimated] Layout animation config must be an object.", Serializable::ValueType::ObjectType);
     }
     auto sharedTag = item.getProperty(rt, "sharedTransitionTag");
     if (!sharedTag.isUndefined()) {
@@ -583,7 +581,7 @@ bool ReanimatedModuleProxy::handleRawEvent(const RawEvent &rawEvent, double curr
 
   if constexpr (StaticFeatureFlags::getFlag("ENABLE_SHARED_ELEMENT_TRANSITIONS")) {
     if (eventType == "onTransitionProgress") {
-      jsi::Runtime &uiRuntime = uiRuntime_->getJSIRuntime();
+      jsi::Runtime &uiRuntime = getJSIRuntimeFromWorkletRuntime(uiRuntime_);
       const auto &eventPayload = rawEvent.eventPayload;
       jsi::Object payload = eventPayload->asJSIValue(uiRuntime).asObject(uiRuntime);
       auto progress = payload.getProperty(uiRuntime, "progress").asNumber();
@@ -620,7 +618,7 @@ bool ReanimatedModuleProxy::handleRawEvent(const RawEvent &rawEvent, double curr
     return false;
   }
 
-  jsi::Runtime &uiRuntime = uiRuntime_->getJSIRuntime();
+  jsi::Runtime &uiRuntime = getJSIRuntimeFromWorkletRuntime(uiRuntime_);
   const auto &eventPayload = rawEvent.eventPayload;
   jsi::Value payload = eventPayload->asJSIValue(uiRuntime);
 
@@ -657,7 +655,7 @@ void ReanimatedModuleProxy::maybeRunCSSLoop() {
 
   cssLoopRunning_ = true;
 
-  uiScheduler_->scheduleOnUI([=, weakThis = weak_from_this()]() {
+  scheduleOnUI(uiScheduler_, [=, weakThis = weak_from_this()]() {
     auto strongThis = weakThis.lock();
     if (!strongThis) {
       return;
@@ -687,7 +685,7 @@ void ReanimatedModuleProxy::performOperations() {
         surfaceId, [](const ShadowTree &shadowTree) { shadowTree.notifyDelegatesOfUpdates(); });
   }
 
-  jsi::Runtime &uiRuntime = uiRuntime_->getJSIRuntime();
+  jsi::Runtime &uiRuntime = getJSIRuntimeFromWorkletRuntime(uiRuntime_);
 
   UpdatesBatch updatesBatch;
   {
@@ -1198,7 +1196,6 @@ void ReanimatedModuleProxy::commitUpdates(jsi::Runtime &rt, const UpdatesBatch &
     for (auto const &[shadowNode, props] : updatesBatch) {
       SurfaceId surfaceId = shadowNode->getSurfaceId();
       auto family = &shadowNode->getFamily();
-      react_native_assert(family->getSurfaceId() == surfaceId);
       propsMapBySurface[surfaceId][family].emplace_back(props);
     }
   }
@@ -1260,7 +1257,7 @@ void ReanimatedModuleProxy::dispatchCommand(
 
 jsi::String
 ReanimatedModuleProxy::obtainProp(jsi::Runtime &rt, const jsi::Value &shadowNodeWrapper, const jsi::Value &propName) {
-  jsi::Runtime &uiRuntime = uiRuntime_->getJSIRuntime();
+  jsi::Runtime &uiRuntime = getJSIRuntimeFromWorkletRuntime(uiRuntime_);
   const auto propNameStr = propName.asString(rt).utf8(rt);
   const auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
   const auto resultStr = obtainPropFromShadowNode(uiRuntime, propNameStr, shadowNode);
@@ -1330,7 +1327,7 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxy() {
           layoutAnimationsManager_,
           componentDescriptorRegistry,
           scheduler->getContextContainer(),
-          uiRuntime_->getJSIRuntime(),
+          getJSIRuntimeFromWorkletRuntime(uiRuntime_),
           uiScheduler_
 #ifdef ANDROID
           ,
@@ -1348,7 +1345,7 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxy() {
           layoutAnimationsManager_,
           componentDescriptorRegistry,
           scheduler->getContextContainer(),
-          uiRuntime_->getJSIRuntime(),
+          getJSIRuntimeFromWorkletRuntime(uiRuntime_),
           uiScheduler_
 #ifdef ANDROID
           ,
@@ -1395,15 +1392,18 @@ jsi::Value ReanimatedModuleProxy::subscribeForKeyboardEvents(
     const jsi::Value &handlerWorklet,
     const jsi::Value &isStatusBarTranslucent,
     const jsi::Value &isNavigationBarTranslucent) {
-  auto serializableHandler = extractSerializableOrThrow<SerializableWorklet>(
-      rt, handlerWorklet, "[Reanimated] Keyboard event handler must be a worklet.");
+  auto serializableHandler = extractSerializable(
+      rt,
+      handlerWorklet,
+      "[Reanimated] Keyboard event handler must be a worklet.",
+      Serializable::ValueType::WorkletType);
   return subscribeForKeyboardEventsFunction_(
       [=, weakThis = weak_from_this()](int keyboardState, int height) {
         auto strongThis = weakThis.lock();
         if (!strongThis) {
           return;
         }
-        strongThis->uiRuntime_->runSync(serializableHandler, jsi::Value(keyboardState), jsi::Value(height));
+        runSyncOnRuntime(strongThis->uiRuntime_, serializableHandler, jsi::Value(keyboardState), jsi::Value(height));
       },
       isStatusBarTranslucent.getBool(),
       isNavigationBarTranslucent.getBool());

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

@@ -11,6 +11,7 @@
 #include <reanimated/CSS/registries/CSSKeyframesRegistry.h>
 #include <reanimated/CSS/registries/CSSTransitionsRegistry.h>
 #include <reanimated/CSS/registries/StaticPropsRegistry.h>
+#include <reanimated/Compat/WorkletsApi.h>
 #include <reanimated/Events/UIEventHandlerRegistry.h>
 #include <reanimated/Fabric/ReanimatedCommitHook.h>
 #include <reanimated/Fabric/ReanimatedCommitShadowNode.h>
@@ -24,8 +25,6 @@
 #include <reanimated/NativeModules/ReanimatedModuleProxySpec.h>
 #include <reanimated/Tools/PlatformDepMethodsHolder.h>
 #include <reanimated/Tools/SingleInstanceChecker.h>
-#include <worklets/Tools/UIScheduler.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 #include <memory>
 #include <set>

package/Common/cpp/reanimated/RuntimeDecorators/UIRuntimeDecorator.cpp

@@ -7,31 +7,31 @@ namespace reanimated {
 
 void UIRuntimeDecorator::decorate(
     jsi::Runtime &uiRuntime,
-    ObtainPropFunction obtainPropFunction,
-    UpdatePropsFunction updateProps,
-    MeasureFunction measure,
-    DispatchCommandFunction dispatchCommand,
-    GetAnimationTimestampFunction getAnimationTimestamp,
-    SetGestureStateFunction setGestureState,
-    ProgressLayoutAnimationFunction progressLayoutAnimation,
-    EndLayoutAnimationFunction endLayoutAnimation,
-    MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue) {
-
-  jsi_utils::installJsiFunction(uiRuntime, "_updateProps", std::move(updateProps));
-  jsi_utils::installJsiFunction(uiRuntime, "_dispatchCommand", std::move(dispatchCommand));
-  jsi_utils::installJsiFunction(uiRuntime, "_measure", std::move(measure));
-  jsi_utils::installJsiFunction(uiRuntime, "_getAnimationTimestamp", std::move(getAnimationTimestamp));
-  jsi_utils::installJsiFunction(uiRuntime, "_notifyAboutProgress", std::move(progressLayoutAnimation));
-  jsi_utils::installJsiFunction(uiRuntime, "_notifyAboutEnd", std::move(endLayoutAnimation));
-  jsi_utils::installJsiFunction(uiRuntime, "_setGestureState", std::move(setGestureState));
-  jsi_utils::installJsiFunction(uiRuntime, "_obtainProp", std::move(obtainPropFunction));
-
-  subscribeForMicrotasksFinalization(uiRuntime, std::move(maybeFlushUIUpdatesQueue));
+    const ObtainPropFunction &obtainPropFunction,
+    const UpdatePropsFunction &updateProps,
+    const MeasureFunction &measure,
+    const DispatchCommandFunction &dispatchCommand,
+    const GetAnimationTimestampFunction &getAnimationTimestamp,
+    const SetGestureStateFunction &setGestureState,
+    const ProgressLayoutAnimationFunction &progressLayoutAnimation,
+    const EndLayoutAnimationFunction &endLayoutAnimation,
+    const MaybeFlushUIUpdatesQueueFunction &maybeFlushUIUpdatesQueue) {
+
+  jsi_utils::installJsiFunction(uiRuntime, "_updateProps", updateProps);
+  jsi_utils::installJsiFunction(uiRuntime, "_dispatchCommand", dispatchCommand);
+  jsi_utils::installJsiFunction(uiRuntime, "_measure", measure);
+  jsi_utils::installJsiFunction(uiRuntime, "_getAnimationTimestamp", getAnimationTimestamp);
+  jsi_utils::installJsiFunction(uiRuntime, "_notifyAboutProgress", progressLayoutAnimation);
+  jsi_utils::installJsiFunction(uiRuntime, "_notifyAboutEnd", endLayoutAnimation);
+  jsi_utils::installJsiFunction(uiRuntime, "_setGestureState", setGestureState);
+  jsi_utils::installJsiFunction(uiRuntime, "_obtainProp", obtainPropFunction);
+
+  subscribeForMicrotasksFinalization(uiRuntime, maybeFlushUIUpdatesQueue);
 }
 
 void UIRuntimeDecorator::subscribeForMicrotasksFinalization(
     jsi::Runtime &uiRuntime,
-    MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue) {
+    const MaybeFlushUIUpdatesQueueFunction &maybeFlushUIUpdatesQueue) {
   auto maybeMicrotaskQueueFinalizers = uiRuntime.global().getProperty(uiRuntime, "_microtaskQueueFinalizers");
 
   if (maybeMicrotaskQueueFinalizers.isUndefined()) {
@@ -50,7 +50,7 @@ void UIRuntimeDecorator::subscribeForMicrotasksFinalization(
               uiRuntime,
               jsi::PropNameID::forAscii(uiRuntime, "_maybeFlushUIUpdatesQueue"),
               0,
-              jsi_utils::createHostFunction(std::move(maybeFlushUIUpdatesQueue))));
+              jsi_utils::createHostFunction(maybeFlushUIUpdatesQueue)));
 }
 
 } // namespace reanimated

package/Common/cpp/reanimated/RuntimeDecorators/UIRuntimeDecorator.h

@@ -12,20 +12,20 @@ class UIRuntimeDecorator {
  public:
   static void decorate(
       jsi::Runtime &uiRuntime,
-      const ObtainPropFunction obtainPropFunction,
-      const UpdatePropsFunction updateProps,
-      const MeasureFunction measure,
-      const DispatchCommandFunction dispatchCommand,
-      const GetAnimationTimestampFunction getAnimationTimestamp,
-      const SetGestureStateFunction setGestureState,
-      const ProgressLayoutAnimationFunction progressLayoutAnimation,
-      const EndLayoutAnimationFunction endLayoutAnimation,
-      const MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue);
+      const ObtainPropFunction &obtainPropFunction,
+      const UpdatePropsFunction &updateProps,
+      const MeasureFunction &measure,
+      const DispatchCommandFunction &dispatchCommand,
+      const GetAnimationTimestampFunction &getAnimationTimestamp,
+      const SetGestureStateFunction &setGestureState,
+      const ProgressLayoutAnimationFunction &progressLayoutAnimation,
+      const EndLayoutAnimationFunction &endLayoutAnimation,
+      const MaybeFlushUIUpdatesQueueFunction &maybeFlushUIUpdatesQueue);
 
  private:
   static void subscribeForMicrotasksFinalization(
       jsi::Runtime &uiRuntime,
-      MaybeFlushUIUpdatesQueueFunction maybeFlushUIUpdatesQueue);
+      const MaybeFlushUIUpdatesQueueFunction &maybeFlushUIUpdatesQueue);
 };
 
 } // namespace reanimated

package/Common/cpp/reanimated/Tools/ReaJSIUtils.h

@@ -75,7 +75,7 @@ inline std::tuple<T, Rest...> convertArgs(jsi::Runtime &rt, const jsi::Value *ar
 // native C++ types needed to call `function`
 template <typename Ret, typename... Args>
 std::tuple<Args...>
-getArgsForFunction(std::function<Ret(Args...)>, jsi::Runtime &rt, const jsi::Value *args, const size_t count) {
+getArgsForFunction(const std::function<Ret(Args...)> &, jsi::Runtime &rt, const jsi::Value *args, const size_t count) {
   react_native_assert(sizeof...(Args) == count && "Argument list has different length than expected");
   return convertArgs<Args...>(rt, args);
 }
@@ -85,7 +85,7 @@ getArgsForFunction(std::function<Ret(Args...)>, jsi::Runtime &rt, const jsi::Val
 // passing `rt` as the first argument
 template <typename Ret, typename... Args>
 std::tuple<jsi::Runtime &, Args...> getArgsForFunction(
-    std::function<Ret(jsi::Runtime &, Args...)>,
+    const std::function<Ret(jsi::Runtime &, Args...)> &,
     jsi::Runtime &rt,
     const jsi::Value *args,
     const size_t count) {
@@ -117,7 +117,7 @@ inline jsi::Value apply(std::function<void(Args...)> function, std::tuple<Args..
 // returns a function with JSI calling convention
 // from a native function `function`
 template <typename Fun>
-jsi::HostFunctionType createHostFunction(Fun function) {
+jsi::HostFunctionType createHostFunction(const Fun &function) {
   return [function](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, const size_t count) {
     auto argz = getArgsForFunction(function, rt, args, count);
     return apply(function, std::move(argz));
@@ -127,7 +127,7 @@ jsi::HostFunctionType createHostFunction(Fun function) {
 // returns a function with JSI calling convention
 // from a native function `function` returning a string
 template <typename... Args>
-jsi::HostFunctionType createHostFunction(std::function<std::string(Args...)> function) {
+jsi::HostFunctionType createHostFunction(const std::function<std::string(Args...)> &function) {
   return [function](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, const size_t count) {
     auto argz = getArgsForFunction(function, rt, args, count);
     return apply(rt, function, std::move(argz));
@@ -151,7 +151,7 @@ struct takes_runtime<jsi::Runtime &, Rest...> {
 // and installs it as a global function named `name`
 // in the `rt` JS runtime
 template <typename Ret, typename... Args>
-void installJsiFunction(jsi::Runtime &rt, std::string_view name, std::function<Ret(Args...)> function) {
+void installJsiFunction(jsi::Runtime &rt, std::string_view name, const std::function<Ret(Args...)> &function) {
   auto clb = createHostFunction(function);
   auto argsCount = sizeof...(Args) - takes_runtime<Args...>::value;
   jsi::Value jsiFunction =

package/android/build.gradle

@@ -43,24 +43,6 @@ def resolveReactNativeDirectory() {
     throw new GradleException("[Reanimated] Unable to resolve react-native location in node_modules. You should set project extension property (in `app/build.gradle`) named `REACT_NATIVE_NODE_MODULES_DIR` with the path to react-native in node_modules.")
 }
 
-def resolveReactNativeWorkletsDirectory() {
-    def reactNativeWorkletsLocation = safeAppExtGet("REACT_NATIVE_WORKLETS_NODE_MODULES_DIR", null)
-    if (reactNativeWorkletsLocation != null) {
-        return file(reactNativeWorkletsLocation)
-    }
-
-    // Fallback to node resolver for custom directory structures like monorepos.
-    def reactNativeWorkletsPackage = file(providers.exec {
-        workingDir(rootDir)
-        commandLine("node", "--print", "require.resolve('react-native-worklets/package.json')")
-    }.standardOutput.asText.get().trim())
-    if (reactNativeWorkletsPackage.exists()) {
-        return reactNativeWorkletsPackage.parentFile
-    }
-
-    throw new GradleException("[Reanimated] Unable to resolve react-native-worklets location in node_modules. You should set project extension property (in `app/build.gradle`) named `REACT_NATIVE_WORKLETS_NODE_MODULES_DIR` with the path to react-native-worklets in node_modules.")
-}
-
 def getReactNativeVersion() {
     def reactNativeRootDir = resolveReactNativeDirectory()
     def reactProperties = new Properties()
@@ -112,7 +94,6 @@ if (isNewArchitectureEnabled() && project != rootProject) {
 
 def packageDir = project.projectDir.parentFile
 def reactNativeRootDir = resolveReactNativeDirectory()
-def reactNativeWorkletsRootDir = resolveReactNativeWorkletsDirectory()
 def REACT_NATIVE_MINOR_VERSION = getReactNativeMinorVersion()
 def REACT_NATIVE_VERSION = getReactNativeVersion()
 def REANIMATED_VERSION = getReanimatedVersion()
@@ -138,7 +119,6 @@ buildscript {
     }
     dependencies {
         classpath "com.android.tools.build:gradle:8.13.1"
-        classpath "de.undercouch:gradle-download-task:5.6.0"
         classpath "com.diffplug.spotless:spotless-plugin-gradle:8.1.0"
     }
 }
@@ -149,7 +129,6 @@ if (project == rootProject) {
 
 apply plugin: "com.android.library"
 apply plugin: "maven-publish"
-apply plugin: "de.undercouch.download"
 
 android {
     compileSdkVersion safeExtGet("compileSdkVersion", 36)

package/android/src/main/cpp/reanimated/android/NativeProxy.cpp

@@ -1,4 +1,5 @@
 #include <react/fabric/Binding.h>
+#include <reanimated/Compat/WorkletsApi.h>
 #include <reanimated/RuntimeDecorators/RNRuntimeDecorator.h>
 #include <reanimated/Tools/PlatformDepMethodsHolder.h>
 #include <reanimated/Tools/ReanimatedVersion.h>
@@ -7,7 +8,6 @@
 #include <reanimated/android/KeyboardWorkletWrapper.h>
 #include <reanimated/android/NativeProxy.h>
 #include <reanimated/android/SensorSetter.h>
-#include <worklets/Compat/Holders.h>
 
 #include <memory>
 #include <string>
@@ -71,16 +71,11 @@ jni::local_ref<NativeProxy::jhybriddata> NativeProxy::initHybrid(
   auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
   auto &rnRuntime = *reinterpret_cast<jsi::Runtime *>(jsContext); // NOLINT //(performance-no-int-to-ptr)
   const auto global = rnRuntime.global();
-
   const auto uiRuntime =
-      std::static_pointer_cast<WorkletRuntimeHolder>(
-          global.getProperty(rnRuntime, "__UI_WORKLET_RUNTIME_HOLDER").asObject(rnRuntime).getNativeState(rnRuntime))
-          ->runtime_;
+      getWorkletRuntimeFromHolder(rnRuntime, global.getPropertyAsObject(rnRuntime, "__UI_WORKLET_RUNTIME_HOLDER"));
 
   const auto uiScheduler =
-      std::static_pointer_cast<UISchedulerHolder>(
-          global.getProperty(rnRuntime, "__UI_SCHEDULER_HOLDER").asObject(rnRuntime).getNativeState(rnRuntime))
-          ->scheduler_;
+      getUISchedulerFromHolder(rnRuntime, global.getPropertyAsObject(rnRuntime, "__UI_SCHEDULER_HOLDER"));
 
   return makeCxxInstance(jThis, &rnRuntime, jsCallInvoker, fabricUIManager, uiRuntime, uiScheduler);
 }
@@ -120,7 +115,8 @@ void NativeProxy::injectCppVersion() {
 
 void NativeProxy::installJSIBindings() {
   jsi::Runtime &rnRuntime = *rnRuntime_;
-  RNRuntimeDecorator::decorate(rnRuntime, uiRuntime_->getJSIRuntime(), reanimatedModuleProxy_);
+  auto &uiRuntime = getJSIRuntimeFromWorkletRuntime(uiRuntime_);
+  RNRuntimeDecorator::decorate(rnRuntime, uiRuntime, reanimatedModuleProxy_);
 }
 
 bool NativeProxy::isAnyHandlerWaitingForEvent(const std::string &eventName, const int emitterReactTag) {
@@ -263,7 +259,7 @@ void NativeProxy::handleEvent(
     return;
   }
 
-  auto &uiRuntime = uiRuntime_->getJSIRuntime();
+  auto &uiRuntime = getJSIRuntimeFromWorkletRuntime(uiRuntime_);
   jsi::Value payload;
   try {
     payload = jsi::Value::createFromJsonUtf8(uiRuntime, reinterpret_cast<uint8_t *>(&eventJSON[0]), eventJSON.size());

package/android/src/main/cpp/reanimated/android/NativeProxy.h

@@ -6,9 +6,8 @@
 #include <react/fabric/JFabricUIManager.h>
 #include <react/jni/WritableNativeMap.h>
 #include <react/renderer/scheduler/Scheduler.h>
+#include <reanimated/Compat/WorkletsApi.h>
 #include <reanimated/NativeModules/ReanimatedModuleProxy.h>
-#include <worklets/Tools/UIScheduler.h>
-#include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 #include <memory>
 #include <string>