react-native-wgpu 0.5.2 → 0.5.4

package/android/cpp/AndroidPlatformContext.h

@@ -3,8 +3,10 @@
 #include <android/bitmap.h>
 #include <jni.h>
 
+#include <functional>
 #include <memory>
 #include <string>
+#include <thread>
 #include <vector>
 
 #include "webgpu/webgpu_cpp.h"
@@ -128,6 +130,112 @@ public:
     result.data = imageData;
     return result;
   }
+
+  void createImageBitmapAsync(
+      std::string blobId, double offset, double size,
+      std::function<void(ImageData)> onSuccess,
+      std::function<void(std::string)> onError) override {
+    // Capture blobModule for the background thread
+    jobject blobModule = _blobModule;
+
+    // Dispatch to a background thread
+    std::thread([blobModule, blobId = std::move(blobId), offset, size,
+                 onSuccess = std::move(onSuccess),
+                 onError = std::move(onError)]() {
+      jni::Environment::ensureCurrentThreadIsAttached();
+
+      JNIEnv *env = facebook::jni::Environment::current();
+      if (!env) {
+        onError("Couldn't get JNI environment");
+        return;
+      }
+
+      if (!blobModule) {
+        onError("BlobModule instance is null");
+        return;
+      }
+
+      // Get the resolve method ID
+      jclass blobModuleClass = env->GetObjectClass(blobModule);
+      if (!blobModuleClass) {
+        onError("Couldn't find BlobModule class");
+        return;
+      }
+
+      jmethodID resolveMethod = env->GetMethodID(blobModuleClass, "resolve",
+                                                 "(Ljava/lang/String;II)[B");
+      if (!resolveMethod) {
+        onError("Couldn't find resolve method in BlobModule");
+        return;
+      }
+
+      // Resolve the blob data
+      jstring jBlobId = env->NewStringUTF(blobId.c_str());
+      jbyteArray blobData = (jbyteArray)env->CallObjectMethod(
+          blobModule, resolveMethod, jBlobId, static_cast<jint>(offset),
+          static_cast<jint>(size));
+      env->DeleteLocalRef(jBlobId);
+
+      if (!blobData) {
+        onError("Couldn't retrieve blob data");
+        return;
+      }
+
+      // Create a Bitmap from the blob data
+      jclass bitmapFactoryClass =
+          env->FindClass("android/graphics/BitmapFactory");
+      jmethodID decodeByteArrayMethod =
+          env->GetStaticMethodID(bitmapFactoryClass, "decodeByteArray",
+                                 "([BII)Landroid/graphics/Bitmap;");
+      jint blobLength = env->GetArrayLength(blobData);
+      jobject bitmap = env->CallStaticObjectMethod(
+          bitmapFactoryClass, decodeByteArrayMethod, blobData, 0, blobLength);
+
+      if (!bitmap) {
+        env->DeleteLocalRef(blobData);
+        onError("Couldn't decode image");
+        return;
+      }
+
+      // Get bitmap info
+      AndroidBitmapInfo bitmapInfo;
+      if (AndroidBitmap_getInfo(env, bitmap, &bitmapInfo) !=
+          ANDROID_BITMAP_RESULT_SUCCESS) {
+        env->DeleteLocalRef(blobData);
+        env->DeleteLocalRef(bitmap);
+        onError("Couldn't get bitmap info");
+        return;
+      }
+
+      // Lock the bitmap pixels
+      void *bitmapPixels;
+      if (AndroidBitmap_lockPixels(env, bitmap, &bitmapPixels) !=
+          ANDROID_BITMAP_RESULT_SUCCESS) {
+        env->DeleteLocalRef(blobData);
+        env->DeleteLocalRef(bitmap);
+        onError("Couldn't lock bitmap pixels");
+        return;
+      }
+
+      // Copy the bitmap data
+      std::vector<uint8_t> imageData(bitmapInfo.height * bitmapInfo.stride);
+      memcpy(imageData.data(), bitmapPixels, imageData.size());
+
+      // Unlock the bitmap pixels
+      AndroidBitmap_unlockPixels(env, bitmap);
+
+      // Clean up JNI references
+      env->DeleteLocalRef(blobData);
+      env->DeleteLocalRef(bitmap);
+
+      ImageData result;
+      result.width = static_cast<int>(bitmapInfo.width);
+      result.height = static_cast<int>(bitmapInfo.height);
+      result.data = std::move(imageData);
+
+      onSuccess(std::move(result));
+    }).detach();
+  }
 };
 
 } // namespace rnwgpu

package/apple/ApplePlatformContext.h

@@ -15,6 +15,11 @@ public:
 
   ImageData createImageBitmap(std::string blobId, double offset,
                               double size) override;
+
+  void createImageBitmapAsync(
+      std::string blobId, double offset, double size,
+      std::function<void(ImageData)> onSuccess,
+      std::function<void(std::string)> onError) override;
 };
 
 } // namespace rnwgpu

package/apple/ApplePlatformContext.mm

@@ -95,4 +95,73 @@ ImageData ApplePlatformContext::createImageBitmap(std::string blobId,
   return result;
 }
 
+void ApplePlatformContext::createImageBitmapAsync(
+    std::string blobId, double offset, double size,
+    std::function<void(ImageData)> onSuccess,
+    std::function<void(std::string)> onError) {
+  // Capture blob data on the current thread (requires RCTBridge access)
+  RCTBlobManager *blobManager =
+      [[RCTBridge currentBridge] moduleForClass:RCTBlobManager.class];
+  NSData *blobData =
+      [blobManager resolve:[NSString stringWithUTF8String:blobId.c_str()]
+                    offset:(long)offset
+                      size:(long)size];
+
+  if (!blobData) {
+    onError("Couldn't retrieve blob data");
+    return;
+  }
+
+  // Retain the data for the background block
+  NSData *retainedData = [blobData copy];
+
+  // Dispatch heavy image decoding work to a background queue
+  dispatch_async(
+      dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+        @autoreleasepool {
+#if !TARGET_OS_OSX
+          UIImage *image = [UIImage imageWithData:retainedData];
+#else
+          NSImage *image = [[NSImage alloc] initWithData:retainedData];
+#endif
+          if (!image) {
+            onError("Couldn't decode image");
+            return;
+          }
+
+#if !TARGET_OS_OSX
+          CGImageRef cgImage = image.CGImage;
+#else
+          CGImageRef cgImage = [image CGImageForProposedRect:NULL
+                                                     context:NULL
+                                                       hints:NULL];
+#endif
+          size_t width = CGImageGetWidth(cgImage);
+          size_t height = CGImageGetHeight(cgImage);
+          size_t bitsPerComponent = 8;
+          size_t bytesPerRow = width * 4;
+          std::vector<uint8_t> imageData(height * bytesPerRow);
+
+          CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+          CGContextRef context = CGBitmapContextCreate(
+              imageData.data(), width, height, bitsPerComponent, bytesPerRow,
+              colorSpace,
+              kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
+
+          CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgImage);
+
+          CGContextRelease(context);
+          CGColorSpaceRelease(colorSpace);
+
+          ImageData result;
+          result.width = static_cast<int>(width);
+          result.height = static_cast<int>(height);
+          result.data = std::move(imageData);
+          result.format = wgpu::TextureFormat::RGBA8Unorm;
+
+          onSuccess(std::move(result));
+        }
+      });
+}
+
 } // namespace rnwgpu

package/cpp/jsi/JSIConverter.h

@@ -9,9 +9,10 @@
 #include <variant>
 #include <map>
 #include <unordered_set>
-
 #include <jsi/jsi.h>
 
+#include "WGPULogger.h"
+
 #include "EnumMapper.h"
 #include "Promise.h"
 
@@ -308,10 +309,17 @@ template <typename T> struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_n
 #endif
     jsi::Object object = arg.getObject(runtime);
 #if DEBUG
-    if (!object.hasNativeState<TPointee>(runtime)) {
-      [[unlikely]];
+    if (!object.hasNativeState<TPointee>(runtime)) [[unlikely]] {
+      // Log instead of throwing: hasNativeState<T>() uses dynamic_cast (RTTI)
+      // which can return false across shared-library / JSI-runtime boundaries
+      // on iOS (duplicate typeinfo symbols in separate .dylib modules).
+      // getNativeState<T>() below uses static_pointer_cast and works correctly
+      // even when dynamic_cast fails, so this is not a fatal error.
       std::string stringRepresentation = arg.toString(runtime).utf8(runtime);
-      throw jsi::JSError(runtime, invalidTypeErrorMessage(stringRepresentation, "It is a different NativeState<T>!"));
+      Logger::logToConsole("NativeState<T> RTTI mismatch for \"%s\" (expected %s) "
+              "-- this is likely a false positive from dynamic_cast across JSI "
+              "runtime boundaries; continuing with static_pointer_cast.",
+              stringRepresentation.c_str(), getFriendlyTypename().c_str());
     }
 #endif
     return object.getNativeState<TPointee>(runtime);

package/cpp/rnwgpu/PlatformContext.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <functional>
 #include <memory>
 #include <string>
 #include <vector>
@@ -24,6 +25,12 @@ public:
                                     int width, int height) = 0;
   virtual ImageData createImageBitmap(std::string blobId, double offset,
                                       double size) = 0;
+
+  // Async version that performs image decoding on a background thread
+  virtual void createImageBitmapAsync(
+      std::string blobId, double offset, double size,
+      std::function<void(ImageData)> onSuccess,
+      std::function<void(std::string)> onError) = 0;
 };
 
 } // namespace rnwgpu

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);
+  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/GPU.h

@@ -48,6 +48,7 @@ public:
   }
 
   inline const wgpu::Instance get() { return _instance; }
+  inline std::shared_ptr<async::AsyncRunner> getAsyncRunner() { return _async; }
 
 private:
   wgpu::Instance _instance;

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/cpp/rnwgpu/api/RNWebGPU.h

@@ -11,6 +11,11 @@
 #include "ImageBitmap.h"
 #include "PlatformContext.h"
 
+#include <ReactCommon/CallInvoker.h>
+
+#include "JSIConverter.h"
+#include "Promise.h"
+
 namespace rnwgpu {
 
 namespace jsi = facebook::jsi;
@@ -23,14 +28,41 @@ struct Blob {
   std::string name;
 };
 
+// JSIConverter specialization must be declared before use
+template <> struct JSIConverter<std::shared_ptr<Blob>> {
+  static std::shared_ptr<Blob>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    if (!outOfBounds && arg.isObject()) {
+      auto result = std::make_unique<Blob>();
+      auto val = arg.asObject(runtime);
+      if (val.hasProperty(runtime, "_data")) {
+        auto value = val.getPropertyAsObject(runtime, "_data");
+        result->blobId = JSIConverter<std::string>::fromJSI(
+            runtime, value.getProperty(runtime, "blobId"), false);
+        result->size = JSIConverter<double>::fromJSI(
+            runtime, value.getProperty(runtime, "size"), false);
+        result->offset = JSIConverter<double>::fromJSI(
+            runtime, value.getProperty(runtime, "offset"), false);
+      }
+      return result;
+    } else {
+      throw std::runtime_error("Invalid Blob::fromJSI()");
+    }
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime, std::shared_ptr<Blob> arg) {
+    throw std::runtime_error("Invalid Blob::toJSI()");
+  }
+};
+
 class RNWebGPU : public NativeObject<RNWebGPU> {
 public:
   static constexpr const char *CLASS_NAME = "RNWebGPU";
 
   explicit RNWebGPU(std::shared_ptr<GPU> gpu,
-                    std::shared_ptr<PlatformContext> platformContext)
-      : NativeObject(CLASS_NAME), _gpu(gpu), _platformContext(platformContext) {
-  }
+                    std::shared_ptr<PlatformContext> platformContext,
+                    std::shared_ptr<facebook::react::CallInvoker> callInvoker)
+      : NativeObject(CLASS_NAME), _gpu(gpu), _platformContext(platformContext),
+        _callInvoker(callInvoker) {}
 
   std::shared_ptr<GPU> getGPU() { return _gpu; }
 
@@ -43,11 +75,41 @@ public:
     return ctx;
   }
 
-  std::shared_ptr<ImageBitmap> createImageBitmap(std::shared_ptr<Blob> blob) {
-    auto imageData = _platformContext->createImageBitmap(
-        blob->blobId, blob->offset, blob->size);
-    auto imageBitmap = std::make_shared<ImageBitmap>(imageData);
-    return imageBitmap;
+  jsi::Value createImageBitmap(jsi::Runtime &runtime,
+                               const jsi::Value & /*thisVal*/,
+                               const jsi::Value *args, size_t count) {
+    if (count < 1) {
+      throw jsi::JSError(runtime, "createImageBitmap requires a Blob argument");
+    }
+
+    auto blob =
+        JSIConverter<std::shared_ptr<Blob>>::fromJSI(runtime, args[0], false);
+    auto platformContext = _platformContext;
+    auto callInvoker = _callInvoker;
+    std::string blobId = blob->blobId;
+    double offset = blob->offset;
+    double size = blob->size;
+
+    return Promise::createPromise(
+        runtime,
+        [platformContext, callInvoker, blobId, offset,
+         size](jsi::Runtime & /*runtime*/, std::shared_ptr<Promise> promise) {
+          platformContext->createImageBitmapAsync(
+              blobId, offset, size,
+              [callInvoker, promise](ImageData imageData) {
+                auto imageBitmap = std::make_shared<ImageBitmap>(imageData);
+                callInvoker->invokeAsync(
+                    [promise, imageBitmap]() {
+                      promise->resolve(
+                          JSIConverter<std::shared_ptr<ImageBitmap>>::toJSI(
+                              promise->runtime, imageBitmap));
+                    });
+              },
+              [callInvoker, promise](std::string error) {
+                callInvoker->invokeAsync(
+                    [promise, error]() { promise->reject(error); });
+              });
+        });
   }
 
   std::shared_ptr<Canvas> getNativeSurface(int contextId) {
@@ -75,35 +137,7 @@ public:
 private:
   std::shared_ptr<GPU> _gpu;
   std::shared_ptr<PlatformContext> _platformContext;
-};
-
-template <> struct JSIConverter<std::shared_ptr<Blob>> {
-  static std::shared_ptr<Blob>
-  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    if (!outOfBounds && arg.isObject()) {
-      auto result = std::make_unique<Blob>();
-      auto val = arg.asObject(runtime);
-      if (val.hasProperty(runtime, "_data")) {
-        auto value = val.getPropertyAsObject(runtime, "_data");
-        result->blobId = JSIConverter<std::string>::fromJSI(
-            runtime, value.getProperty(runtime, "blobId"), false);
-        //        result->type = JSIConverter<std::string>::fromJSI(
-        //            runtime, value.getProperty(runtime, "type"), false);
-        //        result->name = JSIConverter<std::string>::fromJSI(
-        //            runtime, value.getProperty(runtime, "name"), false);
-        result->size = JSIConverter<double>::fromJSI(
-            runtime, value.getProperty(runtime, "size"), false);
-        result->offset = JSIConverter<double>::fromJSI(
-            runtime, value.getProperty(runtime, "offset"), false);
-      }
-      return result;
-    } else {
-      throw std::runtime_error("Invalid Blob::fromJSI()");
-    }
-  }
-  static jsi::Value toJSI(jsi::Runtime &runtime, std::shared_ptr<Blob> arg) {
-    throw std::runtime_error("Invalid Blob::toJSI()");
-  }
+  std::shared_ptr<facebook::react::CallInvoker> _callInvoker;
 };
 
 } // 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/commonjs/main/index.js

@@ -83,5 +83,5 @@ if (!navigator) {
     }
   }
 }
-global.createImageBitmap = global.createImageBitmap ?? ((...params) => new Promise(resolve => resolve(RNWebGPU.createImageBitmap(...params))));
+global.createImageBitmap = global.createImageBitmap ?? RNWebGPU.createImageBitmap.bind(RNWebGPU);
 //# sourceMappingURL=index.js.map

package/lib/commonjs/main/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_external","require","_NativeWebGPUModule","_interopRequireDefault","_Canvas","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_Offscreen","_WebGPUViewNativeComponent","_hooks","e","__esModule","default","WebGPUModule","install","registerWebGPUForReanimated","navigator","gpu","RNWebGPU","userAgent","global","createImageBitmap","params","Promise","resolve"],"sourceRoot":"../../../src","sources":["main/index.tsx"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_external","require","_NativeWebGPUModule","_interopRequireDefault","_Canvas","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_Offscreen","_WebGPUViewNativeComponent","_hooks","e","__esModule","default","WebGPUModule","install","registerWebGPUForReanimated","navigator","gpu","RNWebGPU","userAgent","global","createImageBitmap","bind"],"sourceRoot":"../../../src","sources":["main/index.tsx"],"mappings":"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","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/module/main/index.js

@@ -25,5 +25,5 @@ if (!navigator) {
     }
   }
 }
-global.createImageBitmap = global.createImageBitmap ?? ((...params) => new Promise(resolve => resolve(RNWebGPU.createImageBitmap(...params))));
+global.createImageBitmap = global.createImageBitmap ?? RNWebGPU.createImageBitmap.bind(RNWebGPU);
 //# sourceMappingURL=index.js.map

package/lib/module/main/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["registerWebGPUForReanimated","WebGPUModule","default","install","navigator","gpu","RNWebGPU","userAgent","global","createImageBitmap","params","Promise","resolve"],"sourceRoot":"../../../src","sources":["main/index.tsx"],"mappings":"AAAA,SAASA,2BAA2B,QAAQ,aAAa;AACzD,OAAOC,YAAY,MAAM,uBAAuB;AAEhD,cAAc,WAAW;AACzB,cAAc,cAAc;AAC5B,cAAc,8BAA8B;AAC5C,cAAc,UAAU;AAExB,SAASC,OAAO,IAAID,YAAY,QAAQ,uBAAuB;AAE/DA,YAAY,CAACE,OAAO,CAAC,CAAC;AAEtBH,2BAA2B,CAAC,CAAC;AAE7B,IAAI,CAACI,SAAS,EAAE;EACd;EACAA,SAAS,GAAG;IACVC,GAAG,EAAEC,QAAQ,CAACD,GAAG;IACjBE,SAAS,EAAE;EACb,CAAC;AACH,CAAC,MAAM;EACLH,SAAS,CAACC,GAAG,GAAGC,QAAQ,CAACD,GAAG;EAC5B,IAAI,OAAOD,SAAS,CAACG,SAAS,KAAK,QAAQ,EAAE;IAC3C,IAAI;MACF;MACA;MACAH,SAAS,CAACG,SAAS,GAAG,cAAc;IACtC,CAAC,CAAC,MAAM;MACN;IAAA;EAEJ;AACF;AAEAC,MAAM,CAACC,iBAAiB,GACtBD,MAAM,CAACC,iBAAiB,KACvB,CAAC,GAAGC,MAA4C,KAC/C,IAAIC,OAAO,CAAEC,OAAO,IAAKA,OAAO,CAACN,QAAQ,CAACG,iBAAiB,CAAC,GAAGC,MAAM,CAAC,CAAC,CAAC,CAAC","ignoreList":[]}
+{"version":3,"names":["registerWebGPUForReanimated","WebGPUModule","default","install","navigator","gpu","RNWebGPU","userAgent","global","createImageBitmap","bind"],"sourceRoot":"../../../src","sources":["main/index.tsx"],"mappings":"AAAA,SAASA,2BAA2B,QAAQ,aAAa;AACzD,OAAOC,YAAY,MAAM,uBAAuB;AAEhD,cAAc,WAAW;AACzB,cAAc,cAAc;AAC5B,cAAc,8BAA8B;AAC5C,cAAc,UAAU;AAExB,SAASC,OAAO,IAAID,YAAY,QAAQ,uBAAuB;AAE/DA,YAAY,CAACE,OAAO,CAAC,CAAC;AAEtBH,2BAA2B,CAAC,CAAC;AAE7B,IAAI,CAACI,SAAS,EAAE;EACd;EACAA,SAAS,GAAG;IACVC,GAAG,EAAEC,QAAQ,CAACD,GAAG;IACjBE,SAAS,EAAE;EACb,CAAC;AACH,CAAC,MAAM;EACLH,SAAS,CAACC,GAAG,GAAGC,QAAQ,CAACD,GAAG;EAC5B,IAAI,OAAOD,SAAS,CAACG,SAAS,KAAK,QAAQ,EAAE;IAC3C,IAAI;MACF;MACA;MACAH,SAAS,CAACG,SAAS,GAAG,cAAc;IACtC,CAAC,CAAC,MAAM;MACN;IAAA;EAEJ;AACF;AAEAC,MAAM,CAACC,iBAAiB,GACtBD,MAAM,CAACC,iBAAiB,IAAIH,QAAQ,CAACG,iBAAiB,CAACC,IAAI,CAACJ,QAAQ,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.2",
+  "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({

package/src/main/index.tsx

@@ -32,6 +32,4 @@ if (!navigator) {
 }
 
 global.createImageBitmap =
-  global.createImageBitmap ??
-  ((...params: Parameters<typeof createImageBitmap>) =>
-    new Promise((resolve) => resolve(RNWebGPU.createImageBitmap(...params))));
+  global.createImageBitmap ?? RNWebGPU.createImageBitmap.bind(RNWebGPU);