react-native-worklets 0.10.0 → 0.10.1

package/Common/cpp/worklets/NativeModules/JSIWorkletsModuleProxy.cpp

@@ -335,25 +335,22 @@ jsi::Object JSIWorkletsModuleProxy::toOptimizedObject(jsi::Runtime &rt) const {
         return makeSerializableArrayBuffer(rt, buffer);
       });
 
-  jsi_utils::addMethod<3>(
+  jsi_utils::addMethod<2>(
       rt,
       obj,
       "createSerializableNonWorkletFunction",
-      [jsScheduler = jsScheduler_, hostRuntimeId = hostRuntimeId_](
-          jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[3]) {
+      [jsScheduler = jsScheduler_, hostRuntimeId = hostRuntimeId_, rnRuntimeStatus = rnRuntimeStatus_](
+          jsi::Runtime &rt, const jsi::Value &, const jsi::Value(&args)[2]) {
         auto fun = at<0>(args).getObject(rt).getFunction(rt);
-        const auto name = at<2>(args).isUndefined() ? "" : at<2>(args).getString(rt).utf8(rt);
+        const auto name = at<1>(args).isUndefined() ? "" : at<1>(args).getString(rt).utf8(rt);
         if (fun.isHostFunction(rt)) {
           return makeSerializableHostFunction(
               rt, fun.getHostFunction(rt), name, fun.getProperty(rt, "length").getNumber());
+        } else if (hostRuntimeId == RuntimeData::rnRuntimeId) {
+          return makeRNRuntimeSerializableRemoteFunction(rt, name, fun, jsScheduler, rnRuntimeStatus);
+        } else {
+          return makeWorkletRuntimeSerializableRemoteFunction(rt, name, fun, hostRuntimeId);
         }
-        if (hostRuntimeId == RuntimeData::rnRuntimeId) {
-          const int remoteId = static_cast<int>(at<1>(args).getNumber());
-          auto ref = makeRNOriginSerializableRemoteFunction(rt, name, remoteId, jsScheduler);
-          ref.asObject(rt).setProperty(rt, "__keepAlive", true);
-          return ref;
-        }
-        return makeWorkletOriginSerializableRemoteFunction(rt, name, std::move(fun), hostRuntimeId);
       });
 
   jsi_utils::addMethod<2>(

package/Common/cpp/worklets/NativeModules/JSIWorkletsModuleProxy.h

@@ -4,6 +4,7 @@
 #include <worklets/SharedItems/MemoryManager.h>
 #include <worklets/SharedItems/Serializable.h>
 #include <worklets/SharedItems/UnpackerLoader.h>
+#include <worklets/Tools/RNRuntimeStatus.h>
 #include <worklets/Tools/ScriptBuffer.h>
 #include <worklets/WorkletRuntime/BundleModeConfig.h>
 #include <worklets/WorkletRuntime/RuntimeBindings.h>
@@ -31,6 +32,7 @@ class JSIWorkletsModuleProxy : public std::enable_shared_from_this<JSIWorkletsMo
       const std::shared_ptr<RuntimeBindings> &runtimeBindings,
       const BundleModeConfig &bundleModeConfig,
       const std::shared_ptr<UnpackerLoader> &unpackerLoader,
+      const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus,
       RuntimeData::RuntimeId hostRuntimeId)
       : isDevBundle_(isDevBundle),
         bundleModeConfig_(bundleModeConfig),
@@ -41,6 +43,7 @@ class JSIWorkletsModuleProxy : public std::enable_shared_from_this<JSIWorkletsMo
         uiWorkletRuntime_(uiWorkletRuntime),
         runtimeBindings_(runtimeBindings),
         unpackerLoader_(unpackerLoader),
+        rnRuntimeStatus_(rnRuntimeStatus),
         hostRuntimeId_(hostRuntimeId) {}
 
   static std::shared_ptr<JSIWorkletsModuleProxy> createForNewRuntime(
@@ -56,6 +59,7 @@ class JSIWorkletsModuleProxy : public std::enable_shared_from_this<JSIWorkletsMo
         sourceProxy->runtimeBindings_,
         sourceProxy->bundleModeConfig_,
         sourceProxy->unpackerLoader_,
+        sourceProxy->rnRuntimeStatus_,
         hostRuntimeId);
   }
 
@@ -115,6 +119,7 @@ class JSIWorkletsModuleProxy : public std::enable_shared_from_this<JSIWorkletsMo
   const std::weak_ptr<WorkletRuntime> uiWorkletRuntime_;
   const std::shared_ptr<RuntimeBindings> runtimeBindings_;
   const std::shared_ptr<UnpackerLoader> unpackerLoader_;
+  const std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
   const RuntimeData::RuntimeId hostRuntimeId_;
 };
 

package/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.cpp

@@ -45,7 +45,8 @@ WorkletsModuleProxy::WorkletsModuleProxy(
     const std::shared_ptr<UIScheduler> &uiScheduler,
     std::function<bool()> &&isJavaScriptThread,
     const std::shared_ptr<RuntimeBindings> &runtimeBindings,
-    const BundleModeConfig &bundleModeConfig)
+    const BundleModeConfig &bundleModeConfig,
+    const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus)
     : isDevBundle_(isDevBundleFromRNRuntime(rnRuntime)),
       jsScheduler_(std::make_shared<JSScheduler>(rnRuntime, jsCallInvoker, std::move(isJavaScriptThread))),
       uiScheduler_(uiScheduler),
@@ -55,6 +56,7 @@ WorkletsModuleProxy::WorkletsModuleProxy(
       memoryManager_(std::make_shared<MemoryManager>()),
       runtimeManager_(std::make_shared<RuntimeManager>()),
       unpackerLoader_(std::make_shared<UnpackerLoader>()),
+      rnRuntimeStatus_(rnRuntimeStatus),
       uiWorkletRuntime_(runtimeManager_->createUninitializedUIRuntime(std::make_shared<AsyncQueueUI>(uiScheduler_))),
       rnRuntimeProxy_(std::make_shared<JSIWorkletsModuleProxy>(
           isDevBundle_,
@@ -66,6 +68,7 @@ WorkletsModuleProxy::WorkletsModuleProxy(
           runtimeBindings_,
           bundleModeConfig_,
           unpackerLoader_,
+          rnRuntimeStatus_,
           RuntimeData::rnRuntimeId)) {
   RNRuntimeWorkletDecorator::decorate(rnRuntime, rnRuntimeProxy_->toOptimizedObject(rnRuntime), jsLogger_);
 }

package/Common/cpp/worklets/NativeModules/WorkletsModuleProxy.h

@@ -7,6 +7,7 @@
 #include <worklets/SharedItems/UnpackerLoader.h>
 #include <worklets/Tools/JSLogger.h>
 #include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/RNRuntimeStatus.h>
 #include <worklets/Tools/ScriptBuffer.h>
 #include <worklets/Tools/SingleInstanceChecker.h>
 #include <worklets/Tools/UIScheduler.h>
@@ -28,7 +29,8 @@ class WorkletsModuleProxy : public std::enable_shared_from_this<WorkletsModulePr
       const std::shared_ptr<UIScheduler> &uiScheduler,
       std::function<bool()> &&isJavaScriptQueue,
       const std::shared_ptr<RuntimeBindings> &runtimeBindings,
-      const BundleModeConfig &bundleModeConfig);
+      const BundleModeConfig &bundleModeConfig,
+      const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus);
 
   ~WorkletsModuleProxy();
 
@@ -62,6 +64,7 @@ class WorkletsModuleProxy : public std::enable_shared_from_this<WorkletsModulePr
   const std::shared_ptr<MemoryManager> memoryManager_;
   const std::shared_ptr<RuntimeManager> runtimeManager_;
   const std::shared_ptr<UnpackerLoader> unpackerLoader_;
+  const std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
   std::shared_ptr<WorkletRuntime> uiWorkletRuntime_;
   const std::shared_ptr<JSIWorkletsModuleProxy> rnRuntimeProxy_;
   std::shared_ptr<AnimationFrameBatchinator> animationFrameBatchinator_;

package/Common/cpp/worklets/Registries/WorkletRuntimeRegistry.cpp

@@ -5,6 +5,6 @@
 namespace worklets {
 
 std::set<jsi::Runtime *> WorkletRuntimeRegistry::registry_{};
-std::mutex WorkletRuntimeRegistry::mutex_{};
+std::shared_mutex WorkletRuntimeRegistry::mutex_{};
 
 } // namespace worklets

package/Common/cpp/worklets/Registries/WorkletRuntimeRegistry.h

@@ -3,8 +3,9 @@
 #include <jsi/jsi.h>
 #include <react/debug/react_native_assert.h>
 
-#include <mutex>
 #include <set>
+#include <shared_mutex>
+#include <utility>
 
 using namespace facebook;
 
@@ -13,27 +14,29 @@ namespace worklets {
 class WorkletRuntimeRegistry {
  private:
   static std::set<jsi::Runtime *> registry_;
-  static std::mutex mutex_; // Protects `registry_`.
+  static std::shared_mutex mutex_;
 
-  WorkletRuntimeRegistry() {} // private ctor
+  WorkletRuntimeRegistry() {}
 
   static void registerRuntime(jsi::Runtime &runtime) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::shared_mutex> lock(mutex_);
     registry_.insert(&runtime);
   }
 
   static void unregisterRuntime(jsi::Runtime &runtime) {
-    std::lock_guard<std::mutex> lock(mutex_);
+    std::lock_guard<std::shared_mutex> lock(mutex_);
     registry_.erase(&runtime);
   }
 
   friend class WorkletRuntimeCollector;
 
  public:
-  static bool isRuntimeAlive(jsi::Runtime *runtime) {
+  template <typename TFn>
+  static void runWhileLocked(jsi::Runtime *runtime, TFn &&fn) {
     react_native_assert(runtime != nullptr && "runtime is nullptr");
-    std::lock_guard<std::mutex> lock(mutex_);
-    return registry_.find(runtime) != registry_.end();
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    const bool isAlive = registry_.find(runtime) != registry_.end();
+    std::forward<TFn>(fn)(isAlive);
   }
 };
 

package/Common/cpp/worklets/SharedItems/Serializable.h

@@ -11,7 +11,6 @@
 #include <optional>
 #include <string>
 #include <utility>
-#include <variant>
 #include <vector>
 
 using namespace facebook;
@@ -31,9 +30,16 @@ inline void freeWithoutCallingDestructor(std::unique_ptr<jsi::Value> &value) {
 }
 
 inline void cleanupRuntimeAware(jsi::Runtime *rt, std::unique_ptr<jsi::Value> &value) {
-  if (rt != nullptr && !WorkletRuntimeRegistry::isRuntimeAlive(rt)) {
-    freeWithoutCallingDestructor(value);
+  if (value == nullptr || rt == nullptr) {
+    return;
   }
+  WorkletRuntimeRegistry::runWhileLocked(rt, [&value](bool isAlive) {
+    if (isAlive) {
+      value.reset();
+    } else {
+      freeWithoutCallingDestructor(value);
+    }
+  });
 }
 
 template <typename BaseClass>

package/Common/cpp/worklets/SharedItems/SerializableFactory.cpp

@@ -61,22 +61,31 @@ jsi::Value makeSerializableHostFunction(
   return SerializableJSRef::newNativeStateObject(rt, serializable);
 }
 
-jsi::Value makeRNOriginSerializableRemoteFunction(
+jsi::Value makeRNRuntimeSerializableRemoteFunction(
     jsi::Runtime &rnRuntime,
     const std::string &name,
-    const int remoteId,
-    const std::shared_ptr<JSScheduler> &jsScheduler) {
-  auto serializable = std::make_shared<SerializableRemoteFunction::RNOrigin>(rnRuntime, name, remoteId, jsScheduler);
+    const jsi::Function &function,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus) {
+  auto serializable = std::make_shared<SerializableRemoteFunction>(
+      rnRuntime,
+      name,
+      jsi::Value(rnRuntime, function).getObject(rnRuntime).getFunction(rnRuntime),
+      jsScheduler,
+      rnRuntimeStatus);
   return SerializableJSRef::newNativeStateObject(rnRuntime, serializable);
 }
 
-jsi::Value makeWorkletOriginSerializableRemoteFunction(
+jsi::Value makeWorkletRuntimeSerializableRemoteFunction(
     jsi::Runtime &workletRuntime,
     const std::string &name,
-    jsi::Function &&function,
+    const jsi::Function &function,
     RuntimeData::RuntimeId hostRuntimeId) {
-  auto serializable = std::make_shared<SerializableRemoteFunction::WorkletOrigin>(
-      workletRuntime, name, std::move(function), hostRuntimeId);
+  auto serializable = std::make_shared<SerializableRemoteFunction>(
+      workletRuntime,
+      name,
+      jsi::Value(workletRuntime, function).getObject(workletRuntime).getFunction(workletRuntime),
+      hostRuntimeId);
   return SerializableJSRef::newNativeStateObject(workletRuntime, serializable);
 }
 

package/Common/cpp/worklets/SharedItems/SerializableFactory.h

@@ -9,6 +9,8 @@
 
 namespace worklets {
 
+class RNRuntimeStatus;
+
 jsi::Value makeSerializableString(jsi::Runtime &rt, const jsi::String &string);
 
 jsi::Value makeSerializableNumber(jsi::Runtime &rt, double number);
@@ -63,16 +65,17 @@ jsi::Value makeSerializableHostFunction(
     const std::string &name,
     unsigned int paramCount);
 
-jsi::Value makeRNOriginSerializableRemoteFunction(
+jsi::Value makeRNRuntimeSerializableRemoteFunction(
     jsi::Runtime &rnRuntime,
     const std::string &name,
-    int remoteId,
-    const std::shared_ptr<JSScheduler> &jsScheduler);
+    const jsi::Function &function,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus);
 
-jsi::Value makeWorkletOriginSerializableRemoteFunction(
+jsi::Value makeWorkletRuntimeSerializableRemoteFunction(
     jsi::Runtime &workletRuntime,
     const std::string &name,
-    jsi::Function &&function,
+    const jsi::Function &function,
     RuntimeData::RuntimeId hostRuntimeId);
 
 jsi::Value makeSerializableWorklet(jsi::Runtime &rt, const jsi::Object &object, const bool &shouldRetainRemote);

package/Common/cpp/worklets/SharedItems/SerializableRemoteFunction.cpp

@@ -6,7 +6,6 @@
 #include <worklets/WorkletRuntime/WorkletRuntime.h>
 
 #include <memory>
-#include <utility>
 
 using namespace facebook;
 
@@ -20,94 +19,53 @@ jsi::Function getRemoteFunctionUnpacker(jsi::Runtime &rt) {
   return remoteFunctionUnpacker.asObject(rt).asFunction(rt);
 }
 
-jsi::Object getRemoteFunctionRegistry(jsi::Runtime &rt) {
-  auto registry = rt.global().getProperty(rt, "__remoteFunctionRegistry");
-  react_native_assert(registry.isObject() && "remoteFunctionRegistry not found");
-  return registry.getObject(rt);
-}
-
 } // namespace
 
-SerializableRemoteFunction::~SerializableRemoteFunction() = default;
-
-jsi::Value SerializableRemoteFunction::unpackSelf(jsi::Runtime &rt) {
-  const auto nameValue = name_.empty() ? jsi::Value::undefined() : jsi::String::createFromUtf8(rt, name_);
-  auto holderFunction = getRemoteFunctionUnpacker(rt).call(rt, nameValue).getObject(rt);
-  holderFunction.setNativeState(rt, std::make_shared<SerializableJSRef>(shared_from_this()));
-  return holderFunction;
-}
-
-jsi::Value SerializableRemoteFunction::RNOrigin::toJSValue(jsi::Runtime &rt) {
-  if (&rt == hostRuntime_) {
-    const auto registry = getRemoteFunctionRegistry(rt);
-    return registry.getPropertyAsFunction(rt, "get").callWithThis(rt, registry, jsi::Value(remoteId_));
+SerializableRemoteFunction::~SerializableRemoteFunction() {
+  if (isHostedOnRNRuntime()) {
+    rnRuntimeStatus_->runWhileLocked([this](bool isDead) {
+      if (isDead) {
+        freeWithoutCallingDestructor(function_);
+      } else {
+        function_.reset();
+      }
+    });
+  } else {
+    cleanupRuntimeAware(hostRuntime_, function_);
   }
-  std::shared_ptr<SerializableRemoteFunction> proxy;
-  {
-    std::lock_guard<std::mutex> lock(proxyMutex_);
-    proxy = proxy_.lock();
-    if (!proxy) {
-      auto self = std::static_pointer_cast<RNOrigin>(shared_from_this());
-      proxy = std::make_shared<RNOriginProxy>(self);
-      proxy_ = proxy;
-    }
-  }
-  return proxy->toJSValue(rt);
-}
-
-void SerializableRemoteFunction::RNOrigin::resolveOrRejectPromise(
-    const std::shared_ptr<Serializable> &resolveValue,
-    const std::shared_ptr<RuntimeManager> & /*runtimeManager*/) {
-  jsScheduler_->scheduleOnJS([resolver = shared_from_this(), resolveValue](jsi::Runtime &rt) {
-    resolver->toJSValue(rt).getObject(rt).getFunction(rt).call(rt, resolveValue->toJSValue(rt));
-  });
-}
-
-SerializableRemoteFunction::WorkletOrigin::~WorkletOrigin() {
-  cleanupRuntimeAware(hostRuntime_, function_);
 }
 
-jsi::Value SerializableRemoteFunction::WorkletOrigin::toJSValue(jsi::Runtime &rt) {
+jsi::Value SerializableRemoteFunction::toJSValue(jsi::Runtime &rt) {
   if (&rt == hostRuntime_) {
     return jsi::Value(rt, *function_);
+  } else {
+    const auto name = name_.empty() ? jsi::Value::undefined() : jsi::String::createFromUtf8(rt, name_);
+    auto holderFunction = getRemoteFunctionUnpacker(rt).call(rt, name).getObject(rt);
+    holderFunction.setNativeState(rt, std::make_shared<SerializableJSRef>(shared_from_this()));
+    return holderFunction;
   }
-  return unpackSelf(rt);
 }
 
-void SerializableRemoteFunction::WorkletOrigin::resolveOrRejectPromise(
+// TODO: generalize it and merge with other scheduling methods
+void SerializableRemoteFunction::resolveOrRejectPromise(
     const std::shared_ptr<Serializable> &resolveValue,
     const std::shared_ptr<RuntimeManager> &runtimeManager) {
-  const auto workletRuntime = runtimeManager->getRuntime(hostRuntimeId_);
-  // NOLINTNEXTLINE(readability/braces)
-  if (!workletRuntime) [[unlikely]] {
-    return;
-  }
-  workletRuntime->schedule([resolver = shared_from_this(), resolveValue](jsi::Runtime &rt) {
-    resolver->toJSValue(rt).getObject(rt).getFunction(rt).call(rt, resolveValue->toJSValue(rt));
-  });
-}
-
-SerializableRemoteFunction::RNOrigin::RNOriginProxy::RNOriginProxy(const std::shared_ptr<RNOrigin> &origin)
-    : SerializableRemoteFunction(nullptr, origin->getHostRuntimeId(), origin->getName()), origin_(origin) {}
-
-SerializableRemoteFunction::RNOrigin::RNOriginProxy::~RNOriginProxy() {
-  origin_->getJSScheduler()->scheduleOnJS([id = origin_->getRemoteId()](jsi::Runtime &rt) {
-    const auto registry = getRemoteFunctionRegistry(rt);
-    registry.getPropertyAsFunction(rt, "delete").callWithThis(rt, registry, jsi::Value(id));
-  });
-}
-
-jsi::Value SerializableRemoteFunction::RNOrigin::RNOriginProxy::toJSValue(jsi::Runtime &rt) {
-  if (&rt == origin_->getHostRuntime()) {
-    return origin_->toJSValue(rt);
+  if (isHostedOnRNRuntime()) {
+    jsScheduler_->scheduleOnJS([resolver = shared_from_this(), resolveValue](jsi::Runtime &rt) {
+      resolver->toJSValue(rt).getObject(rt).getFunction(rt).call(rt, resolveValue->toJSValue(rt));
+    });
+  } else {
+    const auto workletRuntime = runtimeManager->getRuntime(hostRuntimeId_);
+    // NOLINTNEXTLINE(readability/braces)
+    if (!workletRuntime) [[unlikely]] {
+      // Host runtime is dead, most likely we're the last owner of the Remote Function.
+      // Do nothing.
+    } else {
+      workletRuntime->schedule([resolver = shared_from_this(), resolveValue](jsi::Runtime &rt) {
+        resolver->toJSValue(rt).getObject(rt).getFunction(rt).call(rt, resolveValue->toJSValue(rt));
+      });
+    }
   }
-  return unpackSelf(rt);
-}
-
-void SerializableRemoteFunction::RNOrigin::RNOriginProxy::resolveOrRejectPromise(
-    const std::shared_ptr<Serializable> &resolveValue,
-    const std::shared_ptr<RuntimeManager> &runtimeManager) {
-  origin_->resolveOrRejectPromise(resolveValue, runtimeManager);
 }
 
 } // namespace worklets

package/Common/cpp/worklets/SharedItems/SerializableRemoteFunction.h

@@ -3,12 +3,10 @@
 #include <jsi/jsi.h>
 #include <worklets/SharedItems/Serializable.h>
 #include <worklets/Tools/JSScheduler.h>
-#include <worklets/WorkletRuntime/RuntimeData.h>
+#include <worklets/Tools/RNRuntimeStatus.h>
 
 #include <memory>
-#include <mutex>
 #include <string>
-#include <utility>
 
 namespace worklets {
 
@@ -17,132 +15,61 @@ class RuntimeManager;
 class SerializableRemoteFunction : public Serializable,
                                    public std::enable_shared_from_this<SerializableRemoteFunction> {
  public:
-  class RNOrigin;
-  class WorkletOrigin;
+  /** Creates RN Runtime Remote Function. */
+  SerializableRemoteFunction(
+      jsi::Runtime &rnRuntime,
+      const std::string &name,
+      jsi::Function &&function,
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const std::shared_ptr<RNRuntimeStatus> &rnRuntimeStatus)
+      : Serializable(ValueType::RemoteFunctionType),
+        hostRuntime_(&rnRuntime),
+        hostRuntimeId_(RuntimeData::rnRuntimeId),
+        function_(std::make_unique<jsi::Value>(rnRuntime, std::move(function))),
+        name_(name),
+        jsScheduler_(jsScheduler),
+        rnRuntimeStatus_(rnRuntimeStatus) {}
+
+  /** Creates Worklet Runtime Remote Function. */
+  SerializableRemoteFunction(
+      jsi::Runtime &workletRuntime,
+      const std::string &name,
+      jsi::Function &&function,
+      RuntimeData::RuntimeId hostRuntimeId)
+      : Serializable(ValueType::RemoteFunctionType),
+        hostRuntime_(&workletRuntime),
+        hostRuntimeId_(hostRuntimeId),
+        function_(std::make_unique<jsi::Value>(workletRuntime, std::move(function))),
+        name_(name),
+        jsScheduler_(nullptr),
+        rnRuntimeStatus_(nullptr) {}
 
   ~SerializableRemoteFunction() override;
 
   SerializableRemoteFunction(const SerializableRemoteFunction &) = delete;
   SerializableRemoteFunction &operator=(const SerializableRemoteFunction &) = delete;
 
-  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override = 0;
-
-  virtual void resolveOrRejectPromise(
+  void resolveOrRejectPromise(
       const std::shared_ptr<Serializable> &resolveValue,
-      const std::shared_ptr<RuntimeManager> &runtimeManager) = 0;
+      const std::shared_ptr<RuntimeManager> &runtimeManager);
 
-  [[nodiscard]] virtual bool isHostedOnRNRuntime() const noexcept = 0;
-
-  [[nodiscard]] RuntimeData::RuntimeId getHostRuntimeId() const {
-    return hostRuntimeId_;
-  }
+  jsi::Value toJSValue(jsi::Runtime &rt) override;
 
-  [[nodiscard]] facebook::jsi::Runtime *getHostRuntime() const {
-    return hostRuntime_;
+  [[nodiscard]] bool isHostedOnRNRuntime() const noexcept {
+    return hostRuntimeId_ == RuntimeData::rnRuntimeId;
   }
 
-  [[nodiscard]] const std::string &getName() const {
-    return name_;
+  [[nodiscard]] RuntimeData::RuntimeId getHostRuntimeId() const noexcept {
+    return hostRuntimeId_;
   }
 
- protected:
-  facebook::jsi::Runtime *hostRuntime_;
+ private:
+  jsi::Runtime *hostRuntime_;
   const RuntimeData::RuntimeId hostRuntimeId_;
+  std::unique_ptr<jsi::Value> function_;
   const std::string name_;
-
-  SerializableRemoteFunction(
-      facebook::jsi::Runtime *hostRuntime,
-      RuntimeData::RuntimeId hostRuntimeId,
-      const std::string &name)
-      : Serializable(ValueType::RemoteFunctionType),
-        hostRuntime_(hostRuntime),
-        hostRuntimeId_(hostRuntimeId),
-        name_(name) {}
-
-  facebook::jsi::Value unpackSelf(facebook::jsi::Runtime &rt);
-};
-
-class SerializableRemoteFunction::RNOrigin final : public SerializableRemoteFunction {
- public:
-  RNOrigin(
-      facebook::jsi::Runtime &rnRuntime,
-      const std::string &name,
-      int remoteId,
-      const std::shared_ptr<JSScheduler> &jsScheduler)
-      : SerializableRemoteFunction(&rnRuntime, RuntimeData::rnRuntimeId, name),
-        remoteId_(remoteId),
-        jsScheduler_(jsScheduler) {}
-
-  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
-
-  void resolveOrRejectPromise(
-      const std::shared_ptr<Serializable> &resolveValue,
-      const std::shared_ptr<RuntimeManager> &runtimeManager) override;
-
-  [[nodiscard]] bool isHostedOnRNRuntime() const noexcept override {
-    return true;
-  }
-
-  [[nodiscard]] int getRemoteId() const {
-    return remoteId_;
-  }
-  [[nodiscard]] const std::shared_ptr<JSScheduler> &getJSScheduler() const {
-    return jsScheduler_;
-  }
-
- private:
-  class RNOriginProxy;
-
-  const int remoteId_;
   const std::shared_ptr<JSScheduler> jsScheduler_;
-  std::weak_ptr<SerializableRemoteFunction> proxy_;
-  std::mutex proxyMutex_;
-};
-
-class SerializableRemoteFunction::WorkletOrigin final : public SerializableRemoteFunction {
- public:
-  WorkletOrigin(
-      facebook::jsi::Runtime &workletRuntime,
-      const std::string &name,
-      facebook::jsi::Function &&function,
-      RuntimeData::RuntimeId hostRuntimeId)
-      : SerializableRemoteFunction(&workletRuntime, hostRuntimeId, name),
-        function_(std::make_unique<facebook::jsi::Value>(workletRuntime, std::move(function))) {}
-
-  ~WorkletOrigin() override;
-
-  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
-
-  void resolveOrRejectPromise(
-      const std::shared_ptr<Serializable> &resolveValue,
-      const std::shared_ptr<RuntimeManager> &runtimeManager) override;
-
-  [[nodiscard]] bool isHostedOnRNRuntime() const noexcept override {
-    return false;
-  }
-
- private:
-  std::unique_ptr<facebook::jsi::Value> function_;
-};
-
-class SerializableRemoteFunction::RNOrigin::RNOriginProxy final : public SerializableRemoteFunction {
- public:
-  explicit RNOriginProxy(const std::shared_ptr<RNOrigin> &origin);
-
-  ~RNOriginProxy() override;
-
-  facebook::jsi::Value toJSValue(facebook::jsi::Runtime &rt) override;
-
-  void resolveOrRejectPromise(
-      const std::shared_ptr<Serializable> &resolveValue,
-      const std::shared_ptr<RuntimeManager> &runtimeManager) override;
-
-  [[nodiscard]] bool isHostedOnRNRuntime() const noexcept override {
-    return false;
-  }
-
- private:
-  std::shared_ptr<RNOrigin> origin_;
+  const std::shared_ptr<RNRuntimeStatus> rnRuntimeStatus_;
 };
 
 } // namespace worklets

package/Common/cpp/worklets/Tools/RNRuntimeStatus.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <shared_mutex>
+#include <utility>
+
+namespace worklets {
+
+class RNRuntimeStatus {
+ public:
+  void setDead() {
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    isDead_ = true;
+  }
+
+  template <typename TFn>
+  void runWhileLocked(TFn &&fn) {
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    const bool isDead = isDead_;
+    std::forward<TFn>(fn)(isDead);
+  }
+
+ private:
+  bool isDead_ = false;
+  std::shared_mutex mutex_;
+};
+
+} // namespace worklets