@shopify/react-native-skia 2.4.17 → 2.4.19

package/cpp/jsi2/JSIConverter.h

@@ -1,17 +1,19 @@
 #pragma once
 
+#include <limits>
+#include <map>
 #include <memory>
-#include <vector>
 #include <string>
-#include <utility>
 #include <type_traits>
-#include <limits>
-#include <variant>
-#include <map>
 #include <unordered_set>
+#include <utility>
+#include <variant>
+#include <vector>
 
 #include <jsi/jsi.h>
 
+#include "utils/RNSkLog.h"
+
 #include "EnumMapper.h"
 #include "Promise.h"
 
@@ -20,7 +22,8 @@
 #include "rnwgpu/async/AsyncTaskHandle.h"
 #endif
 
-// This number is the maximum integer that can be represented exactly as a double
+// This number is the maximum integer that can be represented exactly as a
+// double
 #define MAX_SAFE_INTEGER static_cast<uint64_t>(9007199254740991)
 
 #if __has_include(<cxxabi.h>)
@@ -33,12 +36,14 @@ namespace jsi = facebook::jsi;
 
 // Unknown type (error)
 template <typename ArgType, typename Enable = void> struct JSIConverter {
-  static ArgType fromJSI(jsi::Runtime&, const jsi::Value&, bool outOfBound) {
-    static_assert(always_false<ArgType>::value, "This type is not supported by the JSIConverter!");
+  static ArgType fromJSI(jsi::Runtime &, const jsi::Value &, bool outOfBound) {
+    static_assert(always_false<ArgType>::value,
+                  "This type is not supported by the JSIConverter!");
     return ArgType();
   }
-  static jsi::Value toJSI(jsi::Runtime&, ArgType) {
-    static_assert(always_false<ArgType>::value, "This type is not supported by the JSIConverter!");
+  static jsi::Value toJSI(jsi::Runtime &, ArgType) {
+    static_assert(always_false<ArgType>::value,
+                  "This type is not supported by the JSIConverter!");
     return jsi::Value::undefined();
   }
 
@@ -48,73 +53,77 @@ private:
 
 // int <> number
 template <> struct JSIConverter<int> {
-  static int fromJSI(jsi::Runtime&, const jsi::Value& arg, bool outOfBound) {
+  static int fromJSI(jsi::Runtime &, const jsi::Value &arg, bool outOfBound) {
     return static_cast<int>(arg.asNumber());
   }
-  static jsi::Value toJSI(jsi::Runtime&, int arg) {
-    return jsi::Value(arg);
-  }
+  static jsi::Value toJSI(jsi::Runtime &, int arg) { return jsi::Value(arg); }
 };
 
 // double <> number
 template <> struct JSIConverter<double> {
-  static double fromJSI(jsi::Runtime&, const jsi::Value& arg, bool outOfBound) {
+  static double fromJSI(jsi::Runtime &, const jsi::Value &arg,
+                        bool outOfBound) {
     return arg.asNumber();
   }
-  static jsi::Value toJSI(jsi::Runtime&, double arg) {
+  static jsi::Value toJSI(jsi::Runtime &, double arg) {
     return jsi::Value(arg);
   }
 };
 
 // float <> number
 template <> struct JSIConverter<float> {
-  static float fromJSI(jsi::Runtime&, const jsi::Value& arg, bool outOfBound) {
+  static float fromJSI(jsi::Runtime &, const jsi::Value &arg, bool outOfBound) {
     return static_cast<float>(arg.asNumber());
   }
-  static jsi::Value toJSI(jsi::Runtime&, float arg) {
+  static jsi::Value toJSI(jsi::Runtime &, float arg) {
     return jsi::Value(static_cast<double>(arg));
   }
 };
 
 template <> struct JSIConverter<std::nullptr_t> {
-  static std::nullptr_t fromJSI(jsi::Runtime&, const jsi::Value& arg, bool outOfBound) {
+  static std::nullptr_t fromJSI(jsi::Runtime &, const jsi::Value &arg,
+                                bool outOfBound) {
     return nullptr;
   }
-  static jsi::Value toJSI(jsi::Runtime&, std::nullptr_t arg) {
+  static jsi::Value toJSI(jsi::Runtime &, std::nullptr_t arg) {
     return jsi::Value::null();
   }
 };
 
 template <typename T>
-struct JSIConverter<T, std::enable_if_t<!std::is_same_v<T, uint64_t> && std::is_same_v<T, size_t>>> {
-  static size_t fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
-      if (arg.isNumber()) {
-          double value = arg.asNumber();
-          return static_cast<size_t>(value);
-      } else {
-          return arg.asBigInt(runtime).asInt64(runtime);
-      }
+struct JSIConverter<T, std::enable_if_t<!std::is_same_v<T, uint64_t> &&
+                                        std::is_same_v<T, size_t>>> {
+  static size_t fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                        bool outOfBound) {
+    if (arg.isNumber()) {
+      double value = arg.asNumber();
+      return static_cast<size_t>(value);
+    } else {
+      return arg.asBigInt(runtime).asInt64(runtime);
+    }
   }
 
-  static jsi::Value toJSI(jsi::Runtime& runtime, size_t arg) {
+  static jsi::Value toJSI(jsi::Runtime &runtime, size_t arg) {
     return jsi::Value(static_cast<double>(arg));
   }
 };
 
 // uint32_t <> double
 template <> struct JSIConverter<uint32_t> {
-  static double fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
-      double value = arg.asNumber();
-      return static_cast<uint32_t>(value);
+  static double fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                        bool outOfBound) {
+    double value = arg.asNumber();
+    return static_cast<uint32_t>(value);
   }
-  static jsi::Value toJSI(jsi::Runtime& runtime, uint32_t arg) {
-      return jsi::Value(static_cast<double>(arg));
+  static jsi::Value toJSI(jsi::Runtime &runtime, uint32_t arg) {
+    return jsi::Value(static_cast<double>(arg));
   }
 };
 
 // uint64_t <> BigInt
 template <> struct JSIConverter<uint64_t> {
-  static uint64_t fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+  static uint64_t fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                          bool outOfBound) {
     if (arg.isNumber()) {
       double value = arg.asNumber();
       if (value < 0 || value > MAX_SAFE_INTEGER) {
@@ -126,55 +135,58 @@ template <> struct JSIConverter<uint64_t> {
     }
   }
 
-  static jsi::Value toJSI(jsi::Runtime& runtime, uint64_t arg) {
+  static jsi::Value toJSI(jsi::Runtime &runtime, uint64_t arg) {
     if (arg <= MAX_SAFE_INTEGER) {
       return jsi::Value(static_cast<double>(arg));
     } else {
-      throw jsi::JSError(runtime, "Number too large to be represented as a double");
+      throw jsi::JSError(runtime,
+                         "Number too large to be represented as a double");
     }
   }
 };
 
 template <> struct JSIConverter<void *> {
-  static void* fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+  static void *fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                       bool outOfBound) {
     return reinterpret_cast<void *>(arg.asBigInt(runtime).getUint64(runtime));
   }
 
-  static jsi::Value toJSI(jsi::Runtime& runtime, void* arg) {
+  static jsi::Value toJSI(jsi::Runtime &runtime, void *arg) {
     return jsi::BigInt::fromUint64(runtime, reinterpret_cast<uint64_t>(arg));
   }
 };
 
 // bool <> boolean
 template <> struct JSIConverter<bool> {
-  static bool fromJSI(jsi::Runtime&, const jsi::Value& arg, bool outOfBound) {
+  static bool fromJSI(jsi::Runtime &, const jsi::Value &arg, bool outOfBound) {
     return arg.asBool();
   }
-  static jsi::Value toJSI(jsi::Runtime&, bool arg) {
-    return jsi::Value(arg);
-  }
+  static jsi::Value toJSI(jsi::Runtime &, bool arg) { return jsi::Value(arg); }
 };
 
 // std::string <> string
 template <> struct JSIConverter<std::string> {
-  static std::string fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+  static std::string fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                             bool outOfBound) {
     return arg.asString(runtime).utf8(runtime);
   }
-  static jsi::Value toJSI(jsi::Runtime& runtime, const std::string& arg) {
+  static jsi::Value toJSI(jsi::Runtime &runtime, const std::string &arg) {
     return jsi::String::createFromUtf8(runtime, arg);
   }
 };
 
 // std::optional<T> <> T | undefined
 template <typename TInner> struct JSIConverter<std::optional<TInner>> {
-  static std::optional<TInner> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+  static std::optional<TInner> fromJSI(jsi::Runtime &runtime,
+                                       const jsi::Value &arg, bool outOfBound) {
     if (outOfBound || arg.isUndefined()) {
       return {};
     } else {
       return JSIConverter<TInner>::fromJSI(runtime, std::move(arg), outOfBound);
     }
   }
-  static jsi::Value toJSI(jsi::Runtime& runtime, const std::optional<TInner>& arg) {
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          const std::optional<TInner> &arg) {
     if (arg == std::nullopt) {
       return jsi::Value::undefined();
     } else {
@@ -184,14 +196,16 @@ template <typename TInner> struct JSIConverter<std::optional<TInner>> {
 };
 
 // Enum <> Union
-template <typename TEnum> struct JSIConverter<TEnum, std::enable_if_t<std::is_enum<TEnum>::value>> {
-  static TEnum fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+template <typename TEnum>
+struct JSIConverter<TEnum, std::enable_if_t<std::is_enum<TEnum>::value>> {
+  static TEnum fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                       bool outOfBound) {
     std::string string = arg.asString(runtime).utf8(runtime);
     TEnum outEnum;
     EnumMapper::convertJSUnionToEnum(string, &outEnum);
     return outEnum;
   }
-  static jsi::Value toJSI(jsi::Runtime& runtime, const TEnum& arg) {
+  static jsi::Value toJSI(jsi::Runtime &runtime, const TEnum &arg) {
     std::string outUnion;
     EnumMapper::convertEnumToJSUnion(arg, &outUnion);
     return jsi::String::createFromUtf8(runtime, outUnion);
@@ -201,42 +215,53 @@ template <typename TEnum> struct JSIConverter<TEnum, std::enable_if_t<std::is_en
 #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);
-    });
+  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
 
 // std::map<std::string, T> <> Record<string, T>
-template <typename ValueType> struct JSIConverter<std::map<std::string, ValueType>> {
-  static std::map<std::string, ValueType> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+template <typename ValueType>
+struct JSIConverter<std::map<std::string, ValueType>> {
+  static std::map<std::string, ValueType>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBound) {
     jsi::Object object = arg.asObject(runtime);
     jsi::Array propertyNames = object.getPropertyNames(runtime);
     size_t length = propertyNames.size(runtime);
 
     std::map<std::string, ValueType> map;
     for (size_t i = 0; i < length; ++i) {
-      std::string key = propertyNames.getValueAtIndex(runtime, i).asString(runtime).utf8(runtime);
+      std::string key = propertyNames.getValueAtIndex(runtime, i)
+                            .asString(runtime)
+                            .utf8(runtime);
       jsi::Value value = object.getProperty(runtime, key.c_str());
-      map.emplace(key, JSIConverter<ValueType>::fromJSI(runtime, value, outOfBound));
+      map.emplace(key,
+                  JSIConverter<ValueType>::fromJSI(runtime, value, outOfBound));
     }
     return map;
   }
-  static jsi::Value toJSI(jsi::Runtime& runtime, const std::map<std::string, ValueType>& map) {
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          const std::map<std::string, ValueType> &map) {
     jsi::Object object(runtime);
-    for (const auto& pair : map) {
+    for (const auto &pair : map) {
       jsi::Value value = JSIConverter<ValueType>::toJSI(runtime, pair.second);
       jsi::String key = jsi::String::createFromUtf8(runtime, pair.first);
       object.setProperty(runtime, key, std::move(value));
@@ -245,10 +270,10 @@ template <typename ValueType> struct JSIConverter<std::map<std::string, ValueTyp
   }
 };
 
-
 // std::vector<T> <> T[]
 template <typename ElementType> struct JSIConverter<std::vector<ElementType>> {
-  static std::vector<ElementType> fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+  static std::vector<ElementType>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBound) {
     jsi::Array array = arg.asObject(runtime).asArray(runtime);
     size_t length = array.size(runtime);
 
@@ -256,11 +281,13 @@ template <typename ElementType> struct JSIConverter<std::vector<ElementType>> {
     vector.reserve(length);
     for (size_t i = 0; i < length; ++i) {
       jsi::Value elementValue = array.getValueAtIndex(runtime, i);
-      vector.emplace_back(JSIConverter<ElementType>::fromJSI(runtime, elementValue, outOfBound));
+      vector.emplace_back(JSIConverter<ElementType>::fromJSI(
+          runtime, elementValue, outOfBound));
     }
     return vector;
   }
-  static jsi::Value toJSI(jsi::Runtime& runtime, const std::vector<ElementType>& vector) {
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          const std::vector<ElementType> &vector) {
     jsi::Array array(runtime, vector.size());
     for (size_t i = 0; i < vector.size(); i++) {
       jsi::Value value = JSIConverter<ElementType>::toJSI(runtime, vector[i]);
@@ -273,9 +300,13 @@ template <typename ElementType> struct JSIConverter<std::vector<ElementType>> {
 // NativeState <> {}
 template <typename T> struct is_shared_ptr_to_native_state : std::false_type {};
 
-template <typename T> struct is_shared_ptr_to_native_state<std::shared_ptr<T>> : std::is_base_of<jsi::NativeState, T> {};
+template <typename T>
+struct is_shared_ptr_to_native_state<std::shared_ptr<T>>
+    : std::is_base_of<jsi::NativeState, T> {};
 
-template <typename T> struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_native_state<T>::value>> {
+template <typename T>
+struct JSIConverter<T,
+                    std::enable_if_t<is_shared_ptr_to_native_state<T>::value>> {
   using TPointee = typename T::element_type;
 
 #if DEBUG
@@ -283,7 +314,8 @@ template <typename T> struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_n
     std::string name = std::string(typeid(TPointee).name());
 #if __has_include(<cxxabi.h>)
     int status = 0;
-    char* demangled_name = abi::__cxa_demangle(name.c_str(), NULL, NULL, &status);
+    char *demangled_name =
+        abi::__cxa_demangle(name.c_str(), NULL, NULL, &status);
     if (status == 0) {
       name = demangled_name;
       std::free(demangled_name);
@@ -292,53 +324,71 @@ template <typename T> struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_n
     return name;
   }
 
-  inline static std::string invalidTypeErrorMessage(const std::string& typeDescription, const std::string& reason) {
-    return "Cannot convert \"" + typeDescription + "\" to NativeState<" + getFriendlyTypename() + ">! " + reason;
+  inline static std::string
+  invalidTypeErrorMessage(const std::string &typeDescription,
+                          const std::string &reason) {
+    return "Cannot convert \"" + typeDescription + "\" to NativeState<" +
+           getFriendlyTypename() + ">! " + reason;
   }
 #endif
 
-  static T fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
+  static T fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
+                   bool outOfBound) {
 #if DEBUG
     if (arg.isUndefined()) {
       [[unlikely]];
-      throw jsi::JSError(runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
+      throw jsi::JSError(
+          runtime, invalidTypeErrorMessage("undefined", "It is undefined!"));
     }
     if (!arg.isObject()) {
       [[unlikely]];
       std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is not an object!"));
+      throw jsi::JSError(runtime,
+                         invalidTypeErrorMessage(stringRepresentation,
+                                                 "It is not an object!"));
     }
 #endif
     jsi::Object object = arg.getObject(runtime);
 #if DEBUG
-    if (!object.hasNativeState<TPointee>(runtime)) {
-      [[unlikely]];
+    if (!object.hasNativeState<TPointee>(runtime)) [[unlikely]] {
+      // Log instead of throwing: hasNativeState<T>() uses dynamic_cast (RTTI)
+      // which can return false across shared-library / JSI-runtime boundaries
+      // on iOS (duplicate typeinfo symbols in separate .dylib modules).
+      // getNativeState<T>() below uses static_pointer_cast and works correctly
+      // even when dynamic_cast fails, so this is not a fatal error.
       std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different NativeState<T>!"));
+      RNSkia::RNSkLogger::logToConsole(
+          "NativeState<T> RTTI mismatch for \"%s\" (expected %s) "
+          "-- this is likely a false positive from dynamic_cast across JSI "
+          "runtime boundaries; continuing with static_pointer_cast.",
+          stringRepresentation.c_str(), getFriendlyTypename().c_str());
     }
 #endif
     return object.getNativeState<TPointee>(runtime);
   }
+
 private:
   // SFINAE helper to detect if T has a IsNativeObject marker type
   template <typename U, typename = typename U::IsNativeObject>
   static std::true_type hasNativeObjectMarker(int);
-  template <typename U>
-  static std::false_type hasNativeObjectMarker(...);
+  template <typename U> static std::false_type hasNativeObjectMarker(...);
 
   // Type trait for detection
-  static constexpr bool is_native_object = decltype(hasNativeObjectMarker<TPointee>(0))::value;
+  static constexpr bool is_native_object =
+      decltype(hasNativeObjectMarker<TPointee>(0))::value;
 
 public:
-  static jsi::Value toJSI(jsi::Runtime& runtime, const T& arg) {
+  static jsi::Value toJSI(jsi::Runtime &runtime, const T &arg) {
 #if DEBUG
     if (arg == nullptr) {
       [[unlikely]];
-      throw jsi::JSError(runtime, "Cannot convert nullptr to NativeState<" + getFriendlyTypename() + ">!");
+      throw jsi::JSError(runtime, "Cannot convert nullptr to NativeState<" +
+                                      getFriendlyTypename() + ">!");
     }
 #endif
     // Check if the type is a NativeObject (has IsNativeObject marker)
-    // Use TPointee::create() if it's a NativeObject, otherwise fall back to plain setNativeState
+    // Use TPointee::create() if it's a NativeObject, otherwise fall back to
+    // plain setNativeState
     if constexpr (is_native_object) {
       return TPointee::create(runtime, arg);
     } else {
@@ -349,7 +399,6 @@ public:
   }
 };
 
-
 template <typename O, typename T>
 struct JSIConverter<std::variant<std::vector<T>, std::shared_ptr<O>>> {
   using Target = std::variant<std::vector<T>, std::shared_ptr<O>>;
@@ -445,21 +494,22 @@ struct JSIConverter<
   }
 };
 
-template <>
-struct JSIConverter<std::unordered_set<std::string>> {
+template <> struct JSIConverter<std::unordered_set<std::string>> {
   using Target = std::unordered_set<std::string>;
   static Target fromJSI(jsi::Runtime &runtime, const jsi::Value &arg,
                         bool outOfBound) {
-    throw jsi::JSError(runtime, "JSIConverter<std::unordered_set<std::string>>::fromJSI not implemented");
+    throw jsi::JSError(runtime, "JSIConverter<std::unordered_set<std::string>>:"
+                                ":fromJSI not implemented");
   }
 
   static jsi::Value toJSI(jsi::Runtime &runtime, Target arg) {
-    auto setConstructor = runtime.global().getPropertyAsFunction(runtime, "Set");
+    auto setConstructor =
+        runtime.global().getPropertyAsFunction(runtime, "Set");
     auto set = setConstructor.callAsConstructor(runtime).asObject(runtime);
     auto add = set.getPropertyAsFunction(runtime, "add");
-    for (const auto& value : arg) {
-     jsi::Value jsiValue = JSIConverter<std::string>::toJSI(runtime, value);
-     add.callWithThis(runtime, set, jsiValue);
+    for (const auto &value : arg) {
+      jsi::Value jsiValue = JSIConverter<std::string>::toJSI(runtime, value);
+      add.callWithThis(runtime, set, jsiValue);
     }
     return std::move(set);
   }

package/cpp/jsi2/NativeObject.h

@@ -14,7 +14,7 @@
 #include <unordered_map>
 #include <utility>
 
-#include "jsi/RuntimeAwareCache.h"  // Use Skia's RuntimeAwareCache
+#include "jsi/RuntimeAwareCache.h" // Use Skia's RuntimeAwareCache
 
 // Forward declare to avoid circular dependency
 namespace rnwgpu {
@@ -135,8 +135,7 @@ public:
       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 {
+                 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()) {
@@ -154,8 +153,7 @@ public:
               auto ctorObj = ctor.getObject(rt);
               auto proto = ctorObj.getProperty(rt, "prototype");
               if (proto.isObject()) {
-                auto objectCtor =
-                    rt.global().getPropertyAsObject(rt, "Object");
+                auto objectCtor = rt.global().getPropertyAsObject(rt, "Object");
                 auto setPrototypeOf =
                     objectCtor.getPropertyAsFunction(rt, "setPrototypeOf");
                 setPrototypeOf.call(rt, obj, proto);
@@ -263,8 +261,7 @@ public:
     if (!toStringTag.isUndefined()) {
       // Use Object.defineProperty to set symbol property since setProperty
       // doesn't support symbols directly
-      auto objectCtor =
-          runtime.global().getPropertyAsObject(runtime, "Object");
+      auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
       auto defineProperty =
           objectCtor.getPropertyAsFunction(runtime, "defineProperty");
       jsi::Object descriptor(runtime);
@@ -292,7 +289,8 @@ public:
    * 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)
+    // 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(
@@ -312,9 +310,9 @@ public:
         runtime, jsi::PropNameID::forUtf8(runtime, Derived::CLASS_NAME), 0,
         [](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
            const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
-          throw jsi::JSError(
-              rt, std::string("Illegal constructor: ") + Derived::CLASS_NAME +
-                      " objects are created by the WebGPU API");
+          throw jsi::JSError(rt, std::string("Illegal constructor: ") +
+                                     Derived::CLASS_NAME +
+                                     " objects are created by the WebGPU API");
         });
 
     // Set the prototype property on the constructor
@@ -348,8 +346,7 @@ public:
     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 objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
       auto setPrototypeOf =
           objectCtor.getPropertyAsFunction(runtime, "setPrototypeOf");
       setPrototypeOf.call(runtime, obj, *entry.prototype);
@@ -483,8 +480,8 @@ protected:
             throw jsi::JSError(rt, "Setter requires a value argument");
           }
           auto native = Derived::fromValue(rt, thisVal);
-          auto value =
-              rnwgpu::JSIConverter<std::decay_t<ValueType>>::fromJSI(rt, args[0], false);
+          auto value = rnwgpu::JSIConverter<std::decay_t<ValueType>>::fromJSI(
+              rt, args[0], false);
           (native.get()->*setter)(std::move(value));
           return jsi::Value::undefined();
         });
@@ -504,8 +501,8 @@ protected:
     if (existingDesc.isObject()) {
       auto existingDescObj = existingDesc.getObject(runtime);
       if (existingDescObj.hasProperty(runtime, "get")) {
-        descriptor.setProperty(
-            runtime, "get", existingDescObj.getProperty(runtime, "get"));
+        descriptor.setProperty(runtime, "get",
+                               existingDescObj.getProperty(runtime, "get"));
       }
     }
     descriptor.setProperty(runtime, "set", setterFunc);
@@ -531,8 +528,8 @@ protected:
                  const jsi::Value *args, size_t count) -> jsi::Value {
           auto native = Derived::fromValue(rt, thisVal);
           ReturnType result = (native.get()->*getter)();
-          return rnwgpu::JSIConverter<std::decay_t<ReturnType>>::toJSI(rt,
-                                                               std::move(result));
+          return rnwgpu::JSIConverter<std::decay_t<ReturnType>>::toJSI(
+              rt, std::move(result));
         });
 
     auto setterFunc = jsi::Function::createFromHostFunction(
@@ -544,8 +541,8 @@ protected:
             throw jsi::JSError(rt, "Setter requires a value argument");
           }
           auto native = Derived::fromValue(rt, thisVal);
-          auto value =
-              rnwgpu::JSIConverter<std::decay_t<ValueType>>::fromJSI(rt, args[0], false);
+          auto value = rnwgpu::JSIConverter<std::decay_t<ValueType>>::fromJSI(
+              rt, args[0], false);
           (native.get()->*setter)(std::move(value));
           return jsi::Value::undefined();
         });
@@ -580,10 +577,11 @@ private:
       // This requires the method signature to match HostFunction
       return (obj->*method)(runtime, jsi::Value::undefined(), args, count);
     } else {
-      ReturnType result = (obj->*method)(rnwgpu::JSIConverter<std::decay_t<Args>>::fromJSI(
-          runtime, args[Is], Is >= count)...);
-      return rnwgpu::JSIConverter<std::decay_t<ReturnType>>::toJSI(runtime,
-                                                           std::move(result));
+      ReturnType result =
+          (obj->*method)(rnwgpu::JSIConverter<std::decay_t<Args>>::fromJSI(
+              runtime, args[Is], Is >= count)...);
+      return rnwgpu::JSIConverter<std::decay_t<ReturnType>>::toJSI(
+          runtime, std::move(result));
     }
   }
 };

package/cpp/jsi2/Promise.cpp

@@ -10,20 +10,24 @@ namespace rnwgpu {
 
 namespace jsi = facebook::jsi;
 
-Promise::Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter)
-    : runtime(runtime), _resolver(std::move(resolver)), _rejecter(std::move(rejecter)) {}
+Promise::Promise(jsi::Runtime &runtime, jsi::Function &&resolver,
+                 jsi::Function &&rejecter)
+    : runtime(runtime), _resolver(std::move(resolver)),
+      _rejecter(std::move(rejecter)) {}
 
-jsi::Value Promise::createPromise(jsi::Runtime& runtime, RunPromise run) {
+jsi::Value Promise::createPromise(jsi::Runtime &runtime, RunPromise run) {
   // Get Promise ctor from global
   auto promiseCtor = runtime.global().getPropertyAsFunction(runtime, "Promise");
 
   auto promiseCallback = jsi::Function::createFromHostFunction(
       runtime, jsi::PropNameID::forUtf8(runtime, "PromiseCallback"), 2,
-      [=](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments, size_t count) -> jsi::Value {
+      [=](jsi::Runtime &runtime, const jsi::Value &thisValue,
+          const jsi::Value *arguments, size_t count) -> jsi::Value {
         // Call function
         auto resolver = arguments[0].asObject(runtime).asFunction(runtime);
         auto rejecter = arguments[1].asObject(runtime).asFunction(runtime);
-        auto promise = std::make_shared<Promise>(runtime, std::move(resolver), std::move(rejecter));
+        auto promise = std::make_shared<Promise>(runtime, std::move(resolver),
+                                                 std::move(rejecter));
         run(runtime, promise);
 
         return jsi::Value::undefined();
@@ -32,7 +36,7 @@ jsi::Value Promise::createPromise(jsi::Runtime& runtime, RunPromise run) {
   return promiseCtor.callAsConstructor(runtime, promiseCallback);
 }
 
-void Promise::resolve(jsi::Value&& result) {
+void Promise::resolve(jsi::Value &&result) {
   _resolver.call(runtime, std::move(result));
 }