react-native-worklets 0.3.0 → 0.4.0-bundle-mode-preview-1

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

@@ -33,7 +33,7 @@ inline jsi::Value runOnRuntimeGuarded(
   return getCallGuard(rt).call(rt, function, args...);
 #else
   return function.asObject(rt).asFunction(rt).call(rt, args...);
-#endif
+#endif // NDEBUG
 }
 
 inline void cleanupIfRuntimeExists(
@@ -78,12 +78,16 @@ class Shareable {
     StringType,
     ObjectType,
     ArrayType,
+    MapType,
+    SetType,
     WorkletType,
     RemoteFunctionType,
     HandleType,
     HostObjectType,
     HostFunctionType,
     ArrayBufferType,
+    TurboModuleLikeType,
+    ImportType,
   };
 
   explicit Shareable(ValueType valueType) : valueType_(valueType) {}
@@ -157,6 +161,49 @@ jsi::Value makeShareableUndefined(jsi::Runtime &rt);
 
 jsi::Value makeShareableNull(jsi::Runtime &rt);
 
+jsi::Value makeShareableTurboModuleLike(
+    jsi::Runtime &rt,
+    const jsi::Object &object,
+    const std::shared_ptr<jsi::HostObject> &proto);
+
+jsi::Value makeShareableObject(
+    jsi::Runtime &rt,
+    jsi::Object object,
+    bool shouldRetainRemote,
+    const jsi::Value &nativeStateSource);
+
+jsi::Value makeShareableImport(
+    jsi::Runtime &rt,
+    const double source,
+    const jsi::String &imported);
+
+jsi::Value makeShareableHostObject(
+    jsi::Runtime &rt,
+    const std::shared_ptr<jsi::HostObject> &value);
+
+jsi::Value makeShareableArray(
+    jsi::Runtime &rt,
+    const jsi::Array &array,
+    const jsi::Value &shouldRetainRemote);
+
+jsi::Value makeShareableMap(
+    jsi::Runtime &rt,
+    const jsi::Array &keys,
+    const jsi::Array &values);
+
+jsi::Value makeShareableSet(jsi::Runtime &rt, const jsi::Array &values);
+
+jsi::Value makeShareableInitializer(
+    jsi::Runtime &rt,
+    const jsi::Object &initializerObject);
+
+jsi::Value makeShareableFunction(jsi::Runtime &rt, jsi::Function function);
+
+jsi::Value makeShareableWorklet(
+    jsi::Runtime &rt,
+    const jsi::Object &object,
+    const bool &shouldRetainRemote);
+
 std::shared_ptr<Shareable> extractShareableOrThrow(
     jsi::Runtime &rt,
     const jsi::Value &maybeShareableValue,
@@ -203,6 +250,30 @@ class ShareableObject : public Shareable {
   std::shared_ptr<jsi::NativeState> nativeState_;
 };
 
+class ShareableMap : public Shareable {
+ public:
+  ShareableMap(
+      jsi::Runtime &rt,
+      const jsi::Array &keys,
+      const jsi::Array &values);
+
+  jsi::Value toJSValue(jsi::Runtime &rt) override;
+
+ protected:
+  std::vector<std::pair<std::shared_ptr<Shareable>, std::shared_ptr<Shareable>>>
+      data_;
+};
+
+class ShareableSet : public Shareable {
+ public:
+  ShareableSet(jsi::Runtime &rt, const jsi::Array &values);
+
+  jsi::Value toJSValue(jsi::Runtime &rt) override;
+
+ protected:
+  std::vector<std::shared_ptr<Shareable>> data_;
+};
+
 class ShareableHostObject : public Shareable {
  public:
   ShareableHostObject(
@@ -220,9 +291,7 @@ class ShareableHostFunction : public Shareable {
  public:
   ShareableHostFunction(jsi::Runtime &rt, jsi::Function function)
       : Shareable(HostFunctionType),
-        hostFunction_(
-            (assert(function.isHostFunction(rt)),
-             function.getHostFunction(rt))),
+        hostFunction_(function.getHostFunction(rt)),
         name_(function.getProperty(rt, "name").asString(rt).utf8(rt)),
         paramCount_(function.getProperty(rt, "length").asNumber()) {}
 
@@ -258,6 +327,21 @@ class ShareableWorklet : public ShareableObject {
   jsi::Value toJSValue(jsi::Runtime &rt) override;
 };
 
+class ShareableImport : public Shareable {
+ public:
+  ShareableImport(
+      jsi::Runtime &rt,
+      const double source,
+      const jsi::String &imported)
+      : Shareable(ImportType), source_(source), imported_(imported.utf8(rt)) {}
+
+  jsi::Value toJSValue(jsi::Runtime &rt) override;
+
+ protected:
+  const double source_;
+  const std::string imported_;
+};
+
 class ShareableRemoteFunction
     : public Shareable,
       public std::enable_shared_from_this<ShareableRemoteFunction> {
@@ -285,7 +369,7 @@ class ShareableRemoteFunction
   jsi::Value toJSValue(jsi::Runtime &rt) override;
 };
 
-class ShareableHandle : public Shareable {
+class ShareableInitializer : public Shareable {
  private:
   // We don't release the initializer since the handle can get
   // initialized in parallel on multiple threads. However this is not a problem,
@@ -297,12 +381,12 @@ class ShareableHandle : public Shareable {
   jsi::Runtime *remoteRuntime_;
 
  public:
-  ShareableHandle(jsi::Runtime &rt, const jsi::Object &initializerObject)
+  ShareableInitializer(jsi::Runtime &rt, const jsi::Object &initializerObject)
       : Shareable(HandleType),
         initializer_(std::make_unique<ShareableObject>(rt, initializerObject)) {
   }
 
-  ~ShareableHandle() {
+  ~ShareableInitializer() {
     cleanupIfRuntimeExists(remoteRuntime_, remoteValue_);
   }
 
@@ -354,4 +438,21 @@ class ShareableScalar : public Shareable {
   Data data_;
 };
 
+class ShareableTurboModuleLike : public Shareable {
+ public:
+  ShareableTurboModuleLike(
+      jsi::Runtime &rt,
+      const jsi::Object &object,
+      const std::shared_ptr<jsi::HostObject> &proto)
+      : Shareable(TurboModuleLikeType),
+        proto_(std::make_unique<ShareableHostObject>(rt, proto)),
+        properties_(std::make_unique<ShareableObject>(rt, object)) {}
+
+  jsi::Value toJSValue(jsi::Runtime &rt) override;
+
+ private:
+  const std::unique_ptr<ShareableHostObject> proto_;
+  const std::unique_ptr<ShareableObject> properties_;
+};
+
 } // namespace worklets

package/Common/cpp/worklets/Tools/JSLogger.cpp

@@ -1,16 +1,68 @@
 #include <worklets/Tools/JSLogger.h>
+
 #include <memory>
+#include <utility>
 
 namespace worklets {
 
 void JSLogger::warnOnJS(const std::string &warning) const {
 #ifndef NDEBUG
-  jsScheduler_->scheduleOnJS([warning](jsi::Runtime &rt) {
-    auto console = rt.global().getPropertyAsObject(rt, "console");
-    auto warn = console.getPropertyAsFunction(rt, "warn");
-    warn.call(rt, jsi::String::createFromUtf8(rt, warning));
+  jsScheduler_->scheduleOnJS([warning](jsi::Runtime &rnRuntime) {
+    auto console = rnRuntime.global().getPropertyAsObject(rnRuntime, "console");
+    auto warn = console.getPropertyAsFunction(rnRuntime, "warn");
+    warn.call(rnRuntime, jsi::String::createFromUtf8(rnRuntime, warning));
   });
 #endif // NDEBUG
 }
 
+void JSLogger::reportFatalErrorOnJS(
+    const std::shared_ptr<JSScheduler> &jsScheduler,
+    JSErrorData &&jsErrorData,
+    bool force) {
+  auto job = [jsErrorData = std::move(jsErrorData),
+              force](jsi::Runtime &rnRuntime) {
+    reportFatalErrorOnJS(rnRuntime, jsErrorData, force);
+  };
+  if (jsScheduler->canInvokeSyncOnJS()) {
+    jsScheduler->invokeSyncOnJS(job);
+  } else {
+    jsScheduler->scheduleOnJS(job);
+  }
+}
+
+void JSLogger::reportFatalErrorOnJS(
+    jsi::Runtime &rnRuntime,
+    const JSErrorData &jsErrorData,
+    bool force) {
+  const auto &global = rnRuntime.global();
+  const auto errorInstance = rnRuntime.global()
+                                 .getPropertyAsFunction(rnRuntime, "Error")
+                                 .callAsConstructor(rnRuntime)
+                                 .asObject(rnRuntime);
+
+  errorInstance.setProperty(
+      rnRuntime,
+      "message",
+      jsi::String::createFromUtf8(rnRuntime, jsErrorData.message));
+
+  errorInstance.setProperty(
+      rnRuntime,
+      "stack",
+      jsi::String::createFromUtf8(rnRuntime, jsErrorData.stack));
+
+  errorInstance.setProperty(
+      rnRuntime,
+      "name",
+      jsi::String::createFromUtf8(rnRuntime, jsErrorData.name));
+
+  errorInstance.setProperty(
+      rnRuntime,
+      "jsEngine",
+      jsi::String::createFromUtf8(rnRuntime, jsErrorData.jsEngine));
+
+  const auto &reportFatalErrorFunction =
+      global.getPropertyAsFunction(rnRuntime, "__reportFatalRemoteError");
+  reportFatalErrorFunction.call(rnRuntime, errorInstance, force);
+}
+
 } // namespace worklets

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

@@ -7,13 +7,30 @@
 
 namespace worklets {
 
+struct JSErrorData {
+  std::string message;
+  std::string stack;
+  std::string name;
+  std::string jsEngine;
+};
+
 class JSLogger {
  public:
   explicit JSLogger(const std::shared_ptr<JSScheduler> &jsScheduler)
       : jsScheduler_(jsScheduler) {}
   void warnOnJS(const std::string &warning) const;
 
+  static void reportFatalErrorOnJS(
+      const std::shared_ptr<JSScheduler> &jsScheduler,
+      JSErrorData &&jsErrorData,
+      bool force = false);
+
  private:
+  static void reportFatalErrorOnJS(
+      jsi::Runtime &rnRuntime,
+      const JSErrorData &jsErrorData,
+      bool force = false);
+
   const std::shared_ptr<JSScheduler> jsScheduler_;
 };
 

package/Common/cpp/worklets/Tools/JSScheduler.cpp

@@ -1,3 +1,4 @@
+#include <react/debug/react_native_assert.h>
 #include <worklets/Tools/JSScheduler.h>
 
 #include <utility>
@@ -9,4 +10,15 @@ void JSScheduler::scheduleOnJS(Job job) {
       [job = std::move(job), &rt = rnRuntime_] { job(rt); });
 }
 
+bool JSScheduler::canInvokeSyncOnJS() {
+  return isJavaScriptQueue_();
+}
+
+void JSScheduler::invokeSyncOnJS(Job job) {
+  react_native_assert(
+      canInvokeSyncOnJS() &&
+      "JSScheduler::invokeSyncOnJS should only be called from the JS thread");
+  job(rnRuntime_);
+}
+
 } // namespace worklets

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

@@ -16,14 +16,22 @@ class JSScheduler {
  public:
   explicit JSScheduler(
       jsi::Runtime &rnRuntime,
-      const std::shared_ptr<CallInvoker> &jsCallInvoker)
-      : rnRuntime_(rnRuntime), jsCallInvoker_(jsCallInvoker) {}
+      const std::shared_ptr<CallInvoker> &jsCallInvoker,
+      std::function<bool()> &&isJavaScriptQueue)
+      : rnRuntime_(rnRuntime),
+        jsCallInvoker_(jsCallInvoker),
+        isJavaScriptQueue_(isJavaScriptQueue) {}
 
   void scheduleOnJS(std::function<void(jsi::Runtime &rt)> job);
 
+  void invokeSyncOnJS(std::function<void(jsi::Runtime &rt)> job);
+
+  bool canInvokeSyncOnJS();
+
  protected:
   jsi::Runtime &rnRuntime_;
   const std::shared_ptr<CallInvoker> jsCallInvoker_;
+  const std::function<bool()> isJavaScriptQueue_;
 };
 
 } // namespace worklets

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

@@ -2,6 +2,8 @@
 
 #ifndef NDEBUG
 
+#include <react/debug/react_native_assert.h>
+
 #include <cxxabi.h>
 
 #include <atomic>
@@ -35,7 +37,7 @@ class SingleInstanceChecker {
 #endif
 
 #ifdef IS_REANIMATED_EXAMPLE_APP
-      assert(false);
+      react_native_assert(false && "SingleInstanceChecker failed");
 #endif
     }
   }

package/Common/cpp/worklets/Tools/WorkletsJSIUtils.cpp

@@ -1,4 +1,9 @@
 #include <worklets/Tools/WorkletsJSIUtils.h>
+
+#include <react/debug/react_native_assert.h>
+
+#include <memory>
+#include <sstream>
 #include <vector>
 
 using namespace facebook;
@@ -15,7 +20,9 @@ jsi::Array convertStringToArray(
       std::istream_iterator<float>(stringStream),
       std::istream_iterator<float>(),
       std::back_inserter(transformMatrixList));
-  assert(transformMatrixList.size() == expectedSize);
+  react_native_assert(
+      transformMatrixList.size() == expectedSize &&
+      "Transform matrix list size is different than expected");
   jsi::Array matrix(rt, expectedSize);
   for (unsigned int i = 0; i < expectedSize; i++) {
     matrix.setValueAtIndex(rt, i, transformMatrixList[i]);
@@ -23,4 +30,15 @@ jsi::Array convertStringToArray(
   return matrix;
 }
 
+jsi::Object optimizedFromHostObject(
+    jsi::Runtime &rt,
+    std::shared_ptr<jsi::HostObject> &&hostObject) {
+  auto optimizedObject = jsi::Object(rt);
+  for (const auto &propertyName : hostObject->getPropertyNames(rt)) {
+    optimizedObject.setProperty(
+        rt, propertyName, hostObject->get(rt, propertyName));
+  }
+  return optimizedObject;
+}
+
 } // namespace worklets::jsi_utils

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

@@ -1,7 +1,8 @@
 #pragma once
 
 #include <jsi/jsi.h>
-#include <sstream>
+#include <react/debug/react_native_assert.h>
+#include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
@@ -83,7 +84,9 @@ std::tuple<Args...> getArgsForFunction(
     jsi::Runtime &rt,
     const jsi::Value *args,
     const size_t count) {
-  assert(sizeof...(Args) == count);
+  react_native_assert(
+      sizeof...(Args) == count &&
+      "Argument list has different length than expected");
   return convertArgs<Args...>(rt, args);
 }
 
@@ -96,7 +99,9 @@ std::tuple<jsi::Runtime &, Args...> getArgsForFunction(
     jsi::Runtime &rt,
     const jsi::Value *args,
     const size_t count) {
-  assert(sizeof...(Args) == count);
+  react_native_assert(
+      sizeof...(Args) == count &&
+      "Argument list has different length than expected");
   return std::tuple_cat(std::tie(rt), convertArgs<Args...>(rt, args));
 }
 
@@ -196,4 +201,8 @@ jsi::Array convertStringToArray(
     const std::string &value,
     const unsigned int expectedSize);
 
+jsi::Object optimizedFromHostObject(
+    jsi::Runtime &rt,
+    std::shared_ptr<jsi::HostObject> &&hostObject);
+
 } // namespace worklets::jsi_utils

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

@@ -0,0 +1,136 @@
+#pragma once
+#include <string>
+#include <vector>
+
+#ifdef WORKLETS_PROFILING
+
+#if defined(__APPLE__)
+#include <os/trace_base.h>
+
+#if OS_LOG_TARGET_HAS_10_15_FEATURES
+#include <os/log.h>
+#include <os/signpost.h>
+#include <sstream>
+#endif // OS_LOG_TARGET_HAS_10_15_FEATURES
+
+#elif defined(ANDROID)
+
+#include <android/trace.h>
+
+#endif // defined(ANDROID)
+
+#endif // WORKLETS_PROFILING
+
+namespace worklets {
+
+#if defined(ANDROID) && defined(WORKLETS_PROFILING)
+
+// avg 6.10 min 2.87 max 7.68 dev 0.42
+// avg 6.09 min 3.29 max 8.62 dev 0.50
+
+struct WorkletsSystraceSection {
+ public:
+  template <typename... ConvertsToStringPiece>
+  explicit WorkletsSystraceSection(
+      const char *name,
+      ConvertsToStringPiece &&...args) {
+    ATrace_beginSection(name);
+  }
+
+  ~WorkletsSystraceSection() {
+    ATrace_endSection();
+  }
+};
+
+// The apple part is copied from React Native
+// from
+// https://github.com/facebook/react-native/blob/5697d923a05119314b4cfcd556cb243986637764/packages/react-native/ReactCommon/cxxreact/SystraceSection.h
+#elif defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES && \
+    defined(WORKLETS_PROFILING)
+
+template <typename T, typename = void>
+struct renderer {
+  static std::string render(const T &t) {
+    std::ostringstream oss;
+    oss << t;
+    return oss.str();
+  }
+};
+
+template <typename T>
+static auto render(const T &t)
+    -> decltype(renderer<T>::render(std::declval<const T &>())) {
+  return renderer<T>::render(t);
+}
+
+inline os_log_t instrumentsLogHandle = nullptr;
+
+static inline os_log_t getOrCreateInstrumentsLogHandle() {
+  if (!instrumentsLogHandle) {
+    instrumentsLogHandle = os_log_create(
+        "dev.worklets.instruments", OS_LOG_CATEGORY_POINTS_OF_INTEREST);
+  }
+  return instrumentsLogHandle;
+}
+
+struct WorkletsSystraceSection {
+ public:
+  template <typename... ConvertsToStringPiece>
+  explicit WorkletsSystraceSection(
+      const char *name,
+      ConvertsToStringPiece &&...args) {
+    os_log_t instrumentsLogHandle = worklets::getOrCreateInstrumentsLogHandle();
+
+    // If the log isn't enabled, we don't want the performance overhead of the
+    // rest of the code below.
+    if (!os_signpost_enabled(instrumentsLogHandle)) {
+      return;
+    }
+
+    name_ = name;
+
+    const auto argsVector = std::vector<std::string>{worklets::render(args)...};
+    std::string argsString = "";
+    for (size_t i = 0; i < argsVector.size(); i += 2) {
+      argsString += argsVector[i] + "=" + argsVector[i + 1] + ";";
+    }
+
+    signpostID_ = os_signpost_id_make_with_pointer(instrumentsLogHandle, this);
+
+    os_signpost_interval_begin(
+        instrumentsLogHandle,
+        signpostID_,
+        "Worklets",
+        "%s begin: %s",
+        name,
+        argsString.c_str());
+  }
+
+  ~WorkletsSystraceSection() {
+    os_signpost_interval_end(
+        worklets::instrumentsLogHandle,
+        signpostID_,
+        "Worklets",
+        "%s end",
+        name_.data());
+  }
+
+ private:
+  os_signpost_id_t signpostID_ = OS_SIGNPOST_ID_INVALID;
+  std::string_view name_;
+};
+
+#else
+
+struct WorkletsSystraceSection {
+ public:
+  template <typename... ConvertsToStringPiece>
+  explicit WorkletsSystraceSection(
+      const char *name,
+      ConvertsToStringPiece &&...args) {}
+};
+
+#endif // defined(__APPLE__) && OS_LOG_TARGET_HAS_10_15_FEATURES &&
+       // defined(WORKLETS_PROFILING)
+
+} // namespace worklets

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

@@ -1,11 +1,13 @@
 #include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
 #include <worklets/WorkletRuntime/WorkletRuntimeCollector.h>
 
+#include <utility>
+
 namespace worklets {
 
 void RNRuntimeWorkletDecorator::decorate(
     jsi::Runtime &rnRuntime,
-    const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy) {
+    jsi::Object &&jsiWorkletsModuleProxy) {
   rnRuntime.global().setProperty(rnRuntime, "_WORKLET", false);
 
   // TODO: Remove _IS_FABRIC sometime in the future
@@ -13,9 +15,7 @@ void RNRuntimeWorkletDecorator::decorate(
   rnRuntime.global().setProperty(rnRuntime, "_IS_FABRIC", true);
 
   rnRuntime.global().setProperty(
-      rnRuntime,
-      "__workletsModuleProxy",
-      jsi::Object::createFromHostObject(rnRuntime, workletsModuleProxy));
+      rnRuntime, "__workletsModuleProxy", std::move(jsiWorkletsModuleProxy));
 
   WorkletRuntimeCollector::install(rnRuntime);
 }

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

@@ -13,7 +13,7 @@ class RNRuntimeWorkletDecorator {
  public:
   static void decorate(
       jsi::Runtime &rnRuntime,
-      const std::shared_ptr<WorkletsModuleProxy> &workletsModuleProxy);
+      jsi::Object &&jsiWorkletsModuleProxy);
 };
 
 } // namespace worklets

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

@@ -0,0 +1,85 @@
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/WorkletRuntime/RuntimeManager.h>
+
+#include <utility>
+
+namespace worklets {
+
+const std::string uiRuntimeName{"UI"};
+
+std::shared_ptr<WorkletRuntime> RuntimeManager::getRuntime(uint64_t runtimeId) {
+  std::shared_lock lock(weakRuntimesMutex_);
+  if (weakRuntimes_.contains(runtimeId)) {
+    return weakRuntimes_.at(runtimeId).lock();
+  }
+  return nullptr;
+}
+
+std::shared_ptr<WorkletRuntime> RuntimeManager::getRuntime(
+    const std::string &name) {
+  std::shared_lock lock(weakRuntimesMutex_);
+  if (nameToRuntimeId_.contains(name)) {
+    return getRuntime(nameToRuntimeId_.at(name));
+  }
+  return nullptr;
+}
+
+std::vector<std::shared_ptr<WorkletRuntime>> RuntimeManager::getAllRuntimes() {
+  std::shared_lock lock(weakRuntimesMutex_);
+
+  std::vector<std::shared_ptr<WorkletRuntime>> runtimes;
+  runtimes.reserve(weakRuntimes_.size());
+
+  for (const auto &[id, weakRuntime] : weakRuntimes_) {
+    if (auto runtime = weakRuntime.lock()) {
+      runtimes.push_back(runtime);
+    }
+  }
+
+  return runtimes;
+}
+
+std::shared_ptr<WorkletRuntime> RuntimeManager::getUIRuntime() {
+  return getRuntime(uiRuntimeId);
+}
+
+std::shared_ptr<WorkletRuntime> RuntimeManager::createWorkletRuntime(
+    std::shared_ptr<JSIWorkletsModuleProxy> jsiWorkletsModuleProxy,
+    const bool supportsLocking,
+    const std::string &name,
+    std::shared_ptr<ShareableWorklet> initializer) {
+  const auto runtimeId = getNextRuntimeId();
+  const auto jsQueue = jsiWorkletsModuleProxy->getJSQueue();
+
+  auto workletRuntime = std::make_shared<WorkletRuntime>(
+      runtimeId, jsQueue, name, true /* supportsLocking */
+  );
+
+  workletRuntime->init(std::move(jsiWorkletsModuleProxy));
+
+  if (initializer) {
+    workletRuntime->runGuarded(initializer);
+  }
+
+  std::unique_lock lock(weakRuntimesMutex_);
+  weakRuntimes_[runtimeId] = workletRuntime;
+  nameToRuntimeId_[name] = runtimeId;
+
+  return workletRuntime;
+}
+
+std::shared_ptr<WorkletRuntime> RuntimeManager::createUninitializedUIRuntime(
+    const std::shared_ptr<MessageQueueThread> &jsQueue) {
+  const auto uiRuntime = std::make_shared<WorkletRuntime>(
+      uiRuntimeId, jsQueue, uiRuntimeName, true /* supportsLocking */
+  );
+  std::unique_lock lock(weakRuntimesMutex_);
+  weakRuntimes_[uiRuntimeId] = uiRuntime;
+  return uiRuntime;
+}
+
+uint64_t RuntimeManager::getNextRuntimeId() {
+  return nextRuntimeId_.fetch_add(1, std::memory_order_relaxed);
+}
+
+} // namespace worklets