@react-native-ohos/react-native-reanimated 3.18.2 → 3.18.3-beta.2

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/ReanimatedHermesRuntime.cpp

@@ -1,112 +1,112 @@
-#include <worklets/WorkletRuntime/ReanimatedHermesRuntime.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;
-#if HERMES_ENABLE_DEBUGGER
-using namespace facebook::hermes::inspector_modern;
-#endif // HERMES_ENABLE_DEBUGGER
-
-#if HERMES_ENABLE_DEBUGGER
-
-class HermesExecutorRuntimeAdapter : public RuntimeAdapter {
- 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();
-  }
-
-  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 {}
-
- public:
-  facebook::hermes::HermesRuntime &hermesRuntime_;
-  std::shared_ptr<MessageQueueThread> thread_;
-};
-
-#endif // HERMES_ENABLE_DEBUGGER
-
-ReanimatedHermesRuntime::ReanimatedHermesRuntime(
-    std::unique_ptr<facebook::hermes::HermesRuntime> runtime,
-    const std::shared_ptr<MessageQueueThread> &jsQueue,
-    const std::string &name)
-    : jsi::WithRuntimeDecorator<ReanimatedReentrancyCheck>(
-          *runtime,
-          reentrancyCheck_),
-      runtime_(std::move(runtime)) {
-#if HERMES_ENABLE_DEBUGGER
-  auto adapter =
-      std::make_unique<HermesExecutorRuntimeAdapter>(*runtime_, jsQueue);
-  debugToken_ = chrome::enableDebugging(std::move(adapter), name);
-#else
-  // This is required by iOS, because there is an assertion in the destructor
-  // that the thread was indeed `quit` before
-  jsQueue->quitSynchronous();
-#endif // HERMES_ENABLE_DEBUGGER
-
-#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
-}
-
-ReanimatedHermesRuntime::~ReanimatedHermesRuntime() {
-#if HERMES_ENABLE_DEBUGGER
-  // We have to disable debugging before the runtime is destroyed.
-  chrome::disableDebugging(debugToken_);
-#endif // HERMES_ENABLE_DEBUGGER
-}
-
-} // namespace worklets
-
-#endif // JS_RUNTIME_HERMES
+#include <worklets/WorkletRuntime/ReanimatedHermesRuntime.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;
+#if HERMES_ENABLE_DEBUGGER
+using namespace facebook::hermes::inspector_modern;
+#endif // HERMES_ENABLE_DEBUGGER
+
+#if HERMES_ENABLE_DEBUGGER
+
+class HermesExecutorRuntimeAdapter : public RuntimeAdapter {
+ 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();
+  }
+
+  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 {}
+
+ public:
+  facebook::hermes::HermesRuntime &hermesRuntime_;
+  std::shared_ptr<MessageQueueThread> thread_;
+};
+
+#endif // HERMES_ENABLE_DEBUGGER
+
+ReanimatedHermesRuntime::ReanimatedHermesRuntime(
+    std::unique_ptr<facebook::hermes::HermesRuntime> runtime,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::string &name)
+    : jsi::WithRuntimeDecorator<ReanimatedReentrancyCheck>(
+          *runtime,
+          reentrancyCheck_),
+      runtime_(std::move(runtime)) {
+#if HERMES_ENABLE_DEBUGGER
+  auto adapter =
+      std::make_unique<HermesExecutorRuntimeAdapter>(*runtime_, jsQueue);
+  debugToken_ = chrome::enableDebugging(std::move(adapter), name);
+#else
+  // This is required by iOS, because there is an assertion in the destructor
+  // that the thread was indeed `quit` before
+  jsQueue->quitSynchronous();
+#endif // HERMES_ENABLE_DEBUGGER
+
+#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
+}
+
+ReanimatedHermesRuntime::~ReanimatedHermesRuntime() {
+#if HERMES_ENABLE_DEBUGGER
+  // We have to disable debugging before the runtime is destroyed.
+  chrome::disableDebugging(debugToken_);
+#endif // HERMES_ENABLE_DEBUGGER
+}
+
+} // namespace worklets
+
+#endif // JS_RUNTIME_HERMES

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/ReanimatedHermesRuntime.h

@@ -1,127 +1,127 @@
-#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 <atomic>
-#include <memory>
-#include <string>
-#include <thread>
-
-#if HERMES_ENABLE_DEBUGGER
-#include <hermes/inspector-modern/chrome/Registration.h>
-#endif // HERMES_ENABLE_DEBUGGER
-
-namespace worklets {
-
-using namespace facebook;
-using namespace react;
-#if HERMES_ENABLE_DEBUGGER
-using namespace facebook::hermes::inspector_modern;
-#endif // HERMES_ENABLE_DEBUGGER
-
-// 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 ReanimatedReentrancyCheck {
-  // This is effectively a very subtle and complex assert, so only
-  // include it in builds which would include asserts.
-#ifndef NDEBUG
-  ReanimatedReentrancyCheck() : 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.
-      assert(depth == 0 && "[Reanimated] 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.
-      assert(depth != 0 && "[Reanimated] 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() {
-    assert(
-        tid.load(std::memory_order_relaxed) == std::this_thread::get_id() &&
-        "[Reanimated] 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);
-      assert(didWrite && "[Reanimated] 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: ReanimatedHermesRuntime ->
-// 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 ReanimatedHermesRuntime
-    : public jsi::WithRuntimeDecorator<ReanimatedReentrancyCheck> {
- public:
-  ReanimatedHermesRuntime(
-      std::unique_ptr<facebook::hermes::HermesRuntime> runtime,
-      const std::shared_ptr<MessageQueueThread> &jsQueue,
-      const std::string &name);
-  ~ReanimatedHermesRuntime();
-
- private:
-  std::unique_ptr<facebook::hermes::HermesRuntime> runtime_;
-  ReanimatedReentrancyCheck reentrancyCheck_;
-#if HERMES_ENABLE_DEBUGGER
-  chrome::DebugSessionToken debugToken_;
-#endif // HERMES_ENABLE_DEBUGGER
-};
-
-} // namespace worklets
-
-#endif // JS_RUNTIME_HERMES
+#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 <atomic>
+#include <memory>
+#include <string>
+#include <thread>
+
+#if HERMES_ENABLE_DEBUGGER
+#include <hermes/inspector-modern/chrome/Registration.h>
+#endif // HERMES_ENABLE_DEBUGGER
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+#if HERMES_ENABLE_DEBUGGER
+using namespace facebook::hermes::inspector_modern;
+#endif // HERMES_ENABLE_DEBUGGER
+
+// 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 ReanimatedReentrancyCheck {
+  // This is effectively a very subtle and complex assert, so only
+  // include it in builds which would include asserts.
+#ifndef NDEBUG
+  ReanimatedReentrancyCheck() : 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.
+      assert(depth == 0 && "[Reanimated] 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.
+      assert(depth != 0 && "[Reanimated] 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() {
+    assert(
+        tid.load(std::memory_order_relaxed) == std::this_thread::get_id() &&
+        "[Reanimated] 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);
+      assert(didWrite && "[Reanimated] 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: ReanimatedHermesRuntime ->
+// 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 ReanimatedHermesRuntime
+    : public jsi::WithRuntimeDecorator<ReanimatedReentrancyCheck> {
+ public:
+  ReanimatedHermesRuntime(
+      std::unique_ptr<facebook::hermes::HermesRuntime> runtime,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::string &name);
+  ~ReanimatedHermesRuntime();
+
+ private:
+  std::unique_ptr<facebook::hermes::HermesRuntime> runtime_;
+  ReanimatedReentrancyCheck reentrancyCheck_;
+#if HERMES_ENABLE_DEBUGGER
+  chrome::DebugSessionToken debugToken_;
+#endif // HERMES_ENABLE_DEBUGGER
+};
+
+} // namespace worklets
+
+#endif // JS_RUNTIME_HERMES

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/ReanimatedRuntime.cpp

@@ -1,53 +1,53 @@
-#include <worklets/Tools/Defs.h>
-#include <worklets/WorkletRuntime/ReanimatedRuntime.h>
-
-#include <cxxreact/MessageQueueThread.h>
-#include <jsi/jsi.h>
-
-#include <memory>
-#include <utility>
-
-#if JS_RUNTIME_HERMES
-#include <worklets/WorkletRuntime/ReanimatedHermesRuntime.h>
-#elif JS_RUNTIME_V8
-#include <v8runtime/V8RuntimeFactory.h>
-#else
-#include <jsc/JSCRuntime.h>
-#endif // JS_RUNTIME
-
-namespace worklets {
-
-using namespace facebook;
-using namespace react;
-
-std::shared_ptr<jsi::Runtime> ReanimatedRuntime::make(
-    jsi::Runtime &rnRuntime,
-    const std::shared_ptr<MessageQueueThread> &jsQueue,
-    const std::string &name) {
-  (void)rnRuntime; // used only for V8
-#if JS_RUNTIME_HERMES
-  // We don't call `jsQueue->quitSynchronous()` here, since it will be done
-  // later in ReanimatedHermesRuntime
-
-  auto runtime = facebook::hermes::makeHermesRuntime();
-  return std::make_shared<ReanimatedHermesRuntime>(
-      std::move(runtime), jsQueue, name);
-#elif JS_RUNTIME_V8
-  // This is required by iOS, because there is an assertion in the destructor
-  // that the thread was indeed `quit` before.
-  jsQueue->quitSynchronous();
-
-  auto config = std::make_unique<rnv8::V8RuntimeConfig>();
-  config->enableInspector = false;
-  config->appName = name;
-  return rnv8::createSharedV8Runtime(&rnRuntime, std::move(config));
-#else
-  // This is required by iOS, because there is an assertion in the destructor
-  // that the thread was indeed `quit` before
-  jsQueue->quitSynchronous();
-
-  return facebook::jsc::makeJSCRuntime();
-#endif
-}
-
-} // namespace worklets
+#include <worklets/Tools/Defs.h>
+#include <worklets/WorkletRuntime/ReanimatedRuntime.h>
+
+#include <cxxreact/MessageQueueThread.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <utility>
+
+#if JS_RUNTIME_HERMES
+#include <worklets/WorkletRuntime/ReanimatedHermesRuntime.h>
+#elif JS_RUNTIME_V8
+#include <v8runtime/V8RuntimeFactory.h>
+#else
+#include <jsc/JSCRuntime.h>
+#endif // JS_RUNTIME
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+
+std::shared_ptr<jsi::Runtime> ReanimatedRuntime::make(
+    jsi::Runtime &rnRuntime,
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::string &name) {
+  (void)rnRuntime; // used only for V8
+#if JS_RUNTIME_HERMES
+  // We don't call `jsQueue->quitSynchronous()` here, since it will be done
+  // later in ReanimatedHermesRuntime
+
+  auto runtime = facebook::hermes::makeHermesRuntime();
+  return std::make_shared<ReanimatedHermesRuntime>(
+      std::move(runtime), jsQueue, name);
+#elif JS_RUNTIME_V8
+  // This is required by iOS, because there is an assertion in the destructor
+  // that the thread was indeed `quit` before.
+  jsQueue->quitSynchronous();
+
+  auto config = std::make_unique<rnv8::V8RuntimeConfig>();
+  config->enableInspector = false;
+  config->appName = name;
+  return rnv8::createSharedV8Runtime(&rnRuntime, std::move(config));
+#else
+  // This is required by iOS, because there is an assertion in the destructor
+  // that the thread was indeed `quit` before
+  jsQueue->quitSynchronous();
+
+  return facebook::jsc::makeJSCRuntime();
+#endif
+}
+
+} // namespace worklets

package/harmony/reanimated/src/main/cpp/Common/cpp/worklets/WorkletRuntime/ReanimatedRuntime.h

@@ -1,22 +1,22 @@
-#pragma once
-
-#include <cxxreact/MessageQueueThread.h>
-#include <jsi/jsi.h>
-
-#include <memory>
-#include <string>
-
-namespace worklets {
-
-using namespace facebook;
-using namespace react;
-
-class ReanimatedRuntime {
- public:
-  static std::shared_ptr<jsi::Runtime> make(
-      jsi::Runtime &rnRuntime,
-      const std::shared_ptr<MessageQueueThread> &jsQueue,
-      const std::string &name);
-};
-
-} // namespace worklets
+#pragma once
+
+#include <cxxreact/MessageQueueThread.h>
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+using namespace facebook;
+using namespace react;
+
+class ReanimatedRuntime {
+ public:
+  static std::shared_ptr<jsi::Runtime> make(
+      jsi::Runtime &rnRuntime,
+      const std::shared_ptr<MessageQueueThread> &jsQueue,
+      const std::string &name);
+};
+
+} // namespace worklets