@shopify/react-native-skia 2.9.1-next.1 → 2.9.1

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -18,6 +18,7 @@
 namespace rnwgpu {
 
 async::AsyncTaskHandle GPUAdapter::requestDevice(
+    jsi::Runtime &runtime,
     std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor) {
   wgpu::DeviceDescriptor aDescriptor;
   Convertor conv;
@@ -104,9 +105,15 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
       descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
 
   auto creationRuntime = getCreationRuntime();
-  return _async->postTask(
+  // Post to the CALLING runtime's context so the promise settles on the
+  // thread that requested it (see GPUBuffer::mapAsync). The GPUDevice is also
+  // bound to this context, honoring the contract that a device belongs to the
+  // runtime that requested it.
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  return context->postTask(
       [this, aDescriptor, descriptor, label = std::move(label),
-       deviceLostBinding,
+       deviceLostBinding, context,
        creationRuntime](const async::AsyncTaskHandle::ResolveFunction &resolve,
                         const async::AsyncTaskHandle::RejectFunction &reject) {
         // Build a local mutable copy so we can chain Dawn's device toggles.
@@ -138,7 +145,7 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
         }
         _instance.RequestDevice(
             &deviceDesc, wgpu::CallbackMode::AllowProcessEvents,
-            [context = _async, resolve, reject, label, creationRuntime,
+            [context, resolve, reject, label, creationRuntime,
              deviceLostBinding](wgpu::RequestDeviceStatus status,
                                 wgpu::Device device,
                                 wgpu::StringView message) {

package/cpp/rnwgpu/api/GPUAdapter.h

@@ -33,8 +33,9 @@ public:
 public:
   std::string getBrand() { return CLASS_NAME; }
 
-  async::AsyncTaskHandle
-  requestDevice(std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor);
+  async::AsyncTaskHandle requestDevice(
+      jsi::Runtime &runtime,
+      std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor);
 
   std::unordered_set<std::string> getFeatures();
   std::shared_ptr<GPUSupportedLimits> getLimits();
@@ -42,8 +43,8 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installGetter(runtime, prototype, "__brand", &GPUAdapter::getBrand);
-    installMethod(runtime, prototype, "requestDevice",
-                  &GPUAdapter::requestDevice);
+    installMethodWithRuntime(runtime, prototype, "requestDevice",
+                             &GPUAdapter::requestDevice);
     installGetter(runtime, prototype, "features", &GPUAdapter::getFeatures);
     installGetter(runtime, prototype, "limits", &GPUAdapter::getLimits);
     installGetter(runtime, prototype, "info", &GPUAdapter::getInfo);

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -37,7 +37,8 @@ GPUBuffer::getMappedRange(std::optional<size_t> o, std::optional<size_t> size) {
 
 void GPUBuffer::destroy() { _instance.Destroy(); }
 
-async::AsyncTaskHandle GPUBuffer::mapAsync(uint64_t modeIn,
+async::AsyncTaskHandle GPUBuffer::mapAsync(jsi::Runtime &runtime,
+                                           uint64_t modeIn,
                                            std::optional<uint64_t> offset,
                                            std::optional<uint64_t> size) {
   Convertor conv;
@@ -51,7 +52,16 @@ async::AsyncTaskHandle GPUBuffer::mapAsync(uint64_t modeIn,
   auto bufferHandle = _instance;
   uint64_t resolvedOffset = offset.value_or(0);
 
-  return _async->postTask(
+  // 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.
+  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) {

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -33,7 +33,7 @@ public:
 public:
   std::string getBrand() { return CLASS_NAME; }
 
-  async::AsyncTaskHandle mapAsync(uint64_t modeIn,
+  async::AsyncTaskHandle mapAsync(jsi::Runtime &runtime, uint64_t modeIn,
                                   std::optional<uint64_t> offset,
                                   std::optional<uint64_t> size);
   std::shared_ptr<ArrayBuffer> getMappedRange(std::optional<size_t> offset,
@@ -53,7 +53,8 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installGetter(runtime, prototype, "__brand", &GPUBuffer::getBrand);
-    installMethod(runtime, prototype, "mapAsync", &GPUBuffer::mapAsync);
+    installMethodWithRuntime(runtime, prototype, "mapAsync",
+                             &GPUBuffer::mapAsync);
     installMethod(runtime, prototype, "getMappedRange",
                   &GPUBuffer::getMappedRange);
     installMethod(runtime, prototype, "unmap", &GPUBuffer::unmap);

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -1,6 +1,9 @@
 #include "GPUCanvasContext.h"
 #include "Convertors.h"
+#include <algorithm>
 #include <memory>
+#include <utility>
+#include <vector>
 
 namespace rnwgpu {
 
@@ -9,37 +12,50 @@ void GPUCanvasContext::configure(
   Convertor conv;
   wgpu::SurfaceConfiguration surfaceConfiguration;
   surfaceConfiguration.device = configuration->device->get();
-  if (configuration->viewFormats.has_value()) {
-    if (!conv(surfaceConfiguration.viewFormats,
-              surfaceConfiguration.viewFormatCount,
-              configuration->viewFormats.value())) {
-      throw std::runtime_error("Error with SurfaceConfiguration");
-    }
-  }
   if (!conv(surfaceConfiguration.usage, configuration->usage) ||
       !conv(surfaceConfiguration.format, configuration->format)) {
     throw std::runtime_error("Error with SurfaceConfiguration");
   }
+  // viewFormats are deep-copied into SurfaceInfo (which outlives this call);
+  // Convertor-allocated arrays would dangle.
+  std::vector<wgpu::TextureFormat> viewFormats;
+  if (configuration->viewFormats.has_value()) {
+    viewFormats = configuration->viewFormats.value();
+  }
 
 #ifdef __APPLE__
   surfaceConfiguration.alphaMode = configuration->alphaMode;
 #endif
   surfaceConfiguration.presentMode = wgpu::PresentMode::Fifo;
-  _surfaceInfo->configure(surfaceConfiguration);
+  _surfaceInfo->configure(surfaceConfiguration, std::move(viewFormats));
 }
 
-void GPUCanvasContext::unconfigure() {}
+void GPUCanvasContext::unconfigure() { _surfaceInfo->unconfigure(); }
 
 std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
+  if (!_surfaceInfo->isConfigured()) {
+    // Web parity: on the web this is an InvalidStateError, not a crash.
+    throw std::runtime_error(
+        "[WebGPU] getCurrentTexture() called on a canvas context that is not "
+        "configured; call context.configure() first");
+  }
+  // The drawing buffer tracks canvas.width/height (like on the web); resize it
+  // lazily when they changed. Sizes are clamped to 1 so a canvas that has not
+  // been laid out yet (0x0) keeps working.
   auto prevSize = _surfaceInfo->getConfig();
-  auto width = _canvas->getWidth();
-  auto height = _canvas->getHeight();
-  auto sizeHasChanged = prevSize.width != width || prevSize.height != height;
+  auto width = std::max(1, _canvas->getWidth());
+  auto height = std::max(1, _canvas->getHeight());
+  auto sizeHasChanged = prevSize.width != static_cast<uint32_t>(width) ||
+                        prevSize.height != static_cast<uint32_t>(height);
   if (sizeHasChanged) {
     _surfaceInfo->reconfigure(width, height);
   }
 
   auto texture = _surfaceInfo->getCurrentTexture();
+  if (texture == nullptr) {
+    throw std::runtime_error(
+        "[WebGPU] getCurrentTexture() failed to acquire a texture");
+  }
 
   auto size = _surfaceInfo->getSize();
   _canvas->setClientWidth(size.width);
@@ -49,13 +65,11 @@ std::shared_ptr<GPUTexture> GPUCanvasContext::getCurrentTexture() {
 }
 
 void GPUCanvasContext::present() {
-  // Present runs synchronously on the calling thread (the one that did
-  // getCurrentTexture / submit), preserving Dawn surface thread-affinity.
-  // Required on every runtime (main JS, Reanimated UI, dedicated worklet);
-  // offscreen surfaces have no wgpu::Surface so they no-op.
-  if (_surfaceInfo->hasSurface()) {
-    _surfaceInfo->presentFrame();
-  }
+  // presentFrame() is the end-of-frame boundary: it presents when this frame's
+  // texture was acquired from the on-screen surface (offscreen and dropped
+  // frames are skipped), clears the frame state, and adopts any surface that
+  // attached while the frame was in flight.
+  _surfaceInfo->presentFrame();
 }
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -56,7 +56,9 @@ public:
   std::shared_ptr<GPUTexture> getCurrentTexture();
   // Present is explicit on every runtime (main JS, Reanimated UI, and dedicated
   // worklet runtimes). It runs synchronously on the calling thread, preserving
-  // Dawn surface thread-affinity; offscreen surfaces no-op.
+  // Dawn surface thread-affinity; frames rendered offscreen (no surface
+  // attached) are skipped. It is also the end-of-frame boundary at which a
+  // newly attached native surface is adopted (see SurfaceInfo).
   void present();
 
 private:

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -327,6 +327,7 @@ std::shared_ptr<GPUSharedFence> GPUDevice::importSharedFence(
 }
 
 async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
+    jsi::Runtime &runtime,
     std::shared_ptr<GPUComputePipelineDescriptor> descriptor) {
   wgpu::ComputePipelineDescriptor desc{};
   Convertor conv;
@@ -339,12 +340,16 @@ async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
       descriptor->label.has_value() ? descriptor->label.value() : "");
   auto pipelineHolder = std::make_shared<GPUComputePipeline>(nullptr, label);
 
-  return _async->postTask([device = _instance, desc, descriptor,
-                           pipelineHolder](
-                              const async::AsyncTaskHandle::ResolveFunction
-                                  &resolve,
-                              const async::AsyncTaskHandle::RejectFunction
-                                  &reject) {
+  // Post to the CALLING runtime's context so the promise settles on the
+  // thread that requested it (see GPUBuffer::mapAsync).
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  return context->postTask([device = _instance, desc, descriptor,
+                            pipelineHolder](
+                               const async::AsyncTaskHandle::ResolveFunction
+                                   &resolve,
+                               const async::AsyncTaskHandle::RejectFunction
+                                   &reject) {
     (void)descriptor;
     device.CreateComputePipelineAsync(
         &desc, wgpu::CallbackMode::AllowProcessEvents,
@@ -368,6 +373,7 @@ async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
 }
 
 async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
+    jsi::Runtime &runtime,
     std::shared_ptr<GPURenderPipelineDescriptor> descriptor) {
   wgpu::RenderPipelineDescriptor desc{};
   Convertor conv;
@@ -381,12 +387,16 @@ async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
       descriptor->label.has_value() ? descriptor->label.value() : "");
   auto pipelineHolder = std::make_shared<GPURenderPipeline>(nullptr, label);
 
-  return _async->postTask([device = _instance, desc, descriptor,
-                           pipelineHolder](
-                              const async::AsyncTaskHandle::ResolveFunction
-                                  &resolve,
-                              const async::AsyncTaskHandle::RejectFunction
-                                  &reject) {
+  // Post to the CALLING runtime's context so the promise settles on the
+  // thread that requested it (see GPUBuffer::mapAsync).
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  return context->postTask([device = _instance, desc, descriptor,
+                            pipelineHolder](
+                               const async::AsyncTaskHandle::ResolveFunction
+                                   &resolve,
+                               const async::AsyncTaskHandle::RejectFunction
+                                   &reject) {
     (void)descriptor;
     device.CreateRenderPipelineAsync(
         &desc, wgpu::CallbackMode::AllowProcessEvents,
@@ -413,13 +423,18 @@ void GPUDevice::pushErrorScope(wgpu::ErrorFilter filter) {
   _instance.PushErrorScope(filter);
 }
 
-async::AsyncTaskHandle GPUDevice::popErrorScope() {
+async::AsyncTaskHandle GPUDevice::popErrorScope(jsi::Runtime &runtime) {
   auto device = _instance;
 
-  return _async->postTask([device](const async::AsyncTaskHandle::ResolveFunction
-                                       &resolve,
-                                   const async::AsyncTaskHandle::RejectFunction
-                                       &reject) {
+  // Post to the CALLING runtime's context so the promise settles on the
+  // thread that requested it (see GPUBuffer::mapAsync).
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  return context->postTask([device](
+                               const async::AsyncTaskHandle::ResolveFunction
+                                   &resolve,
+                               const async::AsyncTaskHandle::RejectFunction
+                                   &reject) {
     device.PopErrorScope(
         wgpu::CallbackMode::AllowProcessEvents,
         [resolve, reject](wgpu::PopErrorScopeStatus status,

package/cpp/rnwgpu/api/GPUDevice.h

@@ -141,8 +141,10 @@ public:
   std::shared_ptr<GPURenderPipeline>
   createRenderPipeline(std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
   async::AsyncTaskHandle createComputePipelineAsync(
+      jsi::Runtime &runtime,
       std::shared_ptr<GPUComputePipelineDescriptor> descriptor);
   async::AsyncTaskHandle createRenderPipelineAsync(
+      jsi::Runtime &runtime,
       std::shared_ptr<GPURenderPipelineDescriptor> descriptor);
   std::shared_ptr<GPUCommandEncoder> createCommandEncoder(
       std::optional<std::shared_ptr<GPUCommandEncoderDescriptor>> descriptor);
@@ -151,7 +153,7 @@ public:
   std::shared_ptr<GPUQuerySet>
   createQuerySet(std::shared_ptr<GPUQuerySetDescriptor> descriptor);
   void pushErrorScope(wgpu::ErrorFilter filter);
-  async::AsyncTaskHandle popErrorScope();
+  async::AsyncTaskHandle popErrorScope(jsi::Runtime &runtime);
 
   std::unordered_set<std::string> getFeatures();
   std::shared_ptr<GPUSupportedLimits> getLimits();
@@ -197,10 +199,10 @@ public:
                   &GPUDevice::createComputePipeline);
     installMethod(runtime, prototype, "createRenderPipeline",
                   &GPUDevice::createRenderPipeline);
-    installMethod(runtime, prototype, "createComputePipelineAsync",
-                  &GPUDevice::createComputePipelineAsync);
-    installMethod(runtime, prototype, "createRenderPipelineAsync",
-                  &GPUDevice::createRenderPipelineAsync);
+    installMethodWithRuntime(runtime, prototype, "createComputePipelineAsync",
+                             &GPUDevice::createComputePipelineAsync);
+    installMethodWithRuntime(runtime, prototype, "createRenderPipelineAsync",
+                             &GPUDevice::createRenderPipelineAsync);
     installMethod(runtime, prototype, "createCommandEncoder",
                   &GPUDevice::createCommandEncoder);
     installMethod(runtime, prototype, "createRenderBundleEncoder",
@@ -209,8 +211,8 @@ public:
                   &GPUDevice::createQuerySet);
     installMethod(runtime, prototype, "pushErrorScope",
                   &GPUDevice::pushErrorScope);
-    installMethod(runtime, prototype, "popErrorScope",
-                  &GPUDevice::popErrorScope);
+    installMethodWithRuntime(runtime, prototype, "popErrorScope",
+                             &GPUDevice::popErrorScope);
     installGetter(runtime, prototype, "features", &GPUDevice::getFeatures);
     installGetter(runtime, prototype, "limits", &GPUDevice::getLimits);
     installGetter(runtime, prototype, "queue", &GPUDevice::getQueue);

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -79,9 +79,13 @@ void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
                         static_cast<size_t>(size64));
 }
 
-async::AsyncTaskHandle GPUQueue::onSubmittedWorkDone() {
+async::AsyncTaskHandle GPUQueue::onSubmittedWorkDone(jsi::Runtime &runtime) {
   auto queue = _instance;
-  return _async->postTask(
+  // Post to the CALLING runtime's context so the promise settles on the
+  // thread that requested it (see GPUBuffer::mapAsync).
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  return context->postTask(
       [queue](const async::AsyncTaskHandle::ResolveFunction &resolve,
               const async::AsyncTaskHandle::RejectFunction &reject) {
         queue.OnSubmittedWorkDone(

package/cpp/rnwgpu/api/GPUQueue.h

@@ -40,7 +40,7 @@ public:
   std::string getBrand() { return CLASS_NAME; }
 
   void submit(std::vector<std::shared_ptr<GPUCommandBuffer>> commandBuffers);
-  async::AsyncTaskHandle onSubmittedWorkDone();
+  async::AsyncTaskHandle onSubmittedWorkDone(jsi::Runtime &runtime);
   void writeBuffer(std::shared_ptr<GPUBuffer> buffer, uint64_t bufferOffset,
                    std::shared_ptr<ArrayBuffer> data,
                    std::optional<uint64_t> dataOffsetElements,
@@ -63,8 +63,8 @@ public:
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installGetter(runtime, prototype, "__brand", &GPUQueue::getBrand);
     installMethod(runtime, prototype, "submit", &GPUQueue::submit);
-    installMethod(runtime, prototype, "onSubmittedWorkDone",
-                  &GPUQueue::onSubmittedWorkDone);
+    installMethodWithRuntime(runtime, prototype, "onSubmittedWorkDone",
+                             &GPUQueue::onSubmittedWorkDone);
     installMethod(runtime, prototype, "writeBuffer", &GPUQueue::writeBuffer);
     installMethod(runtime, prototype, "writeTexture", &GPUQueue::writeTexture);
     installMethod(runtime, prototype, "copyExternalImageToTexture",

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -7,10 +7,15 @@
 
 namespace rnwgpu {
 
-async::AsyncTaskHandle GPUShaderModule::getCompilationInfo() {
+async::AsyncTaskHandle
+GPUShaderModule::getCompilationInfo(jsi::Runtime &runtime) {
   auto module = _instance;
 
-  return _async->postTask(
+  // Post to the CALLING runtime's context so the promise settles on the
+  // thread that requested it (see GPUBuffer::mapAsync).
+  auto context =
+      async::RuntimeContext::getOrCreate(runtime, _async->instance());
+  return context->postTask(
       [module](const async::AsyncTaskHandle::ResolveFunction &resolve,
                const async::AsyncTaskHandle::RejectFunction &reject) {
         auto result = std::make_shared<GPUCompilationInfo>();

package/cpp/rnwgpu/api/GPUShaderModule.h

@@ -31,7 +31,7 @@ public:
 public:
   std::string getBrand() { return CLASS_NAME; }
 
-  async::AsyncTaskHandle getCompilationInfo();
+  async::AsyncTaskHandle getCompilationInfo(jsi::Runtime &runtime);
 
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {
@@ -41,8 +41,8 @@ public:
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installGetter(runtime, prototype, "__brand", &GPUShaderModule::getBrand);
-    installMethod(runtime, prototype, "getCompilationInfo",
-                  &GPUShaderModule::getCompilationInfo);
+    installMethodWithRuntime(runtime, prototype, "getCompilationInfo",
+                             &GPUShaderModule::getCompilationInfo);
     installGetterSetter(runtime, prototype, "label", &GPUShaderModule::getLabel,
                         &GPUShaderModule::setLabel);
   }

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -45,11 +45,31 @@ public:
                                     nativeInfo.height);
   }
 
+  // Retires a canvas context from the JS side (Canvas unmount cleanup).
+  // Registry entries have two owners, split by whether a native surface is
+  // attached:
+  // - A native view currently owns a surface (or one is pending): its own
+  //   teardown (WebGPUMetalView dealloc / WebGPUViewManager.onDropViewInstance)
+  //   removes the entry. Skipping here keeps React StrictMode safe: its
+  //   simulated unmount re-runs JS effects without unmounting native views,
+  //   and removing the entry then would orphan the still-attached surface.
+  // - No native surface: the JS side is the last owner and removes the entry.
+  // The check-and-erase runs atomically under the registry lock
+  // (removeSurfaceInfoIfDetached), serialized against the UI thread's
+  // find-or-create + attach (SurfaceRegistry::attachSurface), so a concurrent
+  // attach can never be orphaned by this removal.
+  void destroyContext(int contextId) {
+    auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+    registry.removeSurfaceInfoIfDetached(contextId);
+  }
+
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
     installGetter(runtime, prototype, "fabric", &RNWebGPU::getFabric);
     installGetter(runtime, prototype, "gpu", &RNWebGPU::getGPU);
     installMethod(runtime, prototype, "getNativeSurface",
                   &RNWebGPU::getNativeSurface);
+    installMethod(runtime, prototype, "destroyContext",
+                  &RNWebGPU::destroyContext);
     installMethod(runtime, prototype, "MakeWebGPUCanvasContext",
                   &RNWebGPU::MakeWebGPUCanvasContext);
   }

package/cpp/rnwgpu/async/RuntimeContext.cpp

@@ -39,6 +39,11 @@ void RuntimeContext::registerMainRuntime(
   sMainInvoker = std::move(invoker);
 }
 
+std::shared_ptr<facebook::react::CallInvoker>
+RuntimeContext::mainCallInvoker() {
+  return sMainInvoker;
+}
+
 RuntimeContext::RuntimeContext(jsi::Runtime &runtime, wgpu::Instance instance)
     : _runtime(runtime), _instance(std::move(instance)) {}
 

package/cpp/rnwgpu/async/RuntimeContext.h

@@ -55,8 +55,15 @@ namespace rnwgpu::async {
  * ProcessEvents on one instance is not guaranteed reentrant.
  *
  * Threading contract: a RuntimeContext must only be pumped from the runtime it
- * was created for. Create and use a GPUDevice (and the buffers/queues derived
- * from it) on the same runtime that requested the adapter.
+ * was created for. Request/response async entry points (mapAsync,
+ * onSubmittedWorkDone, popErrorScope, createComputePipelineAsync,
+ * createRenderPipelineAsync, getCompilationInfo, requestAdapter,
+ * requestDevice) must NOT use a context captured when the object was created —
+ * the object may have been boxed across to another runtime. They resolve the
+ * CALLING runtime's context via getOrCreate(runtime, instance) so the promise
+ * is settled on the thread it was created on. Spontaneous events (device.lost,
+ * uncapturederror) remain bound to the device's own context (best-effort, main
+ * runtime only; see the class doc above).
  */
 class RuntimeContext : public std::enable_shared_from_this<RuntimeContext> {
 public:
@@ -84,6 +91,12 @@ public:
     return _callInvoker;
   }
 
+  // The main JS runtime's CallInvoker (registered on install), or null before
+  // install. Used by the platform views to apply latched surface attaches from
+  // the JS thread for contexts that are not actively rendering (see
+  // SurfaceInfo::applyPendingAttach).
+  static std::shared_ptr<facebook::react::CallInvoker> mainCallInvoker();
+
   // The wgpu::Instance bound to this runtime.
   wgpu::Instance instance() const { return _instance; }
 

package/lib/commonjs/views/WebGPUCanvas.d.ts

@@ -6,6 +6,7 @@ declare global {
         fabric: boolean;
         getNativeSurface: (contextId: number) => NativeCanvas;
         MakeWebGPUCanvasContext: (contextId: number, width: number, height: number) => RNCanvasContext;
+        destroyContext: (contextId: number) => void;
     };
 }
 type SurfacePointer = bigint;

package/lib/commonjs/views/WebGPUCanvas.js

@@ -21,6 +21,19 @@ const WebGPUCanvas = ({
 }) => {
   const viewRef = (0, _react.useRef)(null);
   const [contextId] = (0, _react.useState)(() => generateContextId());
+
+  // Retire the native registry entry for this contextId on unmount. When a
+  // native surface is still attached, this is a no-op and the native view's
+  // own teardown retires the entry instead — which keeps StrictMode's
+  // simulated unmount (which re-runs effects without unmounting native views)
+  // from orphaning a live surface.
+  (0, _react.useEffect)(() => {
+    return () => {
+      if (typeof RNWebGPU !== "undefined") {
+        RNWebGPU.destroyContext(contextId);
+      }
+    };
+  }, [contextId]);
   (0, _react.useImperativeHandle)(ref, () => ({
     getContextId: () => contextId,
     getNativeSurface: () => {

package/lib/commonjs/views/WebGPUCanvas.js.map

@@ -1 +1 @@
-{"version":3,"names":["_react","_interopRequireWildcard","require","_reactNative","_WebGPUViewNativeComponent","_interopRequireDefault","e","__esModule","default","t","WeakMap","r","n","o","i","f","__proto__","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","_extends","assign","bind","arguments","length","apply","CONTEXT_COUNTER","generateContextId","WebGPUCanvas","transparent","ref","props","viewRef","useRef","contextId","useState","useImperativeHandle","getContextId","getNativeSurface","RNWebGPU","Error","getContext","contextName","current","view","size","getBoundingClientRect","unstable_getBoundingClientRect","MakeWebGPUCanvasContext","width","height","Platform","OS","createElement","View","collapsable","style","flex","exports"],"sources":["WebGPUCanvas.tsx"],"sourcesContent":["import React, { useImperativeHandle, useRef, useState } from \"react\";\nimport type { ViewProps } from \"react-native\";\nimport { View, Platform } from \"react-native\";\n\nimport WebGPUNativeView from \"../specs/WebGPUViewNativeComponent\";\n\nlet CONTEXT_COUNTER = 1;\nfunction generateContextId() {\n  return CONTEXT_COUNTER++;\n}\n\ndeclare global {\n  var RNWebGPU: {\n    gpu: GPU;\n    fabric: boolean;\n    getNativeSurface: (contextId: number) => NativeCanvas;\n    MakeWebGPUCanvasContext: (\n      contextId: number,\n      width: number,\n      height: number\n    ) => RNCanvasContext;\n  };\n}\n\ntype SurfacePointer = bigint;\n\nexport interface NativeCanvas {\n  surface: SurfacePointer;\n  width: number;\n  height: number;\n  clientWidth: number;\n  clientHeight: number;\n}\n\nexport type RNCanvasContext = GPUCanvasContext & {\n  present: () => void;\n};\n\nexport interface WebGPUCanvasRef {\n  getContextId: () => number;\n  getContext(contextName: \"webgpu\"): RNCanvasContext | null;\n  getNativeSurface: () => NativeCanvas;\n}\n\ninterface WebGPUCanvasProps extends ViewProps {\n  transparent?: boolean;\n  ref?: React.Ref<WebGPUCanvasRef>;\n}\n\nexport const WebGPUCanvas = ({\n  transparent,\n  ref,\n  ...props\n}: WebGPUCanvasProps) => {\n  const viewRef = useRef(null);\n  const [contextId] = useState(() => generateContextId());\n\n  useImperativeHandle(ref, () => ({\n    getContextId: () => contextId,\n    getNativeSurface: () => {\n      if (typeof RNWebGPU === \"undefined\") {\n        throw new Error(\n          \"[WebGPU] RNWebGPU is not available. Make sure SK_GRAPHITE is enabled.\"\n        );\n      }\n      return RNWebGPU.getNativeSurface(contextId);\n    },\n    getContext(contextName: \"webgpu\"): RNCanvasContext | null {\n      if (contextName !== \"webgpu\") {\n        throw new Error(`[WebGPU] Unsupported context: ${contextName}`);\n      }\n      if (!viewRef.current) {\n        throw new Error(\"[WebGPU] Cannot get context before mount\");\n      }\n      if (typeof RNWebGPU === \"undefined\") {\n        throw new Error(\n          \"[WebGPU] RNWebGPU is not available. Make sure SK_GRAPHITE is enabled.\"\n        );\n      }\n      // getBoundingClientRect became stable in RN 0.83\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const view = viewRef.current as any;\n      const size =\n        \"getBoundingClientRect\" in view\n          ? view.getBoundingClientRect()\n          : view.unstable_getBoundingClientRect();\n      return RNWebGPU.MakeWebGPUCanvasContext(\n        contextId,\n        size.width,\n        size.height\n      );\n    },\n  }));\n\n  // WebGPU Canvas is not supported on web\n  if (Platform.OS === \"web\") {\n    return <View {...props} />;\n  }\n\n  return (\n    <View collapsable={false} ref={viewRef} {...props}>\n      <WebGPUNativeView\n        style={{ flex: 1 }}\n        contextId={contextId}\n        transparent={!!transparent}\n      />\n    </View>\n  );\n};\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_react","_interopRequireWildcard","require","_reactNative","_WebGPUViewNativeComponent","_interopRequireDefault","e","__esModule","default","t","WeakMap","r","n","o","i","f","__proto__","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","_extends","assign","bind","arguments","length","apply","CONTEXT_COUNTER","generateContextId","WebGPUCanvas","transparent","ref","props","viewRef","useRef","contextId","useState","useEffect","RNWebGPU","destroyContext","useImperativeHandle","getContextId","getNativeSurface","Error","getContext","contextName","current","view","size","getBoundingClientRect","unstable_getBoundingClientRect","MakeWebGPUCanvasContext","width","height","Platform","OS","createElement","View","collapsable","style","flex","exports"],"sources":["WebGPUCanvas.tsx"],"sourcesContent":["import React, { useEffect, useImperativeHandle, useRef, useState } from \"react\";\nimport type { ViewProps } from \"react-native\";\nimport { View, Platform } from \"react-native\";\n\nimport WebGPUNativeView from \"../specs/WebGPUViewNativeComponent\";\n\nlet CONTEXT_COUNTER = 1;\nfunction generateContextId() {\n  return CONTEXT_COUNTER++;\n}\n\ndeclare global {\n  var RNWebGPU: {\n    gpu: GPU;\n    fabric: boolean;\n    getNativeSurface: (contextId: number) => NativeCanvas;\n    MakeWebGPUCanvasContext: (\n      contextId: number,\n      width: number,\n      height: number\n    ) => RNCanvasContext;\n    // Retires a canvas context; called by the Canvas on unmount (the Canvas\n    // owns the native registry entry for its contextId).\n    destroyContext: (contextId: number) => void;\n  };\n}\n\ntype SurfacePointer = bigint;\n\nexport interface NativeCanvas {\n  surface: SurfacePointer;\n  width: number;\n  height: number;\n  clientWidth: number;\n  clientHeight: number;\n}\n\nexport type RNCanvasContext = GPUCanvasContext & {\n  present: () => void;\n};\n\nexport interface WebGPUCanvasRef {\n  getContextId: () => number;\n  getContext(contextName: \"webgpu\"): RNCanvasContext | null;\n  getNativeSurface: () => NativeCanvas;\n}\n\ninterface WebGPUCanvasProps extends ViewProps {\n  transparent?: boolean;\n  ref?: React.Ref<WebGPUCanvasRef>;\n}\n\nexport const WebGPUCanvas = ({\n  transparent,\n  ref,\n  ...props\n}: WebGPUCanvasProps) => {\n  const viewRef = useRef(null);\n  const [contextId] = useState(() => generateContextId());\n\n  // Retire the native registry entry for this contextId on unmount. When a\n  // native surface is still attached, this is a no-op and the native view's\n  // own teardown retires the entry instead — which keeps StrictMode's\n  // simulated unmount (which re-runs effects without unmounting native views)\n  // from orphaning a live surface.\n  useEffect(() => {\n    return () => {\n      if (typeof RNWebGPU !== \"undefined\") {\n        RNWebGPU.destroyContext(contextId);\n      }\n    };\n  }, [contextId]);\n\n  useImperativeHandle(ref, () => ({\n    getContextId: () => contextId,\n    getNativeSurface: () => {\n      if (typeof RNWebGPU === \"undefined\") {\n        throw new Error(\n          \"[WebGPU] RNWebGPU is not available. Make sure SK_GRAPHITE is enabled.\"\n        );\n      }\n      return RNWebGPU.getNativeSurface(contextId);\n    },\n    getContext(contextName: \"webgpu\"): RNCanvasContext | null {\n      if (contextName !== \"webgpu\") {\n        throw new Error(`[WebGPU] Unsupported context: ${contextName}`);\n      }\n      if (!viewRef.current) {\n        throw new Error(\"[WebGPU] Cannot get context before mount\");\n      }\n      if (typeof RNWebGPU === \"undefined\") {\n        throw new Error(\n          \"[WebGPU] RNWebGPU is not available. Make sure SK_GRAPHITE is enabled.\"\n        );\n      }\n      // getBoundingClientRect became stable in RN 0.83\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const view = viewRef.current as any;\n      const size =\n        \"getBoundingClientRect\" in view\n          ? view.getBoundingClientRect()\n          : view.unstable_getBoundingClientRect();\n      return RNWebGPU.MakeWebGPUCanvasContext(\n        contextId,\n        size.width,\n        size.height\n      );\n    },\n  }));\n\n  // WebGPU Canvas is not supported on web\n  if (Platform.OS === \"web\") {\n    return <View {...props} />;\n  }\n\n  return (\n    <View collapsable={false} ref={viewRef} {...props}>\n      <WebGPUNativeView\n        style={{ flex: 1 }}\n        contextId={contextId}\n        transparent={!!transparent}\n      />\n    </View>\n  );\n};\n"],"mappings":"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","ignoreList":[]}

package/lib/module/views/WebGPUCanvas.d.ts

@@ -6,6 +6,7 @@ declare global {
         fabric: boolean;
         getNativeSurface: (contextId: number) => NativeCanvas;
         MakeWebGPUCanvasContext: (contextId: number, width: number, height: number) => RNCanvasContext;
+        destroyContext: (contextId: number) => void;
     };
 }
 type SurfacePointer = bigint;

package/lib/module/views/WebGPUCanvas.js

@@ -1,5 +1,5 @@
 function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-import React, { useImperativeHandle, useRef, useState } from "react";
+import React, { useEffect, useImperativeHandle, useRef, useState } from "react";
 import { View, Platform } from "react-native";
 import WebGPUNativeView from "../specs/WebGPUViewNativeComponent";
 let CONTEXT_COUNTER = 1;
@@ -13,6 +13,19 @@ export const WebGPUCanvas = ({
 }) => {
   const viewRef = useRef(null);
   const [contextId] = useState(() => generateContextId());
+
+  // Retire the native registry entry for this contextId on unmount. When a
+  // native surface is still attached, this is a no-op and the native view's
+  // own teardown retires the entry instead — which keeps StrictMode's
+  // simulated unmount (which re-runs effects without unmounting native views)
+  // from orphaning a live surface.
+  useEffect(() => {
+    return () => {
+      if (typeof RNWebGPU !== "undefined") {
+        RNWebGPU.destroyContext(contextId);
+      }
+    };
+  }, [contextId]);
   useImperativeHandle(ref, () => ({
     getContextId: () => contextId,
     getNativeSurface: () => {