react-native-webgpu 0.19.2 → 0.20.0

package/Package.swift

@@ -56,21 +56,33 @@ let dawnVersion =
 // changing either package's Dawn reset the package caches (File > Packages >
 // Reset Package Caches) if this does not re-run.
 //
-// A react-native-skia that depends on react-native-webgpu-dawn itself must pin
-// the same version as this package. Older Graphite builds (react-native-skia
-// 3.0.x) vendor their own Dawn and record its release tag at
-// libs/.dawn-version in their binary packages; this package's `dawn` field
+// A react-native-skia that depends on react-native-webgpu-dawn itself must
+// resolve the same version as this package: the copy nested under it when the
+// package manager could not hoist it, else the one next to it (Node's
+// resolution, which react-native-skia's podspec compares too). A workspace
+// that resolves the package to one version for both (yarn `resolutions`, npm
+// `overrides`) passes while react-native-skia's own pin lags behind a Dawn
+// bump: the app then contains that one Dawn. Older Graphite builds
+// (react-native-skia 3.0.x) vendor their own Dawn and record its release tag
+// at libs/.dawn-version in their binary packages; this package's `dawn` field
 // names the release that Dawn is interchangeable with.
 if let skiaPath = nodePackage("react-native-skia"),
   let skiaPackage = readJSON("\(skiaPath)/package.json"),
-  let skiaDawn = (skiaPackage["dependencies"] as? [String: String])?["react-native-webgpu-dawn"]
+  let skiaDawnPin = (skiaPackage["dependencies"] as? [String: String])?["react-native-webgpu-dawn"]
 {
+  let skiaDawnPath = [
+    "\(skiaPath)/node_modules/react-native-webgpu-dawn",
+    "\(skiaPath)/../react-native-webgpu-dawn",
+  ].first { FileManager.default.fileExists(atPath: "\($0)/package.json") }
+  let skiaDawn =
+    skiaDawnPath.flatMap { readJSON("\($0)/package.json")?["version"] as? String } ?? skiaDawnPin
   if skiaDawn != dawnVersion {
     fatalError(
       """
       react-native-webgpu: Dawn version mismatch. This package links \
-      react-native-webgpu-dawn \(dawnVersion) but react-native-skia depends on \
-      \(skiaDawn). Align the two packages so the app contains exactly one Dawn.
+      react-native-webgpu-dawn \(dawnVersion) but react-native-skia resolves \
+      \(skiaDawn) (it depends on \(skiaDawnPin)). Align the two packages so the \
+      app contains exactly one Dawn.
       """)
   }
 } else {

package/android/build.gradle

@@ -97,6 +97,13 @@ def supportsNamespace() {
 android {
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
+  if (rootProject.hasProperty("ndkPath")) {
+    ndkPath = rootProject.ext.ndkPath
+  }
+  if (rootProject.hasProperty("ndkVersion")) {
+    ndkVersion = rootProject.ext.ndkVersion
+  }
+
   defaultConfig {
     minSdkVersion resolveMinSdkVersion()
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")

package/apple/ApplePlatformContext.h

@@ -13,8 +13,12 @@ public:
   // UIView* / NSView* bridged to void*, or nullptr). Called on the main thread
   // only. Provided by WebGPUModule from React Native's view registry.
   using ViewLookup = std::function<void *(int)>;
+  // Returns React Native's RCTBlobManager (unretained, bridged to void*), or
+  // nullptr. Provided by WebGPUModule from React Native's module registry.
+  using BlobManagerLookup = std::function<void *()>;
 
-  explicit ApplePlatformContext(ViewLookup viewLookup = nullptr);
+  explicit ApplePlatformContext(ViewLookup viewLookup,
+                                BlobManagerLookup blobManagerLookup);
   ~ApplePlatformContext() = default;
 
   void snapshotView(const ViewSnapshotRequest &request,
@@ -52,6 +56,7 @@ public:
 
 private:
   ViewLookup _viewLookup;
+  BlobManagerLookup _blobManagerLookup;
 };
 
 } // namespace rnwgpu

package/apple/ApplePlatformContext.mm

@@ -6,7 +6,6 @@
 #import <CoreVideo/CoreVideo.h>
 #import <ImageIO/ImageIO.h>
 #import <React/RCTBlobManager.h>
-#import <React/RCTBridge+Private.h>
 #import <ReactCommon/RCTTurboModule.h>
 
 #include "AppleVideoPlayer.h"
@@ -35,8 +34,10 @@ void checkIfUsingSimulatorWithAPIValidation() {
 #endif
 }
 
-ApplePlatformContext::ApplePlatformContext(ViewLookup viewLookup)
-    : _viewLookup(std::move(viewLookup)) {
+ApplePlatformContext::ApplePlatformContext(ViewLookup viewLookup,
+                                           BlobManagerLookup blobManagerLookup)
+    : _viewLookup(std::move(viewLookup)),
+      _blobManagerLookup(std::move(blobManagerLookup)) {
   checkIfUsingSimulatorWithAPIValidation();
 }
 
@@ -360,8 +361,7 @@ static std::span<const uint8_t> nsDataToSpan(NSData *data) {
 
 ImageData ApplePlatformContext::createImageBitmap(std::string blobId,
                                                   double offset, double size) {
-  RCTBlobManager *blobManager =
-      [[RCTBridge currentBridge] moduleForClass:RCTBlobManager.class];
+  RCTBlobManager *blobManager = (__bridge RCTBlobManager *)_blobManagerLookup();
   NSData *blobData =
       [blobManager resolve:[NSString stringWithUTF8String:blobId.c_str()]
                     offset:(long)offset
@@ -378,9 +378,8 @@ void ApplePlatformContext::createImageBitmapAsync(
     std::string blobId, double offset, double size,
     std::function<void(ImageData)> onSuccess,
     std::function<void(std::string)> onError) {
-  // Resolve blob on current thread (requires RCTBridge access)
-  RCTBlobManager *blobManager =
-      [[RCTBridge currentBridge] moduleForClass:RCTBlobManager.class];
+  // Resolve blob on current thread
+  RCTBlobManager *blobManager = (__bridge RCTBlobManager *)_blobManagerLookup();
   NSData *blobData =
       [blobManager resolve:[NSString stringWithUTF8String:blobId.c_str()]
                     offset:(long)offset

package/apple/MetalLayerColorSpace.mm

@@ -19,9 +19,18 @@ namespace rnwgpu {
 // "display-p3" the layer is tagged Display P3 instead, or its extended range
 // variant on a float format, so the values reach a wide-gamut display without
 // being converted from sRGB first.
+//
+// GPUCanvasConfiguration.toneMapping.mode says what happens to values above
+// 1.0 on a float canvas. Core Animation keeps an extended colorspace inside
+// the display's SDR range unless the layer asks for extended dynamic range
+// content, so without it the values clip at white: that is "standard". For
+// "extended" the layer opts in, and the values use the display's headroom
+// (EDR) as they do in a browser. An 8-bit canvas cannot hold values above 1.0,
+// so the flag only applies to a float format.
 void applyCAMetalLayerColorSpace(void *nativeSurface,
                                  wgpu::TextureFormat format,
-                                 CanvasColorSpace canvasColorSpace) {
+                                 CanvasColorSpace canvasColorSpace,
+                                 CanvasToneMappingMode toneMappingMode) {
   CALayer *layer = (__bridge CALayer *)nativeSurface;
   if (![layer isKindOfClass:[CAMetalLayer class]]) {
     return;
@@ -43,6 +52,13 @@ void applyCAMetalLayerColorSpace(void *nativeSurface,
     // 8-bit sRGB canvas.
     metalLayer.colorspace = nil;
   }
+  const bool extendedRange =
+      isFloat && toneMappingMode == CanvasToneMappingMode::Extended;
+  if (@available(iOS 16.0, tvOS 16.0, *)) {
+    if (metalLayer.wantsExtendedDynamicRangeContent != extendedRange) {
+      metalLayer.wantsExtendedDynamicRangeContent = extendedRange;
+    }
+  }
   // The change must be set synchronously so the first present already sees
   // it, and it must reach the render server. On a non-main thread (RN JS or
   // worklet runtime) the property lands in that thread's implicit

package/apple/WebGPUModule.mm

@@ -37,6 +37,10 @@ static std::shared_ptr<rnwgpu::RNWebGPUManager> webgpuManager;
 // (Fabric component views included), which drawElementImageToTexture needs.
 @synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
 
+// Synthesize the module registry so the TurboModule infra injects it too. It
+// reaches React Native's BlobModule in both Bridge and Bridgeless mode.
+@synthesize moduleRegistry = _moduleRegistry;
+
 + (std::shared_ptr<rnwgpu::RNWebGPUManager>)getManager {
   return webgpuManager;
 }
@@ -93,8 +97,18 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
         [strongSelf.viewRegistry_DEPRECATED viewForReactTag:@(tag)];
     return (__bridge void *)view;
   };
+  rnwgpu::ApplePlatformContext::BlobManagerLookup blobManagerLookup =
+      [weakSelf]() -> void * {
+    WebGPUModule *strongSelf = weakSelf;
+    if (strongSelf == nil) {
+      return nullptr;
+    }
+    return (__bridge void *)[strongSelf.moduleRegistry
+        moduleForName:"BlobModule"];
+  };
   std::shared_ptr<rnwgpu::PlatformContext> platformContext =
-      std::make_shared<rnwgpu::ApplePlatformContext>(std::move(viewLookup));
+      std::make_shared<rnwgpu::ApplePlatformContext>(
+          std::move(viewLookup), std::move(blobManagerLookup));
   webgpuManager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, jsInvoker,
                                                             platformContext);
   return @true;

package/cpp/jsi/Promise.cpp

@@ -41,4 +41,8 @@ void Promise::reject(std::string message) {
   _rejecter.call(runtime, error.value());
 }
 
+void Promise::reject(const jsi::JSError& error) {
+  _rejecter.call(runtime, error.value());
+}
+
 } // namespace rnwgpu

package/cpp/jsi/Promise.h

@@ -15,7 +15,10 @@ public:
   Promise(jsi::Runtime& runtime, jsi::Function&& resolver, jsi::Function&& rejecter);
 
   void resolve(jsi::Value&& result);
+  /** Rejects with a new Error carrying `error` as its message. */
   void reject(std::string error);
+  /** Rejects with the JS error `error` carries, as thrown. */
+  void reject(const jsi::JSError& error);
 
 public:
   jsi::Runtime& runtime;

package/cpp/rnwgpu/CanvasColorSpace.h

@@ -6,4 +6,9 @@ namespace rnwgpu {
 // values are interpreted when it is composited.
 enum class CanvasColorSpace { SRGB, DisplayP3 };
 
+// GPUCanvasConfiguration.toneMapping.mode (GPUCanvasToneMappingMode): whether
+// values above 1.0 on a float canvas are clamped to the display's SDR range
+// ("standard", the default) or reach its extended range ("extended").
+enum class CanvasToneMappingMode { Standard, Extended };
+
 } // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -64,10 +64,8 @@ RNWebGPUManager::RNWebGPUManager(
     : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker),
       _platformContext(platformContext) {
 
-  // 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 README "Threading model").
+  // Register the main runtime + its CallInvoker: how async results reach the
+  // main runtime, and the way to the UI runtime (see async::RuntimeContext).
   async::RuntimeContext::registerMainRuntime(_jsRuntime, _jsCallInvoker);
 
   // Expose the platform context to API objects created later without a

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -39,11 +39,13 @@ namespace rnwgpu {
 
 #ifdef __APPLE__
 // Tags the CAMetalLayer with the colorspace matching the configured texture
-// format and the canvas's colorSpace. Implemented in
+// format and the canvas's colorSpace, and opts it into the display's extended
+// dynamic range for an "extended" toneMapping mode. Implemented in
 // apple/MetalLayerColorSpace.mm.
 void applyCAMetalLayerColorSpace(void *nativeSurface,
                                  wgpu::TextureFormat format,
-                                 CanvasColorSpace colorSpace);
+                                 CanvasColorSpace colorSpace,
+                                 CanvasToneMappingMode toneMappingMode);
 #endif
 
 struct NativeInfo {
@@ -297,7 +299,8 @@ public:
         }
         configureSurfaceLocked(config);
 #ifdef __APPLE__
-        applyCAMetalLayerColorSpace(_nativeSurface, _config.format, _colorSpace);
+        applyCAMetalLayerColorSpace(_nativeSurface, _config.format, _colorSpace,
+                                    _toneMappingMode);
 #endif
         if (blit) {
           presentBlit = blitOffscreenToSurfaceLocked();
@@ -333,13 +336,16 @@ public:
   // --- Rendering thread
   // -------------------------------------------------------
 
-  void configure(wgpu::SurfaceConfiguration &newConfig,
-                 std::vector<wgpu::TextureFormat> viewFormats,
-                 CanvasColorSpace colorSpace = CanvasColorSpace::SRGB) {
+  void configure(
+      wgpu::SurfaceConfiguration &newConfig,
+      std::vector<wgpu::TextureFormat> viewFormats,
+      CanvasColorSpace colorSpace = CanvasColorSpace::SRGB,
+      CanvasToneMappingMode toneMappingMode = CanvasToneMappingMode::Standard) {
     applyPendingAttach(/* supersedeInFlightFrame = */ true);
     std::unique_lock<std::shared_mutex> lock(_mutex);
     _viewFormats = std::move(viewFormats);
     _colorSpace = colorSpace;
+    _toneMappingMode = toneMappingMode;
     _config = newConfig;
     // The caller's viewFormats storage dies with the call; point the stored
     // configuration at our own copy.
@@ -405,6 +411,7 @@ public:
     _texture = nullptr;
     _config = {};
     _colorSpace = CanvasColorSpace::SRGB;
+    _toneMappingMode = CanvasToneMappingMode::Standard;
     _viewFormats.clear();
     _acquiredFromSurface = false;
     _frameEpoch++;
@@ -911,7 +918,8 @@ private:
     if (_surface) {
       configureSurfaceLocked(_config);
 #ifdef __APPLE__
-      applyCAMetalLayerColorSpace(_nativeSurface, _config.format, _colorSpace);
+      applyCAMetalLayerColorSpace(_nativeSurface, _config.format, _colorSpace,
+                                  _toneMappingMode);
 #endif
     } else {
       _texture = createOffscreenTextureLocked();
@@ -1276,6 +1284,7 @@ private:
   wgpu::SurfaceConfiguration _config;
   std::vector<wgpu::TextureFormat> _viewFormats;
   CanvasColorSpace _colorSpace = CanvasColorSpace::SRGB;
+  CanvasToneMappingMode _toneMappingMode = CanvasToneMappingMode::Standard;
   // Keeps the Dawn instance alive for as long as any canvas exists.
   wgpu::Instance _gpu;
   // Native view size in dp (surfaced as clientWidth/clientHeight on the JS

package/cpp/rnwgpu/WebGPURuntime.cpp

@@ -18,7 +18,8 @@ wgpu::Instance createInstance() {
   // react-native-webgpu installs (see the RTLD_NOLOAD lookup below), so the
   // native-module init order decides whether the instance is shared.
   // RNWebGPU.importDevice does not depend on it: an imported device's async
-  // work is pumped on the instance that owns it (see async::RuntimeContext).
+  // work is waited for on the instance that owns it (see
+  // async::RuntimeContext).
   // Both packages must link the same single Dawn copy (they vendor the same
   // artifact) for the handles they exchange to be meaningful.
   using GetInstanceFn = WGPUInstance (*)();

package/cpp/rnwgpu/api/GPU.cpp

@@ -33,17 +33,17 @@ async::AsyncTaskHandle GPU::requestAdapter(
   aOptions.backendType = kDefaultBackendType;
 
   // Per-runtime context: async ops requested on this runtime resolve on this
-  // runtime's own thread (via its ProcessEvents pump).
+  // runtime's own thread (see RuntimeContext).
   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,
-            [context, resolve,
-             reject](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
-                     wgpu::StringView message) {
+        return _instance.RequestAdapter(
+            &aOptions, wgpu::CallbackMode::WaitAnyOnly,
+            [context, resolve, reject](wgpu::RequestAdapterStatus status,
+                                       wgpu::Adapter adapter,
+                                       wgpu::StringView message) {
               if (message.length) {
                 fprintf(stderr, "%s", message.data);
               }

package/cpp/rnwgpu/api/GPU.h

@@ -33,7 +33,7 @@ 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).
+  // RuntimeContext, which settles the promise on that runtime's thread.
   async::AsyncTaskHandle requestAdapter(
       jsi::Runtime &runtime,
       std::optional<std::shared_ptr<GPURequestAdapterOptions>> options);

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -271,6 +271,32 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
             enabledToggles.push_back(name);
           }
         }
+#endif
+#if defined(__APPLE__)
+        // iOS refuses GPU work from an app in the background, and Dawn loses
+        // the device over a refused command buffer. With this toggle Dawn
+        // holds the commits while the app is in the background, from
+        // UIApplication's own notifications, and commits them when it comes
+        // back: nothing is lost, nothing is refused, and a promise on the
+        // held work settles once the app is back (the same toggle Skia
+        // requests on the device it shares, see react-native-skia's
+        // DawnUtils::requestDevice). Dawn applies it on iOS and tvOS only, and
+        // a Dawn without it (react-native-webgpu-dawn before 157.1.0) drops
+        // the name. The caller opts out through disabledToggles.
+        {
+          static const char *const kName =
+              "metal_suspend_submissions_in_background";
+          const auto named = [](const char *t) {
+            return std::strcmp(t, kName) == 0;
+          };
+          const bool explicitlyDisabled = std::any_of(
+              disabledToggles.begin(), disabledToggles.end(), named);
+          const bool alreadyEnabled =
+              std::any_of(enabledToggles.begin(), enabledToggles.end(), named);
+          if (!explicitlyDisabled && !alreadyEnabled) {
+            enabledToggles.push_back(kName);
+          }
+        }
 #endif
         if (!enabledToggles.empty() || !disabledToggles.empty()) {
           toggles.enabledToggleCount = enabledToggles.size();
@@ -279,8 +305,8 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
           toggles.disabledToggles = disabledToggles.data();
           deviceDesc.nextInChain = &toggles;
         }
-        _instance.RequestDevice(
-            &deviceDesc, wgpu::CallbackMode::AllowProcessEvents,
+        return _instance.RequestDevice(
+            &deviceDesc, wgpu::CallbackMode::WaitAnyOnly,
             [context, resolve, reject, label, creationRuntime,
              deviceLostBinding](wgpu::RequestDeviceStatus status,
                                 wgpu::Device device, wgpu::StringView message) {

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -55,18 +55,17 @@ async::AsyncTaskHandle GPUBuffer::mapAsync(jsi::Runtime &runtime,
   // Post to the CALLING runtime's context, not the one captured at buffer
   // creation (_async): the buffer may have been created on another runtime and
   // boxed across (e.g. device created on the main JS runtime, mapAsync called
-  // from a worklet). The returned Promise lives on the calling runtime, so it
-  // must be settled from that runtime's own thread — and postTask itself
-  // schedules the pump through its context's runtime (setTimeout), which is
-  // only safe for the runtime we are currently executing on.
+  // The returned Promise lives on the calling runtime, so it
+  // must be settled from that runtime's own thread, which its context knows
+  // how to reach (see RuntimeContext).
   auto context =
       async::RuntimeContext::getOrCreate(runtime, _async->instance());
   return context->postTask(
       [bufferHandle, mode, resolvedOffset,
        rangeSize](const async::AsyncTaskHandle::ResolveFunction &resolve,
                   const async::AsyncTaskHandle::RejectFunction &reject) {
-        bufferHandle.MapAsync(
-            mode, resolvedOffset, rangeSize, wgpu::CallbackMode::AllowProcessEvents,
+        return bufferHandle.MapAsync(
+            mode, resolvedOffset, rangeSize, wgpu::CallbackMode::WaitAnyOnly,
             [resolve, reject](wgpu::MapAsyncStatus status,
                               wgpu::StringView message) {
               switch (status) {

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -30,7 +30,8 @@ void GPUCanvasContext::configure(
 #endif
   surfaceConfiguration.presentMode = wgpu::PresentMode::Fifo;
   _surfaceInfo->configure(surfaceConfiguration, std::move(viewFormats),
-                          configuration->colorSpace);
+                          configuration->colorSpace,
+                          configuration->toneMappingMode);
 }
 
 void GPUCanvasContext::unconfigure() { _surfaceInfo->unconfigure(); }

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -68,41 +68,35 @@ void GPUDevice::notifyDeviceLost(wgpu::DeviceLostReason reason,
     return;
   }
 
-  // getLost() only registers promises when the device's context has a
-  // CallInvoker (main JS runtime), so a non-empty list implies an invoker.
-  auto invoker = _async ? _async->callInvoker() : nullptr;
-  if (!invoker) {
-    return;
-  }
-
-  // Settle on the owning runtime's JS thread. The promises are held weakly:
-  // if the device graph was collected in the meantime there is nothing to do,
-  // since nobody could observe the resolution anyway. The shared_ptr is only
-  // there because jsi::WeakObject is move-only and std::function requires a
-  // copyable closure; it also ensures the WeakObjects are destroyed on the JS
-  // thread.
-  auto pending =
-      std::make_shared<std::vector<PendingLostPromise>>(std::move(toResolve));
-  invoker->invokeAsync([pending, info]() {
-    for (auto &entry : *pending) {
-      auto &runtime = *entry.runtime;
-      auto locked = entry.promise.lock(runtime);
+  // Settle each promise on the thread of the runtime that read it, through
+  // that runtime's context. The promises are held weakly: if the device graph
+  // was collected in the meantime there is nothing to do, since nobody could
+  // observe the resolution anyway. The shared_ptr is only there because
+  // jsi::WeakObject is move-only and std::function requires a copyable
+  // closure.
+  for (auto &entry : toResolve) {
+    auto context = entry.context.lock();
+    if (context == nullptr) {
+      continue;
+    }
+    auto pending = std::make_shared<jsi::WeakObject>(std::move(entry.promise));
+    context->post([pending, info](jsi::Runtime &runtime) {
+      auto locked = pending->lock(runtime);
       if (!locked.isObject()) {
-        continue;
+        return;
       }
       auto promiseObj = locked.getObject(runtime);
       auto resolveProp = promiseObj.getProperty(runtime, kLostResolveProp);
       if (!resolveProp.isObject() ||
           !resolveProp.getObject(runtime).isFunction(runtime)) {
-        continue;
+        return;
       }
       auto resolveFn = resolveProp.getObject(runtime).getFunction(runtime);
       resolveFn.call(runtime,
                      JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
                          runtime, info));
-    }
-    pending->clear();
-  });
+    });
+  }
 }
 
 void GPUDevice::forceLossForTesting() {
@@ -534,8 +528,8 @@ async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
                                const async::AsyncTaskHandle::RejectFunction
                                    &reject) {
     (void)descriptor;
-    device.CreateComputePipelineAsync(
-        &desc, wgpu::CallbackMode::AllowProcessEvents,
+    return device.CreateComputePipelineAsync(
+        &desc, wgpu::CallbackMode::WaitAnyOnly,
         [pipelineHolder, resolve,
          reject](wgpu::CreatePipelineAsyncStatus status,
                  wgpu::ComputePipeline pipeline, wgpu::StringView msg) {
@@ -581,8 +575,8 @@ async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
                                const async::AsyncTaskHandle::RejectFunction
                                    &reject) {
     (void)descriptor;
-    device.CreateRenderPipelineAsync(
-        &desc, wgpu::CallbackMode::AllowProcessEvents,
+    return device.CreateRenderPipelineAsync(
+        &desc, wgpu::CallbackMode::WaitAnyOnly,
         [pipelineHolder, resolve,
          reject](wgpu::CreatePipelineAsyncStatus status,
                  wgpu::RenderPipeline pipeline, wgpu::StringView msg) {
@@ -617,8 +611,8 @@ async::AsyncTaskHandle GPUDevice::popErrorScope(jsi::Runtime &runtime) {
                                    &resolve,
                                const async::AsyncTaskHandle::RejectFunction
                                    &reject) {
-    device.PopErrorScope(
-        wgpu::CallbackMode::AllowProcessEvents,
+    return device.PopErrorScope(
+        wgpu::CallbackMode::WaitAnyOnly,
         [resolve, reject](wgpu::PopErrorScopeStatus status,
                           wgpu::ErrorType type, wgpu::StringView message) {
           if (status == wgpu::PopErrorScopeStatus::Error ||
@@ -731,12 +725,12 @@ jsi::Value GPUDevice::getLost(jsi::Runtime &runtime,
                          *capturedResolve);
 
     // Register a WEAK reference so notifyDeviceLost() can settle the promise
-    // if it is still alive. Only wired for the device's own runtime when a
-    // CallInvoker exists (main JS runtime): spontaneous events are delivered
-    // through that invoker. A promise created on another runtime stays
-    // pending, matching the previous best-effort behavior.
+    // if it is still alive, on the thread of the runtime that read it,
+    // through that runtime's context (see RuntimeContext::post).
     bool settledMeanwhile = false;
-    if (_async && _async->callInvoker() && &runtime == &_async->runtime()) {
+    if (_async) {
+      auto context =
+          async::RuntimeContext::getOrCreate(runtime, _async->instance());
       std::lock_guard<std::mutex> lock(_lostMutex);
       if (_lostSettled) {
         // The device was lost between the check above and now.
@@ -744,7 +738,7 @@ jsi::Value GPUDevice::getLost(jsi::Runtime &runtime,
         settledInfo = _lostInfo;
       } else {
         _lostPromises.push_back(
-            PendingLostPromise{&runtime, jsi::WeakObject(runtime, promiseObj)});
+            PendingLostPromise{jsi::WeakObject(runtime, promiseObj), context});
       }
     }
     if (settledMeanwhile) {
@@ -775,20 +769,17 @@ void GPUDevice::removeEventListener(std::string type, jsi::Function callback) {
 
 void GPUDevice::notifyUncapturedError(wgpu::ErrorType type,
                                       std::string message) {
-  // Dawn can surface an uncaptured error from any ProcessEvents pump (a worklet
-  // runtime sharing this instance may pump it on the wrong thread). Marshal to
-  // the owning runtime's JS thread via its CallInvoker before touching JSI. The
-  // invoker is wired only for the main JS runtime, so a device created on a
-  // worklet runtime does not deliver uncaptured errors to JS (best-effort; see
-  // README "Threading model").
-  auto invoker = _async ? _async->callInvoker() : nullptr;
-  if (!invoker) {
+  // Dawn reports an uncaptured error from whichever thread detects it. The
+  // listeners run on the thread of the runtime the device was created on,
+  // through its context (see RuntimeContext::post).
+  if (!_async) {
     return;
   }
   auto self = shared_from_this();
-  invoker->invokeAsync([self, type, message = std::move(message)]() mutable {
-    self->deliverUncapturedError(type, std::move(message));
-  });
+  _async->post(
+      [self, type, message = std::move(message)](jsi::Runtime &) mutable {
+        self->deliverUncapturedError(type, std::move(message));
+      });
 }
 
 void GPUDevice::deliverUncapturedError(wgpu::ErrorType type,

package/cpp/rnwgpu/api/GPUDevice.h

@@ -302,7 +302,7 @@ private:
   friend class GPUAdapter;
 
   // Runs the uncapturederror listeners on the creation runtime's JS thread.
-  // Invoked from notifyUncapturedError via the main CallInvoker.
+  // Invoked from notifyUncapturedError through the runtime's context.
   void deliverUncapturedError(wgpu::ErrorType type, std::string message);
 
   wgpu::Device _instance;
@@ -327,12 +327,11 @@ private:
   // resolve function lives as a hidden property on the promise object itself,
   // so if the promise is still alive when the device is lost we can settle
   // it; if it was collected, nobody could have observed the resolution.
-  // Entries are only added for the device's own runtime when a CallInvoker is
-  // available (main JS runtime), matching the best-effort contract for
-  // spontaneous events.
+  // Each entry is settled on the thread of the runtime that read `lost`,
+  // through that runtime's context; a runtime gone since is skipped.
   struct PendingLostPromise {
-    jsi::Runtime *runtime;
     jsi::WeakObject promise;
+    std::weak_ptr<async::RuntimeContext> context;
   };
   std::vector<PendingLostPromise> _lostPromises;
 

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -94,8 +94,8 @@ async::AsyncTaskHandle GPUQueue::onSubmittedWorkDone(jsi::Runtime &runtime) {
   return context->postTask(
       [queue](const async::AsyncTaskHandle::ResolveFunction &resolve,
               const async::AsyncTaskHandle::RejectFunction &reject) {
-        queue.OnSubmittedWorkDone(
-            wgpu::CallbackMode::AllowProcessEvents,
+        return queue.OnSubmittedWorkDone(
+            wgpu::CallbackMode::WaitAnyOnly,
             [resolve, reject](wgpu::QueueWorkDoneStatus status,
                               wgpu::StringView message) {
               if (status == wgpu::QueueWorkDoneStatus::Success) {
@@ -531,6 +531,8 @@ async::AsyncTaskHandle GPUQueue::drawElementImageToTexture(
               });
             },
             [reject](std::string error) { reject(std::move(error)); });
+        // Not Dawn's work: nothing to wait for, the snapshot calls back.
+        return std::nullopt;
       });
 }
 

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -19,8 +19,8 @@ GPUShaderModule::getCompilationInfo(jsi::Runtime &runtime) {
       [module](const async::AsyncTaskHandle::ResolveFunction &resolve,
                const async::AsyncTaskHandle::RejectFunction &reject) {
         auto result = std::make_shared<GPUCompilationInfo>();
-        module.GetCompilationInfo(
-            wgpu::CallbackMode::AllowProcessEvents,
+        return module.GetCompilationInfo(
+            wgpu::CallbackMode::WaitAnyOnly,
             [result, resolve,
              reject](wgpu::CompilationInfoRequestStatus status,
                      const wgpu::CompilationInfo *compilationInfo) {