react-native-webgpu 0.13.0 → 0.14.0

package/cpp/rnwgpu/WebGPURuntime.cpp

@@ -0,0 +1,91 @@
+#include "WebGPURuntime.h"
+
+#include <dlfcn.h>
+
+#include <iterator>
+
+namespace rnwgpu {
+
+namespace {
+
+wgpu::Instance createInstance() {
+  // If a Graphite build of react-native-skia is loaded in this
+  // process, adopt its wgpu::Instance instead of creating our own, so
+  // Graphite's device and every JS-created device live on one instance. That
+  // makes pointer-based handoff (RNWebGPU.importDevice of Skia's device)
+  // sound: the async pump serves the shared instance, so callbacks on
+  // imported devices settle. Discovered at runtime via dlsym so there is no
+  // build-time coupling and native-module init order does not matter. Both
+  // packages must link the same single Dawn copy (they vendor the same
+  // artifact) for the handle to be meaningful.
+  using GetInstanceFn = WGPUInstance (*)();
+  if (auto getSkiaInstance = reinterpret_cast<GetInstanceFn>(
+          dlsym(RTLD_DEFAULT, "rnskia_getWGPUInstance"))) {
+    if (WGPUInstance external = getSkiaInstance()) {
+      wgpuInstanceAddRef(external);
+      return wgpu::Instance::Acquire(external);
+    }
+  }
+
+  static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
+  wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
+                                        .requiredFeatures = &kTimedWaitAny};
+
+  wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
+  instanceDesc.requiredLimits = &limits;
+
+  // Expose Dawn's experimental adapter features. Several features needed by
+  // our Android external-texture path (YCbCrVulkanSamplers,
+  // OpaqueYCbCrAndroidForExternalTexture) are tagged Experimental in Dawn's
+  // feature table and are otherwise filtered out of adapter.features by
+  // PhysicalDeviceBase::GetSupportedFeatures. The allow_unsafe_apis toggle
+  // disables that filter so the features become visible;
+  // expose_wgsl_experimental_features is the parallel toggle for WGSL language
+  // features.
+  //
+  // Trade-off: these are instance-level Dawn toggles, so they apply to every
+  // adapter/device created from this instance, not just the external-texture
+  // path. There is no finer-grained, per-feature mechanism to surface these.
+  // The exposure is acceptable because the toggle only *un-hides* experimental
+  // features in adapter.features; it does not enable any of them. Nothing
+  // experimental becomes active unless application code explicitly lists that
+  // feature in requiredFeatures at device creation, so the default behavior of
+  // a device that asks for no experimental features is unchanged.
+  static const char *const kEnabledToggles[] = {
+      "allow_unsafe_apis",
+      "expose_wgsl_experimental_features",
+  };
+  wgpu::DawnTogglesDescriptor toggles;
+  toggles.enabledToggleCount = std::size(kEnabledToggles);
+  toggles.enabledToggles = kEnabledToggles;
+  instanceDesc.nextInChain = &toggles;
+
+  return wgpu::CreateInstance(&instanceDesc);
+}
+
+} // namespace
+
+WebGPURuntime &WebGPURuntime::shared() {
+  static auto *runtime = new WebGPURuntime();
+  return *runtime;
+}
+
+wgpu::Instance WebGPURuntime::instance() {
+  std::call_once(_instanceOnce, [this] { _instance = createInstance(); });
+  return _instance;
+}
+
+wgpu::Surface WebGPURuntime::makeSurface(void *nativeSurface) {
+#if defined(__ANDROID__)
+  wgpu::SurfaceSourceAndroidNativeWindow source;
+  source.window = nativeSurface;
+#else
+  wgpu::SurfaceSourceMetalLayer source;
+  source.layer = nativeSurface;
+#endif
+  wgpu::SurfaceDescriptor descriptor;
+  descriptor.nextInChain = &source;
+  return instance().CreateSurface(&descriptor);
+}
+
+} // namespace rnwgpu

package/cpp/rnwgpu/WebGPURuntime.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <mutex>
+
+#include "webgpu/webgpu_cpp.h"
+
+namespace rnwgpu {
+
+// Process-lifetime GPU state shared by every React instance, JS runtime and
+// thread. It holds nothing tied to one React instance (no jsi::Runtime,
+// CallInvoker or BlobModule): those stay with the per-instance module.
+// Intentionally never destroyed, so there is no static-destruction ordering to
+// get wrong and it outlives a React reload.
+class WebGPURuntime {
+public:
+  static WebGPURuntime &shared();
+
+  // The process-wide instance: Skia Graphite's when that is loaded, otherwise
+  // our own. Created on first use. Safe to call from any thread.
+  wgpu::Instance instance();
+
+  // Creates a surface on the shared instance for a CAMetalLayer (Apple) or an
+  // ANativeWindow (Android). Safe to call from any thread.
+  wgpu::Surface makeSurface(void *nativeSurface);
+
+  WebGPURuntime(const WebGPURuntime &) = delete;
+  WebGPURuntime &operator=(const WebGPURuntime &) = delete;
+
+private:
+  WebGPURuntime() = default;
+
+  std::once_flag _instanceOnce;
+  wgpu::Instance _instance;
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/Convertors.h

@@ -10,6 +10,7 @@
 
 #include "webgpu/webgpu_cpp.h"
 
+#include "EnforceRange.h"
 #include "GPUBindGroupDescriptor.h"
 #include "GPUBindGroupEntry.h"
 #include "GPUBindGroupLayoutDescriptor.h"
@@ -161,11 +162,19 @@ public:
     return true;
   }
 
+  // JS numbers destined for an integer field are WebIDL [EnforceRange]
+  // integers in WebGPU, so an out-of-range value is a TypeError rather than a
+  // silent wrap (and an undefined cast). Flags are enums here and keep the
+  // plain cast, as GPUFlagsConstant is not [EnforceRange].
   template <typename T>
   [[nodiscard]] typename std::enable_if<
       (std::is_arithmetic<T>::value || std::is_enum<T>::value), bool>::type
   Convert(T &out, const double &in) {
-    out = static_cast<T>(in);
+    if constexpr (std::is_integral_v<T> && !std::is_same_v<T, bool>) {
+      out = enforceRange<T>(in);
+    } else {
+      out = static_cast<T>(in);
+    }
     return true;
   }
 

package/cpp/rnwgpu/api/GPU.cpp

@@ -1,7 +1,5 @@
 #include "GPU.h"
 
-#include <dlfcn.h>
-
 #include <cstdio>
 #include <memory>
 #include <string>
@@ -11,65 +9,13 @@
 
 #include "Convertors.h"
 #include "JSIConverter.h"
+#include "WebGPURuntime.h"
 #include "rnwgpu/async/RuntimeContext.h"
 
 namespace rnwgpu {
 
-GPU::GPU(jsi::Runtime & /*runtime*/) : NativeObject(CLASS_NAME) {
-  // If a Graphite build of react-native-skia is loaded in this
-  // process, adopt its wgpu::Instance instead of creating our own, so
-  // Graphite's device and every JS-created device live on one instance. That
-  // makes pointer-based handoff (RNWebGPU.importDevice of Skia's device)
-  // sound: the async pump serves the shared instance, so callbacks on
-  // imported devices settle. Discovered at runtime via dlsym so there is no
-  // build-time coupling and native-module init order does not matter. Both
-  // packages must link the same single Dawn copy (they vendor the same
-  // artifact) for the handle to be meaningful.
-  using GetInstanceFn = WGPUInstance (*)();
-  if (auto getSkiaInstance = reinterpret_cast<GetInstanceFn>(
-          dlsym(RTLD_DEFAULT, "rnskia_getWGPUInstance"))) {
-    if (WGPUInstance external = getSkiaInstance()) {
-      wgpuInstanceAddRef(external);
-      _instance = wgpu::Instance::Acquire(external);
-      return;
-    }
-  }
-
-  static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
-  wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
-                                        .requiredFeatures = &kTimedWaitAny};
-
-  wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
-  instanceDesc.requiredLimits = &limits;
-
-  // Expose Dawn's experimental adapter features. Several features needed by
-  // our Android external-texture path (YCbCrVulkanSamplers,
-  // OpaqueYCbCrAndroidForExternalTexture) are tagged Experimental in Dawn's
-  // feature table and are otherwise filtered out of adapter.features by
-  // PhysicalDeviceBase::GetSupportedFeatures. The allow_unsafe_apis toggle
-  // disables that filter so the features become visible;
-  // expose_wgsl_experimental_features is the parallel toggle for WGSL language
-  // features.
-  //
-  // Trade-off: these are instance-level Dawn toggles, so they apply to every
-  // adapter/device created from this instance, not just the external-texture
-  // path. There is no finer-grained, per-feature mechanism to surface these.
-  // The exposure is acceptable because the toggle only *un-hides* experimental
-  // features in adapter.features; it does not enable any of them. Nothing
-  // experimental becomes active unless application code explicitly lists that
-  // feature in requiredFeatures at device creation, so the default behavior of
-  // a device that asks for no experimental features is unchanged.
-  static const char *const kEnabledToggles[] = {
-      "allow_unsafe_apis",
-      "expose_wgsl_experimental_features",
-  };
-  wgpu::DawnTogglesDescriptor toggles;
-  toggles.enabledToggleCount = std::size(kEnabledToggles);
-  toggles.enabledToggles = kEnabledToggles;
-  instanceDesc.nextInChain = &toggles;
-
-  _instance = wgpu::CreateInstance(&instanceDesc);
-}
+GPU::GPU(jsi::Runtime & /*runtime*/)
+    : NativeObject(CLASS_NAME), _instance(WebGPURuntime::shared().instance()) {}
 
 async::AsyncTaskHandle GPU::requestAdapter(
     jsi::Runtime &runtime,

package/cpp/rnwgpu/api/GPUError.h

@@ -24,6 +24,21 @@ public:
     installGetter(runtime, prototype, "message", &GPUError::getMessage);
   }
 
+  // GPUValidationError, GPUOutOfMemoryError and GPUInternalError extend
+  // GPUError in the spec: chain their prototype to GPUError.prototype so
+  // `error instanceof GPUError` holds.
+  static void inheritPrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installPrototype(runtime);
+    auto *parent = getCachedPrototype(runtime);
+    if (parent == nullptr) {
+      return;
+    }
+    auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
+    auto setPrototypeOf =
+        objectCtor.getPropertyAsFunction(runtime, "setPrototypeOf");
+    setPrototypeOf.call(runtime, prototype, *parent);
+  }
+
 protected:
   // Protected constructor for subclasses
   GPUError(const char *className, std::string message)

package/cpp/rnwgpu/api/GPUInternalError.h

@@ -2,6 +2,7 @@
 
 #include <string>
 
+#include "GPUError.h"
 #include "NativeObject.h"
 
 namespace rnwgpu {
@@ -20,6 +21,7 @@ public:
   std::string getMessage() { return _message; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    GPUError::inheritPrototype(runtime, prototype);
     installGetter(runtime, prototype, "__brand", &GPUInternalError::getBrand);
     installGetter(runtime, prototype, "message", &GPUInternalError::getMessage);
   }

package/cpp/rnwgpu/api/GPUOutOfMemoryError.h

@@ -2,6 +2,7 @@
 
 #include <string>
 
+#include "GPUError.h"
 #include "NativeObject.h"
 
 namespace rnwgpu {
@@ -20,6 +21,7 @@ public:
   std::string getMessage() { return _message; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    GPUError::inheritPrototype(runtime, prototype);
     installGetter(runtime, prototype, "__brand",
                   &GPUOutOfMemoryError::getBrand);
     installGetter(runtime, prototype, "message",

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "Convertors.h"
+#include "EnforceRange.h"
 #include "ImageBitmap.h"
 #include "PlatformContext.h"
 
@@ -126,15 +127,9 @@ void GPUQueue::copyVideoFrameToTexture(
     throw std::runtime_error(
         "copyExternalImageToTexture: a native frame is a single 2D image");
   }
-  constexpr double kMaxCoordinate =
-      static_cast<double>(std::numeric_limits<uint32_t>::max());
-  auto coordinate = [&](double value, const char *name) {
-    if (!(value >= 0) || value > kMaxCoordinate) {
-      throw std::runtime_error(std::string("copyExternalImageToTexture: ") +
-                               name +
-                               " must be a non-negative integer coordinate");
-    }
-    return static_cast<uint32_t>(value);
+  // GPUOrigin2D coordinates are [EnforceRange] unsigned long.
+  auto coordinate = [](double value, const char * /*name*/) {
+    return enforceRange<uint32_t>(value);
   };
   const double rotation = source.rotation.value_or(0);
   if (rotation != 0 && rotation != 90 && rotation != 180 && rotation != 270) {
@@ -208,18 +203,9 @@ void GPUQueue::copyExternalImageToTexture(
   }
 
   const auto origin = source->origin.value_or(nullptr);
-  // GPUOrigin2D coordinates are [EnforceRange] unsigned long: negative,
-  // NaN, or out-of-range doubles must be rejected here because casting
-  // them to an unsigned integer is undefined behavior.
-  constexpr double kMaxOrigin =
-      static_cast<double>(std::numeric_limits<uint32_t>::max());
-  if (origin && (!(origin->x >= 0) || !(origin->y >= 0) ||
-                 origin->x > kMaxOrigin || origin->y > kMaxOrigin)) {
-    throw std::runtime_error(
-        "The source origin must be a non-negative integer coordinate.");
-  }
-  const size_t sourceOriginX = origin ? static_cast<size_t>(origin->x) : 0;
-  const size_t sourceOriginY = origin ? static_cast<size_t>(origin->y) : 0;
+  // GPUOrigin2D coordinates are [EnforceRange] unsigned long.
+  const size_t sourceOriginX = origin ? enforceRange<uint32_t>(origin->x) : 0;
+  const size_t sourceOriginY = origin ? enforceRange<uint32_t>(origin->y) : 0;
   if (sourceOriginX > source->source->getWidth() ||
       sz.width > source->source->getWidth() - sourceOriginX ||
       sourceOriginY > source->source->getHeight() ||

package/cpp/rnwgpu/api/GPUTexture.h

@@ -101,6 +101,8 @@ public:
     case wgpu::TextureFormat::Stencil8:
       bytesPerPixel = 1;
       break;
+    case wgpu::TextureFormat::R16Unorm:
+    case wgpu::TextureFormat::R16Snorm:
     case wgpu::TextureFormat::R16Uint:
     case wgpu::TextureFormat::R16Sint:
     case wgpu::TextureFormat::R16Float:
@@ -122,6 +124,8 @@ public:
     case wgpu::TextureFormat::R32Float:
     case wgpu::TextureFormat::R32Uint:
     case wgpu::TextureFormat::R32Sint:
+    case wgpu::TextureFormat::RG16Unorm:
+    case wgpu::TextureFormat::RG16Snorm:
     case wgpu::TextureFormat::RG16Uint:
     case wgpu::TextureFormat::RG16Sint:
     case wgpu::TextureFormat::RG16Float:
@@ -133,6 +137,8 @@ public:
     case wgpu::TextureFormat::RG32Float:
     case wgpu::TextureFormat::RG32Uint:
     case wgpu::TextureFormat::RG32Sint:
+    case wgpu::TextureFormat::RGBA16Unorm:
+    case wgpu::TextureFormat::RGBA16Snorm:
     case wgpu::TextureFormat::RGBA16Uint:
     case wgpu::TextureFormat::RGBA16Sint:
     case wgpu::TextureFormat::RGBA16Float:

package/cpp/rnwgpu/api/GPUValidationError.h

@@ -2,6 +2,7 @@
 
 #include <string>
 
+#include "GPUError.h"
 #include "NativeObject.h"
 
 namespace rnwgpu {
@@ -20,6 +21,7 @@ public:
   std::string getMessage() { return _message; }
 
   static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    GPUError::inheritPrototype(runtime, prototype);
     installGetter(runtime, prototype, "__brand", &GPUValidationError::getBrand);
     installGetter(runtime, prototype, "message",
                   &GPUValidationError::getMessage);

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

@@ -866,6 +866,10 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::TextureFormat::R16Sint;
   } else if (inUnion == "r16float") {
     *outEnum = wgpu::TextureFormat::R16Float;
+  } else if (inUnion == "r16unorm") {
+    *outEnum = wgpu::TextureFormat::R16Unorm;
+  } else if (inUnion == "r16snorm") {
+    *outEnum = wgpu::TextureFormat::R16Snorm;
   } else if (inUnion == "rg8unorm") {
     *outEnum = wgpu::TextureFormat::RG8Unorm;
   } else if (inUnion == "rg8snorm") {
@@ -886,6 +890,10 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::TextureFormat::RG16Sint;
   } else if (inUnion == "rg16float") {
     *outEnum = wgpu::TextureFormat::RG16Float;
+  } else if (inUnion == "rg16unorm") {
+    *outEnum = wgpu::TextureFormat::RG16Unorm;
+  } else if (inUnion == "rg16snorm") {
+    *outEnum = wgpu::TextureFormat::RG16Snorm;
   } else if (inUnion == "rgba8unorm") {
     *outEnum = wgpu::TextureFormat::RGBA8Unorm;
   } else if (inUnion == "rgba8unorm-srgb") {
@@ -920,6 +928,10 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::TextureFormat::RGBA16Sint;
   } else if (inUnion == "rgba16float") {
     *outEnum = wgpu::TextureFormat::RGBA16Float;
+  } else if (inUnion == "rgba16unorm") {
+    *outEnum = wgpu::TextureFormat::RGBA16Unorm;
+  } else if (inUnion == "rgba16snorm") {
+    *outEnum = wgpu::TextureFormat::RGBA16Snorm;
   } else if (inUnion == "rgba32uint") {
     *outEnum = wgpu::TextureFormat::RGBA32Uint;
   } else if (inUnion == "rgba32sint") {
@@ -1072,6 +1084,12 @@ inline void convertEnumToJSUnion(wgpu::TextureFormat inEnum,
   case wgpu::TextureFormat::R16Float:
     *outUnion = "r16float";
     break;
+  case wgpu::TextureFormat::R16Unorm:
+    *outUnion = "r16unorm";
+    break;
+  case wgpu::TextureFormat::R16Snorm:
+    *outUnion = "r16snorm";
+    break;
   case wgpu::TextureFormat::RG8Unorm:
     *outUnion = "rg8unorm";
     break;
@@ -1102,6 +1120,12 @@ inline void convertEnumToJSUnion(wgpu::TextureFormat inEnum,
   case wgpu::TextureFormat::RG16Float:
     *outUnion = "rg16float";
     break;
+  case wgpu::TextureFormat::RG16Unorm:
+    *outUnion = "rg16unorm";
+    break;
+  case wgpu::TextureFormat::RG16Snorm:
+    *outUnion = "rg16snorm";
+    break;
   case wgpu::TextureFormat::RGBA8Unorm:
     *outUnion = "rgba8unorm";
     break;
@@ -1153,6 +1177,12 @@ inline void convertEnumToJSUnion(wgpu::TextureFormat inEnum,
   case wgpu::TextureFormat::RGBA16Float:
     *outUnion = "rgba16float";
     break;
+  case wgpu::TextureFormat::RGBA16Unorm:
+    *outUnion = "rgba16unorm";
+    break;
+  case wgpu::TextureFormat::RGBA16Snorm:
+    *outUnion = "rgba16snorm";
+    break;
   case wgpu::TextureFormat::RGBA32Uint:
     *outUnion = "rgba32uint";
     break;
@@ -1431,38 +1461,56 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::VertexFormat::Uint8x2;
   } else if (inUnion == "uint8x4") {
     *outEnum = wgpu::VertexFormat::Uint8x4;
+  } else if (inUnion == "uint8") {
+    *outEnum = wgpu::VertexFormat::Uint8;
   } else if (inUnion == "sint8x2") {
     *outEnum = wgpu::VertexFormat::Sint8x2;
   } else if (inUnion == "sint8x4") {
     *outEnum = wgpu::VertexFormat::Sint8x4;
+  } else if (inUnion == "sint8") {
+    *outEnum = wgpu::VertexFormat::Sint8;
   } else if (inUnion == "unorm8x2") {
     *outEnum = wgpu::VertexFormat::Unorm8x2;
   } else if (inUnion == "unorm8x4") {
     *outEnum = wgpu::VertexFormat::Unorm8x4;
+  } else if (inUnion == "unorm8") {
+    *outEnum = wgpu::VertexFormat::Unorm8;
   } else if (inUnion == "snorm8x2") {
     *outEnum = wgpu::VertexFormat::Snorm8x2;
   } else if (inUnion == "snorm8x4") {
     *outEnum = wgpu::VertexFormat::Snorm8x4;
+  } else if (inUnion == "snorm8") {
+    *outEnum = wgpu::VertexFormat::Snorm8;
   } else if (inUnion == "uint16x2") {
     *outEnum = wgpu::VertexFormat::Uint16x2;
   } else if (inUnion == "uint16x4") {
     *outEnum = wgpu::VertexFormat::Uint16x4;
+  } else if (inUnion == "uint16") {
+    *outEnum = wgpu::VertexFormat::Uint16;
   } else if (inUnion == "sint16x2") {
     *outEnum = wgpu::VertexFormat::Sint16x2;
   } else if (inUnion == "sint16x4") {
     *outEnum = wgpu::VertexFormat::Sint16x4;
+  } else if (inUnion == "sint16") {
+    *outEnum = wgpu::VertexFormat::Sint16;
   } else if (inUnion == "unorm16x2") {
     *outEnum = wgpu::VertexFormat::Unorm16x2;
   } else if (inUnion == "unorm16x4") {
     *outEnum = wgpu::VertexFormat::Unorm16x4;
+  } else if (inUnion == "unorm16") {
+    *outEnum = wgpu::VertexFormat::Unorm16;
   } else if (inUnion == "snorm16x2") {
     *outEnum = wgpu::VertexFormat::Snorm16x2;
   } else if (inUnion == "snorm16x4") {
     *outEnum = wgpu::VertexFormat::Snorm16x4;
+  } else if (inUnion == "snorm16") {
+    *outEnum = wgpu::VertexFormat::Snorm16;
   } else if (inUnion == "float16x2") {
     *outEnum = wgpu::VertexFormat::Float16x2;
   } else if (inUnion == "float16x4") {
     *outEnum = wgpu::VertexFormat::Float16x4;
+  } else if (inUnion == "float16") {
+    *outEnum = wgpu::VertexFormat::Float16;
   } else if (inUnion == "float32") {
     *outEnum = wgpu::VertexFormat::Float32;
   } else if (inUnion == "float32x2") {
@@ -1487,6 +1535,8 @@ inline void convertJSUnionToEnum(const std::string &inUnion,
     *outEnum = wgpu::VertexFormat::Sint32x4;
   } else if (inUnion == "unorm10-10-10-2") {
     *outEnum = wgpu::VertexFormat::Unorm10_10_10_2;
+  } else if (inUnion == "unorm8x4-bgra") {
+    *outEnum = wgpu::VertexFormat::Unorm8x4BGRA;
   } else {
     throw invalidUnion(inUnion);
   }
@@ -1504,54 +1554,81 @@ inline void convertEnumToJSUnion(wgpu::VertexFormat inEnum,
   case wgpu::VertexFormat::Uint8x4:
     *outUnion = "uint8x4";
     break;
+  case wgpu::VertexFormat::Uint8:
+    *outUnion = "uint8";
+    break;
   case wgpu::VertexFormat::Sint8x2:
     *outUnion = "sint8x2";
     break;
   case wgpu::VertexFormat::Sint8x4:
     *outUnion = "sint8x4";
     break;
+  case wgpu::VertexFormat::Sint8:
+    *outUnion = "sint8";
+    break;
   case wgpu::VertexFormat::Unorm8x2:
     *outUnion = "unorm8x2";
     break;
   case wgpu::VertexFormat::Unorm8x4:
     *outUnion = "unorm8x4";
     break;
+  case wgpu::VertexFormat::Unorm8:
+    *outUnion = "unorm8";
+    break;
   case wgpu::VertexFormat::Snorm8x2:
     *outUnion = "snorm8x2";
     break;
   case wgpu::VertexFormat::Snorm8x4:
     *outUnion = "snorm8x4";
     break;
+  case wgpu::VertexFormat::Snorm8:
+    *outUnion = "snorm8";
+    break;
   case wgpu::VertexFormat::Uint16x2:
     *outUnion = "uint16x2";
     break;
   case wgpu::VertexFormat::Uint16x4:
     *outUnion = "uint16x4";
     break;
+  case wgpu::VertexFormat::Uint16:
+    *outUnion = "uint16";
+    break;
   case wgpu::VertexFormat::Sint16x2:
     *outUnion = "sint16x2";
     break;
   case wgpu::VertexFormat::Sint16x4:
     *outUnion = "sint16x4";
     break;
+  case wgpu::VertexFormat::Sint16:
+    *outUnion = "sint16";
+    break;
   case wgpu::VertexFormat::Unorm16x2:
     *outUnion = "unorm16x2";
     break;
   case wgpu::VertexFormat::Unorm16x4:
     *outUnion = "unorm16x4";
     break;
+  case wgpu::VertexFormat::Unorm16:
+    *outUnion = "unorm16";
+    break;
   case wgpu::VertexFormat::Snorm16x2:
     *outUnion = "snorm16x2";
     break;
   case wgpu::VertexFormat::Snorm16x4:
     *outUnion = "snorm16x4";
     break;
+  case wgpu::VertexFormat::Snorm16:
+    *outUnion = "snorm16";
+    break;
   case wgpu::VertexFormat::Float16x2:
     *outUnion = "float16x2";
     break;
   case wgpu::VertexFormat::Float16x4:
     *outUnion = "float16x4";
     break;
+  case wgpu::VertexFormat::Float16:
+    *outUnion = "float16";
+    break;
   case wgpu::VertexFormat::Float32:
     *outUnion = "float32";
     break;
@@ -1588,6 +1665,9 @@ inline void convertEnumToJSUnion(wgpu::VertexFormat inEnum,
   case wgpu::VertexFormat::Unorm10_10_10_2:
     *outUnion = "unorm10-10-10-2";
     break;
+  case wgpu::VertexFormat::Unorm8x4BGRA:
+    *outUnion = "unorm8x4-bgra";
+    break;
   default:
     throw invalidEnum(inEnum);
   }

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

@@ -4,7 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.registerWebGPUForReanimated = void 0;
-// Declare global WebGPU worklet helper functions (installed by native module)
+// The native half of the serializer (WebGPUWorkletHelpers in
+// cpp/jsi/NativeObject.h), installed on the main runtime by the native module.
+// determine/pack capture it by closure, and worklets hands a HostObject to
+// every runtime by reference, so the serializer works wherever a WebGPU object
+// is captured (Reanimated UI runtime, createWorkletRuntime, Vision Camera frame
+// processors) without installing anything on those runtimes.
 
 let isRegistered = false;
 
@@ -19,6 +24,11 @@ const registerWebGPUForReanimated = () => {
     return;
   }
   isRegistered = true;
+  const helpers = globalThis.__webgpuWorkletHelpers;
+  if (helpers === undefined) {
+    // The native module is not installed (web, node): nothing to serialize.
+    return;
+  }
   try {
     const {
       registerCustomSerializable
@@ -28,12 +38,12 @@ const registerWebGPUForReanimated = () => {
       determine: value => {
         "worklet";
 
-        return __webgpuIsWebGPUObject(value);
+        return helpers.isNativeObject(value);
       },
       pack: value => {
         "worklet";
 
-        return __webgpuBox(value);
+        return helpers.box(value);
       },
       unpack: boxed => {
         "worklet";

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;;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":[]}
+{"version":3,"names":["isRegistered","registerWebGPUForReanimated","helpers","globalThis","__webgpuWorkletHelpers","undefined","registerCustomSerializable","require","name","determine","value","isNativeObject","pack","box","unpack","boxed","unbox","exports"],"sourceRoot":"../../../../src","sources":["external/reanimated/registerWebGPUForReanimated.ts"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;;AAkBA,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,MAAME,OAAO,GAAGC,UAAU,CAACC,sBAAsB;EACjD,IAAIF,OAAO,KAAKG,SAAS,EAAE;IACzB;IACA;EACF;EAEA,IAAI;IACF,MAAM;MAAEC;IAA2B,CAAC,GAAGC,OAAO,CAAC,uBAAuB,CAAC;IAEvED,0BAA0B,CAAC;MACzBE,IAAI,EAAE,QAAQ;MACdC,SAAS,EAAGC,KAAa,IAAsB;QAC7C,SAAS;;QACT,OAAOR,OAAO,CAACS,cAAc,CAACD,KAAK,CAAC;MACtC,CAAC;MACDE,IAAI,EAAGF,KAAa,IAAK;QACvB,SAAS;;QACT,OAAOR,OAAO,CAACW,GAAG,CAACH,KAAK,CAAC;MAC3B,CAAC;MACDI,MAAM,EAAGC,KAAwB,IAAK;QACpC,SAAS;;QACT,OAAOA,KAAK,CAACC,KAAK,CAAC,CAAC;MACtB;IACF,CAAC,CAAC;EACJ,CAAC,CAAC,MAAM;IACN;EAAA;AAEJ,CAAC;AAACC,OAAA,CAAAhB,2BAAA,GAAAA,2BAAA","ignoreList":[]}