@shopify/react-native-skia 2.6.5 → 2.6.7

package/android/CMakeLists.txt

@@ -120,9 +120,8 @@ if(SK_GRAPHITE)
         "${PROJECT_SOURCE_DIR}/../cpp/jsi2/Promise.cpp"
 
         # WebGPU async system
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/async/AsyncRunner.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/async/AsyncTaskHandle.cpp"
-        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/async/JSIMicrotaskDispatcher.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/async/RuntimeContext.cpp"
 
         # WebGPU API
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPU.cpp"
@@ -142,6 +141,7 @@ if(SK_GRAPHITE)
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPURenderPassEncoder.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPURenderPipeline.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUShaderModule.cpp"
+        "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUSharedFence.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUSharedTextureMemory.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUSupportedLimits.cpp"
         "${PROJECT_SOURCE_DIR}/../cpp/rnwgpu/api/GPUTexture.cpp"

package/android/src/paper/java/com/facebook/react/viewmanagers/SkiaWebGPUViewManagerDelegate.java

@@ -0,0 +1,35 @@
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* @generated by codegen project: GeneratePropsJavaDelegate.js
+*/
+
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+import androidx.annotation.Nullable;
+import com.facebook.react.uimanager.BaseViewManagerDelegate;
+import com.facebook.react.uimanager.BaseViewManager;
+import com.facebook.react.uimanager.LayoutShadowNode;
+
+public class SkiaWebGPUViewManagerDelegate<T extends View, U extends BaseViewManager<T, ? extends LayoutShadowNode> & SkiaWebGPUViewManagerInterface<T>> extends BaseViewManagerDelegate<T, U> {
+  public SkiaWebGPUViewManagerDelegate(U viewManager) {
+    super(viewManager);
+  }
+  @Override
+  public void setProperty(T view, String propName, @Nullable Object value) {
+    switch (propName) {
+      case "contextId":
+        mViewManager.setContextId(view, value == null ? 0 : ((Double) value).intValue());
+        break;
+      case "transparent":
+        mViewManager.setTransparent(view, value != null && (boolean) value);
+        break;
+      default:
+        super.setProperty(view, propName, value);
+    }
+  }
+}

package/android/src/paper/java/com/facebook/react/viewmanagers/SkiaWebGPUViewManagerInterface.java

@@ -0,0 +1,17 @@
+/**
+* This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+*
+* Do not edit this file as changes may cause incorrect behavior and will be lost
+* once the code is regenerated.
+*
+* @generated by codegen project: GeneratePropsJavaInterface.js
+*/
+
+package com.facebook.react.viewmanagers;
+
+import android.view.View;
+
+public interface SkiaWebGPUViewManagerInterface<T extends View> {
+  void setContextId(T view, int value);
+  void setTransparent(T view, boolean value);
+}

package/apple/RNSkiaModule.mm

@@ -35,11 +35,17 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
     // Already initialized, ignore call.
     return @true;
   }
-  RCTCxxBridge *cxxBridge = (RCTCxxBridge *)self.bridge;
+#ifndef RCT_DISABLE_LEGACY_ARCH
   if (!jsInvoker) {
+    RCTCxxBridge *cxxBridge = (RCTCxxBridge *)self.bridge;
     jsInvoker = cxxBridge.jsCallInvoker;
   }
-  skiaManager = [[SkiaManager alloc] initWithBridge:cxxBridge
+#endif
+  if (!jsInvoker) {
+    NSLog(@"[RNSkiaModule] Failed to install SkiaManager: jsInvoker is not initialized.");
+    return @false;
+  }
+  skiaManager = [[SkiaManager alloc] initWithBridge:self.bridge
                                           jsInvoker:jsInvoker];
   return @true;
 }

package/apple/SkiaManager.mm

@@ -2,12 +2,19 @@
 
 #import <Foundation/Foundation.h>
 
-#import <React/RCTBridge+Private.h>
 #import <React/RCTBridge.h>
 #import <React/RCTUIManager.h>
 
 #import "RNSkApplePlatformContext.h"
 
+// Forward-declared runtime accessor that is satisfied by RCTCxxBridge
+// (legacy/transitional) and RCTBridgeProxy (bridgeless). Avoids referencing
+// RCTCxxBridge directly, which is compiled out when RCT_DISABLE_LEGACY_ARCH
+// is set (React Native 0.82+).
+@interface RCTBridge (RNSkiaRuntime)
+- (void *)runtime;
+@end
+
 static __weak SkiaManager *sharedInstance = nil;
 
 @implementation SkiaManager {
@@ -29,11 +36,9 @@ static __weak SkiaManager *sharedInstance = nil;
   self = [super init];
   if (self) {
     sharedInstance = self;
-    RCTCxxBridge *cxxBridge = (RCTCxxBridge *)bridge;
-    if (cxxBridge.runtime) {
-
+    if (bridge.runtime) {
       facebook::jsi::Runtime *jsRuntime =
-          (facebook::jsi::Runtime *)cxxBridge.runtime;
+          (facebook::jsi::Runtime *)bridge.runtime;
 
       // Create the RNSkiaManager (cross platform)
       _skManager = std::make_shared<RNSkia::RNSkManager>(

package/cpp/api/JsiSkApi.h

@@ -9,7 +9,7 @@
 #ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
 #include "rnwgpu/api/GPUDevice.h"
-#include "rnwgpu/async/AsyncRunner.h"
+#include "rnwgpu/async/RuntimeContext.h"
 #endif
 
 #include "JsiNativeBuffer.h"
@@ -164,12 +164,12 @@ public:
         "getDevice", JSI_HOST_FUNCTION_LAMBDA {
 #ifdef SK_GRAPHITE
           auto &dawnContext = DawnContext::getInstance();
-          auto asyncRunner = rnwgpu::async::AsyncRunner::get(runtime);
-          if (!asyncRunner) {
-            throw jsi::JSError(runtime, "AsyncRunner not initialized");
-          }
+          // Per-runtime context: async ops on this device resolve on the calling
+          // runtime's own thread (via its ProcessEvents pump).
+          auto context = rnwgpu::async::RuntimeContext::getOrCreate(
+              runtime, dawnContext.getWGPUInstance());
           auto device = std::make_shared<rnwgpu::GPUDevice>(
-              dawnContext.getWGPUDevice(), asyncRunner, "Skia Device");
+              dawnContext.getWGPUDevice(), context, "Skia Device");
           return rnwgpu::GPUDevice::create(runtime, device);
 #else
       throw jsi::JSError(runtime,

package/cpp/api/JsiSkCanvas.h

@@ -21,6 +21,10 @@
 
 #include "utils/RNSkTypedArray.h"
 
+#if defined(SK_GRAPHITE)
+#include "rnskia/RNDawnContext.h"
+#endif
+
 #include <jsi/jsi.h>
 
 #pragma clang diagnostic push
@@ -644,6 +648,29 @@ public:
             .getArrayBuffer(runtime);
     auto bfrPtr = reinterpret_cast<void *>(buffer.data(runtime));
 
+#if defined(SK_GRAPHITE)
+    // Graphite records draws lazily and offers no synchronous GPU readback. If
+    // this canvas belongs to a surface, snap & submit its recording, snapshot
+    // it to a CPU raster image and read from that (mirroring makeImageSnapshot).
+    // A canvas without an owning surface (e.g. a picture-recording canvas) has
+    // no texture to read back, so fall through to the raster canvas read below.
+    if (_surface) {
+      // Snapshot first: makeImageSnapshot records a copy task into the recorder
+      // that must be submitted before the texture can be read back (this is the
+      // same ordering used by JsiSkSurface::makeImageSnapshot and RNSkView).
+      auto snapshot = _surface->makeImageSnapshot();
+      if (auto *recorder = _surface->recorder()) {
+        DawnContext::getInstance().submitRecording(recorder->snap().get());
+      }
+      auto raster = DawnContext::getInstance().MakeRasterImage(snapshot);
+      if (!raster ||
+          !raster->readPixels(nullptr, *info, bfrPtr, bytesPerRow, srcX, srcY)) {
+        return jsi::Value::null();
+      }
+      return dest;
+    }
+#endif
+
     if (!_canvas->readPixels(*info, bfrPtr, bytesPerRow, srcX, srcY)) {
       return jsi::Value::null();
     }
@@ -708,7 +735,13 @@ public:
   void setCanvas(SkCanvas *canvas) { _canvas = canvas; }
   SkCanvas *getCanvas() { return _canvas; }
 
+  // Optionally associate the canvas with its owning surface. This lets
+  // readPixels fall back to a surface snapshot on Graphite, which has no
+  // synchronous canvas readback.
+  void setSurface(sk_sp<SkSurface> surface) { _surface = std::move(surface); }
+
 private:
   SkCanvas *_canvas;
+  sk_sp<SkSurface> _surface;
 };
 } // namespace RNSkia

package/cpp/api/JsiSkImage.h

@@ -277,9 +277,6 @@ public:
   }
 
   JSI_HOST_FUNCTION(readPixels) {
-#if defined(SK_GRAPHITE)
-    throw std::runtime_error("Not implemented yet");
-#else
     int srcX = 0;
     int srcY = 0;
     if (count > 0 && !arguments[0].isUndefined()) {
@@ -313,13 +310,24 @@ public:
             .getArrayBuffer(runtime);
     auto bfrPtr = reinterpret_cast<void *>(buffer.data(runtime));
 
+#if defined(SK_GRAPHITE)
+    // Graphite offers no synchronous GPU readback, so fall back to a CPU raster
+    // copy of the image (a no-op when the image is already raster) and read the
+    // pixels from that. This matches the Ganesh behaviour for non-texture and
+    // texture-backed images alike.
+    auto image = DawnContext::getInstance().MakeRasterImage(getObject());
+    if (!image ||
+        !image->readPixels(nullptr, info, bfrPtr, bytesPerRow, srcX, srcY)) {
+      return jsi::Value::null();
+    }
+#else
     auto grContext = getContext()->getDirectContext();
     if (!getObject()->readPixels(grContext, info, bfrPtr, bytesPerRow, srcX,
                                  srcY)) {
       return jsi::Value::null();
     }
-    return dest;
 #endif
+    return dest;
   }
 
   JSI_HOST_FUNCTION(makeNonTextureImage) {

package/cpp/api/JsiSkMaskFilter.h

@@ -30,6 +30,7 @@ public:
   std::string getObjectType() const override { return "JsiSkMaskFilter"; }
 
   EXPORT_JSI_API_TYPENAME(JsiSkMaskFilter, MaskFilter)
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkMaskFilter, dispose))
 };
 
 } // namespace RNSkia

package/cpp/api/JsiSkSurface.h

@@ -72,8 +72,12 @@ public:
   }
 
   JSI_HOST_FUNCTION(getCanvas) {
+    auto surface = getObject();
     auto canvas =
-        std::make_shared<JsiSkCanvas>(getContext(), getObject()->getCanvas());
+        std::make_shared<JsiSkCanvas>(getContext(), surface->getCanvas());
+    // Keep a reference to the owning surface so the canvas can read pixels back
+    // through a snapshot on Graphite (which lacks synchronous canvas readback).
+    canvas->setSurface(surface);
     return JSI_CREATE_HOST_OBJECT_WITH_MEMORY_PRESSURE(runtime, canvas,
                                                        getContext());
   }

package/cpp/jsi2/NativeObject.h

@@ -432,6 +432,29 @@ protected:
     prototype.setProperty(runtime, name, func);
   }
 
+  /**
+   * Install a method whose native implementation needs the calling jsi::Runtime
+   * as its first parameter. Used by entry points that must act per-runtime
+   * (e.g. GPU::requestAdapter, which creates a per-runtime RuntimeContext).
+   */
+  template <typename ReturnType, typename... Args>
+  static void
+  installMethodWithRuntime(jsi::Runtime &runtime, jsi::Object &prototype,
+                           const char *name,
+                           ReturnType (Derived::*method)(jsi::Runtime &,
+                                                         Args...)) {
+    auto func = jsi::Function::createFromHostFunction(
+        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);
+          return callMethodWithRuntime(native.get(), method, rt, args,
+                                       std::index_sequence_for<Args...>{},
+                                       count);
+        });
+    prototype.setProperty(runtime, name, func);
+  }
+
   /**
    * Install a getter on the prototype.
    */
@@ -567,6 +590,22 @@ protected:
   }
 
 private:
+  // Helper to call a method that takes the calling jsi::Runtime as its first
+  // parameter, with JSI argument conversion for the rest and JSI conversion of
+  // the result.
+  template <typename ReturnType, typename... Args, size_t... Is>
+  static jsi::Value
+  callMethodWithRuntime(Derived *obj,
+                        ReturnType (Derived::*method)(jsi::Runtime &, Args...),
+                        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, args[Is], Is >= count)...);
+    return rnwgpu::JSIConverter<std::decay_t<ReturnType>>::toJSI(
+        runtime, std::move(result));
+  }
+
   // Helper to call a method with JSI argument conversion
   template <typename ReturnType, typename... Args, size_t... Is>
   static jsi::Value callMethod(Derived *obj,

package/cpp/rnskia/RNSkManager.cpp

@@ -23,6 +23,8 @@
 #include "rnwgpu/api/descriptors/GPUMapMode.h"
 #include "rnwgpu/api/descriptors/GPUShaderStage.h"
 #include "rnwgpu/api/descriptors/GPUTextureUsage.h"
+#include "rnwgpu/api/WebGPUConstants.h"
+#include "rnwgpu/async/RuntimeContext.h"
 #include "jsi2/Promise.h"
 
 #include "include/core/SkData.h"
@@ -82,6 +84,12 @@ void RNSkManager::installBindings() {
       jsi::Object::createFromHostObject(*_jsRuntime, _viewApi));
 
 #ifdef SK_GRAPHITE
+  // Register the main runtime + its CallInvoker so spontaneous events
+  // (device.lost / uncapturederror) on main-runtime devices can be delivered to
+  // the JS thread without the ProcessEvents pump. Worklet-runtime devices have
+  // no invoker (best-effort; see the RuntimeContext "Threading model" doc).
+  rnwgpu::async::RuntimeContext::registerMainRuntime(_jsRuntime, _jsCallInvoker);
+
   // Install WebGPU constructors
   rnwgpu::GPU::installConstructor(*_jsRuntime);
   rnwgpu::GPUUncapturedErrorEvent::installConstructor(*_jsRuntime);
@@ -104,18 +112,26 @@ void RNSkManager::installBindings() {
                                      std::move(navigator));
   }
 
-  // Install WebGPU constant objects as plain JS objects
-  _jsRuntime->global().setProperty(*_jsRuntime, "GPUBufferUsage",
-                                   rnwgpu::GPUBufferUsage::create(*_jsRuntime));
-  _jsRuntime->global().setProperty(*_jsRuntime, "GPUColorWrite",
-                                   rnwgpu::GPUColorWrite::create(*_jsRuntime));
-  _jsRuntime->global().setProperty(*_jsRuntime, "GPUMapMode",
-                                   rnwgpu::GPUMapMode::create(*_jsRuntime));
-  _jsRuntime->global().setProperty(*_jsRuntime, "GPUShaderStage",
-                                   rnwgpu::GPUShaderStage::create(*_jsRuntime));
+  // Install WebGPU constant objects as plain JS objects on the main runtime.
+  rnwgpu::installWebGPUConstants(*_jsRuntime);
+
+  // Install a global `installWebGPU()` host function so worklet runtimes can get
+  // the same constants. A host function captured into a worklet is serialized as
+  // a SerializableHostFunction and re-created on the worklet runtime, so the body
+  // runs there (its `rt` is the worklet runtime) and installs the constants on
+  // that runtime. The constants come from the native wgpu::*Usage enums, so the
+  // values stay a single source of truth across every runtime. Calling it on a
+  // runtime that already has the globals is a safe, idempotent no-op.
   _jsRuntime->global().setProperty(
-      *_jsRuntime, "GPUTextureUsage",
-      rnwgpu::GPUTextureUsage::create(*_jsRuntime));
+      *_jsRuntime, "installWebGPU",
+      jsi::Function::createFromHostFunction(
+          *_jsRuntime, jsi::PropNameID::forAscii(*_jsRuntime, "installWebGPU"),
+          0,
+          [](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
+             const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
+            rnwgpu::installWebGPUConstants(rt);
+            return jsi::Value::undefined();
+          }));
 
   // Install RNWebGPU global object for WebGPU Canvas support
   auto rnWebGPU = std::make_shared<rnwgpu::RNWebGPU>(gpu, nullptr);

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -7,6 +7,12 @@
 
 #include "webgpu/webgpu_cpp.h"
 
+#ifdef __APPLE__
+namespace dawn::native::metal {
+void WaitForCommandsToBeScheduled(WGPUDevice device);
+} // namespace dawn::native::metal
+#endif
+
 namespace rnwgpu {
 
 struct NativeInfo {
@@ -112,13 +118,39 @@ public:
     height = newHeight;
   }
 
-  void present() {
+  // Present the current surface texture. Called synchronously from the thread
+  // that did getCurrentTexture / submit (via GPUCanvasContext::present), so it
+  // preserves Dawn surface thread-affinity. No-op when offscreen / unconfigured
+  // (no surface).
+  void presentFrame() {
+#ifdef __APPLE__
+    // Ensure command buffers are scheduled before presenting. Read the device
+    // under a shared lock, then wait without holding it (the wait can block).
+    // The device may be reconfigured between the two locks; that is safe because
+    // present() is called on the rendering thread right after submit(), the wait
+    // just flushes that thread's already-submitted work, and the Present() below
+    // re-checks `surface` under the unique lock before touching it.
+    wgpu::Device device;
+    {
+      std::shared_lock<std::shared_mutex> lock(_mutex);
+      device = config.device;
+    }
+    if (device) {
+      dawn::native::metal::WaitForCommandsToBeScheduled(device.Get());
+    }
+#endif
     std::unique_lock<std::shared_mutex> lock(_mutex);
     if (surface) {
       surface.Present();
     }
   }
 
+  // True when an on-screen wgpu::Surface is attached (vs offscreen texture).
+  bool hasSurface() {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    return surface != nullptr;
+  }
+
   wgpu::Texture getCurrentTexture() {
     std::shared_lock<std::shared_mutex> lock(_mutex);
     if (surface) {

package/cpp/rnwgpu/api/GPU.cpp

@@ -9,17 +9,15 @@
 
 #include "Convertors.h"
 #include "jsi2/JSIConverter.h"
-#include "rnwgpu/async/JSIMicrotaskDispatcher.h"
+#include "rnwgpu/async/RuntimeContext.h"
 
 namespace rnwgpu {
 
-GPU::GPU(jsi::Runtime &runtime, wgpu::Instance instance)
-    : NativeObject(CLASS_NAME), _instance(instance) {
-  auto dispatcher = std::make_shared<async::JSIMicrotaskDispatcher>(runtime);
-  _async = async::AsyncRunner::getOrCreate(runtime, _instance, dispatcher);
-}
+GPU::GPU(jsi::Runtime & /*runtime*/, wgpu::Instance instance)
+    : NativeObject(CLASS_NAME), _instance(instance) {}
 
 async::AsyncTaskHandle GPU::requestAdapter(
+    jsi::Runtime &runtime,
     std::optional<std::shared_ptr<GPURequestAdapterOptions>> options) {
   wgpu::RequestAdapterOptions aOptions;
   Convertor conv;
@@ -32,12 +30,17 @@ async::AsyncTaskHandle GPU::requestAdapter(
   constexpr auto kDefaultBackendType = wgpu::BackendType::Vulkan;
 #endif
   aOptions.backendType = kDefaultBackendType;
-  return _async->postTask(
-      [this, aOptions](const async::AsyncTaskHandle::ResolveFunction &resolve,
-                       const async::AsyncTaskHandle::RejectFunction &reject) {
+
+  // Per-runtime context: async ops requested on this runtime resolve on this
+  // runtime's own thread (via its ProcessEvents pump).
+  auto context = async::RuntimeContext::getOrCreate(runtime, _instance);
+  return context->postTask(
+      [this, aOptions,
+       context](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                const async::AsyncTaskHandle::RejectFunction &reject) {
         _instance.RequestAdapter(
             &aOptions, wgpu::CallbackMode::AllowProcessEvents,
-            [asyncRunner = _async, resolve,
+            [context, resolve,
              reject](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
                      wgpu::StringView message) {
               if (message.length) {
@@ -45,8 +48,8 @@ async::AsyncTaskHandle GPU::requestAdapter(
               }
 
               if (status == wgpu::RequestAdapterStatus::Success && adapter) {
-                auto adapterHost = std::make_shared<GPUAdapter>(
-                    std::move(adapter), asyncRunner);
+                auto adapterHost =
+                    std::make_shared<GPUAdapter>(std::move(adapter), context);
                 auto result =
                     std::variant<std::nullptr_t, std::shared_ptr<GPUAdapter>>(
                         adapterHost);
@@ -136,9 +139,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/GPU.h

@@ -9,8 +9,8 @@
 
 #include "jsi2/NativeObject.h"
 
-#include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
+#include "rnwgpu/async/RuntimeContext.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -32,7 +32,10 @@ public:
 public:
   std::string getBrand() { return CLASS_NAME; }
 
+  // requestAdapter needs the calling runtime so each runtime gets its own
+  // RuntimeContext (and ProcessEvents pump on its own thread).
   async::AsyncTaskHandle requestAdapter(
+      jsi::Runtime &runtime,
       std::optional<std::shared_ptr<GPURequestAdapterOptions>> options);
   wgpu::TextureFormat getPreferredCanvasFormat();
 
@@ -40,7 +43,8 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installGetter(runtime, prototype, "__brand", &GPU::getBrand);
-    installMethod(runtime, prototype, "requestAdapter", &GPU::requestAdapter);
+    installMethodWithRuntime(runtime, prototype, "requestAdapter",
+                             &GPU::requestAdapter);
     installMethod(runtime, prototype, "getPreferredCanvasFormat",
                   &GPU::getPreferredCanvasFormat);
     installGetter(runtime, prototype, "wgslLanguageFeatures",
@@ -51,7 +55,6 @@ public:
 
 private:
   wgpu::Instance _instance;
-  std::shared_ptr<async::AsyncRunner> _async;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -138,10 +138,10 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
         }
         _instance.RequestDevice(
             &deviceDesc, wgpu::CallbackMode::AllowProcessEvents,
-            [asyncRunner = _async, resolve, reject, label, creationRuntime,
+            [context = _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);
               }
@@ -154,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 = "";
@@ -183,10 +186,11 @@ 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);
+                                                            context, label);
               *deviceLostBinding = deviceHost;
               resolve([deviceHost = std::move(deviceHost)](
                           jsi::Runtime &runtime) mutable {

package/cpp/rnwgpu/api/GPUAdapter.h

@@ -8,8 +8,8 @@
 
 #include "jsi2/NativeObject.h"
 
-#include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
+#include "rnwgpu/async/RuntimeContext.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -27,7 +27,7 @@ public:
   static constexpr const char *CLASS_NAME = "GPUAdapter";
 
   explicit GPUAdapter(wgpu::Adapter instance,
-                      std::shared_ptr<async::AsyncRunner> async)
+                      std::shared_ptr<async::RuntimeContext> async)
       : NativeObject(CLASS_NAME), _instance(instance), _async(async) {}
 
 public:
@@ -53,7 +53,7 @@ public:
 
 private:
   wgpu::Adapter _instance;
-  std::shared_ptr<async::AsyncRunner> _async;
+  std::shared_ptr<async::RuntimeContext> _async;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -9,8 +9,8 @@
 
 #include "jsi2/NativeObject.h"
 
-#include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
+#include "rnwgpu/async/RuntimeContext.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -25,7 +25,7 @@ public:
   static constexpr const char *CLASS_NAME = "GPUBuffer";
 
   explicit GPUBuffer(wgpu::Buffer instance,
-                     std::shared_ptr<async::AsyncRunner> async,
+                     std::shared_ptr<async::RuntimeContext> async,
                      std::string label)
       : NativeObject(CLASS_NAME), _instance(instance), _async(async),
         _label(label) {}
@@ -71,7 +71,7 @@ public:
 
 private:
   wgpu::Buffer _instance;
-  std::shared_ptr<async::AsyncRunner> _async;
+  std::shared_ptr<async::RuntimeContext> _async;
   std::string _label;
   struct Mapping {
     uint64_t start;