react-native-wgpu 0.5.3 → 0.5.4

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -35,6 +35,7 @@
 #include "GPUSupportedLimits.h"
 #include "GPUTexture.h"
 #include "GPUTextureView.h"
+#include "GPUUncapturedErrorEvent.h"
 #include "GPUValidationError.h"
 
 // Enums
@@ -60,7 +61,8 @@ RNWebGPUManager::RNWebGPUManager(
   BaseRuntimeAwareCache::setMainJsRuntime(_jsRuntime);
 
   auto gpu = std::make_shared<GPU>(*_jsRuntime);
-  auto rnWebGPU = std::make_shared<RNWebGPU>(gpu, _platformContext, _jsCallInvoker);
+  auto rnWebGPU =
+      std::make_shared<RNWebGPU>(gpu, _platformContext, _jsCallInvoker);
   _gpu = gpu->get();
   _jsRuntime->global().setProperty(*_jsRuntime, "RNWebGPU",
                                    RNWebGPU::create(*_jsRuntime, rnWebGPU));
@@ -86,6 +88,7 @@ RNWebGPUManager::RNWebGPUManager(
   GPUInternalError::installConstructor(*_jsRuntime);
   GPUOutOfMemoryError::installConstructor(*_jsRuntime);
   GPUValidationError::installConstructor(*_jsRuntime);
+  GPUUncapturedErrorEvent::installConstructor(*_jsRuntime);
   GPUPipelineLayout::installConstructor(*_jsRuntime);
   GPUQuerySet::installConstructor(*_jsRuntime);
   GPUQueue::installConstructor(*_jsRuntime);

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -50,6 +50,8 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
       });
 
   // Set uncaptured error callback using new template API
+  // Note: This callback cannot capture variables, so we use a static registry
+  // to look up the GPUDevice from the wgpu::Device handle.
   aDescriptor.SetUncapturedErrorCallback([](const wgpu::Device &device,
                                             wgpu::ErrorType type,
                                             wgpu::StringView message) {
@@ -70,11 +72,16 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
     default:
       errorType = "Unknown";
     }
+    std::string msg =
+        message.length > 0 ? std::string(message.data, message.length) : "";
     std::string fullMessage =
-        message.length > 0 ? std::string(errorType) + ": " +
-                                 std::string(message.data, message.length)
-                           : "no message";
-    fprintf(stderr, "%s", fullMessage.c_str());
+        msg.length() > 0 ? std::string(errorType) + ": " + msg : "no message";
+    fprintf(stderr, "%s\n", fullMessage.c_str());
+
+    // Look up the GPUDevice from the registry and notify it
+    if (auto gpuDevice = GPUDevice::lookupDevice(device.Get())) {
+      gpuDevice->notifyUncapturedError(type, std::move(msg));
+    }
   });
   std::string label =
       descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
@@ -138,6 +145,11 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
               auto deviceHost = std::make_shared<GPUDevice>(std::move(device),
                                                             asyncRunner, label);
               *deviceLostBinding = deviceHost;
+
+              // Register the device in the static registry so the uncaptured
+              // error callback can find it
+              GPUDevice::registerDevice(deviceHost->get().Get(), deviceHost);
+
               resolve([deviceHost = std::move(deviceHost)](
                           jsi::Runtime &runtime) mutable {
                 return JSIConverter<std::shared_ptr<GPUDevice>>::toJSI(

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -431,4 +431,62 @@ async::AsyncTaskHandle GPUDevice::getLost() {
   _lostHandle = handle;
   return handle;
 }
+void GPUDevice::addEventListener(std::string type, jsi::Function callback) {
+  auto funcPtr = std::make_shared<jsi::Function>(std::move(callback));
+  _eventListeners[type].push_back(funcPtr);
+}
+
+void GPUDevice::removeEventListener(std::string type, jsi::Function callback) {
+  // Note: Since jsi::Function doesn't support equality comparison,
+  // we cannot reliably remove a specific listener. This is a no-op.
+  // Most use cases (like BabylonJS) only need addEventListener to work.
+  (void)type;
+  (void)callback;
+}
+
+void GPUDevice::notifyUncapturedError(wgpu::ErrorType type,
+                                      std::string message) {
+  auto it = _eventListeners.find("uncapturederror");
+  if (it == _eventListeners.end() || it->second.empty()) {
+    return;
+  }
+
+  auto runtime = getCreationRuntime();
+  if (runtime == nullptr) {
+    return;
+  }
+
+  // Create the appropriate error object based on type
+  GPUErrorVariant error;
+  switch (type) {
+  case wgpu::ErrorType::Validation:
+    error = std::make_shared<GPUValidationError>(message);
+    break;
+  case wgpu::ErrorType::OutOfMemory:
+    error = std::make_shared<GPUOutOfMemoryError>(message);
+    break;
+  case wgpu::ErrorType::Internal:
+  case wgpu::ErrorType::Unknown:
+  default:
+    error = std::make_shared<GPUInternalError>(message);
+    break;
+  }
+
+  // Create the event object
+  auto event = std::make_shared<GPUUncapturedErrorEvent>(std::move(error));
+  auto eventValue =
+      JSIConverter<std::shared_ptr<GPUUncapturedErrorEvent>>::toJSI(*runtime,
+                                                                    event);
+
+  // Call all registered listeners
+  for (const auto &listener : it->second) {
+    try {
+      listener->call(*runtime, eventValue);
+    } catch (const std::exception &e) {
+      // Log but don't throw - we don't want one listener to break others
+      fprintf(stderr, "Error in uncapturederror listener: %s\n", e.what());
+    }
+  }
+}
+
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUDevice.h

@@ -1,11 +1,15 @@
 #pragma once
 
+#include <functional>
 #include <memory>
+#include <mutex>
 #include <optional>
 #include <string>
+#include <unordered_map>
 #include <unordered_set>
 #include <utility>
 #include <variant>
+#include <vector>
 
 #include "Unions.h"
 
@@ -46,6 +50,7 @@
 #include "GPUSupportedLimits.h"
 #include "GPUTexture.h"
 #include "GPUTextureDescriptor.h"
+#include "GPUUncapturedErrorEvent.h"
 
 namespace rnwgpu {
 
@@ -61,6 +66,44 @@ public:
       : NativeObject(CLASS_NAME), _instance(instance), _async(async),
         _label(label) {}
 
+  ~GPUDevice() override {
+    // Unregister from the static registry
+    unregisterDevice(_instance.Get());
+  }
+
+  // Static registry for looking up GPUDevice from wgpu::Device in callbacks
+  static void registerDevice(WGPUDevice handle,
+                             std::weak_ptr<GPUDevice> device) {
+    std::lock_guard<std::mutex> lock(getRegistryMutex());
+    getRegistry()[handle] = device;
+  }
+
+  static void unregisterDevice(WGPUDevice handle) {
+    std::lock_guard<std::mutex> lock(getRegistryMutex());
+    getRegistry().erase(handle);
+  }
+
+  static std::shared_ptr<GPUDevice> lookupDevice(WGPUDevice handle) {
+    std::lock_guard<std::mutex> lock(getRegistryMutex());
+    auto it = getRegistry().find(handle);
+    if (it != getRegistry().end()) {
+      return it->second.lock();
+    }
+    return nullptr;
+  }
+
+private:
+  static std::unordered_map<WGPUDevice, std::weak_ptr<GPUDevice>> &
+  getRegistry() {
+    static std::unordered_map<WGPUDevice, std::weak_ptr<GPUDevice>> registry;
+    return registry;
+  }
+
+  static std::mutex &getRegistryMutex() {
+    static std::mutex mutex;
+    return mutex;
+  }
+
 public:
   std::string getBrand() { return CLASS_NAME; }
 
@@ -103,8 +146,13 @@ public:
   std::shared_ptr<GPUQueue> getQueue();
   async::AsyncTaskHandle getLost();
   void notifyDeviceLost(wgpu::DeviceLostReason reason, std::string message);
+  void notifyUncapturedError(wgpu::ErrorType type, std::string message);
   void forceLossForTesting();
 
+  // EventTarget methods
+  void addEventListener(std::string type, jsi::Function callback);
+  void removeEventListener(std::string type, jsi::Function callback);
+
   std::string getLabel() { return _label; }
   void setLabel(const std::string &label) {
     _label = label;
@@ -155,6 +203,38 @@ public:
                         &GPUDevice::setLabel);
     installMethod(runtime, prototype, "forceLossForTesting",
                   &GPUDevice::forceLossForTesting);
+
+    // EventTarget methods - installed manually since they take jsi::Function
+    auto addEventListenerFunc = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "addEventListener"), 2,
+        [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          if (count < 2 || !args[0].isString() || !args[1].isObject() ||
+              !args[1].getObject(rt).isFunction(rt)) {
+            return jsi::Value::undefined();
+          }
+          auto native = GPUDevice::fromValue(rt, thisVal);
+          native->addEventListener(args[0].getString(rt).utf8(rt),
+                                   args[1].getObject(rt).getFunction(rt));
+          return jsi::Value::undefined();
+        });
+    prototype.setProperty(runtime, "addEventListener", addEventListenerFunc);
+
+    auto removeEventListenerFunc = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "removeEventListener"), 2,
+        [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          if (count < 2 || !args[0].isString() || !args[1].isObject() ||
+              !args[1].getObject(rt).isFunction(rt)) {
+            return jsi::Value::undefined();
+          }
+          auto native = GPUDevice::fromValue(rt, thisVal);
+          native->removeEventListener(args[0].getString(rt).utf8(rt),
+                                      args[1].getObject(rt).getFunction(rt));
+          return jsi::Value::undefined();
+        });
+    prototype.setProperty(runtime, "removeEventListener",
+                          removeEventListenerFunc);
   }
 
   inline const wgpu::Device get() { return _instance; }
@@ -169,6 +249,11 @@ private:
   std::shared_ptr<GPUDeviceLostInfo> _lostInfo;
   bool _lostSettled = false;
   std::optional<async::AsyncTaskHandle::ResolveFunction> _lostResolve;
+
+  // Event listeners storage - keyed by event type
+  // Each entry contains a vector of shared_ptr to functions
+  std::unordered_map<std::string, std::vector<std::shared_ptr<jsi::Function>>>
+      _eventListeners;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/GPUUncapturedErrorEvent.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <variant>
+
+#include "JSIConverter.h"
+#include "NativeObject.h"
+
+#include "GPUInternalError.h"
+#include "GPUOutOfMemoryError.h"
+#include "GPUValidationError.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+using GPUErrorVariant = std::variant<std::shared_ptr<GPUValidationError>,
+                                     std::shared_ptr<GPUOutOfMemoryError>,
+                                     std::shared_ptr<GPUInternalError>>;
+
+class GPUUncapturedErrorEvent : public NativeObject<GPUUncapturedErrorEvent> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUUncapturedErrorEvent";
+
+  explicit GPUUncapturedErrorEvent(GPUErrorVariant error)
+      : NativeObject(CLASS_NAME), _error(std::move(error)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+  std::string getType() { return "uncapturederror"; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand",
+                  &GPUUncapturedErrorEvent::getBrand);
+    installGetter(runtime, prototype, "type",
+                  &GPUUncapturedErrorEvent::getType);
+
+    // Custom getter for error that handles the variant conversion
+    auto errorGetter = jsi::Function::createFromHostFunction(
+        runtime, jsi::PropNameID::forUtf8(runtime, "get_error"), 0,
+        [](jsi::Runtime &rt, const jsi::Value &thisVal, const jsi::Value *args,
+           size_t count) -> jsi::Value {
+          auto native = GPUUncapturedErrorEvent::fromValue(rt, thisVal);
+          return std::visit(
+              [&rt](auto &&err) -> jsi::Value {
+                using T = std::decay_t<decltype(err)>;
+                return JSIConverter<T>::toJSI(rt, err);
+              },
+              native->_error);
+        });
+
+    auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
+    auto defineProperty =
+        objectCtor.getPropertyAsFunction(runtime, "defineProperty");
+
+    jsi::Object descriptor(runtime);
+    descriptor.setProperty(runtime, "get", errorGetter);
+    descriptor.setProperty(runtime, "enumerable", true);
+    descriptor.setProperty(runtime, "configurable", true);
+
+    defineProperty.call(runtime, prototype,
+                        jsi::String::createFromUtf8(runtime, "error"),
+                        descriptor);
+  }
+
+private:
+  GPUErrorVariant _error;
+};
+
+} // namespace rnwgpu

package/lib/commonjs/external/reanimated/registerWebGPUForReanimated.js

@@ -20,7 +20,6 @@ const registerWebGPUForReanimated = () => {
   }
   isRegistered = true;
   try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
     const {
       registerCustomSerializable
     } = require("react-native-worklets");

package/lib/commonjs/external/reanimated/registerWebGPUForReanimated.js.map

@@ -1 +1 @@
-{"version":3,"names":["isRegistered","registerWebGPUForReanimated","registerCustomSerializable","require","name","determine","value","__webgpuIsWebGPUObject","pack","__webgpuBox","unpack","boxed","unbox","exports"],"sourceRoot":"../../../../src","sources":["external/reanimated/registerWebGPUForReanimated.ts"],"mappings":";;;;;;AAAA;;AAMA,IAAIA,YAAY,GAAG,KAAK;;AAExB;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,2BAA2B,GAAGA,CAAA,KAAM;EAC/C,IAAID,YAAY,EAAE;IAChB;EACF;EACAA,YAAY,GAAG,IAAI;EAEnB,IAAI;IACF;IACA,MAAM;MAAEE;IAA2B,CAAC,GAAGC,OAAO,CAAC,uBAAuB,CAAC;IAEvED,0BAA0B,CAAC;MACzBE,IAAI,EAAE,QAAQ;MACdC,SAAS,EAAGC,KAAa,IAAsB;QAC7C,SAAS;;QACT,OAAOC,sBAAsB,CAACD,KAAK,CAAC;MACtC,CAAC;MACDE,IAAI,EAAGF,KAAa,IAAK;QACvB,SAAS;;QACT,OAAOG,WAAW,CAACH,KAAK,CAAC;MAC3B,CAAC;MACDI,MAAM,EAAGC,KAA8B,IAAK;QAC1C,SAAS;;QACT,OAAOA,KAAK,CAACC,KAAK,CAAC,CAAC;MACtB;IACF,CAAC,CAAC;EACJ,CAAC,CAAC,MAAM;IACN;EAAA;AAEJ,CAAC;AAACC,OAAA,CAAAZ,2BAAA,GAAAA,2BAAA","ignoreList":[]}
+{"version":3,"names":["isRegistered","registerWebGPUForReanimated","registerCustomSerializable","require","name","determine","value","__webgpuIsWebGPUObject","pack","__webgpuBox","unpack","boxed","unbox","exports"],"sourceRoot":"../../../../src","sources":["external/reanimated/registerWebGPUForReanimated.ts"],"mappings":";;;;;;AAAA;;AAOA,IAAIA,YAAY,GAAG,KAAK;;AAExB;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,2BAA2B,GAAGA,CAAA,KAAM;EAC/C,IAAID,YAAY,EAAE;IAChB;EACF;EACAA,YAAY,GAAG,IAAI;EAEnB,IAAI;IACF,MAAM;MAAEE;IAA2B,CAAC,GAAGC,OAAO,CAAC,uBAAuB,CAAC;IAEvED,0BAA0B,CAAC;MACzBE,IAAI,EAAE,QAAQ;MACdC,SAAS,EAAGC,KAAa,IAAsB;QAC7C,SAAS;;QACT,OAAOC,sBAAsB,CAACD,KAAK,CAAC;MACtC,CAAC;MACDE,IAAI,EAAGF,KAAa,IAAK;QACvB,SAAS;;QACT,OAAOG,WAAW,CAACH,KAAK,CAAC;MAC3B,CAAC;MACDI,MAAM,EAAGC,KAA8B,IAAK;QAC1C,SAAS;;QACT,OAAOA,KAAK,CAACC,KAAK,CAAC,CAAC;MACtB;IACF,CAAC,CAAC;EACJ,CAAC,CAAC,MAAM;IACN;EAAA;AAEJ,CAAC;AAACC,OAAA,CAAAZ,2BAAA,GAAAA,2BAAA","ignoreList":[]}

package/lib/module/external/reanimated/registerWebGPUForReanimated.js

@@ -14,7 +14,6 @@ export const registerWebGPUForReanimated = () => {
   }
   isRegistered = true;
   try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
     const {
       registerCustomSerializable
     } = require("react-native-worklets");

package/lib/module/external/reanimated/registerWebGPUForReanimated.js.map

@@ -1 +1 @@
-{"version":3,"names":["isRegistered","registerWebGPUForReanimated","registerCustomSerializable","require","name","determine","value","__webgpuIsWebGPUObject","pack","__webgpuBox","unpack","boxed","unbox"],"sourceRoot":"../../../../src","sources":["external/reanimated/registerWebGPUForReanimated.ts"],"mappings":"AAAA;;AAMA,IAAIA,YAAY,GAAG,KAAK;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,2BAA2B,GAAGA,CAAA,KAAM;EAC/C,IAAID,YAAY,EAAE;IAChB;EACF;EACAA,YAAY,GAAG,IAAI;EAEnB,IAAI;IACF;IACA,MAAM;MAAEE;IAA2B,CAAC,GAAGC,OAAO,CAAC,uBAAuB,CAAC;IAEvED,0BAA0B,CAAC;MACzBE,IAAI,EAAE,QAAQ;MACdC,SAAS,EAAGC,KAAa,IAAsB;QAC7C,SAAS;;QACT,OAAOC,sBAAsB,CAACD,KAAK,CAAC;MACtC,CAAC;MACDE,IAAI,EAAGF,KAAa,IAAK;QACvB,SAAS;;QACT,OAAOG,WAAW,CAACH,KAAK,CAAC;MAC3B,CAAC;MACDI,MAAM,EAAGC,KAA8B,IAAK;QAC1C,SAAS;;QACT,OAAOA,KAAK,CAACC,KAAK,CAAC,CAAC;MACtB;IACF,CAAC,CAAC;EACJ,CAAC,CAAC,MAAM;IACN;EAAA;AAEJ,CAAC","ignoreList":[]}
+{"version":3,"names":["isRegistered","registerWebGPUForReanimated","registerCustomSerializable","require","name","determine","value","__webgpuIsWebGPUObject","pack","__webgpuBox","unpack","boxed","unbox"],"sourceRoot":"../../../../src","sources":["external/reanimated/registerWebGPUForReanimated.ts"],"mappings":"AAAA;;AAOA,IAAIA,YAAY,GAAG,KAAK;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,2BAA2B,GAAGA,CAAA,KAAM;EAC/C,IAAID,YAAY,EAAE;IAChB;EACF;EACAA,YAAY,GAAG,IAAI;EAEnB,IAAI;IACF,MAAM;MAAEE;IAA2B,CAAC,GAAGC,OAAO,CAAC,uBAAuB,CAAC;IAEvED,0BAA0B,CAAC;MACzBE,IAAI,EAAE,QAAQ;MACdC,SAAS,EAAGC,KAAa,IAAsB;QAC7C,SAAS;;QACT,OAAOC,sBAAsB,CAACD,KAAK,CAAC;MACtC,CAAC;MACDE,IAAI,EAAGF,KAAa,IAAK;QACvB,SAAS;;QACT,OAAOG,WAAW,CAACH,KAAK,CAAC;MAC3B,CAAC;MACDI,MAAM,EAAGC,KAA8B,IAAK;QAC1C,SAAS;;QACT,OAAOA,KAAK,CAACC,KAAK,CAAC,CAAC;MACtB;IACF,CAAC,CAAC;EACJ,CAAC,CAAC,MAAM;IACN;EAAA;AAEJ,CAAC","ignoreList":[]}

package/lib/typescript/lib/commonjs/external/reanimated/registerWebGPUForReanimated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registerWebGPUForReanimated.d.ts","sourceRoot":"","sources":["../../../../../commonjs/external/reanimated/registerWebGPUForReanimated.js"],"names":[],"mappings":";AAUA;;;;;GAKG;AACH,oDA+BC"}
+{"version":3,"file":"registerWebGPUForReanimated.d.ts","sourceRoot":"","sources":["../../../../../commonjs/external/reanimated/registerWebGPUForReanimated.js"],"names":[],"mappings":";AAUA;;;;;GAKG;AACH,oDA8BC"}

package/lib/typescript/lib/module/external/reanimated/registerWebGPUForReanimated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registerWebGPUForReanimated.d.ts","sourceRoot":"","sources":["../../../../../module/external/reanimated/registerWebGPUForReanimated.js"],"names":[],"mappings":"AAUO,oDA+BN"}
+{"version":3,"file":"registerWebGPUForReanimated.d.ts","sourceRoot":"","sources":["../../../../../module/external/reanimated/registerWebGPUForReanimated.js"],"names":[],"mappings":"AAUO,oDA8BN"}

package/lib/typescript/src/external/reanimated/registerWebGPUForReanimated.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registerWebGPUForReanimated.d.ts","sourceRoot":"","sources":["../../../../../src/external/reanimated/registerWebGPUForReanimated.ts"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,YA4BvC,CAAC"}
+{"version":3,"file":"registerWebGPUForReanimated.d.ts","sourceRoot":"","sources":["../../../../../src/external/reanimated/registerWebGPUForReanimated.ts"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,YA2BvC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-wgpu",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "description": "React Native WebGPU",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/external/ModuleProxy.ts

@@ -6,7 +6,7 @@ type ImportType = ReturnType<typeof require>;
  * This is useful for lazily requiring optional dependencies.
  */
 export const createModuleProxy = <TModule>(
-  getModule: () => ImportType
+  getModule: () => ImportType,
 ): TModule => {
   const holder: { module: TModule | undefined } = { module: undefined };
 

package/src/external/reanimated/registerWebGPUForReanimated.ts

@@ -1,8 +1,9 @@
 // Declare global WebGPU worklet helper functions (installed by native module)
 declare function __webgpuIsWebGPUObject(obj: unknown): boolean;
-declare function __webgpuBox(
-  obj: object
-): { unbox: () => object; __boxedWebGPU: true };
+declare function __webgpuBox(obj: object): {
+  unbox: () => object;
+  __boxedWebGPU: true;
+};
 
 let isRegistered = false;
 
@@ -19,7 +20,6 @@ export const registerWebGPUForReanimated = () => {
   isRegistered = true;
 
   try {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
     const { registerCustomSerializable } = require("react-native-worklets");
 
     registerCustomSerializable({