@shopify/react-native-skia 2.9.1-next.1 → 2.10.0

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
@@ -438,11 +414,9 @@ 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,

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;
 };

package/cpp/jsi/ViewProperty.h

@@ -7,8 +7,8 @@
 #include <string>
 #include <variant>
 
-#include "api/JsiSkPicture.h"
 #include "RuntimeLifecycleMonitor.h"
+#include "api/JsiSkPicture.h"
 
 namespace RNJsi {
 namespace jsi = facebook::jsi;
@@ -38,16 +38,10 @@ private:
 class ViewProperty {
 public:
   ViewProperty(jsi::Runtime &runtime, const jsi::Value &value) {
-    if (value.isObject()) {
-      auto object = value.asObject(runtime);
-      if (object.isHostObject(runtime)) {
-        auto hostObject = object.asHostObject(runtime);
-        auto jsiPicture =
-            std::dynamic_pointer_cast<RNSkia::JsiSkPicture>(hostObject);
-        if (jsiPicture) {
-          _value = jsiPicture->getObject();
-        }
-      }
+    auto jsiPicture =
+        RNSkia::tryGetJsiObject<RNSkia::JsiSkPicture>(runtime, value);
+    if (jsiPicture) {
+      _value = jsiPicture->getObject();
     }
   }
 

package/cpp/rnskia/RNSkJsiViewApi.h

@@ -13,7 +13,8 @@
 #include "RNSkPictureView.h"
 #include "RNSkPlatformContext.h"
 #include "RNSkView.h"
-#include "jsi/JsiHostObject.h"
+#include "api/JsiSkNativeObjects.h"
+#include "jsi/JsiPromises.h"
 #include "jsi/ViewProperty.h"
 #include <jsi/jsi.h>
 
@@ -92,9 +93,10 @@ private:
   std::unordered_set<size_t> _unregistered;
 };
 
-class RNSkJsiViewApi : public RNJsi::JsiHostObject,
-                       public std::enable_shared_from_this<RNSkJsiViewApi> {
+class RNSkJsiViewApi : public JsiSkNativeObject<RNSkJsiViewApi> {
 public:
+  static constexpr const char *CLASS_NAME = "ViewApi";
+
   /**
    Sets a custom property on a view given a view id. The property name/value
    will be stored in a map alongside the id of the view and propagated to the
@@ -199,7 +201,7 @@ public:
                            "Could not create image from current surface.");
         return jsi::Value::undefined();
       }
-      return jsi::Object::createFromHostObject(
+      return makeJsiObject(
           runtime, std::make_shared<JsiSkImage>(_platformContext, image));
     }
     throw jsi::JSError(runtime, "No Skia View currently available.");
@@ -245,7 +247,7 @@ public:
                     promise->reject("Failed to make snapshot from view.");
                     return;
                   }
-                  promise->resolve(jsi::Object::createFromHostObject(
+                  promise->resolve(makeJsiObject(
                       runtime, std::make_shared<JsiSkImage>(std::move(context),
                                                             std::move(image))));
                 });
@@ -286,18 +288,25 @@ public:
     return sizeObj;
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(RNSkJsiViewApi, setJsiProperty),
-                       JSI_EXPORT_FUNC(RNSkJsiViewApi, requestRedraw),
-                       JSI_EXPORT_FUNC(RNSkJsiViewApi, makeImageSnapshotAsync),
-                       JSI_EXPORT_FUNC(RNSkJsiViewApi, makeImageSnapshot),
-                       JSI_EXPORT_FUNC(RNSkJsiViewApi, size))
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installHostMethod(runtime, prototype, "setJsiProperty",
+                      &RNSkJsiViewApi::setJsiProperty);
+    installHostMethod(runtime, prototype, "requestRedraw",
+                      &RNSkJsiViewApi::requestRedraw);
+    installHostMethod(runtime, prototype, "makeImageSnapshotAsync",
+                      &RNSkJsiViewApi::makeImageSnapshotAsync);
+    installHostMethod(runtime, prototype, "makeImageSnapshot",
+                      &RNSkJsiViewApi::makeImageSnapshot);
+    installHostMethod(runtime, prototype, "size", &RNSkJsiViewApi::size);
+  }
 
   /**
    * Constructor
    * @param platformContext Platform context
    */
   explicit RNSkJsiViewApi(std::shared_ptr<RNSkPlatformContext> platformContext)
-      : JsiHostObject(), _platformContext(platformContext) {}
+      : JsiSkNativeObject<RNSkJsiViewApi>(platformContext),
+        _platformContext(platformContext) {}
 
   /**
    Call to remove all draw view infos

package/cpp/rnskia/RNSkManager.cpp

@@ -5,27 +5,27 @@
 
 #include <jsi/jsi.h>
 
-#include "api/JsiSkApi.h"
 #include "RNSkJsiViewApi.h"
 #include "RNSkView.h"
+#include "api/JsiSkApi.h"
 
 #include "jsi/RuntimeAwareCache.h"
 
 #ifdef SK_GRAPHITE
 #include "RNDawnContext.h"
+#include "jsi/Promise.h"
 #include "rnwgpu/ArrayBuffer.h"
 #include "rnwgpu/api/GPU.h"
 #include "rnwgpu/api/GPUUncapturedErrorEvent.h"
 #include "rnwgpu/api/ImageBitmap.h"
 #include "rnwgpu/api/RNWebGPU.h"
+#include "rnwgpu/api/WebGPUConstants.h"
 #include "rnwgpu/api/descriptors/GPUBufferUsage.h"
 #include "rnwgpu/api/descriptors/GPUColorWrite.h"
 #include "rnwgpu/api/descriptors/GPUMapMode.h"
 #include "rnwgpu/api/descriptors/GPUShaderStage.h"
 #include "rnwgpu/api/descriptors/GPUTextureUsage.h"
-#include "rnwgpu/api/WebGPUConstants.h"
 #include "rnwgpu/async/RuntimeContext.h"
-#include "jsi2/Promise.h"
 
 #include "include/core/SkData.h"
 #include "include/core/SkImage.h"
@@ -51,6 +51,12 @@ RNSkManager::RNSkManager(
 }
 
 RNSkManager::~RNSkManager() {
+#ifdef SK_GRAPHITE
+  // Drop all canvas registry entries: after a reload the JS side restarts its
+  // contextId counter, and stale entries would alias new canvases onto dead
+  // surfaces.
+  rnwgpu::SurfaceRegistry::getInstance().clear();
+#endif
   // Free up any references
   _viewApi = nullptr;
   _jsRuntime = nullptr;
@@ -76,19 +82,18 @@ void RNSkManager::installBindings() {
   // provided runtime.
   auto skiaApi = std::make_shared<JsiSkApi>(_platformContext);
   _jsRuntime->global().setProperty(
-      *_jsRuntime, "SkiaApi",
-      jsi::Object::createFromHostObject(*_jsRuntime, std::move(skiaApi)));
+      *_jsRuntime, "SkiaApi", makeJsiObject(*_jsRuntime, std::move(skiaApi)));
 
-  _jsRuntime->global().setProperty(
-      *_jsRuntime, "SkiaViewApi",
-      jsi::Object::createFromHostObject(*_jsRuntime, _viewApi));
+  _jsRuntime->global().setProperty(*_jsRuntime, "SkiaViewApi",
+                                   makeJsiObject(*_jsRuntime, _viewApi));
 
 #ifdef SK_GRAPHITE
   // Register the main runtime + its CallInvoker so spontaneous events
   // (device.lost / uncapturederror) on main-runtime devices can be delivered to
   // the JS thread without the ProcessEvents pump. Worklet-runtime devices have
   // no invoker (best-effort; see the RuntimeContext "Threading model" doc).
-  rnwgpu::async::RuntimeContext::registerMainRuntime(_jsRuntime, _jsCallInvoker);
+  rnwgpu::async::RuntimeContext::registerMainRuntime(_jsRuntime,
+                                                     _jsCallInvoker);
 
   // Install WebGPU constructors
   rnwgpu::GPU::installConstructor(*_jsRuntime);
@@ -115,13 +120,14 @@ void RNSkManager::installBindings() {
   // Install WebGPU constant objects as plain JS objects on the main runtime.
   rnwgpu::installWebGPUConstants(*_jsRuntime);
 
-  // Install a global `installWebGPU()` host function so worklet runtimes can get
-  // the same constants. A host function captured into a worklet is serialized as
-  // a SerializableHostFunction and re-created on the worklet runtime, so the body
-  // runs there (its `rt` is the worklet runtime) and installs the constants on
-  // that runtime. The constants come from the native wgpu::*Usage enums, so the
-  // values stay a single source of truth across every runtime. Calling it on a
-  // runtime that already has the globals is a safe, idempotent no-op.
+  // Install a global `installWebGPU()` host function so worklet runtimes can
+  // get the same constants. A host function captured into a worklet is
+  // serialized as a SerializableHostFunction and re-created on the worklet
+  // runtime, so the body runs there (its `rt` is the worklet runtime) and
+  // installs the constants on that runtime. The constants come from the native
+  // wgpu::*Usage enums, so the values stay a single source of truth across
+  // every runtime. Calling it on a runtime that already has the globals is a
+  // safe, idempotent no-op.
   _jsRuntime->global().setProperty(
       *_jsRuntime, "installWebGPU",
       jsi::Function::createFromHostFunction(
@@ -166,9 +172,8 @@ void RNSkManager::installBindings() {
             bool isBufferSource = obj.isArrayBuffer(rt);
             if (!isBufferSource && obj.hasProperty(rt, "buffer")) {
               auto bufferProp = obj.getProperty(rt, "buffer");
-              isBufferSource =
-                  bufferProp.isObject() &&
-                  bufferProp.getObject(rt).isArrayBuffer(rt);
+              isBufferSource = bufferProp.isObject() &&
+                               bufferProp.getObject(rt).isArrayBuffer(rt);
             }
             if (!isBufferSource) {
               throw jsi::JSError(rt, "createImageBitmap: unsupported source "
@@ -177,9 +182,9 @@ void RNSkManager::installBindings() {
             }
             // Validates bounds and THROWS synchronously on a spoofed view, so
             // the bad pointer never reaches the copy below.
-            auto buffer =
-                rnwgpu::JSIConverter<std::shared_ptr<rnwgpu::ArrayBuffer>>::
-                    fromJSI(rt, args[0], false);
+            auto buffer = rnwgpu::JSIConverter<
+                std::shared_ptr<rnwgpu::ArrayBuffer>>::fromJSI(rt, args[0],
+                                                               false);
             // Copy the encoded bytes off the JS-owned ArrayBuffer.
             const uint8_t *bytes = buffer->data();
             std::vector<uint8_t> encoded(bytes, bytes + buffer->size());
@@ -198,9 +203,8 @@ void RNSkManager::installBindings() {
                   }
                   const int w = image->width();
                   const int h = image->height();
-                  auto info =
-                      SkImageInfo::Make(w, h, kRGBA_8888_SkColorType,
-                                        kUnpremul_SkAlphaType);
+                  auto info = SkImageInfo::Make(w, h, kRGBA_8888_SkColorType,
+                                                kUnpremul_SkAlphaType);
                   std::vector<uint8_t> pixels(info.computeMinByteSize());
                   // nullptr context: decode/read on the CPU (raster).
                   if (!image->readPixels(nullptr, info, pixels.data(),

package/cpp/rnskia/RNSkPictureView.h

@@ -13,9 +13,9 @@
 #include "RNSkView.h"
 #include "jsi/ViewProperty.h"
 
+#include "RNSkPlatformContext.h"
 #include "api/JsiSkPicture.h"
 #include "utils/RNSkLog.h"
-#include "RNSkPlatformContext.h"
 #include "utils/RNSkTimingInfo.h"
 
 #pragma clang diagnostic push