[deno] Print uncaptured errors to stderr, unless preventDefault() is called

This is useful when running test snippets. Update READMEs including to
mention how to do that.

Author: andyleiserson

Cargo.lock

@@ -187,6 +187,7 @@ spirv = "0.3"
 static_assertions = "1.1"
 strum = { version = "0.27.1", default-features = false, features = ["derive"] }
 syn = "2.0.98"
+tempfile = "3"
 toml = "0.9.0"
 trybuild = "1"
 tracy-client = "0.18"

Cargo.toml

@@ -22,3 +22,6 @@ deno_webidl.workspace = true
 deno_webgpu.workspace = true
 tokio = { workspace = true, features = ["full"] }
 termcolor.workspace = true
+
+[dev-dependencies]
+tempfile.workspace = true

cts_runner/Cargo.toml

@@ -0,0 +1,17 @@
+# cts_runner
+
+This crate contains infrastructure for running the WebGPU conformance tests on
+Deno's `wgpu`-based implementation of WebGPU.
+
+Instructions for running the tests via the CTS `xtask` are in the
+[top-level README](https://github.com/gfx-rs/wgpu/blob/trunk/README.md#webgpu-conformance-test-suite).
+The file [revision.txt](./revision.txt) specifies the version of the CTS that
+will be used by default.
+
+`cts_runner` is somewhat misnamed at this point, in that it is useful for
+things other than just running the CTS:
+
+- The [tests](./tests) directory contains a few directed tests for
+  Deno's bindings to `wgpu`.
+- Standalone JavaScript snippets that use WebGPU can be run
+  with a command like: `cargo run -p cts_runner -- test.js`.

cts_runner/README.md

@@ -3,12 +3,15 @@
 // As of June 2025, these tests are not run in CI.
 
 use std::{
-    fmt::{self, Debug, Display},
+    ffi::OsStr,
+    io::Write,
     path::PathBuf,
-    process::Command,
+    process::{Command, Output},
     str,
 };
 
+use tempfile::NamedTempFile;
+
 pub fn target_dir() -> PathBuf {
     let current_exe = std::env::current_exe().unwrap();
     let target_dir = current_exe.parent().unwrap().parent().unwrap();
@@ -24,38 +27,83 @@ pub fn cts_runner_exe_path() -> PathBuf {
     p
 }
 
-pub struct JsError;
+fn exec_cts_runner(script_file: impl AsRef<OsStr>) -> Output {
+    Command::new(cts_runner_exe_path())
+        .arg(script_file)
+        .output()
+        .unwrap()
+}
 
-impl Display for JsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "JavaScript test returned an error")
-    }
+fn exec_js_file(script_file: impl AsRef<OsStr>) {
+    let output = exec_cts_runner(script_file);
+    println!("{}", str::from_utf8(&output.stdout).unwrap());
+    eprintln!("{}", str::from_utf8(&output.stderr).unwrap());
+    assert!(output.status.success());
 }
 
-impl Debug for JsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{self}")
-    }
+fn check_js_stderr(script: &str, expected: &str) {
+    let mut tempfile = NamedTempFile::new().unwrap();
+    tempfile.write_all(script.as_bytes()).unwrap();
+    tempfile.flush().unwrap();
+    let output = exec_cts_runner(tempfile.path());
+    assert!(output.stdout.is_empty());
+    assert_eq!(str::from_utf8(&output.stderr).unwrap(), expected);
+    assert!(output.status.success());
 }
 
-type JsResult = Result<(), JsError>;
+fn exec_js(script: &str) {
+    check_js_stderr(script, "");
+}
 
-fn exec_js_test(script: &str) -> JsResult {
-    let output = Command::new(cts_runner_exe_path())
-        .arg(script)
-        .output()
-        .unwrap();
-    println!("{}", str::from_utf8(&output.stdout).unwrap());
-    eprintln!("{}", str::from_utf8(&output.stderr).unwrap());
-    output.status.success().then_some(()).ok_or(JsError)
+#[test]
+fn hello_compute_example() {
+    exec_js_file("examples/hello-compute.js");
 }
 
 #[test]
-fn hello_compute_example() -> JsResult {
-    exec_js_test("examples/hello-compute.js")
+fn features() {
+    exec_js(
+        r#"
+        const adapter = await navigator.gpu.requestAdapter();
+
+        if (adapter.features.has("mappable-primary-buffers")) {
+            throw new TypeError("Adapter should not report support for wgpu native-only features");
+        }
+    "#,
+    );
 }
 
 #[test]
-fn features() -> JsResult {
-    exec_js_test("tests/features.js")
+fn uncaptured_error() {
+    for suppress in [false, true] {
+        let (handler, expected_err) = if suppress {
+            (
+                "device.onuncapturederror = (event) => { event.preventDefault(); };",
+                "",
+            )
+        } else {
+            (
+                "",
+                "Uncaptured WebGPU error:
+Shader '' parsing error: the type of `val` is expected to be `u32`, but got `{AbstractFloat}`
+  ┌─ wgsl:1:7
+  │
+1 │ const val: u32 = 1.1;
+  │       ^^^ definition of `val`\n\n\n",
+            )
+        };
+        let script = [
+            r#"
+            const code = `const val: u32 = 1.1;`;
+
+            const adapter = await navigator.gpu.requestAdapter();
+            const device = await adapter.requestDevice();
+            "#,
+            handler,
+            r#"device.createShaderModule({ code })"#,
+        ]
+        .concat();
+
+        check_js_stderr(&script, expected_err);
+    }
 }

cts_runner/tests/features.js

@@ -14,13 +14,15 @@ a
 [wgpu trace](https://github.com/gfx-rs/wgpu/wiki/Debugging-wgpu-Applications#tracing-infrastructure)
 to the specified directory.
 
-For testing this op crate will make use of the WebGPU conformance tests suite,
-running through our WPT runner. This will be used to validate implementation
-conformance.
-
-GitHub CI doesn't run with GPUs, so testing relies on software like DX WARP &
-Vulkan lavapipe. Currently, only using DX WARP works, so tests are only run on
-Windows.
+This op crate is tested primarily by running the
+[WebGPU conformance test suite](https://github.com/gpuweb/cts) using `wgpu`'s
+[`cts_runner`](https://github.com/gfx-rs/wgpu/blob/trunk/README.md#webgpu-conformance-test-suite).
+`cts_runner` also has a few
+[directed tests](https://github.com/gfx-rs/wgpu/tree/trunk/cts_runner/tests)
+to fill in missing coverage.
+
+GPU availability in GitHub CI is limited, so some configurations rely on
+software like DX WARP & Vulkan lavapipe.
 
 ## Links
 

cts_runner/tests/integration.rs

@@ -144,13 +144,32 @@ impl DeviceErrorHandler {
         let obj = v8::Object::new(scope);
         let key = v8::String::new(scope, "error").unwrap();
         obj.set(scope, key.into(), error);
+        let key = v8::String::new(scope, "cancelable").unwrap();
+        let val = v8::Boolean::new(scope, true).into();
+        obj.set(scope, key.into(), val);
 
         let event = constructor
           .new_instance(scope, &[kind.into(), obj.into()])
           .unwrap();
 
         let recv = v8::Local::new(scope, device);
         func.open(scope).call(scope, recv, &[event.into()]);
+
+        let default_prevented =
+          v8::String::new(scope, "defaultPrevented").unwrap();
+        if !event
+          .get(scope, default_prevented.into())
+          .unwrap()
+          .boolean_value(scope)
+        {
+          let msg = err.to_string();
+          let space = if msg.chars().next().is_some_and(char::is_whitespace) {
+            ""
+          } else {
+            " "
+          };
+          eprintln!("Uncaptured WebGPU error:{space}{msg}");
+        }
       });
     }
   }