react-native-wgpu 0.2.2 → 0.2.4

package/apple/RNWGUIKit.h

@@ -13,4 +13,4 @@ typedef UIView RNWGPlatformView;
 typedef NSView RNWGPlatformView;
 #endif
 
-#endif  // PACKAGES_WEBGPU_APPLE_RNWGUIKIT_H_
+#endif // PACKAGES_WEBGPU_APPLE_RNWGUIKIT_H_

package/cpp/dawn_logging.cpp

@@ -65,7 +65,7 @@ LogMessage::~LogMessage() {
         case LogSeverity::Error: severityName = "Error"; break;
         default: severityName = "Unknown"; break;
     }
-    
+
 #ifdef __ANDROID__
     int androidPriority;
     switch (mSeverity) {

package/cpp/jsi/RNFHybridObject.h

@@ -65,6 +65,12 @@ public:
    */
   virtual std::string toString(jsi::Runtime& runtime);
 
+  /**
+   * Get the memory pressure of this HostObject in bytes.
+   * This is used to inform the JavaScript runtime about memory usage for garbage collection.
+   */
+  virtual size_t getMemoryPressure() { return 1024; }
+
 private:
   static constexpr auto TAG = "HybridObject";
   int _instanceId = 1;

package/cpp/jsi/RNFJSIConverter.h

@@ -446,7 +446,12 @@ template <typename T> struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_h
       throw jsi::JSError(runtime, "Cannot convert nullptr to HostObject<" + getFriendlyTypename() + ">!");
     }
 #endif
-    return jsi::Object::createFromHostObject(runtime, arg);
+    auto result = jsi::Object::createFromHostObject(runtime, arg);
+    auto memoryPressure = arg->getMemoryPressure();
+    if (memoryPressure > 0) {
+      result.setExternalMemoryPressure(runtime, memoryPressure);
+    }
+    return result;
   }
 };
 

package/cpp/rnwgpu/api/AsyncRunner.h

@@ -23,7 +23,7 @@ public:
         });
   }
 
-private:
+public:
   wgpu::Instance *instance;
 };
 

package/cpp/rnwgpu/api/GPUBindGroup.h

@@ -37,6 +37,13 @@ public:
 
   inline const wgpu::BindGroup get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Bind groups store resource bindings and descriptor state
+    // They reference buffers, textures, samplers, etc.
+    // Estimate: 1KB per bind group (descriptor tables and binding state)
+    return 1024;
+  }
+
 private:
   wgpu::BindGroup _instance;
   std::string _label;

package/cpp/rnwgpu/api/GPUBindGroupLayout.h

@@ -38,6 +38,13 @@ public:
 
   inline const wgpu::BindGroupLayout get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Bind group layouts define the structure/schema for bind groups
+    // They store binding descriptors, types, and validation info
+    // Estimate: 512 bytes per layout (smaller than actual bind groups)
+    return 512;
+  }
+
 private:
   wgpu::BindGroupLayout _instance;
   std::string _label;

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -62,6 +62,8 @@ public:
 
   inline const wgpu::Buffer get() { return _instance; }
 
+  size_t getMemoryPressure() override { return static_cast<size_t>(getSize()); }
+
 private:
   wgpu::Buffer _instance;
   std::shared_ptr<AsyncRunner> _async;

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -1,7 +1,7 @@
 #include "GPUCanvasContext.h"
-#include <memory>
 #include "Convertors.h"
 #include "RNWebGPUManager.h"
+#include <memory>
 
 #ifdef __APPLE__
 #include "dawn/native/MetalBackend.h"

package/cpp/rnwgpu/api/GPUComputePipeline.h

@@ -45,6 +45,13 @@ public:
 
   inline const wgpu::ComputePipeline get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Compute pipelines contain compiled compute shader state and
+    // driver-specific optimized code
+    // Estimate: 16KB for a typical compute pipeline (single compute shader)
+    return 16 * 1024;
+  }
+
 private:
   wgpu::ComputePipeline _instance;
   std::string _label;

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -279,47 +279,68 @@ void GPUDevice::pushErrorScope(wgpu::ErrorFilter filter) {
 
 std::future<std::variant<std::nullptr_t, std::shared_ptr<GPUError>>>
 GPUDevice::popErrorScope() {
-  return _async->runAsync([=](wgpu::Instance *instance) {
-    std::variant<std::nullptr_t, std::shared_ptr<GPUError>> result = nullptr;
-    auto future = _instance.PopErrorScope(
-        wgpu::CallbackMode::WaitAnyOnly,
-        [&result](wgpu::PopErrorScopeStatus, wgpu::ErrorType type,
-                  char const *message) {
-          switch (type) {
-          case wgpu::ErrorType::NoError:
-            break;
-          case wgpu::ErrorType::OutOfMemory: {
-            result = std::make_shared<GPUError>(wgpu::ErrorType::OutOfMemory,
-                                                message);
-            break;
-          }
-          case wgpu::ErrorType::Validation: {
-            result = std::make_shared<GPUError>(wgpu::ErrorType::Validation,
-                                                message);
-            break;
-          }
-          case wgpu::ErrorType::Internal: {
-            result =
-                std::make_shared<GPUError>(wgpu::ErrorType::Internal, message);
-            break;
-          }
-          case wgpu::ErrorType::Unknown:
-            result =
-                std::make_shared<GPUError>(wgpu::ErrorType::Unknown, message);
-            break;
-          default:
-            throw std::runtime_error(
-                "unhandled error type (" +
-                std::to_string(
-                    static_cast<std::underlying_type<wgpu::ErrorType>::type>(
-                        type)) +
-                ")");
-            break;
-          }
-        });
-    instance->WaitAny(future, UINT64_MAX);
-    return result;
-  });
+  // Create a promise to return a future, but do the work synchronously on main
+  // thread
+  auto promise = std::make_shared<
+      std::promise<std::variant<std::nullptr_t, std::shared_ptr<GPUError>>>>();
+  auto future = promise->get_future();
+
+  std::variant<std::nullptr_t, std::shared_ptr<GPUError>> result = nullptr;
+
+  auto wgpu_future = _instance.PopErrorScope(
+      wgpu::CallbackMode::WaitAnyOnly,
+      [&result](wgpu::PopErrorScopeStatus status, wgpu::ErrorType type,
+                wgpu::StringView message) {
+        switch (status) {
+        case wgpu::PopErrorScopeStatus::Error:
+          // PopErrorScope itself failed, e.g. the error scope stack was empty.
+          return;
+        case wgpu::PopErrorScopeStatus::CallbackCancelled:
+          // The instance has been dropped. Shouldn't happen except maybe during
+          // shutdown.
+          return;
+        case wgpu::PopErrorScopeStatus::Success:
+          // This is the only case where `type` is set to a meaningful value.
+          break;
+        }
+        switch (type) {
+        case wgpu::ErrorType::NoError:
+          break;
+        case wgpu::ErrorType::OutOfMemory: {
+          result = std::make_shared<GPUError>(wgpu::ErrorType::OutOfMemory,
+                                              std::string(message));
+          break;
+        }
+        case wgpu::ErrorType::Validation: {
+          result = std::make_shared<GPUError>(wgpu::ErrorType::Validation,
+                                              std::string(message));
+          break;
+        }
+        case wgpu::ErrorType::Internal: {
+          result = std::make_shared<GPUError>(wgpu::ErrorType::Internal,
+                                              std::string(message));
+          break;
+        }
+        case wgpu::ErrorType::Unknown:
+          result = std::make_shared<GPUError>(wgpu::ErrorType::Unknown,
+                                              std::string(message));
+          break;
+        default:
+          throw std::runtime_error(
+              "unhandled error type (" +
+              std::to_string(
+                  static_cast<std::underlying_type<wgpu::ErrorType>::type>(
+                      type)) +
+              ")");
+          break;
+        }
+      });
+
+  // Wait synchronously on main thread - both push and pop now on same thread
+  _async->instance->WaitAny(wgpu_future, UINT64_MAX);
+
+  promise->set_value(result);
+  return future;
 }
 
 std::unordered_set<std::string> GPUDevice::getFeatures() {

package/cpp/rnwgpu/api/GPUError.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <memory>
+#include <utility>
+#include <string>
 
 #include "webgpu/webgpu_cpp.h"
 
@@ -12,11 +14,11 @@ namespace rnwgpu {
 class GPUError {
 
 public:
-  GPUError(wgpu::ErrorType aType, char const *aMessage)
-      : type(aType), message(aMessage) {}
+  GPUError(wgpu::ErrorType aType, std::string aMessage)
+      : type(aType), message(std::move(aMessage)) {}
 
   wgpu::ErrorType type;
-  char const *message;
+  std::string message;
 };
 
 } // namespace rnwgpu
@@ -33,8 +35,9 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUError>> {
   static jsi::Value toJSI(jsi::Runtime &runtime,
                           std::shared_ptr<rnwgpu::GPUError> arg) {
     jsi::Object result(runtime);
-    result.setProperty(runtime, "message",
-                       jsi::String::createFromUtf8(runtime, arg->message));
+    result.setProperty(
+        runtime, "message",
+        jsi::String::createFromUtf8(runtime, arg->message.c_str()));
     return result;
   }
 };

package/cpp/rnwgpu/api/GPUQuerySet.h

@@ -44,6 +44,27 @@ public:
 
   inline const wgpu::QuerySet get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    uint32_t count = getCount();
+    wgpu::QueryType type = getType();
+
+    // Estimate bytes per query based on type
+    size_t bytesPerQuery = 8; // Default estimate
+    switch (type) {
+    case wgpu::QueryType::Occlusion:
+      bytesPerQuery = 8; // 64-bit counter
+      break;
+    case wgpu::QueryType::Timestamp:
+      bytesPerQuery = 8; // 64-bit timestamp
+      break;
+    default:
+      bytesPerQuery = 8; // Safe default
+      break;
+    }
+
+    return static_cast<size_t>(count) * bytesPerQuery;
+  }
+
 private:
   wgpu::QuerySet _instance;
   std::string _label;

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -40,7 +40,8 @@ void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
 
   // Note that in the JS semantics of WebGPU, writeBuffer works in number of
   // elements of the typed arrays.
-  if (dataOffsetElements > static_cast<uint64_t>(src.size / src.bytesPerElement)) {
+  if (dataOffsetElements >
+      static_cast<uint64_t>(src.size / src.bytesPerElement)) {
     throw std::runtime_error("dataOffset is larger than data's size.");
     return;
   }

package/cpp/rnwgpu/api/GPURenderPassEncoder.cpp

@@ -1,6 +1,6 @@
-#include <vector>
-#include <string>
 #include <memory>
+#include <string>
+#include <vector>
 
 #include "GPURenderPassEncoder.h"
 #include "Convertors.h"
@@ -162,4 +162,4 @@ void GPURenderPassEncoder::drawIndexedIndirect(
   _instance.DrawIndexedIndirect(b, indirectOffset);
 }
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPipeline.h

@@ -44,6 +44,14 @@ public:
 
   inline const wgpu::RenderPipeline get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Render pipelines contain compiled shader state, vertex/fragment shaders,
+    // render state, and driver-specific optimized code
+    // Estimate: 24KB for a typical render pipeline with vertex + fragment
+    // shaders
+    return 24 * 1024;
+  }
+
 private:
   wgpu::RenderPipeline _instance;
   std::string _label;

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -1,7 +1,7 @@
 #include "GPUShaderModule.h"
 
-#include <utility>
 #include <memory>
+#include <utility>
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPUShaderModule.h

@@ -48,6 +48,14 @@ public:
 
   inline const wgpu::ShaderModule get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Estimate memory usage for compiled shader module
+    // Shaders can vary widely, but a reasonable estimate is 8-16KB for typical
+    // shaders Complex shaders (with many uniforms, textures, or computations)
+    // can be much larger
+    return 12 * 1024; // 12KB estimate for average shader
+  }
+
 private:
   wgpu::ShaderModule _instance;
   std::shared_ptr<AsyncRunner> _async;

package/cpp/rnwgpu/api/GPUTexture.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <memory>
 #include <string>
 
@@ -64,6 +65,81 @@ public:
 
   inline const wgpu::Texture get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Calculate approximate memory usage based on texture properties
+    uint32_t width = getWidth();
+    uint32_t height = getHeight();
+    uint32_t depthOrArrayLayers = getDepthOrArrayLayers();
+    uint32_t mipLevelCount = getMipLevelCount();
+    uint32_t sampleCount = getSampleCount();
+
+    // Estimate bytes per pixel based on format
+    // This is a simplified estimate - actual values depend on the specific
+    // format
+    size_t bytesPerPixel = 4; // Default to RGBA8 format
+    wgpu::TextureFormat format = getFormat();
+    switch (format) {
+    case wgpu::TextureFormat::R8Unorm:
+    case wgpu::TextureFormat::R8Snorm:
+    case wgpu::TextureFormat::R8Uint:
+    case wgpu::TextureFormat::R8Sint:
+      bytesPerPixel = 1;
+      break;
+    case wgpu::TextureFormat::R16Uint:
+    case wgpu::TextureFormat::R16Sint:
+    case wgpu::TextureFormat::R16Float:
+    case wgpu::TextureFormat::RG8Unorm:
+    case wgpu::TextureFormat::RG8Snorm:
+    case wgpu::TextureFormat::RG8Uint:
+    case wgpu::TextureFormat::RG8Sint:
+      bytesPerPixel = 2;
+      break;
+    case wgpu::TextureFormat::RGBA8Unorm:
+    case wgpu::TextureFormat::RGBA8UnormSrgb:
+    case wgpu::TextureFormat::RGBA8Snorm:
+    case wgpu::TextureFormat::RGBA8Uint:
+    case wgpu::TextureFormat::RGBA8Sint:
+    case wgpu::TextureFormat::BGRA8Unorm:
+    case wgpu::TextureFormat::BGRA8UnormSrgb:
+    case wgpu::TextureFormat::RGB10A2Unorm:
+    case wgpu::TextureFormat::R32Float:
+    case wgpu::TextureFormat::R32Uint:
+    case wgpu::TextureFormat::R32Sint:
+    case wgpu::TextureFormat::RG16Uint:
+    case wgpu::TextureFormat::RG16Sint:
+    case wgpu::TextureFormat::RG16Float:
+      bytesPerPixel = 4;
+      break;
+    case wgpu::TextureFormat::RG32Float:
+    case wgpu::TextureFormat::RG32Uint:
+    case wgpu::TextureFormat::RG32Sint:
+    case wgpu::TextureFormat::RGBA16Uint:
+    case wgpu::TextureFormat::RGBA16Sint:
+    case wgpu::TextureFormat::RGBA16Float:
+      bytesPerPixel = 8;
+      break;
+    case wgpu::TextureFormat::RGBA32Float:
+    case wgpu::TextureFormat::RGBA32Uint:
+    case wgpu::TextureFormat::RGBA32Sint:
+      bytesPerPixel = 16;
+      break;
+    default:
+      bytesPerPixel = 4; // Safe default
+      break;
+    }
+
+    // Calculate total memory for all mip levels
+    size_t totalMemory = 0;
+    for (uint32_t mip = 0; mip < mipLevelCount; ++mip) {
+      uint32_t mipWidth = std::max(1u, width >> mip);
+      uint32_t mipHeight = std::max(1u, height >> mip);
+      totalMemory += static_cast<size_t>(mipWidth) * mipHeight *
+                     depthOrArrayLayers * bytesPerPixel * sampleCount;
+    }
+
+    return totalMemory;
+  }
+
 private:
   wgpu::Texture _instance;
   std::string _label;

package/cpp/rnwgpu/api/ImageBitmap.h

@@ -27,6 +27,8 @@ public:
     registerHybridGetter("height", &ImageBitmap::getHeight, this);
   }
 
+  size_t getMemoryPressure() override { return getSize(); }
+
 private:
   ImageData _imageData;
 };

package/lib/typescript/src/__tests__/ErrorScope.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ErrorScope.spec.d.ts.map

package/lib/typescript/src/__tests__/ErrorScope.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorScope.spec.d.ts","sourceRoot":"","sources":["../../../../src/__tests__/ErrorScope.spec.ts"],"names":[],"mappings":""}

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

@@ -8,7 +8,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>
@@ -17,15 +17,13 @@
 				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
-			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
+			<string>macos</string>
 		</dict>
 		<dict>
 			<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>
@@ -34,13 +32,15 @@
 				<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>
 			<string>libwebgpu_dawn.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>xros-arm64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libwebgpu_dawn.a</string>
 			<key>SupportedArchitectures</key>
@@ -48,13 +48,15 @@
 				<string>arm64</string>
 			</array>
 			<key>SupportedPlatform</key>
-			<string>ios</string>
+			<string>xros</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>libwebgpu_dawn.a</string>
 			<key>LibraryIdentifier</key>
-			<string>xros-arm64-simulator</string>
+			<string>xros-arm64</string>
 			<key>LibraryPath</key>
 			<string>libwebgpu_dawn.a</string>
 			<key>SupportedArchitectures</key>
@@ -63,14 +65,12 @@
 			</array>
 			<key>SupportedPlatform</key>
 			<string>xros</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>libwebgpu_dawn.a</string>
 			<key>LibraryIdentifier</key>
-			<string>xros-arm64</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libwebgpu_dawn.a</string>
 			<key>SupportedArchitectures</key>
@@ -78,7 +78,7 @@
 				<string>arm64</string>
 			</array>
 			<key>SupportedPlatform</key>
-			<string>xros</string>
+			<string>ios</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/package.json

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

package/src/__tests__/ErrorScope.spec.ts

@@ -0,0 +1,92 @@
+import { client } from "./setup";
+
+describe("Error Scope", () => {
+  it("should capture validation error when creating sampler with invalid maxAnisotropy", async () => {
+    const result = await client.eval(({ device }) => {
+      device.pushErrorScope("validation");
+      device.createSampler({
+        maxAnisotropy: 0, // Invalid, maxAnisotropy must be at least 1.
+      });
+      return device.popErrorScope().then((error) => {
+        if (error) {
+          return {
+            hasError: true,
+            message: error.message,
+            messageLength: error.message.length,
+            messageNotEmpty: error.message.length > 0,
+          };
+        } else {
+          return {
+            hasError: false,
+            message: "",
+            messageLength: 0,
+            messageNotEmpty: false,
+          };
+        }
+      });
+    });
+
+    expect(result.hasError).toBe(true);
+    expect(result.messageNotEmpty).toBe(true);
+    expect(result.messageLength).toBeGreaterThan(0);
+  });
+  it("should capture and return error messages from popErrorScope", async () => {
+    const result = await client.eval(({ device }) => {
+      // Invalid WGSL shader with syntax error (missing closing parenthesis)
+      const invalidShaderWGSL = `@fragment
+  fn main() -> @location(0) vec4f {
+    return vec4(1.0, 0.0, 0.0, 1.0;
+  }`;
+      device.pushErrorScope("validation");
+      // This should generate a validation error due to syntax error
+      device.createShaderModule({
+        code: invalidShaderWGSL,
+      });
+      return device.popErrorScope().then((error) => {
+        if (error) {
+          return {
+            hasError: true,
+            message: error.message,
+            messageLength: error.message.length,
+            messageNotEmpty: error.message.length > 0,
+            messageContainsExpected:
+              error.message.includes("expected") ||
+              error.message.includes("error") ||
+              error.message.includes("parsing"),
+          };
+        } else {
+          return {
+            hasError: false,
+            message: "",
+            messageLength: 0,
+            messageNotEmpty: false,
+            messageContainsExpected: false,
+          };
+        }
+      });
+    });
+    expect(result.hasError).toBe(true);
+    expect(result.messageNotEmpty).toBe(true);
+    expect(result.messageLength).toBeGreaterThan(0);
+    // The error message should contain some indication that it's a parsing error
+    expect(result.messageContainsExpected).toBe(true);
+  });
+
+  it("should return null when no error occurs", async () => {
+    const result = await client.eval(({ device, shaders: { redFragWGSL } }) => {
+      device.pushErrorScope("validation");
+      // This should not generate any errors
+      device.createShaderModule({
+        code: redFragWGSL,
+      });
+      return device.popErrorScope().then((error) => {
+        return {
+          hasError: error !== null,
+          error: error,
+        };
+      });
+    });
+    expect(result.hasError).toBe(false);
+    expect(result.error).toBe(null);
+  });
+});