@shopify/react-native-skia 2.9.1 → 2.10.1

package/cpp/jsi/BoxedNativeObject.h

@@ -0,0 +1,146 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+namespace RNJsi {
+
+namespace jsi = facebook::jsi;
+
+/**
+ * Registry mapping a NativeObject class brand (CLASS_NAME) to a reconstructor
+ * that can recreate a fully functional JS object (prototype + native state)
+ * on any runtime. This is what enables native objects (Skia and WebGPU) to
+ * travel between the React Native runtime and secondary runtimes (Reanimated
+ * worklets) via BoxedNativeObject.
+ */
+class BoxedNativeObjectRegistry {
+public:
+  using Reconstructor = std::function<jsi::Value(
+      jsi::Runtime &, std::shared_ptr<jsi::NativeState>)>;
+
+  static BoxedNativeObjectRegistry &getInstance() {
+    static BoxedNativeObjectRegistry instance;
+    return instance;
+  }
+
+  void registerClass(const std::string &brand, Reconstructor reconstructor) {
+    std::lock_guard<std::mutex> lock(_mutex);
+    // Brands are the unboxing key and must be unique process-wide; a silent
+    // overwrite would make one class unbox into another's reconstructor.
+    if (_reconstructors.count(brand) > 0) {
+      throw std::runtime_error("Duplicate native object brand registered: " +
+                               brand);
+    }
+    _reconstructors[brand] = std::move(reconstructor);
+  }
+
+  jsi::Value reconstruct(jsi::Runtime &runtime, const std::string &brand,
+                         std::shared_ptr<jsi::NativeState> state) {
+    Reconstructor reconstructor;
+    {
+      std::lock_guard<std::mutex> lock(_mutex);
+      auto it = _reconstructors.find(brand);
+      if (it == _reconstructors.end()) {
+        throw jsi::JSError(runtime,
+                           "No native class registered for brand: " + brand);
+      }
+      reconstructor = it->second;
+    }
+    return reconstructor(runtime, std::move(state));
+  }
+
+private:
+  BoxedNativeObjectRegistry() = default;
+  std::mutex _mutex;
+  std::unordered_map<std::string, Reconstructor> _reconstructors;
+};
+
+/**
+ * HostObject bridge used to move NativeObjects between runtimes.
+ *
+ * NativeObject-based values are plain JS objects carrying jsi::NativeState;
+ * worklets cannot serialize their prototype, so they are "boxed" into this
+ * HostObject (which worklets pass across runtimes by reference) and unboxed
+ * on the target runtime, where the prototype is re-installed from the class
+ * registry. See registerCustomSerializable in
+ * src/skia/SkiaWorkletSerialization.ts.
+ */
+class BoxedNativeObject : public jsi::HostObject {
+public:
+  BoxedNativeObject(std::shared_ptr<jsi::NativeState> state, std::string brand)
+      : _state(std::move(state)), _brand(std::move(brand)) {}
+
+  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override {
+    auto propName = name.utf8(runtime);
+    if (propName == "unbox") {
+      auto state = _state;
+      auto brand = _brand;
+      return jsi::Function::createFromHostFunction(
+          runtime, jsi::PropNameID::forUtf8(runtime, "unbox"), 0,
+          [state, brand](jsi::Runtime &rt, const jsi::Value &,
+                         const jsi::Value *, size_t) -> jsi::Value {
+            return BoxedNativeObjectRegistry::getInstance().reconstruct(
+                rt, brand, state);
+          });
+    }
+    if (propName == "__boxedNativeObject") {
+      return jsi::Value(true);
+    }
+    if (propName == "__brand") {
+      return jsi::String::createFromUtf8(runtime, _brand);
+    }
+    return jsi::Value::undefined();
+  }
+
+  void set(jsi::Runtime &runtime, const jsi::PropNameID &,
+           const jsi::Value &) override {
+    throw jsi::JSError(runtime, "Boxed native objects are read-only");
+  }
+
+  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override {
+    std::vector<jsi::PropNameID> names;
+    names.reserve(3);
+    names.push_back(jsi::PropNameID::forUtf8(rt, "unbox"));
+    names.push_back(jsi::PropNameID::forUtf8(rt, "__boxedNativeObject"));
+    names.push_back(jsi::PropNameID::forUtf8(rt, "__brand"));
+    return names;
+  }
+
+private:
+  std::shared_ptr<jsi::NativeState> _state;
+  std::string _brand;
+};
+
+/**
+ * Boxes a NativeObject-backed JS value so it can be serialized by worklets
+ * and unboxed on another runtime.
+ */
+inline jsi::Value boxNativeObject(jsi::Runtime &runtime,
+                                  const jsi::Value &value) {
+  if (!value.isObject()) {
+    throw jsi::JSError(runtime, "box() expects a native object");
+  }
+  auto object = value.asObject(runtime);
+  if (!object.hasNativeState(runtime)) {
+    throw jsi::JSError(runtime, "box() expects a native object");
+  }
+  auto brand = object.getProperty(runtime, "__typename__");
+  if (!brand.isString()) {
+    throw jsi::JSError(runtime, "box() expects a native object");
+  }
+  return jsi::Object::createFromHostObject(
+      runtime, std::make_shared<BoxedNativeObject>(
+                   object.getNativeState(runtime),
+                   brand.asString(runtime).utf8(runtime)));
+}
+
+} // namespace RNJsi

package/cpp/{jsi2 → jsi}/EnumMapper.h

@@ -12,7 +12,10 @@ namespace EnumMapper {
 // outEnum)`
 // 2. `static void convertEnumToJSUnion(Enum inEnum, std::string* outUnion)`
 
-static std::runtime_error invalidUnion(const std::string &passedUnion) {
+// inline (not static): this header is now included by every TU via
+// NativeObject.h, and an unused file-scope static would trip
+// -Werror=unused-function in non-Graphite builds.
+inline std::runtime_error invalidUnion(const std::string &passedUnion) {
   return std::runtime_error(
       "Cannot convert JS Value to Enum: Invalid Union value passed! (\"" +
       std::string(passedUnion) + "\")");

package/cpp/{jsi2 → jsi}/JSIConverter.h

@@ -17,11 +17,6 @@
 #include "EnumMapper.h"
 #include "Promise.h"
 
-#ifdef SK_GRAPHITE
-#include "rnwgpu/api/descriptors/Unions.h"
-#include "rnwgpu/async/AsyncTaskHandle.h"
-#endif
-
 // This number is the maximum integer that can be represented exactly as a
 // double
 #define MAX_SAFE_INTEGER static_cast<uint64_t>(9007199254740991)
@@ -212,32 +207,6 @@ struct JSIConverter<TEnum, std::enable_if_t<std::is_enum<TEnum>::value>> {
   }
 };
 
-#ifdef SK_GRAPHITE
-// AsyncTaskHandle <> Promise
-template <> struct JSIConverter<rnwgpu::async::AsyncTaskHandle> {
-  static rnwgpu::async::AsyncTaskHandle fromJSI(jsi::Runtime &,
-                                                const jsi::Value &, bool) {
-    throw std::runtime_error(
-        "Cannot convert a Promise to AsyncTaskHandle on the native side.");
-  }
-
-  static jsi::Value toJSI(jsi::Runtime &runtime,
-                          rnwgpu::async::AsyncTaskHandle &&handle) {
-    return rnwgpu::Promise::createPromise(
-        runtime, [handle = std::move(handle)](
-                     jsi::Runtime &runtime,
-                     std::shared_ptr<rnwgpu::Promise> promise) mutable {
-          if (!handle.valid()) {
-            promise->resolve(jsi::Value::undefined());
-            return;
-          }
-
-          handle.attachPromise(promise);
-        });
-  }
-};
-#endif
-
 // jsi::Function <> Function
 template <> struct JSIConverter<jsi::Function> {
   static jsi::Function fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,

package/cpp/{jsi2 → jsi}/NativeObject.h

@@ -14,6 +14,7 @@
 #include <unordered_map>
 #include <utility>
 
+#include "jsi/BoxedNativeObject.h"
 #include "jsi/RuntimeAwareCache.h" // Use Skia's RuntimeAwareCache
 
 // Forward declare to avoid circular dependency
@@ -36,41 +37,6 @@ static constexpr size_t kMinMemoryPressure = 256;
 // Forward declaration
 template <typename Derived> class NativeObject;
 
-/**
- * Registry for NativeObject prototype installers.
- * This allows BoxedWebGPUObject::unbox() to install prototypes on any runtime
- * by looking up the brand name and calling the appropriate installer.
- */
-class NativeObjectRegistry {
-public:
-  using InstallerFunc = std::function<void(jsi::Runtime &)>;
-
-  static NativeObjectRegistry &getInstance() {
-    static NativeObjectRegistry instance;
-    return instance;
-  }
-
-  void registerInstaller(const std::string &brand, InstallerFunc installer) {
-    std::lock_guard<std::mutex> lock(_mutex);
-    _installers[brand] = std::move(installer);
-  }
-
-  bool installPrototype(jsi::Runtime &runtime, const std::string &brand) {
-    std::lock_guard<std::mutex> lock(_mutex);
-    auto it = _installers.find(brand);
-    if (it != _installers.end()) {
-      it->second(runtime);
-      return true;
-    }
-    return false;
-  }
-
-private:
-  NativeObjectRegistry() = default;
-  std::mutex _mutex;
-  std::unordered_map<std::string, InstallerFunc> _installers;
-};
-
 /**
  * Per-runtime cache entry for a prototype object.
  * Uses std::optional<jsi::Object> so the prototype is stored directly
@@ -110,93 +76,6 @@ template <typename T> struct StaticRuntimeAwareCache {
   }
 };
 
-/**
- * BoxedWebGPUObject is a HostObject wrapper that holds a reference to ANY
- * WebGPU NativeObject. This is used for Reanimated/Worklets serialization.
- *
- * Since NativeObject uses NativeState (not HostObject), Worklets can't
- * serialize them directly. But Worklets CAN serialize HostObjects.
- *
- * This class stores:
- * - The NativeState from the original object
- * - The brand name for prototype reconstruction
- *
- * Usage pattern with registerCustomSerializable:
- * - pack(): Call WebGPU.box(obj) to create a BoxedWebGPUObject (HostObject)
- * - The HostObject is serialized by Worklets and transferred to UI runtime
- * - unpack(): Call boxed.unbox() to get back the original object with prototype
- *
- * This is similar to NitroModules.box()/unbox() pattern.
- */
-class BoxedWebGPUObject : public jsi::HostObject {
-public:
-  BoxedWebGPUObject(std::shared_ptr<jsi::NativeState> nativeState,
-                    const std::string &brand)
-      : _nativeState(std::move(nativeState)), _brand(brand) {}
-
-  jsi::Value get(jsi::Runtime &runtime, const jsi::PropNameID &name) override {
-    auto propName = name.utf8(runtime);
-    if (propName == "unbox") {
-      return jsi::Function::createFromHostFunction(
-          runtime, jsi::PropNameID::forUtf8(runtime, "unbox"), 0,
-          [this](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
-                 const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
-            // Try to get the prototype from the global constructor
-            auto ctor = rt.global().getProperty(rt, _brand.c_str());
-            if (!ctor.isObject()) {
-              // Constructor doesn't exist on this runtime - install it
-              NativeObjectRegistry::getInstance().installPrototype(rt, _brand);
-              ctor = rt.global().getProperty(rt, _brand.c_str());
-            }
-
-            // Create a new object and attach the native state
-            jsi::Object obj(rt);
-            obj.setNativeState(rt, _nativeState);
-
-            // Set the prototype if constructor exists
-            if (ctor.isObject()) {
-              auto ctorObj = ctor.getObject(rt);
-              auto proto = ctorObj.getProperty(rt, "prototype");
-              if (proto.isObject()) {
-                auto objectCtor = rt.global().getPropertyAsObject(rt, "Object");
-                auto setPrototypeOf =
-                    objectCtor.getPropertyAsFunction(rt, "setPrototypeOf");
-                setPrototypeOf.call(rt, obj, proto);
-              }
-            }
-
-            return std::move(obj);
-          });
-    }
-    if (propName == "__boxedWebGPU") {
-      return jsi::Value(true);
-    }
-    if (propName == "__brand") {
-      return jsi::String::createFromUtf8(runtime, _brand);
-    }
-    return jsi::Value::undefined();
-  }
-
-  void set(jsi::Runtime &runtime, const jsi::PropNameID &name,
-           const jsi::Value &value) override {
-    throw jsi::JSError(runtime, "BoxedWebGPUObject is read-only");
-  }
-
-  std::vector<jsi::PropNameID>
-  getPropertyNames(jsi::Runtime &runtime) override {
-    std::vector<jsi::PropNameID> names;
-    names.reserve(3);
-    names.push_back(jsi::PropNameID::forUtf8(runtime, "unbox"));
-    names.push_back(jsi::PropNameID::forUtf8(runtime, "__boxedWebGPU"));
-    names.push_back(jsi::PropNameID::forUtf8(runtime, "__brand"));
-    return names;
-  }
-
-private:
-  std::shared_ptr<jsi::NativeState> _nativeState;
-  std::string _brand;
-};
-
 /**
  * Base class for native objects using the NativeState pattern.
  *
@@ -237,6 +116,10 @@ public:
    * Each NativeObject<Derived> type has its own static cache.
    * Uses StaticRuntimeAwareCache to properly handle runtime lifecycle
    * and hot reload (where the main runtime is destroyed and recreated).
+   *
+   * Callers must hold getPrototypeCacheMutex(): the cache is reached
+   * concurrently from the main JS thread (create()) and from worklet
+   * runtime threads (BoxedNativeObject::unbox() -> installPrototype()).
    */
   static RNJsi::RuntimeAwareCache<PrototypeCacheEntry> &
   getPrototypeCache(jsi::Runtime &runtime) {
@@ -244,11 +127,22 @@ public:
     return cache.get(runtime);
   }
 
+  /**
+   * Per-class mutex guarding getPrototypeCache() and prototype
+   * installation. Serializes the StaticRuntimeAwareCache pointer swap
+   * (hot reload) and the per-runtime cache lookups.
+   */
+  static std::mutex &getPrototypeCacheMutex() {
+    static std::mutex mutex;
+    return mutex;
+  }
+
   /**
    * Ensure the prototype is installed for this runtime.
    * Called automatically by create(), but can be called manually.
    */
   static void installPrototype(jsi::Runtime &runtime) {
+    std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
     auto &entry = getPrototypeCache(runtime).get(runtime);
     if (entry.prototype.has_value()) {
       return; // Already installed
@@ -279,6 +173,95 @@ public:
       defineProperty.call(runtime, prototype, toStringTag, descriptor);
     }
 
+    // Install the shared pieces every native object needs for JS type
+    // detection and cross-runtime transfer (worklets):
+    // - `__typename__` (CLASS_NAME), used by JS type guards and as the
+    //   boxing brand
+    // - `__box()`, which wraps the object into a RNJsi::BoxedNativeObject
+    //   HostObject that worklets can pass across runtimes by reference
+    // See registerCustomSerializable in src/skia/SkiaWorkletSerialization.ts.
+    prototype.setProperty(
+        runtime, "__typename__",
+        jsi::String::createFromUtf8(runtime, Derived::CLASS_NAME));
+
+    auto boxFunc = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "__box"), 0,
+        [](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *,
+           size_t) -> jsi::Value {
+          return RNJsi::boxNativeObject(rt, thisValue);
+        });
+    prototype.setProperty(runtime, "__box", boxFunc);
+
+    // Install a generic toJSON so JSON.stringify sees the data properties.
+    // They live on the prototype (getters), and JSON.stringify only
+    // serializes *own* enumerable properties — with the legacy HostObject
+    // pattern all properties were reported as own, so e.g.
+    // JSON.stringify(rect) used to produce {x, y, width, height,
+    // __typename__} and now would produce {} without this.
+    auto toJSONFunc = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "toJSON"), 0,
+        [](jsi::Runtime &rt, const jsi::Value &thisValue, const jsi::Value *,
+           size_t) -> jsi::Value {
+          if (!thisValue.isObject()) {
+            return jsi::Value::undefined();
+          }
+          auto self = thisValue.asObject(rt);
+          auto objectCtor = rt.global().getPropertyAsObject(rt, "Object");
+          auto getPrototypeOf =
+              objectCtor.getPropertyAsFunction(rt, "getPrototypeOf");
+          auto getOwnPropertyNames =
+              objectCtor.getPropertyAsFunction(rt, "getOwnPropertyNames");
+          auto proto = getPrototypeOf.call(rt, self);
+          jsi::Object result(rt);
+          if (proto.isObject()) {
+            auto names =
+                getOwnPropertyNames.call(rt, proto).asObject(rt).asArray(rt);
+            auto size = names.size(rt);
+            for (size_t i = 0; i < size; i++) {
+              auto name = names.getValueAtIndex(rt, i).asString(rt).utf8(rt);
+              if (name == "constructor" || name == "toJSON") {
+                continue;
+              }
+              auto value = self.getProperty(rt, name.c_str());
+              // Skip methods (dispose, __box, ...) — JSON.stringify would
+              // drop them anyway; skipping avoids serializing them at all.
+              if (value.isObject() && value.asObject(rt).isFunction(rt)) {
+                continue;
+              }
+              result.setProperty(rt, name.c_str(), value);
+            }
+          }
+          return result;
+        });
+    prototype.setProperty(runtime, "toJSON", toJSONFunc);
+
+    // Register the reconstructor used by BoxedNativeObject::unbox() to
+    // rebuild this object (prototype + native state) on another runtime.
+    static std::once_flag boxingRegistered;
+    std::call_once(boxingRegistered, []() {
+      RNJsi::BoxedNativeObjectRegistry::getInstance().registerClass(
+          Derived::CLASS_NAME,
+          [](jsi::Runtime &rt,
+             std::shared_ptr<jsi::NativeState> state) -> jsi::Value {
+            auto instance = std::dynamic_pointer_cast<Derived>(state);
+            if (instance == nullptr) {
+              throw jsi::JSError(rt, "Invalid boxed native object state");
+            }
+            // Unboxing creates a *view* of the object on the target runtime.
+            // Keep the runtime the object was originally created on: async
+            // native code (e.g. GPUDevice error/lost events) delivers into
+            // the creation runtime, and rebinding it to a worklet runtime
+            // would invoke main-runtime jsi::Functions on the wrong runtime
+            // and thread.
+            auto *originalRuntime = instance->getCreationRuntime();
+            auto value = Derived::create(rt, instance);
+            if (originalRuntime != nullptr) {
+              instance->setCreationRuntime(originalRuntime);
+            }
+            return value;
+          });
+    });
+
     // Cache the prototype
     entry.prototype = std::move(prototype);
   }
@@ -289,22 +272,11 @@ public:
    *
    * The constructor throws if called directly (these objects are only
    * created internally by the native code).
-   *
-   * Also registers this class with NativeObjectRegistry so that
-   * BoxedWebGPUObject::unbox() can install prototypes on secondary runtimes.
    */
   static void installConstructor(jsi::Runtime &runtime) {
-    // Register this class's installer in the registry (only needs to happen
-    // once)
-    static std::once_flag registryFlag;
-    std::call_once(registryFlag, []() {
-      NativeObjectRegistry::getInstance().registerInstaller(
-          Derived::CLASS_NAME,
-          [](jsi::Runtime &rt) { Derived::installConstructor(rt); });
-    });
-
     installPrototype(runtime);
 
+    std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
     auto &entry = getPrototypeCache(runtime).get(runtime);
     if (!entry.prototype.has_value()) {
       return;
@@ -348,13 +320,17 @@ public:
     obj.setNativeState(runtime, instance);
 
     // Set prototype
-    auto &entry = getPrototypeCache(runtime).get(runtime);
-    if (entry.prototype.has_value()) {
-      // Use Object.setPrototypeOf to set the prototype
-      auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
-      auto setPrototypeOf =
-          objectCtor.getPropertyAsFunction(runtime, "setPrototypeOf");
-      setPrototypeOf.call(runtime, obj, *entry.prototype);
+    {
+      std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
+      auto &entry = getPrototypeCache(runtime).get(runtime);
+      if (entry.prototype.has_value()) {
+        // Use Object.setPrototypeOf to set the prototype
+        auto objectCtor =
+            runtime.global().getPropertyAsObject(runtime, "Object");
+        auto setPrototypeOf =
+            objectCtor.getPropertyAsFunction(runtime, "setPrototypeOf");
+        setPrototypeOf.call(runtime, obj, *entry.prototype);
+      }
     }
 
     // Set memory pressure hint for GC
@@ -416,6 +392,11 @@ protected:
 
   /**
    * Install a method on the prototype.
+   *
+   * The installers below resolve `this` with NativeObject<Derived>::fromValue
+   * (explicitly qualified): derived classes may shadow fromValue with a
+   * public static of the same name that returns the wrapped inner object
+   * (the RNSkia wrappers do), which must not be picked up here.
    */
   template <typename ReturnType, typename... Args>
   static void installMethod(jsi::Runtime &runtime, jsi::Object &prototype,
@@ -425,7 +406,7 @@ protected:
         runtime, jsi::PropNameID::forUtf8(runtime, name), sizeof...(Args),
         [method](jsi::Runtime &rt, const jsi::Value &thisVal,
                  const jsi::Value *args, size_t count) -> jsi::Value {
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           return callMethod(native.get(), method, rt, args,
                             std::index_sequence_for<Args...>{}, count);
         });
@@ -438,16 +419,14 @@ protected:
    * (e.g. GPU::requestAdapter, which creates a per-runtime RuntimeContext).
    */
   template <typename ReturnType, typename... Args>
-  static void
-  installMethodWithRuntime(jsi::Runtime &runtime, jsi::Object &prototype,
-                           const char *name,
-                           ReturnType (Derived::*method)(jsi::Runtime &,
-                                                         Args...)) {
+  static void installMethodWithRuntime(
+      jsi::Runtime &runtime, jsi::Object &prototype, const char *name,
+      ReturnType (Derived::*method)(jsi::Runtime &, Args...)) {
     auto func = jsi::Function::createFromHostFunction(
         runtime, jsi::PropNameID::forUtf8(runtime, name), sizeof...(Args),
         [method](jsi::Runtime &rt, const jsi::Value &thisVal,
                  const jsi::Value *args, size_t count) -> jsi::Value {
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           return callMethodWithRuntime(native.get(), method, rt, args,
                                        std::index_sequence_for<Args...>{},
                                        count);
@@ -467,7 +446,7 @@ protected:
         0,
         [getter](jsi::Runtime &rt, const jsi::Value &thisVal,
                  const jsi::Value *args, size_t count) -> jsi::Value {
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           if constexpr (std::is_same_v<ReturnType, void>) {
             (native.get()->*getter)();
             return jsi::Value::undefined();
@@ -507,7 +486,7 @@ protected:
           if (count < 1) {
             throw jsi::JSError(rt, "Setter requires a value argument");
           }
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           auto value = rnwgpu::JSIConverter<std::decay_t<ValueType>>::fromJSI(
               rt, args[0], false);
           (native.get()->*setter)(std::move(value));
@@ -554,7 +533,7 @@ protected:
         0,
         [getter](jsi::Runtime &rt, const jsi::Value &thisVal,
                  const jsi::Value *args, size_t count) -> jsi::Value {
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           ReturnType result = (native.get()->*getter)();
           return rnwgpu::JSIConverter<std::decay_t<ReturnType>>::toJSI(
               rt, std::move(result));
@@ -568,7 +547,7 @@ protected:
           if (count < 1) {
             throw jsi::JSError(rt, "Setter requires a value argument");
           }
-          auto native = Derived::fromValue(rt, thisVal);
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
           auto value = rnwgpu::JSIConverter<std::decay_t<ValueType>>::fromJSI(
               rt, args[0], false);
           (native.get()->*setter)(std::move(value));

package/cpp/jsi/RuntimeAwareCache.cpp

@@ -2,6 +2,6 @@
 
 namespace RNJsi {
 
-jsi::Runtime *BaseRuntimeAwareCache::_mainRuntime = nullptr;
+std::atomic<jsi::Runtime *> BaseRuntimeAwareCache::_mainRuntime{nullptr};
 
 } // namespace RNJsi

package/cpp/jsi/RuntimeAwareCache.h

@@ -2,7 +2,9 @@
 
 #include <jsi/jsi.h>
 
+#include <atomic>
 #include <memory>
+#include <mutex>
 #include <unordered_map>
 #include <utility>
 
@@ -14,17 +16,21 @@ namespace jsi = facebook::jsi;
 
 class BaseRuntimeAwareCache {
 public:
-  static void setMainJsRuntime(jsi::Runtime *rt) { _mainRuntime = rt; }
+  static void setMainJsRuntime(jsi::Runtime *rt) {
+    // Atomic: hot reload rewrites this from the JS thread while worklet
+    // runtime threads read it concurrently.
+    _mainRuntime.store(rt, std::memory_order_release);
+  }
   static jsi::Runtime *getMainJsRuntime() {
-    assert(_mainRuntime != nullptr &&
-           "Expected main Javascript runtime to be set in the "
-           "BaseRuntimeAwareCache class.");
+    auto *rt = _mainRuntime.load(std::memory_order_acquire);
+    assert(rt != nullptr && "Expected main Javascript runtime to be set in the "
+                            "BaseRuntimeAwareCache class.");
 
-    return _mainRuntime;
+    return rt;
   }
 
 private:
-  static jsi::Runtime *_mainRuntime;
+  static std::atomic<jsi::Runtime *> _mainRuntime;
 };
 
 /**
@@ -55,7 +61,10 @@ class RuntimeAwareCache : public BaseRuntimeAwareCache,
 public:
   void onRuntimeDestroyed(jsi::Runtime *rt) override {
     if (getMainJsRuntime() != rt) {
-      // We are removing a secondary runtime
+      // We are removing a secondary runtime. This is invoked by
+      // RuntimeLifecycleMonitor on the destroyed runtime's thread, which may
+      // run concurrently with get() on another runtime's thread.
+      std::lock_guard<std::mutex> lock(_secondaryCachesMutex);
       _secondaryRuntimeCaches.erase(rt);
     }
   }
@@ -74,6 +83,14 @@ public:
     if (getMainJsRuntime() == &rt) {
       return _primaryCache;
     } else {
+      // Guard the secondary map: it can be mutated concurrently by get()
+      // on a worklet runtime's thread and by onRuntimeDestroyed() when
+      // another secondary runtime is torn down. The main-runtime path above
+      // stays lock-free. References into the map remain valid after the
+      // lock is released (unordered_map never invalidates references on
+      // insert/erase of other keys, and this runtime's entry can only be
+      // erased from this runtime's own thread).
+      std::lock_guard<std::mutex> lock(_secondaryCachesMutex);
       if (_secondaryRuntimeCaches.count(&rt) == 0) {
         // we only add listener when the secondary runtime is used, this assumes
         // that the secondary runtime is terminated first. This lets us avoid
@@ -87,11 +104,12 @@ public:
         T cache;
         _secondaryRuntimeCaches.emplace(&rt, std::move(cache));
       }
+      return _secondaryRuntimeCaches.at(&rt);
     }
-    return _secondaryRuntimeCaches.at(&rt);
   }
 
 private:
+  std::mutex _secondaryCachesMutex;
   std::unordered_map<void *, T> _secondaryRuntimeCaches;
   T _primaryCache;
 };