@shopify/react-native-skia 2.10.0 → 2.10.2

package/cpp/api/JsiSkTypefaceFactory.h

@@ -2,10 +2,13 @@
 
 #include <memory>
 #include <utility>
+#include <variant>
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkData.h"
+#include "JsiSkFontMgrFactory.h"
 #include "JsiSkNativeObjects.h"
 #include "JsiSkTypeface.h"
 
@@ -17,22 +20,21 @@ class JsiSkTypefaceFactory : public JsiSkNativeObject<JsiSkTypefaceFactory> {
 public:
   static constexpr const char *CLASS_NAME = "TypefaceFactory";
 
-  JSI_HOST_FUNCTION(MakeFreeTypeFaceFromData) {
-    auto data = JsiSkData::fromValue(runtime, arguments[0]);
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkTypeface>>
+  MakeFreeTypeFaceFromData(sk_sp<SkData> data) {
     auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
     auto typeface = fontMgr->makeFromData(std::move(data));
     if (typeface == nullptr) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    return makeJsiObject(runtime, std::make_shared<JsiSkTypeface>(
-                                      getContext(), std::move(typeface)));
+    return std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
   }
 
   size_t getMemoryPressure() override { return 1024; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "MakeFreeTypeFaceFromData",
-                      &JsiSkTypefaceFactory::MakeFreeTypeFaceFromData);
+    installMethod(runtime, prototype, "MakeFreeTypeFaceFromData",
+                  &JsiSkTypefaceFactory::MakeFreeTypeFaceFromData);
   }
 
   explicit JsiSkTypefaceFactory(std::shared_ptr<RNSkPlatformContext> context)

package/cpp/api/JsiSkTypefaceFontProvider.h

@@ -1,10 +1,13 @@
 #pragma once
 
 #include <memory>
+#include <optional>
+#include <string>
 #include <utility>
 
 #include <jsi/jsi.h>
 
+#include "JsiSkConverters.h"
 #include "JsiSkFontStyle.h"
 #include "JsiSkNativeObjects.h"
 #include "JsiSkTypeface.h"
@@ -30,18 +33,16 @@ class JsiSkTypefaceFontProvider
 public:
   static constexpr const char *CLASS_NAME = "TypefaceFontProvider";
 
-  JSI_HOST_FUNCTION(registerFont) {
-    sk_sp<SkTypeface> typeface =
-        JsiSkTypeface::fromValue(runtime, arguments[0]);
-    SkString familyName(arguments[1].asString(runtime).utf8(runtime).c_str());
+  void registerFont(sk_sp<SkTypeface> typeface, std::string familyNameStr) {
+    SkString familyName(familyNameStr.c_str());
     getObject()->registerTypeface(typeface, familyName);
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(matchFamilyStyle) {
-    auto name = count > 0 ? arguments[0].asString(runtime).utf8(runtime) : "";
-    auto fontStyle =
-        count > 1 ? JsiSkFontStyle::fromValue(runtime, arguments[1]) : nullptr;
+  std::shared_ptr<JsiSkTypeface>
+  matchFamilyStyle(std::optional<std::string> nameParam,
+                   std::optional<std::shared_ptr<SkFontStyle>> fontStyleParam) {
+    auto name = nameParam.value_or("");
+    auto fontStyle = fontStyleParam.value_or(nullptr);
     if (name == "" || fontStyle == nullptr) {
       throw std::runtime_error("matchFamilyStyle requires a name and a style");
     }
@@ -53,17 +54,15 @@ public:
     if (!typeface) {
       throw std::runtime_error("Could not find font style for " + name);
     }
-    return makeJsiObject(runtime, std::make_shared<JsiSkTypeface>(
-                                      getContext(), std::move(typeface)));
+    return std::make_shared<JsiSkTypeface>(getContext(), std::move(typeface));
   }
 
-  JSI_HOST_FUNCTION(countFamilies) { return getObject()->countFamilies(); }
+  int countFamilies() { return getObject()->countFamilies(); }
 
-  JSI_HOST_FUNCTION(getFamilyName) {
-    auto i = static_cast<int>(arguments[0].asNumber());
+  std::string getFamilyName(int i) {
     SkString name;
     getObject()->getFamilyName(i, &name);
-    return jsi::String::createFromUtf8(runtime, name.c_str());
+    return std::string(name.c_str());
   }
 
   JsiSkTypefaceFontProvider(std::shared_ptr<RNSkPlatformContext> context,
@@ -92,14 +91,14 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "registerFont",
-                      &JsiSkTypefaceFontProvider::registerFont);
-    installHostMethod(runtime, prototype, "matchFamilyStyle",
-                      &JsiSkTypefaceFontProvider::matchFamilyStyle);
-    installHostMethod(runtime, prototype, "countFamilies",
-                      &JsiSkTypefaceFontProvider::countFamilies);
-    installHostMethod(runtime, prototype, "getFamilyName",
-                      &JsiSkTypefaceFontProvider::getFamilyName);
+    installMethod(runtime, prototype, "registerFont",
+                  &JsiSkTypefaceFontProvider::registerFont);
+    installMethod(runtime, prototype, "matchFamilyStyle",
+                  &JsiSkTypefaceFontProvider::matchFamilyStyle);
+    installMethod(runtime, prototype, "countFamilies",
+                  &JsiSkTypefaceFontProvider::countFamilies);
+    installMethod(runtime, prototype, "getFamilyName",
+                  &JsiSkTypefaceFontProvider::getFamilyName);
   }
 };
 

package/cpp/api/JsiSkTypefaceFontProviderFactory.h

@@ -19,17 +19,16 @@ class JsiSkTypefaceFontProviderFactory
 public:
   static constexpr const char *CLASS_NAME = "TypefaceFontProviderFactory";
 
-  JSI_HOST_FUNCTION(Make) {
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkTypefaceFontProvider>(
-                     getContext(), sk_make_sp<para::TypefaceFontProvider>()));
+  std::shared_ptr<JsiSkTypefaceFontProvider> Make() {
+    return std::make_shared<JsiSkTypefaceFontProvider>(
+        getContext(), sk_make_sp<para::TypefaceFontProvider>());
   }
 
   size_t getMemoryPressure() override { return 2048; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
-    installHostMethod(runtime, prototype, "Make",
-                      &JsiSkTypefaceFontProviderFactory::Make);
+    installMethod(runtime, prototype, "Make",
+                  &JsiSkTypefaceFontProviderFactory::Make);
   }
 
   explicit JsiSkTypefaceFontProviderFactory(

package/cpp/api/JsiSkVertices.h

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "JsiSkNativeObjects.h"
+#include "JsiSkRect.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -28,15 +29,12 @@ public:
       : JsiSkWrappingSkPtrNativeObject<JsiSkVertices, SkVertices>(
             std::move(context), std::move(vertices)) {}
 
-  JSI_HOST_FUNCTION(bounds) {
+  std::shared_ptr<JsiSkRect> bounds() {
     const auto &result = getObject()->bounds();
-    return makeJsiObject(runtime,
-                         std::make_shared<JsiSkRect>(getContext(), result));
+    return std::make_shared<JsiSkRect>(getContext(), result);
   }
 
-  JSI_HOST_FUNCTION(uniqueID) {
-    return static_cast<double>(getObject()->uniqueID());
-  }
+  double uniqueID() { return static_cast<double>(getObject()->uniqueID()); }
 
   size_t getMemoryPressure() override {
     auto vertices = getObject();
@@ -54,8 +52,8 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "bounds", &JsiSkVertices::bounds);
-    installHostMethod(runtime, prototype, "uniqueID", &JsiSkVertices::uniqueID);
+    installMethod(runtime, prototype, "bounds", &JsiSkVertices::bounds);
+    installMethod(runtime, prototype, "uniqueID", &JsiSkVertices::uniqueID);
   }
 
   /**

package/cpp/api/JsiSkiaContext.h

@@ -3,8 +3,10 @@
 #include <memory>
 #include <numeric>
 #include <utility>
+#include <variant>
 #include <vector>
 
+#include "JsiSkConverters.h"
 #include "JsiSkNativeObjects.h"
 #include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
@@ -12,6 +14,7 @@
 #include "JsiSkPaint.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRect.h"
+#include "JsiSkSurface.h"
 #include "JsiSkTypeface.h"
 
 #include "rnskia/RNWindowContext.h"
@@ -33,25 +36,21 @@ class JsiSkiaContext
 public:
   static constexpr const char *CLASS_NAME = "SkiaContext";
 
-  JSI_HOST_FUNCTION(getSurface) {
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkSurface>> getSurface() {
     auto surface = getObject()->getSurface();
     if (surface == nullptr) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    return makeJsiObject(runtime, std::make_shared<JsiSkSurface>(
-                                      getContext(), std::move(surface)));
+    return std::make_shared<JsiSkSurface>(getContext(), std::move(surface));
   }
 
-  JSI_HOST_FUNCTION(present) {
-    getObject()->present();
-    return jsi::Value::undefined();
-  }
+  void present() { getObject()->present(); }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "getSurface",
-                      &JsiSkiaContext::getSurface);
-    installHostMethod(runtime, prototype, "present", &JsiSkiaContext::present);
+    installMethod(runtime, prototype, "getSurface",
+                  &JsiSkiaContext::getSurface);
+    installMethod(runtime, prototype, "present", &JsiSkiaContext::present);
   }
 
   JsiSkiaContext(std::shared_ptr<RNSkPlatformContext> context,

package/cpp/api/JsiVideo.h

@@ -1,29 +1,17 @@
 #pragma once
 
 #include <memory>
-#include <numeric>
 #include <utility>
-#include <vector>
+#include <variant>
 
 #include "JsiSkNativeObjects.h"
-#include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
-#include "JsiSkPaint.h"
-#include "JsiSkPoint.h"
-#include "JsiSkRect.h"
-#include "JsiSkTypeface.h"
+#include "JsiSkConverters.h"
+#include "JsiSkImage.h"
 
 #include "rnskia/RNSkVideo.h"
 
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#include "include/core/SkFont.h"
-#include "include/core/SkFontMetrics.h"
-
-#pragma clang diagnostic pop
-
 namespace RNSkia {
 
 namespace jsi = facebook::jsi;
@@ -33,83 +21,55 @@ class JsiVideo
 public:
   static constexpr const char *CLASS_NAME = "Video";
 
-  JSI_HOST_FUNCTION(nextImage) {
+  std::variant<std::nullptr_t, std::shared_ptr<JsiSkImage>> nextImage() {
     double timestamp = 0;
-    auto video = getObject();
-    auto image = video->nextImage(&timestamp);
+    auto image = getObject()->nextImage(&timestamp);
     if (!image) {
-      return jsi::Value::null();
+      return nullptr;
     }
-    return makeJsiObject(
-        runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
+    return std::make_shared<JsiSkImage>(getContext(), std::move(image));
   }
 
-  JSI_HOST_FUNCTION(duration) { return getObject()->duration(); }
+  double duration() { return getObject()->duration(); }
 
-  JSI_HOST_FUNCTION(framerate) { return getObject()->framerate(); }
+  double framerate() { return getObject()->framerate(); }
 
-  JSI_HOST_FUNCTION(currentTime) { return getObject()->currentTime(); }
+  double currentTime() { return getObject()->currentTime(); }
 
-  JSI_HOST_FUNCTION(isPlaying) { return getObject()->isPlaying(); }
+  bool isPlaying() { return getObject()->isPlaying(); }
 
-  JSI_HOST_FUNCTION(seek) {
-    double timestamp = arguments[0].asNumber();
-    getObject()->seek(timestamp);
-    return jsi::Value::undefined();
-  }
+  void seek(double timestamp) { getObject()->seek(timestamp); }
 
-  JSI_HOST_FUNCTION(rotation) {
-    auto context = getContext();
-    auto rot = getObject()->getRotationInDegrees();
-    return jsi::Value(static_cast<double>(rot));
+  double rotation() {
+    return static_cast<double>(getObject()->getRotationInDegrees());
   }
 
-  JSI_HOST_FUNCTION(size) {
-    auto context = getContext();
-    auto size = getObject()->getSize();
-    auto result = jsi::Object(runtime);
-    result.setProperty(runtime, "width", static_cast<double>(size.width()));
-    result.setProperty(runtime, "height", static_cast<double>(size.height()));
-    return result;
-  }
+  SkISize size() { return getObject()->getSize(); }
 
-  JSI_HOST_FUNCTION(play) {
-    getObject()->play();
-    return jsi::Value::undefined();
-  }
+  void play() { getObject()->play(); }
 
-  JSI_HOST_FUNCTION(pause) {
-    getObject()->pause();
-    return jsi::Value::undefined();
-  }
+  void pause() { getObject()->pause(); }
 
-  JSI_HOST_FUNCTION(setVolume) {
-    auto volume = arguments[0].asNumber();
+  void setVolume(double volume) {
     getObject()->setVolume(static_cast<float>(volume));
-    return jsi::Value::undefined();
   }
 
-  JSI_HOST_FUNCTION(setLooping) {
-    auto looping = arguments[0].asBool();
-    getObject()->setLooping(looping);
-    return jsi::Value::undefined();
-  }
+  void setLooping(bool looping) { getObject()->setLooping(looping); }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installCommon(runtime, prototype);
-    installHostMethod(runtime, prototype, "nextImage", &JsiVideo::nextImage);
-    installHostMethod(runtime, prototype, "duration", &JsiVideo::duration);
-    installHostMethod(runtime, prototype, "framerate", &JsiVideo::framerate);
-    installHostMethod(runtime, prototype, "currentTime",
-                      &JsiVideo::currentTime);
-    installHostMethod(runtime, prototype, "isPlaying", &JsiVideo::isPlaying);
-    installHostMethod(runtime, prototype, "seek", &JsiVideo::seek);
-    installHostMethod(runtime, prototype, "rotation", &JsiVideo::rotation);
-    installHostMethod(runtime, prototype, "size", &JsiVideo::size);
-    installHostMethod(runtime, prototype, "play", &JsiVideo::play);
-    installHostMethod(runtime, prototype, "pause", &JsiVideo::pause);
-    installHostMethod(runtime, prototype, "setVolume", &JsiVideo::setVolume);
-    installHostMethod(runtime, prototype, "setLooping", &JsiVideo::setLooping);
+    installMethod(runtime, prototype, "nextImage", &JsiVideo::nextImage);
+    installMethod(runtime, prototype, "duration", &JsiVideo::duration);
+    installMethod(runtime, prototype, "framerate", &JsiVideo::framerate);
+    installMethod(runtime, prototype, "currentTime", &JsiVideo::currentTime);
+    installMethod(runtime, prototype, "isPlaying", &JsiVideo::isPlaying);
+    installMethod(runtime, prototype, "seek", &JsiVideo::seek);
+    installMethod(runtime, prototype, "rotation", &JsiVideo::rotation);
+    installMethod(runtime, prototype, "size", &JsiVideo::size);
+    installMethod(runtime, prototype, "play", &JsiVideo::play);
+    installMethod(runtime, prototype, "pause", &JsiVideo::pause);
+    installMethod(runtime, prototype, "setVolume", &JsiVideo::setVolume);
+    installMethod(runtime, prototype, "setLooping", &JsiVideo::setLooping);
   }
 
   JsiVideo(std::shared_ptr<RNSkPlatformContext> context,

package/cpp/jsi/EnumMapper.h

@@ -3,7 +3,7 @@
 #include <stdexcept>
 #include <string>
 
-namespace rnwgpu {
+namespace RNJsi {
 
 namespace EnumMapper {
 // Add these two methods in namespace "EnumMapper" to allow parsing a custom
@@ -60,4 +60,4 @@ static void convertEnumToJSUnion(TEnum, std::string *) {
 }
 } // namespace EnumMapper
 
-} // namespace rnwgpu
+} // namespace RNJsi

package/cpp/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)
@@ -30,7 +25,7 @@
 #include <cxxabi.h>
 #endif
 
-namespace rnwgpu {
+namespace RNJsi {
 
 namespace jsi = facebook::jsi;
 
@@ -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,
@@ -526,4 +495,4 @@ template <> struct JSIConverter<std::unordered_set<std::string>> {
   }
 };
 
-} // namespace rnwgpu
+} // namespace RNJsi

package/cpp/jsi/NativeObject.h

@@ -18,14 +18,14 @@
 #include "jsi/RuntimeAwareCache.h" // Use Skia's RuntimeAwareCache
 
 // Forward declare to avoid circular dependency
-namespace rnwgpu {
+namespace RNJsi {
 template <typename ArgType, typename SFINAE> struct JSIConverter;
-} // namespace rnwgpu
+} // namespace RNJsi
 
 // Include the converter - must come after forward declaration
 #include "JSIConverter.h"
 
-namespace rnwgpu {
+namespace RNJsi {
 
 namespace jsi = facebook::jsi;
 
@@ -392,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,
@@ -401,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);
         });
@@ -421,7 +426,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 callMethodWithRuntime(native.get(), method, rt, args,
                                        std::index_sequence_for<Args...>{},
                                        count);
@@ -441,13 +446,13 @@ 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();
           } else {
             ReturnType result = (native.get()->*getter)();
-            return rnwgpu::JSIConverter<std::decay_t<ReturnType>>::toJSI(
+            return RNJsi::JSIConverter<std::decay_t<ReturnType>>::toJSI(
                 rt, std::move(result));
           }
         });
@@ -481,8 +486,8 @@ protected:
           if (count < 1) {
             throw jsi::JSError(rt, "Setter requires a value argument");
           }
-          auto native = Derived::fromValue(rt, thisVal);
-          auto value = rnwgpu::JSIConverter<std::decay_t<ValueType>>::fromJSI(
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
+          auto value = RNJsi::JSIConverter<std::decay_t<ValueType>>::fromJSI(
               rt, args[0], false);
           (native.get()->*setter)(std::move(value));
           return jsi::Value::undefined();
@@ -528,9 +533,9 @@ 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(
+          return RNJsi::JSIConverter<std::decay_t<ReturnType>>::toJSI(
               rt, std::move(result));
         });
 
@@ -542,8 +547,8 @@ protected:
           if (count < 1) {
             throw jsi::JSError(rt, "Setter requires a value argument");
           }
-          auto native = Derived::fromValue(rt, thisVal);
-          auto value = rnwgpu::JSIConverter<std::decay_t<ValueType>>::fromJSI(
+          auto native = NativeObject<Derived>::fromValue(rt, thisVal);
+          auto value = RNJsi::JSIConverter<std::decay_t<ValueType>>::fromJSI(
               rt, args[0], false);
           (native.get()->*setter)(std::move(value));
           return jsi::Value::undefined();
@@ -574,9 +579,9 @@ private:
                         jsi::Runtime &runtime, const jsi::Value *args,
                         std::index_sequence<Is...>, size_t count) {
     ReturnType result = (obj->*method)(
-        runtime, rnwgpu::JSIConverter<std::decay_t<Args>>::fromJSI(
+        runtime, RNJsi::JSIConverter<std::decay_t<Args>>::fromJSI(
                      runtime, args[Is], Is >= count)...);
-    return rnwgpu::JSIConverter<std::decay_t<ReturnType>>::toJSI(
+    return RNJsi::JSIConverter<std::decay_t<ReturnType>>::toJSI(
         runtime, std::move(result));
   }
 
@@ -587,7 +592,7 @@ private:
                                jsi::Runtime &runtime, const jsi::Value *args,
                                std::index_sequence<Is...>, size_t count) {
     if constexpr (std::is_same_v<ReturnType, void>) {
-      (obj->*method)(rnwgpu::JSIConverter<std::decay_t<Args>>::fromJSI(
+      (obj->*method)(RNJsi::JSIConverter<std::decay_t<Args>>::fromJSI(
           runtime, args[Is], Is >= count)...);
       return jsi::Value::undefined();
     } else if constexpr (std::is_same_v<ReturnType, jsi::Value>) {
@@ -596,9 +601,9 @@ private:
       return (obj->*method)(runtime, jsi::Value::undefined(), args, count);
     } else {
       ReturnType result =
-          (obj->*method)(rnwgpu::JSIConverter<std::decay_t<Args>>::fromJSI(
+          (obj->*method)(RNJsi::JSIConverter<std::decay_t<Args>>::fromJSI(
               runtime, args[Is], Is >= count)...);
-      return rnwgpu::JSIConverter<std::decay_t<ReturnType>>::toJSI(
+      return RNJsi::JSIConverter<std::decay_t<ReturnType>>::toJSI(
           runtime, std::move(result));
     }
   }
@@ -611,4 +616,4 @@ template <typename T>
 struct is_native_object<std::shared_ptr<T>>
     : std::bool_constant<std::is_base_of_v<NativeObject<T>, T>> {};
 
-} // namespace rnwgpu
+} // namespace RNJsi

package/cpp/jsi/Promise.cpp

@@ -6,7 +6,7 @@
 #include <utility>
 #include <vector>
 
-namespace rnwgpu {
+namespace RNJsi {
 
 namespace jsi = facebook::jsi;
 
@@ -45,4 +45,4 @@ void Promise::reject(std::string message) {
   _rejecter.call(runtime, error.value());
 }
 
-} // namespace rnwgpu
+} // namespace RNJsi

package/cpp/jsi/Promise.h

@@ -6,7 +6,7 @@
 #include <utility>
 #include <vector>
 
-namespace rnwgpu {
+namespace RNJsi {
 
 namespace jsi = facebook::jsi;
 
@@ -34,4 +34,4 @@ public:
   static jsi::Value createPromise(jsi::Runtime &runtime, RunPromise run);
 };
 
-} // namespace rnwgpu
+} // namespace RNJsi

package/cpp/rnskia/RNDawnContext.h

@@ -366,8 +366,9 @@ private:
   std::mutex _mutex;
 
   DawnContext() {
-    DawnProcTable backendProcs = dawn::native::GetProcs();
-    dawnProcSetProcs(&backendProcs);
+    // No dawnProcSetProcs() here: the monolithic libwebgpu_dawn (shared with
+    // react-native-webgpu) exposes the real wgpu* C entry points directly
+    // rather than the settable dawn_proc trampoline, which it does not ship.
     static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
 
     wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
@@ -376,6 +377,21 @@ private:
     // For limits:
     wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
     instanceDesc.requiredLimits = &limits;
+
+    // Same instance-stage toggles react-native-webgpu sets on its own
+    // instance: when webgpu adopts this instance (rnskia_getWGPUInstance),
+    // its external-texture path expects experimental adapter features to be
+    // visible. These only un-hide features in adapter.features; nothing
+    // becomes active unless a device requests it.
+    static const char *const kInstanceToggles[] = {
+        "allow_unsafe_apis",
+        "expose_wgsl_experimental_features",
+    };
+    wgpu::DawnTogglesDescriptor instanceToggles;
+    instanceToggles.enabledToggleCount = std::size(kInstanceToggles);
+    instanceToggles.enabledToggles = kInstanceToggles;
+    instanceDesc.nextInChain = &instanceToggles;
+
     instance = std::make_unique<dawn::native::Instance>(&instanceDesc);
 
     backendContext = DawnUtils::createDawnBackendContext(instance.get());