react-native-wgpu 0.2.3 → 0.2.4

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/rnwgpu/api/AsyncRunner.h

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

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/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.3",
+  "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);
+  });
+});