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

package/cpp/rnwgpu/api/GPU.cpp

@@ -8,7 +8,7 @@
 #include <vector>
 
 #include "Convertors.h"
-#include "jsi2/JSIConverter.h"
+#include "jsi/JSIConverter.h"
 #include "rnwgpu/async/RuntimeContext.h"
 
 namespace rnwgpu {
@@ -40,9 +40,9 @@ async::AsyncTaskHandle GPU::requestAdapter(
                 const async::AsyncTaskHandle::RejectFunction &reject) {
         _instance.RequestAdapter(
             &aOptions, wgpu::CallbackMode::AllowProcessEvents,
-            [context, resolve,
-             reject](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
-                     wgpu::StringView message) {
+            [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

@@ -7,7 +7,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "rnwgpu/async/AsyncTaskHandle.h"
 #include "rnwgpu/async/RuntimeContext.h"

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -13,11 +13,12 @@
 #include "GPUInternalError.h"
 #include "GPUOutOfMemoryError.h"
 #include "GPUValidationError.h"
-#include "jsi2/JSIConverter.h"
+#include "jsi/JSIConverter.h"
 
 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,10 +145,9 @@ 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) {
+                                wgpu::Device device, wgpu::StringView message) {
               if (message.length) {
                 fprintf(stderr, "%s", message.data);
               }

package/cpp/rnwgpu/api/GPUAdapter.h

@@ -6,7 +6,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "rnwgpu/async/AsyncTaskHandle.h"
 #include "rnwgpu/async/RuntimeContext.h"
@@ -34,7 +34,8 @@ public:
   std::string getBrand() { return CLASS_NAME; }
 
   async::AsyncTaskHandle
-  requestDevice(std::optional<std::shared_ptr<GPUDeviceDescriptor>> descriptor);
+  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/GPUAdapterInfo.h

@@ -5,7 +5,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "Convertors.h"
 

package/cpp/rnwgpu/api/GPUBindGroup.h

@@ -4,7 +4,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUBindGroupLayout.h

@@ -4,7 +4,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 

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

@@ -7,7 +7,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "rnwgpu/async/AsyncTaskHandle.h"
 #include "rnwgpu/async/RuntimeContext.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

@@ -8,7 +8,7 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "GPU.h"
 #include "GPUTexture.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/GPUCommandBuffer.h

@@ -4,7 +4,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUCommandEncoder.h

@@ -5,7 +5,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUCompilationInfo.h

@@ -5,7 +5,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUCompilationMessage.h

@@ -4,7 +4,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUComputePassEncoder.h

@@ -8,7 +8,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUComputePipeline.h

@@ -5,7 +5,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -10,7 +10,7 @@
 
 #include "Convertors.h"
 #include "NativeBufferUtils.h"
-#include "jsi2/JSIConverter.h"
+#include "jsi/JSIConverter.h"
 
 #include "GPUFeatures.h"
 #include "GPUInternalError.h"
@@ -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,
@@ -358,9 +363,9 @@ async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
                   runtime, pipelineHolder);
             });
           } else {
-            std::string error =
-                msg.length ? std::string(msg.data, msg.length)
-                           : "Failed to create compute pipeline";
+            std::string error = msg.length
+                                    ? std::string(msg.data, msg.length)
+                                    : "Failed to create compute pipeline";
             reject(std::move(error));
           }
         });
@@ -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,
@@ -400,9 +410,8 @@ async::AsyncTaskHandle GPUDevice::createRenderPipelineAsync(
                   runtime, pipelineHolder);
             });
           } else {
-            std::string error =
-                msg.length ? std::string(msg.data, msg.length)
-                           : "Failed to create render pipeline";
+            std::string error = msg.length ? std::string(msg.data, msg.length)
+                                           : "Failed to create render pipeline";
             reject(std::move(error));
           }
         });
@@ -413,13 +422,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

@@ -13,7 +13,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "rnwgpu/async/AsyncTaskHandle.h"
 #include "rnwgpu/async/RuntimeContext.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);
@@ -238,8 +240,8 @@ private:
   std::shared_ptr<async::RuntimeContext> _async;
   std::string _label;
   // Guards the device-lost state below. In the ProcessEvents model both
-  // notifyDeviceLost() (fired by Dawn during ProcessEvents) and getLost() run on
-  // the owning runtime's own thread, but device destruction can also trigger
+  // notifyDeviceLost() (fired by Dawn during ProcessEvents) and getLost() run
+  // on the owning runtime's own thread, but device destruction can also trigger
   // notifyDeviceLost() synchronously, so the mutex keeps these fields safe.
   std::mutex _lostMutex;
   std::optional<async::AsyncTaskHandle> _lostHandle;

package/cpp/rnwgpu/api/GPUDeviceLostInfo.h

@@ -4,7 +4,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUError.h

@@ -2,7 +2,7 @@
 
 #include <string>
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPUExtent3D.h

@@ -2,7 +2,7 @@
 
 #include <memory>
 
-#include "jsi2/JSIConverter.h"
+#include "jsi/JSIConverter.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUExternalTexture.h

@@ -6,7 +6,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUInternalError.h

@@ -2,7 +2,7 @@
 
 #include <string>
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPUOrigin2D.h

@@ -2,7 +2,7 @@
 
 #include <memory>
 
-#include "jsi2/JSIConverter.h"
+#include "jsi/JSIConverter.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUOrigin3D.h

@@ -2,7 +2,7 @@
 
 #include <memory>
 
-#include "jsi2/JSIConverter.h"
+#include "jsi/JSIConverter.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUOutOfMemoryError.h

@@ -2,7 +2,7 @@
 
 #include <string>
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPUPipelineLayout.h

@@ -4,7 +4,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPUQuerySet.h

@@ -4,7 +4,7 @@
 
 #include "descriptors/Unions.h"
 
-#include "jsi2/NativeObject.h"
+#include "jsi/NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"