dc07fdf | plum | pyrossh

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

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

dc07fdf — Peter John 2026-11-02T16:59:41+05:30

plum game: serve the web build on 127.0.0.1 and open the browser; -o writes a static build

Files changed (3) hide show

plum-cli/src/game.rs +169 -192
plum-cli/src/main.rs +12 -12
plum-cli/tests/game_web_test.rs +95 -86

plum-cli/src/game.rs CHANGED Viewed

@@ -1,11 +1,17 @@
-//! `plum game`: compile a game and run it natively, or write a static web build.
+//! `plum game`: compile a game and serve it in the browser, or write a static web build.
 use std::fs;
+use std::io::{BufRead, BufReader, Write};
+use std::net::{TcpListener, TcpStream};
 use std::path::{Path, PathBuf};
 use std::process::Command;
+use std::sync::Arc;
 use anyhow::{bail, Context, Result};
+const INDEX_HTML: &str = include_str!("../../plum-game/web/index.html");
+const BRIDGE_JS: &str = include_str!("../../plum-game/web/plum_bridge.js");
 /// The repository root, fixed when plum-cli is compiled.
 fn repoRoot() -> PathBuf {
     Path::new(env!("CARGO_MANIFEST_DIR"))
@@ -14,10 +20,6 @@ fn repoRoot() -> PathBuf {
         .to_path_buf()
 }
-fn gameManifest() -> PathBuf {
-    repoRoot().join("plum-game/Cargo.toml")
-}
 /// The asset root: `--assets`, else `assets` beside the source file.
 fn assetRoot(file: &Path, cli: Option<PathBuf>) -> PathBuf {
     cli.unwrap_or_else(|| {
@@ -28,117 +30,6 @@ fn assetRoot(file: &Path, cli: Option<PathBuf>) -> PathBuf {
     })
 }
-/// The browser renderer of a `--web` build.
-#[derive(Clone, Copy, Debug, PartialEq, Eq, clap::ValueEnum)]
-pub enum Renderer {
-    /// macroquad compiled to wasm32 (the default)
-    Macroquad,
-    /// PixiJS, driven straight from the Plum module (experimental)
-    Pixi,
-    /// our own batching renderer, WebGPU with a WebGL2 fallback, no library (experimental)
-    Gpu,
-}
-pub fn cmdGame(
-    file: PathBuf,
-    web: bool,
-    renderer: Renderer,
-    output: Option<PathBuf>,
-    assets: Option<PathBuf>,
-    lib_path: Option<PathBuf>,
-) -> Result<()> {
-    let lib_path = lib_path.unwrap_or_else(repoRoot);
-    let wasm = crate::compileToWasm(&file, &lib_path)?;
-    let assets = assetRoot(&file, assets);
-    if web {
-        let dist = output.unwrap_or_else(|| {
-            file.parent()
-                .filter(|p| !p.as_os_str().is_empty())
-                .unwrap_or(Path::new("."))
-                .join("dist")
-        });
-        return match renderer {
-            Renderer::Macroquad => writeWeb(&wasm, &dist, &assets),
-            Renderer::Pixi => writeWebPixi(&wasm, &dist, &assets),
-            Renderer::Gpu => writeWebGpu(&wasm, &dist, &assets),
-        };
-    }
-    runNative(&wasm, &assets)
-}
-fn runNative(wasm: &[u8], assets: &Path) -> Result<()> {
-    let dir = std::env::temp_dir().join(format!("plum_game_{}", std::process::id()));
-    fs::create_dir_all(&dir)?;
-    let path = dir.join("game.wasm");
-    fs::write(&path, wasm).with_context(|| format!("failed to write {}", path.display()))?;
-    let status = Command::new("cargo")
-        .args(["run", "--release", "--manifest-path"])
-        .arg(gameManifest())
-        .arg("--")
-        .arg(&path)
-        .arg("--assets")
-        .arg(assets)
-        .status()
-        .context("failed to run cargo")?;
-    let _ = fs::remove_dir_all(&dir);
-    if !status.success() {
-        bail!("the game host exited with {status}");
-    }
-    Ok(())
-}
-/// Path of macroquad's `mq_js_bundle.js`, found through the host crate's
-/// locked dependency (the bundle must match the crate version).
-fn jsBundle() -> Result<PathBuf> {
-    let out = Command::new("cargo")
-        .args(["metadata", "--format-version", "1", "--manifest-path"])
-        .arg(gameManifest())
-        .output()
-        .context("failed to run cargo metadata")?;
-    if !out.status.success() {
-        bail!(
-            "cargo metadata failed: {}",
-            String::from_utf8_lossy(&out.stderr)
-        );
-    }
-    let json = String::from_utf8_lossy(&out.stdout);
-    // `"manifest_path":".../macroquad-0.4.x/Cargo.toml"` of the macroquad package.
-    let mut rest = json.as_ref();
-    while let Some(i) = rest.find("\"manifest_path\":\"") {
-        rest = &rest[i + 17..];
-        let end = rest.find('"').unwrap_or(rest.len());
-        let manifest = &rest[..end];
-        if Path::new(manifest)
-            .parent()
-            .and_then(|d| d.file_name())
-            .is_some_and(|n| n.to_string_lossy().starts_with("macroquad-"))
-        {
-            let bundle = Path::new(manifest).with_file_name("js/mq_js_bundle.js");
-            if bundle.is_file() {
-                return Ok(bundle);
-            }
-        }
-    }
-    bail!("macroquad's mq_js_bundle.js not found; run `cargo fetch --manifest-path plum-game/Cargo.toml`")
-}
-/// Builds the host for the browser and returns the path of its wasm.
-fn buildHostWasm() -> Result<PathBuf> {
-    let status = Command::new("cargo")
-        .args(["build", "--release", "--target", "wasm32-unknown-unknown"])
-        .arg("--manifest-path")
-        .arg(gameManifest())
-        .status()
-        .context("failed to run cargo")?;
-    if !status.success() {
-        bail!("building the web host failed (is the wasm32-unknown-unknown target installed?)");
-    }
-    let target = std::env::var_os("CARGO_TARGET_DIR")
-        .map(PathBuf::from)
-        .unwrap_or_else(|| repoRoot().join("plum-game/target"));
-    Ok(target.join("wasm32-unknown-unknown/release/plum-game.wasm"))
-}
 /// Every file under `dir` (dotfiles skipped), as `/`-separated paths relative to it, sorted.
 fn listFiles(dir: &Path) -> Result<Vec<String>> {
     fn walk(dir: &Path, prefix: &str, out: &mut Vec<String>) -> Result<()> {
@@ -159,96 +50,182 @@ fn listFiles(dir: &Path) -> Result<Vec<String>> {
         Ok(())
     }
     let mut out = Vec::new();
+    if dir.is_dir() {
-    walk(dir, "", &mut out)?;
+        walk(dir, "", &mut out)?;
+    }
     out.sort();
     Ok(out)
 }
-/// Writes `plum.wasm`, `preload.txt` and the `assets/` copy shared by every web build.
+/// The generated files of a web build: the page, the bridge, the Plum module and
+/// the list of assets the bridge fetches before the first frame.
+struct Site {
+    wasm: Vec<u8>,
+    preload: String,
+    assets: PathBuf,
+}
+impl Site {
+    fn new(wasm: Vec<u8>, assets: PathBuf) -> Result<Site> {
+        let preload = listFiles(&assets)?.iter().map(|f| format!("{f}\n")).collect();
+        Ok(Site { wasm, preload, assets })
+    }
+    /// The body and content type of the file at the URL path `rel`.
+    fn get(&self, rel: &str) -> Option<(Vec<u8>, &'static str)> {
+        let rel = if rel.is_empty() { "index.html" } else { rel };
+        match rel {
+            "index.html" => return Some((INDEX_HTML.as_bytes().to_vec(), mime("index.html"))),
+            "plum_bridge.js" => return Some((BRIDGE_JS.as_bytes().to_vec(), mime("plum_bridge.js"))),
+            "plum.wasm" => return Some((self.wasm.clone(), mime("plum.wasm"))),
+            "preload.txt" => return Some((self.preload.clone().into_bytes(), mime("preload.txt"))),
+            _ => {}
+        }
+        let asset = rel.strip_prefix("assets/")?;
+        let listed = self.preload.lines().any(|l| l == asset);
+        listed.then(|| fs::read(self.assets.join(asset)).ok()).flatten().map(|b| (b, mime(asset)))
+    }
+    /// Writes the static build (index.html, plum_bridge.js, plum.wasm, preload.txt, assets/).
-fn writeWebAssets(wasm: &[u8], dist: &Path, assets: &Path) -> Result<()> {
+    fn write(&self, dist: &Path) -> Result<()> {
-    // The whole asset directory (if there is one) is bundled and preloaded.
-    let files = if assets.is_dir() {
+        fs::create_dir_all(dist)?;
-        listFiles(assets)?
+        fs::write(dist.join("index.html"), INDEX_HTML)?;
-    } else {
-        Vec::new()
+        fs::write(dist.join("plum_bridge.js"), BRIDGE_JS)?;
-    };
-    fs::write(dist.join("plum.wasm"), wasm)?;
+        fs::write(dist.join("plum.wasm"), &self.wasm)?;
-    fs::write(
-        dist.join("preload.txt"),
+        fs::write(dist.join("preload.txt"), &self.preload)?;
-        files.iter().map(|f| format!("{f}\n")).collect::<String>(),
-    )?;
-    for rel in &files {
+        for rel in self.preload.lines() {
-        let to = dist.join("assets").join(rel);
+            let to = dist.join("assets").join(rel);
-        fs::create_dir_all(to.parent().expect("asset has a parent"))?;
+            fs::create_dir_all(to.parent().expect("asset has a parent"))?;
-        fs::copy(assets.join(rel), &to)?;
+            fs::copy(self.assets.join(rel), &to)?;
+        }
+        Ok(())
     }
-    Ok(())
 }
-fn writeWeb(wasm: &[u8], dist: &Path, assets: &Path) -> Result<()> {
+fn mime(path: &str) -> &'static str {
+    match path.rsplit('.').next().unwrap_or("").to_ascii_lowercase().as_str() {
+        "html" => "text/html; charset=utf-8",
+        "js" | "mjs" => "text/javascript; charset=utf-8",
-    let hostWasm = buildHostWasm()?;
+        "wasm" => "application/wasm",
+        "txt" => "text/plain; charset=utf-8",
+        "json" => "application/json",
-    let bundle = jsBundle()?;
+        "png" => "image/png",
+        "jpg" | "jpeg" => "image/jpeg",
-    fs::create_dir_all(dist)?;
+        "gif" => "image/gif",
-    let web = repoRoot().join("plum-game/web");
+        "webp" => "image/webp",
-    for name in ["index.html", "plum_bridge.js"] {
+        "bmp" => "image/bmp",
-        fs::copy(web.join(name), dist.join(name))
-            .with_context(|| format!("failed to copy {name}"))?;
+        "wav" => "audio/wav",
+        "ogg" => "audio/ogg",
+        _ => "application/octet-stream",
     }
-    fs::copy(&bundle, dist.join("mq_js_bundle.js"))?;
-    fs::copy(&hostWasm, dist.join("plum-game.wasm"))
-        .with_context(|| format!("failed to copy {}", hostWasm.display()))?;
-    writeWebAssets(wasm, dist, assets)?;
-    eprintln!("wrote web build to {}", dist.display());
-    Ok(())
 }
-/// The vendored PixiJS build and its license, in `plum-game/web/vendor`.
+/// Decodes `%XX` escapes; None when the result is not UTF-8.
-fn pixiVendor() -> Result<(PathBuf, PathBuf)> {
+fn percentDecode(s: &str) -> Option<String> {
-    let dir = repoRoot().join("plum-game/web/vendor");
-    let js = fs::read_dir(&dir)
+    let b = s.as_bytes();
-        .with_context(|| format!("failed to read {}", dir.display()))?
+    let mut out = Vec::with_capacity(b.len());
-        .flatten()
-        .map(|e| e.path())
-        .find(|p| {
+    let mut i = 0;
-            p.file_name().is_some_and(|n| {
+    while i < b.len() {
+        if b[i] == b'%' {
+            let hex = std::str::from_utf8(b.get(i + 1..i + 3)?).ok()?;
+            out.push(u8::from_str_radix(hex, 16).ok()?);
+            i += 3;
+        } else {
+            out.push(b[i]);
+            i += 1;
+        }
+    }
+    String::from_utf8(out).ok()
+}
+fn respond(mut stream: TcpStream, site: &Site) {
-                let n = n.to_string_lossy();
+    let mut line = String::new();
-                n.starts_with("pixi-") && n.ends_with(".min.js")
+    if BufReader::new(&stream).read_line(&mut line).is_err() {
+        return;
-            })
+    }
+    let mut parts = line.split_whitespace();
+    let (method, target) = (parts.next().unwrap_or(""), parts.next().unwrap_or("/"));
+    let rel = target.split(['?', '#']).next().unwrap_or("/").trim_start_matches('/');
+    let found = percentDecode(rel)
+        .filter(|r| !r.split('/').any(|c| c == ".." || c.contains('\\')))
+        .and_then(|r| site.get(&r));
+    let head = matches!(method, "GET" | "HEAD");
+    match found.filter(|_| head) {
+        Some((body, ctype)) => {
+            let _ = write!(
+                stream,
+                "HTTP/1.1 200 OK\r\nContent-Type: {ctype}\r\nContent-Length: {}\r\nCache-Control: no-store\r\nConnection: close\r\n\r\n",
+                body.len()
+            );
+            if method == "GET" {
+                let _ = stream.write_all(&body);
-        })
+            }
+        }
+        None => {
-        .with_context(|| format!("no pixi-*.min.js in {}", dir.display()))?;
+            let status = if head { "404 Not Found" } else { "405 Method Not Allowed" };
-    Ok((js, dir.join("pixi-LICENSE")))
+            let _ = write!(stream, "HTTP/1.1 {status}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n");
+        }
+    }
 }
-/// The PixiJS build needs no host wasm: just the page, the bridge, Pixi and the Plum module.
+/// Opens `url` in the default browser.
-fn writeWebPixi(wasm: &[u8], dist: &Path, assets: &Path) -> Result<()> {
+fn openBrowser(url: &str) -> Result<()> {
-    let (pixi, license) = pixiVendor()?;
+    let mut cmd = if cfg!(target_os = "macos") {
-    fs::create_dir_all(dist)?;
+        Command::new("open")
+    } else if cfg!(target_os = "windows") {
-    let web = repoRoot().join("plum-game/web");
+        let mut c = Command::new("cmd");
-    fs::copy(web.join("index_pixi.html"), dist.join("index.html"))
+        c.args(["/C", "start", ""]);
+        c
+    } else {
+        Command::new("xdg-open")
+    };
-        .context("failed to copy index_pixi.html")?;
+    cmd.arg(url).spawn().context("failed to launch the browser")?;
-    fs::copy(
-        web.join("plum_bridge_pixi.js"),
-        dist.join("plum_bridge_pixi.js"),
-    )
-    .context("failed to copy plum_bridge_pixi.js")?;
-    fs::copy(&pixi, dist.join("pixi.min.js"))
-        .with_context(|| format!("failed to copy {}", pixi.display()))?;
-    fs::copy(&license, dist.join("pixi.LICENSE"))
-        .with_context(|| format!("failed to copy {}", license.display()))?;
-    writeWebAssets(wasm, dist, assets)?;
-    eprintln!("wrote web build (pixi) to {}", dist.display());
     Ok(())
 }
+fn bind(port: Option<u16>) -> Result<TcpListener> {
+    match port {
+        Some(p) => TcpListener::bind(("127.0.0.1", p)).with_context(|| format!("cannot listen on 127.0.0.1:{p}")),
-/// The own-batcher build needs no host wasm and no library: the page, the bridge and the Plum module.
+        // Prefer a stable port so reloads keep the same URL; any free one otherwise.
-fn writeWebGpu(wasm: &[u8], dist: &Path, assets: &Path) -> Result<()> {
-    fs::create_dir_all(dist)?;
-    let web = repoRoot().join("plum-game/web");
+        None => TcpListener::bind(("127.0.0.1", 8080))
-    fs::copy(web.join("index_gpu.html"), dist.join("index.html"))
+            .or_else(|_| TcpListener::bind(("127.0.0.1", 0)))
-        .context("failed to copy index_gpu.html")?;
+            .context("cannot listen on 127.0.0.1"),
+    }
+}
+pub fn cmdGame(
+    file: PathBuf,
+    output: Option<PathBuf>,
+    assets: Option<PathBuf>,
+    port: Option<u16>,
+    noOpen: bool,
+    lib_path: Option<PathBuf>,
+) -> Result<()> {
+    let lib_path = lib_path.unwrap_or_else(repoRoot);
-    fs::copy(web.join("plum_bridge_gpu.js"), dist.join("plum_bridge_gpu.js"))
+    let wasm = crate::compileToWasm(&file, &lib_path)?;
+    let assets = assetRoot(&file, assets);
+    if assets.exists() && !assets.is_dir() {
-        .context("failed to copy plum_bridge_gpu.js")?;
+        bail!("{} is not a directory", assets.display());
+    }
-    writeWebAssets(wasm, dist, assets)?;
+    let site = Site::new(wasm, assets)?;
+    if let Some(dist) = output {
+        site.write(&dist)?;
-    eprintln!("wrote web build (gpu) to {}", dist.display());
+        eprintln!("wrote web build to {}", dist.display());
+        return Ok(());
+    }
+    let listener = bind(port)?;
+    let url = format!("http://127.0.0.1:{}/", listener.local_addr()?.port());
+    println!("serving {url} (Ctrl-C to stop)");
+    std::io::stdout().flush()?;
+    if !noOpen {
+        if let Err(e) = openBrowser(&url) {
+            eprintln!("{e:#}; open {url} yourself");
+        }
+    }
+    let site = Arc::new(site);
+    for stream in listener.incoming().flatten() {
+        let site = site.clone();
+        std::thread::spawn(move || respond(stream, &site));
+    }
     Ok(())
 }

plum-cli/src/main.rs CHANGED Viewed

@@ -76,22 +76,22 @@ enum Command {
         #[arg(long, default_value = ".")]
         lib_path: std::path::PathBuf,
     },
-    /// Compile a Plum game and run it natively, or package it for the browser with --web
+    /// Compile a Plum game and serve it in the browser (WebGPU), or write a static web build with -o
     Game {
         /// Source file with `export fun init/update/draw`
         file: std::path::PathBuf,
-        /// Write a static web build instead of opening a window
-        #[arg(long)]
-        web: bool,
-        /// Browser renderer for --web: macroquad (default), pixi or gpu (both experimental)
+        /// Write the static build (index.html, plum_bridge.js, plum.wasm, preload.txt, assets/) here and exit
-        #[arg(long, value_enum, default_value = "macroquad")]
-        renderer: game::Renderer,
-        /// Output directory for --web (default: `dist` beside the source file)
         #[arg(short, long)]
         output: Option<std::path::PathBuf>,
-        /// Asset root (default: `assets` beside the source file); --web bundles all of it
+        /// Asset root (default: `assets` beside the source file); all of it is served or bundled
         #[arg(long)]
         assets: Option<std::path::PathBuf>,
+        /// Port to serve on (default: 8080, else any free port)
+        #[arg(long)]
+        port: Option<u16>,
+        /// Do not open the browser
+        #[arg(long)]
+        no_open: bool,
         /// Root directory `import <path>` is resolved against (default: the repository root)
         #[arg(long)]
         lib_path: Option<std::path::PathBuf>,
@@ -131,12 +131,12 @@ fn run() -> Result<()> {
         Command::Test { paths, lib_path } => cmdTest(paths, lib_path),
         Command::Game {
             file,
-            web,
-            renderer,
             output,
             assets,
+            port,
+            no_open,
             lib_path,
-        } => game::cmdGame(file, web, renderer, output, assets, lib_path),
+        } => game::cmdGame(file, output, assets, port, no_open, lib_path),
         Command::Editor { editor, insiders } => editor::install(editor, insiders),
     }
 }

plum-cli/tests/game_web_test.rs CHANGED Viewed

@@ -1,5 +1,6 @@
 #![allow(non_snake_case)]
+use std::io::{BufRead, BufReader, Read, Write};
-use std::process::Command;
+use std::process::{Command, Stdio};
 fn plumBin() -> std::path::PathBuf {
     let mut path = std::env::current_exe().unwrap();
@@ -11,114 +12,122 @@ fn plumBin() -> std::path::PathBuf {
     path
 }
-/// Exports the host fixture with `renderer` and returns (dist dir, scratch dir).
-fn exportFixture(renderer: Option<&str>) -> (std::path::PathBuf, std::path::PathBuf) {
+fn root() -> std::path::PathBuf {
-    let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+    std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
         .parent()
-        .unwrap();
+        .unwrap()
+        .to_path_buf()
+}
+/// Stand-in asset files: the build copies and serves them without decoding.
+fn makeAssets(name: &str) -> (std::path::PathBuf, std::path::PathBuf) {
-    let scratch = std::env::temp_dir().join(format!(
+    let scratch = std::env::temp_dir().join(format!("plum_game_web_{}_{name}", std::process::id()));
-        "plum_game_web_{}_{}",
-        std::process::id(),
-        renderer.unwrap_or("default")
-    ));
     let assets = scratch.join("assets");
-    let dist = scratch.join("dist");
-    // Stand-in asset files: the build copies them without reading them.
     std::fs::create_dir_all(assets.join("sub")).unwrap();
     std::fs::write(assets.join("a.png"), b"x").unwrap();
-    std::fs::write(assets.join("sub/b.txt"), b"x").unwrap();
+    std::fs::write(assets.join("sub/b.txt"), b"hello").unwrap();
+    (scratch, assets)
+}
+const FIXTURE: &str = "plum-game/tests/fixtures/host_fixture.plum";
+#[test]
+fn staticBuildWritesTheDist() {
+    let (scratch, assets) = makeAssets("static");
+    let dist = scratch.join("dist");
-    let mut cmd = Command::new(plumBin());
+    let out = Command::new(plumBin())
+        .current_dir(root())
-    cmd.current_dir(root).args(["game", "--web"]);
+        .args(["game", FIXTURE, "-o"])
-    if let Some(r) = renderer {
-        cmd.args(["--renderer", r]);
-    }
-    let out = cmd
-        .args(["plum-game/tests/fixtures/host_fixture.plum", "-o"])
         .arg(&dist)
         .arg("--assets")
         .arg(&assets)
         .output()
         .expect("failed to run plum");
-    let all = format!(
-        "{}{}",
-        String::from_utf8_lossy(&out.stdout),
+    let all = format!("{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr));
-        String::from_utf8_lossy(&out.stderr)
-    );
-    assert!(out.status.success(), "plum game --web failed:\n{all}");
+    assert!(out.status.success(), "plum game -o failed:\n{all}");
+    let mut names: Vec<String> = std::fs::read_dir(&dist)
+        .unwrap()
+        .map(|e| e.unwrap().file_name().to_string_lossy().into_owned())
+        .collect();
-    (dist, scratch)
+    names.sort();
-}
-fn checkAssets(dist: &std::path::Path) {
+    assert_eq!(names, ["assets", "index.html", "plum.wasm", "plum_bridge.js", "preload.txt"]);
     let preload = std::fs::read_to_string(dist.join("preload.txt")).unwrap();
     let lines: Vec<&str> = preload.lines().collect();
     assert_eq!(lines, ["a.png", "sub/b.txt"]);
     for l in &lines {
-        assert!(
-            dist.join("assets").join(l).is_file(),
+        assert!(dist.join("assets").join(l).is_file(), "assets/{l} not copied");
-            "assets/{l} not copied"
-        );
     }
+    let html = std::fs::read_to_string(dist.join("index.html")).unwrap();
+    assert!(html.contains("plum_bridge.js"));
+    let _ = std::fs::remove_dir_all(&scratch);
 }
 #[test]
-fn webBuildWritesTheDist() {
+fn removedFlagsAreRejected() {
-    for renderer in [None, Some("macroquad")] {
+    for flag in ["--web", "--renderer"] {
-        let (dist, scratch) = exportFixture(renderer);
+        let out = Command::new(plumBin()).current_dir(root()).args(["game", FIXTURE, flag]).output().unwrap();
-        for f in [
-            "index.html",
-            "mq_js_bundle.js",
-            "plum_bridge.js",
-            "plum-game.wasm",
-            "plum.wasm",
-            "preload.txt",
-        ] {
-            assert!(dist.join(f).is_file(), "missing {f}");
+        assert!(!out.status.success(), "{flag} should be rejected");
-        }
-        assert!(!dist.join("pixi.min.js").exists());
-        checkAssets(&dist);
-        let _ = std::fs::remove_dir_all(&scratch);
     }
 }
-#[test]
-fn pixiWebBuildNeedsNoHostWasm() {
+/// GET `path` from 127.0.0.1:`port`; returns (status line, content type, body).
-    let (dist, scratch) = exportFixture(Some("pixi"));
+fn get(port: u16, path: &str) -> (String, String, Vec<u8>) {
-    for f in [
-        "index.html",
-        "plum_bridge_pixi.js",
-        "pixi.min.js",
-        "pixi.LICENSE",
-        "plum.wasm",
-        "preload.txt",
-    ] {
-        assert!(dist.join(f).is_file(), "missing {f}");
-    }
-    for f in ["mq_js_bundle.js", "plum-game.wasm", "plum_bridge.js"] {
-        assert!(!dist.join(f).exists(), "unexpected {f}");
-    }
-    let html = std::fs::read_to_string(dist.join("index.html")).unwrap();
+    let mut s = std::net::TcpStream::connect(("127.0.0.1", port)).unwrap();
-    assert!(html.contains("plum_bridge_pixi.js") && html.contains("pixi.min.js"));
+    write!(s, "GET {path} HTTP/1.1\r\nHost: x\r\nConnection: close\r\n\r\n").unwrap();
+    let mut raw = Vec::new();
-    checkAssets(&dist);
+    s.read_to_end(&mut raw).unwrap();
+    let split = raw.windows(4).position(|w| w == b"\r\n\r\n").unwrap();
+    let head = String::from_utf8_lossy(&raw[..split]).into_owned();
-    let _ = std::fs::remove_dir_all(&scratch);
+    let status = head.lines().next().unwrap().to_string();
+    let ctype = head
+        .lines()
+        .find_map(|l| l.strip_prefix("Content-Type: "))
+        .unwrap_or("")
+        .to_string();
+    (status, ctype, raw[split + 4..].to_vec())
 }
 #[test]
-fn gpuWebBuildNeedsNoHostWasmOrLibrary() {
+fn serveStartsAndAnswersWithTheRightContentTypes() {
-    let (dist, scratch) = exportFixture(Some("gpu"));
+    let (scratch, assets) = makeAssets("serve");
+    let mut child = Command::new(plumBin())
+        .current_dir(root())
-    for f in ["index.html", "plum_bridge_gpu.js", "plum.wasm", "preload.txt"] {
+        .args(["game", FIXTURE, "--no-open", "--port", "0", "--assets"])
+        .arg(&assets)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::null())
+        .spawn()
+        .expect("failed to run plum");
+    let mut line = String::new();
+    BufReader::new(child.stdout.take().unwrap()).read_line(&mut line).unwrap();
+    let port: u16 = line
+        .split("127.0.0.1:")
+        .nth(1)
+        .and_then(|r| r.split('/').next())
+        .and_then(|p| p.parse().ok())
+        .unwrap_or_else(|| panic!("no url in `{line}`"));
+    let (status, ctype, body) = get(port, "/");
-        assert!(dist.join(f).is_file(), "missing {f}");
+    assert!(status.contains("200"), "{status}");
-    }
+    assert!(ctype.starts_with("text/html"), "{ctype}");
-    for f in [
+    assert!(String::from_utf8_lossy(&body).contains("plum_bridge.js"));
-        "mq_js_bundle.js",
+    let (_, ctype, body) = get(port, "/plum.wasm");
-        "plum-game.wasm",
+    assert_eq!(ctype, "application/wasm");
+    assert_eq!(&body[..4], b"\0asm");
-        "plum_bridge.js",
+    let (_, ctype, _) = get(port, "/plum_bridge.js");
+    assert!(ctype.starts_with("text/javascript"), "{ctype}");
-        "pixi.min.js",
+    let (_, ctype, body) = get(port, "/preload.txt");
-    ] {
-        assert!(!dist.join(f).exists(), "unexpected {f}");
+    assert!(ctype.starts_with("text/plain"));
+    assert_eq!(body, b"a.png\nsub/b.txt\n");
+    let (_, ctype, body) = get(port, "/assets/sub/b.txt");
+    assert!(ctype.starts_with("text/plain"));
-    }
+    assert_eq!(body, b"hello");
+    assert_eq!(get(port, "/assets/a.png").1, "image/png");
-    let html = std::fs::read_to_string(dist.join("index.html")).unwrap();
+    assert!(get(port, "/nope").0.contains("404"));
-    assert!(html.contains("plum_bridge_gpu.js") && !html.contains("pixi"));
+    assert!(get(port, "/assets/../a.png").0.contains("404"));
+    assert!(get(port, "/assets/%2e%2e/a.png").0.contains("404"));
+    child.kill().unwrap();
-    checkAssets(&dist);
+    child.wait().unwrap();
     let _ = std::fs::remove_dir_all(&scratch);
 }