@shopify/react-native-skia 2.6.2 → 2.6.3-next.2

package/cpp/rnwgpu/api/GPUSharedFence.cpp

@@ -0,0 +1,80 @@
+#include "GPUSharedFence.h"
+
+#include <cstdint>
+#include <string>
+
+#if defined(__ANDROID__)
+#include <fcntl.h>
+#endif
+
+namespace rnwgpu {
+
+namespace {
+
+// Kebab-case names matching the shared-fence-* feature strings (see Unions.h /
+// GPUFeatures.h).
+std::string sharedFenceTypeToString(wgpu::SharedFenceType type) {
+  switch (type) {
+  case wgpu::SharedFenceType::MTLSharedEvent:
+    return "mtl-shared-event";
+  case wgpu::SharedFenceType::SyncFD:
+    return "sync-fd";
+  case wgpu::SharedFenceType::VkSemaphoreOpaqueFD:
+    return "vk-semaphore-opaque-fd";
+  case wgpu::SharedFenceType::VkSemaphoreZirconHandle:
+    return "vk-semaphore-zircon-handle";
+  case wgpu::SharedFenceType::DXGISharedHandle:
+    return "dxgi-shared-handle";
+  case wgpu::SharedFenceType::EGLSync:
+    return "egl-sync";
+  default:
+    return "";
+  }
+}
+
+} // namespace
+
+jsi::Value GPUSharedFence::exportInfo(jsi::Runtime &runtime, const jsi::Value &,
+                                      const jsi::Value *, size_t) {
+  wgpu::SharedFenceExportInfo info{};
+  uint64_t handle = 0;
+
+#if defined(__APPLE__)
+  // Apple: the handle is an id<MTLSharedEvent> pointer.
+  wgpu::SharedFenceMTLSharedEventExportInfo mtlInfo{};
+  info.nextInChain = &mtlInfo;
+  _instance.ExportInfo(&info);
+  handle = reinterpret_cast<uint64_t>(mtlInfo.sharedEvent);
+#elif defined(__ANDROID__)
+  // Android: the handle is an OS file descriptor (sync_fd). Dawn's ExportInfo
+  // returns a BORROWED fd: it is owned by the SharedFence and closed when the
+  // fence is destroyed. This exported handle is documented as caller-owned (the
+  // caller must close() it), so dup() it. Without the dup the same fd is closed
+  // twice (once by the caller and once by Dawn on fence destruction), tripping
+  // Android's fdsan (double-close abort).
+  wgpu::SharedFenceSyncFDExportInfo fdInfo{};
+  info.nextInChain = &fdInfo;
+  _instance.ExportInfo(&info);
+  int exportedFd = fdInfo.handle >= 0
+                       ? ::fcntl(fdInfo.handle, F_DUPFD_CLOEXEC, 0)
+                       : fdInfo.handle;
+  handle = static_cast<uint64_t>(static_cast<uint32_t>(exportedFd));
+#else
+  // react-native-skia only targets Apple (Metal) and Android (Vulkan). On any
+  // other platform there is no native handle convention to expose, so fail
+  // loudly rather than handing back a meaningless handle of 0.
+  throw jsi::JSError(runtime,
+                     "GPUSharedFence::export(): unsupported platform (only "
+                     "Apple/Metal and Android/Vulkan are supported)");
+#endif
+
+  jsi::Object result(runtime);
+  result.setProperty(
+      runtime, "type",
+      jsi::String::createFromUtf8(runtime, sharedFenceTypeToString(info.type)));
+  result.setProperty(runtime, "handle",
+                     jsi::BigInt::fromUint64(runtime, handle));
+  return result;
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedFence.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+// Wraps a wgpu::SharedFence: a native GPU sync primitive (id<MTLSharedEvent> on
+// Apple, sync-fd / VkSemaphore on Android).
+class GPUSharedFence : public NativeObject<GPUSharedFence> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUSharedFence";
+
+  explicit GPUSharedFence(wgpu::SharedFence instance, std::string label)
+      : NativeObject(CLASS_NAME), _instance(std::move(instance)),
+        _label(std::move(label)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  // export() -> { type, handle }: exposes the native handle (as a BigInt) so
+  // app code can wait on or signal the fence. The caller owns the returned
+  // handle (e.g. an exported sync-fd must be close()d).
+  jsi::Value exportInfo(jsi::Runtime &runtime, const jsi::Value &thisVal,
+                        const jsi::Value *args, size_t count);
+
+  std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUSharedFence::getBrand);
+    installMethod(runtime, prototype, "export", &GPUSharedFence::exportInfo);
+    installGetterSetter(runtime, prototype, "label", &GPUSharedFence::getLabel,
+                        &GPUSharedFence::setLabel);
+  }
+
+  inline wgpu::SharedFence get() { return _instance; }
+
+private:
+  wgpu::SharedFence _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedTextureMemory.cpp

@@ -0,0 +1,135 @@
+#include "GPUSharedTextureMemory.h"
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "Convertors.h"
+
+namespace rnwgpu {
+
+std::shared_ptr<GPUTexture> GPUSharedTextureMemory::createTexture(
+    std::optional<std::shared_ptr<GPUTextureDescriptor>> descriptor) {
+  if (!descriptor.has_value() || descriptor.value() == nullptr) {
+    auto texture = _instance.CreateTexture();
+    // The texture aliases the shared memory; it doesn't own GPU allocation, so
+    // it doesn't report memory pressure.
+    return std::make_shared<GPUTexture>(texture, "", false);
+  }
+
+  wgpu::TextureDescriptor desc{};
+  Convertor conv;
+  if (!conv(desc, descriptor.value())) {
+    throw std::runtime_error(
+        "GPUSharedTextureMemory::createTexture(): Error with "
+        "GPUTextureDescriptor");
+  }
+  auto texture = _instance.CreateTexture(&desc);
+  return std::make_shared<GPUTexture>(
+      texture, descriptor.value()->label.value_or(""), false);
+}
+
+void GPUSharedTextureMemory::beginAccess(
+    std::shared_ptr<GPUTexture> texture, bool initialized,
+    std::optional<std::vector<std::shared_ptr<GPUSharedFenceState>>> fences) {
+  if (!texture) {
+    throw std::runtime_error(
+        "GPUSharedTextureMemory::beginAccess(): texture is null");
+  }
+  wgpu::SharedTextureMemoryBeginAccessDescriptor desc{};
+  desc.initialized = initialized;
+  desc.concurrentRead = false;
+
+  // Built in lockstep so fenceCount covers both arrays, and kept in locals so
+  // the raw pointers outlive the synchronous BeginAccess() below.
+  std::vector<wgpu::SharedFence> rawFences;
+  std::vector<uint64_t> values;
+  if (fences.has_value()) {
+    for (const auto &state : *fences) {
+      if (state && state->fence) {
+        rawFences.push_back(state->fence->get());
+        values.push_back(state->signaledValue);
+      }
+    }
+  }
+  if (!rawFences.empty()) {
+    desc.fenceCount = rawFences.size();
+    desc.fences = rawFences.data();
+    desc.signaledValues = values.data();
+  } else {
+    desc.fenceCount = 0;
+    desc.fences = nullptr;
+    desc.signaledValues = nullptr;
+  }
+
+#if defined(__ANDROID__)
+  // Dawn's Vulkan backend (AHardwareBuffer) validates that the begin-access
+  // descriptor chains a SharedTextureMemoryVkImageLayoutBeginState specifying
+  // the VkImageLayout to acquire the image into. UNDEFINED (= 0) on both ends
+  // is the canonical "no prior GPU producer" pattern: Dawn performs an
+  // external-queue acquire from VK_QUEUE_FAMILY_EXTERNAL which preserves the
+  // AHB contents, then transitions to whatever layout the texture's actual
+  // usage requires.
+  wgpu::SharedTextureMemoryVkImageLayoutBeginState vkLayout{};
+  vkLayout.oldLayout = 0;
+  vkLayout.newLayout = 0;
+  desc.nextInChain = &vkLayout;
+#endif
+
+  auto status = _instance.BeginAccess(texture->get(), &desc);
+  if (!status) {
+    throw std::runtime_error("GPUSharedTextureMemory::beginAccess() failed");
+  }
+}
+
+jsi::Value GPUSharedTextureMemory::endAccess(jsi::Runtime &runtime,
+                                             const jsi::Value &,
+                                             const jsi::Value *args,
+                                             size_t count) {
+  if (count < 1 || !args[0].isObject()) {
+    throw jsi::JSError(
+        runtime, "GPUSharedTextureMemory::endAccess(): expected (texture)");
+  }
+  auto texture = GPUTexture::fromValue(runtime, args[0]);
+
+  wgpu::SharedTextureMemoryEndAccessState state{};
+
+#if defined(__ANDROID__)
+  // Dawn's Vulkan backend writes the released old/new VkImageLayouts back into
+  // a chained SharedTextureMemoryVkImageLayoutEndState; validation requires
+  // the chain even when the caller doesn't read the values.
+  wgpu::SharedTextureMemoryVkImageLayoutEndState vkLayout{};
+  state.nextInChain = &vkLayout;
+#endif
+
+  auto status = _instance.EndAccess(texture->get(), &state);
+  if (!status) {
+    throw jsi::JSError(runtime, "GPUSharedTextureMemory::endAccess() failed");
+  }
+
+  // Copy each wgpu::SharedFence (ref-counted) into its own GPUSharedFence
+  // wrapper before `state` is destroyed.
+  jsi::Array fences(runtime, state.fenceCount);
+  for (size_t i = 0; i < state.fenceCount; i++) {
+    wgpu::SharedFence fence = state.fences[i];
+    auto wrapper = std::make_shared<GPUSharedFence>(std::move(fence), "");
+    jsi::Object entry(runtime);
+    entry.setProperty(runtime, "fence",
+                      GPUSharedFence::create(runtime, std::move(wrapper)));
+    entry.setProperty(
+        runtime, "signaledValue",
+        jsi::BigInt::fromUint64(runtime, state.signaledValues[i]));
+    fences.setValueAtIndex(runtime, i, std::move(entry));
+  }
+
+  jsi::Object result(runtime);
+  result.setProperty(runtime, "initialized",
+                     jsi::Value(static_cast<bool>(state.initialized)));
+  result.setProperty(runtime, "fences", std::move(fences));
+  return result;
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedTextureMemory.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "jsi2/NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUSharedFence.h"
+#include "GPUTexture.h"
+#include "descriptors/GPUSharedFenceState.h"
+#include "descriptors/GPUTextureDescriptor.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUSharedTextureMemory : public NativeObject<GPUSharedTextureMemory> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUSharedTextureMemory";
+
+  explicit GPUSharedTextureMemory(wgpu::SharedTextureMemory instance,
+                                  std::string label)
+      : NativeObject(CLASS_NAME), _instance(std::move(instance)),
+        _label(std::move(label)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  std::shared_ptr<GPUTexture> createTexture(
+      std::optional<std::shared_ptr<GPUTextureDescriptor>> descriptor);
+
+  // Optional `fences` are wait fences: Dawn waits for each to reach its
+  // signaledValue before writing the surface. Throws on failure.
+  void beginAccess(
+      std::shared_ptr<GPUTexture> texture, bool initialized,
+      std::optional<std::vector<std::shared_ptr<GPUSharedFenceState>>> fences);
+
+  // endAccess(texture) -> { initialized, fences: { fence, signaledValue }[] }
+  // Surfaces the fences Dawn produced for the access. Throws on failure.
+  jsi::Value endAccess(jsi::Runtime &runtime, const jsi::Value &thisVal,
+                       const jsi::Value *args, size_t count);
+
+  std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand",
+                  &GPUSharedTextureMemory::getBrand);
+    installMethod(runtime, prototype, "createTexture",
+                  &GPUSharedTextureMemory::createTexture);
+    installMethod(runtime, prototype, "beginAccess",
+                  &GPUSharedTextureMemory::beginAccess);
+    installMethod(runtime, prototype, "endAccess",
+                  &GPUSharedTextureMemory::endAccess);
+    installGetterSetter(runtime, prototype, "label",
+                        &GPUSharedTextureMemory::getLabel,
+                        &GPUSharedTextureMemory::setLabel);
+  }
+
+  inline const wgpu::SharedTextureMemory get() { return _instance; }
+
+private:
+  wgpu::SharedTextureMemory _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/ImageBitmap.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "jsi2/NativeObject.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+// DRAFT — compile-unverified. Minimal ImageBitmap holding decoded, unpremul
+// RGBA8 pixels plus its dimensions. Produced by the global createImageBitmap()
+// binding (see RNSkManager.cpp). Decoding is done with Skia's own codec, so no
+// platform-specific image decoder is required.
+//
+// FOLLOW-UP: to make an ImageBitmap usable as a copyExternalImageToTexture
+// source, uncomment the `source` field + ImageBitmap converter in
+// rnwgpu/api/descriptors/GPUImageCopyExternalImage.h and upload `data()` in
+// GPUQueue::copyExternalImageToTexture. That GPU wiring is intentionally out of
+// scope for this draft.
+class ImageBitmap : public NativeObject<ImageBitmap> {
+public:
+  static constexpr const char *CLASS_NAME = "ImageBitmap";
+
+  ImageBitmap(std::vector<uint8_t> data, size_t width, size_t height)
+      : NativeObject(CLASS_NAME), _data(std::move(data)), _width(width),
+        _height(height) {}
+
+  size_t getWidth() { return _width; }
+
+  size_t getHeight() { return _height; }
+
+  // Per the spec, close() releases the bitmap's underlying pixels and zeroes
+  // its dimensions. Idempotent.
+  void close() {
+    _data.clear();
+    _data.shrink_to_fit();
+    _width = 0;
+    _height = 0;
+  }
+
+  // Decoded, unpremultiplied RGBA8 pixels (row-major, width*height*4 bytes).
+  const std::vector<uint8_t> &data() const { return _data; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "width", &ImageBitmap::getWidth);
+    installGetter(runtime, prototype, "height", &ImageBitmap::getHeight);
+    installMethod(runtime, prototype, "close", &ImageBitmap::close);
+  }
+
+  size_t getMemoryPressure() override { return _data.size(); }
+
+private:
+  std::vector<uint8_t> _data;
+  size_t _width;
+  size_t _height;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/NativeBufferUtils.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#if defined(__APPLE__)
+#include "AppleNativeBuffer.h"
+#elif defined(__ANDROID__)
+#include <android/hardware_buffer.h>
+#endif
+
+namespace rnwgpu {
+
+// Import a Skia NativeBuffer pointer (a CVPixelBufferRef on Apple, an
+// AHardwareBuffer* on Android, as returned by Skia.NativeBuffer.MakeFromImage /
+// MakeTestBuffer) as a wgpu::SharedTextureMemory on `device`. When non-null,
+// outWidth/outHeight receive the surface dimensions. Returns a null
+// SharedTextureMemory if the import itself fails (the caller decides how to
+// report that); throws std::runtime_error for pre-import failures (a buffer
+// with no IOSurface, or an unsupported platform).
+//
+// The platform-specific chained descriptor only needs to outlive the
+// ImportSharedTextureMemory call, so it lives entirely within this function.
+// Shared by GPUDevice::importSharedTextureMemory and
+// GPUExternalTexture::Create.
+inline wgpu::SharedTextureMemory importNativeBufferAsSharedTextureMemory(
+    const wgpu::Device &device, void *bufferPtr, const std::string &label,
+    uint32_t *outWidth, uint32_t *outHeight) {
+  wgpu::SharedTextureMemoryDescriptor memDesc{};
+  if (!label.empty()) {
+    memDesc.label = wgpu::StringView(label.c_str(), label.size());
+  }
+
+  uint32_t width = 0;
+  uint32_t height = 0;
+  wgpu::SharedTextureMemory memory;
+
+#if defined(__APPLE__)
+  // Skia's NativeBuffer is a CVPixelBufferRef; extract its backing IOSurface
+  // (and dimensions) in Objective-C++ since CoreVideo isn't available here.
+  void *ioSurface = GetIOSurfaceFromNativeBuffer(bufferPtr, &width, &height);
+  if (ioSurface == nullptr) {
+    throw std::runtime_error(
+        "importNativeBufferAsSharedTextureMemory(): native "
+        "buffer has no IOSurface");
+  }
+  wgpu::SharedTextureMemoryIOSurfaceDescriptor platformDesc{};
+  platformDesc.ioSurface = ioSurface;
+  // Default off: enabling it propagates StorageBinding into properties.usage,
+  // which then forces memory.createTexture() (no-descriptor form) to validate
+  // the format against storage capabilities. bgra8unorm (the standard
+  // CVPixelBuffer format) only supports storage when the device opts into the
+  // bgra8unorm-storage feature, so unconditionally setting this here breaks the
+  // common sample-only case.
+  platformDesc.allowStorageBinding = false;
+  memDesc.nextInChain = &platformDesc;
+  memory = device.ImportSharedTextureMemory(&memDesc);
+#elif defined(__ANDROID__)
+  auto *ahb = reinterpret_cast<AHardwareBuffer *>(bufferPtr);
+  AHardwareBuffer_Desc ahbDesc = {};
+  AHardwareBuffer_describe(ahb, &ahbDesc);
+  width = ahbDesc.width;
+  height = ahbDesc.height;
+  wgpu::SharedTextureMemoryAHardwareBufferDescriptor platformDesc{};
+  platformDesc.handle = ahb;
+  memDesc.nextInChain = &platformDesc;
+  memory = device.ImportSharedTextureMemory(&memDesc);
+#else
+  (void)device;
+  (void)bufferPtr;
+  throw std::runtime_error(
+      "importNativeBufferAsSharedTextureMemory(): unsupported platform");
+#endif
+
+  if (outWidth != nullptr) {
+    *outWidth = width;
+  }
+  if (outHeight != nullptr) {
+    *outHeight = height;
+  }
+  return memory;
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBindGroupEntry.h

@@ -20,7 +20,7 @@ struct GPUBindGroupEntry {
   std::shared_ptr<GPUSampler> sampler = nullptr;
   std::shared_ptr<GPUTextureView> textureView = nullptr;
   std::shared_ptr<GPUBufferBinding> buffer = nullptr;
-  // external textures
+  std::shared_ptr<GPUExternalTexture> externalTexture = nullptr;
 };
 
 } // namespace rnwgpu
@@ -45,6 +45,9 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupEntry>> {
           } else if (obj.hasNativeState<rnwgpu::GPUTextureView>(runtime)) {
             result->textureView =
                 obj.getNativeState<rnwgpu::GPUTextureView>(runtime);
+          } else if (obj.hasNativeState<rnwgpu::GPUExternalTexture>(runtime)) {
+            result->externalTexture =
+                obj.getNativeState<rnwgpu::GPUExternalTexture>(runtime);
           } else if (obj.hasNativeState<rnwgpu::GPUBuffer>(runtime)) {
             auto binding = std::make_shared<rnwgpu::GPUBufferBinding>();
             binding->buffer = obj.getNativeState<rnwgpu::GPUBuffer>(runtime);

package/cpp/rnwgpu/api/descriptors/GPUCanvasConfiguration.h

@@ -7,7 +7,7 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "GPUDevice.h"
+#include "rnwgpu/api/GPUDevice.h"
 
 namespace jsi = facebook::jsi;
 

package/cpp/rnwgpu/api/descriptors/GPUDawnTogglesDescriptor.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// Non-standard, Dawn-only. Mirrors wgpu::DawnTogglesDescriptor field-for-field
+// so the mapping to the native chained struct is 1:1. Chained onto the
+// wgpu::DeviceDescriptor in GPUAdapter::requestDevice.
+struct GPUDawnTogglesDescriptor {
+  std::optional<std::vector<std::string>> enabledToggles;  // Iterable<string>
+  std::optional<std::vector<std::string>> disabledToggles; // Iterable<string>
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUDawnTogglesDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "enabledToggles")) {
+        auto prop = value.getProperty(runtime, "enabledToggles");
+        result->enabledToggles =
+            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "disabledToggles")) {
+        auto prop = value.getProperty(runtime, "disabledToggles");
+        result->disabledToggles =
+            JSIConverter<std::optional<std::vector<std::string>>>::fromJSI(
+                runtime, prop, false);
+      }
+    }
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUDawnTogglesDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUDawnTogglesDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUDeviceDescriptor.h

@@ -9,6 +9,7 @@
 
 #include "jsi2/JSIConverter.h"
 
+#include "GPUDawnTogglesDescriptor.h"
 #include "GPUQueueDescriptor.h"
 
 namespace jsi = facebook::jsi;
@@ -23,6 +24,9 @@ struct GPUDeviceDescriptor {
   std::optional<std::shared_ptr<GPUQueueDescriptor>>
       defaultQueue;                 // GPUQueueDescriptor
   std::optional<std::string> label; // string
+  // Non-standard Dawn-only device toggles, chained onto the wgpu::Device
+  // descriptor in GPUAdapter::requestDevice.
+  std::optional<std::shared_ptr<GPUDawnTogglesDescriptor>> dawnToggles;
 };
 
 } // namespace rnwgpu
@@ -86,6 +90,12 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUDeviceDescriptor>> {
         result->label = JSIConverter<std::optional<std::string>>::fromJSI(
             runtime, prop, false);
       }
+      if (value.hasProperty(runtime, "dawnToggles")) {
+        auto prop = value.getProperty(runtime, "dawnToggles");
+        result->dawnToggles = JSIConverter<std::optional<
+            std::shared_ptr<GPUDawnTogglesDescriptor>>>::fromJSI(runtime, prop,
+                                                                 false);
+      }
     }
 
     return result;