@shopify/react-native-skia 2.6.4 → 2.6.6

package/cpp/api/JsiSkiaContext.h

@@ -6,7 +6,7 @@
 #include <vector>
 
 #include "JsiSkHostObjects.h"
-#include "RNSkLog.h"
+#include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
 #include "JsiSkPaint.h"
@@ -14,7 +14,7 @@
 #include "JsiSkRect.h"
 #include "JsiSkTypeface.h"
 
-#include "RNWindowContext.h"
+#include "rnskia/RNWindowContext.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"

package/cpp/api/JsiTextureInfo.h

@@ -2,7 +2,7 @@
 
 #include <jsi/jsi.h>
 
-#include "RNSkPlatformContext.h"
+#include "rnskia/RNSkPlatformContext.h"
 
 namespace jsi = facebook::jsi;
 namespace react = facebook::react;

package/cpp/api/JsiVideo.h

@@ -6,7 +6,7 @@
 #include <vector>
 
 #include "JsiSkHostObjects.h"
-#include "RNSkLog.h"
+#include "utils/RNSkLog.h"
 #include <jsi/jsi.h>
 
 #include "JsiSkPaint.h"
@@ -14,7 +14,7 @@
 #include "JsiSkRect.h"
 #include "JsiSkTypeface.h"
 
-#include "RNSkVideo.h"
+#include "rnskia/RNSkVideo.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"

package/cpp/api/recorder/Drawings.h

@@ -6,7 +6,7 @@
 #include "Convertor.h"
 #include "DrawingCtx.h"
 #include "ImageFit.h"
-#include "RNSkPlatformContext.h"
+#include "rnskia/RNSkPlatformContext.h"
 
 #include "include/core/SkPathBuilder.h"
 #include "include/core/SkStrokeRec.h"

package/cpp/api/recorder/JsiRecorder.h

@@ -5,13 +5,13 @@
 #include <utility>
 #include <vector>
 
-#include "JsiSkCanvas.h"
-#include "JsiSkHostObjects.h"
-#include "JsiSkPicture.h"
+#include "api/JsiSkCanvas.h"
+#include "api/JsiSkHostObjects.h"
+#include "api/JsiSkPicture.h"
 
 #include "DrawingCtx.h"
 #include "RNRecorder.h"
-#include "RNSkLog.h"
+#include "utils/RNSkLog.h"
 
 #include <jsi/jsi.h>
 

package/cpp/api/recorder/RNRecorder.h

@@ -17,7 +17,7 @@
 #include "ImageFilters.h"
 #include "Paint.h"
 #include "PathEffects.h"
-#include "RNSkPlatformContext.h"
+#include "rnskia/RNSkPlatformContext.h"
 #include "Shaders.h"
 
 namespace RNSkia {

package/cpp/jsi/ViewProperty.h

@@ -7,7 +7,7 @@
 #include <string>
 #include <variant>
 
-#include "JsiSkPicture.h"
+#include "api/JsiSkPicture.h"
 #include "RuntimeLifecycleMonitor.h"
 
 namespace RNJsi {

package/cpp/rnskia/RNDawnContext.h

@@ -138,6 +138,15 @@ public:
     wgpu::SharedTextureMemoryBeginAccessDescriptor beginAccessDesc;
     beginAccessDesc.initialized = true;
     beginAccessDesc.fenceCount = 0;
+#if defined(__ANDROID__)
+    // Dawn's Vulkan backend requires the acquired VkImageLayout to be chained.
+    // UNDEFINED (= 0) on both ends is the canonical "no prior GPU producer"
+    // pattern (matches GPUSharedTextureMemory::beginAccess).
+    wgpu::SharedTextureMemoryVkImageLayoutBeginState vkBegin = {};
+    vkBegin.oldLayout = 0;
+    vkBegin.newLayout = 0;
+    beginAccessDesc.nextInChain = &vkBegin;
+#endif
     bool success = memory.BeginAccess(texture, &beginAccessDesc);
 
     if (success) {
@@ -149,6 +158,10 @@ public:
           [](void *context) {
             auto ctx = static_cast<SharedTextureContext *>(context);
             wgpu::SharedTextureMemoryEndAccessState endState = {};
+#if defined(__ANDROID__)
+            wgpu::SharedTextureMemoryVkImageLayoutEndState vkEnd = {};
+            endState.nextInChain = &vkEnd;
+#endif
             ctx->sharedTextureMemory.EndAccess(ctx->texture, &endState);
             delete ctx;
           },

package/cpp/rnskia/RNDawnUtils.h

@@ -5,7 +5,7 @@
 #include "dawn/dawn_proc.h"
 #include "dawn/native/DawnNative.h"
 
-#include "RNSkLog.h"
+#include "utils/RNSkLog.h"
 #include "include/core/SkColorType.h"
 #include "include/gpu/graphite/dawn/DawnBackendContext.h"
 
@@ -206,12 +206,22 @@ createDawnBackendContext(dawn::native::Instance *instance) {
       wgpu::FeatureName::ImplicitDeviceSynchronization,
 #ifdef __APPLE__
       wgpu::FeatureName::SharedTextureMemoryIOSurface,
+      // Required to call SharedTextureMemory::EndAccess on Metal (it exports a
+      // MTLSharedEvent fence). importExternalTexture / importSharedTextureMemory
+      // end the access window after submit; without this EndAccess errors with
+      // "Required feature (SharedFenceMTLSharedEvent) is missing". Safe here
+      // because we always queue.submit() before EndAccess (the secondary device
+      // omits it on purpose — its camera path doesn't commit first).
+      wgpu::FeatureName::SharedFenceMTLSharedEvent,
       wgpu::FeatureName::DawnMultiPlanarFormats,
       wgpu::FeatureName::MultiPlanarFormatP010,
       wgpu::FeatureName::MultiPlanarFormatP210,
       wgpu::FeatureName::MultiPlanarFormatExtendedUsages,
 #else
       wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer,
+      // Vulkan equivalent of the above: EndAccess exports a sync-fd fence.
+      wgpu::FeatureName::SharedFenceSyncFD,
+      wgpu::FeatureName::SharedFenceVkSemaphoreOpaqueFD,
 #endif
   };
 

package/cpp/rnskia/RNSkJsiViewApi.h

@@ -9,11 +9,11 @@
 #include <utility>
 #include <vector>
 
-#include "JsiHostObject.h"
+#include "jsi/JsiHostObject.h"
 #include "RNSkPictureView.h"
 #include "RNSkPlatformContext.h"
 #include "RNSkView.h"
-#include "ViewProperty.h"
+#include "jsi/ViewProperty.h"
 #include <jsi/jsi.h>
 
 namespace RNSkia {

package/cpp/rnskia/RNSkManager.cpp

@@ -5,22 +5,29 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkApi.h"
+#include "api/JsiSkApi.h"
 #include "RNSkJsiViewApi.h"
 #include "RNSkView.h"
 
-#include "RuntimeAwareCache.h"
+#include "jsi/RuntimeAwareCache.h"
 
 #ifdef SK_GRAPHITE
 #include "RNDawnContext.h"
+#include "rnwgpu/ArrayBuffer.h"
 #include "rnwgpu/api/GPU.h"
 #include "rnwgpu/api/GPUUncapturedErrorEvent.h"
+#include "rnwgpu/api/ImageBitmap.h"
 #include "rnwgpu/api/RNWebGPU.h"
 #include "rnwgpu/api/descriptors/GPUBufferUsage.h"
 #include "rnwgpu/api/descriptors/GPUColorWrite.h"
 #include "rnwgpu/api/descriptors/GPUMapMode.h"
 #include "rnwgpu/api/descriptors/GPUShaderStage.h"
 #include "rnwgpu/api/descriptors/GPUTextureUsage.h"
+#include "jsi2/Promise.h"
+
+#include "include/core/SkData.h"
+#include "include/core/SkImage.h"
+#include "include/core/SkImageInfo.h"
 #endif
 
 namespace RNSkia {
@@ -114,6 +121,85 @@ void RNSkManager::installBindings() {
   auto rnWebGPU = std::make_shared<rnwgpu::RNWebGPU>(gpu, nullptr);
   _jsRuntime->global().setProperty(
       *_jsRuntime, "RNWebGPU", rnwgpu::RNWebGPU::create(*_jsRuntime, rnWebGPU));
+
+  // DRAFT — compile-unverified. Install the ImageBitmap constructor (so
+  // `instanceof ImageBitmap` works) and a global createImageBitmap() that
+  // accepts the non-standard encoded-BufferSource overload.
+  //
+  // The BufferSource is run through the shared rnwgpu::ArrayBuffer converter,
+  // which validates byteOffset/byteLength against the backing buffer and throws
+  // synchronously on a spoofed / out-of-bounds view — so createImageBitmap()
+  // rejects rather than reading out of bounds (see ArrayBufferBounds /
+  // ImageBitmapBounds specs). Decoding uses Skia's own codec; no platform image
+  // decoder is needed.
+  rnwgpu::ImageBitmap::installConstructor(*_jsRuntime);
+  _jsRuntime->global().setProperty(
+      *_jsRuntime, "createImageBitmap",
+      jsi::Function::createFromHostFunction(
+          *_jsRuntime,
+          jsi::PropNameID::forAscii(*_jsRuntime, "createImageBitmap"), 1,
+          [](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
+             const jsi::Value *args, size_t count) -> jsi::Value {
+            if (count < 1 || !args[0].isObject()) {
+              throw jsi::JSError(
+                  rt, "createImageBitmap requires a BufferSource argument");
+            }
+            // Only the encoded ArrayBuffer / ArrayBufferView overload is
+            // supported here. Anything else (Blob, ImageData, …) is rejected.
+            auto obj = args[0].getObject(rt);
+            bool isBufferSource = obj.isArrayBuffer(rt);
+            if (!isBufferSource && obj.hasProperty(rt, "buffer")) {
+              auto bufferProp = obj.getProperty(rt, "buffer");
+              isBufferSource =
+                  bufferProp.isObject() &&
+                  bufferProp.getObject(rt).isArrayBuffer(rt);
+            }
+            if (!isBufferSource) {
+              throw jsi::JSError(rt, "createImageBitmap: unsupported source "
+                                     "(expected an ArrayBuffer or TypedArray "
+                                     "of encoded image bytes)");
+            }
+            // Validates bounds and THROWS synchronously on a spoofed view, so
+            // the bad pointer never reaches the copy below.
+            auto buffer =
+                rnwgpu::JSIConverter<std::shared_ptr<rnwgpu::ArrayBuffer>>::
+                    fromJSI(rt, args[0], false);
+            // Copy the encoded bytes off the JS-owned ArrayBuffer.
+            const uint8_t *bytes = buffer->data();
+            std::vector<uint8_t> encoded(bytes, bytes + buffer->size());
+
+            return rnwgpu::Promise::createPromise(
+                rt, [encoded = std::move(encoded)](
+                        jsi::Runtime &runtime,
+                        std::shared_ptr<rnwgpu::Promise> promise) mutable {
+                  auto skData =
+                      SkData::MakeWithCopy(encoded.data(), encoded.size());
+                  auto image = SkImages::DeferredFromEncodedData(skData);
+                  if (image == nullptr) {
+                    promise->reject(
+                        "createImageBitmap: failed to decode image data");
+                    return;
+                  }
+                  const int w = image->width();
+                  const int h = image->height();
+                  auto info =
+                      SkImageInfo::Make(w, h, kRGBA_8888_SkColorType,
+                                        kUnpremul_SkAlphaType);
+                  std::vector<uint8_t> pixels(info.computeMinByteSize());
+                  // nullptr context: decode/read on the CPU (raster).
+                  if (!image->readPixels(nullptr, info, pixels.data(),
+                                         info.minRowBytes(), 0, 0)) {
+                    promise->reject(
+                        "createImageBitmap: failed to read decoded pixels");
+                    return;
+                  }
+                  auto bitmap = std::make_shared<rnwgpu::ImageBitmap>(
+                      std::move(pixels), static_cast<size_t>(w),
+                      static_cast<size_t>(h));
+                  promise->resolve(
+                      rnwgpu::ImageBitmap::create(runtime, bitmap));
+                });
+          }));
 #endif
 }
 } // namespace RNSkia

package/cpp/rnskia/RNSkPictureView.h

@@ -11,12 +11,12 @@
 #include <jsi/jsi.h>
 
 #include "RNSkView.h"
-#include "ViewProperty.h"
+#include "jsi/ViewProperty.h"
 
-#include "JsiSkPicture.h"
-#include "RNSkLog.h"
+#include "api/JsiSkPicture.h"
+#include "utils/RNSkLog.h"
 #include "RNSkPlatformContext.h"
-#include "RNSkTimingInfo.h"
+#include "utils/RNSkTimingInfo.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"

package/cpp/rnskia/RNSkPlatformContext.h

@@ -141,6 +141,13 @@ public:
 
   virtual uint64_t makeNativeBuffer(sk_sp<SkImage> image) = 0;
 
+  // Allocate a platform native buffer (IOSurface on Apple, AHardwareBuffer on
+  // Android) of the given size filled with a procedural test pattern (RGB
+  // gradient + diagonal stripes), entirely on the CPU. Intended for examples
+  // and tests that need a buffer to feed into importExternalTexture without a
+  // camera/video source. Release it with releaseNativeBuffer().
+  virtual uint64_t makeTestNativeBuffer(int width, int height) = 0;
+
   virtual std::shared_ptr<RNSkVideo> createVideo(const std::string &url) = 0;
 
   /**

package/cpp/rnskia/RNSkView.h

@@ -7,11 +7,11 @@
 #include <vector>
 
 #include "RNSkPlatformContext.h"
-#include "ViewProperty.h"
+#include "jsi/ViewProperty.h"
 
-#include "JsiSkImage.h"
-#include "JsiSkPoint.h"
-#include "JsiSkRect.h"
+#include "api/JsiSkImage.h"
+#include "api/JsiSkPoint.h"
+#include "api/JsiSkRect.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -94,8 +94,11 @@ public:
       image = _surface->makeImageSnapshot();
     }
 #if defined(SK_GRAPHITE)
-    DawnContext::getInstance().submitRecording(
-        _surface->recorder()->snap().get());
+    // Only Graphite-backed surfaces have a recorder to snap/submit; a raster
+    // surface's snapshot is already a valid CPU image.
+    if (auto *recorder = _surface->recorder()) {
+      DawnContext::getInstance().submitRecording(recorder->snap().get());
+    }
     return DawnContext::getInstance().MakeRasterImage(image);
 #else
     auto grContext = _context->getDirectContext();

package/cpp/rnwgpu/ArrayBuffer.h

@@ -1,6 +1,8 @@
 #pragma once
 #include <jsi/jsi.h>
 
+#include <cmath>
+#include <cstdint>
 #include <memory>
 
 #include "jsi2/JSIConverter.h"
@@ -47,16 +49,58 @@ template <> struct JSIConverter<std::shared_ptr<ArrayBuffer>> {
         if (bufferProp.isObject() &&
             bufferProp.getObject(runtime).isArrayBuffer(runtime)) {
           auto buff = bufferProp.getObject(runtime);
-          auto bytesPerElements =
-              obj.getProperty(runtime, "BYTES_PER_ELEMENT").asNumber();
           auto arrayBuffer = buff.getArrayBuffer(runtime);
-          auto byteOffset = static_cast<size_t>(
-              obj.getProperty(runtime, "byteOffset").asNumber());
-          auto byteLength = static_cast<size_t>(
-              obj.getProperty(runtime, "byteLength").asNumber());
+          const size_t bufferSize = arrayBuffer.size(runtime);
+
+          // byteOffset / byteLength are user-readable JS properties, not values
+          // the engine guarantees (unlike Dawn's node binding, which reads them
+          // off the engine's typed-array view). Read them as doubles so we can
+          // reject negative, non-integral, NaN/Inf, or oversized values before
+          // they wrap around when cast to size_t.
+          const double byteOffsetValue =
+              obj.getProperty(runtime, "byteOffset").asNumber();
+          const double byteLengthValue =
+              obj.getProperty(runtime, "byteLength").asNumber();
+
+          auto isValidByteIndex = [](double value) {
+            return std::isfinite(value) && value >= 0.0 &&
+                   value <= static_cast<double>(SIZE_MAX) &&
+                   std::floor(value) == value;
+          };
+          if (!isValidByteIndex(byteOffsetValue) ||
+              !isValidByteIndex(byteLengthValue)) {
+            throw std::runtime_error(
+                "ArrayBuffer::fromJSI: invalid byteOffset/byteLength");
+          }
+
+          const size_t byteOffset = static_cast<size_t>(byteOffsetValue);
+          const size_t byteLength = static_cast<size_t>(byteLengthValue);
+
+          // Overflow-safe bounds check: byteOffset + byteLength <= bufferSize.
+          if (byteOffset > bufferSize ||
+              byteLength > bufferSize - byteOffset) {
+            throw std::runtime_error(
+                "ArrayBuffer::fromJSI: view bounds [byteOffset, byteOffset + "
+                "byteLength) exceed the backing ArrayBuffer size");
+          }
+
+          // BYTES_PER_ELEMENT is absent on a DataView; default to 1. A spoofed
+          // object could report 0 (or a negative/NaN value), so clamp to a
+          // minimum of 1 to avoid a later division by zero in writeBuffer.
+          size_t bytesPerElements = 1;
+          if (obj.hasProperty(runtime, "BYTES_PER_ELEMENT")) {
+            auto bpe = obj.getProperty(runtime, "BYTES_PER_ELEMENT");
+            if (bpe.isNumber()) {
+              const double value = bpe.asNumber();
+              if (std::isfinite(value) && value >= 1.0) {
+                bytesPerElements = static_cast<size_t>(value);
+              }
+            }
+          }
+
           return std::make_shared<ArrayBuffer>(
               arrayBuffer.data(runtime) + byteOffset, byteLength,
-              static_cast<size_t>(bytesPerElements));
+              bytesPerElements);
         }
       }
     }

package/cpp/rnwgpu/api/AppleNativeBuffer.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#if defined(__APPLE__)
+
+#include <cstdint>
+
+namespace rnwgpu {
+
+// Extract the backing IOSurface and dimensions from a CVPixelBufferRef pointer
+// (the value Skia's NativeBuffer.MakeFromImage returns on Apple). The returned
+// IOSurfaceRef is owned by the CVPixelBuffer; the caller must keep the
+// CVPixelBuffer alive while the IOSurface is in use. Returns nullptr (and
+// leaves the out-params at 0) if the buffer has no IOSurface.
+//
+// Defined in apple/RNWebGPUAppleNativeBuffer.mm (Objective-C++ so it can use
+// CoreVideo, which isn't available from the cpp/ translation units).
+void *GetIOSurfaceFromNativeBuffer(void *cvPixelBuffer, uint32_t *outWidth,
+                                   uint32_t *outHeight);
+
+} // namespace rnwgpu
+
+#endif // __APPLE__

package/cpp/rnwgpu/api/Convertors.h

@@ -252,13 +252,24 @@ public:
 
   [[nodiscard]] bool Convert(wgpu::BindGroupLayoutEntry &out,
                              const GPUBindGroupLayoutEntry &in) {
-    return Convert(out.binding, in.binding) &&
-           Convert(out.visibility, in.visibility) &&
-           Convert(out.buffer, in.buffer) && Convert(out.sampler, in.sampler) &&
-           Convert(out.texture, in.texture) &&
-           Convert(out.storageTexture, in.storageTexture);
-    // no external textures here
-    //&& Convert(out.externalTexture, in.externalTexture);
+    out = {};
+    if (!Convert(out.binding, in.binding) ||
+        !Convert(out.visibility, in.visibility) ||
+        !Convert(out.buffer, in.buffer) || !Convert(out.sampler, in.sampler) ||
+        !Convert(out.texture, in.texture) ||
+        !Convert(out.storageTexture, in.storageTexture)) {
+      return false;
+    }
+    if (in.externalTexture.has_value() &&
+        in.externalTexture.value() != nullptr) {
+      // External texture layouts bind via a chained struct rather than a
+      // direct field on BindGroupLayoutEntry. The chained struct must outlive
+      // the BindGroupLayoutEntry until Device::CreateBindGroupLayout returns,
+      // so we allocate it on the Convertor's arena.
+      auto *chain = Allocate<wgpu::ExternalTextureBindingLayout>();
+      out.nextInChain = chain;
+    }
+    return true;
   }
 
   [[nodiscard]] bool Convert(wgpu::BlendComponent &out,
@@ -422,9 +433,11 @@ public:
   }
 
   [[nodiscard]] bool Convert(wgpu::ExternalTextureBindingLayout &out,
-                             const GPUExternalTextureBindingLayout &in) {
-    // no external textures at the moment
-    return false;
+                             const GPUExternalTextureBindingLayout & /*in*/) {
+    // ExternalTextureBindingLayout carries no fields of its own; its presence
+    // (as a chained struct) is what marks the entry as an external texture.
+    out = {};
+    return true;
   }
 
   [[nodiscard]] bool Convert(wgpu::ConstantEntry &out, const std::string &key,
@@ -729,7 +742,16 @@ public:
       out.buffer = buffer->get();
       return true;
     }
-    // Not external textures at the moment
+    if (in.externalTexture != nullptr) {
+      // External textures bind via a chained struct rather than a direct field
+      // on BindGroupEntry. The chained struct must outlive the BindGroupEntry
+      // until Device::CreateBindGroup returns, so we allocate it on the
+      // Convertor's arena.
+      auto *chain = Allocate<wgpu::ExternalTextureBindingEntry>();
+      chain->externalTexture = in.externalTexture->get();
+      out.nextInChain = chain;
+      return true;
+    }
     return false;
   }
 

package/cpp/rnwgpu/api/GPU.cpp

@@ -136,9 +136,6 @@ std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {
     case wgpu::WGSLLanguageFeatureName::BufferView:
       name = "buffer_view";
       break;
-    case wgpu::WGSLLanguageFeatureName::FilteringParameters:
-      name = "filtering_parameters";
-      break;
     case wgpu::WGSLLanguageFeatureName::SwizzleAssignment:
       name = "swizzle_assignment";
       break;

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -109,13 +109,39 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
        deviceLostBinding,
        creationRuntime](const async::AsyncTaskHandle::ResolveFunction &resolve,
                         const async::AsyncTaskHandle::RejectFunction &reject) {
-        (void)descriptor;
+        // Build a local mutable copy so we can chain Dawn's device toggles.
+        // The toggle name strings are owned by `descriptor` (captured above),
+        // and the const char* / DawnTogglesDescriptor locals live for the
+        // whole synchronous RequestDevice call below, which is when Dawn reads
+        // the chained struct.
+        wgpu::DeviceDescriptor deviceDesc = aDescriptor;
+        wgpu::DawnTogglesDescriptor toggles{};
+        std::vector<const char *> enabledToggles;
+        std::vector<const char *> disabledToggles;
+        if (descriptor.has_value() && descriptor.value()->dawnToggles) {
+          const auto &dawnToggles = descriptor.value()->dawnToggles.value();
+          if (dawnToggles->enabledToggles) {
+            for (const auto &t : dawnToggles->enabledToggles.value()) {
+              enabledToggles.push_back(t.c_str());
+            }
+            toggles.enabledToggleCount = enabledToggles.size();
+            toggles.enabledToggles = enabledToggles.data();
+          }
+          if (dawnToggles->disabledToggles) {
+            for (const auto &t : dawnToggles->disabledToggles.value()) {
+              disabledToggles.push_back(t.c_str());
+            }
+            toggles.disabledToggleCount = disabledToggles.size();
+            toggles.disabledToggles = disabledToggles.data();
+          }
+          deviceDesc.nextInChain = &toggles;
+        }
         _instance.RequestDevice(
-            &aDescriptor, wgpu::CallbackMode::AllowProcessEvents,
+            &deviceDesc, wgpu::CallbackMode::AllowProcessEvents,
             [asyncRunner = _async, resolve, reject, label, creationRuntime,
              deviceLostBinding](wgpu::RequestDeviceStatus status,
                                 wgpu::Device device,
-                                wgpu::StringView message) mutable {
+                                wgpu::StringView message) {
               if (message.length) {
                 fprintf(stderr, "%s", message.data);
               }
@@ -128,10 +154,13 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
                 return;
               }
 
+              // SetLoggingCallback is a repeatable callback (no callback mode),
+              // which rejects capturing lambdas. Pass the runtime pointer
+              // through Dawn's userdata argument instead of capturing it.
               device.SetLoggingCallback(
-                  [creationRuntime](wgpu::LoggingType type,
-                                    wgpu::StringView msg) {
-                    if (creationRuntime == nullptr) {
+                  [](wgpu::LoggingType type, wgpu::StringView msg,
+                     jsi::Runtime *runtime) {
+                    if (runtime == nullptr) {
                       return;
                     }
                     const char *logLevel = "";
@@ -157,7 +186,8 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
                       fprintf(stderr, "%s: %.*s\n", logLevel,
                               static_cast<int>(msg.length), msg.data);
                     }
-                  });
+                  },
+                  creationRuntime);
 
               auto deviceHost = std::make_shared<GPUDevice>(std::move(device),
                                                             asyncRunner, label);

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -14,7 +14,7 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "ArrayBuffer.h"
+#include "rnwgpu/ArrayBuffer.h"
 
 namespace rnwgpu {