@depup/react-native-worklets 0.11.3-depup.0

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

@@ -0,0 +1,116 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Tools/ScriptBuffer.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace worklets {
+
+class ScriptLoader {
+
+ public:
+  /**
+   * Safely loads the bundle into the Worklet Runtime and executes Worklets' entry point.
+   */
+  static void loadScript(
+      facebook::jsi::Runtime &rt,
+      const std::shared_ptr<const ScriptBuffer> &script,
+      const std::string &sourceUrl) {
+    ScriptLoader loader{};
+    loader.interceptEntryPoints(rt);
+    rt.evaluateJavaScript(script, sourceUrl);
+    loader.allowEntryPoints(rt);
+    loader.loadWorkletsEntryPoint(rt);
+  }
+
+ private:
+  /**
+   * Sets the `require` function on the global object with a noop getter
+   * and a setter that saves the actual implementation of `require` for later use.
+   *
+   * This is necessary to prevent running the App and React Native entry-points when evaluating the bundle.
+   */
+  void interceptEntryPoints(facebook::jsi::Runtime &rt) {
+    facebook::jsi::Object descriptor(rt);
+    descriptor.setProperty(rt, "configurable", true);
+    descriptor.setProperty(rt, "enumerable", false);
+    descriptor.setProperty(
+        rt,
+        "get",
+        facebook::jsi::Function::createFromHostFunction(
+            rt,
+            facebook::jsi::PropNameID::forUtf8(rt, "get"),
+            0,
+            [](facebook::jsi::Runtime &rt, const facebook::jsi::Value &, const facebook::jsi::Value *, size_t)
+                -> facebook::jsi::Value {
+              return facebook::jsi::Function::createFromHostFunction(
+                  rt,
+                  facebook::jsi::PropNameID::forUtf8(rt, "noop"),
+                  0,
+                  [](facebook::jsi::Runtime &, const facebook::jsi::Value &, const facebook::jsi::Value *, size_t)
+                      -> facebook::jsi::Value { return facebook::jsi::Value::undefined(); });
+            }));
+    descriptor.setProperty(
+        rt,
+        "set",
+        facebook::jsi::Function::createFromHostFunction(
+            rt,
+            facebook::jsi::PropNameID::forUtf8(rt, "set"),
+            1,
+            [&](facebook::jsi::Runtime &rt,
+                const facebook::jsi::Value &,
+                const facebook::jsi::Value *args,
+                size_t count) -> facebook::jsi::Value {
+              metroRequire_ = jsi::Value(rt, args[0]);
+              return facebook::jsi::Value::undefined();
+            }));
+
+    const auto globalObj = rt.global();
+    const auto objectCtor = globalObj.getPropertyAsObject(rt, "Object");
+    const auto defineProperty = objectCtor.getPropertyAsFunction(rt, "defineProperty");
+    defineProperty.call(
+        rt,
+        facebook::jsi::Value(rt, globalObj),
+        facebook::jsi::String::createFromUtf8(rt, kRequireName_),
+        std::move(descriptor));
+  }
+
+  /**
+   * Restores the original `require` function on the global object after evaluating the bundle.
+   * This way we can use worklets as entry points.
+   */
+  void allowEntryPoints(facebook::jsi::Runtime &rt) {
+    facebook::jsi::Object descriptor(rt);
+
+    descriptor.setProperty(rt, "configurable", true);
+    descriptor.setProperty(rt, "enumerable", false);
+    descriptor.setProperty(rt, "writable", true);
+    descriptor.setProperty(rt, "value", std::move(metroRequire_));
+
+    const auto globalObj = rt.global();
+    const auto objectCtor = globalObj.getPropertyAsObject(rt, "Object");
+    const auto defineProperty = objectCtor.getPropertyAsFunction(rt, "defineProperty");
+    defineProperty.call(
+        rt,
+        facebook::jsi::Value(rt, globalObj),
+        facebook::jsi::String::createFromUtf8(rt, kRequireName_),
+        std::move(descriptor));
+  }
+
+  void loadWorkletsEntryPoint(facebook::jsi::Runtime &rt) {
+    const auto require = rt.global().getProperty(rt, kRequireName_).getObject(rt).getFunction(rt);
+    require.call(rt, kWorkletsEntryPointId_);
+  }
+
+  ScriptLoader() = default;
+
+  jsi::Value metroRequire_{};
+
+  static constexpr auto kRequireName_ = "__r";
+  static constexpr auto kWorkletsEntryPointId_ = -2;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,14 @@
+#include <worklets/Compat/StableApi.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+#include <worklets/WorkletRuntime/UIRuntimeDecorator.h>
+
+namespace worklets {
+
+void UIRuntimeDecorator::decorate(
+    facebook::jsi::Runtime &uiRuntime,
+    const std::function<void(facebook::jsi::Runtime &rt, const facebook::jsi::Value &callback)>
+        &requestAnimationFrame) {
+  installRequestAnimationFrame(uiRuntime, requestAnimationFrame);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+namespace worklets {
+
+class UIRuntimeDecorator {
+ public:
+  static void decorate(
+      facebook::jsi::Runtime &uiRuntime,
+      const 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,58 @@
+#include <worklets/Tools/ScriptBuffer.h>
+#include <worklets/WorkletRuntime/WorkletHermesRuntime.h>
+
+#include <jsi/jsi.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+WorkletHermesRuntime::WorkletHermesRuntime(std::unique_ptr<facebook::hermes::HermesRuntime> runtime)
+    : jsi::WithRuntimeDecorator<WorkletsReentrancyCheck>(*runtime, reentrancyCheck_), runtime_(std::move(runtime)) {
+  auto evalBytecode = [](facebook::jsi::Runtime &rt,
+                         const facebook::jsi::Value &,
+                         const facebook::jsi::Value *args,
+                         size_t) -> facebook::jsi::Value {
+    const auto buffer = args[0].getObject(rt).getArrayBuffer(rt);
+    auto data = std::vector<uint8_t>(buffer.data(rt), buffer.data(rt) + buffer.size(rt));
+    return rt.evaluateJavaScript(std::make_shared<BytecodeBuffer>(data), "");
+  };
+  runtime_->global().setProperty(
+      *runtime_,
+      "evalBytecode",
+      facebook::jsi::Function::createFromHostFunction(
+          *runtime_, facebook::jsi::PropNameID::forAscii(*runtime_, "evalBytecode"), 1, evalBytecode));
+
+#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].getString(rt).utf8(rt);
+        }
+        std::shared_ptr<const jsi::Buffer> sourceMap;
+        if (count > 2 && args[2].isString()) {
+          auto sourceMapString = args[2].getString(rt).utf8(rt);
+          if (!sourceMapString.empty()) {
+            sourceMap = std::make_shared<const jsi::StringBuffer>(std::move(sourceMapString));
+          }
+        }
+        return wrappedRuntime->evaluateJavaScriptWithSourceMap(code, sourceMap, sourceURL);
+      });
+  runtime_->global().setProperty(*runtime_, "evalWithSourceMap", evalWithSourceMap);
+#endif // NDEBUG
+}
+
+WorkletHermesRuntime::~WorkletHermesRuntime() = default;
+
+} // namespace worklets

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

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <hermes/hermes.h>
+#include <jsi/decorator.h>
+#include <jsi/jsi.h>
+#include <react/debug/react_native_assert.h>
+
+#include <atomic>
+#include <memory>
+#include <thread>
+
+namespace worklets {
+
+using namespace facebook;
+
+// 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:
+  explicit WorkletHermesRuntime(std::unique_ptr<facebook::hermes::HermesRuntime> runtime);
+  ~WorkletHermesRuntime() override;
+
+ private:
+  std::unique_ptr<facebook::hermes::HermesRuntime> runtime_;
+  WorkletsReentrancyCheck reentrancyCheck_;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,327 @@
+#include <jsi/decorator.h>
+#include <jsi/jsi.h>
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/Tools/JSLogger.h>
+#include <worklets/Tools/WorkletsJSIUtils.h>
+#include <worklets/WorkletRuntime/RuntimeHolder.h>
+#include <worklets/WorkletRuntime/ScriptLoader.h>
+#include <worklets/WorkletRuntime/WorkletHermesRuntime.h>
+#include <worklets/WorkletRuntime/WorkletRuntime.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeCollector.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeDecorator.h>
+
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+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<std::recursive_mutex> &runtimeMutex) {
+  auto hermesRuntime = facebook::hermes::makeHermesRuntime();
+  std::shared_ptr<jsi::Runtime> jsiRuntime = std::make_shared<WorkletHermesRuntime>(std::move(hermesRuntime));
+  return std::make_shared<LockableRuntime>(jsiRuntime, runtimeMutex);
+}
+
+WorkletRuntime::WorkletRuntime(
+    uint64_t runtimeId,
+    const RuntimeData::RuntimeKind runtimeKind,
+    const std::string &name,
+    const std::shared_ptr<AsyncQueue> &queue,
+    bool enableEventLoop)
+    : runtimeId_(runtimeId),
+      runtimeMutex_(std::make_shared<std::recursive_mutex>()),
+      runtime_(makeRuntime(runtimeMutex_)),
+      runtimeKind_(runtimeKind),
+      name_(name),
+      queue_(queue) {
+  jsi::Runtime &rt = *runtime_;
+  WorkletRuntimeCollector::install(rt);
+  if (enableEventLoop) {
+    eventLoop_ = std::make_shared<EventLoop>(name_, runtime_, queue_);
+    eventLoop_->run();
+  }
+}
+
+void WorkletRuntime::init(const std::shared_ptr<JSIWorkletsModuleProxy> &jsiWorkletsModuleProxy) {
+  jsi::Runtime &rt = *runtime_;
+
+  rt.setRuntimeData(
+      RuntimeData::weakRuntimeUUID,
+      std::make_shared<WeakRuntimeHolder>(WeakRuntimeHolder{.weakRuntime = weak_from_this()}));
+
+  const auto jsScheduler = jsiWorkletsModuleProxy->getJSScheduler();
+  jsScheduler_ = jsScheduler;
+  const auto isDevBundle = jsiWorkletsModuleProxy->isDevBundle();
+  const auto memoryManager_ = jsiWorkletsModuleProxy->getMemoryManager();
+  const auto script = jsiWorkletsModuleProxy->getScript();
+  const auto &sourceUrl = jsiWorkletsModuleProxy->getSourceUrl();
+  const auto runtimeBindings = jsiWorkletsModuleProxy->getRuntimeBindings();
+  const auto bundleModeEnabled = jsiWorkletsModuleProxy->isBundleModeEnabled();
+  const auto unpackerLoader = jsiWorkletsModuleProxy->getUnpackerLoader();
+  const auto &nativeLoggingHook = runtimeBindings->nativeLoggingHook;
+
+  WorkletRuntimeDecorator::decorate(
+      rt,
+      runtimeKind_,
+      name_,
+      jsScheduler,
+      isDevBundle,
+      jsiWorkletsModuleProxy->toOptimizedObject(rt),
+      eventLoop_,
+      nativeLoggingHook);
+
+  if (bundleModeEnabled) {
+    bundleModeInit(jsScheduler, script, sourceUrl, runtimeBindings);
+  } else {
+    legacyModeInit(unpackerLoader);
+  }
+
+  try {
+    memoryManager_->loadAllCustomSerializables(shared_from_this());
+  } catch (jsi::JSError &e) {
+    throw std::runtime_error(std::string("[Worklets] Failed to load custom serializables. Reason: ") + e.getMessage());
+  }
+}
+
+void WorkletRuntime::bundleModeInit(
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    const std::shared_ptr<const ScriptBuffer> &script,
+    const std::string &sourceUrl,
+    const std::shared_ptr<RuntimeBindings> &runtimeBindings) {
+  jsi::Runtime &rt = *runtime_;
+
+  if (!script) {
+    throw std::runtime_error("[Worklets] Expected to receive the bundle, but got nullptr instead.");
+  }
+
+  ScriptLoader::loadScript(rt, script, sourceUrl);
+
+  WorkletRuntimeDecorator::postEvaluateScript(rt, runtimeBindings);
+}
+
+void WorkletRuntime::legacyModeInit(const std::shared_ptr<UnpackerLoader> &unpackerLoader) {
+  unpackerLoader->installUnpackers(*runtime_);
+}
+
+/* #region schedule */
+
+void WorkletRuntime::schedule(jsi::Function &&function) const {
+  react_native_assert(
+      queue_ &&
+      "[Worklets] Tried to invoke `schedule` on a Worklet Runtime but the "
+      "async queue is not set. Recreate the runtime with a valid async queue.");
+  queue_->push([function = std::make_shared<jsi::Function>(std::move(function)), weakThis = weak_from_this()]() {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    strongThis->runSync(*function);
+  });
+}
+
+void WorkletRuntime::schedule(std::shared_ptr<SerializableWorklet> worklet) const {
+  react_native_assert(
+      queue_ &&
+      "[Worklets] Tried to invoke `schedule` on a Worklet Runtime but the "
+      "async queue is not set. Recreate the runtime with a valid async queue.");
+
+  queue_->push([worklet = std::move(worklet), weakThis = weak_from_this()] {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    strongThis->runSync(worklet);
+  });
+}
+
+#ifndef NDEBUG
+void WorkletRuntime::schedule(std::shared_ptr<SerializableWorklet> worklet, std::optional<std::string> scheduleStack)
+    const {
+  react_native_assert(
+      queue_ &&
+      "[Worklets] Tried to invoke `schedule` on a Worklet Runtime but the "
+      "async queue is not set. Recreate the runtime with a valid async queue.");
+
+  queue_->push([worklet = std::move(worklet), scheduleStack = std::move(scheduleStack), weakThis = weak_from_this()] {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    strongThis->runSyncWithStack(worklet, scheduleStack);
+  });
+}
+#endif // NDEBUG
+
+void WorkletRuntime::callMicrotasks() const {
+  runSync([](jsi::Runtime &rt) {
+    auto callMicrotasks = rt.global().getProperty(rt, "__callMicrotasks");
+    if (callMicrotasks.isObject()) {
+      auto callMicrotasksObject = callMicrotasks.asObject(rt);
+      if (callMicrotasksObject.isFunction(rt)) {
+        callMicrotasksObject.asFunction(rt).call(rt);
+      }
+    }
+  });
+}
+
+void WorkletRuntime::schedule(std::function<void()> job) const {
+  react_native_assert(
+      queue_ &&
+      "[Worklets] Tried to invoke `schedule` on a Worklet Runtime but the "
+      "async queue is not set. Recreate the runtime with a valid async queue.");
+
+  queue_->push(std::move(job));
+}
+
+void WorkletRuntime::schedule(std::function<void(jsi::Runtime &)> job) const {
+  react_native_assert(
+      queue_ &&
+      "[Worklets] Tried to invoke `schedule` on a Worklet Runtime but the "
+      "async queue is not set. Recreate the runtime with a valid async queue.");
+
+  queue_->push([job = std::move(job), weakThis = weak_from_this()]() {
+    auto strongThis = weakThis.lock();
+    if (!strongThis) {
+      return;
+    }
+
+    auto lock = std::unique_lock<std::recursive_mutex>(*strongThis->runtimeMutex_);
+    jsi::Runtime &runtime = strongThis->getJSIRuntime();
+    job(runtime);
+  });
+}
+
+/* #endregion */
+
+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_);
+  }
+  if (name == "runtimeId") {
+    return jsi::Value(static_cast<double>(runtimeId_));
+  }
+  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"));
+  result.push_back(jsi::PropNameID::forUtf8(rt, "runtimeId"));
+  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->schedule(serializableWorklet);
+}
+
+#ifndef NDEBUG
+void scheduleOnRuntime(
+    jsi::Runtime &rt,
+    const jsi::Value &workletRuntimeValue,
+    const jsi::Value &serializableWorkletValue,
+    const std::optional<std::string> &scheduleStack) {
+  auto workletRuntime = extractWorkletRuntime(rt, workletRuntimeValue);
+  auto serializableWorklet = extractSerializableOrThrow<SerializableWorklet>(
+      rt,
+      serializableWorkletValue,
+      "[Worklets] Function passed to `_scheduleOnRuntime` is not a serializable worklet.");
+  workletRuntime->schedule(serializableWorklet, scheduleStack);
+}
+#endif // NDEBUG
+
+std::weak_ptr<WorkletRuntime> WorkletRuntime::getWeakRuntimeFromJSIRuntime(jsi::Runtime &rt) {
+  auto runtimeData = rt.getRuntimeData(RuntimeData::weakRuntimeUUID);
+  if (!runtimeData) [[unlikely]] {
+    throw std::runtime_error(
+        "[Worklets] No weak runtime data found on the provided JSI runtime."
+        " Perhaps the JSI Runtime is not a WorkletRuntime?");
+  }
+  auto weakHolder = std::static_pointer_cast<WeakRuntimeHolder>(runtimeData);
+  return weakHolder->weakRuntime;
+}
+
+/* #region deprecated */
+
+void WorkletRuntime::runAsyncGuarded(const std::shared_ptr<SerializableWorklet> &worklet) {
+  schedule(worklet);
+}
+
+jsi::Value WorkletRuntime::executeSync(jsi::Runtime &caller, const jsi::Value &worklet) const {
+  auto serializableWorklet = extractSerializableOrThrow<SerializableWorklet>(
+      caller, worklet, "[Worklets] Only worklets can be executed synchronously on UI runtime.");
+  auto result = runSyncSerialized(serializableWorklet);
+  return result->toJSValue(caller);
+}
+
+jsi::Value WorkletRuntime::executeSync(std::function<jsi::Value(jsi::Runtime &)> &&job) const {
+  return runSync(job);
+}
+
+jsi::Value WorkletRuntime::executeSync(const std::function<jsi::Value(jsi::Runtime &)> &job) const {
+  return runSync(job);
+}
+
+/* #endregion */
+
+} // namespace worklets