react-native-worklets 0.0.1-alpha → 0.1.0

package/Common/cpp/worklets/AnimationFrameQueue/AnimationFrameBatchinator.cpp

@@ -0,0 +1,71 @@
+#include <jsi/jsi.h>
+#include <worklets/AnimationFrameQueue/AnimationFrameBatchinator.h>
+#include <worklets/SharedItems/Shareables.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+void AnimationFrameBatchinator::addToBatch(
+    const facebook::jsi::Value &callback) {
+  {
+    std::lock_guard<std::mutex> lock(callbacksMutex_);
+    callbacks_.push_back(
+        std::make_shared<const facebook::jsi::Value>(*uiRuntime_, callback));
+  }
+  flush();
+}
+
+AnimationFrameBatchinator::JsiRequestAnimationFrame
+AnimationFrameBatchinator::getJsiRequestAnimationFrame() {
+  return [weakThis = weak_from_this()](
+             facebook::jsi::Runtime &rt, const facebook::jsi::Value &callback) {
+    const auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    strongThis->addToBatch(callback);
+  };
+}
+
+void AnimationFrameBatchinator::flush() {
+  if (flushRequested_.exchange(true)) {
+    return;
+  }
+
+  requestAnimationFrame_([weakThis = weak_from_this()](double timestampMs) {
+    const auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    auto callbacks = strongThis->pullCallbacks();
+    strongThis->flushRequested_ = false;
+
+    auto &uiRuntime = *(strongThis->uiRuntime_);
+    for (const auto &callback : callbacks) {
+      runOnRuntimeGuarded(uiRuntime, *callback, timestampMs);
+    }
+  });
+}
+
+std::vector<std::shared_ptr<const facebook::jsi::Value>>
+AnimationFrameBatchinator::pullCallbacks() {
+  std::lock_guard<std::mutex> lock(callbacksMutex_);
+  return std::move(callbacks_);
+}
+
+AnimationFrameBatchinator::AnimationFrameBatchinator(
+    facebook::jsi::Runtime &uiRuntime,
+    std::function<void(std::function<void(const double)>)>
+        &&forwardedRequestAnimationFrame)
+    : uiRuntime_(&uiRuntime),
+      requestAnimationFrame_(std::move(forwardedRequestAnimationFrame)) {}
+
+} // namespace worklets

package/Common/cpp/worklets/AnimationFrameQueue/AnimationFrameBatchinator.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/SharedItems/Shareables.h>
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+namespace worklets {
+
+class AnimationFrameBatchinator
+    : public std::enable_shared_from_this<AnimationFrameBatchinator> {
+ public:
+  using JsiRequestAnimationFrame = std::function<
+      void(facebook::jsi::Runtime &, const facebook::jsi::Value &)>;
+
+  void addToBatch(const facebook::jsi::Value &callback);
+  JsiRequestAnimationFrame getJsiRequestAnimationFrame();
+
+  AnimationFrameBatchinator(
+      facebook::jsi::Runtime &uiRuntime,
+      std::function<void(std::function<void(const double)>)>
+          &&forwardedRequestAnimationFrame);
+
+ private:
+  void flush();
+  std::vector<std::shared_ptr<const facebook::jsi::Value>> pullCallbacks();
+
+  std::vector<std::shared_ptr<const facebook::jsi::Value>> callbacks_{};
+  std::mutex callbacksMutex_{};
+  std::atomic_bool flushRequested_{};
+  facebook::jsi::Runtime *uiRuntime_;
+  std::function<void(std::function<void(const double)>)> requestAnimationFrame_;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,131 @@
+#include <memory>
+#include <string>
+#include <utility>
+
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/primitives.h>
+
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/SharedItems/Shareables.h>
+#include <worklets/Tools/Defs.h>
+#include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
+
+#ifdef __ANDROID__
+#include <fbjni/fbjni.h>
+#endif // __ANDROID__
+
+#include <jsi/jsi.h>
+
+using namespace facebook;
+
+namespace worklets {
+
+WorkletsModuleProxy::WorkletsModuleProxy(
+    jsi::Runtime &rnRuntime,
+    const std::string &valueUnpackerCode,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::shared_ptr<CallInvoker> &jsCallInvoker,
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const std::shared_ptr<UIScheduler> &uiScheduler,
+    std::function<void(std::function<void(const double)>)>
+        &&forwardedRequestAnimationFrame)
+    : WorkletsModuleProxySpec(jsCallInvoker),
+      valueUnpackerCode_(valueUnpackerCode),
+      jsQueue_(jsQueue),
+      jsScheduler_(jsScheduler),
+      uiScheduler_(uiScheduler),
+      uiWorkletRuntime_(std::make_shared<WorkletRuntime>(
+          rnRuntime,
+          jsQueue,
+          jsScheduler,
+          "Reanimated UI runtime",
+          true /* supportsLocking */,
+          valueUnpackerCode_)),
+      animationFrameBatchinator_(std::make_shared<AnimationFrameBatchinator>(
+          uiWorkletRuntime_->getJSIRuntime(),
+          std::move(forwardedRequestAnimationFrame))) {
+  UIRuntimeDecorator::decorate(
+      uiWorkletRuntime_->getJSIRuntime(),
+      animationFrameBatchinator_->getJsiRequestAnimationFrame());
+}
+
+WorkletsModuleProxy::~WorkletsModuleProxy() {
+  animationFrameBatchinator_.reset();
+  jsQueue_->quitSynchronous();
+  uiWorkletRuntime_.reset();
+}
+
+jsi::Value WorkletsModuleProxy::makeShareableClone(
+    jsi::Runtime &rt,
+    const jsi::Value &value,
+    const jsi::Value &shouldRetainRemote,
+    const jsi::Value &nativeStateSource) {
+  // TODO: It might be a good idea to rename one of these methods to avoid
+  // confusion.
+  return worklets::makeShareableClone(
+      rt, value, shouldRetainRemote, nativeStateSource);
+}
+
+void WorkletsModuleProxy::scheduleOnUI(
+    jsi::Runtime &rt,
+    const jsi::Value &worklet) {
+  auto shareableWorklet = extractShareableOrThrow<ShareableWorklet>(
+      rt, worklet, "[Worklets] Only worklets can be scheduled to run on UI.");
+  uiScheduler_->scheduleOnUI([shareableWorklet, weakThis = weak_from_this()] {
+    // This callback can outlive the WorkletsModuleProxy object during the
+    // invalidation of React Native. This happens when WorkletsModuleProxy
+    // destructor is called on the JS thread and the UI thread is executing
+    // callbacks from the `scheduleOnUI` queue. Therefore, we need to
+    // make sure it's still alive before we try to access it.
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    auto uiWorkletRuntime = strongThis->getUIWorkletRuntime();
+
+#if JS_RUNTIME_HERMES
+    // JSI's scope defined here allows for JSI-objects to be cleared up
+    // after each runtime loop. Within these loops we typically create some
+    // temporary JSI objects and hence it allows for such objects to be
+    // garbage collected much sooner. Apparently the scope API is only
+    // supported on Hermes at the moment.
+    const auto scope = jsi::Scope(uiWorkletRuntime->getJSIRuntime());
+#endif // JS_RUNTIME_HERMES
+
+    uiWorkletRuntime->runGuarded(shareableWorklet);
+  });
+}
+
+jsi::Value WorkletsModuleProxy::executeOnUIRuntimeSync(
+    jsi::Runtime &rt,
+    const jsi::Value &worklet) {
+  return uiWorkletRuntime_->executeSync(rt, worklet);
+}
+
+jsi::Value WorkletsModuleProxy::createWorkletRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &name,
+    const jsi::Value &initializer) {
+  auto workletRuntime = std::make_shared<WorkletRuntime>(
+      rt,
+      jsQueue_,
+      jsScheduler_,
+      name.asString(rt).utf8(rt),
+      true /* supportsLocking */,
+      valueUnpackerCode_);
+  auto initializerShareable = extractShareableOrThrow<ShareableWorklet>(
+      rt, initializer, "[Worklets] Initializer must be a worklet.");
+  workletRuntime->runGuarded(initializerShareable);
+  return jsi::Object::createFromHostObject(rt, workletRuntime);
+}
+
+jsi::Value WorkletsModuleProxy::scheduleOnRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &workletRuntimeValue,
+    const jsi::Value &shareableWorkletValue) {
+  worklets::scheduleOnRuntime(rt, workletRuntimeValue, shareableWorkletValue);
+  return jsi::Value::undefined();
+}
+
+} // namespace worklets

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

@@ -0,0 +1,82 @@
+#pragma once
+
+#include <cxxreact/MessageQueueThread.h>
+#include <worklets/AnimationFrameQueue/AnimationFrameBatchinator.h>
+#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
+#include <worklets/Tools/JSScheduler.h>
+#include <worklets/Tools/SingleInstanceChecker.h>
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+class WorkletsModuleProxy
+    : public WorkletsModuleProxySpec,
+      public std::enable_shared_from_this<WorkletsModuleProxy> {
+ public:
+  explicit WorkletsModuleProxy(
+      jsi::Runtime &rnRuntime,
+      const std::string &valueUnpackerCode,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::shared_ptr<CallInvoker> &jsCallInvoker,
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      const std::shared_ptr<UIScheduler> &uiScheduler,
+      std::function<void(std::function<void(const double)>)>
+          &&forwardedRequestAnimationFrame);
+
+  ~WorkletsModuleProxy() override;
+
+  jsi::Value makeShareableClone(
+      jsi::Runtime &rt,
+      const jsi::Value &value,
+      const jsi::Value &shouldRetainRemote,
+      const jsi::Value &nativeStateSource) override;
+
+  void scheduleOnUI(jsi::Runtime &rt, const jsi::Value &worklet) override;
+
+  jsi::Value executeOnUIRuntimeSync(jsi::Runtime &rt, const jsi::Value &worklet)
+      override;
+
+  jsi::Value createWorkletRuntime(
+      jsi::Runtime &rt,
+      const jsi::Value &name,
+      const jsi::Value &initializer) override;
+
+  jsi::Value scheduleOnRuntime(
+      jsi::Runtime &rt,
+      const jsi::Value &workletRuntimeValue,
+      const jsi::Value &shareableWorkletValue) override;
+
+  [[nodiscard]] inline std::shared_ptr<MessageQueueThread> getJSQueue() const {
+    return jsQueue_;
+  }
+
+  [[nodiscard]] inline std::shared_ptr<JSScheduler> getJSScheduler() const {
+    return jsScheduler_;
+  }
+
+  [[nodiscard]] inline std::shared_ptr<UIScheduler> getUIScheduler() const {
+    return uiScheduler_;
+  }
+
+  [[nodiscard]] inline std::shared_ptr<WorkletRuntime> getUIWorkletRuntime()
+      const {
+    return uiWorkletRuntime_;
+  }
+
+ private:
+  const std::string valueUnpackerCode_;
+  const std::shared_ptr<MessageQueueThread> jsQueue_;
+  const std::shared_ptr<JSScheduler> jsScheduler_;
+  const std::shared_ptr<UIScheduler> uiScheduler_;
+  std::shared_ptr<WorkletRuntime> uiWorkletRuntime_;
+  std::shared_ptr<AnimationFrameBatchinator> animationFrameBatchinator_;
+#ifndef NDEBUG
+  SingleInstanceChecker<WorkletsModuleProxy> singleInstanceChecker_;
+#endif // NDEBUG
+};
+
+} // namespace worklets

package/Common/cpp/worklets/NativeModules/WorkletsModuleProxySpec.cpp

@@ -0,0 +1,72 @@
+#include <worklets/NativeModules/WorkletsModuleProxySpec.h>
+
+#include <utility>
+
+#define WORKLETS_SPEC_PREFIX(FN_NAME) \
+  __hostFunction_WorkletsModuleProxySpec_##FN_NAME
+
+namespace worklets {
+
+static jsi::Value WORKLETS_SPEC_PREFIX(makeShareableClone)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
+      ->makeShareableClone(
+          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+}
+
+static jsi::Value WORKLETS_SPEC_PREFIX(scheduleOnUI)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  static_cast<WorkletsModuleProxySpec *>(&turboModule)
+      ->scheduleOnUI(rt, std::move(args[0]));
+  return jsi::Value::undefined();
+}
+
+static jsi::Value WORKLETS_SPEC_PREFIX(executeOnUIRuntimeSync)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
+      ->executeOnUIRuntimeSync(rt, std::move(args[0]));
+}
+
+static jsi::Value WORKLETS_SPEC_PREFIX(createWorkletRuntime)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
+      ->createWorkletRuntime(rt, std::move(args[0]), std::move(args[1]));
+}
+
+static jsi::Value WORKLETS_SPEC_PREFIX(scheduleOnRuntime)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t) {
+  return static_cast<WorkletsModuleProxySpec *>(&turboModule)
+      ->scheduleOnRuntime(rt, std::move(args[0]), std::move(args[1]));
+}
+
+WorkletsModuleProxySpec::WorkletsModuleProxySpec(
+    const std::shared_ptr<CallInvoker> jsInvoker)
+    : TurboModule("NativeWorklets", jsInvoker) {
+  methodMap_["makeShareableClone"] =
+      MethodMetadata{2, WORKLETS_SPEC_PREFIX(makeShareableClone)};
+  methodMap_["scheduleOnUI"] =
+      MethodMetadata{1, WORKLETS_SPEC_PREFIX(scheduleOnUI)};
+  methodMap_["executeOnUIRuntimeSync"] =
+      MethodMetadata{1, WORKLETS_SPEC_PREFIX(executeOnUIRuntimeSync)};
+  methodMap_["createWorkletRuntime"] =
+      MethodMetadata{2, WORKLETS_SPEC_PREFIX(createWorkletRuntime)};
+  methodMap_["scheduleOnRuntime"] =
+      MethodMetadata{2, WORKLETS_SPEC_PREFIX(scheduleOnRuntime)};
+}
+
+} // namespace worklets

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

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/TurboModule.h>
+#include <memory>
+
+using namespace facebook;
+using namespace react;
+
+namespace worklets {
+
+class JSI_EXPORT WorkletsModuleProxySpec : public TurboModule {
+ protected:
+  explicit WorkletsModuleProxySpec(
+      const std::shared_ptr<CallInvoker> jsInvoker);
+
+ public:
+  // Shareables
+  virtual jsi::Value makeShareableClone(
+      jsi::Runtime &rt,
+      const jsi::Value &value,
+      const jsi::Value &shouldRetainRemote,
+      const jsi::Value &nativeStateSource) = 0;
+
+  // Scheduling
+  virtual void scheduleOnUI(jsi::Runtime &rt, const jsi::Value &worklet) = 0;
+
+  virtual jsi::Value executeOnUIRuntimeSync(
+      jsi::Runtime &rt,
+      const jsi::Value &worklet) = 0;
+
+  // Worklet runtime
+  virtual jsi::Value createWorkletRuntime(
+      jsi::Runtime &rt,
+      const jsi::Value &name,
+      const jsi::Value &initializer) = 0;
+
+  virtual jsi::Value scheduleOnRuntime(
+      jsi::Runtime &rt,
+      const jsi::Value &workletRuntimeValue,
+      const jsi::Value &shareableWorkletValue) = 0;
+};
+
+} // namespace worklets

package/Common/cpp/worklets/Registries/EventHandlerRegistry.cpp

@@ -0,0 +1,94 @@
+#include <worklets/Registries/EventHandlerRegistry.h>
+#include <worklets/Tools/WorkletEventHandler.h>
+
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+void EventHandlerRegistry::registerEventHandler(
+    const std::shared_ptr<WorkletEventHandler> &eventHandler) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
+  const auto &eventName = eventHandler->getEventName();
+  auto handlerId = eventHandler->getHandlerId();
+
+  if (eventHandler->shouldIgnoreEmitterReactTag()) {
+    eventMappingsWithoutTag[eventName][handlerId] = eventHandler;
+  } else {
+    const auto emitterReactTag = eventHandler->getEmitterReactTag();
+    const auto eventHash = std::make_pair(emitterReactTag, eventName);
+    eventMappingsWithTag[eventHash][handlerId] = eventHandler;
+  }
+  eventHandlers[handlerId] = eventHandler;
+}
+
+void EventHandlerRegistry::unregisterEventHandler(const uint64_t id) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
+  auto handlerIt = eventHandlers.find(id);
+  if (handlerIt != eventHandlers.end()) {
+    const auto &eventHandler = handlerIt->second;
+    const auto &eventName = eventHandler->getEventName();
+
+    if (eventHandler->shouldIgnoreEmitterReactTag()) {
+      const auto eventMappingIt = eventMappingsWithoutTag.find(eventName);
+      auto &handlersMap = eventMappingIt->second;
+      handlersMap.erase(id);
+      if (handlersMap.empty()) {
+        eventMappingsWithoutTag.erase(eventMappingIt);
+      }
+    } else {
+      const auto emitterReactTag = eventHandler->getEmitterReactTag();
+      const auto eventHash = std::make_pair(emitterReactTag, eventName);
+      const auto eventMappingIt = eventMappingsWithTag.find(eventHash);
+      auto &handlersMap = eventMappingIt->second;
+      handlersMap.erase(id);
+      if (handlersMap.empty()) {
+        eventMappingsWithTag.erase(eventMappingIt);
+      }
+    }
+    eventHandlers.erase(handlerIt);
+  }
+}
+
+void EventHandlerRegistry::processEvent(
+    const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+    const double eventTimestamp,
+    const std::string &eventName,
+    const int emitterReactTag,
+    const jsi::Value &eventPayload) {
+  std::vector<std::shared_ptr<WorkletEventHandler>> handlersForEvent;
+  {
+    const std::lock_guard<std::mutex> lock(instanceMutex);
+    auto handlersIt = eventMappingsWithoutTag.find(eventName);
+    if (handlersIt != eventMappingsWithoutTag.end()) {
+      for (auto handler : handlersIt->second) {
+        handlersForEvent.push_back(handler.second);
+      }
+    }
+    const auto eventHash = std::make_pair(emitterReactTag, eventName);
+    auto handlersWithTagIt = eventMappingsWithTag.find(eventHash);
+    if (handlersWithTagIt != eventMappingsWithTag.end()) {
+      for (auto handler : handlersWithTagIt->second) {
+        handlersForEvent.push_back(handler.second);
+      }
+    }
+  }
+
+  jsi::Runtime &rt = uiWorkletRuntime->getJSIRuntime();
+  eventPayload.asObject(rt).setProperty(
+      rt, "eventName", jsi::String::createFromUtf8(rt, eventName));
+  for (auto handler : handlersForEvent) {
+    handler->process(uiWorkletRuntime, eventTimestamp, eventPayload);
+  }
+}
+
+bool EventHandlerRegistry::isAnyHandlerWaitingForEvent(
+    const std::string &eventName,
+    const int emitterReactTag) {
+  const std::lock_guard<std::mutex> lock(instanceMutex);
+  const auto eventHash = std::make_pair(emitterReactTag, eventName);
+  auto it = eventMappingsWithTag.find(eventHash);
+  return it != eventMappingsWithTag.end() && !it->second.empty();
+}
+
+} // namespace worklets

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

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <jsi/jsi.h>
+
+#include <map>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletEventHandler;
+
+class EventHandlerRegistry {
+  std::map<
+      std::pair<int, std::string>,
+      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
+      eventMappingsWithTag;
+  std::map<
+      std::string,
+      std::unordered_map<uint64_t, std::shared_ptr<WorkletEventHandler>>>
+      eventMappingsWithoutTag;
+  std::map<uint64_t, std::shared_ptr<WorkletEventHandler>> eventHandlers;
+  std::mutex instanceMutex;
+
+ public:
+  void registerEventHandler(
+      const std::shared_ptr<WorkletEventHandler> &eventHandler);
+  void unregisterEventHandler(const uint64_t id);
+
+  void processEvent(
+      const std::shared_ptr<WorkletRuntime> &uiWorkletRuntime,
+      const double eventTimestamp,
+      const std::string &eventName,
+      const int emitterReactTag,
+      const jsi::Value &eventPayload);
+
+  bool isAnyHandlerWaitingForEvent(
+      const std::string &eventName,
+      const int emitterReactTag);
+};
+
+} // namespace worklets

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

@@ -0,0 +1,8 @@
+#include <worklets/Registries/WorkletRuntimeRegistry.h>
+
+namespace worklets {
+
+std::set<jsi::Runtime *> WorkletRuntimeRegistry::registry_{};
+std::mutex WorkletRuntimeRegistry::mutex_{};
+
+} // namespace worklets

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

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <mutex>
+#include <set>
+
+using namespace facebook;
+
+namespace worklets {
+
+class WorkletRuntimeRegistry {
+ private:
+  static std::set<jsi::Runtime *> registry_;
+  static std::mutex mutex_; // Protects `registry_`.
+
+  WorkletRuntimeRegistry() {} // private ctor
+
+  static void registerRuntime(jsi::Runtime &runtime) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    registry_.insert(&runtime);
+  }
+
+  static void unregisterRuntime(jsi::Runtime &runtime) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    registry_.erase(&runtime);
+  }
+
+  friend class WorkletRuntimeCollector;
+
+ public:
+  static bool isRuntimeAlive(jsi::Runtime *runtime) {
+    assert(runtime != nullptr);
+    std::lock_guard<std::mutex> lock(mutex_);
+    return registry_.find(runtime) != registry_.end();
+  }
+};
+
+} // namespace worklets