@amazon-devices/react-native-worklets 1.0.0-rn-83

package/Common/cpp/worklets/WorkletRuntime/RuntimeManager.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Tools/UIScheduler.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+
+#include <atomic>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <shared_mutex>
+#include <string>
+#include <vector>
+
+namespace worklets {
+
+/**
+ * Forward declaration to avoid circular dependencies.
+ */
+class JSIWorkletsModuleProxy;
+
+class RuntimeManager {
+ public:
+  std::shared_ptr<WorkletRuntime> getRuntime(uint64_t runtimeId);
+  std::shared_ptr<WorkletRuntime> getRuntime(const std::string &name);
+#ifdef WORKLETS_BUNDLE_MODE
+  std::shared_ptr<WorkletRuntime> getRuntime(jsi::Runtime *runtime);
+#endif // WORKLETS_BUNDLE_MODE
+
+  std::vector<std::shared_ptr<WorkletRuntime>> getAllRuntimes();
+
+  std::shared_ptr<WorkletRuntime> getUIRuntime();
+
+  std::shared_ptr<WorkletRuntime> createWorkletRuntime(
+      std::shared_ptr<JSIWorkletsModuleProxy> jsiWorkletsModuleProxy,
+      const std::string &name,
+      std::shared_ptr<SerializableWorklet> initializer = nullptr,
+      const std::shared_ptr<AsyncQueue> &queue = nullptr,
+      bool enableEventLoop = true);
+
+  std::shared_ptr<WorkletRuntime> createUninitializedUIRuntime(
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::shared_ptr<AsyncQueue> &uiAsyncQueue);
+
+ private:
+  uint64_t getNextRuntimeId();
+
+  void registerRuntime(
+      const uint64_t runtimeId,
+      const std::string &name,
+      const std::shared_ptr<WorkletRuntime> &workletRuntime);
+
+  std::atomic_uint64_t nextRuntimeId_{uiRuntimeId + 1};
+  std::map<uint64_t, std::weak_ptr<WorkletRuntime>> weakRuntimes_;
+  std::shared_mutex weakRuntimesMutex_;
+  std::map<std::string, uint64_t> nameToRuntimeId_;
+#ifdef WORKLETS_BUNDLE_MODE
+  std::map<jsi::Runtime *, uint64_t> runtimeAddressToRuntimeId_;
+#endif // WORKLETS_BUNDLE_MODE
+};
+
+} // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/UIRuntimeDecorator.cpp

@@ -0,0 +1,23 @@
+#include <worklets/Tools/WorkletsJSIUtils.h>
+#include <worklets/WorkletRuntime/RuntimeKind.h>
+#include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
+
+#include <utility>
+
+namespace worklets {
+
+void UIRuntimeDecorator::decorate(
+    facebook::jsi::Runtime &uiRuntime,
+    std::function<
+        void(facebook::jsi::Runtime &rt, const facebook::jsi::Value &callback)>
+        &&requestAnimationFrame) {
+  uiRuntime.global().setProperty(
+      uiRuntime, runtimeKindBindingName, static_cast<int>(RuntimeKind::UI));
+
+  uiRuntime.global().setProperty(uiRuntime, "_UI", true);
+
+  jsi_utils::installJsiFunction(
+      uiRuntime, "requestAnimationFrame", std::move(requestAnimationFrame));
+}
+
+} // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/UIRuntimeDecorator.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace worklets {
+
+class UIRuntimeDecorator {
+ public:
+  static void decorate(
+      facebook::jsi::Runtime &uiRuntime,
+      std::function<void(
+          facebook::jsi::Runtime &rt,
+          const facebook::jsi::Value &callback)> &&requestAnimationFrame);
+};
+
+} // namespace worklets

package/Common/cpp/worklets/WorkletRuntime/WorkletHermesRuntime.cpp

@@ -0,0 +1,119 @@
+#include <worklets/WorkletRuntime/WorkletHermesRuntime.h>
+
+// Only include this file in Hermes-enabled builds as some platforms (like tvOS)
+// don't support hermes and it causes the compilation to fail.
+#if JS_RUNTIME_HERMES
+
+#include <cxxreact/MessageQueueThread.h>
+#include <jsi/decorator.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+// amznmod_react - cherry-pick f312abe
+#if HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+using namespace facebook::hermes::inspector_modern;
+#endif // HERMES_ENABLE_DEBUGGER  && !defined(HERMES_V1_ENABLED)
+
+#if HERMES_ENABLE_DEBUGGER
+
+// amznmod_react - cherry-pick f312abe
+class HermesExecutorRuntimeAdapter
+#if HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+    : public RuntimeAdapter
+#endif // HERMES_ENABLE_DEBUGGER  && !defined(HERMES_V1_ENABLED)
+{
+ public:
+  explicit HermesExecutorRuntimeAdapter(
+      facebook::hermes::HermesRuntime &hermesRuntime,
+      const std::shared_ptr<MessageQueueThread> &thread)
+      : hermesRuntime_(hermesRuntime), thread_(std::move(thread)) {}
+
+  virtual ~HermesExecutorRuntimeAdapter() {
+    // This is required by iOS, because there is an assertion in the destructor
+    // that the thread was indeed `quit` before
+    thread_->quitSynchronous();
+  }
+
+// amznmod_react - cherry-pick f312abe
+#if HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+  facebook::hermes::HermesRuntime &getRuntime() override {
+    return hermesRuntime_;
+  }
+
+  // This is not empty in the original implementation, but we decided to tickle
+  // the runtime by running a small piece of code on every frame as using this
+  // required us to hold a refernce to the runtime inside this adapter which
+  // caused issues while reloading the app.
+  void tickleJs() override {}
+#endif // HERMES_ENABLE_DEBUGGER  && !defined(HERMES_V1_ENABLED)
+  
+ public:
+  facebook::hermes::HermesRuntime &hermesRuntime_;
+  std::shared_ptr<MessageQueueThread> thread_;
+};
+
+#endif // HERMES_ENABLE_DEBUGGER
+
+WorkletHermesRuntime::WorkletHermesRuntime(
+    std::unique_ptr<facebook::hermes::HermesRuntime> runtime,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::string &name)
+    : jsi::WithRuntimeDecorator<WorkletsReentrancyCheck>(
+          *runtime,
+          reentrancyCheck_),
+      runtime_(std::move(runtime)) {
+// amznmod_react - cherry-pick f312abe
+#if HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+  auto adapter =
+      std::make_unique<HermesExecutorRuntimeAdapter>(*runtime_, jsQueue);
+  debugToken_ = chrome::enableDebugging(std::move(adapter), name);
+#endif // HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+
+#ifndef NDEBUG
+  facebook::hermes::HermesRuntime *wrappedRuntime = runtime_.get();
+  jsi::Value evalWithSourceMap = jsi::Function::createFromHostFunction(
+      *runtime_,
+      jsi::PropNameID::forAscii(*runtime_, "evalWithSourceMap"),
+      3,
+      [wrappedRuntime](
+          jsi::Runtime &rt,
+          const jsi::Value &thisValue,
+          const jsi::Value *args,
+          size_t count) -> jsi::Value {
+        auto code = std::make_shared<const jsi::StringBuffer>(
+            args[0].asString(rt).utf8(rt));
+        std::string sourceURL;
+        if (count > 1 && args[1].isString()) {
+          sourceURL = args[1].asString(rt).utf8(rt);
+        }
+        std::shared_ptr<const jsi::Buffer> sourceMap;
+        if (count > 2 && args[2].isString()) {
+          sourceMap = std::make_shared<const jsi::StringBuffer>(
+              args[2].asString(rt).utf8(rt));
+        }
+        return wrappedRuntime->evaluateJavaScriptWithSourceMap(
+            code, sourceMap, sourceURL);
+      });
+  runtime_->global().setProperty(
+      *runtime_, "evalWithSourceMap", evalWithSourceMap);
+#endif // NDEBUG
+}
+
+WorkletHermesRuntime::~WorkletHermesRuntime() {
+// amznmod_react - cherry-pick f312abe
+#if HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+  // We have to disable debugging before the runtime is destroyed.
+  chrome::disableDebugging(debugToken_);
+#endif // HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+}
+
+} // namespace worklets
+
+#endif // JS_RUNTIME_HERMES

package/Common/cpp/worklets/WorkletRuntime/WorkletHermesRuntime.h

@@ -0,0 +1,134 @@
+#pragma once
+
+#include <worklets/Tools/Defs.h>
+
+// Only include this file in Hermes-enabled builds as some platforms (like tvOS)
+// don't support hermes and it causes the compilation to fail.
+#if JS_RUNTIME_HERMES
+
+#include <cxxreact/MessageQueueThread.h>
+#include <hermes/hermes.h>
+#include <jsi/decorator.h>
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+
+#include <atomic>
+#include <memory>
+#include <string>
+#include <thread>
+
+// amznmod_react - cherry-pick f312abe
+#if HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+#include <hermes/inspector-modern/chrome/Registration.h>
+#endif // HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+// amznmod_react - cherry-pick f312abe
+#if HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+using namespace facebook::hermes::inspector_modern;
+#endif // HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+
+// ReentrancyCheck is copied from React Native
+// from ReactCommon/hermes/executor/HermesExecutorFactory.cpp
+// https://github.com/facebook/react-native/blob/main/packages/react-native/ReactCommon/hermes/executor/HermesExecutorFactory.cpp
+struct WorkletsReentrancyCheck {
+  // This is effectively a very subtle and complex assert, so only
+  // include it in builds which would include asserts.
+#ifndef NDEBUG
+  WorkletsReentrancyCheck() : tid(std::thread::id()), depth(0) {}
+
+  void before() {
+    std::thread::id this_id = std::this_thread::get_id();
+    std::thread::id expected = std::thread::id();
+
+    // A note on memory ordering: the main purpose of these checks is
+    // to observe a before/before race, without an intervening after.
+    // This will be detected by the compare_exchange_strong atomicity
+    // properties, regardless of memory order.
+    //
+    // For everything else, it is easiest to think of 'depth' as a
+    // proxy for any access made inside the VM.  If access to depth
+    // are reordered incorrectly, the same could be true of any other
+    // operation made by the VM.  In fact, using acquire/release
+    // memory ordering could create barriers which mask a programmer
+    // error.  So, we use relaxed memory order, to avoid masking
+    // actual ordering errors.  Although, in practice, ordering errors
+    // of this sort would be surprising, because the decorator would
+    // need to call after() without before().
+
+    if (tid.compare_exchange_strong(
+            expected, this_id, std::memory_order_relaxed)) {
+      // Returns true if tid and expected were the same.  If they
+      // were, then the stored tid referred to no thread, and we
+      // atomically saved this thread's tid.  Now increment depth.
+      react_native_assert(
+          depth == 0 && "[Worklets] No thread id, but depth != 0");
+      ++depth;
+    } else if (expected == this_id) {
+      // If the stored tid referred to a thread, expected was set to
+      // that value.  If that value is this thread's tid, that's ok,
+      // just increment depth again.
+      react_native_assert(
+          depth != 0 && "[Worklets] Thread id was set, but depth == 0");
+      ++depth;
+    } else {
+      // The stored tid was some other thread.  This indicates a bad
+      // programmer error, where VM methods were called on two
+      // different threads unsafely.  Fail fast (and hard) so the
+      // crash can be analyzed.
+      __builtin_trap();
+    }
+  }
+
+  void after() {
+    react_native_assert(
+        tid.load(std::memory_order_relaxed) == std::this_thread::get_id() &&
+        "[Worklets] No thread id in after()");
+    if (--depth == 0) {
+      // If we decremented depth to zero, store no-thread into tid.
+      std::thread::id expected = std::this_thread::get_id();
+      bool didWrite = tid.compare_exchange_strong(
+          expected, std::thread::id(), std::memory_order_relaxed);
+      react_native_assert(
+          didWrite && "[Worklets] Decremented to zero, but no tid write");
+    }
+  }
+
+  std::atomic<std::thread::id> tid;
+  // This is not atomic, as it is only written or read from the owning
+  // thread.
+  unsigned int depth;
+#endif // NDEBUG
+};
+
+// This is in fact a subclass of jsi::Runtime! WithRuntimeDecorator is a
+// template class that is a subclass of DecoratedRuntime which is also a
+// template class that then inherits its template, which in this case is
+// jsi::Runtime. So the inheritance is: WorkletHermesRuntime ->
+// WithRuntimeDecorator -> DecoratedRuntime -> jsi::Runtime You can find out
+// more about this in ReactCommon/jsi/jsi/Decorator.h or by following this link:
+// https://github.com/facebook/react-native/blob/main/packages/react-native/ReactCommon/jsi/jsi/decorator.h
+class WorkletHermesRuntime
+    : public jsi::WithRuntimeDecorator<WorkletsReentrancyCheck> {
+ public:
+  WorkletHermesRuntime(
+      std::unique_ptr<facebook::hermes::HermesRuntime> runtime,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::string &name);
+  ~WorkletHermesRuntime();
+
+ private:
+  std::unique_ptr<facebook::hermes::HermesRuntime> runtime_;
+  WorkletsReentrancyCheck reentrancyCheck_;
+// amznmod_react - cherry-pick f312abe
+#if HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+  chrome::DebugSessionToken debugToken_;
+#endif // HERMES_ENABLE_DEBUGGER && !defined(HERMES_V1_ENABLED)
+};
+
+} // namespace worklets
+
+#endif // JS_RUNTIME_HERMES

package/Common/cpp/worklets/WorkletRuntime/WorkletRuntime.cpp

@@ -0,0 +1,244 @@
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/Resources/Unpackers.h>
+#include <worklets/Tools/Defs.h>
+#include <worklets/Tools/JSISerializer.h>
+#include <worklets/Tools/JSLogger.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeCollector.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
+
+#include <cxxreact/MessageQueueThread.h>
+#include <jsi/decorator.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <utility>
+
+#if JS_RUNTIME_HERMES
+#include <worklets/WorkletRuntime/WorkletHermesRuntime.h>
+#else
+#include <jsc/JSCRuntime.h>
+#endif // JS_RUNTIME
+
+namespace worklets {
+
+class AroundLock {
+  const std::shared_ptr<std::recursive_mutex> mutex_;
+
+ public:
+  explicit AroundLock(const std::shared_ptr<std::recursive_mutex> &mutex)
+      : mutex_(mutex) {}
+
+  void before() const {
+    mutex_->lock();
+  }
+
+  void after() const {
+    mutex_->unlock();
+  }
+};
+
+class LockableRuntime : public jsi::WithRuntimeDecorator<AroundLock> {
+  AroundLock aroundLock_;
+  std::shared_ptr<jsi::Runtime> runtime_;
+
+ public:
+  explicit LockableRuntime(
+      std::shared_ptr<jsi::Runtime> &runtime,
+      const std::shared_ptr<std::recursive_mutex> &runtimeMutex)
+      : jsi::WithRuntimeDecorator<AroundLock>(*runtime, aroundLock_),
+        aroundLock_(runtimeMutex),
+        runtime_(std::move(runtime)) {}
+};
+
+static std::shared_ptr<jsi::Runtime> makeRuntime(
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::string &name,
+    const std::shared_ptr<std::recursive_mutex> &runtimeMutex) {
+  std::shared_ptr<jsi::Runtime> jsiRuntime;
+#if JS_RUNTIME_HERMES
+  auto hermesRuntime = facebook::hermes::makeHermesRuntime();
+  jsiRuntime = std::make_shared<WorkletHermesRuntime>(
+      std::move(hermesRuntime), jsQueue, name);
+#else
+  jsiRuntime = facebook::jsc::makeJSCRuntime();
+#endif
+
+  return std::make_shared<LockableRuntime>(jsiRuntime, runtimeMutex);
+}
+
+WorkletRuntime::WorkletRuntime(
+    uint64_t runtimeId,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::string &name,
+    const std::shared_ptr<AsyncQueue> &queue,
+    bool enableEventLoop)
+    : runtimeId_(runtimeId),
+      runtimeMutex_(std::make_shared<std::recursive_mutex>()),
+      runtime_(makeRuntime(jsQueue, name, runtimeMutex_)),
+      name_(name),
+      queue_(queue) {
+  jsi::Runtime &rt = *runtime_;
+  WorkletRuntimeCollector::install(rt);
+  if (enableEventLoop && name != uiRuntimeName) {
+    eventLoop_ = std::make_shared<EventLoop>(name_, runtime_, queue_);
+    eventLoop_->run();
+  }
+}
+
+void WorkletRuntime::init(
+    std::shared_ptr<JSIWorkletsModuleProxy> jsiWorkletsModuleProxy) {
+  jsi::Runtime &rt = *runtime_;
+  const auto jsScheduler = jsiWorkletsModuleProxy->getJSScheduler();
+  const auto isDevBundle = jsiWorkletsModuleProxy->isDevBundle();
+#ifdef WORKLETS_BUNDLE_MODE
+  auto script = jsiWorkletsModuleProxy->getScript();
+  const auto &sourceUrl = jsiWorkletsModuleProxy->getSourceUrl();
+#endif // WORKLETS_BUNDLE_MODE
+
+  auto optimizedJsiWorkletsModuleProxy =
+      jsi_utils::optimizedFromHostObject(rt, std::move(jsiWorkletsModuleProxy));
+
+  WorkletRuntimeDecorator::decorate(
+      rt,
+      name_,
+      jsScheduler,
+      isDevBundle,
+      std::move(optimizedJsiWorkletsModuleProxy),
+      eventLoop_);
+
+#ifdef WORKLETS_BUNDLE_MODE
+  if (!script) {
+    throw std::runtime_error(
+        "[Worklets] Expected to receive the bundle, but got nullptr instead.");
+  }
+
+  try {
+    rt.evaluateJavaScript(script, sourceUrl);
+  } catch (facebook::jsi::JSError error) {
+    const auto &message = error.getMessage();
+    const auto &stack = error.getStack();
+    if (!message.starts_with("[Worklets] Worklets initialized successfully")) {
+      const auto newMessage =
+          "[Worklets] Failed to initialize runtime. Reason: " + message;
+      JSLogger::reportFatalErrorOnJS(
+          jsScheduler,
+          {.message = newMessage,
+           .stack = stack,
+           .name = "WorkletsError",
+           .jsEngine = "Worklets"});
+    }
+  }
+#else
+  // Legacy behavior
+  auto valueUnpackerBuffer =
+      std::make_shared<const jsi::StringBuffer>(ValueUnpackerCode);
+  rt.evaluateJavaScript(valueUnpackerBuffer, "valueUnpacker");
+
+  auto synchronizableUnpackerBuffer =
+      std::make_shared<const jsi::StringBuffer>(SynchronizableUnpackerCode);
+  rt.evaluateJavaScript(synchronizableUnpackerBuffer, "synchronizableUnpacker");
+#endif // WORKLETS_BUNDLE_MODE
+}
+
+void WorkletRuntime::runAsyncGuarded(
+    const std::shared_ptr<SerializableWorklet> &worklet) {
+  react_native_assert(
+      "[Worklets] Tried to invoke `runAsyncGuarded` on a Worklet Runtime but "
+      "the async queue is not set. Recreate the runtime with a valid async queue.");
+
+  queue_->push([worklet, weakThis = weak_from_this()] {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    strongThis->runGuarded(worklet);
+  });
+}
+
+jsi::Value WorkletRuntime::executeSync(
+    jsi::Runtime &rt,
+    const jsi::Value &worklet) const {
+  auto serializableWorklet = extractSerializableOrThrow<SerializableWorklet>(
+      rt,
+      worklet,
+      "[Worklets] Only worklets can be executed synchronously on UI runtime.");
+  auto lock = std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
+  jsi::Runtime &uiRuntime = getJSIRuntime();
+  auto result = runGuarded(serializableWorklet);
+  auto serializableResult = extractSerializableOrThrow(uiRuntime, result);
+  lock.unlock();
+  return serializableResult->toJSValue(rt);
+}
+
+#ifdef WORKLETS_BUNDLE_MODE
+jsi::Value WorkletRuntime::executeSync(
+    std::function<jsi::Value(jsi::Runtime &)> &&job) const {
+  auto lock = std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
+  jsi::Runtime &uiRuntime = getJSIRuntime();
+  return job(uiRuntime);
+}
+
+jsi::Value WorkletRuntime::executeSync(
+    const std::function<jsi::Value(jsi::Runtime &)> &job) const {
+  auto lock = std::unique_lock<std::recursive_mutex>(*runtimeMutex_);
+  jsi::Runtime &uiRuntime = getJSIRuntime();
+  return job(uiRuntime);
+}
+#endif // WORKLETS_BUNDLE_MODE
+
+jsi::Value WorkletRuntime::get(
+    jsi::Runtime &rt,
+    const jsi::PropNameID &propName) {
+  auto name = propName.utf8(rt);
+  if (name == "toString") {
+    return jsi::Function::createFromHostFunction(
+        rt,
+        propName,
+        0,
+        [weakThis = weak_from_this()](
+            jsi::Runtime &rt, const jsi::Value &, const jsi::Value *, size_t)
+            -> jsi::Value {
+          auto strongThis = weakThis.lock();
+          if (!strongThis) {
+            return jsi::String::createFromUtf8(rt, "");
+          }
+
+          return jsi::String::createFromUtf8(rt, strongThis->toString());
+        });
+  }
+  if (name == "name") {
+    return jsi::String::createFromUtf8(rt, name_);
+  }
+  return jsi::Value::undefined();
+}
+
+std::vector<jsi::PropNameID> WorkletRuntime::getPropertyNames(
+    jsi::Runtime &rt) {
+  std::vector<jsi::PropNameID> result;
+  result.push_back(jsi::PropNameID::forUtf8(rt, "toString"));
+  result.push_back(jsi::PropNameID::forUtf8(rt, "name"));
+  return result;
+}
+
+std::shared_ptr<WorkletRuntime> extractWorkletRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &value) {
+  return value.getObject(rt).getHostObject<WorkletRuntime>(rt);
+}
+
+void scheduleOnRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &workletRuntimeValue,
+    const jsi::Value &serializableWorkletValue) {
+  auto workletRuntime = extractWorkletRuntime(rt, workletRuntimeValue);
+  auto serializableWorklet = extractSerializableOrThrow<SerializableWorklet>(
+      rt,
+      serializableWorkletValue,
+      "[Worklets] Function passed to `_scheduleOnRuntime` is not a serializable worklet.");
+  workletRuntime->runAsyncGuarded(serializableWorklet);
+}
+
+} // namespace worklets