react-native-webgpu 0.10.4 → 0.11.0

package/apple/ApplePlatformContext.mm

@@ -10,10 +10,15 @@
 #import <ReactCommon/RCTTurboModule.h>
 
 #include "AppleVideoPlayer.h"
+#import "RNWGUIKit.h"
 
 #include "RNWebGPUManager.h"
 #include "WebGPUModule.h"
 
+#include <cmath>
+#include <string>
+#include <utility>
+
 namespace rnwgpu {
 
 void checkIfUsingSimulatorWithAPIValidation() {
@@ -30,10 +35,180 @@ void checkIfUsingSimulatorWithAPIValidation() {
 #endif
 }
 
-ApplePlatformContext::ApplePlatformContext() {
+ApplePlatformContext::ApplePlatformContext(ViewLookup viewLookup)
+    : _viewLookup(std::move(viewLookup)) {
   checkIfUsingSimulatorWithAPIValidation();
 }
 
+namespace {
+
+// Rasterize `request` on the main thread into tightly packed, premultiplied
+// BGRA8 pixels. Throws std::runtime_error with a user-facing message.
+ImageData snapshotViewOnMainThread(const ApplePlatformContext::ViewLookup &lookup,
+                                   const ViewSnapshotRequest &request) {
+  if (!lookup) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: no view registry is available");
+  }
+  RNWGPlatformView *view = (__bridge RNWGPlatformView *)lookup(request.viewTag);
+  if (view == nil) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: no native view found for tag " +
+        std::to_string(request.viewTag) +
+        " (is the view mounted, and rendered with collapsable={false}?)");
+  }
+  const CGRect bounds = view.bounds;
+  if (bounds.size.width <= 0 || bounds.size.height <= 0) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the view has no size yet");
+  }
+
+  // Source rectangle in points (view space); the whole view by default.
+  const double sourceX = request.sourceX;
+  const double sourceY = request.sourceY;
+  const double sourceWidth =
+      request.sourceWidth > 0 ? request.sourceWidth : bounds.size.width;
+  const double sourceHeight =
+      request.sourceHeight > 0 ? request.sourceHeight : bounds.size.height;
+
+  // Natural pixel size: points times the screen scale the view is shown at.
+#if !TARGET_OS_OSX
+  CGFloat scale = view.window.screen.scale;
+  if (scale <= 0) {
+    scale = UIScreen.mainScreen.scale;
+  }
+#else
+  CGFloat scale = view.window.backingScaleFactor;
+  if (scale <= 0) {
+    scale = NSScreen.mainScreen.backingScaleFactor;
+  }
+#endif
+  const uint32_t width =
+      request.width > 0
+          ? request.width
+          : static_cast<uint32_t>(std::llround(sourceWidth * scale));
+  const uint32_t height =
+      request.height > 0
+          ? request.height
+          : static_cast<uint32_t>(std::llround(sourceHeight * scale));
+  if (width == 0 || height == 0) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the source rectangle is empty");
+  }
+
+  // The view's bounds are drawn scaled so that the source rectangle covers
+  // the whole output.
+  const CGFloat scaleX = static_cast<CGFloat>(width) / sourceWidth;
+  const CGFloat scaleY = static_cast<CGFloat>(height) / sourceHeight;
+  const CGRect drawRect =
+      CGRectMake(-sourceX * scaleX, -sourceY * scaleY,
+                 bounds.size.width * scaleX, bounds.size.height * scaleY);
+
+  CGImageRef cgImage = NULL;
+#if !TARGET_OS_OSX
+  // drawViewHierarchyInRect renders what is on screen (including Metal /
+  // CAMetalLayer content), which is what "the element as displayed" means.
+  // afterScreenUpdates:YES flushes pending layout and layer changes first, so
+  // a snapshot taken right after a state change reflects that change.
+  UIGraphicsImageRendererFormat *format =
+      [UIGraphicsImageRendererFormat defaultFormat];
+  format.scale = 1.0;
+  format.opaque = NO;
+  format.preferredRange = UIGraphicsImageRendererFormatRangeStandard;
+  UIGraphicsImageRenderer *renderer = [[UIGraphicsImageRenderer alloc]
+      initWithSize:CGSizeMake(width, height)
+            format:format];
+  // drawViewHierarchyInRect returns NO and draws nothing when the view is not
+  // in a window (e.g. a screen pushed under another one). The image would
+  // then be fully transparent, so treat it as a failure instead.
+  __block BOOL drawn = NO;
+  UIImage *image = [renderer
+      imageWithActions:^(UIGraphicsImageRendererContext *_Nonnull context) {
+        drawn = [view drawViewHierarchyInRect:drawRect afterScreenUpdates:YES];
+      }];
+  if (!drawn) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the view could not be rendered (is it "
+        "attached to a window?)");
+  }
+  cgImage = image.CGImage;
+  if (cgImage != NULL) {
+    CGImageRetain(cgImage);
+  }
+#else
+  NSBitmapImageRep *rep = [view bitmapImageRepForCachingDisplayInRect:bounds];
+  if (rep != nil) {
+    [view cacheDisplayInRect:bounds toBitmapImageRep:rep];
+    cgImage = rep.CGImage;
+    if (cgImage != NULL) {
+      CGImageRetain(cgImage);
+    }
+  }
+#endif
+  if (cgImage == NULL) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the view could not be rendered");
+  }
+
+  // Normalize into premultiplied BGRA8 with no row padding, whatever the
+  // renderer produced.
+  ImageData result;
+  result.width = width;
+  result.height = height;
+  result.format = wgpu::TextureFormat::BGRA8Unorm;
+  result.premultiplied = true;
+  result.data.assign(static_cast<size_t>(width) * height * 4, 0);
+  CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+  CGContextRef context = CGBitmapContextCreate(
+      result.data.data(), width, height, 8, static_cast<size_t>(width) * 4,
+      colorSpace, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little);
+  CGColorSpaceRelease(colorSpace);
+  if (context == NULL) {
+    CGImageRelease(cgImage);
+    throw std::runtime_error(
+        "drawElementImageToTexture: could not allocate the pixel buffer");
+  }
+#if !TARGET_OS_OSX
+  // The renderer already produced exactly width x height pixels.
+  const CGRect imageRect = CGRectMake(0, 0, width, height);
+#else
+  // The cached display covers the whole view at the backing scale; draw it so
+  // that the source rectangle fills the output. CoreGraphics' origin is the
+  // bottom-left corner, hence the flipped vertical offset.
+  const CGRect imageRect = CGRectMake(
+      -sourceX * scaleX,
+      -(bounds.size.height - sourceY - sourceHeight) * scaleY,
+      bounds.size.width * scaleX, bounds.size.height * scaleY);
+#endif
+  CGContextSetBlendMode(context, kCGBlendModeCopy);
+  CGContextDrawImage(context, imageRect, cgImage);
+  CGContextRelease(context);
+  CGImageRelease(cgImage);
+  return result;
+}
+
+} // namespace
+
+void ApplePlatformContext::snapshotView(
+    const ViewSnapshotRequest &request,
+    std::function<void(ImageData)> onSuccess,
+    std::function<void(std::string)> onError) {
+  // Copies: the block outlives this call.
+  ViewLookup lookup = _viewLookup;
+  ViewSnapshotRequest snapshotRequest = request;
+  dispatch_async(dispatch_get_main_queue(), ^{
+    @autoreleasepool {
+      try {
+        onSuccess(snapshotViewOnMainThread(lookup, snapshotRequest));
+      } catch (const std::exception &error) {
+        onError(error.what());
+      } catch (...) {
+        onError("drawElementImageToTexture: unknown native error");
+      }
+    }
+  });
+}
+
 wgpu::Surface ApplePlatformContext::makeSurface(wgpu::Instance instance,
                                                 void *surface, int width,
                                                 int height) {

package/apple/WebGPUModule.mm

@@ -1,6 +1,7 @@
 #import "WebGPUModule.h"
 #include "ApplePlatformContext.h"
 #import "GPUCanvasContext.h"
+#import "RNWGUIKit.h"
 
 #import <React/RCTBridge+Private.h>
 #import <React/RCTCallInvoker.h>
@@ -31,6 +32,11 @@ static std::shared_ptr<rnwgpu::RNWebGPUManager> webgpuManager;
 // calls setCallInvoker: during module initialization.
 @synthesize callInvoker = _callInvoker;
 
+// Synthesize the view registry so the TurboModule infra injects it too. It
+// resolves React tags to native views in both Bridge and Bridgeless mode
+// (Fabric component views included), which drawElementImageToTexture needs.
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+
 + (std::shared_ptr<rnwgpu::RNWebGPUManager>)getManager {
   return webgpuManager;
 }
@@ -74,8 +80,21 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
     return [NSNumber numberWithBool:NO];
   }
 
+  // Main-thread only (see ApplePlatformContext::ViewLookup). Weak: the module
+  // is invalidated on reload, after which lookups simply fail.
+  __weak WebGPUModule *weakSelf = self;
+  rnwgpu::ApplePlatformContext::ViewLookup viewLookup =
+      [weakSelf](int tag) -> void * {
+    WebGPUModule *strongSelf = weakSelf;
+    if (strongSelf == nil) {
+      return nullptr;
+    }
+    RNWGPlatformView *view =
+        [strongSelf.viewRegistry_DEPRECATED viewForReactTag:@(tag)];
+    return (__bridge void *)view;
+  };
   std::shared_ptr<rnwgpu::PlatformContext> platformContext =
-      std::make_shared<rnwgpu::ApplePlatformContext>();
+      std::make_shared<rnwgpu::ApplePlatformContext>(std::move(viewLookup));
   webgpuManager = std::make_shared<rnwgpu::RNWebGPUManager>(runtime, jsInvoker,
                                                             platformContext);
   return @true;

package/cpp/rnwgpu/PlatformContext.h

@@ -2,6 +2,7 @@
 
 #include <functional>
 #include <memory>
+#include <mutex>
 #include <span>
 #include <string>
 #include <utility>
@@ -72,11 +73,55 @@ public:
   virtual void pause() = 0;
 };
 
+// A request to rasterize a native React Native view (looked up by its React
+// tag) for GPUQueue.drawElementImageToTexture.
+//
+// The source rectangle is expressed in the view's own coordinate space, in
+// density-independent points (the units of React Native layout). A
+// non-positive sourceWidth/sourceHeight means "the whole view". The
+// destination size is in pixels: the platform rasterizes the source rectangle
+// scaled to exactly width x height.
+struct ViewSnapshotRequest {
+  int viewTag = 0;
+  double sourceX = 0;
+  double sourceY = 0;
+  double sourceWidth = 0;
+  double sourceHeight = 0;
+  uint32_t width = 0;
+  uint32_t height = 0;
+};
+
 class PlatformContext {
 public:
   PlatformContext() = default;
   virtual ~PlatformContext() = default;
 
+  // The platform context of the currently installed RNWebGPUManager, for API
+  // objects (e.g. GPUQueue) that are created without a reference to it. Set on
+  // install, cleared on teardown; a dev reload replaces it.
+  static void setCurrent(std::shared_ptr<PlatformContext> context) {
+    std::lock_guard<std::mutex> lock(currentMutex());
+    currentSlot() = std::move(context);
+  }
+  static std::shared_ptr<PlatformContext> current() {
+    std::lock_guard<std::mutex> lock(currentMutex());
+    return currentSlot();
+  }
+
+  // Rasterize a native view into CPU pixels (see ViewSnapshotRequest). The
+  // implementation hops to the platform UI thread, so this is asynchronous:
+  // exactly one of onSuccess / onError is invoked, from an arbitrary thread
+  // (typically the UI thread). Callers must not touch JSI in the callbacks.
+  //
+  // The returned ImageData is tightly packed (no row padding), 4 bytes per
+  // pixel, `format` is rgba8unorm or bgra8unorm depending on what the platform
+  // rasterizer produces natively, and `premultiplied` reports its alpha
+  // representation.
+  virtual void
+  snapshotView(const ViewSnapshotRequest &request,
+               std::function<void(ImageData)> onSuccess,
+               std::function<void(std::string)> onError) = 0;
+
   virtual wgpu::Surface makeSurface(wgpu::Instance instance, void *surface,
                                     int width, int height) = 0;
   virtual ImageData createImageBitmap(std::string blobId, double offset,
@@ -129,6 +174,16 @@ public:
   // and return its absolute path. Lets the SharedTextureMemory example play
   // a real decoded video without bundling an asset.
   virtual std::string writeTestVideoFile() = 0;
+
+private:
+  static std::mutex &currentMutex() {
+    static std::mutex mutex;
+    return mutex;
+  }
+  static std::shared_ptr<PlatformContext> &currentSlot() {
+    static std::shared_ptr<PlatformContext> slot;
+    return slot;
+  }
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -67,6 +67,10 @@ RNWebGPUManager::RNWebGPUManager(
   // no invoker (best-effort; see README "Threading model").
   async::RuntimeContext::registerMainRuntime(_jsRuntime, _jsCallInvoker);
 
+  // Expose the platform context to API objects created later without a
+  // reference to it (GPUQueue::drawElementImageToTexture).
+  PlatformContext::setCurrent(_platformContext);
+
   auto gpu = std::make_shared<GPU>(*_jsRuntime);
   auto rnWebGPU =
       std::make_shared<RNWebGPU>(gpu, _platformContext, _jsCallInvoker);
@@ -248,6 +252,9 @@ RNWebGPUManager::~RNWebGPUManager() {
   // contextId counter, and stale entries would alias new canvases onto dead
   // surfaces.
   SurfaceRegistry::getInstance().clear();
+  if (PlatformContext::current() == _platformContext) {
+    PlatformContext::setCurrent(nullptr);
+  }
   _jsRuntime = nullptr;
   _jsCallInvoker = nullptr;
 }

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -446,8 +446,10 @@ public:
 
   // Returns the texture for the current frame: the surface's swapchain texture
   // when a surface is attached and healthy, an offscreen texture otherwise.
-  // Never returns null; throws when called before configure().
-  wgpu::Texture getCurrentTexture() {
+  // Never returns null; throws when called before configure(). When frameEpoch
+  // is given, it receives the epoch identifying this frame (see
+  // isCurrentFrame).
+  wgpu::Texture getCurrentTexture(uint64_t *frameEpoch = nullptr) {
     // Start-of-frame boundary; a new acquire supersedes any previous frame
     // that never presented.
     applyPendingAttach(/* supersedeInFlightFrame = */ true);
@@ -471,6 +473,9 @@ public:
         _frameInFlight = true;
         _acquiredFromSurface = false;
         _frameEpoch++;
+        if (frameEpoch) {
+          *frameEpoch = _frameEpoch;
+        }
         return texture;
       }
       // No slot available (pool not allocated yet, unsupported device, view
@@ -488,6 +493,9 @@ public:
     _frameInFlight = true;
     _acquiredFromSurface = false;
     _frameEpoch++;
+    if (frameEpoch) {
+      *frameEpoch = _frameEpoch;
+    }
     if (_surface) {
       auto texture = acquireSurfaceTextureLocked();
       if (texture) {
@@ -504,6 +512,17 @@ public:
     return _texture;
   }
 
+  // True while the frame started by the getCurrentTexture() call that
+  // returned frameEpoch is still the current one: nothing presented,
+  // configured, resized, unconfigured, detached, or adopted a surface since.
+  // A pending attach also ends it, so a frame that never presents cannot block
+  // adoption: the next getCurrentTexture() supersedes it, as an uncached call
+  // would.
+  bool isCurrentFrame(uint64_t frameEpoch) {
+    std::shared_lock<std::shared_mutex> lock(_mutex);
+    return _frameInFlight && !_hasPendingAttach && _frameEpoch == frameEpoch;
+  }
+
   // Present the current frame. Runs synchronously on the thread that did
   // getCurrentTexture/submit (main JS, Reanimated UI, or a worklet runtime),
   // preserving Dawn surface thread-affinity. Frames whose texture was not

package/cpp/rnwgpu/api/GPU.cpp

@@ -16,7 +16,7 @@
 namespace rnwgpu {
 
 GPU::GPU(jsi::Runtime & /*runtime*/) : NativeObject(CLASS_NAME) {
-  // If a Graphite build of @shopify/react-native-skia is loaded in this
+  // If a Graphite build of react-native-skia is loaded in this
   // process, adopt its wgpu::Instance instead of creating our own, so
   // Graphite's device and every JS-created device live on one instance. That
   // makes pointer-based handoff (RNWebGPU.importDevice of Skia's device)

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -3,6 +3,7 @@
 #include "RNWebGPUManager.h"
 #include <algorithm>
 #include <memory>
+#include <mutex>
 #include <utility>
 #include <vector>
 
@@ -52,7 +53,17 @@ std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
     _surfaceInfo->reconfigure(width, height);
   }
 
-  auto texture = _surfaceInfo->getCurrentTexture();
+  // Keep both the native texture and its JS wrapper stable until the frame
+  // ends. NativeObject::create already caches JS wrappers by native identity.
+  // The frame ends on any SurfaceInfo transition (present, configure, resize,
+  // unconfigure, surface detach or adoption), tracked by its frame epoch.
+  std::lock_guard<std::mutex> lock(_currentTextureMutex);
+  if (_currentTexture && _surfaceInfo->isCurrentFrame(_currentTextureEpoch)) {
+    return _currentTexture;
+  }
+  _currentTexture.reset();
+
+  auto texture = _surfaceInfo->getCurrentTexture(&_currentTextureEpoch);
   if (texture == nullptr) {
     throw std::runtime_error(
         "[WebGPU] getCurrentTexture() failed to acquire a texture");
@@ -64,7 +75,8 @@ std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
 
   // Pass reportsMemoryPressure=false to avoid triggering spurious Hermes GC
   // cycles every frame since the canvas texture doesn't own the buffer.
-  return std::make_shared<GPUTexture>(texture, "", false);
+  _currentTexture = std::make_shared<GPUTexture>(texture, "", false);
+  return _currentTexture;
 }
 
 void GPUCanvasContext::present() {

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -1,6 +1,8 @@
 #pragma once
 
+#include <cstdint>
 #include <memory>
+#include <mutex>
 #include <string>
 #include <utility>
 
@@ -66,6 +68,12 @@ private:
   std::shared_ptr<Canvas> _canvas;
   std::shared_ptr<SurfaceInfo> _surfaceInfo;
   std::shared_ptr<GPU> _gpu;
+  // The current frame's texture, valid while
+  // _surfaceInfo->isCurrentFrame(_currentTextureEpoch). Guarded by
+  // _currentTextureMutex: contexts can be driven from worklet runtimes.
+  std::mutex _currentTextureMutex;
+  std::shared_ptr<GPUTexture> _currentTexture;
+  uint64_t _currentTextureEpoch = 0;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -1,10 +1,16 @@
 #include "GPUQueue.h"
 
+#include <algorithm>
+#include <cmath>
 #include <limits>
 #include <memory>
+#include <string>
+#include <utility>
 #include <vector>
 
 #include "Convertors.h"
+#include "ImageBitmap.h"
+#include "PlatformContext.h"
 
 namespace rnwgpu {
 
@@ -193,6 +199,187 @@ void GPUQueue::copyExternalImageToTexture(
   }
 }
 
+async::AsyncTaskHandle GPUQueue::drawElementImageToTexture(
+    jsi::Runtime &runtime, std::shared_ptr<GPUDrawElementImageSource> source,
+    std::shared_ptr<GPUDrawElementImageDestination> destination) {
+  auto platform = PlatformContext::current();
+  if (!platform) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: react-native-webgpu is not installed");
+  }
+  if (!destination || !destination->info || !destination->info->texture) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: `destination.texture` is required");
+  }
+  const auto &info = destination->info;
+
+  // Destination texture: only the 8-bit RGBA/BGRA formats the platform
+  // rasterizers produce natively are accepted (with a byte swizzle between
+  // the two); anything else would need a GPU blit.
+  wgpu::TexelCopyTextureInfo dst{};
+  Convertor conv;
+  if (!conv(dst.aspect, info->aspect) || !conv(dst.mipLevel, info->mipLevel) ||
+      !conv(dst.origin, info->origin) || !conv(dst.texture, info->texture)) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: invalid destination");
+  }
+  const wgpu::Texture texture = info->texture->get();
+  bool destinationIsBgra = false;
+  switch (texture.GetFormat()) {
+  case wgpu::TextureFormat::RGBA8Unorm:
+  case wgpu::TextureFormat::RGBA8UnormSrgb:
+    destinationIsBgra = false;
+    break;
+  case wgpu::TextureFormat::BGRA8Unorm:
+  case wgpu::TextureFormat::BGRA8UnormSrgb:
+    destinationIsBgra = true;
+    break;
+  default:
+    throw std::runtime_error(
+        "drawElementImageToTexture: the destination texture must be "
+        "rgba8unorm, rgba8unorm-srgb, bgra8unorm or bgra8unorm-srgb");
+  }
+  if (!(texture.GetUsage() & wgpu::TextureUsage::CopyDst)) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the destination texture must have "
+        "GPUTextureUsage.COPY_DST");
+  }
+  if (texture.GetDimension() != wgpu::TextureDimension::e2D ||
+      texture.GetSampleCount() != 1) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the destination must be a single-sampled "
+        "2D texture");
+  }
+  if (dst.mipLevel >= texture.GetMipLevelCount()) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: destination.mipLevel is out of range");
+  }
+  const uint32_t mipWidth =
+      std::max<uint32_t>(1, texture.GetWidth() >> dst.mipLevel);
+  const uint32_t mipHeight =
+      std::max<uint32_t>(1, texture.GetHeight() >> dst.mipLevel);
+  if (dst.origin.z >= texture.GetDepthOrArrayLayers()) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: destination.origin.z is out of range");
+  }
+
+  // Source rectangle (points, view space). Omitted width/height mean "the
+  // whole view", which only the platform knows.
+  ViewSnapshotRequest request{};
+  request.viewTag = source->viewTag;
+  request.sourceX = source->sourceX.value_or(0.0);
+  request.sourceY = source->sourceY.value_or(0.0);
+  request.sourceWidth = source->sourceWidth.value_or(0.0);
+  request.sourceHeight = source->sourceHeight.value_or(0.0);
+  if (!std::isfinite(request.sourceX) || !std::isfinite(request.sourceY) ||
+      !std::isfinite(request.sourceWidth) ||
+      !std::isfinite(request.sourceHeight) ||
+      (source->sourceWidth.has_value() && request.sourceWidth <= 0) ||
+      (source->sourceHeight.has_value() && request.sourceHeight <= 0)) {
+    throw std::runtime_error(
+        "drawElementImageToTexture: the source rectangle must be finite with "
+        "a positive width and height");
+  }
+
+  // Destination size (pixels). Omitted means the source rectangle's natural
+  // pixel size (points times the device pixel ratio), which the platform
+  // computes; the bounds check then happens once the pixels are back.
+  if (destination->size.has_value()) {
+    wgpu::Extent3D size{};
+    if (!conv(size, destination->size.value())) {
+      throw std::runtime_error(
+          "drawElementImageToTexture: invalid destination.size");
+    }
+    if (size.width == 0 || size.height == 0 || size.depthOrArrayLayers != 1) {
+      throw std::runtime_error(
+          "drawElementImageToTexture: destination.size must have a positive "
+          "width and height and a depthOrArrayLayers of 1");
+    }
+    if (size.width > mipWidth - std::min(dst.origin.x, mipWidth) ||
+        size.height > mipHeight - std::min(dst.origin.y, mipHeight)) {
+      throw std::runtime_error(
+          "drawElementImageToTexture: destination.origin + destination.size "
+          "exceeds the texture's extent at destination.mipLevel");
+    }
+    request.width = size.width;
+    request.height = size.height;
+  }
+
+  // premultipliedAlpha defaults to false, like copyExternalImageToTexture.
+  const bool destinationPremultiplied =
+      info->premultipliedAlpha.value_or(false);
+
+  // Settle on the CALLING runtime's context (see GPUBuffer::mapAsync): the
+  // snapshot completes on the UI thread and is deposited into that context's
+  // mailbox; the texture write and the resolve then run on the runtime's own
+  // thread during its next tick.
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  auto queue = _instance;
+  // Keeps the destination texture alive until the write is issued.
+  auto gpuTexture = info->texture;
+  return context->postTask(
+      [platform, request, dst, mipWidth, mipHeight, destinationIsBgra,
+       destinationPremultiplied, queue,
+       gpuTexture](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                   const async::AsyncTaskHandle::RejectFunction &reject) {
+        platform->snapshotView(
+            request,
+            [resolve, reject, dst, mipWidth, mipHeight, destinationIsBgra,
+             destinationPremultiplied, queue,
+             gpuTexture](ImageData image) mutable {
+              // Arbitrary (UI) thread: validate without touching JSI.
+              if (image.width == 0 || image.height == 0 ||
+                  image.data.size() < image.width * image.height * 4) {
+                reject("drawElementImageToTexture: the view produced no "
+                       "pixels (is it mounted with a non-zero size?)");
+                return;
+              }
+              if (image.width > mipWidth - std::min<uint32_t>(dst.origin.x,
+                                                              mipWidth) ||
+                  image.height > mipHeight - std::min<uint32_t>(dst.origin.y,
+                                                                mipHeight)) {
+                reject("drawElementImageToTexture: the view's natural pixel "
+                       "size (" +
+                       std::to_string(image.width) + "x" +
+                       std::to_string(image.height) +
+                       ") does not fit in the destination texture at "
+                       "destination.origin; pass destination.size to scale "
+                       "it, or create a larger texture");
+                return;
+              }
+              resolve([image = std::move(image), dst, destinationIsBgra,
+                       destinationPremultiplied, queue,
+                       gpuTexture](jsi::Runtime &) mutable -> jsi::Value {
+                // Owning runtime's thread. Bring the pixels into the
+                // destination's channel order and alpha representation, then
+                // issue the write.
+                const bool sourceIsBgra =
+                    image.format == wgpu::TextureFormat::BGRA8Unorm ||
+                    image.format == wgpu::TextureFormat::BGRA8UnormSrgb;
+                uint8_t *pixels = image.data.data();
+                const size_t byteLength = image.width * image.height * 4;
+                if (sourceIsBgra != destinationIsBgra) {
+                  for (size_t i = 0; i + 3 < byteLength; i += 4) {
+                    std::swap(pixels[i], pixels[i + 2]);
+                  }
+                }
+                convertAlpha(pixels, byteLength, image.premultiplied,
+                             destinationPremultiplied);
+                wgpu::TexelCopyBufferLayout layout{};
+                layout.offset = 0;
+                layout.bytesPerRow = static_cast<uint32_t>(image.width * 4);
+                layout.rowsPerImage = static_cast<uint32_t>(image.height);
+                wgpu::Extent3D extent{static_cast<uint32_t>(image.width),
+                                      static_cast<uint32_t>(image.height), 1};
+                queue.WriteTexture(&dst, pixels, byteLength, &layout, &extent);
+                return jsi::Value::undefined();
+              });
+            },
+            [reject](std::string error) { reject(std::move(error)); });
+      });
+}
+
 void GPUQueue::writeTexture(std::shared_ptr<GPUImageCopyTexture> destination,
                             std::shared_ptr<ArrayBuffer> data,
                             std::shared_ptr<GPUImageDataLayout> dataLayout,