react-native-webgpu 0.5.11

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/GPUValidationError.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <string>
+
+#include "NativeObject.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class GPUValidationError : public NativeObject<GPUValidationError> {
+public:
+  static constexpr const char *CLASS_NAME = "GPUValidationError";
+
+  explicit GPUValidationError(std::string message)
+      : NativeObject(CLASS_NAME), _message(std::move(message)) {}
+
+public:
+  std::string getBrand() { return CLASS_NAME; }
+  std::string getMessage() { return _message; }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPUValidationError::getBrand);
+    installGetter(runtime, prototype, "message",
+                  &GPUValidationError::getMessage);
+  }
+
+private:
+  std::string _message;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/ImageBitmap.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "NativeObject.h"
+#include "PlatformContext.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class ImageBitmap : public NativeObject<ImageBitmap> {
+public:
+  static constexpr const char *CLASS_NAME = "ImageBitmap";
+
+  explicit ImageBitmap(ImageData &imageData)
+      : NativeObject(CLASS_NAME), _imageData(imageData) {}
+
+  size_t getWidth() { return _imageData.width; }
+
+  size_t getHeight() { return _imageData.height; }
+
+  void *getData() { return _imageData.data.data(); }
+
+  size_t getSize() { return _imageData.data.size(); }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "width", &ImageBitmap::getWidth);
+    installGetter(runtime, prototype, "height", &ImageBitmap::getHeight);
+  }
+
+  size_t getMemoryPressure() override { return getSize(); }
+
+private:
+  ImageData _imageData;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/RNWebGPU.h

@@ -0,0 +1,199 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "NativeObject.h"
+
+#include "Canvas.h"
+#include "GPU.h"
+#include "GPUCanvasContext.h"
+#include "ImageBitmap.h"
+#include "PlatformContext.h"
+
+#include <ReactCommon/CallInvoker.h>
+
+#include "JSIConverter.h"
+#include "Promise.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+struct Blob {
+  std::string blobId;
+  double size;
+  double offset;
+  std::string type;
+  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,
+                    std::shared_ptr<facebook::react::CallInvoker> callInvoker)
+      : NativeObject(CLASS_NAME), _gpu(gpu), _platformContext(platformContext),
+        _callInvoker(callInvoker) {}
+
+  std::shared_ptr<GPU> getGPU() { return _gpu; }
+
+  bool getFabric() { return true; }
+
+  std::shared_ptr<GPUCanvasContext>
+  MakeWebGPUCanvasContext(int contextId, float width, float height) {
+    auto ctx =
+        std::make_shared<GPUCanvasContext>(_gpu, contextId, width, height);
+    return ctx;
+  }
+
+  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 or ArrayBuffer "
+                         "argument");
+    }
+
+    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;
+
+    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) {
+    auto &registry = rnwgpu::SurfaceRegistry::getInstance();
+    auto info = registry.getSurfaceInfo(contextId);
+    if (info == nullptr) {
+      return std::make_shared<Canvas>(nullptr, 0, 0);
+    }
+    auto nativeInfo = info->getNativeInfo();
+    return std::make_shared<Canvas>(nativeInfo.nativeSurface, nativeInfo.width,
+                                    nativeInfo.height);
+  }
+
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "fabric", &RNWebGPU::getFabric);
+    installGetter(runtime, prototype, "gpu", &RNWebGPU::getGPU);
+    installMethod(runtime, prototype, "createImageBitmap",
+                  &RNWebGPU::createImageBitmap);
+    installMethod(runtime, prototype, "getNativeSurface",
+                  &RNWebGPU::getNativeSurface);
+    installMethod(runtime, prototype, "MakeWebGPUCanvasContext",
+                  &RNWebGPU::MakeWebGPUCanvasContext);
+  }
+
+private:
+  std::shared_ptr<GPU> _gpu;
+  std::shared_ptr<PlatformContext> _platformContext;
+  std::shared_ptr<facebook::react::CallInvoker> _callInvoker;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBindGroupDescriptor.h

@@ -0,0 +1,65 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUBindGroupEntry.h"
+#include "GPUBindGroupLayout.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBindGroupDescriptor {
+  std::shared_ptr<GPUBindGroupLayout> layout; // GPUBindGroupLayout
+  std::vector<std::shared_ptr<GPUBindGroupEntry>>
+      entries;                      // Iterable<GPUBindGroupEntry>
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUBindGroupDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBindGroupDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "layout")) {
+        auto prop = value.getProperty(runtime, "layout");
+        result->layout =
+            JSIConverter<std::shared_ptr<GPUBindGroupLayout>>::fromJSI(
+                runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "entries")) {
+        auto prop = value.getProperty(runtime, "entries");
+        result->entries = JSIConverter<
+            std::vector<std::shared_ptr<GPUBindGroupEntry>>>::fromJSI(runtime,
+                                                                      prop,
+                                                                      false);
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBindGroupDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUBindGroupDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBindGroupEntry.h

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <memory>
+#include <variant>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "GPUBufferBinding.h"
+#include "GPUExternalTexture.h"
+#include "GPUSampler.h"
+#include "GPUTextureView.h"
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBindGroupEntry {
+  double binding;
+  std::shared_ptr<GPUSampler> sampler = nullptr;
+  std::shared_ptr<GPUTextureView> textureView = nullptr;
+  std::shared_ptr<GPUBufferBinding> buffer = nullptr;
+  // external textures
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupEntry>> {
+  static std::shared_ptr<rnwgpu::GPUBindGroupEntry>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBindGroupEntry>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "binding")) {
+        result->binding = value.getProperty(runtime, "binding").asNumber();
+      }
+      if (value.hasProperty(runtime, "resource")) {
+        auto prop = value.getProperty(runtime, "resource");
+        if (prop.isObject()) {
+          auto obj = prop.getObject(runtime);
+          if (obj.hasNativeState<rnwgpu::GPUSampler>(runtime)) {
+            result->sampler = obj.getNativeState<rnwgpu::GPUSampler>(runtime);
+          } else if (obj.hasNativeState<rnwgpu::GPUTextureView>(runtime)) {
+            result->textureView =
+                obj.getNativeState<rnwgpu::GPUTextureView>(runtime);
+          } else if (obj.hasNativeState<rnwgpu::GPUBuffer>(runtime)) {
+            // Support passing GPUBuffer directly as resource (auto-wrap in
+            // GPUBufferBinding)
+            auto binding = std::make_shared<rnwgpu::GPUBufferBinding>();
+            binding->buffer = obj.getNativeState<rnwgpu::GPUBuffer>(runtime);
+            result->buffer = binding;
+          } else {
+            result->buffer = JSIConverter<
+                std::shared_ptr<rnwgpu::GPUBufferBinding>>::fromJSI(runtime,
+                                                                    prop,
+                                                                    false);
+          }
+        }
+        // result->resource = JSIConverter<std::variant<
+        //     std::shared_ptr<GPUSampler>, std::shared_ptr<GPUTextureView>,
+        //     std::shared_ptr<GPUBufferBinding>,
+        //     std::shared_ptr<GPUExternalTexture>>>::fromJSI(runtime, prop,
+        //                                                    false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUBindGroupEntry> arg) {
+    throw std::runtime_error("Invalid GPUBindGroupEntry::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBindGroupLayoutDescriptor.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUBindGroupLayoutEntry.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBindGroupLayoutDescriptor {
+  std::vector<std::shared_ptr<GPUBindGroupLayoutEntry>>
+      entries;                      // Iterable<GPUBindGroupLayoutEntry>
+  std::optional<std::string> label; // string
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBindGroupLayoutDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "entries")) {
+        auto prop = value.getProperty(runtime, "entries");
+        result->entries = JSIConverter<std::vector<
+            std::shared_ptr<GPUBindGroupLayoutEntry>>>::fromJSI(runtime, prop,
+                                                                false);
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUBindGroupLayoutDescriptor> arg) {
+    throw std::runtime_error("Invalid GPUBindGroupLayoutDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUBindGroupLayoutEntry.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "JSIConverter.h"
+#include "WGPULogger.h"
+
+#include "GPUBufferBindingLayout.h"
+#include "GPUExternalTextureBindingLayout.h"
+#include "GPUSamplerBindingLayout.h"
+#include "GPUStorageTextureBindingLayout.h"
+#include "GPUTextureBindingLayout.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+struct GPUBindGroupLayoutEntry {
+  double binding;    // GPUIndex32
+  double visibility; // GPUShaderStageFlags
+  std::optional<std::shared_ptr<GPUBufferBindingLayout>>
+      buffer; // GPUBufferBindingLayout
+  std::optional<std::shared_ptr<GPUSamplerBindingLayout>>
+      sampler; // GPUSamplerBindingLayout
+  std::optional<std::shared_ptr<GPUTextureBindingLayout>>
+      texture; // GPUTextureBindingLayout
+  std::optional<std::shared_ptr<GPUStorageTextureBindingLayout>>
+      storageTexture; // GPUStorageTextureBindingLayout
+  std::optional<std::shared_ptr<GPUExternalTextureBindingLayout>>
+      externalTexture; // GPUExternalTextureBindingLayout
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>> {
+  static std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUBindGroupLayoutEntry>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "binding")) {
+        auto prop = value.getProperty(runtime, "binding");
+        result->binding = JSIConverter<double>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "visibility")) {
+        auto prop = value.getProperty(runtime, "visibility");
+        result->visibility =
+            JSIConverter<double>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "buffer")) {
+        auto prop = value.getProperty(runtime, "buffer");
+        result->buffer = JSIConverter<std::optional<
+            std::shared_ptr<GPUBufferBindingLayout>>>::fromJSI(runtime, prop,
+                                                               false);
+      }
+      if (value.hasProperty(runtime, "sampler")) {
+        auto prop = value.getProperty(runtime, "sampler");
+        result->sampler = JSIConverter<std::optional<
+            std::shared_ptr<GPUSamplerBindingLayout>>>::fromJSI(runtime, prop,
+                                                                false);
+      }
+      if (value.hasProperty(runtime, "texture")) {
+        auto prop = value.getProperty(runtime, "texture");
+        result->texture = JSIConverter<std::optional<
+            std::shared_ptr<GPUTextureBindingLayout>>>::fromJSI(runtime, prop,
+                                                                false);
+      }
+      if (value.hasProperty(runtime, "storageTexture")) {
+        auto prop = value.getProperty(runtime, "storageTexture");
+        result->storageTexture = JSIConverter<std::optional<
+            std::shared_ptr<GPUStorageTextureBindingLayout>>>::fromJSI(runtime,
+                                                                       prop,
+                                                                       false);
+      }
+      if (value.hasProperty(runtime, "externalTexture")) {
+        auto prop = value.getProperty(runtime, "externalTexture");
+        result->externalTexture = JSIConverter<std::optional<
+            std::shared_ptr<GPUExternalTextureBindingLayout>>>::fromJSI(runtime,
+                                                                        prop,
+                                                                        false);
+      }
+    }
+
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime &runtime,
+        std::shared_ptr<rnwgpu::GPUBindGroupLayoutEntry> arg) {
+    throw std::runtime_error("Invalid GPUBindGroupLayoutEntry::toJSI()");
+  }
+};
+
+} // namespace rnwgpu