6d64a1a | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

6d64a1a — Peter John 2026-11-02T17:56:05+05:30

Game bridge: instantiate plum.wasm without WebAssembly.Module.imports (Safari); web-test --browser webkit, --expect-unsupported-webgpu, --no-module-introspection

Files changed (7) hide show

README.md +2 -2
plum-game/web-test/README.md +3 -3
plum-game/web-test/examples/install-browsers.rs +2 -2
plum-game/web-test/src/lib.rs +131 -14
plum-game/web-test/src/main.rs +7 -3
plum-game/web-test/tests/web_check.rs +50 -1
plum-game/web/plum_bridge.js +50 -12

README.md CHANGED Viewed

@@ -1037,7 +1037,7 @@ Every module that imports `std/Str` also exports four helpers for hosts that can
 ## Games
-Games run in the browser on Plum's own WebGPU renderer (`plum-game/web/plum_bridge.js`): the Plum module calls the bridge directly, one extern call per draw, and the bridge batches everything into one buffer upload per frame. A draw call binds up to 16 textures (each vertex carries its texture slot), so mixing atlases in y-sorted scenes costs a handful of draw calls; the canvas is `CSS size x devicePixelRatio` while every game coordinate (`screenWidth`, `mousePos`, the camera) stays in CSS pixels; text is drawn from a signed-distance-field glyph atlas, so it stays crisp at any size or zoom; and if the GPU device is lost the renderer requests a new one, re-uploads the textures and logs `GPU device lost (<reason>); restored` (render-target contents start transparent again). WebGPU is required (Chrome or Edge, Safari 26+, Firefox); there is no fallback.
+Games run in the browser on Plum's own WebGPU renderer (`plum-game/web/plum_bridge.js`): the Plum module calls the bridge directly, one extern call per draw, and the bridge batches everything into one buffer upload per frame. A draw call binds up to 16 textures (each vertex carries its texture slot), so mixing atlases in y-sorted scenes costs a handful of draw calls; the canvas is `CSS size x devicePixelRatio` while every game coordinate (`screenWidth`, `mousePos`, the camera) stays in CSS pixels; text is drawn from a signed-distance-field glyph atlas, so it stays crisp at any size or zoom; and if the GPU device is lost the renderer requests a new one, re-uploads the textures and logs `GPU device lost (<reason>); restored` (render-target contents start transparent again). WebGPU is required (Chrome or Edge, Safari 26+, Firefox); there is no fallback. The bridge reads nothing from the wasm module's import or export lists (`WebAssembly.Module.imports` throws in Safari for typed GC references), so it loads the same way in Safari; `plum-web-test --browser webkit` checks that against Playwright's WebKit.
 `plum game file.plum [--assets DIR] [--port N] [--no-open]` compiles the game, serves it on 127.0.0.1 (port 8080, else any free port; `--port` picks one), prints the URL and opens the default browser unless `--no-open` is given. Ctrl-C stops it. `plum game file.plum -o dist [--assets DIR]` writes a static build instead and exits: `index.html`, `plum_bridge.js`, `plum.wasm`, `preload.txt` and an `assets/` copy of the whole asset directory (every file in it is listed in `preload.txt` and fetched before the first frame). Host that directory on any static file server; the browser needs wasm GC support. The asset root defaults to `assets` beside the source file.
@@ -1057,7 +1057,7 @@ The page calls `init` once after the assets are loaded, then `update` and `draw`
 **Headless tests:** the `plum-game` crate (a standalone crate, wasmtime only) runs a compiled game with no browser against a `Recorder` backend that logs every host call as a string and answers input from scripted values, so `cargo test --manifest-path plum-game/Cargo.toml` checks games' draw-call sequences (`plum-game/tests/host_test.rs`). `plum-game <wasm> [--assets DIR] [--frames N]` does the same from the command line and prints the host calls of the last frame.
-**Browser check:** `cargo run --manifest-path plum-game/web-test/Cargo.toml -- plum-examples/game.plum --screenshot /tmp/orb-run.png` builds the static web version, serves it and drives headless Chromium (software WebGPU) through [playwright-rs](https://crates.io/crates/playwright-rs): it fails if the canvas stays blank or stops changing, or the page logs an error, and reports whether audio started. It also takes `--assets DIR`, `--require-audio`, `--measure SECS` (with `--json`, `draws` is the GPU draw calls per frame), `--headed`, `--dpr N` (a device pixel ratio of N), `--lose-device` (destroys the GPU device after a few frames and requires rendering to resume) and `--expect-pixel x,y,r,g,b[,tol]` (repeatable; the screenshot pixel at CSS (x, y)). `plum-game/web-test/fixtures/` has `interleave.plum`, `text_sizes.plum` and `rendertarget.plum` for these. One-time setup: `cargo run --manifest-path plum-game/web-test/Cargo.toml --example install-browsers`. See [`plum-game/web-test/README.md`](plum-game/web-test/README.md); `docs/game.png` above was made with `--screenshot`. [`plum-game/web-test/BENCHMARK.md`](plum-game/web-test/BENCHMARK.md) records the renderer benchmark that led to this design.
+**Browser check:** `cargo run --manifest-path plum-game/web-test/Cargo.toml -- plum-examples/game.plum --screenshot /tmp/orb-run.png` builds the static web version, serves it and drives headless Chromium (software WebGPU; `--browser webkit` drives Playwright's WebKit, the Safari engine, instead) through [playwright-rs](https://crates.io/crates/playwright-rs): it fails if the canvas stays blank or stops changing, or the page logs an error, and reports whether audio started. It also takes `--assets DIR`, `--require-audio`, `--measure SECS` (with `--json`, `draws` is the GPU draw calls per frame), `--headed`, `--dpr N` (a device pixel ratio of N), `--lose-device` (destroys the GPU device after a few frames and requires rendering to resume) and `--expect-pixel x,y,r,g,b[,tol]` (repeatable; the screenshot pixel at CSS (x, y)), `--expect-unsupported-webgpu` (hides `navigator.gpu` and requires the page's "WebGPU is not supported" message while plum.wasm still loads) and `--no-module-introspection` (makes `WebAssembly.Module.imports/exports/customSections` throw, as Safari does). `plum-game/web-test/fixtures/` has `interleave.plum`, `text_sizes.plum` and `rendertarget.plum` for these. One-time setup: `cargo run --manifest-path plum-game/web-test/Cargo.toml --example install-browsers`. See [`plum-game/web-test/README.md`](plum-game/web-test/README.md); `docs/game.png` above was made with `--screenshot`. [`plum-game/web-test/BENCHMARK.md`](plum-game/web-test/BENCHMARK.md) records the renderer benchmark that led to this design.
 **Asset root:** textures and files are read relative to the asset root. A path that escapes the root (`..` or absolute) fails like a missing file: `-1`, `""` or `false`. The headless runner's root is `--assets` or `assets` beside the wasm; it reads image headers for `textureWidth`/`textureHeight` and records sounds without decoding them.

plum-game/web-test/README.md CHANGED Viewed

@@ -12,7 +12,7 @@ AudioContext state is reported; a missing running context is only a warning unle
 ## One-time setup
-Downloads the Chromium build matching the bundled Playwright driver (about 100 MB, to
+Downloads the Chromium and WebKit builds matching the bundled Playwright driver (about 180 MB, to
 `~/Library/Caches/ms-playwright` on macOS; the driver itself is fetched by the crate's build script):
     cargo run --manifest-path plum-game/web-test/Cargo.toml --example install-browsers
@@ -21,8 +21,8 @@ Downloads the Chromium build matching the bundled Playwright driver (about 100 M
     cargo run --manifest-path plum-game/web-test/Cargo.toml -- plum-examples/game.plum --screenshot /tmp/orb-run.png
-Options: `--frames-wait SECS` (default 8), `--screenshot OUT.png`, `--assets DIR` (default: `assets` beside the source), `--require-audio`, `--json` (adds a one-line JSON object with the backend and frame stats), `--headed` (a real GPU window instead of headless software WebGPU), `--measure SECS` (records requestAnimationFrame intervals in the page and prints avg / p50 / p95 / p99 ms, fps and the mean per-frame update/draw/render split; `--json` adds `update_ms`, `draw_ms`, `render_ms`) and `--uncapped` (lifts vsync so the frame time is the work per frame), `--dpr N` (Playwright `deviceScaleFactor`; also checks the backing store is CSS size x ratio), `--lose-device` (destroys the GPU device from the page after a few frames and requires the `GPU device lost (...); restored` log and resumed rendering; the page exposes the device only when the harness asks) and `--expect-pixel x,y,r,g,b[,tol]` (repeatable; the screenshot pixel at CSS (x, y), default tolerance 2). `--json` also reports `draws`, the GPU draw calls per frame. `fixtures/interleave.plum`, `text_sizes.plum` and `rendertarget.plum` exercise multi-texture batching, SDF text and render targets/blend modes. `fixtures/stress.plum` and `fixtures/stress_scene.plum` are the scenes behind [BENCHMARK.md](BENCHMARK.md).
+Options: `--browser chromium|webkit` (default chromium; WebKit is Playwright's Safari-engine build and has WebGPU, so the same render assertions apply; a WebKit build without `navigator.gpu` is checked for the "WebGPU is not supported in this browser" message and a loadable plum.wasm instead), `--expect-unsupported-webgpu` (hides `navigator.gpu` in any browser and checks that path), `--no-module-introspection` (makes `WebAssembly.Module.imports/exports/customSections` throw the TypeError Safari gives for typed GC references), `--frames-wait SECS` (default 8), `--screenshot OUT.png`, `--assets DIR` (default: `assets` beside the source), `--require-audio`, `--json` (adds a one-line JSON object with the backend and frame stats), `--headed` (a real GPU window instead of headless software WebGPU), `--measure SECS` (records requestAnimationFrame intervals in the page and prints avg / p50 / p95 / p99 ms, fps and the mean per-frame update/draw/render split; `--json` adds `update_ms`, `draw_ms`, `render_ms`) and `--uncapped` (lifts vsync so the frame time is the work per frame), `--dpr N` (Playwright `deviceScaleFactor`; also checks the backing store is CSS size x ratio), `--lose-device` (destroys the GPU device from the page after a few frames and requires the `GPU device lost (...); restored` log and resumed rendering; the page exposes the device only when the harness asks) and `--expect-pixel x,y,r,g,b[,tol]` (repeatable; the screenshot pixel at CSS (x, y), default tolerance 2). `--json` also reports `draws`, the GPU draw calls per frame. `fixtures/interleave.plum`, `text_sizes.plum` and `rendertarget.plum` exercise multi-texture batching, SDF text and render targets/blend modes. `fixtures/stress.plum` and `fixtures/stress_scene.plum` are the scenes behind [BENCHMARK.md](BENCHMARK.md).
 Exit code is non-zero with a message on failure.
 `cargo test --manifest-path plum-game/web-test/Cargo.toml` runs the same check on
-`plum-examples/game.plum` and `plum-examples/scene.plum`; it skips with a note if Chromium is not installed.
+`plum-examples/game.plum` and `plum-examples/scene.plum`, plus WebKit runs; each skips with a note if its browser is not installed.

plum-game/web-test/examples/install-browsers.rs CHANGED Viewed

@@ -1,6 +1,6 @@
-// One-time setup: installs the Chromium build matching the bundled Playwright driver.
+// One-time setup: installs the Chromium and WebKit builds matching the bundled Playwright driver.
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    playwright_rs::install_browsers(Some(&["chromium"])).await?;
+    playwright_rs::install_browsers(Some(&["chromium", "webkit"])).await?;
     Ok(())
 }

plum-game/web-test/src/lib.rs CHANGED Viewed

@@ -8,7 +8,41 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
+/// The browser engine the check drives.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Browser {
+    Chromium,
+    Webkit,
+}
+impl Browser {
+    pub fn parse(s: &str) -> Result<Browser, String> {
+        match s {
+            "chromium" => Ok(Browser::Chromium),
+            "webkit" => Ok(Browser::Webkit),
+            _ => Err(format!("--browser {s}: expected chromium or webkit")),
+        }
+    }
+    pub fn name(self) -> &'static str {
+        match self {
+            Browser::Chromium => "chromium",
+            Browser::Webkit => "webkit",
+        }
+    }
+}
 pub struct Options {
+    /// The engine to drive (default chromium).
+    pub browser: Browser,
+    /// Hide `navigator.gpu` and require the page to report that WebGPU is unsupported
+    /// (the bridge's own message) while plum.wasm still loads. A WebKit run is checked
+    /// this way automatically when its build has no `navigator.gpu`.
+    pub expect_unsupported_webgpu: bool,
+    /// Make `WebAssembly.Module.imports/exports/customSections` throw the TypeError
+    /// JavaScriptCore gives for modules with typed GC references, in any engine: the
+    /// bridge must not need module introspection.
+    pub no_module_introspection: bool,
     pub frames_wait: f64,
     pub screenshot: Option<PathBuf>,
     pub require_audio: bool,
@@ -33,6 +67,9 @@ pub struct Options {
 impl Default for Options {
     fn default() -> Self {
         Options {
+            browser: Browser::Chromium,
+            expect_unsupported_webgpu: false,
+            no_module_introspection: false,
             frames_wait: 8.0,
             screenshot: None,
             require_audio: false,
@@ -163,8 +200,8 @@ pub fn stats_json(opts: &Options, backend: Option<&str>, st: Option<&FrameStats>
     s
 }
-/// Whether `playwright install chromium` has been run (browser cache dir exists).
+/// Whether `browser` has been installed for Playwright (browser cache dir exists).
-pub fn chromium_installed() -> bool {
+pub fn browser_installed(browser: Browser) -> bool {
     let dir = if let Ok(p) = std::env::var("PLAYWRIGHT_BROWSERS_PATH") {
         PathBuf::from(p)
     } else {
@@ -178,10 +215,20 @@ pub fn chromium_installed() -> bool {
         }
     };
     std::fs::read_dir(dir)
-        .map(|rd| rd.flatten().any(|e| e.file_name().to_string_lossy().starts_with("chromium")))
+        .map(|rd| rd.flatten().any(|e| e.file_name().to_string_lossy().starts_with(browser.name())))
         .unwrap_or(false)
 }
+/// Whether `playwright install chromium` has been run.
+pub fn chromium_installed() -> bool {
+    browser_installed(Browser::Chromium)
+}
+/// Whether `playwright install webkit` has been run.
+pub fn webkit_installed() -> bool {
+    browser_installed(Browser::Webkit)
+}
 pub fn repo_root() -> PathBuf {
     Path::new(env!("CARGO_MANIFEST_DIR")).join("../..").canonicalize().expect("repo root")
 }
@@ -312,6 +359,12 @@ const AUDIO_HOOK: &str = r#"(() => {
   }
 })()"#;
+const NO_MODULE_INTROSPECTION: &str = r#"(() => {
+  for (const [k, what] of [["imports", "import"], ["exports", "export"], ["customSections", "custom section"]]) {
+    WebAssembly.Module[k] = () => { throw new TypeError("WebAssembly.Module." + k + " unable to produce " + what + " descriptors for the given module"); };
+  }
+})()"#;
 const RAF_PROBE: &str = r#"(() => {
   window.__rafStamps = [];
   window.__rafOn = false;
@@ -349,22 +402,73 @@ fn pe<E: std::fmt::Display>(what: &'static str) -> impl FnOnce(E) -> String {
 async fn check(port: u16, opts: &Options) -> Result<String, String> {
     let pw = Playwright::launch().await.map_err(pe("launch playwright"))?;
+    let browser = match opts.browser {
+        Browser::Chromium => {
-    let mut args: Vec<String> = ["--ignore-gpu-blocklist", "--autoplay-policy=no-user-gesture-required"].map(String::from).to_vec();
+            let mut args: Vec<String> = ["--ignore-gpu-blocklist", "--autoplay-policy=no-user-gesture-required"].map(String::from).to_vec();
-    // The renderer is WebGPU only: headless Chromium needs a software adapter.
+            // The renderer is WebGPU only: headless Chromium needs a software adapter.
-    args.extend(["--enable-unsafe-webgpu", "--enable-features=Vulkan"].map(String::from));
+            args.extend(["--enable-unsafe-webgpu", "--enable-features=Vulkan"].map(String::from));
-    if !opts.headed {
+            if !opts.headed {
-        args.extend(["--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--use-webgpu-adapter=swiftshader"].map(String::from));
+                args.extend(["--use-angle=swiftshader", "--enable-unsafe-swiftshader", "--use-webgpu-adapter=swiftshader"].map(String::from));
-    }
+            }
-    if opts.uncapped {
+            if opts.uncapped {
-        args.extend(["--disable-gpu-vsync", "--disable-frame-rate-limit"].map(String::from));
+                args.extend(["--disable-gpu-vsync", "--disable-frame-rate-limit"].map(String::from));
-    }
+            }
-    let launch = LaunchOptions::new().headless(!opts.headed).args(args);
-    let browser = pw.chromium().launch_with_options(launch).await.map_err(pe("launch chromium"))?;
+            pw.chromium().launch_with_options(LaunchOptions::new().headless(!opts.headed).args(args)).await.map_err(pe("launch chromium"))?
+        }
+        Browser::Webkit => pw.webkit().launch_with_options(LaunchOptions::new().headless(!opts.headed)).await.map_err(pe("launch webkit"))?,
+    };
     let out = check_page(&browser, port, opts).await;
     let _ = browser.close().await;
     out
 }
+const UNSUPPORTED_MESSAGE: &str = "WebGPU is not supported in this browser";
+/// The page has no `navigator.gpu`: it must say so, plum.wasm must still load and
+/// initialise (`plumWasmProbe` is "ok"), and nothing else may have gone wrong.
+async fn check_unsupported(
+    page: &playwright_rs::protocol::Page,
+    errors: &Arc<Mutex<Vec<String>>>,
+    logs: &Arc<Mutex<Vec<String>>>,
+    opts: &Options,
+) -> Result<String, String> {
+    let mut probe: Option<String> = None;
+    for _ in 0..40 {
+        probe = page.evaluate("() => window.plumWasmProbe || null", None::<&()>).await.unwrap_or(None);
+        if probe.is_some() {
+            break;
+        }
+        tokio::time::sleep(Duration::from_millis(250)).await;
+    }
+    let text: String = page.evaluate("() => document.body.innerText", None::<&()>).await.unwrap_or_default();
+    if let Some(p) = &opts.screenshot {
+        let png = page.screenshot(None).await.map_err(pe("screenshot"))?;
+        std::fs::write(p, &png).map_err(|e| format!("write {}: {e}", p.display()))?;
+    }
+    let expected_log = format!("console.error: {UNSUPPORTED_MESSAGE}");
+    let mut failures: Vec<String> = vec![];
+    if !text.contains(UNSUPPORTED_MESSAGE) {
+        failures.push(format!("the page does not show '{UNSUPPORTED_MESSAGE}'"));
+    }
+    match probe.as_deref() {
+        Some("ok") => {}
+        Some(e) => failures.push(format!("plum.wasm did not load: {e}")),
+        None => failures.push("plum.wasm did not finish loading (no plumWasmProbe result)".to_string()),
+    }
+    failures.extend(errors.lock().unwrap().iter().filter(|e| **e != expected_log).cloned());
+    let report = format!(
+        "WebGPU: navigator.gpu is not available in {}; the page shows '{UNSUPPORTED_MESSAGE}'\nplum.wasm load probe: {}",
+        opts.browser.name(),
+        probe.as_deref().unwrap_or("none")
+    );
+    if failures.is_empty() {
+        Ok(report)
+    } else {
+        let logs = logs.lock().unwrap().join("\n");
+        Err(format!("{}\n{report}\n--- console ---\n{logs}", failures.join("\n")))
+    }
+}
 async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts: &Options) -> Result<String, String> {
     let page = match opts.dpr {
         Some(d) => {
@@ -408,11 +512,24 @@ async fn check_page(browser: &playwright_rs::protocol::Browser, port: u16, opts:
     if opts.lose_device {
         page.add_init_script("window.__plumExposeDevice = true;").await.map_err(pe("init script"))?;
     }
+    if opts.expect_unsupported_webgpu {
+        page.add_init_script("delete Navigator.prototype.gpu;").await.map_err(pe("init script"))?;
+    }
+    if opts.no_module_introspection {
+        page.add_init_script(NO_MODULE_INTROSPECTION).await.map_err(pe("init script"))?;
+    }
     page.add_init_script(RAF_PROBE).await.map_err(pe("init script"))?;
+    // Without WebGPU the bridge stops after its message; this asks it to still compile,
+    // instantiate and initialise plum.wasm and report the outcome in `plumWasmProbe`.
+    page.add_init_script("window.__plumWasmProbe = true;").await.map_err(pe("init script"))?;
     page.goto(&format!("http://127.0.0.1:{port}/"), None).await.map_err(pe("goto"))?;
     // Give the wasm time to load, then provide a user gesture on the canvas.
     tokio::time::sleep(Duration::from_secs_f64((opts.frames_wait / 2.0).min(3.0))).await;
+    let has_gpu: bool = page.evaluate("() => !!navigator.gpu", None::<&()>).await.unwrap_or(false);
+    if !has_gpu && (opts.expect_unsupported_webgpu || opts.browser == Browser::Webkit) {
+        return check_unsupported(&page, &errors, &logs, opts).await;
+    }
     let size: Vec<f64> = page
         .evaluate("() => { const r = document.getElementById('glcanvas').getBoundingClientRect(); return [r.width, r.height]; }", None::<&()>)
         .await

plum-game/web-test/src/main.rs CHANGED Viewed

@@ -1,7 +1,8 @@
-use plum_web_test::{chromium_installed, run, ExpectPixel, Options};
+use plum_web_test::{browser_installed, run, Browser, ExpectPixel, Options};
 use std::path::PathBuf;
 const USAGE: &str = "usage: plum-web-test <file.plum> [--frames-wait SECS] [--screenshot OUT.png] [--require-audio]\n  [--assets DIR] [--headed] [--measure SECS] [--uncapped] [--json]
+  [--browser chromium|webkit] [--expect-unsupported-webgpu] [--no-module-introspection]
   [--dpr N] [--lose-device] [--expect-pixel x,y,r,g,b[,tol]]...";
 #[tokio::main]
@@ -19,6 +20,9 @@ async fn main() {
             "--headed" => opts.headed = true,
             "--uncapped" => opts.uncapped = true,
             "--json" => opts.json = true,
+            "--browser" => opts.browser = Browser::parse(&args.next().unwrap_or_else(|| fail("--browser needs chromium or webkit"))).unwrap_or_else(|e| fail(&e)),
+            "--no-module-introspection" => opts.no_module_introspection = true,
+            "--expect-unsupported-webgpu" => opts.expect_unsupported_webgpu = true,
             "--expect-pixel" => {
                 let v = args.next().unwrap_or_else(|| fail("--expect-pixel needs x,y,r,g,b[,tol]"));
                 opts.expect_pixels.push(ExpectPixel::parse(&v).unwrap_or_else(|e| fail(&e)));
@@ -36,8 +40,8 @@ async fn main() {
         }
     }
     let Some(file) = file else { fail(USAGE) };
-    if !chromium_installed() {
+    if !browser_installed(opts.browser) {
-        fail("Playwright Chromium is not installed; see plum-game/web-test/README.md (one-time setup)");
+        fail(&format!("Playwright {} is not installed; see plum-game/web-test/README.md (one-time setup)", opts.browser.name()));
     }
     match run(&file, &opts).await {
         Ok(report) => println!("{report}\nPASS"),

plum-game/web-test/tests/web_check.rs CHANGED Viewed

@@ -1,4 +1,4 @@
-use plum_web_test::{chromium_installed, repo_root, run, Options};
+use plum_web_test::{chromium_installed, repo_root, run, webkit_installed, Browser, Options};
 #[test]
 fn orb_run_renders_and_animates() {
@@ -22,6 +22,55 @@ fn stats_json_is_one_object() {
     assert_eq!(stats_json(&o, None, None, None), r#"{"backend":null,"headed":true,"uncapped":false}"#);
 }
+/// Safari's JavaScriptCore throws from `WebAssembly.Module.imports` for modules whose imports
+/// use typed GC references; the bridge must instantiate without any module introspection.
+#[test]
+fn bridge_does_not_introspect_the_module() {
+    let js = std::fs::read_to_string(repo_root().join("plum-game/web/plum_bridge.js")).unwrap();
+    for api in ["Module.imports(", "Module.exports(", "Module.customSections("] {
+        assert!(!js.contains(api), "plum_bridge.js calls WebAssembly.{api}");
+    }
+}
+#[test]
+fn chromium_runs_without_module_introspection() {
+    if !chromium_installed() {
+        eprintln!("SKIP: Playwright Chromium not installed (see plum-game/web-test/README.md)");
+        return;
+    }
+    let opts = Options { no_module_introspection: true, ..Options::default() };
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let report = rt.block_on(run(&repo_root().join("plum-examples/game.plum"), &opts)).unwrap_or_else(|e| panic!("{e}"));
+    println!("{report}");
+}
+#[test]
+fn webkit_runs_without_module_introspection() {
+    if !webkit_installed() {
+        eprintln!("SKIP: Playwright WebKit not installed (see plum-game/web-test/README.md)");
+        return;
+    }
+    let opts = Options { browser: Browser::Webkit, no_module_introspection: true, ..Options::default() };
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let report = rt.block_on(run(&repo_root().join("plum-examples/game.plum"), &opts)).unwrap_or_else(|e| {
+        assert!(!e.contains("unable to produce import descriptors"), "{e}");
+        panic!("{e}")
+    });
+    println!("{report}");
+}
+#[test]
+fn webkit_without_webgpu_loads_the_wasm_and_says_so() {
+    if !webkit_installed() {
+        eprintln!("SKIP: Playwright WebKit not installed (see plum-game/web-test/README.md)");
+        return;
+    }
+    let opts = Options { browser: Browser::Webkit, expect_unsupported_webgpu: true, no_module_introspection: true, ..Options::default() };
+    let rt = tokio::runtime::Runtime::new().unwrap();
+    let report = rt.block_on(run(&repo_root().join("plum-examples/game.plum"), &opts)).unwrap_or_else(|e| panic!("{e}"));
+    assert!(report.contains("plum.wasm load probe: ok"), "{report}");
+}
 fn orb_run(example: &str) {
     if !chromium_installed() {
         eprintln!("SKIP: Playwright Chromium not installed (see plum-game/web-test/README.md)");

plum-game/web/plum_bridge.js CHANGED Viewed

@@ -153,7 +153,8 @@
       const resume = () => {
         if (ctx.state !== "running") ctx.resume();
       };
+      // Safari only unlocks audio from the gesture events it counts as activation.
-      for (const ev of ["pointerdown", "keydown", "touchstart"]) window.addEventListener(ev, resume);
+      for (const ev of ["pointerdown", "mousedown", "touchstart", "touchend", "click", "keydown"]) window.addEventListener(ev, resume);
     }
     const sound = (h) => (h >= 0 && h < handles.length ? handles[h] : null);
@@ -1030,6 +1031,52 @@ fn shade(i: VOut) -> vec4f {
   // --- start-up --------------------------------------------------------------------
+  // Compiles and instantiates plum.wasm against `host` (the `plum` import namespace).
+  // The imports are not read from the module (WebAssembly.Module.imports throws in
+  // JavaScriptCore for signatures with typed GC references): the namespace is a Proxy
+  // that answers every name the module asks for, with the host function or, for a
+  // name the host lacks, a stub that throws when called.
+  async function instantiatePlum(host) {
+    const stubs = new Map();
+    const plum = new Proxy(host, {
+      get(target, name) {
+        if (typeof name !== "string") return undefined;
+        if (Object.prototype.hasOwnProperty.call(target, name)) return target[name];
+        let stub = stubs.get(name);
+        if (!stub) {
+          stub = () => {
+            throw new Error("host function '" + name + "' is not available here");
+          };
+          stubs.set(name, stub);
+        }
+        return stub;
+      },
+    });
+    const imports = { plum };
+    let module;
+    try {
+      module = await WebAssembly.compileStreaming(fetch("plum.wasm"));
+    } catch (e) {
+      // A server that does not send application/wasm (or an engine without streaming).
+      const res = await fetch("plum.wasm");
+      if (!res.ok) throw new Error("plum.wasm: HTTP " + res.status);
+      module = await WebAssembly.compile(await res.arrayBuffer());
+    }
+    return WebAssembly.instantiate(module, imports);
+  }
+  // plum-web-test sets __plumWasmProbe: a browser without WebGPU still instantiates
+  // plum.wasm so the check can see that the module loads there; the outcome is
+  // plumWasmProbe ("ok" or the error text).
+  async function probeWasm() {
+    try {
+      const { exports: ex } = await instantiatePlum({});
+      globalThis.plumWasmProbe = ["init", "update", "draw"].every((n) => typeof ex[n] === "function") ? "ok" : "plum.wasm lacks init/update/draw";
+    } catch (e) {
+      globalThis.plumWasmProbe = String(e);
+    }
+  }
   async function main() {
     const canvas = document.getElementById("glcanvas");
     // Game coordinates are CSS pixels; the backing store is CSS size x devicePixelRatio.
@@ -1066,6 +1113,7 @@ fn shade(i: VOut) -> vec4f {
       const msg = "WebGPU is not supported in this browser";
       console.error(msg);
       message(msg, "#f55");
+      if (globalThis.__plumWasmProbe) await probeWasm();
       return;
     }
     // The atlas is a backend texture (smooth, SDF) built once the backend exists.
@@ -1164,17 +1212,7 @@ fn shade(i: VOut) -> vec4f {
       },
     };
-    const module = await WebAssembly.compileStreaming(fetch("plum.wasm"));
-    const plumImports = {};
-    for (const imp of WebAssembly.Module.imports(module)) {
-      if (imp.module !== "plum" || imp.kind !== "function") continue;
-      plumImports[imp.name] =
-        host[imp.name] ||
-        (() => {
-          throw new Error("host function '" + imp.name + "' is not available here");
-        });
-    }
-    const instance = await WebAssembly.instantiate(module, { plum: plumImports });
+    const instance = await instantiatePlum(host);
     ctx.plum = instance.exports;
     const ex = ctx.plum;
     const state = ex.init();