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

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

@@ -0,0 +1,116 @@
+#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/Tools/WorkletsVersion.cpp

@@ -0,0 +1,46 @@
+#include <worklets/Tools/JSLogger.h>
+#include <worklets/Tools/VersionUtils.h>
+#include <worklets/Tools/WorkletsVersion.h>
+
+#include <memory>
+#include <string>
+
+#ifdef WORKLETS_VERSION
+#define STRINGIZE(x) #x
+#define STRINGIZE2(x) STRINGIZE(x)
+#define WORKLETS_VERSION_STRING STRINGIZE2(WORKLETS_VERSION)
+#endif // WORKLETS_VERSION
+
+using namespace facebook;
+
+namespace worklets {
+
+std::string getWorkletsCppVersion() {
+  return std::string(WORKLETS_VERSION_STRING);
+}
+
+void injectWorkletsCppVersion(jsi::Runtime &rnRuntime) {
+  auto version = getWorkletsCppVersion();
+  rnRuntime.global().setProperty(rnRuntime, "_WORKLETS_VERSION_CPP", jsi::String::createFromUtf8(rnRuntime, version));
+}
+
+#ifndef NDEBUG
+void checkJSVersion(jsi::Runtime &rnRuntime, const std::shared_ptr<worklets::JSLogger> &jsLogger) {
+  auto cppVersion = getWorkletsCppVersion();
+  auto jsVersionValue = rnRuntime.global().getProperty(rnRuntime, "_WORKLETS_VERSION_JS");
+  worklets::checkJSVersion(
+      rnRuntime,
+      jsVersionValue,
+      jsLogger,
+      cppVersion,
+      "Worklets",
+      "https://docs.swmansion.com/react-native-worklets/docs");
+}
+#else
+void checkJSVersion(jsi::Runtime &rnRuntime, const std::shared_ptr<worklets::JSLogger> &jsLogger) {
+  // In release builds we don't check the version, hence
+  // this function is a NOOP.
+}
+#endif // NDEBUG
+
+}; // namespace worklets

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

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <worklets/Tools/JSLogger.h>
+
+#include <jsi/jsi.h>
+
+#include <memory>
+#include <string>
+
+using namespace facebook;
+
+namespace worklets {
+
+std::string getWorkletsCppVersion();
+void injectWorkletsCppVersion(jsi::Runtime &);
+void checkJSVersion(jsi::Runtime &, const std::shared_ptr<worklets::JSLogger> &);
+
+}; // namespace worklets

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

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/Tools/ScriptBuffer.h>
+
+#include <memory>
+#include <string>
+
+namespace worklets {
+
+struct BundleModeConfig {
+  bool enabled;
+  std::shared_ptr<const ScriptBuffer> script;
+  std::string sourceURL;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,45 @@
+#include <worklets/WorkletRuntime/HermesProfiling.h>
+
+#include <hermes/hermes.h>
+
+#include <chrono>
+#include <filesystem>
+#include <sstream>
+#include <string>
+
+namespace worklets {
+
+static std::string generateUniqueProfilePath() {
+  auto now = std::chrono::steady_clock::now().time_since_epoch().count();
+  std::ostringstream oss;
+  oss << "profile-" << now << ".cpuprofile";
+  std::filesystem::path dir = std::filesystem::temp_directory_path();
+  return (dir / oss.str()).string();
+}
+
+void startProfiling(facebook::jsi::Runtime &rt, double meanHzFreq) {
+  auto *ihermes = facebook::jsi::castInterface<facebook::hermes::IHermes>(&rt);
+  if (ihermes) {
+    ihermes->registerForProfiling();
+  }
+  auto *api = facebook::jsi::castInterface<facebook::hermes::IHermesRootAPI>(facebook::hermes::makeHermesRootAPI());
+  if (api) {
+    api->enableSamplingProfiler(meanHzFreq);
+  }
+}
+
+std::string stopProfiling(facebook::jsi::Runtime &rt) {
+  std::string path = generateUniqueProfilePath();
+  auto *api = facebook::jsi::castInterface<facebook::hermes::IHermesRootAPI>(facebook::hermes::makeHermesRootAPI());
+  if (api) {
+    api->dumpSampledTraceToFile(path);
+    api->disableSamplingProfiler();
+  }
+  auto *ihermes = facebook::jsi::castInterface<facebook::hermes::IHermes>(&rt);
+  if (ihermes) {
+    ihermes->unregisterForProfiling();
+  }
+  return path;
+}
+
+} // namespace worklets

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

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <string>
+
+namespace worklets {
+
+void startProfiling(facebook::jsi::Runtime &rt, double meanHzFreq);
+std::string stopProfiling(facebook::jsi::Runtime &rt);
+
+} // namespace worklets

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

@@ -0,0 +1,68 @@
+#include <worklets/Tools/WorkletsJSIUtils.h>
+#include <worklets/Tools/WorkletsVersion.h>
+#include <worklets/WorkletRuntime/HermesProfiling.h>
+#include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeCollector.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace worklets {
+
+void RNRuntimeWorkletDecorator::decorate(
+    jsi::Runtime &rnRuntime,
+    jsi::Object &&jsiWorkletsModuleProxy,
+    const std::shared_ptr<JSLogger> &jsLogger) {
+  rnRuntime.global().setProperty(
+      rnRuntime, RuntimeData::runtimeKindBindingName, static_cast<int>(RuntimeData::RuntimeKind::ReactNative));
+
+  rnRuntime.global().setProperty(
+      rnRuntime,
+      RuntimeData::runtimeNameBindingName,
+      jsi::String::createFromUtf8(rnRuntime, RuntimeData::rnRuntimeName));
+
+  rnRuntime.global().setProperty(rnRuntime, "_WORKLET", false);
+
+  rnRuntime.global().setProperty(rnRuntime, "__workletsModuleProxy", std::move(jsiWorkletsModuleProxy));
+
+  WorkletRuntimeCollector::install(rnRuntime);
+
+#ifndef NDEBUG
+  checkJSVersion(rnRuntime, jsLogger);
+#endif // NDEBUG
+
+#ifdef IS_REANIMATED_EXAMPLE_APP
+  installDebugBindings(rnRuntime);
+#endif // IS_REANIMATED_EXAMPLE_APP
+
+  injectWorkletsCppVersion(rnRuntime);
+
+  rnRuntime.global().setProperty(
+      rnRuntime,
+      "_startProfiling",
+      jsi::Function::createFromHostFunction(
+          rnRuntime,
+          jsi::PropNameID::forAscii(rnRuntime, "_startProfiling"),
+          1,
+          [](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) {
+            const double meanHzFreq = (count > 0 && !args[0].isUndefined()) ? args[0].asNumber() : 100.0;
+            startProfiling(rt, meanHzFreq);
+            return jsi::Value::undefined();
+          }));
+
+  jsi_utils::installJsiFunction(rnRuntime, "_stopProfiling", [](jsi::Runtime &rt) {
+    std::string path = stopProfiling(rt);
+    return jsi::String::createFromUtf8(rt, path);
+  });
+}
+
+#ifdef IS_REANIMATED_EXAMPLE_APP
+void RNRuntimeWorkletDecorator::installDebugBindings(jsi::Runtime &rnRuntime) {
+  jsi_utils::installJsiFunction(rnRuntime, "__hasNativeState", [](jsi::Runtime &rt, const jsi::Value &value) {
+    return jsi::Value(value.isObject() && value.asObject(rt).hasNativeState(rt));
+  });
+}
+#endif // IS_REANIMATED_EXAMPLE_APP
+
+} // namespace worklets

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

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <worklets/NativeModules/WorkletsModuleProxy.h>
+#include <worklets/Tools/JSLogger.h>
+#include <memory>
+
+using namespace facebook;
+
+namespace worklets {
+
+class RNRuntimeWorkletDecorator {
+  // TODO: Rename to `RNRuntimeWorkletsDecorator` or something more suitable.
+ public:
+  static void
+  decorate(jsi::Runtime &rnRuntime, jsi::Object &&jsiWorkletsModuleProxy, const std::shared_ptr<JSLogger> &jsLogger);
+
+#ifdef IS_REANIMATED_EXAMPLE_APP
+ private:
+  static void installDebugBindings(jsi::Runtime &rnRuntime);
+#endif // IS_REANIMATED_EXAMPLE_APP
+};
+
+} // namespace worklets

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

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <functional>
+#include <stdexcept>
+
+using namespace facebook;
+
+namespace worklets {
+
+struct RuntimeBindings {
+  using RequestAnimationFrame = std::function<void(std::function<void(const double)>)>;
+  // Host function extracted from RN runtime's `global.nativeLoggingHook`, used
+  // to forward logs from Worklet runtimes to the native console in Bundle Mode.
+  // Signature:
+  //   jsi::Value(jsi::Runtime &rt, const jsi::Value &thisVal,
+  //              const jsi::Value *args, size_t count)
+  // where args[0] is the message string and args[1] is the log level (double).
+  // https://github.com/facebook/react-native/blob/654d64655ab3e3319fdfd4bfbe1c19c0b1233ff8/packages/react-native/ReactCommon/jsitooling/react/runtime/JSRuntimeBindings.cpp
+  using NativeLoggingHook = jsi::HostFunctionType;
+
+  const RequestAnimationFrame requestAnimationFrame;
+  const NativeLoggingHook nativeLoggingHook;
+
+#ifdef WORKLETS_FETCH_PREVIEW_ENABLED
+  using AbortRequest = std::function<void(jsi::Runtime &rt, double requestId)>;
+  using ClearCookies = std::function<void(jsi::Runtime &rt, jsi::Function &&responseSender)>;
+#ifdef ANDROID
+  using SendRequest = std::function<void(
+      jsi::Runtime &rt,
+      jsi::String &method,
+      jsi::String &url,
+      double requestId,
+      jsi::Array &headers,
+      jsi::Object &data,
+      jsi::String &responseType,
+      bool incrementalUpdates,
+      double timeout,
+      bool withCredentials)>;
+#else
+  using SendRequest = std::function<void(jsi::Runtime &rt, const jsi::Value &query, jsi::Function &&responseSender)>;
+#endif // ANDROID
+
+  const AbortRequest abortRequest;
+  const ClearCookies clearCookies;
+  const SendRequest sendRequest;
+#endif // WORKLETS_FETCH_PREVIEW_ENABLED
+};
+
+inline RuntimeBindings::NativeLoggingHook extractNativeLoggingHookFromRNRuntime(jsi::Runtime &rnRuntime) {
+  auto nativeLoggingHookValue = rnRuntime.global().getProperty(rnRuntime, "nativeLoggingHook");
+  if (!nativeLoggingHookValue.isObject() || !nativeLoggingHookValue.asObject(rnRuntime).isFunction(rnRuntime)) {
+    throw std::runtime_error("[Worklets] nativeLoggingHook is missing.");
+  }
+  return nativeLoggingHookValue.asObject(rnRuntime).asFunction(rnRuntime).getHostFunction(rnRuntime);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <cstdint>
+
+namespace worklets {
+namespace RuntimeData {
+
+/**
+ * Represents the different types of runtime environments available for
+ * worklets.
+ */
+enum class RuntimeKind : std::uint8_t {
+  ReactNative = 1,
+  UI = 2,
+  Worker = 3,
+};
+
+constexpr auto runtimeKindBindingName = "__RUNTIME_KIND";
+
+using RuntimeId = uint64_t;
+
+/**
+ * Unused, but kept for possible future use.
+ */
+constexpr RuntimeId rnRuntimeId{static_cast<RuntimeId>(RuntimeKind::ReactNative)};
+constexpr RuntimeId uiRuntimeId{static_cast<RuntimeId>(RuntimeKind::UI)};
+
+constexpr facebook::jsi::UUID weakRuntimeUUID{0x770c6f2e, 0x1e4d, 0x436a, 0xa2b1, 0x9f322c8d5f5e};
+
+constexpr const char *rnRuntimeName = "RN";
+constexpr const char *uiRuntimeName = "UI";
+constexpr const char *runtimeNameBindingName = "__RUNTIME_NAME";
+
+}; // namespace RuntimeData
+
+} // namespace worklets

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

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <memory>
+
+namespace worklets {
+
+class WorkletRuntime;
+
+/**
+ * Holds a weak reference to a WorkletRuntime instance.
+ *
+ * Used to link jsi::Runtime instances back to their WorkletRuntime holders
+ * without inducing reference cycles.
+ */
+struct WeakRuntimeHolder {
+  std::weak_ptr<WorkletRuntime> weakRuntime;
+};
+
+} // namespace worklets

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

@@ -0,0 +1,122 @@
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/WorkletRuntime/RuntimeData.h>
+#include <worklets/WorkletRuntime/RuntimeManager.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+#ifndef NDEBUG
+namespace {
+void evaluateModuleUpdate(
+    const std::shared_ptr<WorkletRuntime> &workletRuntime,
+    const std::string &code,
+    const std::string &sourceUrl) {
+  workletRuntime->runSync([&code, &sourceUrl](jsi::Runtime &rt) -> void {
+    const auto buffer = std::make_shared<jsi::StringBuffer>(code);
+    rt.evaluateJavaScript(buffer, sourceUrl);
+  });
+}
+} // namespace
+#endif // NDEBUG
+
+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::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(RuntimeData::uiRuntimeId);
+}
+
+std::shared_ptr<WorkletRuntime> RuntimeManager::createWorkletRuntime(
+    const std::shared_ptr<const JSIWorkletsModuleProxy> &sourceProxy,
+    const std::string &name,
+    const std::shared_ptr<SerializableWorklet> &initializer,
+    const std::shared_ptr<AsyncQueue> &queue,
+    bool enableEventLoop) {
+  const auto runtimeId = getNextRuntimeId();
+
+  const auto workletRuntime =
+      std::make_shared<WorkletRuntime>(runtimeId, RuntimeData::RuntimeKind::Worker, name, queue, enableEventLoop);
+  const auto targetProxy = JSIWorkletsModuleProxy::createForNewRuntime(sourceProxy, runtimeId);
+
+  workletRuntime->init(targetProxy);
+
+#ifndef NDEBUG
+  withRegistrationPaused([&] { loadModuleUpdates(workletRuntime); });
+#endif // NDEBUG
+
+  if (initializer) {
+    workletRuntime->runSync(initializer);
+  }
+
+  registerRuntime(runtimeId, workletRuntime);
+
+  return workletRuntime;
+}
+
+#ifndef NDEBUG
+void RuntimeManager::propagateModuleUpdate(const std::string &code, const std::string &sourceUrl) {
+  std::unique_lock registrationLock(registrationMutex_);
+
+  moduleUpdates_.push_back(ModuleUpdate{.sourceUrl = sourceUrl, .code = code});
+
+  for (const auto &runtime : getAllRuntimes()) {
+    evaluateModuleUpdate(runtime, code, sourceUrl);
+  }
+}
+
+void RuntimeManager::loadModuleUpdates(const std::shared_ptr<WorkletRuntime> &workletRuntime) {
+  for (const auto &update : moduleUpdates_) {
+    evaluateModuleUpdate(workletRuntime, update.code, update.sourceUrl);
+  }
+}
+#endif // NDEBUG
+
+std::shared_ptr<WorkletRuntime> RuntimeManager::createUninitializedUIRuntime(
+    const std::shared_ptr<AsyncQueue> &uiAsyncQueue) {
+  const auto uiRuntime = std::make_shared<WorkletRuntime>(
+      RuntimeData::uiRuntimeId,
+      RuntimeData::RuntimeKind::UI,
+      RuntimeData::uiRuntimeName,
+      uiAsyncQueue,
+      /*enableEventLoop*/ false);
+
+  registerRuntime(RuntimeData::uiRuntimeId, uiRuntime);
+
+  return uiRuntime;
+}
+
+uint64_t RuntimeManager::getNextRuntimeId() {
+  return nextRuntimeId_.fetch_add(1, std::memory_order_relaxed);
+}
+
+void RuntimeManager::registerRuntime(const uint64_t runtimeId, const std::shared_ptr<WorkletRuntime> &workletRuntime) {
+  std::unique_lock registrationLock(registrationMutex_);
+  std::unique_lock lock(weakRuntimesMutex_);
+  weakRuntimes_[runtimeId] = workletRuntime;
+}
+
+} // namespace worklets

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

@@ -0,0 +1,75 @@
+#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 <mutex>
+#include <shared_mutex>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace worklets {
+
+/**
+ * Forward declaration to avoid circular dependencies.
+ */
+class JSIWorkletsModuleProxy;
+
+class RuntimeManager {
+ public:
+  std::shared_ptr<WorkletRuntime> getRuntime(uint64_t runtimeId);
+
+  std::vector<std::shared_ptr<WorkletRuntime>> getAllRuntimes();
+
+  std::shared_ptr<WorkletRuntime> getUIRuntime();
+
+  std::shared_ptr<WorkletRuntime> createWorkletRuntime(
+      const std::shared_ptr<const JSIWorkletsModuleProxy> &sourceProxy,
+      const std::string &name,
+      const 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<AsyncQueue> &uiAsyncQueue);
+
+#ifndef NDEBUG
+  void propagateModuleUpdate(const std::string &code, const std::string &sourceUrl);
+#endif // NDEBUG
+
+  template <class Fn>
+  decltype(auto) withRegistrationPaused(Fn &&fn) {
+    std::unique_lock lock(registrationMutex_);
+    return std::forward<Fn>(fn)();
+  }
+
+ private:
+  uint64_t getNextRuntimeId();
+
+  void registerRuntime(const uint64_t runtimeId, const std::shared_ptr<WorkletRuntime> &workletRuntime);
+
+#ifndef NDEBUG
+  void loadModuleUpdates(const std::shared_ptr<WorkletRuntime> &workletRuntime);
+
+  struct ModuleUpdate {
+    std::string sourceUrl;
+    std::string code;
+  };
+#endif // NDEBUG
+
+  std::atomic_uint64_t nextRuntimeId_{RuntimeData::uiRuntimeId + 1};
+  std::map<uint64_t, std::weak_ptr<WorkletRuntime>> weakRuntimes_;
+  std::shared_mutex weakRuntimesMutex_;
+  std::mutex registrationMutex_;
+#ifndef NDEBUG
+  std::vector<ModuleUpdate> moduleUpdates_;
+#endif // NDEBUG
+};
+
+} // namespace worklets