react-native-webgpu 0.8.2 → 0.8.4

package/apple/WebGPUView.mm

@@ -10,12 +10,29 @@
 
 using namespace facebook::react;
 
+static const std::shared_ptr<const WebGPUViewProps> &defaultWebGPUViewProps() {
+  static const auto props = std::make_shared<const WebGPUViewProps>();
+  return props;
+}
+
 @implementation WebGPUView
 
 + (ComponentDescriptorProvider)componentDescriptorProvider {
   return concreteComponentDescriptorProvider<WebGPUViewComponentDescriptor>();
 }
 
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    /*
+      The base class initializes _props with a plain ViewProps instance;
+      updateProps: casts _props to WebGPUViewProps, so it must hold our
+      concrete props type from the start (RN 0.87+ asserts on this).
+    */
+    _props = defaultWebGPUViewProps();
+  }
+  return self;
+}
+
 - (void)prepareForRecycle {
   [super prepareForRecycle];
   /*
@@ -24,6 +41,11 @@ using namespace facebook::react;
     the last usage in the new context.
   */
   self.contentView = nil;
+  /*
+    Reset to the default props (contextId == 0) so the next mount always
+    detects a contextId change and configures a fresh Metal layer.
+  */
+  _props = defaultWebGPUViewProps();
 }
 
 - (MetalView *)getContentView {

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -19,9 +19,35 @@
 
 namespace rnwgpu {
 
+namespace {
+
+// Hidden own properties used by device.lost. The promise cache lives on the
+// device wrapper (the spec requires `lost` to return a stable promise) and
+// the resolve function lives on the promise object itself, so both are traced
+// by the GC as part of the device's JS object graph instead of being rooted
+// from C++ (issue #445).
+constexpr const char *kLostPromiseProp = "__rnwgpuLostPromise";
+constexpr const char *kLostResolveProp = "__rnwgpuLostResolve";
+
+void defineHiddenProperty(jsi::Runtime &runtime, const jsi::Object &target,
+                          const char *name, const jsi::Value &value) {
+  auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
+  auto defineProperty =
+      objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+  jsi::Object descriptor(runtime);
+  descriptor.setProperty(runtime, "value", value);
+  descriptor.setProperty(runtime, "enumerable", false);
+  descriptor.setProperty(runtime, "writable", false);
+  descriptor.setProperty(runtime, "configurable", false);
+  defineProperty.call(runtime, target,
+                      jsi::String::createFromUtf8(runtime, name), descriptor);
+}
+
+} // namespace
+
 void GPUDevice::notifyDeviceLost(wgpu::DeviceLostReason reason,
                                  std::string message) {
-  std::optional<async::AsyncTaskHandle::ResolveFunction> resolveToCall;
+  std::vector<PendingLostPromise> toResolve;
   std::shared_ptr<GPUDeviceLostInfo> info;
   {
     std::lock_guard<std::mutex> lock(_lostMutex);
@@ -32,22 +58,49 @@ void GPUDevice::notifyDeviceLost(wgpu::DeviceLostReason reason,
     _lostSettled = true;
     _lostInfo = std::make_shared<GPUDeviceLostInfo>(reason, std::move(message));
     info = _lostInfo;
+    toResolve = std::move(_lostPromises);
+    _lostPromises.clear();
+  }
 
-    if (_lostResolve.has_value()) {
-      resolveToCall = std::move(*_lostResolve);
-      _lostResolve.reset();
-    }
-
-    _lostHandle.reset();
+  if (toResolve.empty()) {
+    return;
   }
 
-  // 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);
-    });
+  // getLost() only registers promises when the device's context has a
+  // CallInvoker (main JS runtime), so a non-empty list implies an invoker.
+  auto invoker = _async ? _async->callInvoker() : nullptr;
+  if (!invoker) {
+    return;
   }
+
+  // Settle on the owning runtime's JS thread. The promises are held weakly:
+  // if the device graph was collected in the meantime there is nothing to do,
+  // since nobody could observe the resolution anyway. The shared_ptr is only
+  // there because jsi::WeakObject is move-only and std::function requires a
+  // copyable closure; it also ensures the WeakObjects are destroyed on the JS
+  // thread.
+  auto pending =
+      std::make_shared<std::vector<PendingLostPromise>>(std::move(toResolve));
+  invoker->invokeAsync([pending, info]() {
+    for (auto &entry : *pending) {
+      auto &runtime = *entry.runtime;
+      auto locked = entry.promise.lock(runtime);
+      if (!locked.isObject()) {
+        continue;
+      }
+      auto promiseObj = locked.getObject(runtime);
+      auto resolveProp = promiseObj.getProperty(runtime, kLostResolveProp);
+      if (!resolveProp.isObject() ||
+          !resolveProp.getObject(runtime).isFunction(runtime)) {
+        continue;
+      }
+      auto resolveFn = resolveProp.getObject(runtime).getFunction(runtime);
+      resolveFn.call(runtime,
+                     JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
+                         runtime, info));
+    }
+    pending->clear();
+  });
 }
 
 void GPUDevice::forceLossForTesting() {
@@ -523,47 +576,84 @@ std::unordered_set<std::string> GPUDevice::getFeatures() {
   return result;
 }
 
-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;
-  }
-
-  if (_lostSettled && _lostInfo) {
-    return _async->postTask(
-        [info = _lostInfo](
-            const async::AsyncTaskHandle::ResolveFunction &resolve,
-            const async::AsyncTaskHandle::RejectFunction & /*reject*/) {
-          resolve([info](jsi::Runtime &runtime) mutable {
-            return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
-                runtime, info);
-          });
-        },
-        /*keepPumping=*/false);
-  }
-
-  auto handle = _async->postTask(
-      [this](const async::AsyncTaskHandle::ResolveFunction &resolve,
-             const async::AsyncTaskHandle::RejectFunction & /*reject*/) {
-        if (_lostSettled && _lostInfo) {
-          resolve([info = _lostInfo](jsi::Runtime &runtime) mutable {
-            return JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
-                runtime, info);
-          });
-          return;
-        }
-
-        // Resolved later from notifyDeviceLost().
-        _lostResolve = resolve;
-      },
-      /*keepPumping=*/false);
-
-  _lostHandle = handle;
-  return handle;
+jsi::Value GPUDevice::getLost(jsi::Runtime &runtime,
+                              const jsi::Object &wrapper) {
+  // The promise is cached on the wrapper, not natively: a strong native
+  // reference would be a GC root, keeping the promise's .then reactions (and
+  // anything they capture, e.g. a whole three.js renderer) alive forever
+  // (issue #445).
+  auto cached = wrapper.getProperty(runtime, kLostPromiseProp);
+  if (cached.isObject()) {
+    return cached;
+  }
+
+  auto promiseCtor = runtime.global().getPropertyAsObject(runtime, "Promise");
+
+  std::shared_ptr<GPUDeviceLostInfo> settledInfo;
+  {
+    std::lock_guard<std::mutex> lock(_lostMutex);
+    if (_lostSettled) {
+      settledInfo = _lostInfo;
+    }
+  }
+
+  jsi::Value promiseValue;
+  if (settledInfo) {
+    auto info = JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
+        runtime, settledInfo);
+    promiseValue = promiseCtor.getPropertyAsFunction(runtime, "resolve")
+                       .callWithThis(runtime, promiseCtor, info);
+  } else {
+    // new Promise(executor): the executor runs synchronously inside the
+    // constructor call, capturing the resolve function.
+    auto capturedResolve = std::make_shared<jsi::Value>();
+    auto executor = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "lostExecutor"), 2,
+        [capturedResolve](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
+                          const jsi::Value *args, size_t count) -> jsi::Value {
+          if (count > 0) {
+            *capturedResolve = jsi::Value(rt, args[0]);
+          }
+          return jsi::Value::undefined();
+        });
+    auto promiseObj = promiseCtor.asFunction(runtime)
+                          .callAsConstructor(runtime, executor)
+                          .getObject(runtime);
+
+    // Stash the resolve function on the promise itself so the GC traces it as
+    // part of the promise graph.
+    defineHiddenProperty(runtime, promiseObj, kLostResolveProp,
+                         *capturedResolve);
+
+    // Register a WEAK reference so notifyDeviceLost() can settle the promise
+    // if it is still alive. Only wired for the device's own runtime when a
+    // CallInvoker exists (main JS runtime): spontaneous events are delivered
+    // through that invoker. A promise created on another runtime stays
+    // pending, matching the previous best-effort behavior.
+    bool settledMeanwhile = false;
+    if (_async && _async->callInvoker() && &runtime == &_async->runtime()) {
+      std::lock_guard<std::mutex> lock(_lostMutex);
+      if (_lostSettled) {
+        // The device was lost between the check above and now.
+        settledMeanwhile = true;
+        settledInfo = _lostInfo;
+      } else {
+        _lostPromises.push_back(
+            PendingLostPromise{&runtime, jsi::WeakObject(runtime, promiseObj)});
+      }
+    }
+    if (settledMeanwhile) {
+      auto resolveFn =
+          promiseObj.getPropertyAsFunction(runtime, kLostResolveProp);
+      resolveFn.call(runtime,
+                     JSIConverter<std::shared_ptr<GPUDeviceLostInfo>>::toJSI(
+                         runtime, settledInfo));
+    }
+    promiseValue = jsi::Value(runtime, promiseObj);
+  }
+
+  defineHiddenProperty(runtime, wrapper, kLostPromiseProp, promiseValue);
+  return promiseValue;
 }
 void GPUDevice::addEventListener(std::string type, jsi::Function callback) {
   auto funcPtr = std::make_shared<jsi::Function>(std::move(callback));

package/cpp/rnwgpu/api/GPUDevice.h

@@ -45,11 +45,11 @@
 #include "GPURenderPipelineDescriptor.h"
 #include "GPUSampler.h"
 #include "GPUSamplerDescriptor.h"
+#include "GPUShaderModule.h"
+#include "GPUShaderModuleDescriptor.h"
 #include "GPUSharedFenceDescriptor.h"
 #include "GPUSharedTextureMemory.h"
 #include "GPUSharedTextureMemoryDescriptor.h"
-#include "GPUShaderModule.h"
-#include "GPUShaderModuleDescriptor.h"
 #include "GPUSupportedLimits.h"
 #include "GPUTexture.h"
 #include "GPUTextureDescriptor.h"
@@ -121,8 +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<GPUSharedFence>
+  importSharedFence(std::shared_ptr<GPUSharedFenceDescriptor> descriptor);
   std::shared_ptr<GPUBindGroupLayout> createBindGroupLayout(
       std::shared_ptr<GPUBindGroupLayoutDescriptor> descriptor);
   std::shared_ptr<GPUPipelineLayout>
@@ -153,7 +153,7 @@ public:
   std::unordered_set<std::string> getFeatures();
   std::shared_ptr<GPUSupportedLimits> getLimits();
   std::shared_ptr<GPUQueue> getQueue();
-  async::AsyncTaskHandle getLost();
+  jsi::Value getLost(jsi::Runtime &runtime, const jsi::Object &wrapper);
   void notifyDeviceLost(wgpu::DeviceLostReason reason, std::string message);
   void notifyUncapturedError(wgpu::ErrorType type, std::string message);
   void forceLossForTesting();
@@ -211,7 +211,30 @@ public:
     installGetter(runtime, prototype, "features", &GPUDevice::getFeatures);
     installGetter(runtime, prototype, "limits", &GPUDevice::getLimits);
     installGetter(runtime, prototype, "queue", &GPUDevice::getQueue);
-    installGetter(runtime, prototype, "lost", &GPUDevice::getLost);
+    // `lost` is installed manually: the getter needs the wrapper object
+    // itself, because the promise (and its resolve function) are cached as
+    // hidden properties on the JS side so the GC traces them as part of the
+    // device graph. Holding them strongly from C++ would root the promise's
+    // .then reactions forever (issue #445).
+    {
+      auto lostGetter = jsi::Function::createFromHostFunction(
+          runtime, jsi::PropNameID::forUtf8(runtime, "get_lost"), 0,
+          [](jsi::Runtime &rt, const jsi::Value &thisVal,
+             const jsi::Value * /*args*/, size_t /*count*/) -> jsi::Value {
+            auto native = GPUDevice::fromValue(rt, thisVal);
+            return native->getLost(rt, thisVal.getObject(rt));
+          });
+      auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
+      auto defineProperty =
+          objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+      jsi::Object descriptor(runtime);
+      descriptor.setProperty(runtime, "get", lostGetter);
+      descriptor.setProperty(runtime, "enumerable", true);
+      descriptor.setProperty(runtime, "configurable", true);
+      defineProperty.call(runtime, prototype,
+                          jsi::String::createFromUtf8(runtime, "lost"),
+                          descriptor);
+    }
     installGetterSetter(runtime, prototype, "label", &GPUDevice::getLabel,
                         &GPUDevice::setLabel);
     installMethod(runtime, prototype, "forceLossForTesting",
@@ -262,15 +285,28 @@ private:
   wgpu::Device _instance;
   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.
+  // Guards the device-lost state below. getLost() runs on a JS thread, but
+  // Dawn's AllowSpontaneous device-lost callback (and device destruction) can
+  // fire notifyDeviceLost() from other threads, so the mutex keeps these
+  // fields safe.
   std::mutex _lostMutex;
-  std::optional<async::AsyncTaskHandle> _lostHandle;
   std::shared_ptr<GPUDeviceLostInfo> _lostInfo;
   bool _lostSettled = false;
-  std::optional<async::AsyncTaskHandle::ResolveFunction> _lostResolve;
+  // Pending `lost` promises, held WEAKLY. A strong native reference would be
+  // a GC root: the promise's .then reactions (three.js captures its whole
+  // renderer there) could never be collected, pinning every GPU wrapper of
+  // the scene and its reported external memory forever (issue #445). The
+  // resolve function lives as a hidden property on the promise object itself,
+  // so if the promise is still alive when the device is lost we can settle
+  // it; if it was collected, nobody could have observed the resolution.
+  // Entries are only added for the device's own runtime when a CallInvoker is
+  // available (main JS runtime), matching the best-effort contract for
+  // spontaneous events.
+  struct PendingLostPromise {
+    jsi::Runtime *runtime;
+    jsi::WeakObject promise;
+  };
+  std::vector<PendingLostPromise> _lostPromises;
 
   // Event listeners storage - keyed by event type
   // Each entry contains a vector of shared_ptr to functions

package/cpp/rnwgpu/async/RuntimeContext.h

@@ -36,14 +36,18 @@ namespace rnwgpu::async {
  * The pump only runs while at least one "pumping" task is outstanding, so it
  * costs nothing when idle and stops cleanly.
  *
- * Spontaneous events (keepPumping = false): events that may fire at any time,
- * independent of any request/response op (today only GPUDevice::getLost, whose
- * Dawn callback is registered AllowSpontaneous). These are NOT driven by the
- * pump. Instead their settle is marshalled onto the owning runtime's JS thread
- * via that runtime's CallInvoker, which is wired only for the MAIN JS runtime
- * (callInvoker()). A device created on a worklet runtime has no invoker, so its
- * device.lost is best-effort and may never fire. See the README "Threading
- * model" section.
+ * Spontaneous events: events that may fire at any time, independent of any
+ * request/response op (today only device.lost, whose Dawn callback is
+ * registered AllowSpontaneous). These are NOT driven by the pump and do NOT go
+ * through postTask: a task that may never settle must not hold the JS promise
+ * strongly from C++, or the promise (and everything reachable from its .then
+ * reactions) becomes a permanent GC root (issue #445). Instead GPUDevice keeps
+ * a jsi::WeakObject to the promise and settles it on the owning runtime's JS
+ * thread via that runtime's CallInvoker, which is wired only for the MAIN JS
+ * runtime (callInvoker()). A device created on a worklet runtime has no
+ * invoker, so its device.lost is best-effort and may never fire. See the
+ * README "Threading model" section. The keepPumping=false path in postTask is
+ * currently unused; it remains for tasks that settle without Dawn's pump.
  *
  * Shared-instance safety (mailbox): multiple runtimes may share one
  * wgpu::Instance. ProcessEvents() drains the whole instance queue and fires
@@ -78,9 +82,10 @@ public:
   static std::shared_ptr<RuntimeContext> getOrCreate(jsi::Runtime &runtime,
                                                      wgpu::Instance instance);
 
-  // Register the main JS runtime and its CallInvoker. The RuntimeContext created
-  // for this runtime gets the invoker (callInvoker() returns it); every other
-  // runtime's context returns null. Called once from RNWebGPUManager on install.
+  // Register the main JS runtime and its CallInvoker. The RuntimeContext
+  // created for this runtime gets the invoker (callInvoker() returns it); every
+  // other runtime's context returns null. Called once from RNWebGPUManager on
+  // install.
   static void
   registerMainRuntime(jsi::Runtime *runtime,
                       std::shared_ptr<facebook::react::CallInvoker> invoker);
@@ -95,17 +100,21 @@ public:
   // The wgpu::Instance bound to this runtime.
   wgpu::Instance instance() const { return _instance; }
 
+  // The runtime this context belongs to. Safe for pointer-identity checks from
+  // any thread; only touch JSI through it on the runtime's own thread.
+  jsi::Runtime &runtime() const { return _runtime; }
+
   AsyncTaskHandle postTask(const TaskCallback &callback,
                            bool keepPumping = true);
 
-  // Deposit a settle-action to run on THIS context's runtime thread. Thread-safe
-  // (callable from any thread, e.g. another runtime that pumped ProcessEvents).
-  // The job must not touch JSI until it runs (it runs during drainMailbox on the
-  // owning thread).
+  // Deposit a settle-action to run on THIS context's runtime thread.
+  // Thread-safe (callable from any thread, e.g. another runtime that pumped
+  // ProcessEvents). The job must not touch JSI until it runs (it runs during
+  // drainMailbox on the owning thread).
   void postSettle(std::function<void()> job);
 
-  // Invoked by a drained settle-action when its task settles. Runs on the owning
-  // runtime's thread.
+  // Invoked by a drained settle-action when its task settles. Runs on the
+  // owning runtime's thread.
   void onTaskSettled(bool keepPumping);
 
 private:

package/lib/commonjs/index.js

@@ -3,9 +3,19 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  installWebGPU: true
+};
+Object.defineProperty(exports, "installWebGPU", {
+  enumerable: true,
+  get: function () {
+    return _install.installWebGPU;
+  }
+});
 var _main = require("./main");
 Object.keys(_main).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _main[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -17,6 +27,7 @@ Object.keys(_main).forEach(function (key) {
 var _constants = require("./constants");
 Object.keys(_constants).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
   if (key in exports && exports[key] === _constants[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
@@ -26,14 +37,4 @@ Object.keys(_constants).forEach(function (key) {
   });
 });
 var _install = require("./install");
-Object.keys(_install).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _install[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _install[key];
-    }
-  });
-});
 //# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_main","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_constants","_install"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;AAcA,IAAAA,KAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,KAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,KAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,KAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,UAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,UAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,UAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,UAAA,CAAAL,GAAA;IAAA;EAAA;AAAA;AACA,IAAAM,QAAA,GAAAV,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAQ,QAAA,EAAAP,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAM,QAAA,CAAAN,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAE,QAAA,CAAAN,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}
+{"version":3,"names":["_main","require","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_constants","_install"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;;;;;;;;;;;;;AAcA,IAAAA,KAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,KAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAL,KAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAb,KAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAS,UAAA,GAAAb,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAW,UAAA,EAAAV,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAS,UAAA,CAAAT,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,UAAA,CAAAT,GAAA;IAAA;EAAA;AAAA;AACA,IAAAU,QAAA,GAAAd,OAAA","ignoreList":[]}

package/lib/commonjs/install.js

@@ -3,8 +3,10 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.installWebGPU = void 0;
+exports.provideGPUForInstall = exports.installWebGPU = void 0;
 var _constants = require("./constants");
+/// <reference types="@webgpu/types" />
+
 // Globals that this function installs on the calling runtime. These are the
 // native-derived flag constants re-exported from `./constants` (a single source
 // of truth, matching the native `wgpu::*Usage` enums), so they are safe to set
@@ -17,38 +19,69 @@ const constants = {
   GPUMapMode: _constants.GPUMapMode
 };
 
+// The GPU instance destined for `navigator.gpu` on other runtimes, wrapped in
+// a holder object. It cannot be read at module evaluation: this module can be
+// evaluated before the native install has populated `RNWebGPU.gpu`, so
+// `main/index.tsx` fills the holder right after installing. The holder itself
+// is captured into the `installWebGPU` worklet closure; when a worklet is
+// serialized (always after startup, so after the holder is filled), the
+// Worklets custom serializer boxes the GPU object inside it, and unboxing on
+// the target runtime installs the GPU prototype there.
+const holder = {};
+
+/**
+ * @internal Called once by `main/index.tsx` after the native install, so
+ * `installWebGPU()` can put `navigator.gpu` on other runtimes.
+ */
+const provideGPUForInstall = gpu => {
+  holder.gpu = gpu;
+};
+
 /**
  * Install WebGPU on the runtime that calls it.
  *
- * The native module installs the WebGPU flag constants (`GPUBufferUsage`,
- * `GPUTextureUsage`, `GPUShaderStage`, `GPUColorWrite`, `GPUMapMode`) as globals
- * on the main JS runtime, but worklet runtimes (Reanimated UI, dedicated worklet
- * runtimes, Vision Camera frame processors) start without them, so referencing
- * the bare global inside a worklet yields `undefined`.
+ * The native module sets up WebGPU on the main JS runtime, but worklet
+ * runtimes (Reanimated UI, dedicated worklet runtimes, Vision Camera frame
+ * processors) start without it: `navigator.gpu` and the flag constants
+ * (`GPUBufferUsage`, `GPUTextureUsage`, `GPUShaderStage`, `GPUColorWrite`,
+ * `GPUMapMode`) are all `undefined` there.
  *
- * Call `installWebGPU()` once at the top of a worklet to make those globals
- * available there, instead of importing each constant by hand:
+ * Call `installWebGPU()` once at the top of a worklet to make them available:
  *
  * ```tsx
  * import { installWebGPU } from "react-native-webgpu";
  *
- * const work = (device: GPUDevice) => {
+ * const work = () => {
  *   "worklet";
  *   installWebGPU();
- *   device.createBuffer({
- *     usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+ *   globalThis.navigator.gpu.requestAdapter().then((adapter) => {
+ *     // ...
  *   });
  * };
  * ```
  *
- * The constants are captured into the worklet by closure (the same way a shader
- * string is), so they work on every runtime. Calling it on a runtime that
- * already has the globals (e.g. the main JS runtime) is a safe no-op.
+ * Known limitations:
+ *
+ * - Read `navigator` through `globalThis.navigator`: the Worklets Babel
+ *   plugin does not treat a bare `navigator` as a known global, so it would
+ *   capture the main runtime's `navigator` object by closure instead of
+ *   reading the one this function installed. Fixed upstream in
+ *   react-native-reanimated#10364; the prefix becomes unnecessary on
+ *   react-native-worklets versions that include it.
+ * - Spontaneous events are main-runtime only: on a device created on a
+ *   worklet runtime, `device.lost` never settles (unless the device is
+ *   already lost when read) and `uncapturederror` listeners never fire.
+ *   Observe those on a device created on the main JS thread.
  *
- * This is the explicit entry point for runtime setup; for now it only installs
- * the flag constants, but it is the place where other per-runtime WebGPU setup
- * (e.g. `navigator.gpu`) can be wired in later.
+ * Everything is captured into the worklet by closure: the constants like a
+ * shader string would be, and the GPU object through the Worklets custom
+ * serializer, which installs the native prototypes on the target runtime when
+ * it crosses. Promises returned by `requestAdapter`/`requestDevice` settle on
+ * the calling runtime (each runtime gets its own async pump). Calling it on a
+ * runtime that already has the globals (e.g. the main JS runtime) is a safe
+ * no-op.
  */
+exports.provideGPUForInstall = provideGPUForInstall;
 const installWebGPU = () => {
   "worklet";
 
@@ -58,6 +91,20 @@ const installWebGPU = () => {
       g[key] = value;
     }
   }
+  const {
+    gpu
+  } = holder;
+  if (gpu !== undefined) {
+    const nav = g.navigator;
+    if (nav === undefined) {
+      g.navigator = {
+        gpu,
+        userAgent: "react-native"
+      };
+    } else if (nav.gpu === undefined) {
+      nav.gpu = gpu;
+    }
+  }
 };
 exports.installWebGPU = installWebGPU;
 //# sourceMappingURL=install.js.map

package/lib/commonjs/install.js.map

@@ -1 +1 @@
-{"version":3,"names":["_constants","require","constants","GPUBufferUsage","GPUTextureUsage","GPUShaderStage","GPUColorWrite","GPUMapMode","installWebGPU","g","globalThis","key","value","Object","entries","undefined","exports"],"sourceRoot":"../../src","sources":["install.ts"],"mappings":";;;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAQA;AACA;AACA;AACA;AACA,MAAMC,SAAS,GAAG;EAChBC,cAAc,EAAdA,yBAAc;EACdC,eAAe,EAAfA,0BAAe;EACfC,cAAc,EAAdA,yBAAc;EACdC,aAAa,EAAbA,wBAAa;EACbC,UAAU,EAAVA;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,aAAa,GAAGA,CAAA,KAAM;EACjC,SAAS;;EACT,MAAMC,CAAC,GAAGC,UAAgD;EAC1D,KAAK,MAAM,CAACC,GAAG,EAAEC,KAAK,CAAC,IAAIC,MAAM,CAACC,OAAO,CAACZ,SAAS,CAAC,EAAE;IACpD,IAAIO,CAAC,CAACE,GAAG,CAAC,KAAKI,SAAS,EAAE;MACxBN,CAAC,CAACE,GAAG,CAAC,GAAGC,KAAK;IAChB;EACF;AACF,CAAC;AAACI,OAAA,CAAAR,aAAA,GAAAA,aAAA","ignoreList":[]}
+{"version":3,"names":["_constants","require","constants","GPUBufferUsage","GPUTextureUsage","GPUShaderStage","GPUColorWrite","GPUMapMode","holder","provideGPUForInstall","gpu","exports","installWebGPU","g","globalThis","key","value","Object","entries","undefined","nav","navigator","userAgent"],"sourceRoot":"../../src","sources":["install.ts"],"mappings":";;;;;;AACA,IAAAA,UAAA,GAAAC,OAAA;AADA;;AASA;AACA;AACA;AACA;AACA,MAAMC,SAAS,GAAG;EAChBC,cAAc,EAAdA,yBAAc;EACdC,eAAe,EAAfA,0BAAe;EACfC,cAAc,EAAdA,yBAAc;EACdC,aAAa,EAAbA,wBAAa;EACbC,UAAU,EAAVA;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,MAAqB,GAAG,CAAC,CAAC;;AAEhC;AACA;AACA;AACA;AACO,MAAMC,oBAAoB,GAAIC,GAAQ,IAAK;EAChDF,MAAM,CAACE,GAAG,GAAGA,GAAG;AAClB,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AA3CAC,OAAA,CAAAF,oBAAA,GAAAA,oBAAA;AA4CO,MAAMG,aAAa,GAAGA,CAAA,KAAM;EACjC,SAAS;;EACT,MAAMC,CAAC,GAAGC,UAAgD;EAC1D,KAAK,MAAM,CAACC,GAAG,EAAEC,KAAK,CAAC,IAAIC,MAAM,CAACC,OAAO,CAAChB,SAAS,CAAC,EAAE;IACpD,IAAIW,CAAC,CAACE,GAAG,CAAC,KAAKI,SAAS,EAAE;MACxBN,CAAC,CAACE,GAAG,CAAC,GAAGC,KAAK;IAChB;EACF;EACA,MAAM;IAAEN;EAAI,CAAC,GAAGF,MAAM;EACtB,IAAIE,GAAG,KAAKS,SAAS,EAAE;IACrB,MAAMC,GAAG,GAAGP,CAAC,CAACQ,SAA0D;IACxE,IAAID,GAAG,KAAKD,SAAS,EAAE;MACrBN,CAAC,CAACQ,SAAS,GAAG;QAAEX,GAAG;QAAEY,SAAS,EAAE;MAAe,CAAC;IAClD,CAAC,MAAM,IAAIF,GAAG,CAACV,GAAG,KAAKS,SAAS,EAAE;MAChCC,GAAG,CAACV,GAAG,GAAGA,GAAG;IACf;EACF;AACF,CAAC;AAACC,OAAA,CAAAC,aAAA,GAAAA,aAAA","ignoreList":[]}

package/lib/commonjs/main/index.js

@@ -13,6 +13,7 @@ Object.defineProperty(exports, "WebGPUModule", {
   }
 });
 var _external = require("../external");
+var _install = require("../install");
 var _NativeWebGPUModule = _interopRequireDefault(require("../NativeWebGPUModule"));
 var _Canvas = require("../Canvas");
 Object.keys(_Canvas).forEach(function (key) {
@@ -121,6 +122,8 @@ if (typeof RNWebGPU !== "undefined") {
     }
   }
   global.createImageBitmap = global.createImageBitmap ?? RNWebGPU.createImageBitmap.bind(RNWebGPU);
+  // Let installWebGPU() put navigator.gpu on other runtimes (see install.ts).
+  (0, _install.provideGPUForInstall)(RNWebGPU.gpu);
 } else {
   console.warn(`[react-native-webgpu] install() returned ${_installOk} but RNWebGPU global is not available`);
 }