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

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

@@ -0,0 +1,161 @@
+#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
+
+// amznmod_react - add support for tracing on Vega
+#elif defined(KEPLER)
+
+#include <Volta/trace/Tracing.h>
+
+#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_;
+};
+
+// amznmod_react - add support for tracing on Vega
+#elif defined(KEPLER) and defined(WORKLETS_PROFILING) && not defined(VOLTA_DARWIN)
+
+struct WorkletsSystraceSection {
+ public:
+  template <typename... ConvertsToStringPiece>
+  explicit WorkletsSystraceSection(
+      const char *name,
+      ConvertsToStringPiece &&...args) {
+    name_ = name;
+    VOLTA_TRACE_BEGIN_STR(name_.data());
+  }
+
+  ~WorkletsSystraceSection() {
+    VOLTA_TRACE_END_STR(name_.data());
+  }
+ private:
+  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,54 @@
+#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,20 @@
+#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/RNRuntimeWorkletDecorator.cpp

@@ -0,0 +1,38 @@
+#include <worklets/Tools/WorkletsVersion.h>
+#include <worklets/WorkletRuntime/RNRuntimeWorkletDecorator.h>
+#include <worklets/WorkletRuntime/RuntimeKind.h>
+#include <worklets/WorkletRuntime/WorkletRuntimeCollector.h>
+#include <memory>
+
+#include <utility>
+
+namespace worklets {
+
+void RNRuntimeWorkletDecorator::decorate(
+    jsi::Runtime &rnRuntime,
+    jsi::Object &&jsiWorkletsModuleProxy,
+    const std::shared_ptr<JSLogger> &jsLogger) {
+  rnRuntime.global().setProperty(
+      rnRuntime,
+      runtimeKindBindingName,
+      static_cast<int>(RuntimeKind::ReactNative));
+
+  rnRuntime.global().setProperty(rnRuntime, "_WORKLET", false);
+
+  // TODO: Remove _IS_FABRIC sometime in the future
+  // react-native-screens 4.9.0 depends on it
+  rnRuntime.global().setProperty(rnRuntime, "_IS_FABRIC", true);
+
+  rnRuntime.global().setProperty(
+      rnRuntime, "__workletsModuleProxy", std::move(jsiWorkletsModuleProxy));
+
+  WorkletRuntimeCollector::install(rnRuntime);
+
+#ifndef NDEBUG
+  checkJSVersion(rnRuntime, jsLogger);
+#endif // NDEBUG
+
+  injectWorkletsCppVersion(rnRuntime);
+}
+
+} // namespace worklets

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

@@ -0,0 +1,21 @@
+#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);
+};
+
+} // namespace worklets

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

@@ -0,0 +1,3 @@
+#include <worklets/WorkletRuntime/RuntimeData.h>
+
+const std::string uiRuntimeName{"UI"};

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

@@ -0,0 +1,12 @@
+#pragma once
+
+// amznmod_react - fix compilation issues
+#include <cstdint>
+#include <string>
+
+/**
+ * Unused, but kept for possible future use.
+ */
+constexpr uint64_t rnRuntimeId{0};
+constexpr uint64_t uiRuntimeId{1};
+extern const std::string uiRuntimeName;

package/Common/cpp/worklets/WorkletRuntime/RuntimeInitialization.md

@@ -0,0 +1,191 @@
+# Hermes Runtime initialization
+
+_Last updated_: 13/09/2022 by @Kwasow
+
+This document describes the current way of initializing Hermes and connecting
+it to the debugger. The work I did was mainly based on
+
+[HermesExecutorFactory.cpp](https://github.com/facebook/react-native/blob/main/packages/react-native/ReactCommon/hermes/executor/HermesExecutorFactory.cpp)
+from React Native.
+
+## Runtime initialization
+
+If you take a look at `NativeProxy` (both on Android and iOS) you'll find
+that it only makes a call to `ReanimatedRuntime::make(jsQueue)`. This
+static function will return the correct runtime based on the user's configuration.
+
+The initialization process is pretty simple and has only been moved out of
+`NativeProxy` into `ReanimatedRuntime` without any major changes.
+
+## Hermes runtime debugging
+
+To enable debugging on the Hermes runtime we need to do two things:
+
+1. Include source maps in JavaScript files
+
+This part is done purely in JavaScript via the Babel plugin. The `makeWorklet`
+function received an AST tree, which is aware of the modifications it made to
+the code and therefore can generate the necessary source maps. It is important
+that when we want to create a string from the AST we use the `generate` function
+and enable source map generation so line mappings are not lost. Then when
+transforming that code (ex. with `transformSync`) we have to pass the source
+map as input so it can be updated.
+
+Source map settings should always be set to `inline` so they are automatically
+appended to the source code. The generated source map will be a base64 encoded
+json.
+
+A workletized function would look like this (after formattings):
+
+```js
+function _f(number) {
+  console.log(_WORKLET, number);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJtYXBwaW5ncyI6IkFBYXNCLFNBQUNBLEVBQUQsQ0FBQ0EsTUFBRCxFQUFvQjtBQUV0Q0MsU0FBTyxDQUFDQyxHQUFSRCxDQUFZRSxRQUFaRixFQUFzQkQsTUFBdEJDO0FBRmtCIiwibmFtZXMiOlsibnVtYmVyIiwiY29uc29sZSIsImxvZyIsIl9XT1JLTEVUIl0sInNvdXJjZXMiOlsiL1VzZXJzL2thcm9sL0dpdC9yZWFjdC1uYXRpdmUtcmVhbmltYXRlZC9GYWJyaWNFeGFtcGxlL3NyYy9Xb3JrbGV0RXhhbXBsZS50c3giXSwic291cmNlc0NvbnRlbnQiOlsiLyogZ2xvYmFsIF9XT1JLTEVUICovXG5pbXBvcnQgeyBCdXR0b24sIFZpZXcsIFN0eWxlU2hlZXQgfSBmcm9tICdyZWFjdC1uYXRpdmUnO1xuaW1wb3J0IHtcbiAgcnVuT25KUyxcbiAgcnVuT25VSSxcbiAgdXNlRGVyaXZlZFZhbHVlLFxuICB1c2VTaGFyZWRWYWx1ZSxcbn0gZnJvbSAncmVhY3QtbmF0aXZlLXJlYW5pbWF0ZWQnO1xuXG5pbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBXb3JrbGV0RXhhbXBsZSgpIHtcbiAgLy8gcnVuT25VSSBkZW1vXG4gIGNvbnN0IHNvbWVXb3JrbGV0ID0gKG51bWJlcjogbnVtYmVyKSA9PiB7XG4gICAgJ3dvcmtsZXQnO1xuICAgIGNvbnNvbGUubG9nKF9XT1JLTEVULCBudW1iZXIpOyAvLyBfV09SS0xFVCBzaG91bGQgYmUgdHJ1ZVxuICB9O1xuXG4gIGNvbnN0IGhhbmRsZVByZXNzMSA9ICgpID0+IHtcbiAgICBydW5PblVJKHNvbWVXb3JrbGV0KShNYXRoLnJhbmRvbSgpKTtcbiAgfTtcblxuICAvLyBydW5PbkpTIGRlbW9cbiAgY29uc3QgeCA9IHVzZVNoYXJlZFZhbHVlKDApO1xuXG4gIGNvbnN0IHNvbWVGdW5jdGlvbiA9IChudW1iZXI6IG51bWJlcikgPT4ge1xuICAgIGNvbnNvbGUubG9nKF9XT1JLTEVULCBudW1iZXIpOyAvLyBfV09SS0xFVCBzaG91bGQgYmUgZmFsc2VcbiAgfTtcblxuICB1c2VEZXJpdmVkVmFsdWUoKCkgPT4ge1xuICAgIHJ1bk9uSlMoc29tZUZ1bmN0aW9uKSh4LnZhbHVlKTtcbiAgfSk7XG5cbiAgY29uc3QgaGFuZGxlUHJlc3MyID0gKCkgPT4ge1xuICAgIHgudmFsdWUgPSBNYXRoLnJhbmRvbSgpO1xuICB9O1xuXG4gIHJldHVybiAoXG4gICAgPFZpZXcgc3R5bGU9e3N0eWxlcy5jb250YWluZXJ9PlxuICAgICAgPEJ1dHRvbiBvblByZXNzPXtoYW5kbGVQcmVzczF9IHRpdGxlPVwicnVuT25VSSBkZW1vXCIgLz5cbiAgICAgIDxCdXR0b24gb25QcmVzcz17aGFuZGxlUHJlc3MyfSB0aXRsZT1cInJ1bk9uSlMgZGVtb1wiIC8+XG4gICAgPC9WaWV3PlxuICApO1xufVxuXG5jb25zdCBzdHlsZXMgPSBTdHlsZVNoZWV0LmNyZWF0ZSh7XG4gIGNvbnRhaW5lcjoge1xuICAgIGZsZXg6IDEsXG4gICAgYWxpZ25JdGVtczogJ2NlbnRlcicsXG4gICAganVzdGlmeUNvbnRlbnQ6ICdjZW50ZXInLFxuICB9LFxufSk7XG4iXX0=
+```
+
+And the base64 string after decoding is:
+
+```json
+{
+  "version": 3,
+  "mappings": "AAasB,SAACA,EAAD,CAACA,MAAD,EAAoB;AAEtCC,SAAO,CAACC,GAARD,CAAYE,QAAZF,EAAsBD,MAAtBC;AAFkB",
+  "names": ["number", "console", "log", "_WORKLET"],
+  "sources": [
+    "/Users/karol/Git/react-native-reanimated/FabricExample/src/WorkletExample.tsx"
+  ],
+  "sourcesContent": [
+    "/* global _WORKLET */\nimport { Button, View, StyleSheet } from 'react-native';\nimport {\n  runOnJS,\n  runOnUI,\n  useDerivedValue,\n  useSharedValue,\n} from 'react-native-reanimated';\n\nimport React from 'react';\n\nexport default function WorkletExample() {\n  // runOnUI demo\n  const someWorklet = (number: number) => {\n    'worklet';\n    console.log(_WORKLET, number); // _WORKLET should be true\n  };\n\n  const handlePress1 = () => {\n    runOnUI(someWorklet)(Math.random());\n  };\n\n  // runOnJS demo\n  const x = useSharedValue(0);\n\n  const someFunction = (number: number) => {\n    console.log(_WORKLET, number); // _WORKLET should be false\n  };\n\n  useDerivedValue(() => {\n    runOnJS(someFunction)(x.value);\n  });\n\n  const handlePress2 = () => {\n    x.value = Math.random();\n  };\n\n  return (\n    <View style={styles.container}>\n      <Button onPress={handlePress1} title=\"runOnUI demo\" />\n      <Button onPress={handlePress2} title=\"runOnJS demo\" />\n    </View>\n  );\n}\n\nconst styles = StyleSheet.create({\n  container: {\n    flex: 1,\n    alignItems: 'center',\n    justifyContent: 'center',\n  },\n});\n"
+  ]
+}
+```
+
+We run jest tests in release mode, because source maps will contain absolute
+paths, which will be different on every machine and therefore would also alter
+worklet hashes. Running in release mode prevents this.
+
+2. Enable debugging on the runtime object
+
+This is done by creating an adapter (`HermesExecutorRuntimeAdapter` inside of
+`WorkletHermesRuntime.cpp`) which holds the runtime and allows the debugger
+to communicate with it. The adapter is managed by a `Connection` (`ConnectionDemux`)
+object, but this is not important in our case. We just have to make a call
+to `facebook::hermes::inspector::chrome::enableDebugging()` and pass the adapter
+and runtime name as parameters.
+
+It is important to also `disableDebugging()` before the runtime is destroyed.
+Failing to do so will probably crash the app as the debugger will try to
+connect to a non-existent runtime.
+
+The runtime should also be destroyed before the Reanimated module, because
+otherwise there might be weird BAD_ACCESS errors when the gc gets it
+hand on the runtime.
+
+## Metro endpoint
+
+Flipper and Chrome DevTools in general use the `localhost:8081/json` (where `8081`
+is the port metro is running on) endpoint of metro to get the list of debuggable
+targets (runtimes). For a normal React Native app the output would look something
+like this:
+
+```json
+[
+  {
+    "id": "0-1",
+    "description": "org.reactjs.native.example.FabricExample",
+    "title": "Hermes React Native",
+    "faviconUrl": "https://reactjs.org/favicon.ico",
+    "devtoolsFrontendUrl": "devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=%5B%3A%3A1%5D%3A8081%2Finspector%2Fdebug%3Fdevice%3D0%26page%3D1",
+    "type": "node",
+    "webSocketDebuggerUrl": "ws://[::1]:8081/inspector/debug?device=0&page=1",
+    "vm": "Hermes"
+  },
+  {
+    "id": "0--1",
+    "description": "org.reactjs.native.example.FabricExample",
+    "title": "React Native Experimental (Improved Chrome Reloads)",
+    "faviconUrl": "https://reactjs.org/favicon.ico",
+    "devtoolsFrontendUrl": "devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=%5B%3A%3A1%5D%3A8081%2Finspector%2Fdebug%3Fdevice%3D0%26page%3D-1",
+    "type": "node",
+    "webSocketDebuggerUrl": "ws://[::1]:8081/inspector/debug?device=0&page=-1",
+    "vm": "don't use"
+  }
+]
+```
+
+For an Android app with Reanimated it should include the Reanimated runtime like
+this:
+
+```json
+[
+  {
+    "id": "0-2",
+    "description": "com.fabricexample",
+    "title": "Reanimated Runtime",
+    "faviconUrl": "https://reactjs.org/favicon.ico",
+    "devtoolsFrontendUrl": "devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=%5B%3A%3A1%5D%3A8081%2Finspector%2Fdebug%3Fdevice%3D0%26page%3D3",
+    "type": "node",
+    "webSocketDebuggerUrl": "ws://[::1]:8081/inspector/debug?device=1&page=2",
+    "vm": "Hermes"
+  },
+  {
+    "id": "0-1",
+    "description": "com.fabricexample",
+    "title": "Hermes React Native",
+    "faviconUrl": "https://reactjs.org/favicon.ico",
+    "devtoolsFrontendUrl": "devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=%5B%3A%3A1%5D%3A8081%2Finspector%2Fdebug%3Fdevice%3D0%26page%3D2",
+    "type": "node",
+    "webSocketDebuggerUrl": "ws://[::1]:8081/inspector/debug?device=1&page=1",
+    "vm": "Hermes"
+  },
+  {
+    "id": "0--1",
+    "description": "com.fabricexample",
+    "title": "React Native Experimental (Improved Chrome Reloads)",
+    "faviconUrl": "https://reactjs.org/favicon.ico",
+    "devtoolsFrontendUrl": "devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=%5B%3A%3A1%5D%3A8081%2Finspector%2Fdebug%3Fdevice%3D0%26page%3D-1",
+    "type": "node",
+    "webSocketDebuggerUrl": "ws://[::1]:8081/inspector/debug?device=1&page=-1",
+    "vm": "don't use"
+  },
+  {
+    "id": "0--2",
+    "description": "com.fabricexample",
+    "title": "Reanimated Runtime Experimental (Improved Chrome Reloads)",
+    "faviconUrl": "https://reactjs.org/favicon.ico",
+    "devtoolsFrontendUrl": "devtools://devtools/bundled/js_app.html?experiments=true&v8only=true&ws=%5B%3A%3A1%5D%3A8081%2Finspector%2Fdebug%3Fdevice%3D0%26page%3D-2",
+    "type": "node",
+    "webSocketDebuggerUrl": "ws://[::1]:8081/inspector/debug?device=1&page=-2",
+    "vm": "don't use"
+  }
+]
+```
+
+Runtimes with negative IDs are 'virtual' - they are just references to the real
+runtimes but their IDs don't change after a reload. If we were to connect to
+the normal runtime and reload the app it would crash, as the debugger would try
+to communicate with a non-existent runtime. These 'virtual' runtimes are made
+and managed by metro (PR: [facebook/metro#864](https://github.com/facebook/metro/pull/864)).
+
+## Known issues
+
+**IFrame sandboxing**
+
+Source maps always define a `sources` array, which contain names of files used
+to generate the source map. For Chrome DevTools this is sufficient as it will
+read files from disk, but the `IFrame` interface used by Flipper is sandboxed
+and doesn't allow filesystem access. Therefore we also need to include the files
+content in the `sourcesContent` array.
+
+**Chrome version 105.0.5195.102 doesn't load source maps**
+
+This version of Chrome introduced a regression into DevTools that broke source
+maps loading for node.js apps. This issue is not caused by Reanimated in any
+way and should be fixed by Chrome developers in later versions.
+
+The issue was tracked here: https://bugs.chromium.org/p/chromium/issues/detail?id=1358497
+
+**App reloads don't work**
+
+On iOS the app will crash on every reload if a debugger is connected to the runtime.
+On Android it will also crash but only after a few reloads.

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

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace worklets {
+/**
+ * Represents the different types of runtime environments available for
+ * worklets.
+ */
+enum class RuntimeKind {
+  ReactNative = 1,
+  UI = 2,
+  Worker = 3,
+};
+
+constexpr auto runtimeKindBindingName = "__RUNTIME_KIND";
+
+} // namespace worklets

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

@@ -0,0 +1,105 @@
+#include <worklets/NativeModules/JSIWorkletsModuleProxy.h>
+#include <worklets/WorkletRuntime/RuntimeManager.h>
+
+#include <utility>
+
+namespace worklets {
+
+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;
+}
+
+#ifdef WORKLETS_BUNDLE_MODE
+std::shared_ptr<WorkletRuntime> RuntimeManager::getRuntime(
+    jsi::Runtime *runtime) {
+  std::shared_lock lock(weakRuntimesMutex_);
+  if (runtimeAddressToRuntimeId_.contains(runtime)) {
+    return getRuntime(runtimeAddressToRuntimeId_.at(runtime));
+  }
+  return nullptr;
+}
+#endif // WORKLETS_BUNDLE_MODE
+
+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 std::string &name,
+    std::shared_ptr<SerializableWorklet> initializer,
+    const std::shared_ptr<AsyncQueue> &queue,
+    bool enableEventLoop) {
+  const auto runtimeId = getNextRuntimeId();
+  const auto jsQueue = jsiWorkletsModuleProxy->getJSQueue();
+
+  auto workletRuntime = std::make_shared<WorkletRuntime>(
+      runtimeId, jsQueue, name, queue, enableEventLoop);
+
+  workletRuntime->init(std::move(jsiWorkletsModuleProxy));
+
+  if (initializer) {
+    workletRuntime->runGuarded(initializer);
+  }
+
+  registerRuntime(runtimeId, name, workletRuntime);
+
+  return workletRuntime;
+}
+
+std::shared_ptr<WorkletRuntime> RuntimeManager::createUninitializedUIRuntime(
+    const std::shared_ptr<MessageQueueThread> &jsQueue,
+    const std::shared_ptr<AsyncQueue> &uiAsyncQueue) {
+  const auto uiRuntime = std::make_shared<WorkletRuntime>(
+      uiRuntimeId, jsQueue, uiRuntimeName, uiAsyncQueue);
+
+  registerRuntime(uiRuntimeId, uiRuntimeName, 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::string &name,
+    const std::shared_ptr<WorkletRuntime> &workletRuntime) {
+  std::unique_lock lock(weakRuntimesMutex_);
+  weakRuntimes_[runtimeId] = workletRuntime;
+  nameToRuntimeId_[name] = runtimeId;
+#ifdef WORKLETS_BUNDLE_MODE
+  runtimeAddressToRuntimeId_[&workletRuntime->getJSIRuntime()] = runtimeId;
+#endif // WORKLETS_BUNDLE_MODE
+}
+
+} // namespace worklets