react-native-wgpu 0.5.5 → 0.5.6

package/android/CMakeLists.txt

@@ -2,7 +2,8 @@ cmake_minimum_required(VERSION 3.4.1)
 project(RNWGPU)
 
 set (CMAKE_VERBOSE_MAKEFILE ON)
-set (CMAKE_CXX_STANDARD 17)
+set (CMAKE_CXX_STANDARD 20)
+set (CMAKE_CXX_STANDARD_REQUIRED True)
 
 set (PACKAGE_NAME "react-native-wgpu")
 

package/android/build.gradle

@@ -71,7 +71,7 @@ android {
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", "true"
     externalNativeBuild {
       cmake {
-        cppFlags "-fexceptions", "-frtti", "-std=c++1y", "-DONANDROID"
+        cppFlags "-fexceptions", "-frtti", "-DONANDROID"
         abiFilters (*reactNativeArchitectures())
         arguments '-DANDROID_STL=c++_shared',
           "-DNODE_MODULES_DIR=${nodeModules}",

package/android/cpp/AndroidPlatformContext.h

@@ -23,6 +23,43 @@ class AndroidPlatformContext : public PlatformContext {
 private:
   jobject _blobModule;
 
+  std::vector<uint8_t> resolveBlob(JNIEnv *env, const std::string &blobId,
+                                   double offset, double size) {
+    if (!_blobModule) {
+      throw std::runtime_error("BlobModule instance is null");
+    }
+
+    jclass blobModuleClass = env->GetObjectClass(_blobModule);
+    if (!blobModuleClass) {
+      throw std::runtime_error("Couldn't find BlobModule class");
+    }
+
+    jmethodID resolveMethod = env->GetMethodID(blobModuleClass, "resolve",
+                                               "(Ljava/lang/String;II)[B");
+    env->DeleteLocalRef(blobModuleClass);
+
+    if (!resolveMethod) {
+      throw std::runtime_error("Couldn't find resolve method in BlobModule");
+    }
+
+    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) {
+      throw std::runtime_error("Couldn't retrieve blob data");
+    }
+
+    jsize len = env->GetArrayLength(blobData);
+    std::vector<uint8_t> data(len);
+    env->GetByteArrayRegion(blobData, 0, len,
+                            reinterpret_cast<jbyte *>(data.data()));
+    env->DeleteLocalRef(blobData);
+    return data;
+  }
+
 public:
   explicit AndroidPlatformContext(jobject blobModule)
       : _blobModule(blobModule) {}
@@ -52,188 +89,116 @@ public:
       throw std::runtime_error("Couldn't get JNI environment");
     }
 
-    // Use the BlobModule instance from _blobModule
-    if (!_blobModule) {
-      throw std::runtime_error("BlobModule instance is null");
-    }
+    auto data = resolveBlob(env, blobId, offset, size);
+    return createImageBitmapFromData(data);
+  }
 
-    // Get the resolve method ID
-    jclass blobModuleClass = env->GetObjectClass(_blobModule);
-    if (!blobModuleClass) {
-      throw std::runtime_error("Couldn't find BlobModule class");
-    }
+  void createImageBitmapAsync(
+      std::string blobId, double offset, double size,
+      std::function<void(ImageData)> onSuccess,
+      std::function<void(std::string)> onError) override {
+    std::thread([this, blobId = std::move(blobId), offset, size,
+                 onSuccess = std::move(onSuccess),
+                 onError = std::move(onError)]() {
+      jni::Environment::ensureCurrentThreadIsAttached();
+      try {
+        JNIEnv *env = facebook::jni::Environment::current();
+        if (!env) {
+          throw std::runtime_error("Couldn't get JNI environment");
+        }
+        auto data = resolveBlob(env, blobId, offset, size);
+        auto result = createImageBitmapFromData(data);
+        onSuccess(std::move(result));
+      } catch (const std::exception &e) {
+        onError(e.what());
+      }
+    }).detach();
+  }
 
-    jmethodID resolveMethod = env->GetMethodID(blobModuleClass, "resolve",
-                                               "(Ljava/lang/String;II)[B");
-    if (!resolveMethod) {
-      throw std::runtime_error("Couldn't find resolve method in BlobModule");
-    }
+  ImageData createImageBitmapFromData(std::span<const uint8_t> data) override {
+    jni::Environment::ensureCurrentThreadIsAttached();
 
-    // 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);
+    JNIEnv *env = facebook::jni::Environment::current();
+    if (!env) {
+      throw std::runtime_error("Couldn't get JNI environment");
+    }
 
-    if (!blobData) {
-      throw std::runtime_error("Couldn't retrieve blob data");
+    // Create jbyteArray from the raw bytes
+    jbyteArray byteArray = env->NewByteArray(static_cast<jsize>(data.size()));
+    if (!byteArray) {
+      throw std::runtime_error("Couldn't allocate byte array");
     }
+    env->SetByteArrayRegion(byteArray, 0, static_cast<jsize>(data.size()),
+                            reinterpret_cast<const jbyte *>(data.data()));
 
-    // Create a Bitmap from the blob data
+    // Decode via BitmapFactory
     jclass bitmapFactoryClass =
         env->FindClass("android/graphics/BitmapFactory");
+    if (!bitmapFactoryClass) {
+      env->DeleteLocalRef(byteArray);
+      throw std::runtime_error("Couldn't find BitmapFactory class");
+    }
     jmethodID decodeByteArrayMethod =
         env->GetStaticMethodID(bitmapFactoryClass, "decodeByteArray",
                                "([BII)Landroid/graphics/Bitmap;");
-    jint blobLength = env->GetArrayLength(blobData);
+    if (!decodeByteArrayMethod) {
+      env->DeleteLocalRef(byteArray);
+      env->DeleteLocalRef(bitmapFactoryClass);
+      throw std::runtime_error("Couldn't find decodeByteArray method");
+    }
+    jint length = static_cast<jint>(data.size());
     jobject bitmap = env->CallStaticObjectMethod(
-        bitmapFactoryClass, decodeByteArrayMethod, blobData, 0, blobLength);
+        bitmapFactoryClass, decodeByteArrayMethod, byteArray, 0, length);
+    env->DeleteLocalRef(bitmapFactoryClass);
 
     if (!bitmap) {
-      env->DeleteLocalRef(blobData);
+      env->DeleteLocalRef(byteArray);
       throw std::runtime_error("Couldn't decode image");
     }
 
-    // Get bitmap info
     AndroidBitmapInfo bitmapInfo;
     if (AndroidBitmap_getInfo(env, bitmap, &bitmapInfo) !=
         ANDROID_BITMAP_RESULT_SUCCESS) {
-      env->DeleteLocalRef(blobData);
+      env->DeleteLocalRef(byteArray);
       env->DeleteLocalRef(bitmap);
       throw std::runtime_error("Couldn't get bitmap info");
     }
 
-    // Lock the bitmap pixels
     void *bitmapPixels;
     if (AndroidBitmap_lockPixels(env, bitmap, &bitmapPixels) !=
         ANDROID_BITMAP_RESULT_SUCCESS) {
-      env->DeleteLocalRef(blobData);
+      env->DeleteLocalRef(byteArray);
       env->DeleteLocalRef(bitmap);
       throw std::runtime_error("Couldn't lock bitmap pixels");
     }
 
-    // Copy the bitmap data
-    std::vector<uint8_t> imageData(bitmapInfo.height * bitmapInfo.stride);
-    memcpy(imageData.data(), bitmapPixels, imageData.size());
+    ImageData result;
+    result.width = static_cast<int>(bitmapInfo.width);
+    result.height = static_cast<int>(bitmapInfo.height);
+    result.data.resize(bitmapInfo.height * bitmapInfo.stride);
+    memcpy(result.data.data(), bitmapPixels, result.data.size());
 
-    // Unlock the bitmap pixels
     AndroidBitmap_unlockPixels(env, bitmap);
 
-    // Clean up JNI references
-    env->DeleteLocalRef(blobData);
+    env->DeleteLocalRef(byteArray);
     env->DeleteLocalRef(bitmap);
 
-    ImageData result;
-    result.width = static_cast<int>(bitmapInfo.width);
-    result.height = static_cast<int>(bitmapInfo.height);
-    result.data = imageData;
     return result;
   }
 
-  void createImageBitmapAsync(
-      std::string blobId, double offset, double size,
-      std::function<void(ImageData)> onSuccess,
+  void createImageBitmapFromDataAsync(
+      std::span<const uint8_t> data, 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,
+    std::thread([this, ownedData = std::vector<uint8_t>(data.begin(), data.end()),
                  onSuccess = std::move(onSuccess),
-                 onError = std::move(onError)]() {
+                 onError = std::move(onError)]() mutable {
       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;
+      try {
+        auto result = createImageBitmapFromData(ownedData);
+        onSuccess(std::move(result));
+      } catch (const std::exception &e) {
+        onError(e.what());
       }
-
-      // 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();
   }
 };

package/apple/ApplePlatformContext.h

@@ -20,6 +20,12 @@ public:
       std::string blobId, double offset, double size,
       std::function<void(ImageData)> onSuccess,
       std::function<void(std::string)> onError) override;
+
+  ImageData createImageBitmapFromData(std::span<const uint8_t> data) override;
+
+  void createImageBitmapFromDataAsync(
+      std::span<const uint8_t> data, std::function<void(ImageData)> onSuccess,
+      std::function<void(std::string)> onError) override;
 };
 
 } // namespace rnwgpu

package/apple/ApplePlatformContext.mm

@@ -39,6 +39,10 @@ wgpu::Surface ApplePlatformContext::makeSurface(wgpu::Instance instance,
   return instance.CreateSurface(&surfaceDescriptor);
 }
 
+static std::span<const uint8_t> nsDataToSpan(NSData *data) {
+  return {static_cast<const uint8_t *>(data.bytes), data.length};
+}
+
 ImageData ApplePlatformContext::createImageBitmap(std::string blobId,
                                                   double offset, double size) {
   RCTBlobManager *blobManager =
@@ -49,13 +53,51 @@ ImageData ApplePlatformContext::createImageBitmap(std::string blobId,
                       size:(long)size];
 
   if (!blobData) {
-    throw std::runtime_error("Couldn't retrive blob data");
+    throw std::runtime_error("Couldn't retrieve blob data");
+  }
+
+  return createImageBitmapFromData(nsDataToSpan(blobData));
+}
+
+void ApplePlatformContext::createImageBitmapAsync(
+    std::string blobId, double offset, double size,
+    std::function<void(ImageData)> onSuccess,
+    std::function<void(std::string)> onError) {
+  // Resolve blob on 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;
   }
 
+  // blobData is alive during this synchronous call;
+  // createImageBitmapFromDataAsync copies the span before dispatching
+  createImageBitmapFromDataAsync(nsDataToSpan(blobData), std::move(onSuccess),
+                                 std::move(onError));
+}
+
+ImageData ApplePlatformContext::createImageBitmapFromData(
+    std::span<const uint8_t> data) {
+  // This avoids a copy by assuming the UIImage/NSImage constructors
+  // decode `nsData` eagerly before the memory for the wrapped `data`
+  // is freed.
+  //
+  // Since we get the `CGImageRef` from `image` and then throw
+  // it away, that's a fairly safe assumption.
+  NSData *nsData = [NSData dataWithBytesNoCopy:const_cast<uint8_t *>(data.data())
+                                        length:data.size()
+                                  freeWhenDone:NO];
+
 #if !TARGET_OS_OSX
-  UIImage *image = [UIImage imageWithData:blobData];
+  UIImage *image = [UIImage imageWithData:nsData];
 #else
-  NSImage *image = [[NSImage alloc] initWithData:blobData];
+  NSImage *image = [[NSImage alloc] initWithData:nsData];
 #endif
   if (!image) {
     throw std::runtime_error("Couldn't decode image");
@@ -72,94 +114,42 @@ ImageData ApplePlatformContext::createImageBitmap(std::string blobId,
   size_t height = CGImageGetHeight(cgImage);
   size_t bitsPerComponent = 8;
   size_t bytesPerRow = width * 4;
-  std::vector<uint8_t> imageData(height * bytesPerRow);
+
+  ImageData result;
+  result.width = static_cast<int>(width);
+  result.height = static_cast<int>(height);
+  result.data.resize(height * bytesPerRow);
+  result.format = wgpu::TextureFormat::RGBA8Unorm;
 
   CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
   CGContextRef context = CGBitmapContextCreate(
-      imageData.data(), width, height, bitsPerComponent, bytesPerRow,
+      result.data.data(), width, height, bitsPerComponent, bytesPerRow,
       colorSpace, kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
 
   CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgImage);
 
-  // Now imageData contains a copy of the bitmap data
-
   CGContextRelease(context);
   CGColorSpaceRelease(colorSpace);
 
-  // Use the copied data
-  ImageData result;
-  result.width = static_cast<int>(width);
-  result.height = static_cast<int>(height);
-  result.data = imageData;
-  result.format = wgpu::TextureFormat::RGBA8Unorm;
   return result;
 }
 
-void ApplePlatformContext::createImageBitmapAsync(
-    std::string blobId, double offset, double size,
-    std::function<void(ImageData)> onSuccess,
+void ApplePlatformContext::createImageBitmapFromDataAsync(
+    std::span<const uint8_t> data, 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];
+  // Copy span data into shared_ptr so the dispatch_async block owns the memory
+  auto ownedData =
+      std::make_shared<std::vector<uint8_t>>(data.begin(), data.end());
 
-  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;
+          try {
+            auto result = createImageBitmapFromData(*ownedData);
+            onSuccess(std::move(result));
+          } catch (const std::exception &e) {
+            onError(e.what());
           }
-
-#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));
         }
       });
 }

package/cpp/rnwgpu/PlatformContext.h

@@ -2,6 +2,7 @@
 
 #include <functional>
 #include <memory>
+#include <span>
 #include <string>
 #include <vector>
 
@@ -31,6 +32,13 @@ public:
       std::string blobId, double offset, double size,
       std::function<void(ImageData)> onSuccess,
       std::function<void(std::string)> onError) = 0;
+
+  // Create ImageBitmap from raw encoded image bytes (PNG/JPEG/etc.)
+  virtual ImageData createImageBitmapFromData(std::span<const uint8_t> data) = 0;
+
+  virtual void createImageBitmapFromDataAsync(
+      std::span<const uint8_t> data, std::function<void(ImageData)> onSuccess,
+      std::function<void(std::string)> onError) = 0;
 };
 
 } // namespace rnwgpu

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -79,13 +79,73 @@ public:
                                const jsi::Value & /*thisVal*/,
                                const jsi::Value *args, size_t count) {
     if (count < 1) {
-      throw jsi::JSError(runtime, "createImageBitmap requires a Blob argument");
+      throw jsi::JSError(runtime,
+                         "createImageBitmap requires a Blob or ArrayBuffer "
+                         "argument");
     }
 
-    auto blob =
-        JSIConverter<std::shared_ptr<Blob>>::fromJSI(runtime, args[0], false);
     auto platformContext = _platformContext;
     auto callInvoker = _callInvoker;
+
+    // Check if the argument is an ArrayBuffer or ArrayBufferView
+    // (TypedArray / DataView)
+    if (args[0].isObject()) {
+      auto obj = args[0].getObject(runtime);
+
+      std::span<const uint8_t> data;
+
+      if (obj.isArrayBuffer(runtime)) {
+        // Plain ArrayBuffer — use the full buffer
+        const auto &ab = obj.getArrayBuffer(runtime);
+        data = {ab.data(runtime), ab.size(runtime)};
+      } else if (obj.hasProperty(runtime, "buffer")) {
+        // TypedArray or DataView — respect byteOffset/byteLength
+        auto bufferVal = obj.getProperty(runtime, "buffer");
+        if (bufferVal.isObject() &&
+            bufferVal.getObject(runtime).isArrayBuffer(runtime)) {
+          const auto &ab =
+              bufferVal.getObject(runtime).getArrayBuffer(runtime);
+          auto byteOffset = static_cast<size_t>(
+              obj.getProperty(runtime, "byteOffset").asNumber());
+          auto byteLength = static_cast<size_t>(
+              obj.getProperty(runtime, "byteLength").asNumber());
+          data = {ab.data(runtime) + byteOffset, byteLength};
+        }
+      }
+
+      if (!data.empty()) {
+        // Copy bytes on the JS thread — the ArrayBuffer pointer is into
+        // JS-owned memory that can be GC'd
+        std::vector<uint8_t> dataCopy(data.begin(), data.end());
+
+        return Promise::createPromise(
+            runtime,
+            [platformContext, callInvoker,
+             dataCopy = std::move(dataCopy)](
+                jsi::Runtime & /*runtime*/,
+                std::shared_ptr<Promise> promise) mutable {
+              platformContext->createImageBitmapFromDataAsync(
+                  dataCopy,
+                  [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); });
+                  });
+            });
+      }
+    }
+
+    // Fall through to existing Blob path
+    auto blob =
+        JSIConverter<std::shared_ptr<Blob>>::fromJSI(runtime, args[0], false);
     std::string blobId = blob->blobId;
     double offset = blob->offset;
     double size = blob->size;

package/lib/typescript/src/index.d.ts

@@ -13,5 +13,6 @@ declare global {
         DecodeToUTF8: (buffer: NodeJS.ArrayBufferView | ArrayBuffer) => string;
         createImageBitmap: typeof createImageBitmap;
     };
+    function createImageBitmap(image: ArrayBuffer | ArrayBufferView): Promise<ImageBitmap>;
 }
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE7D,cAAc,QAAQ,CAAC;AAEvB,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,SAAS;QACjB,GAAG,EAAE,GAAG,CAAC;KACV;IAED,IAAI,SAAS,EAAE,SAAS,CAAC;IAEzB,IAAI,QAAQ,EAAE;QACZ,GAAG,EAAE,GAAG,CAAC;QACT,MAAM,EAAE,OAAO,CAAC;QAChB,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,YAAY,CAAC;QACtD,uBAAuB,EAAE,CACvB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,KACX,eAAe,CAAC;QACrB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,eAAe,GAAG,WAAW,KAAK,MAAM,CAAC;QACvE,iBAAiB,EAAE,OAAO,iBAAiB,CAAC;KAC7C,CAAC;CACH"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE7D,cAAc,QAAQ,CAAC;AAEvB,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,SAAS;QACjB,GAAG,EAAE,GAAG,CAAC;KACV;IAED,IAAI,SAAS,EAAE,SAAS,CAAC;IAEzB,IAAI,QAAQ,EAAE;QACZ,GAAG,EAAE,GAAG,CAAC;QACT,MAAM,EAAE,OAAO,CAAC;QAChB,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,YAAY,CAAC;QACtD,uBAAuB,EAAE,CACvB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,KACX,eAAe,CAAC;QACrB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,eAAe,GAAG,WAAW,KAAK,MAAM,CAAC;QACvE,iBAAiB,EAAE,OAAO,iBAAiB,CAAC;KAC7C,CAAC;IAGF,SAAS,iBAAiB,CACxB,KAAK,EAAE,WAAW,GAAG,eAAe,GACnC,OAAO,CAAC,WAAW,CAAC,CAAC;CACzB"}

package/package.json

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

package/react-native-wgpu.podspec

@@ -35,7 +35,7 @@ Pod::Spec.new do |s|
     s.pod_target_xcconfig    = {
         "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/boost\" \"$(PODS_TARGET_SRCROOT)/cpp\"",
         "OTHER_CPLUSPLUSFLAGS" => "-DFOLLY_NO_CONFIG -DFOLLY_MOBILE=1 -DFOLLY_USE_LIBCPP=1",
-        "CLANG_CXX_LANGUAGE_STANDARD" => "c++17"
+        "CLANG_CXX_LANGUAGE_STANDARD" => "c++20"
     }
     s.dependency "React-RCTFabric"
     s.dependency "React-Codegen"

package/src/index.tsx

@@ -23,4 +23,9 @@ declare global {
     DecodeToUTF8: (buffer: NodeJS.ArrayBufferView | ArrayBuffer) => string;
     createImageBitmap: typeof createImageBitmap;
   };
+
+  // Extend createImageBitmap to accept ArrayBuffer/TypedArray (encoded image bytes)
+  function createImageBitmap(
+    image: ArrayBuffer | ArrayBufferView,
+  ): Promise<ImageBitmap>;
 }