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

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()) {
@@ -495,17 +493,13 @@ void ReanimatedModuleProxy::applyCSSAnimations(
     }
   }
 
-  {
-    auto lock = cssAnimationsRegistry_->lock();
-    cssAnimationsRegistry_->apply(
-        rt, shadowNode, updates.animationNames, newAnimations, updates.settingsUpdates, timestamp);
-  }
+  cssAnimationsRegistry_->apply(
+      rt, shadowNode, updates.animationNames, newAnimations, updates.settingsUpdates, timestamp);
 
   maybeRunCSSLoop();
 }
 
 void ReanimatedModuleProxy::unregisterCSSAnimations(const jsi::Value &viewTag) {
-  auto lock = cssAnimationsRegistry_->lock();
   cssAnimationsRegistry_->remove(viewTag.asNumber());
 }
 
@@ -516,16 +510,12 @@ void ReanimatedModuleProxy::runCSSTransition(
   auto shadowNode = shadowNodeFromValue(rt, shadowNodeWrapper);
   const auto config = parseCSSTransitionConfig(rt, transitionConfig);
 
-  {
-    auto lock = cssTransitionsRegistry_->lock();
-    cssTransitionsRegistry_->run(rt, shadowNode, config);
-  }
+  cssTransitionsRegistry_->run(rt, shadowNode, config);
 
   maybeRunCSSLoop();
 }
 
 void ReanimatedModuleProxy::unregisterCSSTransition(jsi::Runtime &rt, const jsi::Value &viewTag) {
-  auto lock = cssTransitionsRegistry_->lock();
   cssTransitionsRegistry_->remove(viewTag.asNumber());
 }
 
@@ -537,15 +527,12 @@ jsi::Value ReanimatedModuleProxy::getSettledUpdates(jsi::Runtime &rt) {
   // TODO(future): use unified timestamp
   const auto currentTimestamp = getAnimationTimestamp_();
 
-  const auto lock = animatedPropsRegistry_->lock();
-
   // TODO: fix bug when threshold difference is smaller than 1 second
   // TODO(future): flush updates from CSS animations and CSS transitions registries
-  animatedPropsRegistry_->removeUpdatesOlderThanTimestamp(currentTimestamp - 2000); // 2 seconds
-
   // TODO(future): find a better way to obtain timestamp for removing updates
   // TODO(future): move removing old updates to separate method
-  return animatedPropsRegistry_->getUpdatesOlderThanTimestamp(rt, currentTimestamp - 1000); // 1 second
+  return animatedPropsRegistry_->getUpdatesOlderThanTimestamp(
+      rt, currentTimestamp - 1000 /* 1 second */, currentTimestamp - 2000 /* 2 seconds */);
 }
 
 bool ReanimatedModuleProxy::handleEvent(
@@ -583,7 +570,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 +607,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 +644,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 +674,7 @@ void ReanimatedModuleProxy::performOperations() {
         surfaceId, [](const ShadowTree &shadowTree) { shadowTree.notifyDelegatesOfUpdates(); });
   }
 
-  jsi::Runtime &uiRuntime = uiRuntime_->getJSIRuntime();
+  jsi::Runtime &uiRuntime = getJSIRuntimeFromWorkletRuntime(uiRuntime_);
 
   UpdatesBatch updatesBatch;
   {
@@ -696,24 +683,17 @@ void ReanimatedModuleProxy::performOperations() {
     auto lock = updatesRegistryManager_->lock();
 
     if (shouldUpdateCssAnimations_) {
-      currentCssTimestamp_ = getAnimationTimestamp_();
-      auto lock = cssTransitionsRegistry_->lock();
       // Update CSS transitions and flush updates
-      cssTransitionsRegistry_->update(currentCssTimestamp_);
-      cssTransitionsRegistry_->flushUpdates(updatesBatch);
+      currentCssTimestamp_ = getAnimationTimestamp_();
+      cssTransitionsRegistry_->updateAndFlush(currentCssTimestamp_, updatesBatch);
     }
 
-    {
-      auto lock = animatedPropsRegistry_->lock();
-      // Flush all animated props updates
-      animatedPropsRegistry_->flushUpdates(updatesBatch);
-    }
+    // Flush all animated props updates
+    animatedPropsRegistry_->flushUpdates(updatesBatch);
 
     if (shouldUpdateCssAnimations_) {
-      auto lock = cssAnimationsRegistry_->lock();
       // Update CSS animations and flush updates
-      cssAnimationsRegistry_->update(currentCssTimestamp_);
-      cssAnimationsRegistry_->flushUpdates(updatesBatch);
+      cssAnimationsRegistry_->updateAndFlush(currentCssTimestamp_, updatesBatch);
     }
 
     shouldUpdateCssAnimations_ = false;
@@ -1198,7 +1178,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 +1239,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 +1309,7 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxy() {
           layoutAnimationsManager_,
           componentDescriptorRegistry,
           scheduler->getContextContainer(),
-          uiRuntime_->getJSIRuntime(),
+          getJSIRuntimeFromWorkletRuntime(uiRuntime_),
           uiScheduler_
 #ifdef ANDROID
           ,
@@ -1348,7 +1327,7 @@ void ReanimatedModuleProxy::initializeLayoutAnimationsProxy() {
           layoutAnimationsManager_,
           componentDescriptorRegistry,
           scheduler->getContextContainer(),
-          uiRuntime_->getJSIRuntime(),
+          getJSIRuntimeFromWorkletRuntime(uiRuntime_),
           uiScheduler_
 #ifdef ANDROID
           ,
@@ -1395,15 +1374,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/README.md

@@ -6,7 +6,7 @@
 
 ### Nightly CI state
 
-[![NPM Reanimated publish nightly](https://github.com/software-mansion/react-native-reanimated/actions/workflows/npm-reanimated-publish-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/npm-reanimated-publish-nightly.yml)
+[![NPM Reanimated publish nightly](https://github.com/software-mansion/react-native-reanimated/actions/workflows/npm-reanimated-publish.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/npm-reanimated-publish.yml)
 [![Lint clang-tidy [Nightly]](https://github.com/software-mansion/react-native-reanimated/actions/workflows/lint-clang-tidy-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/lint-clang-tidy-nightly.yml)
 [![Reanimated compatibility check](https://github.com/software-mansion/react-native-reanimated/actions/workflows/reanimated-compatibility-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/reanimated-compatibility-check-nightly.yml)
 [![Use frameworks Reanimated build check [Nightly]](https://github.com/software-mansion/react-native-reanimated/actions/workflows/use-frameworks-reanimated-build-check-nightly.yml/badge.svg)](https://github.com/software-mansion/react-native-reanimated/actions/workflows/use-frameworks-reanimated-build-check-nightly.yml)

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>