@shopify/react-native-skia 2.10.0 → 2.10.1

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/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/jsi/NativeObject.h

@@ -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,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();
@@ -481,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));
@@ -528,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));
@@ -542,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/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());

package/cpp/rnskia/RNDawnInterop.cpp

@@ -0,0 +1,19 @@
+#ifdef SK_GRAPHITE
+
+#include "RNDawnContext.h"
+
+// Runtime discovery surface for react-native-webgpu.
+//
+// webgpu looks this symbol up with dlsym(RTLD_DEFAULT, ...) when it creates
+// its GPU object and, when found, adopts the returned instance instead of
+// creating its own. Sharing one wgpu::Instance across both packages makes
+// pointer-based device handoff (RNWebGPU.importDevice(Skia.getNativeDevice()))
+// sound: async callbacks of imported devices settle on the instance webgpu
+// pumps. Plain C, default visibility: no C++ ABI surface, works across
+// separately compiled pods, and stays dlsym-able under -fvisibility=hidden.
+extern "C" __attribute__((visibility("default"))) WGPUInstance
+rnskia_getWGPUInstance() {
+  return RNSkia::DawnContext::getInstance().getWGPUInstance().Get();
+}
+
+#endif

package/cpp/rnskia/RNDawnUtils.h

@@ -1,8 +1,11 @@
 #pragma once
 
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
 #include "webgpu/webgpu_cpp.h"
 
-#include "dawn/dawn_proc.h"
 #include "dawn/native/DawnNative.h"
 
 #include "include/core/SkColorType.h"
@@ -115,6 +118,20 @@ requestDevice(dawn::native::Adapter &nativeAdapter,
   wgpu::DawnTogglesDescriptor togglesDesc;
   togglesDesc.enabledToggleCount = std::size(kToggles);
   togglesDesc.enabledToggles = kToggles;
+#if defined(TARGET_OS_SIMULATOR) && TARGET_OS_SIMULATOR
+  // The iOS Simulator only advertises MTLFeatureSet_iOS_GPUFamily2, so Dawn
+  // defaults disable_base_instance/disable_base_vertex on and then rejects
+  // every draw with a non-zero firstInstance or baseVertex, which Graphite
+  // emits routinely. The simulator forwards Metal calls to the host GPU,
+  // which does support base vertex/instance drawing, so force the toggles
+  // off. Device builds are unaffected: Graphite-capable iPhones and iPads
+  // are all GPUFamily3+. (Same override as react-native-webgpu; see
+  // https://issues.chromium.org/issues/42241591.)
+  static constexpr const char *kDisabledToggles[] = {"disable_base_instance",
+                                                     "disable_base_vertex"};
+  togglesDesc.disabledToggleCount = std::size(kDisabledToggles);
+  togglesDesc.disabledToggles = kDisabledToggles;
+#endif
 
   wgpu::DeviceDescriptor desc;
   desc.requiredFeatureCount = features.size();