react-native-webgpu 0.6.2 → 0.6.4

package/android/cpp/AndroidPlatformContext.h

@@ -179,6 +179,9 @@ public:
     result.height = static_cast<int>(bitmapInfo.height);
     result.data.resize(bitmapInfo.height * bitmapInfo.stride);
     memcpy(result.data.data(), bitmapPixels, result.data.size());
+    // BitmapFactory hands back premultiplied ARGB_8888 pixels; createImageBitmap
+    // converts to the representation requested by premultiplyAlpha.
+    result.premultiplied = true;
 
     AndroidBitmap_unlockPixels(env, bitmap);
 

package/apple/ApplePlatformContext.mm

@@ -4,6 +4,7 @@
 
 #import <AVFoundation/AVFoundation.h>
 #import <CoreVideo/CoreVideo.h>
+#import <ImageIO/ImageIO.h>
 #import <React/RCTBlobManager.h>
 #import <React/RCTBridge+Private.h>
 #import <ReactCommon/RCTTurboModule.h>
@@ -88,36 +89,32 @@ void ApplePlatformContext::createImageBitmapAsync(
 
 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.
+  // All formats are decoded through ImageIO. Apple's imaging stack always
+  // premultiplies alpha at decode, so the result is flagged premultiplied and
+  // createImageBitmap / copyExternalImageToTexture convert from there. This
+  // means premultiplyAlpha "none" is a lossy round trip for low-alpha pixels
+  // (as it is on Android); the snapshot suites compare with pixelmatch
+  // tolerance to absorb it.
   NSData *nsData =
       [NSData dataWithBytesNoCopy:const_cast<uint8_t *>(data.data())
                            length:data.size()
                      freeWhenDone:NO];
 
-#if !TARGET_OS_OSX
-  UIImage *image = [UIImage imageWithData:nsData];
-#else
-  NSImage *image = [[NSImage alloc] initWithData:nsData];
-#endif
-  if (!image) {
+  CGImageSourceRef imageSource =
+      CGImageSourceCreateWithData((__bridge CFDataRef)nsData, NULL);
+  if (imageSource == NULL) {
+    throw std::runtime_error("Couldn't create image source");
+  }
+  NSDictionary *decodeOptions = @{(id)kCGImageSourceShouldCache : @NO};
+  CGImageRef cgImage = CGImageSourceCreateImageAtIndex(
+      imageSource, 0, (__bridge CFDictionaryRef)decodeOptions);
+  CFRelease(imageSource);
+  if (cgImage == NULL) {
     throw std::runtime_error("Couldn't decode image");
   }
 
-#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;
 
   ImageData result;
@@ -126,16 +123,18 @@ ApplePlatformContext::createImageBitmapFromData(std::span<const uint8_t> data) {
   result.data.resize(height * bytesPerRow);
   result.format = wgpu::TextureFormat::RGBA8Unorm;
 
+  // The draw premultiplies alpha; flag the result premultiplied so
+  // createImageBitmap and copyExternalImageToTexture convert consistently.
   CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
   CGContextRef context = CGBitmapContextCreate(
-      result.data.data(), width, height, bitsPerComponent, bytesPerRow,
-      colorSpace, kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
-
+      result.data.data(), width, height, 8, bytesPerRow, colorSpace,
+      kCGImageAlphaPremultipliedLast | kCGBitmapByteOrder32Big);
   CGContextDrawImage(context, CGRectMake(0, 0, width, height), cgImage);
-
   CGContextRelease(context);
   CGColorSpaceRelease(colorSpace);
+  CGImageRelease(cgImage);
 
+  result.premultiplied = true;
   return result;
 }
 

package/cpp/rnwgpu/PlatformContext.h

@@ -16,6 +16,13 @@ struct ImageData {
   size_t width;
   size_t height;
   wgpu::TextureFormat format;
+  // Whether the RGB channels are premultiplied by alpha. Each platform decoder
+  // records the representation it produced; createImageBitmap then converts to
+  // the representation requested through premultiplyAlpha, and
+  // copyExternalImageToTexture converts again to match the destination's
+  // premultipliedAlpha. Defaults to true because most native decoders
+  // (CoreGraphics, Android Bitmap) hand back premultiplied pixels.
+  bool premultiplied = true;
 };
 
 // Pixel layout of a VideoFrame. Determines whether the underlying surface is

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -128,26 +128,40 @@ void GPUQueue::copyExternalImageToTexture(
     throw std::runtime_error("Invalid input for GPUQueue::writeTexture()");
   }
 
-  if (source->flipY.value_or(false)) {
-    // Calculate the row size and total size
+  const bool flipY = source->flipY.value_or(false);
+  // premultipliedAlpha defaults to false per the WebGPU spec: an untagged
+  // destination expects straight alpha. Convert only when the ImageBitmap's
+  // representation differs, using the same rounding as the reference client.
+  const bool sourcePremultiplied = source->source->getPremultiplied();
+  const bool destinationPremultiplied =
+      destination->premultipliedAlpha.value_or(false);
+  const bool needsAlphaConversion =
+      bytesPerPixel == 4 && sourcePremultiplied != destinationPremultiplied;
+
+  if (flipY || needsAlphaConversion) {
     uint32_t rowSize = bytesPerPixel * source->source->getWidth();
     uint32_t totalSize = source->source->getSize();
 
-    // Create a new buffer for the flipped data
-    std::vector<uint8_t> flippedData(totalSize);
-
-    // Flip the data vertically
-    for (uint32_t row = 0; row < source->source->getHeight(); ++row) {
-      std::memcpy(flippedData.data() +
-                      (source->source->getHeight() - 1 - row) * rowSize,
-                  static_cast<const uint8_t *>(source->source->getData()) +
-                      row * rowSize,
-                  rowSize);
+    // Stage a mutable copy so flipping and/or alpha conversion never touch the
+    // ImageBitmap's backing store.
+    std::vector<uint8_t> staged(totalSize);
+    const uint8_t *src =
+        static_cast<const uint8_t *>(source->source->getData());
+    if (flipY) {
+      for (uint32_t row = 0; row < source->source->getHeight(); ++row) {
+        std::memcpy(staged.data() +
+                        (source->source->getHeight() - 1 - row) * rowSize,
+                    src + row * rowSize, rowSize);
+      }
+    } else {
+      std::memcpy(staged.data(), src, totalSize);
+    }
+    if (needsAlphaConversion) {
+      convertAlpha(staged.data(), totalSize, sourcePremultiplied,
+                   destinationPremultiplied);
     }
-    // Use the flipped data for writing to texture
-    _instance.WriteTexture(&dst, flippedData.data(), totalSize, &layout, &sz);
+    _instance.WriteTexture(&dst, staged.data(), totalSize, &layout, &sz);
   } else {
-
     _instance.WriteTexture(&dst, source->source->getData(),
                            source->source->getSize(), &layout, &sz);
   }

package/cpp/rnwgpu/api/ImageBitmap.h

@@ -11,6 +11,33 @@ namespace rnwgpu {
 
 namespace jsi = facebook::jsi;
 
+// Convert RGBA8 pixel data in place between straight and premultiplied alpha.
+// Uses the same integer rounding as the web reference polyfill in the test
+// harness (setup.ts, convertAlpha) so the native result is bit-exact with the
+// dawn.node client. A no-op when the source and destination representations
+// already match.
+inline void convertAlpha(uint8_t *data, size_t byteLength,
+                         bool sourcePremultiplied,
+                         bool destinationPremultiplied) {
+  if (sourcePremultiplied == destinationPremultiplied) {
+    return;
+  }
+  for (size_t i = 0; i + 3 < byteLength; i += 4) {
+    const uint32_t alpha = data[i + 3];
+    for (size_t channel = 0; channel < 3; channel++) {
+      const uint32_t value = data[i + channel];
+      if (destinationPremultiplied) {
+        data[i + channel] = static_cast<uint8_t>((value * alpha + 127) / 255);
+      } else if (alpha == 0) {
+        data[i + channel] = 0;
+      } else {
+        const uint32_t straight = (value * 255 + (alpha >> 1)) / alpha;
+        data[i + channel] = static_cast<uint8_t>(straight > 255 ? 255 : straight);
+      }
+    }
+  }
+}
+
 class ImageBitmap : public NativeObject<ImageBitmap> {
 public:
   static constexpr const char *CLASS_NAME = "ImageBitmap";
@@ -26,6 +53,11 @@ public:
 
   size_t getSize() { return _imageData.data.size(); }
 
+  // Whether the stored pixels are premultiplied by alpha. Used by
+  // copyExternalImageToTexture to decide whether a conversion to the
+  // destination's premultipliedAlpha representation is needed.
+  bool getPremultiplied() { return _imageData.premultiplied; }
+
   void close() {
     _imageData.data.clear();
     _imageData.data.shrink_to_fit();

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -90,6 +90,41 @@ public:
     auto platformContext = _platformContext;
     auto callInvoker = _callInvoker;
 
+    // Resolve the requested alpha representation from the ImageBitmapOptions.
+    // The options bag is the second argument for createImageBitmap(source,
+    // options) and the sixth for the crop-rect overload createImageBitmap(
+    // source, sx, sy, sw, sh, options). premultiplyAlpha defaults to
+    // "default", which (like "premultiply") stores premultiplied pixels; only
+    // "none" keeps straight alpha. The other options (crop rect, resize,
+    // imageOrientation, colorSpaceConversion) are not yet implemented natively.
+    bool wantPremultiplied = true;
+    const jsi::Value *optionsArg = nullptr;
+    if (count >= 2 && args[1].isObject()) {
+      optionsArg = &args[1];
+    } else if (count >= 6 && args[5].isObject()) {
+      optionsArg = &args[5];
+    }
+    if (optionsArg != nullptr) {
+      auto options = optionsArg->getObject(runtime);
+      if (options.hasProperty(runtime, "premultiplyAlpha")) {
+        auto value = options.getProperty(runtime, "premultiplyAlpha");
+        if (value.isString() &&
+            value.getString(runtime).utf8(runtime) == "none") {
+          wantPremultiplied = false;
+        }
+      }
+    }
+
+    // Bring the decoded pixels into the representation requested via
+    // premultiplyAlpha before wrapping them in an ImageBitmap.
+    auto toRequestedAlpha = [wantPremultiplied](ImageData &imageData) {
+      if (imageData.premultiplied != wantPremultiplied) {
+        convertAlpha(imageData.data.data(), imageData.data.size(),
+                     imageData.premultiplied, wantPremultiplied);
+        imageData.premultiplied = wantPremultiplied;
+      }
+    };
+
     // Check if the argument is an ArrayBuffer or ArrayBufferView
     // (TypedArray / DataView). Only a real buffer source is run through the
     // ArrayBuffer converter, which validates byteOffset/byteLength against the
@@ -119,12 +154,14 @@ public:
 
         return Promise::createPromise(
             runtime,
-            [platformContext, callInvoker, dataCopy = std::move(dataCopy)](
+            [platformContext, callInvoker, toRequestedAlpha,
+             dataCopy = std::move(dataCopy)](
                 jsi::Runtime & /*runtime*/,
                 std::shared_ptr<Promise> promise) mutable {
               platformContext->createImageBitmapFromDataAsync(
                   dataCopy,
-                  [callInvoker, promise](ImageData imageData) {
+                  [callInvoker, promise, toRequestedAlpha](ImageData imageData) {
+                    toRequestedAlpha(imageData);
                     auto imageBitmap = std::make_shared<ImageBitmap>(imageData);
                     callInvoker->invokeAsync([promise, imageBitmap]() {
                       promise->resolve(
@@ -149,11 +186,12 @@ public:
 
     return Promise::createPromise(
         runtime,
-        [platformContext, callInvoker, blobId, offset,
+        [platformContext, callInvoker, toRequestedAlpha, blobId, offset,
          size](jsi::Runtime & /*runtime*/, std::shared_ptr<Promise> promise) {
           platformContext->createImageBitmapAsync(
               blobId, offset, size,
-              [callInvoker, promise](ImageData imageData) {
+              [callInvoker, promise, toRequestedAlpha](ImageData imageData) {
+                toRequestedAlpha(imageData);
                 auto imageBitmap = std::make_shared<ImageBitmap>(imageData);
                 callInvoker->invokeAsync([promise, imageBitmap]() {
                   promise->resolve(

package/cpp/webgpu/webgpu.h

@@ -2409,6 +2409,7 @@ typedef struct WGPUSharedBufferMemoryBeginAccessDescriptor {
     WGPUBool initialized;
     size_t fenceCount;
     WGPUSharedFence const * fences;
+    size_t signaledValueCount;
     uint64_t const * signaledValues;
 } WGPUSharedBufferMemoryBeginAccessDescriptor WGPU_STRUCTURE_ATTRIBUTE;
 
@@ -2417,6 +2418,7 @@ typedef struct WGPUSharedBufferMemoryBeginAccessDescriptor {
     /*.initialized=*/WGPU_FALSE _wgpu_COMMA \
     /*.fenceCount=*/0 _wgpu_COMMA \
     /*.fences=*/NULL _wgpu_COMMA \
+    /*.signaledValueCount=*/0 _wgpu_COMMA \
     /*.signaledValues=*/NULL _wgpu_COMMA \
 })
 
@@ -2441,6 +2443,7 @@ typedef struct WGPUSharedBufferMemoryEndAccessState {
     WGPUBool initialized;
     size_t fenceCount;
     WGPUSharedFence const * fences;
+    size_t signaledValueCount;
     uint64_t const * signaledValues;
 } WGPUSharedBufferMemoryEndAccessState WGPU_STRUCTURE_ATTRIBUTE;
 
@@ -2449,6 +2452,7 @@ typedef struct WGPUSharedBufferMemoryEndAccessState {
     /*.initialized=*/WGPU_FALSE _wgpu_COMMA \
     /*.fenceCount=*/0 _wgpu_COMMA \
     /*.fences=*/NULL _wgpu_COMMA \
+    /*.signaledValueCount=*/0 _wgpu_COMMA \
     /*.signaledValues=*/NULL _wgpu_COMMA \
 })
 
@@ -3801,6 +3805,7 @@ typedef struct WGPUSharedTextureMemoryBeginAccessDescriptor {
     WGPUBool initialized;
     size_t fenceCount;
     WGPUSharedFence const * fences;
+    size_t signaledValueCount;
     uint64_t const * signaledValues;
 } WGPUSharedTextureMemoryBeginAccessDescriptor WGPU_STRUCTURE_ATTRIBUTE;
 
@@ -3810,6 +3815,7 @@ typedef struct WGPUSharedTextureMemoryBeginAccessDescriptor {
     /*.initialized=*/WGPU_FALSE _wgpu_COMMA \
     /*.fenceCount=*/0 _wgpu_COMMA \
     /*.fences=*/NULL _wgpu_COMMA \
+    /*.signaledValueCount=*/0 _wgpu_COMMA \
     /*.signaledValues=*/NULL _wgpu_COMMA \
 })
 
@@ -4116,6 +4122,7 @@ typedef struct WGPUSharedTextureMemoryEndAccessState {
     WGPUBool initialized;
     size_t fenceCount;
     WGPUSharedFence const * fences;
+    size_t signaledValueCount;
     uint64_t const * signaledValues;
 } WGPUSharedTextureMemoryEndAccessState WGPU_STRUCTURE_ATTRIBUTE;
 
@@ -4124,6 +4131,7 @@ typedef struct WGPUSharedTextureMemoryEndAccessState {
     /*.initialized=*/WGPU_FALSE _wgpu_COMMA \
     /*.fenceCount=*/0 _wgpu_COMMA \
     /*.fences=*/NULL _wgpu_COMMA \
+    /*.signaledValueCount=*/0 _wgpu_COMMA \
     /*.signaledValues=*/NULL _wgpu_COMMA \
 })
 

package/cpp/webgpu/webgpu_cpp.h

@@ -2887,6 +2887,7 @@ struct SharedBufferMemoryBeginAccessDescriptor {
     Bool initialized;
     size_t fenceCount = 0;
     SharedFence const * fences = nullptr;
+    size_t signaledValueCount = 0;
     uint64_t const * signaledValues = nullptr;
 };
 
@@ -2915,6 +2916,7 @@ struct SharedBufferMemoryEndAccessState {
     Bool const initialized = {};
     size_t const fenceCount = 0;
     SharedFence const * const fences = nullptr;
+    size_t const signaledValueCount = 0;
     uint64_t const * const signaledValues = nullptr;
 
   private:
@@ -3923,6 +3925,7 @@ struct SharedTextureMemoryBeginAccessDescriptor {
     Bool initialized;
     size_t fenceCount;
     SharedFence const * fences = nullptr;
+    size_t signaledValueCount = 0;
     uint64_t const * signaledValues = nullptr;
 };
 
@@ -4166,6 +4169,7 @@ struct SharedTextureMemoryEndAccessState {
     Bool const initialized = {};
     size_t const fenceCount = {};
     SharedFence const * const fences = nullptr;
+    size_t const signaledValueCount = 0;
     uint64_t const * const signaledValues = nullptr;
 
   private:
@@ -4271,7 +4275,7 @@ struct CppFTraitsImpl<CppFT, R(*)(CppArgs...), T> {
     static constexpr bool capturing = false;
 
     static constexpr size_t NumCppArgs = sizeof...(CppArgs);
-    using BaseArgsTuple = decltype([]<std::size_t... Is>(std::index_sequence<Is...>) {
+    using BaseArgsTuple = typename decltype([]<std::size_t... Is>(std::index_sequence<Is...>) {
         return std::type_identity<std::tuple<std::tuple_element_t<Is, std::tuple<CppArgs...>>...>>{};
     }(std::make_index_sequence<std::is_same_v<T, Untyped> ? NumCppArgs : NumCppArgs - 1>{})
     )::type;
@@ -4283,7 +4287,7 @@ struct CppFTraitsImpl<CppFT, R(C::*)(CppArgs...) const, T> {
     static constexpr bool capturing = !std::is_convertible_v<CppFT, PtrT>;
 
     static constexpr size_t NumCppArgs = sizeof...(CppArgs);
-    using BaseArgsTuple = decltype([]<std::size_t... Is>(std::index_sequence<Is...>) {
+    using BaseArgsTuple = typename decltype([]<std::size_t... Is>(std::index_sequence<Is...>) {
         return std::type_identity<std::tuple<std::tuple_element_t<Is, std::tuple<CppArgs...>>...>>{};
     }(std::make_index_sequence<std::is_same_v<T, Untyped> ? NumCppArgs : NumCppArgs - 1>{})
     )::type;
@@ -4487,8 +4491,11 @@ struct CallbackInfoHelper {
                 std::unique_ptr<F> alloc = std::make_unique<F>(std::move(lambda));
                 info.userdata1 = reinterpret_cast<void*>(alloc.release());
             } else {
+                // MSVC <=19.39 doesn't support static_assert(false) and this was fixed in later C++
+                // standards https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2593r1.html
+                constexpr bool kAlwaysFalse = sizeof(F) == 0;
                 static_assert(
-                    false, "capturing lambdas aren't supported for repeatable callbacks"
+                    kAlwaysFalse, "capturing lambdas aren't supported for repeatable callbacks"
                 );
             }
         } else {
@@ -5816,6 +5823,8 @@ static_assert(offsetof(SharedBufferMemoryBeginAccessDescriptor, fenceCount) == o
         "offsetof mismatch for SharedBufferMemoryBeginAccessDescriptor::fenceCount");
 static_assert(offsetof(SharedBufferMemoryBeginAccessDescriptor, fences) == offsetof(WGPUSharedBufferMemoryBeginAccessDescriptor, fences),
         "offsetof mismatch for SharedBufferMemoryBeginAccessDescriptor::fences");
+static_assert(offsetof(SharedBufferMemoryBeginAccessDescriptor, signaledValueCount) == offsetof(WGPUSharedBufferMemoryBeginAccessDescriptor, signaledValueCount),
+        "offsetof mismatch for SharedBufferMemoryBeginAccessDescriptor::signaledValueCount");
 static_assert(offsetof(SharedBufferMemoryBeginAccessDescriptor, signaledValues) == offsetof(WGPUSharedBufferMemoryBeginAccessDescriptor, signaledValues),
         "offsetof mismatch for SharedBufferMemoryBeginAccessDescriptor::signaledValues");
 
@@ -5853,6 +5862,7 @@ SharedBufferMemoryEndAccessState::SharedBufferMemoryEndAccessState(SharedBufferM
     : initialized(rhs.initialized),
             fenceCount(rhs.fenceCount),
             fences(rhs.fences),
+            signaledValueCount(rhs.signaledValueCount),
             signaledValues(rhs.signaledValues){
     Reset(rhs);
 }
@@ -5865,6 +5875,7 @@ SharedBufferMemoryEndAccessState& SharedBufferMemoryEndAccessState::operator=(Sh
     detail::AsNonConstReference(this->initialized) = std::move(rhs.initialized);
     detail::AsNonConstReference(this->fenceCount) = std::move(rhs.fenceCount);
     detail::AsNonConstReference(this->fences) = std::move(rhs.fences);
+    detail::AsNonConstReference(this->signaledValueCount) = std::move(rhs.signaledValueCount);
     detail::AsNonConstReference(this->signaledValues) = std::move(rhs.signaledValues);
     Reset(rhs);
     return *this;
@@ -5883,6 +5894,7 @@ void SharedBufferMemoryEndAccessState::Reset(SharedBufferMemoryEndAccessState& v
     detail::AsNonConstReference(value.initialized) = defaultValue.initialized;
     detail::AsNonConstReference(value.fenceCount) = defaultValue.fenceCount;
     detail::AsNonConstReference(value.fences) = defaultValue.fences;
+    detail::AsNonConstReference(value.signaledValueCount) = defaultValue.signaledValueCount;
     detail::AsNonConstReference(value.signaledValues) = defaultValue.signaledValues;
 }
 
@@ -5900,6 +5912,8 @@ static_assert(offsetof(SharedBufferMemoryEndAccessState, fenceCount) == offsetof
         "offsetof mismatch for SharedBufferMemoryEndAccessState::fenceCount");
 static_assert(offsetof(SharedBufferMemoryEndAccessState, fences) == offsetof(WGPUSharedBufferMemoryEndAccessState, fences),
         "offsetof mismatch for SharedBufferMemoryEndAccessState::fences");
+static_assert(offsetof(SharedBufferMemoryEndAccessState, signaledValueCount) == offsetof(WGPUSharedBufferMemoryEndAccessState, signaledValueCount),
+        "offsetof mismatch for SharedBufferMemoryEndAccessState::signaledValueCount");
 static_assert(offsetof(SharedBufferMemoryEndAccessState, signaledValues) == offsetof(WGPUSharedBufferMemoryEndAccessState, signaledValues),
         "offsetof mismatch for SharedBufferMemoryEndAccessState::signaledValues");
 
@@ -7967,6 +7981,8 @@ static_assert(offsetof(SharedTextureMemoryBeginAccessDescriptor, fenceCount) ==
         "offsetof mismatch for SharedTextureMemoryBeginAccessDescriptor::fenceCount");
 static_assert(offsetof(SharedTextureMemoryBeginAccessDescriptor, fences) == offsetof(WGPUSharedTextureMemoryBeginAccessDescriptor, fences),
         "offsetof mismatch for SharedTextureMemoryBeginAccessDescriptor::fences");
+static_assert(offsetof(SharedTextureMemoryBeginAccessDescriptor, signaledValueCount) == offsetof(WGPUSharedTextureMemoryBeginAccessDescriptor, signaledValueCount),
+        "offsetof mismatch for SharedTextureMemoryBeginAccessDescriptor::signaledValueCount");
 static_assert(offsetof(SharedTextureMemoryBeginAccessDescriptor, signaledValues) == offsetof(WGPUSharedTextureMemoryBeginAccessDescriptor, signaledValues),
         "offsetof mismatch for SharedTextureMemoryBeginAccessDescriptor::signaledValues");
 
@@ -8460,6 +8476,7 @@ SharedTextureMemoryEndAccessState::SharedTextureMemoryEndAccessState(SharedTextu
     : initialized(rhs.initialized),
             fenceCount(rhs.fenceCount),
             fences(rhs.fences),
+            signaledValueCount(rhs.signaledValueCount),
             signaledValues(rhs.signaledValues){
     Reset(rhs);
 }
@@ -8472,6 +8489,7 @@ SharedTextureMemoryEndAccessState& SharedTextureMemoryEndAccessState::operator=(
     detail::AsNonConstReference(this->initialized) = std::move(rhs.initialized);
     detail::AsNonConstReference(this->fenceCount) = std::move(rhs.fenceCount);
     detail::AsNonConstReference(this->fences) = std::move(rhs.fences);
+    detail::AsNonConstReference(this->signaledValueCount) = std::move(rhs.signaledValueCount);
     detail::AsNonConstReference(this->signaledValues) = std::move(rhs.signaledValues);
     Reset(rhs);
     return *this;
@@ -8490,6 +8508,7 @@ void SharedTextureMemoryEndAccessState::Reset(SharedTextureMemoryEndAccessState&
     detail::AsNonConstReference(value.initialized) = defaultValue.initialized;
     detail::AsNonConstReference(value.fenceCount) = defaultValue.fenceCount;
     detail::AsNonConstReference(value.fences) = defaultValue.fences;
+    detail::AsNonConstReference(value.signaledValueCount) = defaultValue.signaledValueCount;
     detail::AsNonConstReference(value.signaledValues) = defaultValue.signaledValues;
 }
 
@@ -8507,6 +8526,8 @@ static_assert(offsetof(SharedTextureMemoryEndAccessState, fenceCount) == offseto
         "offsetof mismatch for SharedTextureMemoryEndAccessState::fenceCount");
 static_assert(offsetof(SharedTextureMemoryEndAccessState, fences) == offsetof(WGPUSharedTextureMemoryEndAccessState, fences),
         "offsetof mismatch for SharedTextureMemoryEndAccessState::fences");
+static_assert(offsetof(SharedTextureMemoryEndAccessState, signaledValueCount) == offsetof(WGPUSharedTextureMemoryEndAccessState, signaledValueCount),
+        "offsetof mismatch for SharedTextureMemoryEndAccessState::signaledValueCount");
 static_assert(offsetof(SharedTextureMemoryEndAccessState, signaledValues) == offsetof(WGPUSharedTextureMemoryEndAccessState, signaledValues),
         "offsetof mismatch for SharedTextureMemoryEndAccessState::signaledValues");
 

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

@@ -37,6 +37,6 @@ declare global {
         destroy(): void;
         readonly yuvToRgbMatrix: number[];
     }
-    function createImageBitmap(image: ArrayBuffer | ArrayBufferView): Promise<ImageBitmap>;
+    function createImageBitmap(image: ArrayBuffer | ArrayBufferView, options?: ImageBitmapOptions): 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":"AACA,OAAO,KAAK,EACV,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACxB,sBAAsB,EACtB,gCAAgC,EAChC,YAAY,EACZ,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAEjB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,gCAAgC,EAChC,oCAAoC,EACpC,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,SAAS,CAAC;AAEjB,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;QAGrB,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;QAC5C,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,eAAe,GAAG,WAAW,KAAK,MAAM,CAAC;QACvE,iBAAiB,EAAE,OAAO,iBAAiB,CAAC;QAC5C,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,gBAAgB,CAAC;QACnD,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,gBAAgB,CAAC;QAI1E,gCAAgC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,gBAAgB,CAAC;QACxE,iBAAiB,EAAE,CACjB,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,sBAAsB,KACjC,WAAW,CAAC;QACjB,kBAAkB,EAAE,MAAM,MAAM,CAAC;KAClC,CAAC;IAEF,UAAU,SAAS;QACjB,yBAAyB,CACvB,UAAU,EAAE,gCAAgC,GAC3C,sBAAsB,CAAC;QAC1B,iBAAiB,CAAC,UAAU,EAAE,wBAAwB,GAAG,cAAc,CAAC;KACzE;IAID,UAAU,mBAAmB;QAC3B,WAAW,CAAC,EAAE,wBAAwB,CAAC;KACxC;IAMD,UAAU,4BAA4B;QACpC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;QAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB;IASD,UAAU,kBAAkB;QAC1B,OAAO,IAAI,IAAI,CAAC;QAShB,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC;KACnC;IAGD,SAAS,iBAAiB,CACxB,KAAK,EAAE,WAAW,GAAG,eAAe,GACnC,OAAO,CAAC,WAAW,CAAC,CAAC;CACzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACxB,sBAAsB,EACtB,gCAAgC,EAChC,YAAY,EACZ,eAAe,EACf,WAAW,EACX,gBAAgB,EAChB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAEjB,cAAc,QAAQ,CAAC;AACvB,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,YAAY,EACV,gBAAgB,EAChB,WAAW,EACX,cAAc,EACd,wBAAwB,EACxB,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EACtB,gCAAgC,EAChC,oCAAoC,EACpC,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,SAAS,CAAC;AAEjB,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;QAGrB,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;QAC5C,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,eAAe,GAAG,WAAW,KAAK,MAAM,CAAC;QACvE,iBAAiB,EAAE,OAAO,iBAAiB,CAAC;QAC5C,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,gBAAgB,CAAC;QACnD,oBAAoB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,gBAAgB,CAAC;QAI1E,gCAAgC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,gBAAgB,CAAC;QACxE,iBAAiB,EAAE,CACjB,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,sBAAsB,KACjC,WAAW,CAAC;QACjB,kBAAkB,EAAE,MAAM,MAAM,CAAC;KAClC,CAAC;IAEF,UAAU,SAAS;QACjB,yBAAyB,CACvB,UAAU,EAAE,gCAAgC,GAC3C,sBAAsB,CAAC;QAC1B,iBAAiB,CAAC,UAAU,EAAE,wBAAwB,GAAG,cAAc,CAAC;KACzE;IAID,UAAU,mBAAmB;QAC3B,WAAW,CAAC,EAAE,wBAAwB,CAAC;KACxC;IAMD,UAAU,4BAA4B;QACpC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;QAC9B,QAAQ,CAAC,EAAE,OAAO,CAAC;KACpB;IASD,UAAU,kBAAkB;QAC1B,OAAO,IAAI,IAAI,CAAC;QAShB,QAAQ,CAAC,cAAc,EAAE,MAAM,EAAE,CAAC;KACnC;IAGD,SAAS,iBAAiB,CACxB,KAAK,EAAE,WAAW,GAAG,eAAe,EACpC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,WAAW,CAAC,CAAC;CACzB"}

package/libs/apple/libwebgpu_dawn.xcframework/Info.plist

@@ -8,7 +8,7 @@
 			<key>BinaryPath</key>
 			<string>libwebgpu_dawn.a</string>
 			<key>LibraryIdentifier</key>
-			<string>macos-arm64_x86_64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libwebgpu_dawn.a</string>
 			<key>SupportedArchitectures</key>
@@ -17,7 +17,9 @@
 				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
-			<string>macos</string>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
@@ -37,7 +39,7 @@
 			<key>BinaryPath</key>
 			<string>libwebgpu_dawn.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>macos-arm64_x86_64</string>
 			<key>LibraryPath</key>
 			<string>libwebgpu_dawn.a</string>
 			<key>SupportedArchitectures</key>
@@ -46,9 +48,7 @@
 				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
-			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
+			<string>macos</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-webgpu",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "React Native WebGPU",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -22,7 +22,8 @@
     "app.plugin.js",
     "plugin/build/**"
   ],
-  "dawn": "chromium/7849",
+  "dawn": "chrome-m150",
+  "dawnCommit": "63f25feec51e9351fb25222b6d5de1af791d7c4f",
   "scripts": {
     "test": "NODE_OPTIONS='--experimental-require-module' jest -i",
     "test:ref": "REFERENCE=true NODE_OPTIONS='--experimental-require-module' jest -i",

package/react-native-webgpu.podspec

@@ -23,7 +23,8 @@ Pod::Spec.new do |s|
 
   # The VideoPlayer API uses AVFoundation / CoreMedia, and shared-texture
   # surfaces use CoreVideo (CVPixelBuffer). Link them so their symbols resolve.
-  s.frameworks = "AVFoundation", "CoreMedia", "CoreVideo"
+  # ImageIO provides CGImageSource, the image decoder behind createImageBitmap.
+  s.frameworks = "AVFoundation", "CoreMedia", "CoreVideo", "ImageIO"
 
   s.pod_target_xcconfig = {
     'HEADER_SEARCH_PATHS' => '$(PODS_TARGET_SRCROOT)/cpp',

package/src/index.tsx

@@ -110,5 +110,6 @@ declare global {
   // Extend createImageBitmap to accept ArrayBuffer/TypedArray (encoded image bytes)
   function createImageBitmap(
     image: ArrayBuffer | ArrayBufferView,
+    options?: ImageBitmapOptions,
   ): Promise<ImageBitmap>;
 }