react-native-webgpu 0.5.14 → 0.5.15

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -6,6 +6,8 @@
 #include <utility>
 #include <vector>
 
+#include <ReactCommon/CallInvoker.h>
+
 #include "Convertors.h"
 #include "JSIConverter.h"
 
@@ -19,23 +21,33 @@ namespace rnwgpu {
 
 void GPUDevice::notifyDeviceLost(wgpu::DeviceLostReason reason,
                                  std::string message) {
-  if (_lostSettled) {
-    return;
-  }
+  std::optional<async::AsyncTaskHandle::ResolveFunction> resolveToCall;
+  std::shared_ptr<GPUDeviceLostInfo> info;
+  {
+    std::lock_guard<std::mutex> lock(_lostMutex);
+    if (_lostSettled) {
+      return;
+    }
 
-  _lostSettled = true;
-  _lostInfo = std::make_shared<GPUDeviceLostInfo>(reason, std::move(message));
+    _lostSettled = true;
+    _lostInfo = std::make_shared<GPUDeviceLostInfo>(reason, std::move(message));
+    info = _lostInfo;
+
+    if (_lostResolve.has_value()) {
+      resolveToCall = std::move(*_lostResolve);
+      _lostResolve.reset();
+    }
+
+    _lostHandle.reset();
+  }
 
-  if (_lostResolve.has_value()) {
-    auto resolve = std::move(*_lostResolve);
-    _lostResolve.reset();
-    resolve([info = _lostInfo](jsi::Runtime &runtime) mutable {
+  // Settle outside the lock: resolve() only enqueues onto the JS thread.
+  if (resolveToCall.has_value()) {
+    (*resolveToCall)([info](jsi::Runtime &runtime) mutable {
       return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(runtime,
                                                                      info);
     });
   }
-
-  _lostHandle.reset();
 }
 
 void GPUDevice::forceLossForTesting() {
@@ -286,6 +298,55 @@ std::shared_ptr<GPUSharedTextureMemory> GPUDevice::importSharedTextureMemory(
                                                   std::move(label));
 }
 
+std::shared_ptr<GPUSharedFence> GPUDevice::importSharedFence(
+    std::shared_ptr<GPUSharedFenceDescriptor> descriptor) {
+  if (!descriptor || descriptor->handle == nullptr) {
+    throw std::runtime_error("GPUDevice::importSharedFence(): handle must be a "
+                             "non-null native handle");
+  }
+
+  wgpu::SharedFenceDescriptor desc{};
+  std::string label = descriptor->label.value_or("");
+  if (!label.empty()) {
+    desc.label = wgpu::StringView(label.c_str(), label.size());
+  }
+
+  // The chained platform descriptor must outlive the synchronous
+  // ImportSharedFence() below; declare them all and chain the matching one.
+  wgpu::SharedFenceMTLSharedEventDescriptor mtlDesc{};
+  wgpu::SharedFenceSyncFDDescriptor syncFdDesc{};
+  wgpu::SharedFenceVkSemaphoreOpaqueFDDescriptor vkFdDesc{};
+
+  const std::string &type = descriptor->type;
+  if (type == "mtl-shared-event") {
+    // handle is an id<MTLSharedEvent> pointer.
+    mtlDesc.sharedEvent = descriptor->handle;
+    desc.nextInChain = &mtlDesc;
+  } else if (type == "sync-fd") {
+    // handle is an OS file descriptor.
+    syncFdDesc.handle =
+        static_cast<int>(reinterpret_cast<uintptr_t>(descriptor->handle));
+    desc.nextInChain = &syncFdDesc;
+  } else if (type == "vk-semaphore-opaque-fd") {
+    vkFdDesc.handle =
+        static_cast<int>(reinterpret_cast<uintptr_t>(descriptor->handle));
+    desc.nextInChain = &vkFdDesc;
+  } else {
+    throw std::runtime_error(
+        "GPUDevice::importSharedFence(): unsupported fence type '" + type +
+        "' (expected 'mtl-shared-event', 'sync-fd' or "
+        "'vk-semaphore-opaque-fd')");
+  }
+
+  auto fence = _instance.ImportSharedFence(&desc);
+  if (fence == nullptr) {
+    throw std::runtime_error(
+        "GPUDevice::importSharedFence(): ImportSharedFence returned null - is "
+        "the matching 'shared-fence-*' feature enabled on the device?");
+  }
+  return std::make_shared<GPUSharedFence>(std::move(fence), std::move(label));
+}
+
 async::AsyncTaskHandle GPUDevice::createComputePipelineAsync(
     std::shared_ptr<GPUComputePipelineDescriptor> descriptor) {
   wgpu::ComputePipelineDescriptor desc{};
@@ -318,9 +379,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));
           }
         });
@@ -360,9 +421,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));
           }
         });
@@ -449,6 +509,11 @@ std::unordered_set<std::string> GPUDevice::getFeatures() {
 }
 
 async::AsyncTaskHandle GPUDevice::getLost() {
+  // Held across the whole body: the postTask callback below runs synchronously
+  // on this (JS) thread and touches the same _lost* fields, so it must not
+  // re-lock. notifyDeviceLost() takes the same lock from its (possibly worker)
+  // thread.
+  std::lock_guard<std::mutex> lock(_lostMutex);
   if (_lostHandle.has_value()) {
     return *_lostHandle;
   }
@@ -463,7 +528,7 @@ async::AsyncTaskHandle GPUDevice::getLost() {
                 runtime, info);
           });
         },
-        false);
+        /*keepPumping=*/false);
   }
 
   auto handle = _async->postTask(
@@ -477,9 +542,10 @@ async::AsyncTaskHandle GPUDevice::getLost() {
           return;
         }
 
+        // Resolved later from notifyDeviceLost().
         _lostResolve = resolve;
       },
-      false);
+      /*keepPumping=*/false);
 
   _lostHandle = handle;
   return handle;
@@ -499,6 +565,24 @@ 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) {
+    return;
+  }
+  auto self = shared_from_this();
+  invoker->invokeAsync([self, type, message = std::move(message)]() mutable {
+    self->deliverUncapturedError(type, std::move(message));
+  });
+}
+
+void GPUDevice::deliverUncapturedError(wgpu::ErrorType type,
+                                       std::string message) {
   auto it = _eventListeners.find("uncapturederror");
   if (it == _eventListeners.end() || it->second.empty()) {
     return;

package/cpp/rnwgpu/api/GPUDevice.h

@@ -15,8 +15,8 @@
 
 #include "NativeObject.h"
 
-#include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
+#include "rnwgpu/async/RuntimeContext.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -45,6 +45,7 @@
 #include "GPURenderPipelineDescriptor.h"
 #include "GPUSampler.h"
 #include "GPUSamplerDescriptor.h"
+#include "GPUSharedFenceDescriptor.h"
 #include "GPUSharedTextureMemory.h"
 #include "GPUSharedTextureMemoryDescriptor.h"
 #include "GPUShaderModule.h"
@@ -63,7 +64,7 @@ public:
   static constexpr const char *CLASS_NAME = "GPUDevice";
 
   explicit GPUDevice(wgpu::Device instance,
-                     std::shared_ptr<async::AsyncRunner> async,
+                     std::shared_ptr<async::RuntimeContext> async,
                      std::string label)
       : NativeObject(CLASS_NAME), _instance(instance), _async(async),
         _label(label) {}
@@ -120,6 +121,8 @@ public:
       std::shared_ptr<GPUExternalTextureDescriptor> descriptor);
   std::shared_ptr<GPUSharedTextureMemory> importSharedTextureMemory(
       std::shared_ptr<GPUSharedTextureMemoryDescriptor> descriptor);
+  std::shared_ptr<GPUSharedFence> importSharedFence(
+      std::shared_ptr<GPUSharedFenceDescriptor> descriptor);
   std::shared_ptr<GPUBindGroupLayout> createBindGroupLayout(
       std::shared_ptr<GPUBindGroupLayoutDescriptor> descriptor);
   std::shared_ptr<GPUPipelineLayout>
@@ -175,6 +178,8 @@ public:
                   &GPUDevice::importExternalTexture);
     installMethod(runtime, prototype, "importSharedTextureMemory",
                   &GPUDevice::importSharedTextureMemory);
+    installMethod(runtime, prototype, "importSharedFence",
+                  &GPUDevice::importSharedFence);
     installMethod(runtime, prototype, "createBindGroupLayout",
                   &GPUDevice::createBindGroupLayout);
     installMethod(runtime, prototype, "createPipelineLayout",
@@ -248,9 +253,18 @@ public:
 private:
   friend class GPUAdapter;
 
+  // Runs the uncapturederror listeners on the creation runtime's JS thread.
+  // Invoked from notifyUncapturedError via the main CallInvoker.
+  void deliverUncapturedError(wgpu::ErrorType type, std::string message);
+
   wgpu::Device _instance;
-  std::shared_ptr<async::AsyncRunner> _async;
+  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() synchronously, so the mutex keeps these fields safe.
+  std::mutex _lostMutex;
   std::optional<async::AsyncTaskHandle> _lostHandle;
   std::shared_ptr<GPUDeviceLostInfo> _lostInfo;
   bool _lostSettled = false;

package/cpp/rnwgpu/api/GPUQueue.h

@@ -8,8 +8,8 @@
 
 #include "NativeObject.h"
 
-#include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
+#include "rnwgpu/async/RuntimeContext.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -28,7 +28,7 @@ public:
   static constexpr const char *CLASS_NAME = "GPUQueue";
 
   explicit GPUQueue(wgpu::Queue instance,
-                    std::shared_ptr<async::AsyncRunner> async,
+                    std::shared_ptr<async::RuntimeContext> async,
                     std::string label)
       : NativeObject(CLASS_NAME), _instance(instance), _async(async),
         _label(label) {}
@@ -74,7 +74,7 @@ public:
 
 private:
   wgpu::Queue _instance;
-  std::shared_ptr<async::AsyncRunner> _async;
+  std::shared_ptr<async::RuntimeContext> _async;
   std::string _label;
 };
 

package/cpp/rnwgpu/api/GPUShaderModule.h

@@ -7,8 +7,8 @@
 
 #include "NativeObject.h"
 
-#include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
+#include "rnwgpu/async/RuntimeContext.h"
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -23,7 +23,7 @@ public:
   static constexpr const char *CLASS_NAME = "GPUShaderModule";
 
   explicit GPUShaderModule(wgpu::ShaderModule instance,
-                           std::shared_ptr<async::AsyncRunner> async,
+                           std::shared_ptr<async::RuntimeContext> async,
                            std::string label)
       : NativeObject(CLASS_NAME), _instance(instance), _async(async),
         _label(label) {}
@@ -59,7 +59,7 @@ public:
 
 private:
   wgpu::ShaderModule _instance;
-  std::shared_ptr<async::AsyncRunner> _async;
+  std::shared_ptr<async::RuntimeContext> _async;
   std::string _label;
 };
 

package/cpp/rnwgpu/api/GPUSharedFence.cpp

@@ -0,0 +1,77 @@
+#include "GPUSharedFence.h"
+
+#include <cstdint>
+#include <string>
+
+#if defined(__ANDROID__)
+#include <fcntl.h>
+#endif
+
+namespace rnwgpu {
+
+namespace {
+
+// Kebab-case names matching the shared-fence-* feature strings (see Unions.h /
+// GPUFeatures.h).
+std::string sharedFenceTypeToString(wgpu::SharedFenceType type) {
+  switch (type) {
+  case wgpu::SharedFenceType::MTLSharedEvent:
+    return "mtl-shared-event";
+  case wgpu::SharedFenceType::SyncFD:
+    return "sync-fd";
+  case wgpu::SharedFenceType::VkSemaphoreOpaqueFD:
+    return "vk-semaphore-opaque-fd";
+  case wgpu::SharedFenceType::VkSemaphoreZirconHandle:
+    return "vk-semaphore-zircon-handle";
+  case wgpu::SharedFenceType::DXGISharedHandle:
+    return "dxgi-shared-handle";
+  case wgpu::SharedFenceType::EGLSync:
+    return "egl-sync";
+  default:
+    return "";
+  }
+}
+
+} // namespace
+
+jsi::Value GPUSharedFence::exportInfo(jsi::Runtime &runtime, const jsi::Value &,
+                                      const jsi::Value *, size_t) {
+  wgpu::SharedFenceExportInfo info{};
+  uint64_t handle = 0;
+
+#if defined(__APPLE__)
+  // Apple: the handle is an id<MTLSharedEvent> pointer.
+  wgpu::SharedFenceMTLSharedEventExportInfo mtlInfo{};
+  info.nextInChain = &mtlInfo;
+  _instance.ExportInfo(&info);
+  handle = reinterpret_cast<uint64_t>(mtlInfo.sharedEvent);
+#elif defined(__ANDROID__)
+  // Android: the handle is an OS file descriptor (sync_fd). Dawn's ExportInfo returns a BORROWED fd — it is
+  // owned by the SharedFence and closed when the fence is destroyed. This exported handle is documented as
+  // caller-owned (the caller must close() it), so dup() it. Without the dup the same fd is closed twice —
+  // once by the caller and once by Dawn on fence destruction — tripping Android's fdsan (double-close abort).
+  wgpu::SharedFenceSyncFDExportInfo fdInfo{};
+  info.nextInChain = &fdInfo;
+  _instance.ExportInfo(&info);
+  int exportedFd =
+      fdInfo.handle >= 0 ? ::fcntl(fdInfo.handle, F_DUPFD_CLOEXEC, 0) : fdInfo.handle;
+  handle = static_cast<uint64_t>(static_cast<uint32_t>(exportedFd));
+#else
+// react-native-webgpu only targets Apple (Metal) and Android (Vulkan). On any
+// other platform there is no native handle convention to expose, so fail loudly
+// rather than handing back a meaningless handle of 0.
+throw jsi::JSError(runtime,
+                    "GPUSharedFence::export(): unsupported platform (only "
+                    "Apple/Metal and Android/Vulkan are supported)");
+#endif
+
+  jsi::Object result(runtime);
+  result.setProperty(
+      runtime, "type",
+      jsi::String::createFromUtf8(runtime, sharedFenceTypeToString(info.type)));
+  result.setProperty(runtime, "handle",
+                     jsi::BigInt::fromUint64(runtime, handle));
+  return result;
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedFence.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "NativeObject.h"
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+// Wraps a wgpu::SharedFence: a native GPU sync primitive (id<MTLSharedEvent> on
+// Apple, sync-fd / VkSemaphore on Android).
+class GPUSharedFence : public NativeObject<GPUSharedFence> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUSharedFence";
+
+  explicit GPUSharedFence(wgpu::SharedFence instance, std::string label)
+      : NativeObject(CLASS_NAME), _instance(std::move(instance)),
+        _label(std::move(label)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+
+  // export() -> { type, handle }: exposes the native handle (as a BigInt) so
+  // app code can wait on or signal the fence. The caller owns the returned
+  // handle (e.g. an exported sync-fd must be close()d).
+  jsi::Value exportInfo(jsi::Runtime &runtime, const jsi::Value &thisVal,
+                        const jsi::Value *args, size_t count);
+
+  std::string getLabel() { return _label; }
+  void setLabel(const std::string &label) {
+    _label = label;
+    _instance.SetLabel(_label.c_str());
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUSharedFence::getBrand);
+    installMethod(runtime, prototype, "export", &GPUSharedFence::exportInfo);
+    installGetterSetter(runtime, prototype, "label", &GPUSharedFence::getLabel,
+                        &GPUSharedFence::setLabel);
+  }
+
+  inline wgpu::SharedFence get() { return _instance; }
+
+private:
+  wgpu::SharedFence _instance;
+  std::string _label;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedTextureMemory.cpp

@@ -27,8 +27,9 @@ std::shared_ptr<GPUTexture> GPUSharedTextureMemory::createTexture(
                                       descriptor.value()->label.value_or(""));
 }
 
-bool GPUSharedTextureMemory::beginAccess(std::shared_ptr<GPUTexture> texture,
-                                         bool initialized) {
+void GPUSharedTextureMemory::beginAccess(
+    std::shared_ptr<GPUTexture> texture, bool initialized,
+    std::optional<std::vector<std::shared_ptr<GPUSharedFenceState>>> fences) {
   if (!texture) {
     throw std::runtime_error(
         "GPUSharedTextureMemory::beginAccess(): texture is null");
@@ -36,9 +37,28 @@ bool GPUSharedTextureMemory::beginAccess(std::shared_ptr<GPUTexture> texture,
   wgpu::SharedTextureMemoryBeginAccessDescriptor desc{};
   desc.initialized = initialized;
   desc.concurrentRead = false;
-  desc.fenceCount = 0;
-  desc.fences = nullptr;
-  desc.signaledValues = nullptr;
+
+  // Built in lockstep so fenceCount covers both arrays, and kept in locals so
+  // the raw pointers outlive the synchronous BeginAccess() below.
+  std::vector<wgpu::SharedFence> rawFences;
+  std::vector<uint64_t> values;
+  if (fences.has_value()) {
+    for (const auto &state : *fences) {
+      if (state && state->fence) {
+        rawFences.push_back(state->fence->get());
+        values.push_back(state->signaledValue);
+      }
+    }
+  }
+  if (!rawFences.empty()) {
+    desc.fenceCount = rawFences.size();
+    desc.fences = rawFences.data();
+    desc.signaledValues = values.data();
+  } else {
+    desc.fenceCount = 0;
+    desc.fences = nullptr;
+    desc.signaledValues = nullptr;
+  }
 
 #if defined(__ANDROID__)
   // Dawn's Vulkan backend (AHardwareBuffer) validates that the begin-access
@@ -55,14 +75,21 @@ bool GPUSharedTextureMemory::beginAccess(std::shared_ptr<GPUTexture> texture,
 #endif
 
   auto status = _instance.BeginAccess(texture->get(), &desc);
-  return static_cast<bool>(status);
+  if (!status) {
+    throw std::runtime_error("GPUSharedTextureMemory::beginAccess() failed");
+  }
 }
 
-bool GPUSharedTextureMemory::endAccess(std::shared_ptr<GPUTexture> texture) {
-  if (!texture) {
-    throw std::runtime_error(
-        "GPUSharedTextureMemory::endAccess(): texture is null");
+jsi::Value GPUSharedTextureMemory::endAccess(jsi::Runtime &runtime,
+                                             const jsi::Value &,
+                                             const jsi::Value *args,
+                                             size_t count) {
+  if (count < 1 || !args[0].isObject()) {
+    throw jsi::JSError(
+        runtime, "GPUSharedTextureMemory::endAccess(): expected (texture)");
   }
+  auto texture = GPUTexture::fromValue(runtime, args[0]);
+
   wgpu::SharedTextureMemoryEndAccessState state{};
 
 #if defined(__ANDROID__)
@@ -74,7 +101,29 @@ bool GPUSharedTextureMemory::endAccess(std::shared_ptr<GPUTexture> texture) {
 #endif
 
   auto status = _instance.EndAccess(texture->get(), &state);
-  return static_cast<bool>(status);
+  if (!status) {
+    throw jsi::JSError(runtime, "GPUSharedTextureMemory::endAccess() failed");
+  }
+
+  // Copy each wgpu::SharedFence (ref-counted) into its own GPUSharedFence
+  // wrapper before `state` is destroyed.
+  jsi::Array fences(runtime, state.fenceCount);
+  for (size_t i = 0; i < state.fenceCount; i++) {
+    wgpu::SharedFence fence = state.fences[i];
+    auto wrapper = std::make_shared<GPUSharedFence>(std::move(fence), "");
+    jsi::Object entry(runtime);
+    entry.setProperty(runtime, "fence",
+                      GPUSharedFence::create(runtime, std::move(wrapper)));
+    entry.setProperty(runtime, "signaledValue",
+                      jsi::BigInt::fromUint64(runtime, state.signaledValues[i]));
+    fences.setValueAtIndex(runtime, i, std::move(entry));
+  }
+
+  jsi::Object result(runtime);
+  result.setProperty(runtime, "initialized",
+                     jsi::Value(static_cast<bool>(state.initialized)));
+  result.setProperty(runtime, "fences", std::move(fences));
+  return result;
 }
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUSharedTextureMemory.h

@@ -1,13 +1,17 @@
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <optional>
 #include <string>
+#include <vector>
 
 #include "NativeObject.h"
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "GPUSharedFence.h"
+#include "GPUSharedFenceState.h"
 #include "GPUTexture.h"
 #include "GPUTextureDescriptor.h"
 
@@ -30,16 +34,16 @@ public:
   std::shared_ptr<GPUTexture>
   createTexture(std::optional<std::shared_ptr<GPUTextureDescriptor>> descriptor);
 
-  // Returns true on success. Marks the shared memory as initialized so the
-  // texture's content is preserved (or not). Callers that want fence-based
-  // synchronization should pass fences via beginAccess descriptor (not yet
-  // exposed - we currently take the implicit/no-fence path that matches the
-  // most common RN use cases: still images, single-producer video frames).
-  bool beginAccess(std::shared_ptr<GPUTexture> texture, bool initialized);
+  // Optional `fences` are wait fences: Dawn waits for each to reach its
+  // signaledValue before writing the surface. Throws on failure.
+  void beginAccess(
+      std::shared_ptr<GPUTexture> texture, bool initialized,
+      std::optional<std::vector<std::shared_ptr<GPUSharedFenceState>>> fences);
 
-  // Returns true on success. Drops any fences produced by end-access (we do
-  // not yet surface them to JS).
-  bool endAccess(std::shared_ptr<GPUTexture> texture);
+  // endAccess(texture) -> { initialized, fences: { fence, signaledValue }[] }
+  // Surfaces the fences Dawn produced for the access. Throws on failure.
+  jsi::Value endAccess(jsi::Runtime &runtime, const jsi::Value &thisVal,
+                       const jsi::Value *args, size_t count);
 
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {

package/cpp/rnwgpu/api/descriptors/GPUSharedFenceDescriptor.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// Descriptor for GPUDevice.importSharedFence. `handle` is the native handle
+// (an id<MTLSharedEvent> pointer on Apple, an OS file descriptor on Android),
+// passed from JS as a BigInt.
+struct GPUSharedFenceDescriptor {
+  std::string type;
+  void *handle = nullptr;
+  std::optional<std::string> label;
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUSharedFenceDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUSharedFenceDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUSharedFenceDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "type")) {
+        result->type =
+            value.getProperty(runtime, "type").asString(runtime).utf8(runtime);
+      }
+      if (value.hasProperty(runtime, "handle")) {
+        auto prop = value.getProperty(runtime, "handle");
+        result->handle = JSIConverter<void *>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime & /*runtime*/,
+        std::shared_ptr<rnwgpu::GPUSharedFenceDescriptor> /*arg*/) {
+    throw std::runtime_error("Invalid GPUSharedFenceDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu